```ts
/**
 * Expands a pattern with a single square-bracketed group into distinct results.
 * @param pattern - The input pattern to expand.
 * @returns An array of expanded strings sorted in ascending order.
 */
export function expandRunTag(pattern: string): string[] {
  if (typeof pattern !== 'string') {
    throw new Error('Input must be a string');
  }

  const match = pattern.match(/^([^[]*)\[(.*?)\](.*)$/);
  if (!match) {
    throw new Error('Pattern must contain exactly one square-bracketed group');
  }

  const [_, stem, body, tail] = match;
  const results: string[] = [];

  if (body.includes(',')) {
    // Listing of items
    const items = body.split(',');
    for (const item of items) {
      if (item === '') {
        throw new Error('Empty comma item is not allowed');
      }
      results.push(stem + item + tail);
    }
  } else {
    // Run pattern
    const runMatch = body.match(/^(\d+)-(\d+)(?:\/(\d+))?$/);
    if (!runMatch) {
      throw new Error('Invalid run pattern');
    }

    const [__, startStr, endStr, stepStr = '1'] = runMatch;
    const start = parseInt(startStr, 10);
    const end = parseInt(endStr, 10);
    const step = parseInt(stepStr, 10);

    if (isNaN(start) || isNaN(end) || isNaN(step)) {
      throw new Error('Invalid number in run pattern');
    }
    if (step === 0) {
      throw new Error('Step must not be zero');
    }
    if (start > end) {
      throw new Error('Start must not exceed end in run pattern');
    }

    for (let i = start; i <= end; i += step) {
      results.push(stem + i + tail);
    }
  }

  return results.sort();
}
```