openapi-typesafe 1.0.0-rc.3 → 1.0.0-rc.4

package/dist/adapters/node-file-system/file-claims.cjs

@@ -0,0 +1,105 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const fileIdentity = require('./file-identity.cjs');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+
+function missingDirectories(directory, exists) {
+  const missing = [];
+  for (let current = directory; !exists(current); current = path__default.dirname(current)) {
+    missing.push(current);
+    if (path__default.dirname(current) === current) {
+      break;
+    }
+  }
+  return missing;
+}
+function claimIdentity(number, storedPath) {
+  return number.file === 0n ? `path:${storedPath()}` : `${number.device}:${number.file}`;
+}
+function identityOf(descriptor, filePath) {
+  const status = fs__default.fstatSync(descriptor, { bigint: true });
+  return claimIdentity(
+    { device: status.dev, file: status.ino },
+    () => fs__default.realpathSync.native(filePath)
+  );
+}
+function errorCodeOf(error) {
+  return error instanceof Error && "code" in error ? error.code : void 0;
+}
+function removeDirectories(directories) {
+  for (const directory of directories) {
+    try {
+      fs__default.rmdirSync(directory);
+    } catch (error) {
+      const code = errorCodeOf(error);
+      if (code === "ENOTEMPTY" || code === "EEXIST") {
+        return;
+      }
+      if (code !== "ENOENT" || fs__default.lstatSync(directory, { throwIfNoEntry: false }) !== void 0) {
+        throw error;
+      }
+    }
+  }
+}
+function createDirectory(directory, queries) {
+  const target = fileIdentity.creationPath(directory, queries);
+  const missing = missingDirectories(target, fs__default.existsSync);
+  try {
+    fs__default.mkdirSync(target, { recursive: true });
+  } catch (error) {
+    removeDirectories(missing.filter((created) => fs__default.existsSync(created)));
+    throw error;
+  }
+  return missing;
+}
+function openClaim(filePath) {
+  const isCreated = !fs__default.existsSync(filePath);
+  const descriptor = fs__default.openSync(filePath, "a");
+  try {
+    const identity = identityOf(descriptor, filePath);
+    return { identity, createdFile: isCreated ? fs__default.realpathSync.native(filePath) : void 0 };
+  } finally {
+    fs__default.closeSync(descriptor);
+  }
+}
+function claimFileAt(filePath, queries) {
+  const directories = createDirectory(path__default.dirname(filePath), queries);
+  let opened;
+  try {
+    opened = openClaim(filePath);
+  } catch (error) {
+    removeDirectories(directories);
+    throw error;
+  }
+  const { identity, createdFile } = opened;
+  return {
+    identity,
+    release: () => {
+      if (createdFile !== void 0) {
+        fs__default.rmSync(createdFile, { force: true });
+      }
+      removeDirectories(directories);
+    }
+  };
+}
+function writeFileAt(filePath, contents, queries) {
+  const directories = createDirectory(path__default.dirname(filePath), queries);
+  try {
+    fs__default.writeFileSync(filePath, contents, "utf8");
+  } catch (error) {
+    removeDirectories(directories);
+    throw error;
+  }
+}
+
+exports.claimFileAt = claimFileAt;
+exports.claimIdentity = claimIdentity;
+exports.missingDirectories = missingDirectories;
+exports.writeFileAt = writeFileAt;
+//# sourceMappingURL=file-claims.cjs.map

package/dist/adapters/node-file-system/file-claims.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-claims.cjs","sources":["../../../src/adapters/node-file-system/file-claims.ts"],"sourcesContent":["import fs from \"node:fs\";\nimport path from \"node:path\";\nimport type { ClaimedFile } from \"../../application/ports/file-system.js\";\nimport { creationPath, type FileNumber, type PathQueries } from \"./file-identity.js\";\n\n/**\n * Claiming an output on Node's `fs` (ADR-043, decision 1): the file is opened for appending,\n * which creates it when it is missing (also through a symbolic link) and never truncates it.\n * The device and file number of the open file are its identity. A claim or a write that fails\n * removes the directories it created.\n */\n\n/**\n * The directories that do not exist yet on the way to `directory`, deepest first: the ones a\n * recursive `fs.mkdirSync` creates. They are listed before it runs, in the form of `directory`\n * itself: on Windows the path that `fs.mkdirSync` returns did not match that form, so comparing\n * with it found no new directory and a failed run left them behind.\n */\nexport function missingDirectories(\n  directory: string,\n  exists: (candidate: string) => boolean,\n): string[] {\n  const missing: string[] = [];\n  for (let current = directory; !exists(current); current = path.dirname(current)) {\n    missing.push(current);\n    if (path.dirname(current) === current) {\n      break;\n    }\n  }\n  return missing;\n}\n\n/**\n * The identity of an open file: its device and file number, or its stored path on a file system\n * that reports the file number 0 (FAT, some network shares), which proves nothing.\n */\nexport function claimIdentity(number: FileNumber, storedPath: () => string): string {\n  return number.file === 0n ? `path:${storedPath()}` : `${number.device}:${number.file}`;\n}\n\nfunction identityOf(descriptor: number, filePath: string): string {\n  const status = fs.fstatSync(descriptor, { bigint: true });\n  return claimIdentity({ device: status.dev, file: status.ino }, () =>\n    fs.realpathSync.native(filePath),\n  );\n}\n\nfunction errorCodeOf(error: unknown): unknown {\n  return error instanceof Error && \"code\" in error ? error.code : undefined;\n}\n\n/** Remove the new directories, deepest first, until one holds another file. */\nfunction removeDirectories(directories: readonly string[]): void {\n  for (const directory of directories) {\n    try {\n      fs.rmdirSync(directory);\n    } catch (error) {\n      const code = errorCodeOf(error);\n      // Another output or the user put a file there since: the directory and its parents stay.\n      if (code === \"ENOTEMPTY\" || code === \"EEXIST\") {\n        return;\n      }\n      // Removed since: nothing to remove, but its parents may still be empty. Windows also gives\n      // ENOENT for a file put in its place, which must fail like any other path it cannot remove.\n      if (code !== \"ENOENT\" || fs.lstatSync(directory, { throwIfNoEntry: false }) !== undefined) {\n        throw error;\n      }\n    }\n  }\n}\n\n/**\n * Create `directory` and give the directories that this created. Through a link to a missing\n * directory it creates the link's target, as a write through the link would, so the path to\n * create and the new directories are real paths, where links are already followed. A recursive\n * `mkdir` that fails part of the way (a directory name too long for the file system) keeps the\n * directories above the failing one, so the ones that exist now are removed here.\n */\nfunction createDirectory(directory: string, queries: PathQueries): string[] {\n  const target = creationPath(directory, queries);\n  const missing = missingDirectories(target, fs.existsSync);\n  try {\n    fs.mkdirSync(target, { recursive: true });\n  } catch (error) {\n    removeDirectories(missing.filter((created) => fs.existsSync(created)));\n    throw error;\n  }\n  return missing;\n}\n\n/** Open `filePath` for appending, which creates it, and give its identity and whether it is new. */\nfunction openClaim(filePath: string): { identity: string; createdFile: string | undefined } {\n  const isCreated = !fs.existsSync(filePath);\n  const descriptor = fs.openSync(filePath, \"a\");\n  try {\n    const identity = identityOf(descriptor, filePath);\n    // A link to a missing file created its target: that file is what the claim removes.\n    return { identity, createdFile: isCreated ? fs.realpathSync.native(filePath) : undefined };\n  } finally {\n    fs.closeSync(descriptor);\n  }\n}\n\n/**\n * Claim the file at `filePath`; the caller turns a failure into a typed error. A claim that fails\n * after creating directories (a file name too long for the file system) removes them again.\n */\nexport function claimFileAt(filePath: string, queries: PathQueries): ClaimedFile {\n  const directories = createDirectory(path.dirname(filePath), queries);\n  let opened: ReturnType<typeof openClaim>;\n  try {\n    opened = openClaim(filePath);\n  } catch (error) {\n    removeDirectories(directories);\n    throw error;\n  }\n  const { identity, createdFile } = opened;\n  return {\n    identity,\n    release: () => {\n      if (createdFile !== undefined) {\n        fs.rmSync(createdFile, { force: true });\n      }\n      removeDirectories(directories);\n    },\n  };\n}\n\n/** Write `contents` to `filePath`, creating its directory; a failed write removes what it made. */\nexport function writeFileAt(filePath: string, contents: string, queries: PathQueries): void {\n  const directories = createDirectory(path.dirname(filePath), queries);\n  try {\n    fs.writeFileSync(filePath, contents, \"utf8\");\n  } catch (error) {\n    removeDirectories(directories);\n    throw error;\n  }\n}\n"],"names":["path","fs","creationPath"],"mappings":"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"}

package/dist/adapters/node-file-system/file-claims.mjs

@@ -0,0 +1,95 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { creationPath } from './file-identity.mjs';
+
+function missingDirectories(directory, exists) {
+  const missing = [];
+  for (let current = directory; !exists(current); current = path.dirname(current)) {
+    missing.push(current);
+    if (path.dirname(current) === current) {
+      break;
+    }
+  }
+  return missing;
+}
+function claimIdentity(number, storedPath) {
+  return number.file === 0n ? `path:${storedPath()}` : `${number.device}:${number.file}`;
+}
+function identityOf(descriptor, filePath) {
+  const status = fs.fstatSync(descriptor, { bigint: true });
+  return claimIdentity(
+    { device: status.dev, file: status.ino },
+    () => fs.realpathSync.native(filePath)
+  );
+}
+function errorCodeOf(error) {
+  return error instanceof Error && "code" in error ? error.code : void 0;
+}
+function removeDirectories(directories) {
+  for (const directory of directories) {
+    try {
+      fs.rmdirSync(directory);
+    } catch (error) {
+      const code = errorCodeOf(error);
+      if (code === "ENOTEMPTY" || code === "EEXIST") {
+        return;
+      }
+      if (code !== "ENOENT" || fs.lstatSync(directory, { throwIfNoEntry: false }) !== void 0) {
+        throw error;
+      }
+    }
+  }
+}
+function createDirectory(directory, queries) {
+  const target = creationPath(directory, queries);
+  const missing = missingDirectories(target, fs.existsSync);
+  try {
+    fs.mkdirSync(target, { recursive: true });
+  } catch (error) {
+    removeDirectories(missing.filter((created) => fs.existsSync(created)));
+    throw error;
+  }
+  return missing;
+}
+function openClaim(filePath) {
+  const isCreated = !fs.existsSync(filePath);
+  const descriptor = fs.openSync(filePath, "a");
+  try {
+    const identity = identityOf(descriptor, filePath);
+    return { identity, createdFile: isCreated ? fs.realpathSync.native(filePath) : void 0 };
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+function claimFileAt(filePath, queries) {
+  const directories = createDirectory(path.dirname(filePath), queries);
+  let opened;
+  try {
+    opened = openClaim(filePath);
+  } catch (error) {
+    removeDirectories(directories);
+    throw error;
+  }
+  const { identity, createdFile } = opened;
+  return {
+    identity,
+    release: () => {
+      if (createdFile !== void 0) {
+        fs.rmSync(createdFile, { force: true });
+      }
+      removeDirectories(directories);
+    }
+  };
+}
+function writeFileAt(filePath, contents, queries) {
+  const directories = createDirectory(path.dirname(filePath), queries);
+  try {
+    fs.writeFileSync(filePath, contents, "utf8");
+  } catch (error) {
+    removeDirectories(directories);
+    throw error;
+  }
+}
+
+export { claimFileAt, claimIdentity, missingDirectories, writeFileAt };
+//# sourceMappingURL=file-claims.mjs.map

package/dist/adapters/node-file-system/file-claims.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-claims.mjs","sources":["../../../src/adapters/node-file-system/file-claims.ts"],"sourcesContent":["import fs from \"node:fs\";\nimport path from \"node:path\";\nimport type { ClaimedFile } from \"../../application/ports/file-system.js\";\nimport { creationPath, type FileNumber, type PathQueries } from \"./file-identity.js\";\n\n/**\n * Claiming an output on Node's `fs` (ADR-043, decision 1): the file is opened for appending,\n * which creates it when it is missing (also through a symbolic link) and never truncates it.\n * The device and file number of the open file are its identity. A claim or a write that fails\n * removes the directories it created.\n */\n\n/**\n * The directories that do not exist yet on the way to `directory`, deepest first: the ones a\n * recursive `fs.mkdirSync` creates. They are listed before it runs, in the form of `directory`\n * itself: on Windows the path that `fs.mkdirSync` returns did not match that form, so comparing\n * with it found no new directory and a failed run left them behind.\n */\nexport function missingDirectories(\n  directory: string,\n  exists: (candidate: string) => boolean,\n): string[] {\n  const missing: string[] = [];\n  for (let current = directory; !exists(current); current = path.dirname(current)) {\n    missing.push(current);\n    if (path.dirname(current) === current) {\n      break;\n    }\n  }\n  return missing;\n}\n\n/**\n * The identity of an open file: its device and file number, or its stored path on a file system\n * that reports the file number 0 (FAT, some network shares), which proves nothing.\n */\nexport function claimIdentity(number: FileNumber, storedPath: () => string): string {\n  return number.file === 0n ? `path:${storedPath()}` : `${number.device}:${number.file}`;\n}\n\nfunction identityOf(descriptor: number, filePath: string): string {\n  const status = fs.fstatSync(descriptor, { bigint: true });\n  return claimIdentity({ device: status.dev, file: status.ino }, () =>\n    fs.realpathSync.native(filePath),\n  );\n}\n\nfunction errorCodeOf(error: unknown): unknown {\n  return error instanceof Error && \"code\" in error ? error.code : undefined;\n}\n\n/** Remove the new directories, deepest first, until one holds another file. */\nfunction removeDirectories(directories: readonly string[]): void {\n  for (const directory of directories) {\n    try {\n      fs.rmdirSync(directory);\n    } catch (error) {\n      const code = errorCodeOf(error);\n      // Another output or the user put a file there since: the directory and its parents stay.\n      if (code === \"ENOTEMPTY\" || code === \"EEXIST\") {\n        return;\n      }\n      // Removed since: nothing to remove, but its parents may still be empty. Windows also gives\n      // ENOENT for a file put in its place, which must fail like any other path it cannot remove.\n      if (code !== \"ENOENT\" || fs.lstatSync(directory, { throwIfNoEntry: false }) !== undefined) {\n        throw error;\n      }\n    }\n  }\n}\n\n/**\n * Create `directory` and give the directories that this created. Through a link to a missing\n * directory it creates the link's target, as a write through the link would, so the path to\n * create and the new directories are real paths, where links are already followed. A recursive\n * `mkdir` that fails part of the way (a directory name too long for the file system) keeps the\n * directories above the failing one, so the ones that exist now are removed here.\n */\nfunction createDirectory(directory: string, queries: PathQueries): string[] {\n  const target = creationPath(directory, queries);\n  const missing = missingDirectories(target, fs.existsSync);\n  try {\n    fs.mkdirSync(target, { recursive: true });\n  } catch (error) {\n    removeDirectories(missing.filter((created) => fs.existsSync(created)));\n    throw error;\n  }\n  return missing;\n}\n\n/** Open `filePath` for appending, which creates it, and give its identity and whether it is new. */\nfunction openClaim(filePath: string): { identity: string; createdFile: string | undefined } {\n  const isCreated = !fs.existsSync(filePath);\n  const descriptor = fs.openSync(filePath, \"a\");\n  try {\n    const identity = identityOf(descriptor, filePath);\n    // A link to a missing file created its target: that file is what the claim removes.\n    return { identity, createdFile: isCreated ? fs.realpathSync.native(filePath) : undefined };\n  } finally {\n    fs.closeSync(descriptor);\n  }\n}\n\n/**\n * Claim the file at `filePath`; the caller turns a failure into a typed error. A claim that fails\n * after creating directories (a file name too long for the file system) removes them again.\n */\nexport function claimFileAt(filePath: string, queries: PathQueries): ClaimedFile {\n  const directories = createDirectory(path.dirname(filePath), queries);\n  let opened: ReturnType<typeof openClaim>;\n  try {\n    opened = openClaim(filePath);\n  } catch (error) {\n    removeDirectories(directories);\n    throw error;\n  }\n  const { identity, createdFile } = opened;\n  return {\n    identity,\n    release: () => {\n      if (createdFile !== undefined) {\n        fs.rmSync(createdFile, { force: true });\n      }\n      removeDirectories(directories);\n    },\n  };\n}\n\n/** Write `contents` to `filePath`, creating its directory; a failed write removes what it made. */\nexport function writeFileAt(filePath: string, contents: string, queries: PathQueries): void {\n  const directories = createDirectory(path.dirname(filePath), queries);\n  try {\n    fs.writeFileSync(filePath, contents, \"utf8\");\n  } catch (error) {\n    removeDirectories(directories);\n    throw error;\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/adapters/node-file-system/file-identity.cjs

@@ -0,0 +1,82 @@
+'use strict';
+
+const path = require('node:path');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+
+const MAX_LINK_HOPS = 40;
+function isSameFileNumber(left, right) {
+  return left.file !== 0n && left.file === right.file && left.device === right.device;
+}
+function hasLetters(text) {
+  return text.toLowerCase() !== text.toUpperCase();
+}
+function flipCase(text) {
+  return [...text].map((character) => {
+    const upper = character.toUpperCase();
+    return character === upper ? character.toLowerCase() : upper;
+  }).join("");
+}
+function isFoundInOtherCase(entryPath, queries) {
+  const status = queries.status(entryPath);
+  if (!status) {
+    return void 0;
+  }
+  const flipped = path__default.join(path__default.dirname(entryPath), flipCase(path__default.basename(entryPath)));
+  const flippedStatus = queries.status(flipped);
+  return flippedStatus !== void 0 && isSameFileNumber(status, flippedStatus);
+}
+function ignoresCase(directory, queries) {
+  const candidates = [
+    ...queries.entries(directory).filter(hasLetters).map((name) => path__default.join(directory, name)),
+    ...hasLetters(path__default.basename(directory)) ? [directory] : []
+  ];
+  for (const candidate of candidates) {
+    const answer = isFoundInOtherCase(candidate, queries);
+    if (answer !== void 0) {
+      return answer;
+    }
+  }
+  return false;
+}
+function nearestExisting(filePath, queries) {
+  const missing = [];
+  let current = path__default.resolve(filePath);
+  let hops = 0;
+  while (queries.status(current) === void 0) {
+    const target = hops < MAX_LINK_HOPS ? queries.linkTarget(current) : void 0;
+    if (target !== void 0) {
+      current = path__default.resolve(queries.realPath(path__default.dirname(current)), target);
+      hops += 1;
+      continue;
+    }
+    const parent = path__default.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    missing.unshift(path__default.basename(current));
+    current = parent;
+  }
+  return [current, missing];
+}
+function creationPath(filePath, queries) {
+  const [existing, missing] = nearestExisting(filePath, queries);
+  return path__default.join(queries.realPath(existing), ...missing);
+}
+function fileIdentityKey(filePath, queries) {
+  const [existing, missing] = nearestExisting(filePath, queries);
+  const realExisting = queries.realPath(existing);
+  if (missing.length === 0) {
+    return realExisting;
+  }
+  const isCaseIgnored = ignoresCase(realExisting, queries);
+  const rest = isCaseIgnored ? missing.map((segment) => segment.toLowerCase()) : missing;
+  return path__default.join(realExisting, ...rest);
+}
+
+exports.creationPath = creationPath;
+exports.fileIdentityKey = fileIdentityKey;
+exports.isSameFileNumber = isSameFileNumber;
+//# sourceMappingURL=file-identity.cjs.map

package/dist/adapters/node-file-system/file-identity.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-identity.cjs","sources":["../../../src/adapters/node-file-system/file-identity.ts"],"sourcesContent":["import path from \"node:path\";\n\n/**\n * The identity of a file path, also of one that does not exist yet (an output before the first\n * run). Two paths are one file when their keys are equal: the real path of the nearest existing\n * ancestor (links resolved, letter case as stored on disk) followed by the segments that do not\n * exist yet, compared in the letter case rules of the file system that will hold them. Equal keys\n * prove one file; different keys do not prove two (Unicode normalization, full case folding):\n * the CLI claims every output before writing to decide those (ADR-043, decision 1).\n */\n\n/** A device and a file number: one file, also through a hard link. */\nexport interface FileNumber {\n  readonly device: bigint;\n  readonly file: bigint;\n}\n\n/** The file-system queries the identity needs; Node's `fs` in production, a fake in tests. */\nexport interface PathQueries {\n  /** The file number of a path, following links; undefined when it cannot be read. */\n  status(filePath: string): FileNumber | undefined;\n  /** The path with every link resolved, in the letter case stored on disk. */\n  realPath(filePath: string): string;\n  /** The names in a directory; empty when it cannot be listed. */\n  entries(directory: string): readonly string[];\n  /** The target of a symbolic link as written in it; undefined for a path that is no link. */\n  linkTarget(filePath: string): string | undefined;\n}\n\n/**\n * The most links followed for one path. Linux follows at most 40 (MAXSYMLINKS) and macOS 32\n * before it fails with ELOOP; a longer chain is a loop, and the path is taken as missing.\n */\nconst MAX_LINK_HOPS = 40;\n\n/** Whether two file numbers name one file. */\nexport function isSameFileNumber(left: FileNumber, right: FileNumber): boolean {\n  // Some file systems (FAT, some network shares) report no file number: 0 then proves nothing.\n  return left.file !== 0n && left.file === right.file && left.device === right.device;\n}\n\nfunction hasLetters(text: string): boolean {\n  return text.toLowerCase() !== text.toUpperCase();\n}\n\nfunction flipCase(text: string): string {\n  return [...text]\n    .map((character) => {\n      const upper = character.toUpperCase();\n      return character === upper ? character.toLowerCase() : upper;\n    })\n    .join(\"\");\n}\n\n/** Whether a directory entry is also found under its name in the other letter case. */\nfunction isFoundInOtherCase(entryPath: string, queries: PathQueries): boolean | undefined {\n  const status = queries.status(entryPath);\n  if (!status) {\n    return undefined;\n  }\n  const flipped = path.join(path.dirname(entryPath), flipCase(path.basename(entryPath)));\n  const flippedStatus = queries.status(flipped);\n  return flippedStatus !== undefined && isSameFileNumber(status, flippedStatus);\n}\n\n/**\n * Whether new names in `directory` ignore letter case. It is asked of the file system, not\n * assumed from the OS: macOS and Windows volumes can be case-sensitive, and Linux mounts can\n * ignore case. An entry of the directory is looked up in the other case; without one with\n * letters, the directory itself is. With nothing to look up, names are taken as case-sensitive.\n */\nfunction ignoresCase(directory: string, queries: PathQueries): boolean {\n  const candidates = [\n    ...queries\n      .entries(directory)\n      .filter(hasLetters)\n      .map((name) => path.join(directory, name)),\n    ...(hasLetters(path.basename(directory)) ? [directory] : []),\n  ];\n  for (const candidate of candidates) {\n    const answer = isFoundInOtherCase(candidate, queries);\n    if (answer !== undefined) {\n      return answer;\n    }\n  }\n  return false;\n}\n\n/**\n * The nearest ancestor of `filePath` that exists (or the path itself), and the rest below it. A\n * link to a missing file or directory is followed to its target, which a write would create: so\n * `link/x.ts` with `link -> missing` is `missing/x.ts`. A relative target is read from the real\n * directory of the link, as the system does: with `a -> real/sub` and\n * `real/sub/link -> ../missing`, `a/link` is `real/missing`, not `missing`.\n */\nfunction nearestExisting(filePath: string, queries: PathQueries): [string, string[]] {\n  const missing: string[] = [];\n  let current = path.resolve(filePath);\n  let hops = 0;\n  while (queries.status(current) === undefined) {\n    const target = hops < MAX_LINK_HOPS ? queries.linkTarget(current) : undefined;\n    if (target !== undefined) {\n      current = path.resolve(queries.realPath(path.dirname(current)), target);\n      hops += 1;\n      continue;\n    }\n    const parent = path.dirname(current);\n    if (parent === current) {\n      break;\n    }\n    missing.unshift(path.basename(current));\n    current = parent;\n  }\n  return [current, missing];\n}\n\n/**\n * The path that a write to `filePath` creates, with links followed also where their target is\n * missing: `link/x.ts` with `link -> missing` is the real path of `missing/x.ts`. `mkdir` does not\n * follow a link to a missing directory on Linux and Windows, so the directories are created here.\n */\nexport function creationPath(filePath: string, queries: PathQueries): string {\n  const [existing, missing] = nearestExisting(filePath, queries);\n  return path.join(queries.realPath(existing), ...missing);\n}\n\n/** The key of a path: equal keys are one file, whether or not it exists yet. */\nexport function fileIdentityKey(filePath: string, queries: PathQueries): string {\n  const [existing, missing] = nearestExisting(filePath, queries);\n  const realExisting = queries.realPath(existing);\n  if (missing.length === 0) {\n    return realExisting;\n  }\n  const isCaseIgnored = ignoresCase(realExisting, queries);\n  const rest = isCaseIgnored ? missing.map((segment) => segment.toLowerCase()) : missing;\n  return path.join(realExisting, ...rest);\n}\n"],"names":["path"],"mappings":"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"}

package/dist/adapters/node-file-system/file-identity.mjs

@@ -0,0 +1,74 @@
+import path from 'node:path';
+
+const MAX_LINK_HOPS = 40;
+function isSameFileNumber(left, right) {
+  return left.file !== 0n && left.file === right.file && left.device === right.device;
+}
+function hasLetters(text) {
+  return text.toLowerCase() !== text.toUpperCase();
+}
+function flipCase(text) {
+  return [...text].map((character) => {
+    const upper = character.toUpperCase();
+    return character === upper ? character.toLowerCase() : upper;
+  }).join("");
+}
+function isFoundInOtherCase(entryPath, queries) {
+  const status = queries.status(entryPath);
+  if (!status) {
+    return void 0;
+  }
+  const flipped = path.join(path.dirname(entryPath), flipCase(path.basename(entryPath)));
+  const flippedStatus = queries.status(flipped);
+  return flippedStatus !== void 0 && isSameFileNumber(status, flippedStatus);
+}
+function ignoresCase(directory, queries) {
+  const candidates = [
+    ...queries.entries(directory).filter(hasLetters).map((name) => path.join(directory, name)),
+    ...hasLetters(path.basename(directory)) ? [directory] : []
+  ];
+  for (const candidate of candidates) {
+    const answer = isFoundInOtherCase(candidate, queries);
+    if (answer !== void 0) {
+      return answer;
+    }
+  }
+  return false;
+}
+function nearestExisting(filePath, queries) {
+  const missing = [];
+  let current = path.resolve(filePath);
+  let hops = 0;
+  while (queries.status(current) === void 0) {
+    const target = hops < MAX_LINK_HOPS ? queries.linkTarget(current) : void 0;
+    if (target !== void 0) {
+      current = path.resolve(queries.realPath(path.dirname(current)), target);
+      hops += 1;
+      continue;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    missing.unshift(path.basename(current));
+    current = parent;
+  }
+  return [current, missing];
+}
+function creationPath(filePath, queries) {
+  const [existing, missing] = nearestExisting(filePath, queries);
+  return path.join(queries.realPath(existing), ...missing);
+}
+function fileIdentityKey(filePath, queries) {
+  const [existing, missing] = nearestExisting(filePath, queries);
+  const realExisting = queries.realPath(existing);
+  if (missing.length === 0) {
+    return realExisting;
+  }
+  const isCaseIgnored = ignoresCase(realExisting, queries);
+  const rest = isCaseIgnored ? missing.map((segment) => segment.toLowerCase()) : missing;
+  return path.join(realExisting, ...rest);
+}
+
+export { creationPath, fileIdentityKey, isSameFileNumber };
+//# sourceMappingURL=file-identity.mjs.map

package/dist/adapters/node-file-system/file-identity.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-identity.mjs","sources":["../../../src/adapters/node-file-system/file-identity.ts"],"sourcesContent":["import path from \"node:path\";\n\n/**\n * The identity of a file path, also of one that does not exist yet (an output before the first\n * run). Two paths are one file when their keys are equal: the real path of the nearest existing\n * ancestor (links resolved, letter case as stored on disk) followed by the segments that do not\n * exist yet, compared in the letter case rules of the file system that will hold them. Equal keys\n * prove one file; different keys do not prove two (Unicode normalization, full case folding):\n * the CLI claims every output before writing to decide those (ADR-043, decision 1).\n */\n\n/** A device and a file number: one file, also through a hard link. */\nexport interface FileNumber {\n  readonly device: bigint;\n  readonly file: bigint;\n}\n\n/** The file-system queries the identity needs; Node's `fs` in production, a fake in tests. */\nexport interface PathQueries {\n  /** The file number of a path, following links; undefined when it cannot be read. */\n  status(filePath: string): FileNumber | undefined;\n  /** The path with every link resolved, in the letter case stored on disk. */\n  realPath(filePath: string): string;\n  /** The names in a directory; empty when it cannot be listed. */\n  entries(directory: string): readonly string[];\n  /** The target of a symbolic link as written in it; undefined for a path that is no link. */\n  linkTarget(filePath: string): string | undefined;\n}\n\n/**\n * The most links followed for one path. Linux follows at most 40 (MAXSYMLINKS) and macOS 32\n * before it fails with ELOOP; a longer chain is a loop, and the path is taken as missing.\n */\nconst MAX_LINK_HOPS = 40;\n\n/** Whether two file numbers name one file. */\nexport function isSameFileNumber(left: FileNumber, right: FileNumber): boolean {\n  // Some file systems (FAT, some network shares) report no file number: 0 then proves nothing.\n  return left.file !== 0n && left.file === right.file && left.device === right.device;\n}\n\nfunction hasLetters(text: string): boolean {\n  return text.toLowerCase() !== text.toUpperCase();\n}\n\nfunction flipCase(text: string): string {\n  return [...text]\n    .map((character) => {\n      const upper = character.toUpperCase();\n      return character === upper ? character.toLowerCase() : upper;\n    })\n    .join(\"\");\n}\n\n/** Whether a directory entry is also found under its name in the other letter case. */\nfunction isFoundInOtherCase(entryPath: string, queries: PathQueries): boolean | undefined {\n  const status = queries.status(entryPath);\n  if (!status) {\n    return undefined;\n  }\n  const flipped = path.join(path.dirname(entryPath), flipCase(path.basename(entryPath)));\n  const flippedStatus = queries.status(flipped);\n  return flippedStatus !== undefined && isSameFileNumber(status, flippedStatus);\n}\n\n/**\n * Whether new names in `directory` ignore letter case. It is asked of the file system, not\n * assumed from the OS: macOS and Windows volumes can be case-sensitive, and Linux mounts can\n * ignore case. An entry of the directory is looked up in the other case; without one with\n * letters, the directory itself is. With nothing to look up, names are taken as case-sensitive.\n */\nfunction ignoresCase(directory: string, queries: PathQueries): boolean {\n  const candidates = [\n    ...queries\n      .entries(directory)\n      .filter(hasLetters)\n      .map((name) => path.join(directory, name)),\n    ...(hasLetters(path.basename(directory)) ? [directory] : []),\n  ];\n  for (const candidate of candidates) {\n    const answer = isFoundInOtherCase(candidate, queries);\n    if (answer !== undefined) {\n      return answer;\n    }\n  }\n  return false;\n}\n\n/**\n * The nearest ancestor of `filePath` that exists (or the path itself), and the rest below it. A\n * link to a missing file or directory is followed to its target, which a write would create: so\n * `link/x.ts` with `link -> missing` is `missing/x.ts`. A relative target is read from the real\n * directory of the link, as the system does: with `a -> real/sub` and\n * `real/sub/link -> ../missing`, `a/link` is `real/missing`, not `missing`.\n */\nfunction nearestExisting(filePath: string, queries: PathQueries): [string, string[]] {\n  const missing: string[] = [];\n  let current = path.resolve(filePath);\n  let hops = 0;\n  while (queries.status(current) === undefined) {\n    const target = hops < MAX_LINK_HOPS ? queries.linkTarget(current) : undefined;\n    if (target !== undefined) {\n      current = path.resolve(queries.realPath(path.dirname(current)), target);\n      hops += 1;\n      continue;\n    }\n    const parent = path.dirname(current);\n    if (parent === current) {\n      break;\n    }\n    missing.unshift(path.basename(current));\n    current = parent;\n  }\n  return [current, missing];\n}\n\n/**\n * The path that a write to `filePath` creates, with links followed also where their target is\n * missing: `link/x.ts` with `link -> missing` is the real path of `missing/x.ts`. `mkdir` does not\n * follow a link to a missing directory on Linux and Windows, so the directories are created here.\n */\nexport function creationPath(filePath: string, queries: PathQueries): string {\n  const [existing, missing] = nearestExisting(filePath, queries);\n  return path.join(queries.realPath(existing), ...missing);\n}\n\n/** The key of a path: equal keys are one file, whether or not it exists yet. */\nexport function fileIdentityKey(filePath: string, queries: PathQueries): string {\n  const [existing, missing] = nearestExisting(filePath, queries);\n  const realExisting = queries.realPath(existing);\n  if (missing.length === 0) {\n    return realExisting;\n  }\n  const isCaseIgnored = ignoresCase(realExisting, queries);\n  const rest = isCaseIgnored ? missing.map((segment) => segment.toLowerCase()) : missing;\n  return path.join(realExisting, ...rest);\n}\n"],"names":[],"mappings":"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"}

package/dist/adapters/node-file-system/node-file-system.cjs

@@ -3,6 +3,8 @@
 const fs = require('node:fs');
 const node_url = require('node:url');
 const errors = require('../../domain/errors.cjs');
+const fileClaims = require('./file-claims.cjs');
+const fileIdentity = require('./file-identity.cjs');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
@@ -11,31 +13,105 @@ const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
 function causeMessage(cause) {
   return cause instanceof Error ? cause.message : String(cause);
 }
+function statusOf(filePath) {
+  try {
+    const status = fs__default.statSync(filePath, { bigint: true });
+    return { device: status.dev, file: status.ino };
+  } catch {
+    return void 0;
+  }
+}
+function realPathOf(filePath) {
+  try {
+    return fs__default.realpathSync.native(filePath);
+  } catch {
+    return filePath;
+  }
+}
+function entriesOf(directory) {
+  try {
+    return fs__default.readdirSync(directory);
+  } catch {
+    return [];
+  }
+}
+function linkTargetOf(filePath) {
+  try {
+    return fs__default.readlinkSync(filePath);
+  } catch {
+    return void 0;
+  }
+}
+const NODE_PATH_QUERIES = {
+  status: statusOf,
+  realPath: realPathOf,
+  entries: entriesOf,
+  linkTarget: linkTargetOf
+};
+function localPathOf(file) {
+  try {
+    return node_url.fileURLToPath(file);
+  } catch {
+    return void 0;
+  }
+}
+function fileError(code, verb, file, cause) {
+  const name = localPathOf(file) ?? file.href;
+  return new errors.OpenAPITypesafeError({
+    code,
+    message: `Cannot ${verb} ${name}: ${causeMessage(cause)}`,
+    details: { file: name },
+    cause
+  });
+}
+function typedWrite(file, step) {
+  try {
+    return step();
+  } catch (cause) {
+    throw fileError(errors.ERROR_CODES.OUTPUT_WRITE_FAILED, "write", file, cause);
+  }
+}
 class NodeFileSystem {
   readText(file) {
     try {
       return fs__default.readFileSync(file, "utf8");
     } catch (cause) {
-      throw new errors.OpenAPITypesafeError({
-        code: errors.ERROR_CODES.OUTPUT_READ_FAILED,
-        message: `Cannot read ${node_url.fileURLToPath(file)}: ${causeMessage(cause)}`,
-        details: { file: node_url.fileURLToPath(file) },
-        cause
-      });
+      throw fileError(errors.ERROR_CODES.OUTPUT_READ_FAILED, "read", file, cause);
     }
   }
   writeText(file, contents) {
     try {
-      fs__default.mkdirSync(new URL(".", file), { recursive: true });
-      fs__default.writeFileSync(file, contents, "utf8");
+      fileClaims.writeFileAt(node_url.fileURLToPath(file), contents, NODE_PATH_QUERIES);
     } catch (cause) {
-      throw new errors.OpenAPITypesafeError({
-        code: errors.ERROR_CODES.OUTPUT_WRITE_FAILED,
-        message: `Cannot write ${node_url.fileURLToPath(file)}: ${causeMessage(cause)}`,
-        details: { file: node_url.fileURLToPath(file) },
-        cause
-      });
+      throw fileError(errors.ERROR_CODES.OUTPUT_WRITE_FAILED, "write", file, cause);
+    }
+  }
+  claimFile(file) {
+    const claim = typedWrite(file, () => fileClaims.claimFileAt(node_url.fileURLToPath(file), NODE_PATH_QUERIES));
+    return {
+      identity: claim.identity,
+      release: () => typedWrite(file, () => claim.release())
+    };
+  }
+  isDirectory(file) {
+    try {
+      return fs__default.statSync(file).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  isSameFile(left, right) {
+    const leftPath = node_url.fileURLToPath(left);
+    const rightPath = node_url.fileURLToPath(right);
+    if (leftPath === rightPath) {
+      return true;
+    }
+    const leftStatus = statusOf(leftPath);
+    const rightStatus = statusOf(rightPath);
+    if (leftStatus && rightStatus && fileIdentity.isSameFileNumber(leftStatus, rightStatus)) {
+      return true;
     }
+    return fileIdentity.fileIdentityKey(leftPath, NODE_PATH_QUERIES) === fileIdentity.fileIdentityKey(rightPath, NODE_PATH_QUERIES);
   }
 }
 function createNodeFileSystem() {

package/dist/adapters/node-file-system/node-file-system.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"node-file-system.cjs","sources":["../../../src/adapters/node-file-system/node-file-system.ts"],"sourcesContent":["import fs from \"node:fs\";\nimport { fileURLToPath } from \"node:url\";\nimport type { FileReader, FileWriter } from \"../../application/ports/file-system.js\";\nimport { ERROR_CODES, OpenAPITypesafeError } from \"../../domain/errors.js\";\n\n/** The file ports on Node's `fs`, with the failures as typed errors (ADR-011). */\n\nfunction causeMessage(cause: unknown): string {\n  return cause instanceof Error ? cause.message : String(cause);\n}\n\nclass NodeFileSystem implements FileReader, FileWriter {\n  readText(file: URL): string {\n    try {\n      return fs.readFileSync(file, \"utf8\");\n    } catch (cause) {\n      throw new OpenAPITypesafeError({\n        code: ERROR_CODES.OUTPUT_READ_FAILED,\n        message: `Cannot read ${fileURLToPath(file)}: ${causeMessage(cause)}`,\n        details: { file: fileURLToPath(file) },\n        cause,\n      });\n    }\n  }\n\n  writeText(file: URL, contents: string): void {\n    try {\n      fs.mkdirSync(new URL(\".\", file), { recursive: true });\n      fs.writeFileSync(file, contents, \"utf8\");\n    } catch (cause) {\n      throw new OpenAPITypesafeError({\n        code: ERROR_CODES.OUTPUT_WRITE_FAILED,\n        message: `Cannot write ${fileURLToPath(file)}: ${causeMessage(cause)}`,\n        details: { file: fileURLToPath(file) },\n        cause,\n      });\n    }\n  }\n}\n\n/** File access for the CLI. */\nexport function createNodeFileSystem(): FileReader & FileWriter {\n  return new NodeFileSystem();\n}\n"],"names":["fs","OpenAPITypesafeError","ERROR_CODES","fileURLToPath"],"mappings":";;;;;;;;;;AAOA,SAAS,aAAa,KAAA,EAAwB;AAC5C,EAAA,OAAO,KAAA,YAAiB,KAAA,GAAQ,KAAA,CAAM,OAAA,GAAU,OAAO,KAAK,CAAA;AAC9D;AAEA,MAAM,cAAA,CAAiD;AAAA,EACrD,SAAS,IAAA,EAAmB;AAC1B,IAAA,IAAI;AACF,MAAA,OAAOA,WAAA,CAAG,YAAA,CAAa,IAAA,EAAM,MAAM,CAAA;AAAA,IACrC,SAAS,KAAA,EAAO;AACd,MAAA,MAAM,IAAIC,2BAAA,CAAqB;AAAA,QAC7B,MAAMC,kBAAA,CAAY,kBAAA;AAAA,QAClB,OAAA,EAAS,eAAeC,sBAAA,CAAc,IAAI,CAAC,CAAA,EAAA,EAAK,YAAA,CAAa,KAAK,CAAC,CAAA,CAAA;AAAA,QACnE,OAAA,EAAS,EAAE,IAAA,EAAMA,sBAAA,CAAc,IAAI,CAAA,EAAE;AAAA,QACrC;AAAA,OACD,CAAA;AAAA,IACH;AAAA,EACF;AAAA,EAEA,SAAA,CAAU,MAAW,QAAA,EAAwB;AAC3C,IAAA,IAAI;AACF,MAAAH,WAAA,CAAG,SAAA,CAAU,IAAI,GAAA,CAAI,GAAA,EAAK,IAAI,CAAA,EAAG,EAAE,SAAA,EAAW,IAAA,EAAM,CAAA;AACpD,MAAAA,WAAA,CAAG,aAAA,CAAc,IAAA,EAAM,QAAA,EAAU,MAAM,CAAA;AAAA,IACzC,SAAS,KAAA,EAAO;AACd,MAAA,MAAM,IAAIC,2BAAA,CAAqB;AAAA,QAC7B,MAAMC,kBAAA,CAAY,mBAAA;AAAA,QAClB,OAAA,EAAS,gBAAgBC,sBAAA,CAAc,IAAI,CAAC,CAAA,EAAA,EAAK,YAAA,CAAa,KAAK,CAAC,CAAA,CAAA;AAAA,QACpE,OAAA,EAAS,EAAE,IAAA,EAAMA,sBAAA,CAAc,IAAI,CAAA,EAAE;AAAA,QACrC;AAAA,OACD,CAAA;AAAA,IACH;AAAA,EACF;AACF;AAGO,SAAS,oBAAA,GAAgD;AAC9D,EAAA,OAAO,IAAI,cAAA,EAAe;AAC5B;;"}
+{"version":3,"file":"node-file-system.cjs","sources":["../../../src/adapters/node-file-system/node-file-system.ts"],"sourcesContent":["import fs from \"node:fs\";\nimport { fileURLToPath } from \"node:url\";\nimport type {\n  ClaimedFile,\n  DirectoryCheck,\n  FileClaims,\n  FileIdentity,\n  FileReader,\n  FileWriter,\n} from \"../../application/ports/file-system.js\";\nimport { ERROR_CODES, type ErrorCode, OpenAPITypesafeError } from \"../../domain/errors.js\";\nimport { claimFileAt, writeFileAt } from \"./file-claims.js\";\nimport {\n  type FileNumber,\n  fileIdentityKey,\n  isSameFileNumber,\n  type PathQueries,\n} from \"./file-identity.js\";\n\n/** The file ports on Node's `fs`, with the failures as typed errors (ADR-011). */\n\nfunction causeMessage(cause: unknown): string {\n  return cause instanceof Error ? cause.message : String(cause);\n}\n\n/**\n * The file number of a path, or undefined when it cannot be read. A missing output is the common\n * case; any other failure (no access, a file used as a directory) is reported by the read or write\n * that follows, so the identity check does not report it a second time.\n */\nfunction statusOf(filePath: string): FileNumber | undefined {\n  try {\n    const status = fs.statSync(filePath, { bigint: true });\n    return { device: status.dev, file: status.ino };\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * The native `realpath` resolves symbolic links and returns the letter case stored on disk, which\n * the JavaScript one does not do on a case-insensitive file system. A path that vanished since its\n * status was read keeps its own spelling.\n */\nfunction realPathOf(filePath: string): string {\n  try {\n    return fs.realpathSync.native(filePath);\n  } catch {\n    return filePath;\n  }\n}\n\n/** A directory that cannot be listed has no entry to tell its letter case rules by. */\nfunction entriesOf(directory: string): readonly string[] {\n  try {\n    return fs.readdirSync(directory);\n  } catch {\n    return [];\n  }\n}\n\n/**\n * The target of a symbolic link, as written in it; undefined for a path that is no link or cannot\n * be read. The key then treats the path as missing, and the claim at write time decides.\n */\nfunction linkTargetOf(filePath: string): string | undefined {\n  try {\n    return fs.readlinkSync(filePath);\n  } catch {\n    return undefined;\n  }\n}\n\nconst NODE_PATH_QUERIES: PathQueries = {\n  status: statusOf,\n  realPath: realPathOf,\n  entries: entriesOf,\n  linkTarget: linkTargetOf,\n};\n\n/** The path of a `file:` URL, or undefined for a URL that names no file on this platform. */\nfunction localPathOf(file: URL): string | undefined {\n  try {\n    return fileURLToPath(file);\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * A failed read or write as a typed error. The location is named by its path, or by the URL when\n * it names no local file: computing the path must not throw a second, untyped error here.\n */\nfunction fileError(code: ErrorCode, verb: string, file: URL, cause: unknown): OpenAPITypesafeError {\n  const name = localPathOf(file) ?? file.href;\n  return new OpenAPITypesafeError({\n    code,\n    message: `Cannot ${verb} ${name}: ${causeMessage(cause)}`,\n    details: { file: name },\n    cause,\n  });\n}\n\n/** Run a step that writes `file`, with its failure as `OUTPUT_WRITE_FAILED`. */\nfunction typedWrite<T>(file: URL, step: () => T): T {\n  try {\n    return step();\n  } catch (cause) {\n    throw fileError(ERROR_CODES.OUTPUT_WRITE_FAILED, \"write\", file, cause);\n  }\n}\n\nclass NodeFileSystem implements FileReader, FileWriter, FileIdentity, DirectoryCheck, FileClaims {\n  readText(file: URL): string {\n    try {\n      return fs.readFileSync(file, \"utf8\");\n    } catch (cause) {\n      throw fileError(ERROR_CODES.OUTPUT_READ_FAILED, \"read\", file, cause);\n    }\n  }\n\n  writeText(file: URL, contents: string): void {\n    try {\n      writeFileAt(fileURLToPath(file), contents, NODE_PATH_QUERIES);\n    } catch (cause) {\n      throw fileError(ERROR_CODES.OUTPUT_WRITE_FAILED, \"write\", file, cause);\n    }\n  }\n\n  claimFile(file: URL): ClaimedFile {\n    const claim = typedWrite(file, () => claimFileAt(fileURLToPath(file), NODE_PATH_QUERIES));\n    return {\n      identity: claim.identity,\n      release: () => typedWrite(file, () => claim.release()),\n    };\n  }\n\n  isDirectory(file: URL): boolean {\n    try {\n      return fs.statSync(file).isDirectory();\n    } catch {\n      // Missing or unreadable: not a directory; the write that follows reports a failure.\n      return false;\n    }\n  }\n\n  isSameFile(left: URL, right: URL): boolean {\n    const leftPath = fileURLToPath(left);\n    const rightPath = fileURLToPath(right);\n    if (leftPath === rightPath) {\n      return true;\n    }\n    const leftStatus = statusOf(leftPath);\n    const rightStatus = statusOf(rightPath);\n    if (leftStatus && rightStatus && isSameFileNumber(leftStatus, rightStatus)) {\n      return true;\n    }\n    return (\n      fileIdentityKey(leftPath, NODE_PATH_QUERIES) === fileIdentityKey(rightPath, NODE_PATH_QUERIES)\n    );\n  }\n}\n\n/** File access for the CLI. */\nexport function createNodeFileSystem(): FileReader &\n  FileWriter &\n  FileIdentity &\n  DirectoryCheck &\n  FileClaims {\n  return new NodeFileSystem();\n}\n"],"names":["fs","fileURLToPath","OpenAPITypesafeError","ERROR_CODES","writeFileAt","claimFileAt","isSameFileNumber","fileIdentityKey"],"mappings":";;;;;;;;;;;;AAqBA,SAAS,aAAa,KAAA,EAAwB;AAC5C,EAAA,OAAO,KAAA,YAAiB,KAAA,GAAQ,KAAA,CAAM,OAAA,GAAU,OAAO,KAAK,CAAA;AAC9D;AAOA,SAAS,SAAS,QAAA,EAA0C;AAC1D,EAAA,IAAI;AACF,IAAA,MAAM,SAASA,WAAA,CAAG,QAAA,CAAS,UAAU,EAAE,MAAA,EAAQ,MAAM,CAAA;AACrD,IAAA,OAAO,EAAE,MAAA,EAAQ,MAAA,CAAO,GAAA,EAAK,IAAA,EAAM,OAAO,GAAA,EAAI;AAAA,EAChD,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,MAAA;AAAA,EACT;AACF;AAOA,SAAS,WAAW,QAAA,EAA0B;AAC5C,EAAA,IAAI;AACF,IAAA,OAAOA,WAAA,CAAG,YAAA,CAAa,MAAA,CAAO,QAAQ,CAAA;AAAA,EACxC,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,QAAA;AAAA,EACT;AACF;AAGA,SAAS,UAAU,SAAA,EAAsC;AACvD,EAAA,IAAI;AACF,IAAA,OAAOA,WAAA,CAAG,YAAY,SAAS,CAAA;AAAA,EACjC,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,EAAC;AAAA,EACV;AACF;AAMA,SAAS,aAAa,QAAA,EAAsC;AAC1D,EAAA,IAAI;AACF,IAAA,OAAOA,WAAA,CAAG,aAAa,QAAQ,CAAA;AAAA,EACjC,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,MAAA;AAAA,EACT;AACF;AAEA,MAAM,iBAAA,GAAiC;AAAA,EACrC,MAAA,EAAQ,QAAA;AAAA,EACR,QAAA,EAAU,UAAA;AAAA,EACV,OAAA,EAAS,SAAA;AAAA,EACT,UAAA,EAAY;AACd,CAAA;AAGA,SAAS,YAAY,IAAA,EAA+B;AAClD,EAAA,IAAI;AACF,IAAA,OAAOC,uBAAc,IAAI,CAAA;AAAA,EAC3B,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,MAAA;AAAA,EACT;AACF;AAMA,SAAS,SAAA,CAAU,IAAA,EAAiB,IAAA,EAAc,IAAA,EAAW,KAAA,EAAsC;AACjG,EAAA,MAAM,IAAA,GAAO,WAAA,CAAY,IAAI,CAAA,IAAK,IAAA,CAAK,IAAA;AACvC,EAAA,OAAO,IAAIC,2BAAA,CAAqB;AAAA,IAC9B,IAAA;AAAA,IACA,OAAA,EAAS,UAAU,IAAI,CAAA,CAAA,EAAI,IAAI,CAAA,EAAA,EAAK,YAAA,CAAa,KAAK,CAAC,CAAA,CAAA;AAAA,IACvD,OAAA,EAAS,EAAE,IAAA,EAAM,IAAA,EAAK;AAAA,IACtB;AAAA,GACD,CAAA;AACH;AAGA,SAAS,UAAA,CAAc,MAAW,IAAA,EAAkB;AAClD,EAAA,IAAI;AACF,IAAA,OAAO,IAAA,EAAK;AAAA,EACd,SAAS,KAAA,EAAO;AACd,IAAA,MAAM,SAAA,CAAUC,kBAAA,CAAY,mBAAA,EAAqB,OAAA,EAAS,MAAM,KAAK,CAAA;AAAA,EACvE;AACF;AAEA,MAAM,cAAA,CAA2F;AAAA,EAC/F,SAAS,IAAA,EAAmB;AAC1B,IAAA,IAAI;AACF,MAAA,OAAOH,WAAA,CAAG,YAAA,CAAa,IAAA,EAAM,MAAM,CAAA;AAAA,IACrC,SAAS,KAAA,EAAO;AACd,MAAA,MAAM,SAAA,CAAUG,kBAAA,CAAY,kBAAA,EAAoB,MAAA,EAAQ,MAAM,KAAK,CAAA;AAAA,IACrE;AAAA,EACF;AAAA,EAEA,SAAA,CAAU,MAAW,QAAA,EAAwB;AAC3C,IAAA,IAAI;AACF,MAAAC,sBAAA,CAAYH,sBAAA,CAAc,IAAI,CAAA,EAAG,QAAA,EAAU,iBAAiB,CAAA;AAAA,IAC9D,SAAS,KAAA,EAAO;AACd,MAAA,MAAM,SAAA,CAAUE,kBAAA,CAAY,mBAAA,EAAqB,OAAA,EAAS,MAAM,KAAK,CAAA;AAAA,IACvE;AAAA,EACF;AAAA,EAEA,UAAU,IAAA,EAAwB;AAChC,IAAA,MAAM,KAAA,GAAQ,WAAW,IAAA,EAAM,MAAME,uBAAYJ,sBAAA,CAAc,IAAI,CAAA,EAAG,iBAAiB,CAAC,CAAA;AACxF,IAAA,OAAO;AAAA,MACL,UAAU,KAAA,CAAM,QAAA;AAAA,MAChB,SAAS,MAAM,UAAA,CAAW,MAAM,MAAM,KAAA,CAAM,SAAS;AAAA,KACvD;AAAA,EACF;AAAA,EAEA,YAAY,IAAA,EAAoB;AAC9B,IAAA,IAAI;AACF,MAAA,OAAOD,WAAA,CAAG,QAAA,CAAS,IAAI,CAAA,CAAE,WAAA,EAAY;AAAA,IACvC,CAAA,CAAA,MAAQ;AAEN,MAAA,OAAO,KAAA;AAAA,IACT;AAAA,EACF;AAAA,EAEA,UAAA,CAAW,MAAW,KAAA,EAAqB;AACzC,IAAA,MAAM,QAAA,GAAWC,uBAAc,IAAI,CAAA;AACnC,IAAA,MAAM,SAAA,GAAYA,uBAAc,KAAK,CAAA;AACrC,IAAA,IAAI,aAAa,SAAA,EAAW;AAC1B,MAAA,OAAO,IAAA;AAAA,IACT;AACA,IAAA,MAAM,UAAA,GAAa,SAAS,QAAQ,CAAA;AACpC,IAAA,MAAM,WAAA,GAAc,SAAS,SAAS,CAAA;AACtC,IAAA,IAAI,UAAA,IAAc,WAAA,IAAeK,6BAAA,CAAiB,UAAA,EAAY,WAAW,CAAA,EAAG;AAC1E,MAAA,OAAO,IAAA;AAAA,IACT;AACA,IAAA,OACEC,6BAAgB,QAAA,EAAU,iBAAiB,CAAA,KAAMA,4BAAA,CAAgB,WAAW,iBAAiB,CAAA;AAAA,EAEjG;AACF;AAGO,SAAS,oBAAA,GAIH;AACX,EAAA,OAAO,IAAI,cAAA,EAAe;AAC5B;;"}