@fortemi/core 2026.7.4 → 2026.7.7

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { PGlite } from '@electric-sql/pglite';
-import { S as ShardAttachmentProjection, a as ShardCollection, b as ShardEmbeddingConfig, c as ShardEmbedding, d as ShardEmbeddingSet, e as ShardEmbeddingSetMember, f as ShardLink, g as ShardNote, h as ShardNoteSkosTag, i as ShardProvenanceEdge, j as ShardSkosConcept, k as ShardSkosRelation, l as ShardSkosScheme, m as ShardTag, n as ShardTemplate, o as ShardManifest, B as BlobStore, E as ExportOptions, I as ImportOptions, p as ImportResult, q as ShardComponent } from './aiwg-index-C2G7iy-b.js';
-export { A as AIWG_SCAN_REQUIRED_FIELDS, r as AiwgChunkedIndexBuildOptions, s as AiwgChunkedIndexBuildResult, t as AiwgChunkedIndexDetailLoader, u as AiwgChunkedIndexLoadOptions, v as AiwgChunkedIndexLoader, w as AiwgChunkedIndexProgress, x as AiwgChunkedIndexProgressPhase, y as AiwgChunkedIndexQueryOptions, z as AiwgChunkedIndexQueryResult, C as AiwgChunkedIndexValidationResult, D as AiwgFortemiAttachmentReference, F as AiwgFortemiBinarySource, G as AiwgFortemiChunk, H as AiwgFortemiChunkDetailRef, J as AiwgFortemiChunkManifest, K as AiwgFortemiChunkPart, L as AiwgFortemiChunkPartRef, M as AiwgFortemiIndexExport, N as AiwgFortemiIndexExportSchemaVersion, O as AiwgFortemiProjectedRecord, P as AiwgFortemiProvenance, Q as AiwgFortemiProvenanceEvent, R as AiwgFortemiRecord, T as AiwgFortemiRecordEmbedding, U as AiwgFortemiRecordSchemaVersion, V as AiwgFortemiRecordSource, W as AiwgFortemiRecordType, X as AiwgFortemiRelationship, Y as AiwgFortemiRelationshipDirection, Z as AiwgFortemiSearchProjection, _ as AiwgFortemiSkosConcept, $ as AiwgFortemiSkosRelation, a0 as AiwgFortemiSkosRelationType, a1 as AiwgHeadlessEmbeddingBackend, a2 as AiwgIndexController, a3 as AiwgIndexControllerListener, a4 as AiwgIndexControllerSnapshot, a5 as AiwgIndexGraphOptions, a6 as AiwgIndexQueryMatch, a7 as AiwgIndexQueryOptions, a8 as AiwgIndexQueryRankedItem, a9 as AiwgIndexQueryResult, aa as AiwgIndexQueryWeights, ab as AiwgIndexValidationResult, ac as AiwgPrivacyClassification, ad as AiwgPrivacyFilterOptions, ae as AiwgProvenanceConfidence, af as AiwgRelationshipDirection, ag as AiwgRelationshipEdgeSummary, ah as AiwgRelationshipNodeSummary, ai as AiwgRelationshipQueryOptions, aj as AiwgRelationshipSetOperation, ak as AiwgRelationshipSetOptions, al as AiwgRelationshipSetResult, am as AiwgRelationshipTraversalOptions, an as AiwgRelationshipTraversalResult, ao as AiwgReviewAction, ap as AiwgReviewDecision, aq as AiwgReviewDecisionExport, ar as AiwgReviewInput, as as AiwgStaticDuplicatePair, at as AiwgStaticEmbeddingRecord, au as AiwgStaticEmbeddingSet, av as AiwgStaticHybridQueryOptions, aw as AiwgStaticSemanticQueryOptions, ax as AiwgStaticSemanticResult, ay as BuildAiwgStaticEmbeddingSetOptions, az as CURRENT_SHARD_VERSION, aA as ConflictStrategy, aB as ImportCounts, aC as ImportProgress, aD as ImportProgressPhase, aE as MemoryBlobStore, aF as SHARD_FORMAT, aG as ShardClusterRef, aH as ShardLayout, aI as aiwgFortemiIndexToCommunityGraph, aJ as assertAiwgFortemiChunkManifest, aK as assertAiwgFortemiChunkPart, aL as assertAiwgFortemiIndexExport, aM as assertAiwgStaticEmbeddingSet, aN as buildAiwgChunkedIndex, aO as buildAiwgStaticEmbeddingSet, aP as createAiwgFetchChunkLoader, aQ as createAiwgFetchDetailLoader, aR as createAiwgIndexController, aS as createAiwgReviewDecisionExport, aT as createBlobStore, aU as filterAiwgRecordsByPrivacy, aV as findAiwgStaticDuplicatePairs, aW as getAiwgFortemiFacets, aX as queryAiwgFortemiIndex, aY as queryAiwgHybridIndex, aZ as queryAiwgSemanticIndex, a_ as validateAiwgFortemiChunkManifest, a$ as validateAiwgFortemiChunkPart, b0 as validateAiwgFortemiIndexExport, b1 as validateAiwgStaticEmbeddingSet } from './aiwg-index-C2G7iy-b.js';
+import { ProbeReport } from '@bytecask/core';
 import { z, ZodType } from 'zod';
+export { AiwgIndexSchemaValidationResult, getAiwgFortemiIndexExportSchema, validateAiwgFortemiIndexExportSchema, validateAiwgFortemiProjectedRecordSchema } from './aiwg-index-schema.js';
 
 /**
  * Generate a RFC 9562 UUIDv7 identifier.
@@ -390,6 +390,591 @@ declare class PGliteWorkerStorageBackendFactory implements StorageBackendFactory
     open(input: StorageOpenRequest): Promise<StorageBackend>;
 }
 
+/**
+ * Content-addressed attachment-byte storage — the Fortemi `BlobStore` seam.
+ *
+ * The store computes the key: `put(bytes)` BLAKE3-hashes the payload and
+ * returns the canonical checksum encoding `blake3:<64-char lowercase hex>`
+ * (server convention; ADR-012 D1/D3). Every method at this seam speaks that
+ * canonical encoding — the bare-hex ⇄ prefixed conversions live in
+ * `shard/blob-sidecar.ts` helpers and inside the bytecask adapter here, and
+ * nowhere else.
+ *
+ * Lifecycle authority (ADR-013 D2): canonical attachment manifests decide
+ * which bytes are live. `reconcile(liveChecksums)` hands that authoritative
+ * set to the store; `gc()` physically removes only unreferenced,
+ * age-thresholded objects. Internal refcounts are an implementation detail,
+ * never a source of truth.
+ *
+ * Implementations:
+ *   - `createBlobStore()`  — `@bytecask/core` behind a dynamic import
+ *     (IndexedDB tier by default, OPFS opt-in, memory fallback). Zero bundle
+ *     cost until the first byte operation (ADR-012 D6).
+ *   - `createLazyBlobStore()` — synchronous facade that defers the dynamic
+ *     import until the first method call (what `FortemiProvider` wires).
+ *   - `MemoryBlobStore`    — dependency-free in-process implementation for
+ *     tests and the no-persistence tier.
+ */
+
+type BlobBackendKind = 'idb' | 'opfs' | 'memory';
+interface BlobStoreDiagnostics {
+    /** The storage tier actually serving bytes. */
+    backend: BlobBackendKind;
+    /** Tier-probe outcome from `@bytecask/core` (null for memory/test stores). */
+    probe: ProbeReport | null;
+}
+interface BlobReconcileOptions {
+    /** Physically remove unreferenced objects now instead of leaving them for gc(). */
+    removeUnreferenced?: boolean;
+}
+interface BlobReconcileResult {
+    /** Live checksums whose bytes are present. */
+    referenced: number;
+    /** Live checksums whose bytes are absent — the reference-only set. */
+    missing: string[];
+    /** Stored checksums not in the live set — GC candidates. */
+    unreferenced: string[];
+    /** Objects physically removed (only when `removeUnreferenced`). */
+    removed: number;
+    bytesFreed: number;
+}
+interface BlobGcOptions {
+    /** Collect only unreferenced objects at least this old (ms). Default 0. */
+    minAgeMs?: number;
+}
+interface BlobGcResult {
+    collected: number;
+    bytesFreed: number;
+}
+/**
+ * The Fortemi attachment-byte seam. All checksums are the canonical
+ * `blake3:<hex>` encoding stored in `attachment_blob.content_hash` and shard
+ * projection records.
+ */
+interface BlobStore {
+    /** Store bytes, return their canonical checksum. Idempotent (content-addressed). */
+    put(bytes: Uint8Array): Promise<string>;
+    /** Fetch bytes by canonical checksum; null when absent (reference-only). */
+    read(checksum: string): Promise<Uint8Array | null>;
+    /** True when the bytes for this checksum are physically present. */
+    has(checksum: string): Promise<boolean>;
+    /**
+     * Reconcile stored bytes against the authoritative live-checksum set
+     * derived from canonical attachment manifests (ADR-013 D4).
+     */
+    reconcile(liveChecksums: Iterable<string>, opts?: BlobReconcileOptions): Promise<BlobReconcileResult>;
+    /** Physically remove unreferenced, age-thresholded objects. */
+    gc(opts?: BlobGcOptions): Promise<BlobGcResult>;
+    /** Selected backend + probe report, for capability/diagnostic surfaces. */
+    diagnostics(): Promise<BlobStoreDiagnostics>;
+    close(): Promise<void>;
+}
+declare class MemoryBlobStore implements BlobStore {
+    private now;
+    private entries;
+    constructor(now?: () => number);
+    put(bytes: Uint8Array): Promise<string>;
+    read(checksum: string): Promise<Uint8Array | null>;
+    has(checksum: string): Promise<boolean>;
+    reconcile(liveChecksums: Iterable<string>, opts?: BlobReconcileOptions): Promise<BlobReconcileResult>;
+    gc(opts?: BlobGcOptions): Promise<BlobGcResult>;
+    diagnostics(): Promise<BlobStoreDiagnostics>;
+    close(): Promise<void>;
+}
+interface CreateBlobStoreOptions {
+    /** Force a tier; omit to probe IndexedDB → OPFS → memory (measured default). */
+    backend?: BlobBackendKind;
+    /** Injectable IDBFactory for tests (fake-indexeddb). Defaults to the global. */
+    indexedDB?: IDBFactory;
+    /** Skip the one-shot migration of the pre-bytecask blob layout. */
+    migrateLegacy?: boolean;
+}
+/**
+ * Construct the bytecask-backed BlobStore for one archive namespace.
+ *
+ * `@bytecask/core` is reached only through a dynamic `import()` here, so
+ * hosts that never touch attachment bytes never load it. The namespace is a
+ * function of `archiveName` alone — identical in DB-free and PGlite modes.
+ *
+ * Tiering: IndexedDB by default (measured default per bytecask's C3
+ * benchmark), memory fallback when IndexedDB is unavailable. The OPFS opt-in
+ * tier arrives with the upstream `createBlobStore()` factory switch
+ * (`@bytecask/core` 2026.7.2); requesting it now fails loudly rather than
+ * silently falling back.
+ */
+declare function createBlobStore(archiveName: string, options?: CreateBlobStoreOptions): Promise<BlobStore>;
+/**
+ * Synchronous facade over {@link createBlobStore}: construction is free, the
+ * dynamic import happens on the first byte operation. This is what
+ * `FortemiProvider` wires so hosts that never touch attachment bytes never
+ * pay for the substrate (ADR-012 D6).
+ */
+declare function createLazyBlobStore(archiveName: string, options?: CreateBlobStoreOptions): BlobStore;
+
+/**
+ * Signed Knowledge-Shard verification (#324, ADR-014).
+ *
+ * Authenticity — as distinct from the consistency the in-archive checksums
+ * provide (SEC7) — comes from an Ed25519 signature over a canonical payload
+ * that commits to the manifest digest and the referenced blob-byte digests.
+ * Verification is pure and side-effect-free; it runs BEFORE any record or
+ * blob mutation (ADR-013 D6 / ADR-014 D3). Bytecask never sees keys.
+ */
+
+declare const SIGNATURE_ENTRY = "signature.json";
+declare const SIGNING_ENVELOPE_VERSION = "1";
+declare const SIGNING_ALGORITHM = "ed25519";
+interface ShardSigner {
+    key_id: string;
+    algorithm: typeof SIGNING_ALGORITHM;
+    /** Raw 32-byte Ed25519 public key, base64url. */
+    public_key: string;
+}
+/** The signed payload (never contains its own signature — ADR-014 D2). */
+interface ShardSigningPayload {
+    format_version: typeof SIGNING_ENVELOPE_VERSION;
+    signer: ShardSigner;
+    /** SHA-256 hex of the canonical manifest.json bytes. */
+    manifest_digest: string;
+    /** Sorted bare-hex BLAKE3 digests of referenced sidecar blobs. */
+    blob_digests: string[];
+}
+/** `signature.json` archive entry: the payload plus its base64url signature. */
+interface ShardSignatureEnvelope extends ShardSigningPayload {
+    signature: string;
+}
+interface TrustedKey {
+    key_id: string;
+    /** Raw 32-byte Ed25519 public key, base64url. */
+    public_key: string;
+    revoked?: boolean;
+}
+interface ShardTrustStore {
+    resolve(keyId: string): TrustedKey | null | Promise<TrustedKey | null>;
+}
+/** In-memory allowlist trust store seeded from `{ key_id, public_key }` entries. */
+declare class AllowlistTrustStore implements ShardTrustStore {
+    private keys;
+    constructor(keys: TrustedKey[]);
+    resolve(keyId: string): TrustedKey | null;
+    /** Mark a key revoked without removing it (still resolvable, verdict `revoked`). */
+    revoke(keyId: string): void;
+}
+type ShardSignatureVerdict = {
+    ok: true;
+    keyId: string;
+} | {
+    ok: false;
+    reason: 'unsigned';
+} | {
+    ok: false;
+    reason: 'malformed';
+    detail: string;
+} | {
+    ok: false;
+    reason: 'unknown-signer';
+    keyId: string;
+} | {
+    ok: false;
+    reason: 'revoked';
+    keyId: string;
+} | {
+    ok: false;
+    reason: 'bad-signature';
+    keyId: string;
+} | {
+    ok: false;
+    reason: 'content-mismatch';
+    detail: string;
+} | {
+    ok: false;
+    reason: 'unsupported';
+};
+/** True when this runtime's WebCrypto verifies Ed25519 (ADR-014 D1). */
+declare function isShardSigningSupported(): Promise<boolean>;
+/** Sorted bare-hex BLAKE3 digests of the sidecar blobs present in the archive. */
+declare function sidecarBlobDigests(files: Map<string, Uint8Array>): string[];
+interface VerifyShardSignatureInput {
+    files: Map<string, Uint8Array>;
+    trustStore: ShardTrustStore;
+}
+/**
+ * Verify a shard's Ed25519 signature over its canonical payload. Pure: reads
+ * archive bytes, resolves the key, checks the signature and the
+ * manifest/blob-digest commitments. No persistence, no mutation.
+ */
+declare function verifyShardSignature(input: VerifyShardSignatureInput): Promise<ShardSignatureVerdict>;
+interface SignShardInput {
+    files: Map<string, Uint8Array>;
+    keyId: string;
+    /** Ed25519 private key (raw 32-byte seed or PKCS8), imported by the caller. */
+    privateKey: CryptoKey;
+    /** Raw 32-byte public key, base64url — embedded in the envelope + trust store. */
+    publicKey: string;
+}
+/**
+ * Produce the `signature.json` envelope for an assembled archive `files` map.
+ * The caller adds the returned bytes to the archive under {@link SIGNATURE_ENTRY}
+ * (excluded from manifest.checksums — it post-dates the manifest).
+ */
+declare function signShard(input: SignShardInput): Promise<Uint8Array>;
+
+/**
+ * Shard format types — matches the fortemi server matric-shard specification.
+ *
+ * A shard is a gzip-compressed tar archive (.shard) containing serialized
+ * knowledge data with a manifest for integrity verification.
+ */
+
+declare const CURRENT_SHARD_VERSION = "1.0.0";
+declare const SHARD_FORMAT = "matric-shard";
+/** Components that can appear in a shard archive. */
+type ShardComponent = 'notes' | 'collections' | 'tags' | 'templates' | 'links' | 'embedding_sets' | 'embedding_configs' | 'embedding_set_members' | 'embeddings' | 'skos_schemes' | 'skos_concepts' | 'skos_relations' | 'note_skos_tags' | 'provenance_edges' | 'community_assignments' | 'communities' | 'graph_edges' | 'graph_sources';
+interface ShardAttachmentReference {
+    id: string;
+    path: string;
+    mime: string | null;
+    checksum: string;
+    bytes: number;
+}
+interface ShardAttachmentProjection {
+    extracted_text: string | null;
+    attachment: ShardAttachmentReference;
+}
+/** @deprecated Legacy React shard field name. Server shards use `attachments`. */
+type ShardBinarySource = ShardAttachmentProjection;
+/**
+ * Reference to one cluster file of a component split across addressable files
+ * (`notes/000.jsonl`, `notes/001.jsonl`, …). `offset` preserves deterministic
+ * component order; readers discover each cluster's size from its contents.
+ */
+interface ShardClusterRef {
+    href: string;
+    offset: number;
+}
+/**
+ * Optional clustered layout (additive — absent on monolithic shards). When a
+ * component is present here, its records live in the listed cluster files instead
+ * of (or in addition to) the single `<component>.jsonl`. Both `importShard` and
+ * the in-place reader consume it; a monolithic shard omits `layout` entirely.
+ */
+interface ShardLayout {
+    clusters?: Partial<Record<ShardComponent, ShardClusterRef[]>>;
+}
+interface ShardMigrationHistoryEntry {
+    from_version: string;
+    to_version: string;
+    migrated_at: string;
+    migrated_by: string;
+    changes: string[];
+}
+/** Manifest included in every shard as manifest.json. */
+interface ShardManifest {
+    version: string;
+    matric_version: string;
+    format: typeof SHARD_FORMAT;
+    created_at: string;
+    components: ShardComponent[];
+    counts: Partial<Record<ShardComponent | 'community_sets', number>>;
+    checksums: Record<string, string>;
+    min_reader_version: string;
+    migrated_from?: string | null;
+    migration_history?: ShardMigrationHistoryEntry[];
+    /** Clustered component layout for partial fetch (issue #189). Absent → monolithic. */
+    layout?: ShardLayout;
+}
+/** Options for shard export. */
+interface ExportOptions {
+    includeEmbeddings?: boolean;
+    /** Filter to specific collection (export only notes in this collection). */
+    collectionId?: string;
+    /** Filter to notes with this tag (e.g. 'app:research' for app-scoped export). */
+    tag?: string;
+    /** Export only these embedding sets and their member/vector rows. */
+    embeddingSetIds?: string[];
+    /** Preserve virtual selector materialization metadata and virtual member rows. */
+    includeMaterializedSelectors?: boolean;
+    /**
+     * When set to a positive integer, emit notes as clustered files
+     * (`notes/000.jsonl`, …) of this many records each, and record the layout in
+     * the manifest, so an in-place reader can fetch only the clusters it needs
+     * (issue #189). Absent → a single monolithic `notes.jsonl` (unchanged).
+     */
+    clusterNotesSize?: number;
+    /**
+     * Pack attachment bytes into a portable content-addressed `blobs/<hex>`
+     * sidecar (Fortemi/fortemi#1046), producing a self-contained shard whose
+     * attachments survive a round-trip (`getBlob()` returns real bytes on the
+     * importing host). Requires {@link blobStore}. Absent/false → reference-only
+     * (server default), which remains a valid shard.
+     */
+    includeBlobs?: boolean;
+    /**
+     * Byte source for the sidecar. Required when `includeBlobs` is set; attachment
+     * bytes are read by their `content_hash`. A blob the store cannot return is
+     * skipped (its attachment stays reference-only) rather than failing export.
+     */
+    blobStore?: BlobStore;
+}
+/** Conflict resolution strategy for shard import. */
+type ConflictStrategy = 'skip' | 'replace' | 'error';
+/** Options for shard import. */
+interface ImportOptions {
+    conflictStrategy?: ConflictStrategy;
+    /** Rows processed between cooperative yields. Defaults to 250. */
+    batchSize?: number;
+    /** Progress callback for long-running import phases. */
+    onProgress?: (progress: ImportProgress) => void;
+    /**
+     * Destination for hydrating attachment bytes from a portable `blobs/<hex>`
+     * sidecar (Fortemi/fortemi#1046). When provided, sidecar entries whose bare
+     * hex matches an imported attachment's `content_hash` are written to this
+     * store after the import transaction commits, so `getBlob()` returns real
+     * bytes. Absent → attachments import as reference-only metadata (unchanged).
+     */
+    blobStore?: BlobStore;
+    /**
+     * Publisher-provenance policy for signed shards (#324, ADR-014):
+     * - `require` — reject unsigned or bad-signature shards (default when a
+     *   `trustStore` is supplied);
+     * - `prefer` — verify signed shards; import unsigned ones with a warning;
+     *   still reject a present-but-invalid signature;
+     * - `trusted-local-only` — ignore signatures (own-export import).
+     * When both `trustStore` and this are omitted, verification is skipped
+     * entirely (checksum-only, unchanged behavior).
+     */
+    verifySignature?: 'require' | 'prefer' | 'trusted-local-only';
+    /** Trust store resolving signer key_id → public key (required for `require`/`prefer`). */
+    trustStore?: ShardTrustStore;
+}
+type ImportProgressPhase = 'unpack' | 'validate' | 'collections' | 'notes' | 'skos' | 'templates' | 'links' | 'provenance' | 'embedding_sets' | 'embedding_configs' | 'embeddings' | 'embedding_set_members' | 'graph' | 'communities' | 'index';
+interface ImportProgress {
+    phase: ImportProgressPhase;
+    done: number;
+    total: number;
+}
+/** Per-entity import counts. */
+interface ImportCounts {
+    notes: number;
+    collections: number;
+    templates: number;
+    tags: number;
+    links: number;
+    embedding_sets: number;
+    embedding_configs: number;
+    embedding_set_members: number;
+    embeddings: number;
+    skos_schemes: number;
+    skos_concepts: number;
+    skos_relations: number;
+    note_skos_tags: number;
+    provenance_edges: number;
+    graph_sources: number;
+    graph_edges: number;
+    community_sets: number;
+    communities: number;
+    community_assignments: number;
+}
+/** Result of a shard import operation. */
+interface ImportResult {
+    success: boolean;
+    counts: ImportCounts;
+    skipped: Partial<ImportCounts>;
+    warnings: string[];
+    errors: string[];
+    duration_ms: number;
+}
+/** Note as serialized in the shard JSONL. */
+interface ShardNote {
+    id: string;
+    title: string | null;
+    original_content: string;
+    revised_content: string | null;
+    metadata?: Record<string, unknown> | null;
+    collection_id?: string | null;
+    attachments?: ShardAttachmentProjection[];
+    /** @deprecated Legacy React shard field name. Use `attachments`. */
+    binary_sources?: ShardBinarySource[];
+    format: string;
+    source: string;
+    starred: boolean;
+    archived: boolean;
+    tags: string[];
+    created_at: string;
+    updated_at: string;
+    deleted_at: string | null;
+}
+/** Collection as serialized in the shard JSON array. */
+interface ShardCollection {
+    id: string;
+    name: string;
+    description: string | null;
+    parent_id: string | null;
+    created_at: string;
+    note_count?: number;
+}
+/** Tag as serialized in the shard JSON array. */
+interface ShardTag {
+    name: string;
+    created_at: string;
+}
+/** Template as serialized in the shard JSON array. */
+interface ShardTemplate {
+    id: string;
+    name: string;
+    description: string | null;
+    content: string;
+    format: string;
+    default_tags: string[];
+    collection_id: string | null;
+    created_at: string;
+    updated_at: string;
+}
+/** Link as serialized in the shard JSONL. */
+interface ShardLink {
+    id: string;
+    from_note_id: string;
+    to_note_id: string | null;
+    /** Optional for legacy React shards exported before URL links existed. */
+    to_url?: string | null;
+    kind: string;
+    score: number | null;
+    created_at: string;
+    /** Optional for legacy React shards exported before link metadata existed. */
+    metadata?: Record<string, unknown> | null;
+}
+/**
+ * Embedding set as serialized in the shard JSON array.
+ *
+ * Fields beyond id/model/dimension are optional for backward compatibility:
+ * legacy React shards omit them and import falls back to the same defaults
+ * `embeddingSetFromShard` applies (name → model, is_system → false, …).
+ */
+interface ShardEmbeddingSet {
+    id: string;
+    name?: string;
+    slug?: string | null;
+    description?: string | null;
+    purpose?: string | null;
+    document_count?: number;
+    embedding_count?: number;
+    is_system?: boolean;
+    keywords?: string[];
+    model: string;
+    dimension: number;
+    kind?: 'physical' | 'filter' | 'virtual';
+    mode?: 'auto' | 'manual' | 'mixed' | null;
+    truncate_dimension?: number | null;
+    criteria?: Record<string, unknown> | null;
+    source?: Record<string, unknown> | null;
+    compatibility?: Record<string, unknown> | null;
+    materialization?: Record<string, unknown> | null;
+    freshness?: ShardArtifactFreshness | null;
+    created_at?: string;
+    updated_at?: string;
+}
+/** Embedding set member as serialized in the shard JSONL. */
+interface ShardEmbeddingSetMember {
+    embedding_set_id: string;
+    note_id: string;
+    /** Legacy React shard field; new exports use server membership metadata instead. */
+    embedding_id?: string;
+    /** Optional for legacy React shards; import defaults to 'materialized'. */
+    membership_type?: string;
+    /** Optional for legacy React shards; import falls back to the manifest timestamp. */
+    added_at?: string;
+    /** Optional for legacy React shards; import defaults to NULL. */
+    added_by?: string | null;
+}
+/** Embedding config as serialized in the shard JSON array. */
+interface ShardEmbeddingConfig {
+    id: string;
+    name: string;
+    description: string | null;
+    model: string;
+    dimension: number;
+    chunk_size: number;
+    chunk_overlap: number;
+    is_default: boolean;
+}
+/**
+ * Embedding as serialized in the shard JSONL.
+ *
+ * Server metadata fields (`chunk_index`, `text`, `model`) are optional for
+ * backward compatibility: legacy React shards exported before migration 0016
+ * carry only `id`, `note_id`, `embedding_set_id`, `vector`, `created_at`.
+ * Import normalizes absent metadata to schema defaults (0, '', NULL).
+ */
+interface ShardEmbedding {
+    id: string;
+    note_id: string;
+    chunk_index?: number;
+    text?: string;
+    vector: number[];
+    model?: string;
+    /** React shard extension used to preserve local embedding-set scoping. */
+    embedding_set_id?: string;
+    /** React shard extension used to preserve local creation ordering. */
+    created_at?: string;
+}
+/** SKOS scheme as serialized in the shard JSON array. */
+interface ShardSkosScheme {
+    id: string;
+    title: string;
+    description: string | null;
+    created_at: string;
+    updated_at: string;
+}
+/** SKOS concept as serialized in the shard JSON array. */
+interface ShardSkosConcept {
+    id: string;
+    scheme_id: string;
+    pref_label: string;
+    alt_labels: string[];
+    definition: string | null;
+    created_at: string;
+    updated_at: string;
+}
+/** SKOS concept relation as serialized in the shard JSONL. */
+interface ShardSkosRelation {
+    id: string;
+    source_concept_id: string;
+    target_concept_id: string;
+    relation_type: 'broader' | 'narrower' | 'related';
+    created_at: string;
+}
+/** Note-to-SKOS-concept assignment as serialized in the shard JSONL. */
+interface ShardNoteSkosTag {
+    id: string;
+    note_id: string;
+    concept_id: string;
+    created_at: string;
+}
+/** Provenance edge as serialized in the shard JSONL. */
+interface ShardProvenanceEdge {
+    id: string;
+    entity_type: string;
+    entity_id: string;
+    activity: string;
+    agent: string;
+    started_at: string;
+    ended_at: string | null;
+    attributes: Record<string, unknown> | null;
+}
+interface ShardArtifactFreshness {
+    status: 'fresh' | 'stale' | 'unknown';
+    checked_at?: string;
+    stale_reason?: string;
+    source_hashes?: {
+        notes?: string;
+        links?: string;
+        embeddings?: string;
+        embedding_set_members?: string;
+        virtual_set_definition?: string;
+        parameters?: string;
+    };
+}
+
 /**
  * LinksRepository — bidirectional note link management.
  *
@@ -483,6 +1068,7 @@ interface BrowserNoteExport {
     deleted_at: Date | string | null;
     original_content: string;
     revised_content: string | null;
+    ai_metadata?: Record<string, unknown> | null;
     collection_id?: string | null;
     attachments?: ShardAttachmentProjection[];
     tags: string[];
@@ -622,7 +1208,7 @@ declare function embeddingFromShard(shard: ShardEmbedding): {
     chunk_index: number;
     text: string;
     vector: string;
-    model: string;
+    model: string | null;
     created_at: string | null;
 };
 declare function skosSchemeToShard(scheme: {
@@ -1279,6 +1865,34 @@ declare function createRoutes(): RouteHandler[];
  */
 declare function matchRoute(routes: RouteHandler[], request: Request, url: URL): RouteHandler | null;
 
+/**
+ * One-shot migration of the pre-bytecask blob layout into the new store.
+ *
+ * The legacy layout (shipped through v2026.7.x) was:
+ *   - IndexedDB: database `fortemi-<archive>-blobs`, object store `blobs`,
+ *     values keyed by the full checksum string (`blake3:<hex>`, historically
+ *     also `sha256:<hex>`).
+ *   - OPFS: directory `fortemi-<archive>-blobs/<h0h1>/<h2h3>/<checksum>`.
+ *
+ * Migration re-`put()`s every payload — the new store recomputes BLAKE3, so
+ * legacy `sha256:`-keyed entries converge to canonical keys for free
+ * (ADR-012 D3). The legacy source is deleted only after every entry migrated
+ * without error; any failure leaves it untouched for the next attempt.
+ */
+
+/** Outcome of one migration attempt (for diagnostics/logging). */
+interface LegacyMigrationReport {
+    migrated: number;
+    /** Migration aborted without deleting the legacy source. */
+    failed: boolean;
+}
+/**
+ * Migrate any legacy blob layout for `archiveName` into `target`, then delete
+ * the legacy source. Failures are contained: the legacy data stays in place
+ * and the new store keeps whatever was already re-put (idempotent on retry).
+ */
+declare function migrateLegacyBlobStore(archiveName: string, target: BlobStore, indexedDbFactory?: IDBFactory): Promise<LegacyMigrationReport>;
+
 /**
  * Shared postMessage protocol types for the PGlite worker.
  *
@@ -1614,6 +2228,13 @@ interface NoteCreateInput {
     visibility?: string;
     tags?: string[];
     archive_id?: string;
+    /**
+     * Explicit primary key. When omitted a UUIDv7 is minted (the default). Supply
+     * this only for deterministic seeding or cross-instance identity — e.g. two
+     * in-browser databases that must agree on a shared note's id so a shard swap
+     * can dedupe it under the `skip` conflict strategy.
+     */
+    id?: string;
 }
 interface NoteUpdateInput {
     title?: string;
@@ -2606,11 +3227,13 @@ declare function manageCapabilities(capabilityManager: CapabilityManager, rawInp
  * AttachmentsRepository — attach and retrieve binary files linked to notes.
  *
  * Responsibilities:
- * - Content-addressed blob deduplication via SHA-256 hash
+ * - Content-addressed blob deduplication via the store-computed BLAKE3 hash
  * - Store blob metadata in DatabaseClient (attachment_blob table)
- * - Store binary data in a BlobStore implementation
+ * - Store binary data in a BlobStore implementation (bytes-first ordering)
  * - Create/soft-delete attachment records linked to notes
  * - List active attachments for a note
+ * - Reconcile/GC blob bytes against the canonical manifest live set
+ *   (ADR-013 D2/D4: manifests are the sole lifecycle authority)
  */
 
 interface AttachmentRow {
@@ -2648,11 +3271,16 @@ declare class AttachmentsRepository {
     /**
      * Attach a binary file to a note.
      *
-     * If a blob with the same BLAKE3 content hash already exists, the existing
-     * blob row is reused (deduplication). Otherwise a new blob row is inserted
-     * and the raw bytes are written to the BlobStore. The BLAKE3 `content_hash`
-     * (`blake3:<hex>`) matches the server convention and is the key used by the
-     * portable Knowledge-Shard byte sidecar.
+     * Bytes are written first (`put()` is idempotent — content addressing makes
+     * replays safe), then the metadata rows commit (ADR-013 D5). A crash
+     * between the two leaves an unreferenced blob that reconcile/gc sweeps —
+     * never a manifest without recoverable state. The store-computed BLAKE3
+     * `content_hash` (`blake3:<hex>`) matches the server convention and is the
+     * key used by the portable Knowledge-Shard byte sidecar.
+     *
+     * If a blob row with the same content hash already exists, it is reused
+     * (deduplication) — re-putting the bytes also heals a previously
+     * reference-only blob whose bytes went missing.
      *
      * Returns the newly created AttachmentRow.
      */
@@ -2664,9 +3292,16 @@ declare class AttachmentsRepository {
     get(id: string): Promise<AttachmentRow>;
     /**
      * Retrieve the raw binary data for an attachment.
-     * Returns null if the blob cannot be found in the BlobStore.
+     * Returns null when the bytes are not present — the attachment is then in
+     * the recoverable reference-only state (metadata intact, bytes
+     * re-hydratable from a shard sidecar or a re-attach of the same content).
      */
     getBlob(attachmentId: string): Promise<Uint8Array | null>;
+    /**
+     * True when the attachment's bytes are physically present in the BlobStore.
+     * False means reference-only (recoverable), not an error.
+     */
+    hasBlob(attachmentId: string): Promise<boolean>;
     /**
      * List active (non-deleted) attachments for a note.
      * Ordered by position ascending, then created_at ascending.
@@ -2674,9 +3309,29 @@ declare class AttachmentsRepository {
     list(noteId: string): Promise<AttachmentRow[]>;
     /**
      * Soft-delete an attachment by setting deleted_at to the current timestamp.
-     * The underlying blob row and BlobStore data are not removed.
+     * The blob row is untouched and no bytes are removed inline — physical
+     * removal happens only through deferred `reconcileBlobs()`/`gcBlobs()`
+     * against the canonical live set (ADR-013 D4).
      */
     delete(id: string): Promise<void>;
+    /**
+     * The authoritative live-checksum set: content hashes referenced by at
+     * least one non-deleted attachment. This — not any refcount — decides
+     * which bytes are reachable.
+     */
+    liveBlobChecksums(): Promise<string[]>;
+    /**
+     * Reconcile the BlobStore against the canonical live set (startup, after
+     * quota events, after interrupted writes). `missing` lists reference-only
+     * checksums; `unreferenced` lists GC candidates.
+     */
+    reconcileBlobs(opts?: BlobReconcileOptions): Promise<BlobReconcileResult>;
+    /**
+     * Deferred, age-thresholded physical removal of unreachable bytes.
+     * Runs a reconcile first so GC always acts on current manifest truth.
+     */
+    gcBlobs(opts?: BlobGcOptions): Promise<BlobGcResult>;
+    private blobChecksumOf;
 }
 
 declare const ManageAttachmentsInputSchema: z.ZodObject<{
@@ -3489,6 +4144,12 @@ declare function sha256Hex(data: Uint8Array): Promise<string>;
  * checked against the whole archive (see `prefetchShard`'s `expectedSha256`,
  * which is real integrity because the hash arrives on a separate channel).
  *
+ * The signed-manifest path is now implemented: `verifyShardSignature`
+ * (`shard-signature.ts`, #324/ADR-014) authenticates publisher provenance via
+ * an Ed25519 signature over the manifest digest + blob-digest set, and
+ * `importShard` runs it BEFORE any record or blob mutation. These in-archive
+ * checksums remain the consistency layer *inside* that verified boundary.
+ *
  * @returns Object with `valid` flag and list of failed filenames.
  */
 declare function validateChecksums(checksums: Record<string, string>, files: Map<string, Uint8Array>): Promise<{
@@ -3708,14 +4369,851 @@ declare function getPrefetchedSha256(url: string): string | undefined;
  */
 declare function clearPrefetchedShard(url?: string): void;
 
-interface AiwgIndexSchemaValidationResult {
+type AiwgFortemiRecordType = string;
+type AiwgFortemiRecordSchemaVersion = 'aiwg.fortemi.index.record.v1' | 'aiwg.fortemi.index.record.v2';
+type AiwgFortemiIndexExportSchemaVersion = 'aiwg.fortemi.index.export.v1' | 'aiwg.fortemi.index.export.v2';
+type AiwgPrivacyClassification = 'private' | 'sanitized' | 'public';
+type AiwgProvenanceConfidence = 'source' | 'candidate' | 'reviewed' | 'rejected';
+type AiwgReviewAction = 'accept' | 'reject' | 'defer';
+type AiwgFortemiRelationshipDirection = 'upstream' | 'downstream' | 'related';
+interface AiwgFortemiRecordSource {
+    path: string;
+    repo_relative_path: string;
+    locator: string;
+    origin?: string;
+    generated?: boolean;
+    checksum?: string;
+    updated_at?: string;
+}
+interface AiwgFortemiRelationship {
+    type: string;
+    target_id: string;
+    source_path?: string;
+    target_path?: string;
+    direction?: AiwgFortemiRelationshipDirection;
+    label?: string;
+    confidence?: number;
+    privacy?: AiwgPrivacyClassification;
+    metadata?: Record<string, unknown>;
+}
+interface AiwgFortemiProvenance {
+    field: string;
+    source: string;
+    path: string;
+    confidence: AiwgProvenanceConfidence;
+    privacy: AiwgPrivacyClassification;
+}
+type AiwgFortemiSkosRelationType = 'broader' | 'narrower' | 'related' | string;
+interface AiwgFortemiSkosConcept {
+    id: string;
+    prefLabel: string;
+    definition?: string;
+    scheme?: string;
+    notation?: string;
+    uri?: string;
+    altLabels?: string[];
+    metadata?: Record<string, unknown>;
+}
+interface AiwgFortemiSkosRelation {
+    type: AiwgFortemiSkosRelationType;
+    source_id: string;
+    target_id: string;
+    source_path?: string;
+    metadata?: Record<string, unknown>;
+}
+interface AiwgFortemiProvenanceEvent {
+    id?: string;
+    activity: string;
+    agent?: string;
+    started_at?: string;
+    ended_at?: string;
+    source?: string;
+    path?: string;
+    confidence?: AiwgProvenanceConfidence;
+    privacy?: AiwgPrivacyClassification;
+    attributes?: Record<string, unknown>;
+}
+interface AiwgFortemiSearchProjection {
+    title?: string;
+    name?: string;
+    summary?: string;
+    body?: string;
+    triggers?: string[];
+    aliases?: string[];
+    capability?: string;
+    tags?: string[];
+    phase?: string;
+    type?: string;
+    frontmatter?: Record<string, unknown>;
+}
+interface AiwgFortemiChunk {
+    id?: string;
+    text?: string;
+    body?: string;
+    summary?: string;
+    source_path?: string;
+    metadata?: Record<string, unknown>;
+}
+interface AiwgFortemiRecordEmbedding {
+    id?: string;
+    embedding?: number[];
+    vector?: number[];
+    model?: string;
+    granularity?: string;
+    input_hash?: string;
+    source_path?: string;
+    metadata?: Record<string, unknown>;
+}
+type AiwgFortemiAttachmentReference = ShardAttachmentReference;
+type AiwgFortemiBinarySource = ShardBinarySource;
+interface AiwgFortemiRecord {
+    schema_version: AiwgFortemiRecordSchemaVersion;
+    id: string;
+    type: AiwgFortemiRecordType;
+    source: AiwgFortemiRecordSource;
+    title?: string;
+    text?: string;
+    facets: Record<string, string[]>;
+    tags: string[];
+    concepts: string[];
+    relationships: AiwgFortemiRelationship[];
+    provenance: AiwgFortemiProvenance[];
+    search?: AiwgFortemiSearchProjection;
+    chunks?: AiwgFortemiChunk[];
+    binary_sources?: AiwgFortemiBinarySource[];
+    embeddings?: AiwgFortemiRecordEmbedding[];
+    compatibility?: Record<string, unknown>;
+    /** Optional rich SKOS metadata for static consumers that need labels/definitions without opening a shard. */
+    skos_concepts?: AiwgFortemiSkosConcept[];
+    /** Optional SKOS relationship edges among concepts referenced by this record. */
+    skos_relations?: AiwgFortemiSkosRelation[];
+    /** Optional W3C PROV-style activity chain for this record. */
+    provenance_events?: AiwgFortemiProvenanceEvent[];
+    privacy: {
+        classification: AiwgPrivacyClassification;
+        pii: boolean;
+        locality?: string;
+    };
+    updated_at: string;
+}
+interface AiwgFortemiIndexExport {
+    schema_version: AiwgFortemiIndexExportSchemaVersion;
+    generated_at: string;
+    source: {
+        repo: string;
+        privacy: AiwgPrivacyClassification;
+        graph?: string;
+    };
+    items: AiwgFortemiRecord[];
+    compatibility?: {
+        previous_schema_version: 'aiwg.fortemi.index.export.v1';
+        strategy: 'supported';
+    };
+}
+interface AiwgFortemiChunkPartRef {
+    href: string;
+    offset: number;
+    count: number;
+}
+declare const AIWG_SCAN_REQUIRED_FIELDS: Array<keyof AiwgFortemiRecord>;
+type AiwgFortemiProjectedRecord = Pick<AiwgFortemiRecord, 'schema_version' | 'id' | 'type' | 'title' | 'text' | 'facets' | 'tags' | 'concepts' | 'privacy'> & Partial<AiwgFortemiRecord>;
+type AiwgDetailIdEncoding = 'uri' | 'base64url';
+interface AiwgFortemiChunkDetailRef {
+    href: string;
+    encoding?: AiwgDetailIdEncoding;
+}
+interface AiwgFortemiChunkManifest {
+    schema_version: 'aiwg.fortemi.index.chunk-manifest.v1';
+    generated_at: string;
+    source: AiwgFortemiIndexExport['source'];
+    source_export_schema_version?: AiwgFortemiIndexExportSchemaVersion;
+    total: number;
+    part_size: number;
+    facets?: Record<string, Record<string, number>>;
+    projection?: Array<keyof AiwgFortemiRecord>;
+    detail?: AiwgFortemiChunkDetailRef;
+    parts: AiwgFortemiChunkPartRef[];
+}
+interface AiwgFortemiChunkPart {
+    schema_version: 'aiwg.fortemi.index.chunk.v1';
+    manifest_schema_version: 'aiwg.fortemi.index.chunk-manifest.v1';
+    offset: number;
+    items: AiwgFortemiRecord[];
+}
+interface AiwgIndexValidationResult {
     valid: boolean;
     errors: string[];
+    counts: Partial<Record<string, number>>;
+}
+interface AiwgKnowledgeShardOptions {
+    createdAt?: string;
+    matricVersion?: string;
+    /**
+     * Include React-native SKOS and provenance component files. The default
+     * portable profile keeps those projections in lossless note metadata so the
+     * shard remains importable by the current Fortemi server.
+     */
+    includeNativeRichComponents?: boolean;
+}
+interface AiwgChunkedIndexValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+interface AiwgIndexQueryOptions {
+    types?: AiwgFortemiRecordType[];
+    facets?: Record<string, string[]>;
+    tags?: string[];
+    concepts?: string[];
+    privacy?: AiwgPrivacyClassification[];
+    relationshipTargetId?: string;
+    limit?: number;
+    offset?: number;
+    rank?: boolean;
+    snippets?: boolean;
+    snippetLength?: number;
+    weights?: Partial<AiwgIndexQueryWeights>;
+    includeMatches?: boolean;
+    searchProfile?: 'default' | 'aiwg-discovery';
+}
+interface AiwgIndexQueryWeights {
+    title: number;
+    text: number;
+    tag: number;
+    concept: number;
+    facet: number;
+    id: number;
+    source: number;
+}
+interface AiwgIndexQueryMatch {
+    field: 'title' | 'text' | 'tag' | 'concept' | 'facet' | 'id' | 'source';
+    value: string;
+    score?: number;
+    reason?: string;
+}
+interface AiwgIndexQueryRankedItem {
+    item: AiwgFortemiRecord;
+    rank: number;
+    snippet?: string;
+    matches?: AiwgIndexQueryMatch[];
+}
+interface AiwgIndexQueryResult {
+    items: AiwgFortemiRecord[];
+    total: number;
+    facets: Record<string, Record<string, number>>;
+    rankedItems?: AiwgIndexQueryRankedItem[];
+}
+type AiwgChunkedIndexLoader = (part: AiwgFortemiChunkPartRef, manifest: AiwgFortemiChunkManifest) => Promise<unknown>;
+type AiwgChunkedIndexDetailLoader = (id: string, manifest: AiwgFortemiChunkManifest) => Promise<unknown>;
+interface AiwgChunkedIndexLoadOptions {
+    maxCachedParts?: number;
+    detailLoader?: AiwgChunkedIndexDetailLoader;
+    maxCachedDetails?: number;
+    maxCachedMatches?: number;
+}
+type AiwgChunkedIndexProgressPhase = 'part' | 'query';
+interface AiwgChunkedIndexProgress {
+    phase: AiwgChunkedIndexProgressPhase;
+    done: number;
+    total: number;
+    href?: string;
+}
+interface AiwgChunkedIndexQueryOptions extends AiwgIndexQueryOptions {
+    onProgress?: (progress: AiwgChunkedIndexProgress) => void;
+}
+interface AiwgChunkedIndexQueryResult extends AiwgIndexQueryResult {
+    manifestTotal: number;
+    scannedParts: number;
+    fetchedParts: number;
+    complete: boolean;
+}
+interface AiwgReviewDecision {
+    item_id: string;
+    action: AiwgReviewAction;
+    reason?: string;
+    updated_at: string;
+}
+interface AiwgReviewDecisionExport {
+    schema_version: 'aiwg.fortemi.review-decisions.v1';
+    generated_at: string;
+    source_export_schema_version: AiwgFortemiIndexExportSchemaVersion;
+    decisions: AiwgReviewDecision[];
+}
+interface AiwgIndexGraphOptions {
+    communityFacet?: string;
+    communityTagPrefix?: string;
+    relationshipWeights?: Record<string, number>;
+    includeDanglingRelationships?: boolean;
+}
+type AiwgRelationshipDirection = 'in' | 'out' | 'both';
+type AiwgRelationshipSetOperation = 'intersection' | 'union' | 'difference';
+interface AiwgRelationshipTraversalOptions {
+    direction?: AiwgRelationshipDirection;
+    relationshipType?: string;
+    relationshipDirection?: AiwgFortemiRelationshipDirection;
+    limit?: number;
+}
+interface AiwgRelationshipQueryOptions extends AiwgRelationshipTraversalOptions {
+    sourceId?: string;
+    targetId?: string;
+    endpointId?: string;
+    type?: string;
+}
+interface AiwgRelationshipEdgeSummary {
+    source_id: string;
+    target_id: string;
+    type: string;
+    source_path?: string;
+    target_path?: string;
+    direction?: AiwgFortemiRelationshipDirection;
+}
+interface AiwgRelationshipNodeSummary {
+    id: string;
+    type: AiwgFortemiRecordType;
+    title: string;
+}
+interface AiwgRelationshipTraversalResult {
+    nodes: AiwgRelationshipNodeSummary[];
+    edges: AiwgRelationshipEdgeSummary[];
+    complete: boolean;
+    scannedParts?: number;
+    fetchedParts?: number;
+}
+interface AiwgRelationshipSetOptions extends AiwgRelationshipTraversalOptions {
+    op: AiwgRelationshipSetOperation;
+    a: string;
+    b: string;
+}
+interface AiwgRelationshipSetResult {
+    ids: string[];
+    op: AiwgRelationshipSetOperation;
+}
+interface AiwgStaticEmbeddingRecord {
+    record_id: string;
+    embedding: number[];
+    embedding_id?: string;
+    granularity?: string;
+    input_hash: string;
+    source_path?: string;
+}
+interface AiwgStaticEmbeddingSet {
+    schema_version: 'aiwg.fortemi.embedding.set.v1';
+    id: string;
+    model: string;
+    dimensions: number;
+    generated_at: string;
+    granularity: 'title-summary' | 'body' | 'chunked-body' | string;
+    metric?: 'cosine' | 'dot' | 'euclidean';
+    input_hash_algorithm?: string;
+    embeddings: AiwgStaticEmbeddingRecord[];
+}
+interface AiwgHeadlessEmbeddingBackend {
+    model: string;
+    dimensions: number;
+    embed(input: string, record: AiwgFortemiRecord): number[] | Promise<number[]>;
+}
+interface AiwgPrivacyFilterOptions {
+    /** Include records classified `private` (default false). */
+    includePrivate?: boolean;
+    /** Include records flagged `pii` (default false). */
+    includePii?: boolean;
+}
+/** Drop `private`/`pii` records unless explicitly opted in (SEC6, default-safe). */
+declare function filterAiwgRecordsByPrivacy(records: AiwgFortemiRecord[], options?: AiwgPrivacyFilterOptions): AiwgFortemiRecord[];
+interface BuildAiwgStaticEmbeddingSetOptions {
+    id: string;
+    backend: AiwgHeadlessEmbeddingBackend;
+    records?: AiwgFortemiRecord[];
+    generatedAt?: string | Date;
+    granularity?: AiwgStaticEmbeddingSet['granularity'];
+    metric?: AiwgStaticEmbeddingSet['metric'];
+    textForRecord?: (record: AiwgFortemiRecord) => string;
+    /** Privacy filtering (SEC6). Default-safe: excludes `private`/`pii` records. */
+    privacy?: AiwgPrivacyFilterOptions;
+}
+interface AiwgStaticSemanticQueryOptions {
+    limit?: number;
+    offset?: number;
+    minScore?: number;
+}
+interface AiwgStaticSemanticResult {
+    item: AiwgFortemiRecord;
+    score: number;
+    embedding?: AiwgStaticEmbeddingRecord;
+}
+interface AiwgStaticHybridQueryOptions extends AiwgStaticSemanticQueryOptions, AiwgIndexQueryOptions {
+    lexicalWeight?: number;
+    semanticWeight?: number;
+}
+interface AiwgStaticDuplicatePair {
+    left: AiwgFortemiRecord;
+    right: AiwgFortemiRecord;
+    score: number;
+}
+interface AiwgReviewInput {
+    item_id: string;
+    action: AiwgReviewAction;
+    reason?: string;
+}
+interface AiwgIndexControllerSnapshot {
+    index: AiwgFortemiIndexExport | null;
+    chunked: {
+        manifest: AiwgFortemiChunkManifest;
+        cachedParts: number;
+        maxCachedParts: number;
+    } | null;
+    data: AiwgIndexQueryResult | null;
+    error: Error | null;
+    reviewDecisions: AiwgReviewDecision[];
+}
+type AiwgIndexControllerListener = (snapshot: AiwgIndexControllerSnapshot) => void;
+interface AiwgIndexController {
+    loadIndex(value: unknown): AiwgFortemiIndexExport;
+    loadChunkedIndex(manifest: unknown, loader: AiwgChunkedIndexLoader, options?: AiwgChunkedIndexLoadOptions): AiwgFortemiChunkManifest;
+    getIndex(): AiwgFortemiIndexExport | null;
+    getChunkedManifest(): AiwgFortemiChunkManifest | null;
+    getSnapshot(): AiwgIndexControllerSnapshot;
+    query(query?: string, options?: AiwgIndexQueryOptions): AiwgIndexQueryResult;
+    queryChunked(query?: string, options?: AiwgChunkedIndexQueryOptions): Promise<AiwgChunkedIndexQueryResult>;
+    getRecord(id: string): Promise<AiwgFortemiRecord>;
+    neighbors(id: string, options?: AiwgRelationshipTraversalOptions): Promise<AiwgRelationshipTraversalResult>;
+    relationshipQuery(options?: AiwgRelationshipQueryOptions): Promise<AiwgRelationshipTraversalResult>;
+    relationshipSet(options: AiwgRelationshipSetOptions): Promise<AiwgRelationshipSetResult>;
+    clearChunkCache(): void;
+    toCommunityGraph(options?: AiwgIndexGraphOptions): ReturnType<typeof aiwgFortemiIndexToCommunityGraph>;
+    toCommunityGraphChunked(options?: AiwgIndexGraphOptions & {
+        onProgress?: (progress: AiwgChunkedIndexProgress) => void;
+    }): Promise<ReturnType<typeof aiwgFortemiIndexToCommunityGraph>>;
+    setReviewDecision(input: AiwgReviewInput): AiwgReviewDecision;
+    clearReviewDecision(itemId: string): void;
+    createReviewDecisionExport(generatedAt?: string): AiwgReviewDecisionExport;
+    subscribe(listener: AiwgIndexControllerListener): () => void;
+}
+declare function validateAiwgFortemiIndexExport(value: unknown): AiwgIndexValidationResult;
+declare function assertAiwgFortemiIndexExport(value: unknown): AiwgFortemiIndexExport;
+declare function validateAiwgFortemiChunkManifest(value: unknown): AiwgChunkedIndexValidationResult;
+declare function assertAiwgFortemiChunkManifest(value: unknown): AiwgFortemiChunkManifest;
+declare function validateAiwgFortemiChunkPart(value: unknown, partRef?: AiwgFortemiChunkPartRef, manifest?: AiwgFortemiChunkManifest): AiwgChunkedIndexValidationResult;
+declare function assertAiwgFortemiChunkPart(value: unknown, partRef?: AiwgFortemiChunkPartRef, manifest?: AiwgFortemiChunkManifest): AiwgFortemiChunkPart;
+declare function createAiwgFetchChunkLoader(baseUrl?: string | URL): AiwgChunkedIndexLoader;
+declare function createAiwgFetchDetailLoader(baseUrl?: string | URL): AiwgChunkedIndexDetailLoader;
+declare function getAiwgFortemiFacets(items: AiwgFortemiRecord[]): Record<string, Record<string, number>>;
+declare function buildAiwgStaticEmbeddingSet(index: AiwgFortemiIndexExport, options: BuildAiwgStaticEmbeddingSetOptions): Promise<AiwgStaticEmbeddingSet>;
+interface AiwgChunkedIndexBuildOptions {
+    partSize?: number;
+    projection?: Array<keyof AiwgFortemiRecord>;
+    detailHref?: string;
+    idEncoding?: AiwgDetailIdEncoding;
+    generatedAt?: string;
+    /** Privacy filtering (SEC6). Default-safe: excludes `private`/`pii` records. */
+    privacy?: AiwgPrivacyFilterOptions;
+}
+interface AiwgChunkedIndexBuildResult {
+    manifest: AiwgFortemiChunkManifest;
+    parts: Array<{
+        href: string;
+        part: AiwgFortemiChunkPart;
+    }>;
+    details: Array<{
+        id: string;
+        href: string;
+        record: AiwgFortemiRecord;
+    }>;
+}
+declare function buildAiwgChunkedIndex(index: AiwgFortemiIndexExport, options?: AiwgChunkedIndexBuildOptions): AiwgChunkedIndexBuildResult;
+declare function queryAiwgFortemiIndex(index: AiwgFortemiIndexExport, query?: string, options?: AiwgIndexQueryOptions): AiwgIndexQueryResult;
+declare function validateAiwgStaticEmbeddingSet(value: unknown): AiwgChunkedIndexValidationResult;
+declare function assertAiwgStaticEmbeddingSet(value: unknown): AiwgStaticEmbeddingSet;
+declare function queryAiwgSemanticIndex(index: AiwgFortemiIndexExport, embeddingSet: AiwgStaticEmbeddingSet, queryEmbedding: number[], options?: AiwgStaticSemanticQueryOptions): AiwgStaticSemanticResult[];
+declare function queryAiwgHybridIndex(index: AiwgFortemiIndexExport, embeddingSet: AiwgStaticEmbeddingSet, query: string, queryEmbedding: number[], options?: AiwgStaticHybridQueryOptions): AiwgStaticSemanticResult[];
+declare function findAiwgStaticDuplicatePairs(index: AiwgFortemiIndexExport, embeddingSet: AiwgStaticEmbeddingSet, threshold?: number, options?: {
+    maxEmbeddings?: number;
+}): AiwgStaticDuplicatePair[];
+declare function createAiwgReviewDecisionExport(source: Pick<AiwgFortemiIndexExport, 'schema_version'>, decisions: AiwgReviewDecision[], generatedAt?: string): AiwgReviewDecisionExport;
+declare function createAiwgIndexController(initialIndex?: AiwgFortemiIndexExport): AiwgIndexController;
+declare function aiwgFortemiIndexToCommunityGraph(index: AiwgFortemiIndexExport, options?: AiwgIndexGraphOptions): {
+    nodes: {
+        id: string;
+    }[];
+    edges: {
+        source: string;
+        target: string;
+        kind: string;
+        weight: number;
+    }[];
+    communities: {
+        id: string;
+        nodes: string[];
+    }[];
+};
+/**
+ * Convert the static AIWG/Fortemi v2 index contract into a portable Knowledge
+ * Shard. Every note retains the complete source envelope and record in metadata,
+ * so the native note/link/SKOS/provenance projections are reversible.
+ */
+declare function aiwgFortemiIndexToKnowledgeShard(index: AiwgFortemiIndexExport, options?: AiwgKnowledgeShardOptions): Promise<Uint8Array>;
+/**
+ * Recover the exact AIWG index envelope and records embedded by
+ * {@link aiwgFortemiIndexToKnowledgeShard}.
+ */
+declare function aiwgFortemiIndexFromKnowledgeShard(bytes: Uint8Array): AiwgFortemiIndexExport;
+
+/**
+ * Canonical RecordStore contract — the writable structured-record layer that
+ * exists independently of PGlite (#323, ADR-013 D3).
+ *
+ * Records mirror the browser SQL rows one-to-one (same field names, ISO-8601
+ * timestamp strings) so the optional PGlite projection is a row-for-row
+ * replay of the change journal — rebuildable at any time without touching
+ * canonical records or attachment bytes.
+ */
+interface NoteRecord0 {
+    id: string;
+    archive_id: string | null;
+    title: string | null;
+    format: string;
+    source: string;
+    visibility: string;
+    revision_mode: string;
+    is_starred: boolean;
+    is_pinned: boolean;
+    is_archived: boolean;
+    created_at: string;
+    updated_at: string;
+    deleted_at: string | null;
+}
+interface NoteOriginalRecord {
+    id: string;
+    note_id: string;
+    content: string;
+    content_hash: string;
+    created_at: string;
+}
+interface NoteRevisedCurrentRecord {
+    /** Keyed by note id (mirrors the SQL PK `note_id`). */
+    id: string;
+    content: string;
+    ai_metadata: unknown | null;
+    generation_count: number;
+    model: string | null;
+    is_user_edited: boolean;
+    updated_at: string;
+}
+interface NoteTagRecord {
+    id: string;
+    note_id: string;
+    tag: string;
+    created_at: string;
 }
-declare function getAiwgFortemiIndexExportSchema(): unknown;
-declare function validateAiwgFortemiIndexExportSchema(value: unknown): AiwgIndexSchemaValidationResult;
-declare function validateAiwgFortemiProjectedRecordSchema(value: unknown): AiwgIndexSchemaValidationResult;
+interface LinkRecord0 {
+    id: string;
+    source_note_id: string;
+    target_note_id: string;
+    link_type: string;
+    created_at: string;
+    deleted_at: string | null;
+}
+interface CollectionRecord {
+    id: string;
+    name: string;
+    description: string | null;
+    created_at: string;
+    updated_at: string;
+    deleted_at: string | null;
+}
+interface CollectionNoteRecord {
+    id: string;
+    collection_id: string;
+    note_id: string;
+    created_at: string;
+}
+interface AttachmentRecord {
+    id: string;
+    note_id: string;
+    blob_id: string;
+    document_type_id: string | null;
+    mime_type: string | null;
+    extracted_text: string | null;
+    filename: string;
+    display_name: string | null;
+    position: number;
+    created_at: string;
+    deleted_at: string | null;
+}
+interface AttachmentBlobRecord {
+    id: string;
+    content_hash: string;
+    size_bytes: number;
+    created_at: string;
+}
+/** Collection name → record type. The store is generic over this map. */
+interface RecordCollections {
+    note: NoteRecord0;
+    note_original: NoteOriginalRecord;
+    note_revised_current: NoteRevisedCurrentRecord;
+    note_tag: NoteTagRecord;
+    link: LinkRecord0;
+    collection: CollectionRecord;
+    collection_note: CollectionNoteRecord;
+    attachment: AttachmentRecord;
+    attachment_blob: AttachmentBlobRecord;
+}
+type RecordCollectionName = keyof RecordCollections;
+declare const RECORD_COLLECTIONS: readonly RecordCollectionName[];
+/**
+ * One committed mutation. Journal entries carry the full record snapshot so
+ * the PGlite projection (and any other consumer) can replay mutations without
+ * re-reading canonical state, and so a rebuild has a total order to follow.
+ */
+interface JournalEntry {
+    /** Monotonically increasing commit sequence (assigned by the store). */
+    seq: number;
+    /** ISO-8601 commit timestamp. */
+    ts: string;
+    op: 'put' | 'delete';
+    collection: RecordCollectionName;
+    id: string;
+    /** Snapshot for `put`; absent for `delete`. */
+    record?: RecordCollections[RecordCollectionName];
+}
+/**
+ * What the canonical record tier can and cannot serve, reported explicitly
+ * (never emulated badly). Advanced capabilities may require the optional
+ * PGlite projection (ADR-013 D3).
+ */
+interface RecordStoreCapabilities {
+    crud: true;
+    journal: true;
+    /** Bounded substring scan over titles/content — not ranked FTS. */
+    boundedTextScan: true;
+    fullTextSearch: false;
+    vectorSearch: false;
+    sqlJoins: false;
+}
+declare const RECORD_STORE_CAPABILITIES: RecordStoreCapabilities;
+interface RecordListOptions {
+    /** Maximum records returned (applied after filtering). */
+    limit?: number;
+}
+/**
+ * The writable canonical structured-record store. Implementations MUST make
+ * each `put`/`remove` an atomic commit of the record mutation plus its
+ * journal entry (the recoverable commit protocol): a torn write leaves
+ * neither, never one without the other.
+ */
+interface RecordStore {
+    get<C extends RecordCollectionName>(collection: C, id: string): Promise<RecordCollections[C] | null>;
+    /** Insert or replace one record, journaled atomically. */
+    put<C extends RecordCollectionName>(collection: C, record: RecordCollections[C]): Promise<JournalEntry>;
+    /** Hard-remove one record, journaled atomically (soft-delete is a field upstream). */
+    remove(collection: RecordCollectionName, id: string): Promise<JournalEntry>;
+    /** All records of a collection (insertion order not guaranteed). */
+    list<C extends RecordCollectionName>(collection: C, opts?: RecordListOptions): Promise<RecordCollections[C][]>;
+    /** Journal entries with `seq > sinceSeq`, ascending. */
+    journalSince(sinceSeq: number, limit?: number): Promise<JournalEntry[]>;
+    /** Highest committed sequence (0 when empty). */
+    headSeq(): Promise<number>;
+    readonly capabilities: RecordStoreCapabilities;
+    close(): Promise<void>;
+}
+
+/**
+ * In-memory RecordStore — the test/SSR tier of the canonical record layer.
+ * Same commit semantics as the durable store: record + journal move together.
+ */
+
+declare class MemoryRecordStore implements RecordStore {
+    readonly capabilities: RecordStoreCapabilities;
+    private collections;
+    private journal;
+    private seq;
+    private table;
+    get<C extends RecordCollectionName>(collection: C, id: string): Promise<RecordCollections[C] | null>;
+    put<C extends RecordCollectionName>(collection: C, record: RecordCollections[C]): Promise<JournalEntry>;
+    remove(collection: RecordCollectionName, id: string): Promise<JournalEntry>;
+    list<C extends RecordCollectionName>(collection: C, opts?: RecordListOptions): Promise<RecordCollections[C][]>;
+    journalSince(sinceSeq: number, limit?: number): Promise<JournalEntry[]>;
+    headSeq(): Promise<number>;
+    close(): Promise<void>;
+}
+
+/**
+ * Durable canonical RecordStore over IndexedDB (#323, ADR-013 D3).
+ *
+ * One database per archive namespace: `fortemi-<archive>-records`. Object
+ * stores: one per record collection (keyPath `id`), plus `journal`
+ * (autoIncrement `seq`) and `meta` (schema version).
+ *
+ * Recoverable commit protocol (ADR-013 D5): every mutation writes the record
+ * change AND its journal entry in a single IndexedDB transaction, so a torn
+ * write commits neither. The journal `seq` is the total order the optional
+ * PGlite projection consumes.
+ *
+ * Schema evolution: `meta.schemaVersion` records the logical record-schema
+ * version; `migrate` hooks run inside the version-change transaction when the
+ * database structure grows. Additive-only, mirroring the SQL migration
+ * discipline.
+ */
+
+/** Logical record-schema version stored in `meta` (independent of DB_VERSION). */
+declare const RECORD_SCHEMA_VERSION = 1;
+interface CreateRecordStoreOptions {
+    /** Injectable factory for tests (fake-indexeddb). Defaults to the global. */
+    indexedDB?: IDBFactory;
+}
+declare class IdbRecordStore implements RecordStore {
+    private db;
+    readonly capabilities: RecordStoreCapabilities;
+    private constructor();
+    static open(archiveName: string, options?: CreateRecordStoreOptions): Promise<IdbRecordStore>;
+    private ensureSchemaVersion;
+    get<C extends RecordCollectionName>(collection: C, id: string): Promise<RecordCollections[C] | null>;
+    put<C extends RecordCollectionName>(collection: C, record: RecordCollections[C]): Promise<JournalEntry>;
+    remove(collection: RecordCollectionName, id: string): Promise<JournalEntry>;
+    list<C extends RecordCollectionName>(collection: C, opts?: RecordListOptions): Promise<RecordCollections[C][]>;
+    journalSince(sinceSeq: number, limit?: number): Promise<JournalEntry[]>;
+    headSeq(): Promise<number>;
+    close(): Promise<void>;
+}
+/** Open the durable canonical record store for one archive namespace. */
+declare function createRecordStore(archiveName: string, options?: CreateRecordStoreOptions): Promise<IdbRecordStore>;
+
+/**
+ * Canonical notes repository — DB-free note/tag/link/collection workflows
+ * over the RecordStore (#323). Mirrors the SQL repositories' semantics
+ * (UUIDv7 ids, immutable note_original, mutable note_revised_current,
+ * soft-delete everywhere) so the PGlite projection replay is row-for-row.
+ *
+ * Query tier: id/recent/tag/link/collection lookups plus a bounded substring
+ * text scan. Ranked FTS, vectors, and complex joins are explicitly NOT
+ * served here — `store.capabilities` reports the boundary (ADR-013 D3).
+ */
+
+interface CanonicalNoteCreateInput {
+    id?: string;
+    title?: string;
+    content: string;
+    format?: string;
+    source?: string;
+    visibility?: string;
+}
+interface CanonicalNoteUpdateInput {
+    title?: string;
+    content?: string;
+    is_starred?: boolean;
+    is_pinned?: boolean;
+    is_archived?: boolean;
+}
+interface CanonicalNoteView {
+    note: NoteRecord0;
+    original_content: string;
+    revised_content: string;
+    tags: string[];
+}
+declare class CanonicalNotesRepository {
+    private store;
+    constructor(store: RecordStore);
+    create(input: CanonicalNoteCreateInput): Promise<CanonicalNoteView>;
+    get(noteId: string): Promise<CanonicalNoteView | null>;
+    update(noteId: string, input: CanonicalNoteUpdateInput): Promise<CanonicalNoteView>;
+    /** Soft-delete: sets `deleted_at`; the record (and history) remains. */
+    softDelete(noteId: string): Promise<void>;
+    restore(noteId: string): Promise<void>;
+    /** Non-deleted notes, most recently updated first. */
+    listRecent(limit?: number): Promise<NoteRecord0[]>;
+    /**
+     * Bounded substring scan over title + revised content (case-insensitive).
+     * This is deliberately not ranked FTS — see `store.capabilities`.
+     */
+    searchText(query: string, limit?: number): Promise<NoteRecord0[]>;
+    addTag(noteId: string, tag: string): Promise<void>;
+    removeTag(noteId: string, tag: string): Promise<void>;
+    notesByTag(tag: string): Promise<NoteRecord0[]>;
+    createLink(sourceNoteId: string, targetNoteId: string, linkType?: string): Promise<LinkRecord0>;
+    softDeleteLink(linkId: string): Promise<void>;
+    /** Active links touching a note (either direction). */
+    linksOf(noteId: string): Promise<LinkRecord0[]>;
+    createCollection(name: string, description?: string): Promise<CollectionRecord>;
+    addNoteToCollection(collectionId: string, noteId: string): Promise<void>;
+    notesInCollection(collectionId: string): Promise<NoteRecord0[]>;
+}
+
+/**
+ * Canonical attachments repository — DB-free attachment manifests over the
+ * RecordStore, bytes through the Bytecask BlobStore (#323, ADR-013 D2/D4/D5).
+ *
+ * Same lifecycle semantics as the SQL-backed AttachmentsRepository: bytes
+ * first (idempotent put), then manifest commit; soft-delete never removes
+ * bytes inline; the manifest-derived live set drives reconcile/gc; missing
+ * bytes are the recoverable reference-only state.
+ */
+
+interface CanonicalAttachInput {
+    noteId: string;
+    data: Uint8Array;
+    filename: string;
+    mimeType?: string;
+    extractedText?: string;
+    displayName?: string;
+}
+declare class CanonicalAttachmentsRepository {
+    private store;
+    private blobStore;
+    constructor(store: RecordStore, blobStore: BlobStore);
+    /** Bytes-first attach (ADR-013 D5); dedupes on the store-computed hash. */
+    attach(input: CanonicalAttachInput): Promise<AttachmentRecord>;
+    get(id: string): Promise<AttachmentRecord>;
+    /** Null when bytes are absent — the recoverable reference-only state. */
+    getBlob(attachmentId: string): Promise<Uint8Array | null>;
+    hasBlob(attachmentId: string): Promise<boolean>;
+    list(noteId: string): Promise<AttachmentRecord[]>;
+    /** Soft-delete the manifest; bytes are only swept via reconcile/gc. */
+    delete(id: string): Promise<void>;
+    /** Authoritative live set: hashes referenced by non-deleted manifests. */
+    liveBlobChecksums(): Promise<string[]>;
+    /** Startup / post-quota reconciliation against canonical manifests (ADR-013 D4). */
+    reconcileBlobs(opts?: BlobReconcileOptions): Promise<BlobReconcileResult>;
+    /** Deferred reachability-based blob GC. */
+    gcBlobs(opts?: BlobGcOptions): Promise<BlobGcResult>;
+    private checksumOf;
+}
+
+/**
+ * PGlite attachment projection (#320, ADR-013 D3).
+ *
+ * Projects canonical attachment state (RecordStore) into the optional PGlite
+ * `attachment_blob` / `attachment` tables. Properties:
+ *
+ * - Idempotent: every row upserts on its primary key; re-running with the
+ *   same canonical state changes nothing.
+ * - Rebuildable: dropping the projection rows and re-projecting yields
+ *   equivalent query results — the canonical records are the source of truth.
+ * - Derived refcounts: `attachment_blob.reference_count` is recomputed from
+ *   live manifests on every projection pass; it is never lifecycle authority
+ *   and no trigger touches it.
+ * - Bytes never enter PGlite; only metadata is projected.
+ */
+
+interface AttachmentProjectionResult {
+    blobs: number;
+    attachments: number;
+}
+/**
+ * Project all canonical attachment records into PGlite. Safe to run at any
+ * time: startup, after journal consumption, or as a full rebuild after the
+ * projection was dropped.
+ *
+ * The parent `note` rows must already exist in the projection (note
+ * projection is the #323 cycle-2 surface); this function owns only the
+ * attachment tables.
+ */
+declare function projectAttachments(db: DatabaseClient, store: RecordStore): Promise<AttachmentProjectionResult>;
+/**
+ * Drop the attachment projection rows (test/rebuild support). Canonical
+ * records and Bytecask bytes are untouched — this is the "PGlite can be
+ * dropped and rebuilt" invariant made executable.
+ */
+declare function dropAttachmentProjection(db: DatabaseClient): Promise<void>;
 
-declare const VERSION = "2026.7.4";
+declare const VERSION = "2026.7.7";
 
-export { type AiwgIndexSchemaValidationResult, type ArchiveInfo, ArchiveManager, type AttachInput, type AttachmentBlobRow, 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, BlobStore, type BridgeCapability, type BridgeProviderInfo, type BrowserNoteExport, CURRENT_MIGRATION_HEAD, type CapabilityInfo, CapabilityManager, type CapabilityName, type CapabilityState, type CaptureKnowledgeInput, CaptureKnowledgeInputSchema, type CaptureKnowledgeResult, type CollectionCreateInput, 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 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, 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, ImportOptions, ImportResult, type InferenceCapabilities, type InferenceProvider, JOB_CAPABILITIES, JOB_PRIORITIES, type JobQueueOptions, JobQueueWorker, type JobStatus, type JobType, LOCAL_ENDPOINTS, 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, type Migration, MigrationRunner, type ModelCategory, type ModelFitResult, type ModelInfo, type NoteCreateInput, type NoteFull, type NoteListOptions, type NoteRevision, type NoteSkosTag, type NoteSummary, 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 ProbeResult, type ProbeStatus, type ProvenanceEdge, ProvenanceRepository, type ProviderCapabilities, ProviderRegistry, type ProviderTier, type QueryExecutor, type QueryResult, type RecommendedTier, type RecordProvenanceInput, 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, type ShardBackendOptions, ShardCollection, ShardComponent, type ShardComponentStore, ShardEmbedding, ShardEmbeddingConfig, ShardEmbeddingSet, ShardEmbeddingSetMember, ShardLink, type ShardListOptions, ShardManifest, ShardNote, type ShardNoteFull, ShardNoteSkosTag, 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, createRemoteBackend, createRoutes, createShardBackend, createWorkerEmbedFunction, defaultStorageBackendFactory, detectCommunities, detectGpuCapabilities, detectInferenceCapabilities, discoverLocalProviders, dumpDbSnapshot, embeddingConfigToShard, embeddingFromShard, embeddingGenerationHandler, embeddingSetFromShard, embeddingSetMemberToShard, embeddingSetToShard, embeddingToShard, enqueueFullWorkflow, enqueueJob, enqueueNoteCreationJobs, estimateModelFit, estimateVramMB, estimateVramTier, exportShard, fetchAndValidateFortemiCompatibility, fetchPluginScript, formatFortemiCompatibilitySummary, fortemiCompatibilityUrl, fortemiManifest, fromPrefetched, generateId, getAiwgFortemiIndexExportSchema, getEmbedFunction, getFortemiBridge, getFortemiSecretStore, getJobQueueStatus, getKnowledgeShardSchema, getLlmFunction, getNote, getPrefetchedSha256, handleEmbedRequests, hasFortemiSecureSecrets, importShard, isPluginScriptAllowed, isShardPrefetched, linkFromShard, linkToShard, linkingHandler, listNotes, manageArchive, manageAttachments, manageCapabilities, manageCollections, manageLinks, manageNote, manageTags, matchRoute, noteFromShard, noteSkosTagToShard, noteToShard, openShard, packTarGz, parseCspReport, prefetchShard, provenanceEdgeToShard, registerLlmCapability, registerSemanticCapability, registerSemanticCapabilityWorker, registerServiceWorker, restoreDbSnapshot, searchTool, selectBackend, selectLlmModel, setEmbedFunction, setLlmFunction, sha256Hex, skosConceptToShard, skosRelationToShard, skosSchemeToShard, suggestTags, tagsToShard, templateToShard, titleGenerationHandler, unpackTarGz, unregisterLlmCapability, unregisterSemanticCapability, urlLinkToShard, validateAiwgFortemiIndexExportSchema, validateAiwgFortemiProjectedRecordSchema, validateChecksums, validateFortemiCompatibilityResponse, validateShardArchive, validateShardComponentRecord, validateShardManifest, verifyDbSnapshotMeta, verifySri };
+export { AIWG_SCAN_REQUIRED_FIELDS, type AiwgChunkedIndexBuildOptions, type AiwgChunkedIndexBuildResult, type AiwgChunkedIndexDetailLoader, type AiwgChunkedIndexLoadOptions, type AiwgChunkedIndexLoader, type AiwgChunkedIndexProgress, type AiwgChunkedIndexProgressPhase, type AiwgChunkedIndexQueryOptions, type AiwgChunkedIndexQueryResult, type AiwgChunkedIndexValidationResult, type AiwgFortemiAttachmentReference, type AiwgFortemiBinarySource, type AiwgFortemiChunk, type AiwgFortemiChunkDetailRef, type AiwgFortemiChunkManifest, type AiwgFortemiChunkPart, type AiwgFortemiChunkPartRef, type AiwgFortemiIndexExport, type AiwgFortemiIndexExportSchemaVersion, type AiwgFortemiProjectedRecord, type AiwgFortemiProvenance, type AiwgFortemiProvenanceEvent, type AiwgFortemiRecord, type AiwgFortemiRecordEmbedding, type AiwgFortemiRecordSchemaVersion, type AiwgFortemiRecordSource, type AiwgFortemiRecordType, type AiwgFortemiRelationship, type AiwgFortemiRelationshipDirection, type AiwgFortemiSearchProjection, type AiwgFortemiSkosConcept, type AiwgFortemiSkosRelation, type AiwgFortemiSkosRelationType, type AiwgHeadlessEmbeddingBackend, type AiwgIndexController, type AiwgIndexControllerListener, type AiwgIndexControllerSnapshot, type AiwgIndexGraphOptions, type AiwgIndexQueryMatch, type AiwgIndexQueryOptions, type AiwgIndexQueryRankedItem, type AiwgIndexQueryResult, type AiwgIndexQueryWeights, type AiwgIndexValidationResult, type AiwgKnowledgeShardOptions, type AiwgPrivacyClassification, type AiwgPrivacyFilterOptions, type AiwgProvenanceConfidence, type AiwgRelationshipDirection, type AiwgRelationshipEdgeSummary, type AiwgRelationshipNodeSummary, type AiwgRelationshipQueryOptions, type AiwgRelationshipSetOperation, type AiwgRelationshipSetOptions, type AiwgRelationshipSetResult, type AiwgRelationshipTraversalOptions, type AiwgRelationshipTraversalResult, type AiwgReviewAction, type AiwgReviewDecision, type AiwgReviewDecisionExport, type AiwgReviewInput, type AiwgStaticDuplicatePair, type AiwgStaticEmbeddingRecord, type AiwgStaticEmbeddingSet, type AiwgStaticHybridQueryOptions, type AiwgStaticSemanticQueryOptions, type AiwgStaticSemanticResult, AllowlistTrustStore, 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, type BlobBackendKind, type BlobGcOptions, type BlobGcResult, type BlobReconcileOptions, type BlobReconcileResult, type BlobStore, type BlobStoreDiagnostics, type BridgeCapability, type BridgeProviderInfo, type BrowserNoteExport, type BuildAiwgStaticEmbeddingSetOptions, CURRENT_MIGRATION_HEAD, CURRENT_SHARD_VERSION, 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 ConflictStrategy, type CooldownConfig, type CooldownEvent, type CosineSemanticProviderOptions, type CreateBlobStoreOptions, 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, type ExportOptions, FORTEMI_COMPATIBILITY_PATH, FORTEMI_COMPATIBILITY_STATES, FORTEMI_REQUIRED_COMPATIBILITY_CAPABILITIES, 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, type ImportCounts, type ImportOptions, type ImportProgress, type ImportProgressPhase, type 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, MemoryBlobStore, MemoryRecordStore, type Migration, MigrationRunner, type ModelCategory, type ModelFitResult, type ModelInfo, type NoteCreateInput, type NoteFull, type NoteListOptions, type NoteOriginalRecord, 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 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 RecordCollectionName, type RecordCollections, type RecordListOptions, type RecordProvenanceInput, type RecordStore, type RecordStoreCapabilities, type RemoteBackendConfig, type RemoteBackendPaths, type ResolvedEmbeddingRow, type ResolvedEmbeddingSet, type RestoreDbSnapshotOptions, type RouteHandler, SHARD_FORMAT, SIGNATURE_ENTRY, SIGNING_ENVELOPE_VERSION, SUPPORTED_PGLITE_VERSION, type SWRegistrationResult, type SearchFacets, type SearchInput, SearchInputSchema, type SearchOptions, SearchRepository, type SearchResponse, type SearchResult, type ShardBackendOptions, type ShardClusterRef, type ShardCollection, type ShardComponent, type ShardComponentStore, type ShardEmbedding, type ShardEmbeddingConfig, type ShardEmbeddingSet, type ShardEmbeddingSetMember, type ShardLayout, type ShardLink, type ShardListOptions, type ShardManifest, type ShardNote, type ShardNoteFull, type ShardNoteSkosTag, type ShardProvenanceEdge, type ShardReader, type ShardReaderNote, type ShardReaderSource, type ShardSchemaValidationResult, type ShardSearchOptions, type ShardSearchRankedNote, type ShardSearchResult, type ShardSearchWeights, type ShardSignatureEnvelope, type ShardSignatureVerdict, type ShardSigner, type ShardSigningPayload, type ShardSkosConcept, type ShardSkosRelation, type ShardSkosScheme, type ShardTag, type ShardTemplate, type ShardTrustStore, type SignShardInput, 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, type TrustedKey, TypedEventBus, VERSION, type VectorEntry, type VerifyShardSignatureInput, type VirtualEmbeddingSetDefinition, type VirtualEmbeddingSetSource, type VirtualEmbeddingSetValidationError, type VirtualMaterializationPolicy, type VramTier, type WorkerRequest, type WorkerResponse, aiRevisionHandler, aiwgFortemiIndexFromKnowledgeShard, aiwgFortemiIndexToCommunityGraph, aiwgFortemiIndexToKnowledgeShard, allMigrations, appendPluginScript, assertAiwgFortemiChunkManifest, assertAiwgFortemiChunkPart, assertAiwgFortemiIndexExport, assertAiwgStaticEmbeddingSet, assertShardComponentRecord, buildAiwgChunkedIndex, buildAiwgStaticEmbeddingSet, buildNoteConditions, buildPluginCsp, captureKnowledge, chunkText, classifyError, classifyModel, clearPrefetchedShard, collectionFromShard, collectionToShard, computeBlobHash, computeHash, computeSri, conceptTaggingHandler, cosineSimilarity, createAiwgFetchChunkLoader, createAiwgFetchDetailLoader, createAiwgIndexController, createAiwgReviewDecisionExport, createBlobStore, createCosineSemanticProvider, createCspReportHandler, createFortemi, createLazyBlobStore, createLegacyProvider, createPGliteBackend, createPGliteInstance, createRecordStore, createRemoteBackend, createRoutes, createShardBackend, createWorkerEmbedFunction, defaultStorageBackendFactory, detectCommunities, detectGpuCapabilities, detectInferenceCapabilities, discoverLocalProviders, dropAttachmentProjection, dumpDbSnapshot, embeddingConfigToShard, embeddingFromShard, embeddingGenerationHandler, embeddingSetFromShard, embeddingSetMemberToShard, embeddingSetToShard, embeddingToShard, enqueueFullWorkflow, enqueueJob, enqueueNoteCreationJobs, estimateModelFit, estimateVramMB, estimateVramTier, exportShard, fetchAndValidateFortemiCompatibility, fetchPluginScript, filterAiwgRecordsByPrivacy, findAiwgStaticDuplicatePairs, formatFortemiCompatibilitySummary, fortemiCompatibilityUrl, fortemiManifest, fromPrefetched, generateId, getAiwgFortemiFacets, getEmbedFunction, getFortemiBridge, getFortemiSecretStore, getJobQueueStatus, getKnowledgeShardSchema, getLlmFunction, getNote, getPrefetchedSha256, handleEmbedRequests, hasFortemiSecureSecrets, importShard, isPluginScriptAllowed, isShardPrefetched, isShardSigningSupported, linkFromShard, linkToShard, linkingHandler, listNotes, manageArchive, manageAttachments, manageCapabilities, manageCollections, manageLinks, manageNote, manageTags, matchRoute, migrateLegacyBlobStore, noteFromShard, noteSkosTagToShard, noteToShard, openShard, packTarGz, parseCspReport, prefetchShard, projectAttachments, provenanceEdgeToShard, queryAiwgFortemiIndex, queryAiwgHybridIndex, queryAiwgSemanticIndex, registerLlmCapability, registerSemanticCapability, registerSemanticCapabilityWorker, registerServiceWorker, restoreDbSnapshot, searchTool, selectBackend, selectLlmModel, setEmbedFunction, setLlmFunction, sha256Hex, sidecarBlobDigests, signShard, skosConceptToShard, skosRelationToShard, skosSchemeToShard, suggestTags, tagsToShard, templateToShard, titleGenerationHandler, unpackTarGz, unregisterLlmCapability, unregisterSemanticCapability, urlLinkToShard, validateAiwgFortemiChunkManifest, validateAiwgFortemiChunkPart, validateAiwgFortemiIndexExport, validateAiwgStaticEmbeddingSet, validateChecksums, validateFortemiCompatibilityResponse, validateShardArchive, validateShardComponentRecord, validateShardManifest, verifyDbSnapshotMeta, verifyShardSignature, verifySri };