@c4a/extract 0.6.19 → 0.7.0

package/index.js

@@ -100,17 +100,17 @@ var require_visit = __commonJS((exports) => {
   visit.BREAK = BREAK;
   visit.SKIP = SKIP;
   visit.REMOVE = REMOVE;
-  function visit_(key, node2, visitor, path) {
-    const ctrl = callVisitor(key, node2, visitor, path);
+  function visit_(key, node2, visitor, path2) {
+    const ctrl = callVisitor(key, node2, visitor, path2);
     if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-      replaceNode(key, path, ctrl);
-      return visit_(key, ctrl, visitor, path);
+      replaceNode(key, path2, ctrl);
+      return visit_(key, ctrl, visitor, path2);
     }
     if (typeof ctrl !== "symbol") {
       if (identity.isCollection(node2)) {
-        path = Object.freeze(path.concat(node2));
+        path2 = Object.freeze(path2.concat(node2));
         for (let i = 0;i < node2.items.length; ++i) {
-          const ci = visit_(i, node2.items[i], visitor, path);
+          const ci = visit_(i, node2.items[i], visitor, path2);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -121,13 +121,13 @@ var require_visit = __commonJS((exports) => {
           }
         }
       } else if (identity.isPair(node2)) {
-        path = Object.freeze(path.concat(node2));
-        const ck = visit_("key", node2.key, visitor, path);
+        path2 = Object.freeze(path2.concat(node2));
+        const ck = visit_("key", node2.key, visitor, path2);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node2.key = null;
-        const cv = visit_("value", node2.value, visitor, path);
+        const cv = visit_("value", node2.value, visitor, path2);
         if (cv === BREAK)
           return BREAK;
         else if (cv === REMOVE)
@@ -148,17 +148,17 @@ var require_visit = __commonJS((exports) => {
   visitAsync.BREAK = BREAK;
   visitAsync.SKIP = SKIP;
   visitAsync.REMOVE = REMOVE;
-  async function visitAsync_(key, node2, visitor, path) {
-    const ctrl = await callVisitor(key, node2, visitor, path);
+  async function visitAsync_(key, node2, visitor, path2) {
+    const ctrl = await callVisitor(key, node2, visitor, path2);
     if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-      replaceNode(key, path, ctrl);
-      return visitAsync_(key, ctrl, visitor, path);
+      replaceNode(key, path2, ctrl);
+      return visitAsync_(key, ctrl, visitor, path2);
     }
     if (typeof ctrl !== "symbol") {
       if (identity.isCollection(node2)) {
-        path = Object.freeze(path.concat(node2));
+        path2 = Object.freeze(path2.concat(node2));
         for (let i = 0;i < node2.items.length; ++i) {
-          const ci = await visitAsync_(i, node2.items[i], visitor, path);
+          const ci = await visitAsync_(i, node2.items[i], visitor, path2);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -169,13 +169,13 @@ var require_visit = __commonJS((exports) => {
           }
         }
       } else if (identity.isPair(node2)) {
-        path = Object.freeze(path.concat(node2));
-        const ck = await visitAsync_("key", node2.key, visitor, path);
+        path2 = Object.freeze(path2.concat(node2));
+        const ck = await visitAsync_("key", node2.key, visitor, path2);
         if (ck === BREAK)
           return BREAK;
         else if (ck === REMOVE)
           node2.key = null;
-        const cv = await visitAsync_("value", node2.value, visitor, path);
+        const cv = await visitAsync_("value", node2.value, visitor, path2);
         if (cv === BREAK)
           return BREAK;
         else if (cv === REMOVE)
@@ -202,23 +202,23 @@ var require_visit = __commonJS((exports) => {
     }
     return visitor;
   }
-  function callVisitor(key, node2, visitor, path) {
+  function callVisitor(key, node2, visitor, path2) {
     if (typeof visitor === "function")
-      return visitor(key, node2, path);
+      return visitor(key, node2, path2);
     if (identity.isMap(node2))
-      return visitor.Map?.(key, node2, path);
+      return visitor.Map?.(key, node2, path2);
     if (identity.isSeq(node2))
-      return visitor.Seq?.(key, node2, path);
+      return visitor.Seq?.(key, node2, path2);
     if (identity.isPair(node2))
-      return visitor.Pair?.(key, node2, path);
+      return visitor.Pair?.(key, node2, path2);
     if (identity.isScalar(node2))
-      return visitor.Scalar?.(key, node2, path);
+      return visitor.Scalar?.(key, node2, path2);
     if (identity.isAlias(node2))
-      return visitor.Alias?.(key, node2, path);
+      return visitor.Alias?.(key, node2, path2);
     return;
   }
-  function replaceNode(key, path, node2) {
-    const parent = path[path.length - 1];
+  function replaceNode(key, path2, node2) {
+    const parent = path2[path2.length - 1];
     if (identity.isCollection(parent)) {
       parent.items[key] = node2;
     } else if (identity.isPair(parent)) {
@@ -775,10 +775,10 @@ var require_Collection = __commonJS((exports) => {
   var createNode = require_createNode();
   var identity = require_identity();
   var Node = require_Node();
-  function collectionFromPath(schema, path, value) {
+  function collectionFromPath(schema, path2, value) {
     let v = value;
-    for (let i = path.length - 1;i >= 0; --i) {
-      const k = path[i];
+    for (let i = path2.length - 1;i >= 0; --i) {
+      const k = path2[i];
       if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
         const a = [];
         a[k] = v;
@@ -797,7 +797,7 @@ var require_Collection = __commonJS((exports) => {
       sourceObjects: new Map
     });
   }
-  var isEmptyPath = (path) => path == null || typeof path === "object" && !!path[Symbol.iterator]().next().done;
+  var isEmptyPath = (path2) => path2 == null || typeof path2 === "object" && !!path2[Symbol.iterator]().next().done;
 
   class Collection extends Node.NodeBase {
     constructor(type, schema) {
@@ -818,11 +818,11 @@ var require_Collection = __commonJS((exports) => {
         copy.range = this.range.slice();
       return copy;
     }
-    addIn(path, value) {
-      if (isEmptyPath(path))
+    addIn(path2, value) {
+      if (isEmptyPath(path2))
         this.add(value);
       else {
-        const [key, ...rest] = path;
+        const [key, ...rest] = path2;
         const node2 = this.get(key, true);
         if (identity.isCollection(node2))
           node2.addIn(rest, value);
@@ -832,8 +832,8 @@ var require_Collection = __commonJS((exports) => {
           throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
       }
     }
-    deleteIn(path) {
-      const [key, ...rest] = path;
+    deleteIn(path2) {
+      const [key, ...rest] = path2;
       if (rest.length === 0)
         return this.delete(key);
       const node2 = this.get(key, true);
@@ -842,8 +842,8 @@ var require_Collection = __commonJS((exports) => {
       else
         throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
     }
-    getIn(path, keepScalar) {
-      const [key, ...rest] = path;
+    getIn(path2, keepScalar) {
+      const [key, ...rest] = path2;
       const node2 = this.get(key, true);
       if (rest.length === 0)
         return !keepScalar && identity.isScalar(node2) ? node2.value : node2;
@@ -858,15 +858,15 @@ var require_Collection = __commonJS((exports) => {
         return n == null || allowScalar && identity.isScalar(n) && n.value == null && !n.commentBefore && !n.comment && !n.tag;
       });
     }
-    hasIn(path) {
-      const [key, ...rest] = path;
+    hasIn(path2) {
+      const [key, ...rest] = path2;
       if (rest.length === 0)
         return this.has(key);
       const node2 = this.get(key, true);
       return identity.isCollection(node2) ? node2.hasIn(rest) : false;
     }
-    setIn(path, value) {
-      const [key, ...rest] = path;
+    setIn(path2, value) {
+      const [key, ...rest] = path2;
       if (rest.length === 0) {
         this.set(key, value);
       } else {
@@ -3248,9 +3248,9 @@ var require_Document = __commonJS((exports) => {
       if (assertCollection(this.contents))
         this.contents.add(value);
     }
-    addIn(path, value) {
+    addIn(path2, value) {
       if (assertCollection(this.contents))
-        this.contents.addIn(path, value);
+        this.contents.addIn(path2, value);
     }
     createAlias(node2, name) {
       if (!node2.anchor) {
@@ -3299,30 +3299,30 @@ var require_Document = __commonJS((exports) => {
     delete(key) {
       return assertCollection(this.contents) ? this.contents.delete(key) : false;
     }
-    deleteIn(path) {
-      if (Collection.isEmptyPath(path)) {
+    deleteIn(path2) {
+      if (Collection.isEmptyPath(path2)) {
         if (this.contents == null)
           return false;
         this.contents = null;
         return true;
       }
-      return assertCollection(this.contents) ? this.contents.deleteIn(path) : false;
+      return assertCollection(this.contents) ? this.contents.deleteIn(path2) : false;
     }
     get(key, keepScalar) {
       return identity.isCollection(this.contents) ? this.contents.get(key, keepScalar) : undefined;
     }
-    getIn(path, keepScalar) {
-      if (Collection.isEmptyPath(path))
+    getIn(path2, keepScalar) {
+      if (Collection.isEmptyPath(path2))
         return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-      return identity.isCollection(this.contents) ? this.contents.getIn(path, keepScalar) : undefined;
+      return identity.isCollection(this.contents) ? this.contents.getIn(path2, keepScalar) : undefined;
     }
     has(key) {
       return identity.isCollection(this.contents) ? this.contents.has(key) : false;
     }
-    hasIn(path) {
-      if (Collection.isEmptyPath(path))
+    hasIn(path2) {
+      if (Collection.isEmptyPath(path2))
         return this.contents !== undefined;
-      return identity.isCollection(this.contents) ? this.contents.hasIn(path) : false;
+      return identity.isCollection(this.contents) ? this.contents.hasIn(path2) : false;
     }
     set(key, value) {
       if (this.contents == null) {
@@ -3331,13 +3331,13 @@ var require_Document = __commonJS((exports) => {
         this.contents.set(key, value);
       }
     }
-    setIn(path, value) {
-      if (Collection.isEmptyPath(path)) {
+    setIn(path2, value) {
+      if (Collection.isEmptyPath(path2)) {
         this.contents = value;
       } else if (this.contents == null) {
-        this.contents = Collection.collectionFromPath(this.schema, Array.from(path), value);
+        this.contents = Collection.collectionFromPath(this.schema, Array.from(path2), value);
       } else if (assertCollection(this.contents)) {
-        this.contents.setIn(path, value);
+        this.contents.setIn(path2, value);
       }
     }
     setSchema(version, options = {}) {
@@ -5226,9 +5226,9 @@ var require_cst_visit = __commonJS((exports) => {
   visit.BREAK = BREAK;
   visit.SKIP = SKIP;
   visit.REMOVE = REMOVE;
-  visit.itemAtPath = (cst, path) => {
+  visit.itemAtPath = (cst, path2) => {
     let item = cst;
-    for (const [field, index] of path) {
+    for (const [field, index] of path2) {
       const tok = item?.[field];
       if (tok && "items" in tok) {
         item = tok.items[index];
@@ -5237,23 +5237,23 @@ var require_cst_visit = __commonJS((exports) => {
     }
     return item;
   };
-  visit.parentCollection = (cst, path) => {
-    const parent = visit.itemAtPath(cst, path.slice(0, -1));
-    const field = path[path.length - 1][0];
+  visit.parentCollection = (cst, path2) => {
+    const parent = visit.itemAtPath(cst, path2.slice(0, -1));
+    const field = path2[path2.length - 1][0];
     const coll = parent?.[field];
     if (coll && "items" in coll)
       return coll;
     throw new Error("Parent collection not found");
   };
-  function _visit(path, item, visitor) {
-    let ctrl = visitor(item, path);
+  function _visit(path2, item, visitor) {
+    let ctrl = visitor(item, path2);
     if (typeof ctrl === "symbol")
       return ctrl;
     for (const field of ["key", "value"]) {
       const token = item[field];
       if (token && "items" in token) {
         for (let i = 0;i < token.items.length; ++i) {
-          const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor);
+          const ci = _visit(Object.freeze(path2.concat([[field, i]])), token.items[i], visitor);
           if (typeof ci === "number")
             i = ci - 1;
           else if (ci === BREAK)
@@ -5264,10 +5264,10 @@ var require_cst_visit = __commonJS((exports) => {
           }
         }
         if (typeof ctrl === "function" && field === "key")
-          ctrl = ctrl(item, path);
+          ctrl = ctrl(item, path2);
       }
     }
-    return typeof ctrl === "function" ? ctrl(item, path) : ctrl;
+    return typeof ctrl === "function" ? ctrl(item, path2) : ctrl;
   }
   exports.visit = visit;
 });
@@ -7177,8 +7177,8 @@ var require_utils = __commonJS((exports) => {
     }
     return output;
   };
-  exports.basename = (path, { windows } = {}) => {
-    const segs = path.split(windows ? /[\\/]/ : "/");
+  exports.basename = (path2, { windows } = {}) => {
+    const segs = path2.split(windows ? /[\\/]/ : "/");
     const last = segs[segs.length - 1];
     if (last === "") {
       return segs[segs.length - 2];
@@ -8775,6 +8775,51 @@ var FactRelation;
   FactRelation2["Supersedes"] = "supersedes";
   FactRelation2["References"] = "references";
 })(FactRelation ||= {});
+// ../core/src/types/refPointer.ts
+var REF_POINTER_PATTERN = /^ref:(entity|relation|content):(.+)$/;
+function parseRef(pointer) {
+  const match = REF_POINTER_PATTERN.exec(pointer);
+  if (!match) {
+    return null;
+  }
+  const [, type, id] = match;
+  if (!id) {
+    return null;
+  }
+  return { type, id };
+}
+function buildRef(type, id) {
+  return `ref:${type}:${id}`;
+}
+function isRefPointer(value) {
+  return typeof value === "string" && parseRef(value) !== null;
+}
+function extractAllRefs(data) {
+  const results = [];
+  const visit = (value, path) => {
+    if (typeof value === "string") {
+      if (isRefPointer(value)) {
+        results.push({ pointer: value, fieldPath: path });
+      }
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        const nextPath = path ? `${path}[${index}]` : `[${index}]`;
+        visit(item, nextPath);
+      });
+      return;
+    }
+    if (value && typeof value === "object") {
+      for (const [key, entry] of Object.entries(value)) {
+        const nextPath = path ? `${path}.${key}` : key;
+        visit(entry, nextPath);
+      }
+    }
+  };
+  visit(data, "");
+  return results;
+}
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -12929,6 +12974,34 @@ var PathFilterConfigSchema = exports_external.object({
     exclude: exports_external.array(exports_external.string()).default([])
   }).default({})
 });
+var DEFAULT_PATH_FILTER = {
+  package: {
+    include: [
+      "**/{package.json,pyproject.toml,setup.py,go.mod,Cargo.toml,pom.xml,build.gradle}"
+    ]
+  },
+  code: {
+    include: ["**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}"],
+    exclude: [
+      "**/__{tests,test,e2e,mocks,fixtures,snapshots}__/**",
+      "**/*.{test,spec}.{ts,tsx,mts,cts,js,jsx,mjs,cjs}",
+      "**/*.d.{ts,mts,cts}"
+    ]
+  },
+  doc: {
+    include: ["*.md", "docs/**/*.md"],
+    exclude: ["**/CHANGELOG.md"]
+  }
+};
+function resolvePathFilter(metadata) {
+  const raw = metadata?.path_filter;
+  if (raw == null)
+    return { config: DEFAULT_PATH_FILTER, isDefault: true };
+  const parsed = PathFilterConfigSchema.safeParse(raw);
+  if (!parsed.success)
+    return { config: DEFAULT_PATH_FILTER, isDefault: true };
+  return { config: parsed.data, isDefault: false };
+}
 // ../core/src/schemas/baseSchema.ts
 var sourceRefSpanSchema = exports_external.object({
   start: exports_external.number().int().min(1),
@@ -13054,6 +13127,501 @@ var factSchema = exports_external.union([
   activeFactSchema,
   deprecatedFactSchema
 ]);
+// ../core/src/schemas/indexerEvidenceAdapterSchema.ts
+import { createHash } from "node:crypto";
+
+// ../core/src/indexerOutputRedaction.ts
+var INDEXER_OUTPUT_REDACTION_MARKER = "[REDACTED:indexer-output]";
+var SECRET_TOKEN = /^(?:password|passwd|pwd|secret|token|credential|credentials|cookie)$/u;
+var SECRET_COMPOUND = /^(?:api-key|access-key|private-key|client-secret|access-token|refresh-token)$/u;
+var NON_SECRET_SUFFIX = new Set([
+  "budget",
+  "count",
+  "digest",
+  "fingerprint",
+  "hash",
+  "index",
+  "kind",
+  "length",
+  "limit",
+  "name",
+  "ref",
+  "reference",
+  "references",
+  "refs",
+  "status",
+  "type"
+]);
+function keyTokens(key) {
+  return key.replace(/([a-z0-9])([A-Z])/gu, "$1-$2").replace(/[^A-Za-z0-9]+/gu, "-").toLowerCase().split("-").filter(Boolean);
+}
+function sensitiveKey(key, value) {
+  const tokens = keyTokens(key);
+  if (tokens.length === 0)
+    return false;
+  const normalized = tokens.join("-");
+  if (normalized === "authorization" && value !== null && typeof value === "object") {
+    return false;
+  }
+  if (NON_SECRET_SUFFIX.has(tokens.at(-1)))
+    return false;
+  return SECRET_COMPOUND.test(normalized) || tokens.some((token) => SECRET_TOKEN.test(token)) || normalized === "authorization";
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function normalizedBlockedScalars(policy) {
+  const identities = new Set;
+  const values = [];
+  for (const value of policy.blocked_scalars ?? []) {
+    if (typeof value === "number" && !Number.isFinite(value))
+      continue;
+    if (typeof value === "string" && value.length === 0)
+      continue;
+    const identity = `${typeof value}:${String(value)}`;
+    if (identities.has(identity))
+      continue;
+    identities.add(identity);
+    values.push(value);
+  }
+  return values.sort((left, right) => String(right).length - String(left).length);
+}
+function replaceWithCount(value, pattern, replacement, count) {
+  return value.replace(pattern, (...args) => {
+    count.replacements += 1;
+    if (typeof replacement === "string")
+      return replacement;
+    return replacement(...args.slice(0, -2));
+  });
+}
+function redactKnownText(value, count) {
+  let output = value;
+  output = replaceWithCount(output, /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/gu, INDEXER_OUTPUT_REDACTION_MARKER, count);
+  output = replaceWithCount(output, /(\bauthorization\s*:\s*(?:bearer|basic)\s+)[^\s,;]+/giu, (_match, prefix) => `${prefix}${INDEXER_OUTPUT_REDACTION_MARKER}`, count);
+  output = replaceWithCount(output, /([a-z][a-z0-9+.-]*:\/\/)[^\s/@:]+:[^\s/@]+@/giu, (_match, prefix) => `${prefix}${INDEXER_OUTPUT_REDACTION_MARKER}@`, count);
+  output = replaceWithCount(output, /([?&](?:access_token|refresh_token|api_key|password|secret)=)[^&#\s]+/giu, (_match, prefix) => `${prefix}${INDEXER_OUTPUT_REDACTION_MARKER}`, count);
+  const key = "(?:[A-Za-z0-9_.-]*(?:password|passwd|pwd|secret|token|credential|cookie)[A-Za-z0-9_.-]*|api[-_]?key|access[-_]?(?:key|token)|private[-_]?key|client[-_]?secret|authorization)";
+  const assignment = `(?:=\\s*|:\\s+(?=\\S)|:\\s*(?=["']))`;
+  output = replaceWithCount(output, new RegExp(`((?:["']?${key}["']?)\\s*${assignment})(?:"(?:\\\\.|[^"])*"|'(?:\\\\.|[^'])*'|[^\\s,;}\\]]+)`, "giu"), (_match, prefix) => `${prefix}"${INDEXER_OUTPUT_REDACTION_MARKER}"`, count);
+  return output;
+}
+function redactBlockedText(value, blocked, count) {
+  let output = value;
+  for (const scalar of blocked) {
+    const pattern = typeof scalar === "number" ? new RegExp(`(?<![0-9.])${escapeRegExp(String(scalar))}(?![0-9.])`, "gu") : new RegExp(escapeRegExp(scalar), "gu");
+    output = replaceWithCount(output, pattern, INDEXER_OUTPUT_REDACTION_MARKER, count);
+  }
+  return output;
+}
+function redactText(value, blocked, count) {
+  return redactBlockedText(redactKnownText(value, count), blocked, count);
+}
+function blockedScalar(value, blocked) {
+  return blocked.some((candidate) => typeof candidate === typeof value && Object.is(candidate, value));
+}
+function redactStructured(value, blocked, count, seen) {
+  if (blockedScalar(value, blocked)) {
+    count.replacements += 1;
+    return INDEXER_OUTPUT_REDACTION_MARKER;
+  }
+  if (typeof value === "string")
+    return redactText(value, blocked, count);
+  if (value === null || typeof value !== "object")
+    return value;
+  if (seen.has(value))
+    throw new TypeError("Indexer output redaction requires an acyclic value");
+  seen.add(value);
+  if (value instanceof Date) {
+    const redacted2 = redactText(value.toISOString(), blocked, count);
+    seen.delete(value);
+    return redacted2;
+  }
+  if (value instanceof Error) {
+    const redacted2 = {
+      name: redactText(value.name, blocked, count),
+      message: redactText(value.message, blocked, count)
+    };
+    seen.delete(value);
+    return redacted2;
+  }
+  if (Array.isArray(value)) {
+    const redacted2 = value.map((item) => redactStructured(item, blocked, count, seen));
+    seen.delete(value);
+    return redacted2;
+  }
+  const redacted = {};
+  for (const [key, item] of Object.entries(value)) {
+    const safeKey = redactText(key, blocked, count);
+    if (sensitiveKey(key, item)) {
+      count.replacements += 1;
+      redacted[safeKey] = INDEXER_OUTPUT_REDACTION_MARKER;
+    } else {
+      redacted[safeKey] = redactStructured(item, blocked, count, seen);
+    }
+  }
+  seen.delete(value);
+  return redacted;
+}
+function redactIndexerOutput(input) {
+  const count = { replacements: 0 };
+  const blocked = normalizedBlockedScalars(input.policy ?? {});
+  const value = typeof input.value === "string" ? redactText(input.value, blocked, count) : redactStructured(input.value, blocked, count, new WeakSet);
+  return {
+    value,
+    redacted: count.replacements > 0,
+    replacement_count: count.replacements
+  };
+}
+function redactIndexerOutputText(input) {
+  return redactIndexerOutput(input).value;
+}
+function assertIndexerOutputSafe(input) {
+  const result = redactIndexerOutput(input);
+  if (result.redacted) {
+    throw new TypeError(`Indexer ${input.channel} was blocked by the common output redaction boundary`);
+  }
+  return input.value;
+}
+
+// ../core/src/schemas/indexerEvidenceAdapterSchema.ts
+var digestSchema = exports_external.string().regex(/^sha256:[a-f0-9]{64}$/u);
+var idSchema = exports_external.string().regex(/^[a-z0-9][a-z0-9._/-]*$/u).superRefine((value, context) => {
+  if (value.split("/").some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      message: "must not contain empty, current-directory, or parent-directory segments"
+    });
+  }
+});
+var semverSchema = exports_external.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u);
+var canonicalRefSchema = exports_external.string().regex(/^[a-z][a-z0-9.-]*:[A-Za-z0-9][A-Za-z0-9._~:/#@+-]*$/u);
+var packageCoordinateSchema = exports_external.string().regex(/^(?:@[a-z0-9._-]+\/)?[a-z0-9][a-z0-9._-]*$/u);
+var portablePathSchema = exports_external.string().superRefine((value, context) => {
+  const segments = value.split("/");
+  if (value.length === 0 || value.includes("\x00") || value.includes("\\") || value.startsWith("/") || /^[A-Za-z]:\//u.test(value) || segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      message: "must be a portable relative path"
+    });
+  }
+});
+function addDuplicateIssues(values, context, field) {
+  const seen = new Set;
+  values.forEach((value, index) => {
+    if (seen.has(value)) {
+      context.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        message: `${field} must not contain duplicate value ${value}`,
+        path: [index]
+      });
+    }
+    seen.add(value);
+  });
+}
+var adapterIdentitySchema = exports_external.object({
+  id: idSchema,
+  package: packageCoordinateSchema,
+  export: exports_external.string().regex(/^[A-Za-z_$][A-Za-z0-9_$.-]*$/u),
+  version: semverSchema,
+  digest: digestSchema
+}).strict();
+var adapterLocatorSchema = exports_external.object({
+  source_ref: canonicalRefSchema,
+  module_ref: canonicalRefSchema.nullable(),
+  normalized_path: portablePathSchema,
+  qualified_item_path: exports_external.string().min(1).max(1024),
+  signature_digest: digestSchema
+}).strict();
+var indexerEvidenceAdapterFactSchema = exports_external.object({
+  fact_ref: canonicalRefSchema,
+  kind: idSchema,
+  locator: adapterLocatorSchema,
+  payload_digest: digestSchema,
+  denominator: exports_external.enum(["none", "eligible-file", "loc", "symbol", "protocol-item"])
+}).strict();
+var indexerEvidenceAdapterFileSchema = exports_external.object({
+  file_ref: canonicalRefSchema,
+  source_ref: canonicalRefSchema,
+  module_ref: canonicalRefSchema.nullable(),
+  normalized_path: portablePathSchema,
+  role: exports_external.enum(["primary-owner", "enricher"]),
+  coverage_tier: exports_external.enum(["ast-catalog", "lightweight-evidence"]),
+  disposition: exports_external.enum(["analyzed", "unsupported", "excluded"]),
+  facts: exports_external.array(indexerEvidenceAdapterFactSchema)
+}).strict().superRefine((value, context) => {
+  addDuplicateIssues(value.facts.map((fact2) => fact2.fact_ref), context, "facts");
+  if (value.disposition !== "analyzed" && value.facts.length > 0) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      message: "unsupported or excluded files cannot publish facts",
+      path: ["facts"]
+    });
+  }
+  if ((value.role === "enricher" || value.coverage_tier === "lightweight-evidence") && value.facts.some((fact2) => fact2.denominator !== "none")) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      message: "enricher and lightweight evidence facts cannot contribute denominators",
+      path: ["facts"]
+    });
+  }
+});
+var toolchainStepSchema = exports_external.object({
+  step: idSchema,
+  package: packageCoordinateSchema,
+  export: exports_external.string().regex(/^[A-Za-z_$][A-Za-z0-9_$.-]*$/u),
+  version: semverSchema,
+  digest: digestSchema,
+  capabilities: exports_external.array(idSchema).min(1),
+  input_digest: digestSchema,
+  output_digest: digestSchema
+}).strict().superRefine((value, context) => {
+  addDuplicateIssues(value.capabilities, context, "capabilities");
+});
+var adapterDiagnosticSchema = exports_external.object({
+  code: idSchema,
+  fact_ref: canonicalRefSchema.optional(),
+  severity: exports_external.enum(["info", "warning", "error"]),
+  detail_digest: digestSchema
+}).strict();
+var indexerEvidenceAdapterResultSchema = exports_external.object({
+  protocol: exports_external.literal("context.indexer.evidence-adapter-result/v1"),
+  adapter: adapterIdentitySchema,
+  authorized_scope: exports_external.object({
+    source_ref: canonicalRefSchema,
+    module_refs: exports_external.array(canonicalRefSchema),
+    scope_digest: digestSchema
+  }).strict(),
+  input_digest: digestSchema,
+  precedence: exports_external.number().int().nonnegative(),
+  files: exports_external.array(indexerEvidenceAdapterFileSchema).min(1),
+  diagnostics: exports_external.array(adapterDiagnosticSchema),
+  toolchain: exports_external.array(toolchainStepSchema).min(1),
+  output_digest: digestSchema
+}).strict().superRefine((value, context) => {
+  addDuplicateIssues(value.authorized_scope.module_refs, context, "authorized_scope.module_refs");
+  addDuplicateIssues(value.files.map((file) => file.file_ref), context, "files");
+  addDuplicateIssues(value.toolchain.map((step) => step.step), context, "toolchain");
+});
+var FACT_PAYLOADS = new WeakMap;
+function canonicalFactPayload(value, seen = new WeakSet, path = "$") {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new TypeError("Indexer Evidence Adapter fact payload numbers must be finite");
+    }
+    return value;
+  }
+  if (typeof value !== "object") {
+    throw new TypeError(`Indexer Evidence Adapter fact payload ${path} must contain only JSON values`);
+  }
+  if (seen.has(value)) {
+    throw new TypeError(`Indexer Evidence Adapter fact payload ${path} must be acyclic`);
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const output2 = value.map((item, index) => canonicalFactPayload(item, seen, `${path}[${index}]`));
+    seen.delete(value);
+    return output2;
+  }
+  if (Object.prototype.toString.call(value) !== "[object Object]") {
+    throw new TypeError(`Indexer Evidence Adapter fact payload ${path} must use plain JSON objects; received ${Object.prototype.toString.call(value)}`);
+  }
+  const output = {};
+  for (const [key, item] of Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)) {
+    output[key] = canonicalFactPayload(item, seen, `${path}.${key}`);
+  }
+  seen.delete(value);
+  return output;
+}
+function canonicalize(value) {
+  if (Array.isArray(value))
+    return value.map(canonicalize);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, item]) => [key, canonicalize(item)]));
+  }
+  return value;
+}
+function indexerEvidenceAdapterProtocolDigest(value) {
+  const canonical = JSON.stringify(canonicalize(value));
+  return `sha256:${createHash("sha256").update(canonical).digest("hex")}`;
+}
+function indexerEvidenceAdapterFileRef(input) {
+  return `adapter-file:${indexerEvidenceAdapterProtocolDigest(input)}`;
+}
+function indexerEvidenceAdapterFactRef(input) {
+  return `adapter-fact:${indexerEvidenceAdapterProtocolDigest(input)}`;
+}
+function createIndexerEvidenceAdapterFact(input) {
+  const payload = canonicalFactPayload(input.payload);
+  const qualifiedItemPath = input.qualified_item_path.length <= 1024 ? input.qualified_item_path : `${input.qualified_item_path.slice(0, 950)}#${indexerEvidenceAdapterProtocolDigest(input.qualified_item_path)}`;
+  const locator = {
+    source_ref: input.source_ref,
+    module_ref: input.module_ref,
+    normalized_path: input.normalized_path,
+    qualified_item_path: qualifiedItemPath,
+    signature_digest: indexerEvidenceAdapterProtocolDigest(input.signature)
+  };
+  const fact2 = {
+    fact_ref: indexerEvidenceAdapterFactRef({ ...locator, kind: input.kind }),
+    kind: input.kind,
+    locator,
+    payload_digest: indexerEvidenceAdapterProtocolDigest(payload),
+    denominator: input.denominator
+  };
+  FACT_PAYLOADS.set(fact2, payload);
+  return fact2;
+}
+function indexerEvidenceAdapterFactPayloads(result) {
+  const payloads = result.files.flatMap((file) => file.facts.map((fact2) => {
+    const payload = FACT_PAYLOADS.get(fact2);
+    if (payload === undefined) {
+      throw new TypeError(`Evidence Adapter fact payload ${fact2.fact_ref} is no longer materialized in this process`);
+    }
+    if (indexerEvidenceAdapterProtocolDigest(payload) !== fact2.payload_digest) {
+      throw new TypeError(`Evidence Adapter fact payload ${fact2.fact_ref} is stale`);
+    }
+    return { fact_ref: fact2.fact_ref, payload };
+  })).sort((left, right) => compareCanonicalText(left.fact_ref, right.fact_ref));
+  return assertIndexerOutputSafe({ channel: "ipc-envelope", value: payloads });
+}
+function materializeIndexerEvidenceAdapterResult(result) {
+  return {
+    result,
+    fact_payloads: indexerEvidenceAdapterFactPayloads(result)
+  };
+}
+function indexerEvidenceAdapterOutputDigest(value) {
+  return indexerEvidenceAdapterProtocolDigest(value);
+}
+function compareCanonicalText(left, right) {
+  if (left < right)
+    return -1;
+  if (left > right)
+    return 1;
+  return 0;
+}
+function buildIndexerEvidenceAdapterResult(input) {
+  const canonical = {
+    ...input,
+    authorized_scope: {
+      ...input.authorized_scope,
+      module_refs: [...input.authorized_scope.module_refs].sort(compareCanonicalText)
+    },
+    files: input.files.map((file) => ({
+      ...file,
+      facts: [...file.facts].sort((left, right) => compareCanonicalText(left.fact_ref, right.fact_ref))
+    })).sort((left, right) => compareCanonicalText(left.file_ref, right.file_ref)),
+    diagnostics: [...input.diagnostics].sort((left, right) => compareCanonicalText(left.fact_ref ?? "", right.fact_ref ?? "") || compareCanonicalText(left.code, right.code) || compareCanonicalText(left.severity, right.severity) || compareCanonicalText(left.detail_digest, right.detail_digest)),
+    toolchain: input.toolchain.map((step) => ({
+      ...step,
+      capabilities: [...step.capabilities].sort(compareCanonicalText)
+    }))
+  };
+  const payloads = new Map;
+  for (const file of canonical.files) {
+    for (const fact2 of file.facts) {
+      const payload = FACT_PAYLOADS.get(fact2);
+      if (payload !== undefined)
+        payloads.set(fact2.fact_ref, payload);
+    }
+  }
+  const parsed = indexerEvidenceAdapterResultSchema.parse({
+    ...canonical,
+    output_digest: indexerEvidenceAdapterOutputDigest(canonical)
+  });
+  for (const file of parsed.files) {
+    for (const fact2 of file.facts) {
+      const payload = payloads.get(fact2.fact_ref);
+      if (payload !== undefined)
+        FACT_PAYLOADS.set(fact2, payload);
+    }
+  }
+  return assertIndexerOutputSafe({ channel: "success-payload", value: parsed });
+}
+// ../core/src/errors/c4aError.ts
+class C4AError extends Error {
+  code;
+  details;
+  constructor(code, message, details, options) {
+    super(message, options);
+    this.name = "C4AError";
+    this.code = code;
+    this.details = details;
+  }
+  toResponse() {
+    if (this.details === undefined) {
+      return { code: this.code, message: this.message };
+    }
+    return { code: this.code, message: this.message, details: this.details };
+  }
+}
+// ../core/src/errors/errorCodes.ts
+var ErrorCode;
+((ErrorCode2) => {
+  ErrorCode2["VALIDATION_FAILED"] = "VALIDATION_FAILED";
+  ErrorCode2["VALIDATION_SCHEMA"] = "VALIDATION_SCHEMA";
+  ErrorCode2["STORAGE_FAILED"] = "STORAGE_FAILED";
+  ErrorCode2["STORAGE_NOT_FOUND"] = "STORAGE_NOT_FOUND";
+  ErrorCode2["STORAGE_CONFLICT"] = "STORAGE_CONFLICT";
+  ErrorCode2["PARSE_FAILED"] = "PARSE_FAILED";
+  ErrorCode2["PARSE_YAML"] = "PARSE_YAML";
+  ErrorCode2["API_NOT_IMPLEMENTED"] = "API_NOT_IMPLEMENTED";
+  ErrorCode2["API_UNAUTHORIZED"] = "API_UNAUTHORIZED";
+  ErrorCode2["API_RATE_LIMITED"] = "API_RATE_LIMITED";
+  ErrorCode2["ENTITY_NOT_FOUND"] = "ENTITY_NOT_FOUND";
+  ErrorCode2["ENTITY_DUPLICATE"] = "ENTITY_DUPLICATE";
+  ErrorCode2["RELATION_INVALID"] = "RELATION_INVALID";
+  ErrorCode2["BATCH_PARTIAL_FAILURE"] = "BATCH_PARTIAL_FAILURE";
+  ErrorCode2["QUERY_INVALID_PARAMS"] = "QUERY_INVALID_PARAMS";
+  ErrorCode2["BACKUP_FAILED"] = "BACKUP_FAILED";
+  ErrorCode2["RESTORE_FAILED"] = "RESTORE_FAILED";
+  ErrorCode2["PURGE_FAILED"] = "PURGE_FAILED";
+  ErrorCode2["BACKUP_VERSION_INCOMPATIBLE"] = "BACKUP_VERSION_INCOMPATIBLE";
+  ErrorCode2["BACKUP_MANIFEST_INVALID"] = "BACKUP_MANIFEST_INVALID";
+  ErrorCode2["BACKUP_DIR_NOT_FOUND"] = "BACKUP_DIR_NOT_FOUND";
+  ErrorCode2["EMBEDDING_NOT_AVAILABLE"] = "EMBEDDING_NOT_AVAILABLE";
+  ErrorCode2["EMBEDDING_FAILED"] = "EMBEDDING_FAILED";
+  ErrorCode2["LLM_NOT_AVAILABLE"] = "LLM_NOT_AVAILABLE";
+  ErrorCode2["LLM_CALL_FAILED"] = "LLM_CALL_FAILED";
+  ErrorCode2["LLM_AUTH_FAILED"] = "LLM_AUTH_FAILED";
+  ErrorCode2["AUTH_REQUIRED"] = "AUTH_REQUIRED";
+  ErrorCode2["AUTH_INVALID_TOKEN"] = "AUTH_INVALID_TOKEN";
+  ErrorCode2["AUTH_INVALID_API_KEY"] = "AUTH_INVALID_API_KEY";
+  ErrorCode2["AUTH_PROVIDER_ERROR"] = "AUTH_PROVIDER_ERROR";
+  ErrorCode2["AUTH_RESERVED_NAME"] = "AUTH_RESERVED_NAME";
+  ErrorCode2["DAEMON_OFFLINE"] = "DAEMON_OFFLINE";
+  ErrorCode2["SOURCE_NOT_FOUND"] = "SOURCE_NOT_FOUND";
+  ErrorCode2["REPO_PATH_NOT_FOUND"] = "REPO_PATH_NOT_FOUND";
+  ErrorCode2["COMMIT_NOT_FOUND"] = "COMMIT_NOT_FOUND";
+  ErrorCode2["INDEX_IN_PROGRESS"] = "INDEX_IN_PROGRESS";
+  ErrorCode2["DIGEST_NOT_FOUND"] = "DIGEST_NOT_FOUND";
+  ErrorCode2["INVALID_REGEX"] = "INVALID_REGEX";
+  ErrorCode2["SOURCE_ACCESS_DENIED"] = "SOURCE_ACCESS_DENIED";
+  ErrorCode2["NOT_INDEXED"] = "NOT_INDEXED";
+  ErrorCode2["QUERY_TIMEOUT"] = "QUERY_TIMEOUT";
+  ErrorCode2["INTENT_NOT_AVAILABLE"] = "INTENT_NOT_AVAILABLE";
+  ErrorCode2["SUB_PATH_CONFLICT"] = "SUB_PATH_CONFLICT";
+  ErrorCode2["WORKSPACE_ISOLATION"] = "WORKSPACE_ISOLATION";
+  ErrorCode2["VECTOR_DIMENSION_MISMATCH"] = "VECTOR_DIMENSION_MISMATCH";
+  ErrorCode2["VECTOR_REBUILD_PARTIAL"] = "VECTOR_REBUILD_PARTIAL";
+  ErrorCode2["COMMIT_NOT_AVAILABLE"] = "COMMIT_NOT_AVAILABLE";
+  ErrorCode2["DAEMON_AUTO_START_FAILED"] = "DAEMON_AUTO_START_FAILED";
+  ErrorCode2["GIT_ARCHIVE_FAILED"] = "GIT_ARCHIVE_FAILED";
+  ErrorCode2["GIT_HOST_NOT_CONFIGURED"] = "GIT_HOST_NOT_CONFIGURED";
+  ErrorCode2["GIT_API_RATE_LIMITED"] = "GIT_API_RATE_LIMITED";
+  ErrorCode2["GIT_API_TREE_TRUNCATED"] = "GIT_API_TREE_TRUNCATED";
+  ErrorCode2["GIT_API_AUTH_FAILED"] = "GIT_API_AUTH_FAILED";
+  ErrorCode2["GIT_API_REPO_NOT_FOUND"] = "GIT_API_REPO_NOT_FOUND";
+  ErrorCode2["GIT_API_NETWORK_ERROR"] = "GIT_API_NETWORK_ERROR";
+  ErrorCode2["DOC_INDEX_LLM_UNAVAILABLE"] = "DOC_INDEX_LLM_UNAVAILABLE";
+  ErrorCode2["DOC_INDEX_EMBEDDING_UNAVAILABLE"] = "DOC_INDEX_EMBEDDING_UNAVAILABLE";
+  ErrorCode2["DOC_INDEX_CONTENT_MISSING"] = "DOC_INDEX_CONTENT_MISSING";
+  ErrorCode2["DOC_INDEX_PARSE_FAILED"] = "DOC_INDEX_PARSE_FAILED";
+  ErrorCode2["DOC_INDEX_LLM_EXHAUSTED"] = "DOC_INDEX_LLM_EXHAUSTED";
+  ErrorCode2["UNKNOWN"] = "UNKNOWN";
+})(ErrorCode ||= {});
 // ../core/src/errors/httpStatus.ts
 var ERROR_CODE_HTTP_STATUS = {
   ["VALIDATION_FAILED" /* VALIDATION_FAILED */]: 400,
@@ -13118,21 +13686,102 @@ var ERROR_CODE_HTTP_STATUS = {
   ["UNKNOWN" /* UNKNOWN */]: 500,
   ["WORKSPACE_ISOLATION" /* WORKSPACE_ISOLATION */]: 400
 };
+function mapErrorCodeToStatus(code) {
+  return ERROR_CODE_HTTP_STATUS[code] ?? 500;
+}
+// ../core/src/utils/id.ts
+import { createHash as createHash2, randomUUID } from "node:crypto";
+function generateId(type, parentId, name) {
+  const input = `${type}:${parentId}:${name}`;
+  const hash = createHash2("sha256").update(input).digest("hex");
+  const hex32 = hash.slice(0, 32);
+  return `${type}_${hex32}`;
+}
+function generateUUID() {
+  return randomUUID();
+}
 // ../core/src/utils/hash.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 function contentHash(content) {
-  return createHash("sha256").update(content).digest("hex");
+  return createHash3("sha256").update(content).digest("hex");
+}
+// ../core/src/utils/object.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeDefaults(defaults, override) {
+  const result = { ...defaults };
+  for (const [key, value] of Object.entries(override)) {
+    if (!(key in defaults))
+      continue;
+    const defaultValue = defaults[key];
+    if (isPlainObject(defaultValue)) {
+      if (isPlainObject(value)) {
+        result[key] = mergeDefaults(defaultValue, value);
+      }
+    } else if (value !== undefined && value !== null) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+// ../core/src/utils/path.ts
+import path from "node:path";
+function isPathSafe(inputPath) {
+  if (inputPath.length === 0) {
+    return false;
+  }
+  if (inputPath.includes("\x00")) {
+    return false;
+  }
+  if (path.isAbsolute(inputPath)) {
+    return false;
+  }
+  if (/^[a-zA-Z]:/.test(inputPath)) {
+    return false;
+  }
+  if (inputPath.startsWith("~")) {
+    return false;
+  }
+  const normalized = path.posix.normalize(inputPath.replaceAll("\\", "/"));
+  const parts = normalized.split("/");
+  return !parts.some((part) => part === ".." || part === "");
 }
 // ../core/src/utils/yaml.ts
 var import_yaml = __toESM(require_dist(), 1);
+function serializeYaml(value) {
+  return import_yaml.default.stringify(value);
+}
+function parseYaml(value) {
+  try {
+    return import_yaml.default.parse(value);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to parse YAML";
+    throw new C4AError("PARSE_YAML" /* PARSE_YAML */, message, { input: value });
+  }
+}
 // ../core/src/utils/glob.ts
 var import_picomatch = __toESM(require_picomatch2(), 1);
+var globToRegex = (glob) => import_picomatch.default.makeRe(glob, { dot: false });
 function createPathMatcher(rules) {
   if (rules.include.length === 0)
     return () => false;
   const isIncluded = import_picomatch.default(rules.include, { dot: false });
   const isExcluded = rules.exclude.length > 0 ? import_picomatch.default(rules.exclude, { dot: false }) : () => false;
-  return (path) => isIncluded(path) && !isExcluded(path);
+  return (path2) => isIncluded(path2) && !isExcluded(path2);
+}
+function matchesPathFilter(path2, category, config) {
+  const section = config[category];
+  const include = section.include;
+  const exclude = "exclude" in section ? section.exclude : [];
+  if (include.length === 0)
+    return false;
+  const isIncluded = import_picomatch.default.isMatch(path2, include, { dot: false });
+  if (!isIncluded)
+    return false;
+  if (exclude.length > 0 && import_picomatch.default.isMatch(path2, exclude, { dot: false }))
+    return false;
+  return true;
 }
 // ../core/src/utils/version.ts
 var VERSION_LABEL_REGEX = /^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-(alpha|beta|rc)\.(0|[1-9]\d*))?$/i;
@@ -13169,7 +13818,38 @@ function encodeVersionLabel(label) {
   }
   return major * 1e6 + minor * 1e4 + patch * 100 + prerelease;
 }
+function isVersionVisible(record, versionCode) {
+  if (versionCode == null) {
+    return true;
+  }
+  return (record.valid_from == null || record.valid_from <= versionCode) && (record.valid_until == null || record.valid_until > versionCode);
+}
+// ../core/src/utils/factContent.ts
+var SEARCH_PREFIX_RE = /^\[c4a:search [^\]\n]+\]\n\n/;
+function buildSearchPrefix(keywords) {
+  if (!keywords || keywords.length === 0)
+    return "";
+  const cleaned = keywords.map((k) => k.trim()).filter((k) => k.length > 0);
+  if (cleaned.length === 0)
+    return "";
+  return `[c4a:search ${cleaned.join(" ")}]
+
+`;
+}
+function stripSearchPrefix(content) {
+  if (!content)
+    return content ?? "";
+  return content.replace(SEARCH_PREFIX_RE, "");
+}
 // ../core/src/constants.ts
+var DEFAULT_WORKSPACE_NAME = "My Brain";
+var DEFAULT_CLOUD_LIBRARY_NAME = "My Drive";
+var SUPERTEST_EMAIL = "supertest@context4ai.org";
+var SUPERTEST_USER_NAME = "SuperTest";
+var RESERVED_USER_NAMES = ["SuperTest"];
+var DAEMON_HEARTBEAT_INTERVAL = 30000;
+var DAEMON_OFFLINE_THRESHOLD = 60000;
+var CLOUD_DAEMON_IDLE_TIMEOUT = 300000;
 var SCAN_EXCLUDED_DIRS = new Set([
   ".git",
   ".svn",
@@ -13205,6 +13885,17 @@ var SCAN_EXCLUDED_DIRS = new Set([
   "fixtures",
   ".tmp"
 ]);
+var CODE_DIGEST_TYPE = "code_tc_b";
+var hasExcludedSegment = (filePath) => {
+  const segments = filePath.split("/");
+  for (let i = 0;i < segments.length - 1; i++) {
+    const seg = segments[i];
+    if (SCAN_EXCLUDED_DIRS.has(seg) || seg.startsWith(".") && seg !== "." || seg.endsWith(".egg-info")) {
+      return true;
+    }
+  }
+  return false;
+};
 // ../core/src/contentTypeRegistry.ts
 var DEFAULT_CONTENT_TYPES = [
   {
@@ -13218,7 +13909,15 @@ var DEFAULT_CONTENT_TYPES = [
   {
     id: "typescript",
     category: "code",
-    match: { extensions: [".ts", ".tsx"] },
+    match: { extensions: [".ts", ".tsx", ".mts", ".cts"] },
+    cas: { encoding: "utf8", hashInput: "content" },
+    pipeline: { digest: ["ast", "summary"], extraction: ["entities", "relations"] },
+    display: { icon: "\uD83D\uDCDC", renderer: "code" }
+  },
+  {
+    id: "javascript",
+    category: "code",
+    match: { extensions: [".js", ".jsx", ".mjs", ".cjs"] },
     cas: { encoding: "utf8", hashInput: "content" },
     pipeline: { digest: ["ast", "summary"], extraction: ["entities", "relations"] },
     display: { icon: "\uD83D\uDCDC", renderer: "code" }
@@ -13326,6 +14025,15 @@ var INDEXABLE_EXTENSIONS = new Set([
 var UPLOAD_ALLOWED_EXTENSIONS = collectExtensions(() => true);
 var TEXT_EXTENSIONS = collectExtensions((definition) => definition.cas.encoding === "utf8");
 var UPLOAD_MAX_FILE_SIZE = 5 * 1024 * 1024;
+var UPLOAD_MAX_FILES = 20;
+function getFileExtension(name) {
+  const dot = name.lastIndexOf(".");
+  return dot >= 0 ? name.slice(dot).toLowerCase() : "";
+}
+function isIndexableFile(fileName, manifestFiles) {
+  const baseName = fileName.includes("/") ? fileName.split("/").pop() : fileName;
+  return defaultRegistry.resolve(baseName) !== null;
+}
 // src/types.ts
 var symbolKindSchema2 = exports_external.enum(Object.values(SymbolKind));
 var visibilitySchema2 = exports_external.enum(Object.values(Visibility));
@@ -13385,6 +14093,23 @@ var fileInfoSchema = exports_external.object({
   language: exports_external.string().min(1),
   lines: exports_external.number().int().nonnegative()
 });
+var extractionDiagnosticSchema = exports_external.object({
+  code: exports_external.string().min(1),
+  severity: exports_external.enum(["info", "warning", "error"]),
+  file: exports_external.string().min(1),
+  line: exports_external.number().int().positive(),
+  column: exports_external.number().int().positive()
+});
+var extractionCoverageSchema = exports_external.object({
+  tier: exports_external.enum(["ast-catalog", "lightweight-evidence"]),
+  capabilities: exports_external.array(exports_external.string().min(1)),
+  files: exports_external.array(exports_external.object({
+    path: exports_external.string().min(1),
+    disposition: exports_external.enum(["analyzed", "unsupported", "excluded"]),
+    diagnosticCodes: exports_external.array(exports_external.string().min(1))
+  })),
+  diagnostics: exports_external.array(extractionDiagnosticSchema)
+});
 var extractionMetaSchema = exports_external.object({
   extractedAt: exports_external.string().datetime(),
   pluginId: exports_external.string().min(1),
@@ -13411,6 +14136,7 @@ var extractionResultSchema = exports_external.object({
   files: exports_external.array(fileInfoSchema),
   symbols: exports_external.array(symbolInfoSchema),
   relations: exports_external.array(relationInfoSchema),
+  coverage: extractionCoverageSchema.optional(),
   stats: extractionStatsSchema
 });
 var digestStatsSchema = exports_external.object({
@@ -13427,6 +14153,7 @@ var digestDataSchema = exports_external.object({
   files: exports_external.array(fileInfoSchema),
   symbols: exports_external.array(symbolInfoSchema),
   relations: exports_external.array(relationInfoSchema),
+  coverage: extractionCoverageSchema.optional(),
   stats: digestStatsSchema
 });
 var symbolDiffSchema = exports_external.object({
@@ -13548,6 +14275,7 @@ var generateDigest = (result) => {
     files: result.files,
     symbols: allSymbols,
     relations: result.relations,
+    ...result.coverage ? { coverage: result.coverage } : {},
     stats: {
       files: result.stats.files,
       lines: result.stats.lines,
@@ -13570,7 +14298,7 @@ var generateSymbolDiff = (current, previous) => {
 };
 // src/documentEvidence.ts
 import { Buffer as Buffer2 } from "node:buffer";
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 
 // src/documentCaptureFidelity.ts
 var DOCUMENT_RESOURCE_SOURCE_MISSING_REASON_CODE = "document.resource.source-missing";
@@ -13588,15 +14316,15 @@ function requiredString(value, field) {
   return value.trim();
 }
 function resourceAssetPath(value, field) {
-  const path2 = requiredString(value, field);
-  if (path2.startsWith("/") || path2.includes("\\") || path2.includes("\x00") || /^[a-zA-Z]:/u.test(path2)) {
+  const path3 = requiredString(value, field);
+  if (path3.startsWith("/") || path3.includes("\\") || path3.includes("\x00") || /^[a-zA-Z]:/u.test(path3)) {
     throw new TypeError(`${field} must be a POSIX relative path`);
   }
-  const segments = path2.split("/");
+  const segments = path3.split("/");
   if (segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
     throw new TypeError(`${field} must not contain empty, dot, or parent segments`);
   }
-  return path2;
+  return path3;
 }
 function counts(value, field) {
   if (!isRecord(value))
@@ -13713,7 +14441,7 @@ function parseDocumentResourceMaterialization(value, field) {
     if (item.status !== "materialized" && item.status !== "reference-only" && item.status !== "failed") {
       throw new TypeError(`${field}.items[${index}].status is invalid`);
     }
-    if (typeof item.required !== "boolean" || !Array.isArray(item.asset_paths) || item.asset_paths.some((path2) => typeof path2 !== "string" || path2.trim().length === 0)) {
+    if (typeof item.required !== "boolean" || !Array.isArray(item.asset_paths) || item.asset_paths.some((path3) => typeof path3 !== "string" || path3.trim().length === 0)) {
       throw new TypeError(`${field}.items[${index}] must include required and asset_paths`);
     }
     const reasonCode = item.reason_code === undefined ? undefined : requiredString(item.reason_code, `${field}.items[${index}].reason_code`);
@@ -13723,7 +14451,7 @@ function parseDocumentResourceMaterialization(value, field) {
       locator: requiredString(item.locator, `${field}.items[${index}].locator`),
       status: item.status,
       required: item.required,
-      asset_paths: item.asset_paths.map((path2, pathIndex) => resourceAssetPath(path2, `${field}.items[${index}].asset_paths[${pathIndex}]`)),
+      asset_paths: item.asset_paths.map((path3, pathIndex) => resourceAssetPath(path3, `${field}.items[${index}].asset_paths[${pathIndex}]`)),
       ...reasonCode !== undefined ? { reason_code: reasonCode } : {},
       ...reason !== undefined ? { reason } : {}
     };
@@ -13768,7 +14496,7 @@ function bytesOf(value) {
   return typeof value === "string" ? Buffer2.from(value, "utf8") : Buffer2.from(value);
 }
 function sha256Hex(value) {
-  return createHash2("sha256").update(bytesOf(value)).digest("hex");
+  return createHash4("sha256").update(bytesOf(value)).digest("hex");
 }
 function normalizeHashId(value) {
   const trimmed = value.trim().toLowerCase();
@@ -13802,29 +14530,29 @@ function normalizeDocumentSourceName(name) {
   }
   return value;
 }
-function normalizeSnapshotRelativePath(path2) {
-  const value = path2.trim();
+function normalizeSnapshotRelativePath(path3) {
+  const value = path3.trim();
   if (value.length === 0 || value.includes("\x00") || value.startsWith("/") || /^[a-zA-Z]:[\\/]/u.test(value)) {
-    throw new TypeError(`snapshot path must be a POSIX relative path: ${path2}`);
+    throw new TypeError(`snapshot path must be a POSIX relative path: ${path3}`);
   }
   if (value.includes("\\")) {
-    throw new TypeError(`snapshot path must use POSIX separators: ${path2}`);
+    throw new TypeError(`snapshot path must use POSIX separators: ${path3}`);
   }
   const segments = value.split("/");
   if (segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
-    throw new TypeError(`snapshot path must not contain empty, dot, or traversal segments: ${path2}`);
+    throw new TypeError(`snapshot path must not contain empty, dot, or traversal segments: ${path3}`);
   }
   return value;
 }
-function encodeSnapshotLocatorPath(path2) {
-  return normalizeSnapshotRelativePath(path2).split("/").map((segment) => encodeURIComponent(segment)).join("/");
+function encodeSnapshotLocatorPath(path3) {
+  return normalizeSnapshotRelativePath(path3).split("/").map((segment) => encodeURIComponent(segment)).join("/");
 }
-function decodeSnapshotLocatorPath(path2) {
+function decodeSnapshotLocatorPath(path3) {
   try {
-    return normalizeSnapshotRelativePath(path2.split("/").map((segment) => decodeURIComponent(segment)).join("/"));
+    return normalizeSnapshotRelativePath(path3.split("/").map((segment) => decodeURIComponent(segment)).join("/"));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    throw new TypeError(`invalid encoded snapshot locator path: ${path2}: ${message}`);
+    throw new TypeError(`invalid encoded snapshot locator path: ${path3}: ${message}`);
   }
 }
 function parseDocumentSourceLocator(source) {
@@ -13886,7 +14614,7 @@ function countMarkdownLines(bytes) {
 `).length;
 }
 function computeLogicalRawHash(files) {
-  const hash2 = createHash2("sha256");
+  const hash2 = createHash4("sha256");
   const sorted = [...files].map((file) => ({
     path: normalizeSnapshotRelativePath(file.path),
     bytes: bytesOf(file.bytes)
@@ -14034,14 +14762,14 @@ function sourceSpanHashMatches(refHash, fullSpanHash) {
   return SOURCE_SPAN_HASH_RE.test(refHash) && /^[a-f0-9]{64}$/u.test(fullSpanHash) && fullSpanHash.startsWith(refHash);
 }
 function createDocumentSnapshotFileEntry(input) {
-  const path2 = normalizeSnapshotRelativePath(input.path);
+  const path3 = normalizeSnapshotRelativePath(input.path);
   const sourcePath = input.source_path === undefined ? undefined : normalizeSnapshotRelativePath(input.source_path);
   if ((input.title?.trim().length ?? 0) === 0 && (input.locator?.trim().length ?? 0) === 0) {
-    throw new TypeError(`snapshot file "${path2}" must include title or locator`);
+    throw new TypeError(`snapshot file "${path3}" must include title or locator`);
   }
   return {
-    path: path2,
-    ...sourcePath !== undefined && sourcePath !== path2 ? { source_path: sourcePath } : {},
+    path: path3,
+    ...sourcePath !== undefined && sourcePath !== path3 ? { source_path: sourcePath } : {},
     content_hash: computeDocumentContentHash(input.bytes),
     line_count: countMarkdownLines(input.bytes),
     ...input.title !== undefined ? { title: input.title.trim() } : {},
@@ -14169,13 +14897,13 @@ function optionalRouteFiles(value, field) {
     if (!isRecord2(item)) {
       throw new TypeError(`${field}[${index}] must be an object`);
     }
-    const path2 = optionalMetadataString(item.path, `${field}[${index}].path`);
-    if (path2 === undefined) {
+    const path3 = optionalMetadataString(item.path, `${field}[${index}].path`);
+    if (path3 === undefined) {
       throw new TypeError(`${field}[${index}].path must be a non-empty string`);
     }
     const routes = optionalMetadataStringArray(item.routes, `${field}[${index}].routes`) ?? [];
     return {
-      path: normalizeSnapshotRelativePath(path2),
+      path: normalizeSnapshotRelativePath(path3),
       routes
     };
   }).filter((item) => item.routes.length > 0);
@@ -14210,8 +14938,8 @@ function captureReportMetadata(value) {
     return;
   if (!isRecord2(value))
     throw new TypeError("snapshot manifest metadata.capture.report must be an object");
-  const path2 = optionalMetadataString(value.path, "snapshot manifest metadata.capture.report.path");
-  if (path2 === undefined)
+  const path3 = optionalMetadataString(value.path, "snapshot manifest metadata.capture.report.path");
+  if (path3 === undefined)
     throw new TypeError("snapshot manifest metadata.capture.report.path is required");
   const fidelityStatus = value.fidelityStatus;
   const evidenceStatus = value.evidenceStatus;
@@ -14230,7 +14958,7 @@ function captureReportMetadata(value) {
     throw new TypeError("snapshot manifest metadata.capture.report.resourceStatus is invalid");
   }
   return {
-    path: normalizeSnapshotRelativePath(path2),
+    path: normalizeSnapshotRelativePath(path3),
     fidelityStatus,
     evidenceStatus,
     projectionStatus,
@@ -14345,7 +15073,7 @@ function parseDocumentSnapshotManifest(value) {
 }
 // src/repository.ts
 import { readFile as readFile2, readdir as readdir2, stat } from "node:fs/promises";
-import path2 from "node:path";
+import path3 from "node:path";
 
 // src/scanner.ts
 import { execFile } from "node:child_process";
@@ -14355,11 +15083,20 @@ import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
 var isScanExcludedDir = (name) => SCAN_EXCLUDED_DIRS.has(name) || name.startsWith(".") && name !== "." || name.endsWith(".egg-info");
 var DEFAULT_EXCLUDED_FILE_PATTERNS = [
-  /\.test\.tsx?$/i,
-  /\.spec\.tsx?$/i,
-  /\.d\.ts$/i
+  /\.test\.(?:[cm]?[jt]sx?)$/i,
+  /\.spec\.(?:[cm]?[jt]sx?)$/i,
+  /\.d\.(?:ts|mts|cts)$/i
 ];
-var SUPPORTED_EXTENSIONS = new Set([".ts", ".tsx"]);
+var SUPPORTED_EXTENSIONS = new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs"
+]);
 var toPosixPath = (value) => value.split(sep).join("/");
 var shouldExcludeFile = (fileName) => DEFAULT_EXCLUDED_FILE_PATTERNS.some((pattern) => pattern.test(fileName));
 var isSupportedSourceFile = (fileName) => SUPPORTED_EXTENSIONS.has(extname(fileName));
@@ -14781,10 +15518,10 @@ class ExtractionInputError extends Error {
 // src/repository.ts
 var PACKAGE_JSON = "package.json";
 var GO_MOD = "go.mod";
-var toPosixPath2 = (value) => value.split(path2.sep).join("/");
+var toPosixPath2 = (value) => value.split(path3.sep).join("/");
 function safeSourceRelativePath(value) {
   const slashPath = value.trim().replace(/\\/gu, "/");
-  const normalized = path2.posix.normalize(slashPath).replace(/^\.\//u, "");
+  const normalized = path3.posix.normalize(slashPath).replace(/^\.\//u, "");
   if (normalized.length === 0 || normalized === "." || normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/") || /^[A-Za-z]:\//u.test(normalized)) {
     throw new Error(`Extraction entry must be a source-relative file path: ${value}`);
   }
@@ -14802,7 +15539,7 @@ function moduleRelativeEntryPath(modulePath, sourcePath) {
 function entrySubpath(filePath, index) {
   if (index === 0)
     return ".";
-  const withoutExtension = filePath.replace(/\.(?:d\.)?(?:ts|tsx|mts|cts|go)$/u, "");
+  const withoutExtension = filePath.replace(/\.(?:d\.)?(?:ts|tsx|mts|cts|js|jsx|mjs|cjs|go)$/u, "");
   return `./${withoutExtension}`;
 }
 function selectedEntryFiles(input) {
@@ -14848,11 +15585,11 @@ var resolveRepoRelativePath = (modulePath, value) => {
     return normalizedValue;
   return `${normalizeRelativePath(modulePath)}/${normalizedValue}`;
 };
-var resolveModuleDir = (repoPath, modulePath) => modulePath === "." ? repoPath : path2.join(repoPath, modulePath);
+var resolveModuleDir = (repoPath, modulePath) => modulePath === "." ? repoPath : path3.join(repoPath, modulePath);
 var resolveModuleFsPath = (moduleDir, filePath) => {
-  const candidate = path2.isAbsolute(filePath) ? filePath : path2.resolve(moduleDir, filePath);
-  const relativePath = path2.relative(moduleDir, candidate);
-  if (relativePath.startsWith("..") || path2.isAbsolute(relativePath)) {
+  const candidate = path3.isAbsolute(filePath) ? filePath : path3.resolve(moduleDir, filePath);
+  const relativePath = path3.relative(moduleDir, candidate);
+  if (relativePath.startsWith("..") || path3.isAbsolute(relativePath)) {
     throw new Error(`Path escapes module root: ${filePath}`);
   }
   return candidate;
@@ -14932,7 +15669,20 @@ var prefixExtractionPaths = (extraction, modulePath, commitHash) => ({
     ...file,
     path: resolveRepoRelativePath(modulePath, file.path)
   })),
-  symbols: extraction.symbols.map((symbol) => prefixSymbolPaths(symbol, modulePath))
+  symbols: extraction.symbols.map((symbol) => prefixSymbolPaths(symbol, modulePath)),
+  ...extraction.coverage ? {
+    coverage: {
+      ...extraction.coverage,
+      files: extraction.coverage.files.map((file) => ({
+        ...file,
+        path: resolveRepoRelativePath(modulePath, file.path)
+      })),
+      diagnostics: extraction.coverage.diagnostics.map((diagnostic) => ({
+        ...diagnostic,
+        file: resolveRepoRelativePath(modulePath, diagnostic.file)
+      }))
+    }
+  } : {}
 });
 var normalizeExtractionPaths = (extraction, entryDetection, modulePath, commitHash) => ({
   entryDetection: prefixEntryDetectionPaths(entryDetection, modulePath),
@@ -14984,7 +15734,7 @@ var resolveRequestedModules = async (repoPath, modulePaths, ref, pathFilter2) =>
   return { modules, moduleErrors };
 };
 var runRepositoryExtraction = async (input) => {
-  const repoPath = path2.resolve(input.repoPath);
+  const repoPath = path3.resolve(input.repoPath);
   input.onProgress?.({ phase: "scanning", progress: 0, message: "detecting modules" });
   const { modules, moduleErrors } = await resolveRequestedModules(repoPath, input.modules, input.ref, input.pathFilter);
   const registry = new ExtractionPluginRegistry;
@@ -15367,7 +16117,7 @@ var buildCodeSnapshot = (input) => {
 // src/runner.ts
 import { readFile as readFile3 } from "node:fs/promises";
 import { createRequire as createRequire2 } from "node:module";
-import path3 from "node:path";
+import path4 from "node:path";
 import { pathToFileURL } from "node:url";
 var pluginSpecSchema = exports_external.object({
   package: exports_external.string().min(1),
@@ -15418,9 +16168,9 @@ var isPlugin = (value) => {
 var resolvePluginModule = (packageName, cwd) => {
   if (packageName.startsWith(".") || packageName.startsWith("/") || packageName.startsWith("file:")) {
     const filePath = packageName.startsWith("file:") ? packageName.slice("file:".length) : packageName;
-    return path3.resolve(cwd, filePath);
+    return path4.resolve(cwd, filePath);
   }
-  const require2 = createRequire2(path3.join(cwd, "package.json"));
+  const require2 = createRequire2(path4.join(cwd, "package.json"));
   return require2.resolve(packageName);
 };
 var loadRunnerPlugins = async (pluginSpecs, cwd = process.cwd()) => {
@@ -15490,11 +16240,15 @@ var runCodeExtractCli = async () => {
     const input = stdin.trim() ? JSON.parse(stdin) : {};
     const events = await runCodeExtractRunner(input);
     for (const event of events) {
-      process.stdout.write(JSON.stringify(event) + `
+      const filtered = redactIndexerOutput({ channel: "stdout", value: event });
+      process.stdout.write(JSON.stringify(filtered.value) + `
 `);
     }
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+    const message = redactIndexerOutputText({
+      channel: "exception-message",
+      value: error instanceof Error ? error.message : String(error)
+    });
     process.stdout.write(JSON.stringify({ type: "error", code: "runner-failed", message }) + `
 `);
     process.exitCode = 1;
@@ -15502,64 +16256,2805 @@ var runCodeExtractCli = async () => {
 };
 var runCodeExtractCliFromFile = async (inputFile) => {
   const content = await readFile3(inputFile, "utf-8");
-  return runCodeExtractRunner(JSON.parse(content), path3.dirname(path3.resolve(inputFile)));
-};
-// src/parser.ts
-import Parser from "web-tree-sitter";
-import { existsSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-var parserInitPromise = null;
-var parsedBytesSinceReset = 0;
-var parserDead = false;
-var PARSER_RESET_THRESHOLD = 16 * 1024 * 1024;
-var resolveWasmPath = (relativePath) => fileURLToPath(new URL(relativePath, import.meta.url));
-var createParserInstance = async () => {
-  const localWasm = resolveWasmPath("./wasm/tree-sitter.wasm");
-  const initOptions = existsSync(localWasm) ? { locateFile: (scriptName) => resolveWasmPath(`./wasm/${scriptName}`) } : undefined;
-  await Parser.init(initOptions);
-  const parser = new Parser;
-  const tsLanguage = await Parser.Language.load(resolveWasmPath("./wasm/tree-sitter-typescript.wasm"));
-  const tsxLanguage = await Parser.Language.load(resolveWasmPath("./wasm/tree-sitter-tsx.wasm"));
-  return { parser, tsLanguage, tsxLanguage };
-};
-var initParser = async () => {
-  if (!parserInitPromise) {
-    parserInitPromise = (async () => {
-      try {
-        parsedBytesSinceReset = 0;
-        return await createParserInstance();
-      } catch (error) {
-        parserInitPromise = null;
-        throw error;
-      }
-    })();
-  }
-  return parserInitPromise;
-};
-var resetParser = () => {
-  parserInitPromise = null;
-  parsedBytesSinceReset = 0;
-  parserDead = false;
+  return runCodeExtractRunner(JSON.parse(content), path4.dirname(path4.resolve(inputFile)));
 };
-var tryParse = async (source, isTsx) => {
-  const { parser, tsLanguage, tsxLanguage } = await initParser();
-  parser.setLanguage(isTsx ? tsxLanguage : tsLanguage);
-  const tree = parser.parse(source);
-  parsedBytesSinceReset += source.length;
-  if (tree.rootNode.hasError()) {
-    return null;
+// src/evidenceAdapter.ts
+function fact2(input) {
+  return createIndexerEvidenceAdapterFact({
+    source_ref: input.sourceRef,
+    module_ref: input.moduleRef,
+    normalized_path: input.normalizedPath,
+    qualified_item_path: input.qualifiedItemPath,
+    kind: input.kind,
+    signature: input.signature,
+    payload: input.payload,
+    denominator: input.denominator
+  });
+}
+function semanticExtractionPayload(extraction) {
+  return {
+    version: extraction.version,
+    meta: {
+      pluginId: extraction.meta.pluginId,
+      commitHash: extraction.meta.commitHash,
+      language: extraction.meta.language
+    },
+    package: extraction.package,
+    files: extraction.files,
+    symbols: extraction.symbols,
+    relations: extraction.relations,
+    coverage: extraction.coverage,
+    stats: extraction.stats
+  };
+}
+function relationSourceFile(relation, symbols) {
+  const candidates = symbols.filter((symbol) => symbol.name === relation.from);
+  if (candidates.length === 1)
+    return candidates[0].file;
+  if (relation.line !== undefined) {
+    const containing = candidates.filter((symbol) => symbol.line <= relation.line && symbol.endLine >= relation.line);
+    if (containing.length === 1)
+      return containing[0].file;
   }
-  return tree;
-};
-var parseFile = async (source, isTsx) => {
-  if (parserDead)
-    return null;
-  if (parsedBytesSinceReset > PARSER_RESET_THRESHOLD) {
-    resetParser();
+  return null;
+}
+function diagnosticPayload(diagnostic) {
+  return {
+    code: diagnostic.code,
+    severity: diagnostic.severity,
+    file: diagnostic.file,
+    line: diagnostic.line,
+    column: diagnostic.column
+  };
+}
+function extractionResultToEvidenceAdapterResult(extraction, invocation) {
+  const coverage = extraction.coverage;
+  if (!coverage) {
+    throw new TypeError("ExtractionResult coverage is required for Evidence Adapter Result conversion");
+  }
+  if (coverage.capabilities.length === 0) {
+    throw new TypeError("ExtractionResult coverage must declare at least one parser capability");
+  }
+  const coverageByPath = new Map(coverage.files.map((file) => [file.path, file]));
+  const fileInfoByPath = new Map(extraction.files.map((file) => [file.path, file]));
+  for (const file of extraction.files) {
+    if (!coverageByPath.has(file.path)) {
+      throw new TypeError(`ExtractionResult file ${file.path} has no coverage disposition`);
+    }
+  }
+  for (const symbol of extraction.symbols) {
+    const disposition = coverageByPath.get(symbol.file)?.disposition;
+    if (disposition !== "analyzed") {
+      throw new TypeError(`ExtractionResult symbol ${symbol.name} belongs to a file without analyzed disposition`);
+    }
+  }
+  const role = invocation.role ?? "primary-owner";
+  const ownsDenominators = role === "primary-owner" && coverage.tier === "ast-catalog";
+  const generatedDiagnostics = [];
+  const relationsByFile = new Map;
+  for (const relation of extraction.relations) {
+    const file = relationSourceFile(relation, extraction.symbols);
+    if (file === null || coverageByPath.get(file)?.disposition !== "analyzed") {
+      generatedDiagnostics.push({
+        code: "relation-locator-unresolved",
+        severity: "warning",
+        detail_digest: indexerEvidenceAdapterProtocolDigest(relation)
+      });
+      continue;
+    }
+    const current = relationsByFile.get(file) ?? [];
+    current.push(relation);
+    relationsByFile.set(file, current);
   }
-  try {
-    return await tryParse(source, isTsx);
-  } catch {
+  const files = coverage.files.map((coverageFile) => {
+    const normalizedPath = coverageFile.path;
+    const fileRef = indexerEvidenceAdapterFileRef({
+      source_ref: invocation.authorized_scope.source_ref,
+      module_ref: invocation.module_ref,
+      normalized_path: normalizedPath
+    });
+    const fileInfo = fileInfoByPath.get(normalizedPath);
+    if (coverageFile.disposition === "analyzed" && !fileInfo) {
+      throw new TypeError(`Analyzed file ${normalizedPath} has no ExtractionResult file metadata`);
+    }
+    const facts = [];
+    if (coverageFile.disposition === "analyzed" && fileInfo) {
+      facts.push(fact2({
+        sourceRef: invocation.authorized_scope.source_ref,
+        moduleRef: invocation.module_ref,
+        normalizedPath,
+        qualifiedItemPath: "file",
+        kind: "source-file",
+        signature: { path: normalizedPath, language: fileInfo.language },
+        payload: fileInfo,
+        denominator: ownsDenominators ? "eligible-file" : "none"
+      }));
+      facts.push(fact2({
+        sourceRef: invocation.authorized_scope.source_ref,
+        moduleRef: invocation.module_ref,
+        normalizedPath,
+        qualifiedItemPath: "loc",
+        kind: "source-loc",
+        signature: { path: normalizedPath },
+        payload: { lines: fileInfo.lines },
+        denominator: ownsDenominators ? "loc" : "none"
+      }));
+      for (const symbol of extraction.symbols.filter((item) => item.file === normalizedPath)) {
+        facts.push(fact2({
+          sourceRef: invocation.authorized_scope.source_ref,
+          moduleRef: invocation.module_ref,
+          normalizedPath,
+          qualifiedItemPath: `symbol:${symbol.kind}:${symbol.name}@${symbol.line}`,
+          kind: "code-symbol",
+          signature: {
+            name: symbol.name,
+            kind: symbol.kind,
+            signature: symbol.signature ?? null,
+            params: symbol.params ?? null,
+            returnType: symbol.returnType ?? null,
+            typeAnnotation: symbol.typeAnnotation ?? null
+          },
+          payload: symbol,
+          denominator: ownsDenominators ? "symbol" : "none"
+        }));
+      }
+      for (const relation of relationsByFile.get(normalizedPath) ?? []) {
+        facts.push(fact2({
+          sourceRef: invocation.authorized_scope.source_ref,
+          moduleRef: invocation.module_ref,
+          normalizedPath,
+          qualifiedItemPath: `relation:${relation.type}:${relation.from}->${relation.to}@${relation.line ?? 0}`,
+          kind: "code-relation",
+          signature: relation,
+          payload: relation,
+          denominator: "none"
+        }));
+      }
+    }
+    return {
+      file_ref: fileRef,
+      source_ref: invocation.authorized_scope.source_ref,
+      module_ref: invocation.module_ref,
+      normalized_path: normalizedPath,
+      role,
+      coverage_tier: coverage.tier,
+      disposition: coverageFile.disposition,
+      facts
+    };
+  });
+  const diagnostics = [
+    ...coverage.diagnostics.map((diagnostic) => {
+      const coverageFile = coverageByPath.get(diagnostic.file);
+      const fileRef = coverageFile ? indexerEvidenceAdapterFileRef({
+        source_ref: invocation.authorized_scope.source_ref,
+        module_ref: invocation.module_ref,
+        normalized_path: diagnostic.file
+      }) : undefined;
+      return {
+        code: diagnostic.code,
+        severity: diagnostic.severity,
+        detail_digest: indexerEvidenceAdapterProtocolDigest(diagnosticPayload(diagnostic)),
+        ...fileRef ? { fact_ref: fileRef } : {}
+      };
+    }),
+    ...generatedDiagnostics
+  ];
+  const parserOutputDigest = indexerEvidenceAdapterProtocolDigest(semanticExtractionPayload(extraction));
+  return buildIndexerEvidenceAdapterResult({
+    protocol: "context.indexer.evidence-adapter-result/v1",
+    adapter: invocation.adapter,
+    authorized_scope: invocation.authorized_scope,
+    input_digest: invocation.input_digest,
+    precedence: invocation.precedence,
+    files,
+    diagnostics,
+    toolchain: [{
+      step: "parse-source",
+      package: invocation.adapter.package,
+      export: invocation.adapter.export,
+      version: invocation.adapter.version,
+      digest: invocation.adapter.digest,
+      capabilities: coverage.capabilities,
+      input_digest: invocation.input_digest,
+      output_digest: parserOutputDigest
+    }]
+  });
+}
+function extractionResultToEvidenceAdapterMaterialization(extraction, invocation) {
+  return materializeIndexerEvidenceAdapterResult(extractionResultToEvidenceAdapterResult(extraction, invocation));
+}
+// ../../node_modules/.bun/eslint-visitor-keys@5.0.1/node_modules/eslint-visitor-keys/lib/visitor-keys.js
+var KEYS = {
+  ArrayExpression: ["elements"],
+  ArrayPattern: ["elements"],
+  ArrowFunctionExpression: ["params", "body"],
+  AssignmentExpression: ["left", "right"],
+  AssignmentPattern: ["left", "right"],
+  AwaitExpression: ["argument"],
+  BinaryExpression: ["left", "right"],
+  BlockStatement: ["body"],
+  BreakStatement: ["label"],
+  CallExpression: ["callee", "arguments"],
+  CatchClause: ["param", "body"],
+  ChainExpression: ["expression"],
+  ClassBody: ["body"],
+  ClassDeclaration: ["id", "superClass", "body"],
+  ClassExpression: ["id", "superClass", "body"],
+  ConditionalExpression: ["test", "consequent", "alternate"],
+  ContinueStatement: ["label"],
+  DebuggerStatement: [],
+  DoWhileStatement: ["body", "test"],
+  EmptyStatement: [],
+  ExperimentalRestProperty: ["argument"],
+  ExperimentalSpreadProperty: ["argument"],
+  ExportAllDeclaration: ["exported", "source", "attributes"],
+  ExportDefaultDeclaration: ["declaration"],
+  ExportNamedDeclaration: [
+    "declaration",
+    "specifiers",
+    "source",
+    "attributes"
+  ],
+  ExportSpecifier: ["local", "exported"],
+  ExpressionStatement: ["expression"],
+  ForInStatement: ["left", "right", "body"],
+  ForOfStatement: ["left", "right", "body"],
+  ForStatement: ["init", "test", "update", "body"],
+  FunctionDeclaration: ["id", "params", "body"],
+  FunctionExpression: ["id", "params", "body"],
+  Identifier: [],
+  IfStatement: ["test", "consequent", "alternate"],
+  ImportAttribute: ["key", "value"],
+  ImportDeclaration: ["specifiers", "source", "attributes"],
+  ImportDefaultSpecifier: ["local"],
+  ImportExpression: ["source", "options"],
+  ImportNamespaceSpecifier: ["local"],
+  ImportSpecifier: ["imported", "local"],
+  JSXAttribute: ["name", "value"],
+  JSXClosingElement: ["name"],
+  JSXClosingFragment: [],
+  JSXElement: ["openingElement", "children", "closingElement"],
+  JSXEmptyExpression: [],
+  JSXExpressionContainer: ["expression"],
+  JSXFragment: ["openingFragment", "children", "closingFragment"],
+  JSXIdentifier: [],
+  JSXMemberExpression: ["object", "property"],
+  JSXNamespacedName: ["namespace", "name"],
+  JSXOpeningElement: ["name", "attributes"],
+  JSXOpeningFragment: [],
+  JSXSpreadAttribute: ["argument"],
+  JSXSpreadChild: ["expression"],
+  JSXText: [],
+  LabeledStatement: ["label", "body"],
+  Literal: [],
+  LogicalExpression: ["left", "right"],
+  MemberExpression: ["object", "property"],
+  MetaProperty: ["meta", "property"],
+  MethodDefinition: ["key", "value"],
+  NewExpression: ["callee", "arguments"],
+  ObjectExpression: ["properties"],
+  ObjectPattern: ["properties"],
+  PrivateIdentifier: [],
+  Program: ["body"],
+  Property: ["key", "value"],
+  PropertyDefinition: ["key", "value"],
+  RestElement: ["argument"],
+  ReturnStatement: ["argument"],
+  SequenceExpression: ["expressions"],
+  SpreadElement: ["argument"],
+  StaticBlock: ["body"],
+  Super: [],
+  SwitchCase: ["test", "consequent"],
+  SwitchStatement: ["discriminant", "cases"],
+  TaggedTemplateExpression: ["tag", "quasi"],
+  TemplateElement: [],
+  TemplateLiteral: ["quasis", "expressions"],
+  ThisExpression: [],
+  ThrowStatement: ["argument"],
+  TryStatement: ["block", "handler", "finalizer"],
+  UnaryExpression: ["argument"],
+  UpdateExpression: ["argument"],
+  VariableDeclaration: ["declarations"],
+  VariableDeclarator: ["id", "init"],
+  WhileStatement: ["test", "body"],
+  WithStatement: ["object", "body"],
+  YieldExpression: ["argument"]
+};
+var NODE_TYPES = Object.keys(KEYS);
+for (const type of NODE_TYPES) {
+  Object.freeze(KEYS[type]);
+}
+Object.freeze(KEYS);
+var visitor_keys_default = KEYS;
+
+// ../../node_modules/.bun/eslint-visitor-keys@5.0.1/node_modules/eslint-visitor-keys/lib/index.js
+var KEY_BLACKLIST = new Set([
+  "parent",
+  "leadingComments",
+  "trailingComments"
+]);
+function unionWith(additionalKeys) {
+  const retv = Object.assign({}, visitor_keys_default);
+  for (const type of Object.keys(additionalKeys)) {
+    if (Object.hasOwn(retv, type)) {
+      const keys = new Set(additionalKeys[type]);
+      for (const key of retv[type]) {
+        keys.add(key);
+      }
+      retv[type] = Object.freeze(Array.from(keys));
+    } else {
+      retv[type] = Object.freeze(Array.from(additionalKeys[type]));
+    }
+  }
+  return Object.freeze(retv);
+}
+
+// ../../node_modules/.bun/toml-eslint-parser@1.0.3/node_modules/toml-eslint-parser/lib/index.mjs
+function last(arr) {
+  return arr[arr.length - 1] ?? null;
+}
+function toKeyName(node2) {
+  return node2.type === "TOMLBare" ? node2.name : node2.value;
+}
+var TOMLVerImpl = class {
+  constructor(major, minor) {
+    this.major = major;
+    this.minor = minor;
+  }
+  lt(major, minor) {
+    return this.major < major || this.major === major && this.minor < minor;
+  }
+  gte(major, minor) {
+    return this.major > major || this.major === major && this.minor >= minor;
+  }
+};
+var TOML_VERSION_1_0 = new TOMLVerImpl(1, 0);
+var TOML_VERSION_1_1 = new TOMLVerImpl(1, 1);
+var DEFAULT_TOML_VERSION = TOML_VERSION_1_1;
+var SUPPORTED_TOML_VERSIONS = {
+  "1.0": TOML_VERSION_1_0,
+  "1.0.0": TOML_VERSION_1_0,
+  "1.1": TOML_VERSION_1_1,
+  "1.1.0": TOML_VERSION_1_1,
+  latest: TOML_VERSION_1_1,
+  next: TOML_VERSION_1_1
+};
+function getTOMLVer(v) {
+  return v && SUPPORTED_TOML_VERSIONS[v] || DEFAULT_TOML_VERSION;
+}
+var MESSAGES = {
+  "unterminated-string": "Unterminated string constant",
+  "unterminated-table-key": "Unterminated table-key",
+  "unterminated-array": "Unterminated array",
+  "unterminated-inline-table": "Unterminated inline table",
+  "missing-key": "Empty bare keys are not allowed",
+  "missing-newline": "Must be a newline",
+  "missing-equals-sign": "Expected equal (=) token",
+  "missing-value": "Unspecified values are invalid",
+  "missing-comma": "Expected comma (,) token",
+  "dupe-keys": "Defining a key multiple times is invalid",
+  "unexpected-char": "Unexpected character",
+  "unexpected-token": "Unexpected token",
+  "invalid-control-character": "Control characters (codes < 0x1f and 0x7f) are not allowed",
+  "invalid-comment-character": "Invalid code point {{cp}} within comments",
+  "invalid-key-value-newline": "The key, equals sign, and value must be on the same line",
+  "invalid-inline-table-newline": "No newlines are allowed between the curly braces unless they are valid within a value",
+  "invalid-underscore": "Underscores are allowed between digits",
+  "invalid-space": "Unexpected spaces",
+  "invalid-three-quotes": "Three or more quotes are not permitted",
+  "invalid-date": "Unexpected invalid date",
+  "invalid-time": "Unexpected invalid time",
+  "invalid-leading-zero": "Leading zeros are not allowed",
+  "invalid-trailing-comma-in-inline-table": "Trailing comma is not permitted in an inline table",
+  "invalid-char-in-escape-sequence": "Invalid character in escape sequence",
+  "invalid-consecutive-dots-in-key": "Consecutive dots are not permitted in keys",
+  "invalid-code-point": "Invalid code point {{cp}}",
+  "invalid-trailing-dot-in-key": "Keys cannot end with a dot",
+  "invalid-leading-dot-in-key": "Keys cannot start with a dot"
+};
+function getMessage(code, data) {
+  if (data)
+    return MESSAGES[code].replace(/\{\{(.*?)\}\}/gu, (_, name$2) => {
+      if (name$2 in data)
+        return data[name$2];
+      return `{{${name$2}}}`;
+    });
+  return MESSAGES[code];
+}
+var ParseError = class extends SyntaxError {
+  constructor(code, offset, line, column, data) {
+    super(getMessage(code, data));
+    this.index = offset;
+    this.lineNumber = line;
+    this.column = column;
+  }
+};
+var CodePoint = {
+  EOF: -1,
+  NULL: 0,
+  SOH: 1,
+  BACKSPACE: 8,
+  TABULATION: 9,
+  LINE_FEED: 10,
+  FORM_FEED: 12,
+  CARRIAGE_RETURN: 13,
+  ESCAPE: 27,
+  SO: 14,
+  US: 31,
+  SPACE: 32,
+  QUOTATION_MARK: 34,
+  HASH: 35,
+  SINGLE_QUOTE: 39,
+  PLUS_SIGN: 43,
+  COMMA: 44,
+  DASH: 45,
+  DOT: 46,
+  DIGIT_0: 48,
+  DIGIT_1: 49,
+  DIGIT_2: 50,
+  DIGIT_3: 51,
+  DIGIT_7: 55,
+  DIGIT_9: 57,
+  COLON: 58,
+  EQUALS_SIGN: 61,
+  LATIN_CAPITAL_A: 65,
+  LATIN_CAPITAL_E: 69,
+  LATIN_CAPITAL_F: 70,
+  LATIN_CAPITAL_T: 84,
+  LATIN_CAPITAL_U: 85,
+  LATIN_CAPITAL_Z: 90,
+  LEFT_BRACKET: 91,
+  BACKSLASH: 92,
+  RIGHT_BRACKET: 93,
+  UNDERSCORE: 95,
+  LATIN_SMALL_A: 97,
+  LATIN_SMALL_B: 98,
+  LATIN_SMALL_E: 101,
+  LATIN_SMALL_F: 102,
+  LATIN_SMALL_I: 105,
+  LATIN_SMALL_L: 108,
+  LATIN_SMALL_N: 110,
+  LATIN_SMALL_O: 111,
+  LATIN_SMALL_R: 114,
+  LATIN_SMALL_S: 115,
+  LATIN_SMALL_T: 116,
+  LATIN_SMALL_U: 117,
+  LATIN_SMALL_X: 120,
+  LATIN_SMALL_Z: 122,
+  LEFT_BRACE: 123,
+  RIGHT_BRACE: 125,
+  TILDE: 126,
+  DELETE: 127,
+  PAD: 128,
+  SUPERSCRIPT_TWO: 178,
+  SUPERSCRIPT_THREE: 179,
+  SUPERSCRIPT_ONE: 185,
+  VULGAR_FRACTION_ONE_QUARTER: 188,
+  VULGAR_FRACTION_THREE_QUARTERS: 190,
+  LATIN_CAPITAL_LETTER_A_WITH_GRAVE: 192,
+  LATIN_CAPITAL_LETTER_O_WITH_DIAERESIS: 214,
+  LATIN_CAPITAL_LETTER_O_WITH_STROKE: 216,
+  LATIN_SMALL_LETTER_O_WITH_DIAERESIS: 246,
+  LATIN_SMALL_LETTER_O_WITH_STROKE: 248,
+  GREEK_SMALL_REVERSED_DOTTED_LUNATE_SIGMA_SYMBOL: 891,
+  GREEK_CAPITAL_LETTER_YOT: 895,
+  CP_1FFF: 8191,
+  ZERO_WIDTH_NON_JOINER: 8204,
+  ZERO_WIDTH_JOINER: 8205,
+  UNDERTIE: 8255,
+  CHARACTER_TIE: 8256,
+  SUPERSCRIPT_ZERO: 8304,
+  CP_218F: 8591,
+  CIRCLED_DIGIT_ONE: 9312,
+  NEGATIVE_CIRCLED_DIGIT_ZERO: 9471,
+  GLAGOLITIC_CAPITAL_LETTER_AZU: 11264,
+  CP_2FEF: 12271,
+  IDEOGRAPHIC_COMMA: 12289,
+  CP_D7FF: 55295,
+  CP_E000: 57344,
+  CJK_COMPATIBILITY_IDEOGRAPH_F900: 63744,
+  ARABIC_LIGATURE_SALAAMUHU_ALAYNAA: 64975,
+  ARABIC_LIGATURE_SALLA_USED_AS_KORANIC_STOP_SIGN_ISOLATED_FORM: 65008,
+  REPLACEMENT_CHARACTER: 65533,
+  LINEAR_B_SYLLABLE_B008_A: 65536,
+  CP_EFFFF: 983039,
+  CP_10FFFF: 1114111
+};
+function isControl(cp) {
+  return cp >= CodePoint.NULL && cp <= CodePoint.US;
+}
+function isWhitespace(cp) {
+  return cp === CodePoint.TABULATION || cp === CodePoint.SPACE;
+}
+function isEOL(cp) {
+  return cp === CodePoint.LINE_FEED || cp === CodePoint.CARRIAGE_RETURN;
+}
+function isUpperLetter(cp) {
+  return cp >= CodePoint.LATIN_CAPITAL_A && cp <= CodePoint.LATIN_CAPITAL_Z;
+}
+function isLowerLetter(cp) {
+  return cp >= CodePoint.LATIN_SMALL_A && cp <= CodePoint.LATIN_SMALL_Z;
+}
+function isLetter(cp) {
+  return isLowerLetter(cp) || isUpperLetter(cp);
+}
+function isDigit(cp) {
+  return cp >= CodePoint.DIGIT_0 && cp <= CodePoint.DIGIT_9;
+}
+function isHexDig(cp) {
+  return isDigit(cp) || cp >= CodePoint.LATIN_SMALL_A && cp <= CodePoint.LATIN_SMALL_F || cp >= CodePoint.LATIN_CAPITAL_A && cp <= CodePoint.LATIN_CAPITAL_F;
+}
+function isOctalDig(cp) {
+  return cp >= CodePoint.DIGIT_0 && cp <= CodePoint.DIGIT_7;
+}
+function isUnicodeScalarValue(cp) {
+  return cp >= 0 && cp <= 55295 || cp >= 57344 && cp <= 1114111;
+}
+function sortedLastIndex(array, value) {
+  let low = 0;
+  let high = array.length;
+  while (low < high) {
+    const mid = low + high >>> 1;
+    const val = array[mid];
+    if (val === value)
+      return mid + 1;
+    if (val < value)
+      low = mid + 1;
+    else
+      high = mid;
+  }
+  return low;
+}
+var Locations = class {
+  constructor() {
+    this.offsets = [];
+  }
+  addOffset(offset) {
+    for (let i = this.offsets.length - 1;i >= 0; i--) {
+      const element = this.offsets[i];
+      if (element === offset)
+        return;
+      if (element < offset)
+        break;
+    }
+    this.offsets.push(offset);
+  }
+  getLocFromIndex(offset) {
+    const line = sortedLastIndex(this.offsets, offset) + 1;
+    return {
+      line,
+      column: offset - (line === 1 ? 0 : this.offsets[line - 2])
+    };
+  }
+};
+var CodePointIterator = class {
+  constructor(text) {
+    this.locs = new Locations;
+    this.lastCodePoint = CodePoint.NULL;
+    this.start = -1;
+    this.end = 0;
+    this.text = text;
+  }
+  next() {
+    if (this.lastCodePoint === CodePoint.EOF)
+      return CodePoint.EOF;
+    return this.lastCodePoint = this.moveAt(this.end);
+  }
+  getLocFromIndex(index) {
+    return this.locs.getLocFromIndex(index);
+  }
+  eat(cp) {
+    if (this.text.codePointAt(this.end) === cp) {
+      this.next();
+      return true;
+    }
+    return false;
+  }
+  moveAt(offset) {
+    this.start = this.end = offset;
+    const cp = this.text.codePointAt(this.start) ?? CodePoint.EOF;
+    if (cp === CodePoint.EOF) {
+      this.end = this.start;
+      return cp;
+    }
+    this.end += cp >= 65536 ? 2 : 1;
+    if (cp === CodePoint.LINE_FEED)
+      this.locs.addOffset(this.end);
+    else if (cp === CodePoint.CARRIAGE_RETURN) {
+      if (this.text.codePointAt(this.end) === CodePoint.LINE_FEED) {
+        this.end++;
+        this.locs.addOffset(this.end);
+      }
+      return CodePoint.LINE_FEED;
+    }
+    return cp;
+  }
+};
+var HAS_BIGINT = typeof BigInt !== "undefined";
+var RADIX_PREFIXES = {
+  16: "0x",
+  10: "",
+  8: "0o",
+  2: "0b"
+};
+var ESCAPES_1_0 = {
+  [CodePoint.QUOTATION_MARK]: CodePoint.QUOTATION_MARK,
+  [CodePoint.BACKSLASH]: CodePoint.BACKSLASH,
+  [CodePoint.LATIN_SMALL_B]: CodePoint.BACKSPACE,
+  [CodePoint.LATIN_SMALL_F]: CodePoint.FORM_FEED,
+  [CodePoint.LATIN_SMALL_N]: CodePoint.LINE_FEED,
+  [CodePoint.LATIN_SMALL_R]: CodePoint.CARRIAGE_RETURN,
+  [CodePoint.LATIN_SMALL_T]: CodePoint.TABULATION
+};
+var ESCAPES_LATEST = {
+  ...ESCAPES_1_0,
+  [CodePoint.LATIN_SMALL_E]: CodePoint.ESCAPE
+};
+var Tokenizer = class {
+  constructor(text, parserOptions) {
+    this.backCode = false;
+    this.lastCodePoint = CodePoint.NULL;
+    this.state = "DATA";
+    this.token = null;
+    this.tokenStart = -1;
+    this.valuesEnabled = false;
+    this.text = text;
+    this.parserOptions = parserOptions || {};
+    this.codePointIterator = new CodePointIterator(text);
+    this.tomlVersion = getTOMLVer(this.parserOptions.tomlVersion);
+    this.ESCAPES = this.tomlVersion.gte(1, 1) ? ESCAPES_LATEST : ESCAPES_1_0;
+  }
+  get start() {
+    return this.codePointIterator.start;
+  }
+  get end() {
+    return this.codePointIterator.end;
+  }
+  getLocFromIndex(index) {
+    return this.codePointIterator.getLocFromIndex(index);
+  }
+  reportParseError(code, data) {
+    const offset = this.codePointIterator.start;
+    const loc = this.codePointIterator.getLocFromIndex(offset);
+    throw new ParseError(code, offset, loc.line, loc.column, data);
+  }
+  nextToken() {
+    let token = this.token;
+    if (token != null) {
+      this.token = null;
+      return token;
+    }
+    let cp = this.lastCodePoint;
+    while (cp !== CodePoint.EOF && !this.token) {
+      cp = this.nextCode();
+      const nextState = this[this.state](cp);
+      if (!nextState)
+        throw new Error(`Unknown error: pre state=${this.state}`);
+      this.state = nextState;
+    }
+    token = this.token;
+    this.token = null;
+    return token;
+  }
+  nextCode() {
+    if (this.lastCodePoint === CodePoint.EOF)
+      return CodePoint.EOF;
+    if (this.backCode) {
+      this.backCode = false;
+      return this.lastCodePoint;
+    }
+    return this.lastCodePoint = this.codePointIterator.next();
+  }
+  eatCode(cp) {
+    if (this.lastCodePoint === CodePoint.EOF)
+      return false;
+    if (this.backCode) {
+      if (this.lastCodePoint === cp) {
+        this.backCode = false;
+        return true;
+      }
+      return false;
+    }
+    return this.codePointIterator.eat(cp);
+  }
+  moveAt(loc) {
+    if (this.backCode)
+      this.backCode = false;
+    this.lastCodePoint = this.codePointIterator.moveAt(loc);
+  }
+  back(state) {
+    this.backCode = true;
+    return state;
+  }
+  punctuatorToken() {
+    this.startToken();
+    this.endToken("Punctuator", "end");
+  }
+  startToken() {
+    this.tokenStart = this.codePointIterator.start;
+  }
+  endToken(type, pos, option1, option2) {
+    const { tokenStart } = this;
+    const end = this.codePointIterator[pos];
+    const range = [tokenStart, end];
+    const loc = {
+      start: this.codePointIterator.getLocFromIndex(tokenStart),
+      end: this.codePointIterator.getLocFromIndex(end)
+    };
+    if (type === "Block")
+      this.token = {
+        type,
+        value: this.text.slice(tokenStart + 1, end),
+        range,
+        loc
+      };
+    else {
+      let token;
+      const value = this.text.slice(tokenStart, end);
+      if (type === "BasicString" || type === "LiteralString" || type === "MultiLineBasicString" || type === "MultiLineLiteralString")
+        token = {
+          type,
+          value,
+          string: option1,
+          range,
+          loc
+        };
+      else if (type === "Integer") {
+        const text = option1;
+        token = {
+          type,
+          value,
+          number: parseInt(text, option2),
+          bigint: HAS_BIGINT ? BigInt(RADIX_PREFIXES[option2] + text) : null,
+          range,
+          loc
+        };
+      } else if (type === "Float")
+        token = {
+          type,
+          value,
+          number: option1,
+          range,
+          loc
+        };
+      else if (type === "Boolean")
+        token = {
+          type,
+          value,
+          boolean: option1,
+          range,
+          loc
+        };
+      else if (type === "LocalDate" || type === "LocalTime" || type === "LocalDateTime" || type === "OffsetDateTime")
+        token = {
+          type,
+          value,
+          date: option1,
+          range,
+          loc
+        };
+      else
+        token = {
+          type,
+          value,
+          range,
+          loc
+        };
+      this.token = token;
+    }
+  }
+  DATA(cp) {
+    while (isWhitespace(cp) || isEOL(cp))
+      cp = this.nextCode();
+    if (cp === CodePoint.HASH) {
+      this.startToken();
+      return "COMMENT";
+    }
+    if (cp === CodePoint.QUOTATION_MARK) {
+      this.startToken();
+      return "BASIC_STRING";
+    }
+    if (cp === CodePoint.SINGLE_QUOTE) {
+      this.startToken();
+      return "LITERAL_STRING";
+    }
+    if (cp === CodePoint.DOT || cp === CodePoint.EQUALS_SIGN || cp === CodePoint.LEFT_BRACKET || cp === CodePoint.RIGHT_BRACKET || cp === CodePoint.LEFT_BRACE || cp === CodePoint.RIGHT_BRACE || cp === CodePoint.COMMA) {
+      this.punctuatorToken();
+      return "DATA";
+    }
+    if (this.valuesEnabled) {
+      if (cp === CodePoint.DASH || cp === CodePoint.PLUS_SIGN) {
+        this.startToken();
+        return "SIGN";
+      }
+      if (cp === CodePoint.LATIN_SMALL_N || cp === CodePoint.LATIN_SMALL_I) {
+        this.startToken();
+        return this.back("NAN_OR_INF");
+      }
+      if (isDigit(cp)) {
+        this.startToken();
+        return this.back("NUMBER");
+      }
+      if (cp === CodePoint.LATIN_SMALL_T || cp === CodePoint.LATIN_SMALL_F) {
+        this.startToken();
+        return this.back("BOOLEAN");
+      }
+    } else if (isUnquotedKeyChar(cp, this.tomlVersion)) {
+      this.startToken();
+      return "BARE";
+    }
+    if (cp === CodePoint.EOF)
+      return "DATA";
+    return this.reportParseError("unexpected-char");
+  }
+  COMMENT(cp) {
+    const processCommentChar = this.tomlVersion.gte(1, 1) ? (c) => {
+      if (!isNonEOL(c))
+        this.reportParseError("invalid-comment-character", { cp: JSON.stringify(String.fromCodePoint(c)).slice(1, -1) });
+    } : (c) => {
+      if (isControlOtherThanTab(c))
+        this.reportParseErrorControlChar();
+    };
+    while (!isEOL(cp) && cp !== CodePoint.EOF) {
+      processCommentChar(cp);
+      cp = this.nextCode();
+    }
+    this.endToken("Block", "start");
+    return "DATA";
+  }
+  BARE(cp) {
+    while (isUnquotedKeyChar(cp, this.tomlVersion))
+      cp = this.nextCode();
+    this.endToken("Bare", "start");
+    return this.back("DATA");
+  }
+  BASIC_STRING(cp) {
+    if (cp === CodePoint.QUOTATION_MARK) {
+      cp = this.nextCode();
+      if (cp === CodePoint.QUOTATION_MARK)
+        return "MULTI_LINE_BASIC_STRING";
+      this.endToken("BasicString", "start", "");
+      return this.back("DATA");
+    }
+    const out = [];
+    while (cp !== CodePoint.QUOTATION_MARK && cp !== CodePoint.EOF && cp !== CodePoint.LINE_FEED) {
+      if (isControlOtherThanTab(cp))
+        return this.reportParseErrorControlChar();
+      if (cp === CodePoint.BACKSLASH) {
+        cp = this.nextCode();
+        const ecp = this.ESCAPES[cp];
+        if (ecp) {
+          out.push(ecp);
+          cp = this.nextCode();
+          continue;
+        } else if (cp === CodePoint.LATIN_SMALL_U) {
+          const code = this.parseUnicode(4);
+          out.push(code);
+          cp = this.nextCode();
+          continue;
+        } else if (cp === CodePoint.LATIN_CAPITAL_U) {
+          const code = this.parseUnicode(8);
+          out.push(code);
+          cp = this.nextCode();
+          continue;
+        } else if (cp === CodePoint.LATIN_SMALL_X && this.tomlVersion.gte(1, 1)) {
+          const code = this.parseUnicode(2);
+          out.push(code);
+          cp = this.nextCode();
+          continue;
+        }
+        return this.reportParseError("invalid-char-in-escape-sequence");
+      }
+      out.push(cp);
+      cp = this.nextCode();
+    }
+    if (cp !== CodePoint.QUOTATION_MARK)
+      return this.reportParseError("unterminated-string");
+    this.endToken("BasicString", "end", String.fromCodePoint(...out));
+    return "DATA";
+  }
+  MULTI_LINE_BASIC_STRING(cp) {
+    const out = [];
+    if (cp === CodePoint.LINE_FEED)
+      cp = this.nextCode();
+    while (cp !== CodePoint.EOF) {
+      if (cp !== CodePoint.LINE_FEED && isControlOtherThanTab(cp))
+        return this.reportParseErrorControlChar();
+      if (cp === CodePoint.QUOTATION_MARK) {
+        const startPos = this.codePointIterator.start;
+        if (this.eatCode(CodePoint.QUOTATION_MARK) && this.eatCode(CodePoint.QUOTATION_MARK)) {
+          if (this.eatCode(CodePoint.QUOTATION_MARK)) {
+            out.push(CodePoint.QUOTATION_MARK);
+            if (this.eatCode(CodePoint.QUOTATION_MARK)) {
+              out.push(CodePoint.QUOTATION_MARK);
+              if (this.eatCode(CodePoint.QUOTATION_MARK)) {
+                this.moveAt(startPos);
+                return this.reportParseError("invalid-three-quotes");
+              }
+            }
+          }
+          this.endToken("MultiLineBasicString", "end", String.fromCodePoint(...out));
+          return "DATA";
+        }
+        this.moveAt(startPos);
+      }
+      if (cp === CodePoint.BACKSLASH) {
+        cp = this.nextCode();
+        const ecp = this.ESCAPES[cp];
+        if (ecp) {
+          out.push(ecp);
+          cp = this.nextCode();
+          continue;
+        } else if (cp === CodePoint.LATIN_SMALL_U) {
+          const code = this.parseUnicode(4);
+          out.push(code);
+          cp = this.nextCode();
+          continue;
+        } else if (cp === CodePoint.LATIN_CAPITAL_U) {
+          const code = this.parseUnicode(8);
+          out.push(code);
+          cp = this.nextCode();
+          continue;
+        } else if (cp === CodePoint.LATIN_SMALL_X && this.tomlVersion.gte(1, 1)) {
+          const code = this.parseUnicode(2);
+          out.push(code);
+          cp = this.nextCode();
+          continue;
+        } else if (cp === CodePoint.LINE_FEED) {
+          cp = this.nextCode();
+          while (isWhitespace(cp) || cp === CodePoint.LINE_FEED)
+            cp = this.nextCode();
+          continue;
+        } else if (isWhitespace(cp)) {
+          let valid = true;
+          const startPos = this.codePointIterator.start;
+          let nextCp;
+          while ((nextCp = this.nextCode()) !== CodePoint.EOF) {
+            if (nextCp === CodePoint.LINE_FEED)
+              break;
+            if (!isWhitespace(nextCp)) {
+              this.moveAt(startPos);
+              valid = false;
+              break;
+            }
+          }
+          if (valid) {
+            cp = this.nextCode();
+            while (isWhitespace(cp) || cp === CodePoint.LINE_FEED)
+              cp = this.nextCode();
+            continue;
+          }
+        }
+        return this.reportParseError("invalid-char-in-escape-sequence");
+      }
+      out.push(cp);
+      cp = this.nextCode();
+    }
+    return this.reportParseError("unterminated-string");
+  }
+  LITERAL_STRING(cp) {
+    if (cp === CodePoint.SINGLE_QUOTE) {
+      cp = this.nextCode();
+      if (cp === CodePoint.SINGLE_QUOTE)
+        return "MULTI_LINE_LITERAL_STRING";
+      this.endToken("LiteralString", "start", "");
+      return this.back("DATA");
+    }
+    const out = [];
+    while (cp !== CodePoint.SINGLE_QUOTE && cp !== CodePoint.EOF && cp !== CodePoint.LINE_FEED) {
+      if (isControlOtherThanTab(cp))
+        return this.reportParseErrorControlChar();
+      out.push(cp);
+      cp = this.nextCode();
+    }
+    if (cp !== CodePoint.SINGLE_QUOTE)
+      return this.reportParseError("unterminated-string");
+    this.endToken("LiteralString", "end", String.fromCodePoint(...out));
+    return "DATA";
+  }
+  MULTI_LINE_LITERAL_STRING(cp) {
+    const out = [];
+    if (cp === CodePoint.LINE_FEED)
+      cp = this.nextCode();
+    while (cp !== CodePoint.EOF) {
+      if (cp !== CodePoint.LINE_FEED && isControlOtherThanTab(cp))
+        return this.reportParseErrorControlChar();
+      if (cp === CodePoint.SINGLE_QUOTE) {
+        const startPos = this.codePointIterator.start;
+        if (this.eatCode(CodePoint.SINGLE_QUOTE) && this.eatCode(CodePoint.SINGLE_QUOTE)) {
+          if (this.eatCode(CodePoint.SINGLE_QUOTE)) {
+            out.push(CodePoint.SINGLE_QUOTE);
+            if (this.eatCode(CodePoint.SINGLE_QUOTE)) {
+              out.push(CodePoint.SINGLE_QUOTE);
+              if (this.eatCode(CodePoint.SINGLE_QUOTE)) {
+                this.moveAt(startPos);
+                return this.reportParseError("invalid-three-quotes");
+              }
+            }
+          }
+          this.endToken("MultiLineLiteralString", "end", String.fromCodePoint(...out));
+          return "DATA";
+        }
+        this.moveAt(startPos);
+      }
+      out.push(cp);
+      cp = this.nextCode();
+    }
+    return this.reportParseError("unterminated-string");
+  }
+  SIGN(cp) {
+    if (cp === CodePoint.LATIN_SMALL_N || cp === CodePoint.LATIN_SMALL_I)
+      return this.back("NAN_OR_INF");
+    if (isDigit(cp))
+      return this.back("NUMBER");
+    return this.reportParseError("unexpected-char");
+  }
+  NAN_OR_INF(cp) {
+    if (cp === CodePoint.LATIN_SMALL_N) {
+      const startPos = this.codePointIterator.start;
+      if (this.eatCode(CodePoint.LATIN_SMALL_A) && this.eatCode(CodePoint.LATIN_SMALL_N)) {
+        this.endToken("Float", "end", NaN);
+        return "DATA";
+      }
+      this.moveAt(startPos);
+    } else if (cp === CodePoint.LATIN_SMALL_I) {
+      const startPos = this.codePointIterator.start;
+      if (this.eatCode(CodePoint.LATIN_SMALL_N) && this.eatCode(CodePoint.LATIN_SMALL_F)) {
+        this.endToken("Float", "end", this.text[this.tokenStart] === "-" ? -Infinity : Infinity);
+        return "DATA";
+      }
+      this.moveAt(startPos);
+    }
+    return this.reportParseError("unexpected-char");
+  }
+  NUMBER(cp) {
+    const start = this.text[this.tokenStart];
+    const sign = start === "+" ? CodePoint.PLUS_SIGN : start === "-" ? CodePoint.DASH : CodePoint.NULL;
+    if (cp === CodePoint.DIGIT_0) {
+      if (sign === CodePoint.NULL) {
+        const startPos = this.codePointIterator.start;
+        const nextCp$1 = this.nextCode();
+        if (isDigit(nextCp$1)) {
+          const nextNextCp = this.nextCode();
+          if (nextNextCp === CodePoint.COLON) {
+            this.data = {
+              hasDate: false,
+              year: 0,
+              month: 0,
+              day: 0,
+              hour: Number(String.fromCodePoint(CodePoint.DIGIT_0, nextCp$1)),
+              minute: 0,
+              second: 0
+            };
+            return "TIME_MINUTE";
+          }
+          if (isDigit(nextNextCp)) {
+            const nextNextNextCp = this.nextCode();
+            if (isDigit(nextNextNextCp) && this.eatCode(CodePoint.DASH)) {
+              this.data = {
+                hasDate: true,
+                year: Number(String.fromCodePoint(CodePoint.DIGIT_0, nextCp$1, nextNextCp, nextNextNextCp)),
+                month: 0,
+                day: 0,
+                hour: 0,
+                minute: 0,
+                second: 0
+              };
+              return "DATE_MONTH";
+            }
+          }
+          this.moveAt(startPos);
+          return this.reportParseError("invalid-leading-zero");
+        }
+        this.moveAt(startPos);
+      }
+      cp = this.nextCode();
+      if (cp === CodePoint.LATIN_SMALL_X || cp === CodePoint.LATIN_SMALL_O || cp === CodePoint.LATIN_SMALL_B) {
+        if (sign !== CodePoint.NULL)
+          return this.reportParseError("unexpected-char");
+        return cp === CodePoint.LATIN_SMALL_X ? "HEX" : cp === CodePoint.LATIN_SMALL_O ? "OCTAL" : "BINARY";
+      }
+      if (cp === CodePoint.LATIN_SMALL_E || cp === CodePoint.LATIN_CAPITAL_E) {
+        this.data = {
+          minus: sign === CodePoint.DASH,
+          left: [CodePoint.DIGIT_0]
+        };
+        return "EXPONENT_RIGHT";
+      }
+      if (cp === CodePoint.DOT) {
+        this.data = {
+          minus: sign === CodePoint.DASH,
+          absInt: [CodePoint.DIGIT_0]
+        };
+        return "FRACTIONAL_RIGHT";
+      }
+      this.endToken("Integer", "start", "0", 10);
+      return this.back("DATA");
+    }
+    const { out, nextCp, hasUnderscore } = this.parseDigits(cp, isDigit);
+    if (nextCp === CodePoint.DASH && sign === CodePoint.NULL && !hasUnderscore && out.length === 4) {
+      this.data = {
+        hasDate: true,
+        year: Number(String.fromCodePoint(...out)),
+        month: 0,
+        day: 0,
+        hour: 0,
+        minute: 0,
+        second: 0
+      };
+      return "DATE_MONTH";
+    }
+    if (nextCp === CodePoint.COLON && sign === CodePoint.NULL && !hasUnderscore && out.length === 2) {
+      this.data = {
+        hasDate: false,
+        year: 0,
+        month: 0,
+        day: 0,
+        hour: Number(String.fromCodePoint(...out)),
+        minute: 0,
+        second: 0
+      };
+      return "TIME_MINUTE";
+    }
+    if (nextCp === CodePoint.LATIN_SMALL_E || nextCp === CodePoint.LATIN_CAPITAL_E) {
+      this.data = {
+        minus: sign === CodePoint.DASH,
+        left: out
+      };
+      return "EXPONENT_RIGHT";
+    }
+    if (nextCp === CodePoint.DOT) {
+      this.data = {
+        minus: sign === CodePoint.DASH,
+        absInt: out
+      };
+      return "FRACTIONAL_RIGHT";
+    }
+    this.endToken("Integer", "start", sign === CodePoint.DASH ? String.fromCodePoint(CodePoint.DASH, ...out) : String.fromCodePoint(...out), 10);
+    return this.back("DATA");
+  }
+  HEX(cp) {
+    const { out } = this.parseDigits(cp, isHexDig);
+    this.endToken("Integer", "start", String.fromCodePoint(...out), 16);
+    return this.back("DATA");
+  }
+  OCTAL(cp) {
+    const { out } = this.parseDigits(cp, isOctalDig);
+    this.endToken("Integer", "start", String.fromCodePoint(...out), 8);
+    return this.back("DATA");
+  }
+  BINARY(cp) {
+    const { out } = this.parseDigits(cp, (c) => c === CodePoint.DIGIT_0 || c === CodePoint.DIGIT_1);
+    this.endToken("Integer", "start", String.fromCodePoint(...out), 2);
+    return this.back("DATA");
+  }
+  FRACTIONAL_RIGHT(cp) {
+    const { minus, absInt } = this.data;
+    const { out, nextCp } = this.parseDigits(cp, isDigit);
+    const absNum = [
+      ...absInt,
+      CodePoint.DOT,
+      ...out
+    ];
+    if (nextCp === CodePoint.LATIN_SMALL_E || nextCp === CodePoint.LATIN_CAPITAL_E) {
+      this.data = {
+        minus,
+        left: absNum
+      };
+      return "EXPONENT_RIGHT";
+    }
+    const value = Number(minus ? String.fromCodePoint(CodePoint.DASH, ...absNum) : String.fromCodePoint(...absNum));
+    this.endToken("Float", "start", value);
+    return this.back("DATA");
+  }
+  EXPONENT_RIGHT(cp) {
+    const { left, minus: leftMinus } = this.data;
+    let minus = false;
+    if (cp === CodePoint.DASH || cp === CodePoint.PLUS_SIGN) {
+      minus = cp === CodePoint.DASH;
+      cp = this.nextCode();
+    }
+    const { out } = this.parseDigits(cp, isDigit);
+    const right = out;
+    if (minus)
+      right.unshift(CodePoint.DASH);
+    const value = Number(leftMinus ? String.fromCodePoint(CodePoint.DASH, ...left, CodePoint.LATIN_SMALL_E, ...right) : String.fromCodePoint(...left, CodePoint.LATIN_SMALL_E, ...right));
+    this.endToken("Float", "start", value);
+    return this.back("DATA");
+  }
+  BOOLEAN(cp) {
+    if (cp === CodePoint.LATIN_SMALL_T) {
+      const startPos = this.codePointIterator.start;
+      if (this.eatCode(CodePoint.LATIN_SMALL_R) && this.eatCode(CodePoint.LATIN_SMALL_U) && this.eatCode(CodePoint.LATIN_SMALL_E)) {
+        this.endToken("Boolean", "end", true);
+        return "DATA";
+      }
+      this.moveAt(startPos);
+    } else if (cp === CodePoint.LATIN_SMALL_F) {
+      const startPos = this.codePointIterator.start;
+      if (this.eatCode(CodePoint.LATIN_SMALL_A) && this.eatCode(CodePoint.LATIN_SMALL_L) && this.eatCode(CodePoint.LATIN_SMALL_S) && this.eatCode(CodePoint.LATIN_SMALL_E)) {
+        this.endToken("Boolean", "end", false);
+        return "DATA";
+      }
+      this.moveAt(startPos);
+    }
+    return this.reportParseError("unexpected-char");
+  }
+  DATE_MONTH(cp) {
+    const start = this.codePointIterator.start;
+    if (!isDigit(cp))
+      return this.reportParseError("unexpected-char");
+    cp = this.nextCode();
+    if (!isDigit(cp))
+      return this.reportParseError("unexpected-char");
+    cp = this.nextCode();
+    if (cp !== CodePoint.DASH)
+      return this.reportParseError("unexpected-char");
+    const end = this.codePointIterator.start;
+    const data = this.data;
+    data.month = Number(this.text.slice(start, end));
+    return "DATE_DAY";
+  }
+  DATE_DAY(cp) {
+    const start = this.codePointIterator.start;
+    if (!isDigit(cp))
+      return this.reportParseError("unexpected-char");
+    cp = this.nextCode();
+    if (!isDigit(cp))
+      return this.reportParseError("unexpected-char");
+    const end = this.codePointIterator.end;
+    const data = this.data;
+    data.day = Number(this.text.slice(start, end));
+    if (!isValidDate(data.year, data.month, data.day))
+      return this.reportParseError("invalid-date");
+    cp = this.nextCode();
+    if (cp === CodePoint.LATIN_CAPITAL_T || cp === CodePoint.LATIN_SMALL_T)
+      return "TIME_HOUR";
+    if (cp === CodePoint.SPACE) {
+      const startPos = this.codePointIterator.start;
+      if (isDigit(this.nextCode()) && isDigit(this.nextCode())) {
+        this.moveAt(startPos);
+        return "TIME_HOUR";
+      }
+      this.moveAt(startPos);
+    }
+    const dateValue = getDateFromDateTimeData(data, "");
+    this.endToken("LocalDate", "start", dateValue);
+    return this.back("DATA");
+  }
+  TIME_HOUR(cp) {
+    const start = this.codePointIterator.start;
+    if (!isDigit(cp))
+      return this.reportParseError("unexpected-char");
+    cp = this.nextCode();
+    if (!isDigit(cp))
+      return this.reportParseError("unexpected-char");
+    cp = this.nextCode();
+    if (cp !== CodePoint.COLON)
+      return this.reportParseError("unexpected-char");
+    const end = this.codePointIterator.start;
+    const data = this.data;
+    data.hour = Number(this.text.slice(start, end));
+    return "TIME_MINUTE";
+  }
+  TIME_MINUTE(cp) {
+    const start = this.codePointIterator.start;
+    if (!isDigit(cp))
+      return this.reportParseError("unexpected-char");
+    cp = this.nextCode();
+    if (!isDigit(cp))
+      return this.reportParseError("unexpected-char");
+    const end = this.codePointIterator.end;
+    const data = this.data;
+    data.minute = Number(this.text.slice(start, end));
+    cp = this.nextCode();
+    if (cp === CodePoint.COLON)
+      return "TIME_SECOND";
+    if (this.tomlVersion.lt(1, 1))
+      return this.reportParseError("unexpected-char");
+    if (!isValidTime(data.hour, data.minute, data.second))
+      return this.reportParseError("invalid-time");
+    return this.processTimeEnd(cp, data);
+  }
+  TIME_SECOND(cp) {
+    const start = this.codePointIterator.start;
+    if (!isDigit(cp))
+      return this.reportParseError("unexpected-char");
+    cp = this.nextCode();
+    if (!isDigit(cp))
+      return this.reportParseError("unexpected-char");
+    const end = this.codePointIterator.end;
+    const data = this.data;
+    data.second = Number(this.text.slice(start, end));
+    if (!isValidTime(data.hour, data.minute, data.second))
+      return this.reportParseError("invalid-time");
+    cp = this.nextCode();
+    if (cp === CodePoint.DOT)
+      return "TIME_SEC_FRAC";
+    return this.processTimeEnd(cp, data);
+  }
+  TIME_SEC_FRAC(cp) {
+    if (!isDigit(cp))
+      return this.reportParseError("unexpected-char");
+    const start = this.codePointIterator.start;
+    while (isDigit(cp))
+      cp = this.nextCode();
+    const end = this.codePointIterator.start;
+    const data = this.data;
+    data.frac = this.text.slice(start, end);
+    return this.processTimeEnd(cp, data);
+  }
+  processTimeEnd(cp, data) {
+    if (data.hasDate) {
+      if (cp === CodePoint.DASH || cp === CodePoint.PLUS_SIGN) {
+        data.offsetSign = cp;
+        return "TIME_OFFSET";
+      }
+      if (cp === CodePoint.LATIN_CAPITAL_Z || cp === CodePoint.LATIN_SMALL_Z) {
+        const dateValue$2 = getDateFromDateTimeData(data, "Z");
+        this.endToken("OffsetDateTime", "end", dateValue$2);
+        return "DATA";
+      }
+      const dateValue$1 = getDateFromDateTimeData(data, "");
+      this.endToken("LocalDateTime", "start", dateValue$1);
+      return this.back("DATA");
+    }
+    const dateValue = getDateFromDateTimeData(data, "");
+    this.endToken("LocalTime", "start", dateValue);
+    return this.back("DATA");
+  }
+  TIME_OFFSET(cp) {
+    if (!isDigit(cp))
+      return this.reportParseError("unexpected-char");
+    const hourStart = this.codePointIterator.start;
+    cp = this.nextCode();
+    if (!isDigit(cp))
+      return this.reportParseError("unexpected-char");
+    cp = this.nextCode();
+    if (cp !== CodePoint.COLON)
+      return this.reportParseError("unexpected-char");
+    const hourEnd = this.codePointIterator.start;
+    cp = this.nextCode();
+    const minuteStart = this.codePointIterator.start;
+    if (!isDigit(cp))
+      return this.reportParseError("unexpected-char");
+    cp = this.nextCode();
+    if (!isDigit(cp))
+      return this.reportParseError("unexpected-char");
+    const minuteEnd = this.codePointIterator.end;
+    const hour = Number(this.text.slice(hourStart, hourEnd));
+    const minute = Number(this.text.slice(minuteStart, minuteEnd));
+    if (!isValidTime(hour, minute, 0))
+      return this.reportParseError("invalid-time");
+    const data = this.data;
+    const dateValue = getDateFromDateTimeData(data, `${String.fromCodePoint(data.offsetSign)}${padStart(hour, 2)}:${padStart(minute, 2)}`);
+    this.endToken("OffsetDateTime", "end", dateValue);
+    return "DATA";
+  }
+  parseDigits(cp, checkDigit) {
+    if (cp === CodePoint.UNDERSCORE)
+      return this.reportParseError("invalid-underscore");
+    if (!checkDigit(cp))
+      return this.reportParseError("unexpected-char");
+    const out = [];
+    let before = CodePoint.NULL;
+    let hasUnderscore = false;
+    while (checkDigit(cp) || cp === CodePoint.UNDERSCORE) {
+      if (cp === CodePoint.UNDERSCORE) {
+        hasUnderscore = true;
+        if (before === CodePoint.UNDERSCORE)
+          return this.reportParseError("invalid-underscore");
+      } else
+        out.push(cp);
+      before = cp;
+      cp = this.nextCode();
+    }
+    if (before === CodePoint.UNDERSCORE)
+      return this.reportParseError("invalid-underscore");
+    return {
+      out,
+      nextCp: cp,
+      hasUnderscore
+    };
+  }
+  parseUnicode(count) {
+    const startLoc = this.codePointIterator.start;
+    const start = this.codePointIterator.end;
+    let charCount = 0;
+    let cp;
+    while ((cp = this.nextCode()) !== CodePoint.EOF) {
+      if (!isHexDig(cp)) {
+        this.moveAt(startLoc);
+        return this.reportParseError("invalid-char-in-escape-sequence");
+      }
+      charCount++;
+      if (charCount >= count)
+        break;
+    }
+    const end = this.codePointIterator.end;
+    const code = this.text.slice(start, end);
+    const codePoint = parseInt(code, 16);
+    if (!isUnicodeScalarValue(codePoint))
+      return this.reportParseError("invalid-code-point", { cp: code });
+    return codePoint;
+  }
+  reportParseErrorControlChar() {
+    return this.reportParseError("invalid-control-character");
+  }
+};
+function isUnquotedKeyChar(cp, tomlVersion) {
+  if (isLetter(cp) || isDigit(cp) || cp === CodePoint.UNDERSCORE || cp === CodePoint.DASH)
+    return true;
+  if (tomlVersion.lt(1, 1))
+    return false;
+  return false;
+}
+function isControlOtherThanTab(cp) {
+  return isControl(cp) && cp !== CodePoint.TABULATION || cp === CodePoint.DELETE;
+}
+function isNonEOL(cp) {
+  return cp === CodePoint.TABULATION || CodePoint.SPACE <= cp && cp <= CodePoint.TILDE || isNonAscii(cp);
+}
+function isNonAscii(cp) {
+  return CodePoint.PAD <= cp && cp <= CodePoint.CP_D7FF || CodePoint.CP_E000 <= cp && cp <= CodePoint.CP_10FFFF;
+}
+function isValidDate(y, m, d) {
+  if (y >= 0 && m <= 12 && m >= 1 && d >= 1)
+    return d <= (m === 2 ? y & 3 || !(y % 25) && y & 15 ? 28 : 29 : 30 + (m + (m >> 3) & 1));
+  return false;
+}
+function isValidTime(h, m, s) {
+  if (h >= 24 || h < 0 || m > 59 || m < 0 || s > 60 || s < 0)
+    return false;
+  return true;
+}
+function getDateFromDateTimeData(data, timeZone) {
+  const year = padStart(data.year, 4);
+  const month = data.month ? padStart(data.month, 2) : "01";
+  const day = data.day ? padStart(data.day, 2) : "01";
+  const hour = padStart(data.hour, 2);
+  const minute = padStart(data.minute, 2);
+  const second = padStart(data.second, 2);
+  const textDate = `${year}-${month}-${day}`;
+  const frac = data.frac ? `.${data.frac}` : "";
+  const dateValue = /* @__PURE__ */ new Date(`${textDate}T${hour}:${minute}:${second}${frac}${timeZone}`);
+  if (!isNaN(dateValue.getTime()) || data.second !== 60)
+    return dateValue;
+  return /* @__PURE__ */ new Date(`${textDate}T${hour}:${minute}:59${frac}${timeZone}`);
+}
+function padStart(num, maxLength) {
+  return String(num).padStart(maxLength, "0");
+}
+var VALUE_KIND_VALUE = Symbol("VALUE_KIND_VALUE");
+var VALUE_KIND_INTERMEDIATE = Symbol("VALUE_KIND_INTERMEDIATE");
+var KeysResolver = class {
+  constructor(ctx) {
+    this.rootKeys = /* @__PURE__ */ new Map;
+    this.tables = [];
+    this.ctx = ctx;
+  }
+  applyResolveKeyForTable(node2) {
+    let keys = this.rootKeys;
+    const peekKeyIndex = node2.key.keys.length - 1;
+    for (let index = 0;index < peekKeyIndex; index++) {
+      const keyNode = node2.key.keys[index];
+      const keyName = toKeyName(keyNode);
+      node2.resolvedKey.push(keyName);
+      let keyStore = keys.get(keyName);
+      if (!keyStore) {
+        keyStore = {
+          node: keyNode,
+          keys: /* @__PURE__ */ new Map
+        };
+        keys.set(keyName, keyStore);
+      } else if (keyStore.table === "array") {
+        const peekIndex = keyStore.peekIndex;
+        node2.resolvedKey.push(peekIndex);
+        keyStore = keyStore.keys.get(peekIndex);
+      }
+      keys = keyStore.keys;
+    }
+    const lastKeyNode = node2.key.keys[peekKeyIndex];
+    const lastKeyName = toKeyName(lastKeyNode);
+    node2.resolvedKey.push(lastKeyName);
+    const lastKeyStore = keys.get(lastKeyName);
+    if (!lastKeyStore)
+      if (node2.kind === "array") {
+        node2.resolvedKey.push(0);
+        const newKeyStore = {
+          node: lastKeyNode,
+          keys: /* @__PURE__ */ new Map
+        };
+        keys.set(lastKeyName, {
+          table: node2.kind,
+          node: lastKeyNode,
+          keys: new Map([[0, newKeyStore]]),
+          peekIndex: 0
+        });
+        this.tables.push({
+          node: node2,
+          keys: newKeyStore.keys
+        });
+      } else {
+        const newKeyStore = {
+          table: node2.kind,
+          node: lastKeyNode,
+          keys: /* @__PURE__ */ new Map
+        };
+        keys.set(lastKeyName, newKeyStore);
+        this.tables.push({
+          node: node2,
+          keys: newKeyStore.keys
+        });
+      }
+    else if (!lastKeyStore.table)
+      if (node2.kind === "array")
+        this.ctx.reportParseError("dupe-keys", lastKeyNode);
+      else {
+        const transformKey = {
+          table: node2.kind,
+          node: lastKeyNode,
+          keys: lastKeyStore.keys
+        };
+        keys.set(lastKeyName, transformKey);
+        this.tables.push({
+          node: node2,
+          keys: transformKey.keys
+        });
+      }
+    else if (lastKeyStore.table === "array")
+      if (node2.kind === "array") {
+        const newKeyStore = {
+          node: lastKeyNode,
+          keys: /* @__PURE__ */ new Map
+        };
+        const newIndex = lastKeyStore.peekIndex + 1;
+        node2.resolvedKey.push(newIndex);
+        lastKeyStore.keys.set(newIndex, newKeyStore);
+        lastKeyStore.peekIndex = newIndex;
+        this.tables.push({
+          node: node2,
+          keys: newKeyStore.keys
+        });
+      } else
+        this.ctx.reportParseError("dupe-keys", lastKeyNode);
+    else
+      this.ctx.reportParseError("dupe-keys", lastKeyNode);
+  }
+  verifyDuplicateKeys(node2) {
+    for (const body of node2.body)
+      if (body.type === "TOMLKeyValue")
+        verifyDuplicateKeysForKeyValue(this.ctx, this.rootKeys, body);
+    for (const { node: tableNode, keys } of this.tables)
+      for (const body of tableNode.body)
+        verifyDuplicateKeysForKeyValue(this.ctx, keys, body);
+  }
+};
+function verifyDuplicateKeysForKeyValue(ctx, defineKeys, node2) {
+  let keys = defineKeys;
+  const lastKey = last(node2.key.keys);
+  for (const keyNode of node2.key.keys) {
+    const key = toKeyName(keyNode);
+    let defineKey = keys.get(key);
+    if (defineKey) {
+      if (defineKey.value === VALUE_KIND_VALUE)
+        ctx.reportParseError("dupe-keys", getAfterNode(keyNode, defineKey.node));
+      else if (lastKey === keyNode)
+        ctx.reportParseError("dupe-keys", getAfterNode(keyNode, defineKey.node));
+      else if (defineKey.table)
+        ctx.reportParseError("dupe-keys", getAfterNode(keyNode, defineKey.node));
+      defineKey.value = VALUE_KIND_INTERMEDIATE;
+    } else {
+      if (lastKey === keyNode)
+        defineKey = {
+          value: VALUE_KIND_VALUE,
+          node: keyNode,
+          keys: /* @__PURE__ */ new Map
+        };
+      else
+        defineKey = {
+          value: VALUE_KIND_INTERMEDIATE,
+          node: keyNode,
+          keys: /* @__PURE__ */ new Map
+        };
+      keys.set(key, defineKey);
+    }
+    keys = defineKey.keys;
+  }
+  if (node2.value.type === "TOMLInlineTable")
+    verifyDuplicateKeysForInlineTable(ctx, keys, node2.value);
+  else if (node2.value.type === "TOMLArray")
+    verifyDuplicateKeysForArray(ctx, keys, node2.value);
+}
+function verifyDuplicateKeysForInlineTable(ctx, defineKeys, node2) {
+  for (const body of node2.body)
+    verifyDuplicateKeysForKeyValue(ctx, defineKeys, body);
+}
+function verifyDuplicateKeysForArray(ctx, defineKeys, node2) {
+  const keys = defineKeys;
+  for (let index = 0;index < node2.elements.length; index++) {
+    const element = node2.elements[index];
+    let defineKey = keys.get(index);
+    if (defineKey)
+      ctx.reportParseError("dupe-keys", getAfterNode(element, defineKey.node));
+    else {
+      defineKey = {
+        value: VALUE_KIND_VALUE,
+        node: element,
+        keys: /* @__PURE__ */ new Map
+      };
+      defineKeys.set(index, defineKey);
+      if (element.type === "TOMLInlineTable")
+        verifyDuplicateKeysForInlineTable(ctx, defineKey.keys, element);
+      else if (element.type === "TOMLArray")
+        verifyDuplicateKeysForArray(ctx, defineKey.keys, element);
+    }
+  }
+}
+function getAfterNode(a, b) {
+  return a.range[0] <= b.range[0] ? b : a;
+}
+var Context = class {
+  constructor(data) {
+    this.tokens = [];
+    this.comments = [];
+    this.back = null;
+    this.stateStack = [];
+    this.needNewLine = false;
+    this.needSameLine = false;
+    this.currToken = null;
+    this.prevToken = null;
+    this.valueContainerStack = [];
+    this.tokenizer = new Tokenizer(data.text, data.parserOptions);
+    this.topLevelTable = data.topLevelTable;
+    this.table = data.topLevelTable;
+    this.keysResolver = new KeysResolver(this);
+  }
+  nextToken(option) {
+    this.prevToken = this.currToken;
+    if (this.back) {
+      this.currToken = this.back;
+      this.back = null;
+    } else
+      this.currToken = this._nextTokenFromTokenizer(option);
+    if ((this.needNewLine || this.needSameLine || option?.needSameLine) && this.prevToken && this.currToken)
+      if (this.prevToken.loc.end.line === this.currToken.loc.start.line) {
+        if (this.needNewLine)
+          return this.reportParseError("missing-newline", this.currToken);
+      } else {
+        const needSameLine = this.needSameLine || option?.needSameLine;
+        if (needSameLine)
+          return this.reportParseError(needSameLine, this.currToken);
+      }
+    this.needNewLine = false;
+    this.needSameLine = false;
+    return this.currToken;
+  }
+  _nextTokenFromTokenizer(option) {
+    const valuesEnabled = this.tokenizer.valuesEnabled;
+    if (option?.valuesEnabled)
+      this.tokenizer.valuesEnabled = option.valuesEnabled;
+    let token = this.tokenizer.nextToken();
+    while (token && token.type === "Block") {
+      this.comments.push(token);
+      token = this.tokenizer.nextToken();
+    }
+    if (token)
+      this.tokens.push(token);
+    this.tokenizer.valuesEnabled = valuesEnabled;
+    return token;
+  }
+  backToken() {
+    if (this.back)
+      throw new Error("Illegal state");
+    this.back = this.currToken;
+    this.currToken = this.prevToken;
+  }
+  addValueContainer(valueContainer) {
+    this.valueContainerStack.push(valueContainer);
+    this.tokenizer.valuesEnabled = true;
+  }
+  consumeValueContainer() {
+    const valueContainer = this.valueContainerStack.pop();
+    this.tokenizer.valuesEnabled = this.valueContainerStack.length > 0;
+    return valueContainer;
+  }
+  applyResolveKeyForTable(node2) {
+    this.keysResolver.applyResolveKeyForTable(node2);
+  }
+  verifyDuplicateKeys() {
+    this.keysResolver.verifyDuplicateKeys(this.topLevelTable);
+  }
+  reportParseError(code, token) {
+    let offset, line, column;
+    if (token) {
+      offset = token.range[0];
+      line = token.loc.start.line;
+      column = token.loc.start.column;
+    } else {
+      offset = this.tokenizer.start;
+      const startPos = this.tokenizer.getLocFromIndex(offset);
+      line = startPos.line;
+      column = startPos.column;
+    }
+    throw new ParseError(code, offset, line, column);
+  }
+};
+var STATE_FOR_ERROR = { VALUE: "missing-value" };
+var STRING_VALUE_STYLE_MAP = {
+  BasicString: "basic",
+  MultiLineBasicString: "basic",
+  LiteralString: "literal",
+  MultiLineLiteralString: "literal"
+};
+var STRING_KEY_STYLE_MAP = {
+  BasicString: "basic",
+  LiteralString: "literal"
+};
+var DATETIME_VALUE_KIND_MAP = {
+  OffsetDateTime: "offset-date-time",
+  LocalDateTime: "local-date-time",
+  LocalDate: "local-date",
+  LocalTime: "local-time"
+};
+var TOMLParser = class {
+  constructor(text, parserOptions) {
+    this.text = text;
+    this.parserOptions = parserOptions || {};
+    this.tomlVersion = getTOMLVer(this.parserOptions.tomlVersion);
+  }
+  parse() {
+    const ast = {
+      type: "Program",
+      body: [],
+      sourceType: "module",
+      tokens: [],
+      comments: [],
+      parent: null,
+      range: [0, 0],
+      loc: {
+        start: {
+          line: 1,
+          column: 0
+        },
+        end: {
+          line: 1,
+          column: 0
+        }
+      }
+    };
+    const node2 = {
+      type: "TOMLTopLevelTable",
+      body: [],
+      parent: ast,
+      range: cloneRange(ast.range),
+      loc: cloneLoc(ast.loc)
+    };
+    ast.body = [node2];
+    const ctx = new Context({
+      text: this.text,
+      parserOptions: this.parserOptions,
+      topLevelTable: node2
+    });
+    let token = ctx.nextToken();
+    if (token) {
+      node2.range[0] = token.range[0];
+      node2.loc.start = clonePos(token.loc.start);
+      while (token) {
+        const state$1 = ctx.stateStack.pop() || "TABLE";
+        ctx.stateStack.push(...this[state$1](token, ctx));
+        token = ctx.nextToken();
+      }
+      const state = ctx.stateStack.pop() || "TABLE";
+      if (state in STATE_FOR_ERROR)
+        return ctx.reportParseError(STATE_FOR_ERROR[state], null);
+      if (ctx.table.type === "TOMLTable")
+        applyEndLoc(ctx.table, last(ctx.table.body));
+      applyEndLoc(node2, last(node2.body));
+    }
+    ctx.verifyDuplicateKeys();
+    ast.tokens = ctx.tokens;
+    ast.comments = ctx.comments;
+    const endOffset = ctx.tokenizer.end;
+    const endPos = ctx.tokenizer.getLocFromIndex(endOffset);
+    ast.range[1] = endOffset;
+    ast.loc.end = {
+      line: endPos.line,
+      column: endPos.column
+    };
+    return ast;
+  }
+  TABLE(token, ctx) {
+    if (isBare(token) || isString(token))
+      return this.processKeyValue(token, ctx.table, ctx);
+    if (isLeftBracket(token))
+      return this.processTable(token, ctx.topLevelTable, ctx);
+    return ctx.reportParseError("unexpected-token", token);
+  }
+  VALUE(token, ctx) {
+    if (isString(token) || isMultiLineString(token))
+      return this.processStringValue(token, ctx);
+    if (isNumber(token))
+      return this.processNumberValue(token, ctx);
+    if (isBoolean(token))
+      return this.processBooleanValue(token, ctx);
+    if (isDateTime(token))
+      return this.processDateTimeValue(token, ctx);
+    if (isLeftBracket(token))
+      return this.processArray(token, ctx);
+    if (isLeftBrace(token))
+      return this.processInlineTable(token, ctx);
+    return ctx.reportParseError("unexpected-token", token);
+  }
+  processTable(token, topLevelTableNode, ctx) {
+    const tableNode = {
+      type: "TOMLTable",
+      kind: "standard",
+      key: null,
+      resolvedKey: [],
+      body: [],
+      parent: topLevelTableNode,
+      range: cloneRange(token.range),
+      loc: cloneLoc(token.loc)
+    };
+    if (ctx.table.type === "TOMLTable")
+      applyEndLoc(ctx.table, last(ctx.table.body));
+    topLevelTableNode.body.push(tableNode);
+    ctx.table = tableNode;
+    let targetToken = ctx.nextToken({ needSameLine: "invalid-key-value-newline" });
+    if (isLeftBracket(targetToken)) {
+      if (token.range[1] < targetToken.range[0])
+        return ctx.reportParseError("invalid-space", targetToken);
+      tableNode.kind = "array";
+      targetToken = ctx.nextToken({ needSameLine: "invalid-key-value-newline" });
+    }
+    if (isRightBracket(targetToken))
+      return ctx.reportParseError("missing-key", targetToken);
+    if (!targetToken)
+      return ctx.reportParseError("unterminated-table-key", null);
+    targetToken = this.processKeyNode(targetToken, tableNode, ctx).nextToken;
+    if (!isRightBracket(targetToken))
+      return ctx.reportParseError("unterminated-table-key", targetToken);
+    if (tableNode.kind === "array") {
+      const rightBracket = targetToken;
+      targetToken = ctx.nextToken({ needSameLine: "invalid-key-value-newline" });
+      if (!isRightBracket(targetToken))
+        return ctx.reportParseError("unterminated-table-key", targetToken);
+      if (rightBracket.range[1] < targetToken.range[0])
+        return ctx.reportParseError("invalid-space", targetToken);
+    }
+    applyEndLoc(tableNode, targetToken);
+    ctx.applyResolveKeyForTable(tableNode);
+    ctx.needNewLine = true;
+    return [];
+  }
+  processKeyValue(token, tableNode, ctx) {
+    const keyValueNode = {
+      type: "TOMLKeyValue",
+      key: null,
+      value: null,
+      parent: tableNode,
+      range: cloneRange(token.range),
+      loc: cloneLoc(token.loc)
+    };
+    tableNode.body.push(keyValueNode);
+    const { nextToken: targetToken } = this.processKeyNode(token, keyValueNode, ctx);
+    if (!isEq(targetToken))
+      return ctx.reportParseError("missing-equals-sign", targetToken);
+    ctx.addValueContainer({
+      parent: keyValueNode,
+      set: (valNode) => {
+        keyValueNode.value = valNode;
+        applyEndLoc(keyValueNode, valNode);
+        ctx.needNewLine = true;
+        return [];
+      }
+    });
+    ctx.needSameLine = "invalid-key-value-newline";
+    return ["VALUE"];
+  }
+  processKeyNode(token, parent, ctx) {
+    if (isDot(token))
+      ctx.reportParseError("invalid-leading-dot-in-key", token);
+    const keyNode = {
+      type: "TOMLKey",
+      keys: [],
+      parent,
+      range: cloneRange(token.range),
+      loc: cloneLoc(token.loc)
+    };
+    parent.key = keyNode;
+    let targetToken = token;
+    let dotToken = null;
+    do {
+      if (isBare(targetToken))
+        this.processBareKey(targetToken, keyNode);
+      else if (isString(targetToken))
+        this.processStringKey(targetToken, keyNode);
+      else
+        break;
+      dotToken = null;
+      targetToken = ctx.nextToken({ needSameLine: "invalid-key-value-newline" });
+      if (!isDot(targetToken))
+        break;
+      dotToken = targetToken;
+      targetToken = ctx.nextToken({ needSameLine: "invalid-key-value-newline" });
+    } while (targetToken);
+    if (dotToken)
+      ctx.reportParseError(isDot(targetToken) ? "invalid-consecutive-dots-in-key" : "invalid-trailing-dot-in-key", dotToken);
+    applyEndLoc(keyNode, last(keyNode.keys));
+    return {
+      keyNode,
+      nextToken: targetToken
+    };
+  }
+  processBareKey(token, keyNode) {
+    const node2 = {
+      type: "TOMLBare",
+      name: token.value,
+      parent: keyNode,
+      range: cloneRange(token.range),
+      loc: cloneLoc(token.loc)
+    };
+    keyNode.keys.push(node2);
+  }
+  processStringKey(token, keyNode) {
+    const node2 = {
+      type: "TOMLQuoted",
+      kind: "string",
+      value: token.string,
+      style: STRING_KEY_STYLE_MAP[token.type],
+      multiline: false,
+      parent: keyNode,
+      range: cloneRange(token.range),
+      loc: cloneLoc(token.loc)
+    };
+    keyNode.keys.push(node2);
+  }
+  processStringValue(token, ctx) {
+    const valueContainer = ctx.consumeValueContainer();
+    const node2 = {
+      type: "TOMLValue",
+      kind: "string",
+      value: token.string,
+      style: STRING_VALUE_STYLE_MAP[token.type],
+      multiline: isMultiLineString(token),
+      parent: valueContainer.parent,
+      range: cloneRange(token.range),
+      loc: cloneLoc(token.loc)
+    };
+    return valueContainer.set(node2);
+  }
+  processNumberValue(token, ctx) {
+    const valueContainer = ctx.consumeValueContainer();
+    const text = this.text;
+    const [startRange, endRange] = token.range;
+    let numberString = null;
+    const getNumberText = () => {
+      return numberString ?? (numberString = text.slice(startRange, endRange).replace(/_/g, ""));
+    };
+    let node2;
+    if (token.type === "Integer")
+      node2 = {
+        type: "TOMLValue",
+        kind: "integer",
+        value: token.number,
+        bigint: token.bigint,
+        get number() {
+          return getNumberText();
+        },
+        parent: valueContainer.parent,
+        range: cloneRange(token.range),
+        loc: cloneLoc(token.loc)
+      };
+    else
+      node2 = {
+        type: "TOMLValue",
+        kind: "float",
+        value: token.number,
+        get number() {
+          return getNumberText();
+        },
+        parent: valueContainer.parent,
+        range: cloneRange(token.range),
+        loc: cloneLoc(token.loc)
+      };
+    return valueContainer.set(node2);
+  }
+  processBooleanValue(token, ctx) {
+    const valueContainer = ctx.consumeValueContainer();
+    const node2 = {
+      type: "TOMLValue",
+      kind: "boolean",
+      value: token.boolean,
+      parent: valueContainer.parent,
+      range: cloneRange(token.range),
+      loc: cloneLoc(token.loc)
+    };
+    return valueContainer.set(node2);
+  }
+  processDateTimeValue(token, ctx) {
+    const valueContainer = ctx.consumeValueContainer();
+    const node2 = {
+      type: "TOMLValue",
+      kind: DATETIME_VALUE_KIND_MAP[token.type],
+      value: token.date,
+      datetime: token.value,
+      parent: valueContainer.parent,
+      range: cloneRange(token.range),
+      loc: cloneLoc(token.loc)
+    };
+    return valueContainer.set(node2);
+  }
+  processArray(token, ctx) {
+    const valueContainer = ctx.consumeValueContainer();
+    const node2 = {
+      type: "TOMLArray",
+      elements: [],
+      parent: valueContainer.parent,
+      range: cloneRange(token.range),
+      loc: cloneLoc(token.loc)
+    };
+    const nextToken = ctx.nextToken({ valuesEnabled: true });
+    if (isRightBracket(nextToken)) {
+      applyEndLoc(node2, nextToken);
+      return valueContainer.set(node2);
+    }
+    ctx.backToken();
+    return this.processArrayValue(node2, valueContainer, ctx);
+  }
+  processArrayValue(node2, valueContainer, ctx) {
+    ctx.addValueContainer({
+      parent: node2,
+      set: (valNode) => {
+        node2.elements.push(valNode);
+        let nextToken = ctx.nextToken({ valuesEnabled: true });
+        const hasComma = isComma(nextToken);
+        if (hasComma)
+          nextToken = ctx.nextToken({ valuesEnabled: true });
+        if (isRightBracket(nextToken)) {
+          applyEndLoc(node2, nextToken);
+          return valueContainer.set(node2);
+        }
+        if (hasComma) {
+          ctx.backToken();
+          return this.processArrayValue(node2, valueContainer, ctx);
+        }
+        return ctx.reportParseError(nextToken ? "missing-comma" : "unterminated-array", nextToken);
+      }
+    });
+    return ["VALUE"];
+  }
+  processInlineTable(token, ctx) {
+    const valueContainer = ctx.consumeValueContainer();
+    const node2 = {
+      type: "TOMLInlineTable",
+      body: [],
+      parent: valueContainer.parent,
+      range: cloneRange(token.range),
+      loc: cloneLoc(token.loc)
+    };
+    const needSameLine = this.tomlVersion.gte(1, 1) ? undefined : "invalid-inline-table-newline";
+    const nextToken = ctx.nextToken({ needSameLine });
+    if (nextToken) {
+      if (isBare(nextToken) || isString(nextToken))
+        return this.processInlineTableKeyValue(nextToken, node2, valueContainer, ctx);
+      if (isRightBrace(nextToken)) {
+        applyEndLoc(node2, nextToken);
+        return valueContainer.set(node2);
+      }
+    }
+    return ctx.reportParseError("unexpected-token", nextToken);
+  }
+  processInlineTableKeyValue(token, inlineTableNode, valueContainer, ctx) {
+    const keyValueNode = {
+      type: "TOMLKeyValue",
+      key: null,
+      value: null,
+      parent: inlineTableNode,
+      range: cloneRange(token.range),
+      loc: cloneLoc(token.loc)
+    };
+    inlineTableNode.body.push(keyValueNode);
+    const { nextToken: targetToken } = this.processKeyNode(token, keyValueNode, ctx);
+    if (!isEq(targetToken))
+      return ctx.reportParseError("missing-equals-sign", targetToken);
+    const needSameLine = this.tomlVersion.gte(1, 1) ? undefined : "invalid-inline-table-newline";
+    ctx.addValueContainer({
+      parent: keyValueNode,
+      set: (valNode) => {
+        keyValueNode.value = valNode;
+        applyEndLoc(keyValueNode, valNode);
+        let nextToken = ctx.nextToken({ needSameLine });
+        if (isComma(nextToken)) {
+          nextToken = ctx.nextToken({ needSameLine });
+          if (nextToken && (isBare(nextToken) || isString(nextToken)))
+            return this.processInlineTableKeyValue(nextToken, inlineTableNode, valueContainer, ctx);
+          if (isRightBrace(nextToken)) {
+            if (this.tomlVersion.lt(1, 1))
+              return ctx.reportParseError("invalid-trailing-comma-in-inline-table", nextToken);
+          } else
+            return ctx.reportParseError(nextToken ? "unexpected-token" : "unterminated-inline-table", nextToken);
+        }
+        if (isRightBrace(nextToken)) {
+          applyEndLoc(inlineTableNode, nextToken);
+          return valueContainer.set(inlineTableNode);
+        }
+        return ctx.reportParseError(nextToken ? "missing-comma" : "unterminated-inline-table", nextToken);
+      }
+    });
+    ctx.needSameLine = "invalid-key-value-newline";
+    return ["VALUE"];
+  }
+};
+function isDot(token) {
+  return isPunctuator(token) && token.value === ".";
+}
+function isEq(token) {
+  return isPunctuator(token) && token.value === "=";
+}
+function isLeftBracket(token) {
+  return isPunctuator(token) && token.value === "[";
+}
+function isRightBracket(token) {
+  return isPunctuator(token) && token.value === "]";
+}
+function isLeftBrace(token) {
+  return isPunctuator(token) && token.value === "{";
+}
+function isRightBrace(token) {
+  return isPunctuator(token) && token.value === "}";
+}
+function isComma(token) {
+  return isPunctuator(token) && token.value === ",";
+}
+function isPunctuator(token) {
+  return Boolean(token && token.type === "Punctuator");
+}
+function isBare(token) {
+  return token.type === "Bare";
+}
+function isString(token) {
+  return token.type === "BasicString" || token.type === "LiteralString";
+}
+function isMultiLineString(token) {
+  return token.type === "MultiLineBasicString" || token.type === "MultiLineLiteralString";
+}
+function isNumber(token) {
+  return token.type === "Integer" || token.type === "Float";
+}
+function isBoolean(token) {
+  return token.type === "Boolean";
+}
+function isDateTime(token) {
+  return token.type === "OffsetDateTime" || token.type === "LocalDateTime" || token.type === "LocalDate" || token.type === "LocalTime";
+}
+function applyEndLoc(node2, child) {
+  if (child) {
+    node2.range[1] = child.range[1];
+    node2.loc.end = clonePos(child.loc.end);
+  }
+}
+function cloneRange(range) {
+  return [range[0], range[1]];
+}
+function cloneLoc(loc) {
+  return {
+    start: clonePos(loc.start),
+    end: clonePos(loc.end)
+  };
+}
+function clonePos(pos) {
+  return {
+    line: pos.line,
+    column: pos.column
+  };
+}
+var tomlKeys = {
+  Program: ["body"],
+  TOMLTopLevelTable: ["body"],
+  TOMLTable: ["key", "body"],
+  TOMLKeyValue: ["key", "value"],
+  TOMLKey: ["keys"],
+  TOMLArray: ["elements"],
+  TOMLInlineTable: ["body"],
+  TOMLBare: [],
+  TOMLQuoted: [],
+  TOMLValue: []
+};
+var KEYS2 = unionWith(tomlKeys);
+function parseForESLint(code, options) {
+  return {
+    ast: new TOMLParser(code, options).parse(),
+    visitorKeys: KEYS2,
+    services: { isTOML: true }
+  };
+}
+var getStaticTOMLValue = generateConvertTOMLValue((node2) => node2.value);
+function generateConvertTOMLValue(convertValue) {
+  function resolveValue(node2, baseTable) {
+    return resolver[node2.type](node2, baseTable);
+  }
+  const resolver = {
+    Program(node2, baseTable = {}) {
+      return resolveValue(node2.body[0], baseTable);
+    },
+    TOMLTopLevelTable(node2, baseTable = {}) {
+      for (const body of node2.body)
+        resolveValue(body, baseTable);
+      return baseTable;
+    },
+    TOMLKeyValue(node2, baseTable = {}) {
+      const value = resolveValue(node2.value);
+      set(baseTable, resolveValue(node2.key), value);
+      return baseTable;
+    },
+    TOMLTable(node2, baseTable = {}) {
+      const table = getTable(baseTable, resolveValue(node2.key), node2.kind === "array");
+      for (const body of node2.body)
+        resolveValue(body, table);
+      return baseTable;
+    },
+    TOMLArray(node2) {
+      return node2.elements.map((e) => resolveValue(e));
+    },
+    TOMLInlineTable(node2) {
+      const table = {};
+      for (const body of node2.body)
+        resolveValue(body, table);
+      return table;
+    },
+    TOMLKey(node2) {
+      return node2.keys.map((key) => resolveValue(key));
+    },
+    TOMLBare(node2) {
+      return node2.name;
+    },
+    TOMLQuoted(node2) {
+      return node2.value;
+    },
+    TOMLValue(node2) {
+      return convertValue(node2);
+    }
+  };
+  return (node2) => resolveValue(node2);
+}
+function getTable(baseTable, keys, array) {
+  let target = baseTable;
+  for (let index = 0;index < keys.length - 1; index++) {
+    const key = keys[index];
+    target = getNextTargetFromKey(target, key);
+  }
+  const lastKey = last(keys);
+  const lastTarget = target[lastKey];
+  if (lastTarget == null) {
+    const tableValue$1 = {};
+    target[lastKey] = array ? [tableValue$1] : tableValue$1;
+    return tableValue$1;
+  }
+  if (isValue(lastTarget)) {
+    const tableValue$1 = {};
+    target[lastKey] = array ? [tableValue$1] : tableValue$1;
+    return tableValue$1;
+  }
+  if (!array) {
+    if (Array.isArray(lastTarget)) {
+      const tableValue$1 = {};
+      target[lastKey] = tableValue$1;
+      return tableValue$1;
+    }
+    return lastTarget;
+  }
+  if (Array.isArray(lastTarget)) {
+    const tableValue$1 = {};
+    lastTarget.push(tableValue$1);
+    return tableValue$1;
+  }
+  const tableValue = {};
+  target[lastKey] = [tableValue];
+  return tableValue;
+  function getNextTargetFromKey(currTarget, key) {
+    const nextTarget = currTarget[key];
+    if (nextTarget == null) {
+      const val = {};
+      currTarget[key] = val;
+      return val;
+    }
+    if (isValue(nextTarget)) {
+      const val = {};
+      currTarget[key] = val;
+      return val;
+    }
+    let resultTarget = nextTarget;
+    while (Array.isArray(resultTarget)) {
+      const lastIndex = resultTarget.length - 1;
+      const nextElement = resultTarget[lastIndex];
+      if (isValue(nextElement)) {
+        const val = {};
+        resultTarget[lastIndex] = val;
+        return val;
+      }
+      resultTarget = nextElement;
+    }
+    return resultTarget;
+  }
+}
+function set(baseTable, keys, value) {
+  let target = baseTable;
+  for (let index = 0;index < keys.length - 1; index++) {
+    const key = keys[index];
+    const nextTarget = target[key];
+    if (nextTarget == null) {
+      const val = {};
+      target[key] = val;
+      target = val;
+    } else if (isValue(nextTarget) || Array.isArray(nextTarget)) {
+      const val = {};
+      target[key] = val;
+      target = val;
+    } else
+      target = nextTarget;
+  }
+  target[last(keys)] = value;
+}
+function isValue(value) {
+  return typeof value !== "object" || value instanceof Date;
+}
+function parseTOML(code, options) {
+  return parseForESLint(code, options).ast;
+}
+
+// src/configEvidenceParser.ts
+var import_yaml2 = __toESM(require_dist(), 1);
+var SECRET_TOKEN2 = /^(?:password|passwd|pwd|secret|token|credential|credentials|authorization|cookie)$/u;
+var SECRET_COMPOUND2 = /^(?:api-key|access-key|private-key|client-secret|access-token|refresh-token)$/u;
+var SECRET_VALUE = /^(?:[a-z][a-z0-9+.-]*:\/\/[^\s/@:]+:[^\s/@]+@)|[?&](?:access_token|refresh_token|api_key|password|secret)=/iu;
+var REFERENCE_KEY = /(?:path|file|url|uri|endpoint|module|package|import|include|extends|schema|ref)$/iu;
+var REFERENCE_VALUE = /^(?:[a-z][a-z0-9+.-]*:\/\/|\.\.?(?:\/|$)|[~@]?[a-z0-9_.-]+\/[a-z0-9_./-]+|[a-z0-9_.-]+\.(?:json|ya?ml|toml|js|mjs|cjs|ts|tsx|css|scss))$/iu;
+var BOUNDARY_PATTERNS = [
+  ["entry", /^(?:entry|entries|main|bootstrap|startup)$/iu],
+  ["route", /^(?:route|routes|router|routing|path)$/iu],
+  ["build", /^(?:build|bundle|bundler|compiler|compile|output|outdir|target)$/iu],
+  ["protocol", /^(?:protocol|schema|schemas|api|rpc|openapi|graphql|protobuf|thrift)$/iu],
+  ["runtime", /^(?:runtime|host|port|server|environment|env|command|args)$/iu],
+  ["dependency", /^(?:dependencies|dependency|imports|includes|extends|plugins)$/iu]
+];
+function pathIdentity(path5) {
+  return JSON.stringify(path5);
+}
+function qualifiedItemPath(path5) {
+  if (path5.length === 0)
+    return "config:/";
+  return `config:/${path5.map((segment) => segment.replace(/~/gu, "~0").replace(/\//gu, "~1")).join("/")}`;
+}
+function locator(filePath, keyPath, location) {
+  return {
+    path: filePath,
+    line: Math.max(1, location.line),
+    column: Math.max(1, location.column),
+    qualified_item_path: qualifiedItemPath(keyPath)
+  };
+}
+function normalizedKeySegment(segment) {
+  return segment.replace(/([a-z0-9])([A-Z])/gu, "$1-$2").replace(/[^A-Za-z0-9]+/gu, "-").toLowerCase();
+}
+function secretLike(keyPath, value) {
+  const keySecret = keyPath.some((segment) => {
+    const normalized = normalizedKeySegment(segment);
+    return SECRET_COMPOUND2.test(normalized) || normalized.split("-").some((token) => SECRET_TOKEN2.test(token));
+  });
+  return keySecret || typeof value === "string" && SECRET_VALUE.test(value);
+}
+function boundaryCandidate(keyPath) {
+  for (let index = keyPath.length - 1;index >= 0; index -= 1) {
+    const segment = keyPath[index];
+    for (const [candidate, pattern] of BOUNDARY_PATTERNS) {
+      if (pattern.test(segment))
+        return candidate;
+    }
+  }
+  return null;
+}
+function valueType(value) {
+  if (value === null)
+    return "null";
+  if (value instanceof Date)
+    return "datetime";
+  if (Array.isArray(value))
+    return "array";
+  if (typeof value === "object")
+    return "object";
+  if (typeof value === "string")
+    return "string";
+  if (typeof value === "boolean")
+    return "boolean";
+  return "number";
+}
+function digestableScalar(value) {
+  if (typeof value === "bigint")
+    return { integer: value.toString() };
+  if (value instanceof Date)
+    return { datetime: value.toISOString() };
+  return value;
+}
+function allowlistedScalar(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return value;
+  if (typeof value === "number" && Number.isFinite(value) && (!Number.isInteger(value) || Number.isSafeInteger(value)))
+    return value;
+  return;
+}
+function scalarEqual(left, right) {
+  return Object.is(left, right);
+}
+function classify(keyPath, value, isContainer, isSecret, exposed) {
+  if (isContainer)
+    return "container";
+  if (isSecret)
+    return "secret-like";
+  if (exposed)
+    return "enum-allowlisted";
+  const finalKey = keyPath.at(-1) ?? "";
+  if (typeof value === "string" && (REFERENCE_KEY.test(finalKey) || REFERENCE_VALUE.test(value))) {
+    return "reference-like";
+  }
+  return "scalar";
+}
+function addValue(context, keyPath, value, location) {
+  const type = valueType(value);
+  const isContainer = type === "object" || type === "array";
+  const allowlist = context.allowlist.get(pathIdentity(keyPath));
+  const scalar = allowlistedScalar(value);
+  const isSecret = secretLike(keyPath, value);
+  const exposed = !isSecret && scalar !== undefined && allowlist !== undefined && allowlist.allowed_values.some((allowed) => scalarEqual(allowed, scalar));
+  if (allowlist && scalar !== undefined && !exposed && !isSecret) {
+    context.diagnostics.push({
+      code: "config-enum-value-not-allowlisted",
+      severity: "warning",
+      locator: locator(context.path, keyPath, location),
+      detail: "configured enum allowlist does not include the parsed scalar"
+    });
+  }
+  const classification = classify(keyPath, value, isContainer, isSecret, exposed);
+  const digestSafe = !(typeof value === "number" && (!Number.isFinite(value) || Number.isInteger(value) && !Number.isSafeInteger(value)));
+  context.values.push({
+    config_ref: context.configRef,
+    key_path: keyPath,
+    value_type: type,
+    classification,
+    boundary_candidate: boundaryCandidate(keyPath),
+    value_digest: isContainer || classification === "secret-like" || !digestSafe ? null : indexerEvidenceAdapterProtocolDigest({ type, value: digestableScalar(value) }),
+    ...exposed ? { normalized_value: scalar } : {},
+    locator: locator(context.path, keyPath, location)
+  });
+}
+function walkValue(context, value, keyPath, locate) {
+  addValue(context, keyPath, value, locate(keyPath));
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => walkValue(context, item, [...keyPath, String(index)], locate));
+    return;
+  }
+  if (value !== null && typeof value === "object" && !(value instanceof Date)) {
+    for (const [key, item] of Object.entries(value)) {
+      walkValue(context, item, [...keyPath, key], locate);
+    }
+  }
+}
+function validateYamlKeys(node2) {
+  if (!node2)
+    return;
+  if (import_yaml2.isMap(node2)) {
+    for (const pair of node2.items) {
+      if (!import_yaml2.isScalar(pair.key) || typeof pair.key.value !== "string") {
+        throw new TypeError("YAML mapping keys must be scalar strings");
+      }
+      validateYamlKeys(pair.value);
+    }
+  } else if (import_yaml2.isSeq(node2)) {
+    for (const item of node2.items)
+      validateYamlKeys(item);
+  }
+}
+function yamlLocation(document, lineCounter, logicalPath, documentPrefixLength) {
+  const yamlPath = logicalPath.slice(documentPrefixLength).map((segment) => /^\d+$/u.test(segment) ? Number(segment) : segment);
+  const node2 = document.getIn(yamlPath, true);
+  const offset = node2?.range?.[0] ?? document.contents?.range?.[0] ?? 0;
+  const position = lineCounter.linePos(offset);
+  return { line: position.line, column: position.col };
+}
+function parseYamlLike(context, source, strictJson) {
+  if (strictJson)
+    JSON.parse(source);
+  const lineCounter = new import_yaml2.LineCounter;
+  const documents = strictJson ? [import_yaml2.parseDocument(source, { lineCounter, schema: "json", strict: true, uniqueKeys: true })] : import_yaml2.parseAllDocuments(source, { lineCounter, strict: true, uniqueKeys: true });
+  if (documents.length === 0)
+    throw new TypeError("configuration document is empty");
+  for (const [documentIndex, document] of documents.entries()) {
+    if (document.errors.length > 0)
+      throw new TypeError("configuration syntax is invalid");
+    validateYamlKeys(document.contents);
+    const value = document.toJS({ maxAliasCount: 100 });
+    const prefix = documents.length > 1 ? ["$document", String(documentIndex)] : [];
+    walkValue(context, value, prefix, (path5) => yamlLocation(document, lineCounter, path5, prefix.length));
+  }
+}
+function tomlKey(node2) {
+  return node2.keys.map((item) => item.type === "TOMLBare" ? item.name : item.value);
+}
+function tomlLocations(ast) {
+  const locations = new Map;
+  const remember = (path5, node2) => {
+    locations.set(pathIdentity(path5), { line: node2.loc.start.line, column: node2.loc.start.column + 1 });
+  };
+  const walkContent = (node2, path5) => {
+    remember(path5, node2);
+    if (node2.type === "TOMLArray") {
+      node2.elements.forEach((element, index) => walkContent(element, [...path5, String(index)]));
+    } else if (node2.type === "TOMLInlineTable") {
+      for (const item of node2.body) {
+        const itemPath = [...path5, ...tomlKey(item.key)];
+        remember(itemPath, item.key);
+        walkContent(item.value, itemPath);
+      }
+    }
+  };
+  remember([], ast);
+  for (const item of ast.body[0].body) {
+    if (item.type === "TOMLKeyValue") {
+      const itemPath = tomlKey(item.key);
+      remember(itemPath, item.key);
+      walkContent(item.value, itemPath);
+      continue;
+    }
+    const tablePath = item.resolvedKey.map(String);
+    remember(tablePath, item.key);
+    for (const entry of item.body) {
+      const entryPath = [...tablePath, ...tomlKey(entry.key)];
+      remember(entryPath, entry.key);
+      walkContent(entry.value, entryPath);
+    }
+  }
+  return locations;
+}
+function parseToml(context, source) {
+  const ast = parseTOML(source, { tomlVersion: "1.0.0" });
+  const value = getStaticTOMLValue(ast);
+  const locations = tomlLocations(ast);
+  walkValue(context, value, [], (path5) => locations.get(pathIdentity(path5)) ?? { line: 1, column: 1 });
+}
+function detectFormat(path5) {
+  const lower = path5.toLowerCase();
+  if (lower.endsWith(".json"))
+    return "json";
+  if (lower.endsWith(".yaml") || lower.endsWith(".yml"))
+    return "yaml";
+  if (lower.endsWith(".toml"))
+    return "toml";
+  return "excluded";
+}
+function validatePath(path5) {
+  const segments = path5.split("/");
+  if (!path5 || path5.includes("\\") || path5.startsWith("/") || segments.some((segment) => !segment || segment === "." || segment === "..")) {
+    throw new TypeError(`config path must be a portable relative path: ${path5}`);
+  }
+}
+function validatedAllowlists(options) {
+  const byFile = new Map;
+  for (const entry of options.non_sensitive_enums ?? []) {
+    validatePath(entry.path);
+    if (entry.key_path.length === 0)
+      throw new TypeError("config enum allowlist cannot target the document root");
+    if (secretLike(entry.key_path))
+      throw new TypeError("config enum allowlist cannot target a secret-like key path");
+    if (entry.allowed_values.length === 0)
+      throw new TypeError("config enum allowlist must declare at least one value");
+    const identities = entry.allowed_values.map((value) => JSON.stringify([typeof value, value]));
+    if (new Set(identities).size !== identities.length)
+      throw new TypeError("config enum allowlist contains duplicate values");
+    const fileEntries = byFile.get(entry.path) ?? new Map;
+    const identity = pathIdentity(entry.key_path);
+    if (fileEntries.has(identity))
+      throw new TypeError("config enum allowlist contains a duplicate file and key path");
+    fileEntries.set(identity, entry);
+    byFile.set(entry.path, fileEntries);
+  }
+  return byFile;
+}
+function parseOne(path5, source, format, allowlist) {
+  if (format === "excluded")
+    return { path: path5, format, disposition: "excluded", values: [], diagnostics: [] };
+  const context = {
+    path: path5,
+    format,
+    configRef: `config:${indexerEvidenceAdapterProtocolDigest({ path: path5, format })}`,
+    allowlist,
+    diagnostics: [],
+    values: []
+  };
+  try {
+    if (format === "toml")
+      parseToml(context, source);
+    else
+      parseYamlLike(context, source, format === "json");
+    return { path: path5, format, disposition: "analyzed", values: context.values, diagnostics: context.diagnostics };
+  } catch {
+    const root = locator(path5, [], { line: 1, column: 1 });
+    return {
+      path: path5,
+      format,
+      disposition: "unsupported",
+      values: [],
+      diagnostics: [{ code: "config-source-unsupported", severity: "error", locator: root, detail: `${format} configuration could not be analyzed` }]
+    };
+  }
+}
+function parseConfigSources(files, options = {}) {
+  const allowlists = validatedAllowlists(options);
+  return Object.entries(files).sort(([left], [right]) => left.localeCompare(right)).map(([path5, source]) => {
+    validatePath(path5);
+    return parseOne(path5, source, detectFormat(path5), allowlists.get(path5) ?? new Map);
+  });
+}
+// src/configEvidenceAdapter.ts
+function assertModuleAuthorized(moduleRef, invocation) {
+  if (moduleRef !== null && !invocation.authorized_scope.module_refs.includes(moduleRef)) {
+    throw new TypeError(`config module ${moduleRef} escapes authorized scope`);
+  }
+}
+function fact3(document, value, invocation, moduleRef) {
+  const semantic = {
+    config_ref: value.config_ref,
+    key_path: value.key_path,
+    value_type: value.value_type,
+    classification: value.classification,
+    boundary_candidate: value.boundary_candidate,
+    value_digest: value.value_digest,
+    ...value.normalized_value !== undefined ? { normalized_value: value.normalized_value } : {},
+    locator: value.locator
+  };
+  return createIndexerEvidenceAdapterFact({
+    source_ref: invocation.authorized_scope.source_ref,
+    module_ref: moduleRef,
+    normalized_path: document.path,
+    qualified_item_path: value.locator.qualified_item_path,
+    kind: "config-value",
+    signature: semantic,
+    payload: semantic,
+    denominator: "none"
+  });
+}
+function configSourcesToEvidenceAdapterResult(files, invocation, options = {}) {
+  const role = invocation.role ?? "primary-owner";
+  const documents = parseConfigSources(files, options);
+  const diagnostics = [];
+  const evidenceFiles = documents.map((document) => {
+    const moduleRef = invocation.module_refs?.[document.path] ?? null;
+    assertModuleAuthorized(moduleRef, invocation);
+    const fileRef = indexerEvidenceAdapterFileRef({
+      source_ref: invocation.authorized_scope.source_ref,
+      module_ref: moduleRef,
+      normalized_path: document.path
+    });
+    for (const diagnostic of document.diagnostics) {
+      diagnostics.push({
+        code: diagnostic.code,
+        severity: diagnostic.severity,
+        fact_ref: fileRef,
+        detail_digest: indexerEvidenceAdapterProtocolDigest({
+          locator: diagnostic.locator,
+          detail: diagnostic.detail
+        })
+      });
+    }
+    const sourceFact = document.disposition === "analyzed" ? createIndexerEvidenceAdapterFact({
+      source_ref: invocation.authorized_scope.source_ref,
+      module_ref: moduleRef,
+      normalized_path: document.path,
+      qualified_item_path: "file",
+      kind: "source-file",
+      signature: { catalog: "config", format: document.format, tier: "lightweight-evidence" },
+      payload: { path: document.path, format: document.format },
+      denominator: "none"
+    }) : null;
+    return {
+      file_ref: fileRef,
+      source_ref: invocation.authorized_scope.source_ref,
+      module_ref: moduleRef,
+      normalized_path: document.path,
+      role,
+      coverage_tier: "lightweight-evidence",
+      disposition: document.disposition,
+      facts: sourceFact === null ? [] : [sourceFact, ...document.values.map((value) => fact3(document, value, invocation, moduleRef))]
+    };
+  });
+  return buildIndexerEvidenceAdapterResult({
+    protocol: "context.indexer.evidence-adapter-result/v1",
+    adapter: invocation.adapter,
+    authorized_scope: invocation.authorized_scope,
+    input_digest: invocation.input_digest,
+    precedence: invocation.precedence,
+    files: evidenceFiles,
+    diagnostics,
+    toolchain: [{
+      step: "parse-config-evidence",
+      package: invocation.adapter.package,
+      export: invocation.adapter.export,
+      version: invocation.adapter.version,
+      digest: invocation.adapter.digest,
+      capabilities: ["config-boundary-candidates", "config-schema-neutral", "parser.json", "parser.toml", "parser.yaml"],
+      input_digest: invocation.input_digest,
+      output_digest: indexerEvidenceAdapterProtocolDigest(documents)
+    }]
+  });
+}
+function configSourcesToEvidenceAdapterMaterialization(files, invocation, options = {}) {
+  return materializeIndexerEvidenceAdapterResult(configSourcesToEvidenceAdapterResult(files, invocation, options));
+}
+// src/parser.ts
+import * as WebTreeSitter from "web-tree-sitter";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+var treeSitterRuntime = WebTreeSitter;
+var Parser = treeSitterRuntime.default ?? treeSitterRuntime.Parser;
+if (!Parser) {
+  throw new TypeError("web-tree-sitter runtime does not expose Parser");
+}
+var parserInitPromise = null;
+var parsedBytesSinceReset = 0;
+var parserDead = false;
+var PARSER_RESET_THRESHOLD = 16 * 1024 * 1024;
+var resolveWasmPath = (relativePath) => fileURLToPath(new URL(relativePath, import.meta.url));
+var createParserInstance = async () => {
+  const localWasm = resolveWasmPath("./wasm/tree-sitter.wasm");
+  const initOptions = existsSync(localWasm) ? { locateFile: (scriptName) => resolveWasmPath(`./wasm/${scriptName}`) } : undefined;
+  await Parser.init(initOptions);
+  const LanguageRuntime = treeSitterRuntime.default?.Language ?? treeSitterRuntime.Language;
+  if (!LanguageRuntime) {
+    throw new TypeError("web-tree-sitter runtime does not expose Language after initialization");
+  }
+  const parser = new Parser;
+  const tsLanguage = await LanguageRuntime.load(resolveWasmPath("./wasm/tree-sitter-typescript.wasm"));
+  const tsxLanguage = await LanguageRuntime.load(resolveWasmPath("./wasm/tree-sitter-tsx.wasm"));
+  return { parser, tsLanguage, tsxLanguage };
+};
+var initParser = async () => {
+  if (!parserInitPromise) {
+    parserInitPromise = (async () => {
+      try {
+        parsedBytesSinceReset = 0;
+        return await createParserInstance();
+      } catch (error) {
+        parserInitPromise = null;
+        throw error;
+      }
+    })();
+  }
+  return parserInitPromise;
+};
+var resetParser = () => {
+  parserInitPromise = null;
+  parsedBytesSinceReset = 0;
+  parserDead = false;
+};
+var tryParse = async (source, isTsx) => {
+  const { parser, tsLanguage, tsxLanguage } = await initParser();
+  parser.setLanguage(isTsx ? tsxLanguage : tsLanguage);
+  const tree = parser.parse(source);
+  parsedBytesSinceReset += source.length;
+  if (tree.rootNode.hasError()) {
+    return null;
+  }
+  return tree;
+};
+var parseFile = async (source, isTsx) => {
+  if (parserDead)
+    return null;
+  if (parsedBytesSinceReset > PARSER_RESET_THRESHOLD) {
+    resetParser();
+  }
+  try {
+    return await tryParse(source, isTsx);
+  } catch {
     resetParser();
   }
   try {
@@ -15622,95 +19117,226 @@ var detectTechStack = async (repoPath) => {
   }
   return labels;
 };
+
+// src/index.ts
+var CONFIG_EVIDENCE_ADAPTER_EXPORT = "configSourcesToEvidenceAdapterResult";
 export {
+  visibilitySchema,
   truncateSourceSpanHash,
+  transitionAtomSchema,
   symbolParamSchema,
+  symbolKindSchema,
   symbolInfoSchema,
   symbolDiffSchema,
+  stripSearchPrefix,
+  stateAtomSchema,
   stableStringify,
+  sourceSpanSchema,
   sourceSpanHashMatches,
+  sourceRefSpanSchema,
+  sourceRefSchema,
   sourceInfoSchema,
+  serializeYaml,
+  sectionSchema,
   scanSourceFiles,
   runRepositoryExtraction,
   runCodeExtractRunner,
   runCodeExtractCliFromFile,
   runCodeExtractCli,
+  ruleAtomSchema,
+  roleAtomSchema,
   resolveRepoRelativePath,
+  resolvePathFilter,
   resolveModuleFsPath,
   resolveModuleDir,
   relationInfoSchema,
+  relationAtomSchema,
+  relatedFactSchema,
+  redactIndexerOutputText,
+  redactIndexerOutput,
+  productKindSchema,
   prefixSymbolPaths,
   prefixExtractionPaths,
   prefixEntryDetectionPaths,
   patternDetectionResultSchema,
+  parseYaml,
   parseSpanSourceRef,
+  parseRef,
   parseFile,
   parseDocumentSourceLocator,
   parseDocumentSnapshotManifest,
   parseDocumentResourceMaterialization,
   parseDocumentCaptureFidelity,
+  parseConfigSources,
+  paragraphAtomSchema,
+  packageKindSchema,
   normalizeSnapshotRelativePath,
   normalizeRelativePath,
   normalizeMarkdownDocument,
   normalizeExtractionPaths,
   normalizeDocumentSourceName,
+  nodeTypeSchema,
+  nodeSchema,
+  metricMilestoneSchema,
+  metricAtomSchema,
   metaText,
+  mergeDefaults,
+  materializeIndexerEvidenceAdapterResult,
+  matchesPathFilter,
+  mapErrorCodeToStatus,
   manifestTypeSchema,
   manifestText,
   manifestInfoSchema,
   loadSourceInfo,
   loadRunnerPlugins,
   jsonl,
+  isVersionVisible,
   isScanExcludedDir,
+  isRefPointer,
+  isPlainObject,
+  isPathSafe,
   isNonBlockingDocumentResourceFailureReasonCode,
+  isIndexableFile,
   initParser,
+  indexerEvidenceAdapterResultSchema,
+  indexerEvidenceAdapterProtocolDigest,
+  indexerEvidenceAdapterOutputDigest,
+  indexerEvidenceAdapterFileSchema,
+  indexerEvidenceAdapterFileRef,
+  indexerEvidenceAdapterFactSchema,
+  indexerEvidenceAdapterFactRef,
+  indexerEvidenceAdapterFactPayloads,
   hashStable,
+  hasExcludedSegment,
+  groundingSchema,
+  globToRegex,
   getGitCommitHash,
+  getFileExtension,
+  generateUUID,
   generateSymbolDiff,
+  generateId,
   generateDigest,
   formatSpanSourceRef,
   formatCanonicalProseSourceRef,
   flattenSymbols,
   fileInfoSchema,
+  factStatusSchema,
+  factSourceTypeSchema,
+  factSchemaBase,
+  factSchema,
+  factRelationSchema,
+  factKindSchema,
+  factConfidenceSchema,
   extractionStatsSchema,
+  extractionResultToEvidenceAdapterResult,
+  extractionResultToEvidenceAdapterMaterialization,
   extractionResultSchema,
   extractionPackageSchema,
   extractionMetaSchema,
+  extractionDiagnosticSchema,
+  extractionCoverageSchema,
+  extractAllRefs,
+  eventAtomSchema,
   entryFileSchema,
   entryDetectionResultSchema,
+  entityAtomSchema,
+  encodeVersionLabel,
   encodeSnapshotLocatorPath,
+  embeddingEntrySchema,
+  edgeTypeSchema,
+  edgeSourceSchema,
+  edgeSchema,
+  docDigestSchema,
+  docChunkResultSchema,
+  docChunkParagraphSchema,
   digestStatsSchema,
   digestDataSchema,
   detectTechStack,
   detectModules,
   detectModuleBoundaries,
   detectModuleAt,
+  defaultRegistry,
   decodeSnapshotLocatorPath,
+  decisionPhaseSchema,
+  decisionAtomSchema,
+  createPathMatcher,
   createModuleFileSystem,
+  createIndexerEvidenceAdapterFact,
   createDocumentSourceSpan,
   createDocumentSnapshotManifest,
   createDocumentSnapshotFileEntry,
   countMarkdownLines,
+  contentHash,
+  constraintAtomSchema,
+  configSourcesToEvidenceAdapterResult,
+  configSourcesToEvidenceAdapterMaterialization,
   computeLogicalRawHash,
   computeDocumentContentHash,
+  comparisonDimensionValueSchema,
+  comparisonDimensionSchema,
+  comparisonAtomSchema,
   codeExtractRunnerInputSchema,
   canonicalizeCodeVersionLabel,
   buildSourceFileHashId,
+  buildSearchPrefix,
+  buildRef,
   buildPackageHashId,
+  buildIndexerEvidenceAdapterResult,
   buildHashId,
   buildEdgeHashId,
   buildDigestData,
   buildCodeSnapshot,
+  boundaryAtomSchema,
+  behaviorAtomSchema,
+  attributeAtomSchema,
+  assertIndexerOutputSafe,
+  Visibility,
+  UPLOAD_MAX_FILE_SIZE,
+  UPLOAD_MAX_FILES,
+  UPLOAD_ALLOWED_EXTENSIONS,
+  TEXT_EXTENSIONS,
+  SymbolKind,
+  SUPERTEST_USER_NAME,
+  SUPERTEST_EMAIL,
   SCAN_EXCLUDED_DIRS,
+  RESERVED_USER_NAMES,
+  ProductKind,
+  PathFilterConfigSchema,
+  PackageKind,
   PACKAGE_JSON,
+  NodeType,
   NO_ENTRY_DETECTED,
+  INDEXER_OUTPUT_REDACTION_MARKER,
+  INDEXABLE_EXTENSIONS,
+  INDEXABLE_DOC_EXTENSIONS,
+  INDEXABLE_CODE_EXTENSIONS,
+  Grounding,
   GO_MOD,
+  FactStatus,
+  FactSourceType,
+  FactRelation,
+  FactKind,
+  FactConfidence,
   ExtractionPluginRegistry,
   ExtractionInputError,
+  ErrorCode,
+  EdgeType,
+  EdgeSource,
   DOCUMENT_SNAPSHOT_MANIFEST_SCHEMA_VERSION,
   DOCUMENT_RESOURCE_SOURCE_MISSING_REASON_CODE,
   DOCUMENT_RESOURCE_PERMISSION_DENIED_REASON_CODE,
   DOCUMENT_EVIDENCE_NORMALIZER_VERSION,
+  DEFAULT_WORKSPACE_NAME,
   DEFAULT_SOURCE_SPAN_HASH_LENGTH,
-  CODE_SNAPSHOT_META_SCHEMA_VERSION
+  DEFAULT_PATH_FILTER,
+  DEFAULT_CONTENT_TYPE_DEFINITIONS,
+  DEFAULT_CLOUD_LIBRARY_NAME,
+  DAEMON_OFFLINE_THRESHOLD,
+  DAEMON_HEARTBEAT_INTERVAL,
+  ContentTypeRegistry,
+  CONFIG_EVIDENCE_ADAPTER_EXPORT,
+  CODE_SNAPSHOT_META_SCHEMA_VERSION,
+  CODE_DIGEST_TYPE,
+  CLOUD_DAEMON_IDLE_TIMEOUT,
+  C4AError
 };