@vostride/agent-qa-knowledge-local 0.2.2 → 0.2.4

package/dist/mark-evidence-plan-CmOkzw6u.d.cts

@@ -0,0 +1,556 @@
+import { EmbeddingProfile, QuarantineLedgerEvent, QuarantineEntryState, VerdictClass, Verdict, RecordFrontmatter, BundleManifest, BundleProvenance, BundleRelations, BundleOutcomeEvent, ArtifactsIndex, ScreenState, MeasurementBaseline, MeasurementObservation, DerivedTrustState, GateLine, RecordId, Anchor, BundleStatus, ScopeKey, IndexEntry, AuthoringBrief, ServedRetrievalTraceV1, InspectFilter, InspectRecordView, RecordChange, KnowledgeRecordShowResult, EvidenceToken, MarkReceipt, CompletedRunHandoff } from '@vostride/agent-qa-schema';
+import { AuthoringReadPort } from '@vostride/agent-qa-agent';
+import { KnowledgeHintReader } from '@vostride/agent-qa-runner';
+import { DatabaseSync } from 'node:sqlite';
+
+interface EmbedderPort {
+    embedDocument(rendering: string): Promise<Float32Array>;
+    embedQuery(rendering: string): Promise<Float32Array>;
+}
+
+declare const INDEX_DB_FILE = "knowledge.db";
+/** Any other stamp resets the index. */
+declare const INDEX_SCHEMA_VERSION = 2;
+declare const INDEX_RENDERING_SCHEMA_VERSION = 2;
+/**
+ * Projection tables every readable index must expose.
+ *
+ * Per-profile vec tables are deliberately excluded: vec0 is a conditional
+ * capability, while operation-time failover and the next rebuild heal a lost
+ * capability-specific table.
+ */
+declare const REQUIRED_INDEX_TABLES: readonly ["records", "fts_records", "anchors", "graph_nodes", "graph_edges", "meta"];
+declare const WRITER_BUSY_TIMEOUT_MS = 2000;
+declare const READER_BUSY_TIMEOUT_MS = 500;
+declare const CHECKPOINT_EVERY_N_BUNDLES = 32;
+type VecCapability = 'vec0' | 'brute';
+interface IndexWriterHandle {
+    db: DatabaseSync;
+    vec: VecCapability;
+    readonly renderingEpochStale: boolean;
+    completeRenderingEpoch(): void;
+    checkpointPassive(): void;
+    close(): void;
+}
+interface IndexReaderConnection {
+    db: DatabaseSync;
+    vec: VecCapability;
+}
+/** Durable writer work that can be inspected without opening a mutable index connection. */
+interface IndexMaintenanceState {
+    indexAbsent: boolean;
+    pendingEmbeddings: number;
+    renderingEpochStale: boolean;
+    vectorReconciliationOutstanding: boolean;
+}
+type IndexHealth = {
+    ok: true;
+} | {
+    ok: false;
+    probe: 'quick-check' | 'projection-schema' | 'schema-version';
+    reason: string;
+};
+interface IndexOpenOptions {
+    vecLoadablePath?: string;
+}
+interface IndexReaderOpenOptions extends IndexOpenOptions {
+    inspectCheckpointedImmutably?: boolean;
+}
+declare function indexDbPath(knowledgeRoot: string): string;
+/**
+ * Inspect bounded durable maintenance facts without bootstrapping, migrating, or restamping.
+ *
+ * Absence is a valid schedulable state. Once the database exists, malformed or incomplete
+ * projection schemas throw so callers cannot mistake an unreadable index for convergence.
+ */
+declare function readIndexMaintenanceState(knowledgeRoot: string): IndexMaintenanceState;
+declare function resolveVecCapability(db: DatabaseSync, loadablePath?: string): VecCapability;
+declare function vecTableName(profile: EmbeddingProfile): string;
+/** Stable identity persisted in meta and used to select a closed-list profile. */
+declare function embeddingProfileKey(profile: EmbeddingProfile): string;
+declare function resolveActiveProfile(db: DatabaseSync): EmbeddingProfile;
+declare function openIndexWriter(knowledgeRoot: string, opts?: IndexOpenOptions): IndexWriterHandle;
+declare function openIndexReaderConnection(knowledgeRoot: string, opts?: IndexReaderOpenOptions): IndexReaderConnection;
+declare function probeIndexHealth(db: DatabaseSync): IndexHealth;
+
+/** The ledger's fixed name directly under the committed knowledge root — never caller-supplied. */
+declare const QUARANTINE_LEDGER_FILENAME = "quarantine.jsonl";
+/** One line the read refused, surfaced as data so a caller can print or audit it. */
+interface RefusedQuarantineLine {
+    /** 1-based, so it matches what an editor shows the human who has to fix the file. */
+    lineNumber: number;
+    reason: string;
+}
+interface QuarantineLedgerRead {
+    events: readonly QuarantineLedgerEvent[];
+    refusedLines: readonly RefusedQuarantineLine[];
+}
+/** The ledger's absolute path under one knowledge root. */
+declare function quarantineLedgerPath(knowledgeRoot: string): string;
+declare function readQuarantineLedger(knowledgeRoot: string): QuarantineLedgerRead;
+declare function foldQuarantineLedgerState(events: readonly QuarantineLedgerEvent[], now: string): QuarantineEntryState[];
+/** What an append answers: how many lines it wrote. */
+type QuarantineAppendOutcome = {
+    kind: 'appended';
+    lines: number;
+};
+
+declare const QUARANTINE_FLAG_FLOOR = 2;
+declare const QUARANTINE_ESCALATE_THRESHOLD = 3;
+declare const QUARANTINE_AUTO_EXIT_PASSES = 5;
+declare const QUARANTINE_DEFAULT_EXPIRY_DAYS = 30;
+/** What escalation does with a verdict class. */
+type QuarantineDisposition = 'auto-quarantine' | 'escalate-only';
+declare const QUARANTINE_CLASS_DISPOSITIONS: {
+    readonly flake: "auto-quarantine";
+    readonly environment: "auto-quarantine";
+    readonly timeout: "auto-quarantine";
+    readonly app_bug: "escalate-only";
+    readonly test_bug: "escalate-only";
+    readonly config_error: "escalate-only";
+    readonly llm_error: "escalate-only";
+    readonly unknown: "escalate-only";
+};
+declare const AUTO_QUARANTINE_CLASSES: readonly VerdictClass[];
+type QuarantineFloorEligibility = 'floor-eligible' | 'authored-required';
+declare const QUARANTINE_FLOOR_ELIGIBILITY: {
+    readonly flake: "floor-eligible";
+    readonly environment: "authored-required";
+    readonly timeout: "floor-eligible";
+    readonly app_bug: "authored-required";
+    readonly test_bug: "authored-required";
+    readonly config_error: "authored-required";
+    readonly llm_error: "authored-required";
+    readonly unknown: "authored-required";
+};
+interface QuarantineDetectionFailure {
+    product: string;
+    filePath: string;
+    testName: string;
+    fingerprint: string;
+    verdictClass: VerdictClass;
+    producer: Verdict['producer'];
+    sameBuildPassAndFail: boolean;
+    /** DISTINCT build ordinals inside the window carrying this fingerprint. */
+    occurrenceOrdinals: number;
+    /** DISTINCT build ordinals inside the window carrying ANY failure — the honest denominator. */
+    windowOrdinals: number;
+}
+/** One recorded outcome, ordinal-keyed. Mirrors the projection's per-test outcome window entry. */
+interface QuarantineOrdinalOutcome {
+    buildOrdinal: number;
+    passed: boolean;
+}
+/** One quarantined test's recent outcome window — the auto-exit's only input. */
+interface QuarantineDetectionTestWindow {
+    product: string;
+    filePath: string;
+    testName: string;
+    /** May carry several entries per ordinal (two runs in one build); order is irrelevant. */
+    ordinals: readonly QuarantineOrdinalOutcome[];
+}
+interface EvaluateQuarantineDetectionInput {
+    failures: readonly QuarantineDetectionFailure[];
+    testWindows: readonly QuarantineDetectionTestWindow[];
+    /** The ledger folded against this same `now` — the suppression and exit input. */
+    entries: readonly QuarantineEntryState[];
+    /** ISO-8601 instant. The ONLY way wall clock enters this rule. */
+    now: string;
+}
+/** A crossing the caller must SHOW: flagged, or escalated-and-deliberately-not-quarantined. */
+interface QuarantineDetectionSighting {
+    product: string;
+    filePath: string;
+    testName: string;
+    fingerprint: string;
+    verdictClass: VerdictClass;
+    producer: Verdict['producer'];
+    occurrenceOrdinals: number;
+    windowOrdinals: number;
+}
+interface QuarantineDetectionResult {
+    /** Lifecycle events to append, entered-then-released, each group identity-sorted. */
+    events: QuarantineLedgerEvent[];
+    /** At the flag floor: suspected flaky, no state change, no ledger write. */
+    flagged: QuarantineDetectionSighting[];
+    /** Escalated but class-gated away from auto-quarantine — the build keeps failing. */
+    escalatedNotQuarantined: QuarantineDetectionSighting[];
+}
+declare function evaluateQuarantineDetection(input: EvaluateQuarantineDetectionInput): QuarantineDetectionResult;
+
+interface LoadedBundle {
+    frontmatter: RecordFrontmatter;
+    summary: string;
+    body: string;
+    manifest: BundleManifest;
+    provenance: BundleProvenance;
+    relations: BundleRelations;
+    events: BundleOutcomeEvent[];
+    artifactsIndex: ArtifactsIndex;
+    screenStates: ScreenState[];
+}
+type LoadBundleOutcome = {
+    kind: 'loaded';
+    bundle: LoadedBundle;
+} | {
+    kind: 'not-found';
+} | {
+    kind: 'incomplete';
+} | {
+    kind: 'version-error';
+    reason: string;
+} | {
+    kind: 'invalid';
+    reason: string;
+};
+interface IntegrityReport {
+    ok: boolean;
+    violations: string[];
+}
+declare const GATES_REL_PATH = "evidence/gates.jsonl";
+interface Measurements {
+    baseline: MeasurementBaseline;
+    observations: MeasurementObservation[];
+}
+declare function readMeasurements(bundleDir: string): Measurements | undefined;
+declare function readGateReceipts(bundleDir: string, bundleId: string): GateLine[] | undefined;
+declare function loadBundle(bundleDir: string): LoadBundleOutcome;
+declare function verifyBundleIntegrity(bundleDir: string): IntegrityReport;
+declare function deriveBundleTrust(loaded: LoadedBundle): DerivedTrustState;
+
+interface KnowledgeHit {
+    bundleId: string;
+    product: string;
+    kind: LoadedBundle['frontmatter']['kind'];
+    subtype: string | null;
+    status: BundleStatus;
+    trust: number;
+    validity: DerivedTrustState['validity'];
+    summary: string;
+    embeddingInput: string;
+}
+interface ScanBundlesOptions {
+    knowledgeRoot: string;
+    text?: string;
+    anchor?: Anchor;
+    product?: string;
+    k?: number;
+}
+interface ScanBundleByIdOptions {
+    knowledgeRoot: string;
+    bundleId: string;
+}
+type CanonicalBundleAnchorLookup = {
+    kind: 'resolved';
+    bundleId: RecordId;
+    product: string;
+    anchors: Anchor[];
+} | {
+    kind: 'unresolved';
+    reason: 'not-found';
+} | {
+    kind: 'unresolved';
+    reason: 'invalid';
+    detail: string;
+};
+interface EnumeratedBundleDir {
+    product: string;
+    dir: string;
+}
+/** Enumerate bundle directories in stable product-then-directory order. */
+declare function enumerateBundleDirs(knowledgeRoot: string): EnumeratedBundleDir[];
+/** The single withdrawn-fact firewall reused by degraded and indexed reader paths. */
+declare function isServable(trust: Pick<DerivedTrustState, 'status' | 'validity'>): boolean;
+declare function scanBundles(opts: ScanBundlesOptions): KnowledgeHit[];
+declare function scanBundleById(opts: ScanBundleByIdOptions): KnowledgeHit | undefined;
+/**
+ * Trusted, read-only lookup for post-verdict attribution. Unlike scanBundleById this deliberately
+ * ignores serving lifecycle state: a handoff may outlive a candidate's promotion, supersession, or
+ * deprecation. Canonical bytes still have to parse and pass the complete integrity oracle.
+ */
+declare function readCanonicalBundleAnchors(input: {
+    knowledgeRoot: string;
+    bundleId: RecordId;
+}): CanonicalBundleAnchorLookup;
+
+declare const REBUILD_MARKER_FILE = ".rebuild-requested";
+type RebuildReason = 'absent' | 'corrupt' | 'locked' | 'schema-version';
+interface RebuildRequest {
+    reason: RebuildReason;
+    detail: string;
+    requestedAt: string;
+}
+interface RequestRebuildOptions {
+    knowledgeRoot: string;
+    reason: RebuildReason;
+    detail: string;
+}
+type ReadRebuildRequestOutcome = {
+    present: false;
+} | {
+    present: true;
+    request: RebuildRequest | undefined;
+};
+/**
+ * Write the first rebuild signal atomically; later signals never overwrite its diagnostic cause.
+ */
+declare function requestRebuild(opts: RequestRebuildOptions): void;
+/** Read a marker through a strict disk-boundary guard; malformed bytes remain a bare signal. */
+declare function readRebuildRequest(knowledgeRoot: string): ReadRebuildRequestOutcome;
+/** Consume the durable rebuild signal. Clearing an absent marker is intentionally a no-op. */
+declare function clearRebuildRequest(knowledgeRoot: string): void;
+
+interface KnowledgeSearchOptions {
+    product?: string;
+    k?: number;
+}
+interface DenseSearchOptions extends KnowledgeSearchOptions {
+    k: number;
+}
+type DenseHit = KnowledgeHit & {
+    distance: number;
+};
+interface KnowledgeReader {
+    /** Current serving face; permanently changes to scan after an index operation failure. */
+    readonly source: 'index' | 'scan';
+    /** Current vector capability; changes to none when the serving face degrades to scan. */
+    readonly vec: VecCapability | 'none';
+    getById(bundleId: string): KnowledgeHit | undefined;
+    searchLexical(text: string, opts?: KnowledgeSearchOptions): KnowledgeHit[];
+    lookupAnchor(anchor: Anchor, opts?: KnowledgeSearchOptions): KnowledgeHit[];
+    searchDense(embedding: Float32Array, opts: DenseSearchOptions): DenseHit[];
+    recheck(hits: readonly KnowledgeHit[]): KnowledgeHit[];
+    close(): void;
+}
+interface OpenKnowledgeReaderOptions {
+    vecLoadablePath?: string;
+}
+type IndexFace = {
+    source: 'index';
+} | {
+    source: 'scan';
+    reason: RebuildReason;
+    detail: string;
+    filePresent: boolean;
+};
+interface ClassifyIndexFaceOptions extends OpenKnowledgeReaderOptions {
+    /** `IndexReaderOpenOptions.inspectCheckpointedImmutably`: the probe only, never the facade. */
+    inspectCheckpointedImmutably?: boolean;
+}
+declare function classifyIndexFace(knowledgeRoot: string, opts?: ClassifyIndexFaceOptions): IndexFace;
+declare function openKnowledgeReader$1(knowledgeRoot: string, opts?: OpenKnowledgeReaderOptions): KnowledgeReader;
+
+interface OpenServingKnowledgeReaderConfig {
+    knowledgeRoot: string;
+    product?: string;
+    scopeDefaults?: {
+        asOfBuild?: number;
+        /** Known containing scopes for member requests (for example, the owning suite). */
+        parentScopes?: readonly ScopeKey[];
+    };
+    budgets?: {
+        recordCap?: number;
+    };
+}
+interface IndexRow {
+    bundle_id: string;
+    product: string;
+    scope_tier: string;
+    scope_key: string;
+}
+interface HydratedEntry {
+    dir: string;
+    bundle: LoadedBundle;
+    entry: IndexEntry;
+}
+/** @deprecated The safe serving reader reports misses as `undefined` and never throws this. */
+declare class KnowledgeRecordNotFoundError extends Error {
+    readonly recordId: RecordId;
+    constructor(recordId: RecordId);
+}
+/** Shared serving internal: scope-laddered index rows (also feeds the authoring reader). */
+declare function readIndexRows(config: OpenServingKnowledgeReaderConfig, scope?: ScopeKey): IndexRow[];
+/** Shared serving internal: integrity-checked bundle hydration (also feeds the authoring reader). */
+declare function hydrateRows(config: OpenServingKnowledgeReaderConfig, rows: readonly IndexRow[], audit: boolean): HydratedEntry[];
+declare function openKnowledgeReader(config: OpenServingKnowledgeReaderConfig): KnowledgeHintReader;
+declare function openKnowledgeReader(knowledgeRoot: string, opts?: OpenKnowledgeReaderOptions): KnowledgeReader;
+
+/**
+ * The bundle facts the matcher folds. `LoadedBundle` satisfies this structurally, so the reader
+ * passes hydrated entries straight through; tests construct the narrow shape directly.
+ */
+interface ProcedureMatchCandidate {
+    entry: IndexEntry;
+    bundle: {
+        summary: string;
+        body: string;
+        events: readonly BundleOutcomeEvent[];
+        provenance: BundleProvenance;
+    };
+}
+
+declare const AUTHORING_EXEMPLAR_CAP = 4;
+declare const AUTHORING_PROCEDURE_CAP = 5;
+declare const AUTHORING_EXCERPT_CHAR_BUDGET = 240;
+/** Hydrated store entry: `LoadedBundle`-backed entries satisfy this structurally. */
+type AuthoringEntryCandidate = ProcedureMatchCandidate;
+interface AuthoringExemplarRow {
+    filePath: string;
+    testName: string;
+    passes: number;
+    failures: number;
+    heals: number;
+    flakeCount: number;
+    /** Resolved by the hydrating reader from the committed quarantine ledger. */
+    quarantined: boolean;
+    /** Last-N window entries — ordinals only, wall-clock never. */
+    lastOutcomes: readonly {
+        buildOrdinal: number;
+        passed: boolean;
+    }[];
+    anchorKeys: readonly string[];
+}
+/** A test reference in the caller-supplied discovery universe (refs only, never content). */
+interface AuthoringTestRef {
+    filePath: string;
+    testName: string;
+}
+interface AssembleAuthoringBriefInput {
+    /** Already-hydrated entries; the reader's SQL scope ladder has applied the scope walls. */
+    entries: readonly AuthoringEntryCandidate[];
+    /** Per-test outcome counters + exercised-anchor sets from the run-outcome projection. */
+    projectionRows: readonly AuthoringExemplarRow[];
+    knownTests?: readonly AuthoringTestRef[];
+    intent: string;
+    scope: ScopeKey;
+    /** `page:`/`flow:` anchors derived from scope + intent by the caller — never a ScreenState. */
+    targetAnchors: readonly Anchor[];
+    budget: number;
+    /** Optional additive dense-leg scores keyed by record id, present only when an embedder is up. */
+    denseScoreByRecordId?: ReadonlyMap<string, number>;
+}
+interface AssembledAuthoringBrief {
+    readonly brief: AuthoringBrief;
+    readonly trace: ServedRetrievalTraceV1;
+}
+/**
+ * Pure screenless assembly over already-loaded snapshot inputs. Retrieval SQL, hydration,
+ * budgets-as-plain-numbers, and the projection read all live at the composition boundary
+ * (`createAuthoringReader`); nothing here touches a connection, the clock, or the filesystem.
+ *
+ * The trace's `rank` is the candidate's 1-based position in the ONE admission walk below —
+ * caution, then procedure, then exemplar, then fact — which is the actual total order this
+ * assembly serves in. Everything the ledger admits becomes a served line; everything it sheds
+ * becomes a cut candidate, bounded by the pinned top-K.
+ */
+declare function assembleAuthoringBrief(input: AssembleAuthoringBriefInput): AssembledAuthoringBrief;
+
+declare const AUTHORING_BRIEF_DEFAULT_BUDGET = 2000;
+/** PROVISIONAL dense candidate cap pending authoring-channel retrieval telemetry. */
+declare const AUTHORING_DENSE_K = 32;
+interface AuthoringReaderDependencies {
+    /** Consumer-owned test inventory crossing this boundary as identity refs only. */
+    discoverKnownTests?: () => readonly AuthoringTestRef[];
+    /** Test/integration seam; production omission uses denseLeg's automatic acquisition ladder. */
+    embedder?: EmbedderPort;
+    now?: () => string;
+}
+/** Open the screenless authoring channel over the same store config as the serving reader. */
+declare function createAuthoringReader(config: OpenServingKnowledgeReaderConfig, deps?: AuthoringReaderDependencies): AuthoringReadPort;
+
+interface InspectRecordsOptions {
+    knowledgeRoot: string;
+    filter: InspectFilter;
+}
+type InspectionTrustState = Pick<DerivedTrustState, 'status' | 'counters' | 'validity'>;
+/**
+ * Project ONE loaded bundle and its already-derived trust into the maintenance view.
+ *
+ * The fold below and `showRecord` both render through this, so a record's row and detail agree.
+ * `bundle.events` is taken as given: an as-of caller narrows the visible events first.
+ */
+declare function toInspectRecordView(entry: EnumeratedBundleDir, bundle: LoadedBundle, trust: InspectionTrustState): InspectRecordView;
+/**
+ * Fold canonical committed bundles into maintenance views. Explicit non-live status filters and
+ * as-of queries enable audit visibility; an unqualified query retains the serving firewall.
+ */
+declare function inspectRecords(options: InspectRecordsOptions): InspectRecordView[];
+
+interface DiffSinceOptions {
+    knowledgeRoot: string;
+    sinceOrdinal: number;
+}
+/** Pure build-ordinal fold over committed bundle outcomes and content-free purge receipts. */
+declare function diffSince(options: DiffSinceOptions): RecordChange[];
+
+interface ShowRecordOptions {
+    knowledgeRoot: string;
+    recordId: string;
+}
+declare function showRecord(options: ShowRecordOptions): KnowledgeRecordShowResult;
+
+type KnowledgeMaintenanceScanIssue = 'directory-read' | 'non-directory-entry' | 'bundle-load' | 'bundle-integrity' | 'receipt-read' | 'receipt-invalid';
+/** Fail-closed maintenance read error: callers must never render a partial clean-looking view. */
+declare class KnowledgeMaintenanceScanError extends Error {
+    readonly name = "KnowledgeMaintenanceScanError";
+    readonly issue: KnowledgeMaintenanceScanIssue;
+    readonly path: string;
+    constructor(issue: KnowledgeMaintenanceScanIssue, path: string, detail: string);
+}
+
+declare const MARK_EVIDENCE_TOKEN_PREFIX = "mark:";
+interface PlanMarkEvidenceInput {
+    knowledgeRoot: string;
+    /** markId is optional: a preview plans ephemeral effects; a resumed writer supplies it to see durable ones. */
+    mark: Pick<MarkReceipt, 'runId' | 'kind'> & {
+        markId?: string;
+    };
+    servedRecordIds: readonly string[];
+    /** Historical observation hashes require the original member/step coordinates. */
+    handoff?: CompletedRunHandoff;
+    /** Host-derived chainJobIdsForRun(runId, idSource).curateMemory; never guessed here. */
+    curationJobIds?: readonly string[];
+}
+type MarkEvidenceEffect = {
+    direction: 'confirm';
+    alreadyAppended: boolean;
+} | {
+    direction: 'overturn';
+    overturnsEvidenceToken: EvidenceToken;
+    overturnsCurationJobId: string;
+    alreadyAppended: boolean;
+};
+type MarkEvidenceTarget = {
+    recordId: string;
+    kind: 'unreadable';
+} | {
+    recordId: string;
+    kind: 'effects';
+    productKey: string;
+    served: boolean;
+    buildOrdinal: number;
+    effects: MarkEvidenceEffect[];
+};
+interface MarkEvidencePlan {
+    targets: MarkEvidenceTarget[];
+    /** Without the handoff, opaque historical canary hashes cannot all be correlated. */
+    correlationIncomplete?: true;
+}
+type AppendMarkEvidenceOutcome = {
+    confirmed: number;
+    overturned: number;
+    skipped: {
+        recordId: string;
+        reason: 'bundle-unreadable' | 'already-appended';
+    }[];
+    /** Without the handoff, opaque historical canary hashes cannot all be correlated. */
+    correlationIncomplete?: true;
+};
+declare function markEvidenceEvent(effect: MarkEvidenceEffect, markId: string, buildOrdinal: number): BundleOutcomeEvent;
+declare function planMarkEvidence(input: PlanMarkEvidenceInput): MarkEvidencePlan;
+/** The outcome an append executing this plan reports, with duplicates counted only on resume. */
+declare function projectMarkEvidenceOutcome(plan: MarkEvidencePlan, options: {
+    includeAlreadyAppended: boolean;
+}): AppendMarkEvidenceOutcome;
+
+export { type OpenServingKnowledgeReaderConfig as $, type AppendMarkEvidenceOutcome as A, type IndexHealth as B, CHECKPOINT_EVERY_N_BUNDLES as C, type DenseHit as D, type EmbedderPort as E, type IndexWriterHandle as F, GATES_REL_PATH as G, type InspectRecordsOptions as H, type IndexReaderConnection as I, type IntegrityReport as J, type KnowledgeReader as K, type LoadedBundle as L, type KnowledgeHit as M, KnowledgeMaintenanceScanError as N, type KnowledgeMaintenanceScanIssue as O, KnowledgeRecordNotFoundError as P, type QuarantineAppendOutcome as Q, type RefusedQuarantineLine as R, type KnowledgeSearchOptions as S, type LoadBundleOutcome as T, MARK_EVIDENCE_TOKEN_PREFIX as U, type VecCapability as V, type MarkEvidenceEffect as W, type MarkEvidencePlan as X, type MarkEvidenceTarget as Y, type Measurements as Z, type OpenKnowledgeReaderOptions as _, type IndexFace as a, readIndexRows as a$, type PlanMarkEvidenceInput as a0, QUARANTINE_AUTO_EXIT_PASSES as a1, QUARANTINE_CLASS_DISPOSITIONS as a2, QUARANTINE_DEFAULT_EXPIRY_DAYS as a3, QUARANTINE_ESCALATE_THRESHOLD as a4, QUARANTINE_FLAG_FLOOR as a5, QUARANTINE_LEDGER_FILENAME as a6, type QuarantineDetectionFailure as a7, type QuarantineDetectionResult as a8, type QuarantineDetectionTestWindow as a9, loadBundle as aA, markEvidenceEvent as aB, openIndexReaderConnection as aC, openIndexWriter as aD, openKnowledgeReader as aE, planMarkEvidence as aF, probeIndexHealth as aG, projectMarkEvidenceOutcome as aH, quarantineLedgerPath as aI, readCanonicalBundleAnchors as aJ, readGateReceipts as aK, readMeasurements as aL, readQuarantineLedger as aM, requestRebuild as aN, resolveActiveProfile as aO, resolveVecCapability as aP, scanBundleById as aQ, scanBundles as aR, showRecord as aS, toInspectRecordView as aT, vecTableName as aU, verifyBundleIntegrity as aV, type HydratedEntry as aW, type IndexRow as aX, QUARANTINE_FLOOR_ELIGIBILITY as aY, type QuarantineFloorEligibility as aZ, hydrateRows as a_, type QuarantineDisposition as aa, type QuarantineLedgerRead as ab, type QuarantineOrdinalOutcome as ac, READER_BUSY_TIMEOUT_MS as ad, REBUILD_MARKER_FILE as ae, REQUIRED_INDEX_TABLES as af, type ReadRebuildRequestOutcome as ag, type RebuildReason as ah, type RequestRebuildOptions as ai, type ScanBundleByIdOptions as aj, type ScanBundlesOptions as ak, type ShowRecordOptions as al, WRITER_BUSY_TIMEOUT_MS as am, assembleAuthoringBrief as an, classifyIndexFace as ao, clearRebuildRequest as ap, createAuthoringReader as aq, deriveBundleTrust as ar, diffSince as as, embeddingProfileKey as at, enumerateBundleDirs as au, evaluateQuarantineDetection as av, foldQuarantineLedgerState as aw, indexDbPath as ax, inspectRecords as ay, isServable as az, type QuarantineDetectionSighting as b, readIndexMaintenanceState as c, type RebuildRequest as d, AUTHORING_BRIEF_DEFAULT_BUDGET as e, AUTHORING_DENSE_K as f, AUTHORING_EXCERPT_CHAR_BUDGET as g, AUTHORING_EXEMPLAR_CAP as h, AUTHORING_PROCEDURE_CAP as i, AUTO_QUARANTINE_CLASSES as j, type AssembleAuthoringBriefInput as k, type AssembledAuthoringBrief as l, type AuthoringEntryCandidate as m, type AuthoringExemplarRow as n, openKnowledgeReader$1 as o, type AuthoringReaderDependencies as p, type AuthoringTestRef as q, readRebuildRequest as r, type CanonicalBundleAnchorLookup as s, type DenseSearchOptions as t, type DiffSinceOptions as u, type EnumeratedBundleDir as v, type EvaluateQuarantineDetectionInput as w, INDEX_DB_FILE as x, INDEX_RENDERING_SCHEMA_VERSION as y, INDEX_SCHEMA_VERSION as z };