@stripe/extensibility-tool-utils 0.6.2

package/dist/index.js

@@ -0,0 +1,2847 @@
+// src/naming/stripe-api-case.ts
+var UPPERCASE_ACRONYM_TOKENS = [
+  "HTTPS",
+  "HTTP",
+  "UUID",
+  "JSON",
+  "XML",
+  "OAuth",
+  "URL",
+  "URI",
+  "API",
+  "SQL",
+  "MFA",
+  "2FA",
+  "3DS",
+  "CSV",
+  "HTML",
+  "PDF",
+  "JWT",
+  "SHA",
+  "TLS",
+  "SSL",
+  "ACH",
+  "ID"
+];
+var COMPOSITE_CASE_TOKENS = ["OAuth"];
+function isUppercaseRun(token) {
+  return /^[A-Z0-9]+$/.test(token) && /[A-Z]/.test(token);
+}
+function splitUppercaseRun(token) {
+  const pieces = [];
+  let rest = token;
+  while (rest.length > 0) {
+    const matched = UPPERCASE_ACRONYM_TOKENS.find(
+      (candidate) => rest.startsWith(candidate.toUpperCase())
+    );
+    if (matched) {
+      pieces.push(matched);
+      rest = rest.slice(matched.length);
+      continue;
+    }
+    pieces.push(rest);
+    break;
+  }
+  return pieces;
+}
+function mergeCompositeTokens(tokens) {
+  const merged = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const current = tokens[index];
+    const next = tokens[index + 1];
+    if (!current) {
+      continue;
+    }
+    if (next) {
+      const combined = `${current}${next}`;
+      const matched = COMPOSITE_CASE_TOKENS.find(
+        (candidate) => candidate.toLowerCase() === combined.toLowerCase()
+      );
+      if (matched) {
+        merged.push(matched);
+        index += 1;
+        continue;
+      }
+    }
+    merged.push(current);
+  }
+  return merged;
+}
+function tokenizeSegment(segment) {
+  const matches = segment.match(
+    /(?:[0-9]+[A-Z]+(?=$|[A-Z][a-z]))|(?:[A-Z]+(?=[A-Z][a-z]))|(?:[A-Z]?[a-z]+)|(?:[A-Z]+)|(?:[0-9]+)/g
+  ) ?? [segment];
+  return mergeCompositeTokens(matches).flatMap((token) => {
+    if (/^[0-9]+[A-Z]+$/.test(token)) {
+      const digitPrefix = /^[0-9]+/.exec(token)?.[0] ?? "";
+      const upperSuffix = token.slice(digitPrefix.length);
+      return [digitPrefix, ...splitUppercaseRun(upperSuffix)];
+    }
+    return isUppercaseRun(token) && token.length > 1 ? splitUppercaseRun(token) : [token];
+  });
+}
+function isAcronymToken(token) {
+  const upper = token.toUpperCase();
+  return token === upper && UPPERCASE_ACRONYM_TOKENS.some((candidate) => candidate.toUpperCase() === upper) || COMPOSITE_CASE_TOKENS.some(
+    (candidate) => candidate.toLowerCase() === token.toLowerCase()
+  );
+}
+function _tokenizeIdentifier(input) {
+  return input.replace(/[\s-]+/g, "_").split("_").filter(Boolean).flatMap((segment) => tokenizeSegment(segment)).filter(Boolean);
+}
+function _toStripeApiCase(input) {
+  return _tokenizeIdentifier(input).map((token) => token.replace(/[^A-Za-z0-9]/g, "").toLowerCase()).filter(Boolean).join("_");
+}
+function _toSentenceDisplayName(input) {
+  const tokens = _tokenizeIdentifier(input);
+  if (tokens.length === 0) {
+    return input;
+  }
+  return tokens.map((token, index) => {
+    if (/^[0-9]+$/.test(token)) {
+      return token;
+    }
+    if (isAcronymToken(token)) {
+      return token.toUpperCase();
+    }
+    const lower = token.toLowerCase();
+    if (index === 0) {
+      return lower.charAt(0).toUpperCase() + lower.slice(1);
+    }
+    return lower;
+  }).join(" ");
+}
+function _truncateName(value, maxLength) {
+  return value.slice(0, maxLength);
+}
+
+// src/naming/inflection.ts
+import { camelize, capitalize, pluralize, singularize, underscore } from "inflected";
+function _toPascalCase(value) {
+  return camelize(value);
+}
+function _toSnakeCase(value) {
+  return underscore(value);
+}
+function _toPlural(value) {
+  return pluralize(value);
+}
+function _toSingular(value) {
+  return singularize(value);
+}
+function _looksPlural(value) {
+  const singular = singularize(value);
+  return singular !== value;
+}
+function _toCapitalized(value) {
+  return capitalize(value);
+}
+function _looksSingular(value) {
+  return pluralize(value) !== value;
+}
+
+// src/naming/metadata-policy.ts
+function _inferStripeApiName(context) {
+  return _toStripeApiCase(context.logicalName);
+}
+function inferStripeDisplayName(context) {
+  return _toSentenceDisplayName(context.logicalName);
+}
+function pluralizeStripeMetadata(context) {
+  return _toPlural(context.singular);
+}
+var _stripeMetadataPolicy = {
+  type: {
+    apiName: {
+      mode: "infer-if-missing",
+      infer: _inferStripeApiName,
+      pluralization: {
+        mode: "infer-if-missing",
+        inflect: pluralizeStripeMetadata
+      }
+    },
+    displayName: {
+      mode: "infer-if-missing",
+      infer: inferStripeDisplayName,
+      pluralization: {
+        mode: "infer-if-missing",
+        inflect: pluralizeStripeMetadata
+      }
+    }
+  },
+  field: {
+    apiName: {
+      mode: "infer-if-missing",
+      infer: _inferStripeApiName
+    },
+    displayName: {
+      mode: "infer-if-missing",
+      infer: inferStripeDisplayName
+    }
+  },
+  method: {
+    apiName: {
+      mode: "infer-if-missing",
+      infer: _inferStripeApiName
+    },
+    displayName: {
+      mode: "infer-if-missing",
+      infer: inferStripeDisplayName
+    }
+  }
+};
+
+// src/naming/validate.ts
+function _validateApiName(value) {
+  const reasons = [];
+  if (value.length === 0) {
+    reasons.push("API name must not be empty.");
+  }
+  if (value.length > 40) {
+    reasons.push("API name must not exceed 40 characters.");
+  }
+  const firstCharacter = value[0];
+  if (firstCharacter && !/[a-z]/.test(firstCharacter)) {
+    reasons.push("API name must start with a lowercase letter.");
+  }
+  if (value.endsWith("_")) {
+    reasons.push("API name must not end with an underscore.");
+  }
+  if (/[^a-z0-9_]/.test(value)) {
+    reasons.push(
+      "API name must contain only lowercase letters, digits, and underscores."
+    );
+  }
+  if (value.includes("__")) {
+    reasons.push("API name must not contain consecutive underscores.");
+  }
+  return {
+    valid: reasons.length === 0,
+    reasons
+  };
+}
+function _validateDisplayName(value) {
+  const reasons = [];
+  if (value.length === 0) {
+    reasons.push("Display name must not be empty.");
+  }
+  if (value.length > 40) {
+    reasons.push("Display name must not exceed 40 characters.");
+  }
+  return {
+    valid: reasons.length === 0,
+    reasons
+  };
+}
+
+// src/logging/levels.ts
+var VALID_LOG_LEVELS = /* @__PURE__ */ new Set([
+  "trace",
+  "debug",
+  "info",
+  "warn",
+  "error",
+  "fatal",
+  "silent"
+]);
+function isValidLogLevel(value) {
+  return VALID_LOG_LEVELS.has(value);
+}
+function _parseLogLevel(input) {
+  if (input === void 0 || input === "") return "info";
+  const normalized = input.trim().toLowerCase();
+  if (isValidLogLevel(normalized)) return normalized;
+  return "info";
+}
+
+// src/logging/create-logger.ts
+import pino from "pino";
+function _createLogger(options) {
+  const level = options?.level ?? _parseLogLevel(process.env.LOG_LEVEL);
+  const colorize = process.env.NO_COLOR === void 0 && process.stderr.isTTY;
+  return pino({
+    ...options?.name !== void 0 && { name: options.name },
+    level,
+    transport: {
+      target: "pino-pretty",
+      options: { destination: 2, colorize }
+    }
+  });
+}
+
+// src/cli/cli-ux.ts
+var _CliUx = class {
+  #stdout;
+  #stderr;
+  constructor(options) {
+    this.#stdout = options?.stdout ?? process.stdout;
+    this.#stderr = options?.stderr ?? process.stderr;
+  }
+  /** Write a product output line to stdout (or the configured stream). */
+  print(message) {
+    this.#stdout.write(message + "\n");
+  }
+  /** Write a status/progress line to stderr (or the configured stream). */
+  log(message) {
+    this.#stderr.write(message + "\n");
+  }
+  /**
+   * Error message to **stderr** (or the configured stderr stream).
+   *
+   * Behaviorally identical to {@link _CliUx.log} today. Use `error()` for failures
+   * and `log()` for progress/status — the distinction supports future
+   * formatting differentiation (color, prefixes, severity filtering).
+   */
+  error(message) {
+    this.#stderr.write(message + "\n");
+  }
+};
+
+// src/cli/context.ts
+function _createCliContext(options) {
+  return { ux: options?.ux ?? new _CliUx() };
+}
+
+// src/cli/output-path.ts
+import { writeFileSync } from "fs";
+function _writeJsonOutput(outputPath, data) {
+  if (outputPath === void 0) return;
+  writeFileSync(outputPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+
+// src/cli/guards.ts
+function _isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function _isRecordWithValueType(guard) {
+  return (value) => {
+    if (!_isRecord(value)) return false;
+    return Object.values(value).every(guard);
+  };
+}
+
+// src/templates/template-manager.ts
+var _TemplateManager = class {
+  templates;
+  fs;
+  /**
+   * Create a new TemplateManager
+   * @param templates - Object mapping string keys to templates
+   * @param fs - Filesystem abstraction for template file reading
+   *
+   * @example
+   * ```typescript
+   * import { fs } from './fs/index.js';
+   *
+   * const manager = new TemplateManager({
+   *   foo: fooTemplate,
+   *   bar: barTemplate,
+   * }, fs)
+   *
+   * await manager.generate('foo', params)
+   * ```
+   */
+  constructor(templates, fs) {
+    this.templates = new Map(Object.entries(templates));
+    this.fs = fs;
+  }
+  /**
+   * Generate output from a template
+   * @param key - Template key to generate from
+   * @param params - Template-specific parameters
+   * @returns Template output with files and any additional fields
+   * @throws Error if template key is not found
+   */
+  async generate(key, params) {
+    const template = this.templates.get(key);
+    if (!template) {
+      let msg = `Template not found for key: ${key}.`;
+      const supported = [...this.templates.keys()];
+      if (supported.length > 0) {
+        msg += ` Supported: ${supported.join(", ")}`;
+      }
+      throw new Error(msg);
+    }
+    const context = {
+      fs: this.fs
+    };
+    return await template.generate(params, context);
+  }
+  /**
+   * Get all template entries as [key, template] pairs
+   */
+  getTemplateEntries() {
+    return [...this.templates.entries()];
+  }
+  /**
+   * Get list of all supported template keys
+   */
+  getSupportedKeys() {
+    return [...this.templates.keys()];
+  }
+};
+
+// src/templates/in-memory-fs.ts
+import Mustache from "mustache";
+function _createInMemoryTemplateFS(image, pathPrefix = "") {
+  const index = /* @__PURE__ */ new Map();
+  const allPaths = [];
+  for (const entry of image) {
+    index.set(entry.path, entry.content);
+    allPaths.push(entry.path);
+  }
+  return {
+    textFile(...segments) {
+      const fullSegments = pathPrefix ? [pathPrefix, ...segments] : segments;
+      const requestedPath = fullSegments.join("/");
+      const content = index.get(requestedPath);
+      if (content === void 0) {
+        const available = Array.from(index.keys()).slice(0, 5).join(", ");
+        throw new Error(
+          `Template not found: ${requestedPath}
+Available paths (first 5): ${available}...`
+        );
+      }
+      return content;
+    },
+    mustache(params, ...segments) {
+      const template = this.textFile(...segments);
+      return Mustache.render(template, params, void 0, {
+        escape: (text) => text
+      });
+    },
+    scope(prefix) {
+      const newPrefix = pathPrefix ? `${pathPrefix}/${prefix}` : prefix;
+      return _createInMemoryTemplateFS(image, newPrefix);
+    },
+    _getPathsUnder(prefix) {
+      const normalizedPrefix = prefix.endsWith("/") ? prefix : prefix + "/";
+      return allPaths.filter((p) => p.startsWith(normalizedPrefix));
+    }
+  };
+}
+
+// src/templates/simple-templates.ts
+function _createSimpleTemplate(generateContent, pathTemplate) {
+  return {
+    generate: (params, _context) => ({
+      files: [
+        {
+          path: pathTemplate(params),
+          content: generateContent(params)
+        }
+      ]
+    })
+  };
+}
+var _SingleTemplateManager = class {
+  template;
+  fs;
+  /**
+   * Create a new SingleTemplateManager
+   * @param template - The single template to use
+   * @param fs - Filesystem for template file reading
+   */
+  constructor(template, fs) {
+    this.template = template;
+    this.fs = fs;
+  }
+  /**
+   * Generate output from the template
+   * @param params - Template parameters
+   * @returns Template output
+   */
+  async generate(params) {
+    const context = {
+      fs: this.fs
+    };
+    return await this.template.generate(params, context);
+  }
+};
+function _createSimpleSingleFileTemplate(generateContent, pathTemplate) {
+  const template = _createSimpleTemplate(generateContent, pathTemplate);
+  return new _SingleTemplateManager(template, _createInMemoryTemplateFS([]));
+}
+
+// src/templates/filesystem-fs.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+import Mustache2 from "mustache";
+function _createFilesystemTemplateFS(templateDir = process.cwd()) {
+  return {
+    textFile(...segments) {
+      return readFileSync(join(templateDir, ...segments), "utf-8");
+    },
+    mustache(params, ...segments) {
+      const template = readFileSync(join(templateDir, ...segments), "utf-8");
+      return Mustache2.render(template, params, void 0, {
+        escape: (text) => text
+      });
+    },
+    scope(prefix) {
+      return _createFilesystemTemplateFS(join(templateDir, prefix));
+    }
+  };
+}
+
+// src/templates/generator.ts
+import { existsSync, readdirSync, statSync } from "fs";
+import { isAbsolute, join as join2, posix, relative, sep } from "path";
+import Mustache3 from "mustache";
+var _GeneratorInputError = class extends Error {
+  remediation;
+  constructor(message, remediation, options) {
+    super(message, options);
+    this.name = "_GeneratorInputError";
+    this.remediation = remediation;
+  }
+};
+var _GeneratorDefectError = class extends Error {
+  generatorId;
+  constructor(message, generatorId, options) {
+    super(message, options);
+    this.name = "_GeneratorDefectError";
+    this.generatorId = generatorId;
+  }
+};
+var PATH_TOKEN_PATTERN = /___([a-zA-Z][a-zA-Z0-9]*)___/g;
+function resolvePathTokens(segment, locals) {
+  PATH_TOKEN_PATTERN.lastIndex = 0;
+  return segment.replace(PATH_TOKEN_PATTERN, (_match, token) => {
+    const value = locals[token];
+    if (value === void 0) {
+      throw new _GeneratorDefectError(
+        `Path token "___${token}___" has no corresponding value in locals(). Available keys: ${Object.keys(locals).join(", ")}`
+      );
+    }
+    if (typeof value !== "string") {
+      throw new _GeneratorDefectError(
+        `Path token "___${token}___" must resolve to a string, got ${typeof value}`
+      );
+    }
+    return value;
+  });
+}
+function walkDir(root, dir = root) {
+  const entries = readdirSync(dir).sort();
+  const paths = [];
+  for (const entry of entries) {
+    const fullPath = join2(dir, entry);
+    const stat2 = statSync(fullPath);
+    if (stat2.isDirectory()) {
+      paths.push(...walkDir(root, fullPath));
+    } else {
+      paths.push(relative(root, fullPath).split(sep).join("/"));
+    }
+  }
+  return paths;
+}
+function assertSafePath(outputPath) {
+  if (isAbsolute(outputPath)) {
+    throw new _GeneratorDefectError(
+      `Generator produced an unsafe path: ${outputPath}. Paths must be relative and cannot contain '..' segments.`
+    );
+  }
+  const segments = outputPath.split(/[\\/]/);
+  for (const segment of segments) {
+    if (segment === "..") {
+      throw new _GeneratorDefectError(
+        `Generator produced an unsafe path: ${outputPath}. Paths must be relative and cannot contain '..' segments.`
+      );
+    }
+  }
+}
+function assertNoMalformedTokens(templatePath) {
+  const segments = templatePath.split("/");
+  const anyTokenLike = /___[^_/].*?___/g;
+  for (const segment of segments) {
+    anyTokenLike.lastIndex = 0;
+    let match;
+    while ((match = anyTokenLike.exec(segment)) !== null) {
+      const occurrence = match[0];
+      PATH_TOKEN_PATTERN.lastIndex = 0;
+      const isValid = PATH_TOKEN_PATTERN.test(occurrence);
+      PATH_TOKEN_PATTERN.lastIndex = 0;
+      if (!isValid) {
+        throw new _GeneratorDefectError(
+          `Path "${templatePath}" contains what looks like an unresolved ___token___. Token names must be camelCase alphanumeric (e.g., ___packageName___, not ___package_name___).`
+        );
+      }
+    }
+  }
+}
+var MUSTACHE_EXT = ".mustache";
+var FILES_SUBDIR = "files";
+var _GeneratorRunner = class {
+  #generators;
+  constructor(generator) {
+    this.#generators = Array.isArray(generator) ? generator : [generator];
+  }
+  /**
+   * Plan phase — compute all files that would be generated, without writing
+   * anything to disk.
+   *
+   * Also runs `beforeExecute` hooks to collect preflight results, and
+   * `describeSideEffects` to surface planned side effects. Neither of these
+   * write anything or produce observable external effects during plan.
+   *
+   * Use this for dry runs, previews, and testing.
+   *
+   * Validates that all output paths are safe (no `..`, no leading `/`) and
+   * that no two generators produce the same output path.
+   *
+   * @param params - User-provided parameters for the generator
+   * @param context - Generator context (standalone or project). Passed to
+   *   `beforeExecute` hooks. Callers must supply a real context — there is no
+   *   synthetic plan-time sentinel. For dry-run calls outside of a project,
+   *   use a standalone context with an appropriate `targetDir`.
+   */
+  async plan(params, context) {
+    const files = [];
+    const preflightResults = [];
+    const plannedSideEffects = [];
+    for (const generator of this.#generators) {
+      if (generator.beforeExecute) {
+        const result = await generator.beforeExecute(params, context);
+        preflightResults.push(result);
+      }
+      if (generator.describeSideEffects) {
+        const effects = await generator.describeSideEffects(params);
+        plannedSideEffects.push(...effects);
+      }
+    }
+    for (const generator of this.#generators) {
+      const locals = generator.locals(params);
+      const filesDir = join2(generator.filesDir, FILES_SUBDIR);
+      const fs = _createFilesystemTemplateFS(filesDir);
+      if (!existsSync(filesDir)) {
+        throw new _GeneratorDefectError(
+          `Generator at "${generator.filesDir}" is missing a files/ subdirectory. Expected to find templates at "${filesDir}".`
+        );
+      }
+      const templatePaths = walkDir(filesDir);
+      for (const templatePath of templatePaths) {
+        assertNoMalformedTokens(templatePath);
+        const resolvedPath = templatePath.split("/").map((segment) => {
+          const resolved = resolvePathTokens(segment, locals);
+          if (resolved === "") {
+            throw new _GeneratorDefectError(
+              `Template token in path segment "${segment}" resolved to empty string`
+            );
+          }
+          return resolved;
+        }).join("/");
+        const stripped = resolvedPath.endsWith(MUSTACHE_EXT) ? resolvedPath.slice(0, -MUSTACHE_EXT.length) : resolvedPath;
+        if (stripped === "") {
+          throw new _GeneratorDefectError(
+            `Generator produced an empty output path after processing template "${templatePath}".`
+          );
+        }
+        assertSafePath(stripped);
+        const outputPath = posix.normalize(stripped);
+        const pathSegments = templatePath.split("/");
+        let content;
+        if (templatePath.endsWith(MUSTACHE_EXT)) {
+          content = fs.mustache(locals, ...pathSegments);
+        } else {
+          content = fs.textFile(...pathSegments);
+        }
+        const description = resolveDescription(
+          templatePath,
+          generator.descriptions,
+          locals,
+          fs
+        );
+        files.push({
+          path: outputPath,
+          content,
+          ...description !== void 0 && { description }
+        });
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const file of files) {
+      if (seen.has(file.path)) {
+        throw new _GeneratorDefectError(
+          `Generator produced duplicate output path: ${file.path}`
+        );
+      }
+      seen.add(file.path);
+    }
+    return { files, preflightResults, plannedSideEffects };
+  }
+  /**
+   * Execute phase — runs the full lifecycle:
+   * 1. `plan()` to collect preflight results and planned files
+   * 2. If any preflight returned `proceed: false`, return early without writing
+   * 3. `context.writeFiles()` to write files to disk (delegated to caller)
+   * 4. If the write was aborted, return early without calling `afterExecute`
+   * 5. `afterExecute` hooks for all generators with the write result
+   */
+  async execute(params, context) {
+    const plan = await this.plan(params, context);
+    const rejected = plan.preflightResults.some((r) => !r.proceed);
+    if (rejected) {
+      return {
+        files: plan.files,
+        preflightResults: plan.preflightResults,
+        plannedSideEffects: plan.plannedSideEffects,
+        writeResult: void 0,
+        afterExecuteResults: []
+      };
+    }
+    const writeResult = await context.writeFiles(plan.files);
+    if (writeResult.aborted) {
+      return {
+        files: plan.files,
+        preflightResults: plan.preflightResults,
+        plannedSideEffects: plan.plannedSideEffects,
+        writeResult,
+        afterExecuteResults: []
+      };
+    }
+    const afterExecuteResults = [];
+    for (const generator of this.#generators) {
+      if (generator.afterExecute) {
+        const result = await generator.afterExecute(params, context, writeResult);
+        afterExecuteResults.push(result);
+      }
+    }
+    return {
+      files: plan.files,
+      preflightResults: plan.preflightResults,
+      plannedSideEffects: plan.plannedSideEffects,
+      writeResult,
+      afterExecuteResults
+    };
+  }
+};
+function resolveDescription(templatePath, descriptions, locals, _fs) {
+  if (!descriptions) return void 0;
+  const template = descriptions[templatePath];
+  if (template === void 0) return void 0;
+  return Mustache3.render(template, locals, void 0, {
+    escape: (t) => t
+  });
+}
+function _compositeGenerator(...generators) {
+  return new _GeneratorRunner(generators);
+}
+
+// src/workspace-versions.json
+var workspace_versions_default = {
+  "@stripe/extensibility-api-objects": "0.3.1",
+  "@stripe/extensibility-custom-objects": "0.7.2",
+  "@stripe/extensibility-custom-objects-tools": "0.39.2",
+  "@stripe/extensibility-dev-tools": "0.23.1",
+  "@stripe/extensibility-doc-helpers": "0.3.0",
+  "@stripe/extensibility-eslint-plugin": "0.15.2",
+  "@stripe/extensibility-jsonschema-tools": "0.6.3",
+  "@stripe/extensibility-language-server": "0.2.8",
+  "@stripe/extensibility-script-build-tools": "1.5.4",
+  "@stripe/extensibility-sdk": "0.22.2",
+  "@stripe/extensibility-test-helpers": "0.2.5",
+  "@stripe/extensibility-tool-utils": "0.6.2"
+};
+
+// src/workspace-versions.ts
+var _workspaceVersions = workspace_versions_default;
+function _workspaceVersion(packageName) {
+  const v = _workspaceVersions[packageName];
+  if (v === void 0) {
+    throw new Error(
+      `Unknown workspace package "${packageName}". Check workspace-versions.json or run: tsx scripts/src/sync-workspace-versions.ts`
+    );
+  }
+  return v;
+}
+
+// src/file-editor/document.ts
+import { readFile } from "fs/promises";
+
+// src/file-editor/assertions/index.ts
+import semver from "semver";
+
+// src/file-editor/errors.ts
+var _FileEditorError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "_FileEditorError";
+    this.code = code;
+  }
+};
+var _ParseError = class extends _FileEditorError {
+  format;
+  offset;
+  snippet;
+  constructor(format, message, details = {}) {
+    super("PARSE_ERROR", message);
+    this.name = "_ParseError";
+    this.format = format;
+    this.offset = details.offset ?? null;
+    this.snippet = details.snippet ?? null;
+  }
+};
+var _PathError = class extends _FileEditorError {
+  pointer;
+  constructor(pointer, message) {
+    super("PATH_ERROR", message);
+    this.name = "_PathError";
+    this.pointer = pointer;
+  }
+};
+var _TypeMismatchError = class extends _FileEditorError {
+  pointer;
+  constructor(pointer, message) {
+    super("TYPE_MISMATCH", message);
+    this.name = "_TypeMismatchError";
+    this.pointer = pointer;
+  }
+};
+var _AssertionError = class extends _FileEditorError {
+  pointer;
+  expected;
+  actual;
+  constructor(pointer, message, details = {}) {
+    super("ASSERTION_ERROR", message);
+    this.name = "_AssertionError";
+    this.pointer = pointer;
+    this.expected = details.expected;
+    this.actual = details.actual;
+  }
+};
+var _ConflictError = class extends _FileEditorError {
+  conflict;
+  constructor(conflict) {
+    super(
+      "CONFLICT",
+      `Drift detected for ${conflict.path}: file was modified outside the tool.`
+    );
+    this.name = "_ConflictError";
+    this.conflict = conflict;
+  }
+};
+var _ConflictAbortedError = class extends _FileEditorError {
+  path;
+  constructor(path) {
+    super("CONFLICT_ABORTED", `Conflict resolution aborted for ${path}.`);
+    this.name = "_ConflictAbortedError";
+    this.path = path;
+  }
+};
+var _WriteAbortedError = class extends _FileEditorError {
+  path;
+  constructor(path) {
+    super("WRITE_ABORTED", `Write aborted for ${path} via confirmWrite hook.`);
+    this.name = "_WriteAbortedError";
+    this.path = path;
+  }
+};
+var _FormatNotSupportedError = class extends _FileEditorError {
+  path;
+  constructor(path, message) {
+    super(
+      "FORMAT_NOT_SUPPORTED",
+      message ?? `Cannot infer format for ${path}; pass options.format explicitly.`
+    );
+    this.name = "_FormatNotSupportedError";
+    this.path = path;
+  }
+};
+
+// src/file-editor/pointer.ts
+function _parsePointer(pointer) {
+  if (pointer === "") return [];
+  if (!pointer.startsWith("/")) {
+    throw new _PathError(
+      pointer,
+      `Invalid JSON Pointer: must start with "/" or be empty.`
+    );
+  }
+  const parts = pointer.slice(1).split("/");
+  return parts.map(_unescapeToken);
+}
+function _compilePointer(segments) {
+  if (segments.length === 0) return "";
+  return "/" + segments.map((s) => _escapeToken(String(s))).join("/");
+}
+function _unescapeToken(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function _escapeToken(raw) {
+  return raw.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function _resolvePointer(root, pointer) {
+  const segments = _parsePointer(pointer);
+  let current = root;
+  for (const seg of segments) {
+    if (current === null || current === void 0) return void 0;
+    if (Array.isArray(current)) {
+      if (seg === "-") return void 0;
+      const idx = _parseArrayIndex(seg);
+      if (idx === null) return void 0;
+      current = current[idx];
+    } else if (typeof current === "object") {
+      const obj = current;
+      if (!Object.prototype.hasOwnProperty.call(obj, seg)) return void 0;
+      current = obj[seg];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function _hasPointer(root, pointer) {
+  const segments = _parsePointer(pointer);
+  let current = root;
+  for (const seg of segments) {
+    if (current === null || current === void 0) return false;
+    if (Array.isArray(current)) {
+      if (seg === "-") return false;
+      const idx = _parseArrayIndex(seg);
+      if (idx === null || idx >= current.length) return false;
+      current = current[idx];
+    } else if (typeof current === "object") {
+      const obj = current;
+      if (!Object.prototype.hasOwnProperty.call(obj, seg)) return false;
+      current = obj[seg];
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+function _parseArrayIndex(token) {
+  if (token === "0") return 0;
+  if (!/^[1-9][0-9]*$/.test(token)) return null;
+  return Number.parseInt(token, 10);
+}
+function _pointer() {
+  return makePointerProxy([]);
+}
+var _POINTER_STRING = "$";
+function makePointerProxy(segments) {
+  return new Proxy(() => void 0, {
+    get(_t, prop) {
+      if (prop === _POINTER_STRING) return _compilePointer(segments);
+      if (typeof prop === "symbol") return void 0;
+      const next = /^\d+$/.test(prop) ? Number.parseInt(prop, 10) : prop;
+      return makePointerProxy([...segments, next]);
+    }
+  });
+}
+
+// src/file-editor/assertions/index.ts
+var DEFAULT_SEVERITY = "error";
+var _check = {
+  /** The pointer must resolve to something (including `null`). @internal */
+  exists(pointer, opts = {}) {
+    return ({ path, value }) => {
+      if (_hasPointer(value, pointer)) return [];
+      return [
+        {
+          path,
+          pointer,
+          code: "MISSING_KEY",
+          severity: opts.severity ?? DEFAULT_SEVERITY,
+          message: opts.message ?? `required value is missing at ${pointer}`,
+          expected: "a value to be present",
+          actual: void 0
+        }
+      ];
+    };
+  },
+  /** The value at the pointer must deep-equal `expected`. @internal */
+  equals(pointer, expected, opts = {}) {
+    return ({ path, value }) => {
+      const actual = _resolvePointer(value, pointer);
+      if (deepEqual(actual, expected)) return [];
+      return [
+        {
+          path,
+          pointer,
+          code: "VALUE_MISMATCH",
+          severity: opts.severity ?? DEFAULT_SEVERITY,
+          message: opts.message ?? `expected ${pointer} to equal ${JSON.stringify(expected)}`,
+          expected,
+          actual
+        }
+      ];
+    };
+  },
+  /** The value at the pointer must equal one of `allowed`. @internal */
+  oneOf(pointer, allowed, opts = {}) {
+    return ({ path, value }) => {
+      const actual = _resolvePointer(value, pointer);
+      if (allowed.some((candidate) => deepEqual(actual, candidate))) return [];
+      return [
+        {
+          path,
+          pointer,
+          code: "VALUE_NOT_ALLOWED",
+          severity: opts.severity ?? DEFAULT_SEVERITY,
+          message: opts.message ?? `expected ${pointer} to be one of ${allowed.map((a) => JSON.stringify(a)).join(", ")}`,
+          expected: allowed,
+          actual
+        }
+      ];
+    };
+  },
+  /** The string value at the pointer must match the given pattern. @internal */
+  matches(pointer, pattern, opts = {}) {
+    return ({ path, value }) => {
+      const actual = _resolvePointer(value, pointer);
+      if (typeof actual === "string" && pattern.test(actual)) return [];
+      return [
+        {
+          path,
+          pointer,
+          code: typeof actual === "string" ? "PATTERN_MISMATCH" : "TYPE_MISMATCH",
+          severity: opts.severity ?? DEFAULT_SEVERITY,
+          message: opts.message ?? `expected ${pointer} to match ${pattern.toString()}`,
+          expected: pattern.toString(),
+          actual
+        }
+      ];
+    };
+  },
+  /**
+   * The value at the pointer must satisfy a caller predicate.
+   * @internal
+   */
+  satisfies(pointer, predicate, opts = {}) {
+    return ({ path, value }) => {
+      const actual = _resolvePointer(value, pointer);
+      if (predicate(actual)) return [];
+      return [
+        {
+          path,
+          pointer,
+          code: "PREDICATE_FAILED",
+          severity: opts.severity ?? DEFAULT_SEVERITY,
+          message: opts.message ?? `predicate failed at ${pointer}`,
+          actual
+        }
+      ];
+    };
+  },
+  /**
+   * The value at the pointer must validate against the supplied Standard
+   * Schema (Zod v4, Valibot, ArkType, etc.). Each schema issue becomes a
+   * `SCHEMA_VIOLATION` diagnostic with the pointer extended by the issue's
+   * path.
+   *
+   * NOTE: the validator is invoked synchronously and its result awaited at
+   * call time, so this returns a `Promise<_Diagnostic[]>` rather than a
+   * synchronous `_Assertion`. Wrap the result with `_runAsyncAssertions` if
+   * you need to compose it with other async checks.
+   * @internal
+   */
+  matchesSchema(pointer, schema, opts = {}) {
+    return async ({ path, value }) => {
+      const actual = _resolvePointer(value, pointer);
+      const result = await schema["~standard"].validate(actual);
+      if (!result.issues) return [];
+      return result.issues.map(
+        (issue) => ({
+          path,
+          pointer: appendIssuePath(pointer, issue.path),
+          code: "SCHEMA_VIOLATION",
+          severity: opts.severity ?? DEFAULT_SEVERITY,
+          message: opts.message ?? issue.message,
+          actual
+        })
+      );
+    };
+  },
+  /**
+   * The string value at the pointer must be a valid semver range satisfying
+   * the supplied constraint.
+   * @internal
+   */
+  semverSatisfies(pointer, range, opts = {}) {
+    return ({ path, value }) => {
+      const actual = _resolvePointer(value, pointer);
+      if (typeof actual !== "string") {
+        return [
+          {
+            path,
+            pointer,
+            code: "TYPE_MISMATCH",
+            severity: opts.severity ?? DEFAULT_SEVERITY,
+            message: opts.message ?? `expected a string version at ${pointer}`,
+            expected: "semver string",
+            actual
+          }
+        ];
+      }
+      const valid = semver.validRange(actual);
+      if (!valid) {
+        return [
+          {
+            path,
+            pointer,
+            code: "INVALID_SEMVER",
+            severity: opts.severity ?? DEFAULT_SEVERITY,
+            message: opts.message ?? `value at ${pointer} is not a valid semver range`,
+            expected: "valid semver range",
+            actual
+          }
+        ];
+      }
+      if (!semver.subset(valid, range)) {
+        return [
+          {
+            path,
+            pointer,
+            code: "SEMVER_OUT_OF_RANGE",
+            severity: opts.severity ?? DEFAULT_SEVERITY,
+            message: opts.message ?? `value at ${pointer} (${actual}) is not a subset of ${range}`,
+            expected: range,
+            actual
+          }
+        ];
+      }
+      return [];
+    };
+  }
+};
+function _runAssertions(path, value, assertions) {
+  const results = [];
+  for (const a of assertions) {
+    results.push(...a({ path, value }));
+  }
+  return results;
+}
+async function _runAsyncAssertions(path, value, assertions) {
+  const results = [];
+  for (const a of assertions) {
+    results.push(...await a({ path, value }));
+  }
+  return results;
+}
+function appendIssuePath(base, issuePath) {
+  if (!issuePath || issuePath.length === 0) return base;
+  const suffix = issuePath.map((seg) => {
+    const key = typeof seg === "object" ? seg.key : seg;
+    const s = typeof key === "symbol" ? key.description ?? "" : String(key);
+    return s.replace(/~/g, "~0").replace(/\//g, "~1");
+  }).join("/");
+  return base + "/" + suffix;
+}
+function deepEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (a === null || b === null) return false;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const ao = a;
+    const bo = b;
+    const keys = Object.keys(ao);
+    if (keys.length !== Object.keys(bo).length) return false;
+    for (const k of keys) {
+      if (!deepEqual(ao[k], bo[k])) return false;
+    }
+    return true;
+  }
+  return false;
+}
+
+// src/file-editor/fingerprint.ts
+import { createHash } from "crypto";
+import {
+  parse as parseJsonc,
+  printParseErrorCode
+} from "jsonc-parser";
+import { parse as parseYaml } from "yaml";
+function _canonicalNormalize(text, format) {
+  const value = parseForCanonical(text, format);
+  return _canonicalStringify(value);
+}
+function _fingerprint(text, format) {
+  const canonical = _canonicalNormalize(text, format);
+  return _sha256Hex(canonical);
+}
+function _sha256Hex(input) {
+  const hash = createHash("sha256");
+  hash.update(input);
+  return hash.digest("hex");
+}
+function parseForCanonical(text, format) {
+  const stripped = stripBom(text);
+  switch (format) {
+    case "json":
+      return parseStrictJson(stripped);
+    case "jsonc":
+      return parseJsoncForCanonical(stripped);
+    case "yaml":
+      return parseYamlForCanonical(stripped);
+  }
+}
+function stripBom(text) {
+  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+}
+function parseStrictJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new _ParseError("json", `Invalid JSON: ${message}`);
+  }
+}
+function parseJsoncForCanonical(text) {
+  const errors = [];
+  const value = parseJsonc(text, errors, {
+    allowTrailingComma: true,
+    disallowComments: false
+  });
+  if (errors.length > 0) {
+    const first = errors[0];
+    if (first === void 0) return value;
+    throw new _ParseError(
+      "jsonc",
+      `Invalid JSONC at offset ${String(first.offset)}: ${printParseErrorCode(first.error)}`,
+      { offset: first.offset }
+    );
+  }
+  return value;
+}
+function parseYamlForCanonical(text) {
+  try {
+    return parseYaml(text, { merge: true, prettyErrors: false });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new _ParseError("yaml", `Invalid YAML: ${message}`);
+  }
+}
+function _canonicalStringify(value) {
+  return stringify(value);
+}
+function stringify(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "null";
+  if (typeof value === "string") return JSON.stringify(value.normalize("NFC"));
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new _ParseError(
+        "json",
+        `Cannot canonicalize non-finite number: ${value.toString()}`
+      );
+    }
+    return JSON.stringify(value);
+  }
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "bigint") return value.toString();
+  if (Array.isArray(value)) {
+    return "[" + value.map(stringify).join(",") + "]";
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    const parts = [];
+    for (const key of keys) {
+      const v = obj[key];
+      if (v === void 0) continue;
+      parts.push(JSON.stringify(key.normalize("NFC")) + ":" + stringify(v));
+    }
+    return "{" + parts.join(",") + "}";
+  }
+  throw new _ParseError("json", `Cannot canonicalize value of type ${typeof value}`);
+}
+
+// src/file-editor/formats/jsonc.ts
+import {
+  applyEdits,
+  modify,
+  parse as jsoncParse,
+  printParseErrorCode as printParseErrorCode2
+} from "jsonc-parser";
+
+// src/file-editor/formats/adapter.ts
+function _defaultMeta() {
+  return { indent: "  ", eol: "\n", hasFinalNewline: true, hasBom: false };
+}
+function _detectMeta(text) {
+  const hasBom = text.charCodeAt(0) === 65279;
+  const body = hasBom ? text.slice(1) : text;
+  const eol = body.includes("\r\n") ? "\r\n" : "\n";
+  const hasFinalNewline = body.endsWith("\n");
+  const indent = detectIndent(body);
+  return { indent, eol, hasFinalNewline, hasBom };
+}
+function detectIndent(text) {
+  const lines = text.split(/\r?\n/);
+  for (const line of lines) {
+    const m = /^([ \t]+)\S/.exec(line);
+    if (m?.[1]) return m[1];
+  }
+  return "  ";
+}
+
+// src/file-editor/formats/jsonc.ts
+function createJsoncFlavor(format, allowComments) {
+  return {
+    format,
+    permitsComments: allowComments,
+    parse(text) {
+      const errors = [];
+      const body = stripBom2(text);
+      const value = jsoncParse(body, errors, {
+        allowTrailingComma: allowComments,
+        disallowComments: !allowComments
+      });
+      if (errors.length > 0) {
+        const first = errors[0];
+        if (first === void 0) return { value, meta: _detectMeta(text) };
+        throw new _ParseError(
+          format,
+          `Invalid ${format.toUpperCase()} at offset ${String(first.offset)}: ${printParseErrorCode2(first.error)}`,
+          { offset: first.offset, snippet: text.slice(first.offset, first.offset + 40) }
+        );
+      }
+      return { value, meta: _detectMeta(text) };
+    },
+    applyEdits(text, edits, meta) {
+      let current = text === "" ? "{}" : text;
+      for (const edit of edits) {
+        current = applyOne(current, edit, meta, format);
+      }
+      if (meta.hasFinalNewline && !current.endsWith(meta.eol)) {
+        current = current + meta.eol;
+      }
+      if (meta.hasBom && !current.startsWith("\uFEFF")) {
+        current = "\uFEFF" + current;
+      }
+      return current;
+    }
+  };
+}
+function applyOne(text, edit, meta, format) {
+  const path = pointerToPath(edit.pointer);
+  const formattingOptions = {
+    tabSize: meta.indent.startsWith("	") ? 1 : meta.indent.length || 2,
+    insertSpaces: !meta.indent.startsWith("	"),
+    eol: meta.eol
+  };
+  const currentValue = parseCurrent(text, format);
+  switch (edit.kind) {
+    case "set": {
+      const jsonEdits = modify(text, path, edit.value, { formattingOptions });
+      return applyEdits(text, jsonEdits);
+    }
+    case "addIfMissing": {
+      if (_hasPointer(currentValue, edit.pointer)) return text;
+      const jsonEdits = modify(text, path, edit.value, { formattingOptions });
+      return applyEdits(text, jsonEdits);
+    }
+    case "updateIfPresent": {
+      if (!_hasPointer(currentValue, edit.pointer)) return text;
+      if (!edit.updater) {
+        throw new _PathError(
+          edit.pointer,
+          "updateIfPresent requires an updater function."
+        );
+      }
+      const prior = _resolvePointer(currentValue, edit.pointer);
+      const next = edit.updater(prior);
+      const jsonEdits = modify(text, path, next, { formattingOptions });
+      return applyEdits(text, jsonEdits);
+    }
+    case "remove": {
+      if (!_hasPointer(currentValue, edit.pointer)) return text;
+      const jsonEdits = modify(text, path, void 0, { formattingOptions });
+      return applyEdits(text, jsonEdits);
+    }
+    case "merge": {
+      const prior = _resolvePointer(currentValue, edit.pointer);
+      const merged = mergeValues(prior, edit.value, edit.mergeOptions, edit.pointer);
+      const jsonEdits = modify(text, path, merged, { formattingOptions });
+      return applyEdits(text, jsonEdits);
+    }
+    case "arrayAppend": {
+      const prior = _resolvePointer(currentValue, edit.pointer);
+      if (prior === void 0) {
+        const jsonEdits2 = modify(text, path, [edit.value], { formattingOptions });
+        return applyEdits(text, jsonEdits2);
+      }
+      if (!Array.isArray(prior)) {
+        throw new _TypeMismatchError(
+          edit.pointer,
+          `arrayAppend requires an array at ${edit.pointer}`
+        );
+      }
+      const appendPath = [...path, prior.length];
+      const jsonEdits = modify(text, appendPath, edit.value, {
+        formattingOptions,
+        isArrayInsertion: true
+      });
+      return applyEdits(text, jsonEdits);
+    }
+    case "arrayUpsert": {
+      const prior = _resolvePointer(currentValue, edit.pointer);
+      const keyFn = edit.arrayKey;
+      if (!keyFn) throw new _PathError(edit.pointer, "arrayUpsert requires a keyFn.");
+      const newElement = edit.value;
+      if (prior === void 0) {
+        const jsonEdits2 = modify(text, path, [newElement], { formattingOptions });
+        return applyEdits(text, jsonEdits2);
+      }
+      if (!Array.isArray(prior)) {
+        throw new _TypeMismatchError(
+          edit.pointer,
+          `arrayUpsert requires an array at ${edit.pointer}`
+        );
+      }
+      const targetKey = keyFn(newElement);
+      const idx = prior.findIndex((el) => keyFn(el) === targetKey);
+      if (idx >= 0) {
+        const jsonEdits2 = modify(text, [...path, idx], newElement, { formattingOptions });
+        return applyEdits(text, jsonEdits2);
+      }
+      const appendPath = [...path, prior.length];
+      const jsonEdits = modify(text, appendPath, newElement, {
+        formattingOptions,
+        isArrayInsertion: true
+      });
+      return applyEdits(text, jsonEdits);
+    }
+  }
+}
+function pointerToPath(pointer) {
+  const segments = _parsePointer(pointer);
+  return segments.map((seg) => {
+    const idx = _parseArrayIndex(seg);
+    return idx ?? seg;
+  });
+}
+function stripBom2(text) {
+  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+}
+function parseCurrent(text, format) {
+  const errors = [];
+  const value = jsoncParse(stripBom2(text), errors, {
+    allowTrailingComma: format === "jsonc",
+    disallowComments: format === "json"
+  });
+  if (errors.length > 0) {
+    const first = errors[0];
+    if (first === void 0) return value;
+    throw new _ParseError(
+      format,
+      `Invalid ${format}: ${printParseErrorCode2(first.error)}`,
+      {
+        offset: first.offset
+      }
+    );
+  }
+  return value;
+}
+function mergeValues(prior, incoming, options, pointer) {
+  const deep = options?.deep ?? true;
+  const arrayStrategy = options?.arrays ?? "replace";
+  if (prior === void 0 || prior === null) return incoming;
+  if (!isPlainObject(prior) || !isPlainObject(incoming)) {
+    if (Array.isArray(prior) && Array.isArray(incoming)) {
+      return mergeArrays(prior, incoming, arrayStrategy);
+    }
+    throw new _TypeMismatchError(
+      pointer,
+      "merge requires an object at the target pointer."
+    );
+  }
+  const out = { ...prior };
+  for (const [key, val] of Object.entries(incoming)) {
+    const existing = out[key];
+    if (deep && isPlainObject(existing) && isPlainObject(val)) {
+      out[key] = mergeValues(existing, val, options, pointer + "/" + key);
+    } else if (Array.isArray(existing) && Array.isArray(val)) {
+      out[key] = mergeArrays(existing, val, arrayStrategy);
+    } else {
+      out[key] = val;
+    }
+  }
+  return out;
+}
+function mergeArrays(a, b, strategy) {
+  switch (strategy) {
+    case "replace":
+      return [...b];
+    case "concat":
+      return [...a, ...b];
+    case "concatUnique": {
+      const seen = /* @__PURE__ */ new Set();
+      const out = [];
+      for (const v of [...a, ...b]) {
+        const key = stableStringify(v);
+        if (!seen.has(key)) {
+          seen.add(key);
+          out.push(v);
+        }
+      }
+      return out;
+    }
+  }
+}
+function stableStringify(v) {
+  return _canonicalNormalize(JSON.stringify(v), "json");
+}
+function isPlainObject(v) {
+  if (v === null || typeof v !== "object") return false;
+  if (Array.isArray(v)) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+var jsonAdapter = createJsoncFlavor("json", false);
+var jsoncAdapter = createJsoncFlavor("jsonc", true);
+
+// src/file-editor/formats/yaml.ts
+import YAML, { isCollection, isMap, isSeq } from "yaml";
+var yamlAdapter = {
+  format: "yaml",
+  permitsComments: true,
+  parse(text) {
+    const doc = YAML.parseDocument(text, { merge: true, prettyErrors: false });
+    const value = doc.toJS();
+    if (doc.errors.length > 0) {
+      const first = doc.errors[0];
+      if (first === void 0) return { value, meta: _detectMeta(text) };
+      throw new _ParseError("yaml", `Invalid YAML: ${first.message}`, {
+        offset: first.pos[0],
+        snippet: text.slice(first.pos[0], first.pos[0] + 40)
+      });
+    }
+    return { value, meta: _detectMeta(text) };
+  },
+  applyEdits(text, edits, meta) {
+    const source = text === "" ? "{}\n" : text;
+    const doc = YAML.parseDocument(source, { merge: true });
+    if (doc.errors.length > 0) {
+      const first = doc.errors[0];
+      if (first !== void 0) {
+        throw new _ParseError("yaml", `Invalid YAML: ${first.message}`);
+      }
+    }
+    for (const edit of edits) {
+      applyYamlEdit(doc, edit);
+    }
+    let result = doc.toString();
+    if (meta.eol === "\r\n") {
+      result = result.replace(/\r?\n/g, "\r\n");
+    }
+    const endsWithEol = result.endsWith(meta.eol);
+    if (meta.hasFinalNewline && !endsWithEol) {
+      result = result + meta.eol;
+    } else if (!meta.hasFinalNewline && endsWithEol) {
+      result = result.slice(0, -meta.eol.length);
+    }
+    if (meta.hasBom && !result.startsWith("\uFEFF")) {
+      result = "\uFEFF" + result;
+    }
+    return result;
+  }
+};
+function applyYamlEdit(doc, edit) {
+  const segments = toYamlPath(edit.pointer);
+  switch (edit.kind) {
+    case "set": {
+      setInWithParents(doc, segments, edit.value);
+      return;
+    }
+    case "addIfMissing": {
+      if (doc.hasIn(segments)) return;
+      setInWithParents(doc, segments, edit.value);
+      return;
+    }
+    case "updateIfPresent": {
+      if (!doc.hasIn(segments)) return;
+      if (!edit.updater)
+        throw new _PathError(edit.pointer, "updateIfPresent requires an updater.");
+      const prior = jsValueAt(doc, segments);
+      const next = edit.updater(prior);
+      doc.setIn(segments, next);
+      return;
+    }
+    case "remove": {
+      if (!doc.hasIn(segments)) return;
+      doc.deleteIn(segments);
+      return;
+    }
+    case "merge": {
+      const prior = jsValueAt(doc, segments);
+      const merged = mergeValues2(prior, edit.value, edit.mergeOptions, edit.pointer);
+      setInWithParents(doc, segments, merged);
+      return;
+    }
+    case "arrayAppend": {
+      const node = segments.length === 0 ? doc.contents : doc.getIn(segments, true);
+      if (node === void 0 || node === null) {
+        setInWithParents(doc, segments, [edit.value]);
+        return;
+      }
+      if (!isSeq(node)) {
+        throw new _TypeMismatchError(
+          edit.pointer,
+          `arrayAppend requires a sequence at ${edit.pointer}`
+        );
+      }
+      node.add(edit.value);
+      return;
+    }
+    case "arrayUpsert": {
+      const keyFn = edit.arrayKey;
+      if (!keyFn) throw new _PathError(edit.pointer, "arrayUpsert requires a keyFn.");
+      const priorJs = jsValueAt(doc, segments);
+      const newElement = edit.value;
+      if (priorJs === void 0 || priorJs === null) {
+        setInWithParents(doc, segments, [newElement]);
+        return;
+      }
+      if (!Array.isArray(priorJs)) {
+        throw new _TypeMismatchError(
+          edit.pointer,
+          `arrayUpsert requires a sequence at ${edit.pointer}`
+        );
+      }
+      const targetKey = keyFn(newElement);
+      const idx = priorJs.findIndex((el) => keyFn(el) === targetKey);
+      if (idx >= 0) {
+        doc.setIn([...segments, idx], newElement);
+      } else {
+        const seqNode = segments.length === 0 ? doc.contents : doc.getIn(segments, true);
+        if (isSeq(seqNode)) {
+          seqNode.add(newElement);
+        }
+      }
+      return;
+    }
+  }
+}
+function toYamlPath(pointer) {
+  const segments = _parsePointer(pointer);
+  return segments.map((seg) => {
+    const idx = _parseArrayIndex(seg);
+    return idx ?? seg;
+  });
+}
+function jsValueAt(doc, segments) {
+  if (segments.length === 0) {
+    return doc.toJS();
+  }
+  return _resolvePointer(
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- yaml's toJS() returns any; widening to unknown is safe
+    doc.toJS(),
+    "/" + segments.map((s) => String(s)).join("/")
+  );
+}
+function setInWithParents(doc, segments, value) {
+  if (segments.length === 0) {
+    doc.contents = doc.createNode(value);
+    return;
+  }
+  const partial = [];
+  for (let i = 0; i < segments.length - 1; i++) {
+    const seg = segments[i];
+    if (seg === void 0) break;
+    partial.push(seg);
+    if (!doc.hasIn(partial)) break;
+    const cur = doc.getIn(partial, true);
+    if (!isCollection(cur)) {
+      throw new _TypeMismatchError(
+        "/" + partial.map(String).join("/"),
+        `cannot descend through non-collection value`
+      );
+    }
+    const needsIndex = typeof segments[i + 1] === "number";
+    if (needsIndex && !isSeq(cur)) {
+      throw new _TypeMismatchError(
+        "/" + partial.map(String).join("/"),
+        `expected sequence, found mapping`
+      );
+    }
+    if (!needsIndex && !isMap(cur)) {
+      throw new _TypeMismatchError(
+        "/" + partial.map(String).join("/"),
+        `expected mapping, found sequence`
+      );
+    }
+  }
+  doc.setIn(segments, doc.createNode(value));
+}
+function mergeValues2(prior, incoming, options, pointer) {
+  const deep = options?.deep ?? true;
+  const arrayStrategy = options?.arrays ?? "replace";
+  if (prior === void 0 || prior === null) return incoming;
+  if (!isPlainObject2(prior) || !isPlainObject2(incoming)) {
+    if (Array.isArray(prior) && Array.isArray(incoming)) {
+      return mergeArrays2(prior, incoming, arrayStrategy);
+    }
+    throw new _TypeMismatchError(
+      pointer,
+      "merge requires a mapping at the target pointer."
+    );
+  }
+  const out = { ...prior };
+  for (const [key, val] of Object.entries(incoming)) {
+    const existing = out[key];
+    if (deep && isPlainObject2(existing) && isPlainObject2(val)) {
+      out[key] = mergeValues2(existing, val, options, pointer + "/" + key);
+    } else if (Array.isArray(existing) && Array.isArray(val)) {
+      out[key] = mergeArrays2(existing, val, arrayStrategy);
+    } else {
+      out[key] = val;
+    }
+  }
+  return out;
+}
+function mergeArrays2(a, b, strategy) {
+  switch (strategy) {
+    case "replace":
+      return [...b];
+    case "concat":
+      return [...a, ...b];
+    case "concatUnique": {
+      const seen = /* @__PURE__ */ new Set();
+      const out = [];
+      for (const v of [...a, ...b]) {
+        const key = _canonicalNormalize(JSON.stringify(v), "json");
+        if (!seen.has(key)) {
+          seen.add(key);
+          out.push(v);
+        }
+      }
+      return out;
+    }
+  }
+}
+function isPlainObject2(v) {
+  if (v === null || typeof v !== "object") return false;
+  if (Array.isArray(v)) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+
+// src/file-editor/formats/detect.ts
+import { extname } from "path";
+function _detectFormat(path, text) {
+  const ext = extname(path).toLowerCase();
+  switch (ext) {
+    case ".json":
+      if (text !== void 0 && containsJsoncMarkers(text)) return "jsonc";
+      return inferJsonFlavor(path);
+    case ".jsonc":
+      return "jsonc";
+    case ".yaml":
+    case ".yml":
+      return "yaml";
+    default:
+      throw new _FormatNotSupportedError(path);
+  }
+}
+var JSONC_PATH_HINTS = [
+  "tsconfig.json",
+  "tsconfig.base.json",
+  "jsconfig.json",
+  "api-extractor.json",
+  ".vscode/settings.json",
+  ".vscode/launch.json"
+];
+function inferJsonFlavor(path) {
+  const normalized = path.replace(/\\/g, "/").toLowerCase();
+  for (const hint of JSONC_PATH_HINTS) {
+    if (normalized.endsWith("/" + hint) || normalized === hint) return "jsonc";
+    if (/\/tsconfig\.[^/]*\.json$/.test(normalized)) return "jsonc";
+  }
+  return "json";
+}
+function containsJsoncMarkers(text) {
+  return scanForCommentOrTrailingComma(text);
+}
+function scanForCommentOrTrailingComma(text) {
+  let inString = false;
+  let escape = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text.charCodeAt(i);
+    if (escape) {
+      escape = false;
+      continue;
+    }
+    if (inString) {
+      if (ch === 92) escape = true;
+      else if (ch === 34) inString = false;
+      continue;
+    }
+    if (ch === 34) {
+      inString = true;
+      continue;
+    }
+    if (ch === 47) {
+      const next = text.charCodeAt(i + 1);
+      if (next === 47 || next === 42) return true;
+    }
+    if (ch === 44) {
+      for (let j = i + 1; j < text.length; j++) {
+        const nc = text.charCodeAt(j);
+        if (nc === 32 || nc === 9 || nc === 10 || nc === 13) continue;
+        if (nc === 93 || nc === 125) return true;
+        break;
+      }
+    }
+  }
+  return false;
+}
+
+// src/file-editor/formats/index.ts
+var REGISTRY = /* @__PURE__ */ new Map([
+  ["json", jsonAdapter],
+  ["jsonc", jsoncAdapter],
+  ["yaml", yamlAdapter]
+]);
+function _getAdapter(format) {
+  const adapter = REGISTRY.get(format);
+  if (!adapter) {
+    throw new Error(`No adapter registered for format "${format}"`);
+  }
+  return adapter;
+}
+function _registerFormatAdapter(format, adapter) {
+  REGISTRY.set(format, adapter);
+}
+
+// src/file-editor/document.ts
+var _Document = class {
+  absolutePath;
+  format;
+  /** Optional Standard Schema; when set, {@link _Document.validate} runs it. */
+  schema;
+  /** Original on-disk text (may be `""` for new files). */
+  originalText;
+  meta;
+  edits = [];
+  staticDiagnostics = [];
+  constructor(init) {
+    this.absolutePath = init.absolutePath;
+    this.format = init.format;
+    this.originalText = init.originalText;
+    this.meta = init.meta;
+    this.schema = init.schema ?? null;
+  }
+  // ── Reads ──────────────────────────────────────────────────────────
+  /** Get the value at a pointer. Reflects pending edits via `preview()`. */
+  get(pointer) {
+    const current = this.parseCurrentValue();
+    return _resolvePointer(current, pointer);
+  }
+  /** Like `get` but throws {@link _AssertionError} on miss. */
+  getRequired(pointer) {
+    const current = this.parseCurrentValue();
+    if (!_hasPointer(current, pointer)) {
+      throw new _AssertionError(pointer, `required value is missing at ${pointer}`);
+    }
+    return _resolvePointer(current, pointer);
+  }
+  has(pointer) {
+    return _hasPointer(this.parseCurrentValue(), pointer);
+  }
+  // ── Mutations (staged) ─────────────────────────────────────────────
+  set(pointer, value, opts) {
+    return this.stage({ kind: "set", pointer, value, ...this.opts(opts) });
+  }
+  addIfMissing(pointer, value, opts) {
+    return this.stage({ kind: "addIfMissing", pointer, value, ...this.opts(opts) });
+  }
+  updateIfPresent(pointer, updater, opts) {
+    return this.stage({
+      kind: "updateIfPresent",
+      pointer,
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-unsafe-type-assertion -- _PendingEdit.updater is typed as (unknown) => unknown; widening the typed updater is safe since it will receive the same runtime value
+      updater,
+      ...this.opts(opts)
+    });
+  }
+  remove(pointer, opts) {
+    return this.stage({ kind: "remove", pointer, ...this.opts(opts) });
+  }
+  merge(pointer, partial, opts) {
+    const base = {
+      kind: "merge",
+      pointer,
+      value: partial,
+      ...this.opts(opts)
+    };
+    return this.stage(
+      opts?.mergeOptions ? { ...base, mergeOptions: opts.mergeOptions } : base
+    );
+  }
+  arrayAppend(pointer, value, opts) {
+    return this.stage({ kind: "arrayAppend", pointer, value, ...this.opts(opts) });
+  }
+  arrayUpsert(pointer, value, keyFn, opts) {
+    return this.stage({
+      kind: "arrayUpsert",
+      pointer,
+      value,
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-unsafe-type-assertion -- _PendingEdit.arrayKey is typed as (unknown) => unknown; widening the typed keyFn is safe since it will receive the same runtime value
+      arrayKey: keyFn,
+      ...this.opts(opts)
+    });
+  }
+  // ── Assertions ─────────────────────────────────────────────────────
+  assert(...checks) {
+    const results = _runAssertions(this.absolutePath, this.parseCurrentValue(), checks);
+    this.staticDiagnostics.push(...results);
+    return results;
+  }
+  /**
+   * If a schema is configured, validate the current preview against it and
+   * return a diagnostic per issue. Returns `[]` when no schema is set or
+   * validation passes.
+   *
+   * Each call replaces any previously accumulated `SCHEMA_VIOLATION` diagnostics
+   * so that calling `validate()` multiple times does not duplicate findings.
+   */
+  async validate() {
+    if (!this.schema) return [];
+    const result = await this.schema["~standard"].validate(this.parseCurrentValue());
+    const withoutPriorSchema = this.staticDiagnostics.filter(
+      (d) => d.code !== "SCHEMA_VIOLATION"
+    );
+    this.staticDiagnostics.length = 0;
+    this.staticDiagnostics.push(...withoutPriorSchema);
+    if (!result.issues) return [];
+    const diagnostics = result.issues.map((issue) => ({
+      path: this.absolutePath,
+      pointer: issuePathToPointer(issue.path),
+      code: "SCHEMA_VIOLATION",
+      severity: "error",
+      message: issue.message
+    }));
+    this.staticDiagnostics.push(...diagnostics);
+    return diagnostics;
+  }
+  diagnostics() {
+    return this.staticDiagnostics;
+  }
+  // ── Introspection ──────────────────────────────────────────────────
+  pendingEdits() {
+    return this.edits;
+  }
+  /** Serialize with all pending edits applied. Pure — no disk I/O. */
+  preview() {
+    if (this.edits.length === 0) return this.originalText;
+    const adapter = _getAdapter(this.format);
+    return adapter.applyEdits(this.originalText, this.edits, this.meta);
+  }
+  /** Reset all pending edits. Used by transactions on rollback. */
+  rollback() {
+    this.edits.length = 0;
+  }
+  /** @internal Metadata for transaction serialization. */
+  getMeta() {
+    return this.meta;
+  }
+  /** @internal Original text, for transaction fingerprinting. */
+  getOriginalText() {
+    return this.originalText;
+  }
+  // ── Internals ──────────────────────────────────────────────────────
+  parseCurrentValue() {
+    const text = this.preview();
+    if (text === "") return void 0;
+    const adapter = _getAdapter(this.format);
+    return adapter.parse(text).value;
+  }
+  stage(edit) {
+    if (edit.guard && !edit.guard(this.parseCurrentValue())) return this;
+    this.edits.push(edit);
+    return this;
+  }
+  opts(opts) {
+    const out = {};
+    if (opts?.conflictPolicy !== void 0) out.conflictPolicy = opts.conflictPolicy;
+    if (opts?.guard !== void 0) {
+      const g = opts.guard;
+      out.guard = () => g(this);
+    }
+    return out;
+  }
+};
+function issuePathToPointer(path) {
+  if (!path || path.length === 0) return "";
+  const parts = path.map((seg) => {
+    const key = typeof seg === "object" ? seg.key : seg;
+    const s = typeof key === "symbol" ? key.description ?? "" : String(key);
+    return s.replace(/~/g, "~0").replace(/\//g, "~1");
+  });
+  return "/" + parts.join("/");
+}
+async function _openDocumentFromDisk(absolutePath, options = {}) {
+  const schema = options.schema ?? null;
+  let text;
+  try {
+    text = await readFile(absolutePath, "utf8");
+  } catch (err) {
+    if (isNodeNotFound(err)) {
+      const format2 = options.format ?? _detectFormat(absolutePath);
+      return new _Document({
+        absolutePath,
+        format: format2,
+        originalText: "",
+        meta: _defaultMeta(),
+        schema
+      });
+    }
+    throw err;
+  }
+  const format = options.format ?? _detectFormat(absolutePath, text);
+  const adapter = _getAdapter(format);
+  const { meta } = adapter.parse(text);
+  return new _Document({ absolutePath, format, originalText: text, meta, schema });
+}
+function isNodeNotFound(err) {
+  return err !== null && typeof err === "object" && "code" in err && err.code === "ENOENT";
+}
+function _previewFingerprint(doc) {
+  return _fingerprint(doc.preview(), doc.format);
+}
+
+// src/file-editor/transaction.ts
+import { readFile as readFile2, stat } from "fs/promises";
+
+// src/file-editor/state/in-memory.ts
+function _InMemoryStateStore() {
+  const records = /* @__PURE__ */ new Map();
+  return {
+    // eslint-disable-next-line @typescript-eslint/require-await -- synchronous Map operation wrapped in async interface
+    async read(path) {
+      return records.get(path) ?? null;
+    },
+    // eslint-disable-next-line @typescript-eslint/require-await -- synchronous Map operation wrapped in async interface
+    async write(path, record) {
+      records.set(path, record);
+    },
+    // eslint-disable-next-line @typescript-eslint/require-await -- synchronous Map operation wrapped in async interface
+    async delete(path) {
+      records.delete(path);
+    },
+    // eslint-disable-next-line @typescript-eslint/require-await -- synchronous Map operation wrapped in async interface
+    async list() {
+      return [...records.entries()].map(([path, record]) => ({ path, record }));
+    }
+  };
+}
+
+// src/file-editor/util/atomic-write.ts
+import { randomBytes } from "crypto";
+import { mkdir, rename, unlink, writeFile } from "fs/promises";
+import { dirname } from "path";
+async function _atomicWriteText(path, text) {
+  await mkdir(dirname(path), { recursive: true });
+  const suffix = randomBytes(6).toString("hex");
+  const tmp = `${path}.${suffix}.tmp`;
+  await writeFile(tmp, text, "utf8");
+  try {
+    await rename(tmp, path);
+  } catch (err) {
+    await unlink(tmp).catch((_unlinkErr) => void 0);
+    throw err;
+  }
+}
+
+// src/file-editor/util/diff.ts
+function _unified(a, b, opts = {}) {
+  const context = opts.context ?? 3;
+  const nameA = opts.fileNameA ?? "a";
+  const nameB = opts.fileNameB ?? "b";
+  const hunksList = _hunks(a, b, { context });
+  if (hunksList.length === 0) return "";
+  const lines = [`--- ${nameA}`, `+++ ${nameB}`];
+  for (const h of hunksList) {
+    lines.push(
+      `@@ -${String(h.oldStart)},${String(h.oldLines)} +${String(h.newStart)},${String(h.newLines)} @@`
+    );
+    for (const l of h.lines) {
+      const prefix = l.kind === "context" ? " " : l.kind === "add" ? "+" : "-";
+      lines.push(prefix + l.text);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function _hunks(a, b, opts = {}) {
+  const context = opts.context ?? 3;
+  const aLines = splitLines(a);
+  const bLines = splitLines(b);
+  const ops = diffLines(aLines, bLines);
+  return groupIntoHunks(ops, context);
+}
+function splitLines(text) {
+  if (text === "") return [];
+  const parts = text.split(/\r?\n/);
+  if (parts.length > 0 && parts.at(-1) === "" && /\r?\n$/.test(text)) {
+    parts.pop();
+  }
+  return parts;
+}
+var Dp2D = class {
+  data;
+  cols;
+  constructor(rows, cols) {
+    this.cols = cols;
+    this.data = new Array(rows * cols).fill(0);
+  }
+  get(row, col) {
+    return this.data[row * this.cols + col] ?? 0;
+  }
+  set(row, col, val) {
+    this.data[row * this.cols + col] = val;
+  }
+};
+function diffLines(a, b) {
+  const n = a.length;
+  const m = b.length;
+  const dp = new Dp2D(n + 1, m + 1);
+  for (let i2 = n - 1; i2 >= 0; i2--) {
+    for (let j2 = m - 1; j2 >= 0; j2--) {
+      if (a[i2] === b[j2]) dp.set(i2, j2, dp.get(i2 + 1, j2 + 1) + 1);
+      else dp.set(i2, j2, Math.max(dp.get(i2 + 1, j2), dp.get(i2, j2 + 1)));
+    }
+  }
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    const aLine = a[i] ?? "";
+    const bLine = b[j] ?? "";
+    if (aLine === bLine) {
+      ops.push({ kind: "context", text: aLine, oldIdx: i, newIdx: j });
+      i++;
+      j++;
+    } else if (dp.get(i + 1, j) >= dp.get(i, j + 1)) {
+      ops.push({ kind: "del", text: aLine, oldIdx: i });
+      i++;
+    } else {
+      ops.push({ kind: "add", text: bLine, newIdx: j });
+      j++;
+    }
+  }
+  while (i < n) {
+    ops.push({ kind: "del", text: a[i] ?? "", oldIdx: i });
+    i++;
+  }
+  while (j < m) {
+    ops.push({ kind: "add", text: b[j] ?? "", newIdx: j });
+    j++;
+  }
+  return ops;
+}
+function groupIntoHunks(ops, context) {
+  const changeIndices = [];
+  for (let k = 0; k < ops.length; k++) {
+    const op = ops[k];
+    if (op !== void 0 && op.kind !== "context") changeIndices.push(k);
+  }
+  if (changeIndices.length === 0) return [];
+  const groups = [];
+  let groupStart = Math.max(0, (changeIndices[0] ?? 0) - context);
+  let groupEnd = Math.min(ops.length - 1, (changeIndices[0] ?? 0) + context);
+  for (let k = 1; k < changeIndices.length; k++) {
+    const idx = changeIndices[k] ?? 0;
+    if (idx - context <= groupEnd + 1) {
+      groupEnd = Math.min(ops.length - 1, idx + context);
+    } else {
+      groups.push({ start: groupStart, end: groupEnd });
+      groupStart = Math.max(0, idx - context);
+      groupEnd = Math.min(ops.length - 1, idx + context);
+    }
+  }
+  groups.push({ start: groupStart, end: groupEnd });
+  const result = [];
+  for (const g of groups) {
+    const slice = ops.slice(g.start, g.end + 1);
+    const first = slice[0];
+    if (first === void 0) continue;
+    const lines = slice.map((op) => toDiffLine(op));
+    const oldLines = slice.filter((op) => op.kind !== "add").length;
+    const newLines = slice.filter((op) => op.kind !== "del").length;
+    let oldStart;
+    let newStart;
+    if (first.kind === "context") {
+      oldStart = first.oldIdx + 1;
+      newStart = first.newIdx + 1;
+    } else if (first.kind === "del") {
+      oldStart = first.oldIdx + 1;
+      const prevNew = findNewIndex(ops, g.start, "before");
+      newStart = prevNew === 0 && newLines === 0 ? 0 : prevNew + 1;
+    } else {
+      const prevOld = findOldIndex(ops, g.start, "before");
+      oldStart = prevOld === 0 && oldLines === 0 ? 0 : prevOld + 1;
+      newStart = first.newIdx + 1;
+    }
+    result.push({ oldStart, oldLines, newStart, newLines, lines });
+  }
+  return result;
+}
+function toDiffLine(op) {
+  if (op.kind === "context") {
+    return {
+      kind: "context",
+      text: op.text,
+      oldLineNo: op.oldIdx + 1,
+      newLineNo: op.newIdx + 1
+    };
+  }
+  if (op.kind === "del") {
+    return { kind: "del", text: op.text, oldLineNo: op.oldIdx + 1, newLineNo: null };
+  }
+  return { kind: "add", text: op.text, oldLineNo: null, newLineNo: op.newIdx + 1 };
+}
+function findOldIndex(ops, from, _direction) {
+  for (let k = from - 1; k >= 0; k--) {
+    const op = ops[k];
+    if (op === void 0) continue;
+    if (op.kind === "context") return op.oldIdx + 1;
+    if (op.kind === "del") return op.oldIdx + 1;
+  }
+  return 0;
+}
+function findNewIndex(ops, from, _direction) {
+  for (let k = from - 1; k >= 0; k--) {
+    const op = ops[k];
+    if (op === void 0) continue;
+    if (op.kind === "context") return op.newIdx + 1;
+    if (op.kind === "add") return op.newIdx + 1;
+  }
+  return 0;
+}
+
+// src/file-editor/transaction.ts
+var _Transaction = class {
+  documents = /* @__PURE__ */ new Map();
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /** Open or return the cached document for a path. Memoized per transaction. */
+  async open(absolutePath) {
+    const cached = this.documents.get(absolutePath);
+    if (cached) return cached;
+    const opts = this.options.format === void 0 ? {} : { format: this.options.format };
+    const doc = await _openDocumentFromDisk(absolutePath, opts);
+    this.documents.set(absolutePath, doc);
+    return doc;
+  }
+  /** @internal — register a document that was opened externally (e.g. via a façade). */
+  adopt(doc) {
+    this.documents.set(doc.absolutePath, doc);
+  }
+  /** Drop all staged edits across every document in the transaction. */
+  rollback() {
+    for (const doc of this.documents.values()) doc.rollback();
+  }
+  /** Plan without writing. Invokes `onConflict`/`confirmWrite` as a real commit would. */
+  async dryRun(options = {}) {
+    return this.run(options, { write: false });
+  }
+  /** Apply staged edits to disk. */
+  async commit(options = {}) {
+    return this.run(options, { write: true });
+  }
+  async run(options, mode) {
+    const store = this.options.stateStore ?? _InMemoryStateStore();
+    const defaultPolicy = options.defaultPolicy ?? "error";
+    const confirmationPolicy = this.options.confirmationPolicy ?? "on-conflict";
+    const written = [];
+    const skipped = [];
+    const conflicts = [];
+    const diagnostics = [];
+    for (const doc of this.documents.values()) {
+      const schemaDiagnostics = await doc.validate();
+      diagnostics.push(...schemaDiagnostics);
+      diagnostics.push(
+        ...doc.diagnostics().filter((d) => !schemaDiagnostics.includes(d))
+      );
+      if (schemaDiagnostics.some((d) => d.severity === "error")) {
+        skipped.push({ path: doc.absolutePath, reason: "schema-invalid" });
+        continue;
+      }
+      const nextText = doc.preview();
+      const hasEdits = doc.pendingEdits().length > 0;
+      const fileExists = await pathExists(doc.absolutePath);
+      if (!hasEdits && fileExists) {
+        skipped.push({ path: doc.absolutePath, reason: "no-change" });
+        continue;
+      }
+      if (!hasEdits && !fileExists) {
+        skipped.push({ path: doc.absolutePath, reason: "no-change" });
+        continue;
+      }
+      const stored = await store.read(doc.absolutePath);
+      const diskText = fileExists ? await readExistingText(doc.absolutePath) : null;
+      const conflict = await resolveDrift({
+        doc,
+        nextText,
+        diskText,
+        stored,
+        defaultPolicy,
+        onConflict: this.options.onConflict
+      });
+      if (conflict.decision === "skip") {
+        skipped.push({ path: doc.absolutePath, reason: "conflict-skipped" });
+        if (conflict.conflict) conflicts.push(conflict.conflict);
+        continue;
+      }
+      if (conflict.conflict) conflicts.push(conflict.conflict);
+      const reason = decideReason(conflict.conflict !== null, diskText !== null);
+      const shouldConfirm = confirmationPolicy === "always" || confirmationPolicy === "on-conflict" && reason === "conflict";
+      if (shouldConfirm && this.options.confirmWrite) {
+        const req = buildWriteRequest({
+          path: doc.absolutePath,
+          format: doc.format,
+          reason,
+          currentText: diskText,
+          nextText,
+          conflict: conflict.conflict
+        });
+        const decision = await this.options.confirmWrite(req);
+        if (decision === "abort") throw new _WriteAbortedError(doc.absolutePath);
+        if (decision === "skip") {
+          skipped.push({ path: doc.absolutePath, reason: "write-skipped" });
+          continue;
+        }
+      }
+      if (diskText === nextText) {
+        skipped.push({ path: doc.absolutePath, reason: "no-change" });
+        continue;
+      }
+      if (mode.write) {
+        await _atomicWriteText(doc.absolutePath, nextText);
+        const record = {
+          fingerprint: _previewFingerprint(doc),
+          rawSha256: _sha256Hex(nextText),
+          writtenAt: (/* @__PURE__ */ new Date()).toISOString(),
+          toolId: this.options.toolId ?? null,
+          toolVersion: this.options.toolVersion ?? null,
+          format: doc.format,
+          baseText: nextText
+        };
+        await store.write(doc.absolutePath, record);
+      }
+      written.push({
+        path: doc.absolutePath,
+        bytesBefore: Buffer.byteLength(diskText ?? "", "utf8"),
+        bytesAfter: Buffer.byteLength(nextText, "utf8"),
+        unifiedDiff: _unified(diskText ?? "", nextText, {
+          fileNameA: "a/" + doc.absolutePath,
+          fileNameB: "b/" + doc.absolutePath
+        })
+      });
+    }
+    return { written, skipped, conflicts, diagnostics };
+  }
+};
+async function resolveDrift(args) {
+  const { doc, nextText, diskText, stored, defaultPolicy, onConflict } = args;
+  if (diskText === nextText) return { decision: "proceed", conflict: null };
+  if (stored === null) return { decision: "proceed", conflict: null };
+  if (diskText !== null) {
+    const diskFp = _fingerprint(diskText, doc.format);
+    if (diskFp === stored.fingerprint) return { decision: "proceed", conflict: null };
+  }
+  const conflict = {
+    path: doc.absolutePath,
+    ours: nextText,
+    theirs: diskText ?? "",
+    base: stored.baseText ?? null,
+    lastWriteAt: stored.writtenAt,
+    lastWriteTool: stored.toolId
+  };
+  const policy = pickPolicy(doc, defaultPolicy);
+  switch (policy) {
+    case "error":
+      throw new _ConflictError(conflict);
+    case "skip":
+      return { decision: "skip", conflict };
+    case "overwrite":
+      return { decision: "proceed", conflict };
+    case "ask": {
+      if (!onConflict) {
+        throw new _FileEditorError(
+          "CONFLICT_RESOLVER_MISSING",
+          `conflictPolicy "ask" requires an onConflict resolver for ${doc.absolutePath}.`
+        );
+      }
+      const resolution = await onConflict(conflict);
+      if (resolution === "abort") throw new _ConflictAbortedError(doc.absolutePath);
+      if (resolution === "skip") return { decision: "skip", conflict };
+      return { decision: "proceed", conflict };
+    }
+  }
+}
+function pickPolicy(doc, fallback) {
+  for (const edit of doc.pendingEdits()) {
+    if (edit.conflictPolicy !== void 0) return edit.conflictPolicy;
+  }
+  return fallback;
+}
+function decideReason(isConflict, fileExisted) {
+  if (isConflict) return "conflict";
+  return fileExisted ? "update" : "new-file";
+}
+function buildWriteRequest(args) {
+  const base = args.currentText ?? "";
+  return {
+    path: args.path,
+    format: args.format,
+    reason: args.reason,
+    currentText: args.currentText,
+    nextText: args.nextText,
+    unifiedDiff: _unified(base, args.nextText, {
+      fileNameA: "a/" + args.path,
+      fileNameB: "b/" + args.path
+    }),
+    hunks: _hunks(base, args.nextText),
+    conflict: args.conflict
+  };
+}
+async function pathExists(path) {
+  try {
+    const s = await stat(path);
+    return s.isFile();
+  } catch {
+    return false;
+  }
+}
+async function readExistingText(path) {
+  return readFile2(path, "utf8");
+}
+function _beginTransaction(options = {}) {
+  return new _Transaction(options);
+}
+async function _openDocument(absolutePath, options = {}) {
+  const tx = _beginTransaction(options);
+  return tx.open(absolutePath);
+}
+
+// src/file-editor/schema.ts
+async function _validateWithSchema(schema, value) {
+  const result = await schema["~standard"].validate(value);
+  if (result.issues) {
+    const summary = result.issues.map(formatIssue).join("; ");
+    throw new _SchemaValidationError(summary, result.issues);
+  }
+  return result.value;
+}
+function _tryValidateWithSchema(schema, value) {
+  return Promise.resolve(schema["~standard"].validate(value));
+}
+var _SchemaValidationError = class extends Error {
+  issues;
+  constructor(message, issues) {
+    super(message);
+    this.name = "_SchemaValidationError";
+    this.issues = issues;
+  }
+};
+function formatIssue(issue) {
+  if (!issue.path || issue.path.length === 0) return issue.message;
+  const path = issue.path.map((seg) => typeof seg === "object" ? String(seg.key) : String(seg)).join(".");
+  return `${path}: ${issue.message}`;
+}
+
+// src/file-editor/state/fs-manifest.ts
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, isAbsolute as isAbsolute2, relative as relative2, resolve, sep as sep2 } from "path";
+function _FsCentralManifestStore(options = {}) {
+  const root = resolve(options.rootDir ?? process.cwd());
+  const manifestPath = resolve(root, options.filename ?? ".file-editor/state.json");
+  const keepBase = options.keepBaseSnapshots ?? false;
+  const toKey = (p) => {
+    const abs = isAbsolute2(p) ? p : resolve(root, p);
+    const rel = relative2(root, abs);
+    return rel.split(sep2).join("/");
+  };
+  const load = async () => {
+    try {
+      const text = await readFile3(manifestPath, "utf8");
+      const raw = JSON.parse(text);
+      const version = raw !== null && typeof raw === "object" && "version" in raw ? raw.version : void 0;
+      if (version !== 1) {
+        throw new Error(`Unsupported state manifest version: ${String(version)}`);
+      }
+      return raw;
+    } catch (err) {
+      if (isNodeNotFound2(err)) return { version: 1, records: {} };
+      throw err;
+    }
+  };
+  const save = async (manifest) => {
+    await mkdir2(dirname2(manifestPath), { recursive: true });
+    const text = JSON.stringify(manifest, null, 2) + "\n";
+    await writeFile2(manifestPath, text, "utf8");
+  };
+  const stripBase = (record) => {
+    if (keepBase) return record;
+    const { baseText: _baseText, ...rest } = record;
+    return rest;
+  };
+  return {
+    async read(path) {
+      const manifest = await load();
+      return manifest.records[toKey(path)] ?? null;
+    },
+    async write(path, record) {
+      const manifest = await load();
+      const next = {
+        version: 1,
+        records: { ...manifest.records, [toKey(path)]: stripBase(record) }
+      };
+      await save(next);
+    },
+    async delete(path) {
+      const manifest = await load();
+      const key = toKey(path);
+      if (!(key in manifest.records)) return;
+      const { [key]: _removed, ...nextRecords } = manifest.records;
+      await save({ version: 1, records: nextRecords });
+    },
+    async list() {
+      const manifest = await load();
+      return Object.entries(manifest.records).map(([key, record]) => ({
+        path: resolve(root, key),
+        record
+      }));
+    }
+  };
+}
+function isNodeNotFound2(err) {
+  return err !== null && typeof err === "object" && "code" in err && err.code === "ENOENT";
+}
+
+// src/file-editor/facades/package-json.ts
+var _PackageJsonDoc = class extends _Document {
+  setScript(name, command, opts) {
+    return this.set(scriptPointer(name), command, opts);
+  }
+  requireScript(name, command) {
+    if (command !== void 0) this.addIfMissing(scriptPointer(name), command);
+    this.assert(_check.exists(scriptPointer(name)));
+    return this;
+  }
+  addDependency(name, range, kind = "dependencies", opts) {
+    return this.set(depPointer(kind, name), range, opts);
+  }
+  updateDependency(name, range, kind = "dependencies", opts) {
+    return this.updateIfPresent(depPointer(kind, name), () => range, opts);
+  }
+  removeDependency(name, kind = "dependencies", opts) {
+    return this.remove(depPointer(kind, name), opts);
+  }
+  ensureDependency(name, range, kind = "dependencies", opts) {
+    return this.addIfMissing(depPointer(kind, name), range, opts);
+  }
+  mustHaveScript(name, opts = {}) {
+    const checks = [_check.exists(scriptPointer(name))];
+    if (opts.equals !== void 0)
+      checks.push(_check.equals(scriptPointer(name), opts.equals));
+    if (opts.matches !== void 0)
+      checks.push(_check.matches(scriptPointer(name), opts.matches));
+    return this.assert(...checks);
+  }
+  mustHaveDependency(name, opts = {}) {
+    const kind = opts.kind ?? "dependencies";
+    const checks = [_check.exists(depPointer(kind, name))];
+    if (opts.range !== void 0) {
+      checks.push(_check.semverSatisfies(depPointer(kind, name), opts.range));
+    }
+    return this.assert(...checks);
+  }
+};
+function scriptPointer(name) {
+  return _compilePointer(["scripts", name]);
+}
+function depPointer(kind, name) {
+  return "/" + kind + "/" + _escapeToken(name);
+}
+async function _openPackageJson(absolutePath, options = {}) {
+  const openOpts = {
+    format: options.format ?? "json"
+  };
+  if (options.schema) openOpts.schema = options.schema;
+  const base = await _openDocumentFromDisk(absolutePath, openOpts);
+  return new _PackageJsonDoc({
+    absolutePath: base.absolutePath,
+    format: base.format,
+    originalText: base.getOriginalText(),
+    meta: base.getMeta(),
+    schema: base.schema
+  });
+}
+
+// src/file-editor/facades/tsconfig.ts
+var _TsConfigDoc = class extends _Document {
+  setCompilerOption(name, value, opts) {
+    return this.set(coPointer(name), value, opts);
+  }
+  ensureCompilerOption(name, value, opts) {
+    return this.addIfMissing(coPointer(name), value, opts);
+  }
+  addInclude(pattern, opts) {
+    return this.arrayUpsert("/include", pattern, (p) => p, opts);
+  }
+  addExclude(pattern, opts) {
+    return this.arrayUpsert("/exclude", pattern, (p) => p, opts);
+  }
+  addReference(path, opts) {
+    return this.arrayUpsert(
+      "/references",
+      { path },
+      (ref) => ref.path,
+      opts
+    );
+  }
+  mustHaveCompilerOption(name, opts = {}) {
+    const checks = [_check.exists(coPointer(name))];
+    if (opts.equals !== void 0)
+      checks.push(_check.equals(coPointer(name), opts.equals));
+    if (opts.oneOf !== void 0) checks.push(_check.oneOf(coPointer(name), opts.oneOf));
+    return this.assert(...checks);
+  }
+};
+function coPointer(name) {
+  return _compilePointer(["compilerOptions", name]);
+}
+async function _openTsConfig(absolutePath, options = {}) {
+  const opts = {
+    format: options.format ?? "jsonc"
+  };
+  if (options.schema) opts.schema = options.schema;
+  const base = await _openDocumentFromDisk(absolutePath, opts);
+  return new _TsConfigDoc({
+    absolutePath: base.absolutePath,
+    format: base.format,
+    originalText: base.getOriginalText(),
+    meta: base.getMeta(),
+    schema: base.schema
+  });
+}
+
+// src/file-editor/facades/api-extractor.ts
+var _ApiExtractorDoc = class extends _Document {
+  setMainEntryPoint(path, opts) {
+    return this.set("/mainEntryPointFilePath", path, opts);
+  }
+  enableApiReport(folder, fileName, opts) {
+    this.set("/apiReport/enabled", true, opts);
+    this.set("/apiReport/reportFolder", folder, opts);
+    this.set("/apiReport/reportFileName", fileName, opts);
+    return this;
+  }
+  enableDtsRollup(publicPath, opts) {
+    this.set("/dtsRollup/enabled", true, opts);
+    this.set("/dtsRollup/publicTrimmedFilePath", publicPath, opts);
+    return this;
+  }
+};
+async function _openApiExtractor(absolutePath, options = {}) {
+  const opts = {
+    format: options.format ?? "jsonc"
+  };
+  if (options.schema)
+    opts.schema = options.schema;
+  const base = await _openDocumentFromDisk(absolutePath, opts);
+  return new _ApiExtractorDoc({
+    absolutePath: base.absolutePath,
+    format: base.format,
+    originalText: base.getOriginalText(),
+    meta: base.getMeta(),
+    schema: base.schema
+  });
+}
+
+// src/file-editor/facades/stripe-app-manifest.ts
+var _StripeAppManifestDoc = class extends _Document {
+  setName(name, opts) {
+    return this.set("/name", name, opts);
+  }
+  setVersion(version, opts) {
+    return this.set("/version", version, opts);
+  }
+  addPermission(permission, opts) {
+    return this.arrayUpsert(
+      "/permissions",
+      permission,
+      (p) => p,
+      opts
+    );
+  }
+  removePermission(permission, opts) {
+    const existing = this.get("/permissions");
+    const permissions = (existing ?? []).filter((p) => p !== permission);
+    return this.set("/permissions", permissions, opts);
+  }
+  /**
+   * Add a custom object definition. Uses arrayUpsert to avoid duplicates
+   * (keyed on `id`). Creates the `custom_object_definitions.definitions`
+   * array if it doesn't exist.
+   */
+  addCustomObject(id, content, type = "typescript", opts) {
+    this.addIfMissing("/custom_object_definitions", {}, opts);
+    this.addIfMissing("/custom_object_definitions/definitions", [], opts);
+    return this.arrayUpsert(
+      "/custom_object_definitions/definitions",
+      { id, specification: { type, content } },
+      (entry) => entry.id,
+      opts
+    );
+  }
+  /**
+   * Check if a custom object definition exists by id.
+   */
+  hasCustomObject(id) {
+    const defs = this.get("/custom_object_definitions");
+    if (!defs?.definitions) return false;
+    return defs.definitions.some((d) => d.id === id);
+  }
+};
+async function _openStripeAppManifest(absolutePath, options = {}) {
+  const opts = {};
+  if (options.format !== void 0) opts.format = options.format;
+  if (options.schema)
+    opts.schema = options.schema;
+  const base = await _openDocumentFromDisk(absolutePath, opts);
+  return new _StripeAppManifestDoc({
+    absolutePath: base.absolutePath,
+    format: base.format,
+    originalText: base.getOriginalText(),
+    meta: base.getMeta(),
+    schema: base.schema
+  });
+}
+
+// src/file-editor/facades/brands.ts
+import semver2 from "semver";
+function _semverRange(input) {
+  const valid = semver2.validRange(input);
+  if (valid === null) {
+    throw new TypeError(`Invalid semver range: ${JSON.stringify(input)}`);
+  }
+  return input;
+}
+function _tryParseSemverRange(input) {
+  return semver2.validRange(input) === null ? null : input;
+}
+function _isSemverRange(input) {
+  return typeof input === "string" && semver2.validRange(input) !== null;
+}
+function _semverVersion(input) {
+  if (semver2.valid(input) === null) {
+    throw new TypeError(`Invalid semver version: ${JSON.stringify(input)}`);
+  }
+  return input;
+}
+function _tryParseSemverVersion(input) {
+  return semver2.valid(input) === null ? null : input;
+}
+function _isSemverVersion(input) {
+  return typeof input === "string" && semver2.valid(input) !== null;
+}
+export {
+  _ApiExtractorDoc,
+  _AssertionError,
+  _CliUx,
+  _ConflictAbortedError,
+  _ConflictError,
+  _Document,
+  _FileEditorError,
+  _FormatNotSupportedError,
+  _FsCentralManifestStore,
+  _GeneratorDefectError,
+  _GeneratorInputError,
+  _GeneratorRunner,
+  _InMemoryStateStore,
+  _POINTER_STRING,
+  _PackageJsonDoc,
+  _ParseError,
+  _PathError,
+  _SchemaValidationError,
+  _SingleTemplateManager,
+  _StripeAppManifestDoc,
+  _TemplateManager,
+  _Transaction,
+  _TsConfigDoc,
+  _TypeMismatchError,
+  _WriteAbortedError,
+  _beginTransaction,
+  _canonicalNormalize,
+  _canonicalStringify,
+  _check,
+  _compilePointer,
+  _compositeGenerator,
+  _createCliContext,
+  _createFilesystemTemplateFS,
+  _createInMemoryTemplateFS,
+  _createLogger,
+  _createSimpleSingleFileTemplate,
+  _createSimpleTemplate,
+  _defaultMeta,
+  _detectFormat,
+  _detectMeta,
+  _hunks as _diffHunks,
+  _unified as _diffUnified,
+  _escapeToken,
+  _fingerprint,
+  _getAdapter,
+  _hasPointer,
+  _inferStripeApiName,
+  _isRecord,
+  _isRecordWithValueType,
+  _isSemverRange,
+  _isSemverVersion,
+  jsonAdapter as _jsonAdapter,
+  jsoncAdapter as _jsoncAdapter,
+  _looksPlural,
+  _looksSingular,
+  _openApiExtractor,
+  _openDocument,
+  _openDocumentFromDisk,
+  _openPackageJson,
+  _openStripeAppManifest,
+  _openTsConfig,
+  _parseArrayIndex,
+  _parseLogLevel,
+  _parsePointer,
+  _pointer,
+  _registerFormatAdapter,
+  _resolvePointer,
+  _runAssertions,
+  _runAsyncAssertions,
+  _semverRange,
+  _semverVersion,
+  _sha256Hex,
+  _stripeMetadataPolicy,
+  _toCapitalized,
+  _toPascalCase,
+  _toPlural,
+  _toSentenceDisplayName,
+  _toSingular,
+  _toSnakeCase,
+  _toStripeApiCase,
+  _tokenizeIdentifier,
+  _truncateName,
+  _tryParseSemverRange,
+  _tryParseSemverVersion,
+  _tryValidateWithSchema,
+  _unescapeToken,
+  _validateApiName,
+  _validateDisplayName,
+  _validateWithSchema,
+  _workspaceVersion,
+  _writeJsonOutput,
+  yamlAdapter as _yamlAdapter
+};