```ts
/** One line per row of a zoned pick walk. */
export function zonePickWalk(plan: Record<string, unknown>): string[] {
  if (typeof plan !== 'object' || plan === null) {
    throw new Error('Invalid argument: plan must be an object');
  }

  const picks = plan.picks as any[];
  if (!Array.isArray(picks)) {
    throw new Error('Invalid argument: picks must be a list');
  }
  if (picks.some((pick) => typeof pick !== 'object' || pick === null)) {
    throw new Error('Invalid argument: all elements in picks must be objects');
  }

  const zoneOrder = plan.zoneOrder as any[];
  if (!Array.isArray(zoneOrder)) {
    throw new Error('Invalid argument: zoneOrder must be a list');
  }
  if (zoneOrder.length === 0) {
    throw new Error('Invalid argument: zoneOrder cannot be empty');
  }
  if (new Set(zoneOrder).size !== zoneOrder.length) {
    throw new Error('Invalid argument: zoneOrder cannot have duplicate zones');
  }

  const byZone = new Map<string, any[]>();
  for (const pick of picks) {
    if (!zoneOrder.includes(pick.zone)) {
      throw new Error(`Invalid argument: pick ${pick.code} references a non-existent zone`);
    }
    if (!byZone.has(pick.zone)) {
      byZone.set(pick.zone, []);
    }
    const zonePicks = byZone.get(pick.zone) as any[];
    if (zonePicks.some((p) => p.code === pick.code)) {
      throw new Error(`Invalid argument: duplicate code ${pick.code}`);
    }
    zonePicks.push(pick);
  }

  const lines: string[] = [];
  for (const zone of zoneOrder) {
    const group = byZone.get(zone) as any[];
    const rows = Array.from(new Set(group.map((pick) => pick.row))).sort(
      (a, b) => a - b
    );
    let facingUp = true;
    for (const row of rows) {
      const here = group.filter((pick) => pick.row === row);
      if (facingUp) {
        here.sort((a, b) => a.slot - b.slot);
      } else {
        here.sort((a, b) => b.slot - a.slot);
      }
      lines.push(
        zone + "/" + row + ":" + here.map((pick) => pick.code).join("|")
      );
      facingUp = !facingUp;
    }
  }

  return lines;
}
```