```ts
export function pinPackageSet(plan: Record<string, unknown>): Record<string, unknown> {
  const { shelf, needs, root } = plan;

  if (typeof shelf !== 'object' || shelf === null) {
    throw new Error('Invalid shelf');
  }
  if (typeof needs !== 'object' || needs === null) {
    throw new Error('Invalid needs');
  }
  if (!Array.isArray(root)) {
    throw new Error('Invalid root');
  }

  const validateVersion = (version: string): boolean => {
    return /^\d+\.\d+\.\d+$/.test(version);
  };

  const compareVersions = (a: string, b: string): number => {
    const [a1, a2, a3] = a.split('.').map(Number);
    const [b1, b2, b3] = b.split('.').map(Number);

    if (a1 !== b1) return a1 - b1;
    if (a2 !== b2) return a2 - b2;
    return a3 - b3;
  };

  const validateShelfEntry = (versions: string[]): boolean => {
    return (
      Array.isArray(versions) &&
      versions.length > 0 &&
      versions.every((v, i) => validateVersion(v) && (!i || compareVersions(versions[i], versions[i - 1]) > 0))
    );
  };

  const validateWants = (wants: Record<string, unknown>): boolean => {
    return (
      Array.isArray(wants) &&
      wants.every((want) => {
        if (typeof want !== 'object' || want === null) return false;
        const { name, from, under } = want as { name: string; from: string; under: string };
        return (
          typeof name === 'string' && validateVersion(from) && validateVersion(under) && compareVersions(from, under) < 0
        );
      })
    );
  };

  for (const [name, versions] of Object.entries(shelf)) {
    if (!validateShelfEntry(versions as string[])) {
      throw new Error(`Invalid shelf entry for ${name}`);
    }
  }

  for (const [name, wants] of Object.entries(needs)) {
    if (!Array.isArray(wants) || !validateWants(wants as Record<string, unknown>[])) {
      throw new Error(`Invalid needs entry for ${name}`);
    }
  }

  const reached = new Set<string>();
  const queue: { name: string; from: string; under: string }[] = root.map((want) => ({
    ...(want as { name: string; from: string; under: string }),
  }));

  while (queue.length > 0) {
    const { name, from, under } = queue.shift()!;
    if (!reached.has(name)) {
      reached.add(name);
      if (needs[name]) {
        queue.push(...(needs[name] as Record<string, unknown>[]));
      }
    }
  }

  const picked: { name: string; version: string }[] = [];
  const stuck: string[] = [];

  for (const name of Array.from(reached).sort()) {
    if (!shelf[name]) continue;

    const versions = shelf[name] as string[];
    let selectedVersion: string | null = null;

    for (const version of versions) {
      if (
        !selectedVersion ||
        compareVersions(version, selectedVersion) < 0 ||
        (compareVersions(version, selectedVersion) === 0 &&
          version.split('.').map(Number).reduce((acc, cur) => acc + cur, 0)