scip-query 0.20.0 → 0.21.1

package/dist/{config-types-jVM3D7MA.d.ts → config-types-B9B60MiR.d.ts}

@@ -1,12 +1,19 @@
-declare const OBSERVATION_RECEIPT_SCHEMA_VERSION: 1;
+declare const LEGACY_OBSERVATION_RECEIPT_SCHEMA_VERSION: 1;
+declare const OBSERVATION_RECEIPT_SCHEMA_VERSION: 2;
+declare const OBSERVATION_IDENTITY_SCHEMA_VERSION: 1;
+declare const OBSERVATION_IDENTITY_CANONICALIZATION_VERSION: 1;
+declare const OBSERVATION_IDENTITY_HASH_ALGORITHM: "sha256";
+declare const OBSERVATION_STATE_AUTHORITY_POLICY_VERSION: 1;
 type ObservationAuthorityKind = 'index-worktree' | 'index-only' | 'worktree-only' | 'process-local';
 /**
- * Identifies the concrete index and checkout state surrounding one result.
- * `alignment: not-certified` is deliberate: ordinary commands disclose their
- * state but do not claim the pre/post lease that Stop establishes.
+ * A version-1 receipt identifies the local index/worktree evidence emitted by
+ * scip-query before state identity was split into independent facts. Its
+ * project and worktree values are retained as historical facts, but their
+ * combined path/state meanings cannot prove v2 collaboration, workspace, or
+ * content relationships.
  */
-interface ObservationReceipt {
-    schemaVersion: typeof OBSERVATION_RECEIPT_SCHEMA_VERSION;
+interface ObservationReceiptV1 {
+    schemaVersion: typeof LEGACY_OBSERVATION_RECEIPT_SCHEMA_VERSION;
     authorityKind: ObservationAuthorityKind;
     observedAt: string;
     projectIdentity: string;
@@ -22,17 +29,150 @@ interface ObservationReceipt {
         treeOid?: string;
     };
 }
+/**
+ * An observation identity is a content-derived identifier whose projection
+ * says which real inputs were selected and whose digest says what values that
+ * projection observed. Including every version in the hash preimage prevents
+ * equal-looking digests from silently crossing incompatible identity rules.
+ */
+interface ObservationIdentity {
+    schemaVersion: typeof OBSERVATION_IDENTITY_SCHEMA_VERSION;
+    canonicalizationVersion: typeof OBSERVATION_IDENTITY_CANONICALIZATION_VERSION;
+    hashAlgorithm: typeof OBSERVATION_IDENTITY_HASH_ALGORITHM;
+    projection: {
+        name: string;
+        version: number;
+    };
+    digest: string;
+}
+interface RelevantInputIdentity {
+    /** The result or claim family whose answer can be changed by this projection. */
+    subject: string;
+    identity: ObservationIdentity;
+}
+type ObservationSourceKind = 'index-generation' | 'repository-snapshot' | 'live-workspace' | 'process';
+/**
+ * An observed source is one state-bearing input an operation actually read.
+ * It names the referent only; whether that referent stayed fixed is a separate
+ * stability fact.
+ */
+interface ObservationSourceFact {
+    kind: ObservationSourceKind;
+    identity?: ObservationIdentity;
+}
+type ObservationStabilityProofKind = 'immutable' | 'fixed-snapshot' | 'bracketed' | 'not-established' | 'invalidated';
+/**
+ * A stability proof records how one observed source was prevented from
+ * changing during the observation interval. Immutable and fixed-snapshot
+ * proofs establish fixed input; bracketed equality is weaker because an
+ * intermediate change can return to the same endpoint.
+ */
+interface ObservationStabilityProof {
+    source: ObservationSourceKind;
+    kind: ObservationStabilityProofKind;
+}
+interface ObservationReceiptV2 {
+    schemaVersion: typeof OBSERVATION_RECEIPT_SCHEMA_VERSION;
+    observedAt: string;
+    facts: {
+        collaborationDomain?: ObservationIdentity;
+        repositoryLineage?: ObservationIdentity;
+        workspaceInstance?: ObservationIdentity;
+        wholeContent?: ObservationIdentity;
+        relevantInputs?: readonly RelevantInputIdentity[];
+        index?: {
+            generation: ObservationIdentity;
+            /** Inputs persisted with the immutable generation when known. */
+            inputs?: ObservationIdentity;
+            source: 'immutable' | 'legacy';
+        };
+    };
+    observedSources: readonly ObservationSourceFact[];
+    stabilityProofs: readonly ObservationStabilityProof[];
+    /** Human-useful state facts that are not compatibility identities. */
+    diagnostics?: {
+        clean?: boolean;
+        headCommit?: string;
+        treeOid?: string;
+    };
+}
+type ObservationReceipt = ObservationReceiptV1 | ObservationReceiptV2;
+type DecodedObservationReceipt = {
+    kind: 'legacy';
+    schemaVersion: 1;
+    receipt: ObservationReceiptV1;
+} | {
+    kind: 'supported';
+    schemaVersion: 2;
+    receipt: ObservationReceiptV2;
+} | {
+    kind: 'unsupported';
+    schemaVersion: number;
+    direction: 'older' | 'future';
+} | {
+    kind: 'malformed';
+    reason: string;
+};
+type ObservationRelationshipState = 'established' | 'disproven' | 'unknown';
+type ObservationComparisonReason = 'identities-equal' | 'identities-different' | 'left-fact-missing' | 'right-fact-missing' | 'both-facts-missing' | 'identity-projections-not-comparable' | 'legacy-fact-not-comparable' | 'all-observed-sources-fixed' | 'left-observation-has-no-repository-source' | 'right-observation-has-no-repository-source' | 'left-observation-not-fixed' | 'right-observation-not-fixed' | 'left-observation-invalidated' | 'right-observation-invalidated';
+type ObservationComparedFact = {
+    kind: 'identity';
+    identity: ObservationIdentity;
+} | {
+    kind: 'legacy-index-generation';
+    value: string;
+} | {
+    kind: 'stability';
+    proof: ObservationStabilityProof;
+};
+interface ObservationRelationshipJudgment {
+    state: ObservationRelationshipState;
+    reasons: readonly ObservationComparisonReason[];
+    facts: {
+        left: readonly ObservationComparedFact[];
+        right: readonly ObservationComparedFact[];
+    };
+}
+interface RelevantInputRelationshipJudgment {
+    subject: string;
+    projection: string;
+    judgment: ObservationRelationshipJudgment;
+}
+/**
+ * A receipt comparison is a set of independent relationship judgments. Each
+ * field answers one real question; no field is a total "strength" score and
+ * no established relationship silently upgrades another.
+ */
 interface ObservationReceiptComparison {
-    compatible: boolean;
-    reasons: Array<'project-mismatch' | 'index-authority-missing' | 'generation-mismatch' | 'worktree-authority-missing' | 'worktree-mismatch'>;
+    collaborationDomain: ObservationRelationshipJudgment;
+    repositoryLineage: ObservationRelationshipJudgment;
+    workspaceInstance: ObservationRelationshipJudgment;
+    wholeContent: ObservationRelationshipJudgment;
+    relevantInputs: readonly RelevantInputRelationshipJudgment[];
+    indexInput: ObservationRelationshipJudgment;
+    indexGeneration: ObservationRelationshipJudgment;
+    observationStability: ObservationRelationshipJudgment;
 }
+type ObservationStateAuthority = 'completion' | 'advisory' | 'none';
 /**
- * Decide whether two results can support one same-state complete-set claim.
- * Both index and worktree authority are required; equal timestamps alone do
- * not make observations compatible.
+ * A derived state-authority judgment is product policy applied to receipt
+ * facts at use time. It is not serialized into the producer's receipt, so a
+ * producer cannot grant itself completion authority by asserting a label.
  */
-declare function compareObservationReceipts(left: ObservationReceipt, right: ObservationReceipt): ObservationReceiptComparison;
+interface DerivedObservationStateAuthority {
+    policyVersion: typeof OBSERVATION_STATE_AUTHORITY_POLICY_VERSION;
+    authority: ObservationStateAuthority;
+    requiredRelationships: readonly ['collaborationDomain', 'wholeContent', 'observationStability'];
+    reasons: readonly string[];
+}
+declare function createObservationIdentity(projectionName: string, projectionVersion: number, canonicalValue: string): ObservationIdentity;
+declare function decodeObservationReceipt(value: unknown): DecodedObservationReceipt;
 declare function isObservationReceipt(value: unknown): value is ObservationReceipt;
+declare function compareObservationReceipts(left: ObservationReceipt, right: ObservationReceipt): ObservationReceiptComparison;
+declare function deriveObservationStateAuthority(left: ObservationReceipt, right: ObservationReceipt, comparison?: ObservationReceiptComparison): DerivedObservationStateAuthority;
+declare function observationReceiptGenerationIdentity(receipt: ObservationReceipt): string | undefined;
+declare function observationReceiptWorkspaceIdentity(receipt: ObservationReceipt): string | undefined;
+declare function observationReceiptStabilityLabel(receipt: ObservationReceipt): string;
 
 interface InstallMethod {
     /** Human-readable label (e.g., "npm", "pip", "go install") */
@@ -95,6 +235,10 @@ interface ScipQueryConfig {
     indexPath: string;
     /** Project root directory */
     projectRoot: string;
+    /** Committed identity shared by branches, clones, and forks intended to merge into one project history. */
+    collaborationDomainId?: string;
+    /** Persistent cache path used when the indexed database is a temporary publish candidate. */
+    evidenceDbPath?: string;
     /** Internal repository-level read-through cache for proven content-addressed evidence products. */
     sharedEvidenceDbPath?: string;
     /** Project-specific externally-live roots for dead-code filtering */
@@ -121,14 +265,18 @@ interface ProjectConfig {
     $schema?: string;
     /** Persisted project-config format. Omitted only by readable legacy v1 records and in-memory callers. */
     schemaVersion?: 2;
+    /**
+     * Opaque committed identity shared by branches, clones, linked worktrees,
+     * and contributor forks whose durable decisions are intended to merge.
+     * Independent derivatives deliberately replace it.
+     */
+    collaborationDomainId?: string;
     /** Override which languages to index (default: auto-detect) */
     languages?: SupportedLanguage[];
     /** Number of indexer workers to run at once (default: adaptive, max 8) */
     indexerConcurrency?: number;
     /** Watch mode settings */
     watch?: WatchConfig;
-    /** Agent hook behavior. */
-    hooks?: HookRuntimeConfig;
     /** Per-language indexer overrides */
     indexer?: Partial<Record<SupportedLanguage, IndexerOverrides>>;
     /** Override the database storage path (default: ~/.cache/scip-query/<hash>/) */
@@ -220,6 +368,12 @@ interface ArchitectureConfig {
      * row. This prevents an omitted row from silently weakening enforcement.
      */
     requireCompletePolicy?: boolean;
+    /**
+     * Require every indexed, non-ignored file to belong to exactly one declared
+     * boundary. Unmapped and ambiguously mapped files otherwise remain visible
+     * coverage facts without being policy violations.
+     */
+    requireCompleteCoverage?: boolean;
     /** Treat every multi-boundary dependency cycle as a declared violation. */
     requireAcyclic?: boolean;
     /**
@@ -281,7 +435,7 @@ interface DocsConfig {
     /**
      * Glob patterns (see src/analysis/glob-match.ts for supported syntax) for
      * dated snapshot docs that intentionally cite code "as of" a moment in
-     * time — excluded from diff-gate's doc-reference check and doc-drift's
+     * time — excluded from doc-drift's
      * default findings. A `<!-- scip-query: snapshot -->` marker inside a doc
      * has the same effect regardless of its path.
      */
@@ -326,7 +480,7 @@ interface SuppressionDecision {
 interface FindingSuppression {
     /** Stable finding id, for example SQABC123DEF456. */
     id?: string;
-    /** Detector/check name, for example diff-gate's "echo". */
+    /** Detector name, for example "twin-drift". */
     check?: string;
     /** Optional file path to narrow check-level suppressions. */
     file?: string;
@@ -363,22 +517,34 @@ interface EntryRootsConfig {
 interface WatchConfig {
     /** Enable file watching (default: false, must opt in) */
     enabled?: boolean;
-    /** Ms to wait after the last file change before triggering reindex (default: 250) */
+    /** Let ordinary commands start the background watch service (default: false). */
+    autoStart?: boolean;
+    /** Permit watcher-triggered whole-project indexers after an incremental miss (default: false). */
+    allowExpensiveRebuild?: boolean;
+    /** Ms to wait after the last file change before triggering reindex (default: 2000) */
     debounceMs?: number;
-    /** Minimum ms between reindex completions; 0 disables spacing (default: 5000) */
+    /** Requested ms between reindex completions; values below 5000 use the 5000ms safety floor. */
     cooldownMs?: number;
     /** Ms between Git HEAD/index state checks (default: 2000) */
     gitPollMs?: number;
-    /** Ms of clean inactivity before the background watcher exits; 0 keeps it running (default: 600000) */
+    /** Ms of clean inactivity before the background watcher exits; 0 keeps it running (default: 900000) */
     idleTimeoutMs?: number;
     /** Let project agent hooks refresh stale indexes without a live watch process (default: true) */
     autoRefresh?: boolean;
     /** Extra glob patterns to ignore beyond .gitignore */
     ignore?: string[];
+    /** Rolling admission guard for automatic watcher rebuilds. */
+    resourceBudget?: WatchResourceBudgetConfig;
 }
-interface HookRuntimeConfig {
-    /** Prompt router mode for project-local hooks (default: single). */
-    router?: 'off' | 'single';
+interface WatchResourceBudgetConfig {
+    /** Enable automatic rebuild admission limits (default: true). */
+    enabled?: boolean;
+    /** Rolling observation window in milliseconds (default: 900000 / 15 minutes). */
+    windowMs?: number;
+    /** Completed rebuilds allowed inside the window before automatic work pauses (default: 2). */
+    maxRebuilds?: number;
+    /** Estimated bytes written inside the window before automatic work pauses (default: 1 GiB). */
+    maxEstimatedWriteBytes?: number;
 }
 interface IndexerOverrides {
     /** Enable pnpm workspace support (TypeScript) */
@@ -389,6 +555,16 @@ interface IndexerOverrides {
     projects?: string[];
     /** Indexer-specific config file path, relative to project root */
     configPath?: string;
+    /** Maximum TypeScript compiler programs retained by the watch worker (default: 8). */
+    maxWarmSessions?: number;
+    /** Retire an idle TypeScript index worker after this many milliseconds (default: 600000; 0 keeps it warm). */
+    workerIdleMs?: number;
+    /** Retire the TypeScript index worker after a response reaches this heap usage, in MiB. */
+    workerSoftMemoryMb?: number;
+    /** Hard heap limit for the bounded TypeScript document worker, in MiB (default: 4096). */
+    workerHeapMb?: number;
+    /** Heap limit for an explicitly authorized whole-project TypeScript indexer, in MiB. */
+    maxHeapMb?: number;
 }
 
-export { type ArchitectureConfig as A, type FindingSuppression as F, type IndexerConfig as I, OBSERVATION_RECEIPT_SCHEMA_VERSION as O, type ProjectConfig as P, type ScipQueryConfig as S, type TypeScriptProjectMode as T, type SupportedLanguage as a, type ObservationAuthorityKind as b, type ObservationReceipt as c, type ObservationReceiptComparison as d, compareObservationReceipts as e, isObservationReceipt as i };
+export { deriveObservationStateAuthority as A, isObservationReceipt as B, observationReceiptGenerationIdentity as C, type DerivedObservationStateAuthority as D, observationReceiptStabilityLabel as E, observationReceiptWorkspaceIdentity as F, type ArchitectureConfig as G, type IndexerConfig as I, LEGACY_OBSERVATION_RECEIPT_SCHEMA_VERSION as L, type ObservationSourceKind as O, type ProjectConfig as P, type RelevantInputIdentity as R, type ScipQueryConfig as S, type TypeScriptProjectMode as T, type WatchConfig as W, type SupportedLanguage as a, type WatchResourceBudgetConfig as b, type ObservationReceipt as c, type DecodedObservationReceipt as d, OBSERVATION_IDENTITY_CANONICALIZATION_VERSION as e, OBSERVATION_IDENTITY_HASH_ALGORITHM as f, OBSERVATION_IDENTITY_SCHEMA_VERSION as g, OBSERVATION_RECEIPT_SCHEMA_VERSION as h, OBSERVATION_STATE_AUTHORITY_POLICY_VERSION as i, type ObservationAuthorityKind as j, type ObservationComparedFact as k, type ObservationComparisonReason as l, type ObservationIdentity as m, type ObservationReceiptComparison as n, type ObservationReceiptV1 as o, type ObservationReceiptV2 as p, type ObservationRelationshipJudgment as q, type ObservationRelationshipState as r, type ObservationSourceFact as s, type ObservationStabilityProof as t, type ObservationStabilityProofKind as u, type ObservationStateAuthority as v, type RelevantInputRelationshipJudgment as w, compareObservationReceipts as x, createObservationIdentity as y, decodeObservationReceipt as z };

package/dist/dataflow-AFXY423Q.js

@@ -0,0 +1,2 @@
+import{a,b}from"./chunk-ZGDHC5AT.js";import"./chunk-7KCZELVM.js";import"./chunk-BGBBVSH4.js";import"./chunk-PJBYDCBQ.js";import"./chunk-MTDBHTSF.js";import"./chunk-ZMS4YCY7.js";import"./chunk-IQMGNIGY.js";import"./chunk-MFBVUQJZ.js";import"./chunk-5J3A6RBZ.js";import"./chunk-WRQXLNYE.js";import"./chunk-YDTK77JP.js";import"./chunk-T2PBOVDI.js";import"./chunk-4IASLUOP.js";import"./chunk-FLSVYEPL.js";import"./chunk-CTO3TRX7.js";import"./chunk-F4FNK44D.js";import"./chunk-67FK5KGV.js";import"./chunk-PAZSBPJR.js";import"./chunk-UAQQR55F.js";import"./chunk-NP4JFCLE.js";import"./chunk-5Z2H76VD.js";import"./chunk-DRENNWRG.js";import"./chunk-UXNXOMXJ.js";import"./chunk-4SZJF4GK.js";import"./chunk-DUDUIT5P.js";import"./chunk-PRLU3I7G.js";import"./chunk-DXYMTQZ4.js";import"./chunk-FYCH2EYQ.js";import"./chunk-NQXWWE6S.js";import"./chunk-H5EXS3HM.js";import"./chunk-HGFDYOVB.js";import"./chunk-Z2KGMIL4.js";import"./chunk-XIPGCT3D.js";export{b as dataflow,a as referenceNeighborhood};
+//# sourceMappingURL=dataflow-AFXY423Q.js.map

package/dist/{db-B5PM5yNk.d.ts → db-BwIVAYNB.d.ts}

@@ -1,5 +1,5 @@
 import Database from 'better-sqlite3';
-import { S as ScipQueryConfig } from './config-types-jVM3D7MA.js';
+import { S as ScipQueryConfig } from './config-types-B9B60MiR.js';
 
 /**
  * One retained publication of the compiler index. Its immutable paths and

package/dist/dependence-slice-2G4X6VSJ.js

@@ -0,0 +1,2 @@
+import{a}from"./chunk-7G2WIVIX.js";import"./chunk-DXEJ4FLZ.js";import"./chunk-3TNRNKAT.js";import"./chunk-7KCZELVM.js";import"./chunk-OFZVFIDF.js";import"./chunk-YF25RQER.js";import"./chunk-SRIZDEWX.js";import"./chunk-BGBBVSH4.js";import"./chunk-PJBYDCBQ.js";import"./chunk-MTDBHTSF.js";import"./chunk-ZMS4YCY7.js";import"./chunk-IQMGNIGY.js";import"./chunk-MR4ZKWO6.js";import"./chunk-XFRHBAIT.js";import"./chunk-MFBVUQJZ.js";import"./chunk-EPLE5O5O.js";import"./chunk-5J3A6RBZ.js";import"./chunk-WRQXLNYE.js";import"./chunk-YDTK77JP.js";import"./chunk-T2PBOVDI.js";import"./chunk-YUKYB54I.js";import"./chunk-4IASLUOP.js";import"./chunk-FLSVYEPL.js";import"./chunk-CTO3TRX7.js";import"./chunk-F4FNK44D.js";import"./chunk-67FK5KGV.js";import"./chunk-PAZSBPJR.js";import"./chunk-UAQQR55F.js";import"./chunk-NP4JFCLE.js";import"./chunk-5Z2H76VD.js";import"./chunk-DRENNWRG.js";import"./chunk-UXNXOMXJ.js";import"./chunk-4SZJF4GK.js";import"./chunk-DHEQMPLW.js";import"./chunk-DUDUIT5P.js";import"./chunk-PRLU3I7G.js";import"./chunk-DXYMTQZ4.js";import"./chunk-FYCH2EYQ.js";import"./chunk-NQXWWE6S.js";import"./chunk-H5EXS3HM.js";import"./chunk-HGFDYOVB.js";import"./chunk-Z2KGMIL4.js";import"./chunk-XIPGCT3D.js";export{a as dependenceSlice};
+//# sourceMappingURL=dependence-slice-2G4X6VSJ.js.map

package/dist/deps-LMCAV5DO.js

@@ -0,0 +1,2 @@
+import{a,b}from"./chunk-6QN4FYQW.js";import"./chunk-OMVNRPST.js";import"./chunk-YDTK77JP.js";import"./chunk-T2PBOVDI.js";import"./chunk-NP4JFCLE.js";import"./chunk-5Z2H76VD.js";import"./chunk-DRENNWRG.js";import"./chunk-PRLU3I7G.js";import"./chunk-DXYMTQZ4.js";import"./chunk-FYCH2EYQ.js";import"./chunk-H5EXS3HM.js";import"./chunk-HGFDYOVB.js";import"./chunk-XIPGCT3D.js";export{a as deps,b as rdeps};
+//# sourceMappingURL=deps-LMCAV5DO.js.map

package/dist/direct-navigation-2ONV22Y2.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import{z as a}from"./chunk-LIWIV26I.js";import"./chunk-IZKJQQCQ.js";import"./chunk-Z67JOKRE.js";import"./chunk-VRJG7N3I.js";export{a as directNavigationQueryCommandDescriptors};
+//# sourceMappingURL=direct-navigation-2ONV22Y2.js.map

package/dist/entry-map-ZOC3VXO5.js

@@ -0,0 +1,2 @@
+import{a,b}from"./chunk-BM4OTGSY.js";import"./chunk-3TNRNKAT.js";import"./chunk-OFZVFIDF.js";import"./chunk-SRIZDEWX.js";import"./chunk-BGBBVSH4.js";import"./chunk-PJBYDCBQ.js";import"./chunk-MTDBHTSF.js";import"./chunk-ZMS4YCY7.js";import"./chunk-IQMGNIGY.js";import"./chunk-MFBVUQJZ.js";import"./chunk-EPLE5O5O.js";import"./chunk-5J3A6RBZ.js";import"./chunk-WRQXLNYE.js";import"./chunk-YDTK77JP.js";import"./chunk-T2PBOVDI.js";import"./chunk-YUKYB54I.js";import"./chunk-4IASLUOP.js";import"./chunk-FLSVYEPL.js";import"./chunk-CTO3TRX7.js";import"./chunk-F4FNK44D.js";import"./chunk-67FK5KGV.js";import"./chunk-PAZSBPJR.js";import"./chunk-UAQQR55F.js";import"./chunk-NP4JFCLE.js";import"./chunk-5Z2H76VD.js";import"./chunk-DRENNWRG.js";import"./chunk-UXNXOMXJ.js";import"./chunk-4SZJF4GK.js";import"./chunk-DHEQMPLW.js";import"./chunk-DUDUIT5P.js";import"./chunk-PRLU3I7G.js";import"./chunk-DXYMTQZ4.js";import"./chunk-FYCH2EYQ.js";import"./chunk-NQXWWE6S.js";import"./chunk-H5EXS3HM.js";import"./chunk-HGFDYOVB.js";import"./chunk-Z2KGMIL4.js";import"./chunk-XIPGCT3D.js";export{b as entryCallMap,a as entryPoints};
+//# sourceMappingURL=entry-map-ZOC3VXO5.js.map

package/dist/exploration-topology-BG4v30HZ.d.ts

@@ -0,0 +1,256 @@
+/**
+ * A repository location is a source-backed place that another query can
+ * retrieve exactly. A null location means the evidence identifies a
+ * repository relationship but the installed index does not retain one
+ * authoritative source line for that relationship.
+ */
+interface ExplorationSourceLocation {
+    file: string;
+    line: number;
+    endLine?: number;
+}
+type ExplorationEvidenceStrength = 'exact' | 'derived' | 'candidate' | 'mixed' | 'unknown';
+type ExplorationDisposition = 'emitted' | 'folded' | 'excluded' | 'unsupported';
+type ExplorationAnchorStatus = 'matched' | 'ambiguous' | 'missing';
+/**
+ * The closed semantic families used to explain program relationships without
+ * baking language or framework vocabulary into the universal graph contract.
+ */
+declare const PROGRAM_EDGE_FAMILIES: readonly ["identity", "contract", "control", "data", "state", "temporal"];
+type ProgramEdgeFamily = (typeof PROGRAM_EDGE_FAMILIES)[number];
+/** Context that qualifies a semantic relationship without changing its family. */
+interface ProgramEdgeSemanticContext {
+    crossesRuntimeBoundary?: true;
+    protocol?: string;
+    runtimeKey?: string;
+    process?: string;
+    transaction?: string;
+    synchronizationScope?: string;
+}
+type ProgramEdgeSemanticAttribute = string | number | boolean | null;
+/** One primitive interpretation of an existing evidenced topology edge. */
+interface ProgramEdgeSemantic {
+    family: ProgramEdgeFamily;
+    subtype: string;
+    context?: ProgramEdgeSemanticContext;
+    /** Evidence-specific values that qualify this primitive relationship. */
+    attributes?: Record<string, ProgramEdgeSemanticAttribute>;
+}
+interface ProgramEdgeFamilyInventory {
+    sourceEdges: number;
+    projectedEdges: number;
+    subtypes: string[];
+}
+/** Diagnostic accounting for semantic coverage of one topology packet. */
+interface ProgramEdgeInventory {
+    sourceEdges: number;
+    mappedSourceEdges: number;
+    projectedEdges: number;
+    unmappedSourceEdges: number;
+    unsupportedSourceEdges: number;
+    unmappedKinds: string[];
+    families: Record<ProgramEdgeFamily, ProgramEdgeFamilyInventory>;
+}
+/**
+ * A completion status names what one repository query established, never
+ * whether the agent has finished the user's task. Selection completion covers
+ * requested units, connector completion covers proved paths between anchors,
+ * frontier accounting covers reversible withheld directions, and incomplete
+ * coverage means at least one required identity or direction remains unknown.
+ */
+type ExplorationCompletionStatus = 'selection-complete' | 'connector-complete' | 'frontier-accounted' | 'coverage-incomplete';
+interface ExplorationCompletion {
+    status: ExplorationCompletionStatus;
+    scope: string;
+    explanation: string;
+}
+/** One independently inspectable basis for a graph relationship. */
+interface ExplorationEvidenceSource {
+    method: string;
+    strength: ExplorationEvidenceStrength;
+    identity: string | null;
+    location: ExplorationSourceLocation | null;
+}
+/**
+ * An anchor records how an explicit query term was tied to repository units.
+ * Candidate identities remain separate from matched identities so ambiguity
+ * is never silently converted into a graph fact.
+ */
+interface ExplorationTopologyAnchor {
+    id: string;
+    kind: string;
+    query: string;
+    status: ExplorationAnchorStatus;
+    nodeIds: string[];
+    candidateNodeIds: string[];
+    omittedCandidates: number;
+}
+/** A node is one repository unit at the resolution chosen by the producer. */
+interface ExplorationTopologyNode {
+    id: string;
+    kind: string;
+    label: string;
+    disposition: ExplorationDisposition;
+    location: ExplorationSourceLocation | null;
+    anchorIds: string[];
+    attributes: Record<string, string | number | boolean | null>;
+}
+/** An edge is one directed, evidenced relationship between two nodes. */
+interface ExplorationTopologyEdge {
+    id: string;
+    kind: string;
+    fromNodeId: string;
+    toNodeId: string;
+    directed: true;
+    disposition: ExplorationDisposition;
+    evidence: ExplorationEvidenceSource[];
+    /** Additive semantic projection; absent means this producer has not mapped the edge yet. */
+    semantics?: ProgramEdgeSemantic[];
+}
+/** A path records a proved or still-partial connection between explicit anchors. */
+interface ExplorationTopologyPath {
+    id: string;
+    fromAnchorId: string;
+    toAnchorId: string;
+    status: 'connected' | 'partial' | 'candidate';
+    nodeIds: string[];
+    edgeIds: string[];
+}
+/**
+ * A frontier group is an accounted direction that the current packet did not
+ * materialize. Its exact members make folding reversible without pretending
+ * that those members were inspected.
+ */
+interface ExplorationFrontierGroup {
+    id: string;
+    kind: string;
+    direction: 'incoming' | 'outgoing' | 'undirected' | 'unresolved';
+    fromNodeIds: string[];
+    edgeIds: string[];
+    memberNodeIds: string[];
+    memberCount: number;
+    disposition: 'folded' | 'excluded' | 'unsupported';
+    reason: string;
+    expansion: string | null;
+}
+interface ExplorationDispositionCounts {
+    total: number;
+    emitted: number;
+    folded: number;
+    excluded: number;
+    unsupported: number;
+}
+/**
+ * Coverage accounts for the declared query scope. It does not claim that the
+ * producer understood the user's English goal or represented dynamic runtime
+ * behavior that its installed analyzers cannot observe.
+ */
+interface ExplorationTopologyCoverage {
+    status: 'accounted' | 'incomplete';
+    scope: string;
+    nodes: ExplorationDispositionCounts;
+    edges: ExplorationDispositionCounts;
+    matchedAnchors: number;
+    ambiguousAnchors: number;
+    missingAnchors: number;
+    omittedCandidates: number;
+    frontierGroups: number;
+    /** Additive semantic inventory; absent on topology values produced before semantic projection. */
+    programEdges?: ProgramEdgeInventory;
+    blindSpots: string[];
+    explanation: string;
+}
+interface ExplorationTopology {
+    schemaVersion: 1;
+    anchors: ExplorationTopologyAnchor[];
+    nodes: ExplorationTopologyNode[];
+    edges: ExplorationTopologyEdge[];
+    paths: ExplorationTopologyPath[];
+    frontiers: ExplorationFrontierGroup[];
+    coverage: ExplorationTopologyCoverage;
+    completion?: ExplorationCompletion;
+    /** Optional proved anchor-to-outcome closure used by system-map rendering. */
+    corridor?: ExplorationCausalCorridor;
+    /** Additive catalogue of proved upstream routes available for explicit selection. */
+    routeCatalog?: ExplorationRouteCatalog;
+}
+interface ExplorationTopologyInput {
+    anchors: readonly ExplorationTopologyAnchor[];
+    nodes: readonly ExplorationTopologyNode[];
+    edges: readonly ExplorationTopologyEdge[];
+    paths?: readonly ExplorationTopologyPath[];
+    frontiers?: readonly ExplorationFrontierGroup[];
+    scope: string;
+    blindSpots?: readonly string[];
+    incompleteReasons?: readonly string[];
+    routeCatalog?: ExplorationRouteCatalog;
+}
+type CausalCorridorStatus = 'complete' | 'incomplete';
+interface CausalCorridorCoverage {
+    protectedNodes: number;
+    protectedEdges: number;
+    baseNodes: number;
+    baseEdges: number;
+    accountedFrontiers: number;
+    unresolvedFrontiers: number;
+    unresolvedEdges: number;
+}
+/**
+ * A causal corridor is the proved subgraph from explicit anchors to mechanical
+ * outcomes, closed over the facts required to interpret that path without
+ * guessing from names or repository vocabulary.
+ */
+interface ExplorationCausalCorridor {
+    schemaVersion: 1;
+    status: CausalCorridorStatus;
+    startNodeIds: string[];
+    outcomeNodeIds: string[];
+    baseNodeIds: string[];
+    baseEdgeIds: string[];
+    nodeIds: string[];
+    edgeIds: string[];
+    accountedFrontierIds: string[];
+    unresolvedFrontierIds: string[];
+    unresolvedEdgeIds: string[];
+    coverage: CausalCorridorCoverage;
+    explanation: string;
+}
+type ExplorationUpstreamEndpointKind = 'public-entry' | 'runtime-boundary' | 'traversal-root';
+interface ExplorationRoute {
+    id: string;
+    status: 'proved';
+    anchorNodeId: string;
+    anchorLabel: string;
+    endpointNodeId: string;
+    endpointLabel: string;
+    endpointLocation: ExplorationSourceLocation;
+    endpointKind: Exclude<ExplorationUpstreamEndpointKind, 'traversal-root'>;
+    /** Ordered in runtime direction, from the upstream endpoint to the anchor. */
+    nodeIds: string[];
+    /** Ordered in runtime direction, from the upstream endpoint to the anchor. */
+    edgeIds: string[];
+    evidenceStrengths: ExplorationEvidenceStrength[];
+    spineEdgeFamilies: ProgramEdgeFamily[];
+    relatedEdgeFamilies: ProgramEdgeFamily[];
+    crossesRuntimeBoundary: boolean;
+}
+interface ExplorationRouteCatalogCoverage {
+    status: 'accounted' | 'incomplete';
+    scope: string;
+    enumeration: 'one-shortest-proved-path-per-endpoint';
+    maximumDepth: number;
+    anchorNodeIds: string[];
+    anchorsWithRoutes: string[];
+    anchorsWithoutRoutes: string[];
+    depthLimitedAnchorNodeIds: string[];
+    routeCount: number;
+    explanation: string;
+}
+interface ExplorationRouteCatalog {
+    schemaVersion: 1;
+    routes: ExplorationRoute[];
+    selectedRouteIds: string[];
+    coverage: ExplorationRouteCatalogCoverage;
+}
+
+export type { ExplorationSourceLocation as E, ProgramEdgeSemantic as P, ExplorationEvidenceStrength as a, ExplorationTopologyNode as b, ExplorationEvidenceSource as c, ExplorationTopology as d, ExplorationAnchorStatus as e, ExplorationCompletion as f, ExplorationCompletionStatus as g, ExplorationDisposition as h, ExplorationDispositionCounts as i, ExplorationFrontierGroup as j, ExplorationTopologyAnchor as k, ExplorationTopologyCoverage as l, ExplorationTopologyEdge as m, ExplorationTopologyInput as n, ExplorationTopologyPath as o };

package/dist/file-dep-graph-Bqg3t3Px.d.ts

@@ -0,0 +1,4 @@
+/** The public relation selected by file dependency analyses. */
+type FileDependencyEdgeBasis = 'symbol-references' | 'imports';
+
+export type { FileDependencyEdgeBasis as F };

package/dist/file-kind-BKCVMNUf.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A file kind is a source-path role distinguished by the convention that
+ * makes a file an executable boundary, re-export surface, worker, test, or
+ * ordinary implementation. It is intentionally derived from paths alone.
+ */
+type FileKind = 'entry' | 'barrel' | 'worker' | 'test' | 'source';
+/** Classify a source path by its structural role without consulting project state. */
+declare function classifyFile(file: string): FileKind;
+
+export { type FileKind as F, classifyFile as c };

package/dist/files-WJQJLHMH.js

@@ -0,0 +1,2 @@
+import{a,b}from"./chunk-KBIC6JHJ.js";import"./chunk-YA72ZUKO.js";import"./chunk-YUKYB54I.js";import"./chunk-DXYMTQZ4.js";import"./chunk-H5EXS3HM.js";import"./chunk-XIPGCT3D.js";export{a as files,b as pathMatchesGlob};
+//# sourceMappingURL=files-WJQJLHMH.js.map