```ts
/**
 * Sorts shelf marks according to the Marrow scheme rules.
 * @param {string[]} marks - The array of shelf mark strings to sort.
 * @returns {string[]} - The sorted array of shelf mark strings.
 */
export function orderShelfMarks(marks: string[]): string[] {
  if (!Array.isArray(marks) || marks.length === 0) {
    throw new Error('Invalid input');
  }

  const regex = /^(?<stack>\w{1,3})\s(?<run>\d+(\.\d+)?)\s(?<cutter>[a-z]\d{1,3})$/;

  const isValidMark = (mark: string): boolean => {
    return regex.test(mark);
  };

  if (!marks.every(isValidMark)) {
    throw new Error('Invalid mark format');
  }

  const parseMark = (mark: string): [string, number, string] => {
    const match = mark.match(regex);
    if (!match) {
      throw new Error('Unexpected error parsing mark');
    }
    const { stack, run, cutter } = match.groups!;
    return [stack, parseFloat(run), cutter];
  };

  const sortedMarks = marks
    .map(parseMark)
    .sort((a, b) => {
      if (a[0] !== b[0]) return a[0].localeCompare(b[0]);
      if (a[1] !== b[1]) return a[1] - b[1];
      if (a[2][0] !== b[2][0]) return a[2][0].localeCompare(b[2][0]);
      return parseInt(a[2].slice(1), 10) - parseInt(b[2].slice(1), 10);
    })
    .map(([stack, run, cutter]) => `${stack} ${run} ${cutter}`);

  const uniqueMarks = [...new Set(sortedMarks)];
  if (uniqueMarks.length !== sortedMarks.length) {
    throw new Error('Duplicate marks found');
  }

  return uniqueMarks;
}
```