kibi-cli 2.35.1 → 2.38.0

package/dist/public/operations/discovery-executors.js

@@ -7,6 +7,7 @@ import { executeIntentSearch, questionPaths, validateIntentSearchInput, } from "
 import { classifyActivation } from "../../operations/bootstrap/activation.js";
 import { SwiplResolutionError } from "../../prolog/swipl-resolver.js";
 import { buildSearchAnswer } from "../../search-answer.js";
+import { buildSearchHints, searchHintsNote, searchHintsTrigger, } from "../../search-hints.js";
 import { rankEntities } from "../../search-ranking.js";
 import { resolveBranchAttachment } from "../../utils/branch-resolver.js";
 import { BRANCH_STORE_NOT_COMPILED, branchStoreReason, inspectBranchStore, storeLockJournalReason, storeLockTakeoverReason, uncompiledBranchStoreReason, } from "../../utils/branch-store.js";
@@ -584,9 +585,49 @@ function questionPathHint(query, locations) {
         ? ` The question names ${list}; its words were left out of the topic. Pass it as sourceLocations to also see the requirements linked to that file.`
         : ` The question names ${list}; their words were left out of the topic. Pass them as sourceLocations to also see the requirements linked to those files.`;
 }
+/**
+ * Hints from the workspace's kibi.search-hints.v1 provider. A host without a
+ * plugin runtime, or a registry that fails to load, gives no hints rather than
+ * failing the search.
+ */
+// implements REQ-kibi-search-hints-host
+async function searchHintsFor(context, options) {
+    if (!context.ensurePlugins)
+        return undefined;
+    let resolution;
+    try {
+        resolution = await (await context.ensurePlugins()).resolveSearchHints();
+    }
+    catch (error) {
+        // A configured provider that cannot load is reported, not thrown: the
+        // lexical answer stands on its own.
+        const trigger = searchHintsTrigger(options.analysis);
+        return trigger === null
+            ? undefined
+            : {
+                trigger,
+                provider: null,
+                items: [],
+                diagnostics: [
+                    {
+                        pluginId: "unresolved",
+                        packageName: null,
+                        mode: "replace",
+                        code: "provider_unavailable",
+                        message: error instanceof Error ? error.message : String(error),
+                    },
+                ],
+            };
+    }
+    return buildSearchHints({
+        ...options,
+        resolution,
+        workspaceRoot: context.workspaceRoot,
+    });
+}
 export async function executeSearch(input, context) {
     // implements REQ-kibi-operation-interface-parity, REQ-mcp-search-discovery
-    const { query, type, limit = 10, offset = 0, rankingMode = "intent-v1", semanticFacets, sourceLocations, minScore, fields = "summary", answer, } = input;
+    const { query, type, limit = 10, offset = 0, rankingMode = "intent-v1", semanticFacets, sourceLocations, minScore, fields = "summary", answer, hints: hintsWanted = true, } = input;
     const trimmedQuery = query.trim();
     if (!trimmedQuery) {
         throw new Error("Search execution failed: query must be a non-empty string");
@@ -615,7 +656,10 @@ export async function executeSearch(input, context) {
                 ...(minScore !== undefined ? { minScore } : {}),
             };
             validateIntentSearchInput(intentInput);
-            const intentResult = await executeIntentSearch(intentInput, prolog, context.workspaceRoot);
+            let corpus;
+            const intentResult = await executeIntentSearch(intentInput, prolog, context.workspaceRoot, (entities, bodies) => {
+                corpus = { entities, bodies };
+            });
             const paginated = paginateResults(intentResult.matches, limit, offset);
             // The answer layer summarizes the whole ranking, so it belongs to the
             // first page only.
@@ -630,12 +674,27 @@ export async function executeSearch(input, context) {
             // A top match no requirement owns is said in the digest too, so the
             // governing list is never read as the top match's requirement.
             const topUngoverned = answerLayer?.ungoverned.find((entry) => entry.rank === 1);
+            // Hints come after the lexical answer and never change it; a strong
+            // answer never reaches a provider.
+            const hints = hintsWanted &&
+                offset === 0 &&
+                corpus !== undefined &&
+                searchHintsTrigger(intentResult.analysis) !== null
+                ? await searchHintsFor(context, {
+                    query: trimmedQuery,
+                    analysis: intentResult.analysis,
+                    entities: corpus.entities,
+                    bodies: corpus.bodies,
+                    governingIds: (answerLayer?.governing ?? []).map((req) => req.id),
+                    prolog,
+                })
+                : undefined;
             const text = `${intentResult.matches.length === 0
                 ? `No intent search results for '${trimmedQuery}' (abstained). No entity shares enough of the question's words: ask again in the words and language the KB is written in, or pass sourceLocations.`
                 : `Found ${intentResult.matches.length} intent search results for '${trimmedQuery}'${intentResult.analysis.ambiguous ? " (top matches are close; confirm before relying on one)" : ""}. Top: ${paginated
                     .slice(0, 5)
                     .map((match) => String(match.entity.id ?? ""))
-                    .join(", ")}${answerLayer ? `. Governing: ${answerLayer.governing.map((req) => req.id).join(", ") || "none found"}` : ""}${topUngoverned ? ` (the top match ${topUngoverned.id} is linked to no requirement)` : ""}.`}${questionPathHint(trimmedQuery, sourceLocations)}${CONTRADICTION_QUESTION.test(trimmedQuery) ? CONTRADICTION_HINT : ""}${storeNote}`;
+                    .join(", ")}${answerLayer ? `. Governing: ${answerLayer.governing.map((req) => req.id).join(", ") || "none found"}` : ""}${topUngoverned ? ` (the top match ${topUngoverned.id} is linked to no requirement)` : ""}.`}${searchHintsNote(hints)}${questionPathHint(trimmedQuery, sourceLocations)}${CONTRADICTION_QUESTION.test(trimmedQuery) ? CONTRADICTION_HINT : ""}${storeNote}`;
             return {
                 content: [{ type: "text", text }],
                 structuredContent: {
@@ -643,7 +702,9 @@ export async function executeSearch(input, context) {
                     count: intentResult.matches.length,
                     returned: paginated.length,
                     truncated: offset + paginated.length < intentResult.matches.length,
-                    queryAnalysis: intentResult.analysis,
+                    queryAnalysis: hints !== undefined
+                        ? { ...intentResult.analysis, hints }
+                        : intentResult.analysis,
                     ...(answerLayer ? { answer: answerLayer } : {}),
                     ...branchFields,
                 },

package/dist/public/operations/evidence-floor.d.ts

@@ -27,6 +27,13 @@ export type EvidenceFloorOptions = Readonly<{
      * `kibi prove --all`.
      */
     freshEvidence?: boolean;
+    /**
+     * The instant and workspace snapshot the whole check judges receipts at,
+     * so the floor reads the same requirement proofs the coverage evidence
+     * read instead of computing them again.
+     */
+    checkedAt?: string;
+    snapshotEvidence?: Awaited<ReturnType<typeof readWorkspaceSnapshot>>;
 }>;
 /** The entities behind the gaps, for a person reading kibi check's text. */
 export declare function gapDetailLines(row: EvidenceFloorRow): string[];
@@ -39,7 +46,7 @@ export declare function evidenceFloorViolations(rows: readonly EvidenceFloorRow[
  * ignores the schema version, so a migration can read the floor the ladder
  * will apply before it records the new schema.
  */
-export declare function readEvidenceFloorRows(context: OperationContext, snapshotEvidence?: Awaited<ReturnType<typeof readWorkspaceSnapshot>>): Promise<readonly EvidenceFloorRow[]>;
+export declare function readEvidenceFloorRows(context: OperationContext, snapshotEvidence?: Awaited<ReturnType<typeof readWorkspaceSnapshot>>, checkedAt?: string): Promise<readonly EvidenceFloorRow[]>;
 /**
  * Evaluate the evidence-floor rule against the attached store, with the same
  * per-contract receipt binding kb_coverage uses.

package/dist/public/operations/evidence-floor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"evidence-floor.d.ts","sourceRoot":"","sources":["../../../src/public/operations/evidence-floor.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAG9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;GAIG;AAEH,eAAO,MAAM,6BAA6B,KAAK,CAAC;AAEhD,mEAAmE;AAEnE,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAGpD,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,MAAM,EAAE,OAAO,GAAG,iBAAiB,CAAC;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,uEAAuE;IACvE,UAAU,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,CAAC;CAC1D,CAAC,CAAC;AAOH,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC,CAAC;AAqBH,4EAA4E;AAE5E,wBAAgB,cAAc,CAAC,GAAG,EAAE,gBAAgB,GAAG,MAAM,EAAE,CAQ9D;AAeD,6EAA6E;AAE7E,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,SAAS,gBAAgB,EAAE,EACjC,OAAO,GAAE,oBAAyB,GACjC,SAAS,EAAE,CAqBb;AAED;;;;;;GAMG;AAEH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,gBAAgB,EACzB,gBAAgB,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC,GACnE,OAAO,CAAC,SAAS,gBAAgB,EAAE,CAAC,CAgBtC;AAED;;;GAGG;AAEH,wBAAsB,8BAA8B,CAClD,OAAO,EAAE,gBAAgB,EACzB,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,EAC1B,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,SAAS,EAAE,CAAC,CA4BtB"}
+{"version":3,"file":"evidence-floor.d.ts","sourceRoot":"","sources":["../../../src/public/operations/evidence-floor.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAG9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;GAIG;AAEH,eAAO,MAAM,6BAA6B,KAAK,CAAC;AAEhD,mEAAmE;AAEnE,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAGpD,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,MAAM,EAAE,OAAO,GAAG,iBAAiB,CAAC;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,uEAAuE;IACvE,UAAU,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,CAAC;CAC1D,CAAC,CAAC;AAOH,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC,CAAC;CACtE,CAAC,CAAC;AAqBH,4EAA4E;AAE5E,wBAAgB,cAAc,CAAC,GAAG,EAAE,gBAAgB,GAAG,MAAM,EAAE,CAQ9D;AAeD,6EAA6E;AAE7E,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,SAAS,gBAAgB,EAAE,EACjC,OAAO,GAAE,oBAAyB,GACjC,SAAS,EAAE,CAqBb;AAED;;;;;;GAMG;AAEH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,gBAAgB,EACzB,gBAAgB,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC,EACpE,SAAS,GAAE,MAAsC,GAChD,OAAO,CAAC,SAAS,gBAAgB,EAAE,CAAC,CAetC;AAED;;;GAGG;AAEH,wBAAsB,8BAA8B,CAClD,OAAO,EAAE,gBAAgB,EACzB,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,EAC1B,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,SAAS,EAAE,CAAC,CAiCtB"}

package/dist/public/operations/evidence-floor.js

@@ -98,7 +98,7 @@ export function evidenceFloorViolations(rows, options = {}) {
  * will apply before it records the new schema.
  */
 // implements REQ-kibi-evidence-floors
-export async function readEvidenceFloorRows(context, snapshotEvidence) {
+export async function readEvidenceFloorRows(context, snapshotEvidence, checkedAt = context.clock().toISOString()) {
     const prolog = context.prolog ?? (await context.ensureProlog?.());
     if (prolog === undefined)
         return [];
@@ -106,7 +106,6 @@ export async function readEvidenceFloorRows(context, snapshotEvidence) {
     const snapshot = evidence.available ? evidence.snapshot.hash : "unknown";
     const { perContractTestBindings } = await import("./specs/reporting.js");
     const bindings = await perContractTestBindings({ ...context, prolog });
-    const checkedAt = context.clock().toISOString();
     const goal = `discovery:evidence_floor_json(${bindings === null ? "strict_snapshot, _{}" : `per_contract, ${bindings}`}, ${toPrologAtom(snapshot)}, ${toPrologAtom(checkedAt)}, ${PROOF_RECEIPT_MAX_AGE_SECONDS}, JsonString)`;
     const payload = await runOperationJsonQuery(prolog, "discovery.pl", goal, "Evidence floor evaluation");
     return payload.rows ?? [];
@@ -124,8 +123,8 @@ export async function collectEvidenceFloorViolations(context, rules, options = {
     if (schemaVersion === undefined ||
         schemaVersion < EVIDENCE_FLOOR_SCHEMA_VERSION)
         return [];
-    const snapshotEvidence = await readWorkspaceSnapshot(context);
-    const rows = await readEvidenceFloorRows(context, snapshotEvidence);
+    const snapshotEvidence = options.snapshotEvidence ?? (await readWorkspaceSnapshot(context));
+    const rows = await readEvidenceFloorRows(context, snapshotEvidence, options.checkedAt);
     const violations = evidenceFloorViolations(rows, options);
     if (options.freshEvidence === true) {
         const clean = snapshotEvidence.available && snapshotEvidence.snapshot.dirty === false;

package/dist/public/operations/migration-plan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"migration-plan.d.ts","sourceRoot":"","sources":["../../../src/public/operations/migration-plan.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"migration-plan.d.ts","sourceRoot":"","sources":["../../../src/public/operations/migration-plan.ts"],"names":[],"mappings":"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"}

package/dist/public/operations/migration-plan.js

@@ -54,30 +54,56 @@ function dependencyOrder(actions) {
         action.id,
         new Set(action.dependsOn.filter((dependency) => byId.has(dependency))),
     ]));
+    // Dependents of each action in action order, so an emitted action frees
+    // its dependents in the order a scan over every action would.
+    const dependents = new Map();
+    for (const action of actions) {
+        for (const dependency of remaining.get(action.id)) {
+            const list = dependents.get(dependency);
+            if (list === undefined)
+                dependents.set(dependency, [action.id]);
+            else
+                list.push(action.id);
+        }
+    }
     const ordered = [];
     const ready = actions
         .filter((action) => (remaining.get(action.id)?.size ?? 0) === 0)
         .sort(actionSort)
         .map((action) => action.id);
     const queued = new Set(ready);
-    while (ready.length > 0) {
-        const id = ready.shift();
-        if (id === undefined)
-            break;
+    const compareReady = (left, right) => compareReadyActionIds(left, right, byId);
+    // `ready` stays sorted; a freed action is inserted after its equals, where
+    // a stable sort of the pushed list would have put it.
+    const enqueue = (id, head) => {
+        let low = head;
+        let high = ready.length;
+        while (low < high) {
+            const middle = (low + high) >>> 1;
+            if (compareReady(ready[middle], id) <= 0)
+                low = middle + 1;
+            else
+                high = middle;
+        }
+        ready.splice(low, 0, id);
+    };
+    let head = 0;
+    while (head < ready.length) {
+        const id = ready[head];
+        head += 1;
         queued.delete(id);
+        // Only ids of `actions` are ever queued or listed as dependents.
         const action = byId.get(id);
-        if (action === undefined)
-            continue;
         ordered.push(action);
-        for (const [candidateId, dependencies] of remaining) {
+        for (const candidateId of dependents.get(id) ?? []) {
+            const dependencies = remaining.get(candidateId);
             if (!dependencies.delete(id) ||
                 dependencies.size !== 0 ||
                 queued.has(candidateId)) {
                 continue;
             }
-            ready.push(candidateId);
             queued.add(candidateId);
-            ready.sort((left, right) => compareReadyActionIds(left, right, byId));
+            enqueue(candidateId, head);
         }
     }
     // Preserve cyclic/missing-dependency actions in canonical order; validation will block them.
@@ -103,7 +129,12 @@ function summarize(actions) {
 }
 // implements REQ-agent-guided-migration-orchestration
 export function buildMigrationPlan(input = {}) {
-    const actions = dependencyOrder([...(input.actions ?? [])].sort(actionSort));
+    // An id names one action, as in a merged plan: a later definition of the
+    // same id replaces the earlier one instead of being ordered twice.
+    const uniqueActions = [
+        ...new Map((input.actions ?? []).map((action) => [action.id, action])).values(),
+    ];
+    const actions = dependencyOrder(uniqueActions.sort(actionSort));
     const evaluatedDomains = uniqueSorted(input.evaluatedDomains);
     const incompleteDomains = uniqueSorted(input.incompleteDomains);
     const expected = {

package/dist/public/operations/node-ports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-ports.d.ts","sourceRoot":"","sources":["../../../src/public/operations/node-ports.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAE/E,KAAK,kBAAkB,GAAG,cAAc,GAAG;IACzC,QAAQ,CAAC,IAAI,EAAE,CACb,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,OAAO,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAA;KAAE,KACjE,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAAC;CACjC,CAAC;AAEF,KAAK,WAAW,GAAG,OAAO,GAAG;IAC3B,QAAQ,CAAC,YAAY,EAAE,CACrB,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,SAAS,MAAM,EAAE,KACrB,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAAC;CACjC,CAAC;AAoKF,eAAO,MAAM,cAAc,EAAE,kBAkC5B,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,WAiBrB,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,WAEzB,CAAC"}
+{"version":3,"file":"node-ports.d.ts","sourceRoot":"","sources":["../../../src/public/operations/node-ports.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAE/E,KAAK,kBAAkB,GAAG,cAAc,GAAG;IACzC,QAAQ,CAAC,IAAI,EAAE,CACb,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,OAAO,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAA;KAAE,KACjE,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAAC;CACjC,CAAC;AAEF,KAAK,WAAW,GAAG,OAAO,GAAG;IAC3B,QAAQ,CAAC,YAAY,EAAE,CACrB,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,SAAS,MAAM,EAAE,KACrB,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAAC;CACjC,CAAC;AAsKF,eAAO,MAAM,cAAc,EAAE,kBAkC5B,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,WAiBrB,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,WAEzB,CAAC"}

package/dist/public/operations/node-ports.js

@@ -82,11 +82,13 @@ async function workspaceSnapshot(workspaceRoot) {
         .sort((left, right) => left.key < right.key ? -1 : left.key > right.key ? 1 : 0);
     const digest = createHash("sha256");
     digest.update("kibi.workspace-snapshot.v2\0");
+    // Synchronous reads: one awaited read per file paid a file-handle round
+    // trip each, about eight times the time of reading the same files directly.
     for (const { raw, key: relativePath } of paths) {
         digest.update(relativePath);
         digest.update("\0");
         try {
-            const content = await fs.readFile(path.join(workspaceRoot, raw));
+            const content = fsSync.readFileSync(path.join(workspaceRoot, raw));
             digest.update(snapshotFileContent(relativePath, content));
         }
         catch (error) {

package/dist/public/operations/source-analysis-cache.d.ts

@@ -0,0 +1,22 @@
+import type { HostSourceAnalysisResultV2 } from "../../plugins/source-analysis-service.js";
+/**
+ * Parser-backed source analyses kept across `kibi check` runs. Parsing every
+ * symbol's source file was the largest client cost of a warm check, and an
+ * analysis is a pure function of the file's path and bytes under one
+ * analyzer set, so an entry is keyed by both and the whole cache by the
+ * analyzer set. The file lives in the branch store, which is never tracked.
+ */
+export declare const SOURCE_ANALYSIS_CACHE_FILE = "source-analysis-cache.json";
+export type SourceAnalysisCache = {
+    get(file: string, content: string): HostSourceAnalysisResultV2 | undefined;
+    set(file: string, content: string, analysis: HostSourceAnalysisResultV2): void;
+    /** Write the entries this run read or added, dropping the rest. */
+    save(): void;
+};
+/**
+ * The cache in `storeDir`, or null when the analyzer set cannot be
+ * fingerprinted or there is no store. Only complete (`ok`) analyses
+ * are kept; anything else is computed again.
+ */
+export declare function openSourceAnalysisCache(storeDir: string | undefined, workspaceRoot: string): SourceAnalysisCache | null;
+//# sourceMappingURL=source-analysis-cache.d.ts.map

package/dist/public/operations/source-analysis-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-analysis-cache.d.ts","sourceRoot":"","sources":["../../../src/public/operations/source-analysis-cache.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,0CAA0C,CAAC;AAE3F;;;;;;GAMG;AAEH,eAAO,MAAM,0BAA0B,+BAA+B,CAAC;AASvE,MAAM,MAAM,mBAAmB,GAAG;IAChC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,0BAA0B,GAAG,SAAS,CAAC;IAC3E,GAAG,CACD,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,0BAA0B,GACnC,IAAI,CAAC;IACR,mEAAmE;IACnE,IAAI,IAAI,IAAI,CAAC;CACd,CAAC;AAkFF;;;;GAIG;AAEH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,aAAa,EAAE,MAAM,GACpB,mBAAmB,GAAG,IAAI,CA4C5B"}

package/dist/public/operations/source-analysis-cache.js

@@ -0,0 +1,157 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { fingerprintMaintenanceSourceSet } from "../../plugins/maintenance-source-analysis.js";
+import { readProjectKibiConfig } from "../../plugins/project-config.js";
+/**
+ * Parser-backed source analyses kept across `kibi check` runs. Parsing every
+ * symbol's source file was the largest client cost of a warm check, and an
+ * analysis is a pure function of the file's path and bytes under one
+ * analyzer set, so an entry is keyed by both and the whole cache by the
+ * analyzer set. The file lives in the branch store, which is never tracked.
+ */
+// implements REQ-cli-check
+export const SOURCE_ANALYSIS_CACHE_FILE = "source-analysis-cache.json";
+const SOURCE_ANALYSIS_CACHE_VERSION = 1;
+function entryKey(file, content) {
+    return createHash("sha256")
+        .update(file)
+        .update("\0")
+        .update(content)
+        .digest("hex");
+}
+/**
+ * The builtin analyzer is identified by its package version, which a local
+ * build does not bump; its built files' sizes and times stand in for its
+ * code so a rebuilt analyzer starts a fresh cache.
+ */
+function builtinBuildStamp() {
+    const hash = createHash("sha256");
+    try {
+        const manifest = createRequire(import.meta.url).resolve("kibi-plugin-builtin/package.json");
+        const symbolsDir = path.join(path.dirname(manifest), "dist", "symbols");
+        // rationale: readdir lists this directory in name order on the supported
+        // filesystems, so the sort only guards odd ones and no test can tell.
+        // Stryker disable next-line MethodExpression
+        for (const name of readdirSync(symbolsDir).sort()) {
+            const stat = statSync(path.join(symbolsDir, name));
+            hash.update(`${name}\0${stat.size}\0${stat.mtimeMs}\n`);
+        }
+    }
+    catch {
+        // An unavailable builtin package stamps as no built files.
+    }
+    // rationale: the stamp only feeds the analyzer-set JSON; a Buffer
+    // serializes as deterministically as the hex text it replaces.
+    // Stryker disable next-line StringLiteral
+    return hash.digest("hex");
+}
+function analyzerSetKey(workspaceRoot) {
+    try {
+        const sourceSet = fingerprintMaintenanceSourceSet(workspaceRoot, readProjectKibiConfig(workspaceRoot));
+        return createHash("sha256")
+            .update(JSON.stringify({
+            version: SOURCE_ANALYSIS_CACHE_VERSION,
+            sourceSet,
+            builtin: builtinBuildStamp(),
+        }))
+            .digest("hex");
+    }
+    catch {
+        // An analyzer set Kibi cannot fingerprint is never cached.
+        return null;
+    }
+}
+function readCacheFile(cachePath, analyzers) {
+    const empty = {
+        version: SOURCE_ANALYSIS_CACHE_VERSION,
+        analyzers,
+        entries: {},
+    };
+    try {
+        // A missing or unreadable file, or JSON null, throws and starts empty.
+        const parsed = JSON.parse(readFileSync(cachePath, "utf8"));
+        if (parsed.version !== SOURCE_ANALYSIS_CACHE_VERSION ||
+            parsed.analyzers !== analyzers ||
+            parsed.entries === null ||
+            typeof parsed.entries !== "object") {
+            return empty;
+        }
+        return parsed;
+    }
+    catch {
+        return empty;
+    }
+}
+/**
+ * The cache in `storeDir`, or null when the analyzer set cannot be
+ * fingerprinted or there is no store. Only complete (`ok`) analyses
+ * are kept; anything else is computed again.
+ */
+// implements REQ-cli-check
+export function openSourceAnalysisCache(storeDir, workspaceRoot) {
+    // rationale: an undefined directory does not exist either, so dropping the
+    // first test changes nothing observable.
+    // Stryker disable next-line ConditionalExpression
+    if (storeDir === undefined || !existsSync(storeDir))
+        return null;
+    const analyzers = analyzerSetKey(workspaceRoot);
+    if (analyzers === null)
+        return null;
+    const cachePath = path.join(storeDir, SOURCE_ANALYSIS_CACHE_FILE);
+    const stored = readCacheFile(cachePath, analyzers);
+    const used = {};
+    let changed = false;
+    return {
+        get(file, content) {
+            const key = entryKey(file, content);
+            const entry = stored.entries[key];
+            if (entry === undefined || entry.status !== "ok")
+                return undefined;
+            used[key] = entry;
+            return entry;
+        },
+        set(file, content, analysis) {
+            if (analysis.status !== "ok")
+                return;
+            used[entryKey(file, content)] = analysis;
+            changed = true;
+        },
+        save() {
+            const kept = Object.keys(used).length;
+            if (!changed && kept === Object.keys(stored.entries).length)
+                return;
+            const temporary = `${cachePath}.${process.pid}.tmp`;
+            try {
+                writeFileSync(temporary, JSON.stringify({
+                    version: SOURCE_ANALYSIS_CACHE_VERSION,
+                    analyzers,
+                    entries: used,
+                }));
+                renameSync(temporary, cachePath);
+            }
+            catch {
+                // The cache is an optimization; a failed write only costs a reparse.
+                rmSync(temporary, { force: true });
+            }
+        },
+    };
+}

package/dist/public/operations/specs/discovery.d.ts

@@ -100,7 +100,7 @@ export declare const querySpec: {
 export declare const searchSpec: {
     readonly name: "kb_search";
     readonly cliName: "search";
-    readonly description: "Ask the KB a question or search it. Default intent-v1 ranking accepts questions, host-agent semantic facets and changed-code source locations, returns evidence, abstains below its confidence threshold and adds an answer layer: the current requirements that govern the topic, what must stay true (linked facts), why (ADRs) and what verifies it (scenarios, tests). Use before changing behavior, then kb_query for exact follow-up. No mutation side effects.";
+    readonly description: "Ask the KB a question or search it. Default intent-v1 ranking accepts questions, host-agent semantic facets and changed-code source locations, returns evidence, abstains below its confidence threshold and adds an answer layer: the current requirements that govern the topic, what must stay true (linked facts), why (ADRs) and what verifies it (scenarios, tests). A weak answer may add queryAnalysis.hints from a search-hints plugin: requirements the question may mean, to re-ask with. Use before changing behavior, then kb_query for exact follow-up. No mutation side effects.";
     readonly businessInputSchema: {
         readonly type: "object";
         readonly required: readonly ["query"];
@@ -139,6 +139,11 @@ export declare const searchSpec: {
                 readonly default: true;
                 readonly description: "Intent-v1 only, first page only. When true (default) the result includes an answer layer: current governing requirements with their linked facts, scenarios, tests and ADRs, superseded requirements listed separately, and observation facts labelled as notes. Bounded in size; discovery, not proof.";
             };
+            readonly hints: {
+                readonly type: "boolean";
+                readonly default: true;
+                readonly description: "Intent-v1 only, first page only. When true (default) and the project activates a kibi.search-hints.v1 plugin, a weak or abstained answer adds queryAnalysis.hints: requirements the question may mean, to re-ask with. Hints never change results or the answer layer.";
+            };
             readonly semanticFacets: {
                 readonly type: "object";
                 readonly additionalProperties: false;
@@ -179,7 +184,7 @@ export declare const searchSpec: {
                         readonly maxItems: 20;
                     };
                 };
-                readonly description: "Optional host-agent semantic interpretation. Kibi uses these strings as deterministic aliases/facets; it does not call a model itself.";
+                readonly description: "Optional host-agent semantic interpretation. Kibi uses these strings as deterministic aliases/facets; ranking never calls a model.";
             };
             readonly sourceLocations: {
                 readonly type: "array";

package/dist/public/operations/specs/discovery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EACb,aAAa,EACd,MAAM,2BAA2B,CAAC;AAiCnC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6GsC,CAAC;AAE7D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2GuC,CAAC;AAE/D,eAAO,MAAM,UAAU;;;;;;;;;;;;CAWuC,CAAC"}
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EACb,aAAa,EACd,MAAM,2BAA2B,CAAC;AAiCnC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6GsC,CAAC;AAE7D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiHuC,CAAC;AAE/D,eAAO,MAAM,UAAU;;;;;;;;;;;;CAWuC,CAAC"}

package/dist/public/operations/specs/discovery.js

@@ -114,7 +114,7 @@ export const querySpec = {
 export const searchSpec = {
     name: "kb_search",
     cliName: "search",
-    description: "Ask the KB a question or search it. Default intent-v1 ranking accepts questions, host-agent semantic facets and changed-code source locations, returns evidence, abstains below its confidence threshold and adds an answer layer: the current requirements that govern the topic, what must stay true (linked facts), why (ADRs) and what verifies it (scenarios, tests). Use before changing behavior, then kb_query for exact follow-up. No mutation side effects.",
+    description: "Ask the KB a question or search it. Default intent-v1 ranking accepts questions, host-agent semantic facets and changed-code source locations, returns evidence, abstains below its confidence threshold and adds an answer layer: the current requirements that govern the topic, what must stay true (linked facts), why (ADRs) and what verifies it (scenarios, tests). A weak answer may add queryAnalysis.hints from a search-hints plugin: requirements the question may mean, to re-ask with. Use before changing behavior, then kb_query for exact follow-up. No mutation side effects.",
     businessInputSchema: {
         type: "object",
         required: ["query"],
@@ -153,6 +153,11 @@ export const searchSpec = {
                 default: true,
                 description: "Intent-v1 only, first page only. When true (default) the result includes an answer layer: current governing requirements with their linked facts, scenarios, tests and ADRs, superseded requirements listed separately, and observation facts labelled as notes. Bounded in size; discovery, not proof.",
             },
+            hints: {
+                type: "boolean",
+                default: true,
+                description: "Intent-v1 only, first page only. When true (default) and the project activates a kibi.search-hints.v1 plugin, a weak or abstained answer adds queryAnalysis.hints: requirements the question may mean, to re-ask with. Hints never change results or the answer layer.",
+            },
             semanticFacets: {
                 type: "object",
                 additionalProperties: false,
@@ -167,7 +172,7 @@ export const searchSpec = {
                     },
                     aliases: { type: "array", items: { type: "string" }, maxItems: 20 },
                 },
-                description: "Optional host-agent semantic interpretation. Kibi uses these strings as deterministic aliases/facets; it does not call a model itself.",
+                description: "Optional host-agent semantic interpretation. Kibi uses these strings as deterministic aliases/facets; ranking never calls a model.",
             },
             sourceLocations: {
                 type: "array",

package/dist/public/operations/specs/mutation-schemas.d.ts

@@ -240,6 +240,11 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
                             readonly minLength: 1;
                             readonly description: "The name the domain is exported under in the symbol's source file, when the symbol's title is not that name.";
                         };
+                        readonly field: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                            readonly description: "exhaustive: when the export is a list of records, the field of each record that names a domain member (a catalog's name).";
+                        };
                     };
                     readonly additionalProperties: false;
                 };
@@ -267,7 +272,7 @@ export declare const ENTITY_PROPERTIES_SCHEMA: {
                 };
                 readonly value_source: {
                     readonly type: "array";
-                    readonly description: "arithmetic and smt: code constants the assumptions read. Kibi evaluates each export at ingest and requires the certificate to assume the variable equals that value, so the proof is about the code and not only the knowledge base. With measure count the value is the size of a list, set, map or object export, so a count claim reads the collection itself. An entry {source, measure: count} counts the members Kibi reads from a project source (routes, tables, environment variables).";
+                    readonly description: "arithmetic and smt: code constants the assumptions read. Kibi evaluates each export at ingest and requires the certificate to assume the variable equals that value, so the proof is about the code and not only the knowledge base. With measure count the value is the size of a list, set, map or object export, so a count claim reads the collection itself. A dotted export (POLICY.eventLimit) reads one field of an object export. An entry {source, measure: count} counts the members Kibi reads from a project source (routes, tables, environment variables).";
                     readonly minItems: 1;
                     readonly items: {
                         readonly type: "object";

package/dist/public/operations/specs/mutation-schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mutation-schemas.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/mutation-schemas.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,YAAY,gFASf,CAAC;AAWX,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmZ3B,CAAC;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;CA8CvB,CAAC"}
+{"version":3,"file":"mutation-schemas.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/mutation-schemas.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,YAAY,gFASf,CAAC;AAWX,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmZ3B,CAAC;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;CA8CvB,CAAC"}

package/dist/public/operations/specs/upsert.d.ts

@@ -257,6 +257,11 @@ export declare const upsertSpec: {
                                         readonly minLength: 1;
                                         readonly description: "The name the domain is exported under in the symbol's source file, when the symbol's title is not that name.";
                                     };
+                                    readonly field: {
+                                        readonly type: "string";
+                                        readonly minLength: 1;
+                                        readonly description: "exhaustive: when the export is a list of records, the field of each record that names a domain member (a catalog's name).";
+                                    };
                                 };
                                 readonly additionalProperties: false;
                             };
@@ -284,7 +289,7 @@ export declare const upsertSpec: {
                             };
                             readonly value_source: {
                                 readonly type: "array";
-                                readonly description: "arithmetic and smt: code constants the assumptions read. Kibi evaluates each export at ingest and requires the certificate to assume the variable equals that value, so the proof is about the code and not only the knowledge base. With measure count the value is the size of a list, set, map or object export, so a count claim reads the collection itself. An entry {source, measure: count} counts the members Kibi reads from a project source (routes, tables, environment variables).";
+                                readonly description: "arithmetic and smt: code constants the assumptions read. Kibi evaluates each export at ingest and requires the certificate to assume the variable equals that value, so the proof is about the code and not only the knowledge base. With measure count the value is the size of a list, set, map or object export, so a count claim reads the collection itself. A dotted export (POLICY.eventLimit) reads one field of an object export. An entry {source, measure: count} counts the members Kibi reads from a project source (routes, tables, environment variables).";
                                 readonly minItems: 1;
                                 readonly items: {
                                     readonly type: "object";

package/dist/public/operations/specs/upsert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/upsert.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAQvE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DuC,CAAC"}
+{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/upsert.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAQvE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DuC,CAAC"}