```ts
interface ShelfMark {
  stack: string;
  run: { whole: number; fraction?: number };
  cutter: { letter: string; digits: number };
}

function parseShelfMark(mark: string): ShelfMark {
  const parts = mark.split(' ');
  if (parts.length !== 3) throw new Error('Invalid shelf mark format');

  const stack = parts[0];
  if (!/^[A-Z]{1,3}$/.test(stack)) throw new Error('Invalid stack format');

  const runParts = parts[1].split('.');
  const whole = parseInt(runParts[0], 10);
  if (isNaN(whole) || whole <= 0 || whole > 9999) throw new Error('Invalid run format');
  const fraction = runParts.length === 2 ? parseFloat(`0.${runParts[1]}`) : undefined;

  const cutterParts = parts[2].split('');
  if (cutterParts.length !== 2) throw new Error('Invalid cutter format');
  const letter = cutterParts[0];
  const digits = parseInt(cutterParts[1], 10);
  if (!/^[a-z]$/.test(letter) || isNaN(digits) || digits <= 0 || digits > 999) throw new Error('Invalid cutter format');

  return { stack, run: { whole, fraction }, cutter: { letter, digits } };
}

function compareShelfMarks(a: ShelfMark, b: ShelfMark): number {
  if (a.stack !== b.stack) return a.stack.localeCompare(b.stack);
  if (a.run.whole !== b.run.whole) return a.run.whole - b.run.whole;
  if (a.run.fraction !== undefined && b.run.fraction !== undefined) return a.run.fraction - b.run.fraction;
  if (a.run.fraction !== undefined) return -1;
  if (b.run.fraction !== undefined) return 1;
  if (a.cutter.letter !== b.cutter.letter) return a.cutter.letter.localeCompare(b.cutter.letter);
  return a.cutter.digits - b.cutter.digits;
}

export function orderShelfMarks(marks: string[]): string[] {
  if (!Array.isArray(marks)) throw new Error('Input must be an array');
  if (marks.length === 0) throw new Error('Input cannot be empty');

  const parsedMarks = marks.map(parseShelfMark);
  const uniqueParsedMarks = [...new Set(parsedMarks)];
  if (uniqueParsedMarks.length !== parsedMarks.length) throw new Error('Duplicate shelf marks found');

  return uniqueParsedMarks.sort(compareShelfMarks).map(mark => `${mark.stack} ${mark.run.whole}${mark.run.fraction ? `.${mark.run.fraction}` : ''} ${mark.cutter.letter}${mark.cutter.digits}`);
}
```