@fortemi/core 2026.7.15 → 2026.9.0

package/dist/index.d.ts

@@ -11,6 +11,845 @@ import '@bytecask/core';
  * time-sortable and monotonic within the same millisecond.
  */
 declare function generateId(): string;
+declare const DATASET_INGEST_CONTRACT: "fortemi.dataset-ingest/v1";
+declare const DATASET_INGEST_SCHEMA_VERSION: "1.0.0";
+type DatasetIngestMode = 'full' | 'incremental' | 'snapshot';
+type DatasetRunState = 'cancelled' | 'committed' | 'degraded' | 'failed' | 'running';
+type DatasetVerificationState = 'failed' | 'pending' | 'verified';
+interface DatasetDestinationScope {
+    tenant: string;
+    dataset: string;
+    sourceBinding: string;
+    stream: string;
+    partition?: string;
+}
+interface DatasetProcessingPlan {
+    contract: typeof DATASET_INGEST_CONTRACT;
+    schemaVersion: string;
+    planId: string;
+    planDigest: string;
+    sourceRevision: string;
+    configurationDigest: string;
+    transformationDigest: string;
+    destination: DatasetDestinationScope;
+    mode: DatasetIngestMode;
+    rejectionPolicy: {
+        maxRejectedRecords: number;
+        mode: 'bounded-reject' | 'dlq' | 'fail-fast';
+    };
+    reconciliation: {
+        enabled: boolean;
+        maxTombstones: number;
+    };
+}
+interface DatasetCheckpoint {
+    contract: typeof DATASET_INGEST_CONTRACT;
+    schemaVersion: string;
+    scope: DatasetDestinationScope;
+    opaque: string;
+    sequence: number;
+}
+interface DatasetUpsertMutation {
+    operation: 'upsert';
+    logicalId: string;
+    revision: string;
+    digest: string;
+    value: unknown;
+    locator?: string;
+}
+interface DatasetTombstoneMutation {
+    operation: 'tombstone';
+    logicalId: string;
+    revision: string;
+    digest: string;
+    locator?: string;
+}
+type DatasetMutation = DatasetTombstoneMutation | DatasetUpsertMutation;
+interface DatasetMutationBatch {
+    contract: typeof DATASET_INGEST_CONTRACT;
+    schemaVersion: string;
+    sequence: number;
+    idempotencyKey?: string;
+    mutations: DatasetMutation[];
+    checkpointBefore?: DatasetCheckpoint;
+    checkpointAfter: DatasetCheckpoint;
+    enumeration?: {
+        approvalId?: string;
+        complete: boolean;
+    };
+}
+interface DatasetRecordRejection {
+    logicalIdDigest: string;
+    locator?: string;
+    code: string;
+    message: string;
+}
+interface DatasetRunReceipt {
+    contract: typeof DATASET_INGEST_CONTRACT;
+    schemaVersion: string;
+    runId: string;
+    idempotencyKey: string;
+    requestDigest: string;
+    planId: string;
+    planDigest: string;
+    sourceRevision: string;
+    destination: DatasetDestinationScope;
+    mode: DatasetIngestMode;
+    state: 'committed' | 'degraded';
+    effects: Array<{
+        digest: string;
+        logicalId: string;
+        operation: DatasetMutation['operation'];
+        revision: string;
+    }>;
+    acceptedRecords: number;
+    rejectedRecords: number;
+    rejections: DatasetRecordRejection[];
+    outputDigest: string;
+    checkpointBefore?: DatasetCheckpoint;
+    checkpointAfter: DatasetCheckpoint;
+    verification: 'verified';
+}
+interface DatasetRunAttempt {
+    runId: string;
+    state: DatasetRunState;
+    verification: DatasetVerificationState;
+    idempotencyKey: string;
+    errorCode?: DatasetIngestErrorCode;
+}
+interface DatasetRunStatus {
+    scope: DatasetDestinationScope;
+    lastAttempt?: DatasetRunAttempt;
+    lastSuccessful?: DatasetRunReceipt;
+    freshness: 'current' | 'never' | 'stale';
+}
+type DatasetIngestErrorCode = 'BATCH_OUT_OF_ORDER' | 'CHECKPOINT_MISMATCH' | 'CHECKPOINT_REGRESSION' | 'CHECKPOINT_SCOPE_MISMATCH' | 'CHECKPOINT_VERSION_UNSUPPORTED' | 'IDEMPOTENCY_CONFLICT' | 'INGEST_CANCELLED' | 'INGEST_CONTRACT_UNSUPPORTED' | 'INGEST_SCHEMA_UNSUPPORTED' | 'RECONCILIATION_APPROVAL_REQUIRED' | 'RECONCILIATION_INCOMPLETE' | 'RECONCILIATION_NOT_ENABLED' | 'RECORD_REJECTED' | 'REJECTION_LIMIT_EXCEEDED';
+declare class DatasetIngestError extends Error {
+    readonly code: DatasetIngestErrorCode;
+    constructor(code: DatasetIngestErrorCode, message: string);
+}
+interface DatasetStoredRecord {
+    logicalId: string;
+    revision: string;
+    digest: string;
+    value?: unknown;
+    tombstoned: boolean;
+}
+interface DatasetIngestTransaction {
+    getRecord(logicalId: string): DatasetStoredRecord | undefined;
+    setRecord(record: DatasetStoredRecord): void;
+    getReceipt(idempotencyKey: string): DatasetRunReceipt | undefined;
+    setReceipt(receipt: DatasetRunReceipt): void;
+    getCheckpoint(): DatasetCheckpoint | undefined;
+    setCheckpoint(checkpoint: DatasetCheckpoint): void;
+}
+interface DatasetIngestStore {
+    transact<T>(scopeKey: string, operation: (transaction: DatasetIngestTransaction) => Promise<T> | T): Promise<T>;
+    getReceipt(scopeKey: string, idempotencyKey: string): Promise<DatasetRunReceipt | undefined>;
+    getCheckpoint(scopeKey: string): Promise<DatasetCheckpoint | undefined>;
+    getRecords(scopeKey: string): Promise<DatasetStoredRecord[]>;
+}
+declare class MemoryDatasetIngestStore implements DatasetIngestStore {
+    private readonly scopes;
+    private readonly queues;
+    transact<T>(scopeKey: string, operation: (transaction: DatasetIngestTransaction) => Promise<T> | T): Promise<T>;
+    getReceipt(scopeKey: string, idempotencyKey: string): Promise<DatasetRunReceipt | undefined>;
+    getCheckpoint(scopeKey: string): Promise<DatasetCheckpoint | undefined>;
+    getRecords(scopeKey: string): Promise<DatasetStoredRecord[]>;
+}
+declare function datasetDestinationScopeKey(scope: DatasetDestinationScope): string;
+declare function deriveDatasetIngestIdempotencyKey(plan: DatasetProcessingPlan, batch: DatasetMutationBatch): string;
+interface DatasetIngestHooks {
+    beforeCommit?: () => Promise<void> | void;
+    afterCommit?: (receipt: DatasetRunReceipt) => Promise<void> | void;
+}
+interface ExecuteDatasetBatchOptions {
+    signal?: AbortSignal;
+    hooks?: DatasetIngestHooks;
+    validateRecord?: (mutation: DatasetMutation) => {
+        code: string;
+        message: string;
+    } | undefined;
+}
+declare class DatasetIngestExecutor {
+    private readonly store;
+    private readonly attempts;
+    private readonly successes;
+    constructor(store: DatasetIngestStore);
+    preview(plan: DatasetProcessingPlan, batch: DatasetMutationBatch): {
+        idempotencyKey: string;
+        tombstones: number;
+        upserts: number;
+    };
+    connectionCheck(plan: DatasetProcessingPlan, batch: DatasetMutationBatch): {
+        compatible: true;
+        idempotencyKey: string;
+        scopeKey: string;
+    };
+    executeBatch(plan: DatasetProcessingPlan, batch: DatasetMutationBatch, options?: ExecuteDatasetBatchOptions): Promise<DatasetRunReceipt>;
+    resolveAmbiguousCommit(plan: DatasetProcessingPlan, batch: DatasetMutationBatch): Promise<DatasetRunReceipt | undefined>;
+    status(scope: DatasetDestinationScope, expectedSourceRevision?: string): DatasetRunStatus;
+}
+declare const DATASET_LINEAGE_CONTRACT: "fortemi.dataset-lineage/v1";
+declare const DATASET_LINEAGE_SCHEMA_VERSION: "1.0.0";
+declare const LINEAGE_ENTITY_KINDS: readonly [
+    "dataset",
+    "dataset-revision",
+    "distribution",
+    "record",
+    "field",
+    "chunk",
+    "index",
+    "embedding-set",
+    "graph-artifact",
+    "community-artifact",
+    "processing-plan",
+    "run"
+];
+type LineageEntityKind = typeof LINEAGE_ENTITY_KINDS[number];
+declare const LINEAGE_RELATIONSHIP_KINDS: readonly [
+    "derived-from",
+    "field-derived-from",
+    "extracted-from",
+    "chunk-of",
+    "indexed-from",
+    "embedded-from",
+    "graph-derived-from",
+    "community-derived-from",
+    "revision-of",
+    "distributed-as",
+    "join-influence",
+    "filter-influence",
+    "aggregation-influence",
+    "ordering-influence",
+    "similarity-influence"
+];
+type LineageRelationshipKind = typeof LINEAGE_RELATIONSHIP_KINDS[number];
+type LineageAssertionKind = 'declared' | 'observed';
+type LineagePrivacy = 'confidential' | 'internal' | 'public' | 'restricted';
+interface LineageEntity {
+    id: string;
+    kind: LineageEntityKind;
+    schemaId: string;
+    schemaVersion: string;
+    revision?: string;
+    datasetId?: string;
+    createdAt: string;
+    attributes?: Record<string, unknown>;
+}
+interface LineageAgent {
+    id: string;
+    kind: 'organization' | 'person' | 'service' | 'software';
+    name: string;
+    version?: string;
+}
+interface LineageActivity {
+    id: string;
+    kind: 'correction' | 'export' | 'import' | 'index' | 'ingest' | 'query' | 'transform';
+    planId?: string;
+    runId?: string;
+    startedAt: string;
+    endedAt?: string;
+    agentIds: string[];
+}
+interface LineageEvidence {
+    id: string;
+    revision: string;
+    locator: string;
+    digest: string;
+    mediaType?: string;
+    privacy: LineagePrivacy;
+    capturedAt: string;
+    payload?: unknown;
+}
+interface LineageEvidenceReference {
+    evidenceId: string;
+    revision: string;
+    digest: string;
+    locator?: string;
+}
+interface LineageAssertion {
+    id: string;
+    revision: string;
+    relationship: LineageRelationshipKind;
+    assertionKind: LineageAssertionKind;
+    sourceEntityId: string;
+    targetEntityId: string;
+    issuerAgentId: string;
+    producingActivityId?: string;
+    method: string;
+    evidence: LineageEvidenceReference[];
+    confidence: number;
+    privacy: LineagePrivacy;
+    schemaId: string;
+    schemaVersion: string;
+    assertedAt: string;
+}
+interface LineageCorrection {
+    id: string;
+    assertionId: string;
+    assertionRevision: string;
+    action: 'correct' | 'retract' | 'supersede';
+    issuerAgentId: string;
+    activityId: string;
+    reason: string;
+    recordedAt: string;
+    replacementAssertionId?: string;
+    replacementRevision?: string;
+}
+interface LineageLedgerArchive {
+    contract: typeof DATASET_LINEAGE_CONTRACT;
+    schemaVersion: string;
+    snapshot: number;
+    entities: LineageEntity[];
+    agents: LineageAgent[];
+    activities: LineageActivity[];
+    evidence: LineageEvidence[];
+    assertions: LineageAssertion[];
+    corrections: LineageCorrection[];
+    digest: string;
+}
+interface LineageAuthorizationPolicy {
+    canReadEntity(entity: LineageEntity): boolean;
+    canReadAssertion(assertion: LineageAssertion): boolean;
+    canReadEvidence(evidence: LineageEvidence): boolean;
+}
+interface LineageTraversalRequest {
+    startEntityIds: string[];
+    direction: 'both' | 'downstream' | 'upstream';
+    entityKinds?: LineageEntityKind[];
+    relationshipKinds?: LineageRelationshipKind[];
+    assertionKinds?: LineageAssertionKind[];
+    maximumDepth: number;
+    maximumResults: number;
+    pageSize: number;
+    snapshot?: number;
+    cursor?: string;
+    includeEvidence?: boolean;
+}
+interface LineageTraversalNode {
+    entity: LineageEntity;
+    depth: number;
+    pathAssertionIds: string[];
+}
+interface LineageTraversalEdge {
+    assertion: LineageAssertion;
+    status: 'active' | 'corrected' | 'retracted' | 'superseded';
+    evidence?: LineageEvidence[];
+}
+interface LineageTraversalResult {
+    contract: typeof DATASET_LINEAGE_CONTRACT;
+    schemaVersion: string;
+    snapshot: number;
+    nodes: LineageTraversalNode[];
+    edges: LineageTraversalEdge[];
+    nextCursor?: string;
+    truncated: boolean;
+}
+type LineageValidationCode = 'ACTIVITY_REQUIRED' | 'AGENT_DANGLING' | 'CORRECTION_INVALID' | 'CURSOR_INVALID' | 'EVIDENCE_DANGLING' | 'EVIDENCE_DIGEST_MISMATCH' | 'IDENTITY_DANGLING' | 'IDENTITY_DUPLICATE' | 'IDENTITY_REQUIRED' | 'SNAPSHOT_UNAVAILABLE' | 'TRAVERSAL_LIMIT_EXCEEDED' | 'TYPE_DIRECTION_INVALID' | 'VALUE_INVALID';
+declare class LineageValidationError extends Error {
+    readonly code: LineageValidationCode;
+    constructor(code: LineageValidationCode, message: string);
+}
+interface LineageProjectionCapabilities {
+    entityKinds: LineageEntityKind[];
+    relationshipKinds: LineageRelationshipKind[];
+    assertionKinds: LineageAssertionKind[];
+    preservesEvidence: boolean;
+    preservesCorrections: boolean;
+}
+interface LineageLossItem {
+    path: string;
+    reason: 'corrections-omitted' | 'evidence-omitted' | 'unsupported-assertion-kind' | 'unsupported-entity-kind' | 'unsupported-relationship-kind';
+    canonicalDigest: string;
+}
+interface LineageLossReceipt {
+    contract: typeof DATASET_LINEAGE_CONTRACT;
+    schemaVersion: string;
+    sourceDigest: string;
+    projectionDigest: string;
+    lossless: boolean;
+    losses: LineageLossItem[];
+}
+interface LineageProjection {
+    contract: typeof DATASET_LINEAGE_CONTRACT;
+    schemaVersion: string;
+    canonical: false;
+    regenerable: true;
+    sourceDigest: string;
+    entities: LineageEntity[];
+    assertions: LineageAssertion[];
+    evidence: LineageEvidence[];
+    corrections: LineageCorrection[];
+    digest: string;
+    lossReceipt: LineageLossReceipt;
+}
+declare function computeLineageDigest(value: unknown): string;
+interface DatasetLineageLedgerOptions {
+    maximumTraversalDepth?: number;
+    maximumTraversalResults?: number;
+    maximumPageSize?: number;
+}
+/**
+ * Append-only canonical lineage ledger. Graph and index views are projections;
+ * this ledger remains the authority for assertions and their evidence.
+ */
+declare class DatasetLineageLedger {
+    private sequence;
+    private readonly entities;
+    private readonly agents;
+    private readonly activities;
+    private readonly evidence;
+    private readonly assertions;
+    private readonly corrections;
+    private readonly maximumTraversalDepth;
+    private readonly maximumTraversalResults;
+    private readonly maximumPageSize;
+    constructor(options?: DatasetLineageLedgerOptions);
+    get snapshot(): number;
+    appendEntity(entity: LineageEntity): number;
+    appendAgent(agent: LineageAgent): number;
+    appendActivity(activity: LineageActivity): number;
+    appendEvidence(item: LineageEvidence): number;
+    appendAssertion(assertion: LineageAssertion): number;
+    appendCorrection(correction: LineageCorrection): number;
+    traverse(request: LineageTraversalRequest, policy: LineageAuthorizationPolicy): LineageTraversalResult;
+    exportArchive(snapshot?: number): LineageLedgerArchive;
+    static importArchive(archive: LineageLedgerArchive, options?: DatasetLineageLedgerOptions): DatasetLineageLedger;
+    project(capabilities: LineageProjectionCapabilities, snapshot?: number): LineageProjection;
+    private append;
+    private ensureUnique;
+    private visibleAt;
+    private sorted;
+    private hasReplacementPermission;
+    private statusAt;
+    private validateTraversalRequest;
+    private traversalFingerprint;
+    private decodeCursor;
+}
+/**
+ * Language-neutral dataset execution capability negotiation contract.
+ *
+ * A descriptor reports demonstrated behavior for one concrete runtime. It is
+ * not inferred from a package/backend name and it does not establish liveness.
+ */
+declare const DATASET_EXECUTION_CONTRACT: "fortemi.dataset-execution-capabilities/v1";
+declare const DATASET_EXECUTION_SCHEMA_VERSION: "1.0.0";
+declare const DATASET_EXECUTION_CAPABILITY_IDS: readonly [
+    "ingest.full",
+    "ingest.snapshot",
+    "ingest.incremental",
+    "ingest.stream",
+    "schema.inspect",
+    "identity.stable-revision",
+    "identity.record",
+    "mutation.upsert",
+    "mutation.tombstone",
+    "mutation.reconcile",
+    "checkpoint.read",
+    "checkpoint.write",
+    "execution.cancel",
+    "rejection.record",
+    "index.lexical",
+    "index.chunk",
+    "index.vector",
+    "index.hybrid",
+    "index.rerank",
+    "index.graph",
+    "index.community",
+    "lineage.dataset",
+    "lineage.record",
+    "lineage.field",
+    "lineage.relationship-evidence",
+    "transaction.atomic-batch",
+    "privacy.pre-materialization-filter",
+    "pagination.cursor",
+    "ordering.deterministic"
+];
+type DatasetExecutionCapabilityId = typeof DATASET_EXECUTION_CAPABILITY_IDS[number];
+type DatasetExecutionPlane = 'browser-local-archive' | 'live-remote-persistence' | 'portable-shard' | 'server-process' | 'static-cache';
+type DatasetExecutionDataClass = 'canonical' | 'portable-projection' | 'regenerable-index' | 'remote-persistence' | 'static-cache';
+type DatasetExecutionMaturity = 'alpha' | 'beta' | 'experimental' | 'stable';
+type DatasetCapabilityStatus = 'experimental' | 'supported' | 'unsupported';
+interface DatasetCapabilityEvidence {
+    id: string;
+    kind: 'conformance-report' | 'fixture' | 'live-qualification';
+    uri: string;
+    digest?: string;
+}
+interface DatasetCapabilityLimits {
+    maxInputBytes?: number;
+    maxRecordBytes?: number;
+    maxBatchRecords?: number;
+    maxConcurrency?: number;
+    maxPageSize?: number;
+    maxTraversalDepth?: number;
+}
+interface DatasetCapabilityDeclaration {
+    id: DatasetExecutionCapabilityId;
+    version: string;
+    status: DatasetCapabilityStatus;
+    limits?: DatasetCapabilityLimits;
+    evidence: string[];
+}
+interface DatasetExecutionCapabilityDescriptor {
+    contract: typeof DATASET_EXECUTION_CONTRACT;
+    schemaVersion: string;
+    runtime: {
+        dataClass: DatasetExecutionDataClass;
+        id: string;
+        maturity: DatasetExecutionMaturity;
+        plane: DatasetExecutionPlane;
+        version: string;
+    };
+    guarantees: {
+        availability: 'local-process' | 'remote-service' | 'single-host';
+        durability: 'filesystem' | 'memory' | 'process' | 'replicated' | 'wal';
+        isolation: 'none' | 'serializable' | 'snapshot';
+        ordering: 'backend-cursor' | 'stable-identity' | 'unspecified';
+        transaction: 'atomic-batch' | 'none' | 'single-record';
+    };
+    capabilities: DatasetCapabilityDeclaration[];
+    evidence: DatasetCapabilityEvidence[];
+}
+interface DatasetCapabilityRequirement {
+    id: DatasetExecutionCapabilityId;
+    minimumVersion?: string;
+    minimumLimits?: DatasetCapabilityLimits;
+}
+interface DatasetOptionalCapabilityRequirement extends DatasetCapabilityRequirement {
+    fallback?: DatasetExecutionCapabilityId[];
+}
+interface DatasetCapabilityNegotiationRequest {
+    contract: typeof DATASET_EXECUTION_CONTRACT;
+    required: DatasetCapabilityRequirement[];
+    optional?: DatasetOptionalCapabilityRequirement[];
+}
+type DatasetCapabilityDiagnosticCode = 'CAPABILITY_DUPLICATE' | 'CAPABILITY_INCONSISTENT' | 'CAPABILITY_LIMIT_INSUFFICIENT' | 'CAPABILITY_VERSION_INSUFFICIENT' | 'CONTRACT_MAJOR_UNSUPPORTED' | 'DESCRIPTOR_INVALID' | 'REQUIRED_CAPABILITY_MISSING' | 'SCHEMA_VERSION_UNSUPPORTED';
+interface DatasetCapabilityDiagnostic {
+    code: DatasetCapabilityDiagnosticCode;
+    capability?: DatasetExecutionCapabilityId;
+    path?: string;
+    message: string;
+}
+interface DatasetCapabilityDegradation {
+    requested: DatasetExecutionCapabilityId;
+    selected?: DatasetExecutionCapabilityId;
+    reason: 'limit-insufficient' | 'unsupported' | 'version-insufficient';
+    changedGuarantees: string[];
+}
+interface DatasetCapabilityNegotiationResult {
+    contract: typeof DATASET_EXECUTION_CONTRACT;
+    accepted: boolean;
+    runtime: DatasetExecutionCapabilityDescriptor['runtime'];
+    selected: DatasetExecutionCapabilityId[];
+    degradations: DatasetCapabilityDegradation[];
+    diagnostics: DatasetCapabilityDiagnostic[];
+}
+declare function validateDatasetExecutionDescriptor(descriptor: DatasetExecutionCapabilityDescriptor): DatasetCapabilityDiagnostic[];
+/** Pure negotiation: performs no I/O and cannot mutate the descriptor or request. */
+declare function negotiateDatasetExecutionCapabilities(descriptor: DatasetExecutionCapabilityDescriptor, request: DatasetCapabilityNegotiationRequest): DatasetCapabilityNegotiationResult;
+/** Descriptor for the journaled browser-local RecordStore/PGlite projection. */
+declare const FORTEMI_BROWSER_LOCAL_DATASET_EXECUTION_DESCRIPTOR: DatasetExecutionCapabilityDescriptor;
+/** Descriptor for the read-only generated Fortemi index cache. */
+declare const FORTEMI_STATIC_CACHE_DATASET_EXECUTION_DESCRIPTOR: DatasetExecutionCapabilityDescriptor;
+/** Descriptor for a verified, immutable Knowledge Shard projection. */
+declare const FORTEMI_PORTABLE_SHARD_DATASET_EXECUTION_DESCRIPTOR: DatasetExecutionCapabilityDescriptor;
+declare const DATASET_MATERIALIZATION_CONTRACT: "fortemi.dataset-materialization-profile/v1";
+declare const DATASET_MATERIALIZATION_SCHEMA_VERSION: "1.0.0";
+declare const DATASET_MATERIALIZATION_KINDS: readonly [
+    "chunking",
+    "lexical",
+    "vector",
+    "hybrid",
+    "rerank",
+    "entity-relationship-extraction",
+    "graph-retrieval",
+    "community"
+];
+type DatasetMaterializationKind = typeof DATASET_MATERIALIZATION_KINDS[number];
+type DatasetMaterializationOperation = 'build' | 'query';
+type DatasetDeterminismClass = 'deterministic' | 'nondeterministic' | 'seeded';
+type DatasetPrivacyBoundary = 'chunking' | 'index-persistence' | 'model-invocation';
+type DatasetProfileStatus = 'experimental' | 'supported' | 'unsupported';
+type DatasetDigest = `sha256:${string}`;
+interface DatasetImplementationIdentity {
+    id: string;
+    version: string;
+    digest: DatasetDigest;
+    model?: {
+        digest: DatasetDigest;
+        id: string;
+        version: string;
+    };
+}
+interface DatasetMaterializationProfile {
+    contract: typeof DATASET_MATERIALIZATION_CONTRACT;
+    schemaVersion: string;
+    id: string;
+    version: string;
+    kind: DatasetMaterializationKind;
+    status: DatasetProfileStatus;
+    operations: DatasetMaterializationOperation[];
+    inputTypes: string[];
+    implementation: DatasetImplementationIdentity;
+    configurationSchema: Record<string, unknown>;
+    requiredRuntimeCapabilities: DatasetCapabilityRequirement[];
+    optionalRuntimeCapabilities?: Array<DatasetCapabilityRequirement & {
+        fallback?: DatasetExecutionCapabilityId[];
+    }>;
+    determinism: {
+        class: DatasetDeterminismClass;
+        seedRequired?: boolean;
+    };
+    privacy: {
+        authorizationRequired: true;
+        behavior: 'local-only' | 'policy-filtered-external';
+        filtersBefore: DatasetPrivacyBoundary[];
+    };
+    resourceLimits: {
+        maxConcurrency: number;
+        maxInputBytes: number;
+        maxMemoryBytes?: number;
+        maxRecords: number;
+        timeoutMs?: number;
+    };
+    output: {
+        canonicalMutation: false;
+        dataClass: 'regenerable-index';
+    };
+}
+interface DatasetProfileNegotiationRequest {
+    operation: DatasetMaterializationOperation;
+    profile: DatasetMaterializationProfile;
+    runtime: DatasetExecutionCapabilityDescriptor;
+    fallbackProfiles?: DatasetMaterializationProfile[];
+}
+interface DatasetProfileNegotiationResult {
+    accepted: boolean;
+    requestedProfile: string;
+    selectedProfile?: string;
+    runtime: DatasetExecutionCapabilityDescriptor['runtime'];
+    degraded: boolean;
+    degradations: DatasetCapabilityDegradation[];
+    diagnostics: Array<{
+        code: 'NO_FALLBACK_PROFILE' | 'OPERATION_UNSUPPORTED' | 'PROFILE_INVALID' | 'PROFILE_UNSUPPORTED';
+        message: string;
+        path?: string;
+    } | DatasetCapabilityDiagnostic>;
+}
+interface DatasetSourceRecord {
+    logicalId: string;
+    revision: string;
+    digest: DatasetDigest;
+    content: unknown;
+    locator?: string;
+}
+interface DatasetSourceSnapshot {
+    datasetId: string;
+    revision: string;
+    schemaId: string;
+    schemaVersion: string;
+    schemaDigest: DatasetDigest;
+    sourceDigests: DatasetDigest[];
+    records: DatasetSourceRecord[];
+}
+interface DatasetPrivacyDecision {
+    policyId: string;
+    policyVersion: string;
+    policyDigest: DatasetDigest;
+    allowedRecordDigests: DatasetDigest[];
+    deniedRecordDigests: DatasetDigest[];
+    evaluatedAt: string;
+}
+interface DatasetMaterializationArtifact {
+    kind: 'chunk' | 'community' | 'entity' | 'graph-result' | 'lexical-entry' | 'relationship' | 'reranked-hit' | 'vector';
+    logicalId: string;
+    sourceRecordDigests: DatasetDigest[];
+    digest: DatasetDigest;
+    payload?: unknown;
+    score?: number;
+}
+interface DatasetMeasuredResources {
+    elapsedMs: number;
+    inputBytes: number;
+    peakMemoryBytes?: number;
+    modelInvocations: number;
+    persistedBytes: number;
+}
+interface DatasetMaterializationRequest {
+    runId: string;
+    processingRunId: string;
+    snapshot: DatasetSourceSnapshot;
+    profile: DatasetMaterializationProfile;
+    configuration: unknown;
+    operation: 'build';
+    mode: 'full' | 'incremental';
+    affected?: {
+        chunkDigests: DatasetDigest[];
+        recordDigests: DatasetDigest[];
+        sourceRevisions: string[];
+    };
+}
+interface DatasetMaterializationReceipt {
+    contract: typeof DATASET_MATERIALIZATION_CONTRACT;
+    schemaVersion: string;
+    receiptId: string;
+    runId: string;
+    processingRunId: string;
+    source: {
+        datasetId: string;
+        digests: DatasetDigest[];
+        revision: string;
+    };
+    schema: {
+        digest: DatasetDigest;
+        id: string;
+        version: string;
+    };
+    profile: {
+        configurationDigest: DatasetDigest;
+        digest: DatasetDigest;
+        id: string;
+        implementation: DatasetImplementationIdentity;
+        version: string;
+    };
+    runtime: DatasetExecutionCapabilityDescriptor['runtime'];
+    negotiation: Pick<DatasetProfileNegotiationResult, 'degradations' | 'degraded' | 'requestedProfile' | 'selectedProfile'>;
+    mode: 'full' | 'incremental';
+    affected: {
+        chunkDigests: DatasetDigest[];
+        recordDigests: DatasetDigest[];
+        sourceRevisions: string[];
+    };
+    output: {
+        aggregateDigest: DatasetDigest;
+        counts: Record<string, number>;
+        digests: DatasetDigest[];
+    };
+    privacy: DatasetPrivacyDecision;
+    resources: DatasetMeasuredResources;
+    createdAt: string;
+}
+interface DatasetRetrievalRequest {
+    queryId: string;
+    operation: 'query';
+    profile: DatasetMaterializationProfile;
+    query: unknown;
+    limit: number;
+}
+interface DatasetRetrievalResponse {
+    contract: typeof DATASET_MATERIALIZATION_CONTRACT;
+    schemaVersion: string;
+    queryId: string;
+    requestedProfile: string;
+    actualProfile: string;
+    actualBackend: {
+        id: string;
+        plane: DatasetExecutionCapabilityDescriptor['runtime']['plane'];
+        version: string;
+    };
+    degraded: boolean;
+    fallbackReason?: string;
+    scoreSemantics: {
+        comparableAcrossImplementations: false;
+        implementationScoped: true;
+    };
+    results: DatasetMaterializationArtifact[];
+    receiptId: string;
+}
+interface DatasetBenchmarkEvidence {
+    contract: typeof DATASET_MATERIALIZATION_CONTRACT;
+    schemaVersion: string;
+    evidenceType: 'benchmark';
+    benchmarkId: string;
+    corpus: {
+        bytes: number;
+        digest: DatasetDigest;
+        id: string;
+        records: number;
+        revision: string;
+    };
+    hardware: {
+        accelerator?: string;
+        cpu: string;
+        memoryBytes: number;
+        runtime: string;
+    };
+    implementation: DatasetImplementationIdentity;
+    profile: {
+        configurationDigest: DatasetDigest;
+        digest: DatasetDigest;
+        id: string;
+        version: string;
+    };
+    correctness: {
+        passed: boolean;
+        receiptDigest: DatasetDigest;
+        suite: string;
+    };
+    freshness: {
+        measuredAt: string;
+        sourceRevision: string;
+    };
+    measurements: Array<{
+        name: string;
+        unit: 'bytes' | 'ms' | 'queries/s' | 'records/s';
+        value: number;
+    }>;
+    claims: {
+        corpusScoped: true;
+        universalScaleLimit: false;
+    };
+}
+interface DatasetMaterializationAdapter {
+    readonly backend: {
+        id: string;
+        version: string;
+    };
+    materialize(input: Readonly<{
+        affected: DatasetMaterializationReceipt['affected'];
+        configuration: unknown;
+        mode: 'full' | 'incremental';
+        profile: DatasetMaterializationProfile;
+        snapshot: DatasetSourceSnapshot;
+    }>): Promise<{
+        artifacts: DatasetMaterializationArtifact[];
+        resources: DatasetMeasuredResources;
+    }>;
+    retrieve?(input: Readonly<{
+        profile: DatasetMaterializationProfile;
+        request: DatasetRetrievalRequest;
+    }>): Promise<DatasetMaterializationArtifact[]>;
+}
+type DatasetRecordAuthorizer = (record: Readonly<DatasetSourceRecord>) => boolean | Promise<boolean>;
+declare class DatasetMaterializationError extends Error {
+    readonly code: 'ADAPTER_MISMATCH' | 'CONFIGURATION_INVALID' | 'NEGOTIATION_FAILED' | 'PROFILE_INVALID' | 'RESOURCE_LIMIT_EXCEEDED';
+    constructor(code: 'ADAPTER_MISMATCH' | 'CONFIGURATION_INVALID' | 'NEGOTIATION_FAILED' | 'PROFILE_INVALID' | 'RESOURCE_LIMIT_EXCEEDED', message: string);
+}
+declare function digestDatasetMaterializationValue(value: unknown): DatasetDigest;
+/** Negotiate the profile and its required/optional runtime capabilities before any build or query I/O. */
+declare function negotiateDatasetMaterializationProfile(request: DatasetProfileNegotiationRequest): DatasetProfileNegotiationResult;
+/**
+ * Runs authorization before the adapter sees text, model inputs, or persistence inputs.
+ * The adapter receives a detached immutable snapshot and can only return derived artifacts.
+ */
+declare function executeDatasetMaterialization(request: DatasetMaterializationRequest, runtime: DatasetExecutionCapabilityDescriptor, adapter: DatasetMaterializationAdapter, authorize: DatasetRecordAuthorizer, options?: {
+    fallbackProfiles?: DatasetMaterializationProfile[];
+    now?: () => string;
+}): Promise<{
+    artifacts: DatasetMaterializationArtifact[];
+    receipt: DatasetMaterializationReceipt;
+}>;
+declare function executeDatasetRetrieval(request: DatasetRetrievalRequest, runtime: DatasetExecutionCapabilityDescriptor, adapter: DatasetMaterializationAdapter, receiptId: string, fallbackProfiles?: DatasetMaterializationProfile[]): Promise<DatasetRetrievalResponse>;
+interface DatasetIncrementalParityResult {
+    equivalent: boolean;
+    mismatches: Array<'chunks' | 'communities' | 'digests' | 'identities' | 'ordering' | 'relationships'>;
+}
+/** Compares every correctness dimension required before incremental output may replace a full rebuild. */
+declare function compareDatasetIncrementalParity(full: readonly DatasetMaterializationArtifact[], incremental: readonly DatasetMaterializationArtifact[]): DatasetIncrementalParityResult;
+/** Benchmark evidence is publishable only after correctness and source-binding gates pass. */
+declare function validateDatasetBenchmarkEvidence(evidence: DatasetBenchmarkEvidence): string[];
 /**
  * Typed event bus with IDisposable subscriptions (Monaco-style).
  * SSE-style pub/sub across all layers.
@@ -40,6 +879,14 @@ interface EventMap {
         id: string;
         revisionNumber: number;
     };
+    'source.upserted': {
+        counts: Record<string, number>;
+        importRunId: string;
+    };
+    'purge.completed': {
+        counts: Record<string, number>;
+        receiptId: string;
+    };
     'search.reindexed': Record<string, never>;
     'embedding.ready': {
         noteId: string;
@@ -96,6 +943,51 @@ interface EventMap {
         id: string;
         name: string;
     };
+    'provider.route.configured': {
+        fallback?: boolean;
+        hasRequirements: boolean;
+        model?: string;
+        providerIds: string[];
+        task: string;
+    };
+    'provider.route.cleared': {
+        task?: string;
+    };
+    'provider.route.selected': {
+        capability: string;
+        model?: string;
+        providerId: string;
+        providerName: string;
+        routeMatched: boolean;
+        task?: string;
+        tier: string;
+    };
+    'provider.route.completed': {
+        attempt: number;
+        capability: string;
+        fallbackCount: number;
+        latencyMs: number;
+        model?: string;
+        providerId: string;
+        providerName: string;
+        routeMatched: boolean;
+        task?: string;
+        tier: string;
+    };
+    'provider.route.failed': {
+        attempt: number;
+        capability: string;
+        error: string;
+        errorCategory: string;
+        fallbackCount: number;
+        latencyMs: number;
+        model?: string;
+        providerId?: string;
+        providerName?: string;
+        routeMatched: boolean;
+        task?: string;
+        tier?: string;
+    };
     'provider.fallback': {
         error: string;
         errorCategory: string;
@@ -1542,6 +2434,58 @@ declare class EmbeddingSetsRepository {
     private inferDefinitionModel;
     private inferDefinitionDimension;
 }
+declare const REGISTERED_METADATA_PATHS: readonly [
+    "provider",
+    "model",
+    "role",
+    "event_kind",
+    "sensitivity",
+    "import_run_id"
+];
+type RegisteredMetadataPath = typeof REGISTERED_METADATA_PATHS[number];
+type MetadataPredicate = {
+    gte?: number | string;
+    lte?: number | string;
+    op: 'range';
+    path: RegisteredMetadataPath;
+} | {
+    op: 'eq';
+    path: RegisteredMetadataPath;
+    value: boolean | null | number | string;
+} | {
+    op: 'exists';
+    path: RegisteredMetadataPath;
+    value?: boolean;
+} | {
+    op: 'in';
+    path: RegisteredMetadataPath;
+    value: readonly (boolean | null | number | string)[];
+};
+interface EvidenceLocator {
+    note_id: string;
+    chunk?: {
+        index: number;
+        kind: 'attachment' | 'current' | 'title';
+    };
+    span?: {
+        end: number;
+        start: number;
+    };
+    source?: {
+        external_id_hash: string;
+        import_run_id: string;
+        namespace: string;
+        schema_version: string;
+    };
+    metadata_paths: RegisteredMetadataPath[];
+}
+interface MetadataPredicateConditionResult {
+    conditions: string[];
+    joins: string[];
+    params: unknown[];
+    nextIdx: number;
+}
+declare function buildMetadataPredicateConditions(options: Pick<SearchOptions, 'archive_id' | 'metadataPredicates' | 'tenant_id'>, startIdx: number): MetadataPredicateConditionResult;
 /**
  * Shared types for repository layer.
  * All repository methods use these types as inputs and outputs.
@@ -1628,6 +2572,7 @@ interface SearchResult {
     updated_at: Date;
     tags: string[];
     has_embedding?: boolean;
+    locators?: EvidenceLocator[];
 }
 interface SearchFacets {
     tags: {
@@ -1662,6 +2607,9 @@ interface SearchOptions {
     format?: string;
     source?: string;
     visibility?: string;
+    tenant_id?: string;
+    archive_id?: null | string;
+    metadataPredicates?: readonly MetadataPredicate[];
     include_facets?: boolean;
     mode?: 'auto' | 'hybrid' | 'semantic' | 'text';
     embeddingSetId?: string;
@@ -1756,6 +2704,8 @@ declare class SearchRepository {
     private scopeToResolvedEmbeddingRows;
     private fetchEmbeddingStatus;
     private attachEmbeddingStatus;
+    private fetchLocatorMap;
+    private metadataPaths;
     search(query: string, options?: SearchOptions, queryEmbedding?: number[]): Promise<SearchResponse>;
     semanticSearch(queryEmbedding: number[], options?: SearchOptions): Promise<SearchResponse>;
     hybridSearch(query: string, queryEmbedding: number[], options?: SearchOptions): Promise<SearchResponse>;
@@ -1763,6 +2713,100 @@ declare class SearchRepository {
     private fetchFacets;
     private fetchTagMap;
 }
+type SourceUpsertPolicy = 'conflict' | 'replace' | 'version';
+type SourceUpsertOutcome = 'conflict' | 'inserted' | 'rejected' | 'replaced' | 'unchanged' | 'versioned';
+interface SourceIdentityInput {
+    tenant_id?: string;
+    archive_id?: null | string;
+    namespace: string;
+    external_id: string;
+    source_schema_version: string;
+    import_run_id: string;
+    caller_stable_id?: string;
+}
+interface SourceUpsertItem {
+    source: SourceIdentityInput;
+    title?: null | string;
+    content: string;
+    format?: string;
+    visibility?: string;
+    metadata?: null | Record<string, unknown>;
+    policy?: SourceUpsertPolicy;
+}
+interface SourceUpsertOptions {
+    dryRun?: boolean;
+    maxItems?: number;
+}
+interface SourceUpsertItemResult {
+    index: number;
+    outcome: SourceUpsertOutcome;
+    note_id?: string;
+    external_id_hash: string;
+    content_digest: string;
+    reason?: string;
+}
+interface SourceUpsertBatchResult {
+    import_run_id: string;
+    dry_run: boolean;
+    outcomes: SourceUpsertItemResult[];
+    counts: Record<SourceUpsertOutcome, number>;
+}
+declare class SourceUpsertRepository {
+    private db;
+    private events?;
+    constructor(db: DatabaseClient, events?: TypedEventBus | undefined);
+    upsertBatch(items: readonly SourceUpsertItem[], options?: SourceUpsertOptions): Promise<SourceUpsertBatchResult>;
+    private finish;
+}
+interface PurgeSelector {
+    tenant_id?: string;
+    archive_id?: null | string;
+    note_ids?: readonly string[];
+    source?: {
+        external_id?: string;
+        namespace: string;
+    };
+}
+interface PurgeCounts {
+    notes: number;
+    revisions: number;
+    links: number;
+    tags: number;
+    embeddings: number;
+    attachments: number;
+    blobs: number;
+    graph_edges: number;
+    provenance_edges: number;
+    source_identities: number;
+}
+interface DeletionReceipt {
+    id: string;
+    operation_key: string;
+    tenant_id: string;
+    archive_id: null | string;
+    selector_hash: string;
+    outcome: 'completed';
+    counts: PurgeCounts;
+    completed_at: string;
+    policy: {
+        authority: 'fortemi#1092';
+        mode: 'terminal-purge';
+        receipt_contains_content: false;
+    };
+}
+interface PurgePreview {
+    selector_hash: string;
+    counts: PurgeCounts;
+}
+declare class LifecyclePurgeRepository {
+    private db;
+    private events?;
+    constructor(db: DatabaseClient, events?: TypedEventBus | undefined);
+    preview(selector: PurgeSelector): Promise<PurgePreview>;
+    purge(selector: PurgeSelector, operationKey: string): Promise<DeletionReceipt>;
+    private count;
+    private deleteSelected;
+}
 interface GraphNode {
     id: string;
 }
@@ -2910,6 +3954,100 @@ declare function detectInferenceCapabilities(): Promise<InferenceCapabilities>;
  */
 /** Split text into overlapping chunks for embedding. */
 declare function chunkText(text: string, maxChars?: number, overlap?: number): string[];
+/**
+ * Formal InferenceProvider interface.
+ * Core contract for all inference providers — remote APIs, local servers, in-browser models.
+ * Core stays dependency-free: interface only, no implementations.
+ *
+ * @implements #112 formal InferenceProvider interface
+ */
+interface ProviderCapabilities {
+    embeddings: boolean;
+    chat: boolean;
+    streaming: boolean;
+    vision: boolean;
+    toolCalling: boolean;
+    structuredOutput: boolean;
+    maxContextTokens?: number;
+}
+type ProviderPrivacyTier = 'external' | 'host-managed' | 'local';
+type ProviderCostTier = 'free' | 'high' | 'low' | 'medium';
+type ProviderDataClass = 'private' | 'public' | 'regulated' | 'sensitive';
+interface ProviderProfile {
+    privacyTier?: ProviderPrivacyTier;
+    costTier?: ProviderCostTier;
+    maxInputChars?: number;
+    embeddingDimensions?: number[];
+    dataClasses?: ProviderDataClass[];
+}
+type InferenceTask = 'chat.general' | 'chat.linking' | 'chat.revision' | 'chat.tagging' | 'embedding.document' | 'embedding.large-document' | 'embedding.query' | 'vision.general';
+interface EmbedRequest {
+    texts: string[];
+    model?: string;
+    task?: InferenceTask;
+}
+interface EmbedResponse {
+    vectors: number[][];
+    model: string;
+    usage?: {
+        totalTokens: number;
+    };
+}
+interface CompletionRequest {
+    prompt: string;
+    model?: string;
+    task?: InferenceTask;
+    maxTokens?: number;
+    temperature?: number;
+    systemPrompt?: string;
+    stopSequences?: string[];
+}
+interface CompletionResponse {
+    text: string;
+    model: string;
+    usage?: {
+        completionTokens: number;
+        promptTokens: number;
+    };
+    finishReason?: 'content_filter' | 'length' | 'stop';
+}
+interface StreamChunk {
+    text: string;
+    done: boolean;
+}
+interface ModelInfo {
+    id: string;
+    name?: string;
+    capabilities: Partial<ProviderCapabilities>;
+    contextWindow?: number;
+    owned_by?: string;
+}
+type ProbeStatus = 'degraded' | 'down' | 'ok';
+interface ProbeResult {
+    status: ProbeStatus;
+    latencyMs: number;
+    message?: string;
+}
+type ProviderTier = 'chrome-ai' | 'in-browser' | 'local-server' | 'remote';
+interface InferenceProvider {
+    readonly id: string;
+    readonly name: string;
+    readonly tier: ProviderTier;
+    readonly capabilities: ProviderCapabilities;
+    readonly profile?: ProviderProfile;
+    /** Generate embeddings for text inputs */
+    embed?(request: EmbedRequest): Promise<EmbedResponse>;
+    /** Generate a completion (non-streaming) */
+    complete?(request: CompletionRequest): Promise<CompletionResponse>;
+    /** Generate a streaming completion */
+    stream?(request: CompletionRequest): AsyncIterable<StreamChunk>;
+    /** List available models from this provider */
+    listModels(): Promise<ModelInfo[]>;
+    /** Health check — probe the provider */
+    probe(): Promise<ProbeResult>;
+    /** Clean up resources */
+    dispose(): void;
+}
 /**
  * Embedding generation job handler.
  * Generates and stores vector embeddings for note content.
@@ -2917,9 +4055,22 @@ declare function chunkText(text: string, maxChars?: number, overlap?: number): s
  *
  * @implements #63 embedding generation
  */
+interface EmbedFunctionOptions {
+    task?: InferenceTask;
+    model?: string;
+}
+interface EmbeddingTaskSelectionOptions {
+    largeDocumentChars?: number;
+    largeDocumentChunks?: number;
+}
+declare const DEFAULT_LARGE_DOCUMENT_CHARS = 12000;
+declare const DEFAULT_LARGE_DOCUMENT_CHUNKS = 12;
 /** Type for the embed function — injected by the semantic capability module */
-type EmbedFunction = (texts: string[]) => Promise<number[][]>;
+type EmbedFunction = (texts: string[], options?: EmbedFunctionOptions) => Promise<number[][]>;
 declare function setEmbedFunction(fn: EmbedFunction | null): void;
+declare function setEmbeddingTaskSelectionOptions(options?: EmbeddingTaskSelectionOptions): void;
+declare function getEmbeddingTaskSelectionOptions(): EmbeddingTaskSelectionOptions;
+declare function selectEmbeddingTask(content: string, chunks: string[], options?: EmbeddingTaskSelectionOptions): InferenceTask;
 declare function getEmbedFunction(): EmbedFunction | null;
 /** Job handler for embedding generation. Registered in JobQueueWorker. */
 declare function embeddingGenerationHandler(job: {
@@ -2932,11 +4083,14 @@ declare function embeddingGenerationHandler(job: {
  *
  * @implements #66 AI title generation
  */
-/** Type for the LLM completion function — injected by the llm capability module */
-type LlmCompleteFn = (prompt: string, options?: {
+interface LlmCompleteOptions {
     maxTokens?: number;
     temperature?: number;
-}) => Promise<string>;
+    task?: InferenceTask;
+    model?: string;
+}
+/** Type for the LLM completion function — injected by the llm capability module */
+type LlmCompleteFn = (prompt: string, options?: LlmCompleteOptions) => Promise<string>;
 declare function setLlmFunction(fn: LlmCompleteFn | null): void;
 declare function getLlmFunction(): LlmCompleteFn | null;
 /**
@@ -3149,86 +4303,6 @@ declare function registerLlmCapability(manager: CapabilityManager, completeFn: L
  * Unregister the LLM capability — clears the completion function.
  */
 declare function unregisterLlmCapability(): void;
-/**
- * Formal InferenceProvider interface.
- * Core contract for all inference providers — remote APIs, local servers, in-browser models.
- * Core stays dependency-free: interface only, no implementations.
- *
- * @implements #112 formal InferenceProvider interface
- */
-interface ProviderCapabilities {
-    embeddings: boolean;
-    chat: boolean;
-    streaming: boolean;
-    vision: boolean;
-    toolCalling: boolean;
-    structuredOutput: boolean;
-    maxContextTokens?: number;
-}
-interface EmbedRequest {
-    texts: string[];
-    model?: string;
-}
-interface EmbedResponse {
-    vectors: number[][];
-    model: string;
-    usage?: {
-        totalTokens: number;
-    };
-}
-interface CompletionRequest {
-    prompt: string;
-    model?: string;
-    maxTokens?: number;
-    temperature?: number;
-    systemPrompt?: string;
-    stopSequences?: string[];
-}
-interface CompletionResponse {
-    text: string;
-    model: string;
-    usage?: {
-        completionTokens: number;
-        promptTokens: number;
-    };
-    finishReason?: 'content_filter' | 'length' | 'stop';
-}
-interface StreamChunk {
-    text: string;
-    done: boolean;
-}
-interface ModelInfo {
-    id: string;
-    name?: string;
-    capabilities: Partial<ProviderCapabilities>;
-    contextWindow?: number;
-    owned_by?: string;
-}
-type ProbeStatus = 'degraded' | 'down' | 'ok';
-interface ProbeResult {
-    status: ProbeStatus;
-    latencyMs: number;
-    message?: string;
-}
-type ProviderTier = 'chrome-ai' | 'in-browser' | 'local-server' | 'remote';
-interface InferenceProvider {
-    readonly id: string;
-    readonly name: string;
-    readonly tier: ProviderTier;
-    readonly capabilities: ProviderCapabilities;
-    /** Generate embeddings for text inputs */
-    embed?(request: EmbedRequest): Promise<EmbedResponse>;
-    /** Generate a completion (non-streaming) */
-    complete?(request: CompletionRequest): Promise<CompletionResponse>;
-    /** Generate a streaming completion */
-    stream?(request: CompletionRequest): AsyncIterable<StreamChunk>;
-    /** List available models from this provider */
-    listModels(): Promise<ModelInfo[]>;
-    /** Health check — probe the provider */
-    probe(): Promise<ProbeResult>;
-    /** Clean up resources */
-    dispose(): void;
-}
 /**
  * ProviderRegistry — manages InferenceProvider instances.
  * Supports add/remove/getActive/setActive and derives CapabilityManager state.
@@ -3239,6 +4313,7 @@ declare class ProviderRegistry {
     private events?;
     private providers;
     private activeId;
+    private routes;
     constructor(events?: TypedEventBus | undefined);
     /** Register a provider. First provider with embedding capability becomes active. */
     add(provider: InferenceProvider): void;
@@ -3246,6 +4321,10 @@ declare class ProviderRegistry {
     remove(id: string): void;
     /** Set the active provider by ID */
     setActive(id: string): void;
+    setRoute(task: InferenceTask, policy: ProviderRoutePolicy): void;
+    getRoute(task: InferenceTask): ProviderRoutePolicy | undefined;
+    clearRoute(task: InferenceTask): void;
+    clearRoutes(): void;
     /** Get the currently active provider */
     getActive(): InferenceProvider | null;
     /** Get a provider by ID */
@@ -3266,6 +4345,10 @@ declare class ProviderRegistry {
     complete(request: CompletionRequest): Promise<CompletionResponse>;
     /** Convenience: stream using active provider */
     stream(request: CompletionRequest): AsyncIterable<StreamChunk>;
+    previewRoute(task: InferenceTask | undefined, capability: keyof ProviderCapabilities, requestModel?: string): ProviderRouteSelection;
+    probeRoute(task: InferenceTask | undefined, capability: keyof ProviderCapabilities, requestModel?: string): Promise<ProviderRouteProbeResult>;
+    validateRoute(task: InferenceTask, capability?: keyof ProviderCapabilities, policy?: ProviderRoutePolicy | undefined): ProviderRouteValidation;
+    validateRoutes(): ProviderRouteValidation[];
     /** Dispose all providers */
     dispose(): void;
     /**
@@ -3274,7 +4357,62 @@ declare class ProviderRegistry {
      * consumers that call getEmbedFunction() / getLlmFunction() still work.
      */
     private syncLegacyFunctions;
+    private resolveProvider;
+    private resolveRouteSelections;
+    private emitRouteSelected;
+    private withRouteFallback;
+    private emitRouteCompleted;
+    private emitRouteFailed;
+    private resolveCandidates;
+}
+interface ProviderRoutePolicy {
+    providerIds?: string[];
+    tiers?: ProviderTier[];
+    model?: string;
+    fallback?: boolean;
+    requirements?: ProviderRouteRequirements;
+}
+interface ProviderRouteRequirements {
+    privacyTiers?: ProviderPrivacyTier[];
+    maxCostTier?: ProviderCostTier;
+    minContextTokens?: number;
+    minEmbeddingDimensions?: number;
+    dataClass?: ProviderDataClass;
+    maxInputChars?: number;
+}
+interface ProviderRouteSelection {
+    provider: InferenceProvider;
+    providerId: string;
+    providerName: string;
+    tier: ProviderTier;
+    capability: keyof ProviderCapabilities;
+    task?: InferenceTask;
+    model?: string;
+    routeMatched: boolean;
+}
+interface ProviderRouteProbeResult extends ProviderRouteSelection {
+    probe: ProbeResult;
+}
+type ProviderRouteValidationSeverity = 'error' | 'warning';
+interface ProviderRouteValidationIssue {
+    severity: ProviderRouteValidationSeverity;
+    code: 'empty-explicit-chain' | 'missing-handler' | 'missing-provider' | 'no-eligible-provider' | 'profile-requirement' | 'unsupported-capability';
+    message: string;
+    providerId?: string;
+}
+interface ProviderRouteValidation {
+    task: InferenceTask;
+    capability: keyof ProviderCapabilities;
+    policy?: ProviderRoutePolicy;
+    providerIds: string[];
+    eligibleProviderIds: string[];
+    issues: ProviderRouteValidationIssue[];
+    ok: boolean;
 }
+declare function inferInferenceTaskCapability(task: InferenceTask): keyof ProviderCapabilities;
+declare function validateProviderRoute(task: InferenceTask, capability: keyof ProviderCapabilities, policy: ProviderRoutePolicy | undefined, providers: InferenceProvider[]): ProviderRouteValidation;
+declare function providerSatisfiesRouteRequirements(provider: InferenceProvider, requirements: ProviderRouteRequirements | undefined, capability: keyof ProviderCapabilities): boolean;
+declare function getProviderRouteRequirementIssue(provider: InferenceProvider, requirements: ProviderRouteRequirements | undefined, capability: keyof ProviderCapabilities): string | undefined;
 /**
  * Create an InferenceProvider from legacy bare functions.
  * Used by setEmbedFunction/setLlmFunction backward compat layer.
@@ -3284,6 +4422,7 @@ declare function createLegacyProvider(options: {
     id?: string;
     llmFn?: LlmCompleteFn | null;
     name?: string;
+    profile?: InferenceProvider['profile'];
 }): InferenceProvider;
 /**
  * OpenAI-compatible inference provider.
@@ -3304,12 +4443,14 @@ interface OpenAIProviderConfig {
     tier?: ProviderTier;
     headers?: Record<string, string>;
     timeoutMs?: number;
+    profile?: ProviderProfile;
 }
 declare class OpenAICompatibleProvider implements InferenceProvider {
     readonly id: string;
     readonly name: string;
     readonly tier: ProviderTier;
     readonly capabilities: ProviderCapabilities;
+    readonly profile?: ProviderProfile;
     private baseURL;
     private apiKey?;
     private defaultModel;
@@ -3326,11 +4467,70 @@ declare class OpenAICompatibleProvider implements InferenceProvider {
     dispose(): void;
     private buildMessages;
     private mapFinishReason;
-    private isEmbeddingModel;
     private isLocalURL;
     private fetch;
     private rawFetch;
 }
+interface FortemiBridgeCapabilities {
+    secureSecrets: boolean;
+    providerRouting: boolean;
+    localNetworkAccess: boolean;
+    auditLog: boolean;
+}
+interface FortemiSecretStore {
+    isAvailable(): boolean | Promise<boolean>;
+    getSecret(key: string): Promise<null | string>;
+    setSecret(key: string, value: string): Promise<void>;
+    deleteSecret(key: string): Promise<void>;
+}
+interface BridgeProviderInfo {
+    id: string;
+    name: string;
+    tier: 'chrome-ai' | 'in-browser' | 'local-server' | 'remote';
+    requiresApiKey: boolean;
+    capabilities: {
+        chat?: boolean;
+        embeddings?: boolean;
+        streaming?: boolean;
+    };
+    profile?: ProviderProfile;
+}
+interface FortemiInferenceRouter {
+    listProviders(): Promise<BridgeProviderInfo[]>;
+    probeProvider(providerId: string): Promise<ProbeResult>;
+    complete(providerId: string, request: CompletionRequest): Promise<CompletionResponse>;
+    embed(providerId: string, request: EmbedRequest): Promise<EmbedResponse>;
+    stream?(providerId: string, request: CompletionRequest): AsyncIterable<StreamChunk>;
+}
+interface FortemiBridge {
+    version: string;
+    capabilities(): Promise<FortemiBridgeCapabilities>;
+    secrets: FortemiSecretStore;
+    inference?: FortemiInferenceRouter;
+}
+interface FortemiBridgeHost {
+    fortemiBridge?: FortemiBridge;
+    fortemiSecureStorage?: FortemiSecretStore;
+}
+declare function getFortemiBridge(host?: FortemiBridgeHost | undefined): FortemiBridge | null;
+declare function getFortemiSecretStore(host?: FortemiBridgeHost | undefined): FortemiSecretStore | null;
+declare function hasFortemiSecureSecrets(host?: FortemiBridgeHost | undefined): Promise<boolean>;
+declare class BridgeInferenceProvider implements InferenceProvider {
+    private bridge;
+    readonly id: string;
+    readonly name: string;
+    readonly tier: ProviderTier;
+    readonly capabilities: ProviderCapabilities;
+    readonly profile: InferenceProvider['profile'];
+    constructor(bridge: FortemiBridge, info: BridgeProviderInfo);
+    embed(request: EmbedRequest): Promise<EmbedResponse>;
+    complete(request: CompletionRequest): Promise<CompletionResponse>;
+    stream(request: CompletionRequest): AsyncIterable<StreamChunk>;
+    listModels(): Promise<ModelInfo[]>;
+    probe(): Promise<ProbeResult>;
+    dispose(): void;
+}
+declare function createBridgeInferenceProviders(bridge: FortemiBridge): Promise<BridgeInferenceProvider[]>;
 /**
  * Local inference server auto-discovery.
  * Probes known local endpoints (Ollama, LM Studio, llama.cpp, vLLM, Jan, LocalAI)
@@ -3364,11 +4564,57 @@ type ModelCategory = 'chat' | 'embedding' | 'vision';
  * Classify a model by its ID/name into embedding, vision, or chat.
  */
 declare function classifyModel(modelId: string): ModelCategory;
+declare function inferLocalEmbeddingDimensions(models: ModelInfo[]): number[] | undefined;
+declare function createLocalProviderProfile(models?: ModelInfo[]): ProviderProfile;
 /**
  * Discover local inference servers by probing known endpoints.
  * Returns all reachable providers with their available models.
  */
 declare function discoverLocalProviders(options?: DiscoveryOptions): Promise<DiscoveredProvider[]>;
+type ConfiguredInferenceProvider = {
+    config: OpenAIProviderConfig;
+    kind: 'openai-compatible';
+} | {
+    embedFn?: EmbedFunction | null;
+    id?: string;
+    kind: 'legacy';
+    llmFn?: LlmCompleteFn | null;
+    name?: string;
+    profile?: InferenceProvider['profile'];
+} | {
+    kind: 'provider';
+    provider: InferenceProvider;
+};
+type LegacyInferenceProviderConfig = Omit<Extract<ConfiguredInferenceProvider, {
+    kind: 'legacy';
+}>, 'kind'>;
+interface InferenceRuntimeConfig {
+    providers?: ConfiguredInferenceProvider[];
+    routes?: Partial<Record<InferenceTask, ProviderRoutePolicy>>;
+    activeProviderId?: string;
+    bridgeHost?: FortemiBridgeHost;
+    includeBridgeProviders?: boolean;
+    discoverLocal?: boolean | DiscoveryOptions;
+    embeddingTaskSelection?: EmbeddingTaskSelectionOptions;
+}
+interface ConfigureInferenceRuntimeOptions extends InferenceRuntimeConfig {
+    registry?: ProviderRegistry;
+    events?: TypedEventBus;
+    capabilityManager?: CapabilityManager;
+}
+interface ConfiguredInferenceRuntime {
+    registry: ProviderRegistry;
+    providers: InferenceProvider[];
+    routeValidation: ProviderRouteValidation[];
+    routeIssues: ProviderRouteValidation['issues'];
+}
+declare function defineInferenceRuntime(config: InferenceRuntimeConfig): InferenceRuntimeConfig;
+declare function defineInferenceProvider(provider: InferenceProvider): ConfiguredInferenceProvider;
+declare function defineOpenAICompatibleProvider(config: OpenAIProviderConfig): ConfiguredInferenceProvider;
+declare function defineLegacyInferenceProvider(config: LegacyInferenceProviderConfig): ConfiguredInferenceProvider;
+declare function mergeInferenceRuntimeConfigs(...configs: Array<InferenceRuntimeConfig | null | undefined>): InferenceRuntimeConfig;
+declare function getConfiguredInferenceProviderId(config: ConfiguredInferenceProvider): string;
+declare function configureInferenceRuntime(options?: ConfigureInferenceRuntimeOptions): Promise<ConfiguredInferenceRuntime>;
 /**
  * FallbackRouter — wraps multiple InferenceProviders with automatic failover.
  * Routes requests to the highest-priority available provider, falling through
@@ -3445,49 +4691,6 @@ declare class FallbackRouter implements InferenceProvider {
     private withFallback;
     private applyCooldown;
 }
-interface FortemiBridgeCapabilities {
-    secureSecrets: boolean;
-    providerRouting: boolean;
-    localNetworkAccess: boolean;
-    auditLog: boolean;
-}
-interface FortemiSecretStore {
-    isAvailable(): boolean | Promise<boolean>;
-    getSecret(key: string): Promise<null | string>;
-    setSecret(key: string, value: string): Promise<void>;
-    deleteSecret(key: string): Promise<void>;
-}
-interface BridgeProviderInfo {
-    id: string;
-    name: string;
-    tier: 'chrome-ai' | 'in-browser' | 'local-server' | 'remote';
-    requiresApiKey: boolean;
-    capabilities: {
-        chat?: boolean;
-        embeddings?: boolean;
-        streaming?: boolean;
-    };
-}
-interface FortemiInferenceRouter {
-    listProviders(): Promise<BridgeProviderInfo[]>;
-    probeProvider(providerId: string): Promise<ProbeResult>;
-    complete(providerId: string, request: CompletionRequest): Promise<CompletionResponse>;
-    embed(providerId: string, request: EmbedRequest): Promise<EmbedResponse>;
-    stream?(providerId: string, request: CompletionRequest): AsyncIterable<StreamChunk>;
-}
-interface FortemiBridge {
-    version: string;
-    capabilities(): Promise<FortemiBridgeCapabilities>;
-    secrets: FortemiSecretStore;
-    inference?: FortemiInferenceRouter;
-}
-interface FortemiBridgeHost {
-    fortemiBridge?: FortemiBridge;
-    fortemiSecureStorage?: FortemiSecretStore;
-}
-declare function getFortemiBridge(host?: FortemiBridgeHost | undefined): FortemiBridge | null;
-declare function getFortemiSecretStore(host?: FortemiBridgeHost | undefined): FortemiSecretStore | null;
-declare function hasFortemiSecureSecrets(host?: FortemiBridgeHost | undefined): Promise<boolean>;
 type CspDirectiveName = 'base-uri' | 'connect-src' | 'default-src' | 'font-src' | 'frame-ancestors' | 'img-src' | 'manifest-src' | 'object-src' | 'report-uri' | 'script-src' | 'style-src' | 'worker-src';
 type CspDirectives = Partial<Record<CspDirectiveName, string[]>>;
 interface PluginCspOptions {
@@ -3956,6 +5159,42 @@ interface ShardManifestRecord extends PresenceTrackedRecord {
     id: string;
     manifest: Record<string, unknown>;
 }
+interface SourceIdentityRecord extends PresenceTrackedRecord {
+    id: string;
+    tenant_id: string;
+    archive_id: null | string;
+    namespace: string;
+    external_id: string;
+    external_id_hash: string;
+    source_schema_version: string;
+    content_digest: string;
+    import_run_id: string;
+    caller_stable_id: null | string;
+    note_id: string;
+    created_at: string;
+    updated_at: string;
+}
+interface SourceImportRunRecord extends PresenceTrackedRecord {
+    id: string;
+    tenant_id: string;
+    archive_id: null | string;
+    namespace: string;
+    started_at: string;
+    completed_at: null | string;
+    checkpoint: Record<string, unknown>;
+    receipt: Record<string, unknown>;
+}
+interface DeletionReceiptRecord extends PresenceTrackedRecord {
+    id: string;
+    operation_key: string;
+    tenant_id: string;
+    archive_id: null | string;
+    selector_hash: string;
+    outcome: string;
+    counts: Record<string, number>;
+    completed_at: string;
+    policy: Record<string, unknown>;
+}
 /** Collection name → record type. The store is generic over this map. */
 interface RecordCollections {
     note: NoteRecord0;
@@ -3968,6 +5207,9 @@ interface RecordCollections {
     attachment: AttachmentRecord;
     attachment_blob: AttachmentBlobRecord;
     shard_manifest: ShardManifestRecord;
+    source_identity: SourceIdentityRecord;
+    source_import_run: SourceImportRunRecord;
+    deletion_receipt: DeletionReceiptRecord;
 }
 type RecordCollectionName = keyof RecordCollections;
 declare const RECORD_COLLECTIONS: readonly RecordCollectionName[];
@@ -3999,6 +5241,10 @@ interface RecordStoreCapabilities {
     atomicBatch?: true;
     /** Bounded substring scan over titles/content — not ranked FTS. */
     boundedTextScan: true;
+    sourceAddressedUpsert?: true;
+    deletionReceipts?: true;
+    typedMetadataPredicates?: false;
+    evidenceLocators?: true;
     fullTextSearch: false;
     vectorSearch: false;
     sqlJoins: false;
@@ -4359,11 +5605,14 @@ declare function exportShardFromRecords(store: RecordStore, options?: ExportOpti
  * explicit warnings and reported under `skipped`.
  */
 declare function importShardToRecords(store: RecordStore, data: ArrayBuffer | Uint8Array, options?: ImportOptions): Promise<ImportResult>;
+declare function upsertRecordStoreSources(store: RecordStore, items: readonly SourceUpsertItem[], options?: SourceUpsertOptions): Promise<SourceUpsertBatchResult>;
+declare function previewRecordStorePurge(store: RecordStore, selector: PurgeSelector): Promise<PurgePreview>;
+declare function purgeRecordStoreGraph(store: RecordStore, selector: PurgeSelector, operationKey: string): Promise<DeletionReceipt>;
 /**
  * @implements @.aiwg/adrs/ADR-011-shard-server-conformance-and-version-negotiation.md
  * @source @packages/core/src/shard/schema-validator.ts
  * @created 2026-07-17
  * @agent Codex
  */
-declare const VERSION = "2026.7.15";
-export { type ArchiveInfo, ArchiveManager, type AttachInput, type AttachmentBlobRecord, type AttachmentBlobRow, type AttachmentProjectionResult, type AttachmentRecord, type AttachmentRow, AttachmentsRepository, type BackendCandidate, type BackendCapabilities, type BackendConcept, type BackendLink, type BackendListOptions, type BackendNote, type BackendNoteFull, type BackendProvenanceEdge, type BackendRequest, type BackendSearchHit, type BackendSearchQueryOptions, type BackendSearchResult, type BackendSelection, type BackendSemanticTier, type BackendStartupCost, BlobGcOptions, BlobGcResult, BlobReconcileOptions, BlobReconcileResult, BlobStore, type BridgeCapability, type BridgeProviderInfo, type BrowserNoteExport, CORE_V1_COMPONENTS, CURRENT_MIGRATION_HEAD, type CanonicalAttachInput, CanonicalAttachmentsRepository, type CanonicalNoteCreateInput, type CanonicalNoteUpdateInput, type CanonicalNoteView, CanonicalNotesRepository, type CapabilityInfo, CapabilityManager, type CapabilityName, type CapabilityState, type CaptureKnowledgeInput, CaptureKnowledgeInputSchema, type CaptureKnowledgeResult, type CollectionCreateInput, type CollectionNoteRecord, type CollectionRecord, type CollectionRow, CollectionsRepository, CommunitiesRepository, type CommunityAssignmentView, type CommunityCreateInput, type CommunityFilterDefinition, type CommunityGraph, type CommunityOptions, type CommunitySourceDescriptor, type CommunitySourceType, type CommunitySummary, type CompletionRequest, type CompletionResponse, type ConditionResult, type CooldownConfig, type CooldownEvent, type CosineSemanticProviderOptions, type CreatePGliteOptions, type CreateRecordStoreOptions, type CspDirectiveName, type CspDirectives, type CspViolationReport, DB_SNAPSHOT_SCHEMA_VERSION, type DataBackend, type DatabaseClient, type DbSnapshot, type DbSnapshotCompat, type DbSnapshotCompression, type DbSnapshotExpectations, type DbSnapshotMeta, type DbSnapshotSource, DbSnapshotVersionError, type DiscoveredProvider, type DiscoveryOptions, type DumpDbSnapshotOptions, type DumpableDb, EMBED_REQUEST_KIND, EMBED_RESPONSE_KIND, type EmbedFunction, type EmbedRequest, type EmbedRequestMessage, type EmbedResponse, type EmbedResponseMessage, type EmbedTransportPort, type EmbedWorkerOptions, type EmbeddingCompatibilityPolicy, type EmbeddingSetCreateInput, type EmbeddingSetCriteria, type EmbeddingSetDescriptor, type EmbeddingSetEmbeddingInput, type EmbeddingSetFreshness, type EmbeddingSetKind, type EmbeddingSetMode, type EmbeddingSetRow, type EmbeddingSetSelector, EmbeddingSetsRepository, type EnqueueJobInput, type ErrorCategory, type EventMap, ExportOptions, FORTEMI_COMPATIBILITY_PATH, FORTEMI_COMPATIBILITY_STATES, FORTEMI_REQUIRED_COMPATIBILITY_CAPABILITIES, FORTEMI_SERVER_COMPATIBILITY_REVISION, type FallbackEvent, FallbackRouter, type FallbackRouterConfig, type FetchFortemiCompatibilityOptions, type FortemiBridge, type FortemiBridgeCapabilities, type FortemiBridgeHost, type FortemiCompatibilityCapability, type FortemiCompatibilityResponse, type FortemiCompatibilityState, type FortemiCompatibilityValidationResult, type FortemiConfig, type FortemiCore, type FortemiInferenceRouter, type FortemiRequiredCompatibilityCapability, type FortemiSecretStore, type FortemiToolDefinition, FortemiToolManifest, type GetNoteInput, GetNoteInputSchema, type GpuCapabilities, type GraphCommunity, type GraphEdge, type GraphNode, GraphRepository, type IDisposable, IdbRecordStore, ImportOptions, ImportResult, type InferenceCapabilities, type InferenceProvider, JOB_CAPABILITIES, JOB_PRIORITIES, type JobQueueOptions, JobQueueWorker, type JobStatus, type JobType, type JournalEntry, LOCAL_ENDPOINTS, type LegacyMigrationReport, type LinkRecord0, type LinkRow, LinksRepository, type ListNotesInput, ListNotesInputSchema, type LlmCapabilityOptions, type LlmCompleteFn, type LoadedPluginScript, type LocalEndpoint, type ManageArchiveInput, ManageArchiveInputSchema, type ManageArchiveResult, type ManageAttachmentsInput, ManageAttachmentsInputSchema, type ManageAttachmentsResult, type ManageCapabilitiesInput, ManageCapabilitiesInputSchema, type ManageCapabilitiesResult, type ManageCollectionsInput, ManageCollectionsInputSchema, type ManageCollectionsResult, type ManageLinksInput, ManageLinksInputSchema, type ManageLinksResult, type ManageNoteInput, ManageNoteInputSchema, type ManageNoteResult, type ManageTagsInput, ManageTagsInputSchema, type ManageTagsResult, MemoryRecordStore, type Migration, MigrationRunner, type ModelCategory, type ModelFitResult, type ModelInfo, type NoteCreateInput, type NoteFull, type NoteListOptions, type NoteOriginalRecord, type NoteProjectionResult, type NoteRecord0, type NoteRevisedCurrentRecord, type NoteRevision, type NoteSkosTag, type NoteSummary, type NoteTagRecord, type NoteUpdateInput, NotesRepository, OpenAICompatibleProvider, type OpenAIProviderConfig, type OpenShardOptions, type PGliteBackendOptions, PGliteStorageBackend, PGliteStorageBackendFactory, PGliteWorkerClient, PGliteWorkerStorageBackend, PGliteWorkerStorageBackendFactory, type PGliteWorkerStorageBackendFactoryOptions, type PaginatedResult, type PersistenceMode, type PluginCspOptions, type PluginScriptDescriptor, type PluginScriptPolicy, type PrefetchOptions, type PrefetchResult, type PresenceTrackedRecord, type ProbeResult, type ProbeStatus, type ProvenanceEdge, ProvenanceRepository, type ProviderCapabilities, ProviderRegistry, type ProviderTier, type QueryExecutor, type QueryResult, RECORD_COLLECTIONS, RECORD_SCHEMA_VERSION, RECORD_STORE_CAPABILITIES, type RecommendedTier, type RecordBackendManageNoteResult, type RecordBackendOptions, type RecordCollectionName, type RecordCollections, type RecordListOptions, type RecordMutation, type RecordProjectionResult, type RecordProvenanceInput, type RecordStore, type RecordStoreCapabilities, type RemoteBackendConfig, type RemoteBackendPaths, type ResolvedEmbeddingRow, type ResolvedEmbeddingSet, type RestoreDbSnapshotOptions, type RouteHandler, SUPPORTED_PGLITE_VERSION, type SWRegistrationResult, type SearchFacets, type SearchInput, SearchInputSchema, type SearchOptions, SearchRepository, type SearchResponse, type SearchResult, ShardBackend, type ShardBackendOptions, ShardCapabilityReport, ShardCollection, ShardComponent, type ShardComponentStore, ShardEmbedding, ShardEmbeddingConfig, ShardEmbeddingSet, ShardEmbeddingSetMember, ShardExportResult, ShardLink, type ShardListOptions, ShardLossEntry, ShardManifest, ShardNote, type ShardNoteFull, ShardNoteSkosTag, ShardOperation, ShardProfileRegistryEntry, ShardProvenanceEdge, type ShardReader, type ShardReaderNote, type ShardReaderSource, type ShardSchemaValidationResult, type ShardSearchOptions, type ShardSearchRankedNote, type ShardSearchResult, type ShardSearchWeights, ShardSkosConcept, ShardSkosRelation, ShardSkosScheme, ShardTag, ShardTemplate, type SimilarityGraphCacheKey, type SimilarityGraphOptions, type SimilarityGraphRequest, type SimilarityGraphResult, type SkosConcept, type SkosRelation, SkosRepository, type SkosScheme, type StaticSemanticProvider, type StorageBackend, type StorageBackendFactory, type StorageOpenRequest, type StorageTopology, type StreamChunk, TagsRepository, TransactionProxy, TypedEventBus, VERSION, type VectorEntry, type VirtualEmbeddingSetDefinition, type VirtualEmbeddingSetSource, type VirtualEmbeddingSetValidationError, type VirtualMaterializationPolicy, type VramTier, type WorkerRequest, type WorkerResponse, aiRevisionHandler, allMigrations, appendPluginScript, assertShardComponentRecord, buildNoteConditions, buildPluginCsp, captureKnowledge, chunkText, classifyError, classifyModel, clearPrefetchedShard, collectionFromShard, collectionToShard, computeBlobHash, computeHash, computeSri, conceptTaggingHandler, cosineSimilarity, createCosineSemanticProvider, createCspReportHandler, createFortemi, createLegacyProvider, createPGliteBackend, createPGliteInstance, createRecordBackend, createRecordStore, createRemoteBackend, createRoutes, createShardBackend, createShardCapabilityReport, createWorkerEmbedFunction, defaultStorageBackendFactory, detectCommunities, detectGpuCapabilities, detectInferenceCapabilities, discoverLocalProviders, dropAttachmentProjection, dropNoteProjection, dumpDbSnapshot, embeddingConfigToShard, embeddingFromShard, embeddingGenerationHandler, embeddingSetFromShard, embeddingSetMemberToShard, embeddingSetToShard, embeddingToShard, enqueueFullWorkflow, enqueueJob, enqueueNoteCreationJobs, estimateModelFit, estimateVramMB, estimateVramTier, exportShard, exportShardFromRecords, exportShardFromRecordsWithReport, exportShardWithReport, fetchAndValidateFortemiCompatibility, fetchPluginScript, formatFortemiCompatibilitySummary, fortemiCompatibilityUrl, fortemiManifest, fromPrefetched, generateId, getEmbedFunction, getFortemiBridge, getFortemiSecretStore, getJobQueueStatus, getKnowledgeShardContractReceipt, getKnowledgeShardProfileRegistry, getKnowledgeShardSchema, getLlmFunction, getNote, getPrefetchedSha256, handleEmbedRequests, hasFortemiSecureSecrets, importShard, importShardToRecords, isPluginScriptAllowed, isShardPrefetched, linkFromShard, linkToShard, linkingHandler, listNotes, manageArchive, manageAttachments, manageCapabilities, manageCollections, manageLinks, manageNote, manageTags, matchRoute, migrateLegacyBlobStore, noteFromShard, noteSkosTagToShard, noteToShard, openShard, packTarGz, parseCspReport, prefetchShard, profileSupportError, projectAttachments, projectNotes, projectRecords, provenanceEdgeToShard, registerLlmCapability, registerSemanticCapability, registerSemanticCapabilityWorker, registerServiceWorker, restoreDbSnapshot, searchTool, selectBackend, selectLlmModel, setEmbedFunction, setLlmFunction, sha256Hex, skosConceptToShard, skosRelationToShard, skosSchemeToShard, suggestTags, tagsToShard, templateToShard, titleGenerationHandler, unpackTarGz, unregisterLlmCapability, unregisterSemanticCapability, urlLinkToShard, validateChecksums, validateCoreV1ShardArchive, validateFortemiCompatibilityResponse, validateFullV1ShardArchive, validateRecordV1ShardArchive, validateShardArchive, validateShardComponentRecord, validateShardManifest, verifyDbSnapshotMeta, verifySri };
+declare const VERSION = "2026.9.0";
+export { type ArchiveInfo, ArchiveManager, type AttachInput, type AttachmentBlobRecord, type AttachmentBlobRow, type AttachmentProjectionResult, type AttachmentRecord, type AttachmentRow, AttachmentsRepository, type BackendCandidate, type BackendCapabilities, type BackendConcept, type BackendLink, type BackendListOptions, type BackendNote, type BackendNoteFull, type BackendProvenanceEdge, type BackendRequest, type BackendSearchHit, type BackendSearchQueryOptions, type BackendSearchResult, type BackendSelection, type BackendSemanticTier, type BackendStartupCost, BlobGcOptions, BlobGcResult, BlobReconcileOptions, BlobReconcileResult, BlobStore, type BridgeCapability, BridgeInferenceProvider, type BridgeProviderInfo, type BrowserNoteExport, CORE_V1_COMPONENTS, CURRENT_MIGRATION_HEAD, type CanonicalAttachInput, CanonicalAttachmentsRepository, type CanonicalNoteCreateInput, type CanonicalNoteUpdateInput, type CanonicalNoteView, CanonicalNotesRepository, type CapabilityInfo, CapabilityManager, type CapabilityName, type CapabilityState, type CaptureKnowledgeInput, CaptureKnowledgeInputSchema, type CaptureKnowledgeResult, type CollectionCreateInput, type CollectionNoteRecord, type CollectionRecord, type CollectionRow, CollectionsRepository, CommunitiesRepository, type CommunityAssignmentView, type CommunityCreateInput, type CommunityFilterDefinition, type CommunityGraph, type CommunityOptions, type CommunitySourceDescriptor, type CommunitySourceType, type CommunitySummary, type CompletionRequest, type CompletionResponse, type ConditionResult, type ConfigureInferenceRuntimeOptions, type ConfiguredInferenceProvider, type ConfiguredInferenceRuntime, type CooldownConfig, type CooldownEvent, type CosineSemanticProviderOptions, type CreatePGliteOptions, type CreateRecordStoreOptions, type CspDirectiveName, type CspDirectives, type CspViolationReport, DATASET_EXECUTION_CAPABILITY_IDS, DATASET_EXECUTION_CONTRACT, DATASET_EXECUTION_SCHEMA_VERSION, DATASET_INGEST_CONTRACT, DATASET_INGEST_SCHEMA_VERSION, DATASET_LINEAGE_CONTRACT, DATASET_LINEAGE_SCHEMA_VERSION, DATASET_MATERIALIZATION_CONTRACT, DATASET_MATERIALIZATION_KINDS, DATASET_MATERIALIZATION_SCHEMA_VERSION, DB_SNAPSHOT_SCHEMA_VERSION, DEFAULT_LARGE_DOCUMENT_CHARS, DEFAULT_LARGE_DOCUMENT_CHUNKS, type DataBackend, type DatabaseClient, type DatasetBenchmarkEvidence, type DatasetCapabilityDeclaration, type DatasetCapabilityDegradation, type DatasetCapabilityDiagnostic, type DatasetCapabilityDiagnosticCode, type DatasetCapabilityEvidence, type DatasetCapabilityLimits, type DatasetCapabilityNegotiationRequest, type DatasetCapabilityNegotiationResult, type DatasetCapabilityRequirement, type DatasetCapabilityStatus, type DatasetCheckpoint, type DatasetDestinationScope, type DatasetDeterminismClass, type DatasetDigest, type DatasetExecutionCapabilityDescriptor, type DatasetExecutionCapabilityId, type DatasetExecutionDataClass, type DatasetExecutionMaturity, type DatasetExecutionPlane, type DatasetImplementationIdentity, type DatasetIncrementalParityResult, DatasetIngestError, type DatasetIngestErrorCode, DatasetIngestExecutor, type DatasetIngestHooks, type DatasetIngestMode, type DatasetIngestStore, type DatasetIngestTransaction, DatasetLineageLedger, type DatasetLineageLedgerOptions, type DatasetMaterializationAdapter, type DatasetMaterializationArtifact, DatasetMaterializationError, type DatasetMaterializationKind, type DatasetMaterializationOperation, type DatasetMaterializationProfile, type DatasetMaterializationReceipt, type DatasetMaterializationRequest, type DatasetMeasuredResources, type DatasetMutation, type DatasetMutationBatch, type DatasetOptionalCapabilityRequirement, type DatasetPrivacyBoundary, type DatasetPrivacyDecision, type DatasetProcessingPlan, type DatasetProfileNegotiationRequest, type DatasetProfileNegotiationResult, type DatasetProfileStatus, type DatasetRecordAuthorizer, type DatasetRecordRejection, type DatasetRetrievalRequest, type DatasetRetrievalResponse, type DatasetRunAttempt, type DatasetRunReceipt, type DatasetRunState, type DatasetRunStatus, type DatasetSourceRecord, type DatasetSourceSnapshot, type DatasetStoredRecord, type DatasetTombstoneMutation, type DatasetUpsertMutation, type DatasetVerificationState, type DbSnapshot, type DbSnapshotCompat, type DbSnapshotCompression, type DbSnapshotExpectations, type DbSnapshotMeta, type DbSnapshotSource, DbSnapshotVersionError, type DeletionReceipt, type DeletionReceiptRecord, type DiscoveredProvider, type DiscoveryOptions, type DumpDbSnapshotOptions, type DumpableDb, EMBED_REQUEST_KIND, EMBED_RESPONSE_KIND, type EmbedFunction, type EmbedFunctionOptions, type EmbedRequest, type EmbedRequestMessage, type EmbedResponse, type EmbedResponseMessage, type EmbedTransportPort, type EmbedWorkerOptions, type EmbeddingCompatibilityPolicy, type EmbeddingSetCreateInput, type EmbeddingSetCriteria, type EmbeddingSetDescriptor, type EmbeddingSetEmbeddingInput, type EmbeddingSetFreshness, type EmbeddingSetKind, type EmbeddingSetMode, type EmbeddingSetRow, type EmbeddingSetSelector, EmbeddingSetsRepository, type EmbeddingTaskSelectionOptions, type EnqueueJobInput, type ErrorCategory, type EventMap, type EvidenceLocator, type ExecuteDatasetBatchOptions, ExportOptions, FORTEMI_BROWSER_LOCAL_DATASET_EXECUTION_DESCRIPTOR, FORTEMI_COMPATIBILITY_PATH, FORTEMI_COMPATIBILITY_STATES, FORTEMI_PORTABLE_SHARD_DATASET_EXECUTION_DESCRIPTOR, FORTEMI_REQUIRED_COMPATIBILITY_CAPABILITIES, FORTEMI_SERVER_COMPATIBILITY_REVISION, FORTEMI_STATIC_CACHE_DATASET_EXECUTION_DESCRIPTOR, type FallbackEvent, FallbackRouter, type FallbackRouterConfig, type FetchFortemiCompatibilityOptions, type FortemiBridge, type FortemiBridgeCapabilities, type FortemiBridgeHost, type FortemiCompatibilityCapability, type FortemiCompatibilityResponse, type FortemiCompatibilityState, type FortemiCompatibilityValidationResult, type FortemiConfig, type FortemiCore, type FortemiInferenceRouter, type FortemiRequiredCompatibilityCapability, type FortemiSecretStore, type FortemiToolDefinition, FortemiToolManifest, type GetNoteInput, GetNoteInputSchema, type GpuCapabilities, type GraphCommunity, type GraphEdge, type GraphNode, GraphRepository, type IDisposable, IdbRecordStore, ImportOptions, ImportResult, type InferenceCapabilities, type InferenceProvider, type InferenceRuntimeConfig, type InferenceTask, JOB_CAPABILITIES, JOB_PRIORITIES, type JobQueueOptions, JobQueueWorker, type JobStatus, type JobType, type JournalEntry, LINEAGE_ENTITY_KINDS, LINEAGE_RELATIONSHIP_KINDS, LOCAL_ENDPOINTS, type LegacyInferenceProviderConfig, type LegacyMigrationReport, LifecyclePurgeRepository, type LineageActivity, type LineageAgent, type LineageAssertion, type LineageAssertionKind, type LineageAuthorizationPolicy, type LineageCorrection, type LineageEntity, type LineageEntityKind, type LineageEvidence, type LineageEvidenceReference, type LineageLedgerArchive, type LineageLossItem, type LineageLossReceipt, type LineagePrivacy, type LineageProjection, type LineageProjectionCapabilities, type LineageRelationshipKind, type LineageTraversalEdge, type LineageTraversalNode, type LineageTraversalRequest, type LineageTraversalResult, type LineageValidationCode, LineageValidationError, type LinkRecord0, type LinkRow, LinksRepository, type ListNotesInput, ListNotesInputSchema, type LlmCapabilityOptions, type LlmCompleteFn, type LlmCompleteOptions, type LoadedPluginScript, type LocalEndpoint, type ManageArchiveInput, ManageArchiveInputSchema, type ManageArchiveResult, type ManageAttachmentsInput, ManageAttachmentsInputSchema, type ManageAttachmentsResult, type ManageCapabilitiesInput, ManageCapabilitiesInputSchema, type ManageCapabilitiesResult, type ManageCollectionsInput, ManageCollectionsInputSchema, type ManageCollectionsResult, type ManageLinksInput, ManageLinksInputSchema, type ManageLinksResult, type ManageNoteInput, ManageNoteInputSchema, type ManageNoteResult, type ManageTagsInput, ManageTagsInputSchema, type ManageTagsResult, MemoryDatasetIngestStore, MemoryRecordStore, type MetadataPredicate, type Migration, MigrationRunner, type ModelCategory, type ModelFitResult, type ModelInfo, type NoteCreateInput, type NoteFull, type NoteListOptions, type NoteOriginalRecord, type NoteProjectionResult, type NoteRecord0, type NoteRevisedCurrentRecord, type NoteRevision, type NoteSkosTag, type NoteSummary, type NoteTagRecord, type NoteUpdateInput, NotesRepository, OpenAICompatibleProvider, type OpenAIProviderConfig, type OpenShardOptions, type PGliteBackendOptions, PGliteStorageBackend, PGliteStorageBackendFactory, PGliteWorkerClient, PGliteWorkerStorageBackend, PGliteWorkerStorageBackendFactory, type PGliteWorkerStorageBackendFactoryOptions, type PaginatedResult, type PersistenceMode, type PluginCspOptions, type PluginScriptDescriptor, type PluginScriptPolicy, type PrefetchOptions, type PrefetchResult, type PresenceTrackedRecord, type ProbeResult, type ProbeStatus, type ProvenanceEdge, ProvenanceRepository, type ProviderCapabilities, type ProviderCostTier, type ProviderDataClass, type ProviderPrivacyTier, type ProviderProfile, ProviderRegistry, type ProviderRoutePolicy, type ProviderRouteProbeResult, type ProviderRouteRequirements, type ProviderRouteSelection, type ProviderRouteValidation, type ProviderRouteValidationIssue, type ProviderRouteValidationSeverity, type ProviderTier, type PurgeCounts, type PurgePreview, type PurgeSelector, type QueryExecutor, type QueryResult, RECORD_COLLECTIONS, RECORD_SCHEMA_VERSION, RECORD_STORE_CAPABILITIES, REGISTERED_METADATA_PATHS, type RecommendedTier, type RecordBackendManageNoteResult, type RecordBackendOptions, type RecordCollectionName, type RecordCollections, type RecordListOptions, type RecordMutation, type RecordProjectionResult, type RecordProvenanceInput, type RecordStore, type RecordStoreCapabilities, type RegisteredMetadataPath, type RemoteBackendConfig, type RemoteBackendPaths, type ResolvedEmbeddingRow, type ResolvedEmbeddingSet, type RestoreDbSnapshotOptions, type RouteHandler, SUPPORTED_PGLITE_VERSION, type SWRegistrationResult, type SearchFacets, type SearchInput, SearchInputSchema, type SearchOptions, SearchRepository, type SearchResponse, type SearchResult, ShardBackend, type ShardBackendOptions, ShardCapabilityReport, ShardCollection, ShardComponent, type ShardComponentStore, ShardEmbedding, ShardEmbeddingConfig, ShardEmbeddingSet, ShardEmbeddingSetMember, ShardExportResult, ShardLink, type ShardListOptions, ShardLossEntry, ShardManifest, ShardNote, type ShardNoteFull, ShardNoteSkosTag, ShardOperation, ShardProfileRegistryEntry, ShardProvenanceEdge, type ShardReader, type ShardReaderNote, type ShardReaderSource, type ShardSchemaValidationResult, type ShardSearchOptions, type ShardSearchRankedNote, type ShardSearchResult, type ShardSearchWeights, ShardSkosConcept, ShardSkosRelation, ShardSkosScheme, ShardTag, ShardTemplate, type SimilarityGraphCacheKey, type SimilarityGraphOptions, type SimilarityGraphRequest, type SimilarityGraphResult, type SkosConcept, type SkosRelation, SkosRepository, type SkosScheme, type SourceIdentityInput, type SourceIdentityRecord, type SourceImportRunRecord, type SourceUpsertBatchResult, type SourceUpsertItem, type SourceUpsertItemResult, type SourceUpsertOptions, type SourceUpsertOutcome, type SourceUpsertPolicy, SourceUpsertRepository, type StaticSemanticProvider, type StorageBackend, type StorageBackendFactory, type StorageOpenRequest, type StorageTopology, type StreamChunk, TagsRepository, TransactionProxy, TypedEventBus, VERSION, type VectorEntry, type VirtualEmbeddingSetDefinition, type VirtualEmbeddingSetSource, type VirtualEmbeddingSetValidationError, type VirtualMaterializationPolicy, type VramTier, type WorkerRequest, type WorkerResponse, aiRevisionHandler, allMigrations, appendPluginScript, assertShardComponentRecord, buildMetadataPredicateConditions, buildNoteConditions, buildPluginCsp, captureKnowledge, chunkText, classifyError, classifyModel, clearPrefetchedShard, collectionFromShard, collectionToShard, compareDatasetIncrementalParity, computeBlobHash, computeHash, computeLineageDigest, computeSri, conceptTaggingHandler, configureInferenceRuntime, cosineSimilarity, createBridgeInferenceProviders, createCosineSemanticProvider, createCspReportHandler, createFortemi, createLegacyProvider, createLocalProviderProfile, createPGliteBackend, createPGliteInstance, createRecordBackend, createRecordStore, createRemoteBackend, createRoutes, createShardBackend, createShardCapabilityReport, createWorkerEmbedFunction, datasetDestinationScopeKey, defaultStorageBackendFactory, defineInferenceProvider, defineInferenceRuntime, defineLegacyInferenceProvider, defineOpenAICompatibleProvider, deriveDatasetIngestIdempotencyKey, detectCommunities, detectGpuCapabilities, detectInferenceCapabilities, digestDatasetMaterializationValue, discoverLocalProviders, dropAttachmentProjection, dropNoteProjection, dumpDbSnapshot, embeddingConfigToShard, embeddingFromShard, embeddingGenerationHandler, embeddingSetFromShard, embeddingSetMemberToShard, embeddingSetToShard, embeddingToShard, enqueueFullWorkflow, enqueueJob, enqueueNoteCreationJobs, estimateModelFit, estimateVramMB, estimateVramTier, executeDatasetMaterialization, executeDatasetRetrieval, exportShard, exportShardFromRecords, exportShardFromRecordsWithReport, exportShardWithReport, fetchAndValidateFortemiCompatibility, fetchPluginScript, formatFortemiCompatibilitySummary, fortemiCompatibilityUrl, fortemiManifest, fromPrefetched, generateId, getConfiguredInferenceProviderId, getEmbedFunction, getEmbeddingTaskSelectionOptions, getFortemiBridge, getFortemiSecretStore, getJobQueueStatus, getKnowledgeShardContractReceipt, getKnowledgeShardProfileRegistry, getKnowledgeShardSchema, getLlmFunction, getNote, getPrefetchedSha256, getProviderRouteRequirementIssue, handleEmbedRequests, hasFortemiSecureSecrets, importShard, importShardToRecords, inferInferenceTaskCapability, inferLocalEmbeddingDimensions, isPluginScriptAllowed, isShardPrefetched, linkFromShard, linkToShard, linkingHandler, listNotes, manageArchive, manageAttachments, manageCapabilities, manageCollections, manageLinks, manageNote, manageTags, matchRoute, mergeInferenceRuntimeConfigs, migrateLegacyBlobStore, negotiateDatasetExecutionCapabilities, negotiateDatasetMaterializationProfile, noteFromShard, noteSkosTagToShard, noteToShard, openShard, packTarGz, parseCspReport, prefetchShard, previewRecordStorePurge, profileSupportError, projectAttachments, projectNotes, projectRecords, provenanceEdgeToShard, providerSatisfiesRouteRequirements, purgeRecordStoreGraph, registerLlmCapability, registerSemanticCapability, registerSemanticCapabilityWorker, registerServiceWorker, restoreDbSnapshot, searchTool, selectBackend, selectEmbeddingTask, selectLlmModel, setEmbedFunction, setEmbeddingTaskSelectionOptions, setLlmFunction, sha256Hex, skosConceptToShard, skosRelationToShard, skosSchemeToShard, suggestTags, tagsToShard, templateToShard, titleGenerationHandler, unpackTarGz, unregisterLlmCapability, unregisterSemanticCapability, upsertRecordStoreSources, urlLinkToShard, validateChecksums, validateCoreV1ShardArchive, validateDatasetBenchmarkEvidence, validateDatasetExecutionDescriptor, validateFortemiCompatibilityResponse, validateFullV1ShardArchive, validateProviderRoute, validateRecordV1ShardArchive, validateShardArchive, validateShardComponentRecord, validateShardManifest, verifyDbSnapshotMeta, verifySri };