@fortemi/core 2026.7.3 → 2026.7.5

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { PGlite } from '@electric-sql/pglite';
 import { z, ZodType } from 'zod';
-export { AIWG_SCAN_REQUIRED_FIELDS, AiwgChunkedIndexBuildOptions, AiwgChunkedIndexBuildResult, AiwgChunkedIndexDetailLoader, AiwgChunkedIndexLoadOptions, AiwgChunkedIndexLoader, AiwgChunkedIndexProgress, AiwgChunkedIndexProgressPhase, AiwgChunkedIndexQueryOptions, AiwgChunkedIndexQueryResult, AiwgChunkedIndexValidationResult, AiwgFortemiAttachmentReference, AiwgFortemiBinarySource, AiwgFortemiChunk, AiwgFortemiChunkDetailRef, AiwgFortemiChunkManifest, AiwgFortemiChunkPart, AiwgFortemiChunkPartRef, AiwgFortemiIndexExport, AiwgFortemiIndexExportSchemaVersion, AiwgFortemiKnownRecordType, AiwgFortemiProjectedRecord, AiwgFortemiProvenance, AiwgFortemiProvenanceEvent, AiwgFortemiRecord, AiwgFortemiRecordEmbedding, AiwgFortemiRecordSchemaVersion, AiwgFortemiRecordSource, AiwgFortemiRecordType, AiwgFortemiRelationship, AiwgFortemiRelationshipDirection, AiwgFortemiSearchProjection, AiwgFortemiSkosConcept, AiwgFortemiSkosRelation, AiwgFortemiSkosRelationType, AiwgHeadlessEmbeddingBackend, AiwgIndexController, AiwgIndexControllerListener, AiwgIndexControllerSnapshot, AiwgIndexGraphOptions, AiwgIndexQueryMatch, AiwgIndexQueryOptions, AiwgIndexQueryRankedItem, AiwgIndexQueryResult, AiwgIndexQueryWeights, AiwgIndexValidationResult, AiwgPrivacyClassification, AiwgPrivacyFilterOptions, AiwgProvenanceConfidence, AiwgRelationshipDirection, AiwgRelationshipEdgeSummary, AiwgRelationshipNodeSummary, AiwgRelationshipQueryOptions, AiwgRelationshipSetOperation, AiwgRelationshipSetOptions, AiwgRelationshipSetResult, AiwgRelationshipTraversalOptions, AiwgRelationshipTraversalResult, AiwgReviewAction, AiwgReviewDecision, AiwgReviewDecisionExport, AiwgReviewInput, AiwgStaticDuplicatePair, AiwgStaticEmbeddingRecord, AiwgStaticEmbeddingSet, AiwgStaticHybridQueryOptions, AiwgStaticSemanticQueryOptions, AiwgStaticSemanticResult, BuildAiwgStaticEmbeddingSetOptions, aiwgFortemiIndexToCommunityGraph, assertAiwgFortemiChunkManifest, assertAiwgFortemiChunkPart, assertAiwgFortemiIndexExport, assertAiwgStaticEmbeddingSet, buildAiwgChunkedIndex, buildAiwgStaticEmbeddingSet, createAiwgFetchChunkLoader, createAiwgFetchDetailLoader, createAiwgIndexController, createAiwgReviewDecisionExport, filterAiwgRecordsByPrivacy, findAiwgStaticDuplicatePairs, getAiwgFortemiFacets, queryAiwgFortemiIndex, queryAiwgHybridIndex, queryAiwgSemanticIndex, validateAiwgFortemiChunkManifest, validateAiwgFortemiChunkPart, validateAiwgFortemiIndexExport, validateAiwgStaticEmbeddingSet } from './aiwg-index.js';
+export { AiwgIndexSchemaValidationResult, getAiwgFortemiIndexExportSchema, validateAiwgFortemiIndexExportSchema, validateAiwgFortemiProjectedRecordSchema } from './aiwg-index-schema.js';
 
 /**
  * Generate a RFC 9562 UUIDv7 identifier.
@@ -128,6 +128,12 @@ declare class TypedEventBus {
  * PGlite database factory.
  * Enforces PGlite 0.4.x conventions (explicit database: 'postgres').
  * Selects persistence adapter based on config.
+ *
+ * PGlite is loaded LAZILY via dynamic `import()` inside `createPGliteInstance`
+ * (issue #261) — the top-level import is type-only so the emitted `dist/index.js`
+ * carries no static `import '@electric-sql/pglite'`. Consumers that never boot a
+ * PGlite-backed store therefore do not pull the WASM engine into their bundle,
+ * and `@electric-sql/pglite` is an OPTIONAL dependency of `@fortemi/core`.
  */
 
 type PersistenceMode = 'opfs' | 'idb' | 'memory';
@@ -356,6 +362,13 @@ declare class PGliteStorageBackend implements StorageBackend {
 declare class PGliteStorageBackendFactory implements StorageBackendFactory {
     open(input: StorageOpenRequest): Promise<StorageBackend>;
 }
+/**
+ * Built-in PGlite backend factory — the opt-in default (issue #261). PGlite is
+ * loaded lazily by `createPGliteInstance` on first `open()`, so referencing
+ * this constant does not force the WASM engine into a consumer's static graph.
+ * Hosts wanting a different store pass their own `StorageBackendFactory` to
+ * `ArchiveManager` instead.
+ */
 declare const defaultStorageBackendFactory: PGliteStorageBackendFactory;
 declare class PGliteWorkerStorageBackend implements StorageBackend {
     readonly id: string;
@@ -376,16 +389,47 @@ declare class PGliteWorkerStorageBackendFactory implements StorageBackendFactory
     open(input: StorageOpenRequest): Promise<StorageBackend>;
 }
 
+/**
+ * Content-addressable blob storage.
+ *
+ * Path format: blobs/{dir1}/{dir2}/{hash}
+ *   dir1 = first 2 hex chars of hash
+ *   dir2 = next 2 hex chars of hash
+ *   filename = full hash
+ *
+ * Two implementations are provided:
+ *   - OpfsBlobStore  — Origin Private File System (Chrome/Edge 86+)
+ *   - IdbBlobStore   — IndexedDB fallback (Firefox, Safari)
+ *
+ * Use createBlobStore() to get the best available implementation.
+ * Export MemoryBlobStore for use in tests.
+ */
+interface BlobStore {
+    write(hash: string, data: Uint8Array): Promise<void>;
+    read(hash: string): Promise<Uint8Array | null>;
+    remove(hash: string): Promise<void>;
+    exists(hash: string): Promise<boolean>;
+}
+declare class MemoryBlobStore implements BlobStore {
+    private store;
+    write(hash: string, data: Uint8Array): Promise<void>;
+    read(hash: string): Promise<Uint8Array | null>;
+    remove(hash: string): Promise<void>;
+    exists(hash: string): Promise<boolean>;
+}
+declare function createBlobStore(archiveName: string): BlobStore;
+
 /**
  * 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' | 'links' | 'embedding_sets' | 'embedding_set_members' | 'embedding_configs' | 'embeddings' | 'skos_schemes' | 'skos_concepts' | 'skos_relations' | 'note_skos_tags' | 'provenance_edges' | 'community_assignments' | 'communities' | 'graph_edges' | 'graph_sources';
+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;
@@ -393,20 +437,20 @@ interface ShardAttachmentReference {
     checksum: string;
     bytes: number;
 }
-interface ShardBinarySource {
-    extracted_text: string;
+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`/`count` are the record
- * range within the component, so an in-place reader fetches only the clusters a
- * query needs — the shard analog of the AIWG chunk-manifest scan parts.
+ * (`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;
-    count: number;
 }
 /**
  * Optional clustered layout (additive — absent on monolithic shards). When a
@@ -417,6 +461,13 @@ interface ShardClusterRef {
 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;
@@ -427,6 +478,8 @@ interface ShardManifest {
     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;
 }
@@ -448,6 +501,20 @@ interface ExportOptions {
      * (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';
@@ -458,8 +525,16 @@ interface ImportOptions {
     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;
 }
-type ImportProgressPhase = 'unpack' | 'validate' | 'collections' | 'notes' | 'skos' | 'links' | 'provenance' | 'embedding_sets' | 'embeddings' | 'embedding_set_members' | 'graph' | 'communities' | 'index';
+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;
@@ -469,9 +544,11 @@ interface ImportProgress {
 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;
@@ -500,6 +577,9 @@ interface ShardNote {
     title: string | null;
     original_content: string;
     revised_content: string | null;
+    collection_id?: string | null;
+    attachments?: ShardAttachmentProjection[];
+    /** @deprecated Legacy React shard field name. Use `attachments`. */
     binary_sources?: ShardBinarySource[];
     format: string;
     source: string;
@@ -524,21 +604,40 @@ 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;
+    to_note_id: string | null;
+    to_url: string | null;
     kind: string;
     score: number | null;
     created_at: string;
-    metadata?: Record<string, unknown>;
+    metadata: Record<string, unknown> | null;
 }
 /** Embedding set as serialized in the shard JSON array. */
 interface ShardEmbeddingSet {
     id: string;
-    name?: string;
-    purpose?: string | null;
+    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';
@@ -549,22 +648,42 @@ interface ShardEmbeddingSet {
     compatibility?: Record<string, unknown> | null;
     materialization?: Record<string, unknown> | null;
     freshness?: ShardArtifactFreshness | null;
-    created_at: string;
+    created_at?: string;
     updated_at?: string;
 }
 /** Embedding set member as serialized in the shard JSONL. */
 interface ShardEmbeddingSetMember {
     embedding_set_id: string;
     note_id: string;
-    embedding_id: string;
+    /** Legacy React shard field; new exports use server membership metadata instead. */
+    embedding_id?: string;
+    membership_type: string;
+    added_at: string;
+    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. */
 interface ShardEmbedding {
     id: string;
     note_id: string;
-    embedding_set_id: string;
+    chunk_index: number;
+    text: string;
     vector: number[];
-    created_at: string;
+    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 {
@@ -717,7 +836,8 @@ interface BrowserNoteExport {
     deleted_at: Date | string | null;
     original_content: string;
     revised_content: string | null;
-    binary_sources?: ShardBinarySource[];
+    collection_id?: string | null;
+    attachments?: ShardAttachmentProjection[];
     tags: string[];
 }
 /** Convert a browser note to shard format. */
@@ -726,14 +846,26 @@ declare function noteToShard(note: BrowserNoteExport): ShardNote;
 declare function noteFromShard(shard: ShardNote): BrowserNoteExport;
 /** Convert a browser link to shard format. */
 declare function linkToShard(link: LinkRow): ShardLink;
+/** Convert a browser URL-target link row to shard format. */
+declare function urlLinkToShard(link: {
+    id: string;
+    source_note_id: string;
+    to_url: string;
+    link_type: string;
+    confidence: number | null;
+    metadata_json?: Record<string, unknown> | string | null;
+    created_at: Date | string;
+}): ShardLink;
 /** Convert a shard link back to browser-insertable format. */
 declare function linkFromShard(shard: ShardLink): {
     id: string;
     source_note_id: string;
-    target_note_id: string;
+    target_note_id: string | null;
+    to_url: string | null;
     link_type: string;
     confidence: number | null;
     created_at: string;
+    metadata: Record<string, unknown> | null;
 };
 /** Convert a browser collection to shard format. */
 declare function collectionToShard(collection: CollectionRow, noteCount?: number): ShardCollection;
@@ -753,16 +885,29 @@ declare function tagsToShard(allTags: Array<{
     name: string;
     created_at: Date | string;
 }>): ShardTag[];
-/**
- * Convert shard flat tags to browser format for insertion.
- * Returns unique tag names ready for note_tag association.
- */
-declare function tagsFromShard(shardTags: ShardTag[]): string[];
+/** Convert a browser template row to shard format. */
+declare function templateToShard(template: {
+    id: string;
+    name: string;
+    description: string | null;
+    content: string;
+    format: string;
+    default_tags: string[] | string;
+    collection_id: string | null;
+    created_at: Date | string;
+    updated_at: Date | string;
+}): ShardTemplate;
 /** Convert a browser embedding_set to shard format. */
 declare function embeddingSetToShard(set: {
     id: string;
     name?: string;
+    slug?: string | null;
+    description?: string | null;
     purpose?: string | null;
+    document_count?: number | null;
+    embedding_count?: number | null;
+    is_system?: boolean | null;
+    keywords_json?: unknown | null;
     model_name: string;
     dimensions: number;
     kind?: 'physical' | 'filter' | 'virtual';
@@ -777,10 +922,16 @@ declare function embeddingSetToShard(set: {
     updated_at?: Date | string;
 }): ShardEmbeddingSet;
 /** Convert a shard embedding set back to browser format. */
-declare function embeddingSetFromShard(shard: ShardEmbeddingSet): {
+declare function embeddingSetFromShard(shard: ShardEmbeddingSet, fallbackCreatedAt: string): {
     id: string;
     name: string;
+    slug: string | null;
+    description: string | null;
     purpose: string | null;
+    document_count: number | null;
+    embedding_count: number | null;
+    is_system: boolean;
+    keywords_json: string | null;
     model_name: string;
     dimensions: number;
     kind: 'physical' | 'filter' | 'virtual';
@@ -798,23 +949,34 @@ declare function embeddingSetFromShard(shard: ShardEmbeddingSet): {
 declare function embeddingSetMemberToShard(member: {
     embedding_set_id: string;
     note_id: string;
-    embedding_id: string;
+    membership_type?: string | null;
+    added_at?: Date | string | null;
+    added_by?: string | null;
 }): ShardEmbeddingSetMember;
+/** Convert a browser embedding_config row to shard format. */
+declare function embeddingConfigToShard(config: ShardEmbeddingConfig): ShardEmbeddingConfig;
 /** Convert a browser embedding to shard format. */
 declare function embeddingToShard(emb: {
     id: string;
     note_id: string;
     embedding_set_id: string;
+    chunk_index?: number | null;
+    text?: string | null;
     vector: string | number[];
+    model?: string | null;
+    model_name?: string | null;
     created_at: Date | string;
 }): ShardEmbedding;
 /** Convert a shard embedding back to browser format. */
 declare function embeddingFromShard(shard: ShardEmbedding): {
     id: string;
     note_id: string;
-    embedding_set_id: string;
+    embedding_set_id: string | null;
+    chunk_index: number;
+    text: string;
     vector: string;
-    created_at: string;
+    model: string;
+    created_at: string | null;
 };
 declare function skosSchemeToShard(scheme: {
     id: string;
@@ -938,6 +1100,8 @@ interface OpenShardOptions {
     semantic?: StaticSemanticProvider;
     /** Bounds the cross-page search match cache (total cached note records). Default 5000. */
     maxCachedMatches?: number;
+    /** Maximum bytes fetched for any unpacked component. Default 256 MiB. */
+    maxComponentBytes?: number;
 }
 /** Reads shard component/cluster files from a packed map or a static base URL. */
 interface ShardComponentStore {
@@ -1039,7 +1203,8 @@ interface BackendNoteFull extends BackendNote {
 interface BackendLink {
     id: string;
     fromNoteId: string;
-    toNoteId: string;
+    toNoteId: string | null;
+    toUrl?: string | null;
     kind: string;
     score: number | null;
     createdAt: string;
@@ -1300,6 +1465,20 @@ declare class ArchiveManager {
     private archives;
     private persistence;
     private backendFactory;
+    /**
+     * Persistence is a PLUGGABLE, opt-in backend (issue #261). Pass a
+     * `StorageBackendFactory` to run against any `StorageBackend`
+     * implementation; PGlite is merely the built-in default, selected only when
+     * the convenience `PersistenceMode` string form is used. Because
+     * `defaultStorageBackendFactory` reaches PGlite through the lazily-imported
+     * `createPGliteInstance` (see `db.ts`), a consumer that supplies its own
+     * factory — or never opens an archive at all — never pulls the PGlite WASM
+     * engine into its bundle.
+     *
+     * @param persistenceOrFactory `PersistenceMode` string (uses the built-in
+     *   PGlite backend) OR a custom `StorageBackendFactory`.
+     * @param persistenceOverride persistence hint passed to a custom factory.
+     */
     constructor(persistenceOrFactory: PersistenceMode | StorageBackendFactory, events?: TypedEventBus | undefined, persistenceOverride?: PersistenceMode);
     getCurrentArchiveName(): string;
     getDb(): StorageBackend | null;
@@ -1335,15 +1514,91 @@ interface FortemiCore {
 declare function createFortemi(config: FortemiConfig): FortemiCore;
 
 /**
- * Compute a SHA-256 content hash for the given byte array.
+ * Compute a browser-local content-identity hash (SHA-256), encoded as
+ * `sha256:<64-char lowercase hex>`.
  *
- * Returns a string in `algorithm:hex` format to match the server-side
- * convention, e.g. `sha256:a3b4c5...` (64 hex characters after the prefix).
+ * This is an internal identity/dedup digest used for note content, embedding
+ * configs, the AIWG index, and graph identity — NOT the server's attachment
+ * content-hash convention. Binary-attachment blobs use {@link computeBlobHash}
+ * (BLAKE3), which is the canonical checksum defined by the binary-attachment
+ * projection contract (`checksum: "blake3:<hex>"`). Keeping these two functions
+ * separate preserves JSON format parity for the identity hashes above while
+ * letting attachments match the server's `compute_content_hash`.
  *
  * @param data - Raw bytes to hash
  * @returns `'sha256:<64-char lowercase hex>'`
  */
 declare function computeHash(data: Uint8Array): string;
+/**
+ * Compute the canonical attachment content hash: **BLAKE3**, encoded as
+ * `blake3:<64-char lowercase hex>`.
+ *
+ * Matches the fortemi server (`crates/matric-db/src/file_storage.rs`
+ * `compute_content_hash`) and the portable Knowledge-Shard byte-sidecar
+ * contract, where the sidecar tar entry name is the bare hex (the `blake3:`
+ * prefix stripped). SubtleCrypto has no BLAKE3, so this uses `@noble/hashes`.
+ *
+ * @param data - Raw attachment bytes to hash
+ * @returns `'blake3:<64-char lowercase hex>'`
+ */
+declare function computeBlobHash(data: Uint8Array): string;
+
+declare const FORTEMI_COMPATIBILITY_PATH = "/api/v1/system/compatibility";
+declare const FORTEMI_COMPATIBILITY_STATES: readonly ["available", "degraded", "preview", "unavailable", "unknown"];
+type FortemiCompatibilityState = (typeof FORTEMI_COMPATIBILITY_STATES)[number];
+declare const FORTEMI_REQUIRED_COMPATIBILITY_CAPABILITIES: readonly ["core_notes", "search", "jobs", "realtime_activity", "hosted_auth", "premium_components", "backoffice_api", "audit_posture", "quota_status", "kms_status", "mcp_scope_gate"];
+type FortemiRequiredCompatibilityCapability = (typeof FORTEMI_REQUIRED_COMPATIBILITY_CAPABILITIES)[number];
+interface FortemiCompatibilityCapability {
+    state: FortemiCompatibilityState;
+    reason_code?: string;
+}
+interface FortemiCompatibilityResponse {
+    schema_version: number;
+    contract_revision: string;
+    api: {
+        name: string;
+        version: string;
+        minimum_hotm_enterprise_client: string;
+        git_sha_present: boolean;
+        build_date_present: boolean;
+    };
+    deployment: {
+        mode: string;
+        edition: string;
+        hosted_multi_tenant_ready: boolean;
+    };
+    auth: {
+        required: boolean;
+        mode: string;
+        oauth_issuer_configured: boolean;
+        tenant_context_available: boolean;
+    };
+    capabilities: Record<string, FortemiCompatibilityCapability>;
+    links: {
+        openapi: string;
+        asyncapi: string;
+        health: string;
+        streaming_health: string;
+    };
+}
+interface FortemiCompatibilityValidationResult {
+    ok: boolean;
+    errors: string[];
+    warnings: string[];
+    response?: FortemiCompatibilityResponse;
+}
+interface FetchFortemiCompatibilityOptions {
+    baseUrl?: string;
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+}
+declare function fortemiCompatibilityUrl(baseUrl?: string): string;
+declare function validateFortemiCompatibilityResponse(raw: unknown): FortemiCompatibilityValidationResult;
+declare function formatFortemiCompatibilitySummary(response: FortemiCompatibilityResponse): string;
+declare function fetchAndValidateFortemiCompatibility(options?: FetchFortemiCompatibilityOptions): Promise<FortemiCompatibilityValidationResult & {
+    url: string;
+    status?: number;
+}>;
 
 interface SWRegistrationResult {
     registered: boolean;
@@ -1377,36 +1632,6 @@ declare function createRoutes(): RouteHandler[];
  */
 declare function matchRoute(routes: RouteHandler[], request: Request, url: URL): RouteHandler | null;
 
-/**
- * Content-addressable blob storage.
- *
- * Path format: blobs/{dir1}/{dir2}/{hash}
- *   dir1 = first 2 hex chars of hash
- *   dir2 = next 2 hex chars of hash
- *   filename = full hash
- *
- * Two implementations are provided:
- *   - OpfsBlobStore  — Origin Private File System (Chrome/Edge 86+)
- *   - IdbBlobStore   — IndexedDB fallback (Firefox, Safari)
- *
- * Use createBlobStore() to get the best available implementation.
- * Export MemoryBlobStore for use in tests.
- */
-interface BlobStore {
-    write(hash: string, data: Uint8Array): Promise<void>;
-    read(hash: string): Promise<Uint8Array | null>;
-    remove(hash: string): Promise<void>;
-    exists(hash: string): Promise<boolean>;
-}
-declare class MemoryBlobStore implements BlobStore {
-    private store;
-    write(hash: string, data: Uint8Array): Promise<void>;
-    read(hash: string): Promise<Uint8Array | null>;
-    remove(hash: string): Promise<void>;
-    exists(hash: string): Promise<boolean>;
-}
-declare function createBlobStore(archiveName: string): BlobStore;
-
 /**
  * Shared postMessage protocol types for the PGlite worker.
  *
@@ -2378,19 +2603,19 @@ declare const CaptureKnowledgeInputSchema: z.ZodObject<{
     }, {
         content: string;
         title?: string | undefined;
-        tags?: string[] | undefined;
         format?: "markdown" | "plain" | "html" | undefined;
+        tags?: string[] | undefined;
     }>, "many">>;
     template: z.ZodOptional<z.ZodString>;
     variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
     source: string;
     format: "markdown" | "plain" | "html";
-    visibility: "private" | "public" | "shared";
+    visibility: "private" | "shared" | "public";
     action: "create" | "bulk_create" | "from_template";
     title?: string | undefined;
-    tags?: string[] | undefined;
     archive_id?: string | undefined;
+    tags?: string[] | undefined;
     content?: string | undefined;
     notes?: {
         format: "markdown" | "plain" | "html";
@@ -2404,16 +2629,16 @@ declare const CaptureKnowledgeInputSchema: z.ZodObject<{
     action: "create" | "bulk_create" | "from_template";
     source?: string | undefined;
     title?: string | undefined;
-    tags?: string[] | undefined;
     archive_id?: string | undefined;
     format?: "markdown" | "plain" | "html" | undefined;
-    visibility?: "private" | "public" | "shared" | undefined;
+    visibility?: "private" | "shared" | "public" | undefined;
+    tags?: string[] | undefined;
     content?: string | undefined;
     notes?: {
         content: string;
         title?: string | undefined;
-        tags?: string[] | undefined;
         format?: "markdown" | "plain" | "html" | undefined;
+        tags?: string[] | undefined;
     }[] | undefined;
     template?: string | undefined;
     variables?: Record<string, string> | undefined;
@@ -2460,17 +2685,17 @@ declare const SearchInputSchema: z.ZodObject<{
     visibility: z.ZodOptional<z.ZodEnum<["private", "shared", "public"]>>;
     include_facets: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
-    query: string;
-    offset: number;
     limit: number;
+    offset: number;
     include_facets: boolean;
-    mode: "text" | "auto" | "semantic" | "hybrid";
+    mode: "auto" | "text" | "semantic" | "hybrid";
+    query: string;
     source?: string | undefined;
-    tags?: string[] | undefined;
     format?: "markdown" | "plain" | "html" | undefined;
-    visibility?: "private" | "public" | "shared" | undefined;
+    visibility?: "private" | "shared" | "public" | undefined;
     is_starred?: boolean | undefined;
     is_archived?: boolean | undefined;
+    tags?: string[] | undefined;
     collection_id?: string | undefined;
     date_from?: Date | undefined;
     date_to?: Date | undefined;
@@ -2479,18 +2704,18 @@ declare const SearchInputSchema: z.ZodObject<{
 }, {
     query: string;
     source?: string | undefined;
-    tags?: string[] | undefined;
-    offset?: number | undefined;
-    limit?: number | undefined;
     format?: "markdown" | "plain" | "html" | undefined;
-    visibility?: "private" | "public" | "shared" | undefined;
+    visibility?: "private" | "shared" | "public" | undefined;
     is_starred?: boolean | undefined;
     is_archived?: boolean | undefined;
+    tags?: string[] | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
     collection_id?: string | undefined;
     date_from?: Date | undefined;
     date_to?: Date | undefined;
     include_facets?: boolean | undefined;
-    mode?: "text" | "auto" | "semantic" | "hybrid" | undefined;
+    mode?: "auto" | "text" | "semantic" | "hybrid" | undefined;
     embeddingSetId?: string | undefined;
     query_embedding?: number[] | undefined;
 }>;
@@ -2570,22 +2795,22 @@ declare const ListNotesInputSchema: z.ZodObject<{
     collection_id: z.ZodOptional<z.ZodString>;
     include_deleted: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
-    sort: "title" | "updated_at" | "created_at";
-    offset: number;
+    sort: "created_at" | "updated_at" | "title";
     limit: number;
+    offset: number;
     order: "asc" | "desc";
-    tags?: string[] | undefined;
     is_starred?: boolean | undefined;
     is_archived?: boolean | undefined;
+    tags?: string[] | undefined;
     include_deleted?: boolean | undefined;
     collection_id?: string | undefined;
 }, {
-    tags?: string[] | undefined;
-    sort?: "title" | "updated_at" | "created_at" | undefined;
-    offset?: number | undefined;
-    limit?: number | undefined;
+    sort?: "created_at" | "updated_at" | "title" | undefined;
     is_starred?: boolean | undefined;
     is_archived?: boolean | undefined;
+    tags?: string[] | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
     order?: "asc" | "desc" | undefined;
     include_deleted?: boolean | undefined;
     collection_id?: string | undefined;
@@ -2599,12 +2824,12 @@ declare const ManageTagsInputSchema: z.ZodObject<{
     tag: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     action: "add" | "remove" | "list_for_note" | "list_all";
-    tag?: string | undefined;
     note_id?: string | undefined;
+    tag?: string | undefined;
 }, {
     action: "add" | "remove" | "list_for_note" | "list_all";
-    tag?: string | undefined;
     note_id?: string | undefined;
+    tag?: string | undefined;
 }>;
 type ManageTagsInput = z.infer<typeof ManageTagsInputSchema>;
 interface ManageTagsResult {
@@ -2626,17 +2851,17 @@ declare const ManageCollectionsInputSchema: z.ZodObject<{
     note_id: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     action: "create" | "delete" | "list" | "assign" | "unassign" | "list_tree";
-    name?: string | undefined;
-    description?: string | undefined;
     collection_id?: string | undefined;
     note_id?: string | undefined;
+    name?: string | undefined;
+    description?: string | undefined;
     parent_id?: string | undefined;
 }, {
     action: "create" | "delete" | "list" | "assign" | "unassign" | "list_tree";
-    name?: string | undefined;
-    description?: string | undefined;
     collection_id?: string | undefined;
     note_id?: string | undefined;
+    name?: string | undefined;
+    description?: string | undefined;
     parent_id?: string | undefined;
 }>;
 type ManageCollectionsInput = z.infer<typeof ManageCollectionsInputSchema>;
@@ -2776,9 +3001,11 @@ declare class AttachmentsRepository {
     /**
      * Attach a binary file to a note.
      *
-     * If a blob with the same SHA-256 content hash already exists, the existing
+     * 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.
+     * 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.
      *
      * Returns the newly created AttachmentRow.
      */
@@ -3574,7 +3801,9 @@ declare function createCspReportHandler(onReport: (report: CspViolationReport) =
  * @param files Map of filename → file contents
  * @returns Compressed archive bytes (suitable for .shard file)
  */
-declare function packTarGz(files: Map<string, Uint8Array>): Uint8Array;
+declare function packTarGz(files: Map<string, Uint8Array>, opts?: {
+    maxDecompressedBytes?: number;
+}): Uint8Array;
 /**
  * Unpack a gzip-compressed tar archive.
  *
@@ -3655,6 +3884,17 @@ declare function exportShard(db: DatabaseClient, options?: ExportOptions): Promi
  */
 declare function importShard(db: DatabaseClient, data: Uint8Array | ArrayBuffer, options?: ImportOptions): Promise<ImportResult>;
 
+interface ShardSchemaValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+type ShardFiles = Map<string, Uint8Array>;
+declare function getKnowledgeShardSchema(): unknown;
+declare function validateShardManifest(value: unknown): ShardSchemaValidationResult;
+declare function validateShardArchive(input: Uint8Array | ArrayBuffer | ShardFiles): ShardSchemaValidationResult;
+declare function validateShardComponentRecord(component: ShardComponent | 'templates', value: unknown): ShardSchemaValidationResult;
+declare function assertShardComponentRecord(component: ShardComponent | 'templates', value: unknown): void;
+
 /**
  * Pluggable semantic providers for the in-place shard reader (issue #189).
  *
@@ -3821,6 +4061,473 @@ declare function getPrefetchedSha256(url: string): string | undefined;
  */
 declare function clearPrefetchedShard(url?: string): void;
 
-declare const VERSION = "2026.7.3";
+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 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[];
+    }[];
+};
+
+declare const VERSION = "2026.7.5";
 
-export { 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, type BlobStore, type BridgeCapability, type BridgeProviderInfo, type BrowserNoteExport, CURRENT_MIGRATION_HEAD, CURRENT_SHARD_VERSION, 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 ConflictStrategy, 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, type ExportOptions, type FallbackEvent, FallbackRouter, type FallbackRouterConfig, type FortemiBridge, type FortemiBridgeCapabilities, type FortemiBridgeHost, type FortemiConfig, type FortemiCore, type FortemiInferenceRouter, type FortemiSecretStore, type FortemiToolDefinition, FortemiToolManifest, type GetNoteInput, GetNoteInputSchema, type GpuCapabilities, type GraphCommunity, type GraphEdge, type GraphNode, GraphRepository, type IDisposable, 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, 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, MemoryBlobStore, 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, SHARD_FORMAT, 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 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 ShardSearchOptions, type ShardSearchRankedNote, type ShardSearchResult, type ShardSearchWeights, type ShardSkosConcept, type ShardSkosRelation, type ShardSkosScheme, type ShardTag, 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, buildNoteConditions, buildPluginCsp, captureKnowledge, chunkText, classifyError, classifyModel, clearPrefetchedShard, collectionFromShard, collectionToShard, computeHash, computeSri, conceptTaggingHandler, cosineSimilarity, createBlobStore, createCosineSemanticProvider, createCspReportHandler, createFortemi, createLegacyProvider, createPGliteBackend, createPGliteInstance, createRemoteBackend, createRoutes, createShardBackend, createWorkerEmbedFunction, defaultStorageBackendFactory, detectCommunities, detectGpuCapabilities, detectInferenceCapabilities, discoverLocalProviders, dumpDbSnapshot, embeddingFromShard, embeddingGenerationHandler, embeddingSetFromShard, embeddingSetMemberToShard, embeddingSetToShard, embeddingToShard, enqueueFullWorkflow, enqueueJob, enqueueNoteCreationJobs, estimateModelFit, estimateVramMB, estimateVramTier, exportShard, fetchPluginScript, fortemiManifest, fromPrefetched, generateId, getEmbedFunction, getFortemiBridge, getFortemiSecretStore, getJobQueueStatus, 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, tagsFromShard, tagsToShard, titleGenerationHandler, unpackTarGz, unregisterLlmCapability, unregisterSemanticCapability, validateChecksums, 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 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, 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, type BlobStore, type BridgeCapability, type BridgeProviderInfo, type BrowserNoteExport, type BuildAiwgStaticEmbeddingSetOptions, CURRENT_MIGRATION_HEAD, CURRENT_SHARD_VERSION, 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 ConflictStrategy, 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, 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, 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, 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, MemoryBlobStore, 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, SHARD_FORMAT, 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 ShardSkosConcept, type ShardSkosRelation, type ShardSkosScheme, type ShardTag, type 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, aiwgFortemiIndexToCommunityGraph, 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, 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, filterAiwgRecordsByPrivacy, findAiwgStaticDuplicatePairs, formatFortemiCompatibilitySummary, fortemiCompatibilityUrl, fortemiManifest, fromPrefetched, generateId, getAiwgFortemiFacets, 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, queryAiwgFortemiIndex, queryAiwgHybridIndex, queryAiwgSemanticIndex, registerLlmCapability, registerSemanticCapability, registerSemanticCapabilityWorker, registerServiceWorker, restoreDbSnapshot, searchTool, selectBackend, selectLlmModel, setEmbedFunction, setLlmFunction, sha256Hex, skosConceptToShard, skosRelationToShard, skosSchemeToShard, suggestTags, tagsToShard, templateToShard, titleGenerationHandler, unpackTarGz, unregisterLlmCapability, unregisterSemanticCapability, urlLinkToShard, validateAiwgFortemiChunkManifest, validateAiwgFortemiChunkPart, validateAiwgFortemiIndexExport, validateAiwgStaticEmbeddingSet, validateChecksums, validateFortemiCompatibilityResponse, validateShardArchive, validateShardComponentRecord, validateShardManifest, verifyDbSnapshotMeta, verifySri };