@fortemi/core 2026.7.11 → 2026.7.13

package/dist/aiwg-index-shard-BhF8kKAU.d.ts

@@ -0,0 +1,1210 @@
+import { ProbeReport } from '@bytecask/core';
+
+/**
+ * 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>;
+    /**
+     * Physically remove one checksum. Import staging uses this only to roll back
+     * content that was absent before promotion.
+     */
+    delete?(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>;
+    delete(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.
+ *
+ * @implements @.aiwg/adrs/ADR-011-shard-server-conformance-and-version-negotiation.md
+ * @schema @packages/core/schemas/knowledge-shard.schema.receipt.json
+ * @created 2026-07-17
+ * @agent Codex
+ */
+
+declare const CURRENT_SHARD_VERSION = "1.2.0";
+declare const SHARD_FORMAT = "matric-shard";
+/** Components that can appear in a shard archive. */
+type ShardComponent = 'notes' | 'collections' | 'tags' | 'templates' | 'links' | 'note_originals' | 'note_original_history' | 'note_revised_current' | 'note_revisions' | 'embedding_sets' | 'embedding_configs' | 'embedding_set_members' | 'embeddings' | 'provenance_activities' | 'named_locations' | 'provenance_locations' | 'provenance_devices' | 'provenance_records' | 'skos_schemes' | 'skos_concepts' | 'skos_labels' | 'skos_notes' | 'skos_relations' | 'skos_mapping_relations' | 'skos_scheme_memberships' | 'note_skos_tags' | 'skos_collections' | 'skos_collection_members' | 'provenance_edges' | 'community_assignments' | 'communities' | 'graph_edges' | 'graph_sources';
+type KnowledgeShardProfile = 'core-v1' | 'full-v1' | 'record-v1';
+type ShardBackend = 'pglite' | 'record-store';
+type ShardOperation = 'export' | 'import';
+type ShardAuthorityStatus = 'supported' | 'candidate' | 'reserved' | 'unknown' | 'unprofiled';
+interface ShardProfileRegistryEntry {
+    profile: KnowledgeShardProfile;
+    authority_status: 'supported' | 'candidate' | 'reserved';
+    components: ShardComponent[];
+}
+interface ShardLossEntry {
+    code: string;
+    message: string;
+    component?: ShardComponent;
+    count?: number;
+    record_id?: string;
+    field_path?: string;
+    source_state?: 'absent' | 'null' | 'empty' | 'value' | 'legacy-indeterminate';
+    destination_capability?: string;
+    action?: 'reject' | 'omit' | 'default' | 'degrade';
+    reason?: string;
+}
+interface ShardCapabilityReport {
+    schema_version: 'fortemi.shard.capability-report.v1';
+    backend: ShardBackend;
+    operation: ShardOperation;
+    requested_profile: string | null;
+    requested_schema_version: string | null;
+    authority_status: ShardAuthorityStatus;
+    backend_supported: boolean;
+    portable: boolean;
+    authority: {
+        repository: string;
+        commit: string;
+        contract_sha256: string;
+        contract_revision: string;
+        schema_version: string;
+        schema_bundle_sha256: string;
+    };
+    advertised_profiles: KnowledgeShardProfile[];
+    supported_components: ShardComponent[];
+    declared_components: ShardComponent[];
+    unsupported_components: ShardComponent[];
+    omitted_components: ShardComponent[];
+    losses: ShardLossEntry[];
+}
+interface ShardAttachmentReference {
+    id: string;
+    path: string;
+    mime: string | null;
+    checksum: string;
+    bytes: number;
+}
+interface ShardAttachmentProjection {
+    extracted_text: string | null;
+    /** Legacy unprofiled relationship timestamp; outside core-v1. */
+    created_at?: string;
+    /** Legacy unprofiled attachment tombstone; outside core-v1. */
+    deleted_at?: string | null;
+    extraction_status?: 'extracted' | 'pending' | 'failed' | 'blocked' | 'deferred';
+    reason?: null | 'extraction_pending' | 'extractor_failed' | 'quarantined' | 'large_binary' | 'unsupported_mime' | 'no_extracted_text';
+    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 ShardProducer {
+    name: string;
+    version: string;
+    revision?: string;
+}
+interface ShardManifest {
+    version: string;
+    /** Named server-owned portability profile. Required for canonical interchange. */
+    profile?: string;
+    /** Structured producer identity used by canonical profiles. */
+    producer?: ShardProducer;
+    /** @deprecated Legacy producer release field. */
+    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 {
+    /**
+     * Explicit portability profile. Only profiles advertised by the selected
+     * producer are accepted. Omit to retain the legacy unprofiled React archive.
+     */
+    profile?: string;
+    /** Explicit authority schema tuple; 2.0.0 is opt-in until matrix receipts pass. */
+    schemaVersion?: '1.2.0' | '2.0.0';
+    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;
+    /** Optional Ed25519 publisher envelope for newly produced archives. */
+    signing?: {
+        keyId: string;
+        privateKey: CryptoKey;
+        publicKey: string;
+    };
+}
+/** 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 promoted before
+     * the logical transaction. A transaction failure removes only bytes that
+     * were absent before promotion. Stores without the optional `delete`
+     * capability fail before promotion. Absent → reference-only metadata.
+     */
+    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;
+    capability_report: ShardCapabilityReport;
+    /** Complete manifest counts when a profile contains components outside legacy counters. */
+    component_counts?: ShardManifest['counts'];
+}
+interface ShardExportResult {
+    success: boolean;
+    archive: Uint8Array | null;
+    errors: string[];
+    capability_report: ShardCapabilityReport;
+}
+/** Note as serialized in the shard JSONL. */
+interface ShardNote {
+    id: string;
+    title: string | null;
+    original_content: string;
+    revised_content: string | null;
+    metadata?: unknown;
+    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;
+    /** Schema 1.1 core-v1 tombstone; legacy unprofiled archives also carry it. */
+    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;
+    /** Legacy unprofiled fields; outside core-v1. */
+    updated_at?: string;
+    deleted_at?: string | null;
+    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?: unknown;
+}
+/**
+ * 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;
+    };
+}
+
+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>;
+}
+interface AiwgFortemiAttachmentReference {
+    id: string;
+    path: string;
+    mime: string | null;
+    checksum: string;
+    bytes: number;
+}
+interface AiwgFortemiBinarySource {
+    extracted_text: string | null;
+    created_at?: string;
+    deleted_at?: string | null;
+    extraction_status?: 'extracted' | 'pending' | 'failed' | 'blocked' | 'deferred';
+    reason?: null | 'extraction_pending' | 'extractor_failed' | 'quarantined' | 'large_binary' | 'unsupported_mime' | 'no_extracted_text';
+    attachment: AiwgFortemiAttachmentReference;
+}
+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 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[];
+    }[];
+};
+
+interface AiwgFullV1ConversionResult {
+    success: boolean;
+    archive: Uint8Array | null;
+    profile: 'full-v1';
+    schema_version: '2.0.0';
+    /** Structural validity is separate from semantic losslessness. */
+    lossless: boolean;
+    losses: ShardLossEntry[];
+    receipt: {
+        schema_version: 'fortemi.aiwg-full-v1-conversion-receipt.v1';
+        source_schema_version: 'aiwg.fortemi.index.export.v2';
+        authority_repository: string;
+        authority_commit: string;
+        authority_contract_sha256: string;
+        authority_schema_bundle_sha256: string;
+        manifest_sha256: string | null;
+        component_checksums: Record<string, string>;
+        contract_valid: boolean;
+        signed: false;
+    };
+}
+
+interface AiwgKnowledgeShardOptions {
+    createdAt?: string;
+    matricVersion?: string;
+    /** Use the report-bearing entry point for rich conversion. */
+    includeNativeRichComponents?: boolean;
+}
+type AiwgKnowledgeShardConversionResult = AiwgFullV1ConversionResult;
+/**
+ * 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>;
+/** Convert AIWG v2 into exact 2.0.0/full-v1 with mandatory loss evidence. */
+declare function aiwgFortemiIndexToKnowledgeShardWithReport(index: AiwgFortemiIndexExport, options?: Omit<AiwgKnowledgeShardOptions, 'includeNativeRichComponents'>): Promise<AiwgKnowledgeShardConversionResult>;
+/**
+ * Recover the exact AIWG index envelope and records embedded by
+ * {@link aiwgFortemiIndexToKnowledgeShard}.
+ */
+declare function aiwgFortemiIndexFromKnowledgeShard(bytes: Uint8Array): AiwgFortemiIndexExport;
+
+export { type AiwgFortemiProvenanceEvent as $, type ImportResult as A, type BlobStore as B, AIWG_SCAN_REQUIRED_FIELDS as C, type AiwgChunkedIndexBuildOptions as D, type ExportOptions as E, type AiwgChunkedIndexBuildResult as F, type AiwgChunkedIndexDetailLoader as G, type AiwgChunkedIndexLoadOptions as H, type ImportOptions as I, type AiwgChunkedIndexLoader as J, type AiwgChunkedIndexProgress as K, type AiwgChunkedIndexProgressPhase as L, type AiwgChunkedIndexQueryOptions as M, type AiwgChunkedIndexQueryResult as N, type AiwgChunkedIndexValidationResult as O, type AiwgFortemiAttachmentReference as P, type AiwgFortemiBinarySource as Q, type AiwgFortemiChunk as R, type ShardAttachmentProjection as S, type AiwgFortemiChunkDetailRef as T, type AiwgFortemiChunkManifest as U, type AiwgFortemiChunkPart as V, type AiwgFortemiChunkPartRef as W, type AiwgFortemiIndexExport as X, type AiwgFortemiIndexExportSchemaVersion as Y, type AiwgFortemiProjectedRecord as Z, type AiwgFortemiProvenance as _, type ShardCollection as a, type ShardLayout as a$, type AiwgFortemiRecord as a0, type AiwgFortemiRecordEmbedding as a1, type AiwgFortemiRecordSchemaVersion as a2, type AiwgFortemiRecordSource as a3, type AiwgFortemiRecordType as a4, type AiwgFortemiRelationship as a5, type AiwgFortemiRelationshipDirection as a6, type AiwgFortemiSearchProjection as a7, type AiwgFortemiSkosConcept as a8, type AiwgFortemiSkosRelation as a9, type AiwgReviewAction as aA, type AiwgReviewDecision as aB, type AiwgReviewDecisionExport as aC, type AiwgReviewInput as aD, type AiwgStaticDuplicatePair as aE, type AiwgStaticEmbeddingRecord as aF, type AiwgStaticEmbeddingSet as aG, type AiwgStaticHybridQueryOptions as aH, type AiwgStaticSemanticQueryOptions as aI, type AiwgStaticSemanticResult as aJ, AllowlistTrustStore as aK, type BlobBackendKind as aL, type BlobStoreDiagnostics as aM, type BuildAiwgStaticEmbeddingSetOptions as aN, CURRENT_SHARD_VERSION as aO, type ConflictStrategy as aP, type CreateBlobStoreOptions as aQ, type ImportCounts as aR, type ImportProgress as aS, type ImportProgressPhase as aT, type KnowledgeShardProfile as aU, MemoryBlobStore as aV, SHARD_FORMAT as aW, SIGNATURE_ENTRY as aX, SIGNING_ENVELOPE_VERSION as aY, type ShardAuthorityStatus as aZ, type ShardClusterRef as a_, type AiwgFortemiSkosRelationType as aa, type AiwgHeadlessEmbeddingBackend as ab, type AiwgIndexController as ac, type AiwgIndexControllerListener as ad, type AiwgIndexControllerSnapshot as ae, type AiwgIndexGraphOptions as af, type AiwgIndexQueryMatch as ag, type AiwgIndexQueryOptions as ah, type AiwgIndexQueryRankedItem as ai, type AiwgIndexQueryResult as aj, type AiwgIndexQueryWeights as ak, type AiwgIndexValidationResult as al, type AiwgKnowledgeShardConversionResult as am, type AiwgKnowledgeShardOptions as an, type AiwgPrivacyClassification as ao, type AiwgPrivacyFilterOptions as ap, type AiwgProvenanceConfidence as aq, type AiwgRelationshipDirection as ar, type AiwgRelationshipEdgeSummary as as, type AiwgRelationshipNodeSummary as at, type AiwgRelationshipQueryOptions as au, type AiwgRelationshipSetOperation as av, type AiwgRelationshipSetOptions as aw, type AiwgRelationshipSetResult as ax, type AiwgRelationshipTraversalOptions as ay, type AiwgRelationshipTraversalResult as az, type ShardEmbeddingConfig as b, type ShardSignatureEnvelope as b0, type ShardSignatureVerdict as b1, type ShardSigner as b2, type ShardSigningPayload as b3, type ShardTrustStore as b4, type SignShardInput as b5, type TrustedKey as b6, type VerifyShardSignatureInput as b7, aiwgFortemiIndexFromKnowledgeShard as b8, aiwgFortemiIndexToCommunityGraph as b9, validateAiwgStaticEmbeddingSet as bA, verifyShardSignature as bB, aiwgFortemiIndexToKnowledgeShard as ba, aiwgFortemiIndexToKnowledgeShardWithReport as bb, assertAiwgFortemiChunkManifest as bc, assertAiwgFortemiChunkPart as bd, assertAiwgFortemiIndexExport as be, assertAiwgStaticEmbeddingSet as bf, buildAiwgChunkedIndex as bg, buildAiwgStaticEmbeddingSet as bh, createAiwgFetchChunkLoader as bi, createAiwgFetchDetailLoader as bj, createAiwgIndexController as bk, createAiwgReviewDecisionExport as bl, createBlobStore as bm, createLazyBlobStore as bn, filterAiwgRecordsByPrivacy as bo, findAiwgStaticDuplicatePairs as bp, getAiwgFortemiFacets as bq, isShardSigningSupported as br, queryAiwgFortemiIndex as bs, queryAiwgHybridIndex as bt, queryAiwgSemanticIndex as bu, sidecarBlobDigests as bv, signShard as bw, validateAiwgFortemiChunkManifest as bx, validateAiwgFortemiChunkPart as by, validateAiwgFortemiIndexExport as bz, type ShardEmbedding as c, type ShardEmbeddingSet as d, type ShardEmbeddingSetMember as e, type ShardLink as f, type ShardNote as g, type ShardNoteSkosTag as h, type ShardProvenanceEdge as i, type ShardSkosConcept as j, type ShardSkosRelation as k, type ShardSkosScheme as l, type ShardTag as m, type ShardTemplate as n, type ShardManifest as o, type BlobReconcileOptions as p, type BlobReconcileResult as q, type BlobGcOptions as r, type BlobGcResult as s, type ShardBackend as t, type ShardOperation as u, type ShardComponent as v, type ShardLossEntry as w, type ShardCapabilityReport as x, type ShardProfileRegistryEntry as y, type ShardExportResult as z };