@fortemi/core 2026.5.0

package/dist/index.d.ts

@@ -0,0 +1,2375 @@
+import { PGlite } from '@electric-sql/pglite';
+import { z, ZodType } from 'zod';
+
+/**
+ * Generate a RFC 9562 UUIDv7 identifier.
+ *
+ * UUIDv7 embeds a Unix timestamp in the high bits, making IDs
+ * time-sortable and monotonic within the same millisecond.
+ */
+declare function generateId(): string;
+
+/**
+ * Typed event bus with IDisposable subscriptions (Monaco-style).
+ * SSE-style pub/sub across all layers.
+ *
+ * Features:
+ * - Exact event subscriptions via on() and once()
+ * - Wildcard prefix subscriptions: on('note.*', handler)
+ * - Cross-context bridging via bridge(port: MessagePort)
+ */
+interface IDisposable {
+    dispose(): void;
+}
+interface EventMap {
+    'note.created': {
+        id: string;
+    };
+    'note.updated': {
+        id: string;
+    };
+    'note.deleted': {
+        id: string;
+    };
+    'note.restored': {
+        id: string;
+    };
+    'note.revised': {
+        id: string;
+        revisionNumber: number;
+    };
+    'search.reindexed': Record<string, never>;
+    'embedding.ready': {
+        noteId: string;
+    };
+    'capability.ready': {
+        name: string;
+    };
+    'capability.disabled': {
+        name: string;
+    };
+    'capability.loading': {
+        name: string;
+        progress?: number;
+    };
+    'job.completed': {
+        id: string;
+        noteId: string;
+        type: string;
+    };
+    'job.failed': {
+        id: string;
+        noteId: string;
+        type: string;
+        error: string;
+    };
+    'archive.switched': {
+        name: string;
+    };
+    'migration.applied': {
+        version: number;
+    };
+    'provider.added': {
+        id: string;
+        name: string;
+    };
+    'provider.removed': {
+        id: string;
+    };
+    'provider.active': {
+        id: string;
+        name: string;
+    };
+    'provider.fallback': {
+        fromProvider: string;
+        toProvider: string;
+        errorCategory: string;
+        error: string;
+    };
+    'provider.cooldown': {
+        providerId: string;
+        errorCategory: string;
+        cooldownMs: number;
+        expiresAt: number;
+    };
+}
+type EventHandler<T> = (payload: T) => void;
+/** Wildcard pattern: a string literal ending with '.*' */
+type WildcardPattern = `${string}.*`;
+declare class TypedEventBus {
+    private listeners;
+    private wildcardListeners;
+    on<K extends keyof EventMap>(event: K, handler: EventHandler<EventMap[K]>): IDisposable;
+    on(pattern: WildcardPattern, handler: EventHandler<unknown>): IDisposable;
+    private _onExact;
+    private _onWildcard;
+    once<K extends keyof EventMap>(event: K, handler: EventHandler<EventMap[K]>): IDisposable;
+    emit<K extends keyof EventMap>(event: K, payload: EventMap[K]): void;
+    bridge(port: MessagePort): IDisposable;
+    removeAllListeners(): void;
+}
+
+/**
+ * PGlite database factory.
+ * Enforces PGlite 0.4.x conventions (explicit database: 'postgres').
+ * Selects persistence adapter based on config.
+ */
+
+type PersistenceMode = 'opfs' | 'idb' | 'memory';
+declare function createPGliteInstance(persistence: PersistenceMode, archiveName?: string): Promise<PGlite>;
+
+interface QueryResult<T = Record<string, unknown>> {
+    rows: T[];
+    fields?: Array<{
+        name: string;
+        dataTypeID: number;
+    }>;
+}
+interface QueryExecutor {
+    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<QueryResult<T>>;
+    exec(sql: string): Promise<unknown>;
+}
+interface DatabaseClient extends QueryExecutor {
+    transaction<T>(fn: (tx: QueryExecutor) => Promise<T>): Promise<T>;
+}
+interface StorageBackend extends DatabaseClient {
+    readonly id: string;
+    readonly mode: 'readwrite' | 'readonly';
+    close(): Promise<void>;
+}
+interface StorageOpenRequest {
+    archiveName: string;
+    persistence: PersistenceMode;
+}
+interface StorageBackendFactory {
+    open(input: StorageOpenRequest): Promise<StorageBackend>;
+}
+interface StorageTopology {
+    primary: StorageBackend;
+    secondary?: StorageBackend;
+    policy: 'primary-only' | 'read-through-secondary' | 'explicit-replication';
+}
+declare class PGliteStorageBackend implements StorageBackend {
+    readonly id: string;
+    private db;
+    readonly mode = "readwrite";
+    constructor(id: string, db: PGlite);
+    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<QueryResult<T>>;
+    exec(sql: string): Promise<unknown>;
+    transaction<T>(fn: (tx: QueryExecutor) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}
+declare class PGliteStorageBackendFactory implements StorageBackendFactory {
+    open(input: StorageOpenRequest): Promise<StorageBackend>;
+}
+declare const defaultStorageBackendFactory: PGliteStorageBackendFactory;
+
+/**
+ * Capability module system (ADR-002).
+ * Tracks opt-in WASM module states. No WASM loaded by default (CAP-001).
+ *
+ * State machine (valid transitions):
+ *   unloaded  -> loading  (via enable)
+ *   loading   -> ready    (via markReady or successful loader)
+ *   loading   -> error    (via markError or failed loader)
+ *   ready     -> disabled (via disable)
+ *   disabled  -> loading  (via enable, re-enable)
+ *   error     -> loading  (via enable, retry)
+ */
+
+type CapabilityState = 'unloaded' | 'loading' | 'ready' | 'error' | 'disabled';
+type CapabilityName = 'semantic' | 'llm' | 'audio' | 'vision' | 'pdf';
+declare class CapabilityManager {
+    private events;
+    private capabilities;
+    private loaders;
+    private progressMessages;
+    constructor(events: TypedEventBus);
+    /**
+     * Register an async loader for a capability.
+     * Called by enable(); if no loader is registered the capability transitions
+     * directly to ready (useful for capabilities that require no async init).
+     */
+    registerLoader(name: CapabilityName, loader: () => Promise<void>): void;
+    getState(name: CapabilityName): CapabilityState;
+    isReady(name: CapabilityName): boolean;
+    /**
+     * Enable a capability.
+     * Valid from: unloaded, disabled, error (retry).
+     * Runs the registered loader if present; transitions to ready on success,
+     * error on failure.
+     */
+    enable(name: CapabilityName): Promise<void>;
+    /**
+     * Disable a ready capability.
+     * Valid from: ready only.
+     */
+    disable(name: CapabilityName): void;
+    /**
+     * Mark a loading capability as ready (external use, e.g. bridge protocol).
+     * Valid from: loading only.
+     */
+    markReady(name: CapabilityName): void;
+    /**
+     * Mark a loading capability as errored (external use, e.g. bridge protocol).
+     * Valid from: loading only.
+     */
+    markError(name: CapabilityName, error: string): void;
+    /**
+     * Report loading progress (0-100).
+     * Emits capability.loading with progress if the capability is currently loading.
+     * No-op if the capability is not in loading state.
+     */
+    reportProgress(name: CapabilityName, progress: number): void;
+    /** Set a human-readable progress message for a loading capability */
+    setProgress(name: CapabilityName, message: string): void;
+    /** Get the current progress message for a capability */
+    getProgress(name: CapabilityName): string | undefined;
+    getError(name: CapabilityName): string | undefined;
+    listAll(): Array<{
+        name: CapabilityName;
+        state: CapabilityState;
+    }>;
+}
+
+/**
+ * Sequential SQL migration runner for DatabaseClient.
+ * Tracks applied migrations in a schema_version table.
+ * Each migration runs in a transaction; version updated atomically.
+ */
+
+interface Migration {
+    version: number;
+    name: string;
+    sql: string;
+}
+declare class MigrationRunner {
+    private db;
+    private events?;
+    constructor(db: DatabaseClient, events?: TypedEventBus | undefined);
+    ensureSchemaTable(): Promise<void>;
+    getCurrentVersion(): Promise<number>;
+    apply(migrations: Migration[]): Promise<number>;
+    getAppliedMigrations(): Promise<Array<{
+        version: number;
+        name: string;
+    }>>;
+}
+
+declare const allMigrations: Migration[];
+
+/**
+ * Multi-archive manager for Fortemi.
+ * Each archive is a separate PGlite instance with its own persistence path.
+ * Migrations are applied automatically on open.
+ */
+
+interface ArchiveInfo {
+    name: string;
+    createdAt: string;
+}
+declare class ArchiveManager {
+    private events?;
+    private currentArchive;
+    private db;
+    private archives;
+    private persistence;
+    private backendFactory;
+    constructor(persistenceOrFactory: PersistenceMode | StorageBackendFactory, events?: TypedEventBus | undefined);
+    getCurrentArchiveName(): string;
+    getDb(): StorageBackend | null;
+    open(archiveName?: string): Promise<StorageBackend>;
+    create(archiveName: string): Promise<StorageBackend>;
+    switchTo(archiveName: string): Promise<StorageBackend>;
+    delete(archiveName: string): Promise<void>;
+    listArchives(): ArchiveInfo[];
+    close(): Promise<void>;
+}
+
+/**
+ * Factory function for creating a FortemiCore instance.
+ * All deployment modes use this entry point.
+ */
+
+interface FortemiConfig {
+    persistence: 'opfs' | 'idb' | 'memory';
+    archiveName?: string;
+}
+interface FortemiCore {
+    events: TypedEventBus;
+    config: FortemiConfig;
+    destroy(): void;
+}
+declare function createFortemi(config: FortemiConfig): FortemiCore;
+
+/**
+ * Compute a SHA-256 content hash for the given byte array.
+ *
+ * Returns a string in `algorithm:hex` format to match the server-side
+ * convention, e.g. `sha256:a3b4c5...` (64 hex characters after the prefix).
+ *
+ * @param data - Raw bytes to hash
+ * @returns `'sha256:<64-char lowercase hex>'`
+ */
+declare function computeHash(data: Uint8Array): string;
+
+interface SWRegistrationResult {
+    registered: boolean;
+    registration?: ServiceWorkerRegistration;
+    error?: string;
+}
+declare function registerServiceWorker(swUrl?: string): Promise<SWRegistrationResult>;
+
+/**
+ * REST route definitions for Service Worker.
+ * These are pure functions that transform HTTP Request → tool input and tool output → Response.
+ * The actual DB connection is injected at registration time.
+ *
+ * All routes currently return 503 Not Implemented — the DB wiring happens in a later issue.
+ * The URL structure and request/response shapes are the valuable contract defined here.
+ */
+interface RouteHandler {
+    method: string;
+    pattern: RegExp;
+    handler: (request: Request, match: RegExpMatchArray, params: URLSearchParams) => Promise<Response>;
+}
+/**
+ * Create route handlers.
+ * db parameter will be injected when the SW gets access to PGlite.
+ * For now, returns 503 Not Implemented for all routes.
+ */
+declare function createRoutes(): RouteHandler[];
+/**
+ * Match a request against the registered routes and return the first matching
+ * handler, or null if no route matches.
+ */
+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.
+ *
+ * WorkerRequest — messages sent from the client to the worker.
+ * WorkerResponse — messages sent from the worker back to the client.
+ *
+ * Every request carries a unique `id` that the worker echoes in its response,
+ * allowing the client to correlate replies with pending promises.
+ * The READY broadcast is the only message without an `id` — it is sent once
+ * on startup before any requests are processed.
+ */
+/** Messages from client to worker */
+type WorkerRequest = {
+    id: string;
+    type: 'QUERY';
+    sql: string;
+    params?: unknown[];
+} | {
+    id: string;
+    type: 'EXEC';
+    sql: string;
+} | {
+    id: string;
+    type: 'BEGIN';
+    isolationLevel?: string;
+} | {
+    id: string;
+    type: 'COMMIT';
+    txId: string;
+} | {
+    id: string;
+    type: 'ROLLBACK';
+    txId: string;
+} | {
+    id: string;
+    type: 'TX_QUERY';
+    txId: string;
+    sql: string;
+    params?: unknown[];
+} | {
+    id: string;
+    type: 'TX_EXEC';
+    txId: string;
+    sql: string;
+} | {
+    id: string;
+    type: 'CLOSE';
+} | {
+    id: string;
+    type: 'PING';
+};
+/** Messages from worker to client */
+type WorkerResponse = {
+    id: string;
+    type: 'RESULT';
+    rows: unknown[];
+    fields?: Array<{
+        name: string;
+        dataTypeID: number;
+    }>;
+} | {
+    id: string;
+    type: 'EXEC_DONE';
+    affectedRows?: number;
+} | {
+    id: string;
+    type: 'TX_STARTED';
+    txId: string;
+} | {
+    id: string;
+    type: 'TX_DONE';
+} | {
+    id: string;
+    type: 'ERROR';
+    error: string;
+} | {
+    id: string;
+    type: 'PONG';
+} | {
+    type: 'READY';
+};
+
+/**
+ * Type-safe client for the PGlite Worker.
+ *
+ * PGliteWorkerClient wraps a Worker instance and exposes the same surface as
+ * PGlite (query / exec / transaction) but serialises every call to a typed
+ * postMessage exchange. Each outgoing request is tagged with a UUIDv7 `id`;
+ * the worker echoes that id in its reply so the client can resolve or reject
+ * the matching Promise.
+ *
+ * TransactionProxy is a lightweight wrapper handed to the callback in
+ * transaction(), forwarding TX_QUERY / TX_EXEC messages with the active txId.
+ */
+declare class PGliteWorkerClient {
+    private worker;
+    private pending;
+    private readyPromise;
+    private resolveReady;
+    constructor(worker: Worker);
+    /** Resolves when the worker broadcasts READY after database initialisation. */
+    waitReady(): Promise<void>;
+    private send;
+    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<{
+        rows: T[];
+        fields?: Array<{
+            name: string;
+            dataTypeID: number;
+        }>;
+    }>;
+    exec(sql: string): Promise<void>;
+    transaction<T>(fn: (tx: TransactionProxy) => Promise<T>): Promise<T>;
+    /** Forward TX_QUERY for TransactionProxy — not part of the public surface. */
+    _txQuery<T>(txId: string, sql: string, params?: unknown[]): Promise<{
+        rows: T[];
+    }>;
+    /** Forward TX_EXEC for TransactionProxy — not part of the public surface. */
+    _txExec(txId: string, sql: string): Promise<void>;
+    ping(): Promise<void>;
+    close(): Promise<void>;
+}
+/** Proxy passed to the transaction callback — scopes queries to the active txId. */
+declare class TransactionProxy {
+    private client;
+    private txId;
+    constructor(client: PGliteWorkerClient, txId: string);
+    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<{
+        rows: T[];
+    }>;
+    exec(sql: string): Promise<void>;
+}
+
+/**
+ * Shared types for repository layer.
+ * All repository methods use these types as inputs and outputs.
+ */
+interface NoteSummary {
+    id: string;
+    title: string | null;
+    format: string;
+    source: string;
+    visibility: string;
+    is_starred: boolean;
+    is_pinned: boolean;
+    is_archived: boolean;
+    created_at: Date;
+    updated_at: Date;
+    deleted_at: Date | null;
+    tags: string[];
+}
+interface NoteFull extends NoteSummary {
+    archive_id: string | null;
+    revision_mode: string;
+    original: {
+        id: string;
+        content: string;
+        content_hash: string;
+        created_at: Date;
+    };
+    current: {
+        content: string;
+        ai_metadata: unknown | null;
+        generation_count: number;
+        model: string | null;
+        is_user_edited: boolean;
+        updated_at: Date;
+    };
+}
+interface NoteCreateInput {
+    content: string;
+    title?: string;
+    format?: string;
+    source?: string;
+    visibility?: string;
+    tags?: string[];
+    archive_id?: string;
+}
+interface NoteUpdateInput {
+    title?: string;
+    content?: string;
+    format?: string;
+    visibility?: string;
+}
+interface NoteListOptions {
+    limit?: number;
+    offset?: number;
+    sort?: 'created_at' | 'updated_at' | 'title';
+    order?: 'asc' | 'desc';
+    is_starred?: boolean;
+    is_pinned?: boolean;
+    is_archived?: boolean;
+    include_deleted?: boolean;
+    include_archived?: boolean;
+    collection_id?: string;
+    tags?: string[];
+}
+interface PaginatedResult<T> {
+    items: T[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+interface SearchResult {
+    id: string;
+    title: string | null;
+    snippet: string;
+    rank: number;
+    created_at: Date;
+    updated_at: Date;
+    tags: string[];
+    has_embedding?: boolean;
+}
+interface SearchFacets {
+    tags: {
+        tag: string;
+        count: number;
+    }[];
+    collections: {
+        id: string;
+        name: string;
+        count: number;
+    }[];
+}
+interface SearchResponse {
+    results: SearchResult[];
+    total: number;
+    query: string;
+    mode: 'text' | 'semantic' | 'hybrid';
+    semantic_available: boolean;
+    limit: number;
+    offset: number;
+    facets?: SearchFacets;
+}
+interface SearchOptions {
+    limit?: number;
+    offset?: number;
+    tags?: string[];
+    collection_id?: string;
+    date_from?: Date;
+    date_to?: Date;
+    is_starred?: boolean;
+    is_archived?: boolean;
+    format?: string;
+    source?: string;
+    visibility?: string;
+    include_facets?: boolean;
+    mode?: 'text' | 'semantic' | 'hybrid' | 'auto';
+}
+interface NoteRevision {
+    id: string;
+    note_id: string;
+    revision_number: number;
+    type: string;
+    content: string;
+    ai_metadata: unknown | null;
+    model: string | null;
+    created_at: Date;
+}
+
+/**
+ * NotesRepository — CRUD and lifecycle operations for the note entity.
+ *
+ * Responsibilities:
+ * - Create notes with immutable original content and mutable current revision
+ * - Manage note lifecycle: soft-delete, restore, star, pin, archive
+ * - List notes with filtering, pagination, and sorting
+ * - Emit domain events via TypedEventBus on every mutation
+ */
+
+declare class NotesRepository {
+    private db;
+    private events?;
+    constructor(db: DatabaseClient, events?: TypedEventBus | undefined);
+    /**
+     * Create a new note with its original content record, current revision,
+     * optional tags, and an auto-queued title_generation job when no title
+     * is provided.
+     *
+     * All writes happen in a single transaction.
+     */
+    create(input: NoteCreateInput): Promise<NoteFull>;
+    /**
+     * Fetch a single note by its ID.
+     * Returns NoteFull which includes original content, current revision, and tags.
+     * Throws when the note does not exist.
+     */
+    get(id: string): Promise<NoteFull>;
+    /**
+     * List notes with optional filtering, sorting, and pagination.
+     * Excludes soft-deleted notes by default (pass include_deleted: true to override).
+     */
+    list(options?: NoteListOptions): Promise<PaginatedResult<NoteSummary>>;
+    /**
+     * Update mutable note fields.
+     * When content changes, the previous current content is saved as a numbered
+     * revision before the new content is applied.
+     */
+    update(id: string, input: NoteUpdateInput): Promise<NoteFull>;
+    /**
+     * Soft-delete a note by setting deleted_at to the current timestamp.
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Restore a soft-deleted note by clearing deleted_at.
+     */
+    restore(id: string): Promise<NoteFull>;
+    /**
+     * Toggle the is_starred field on a note.
+     */
+    star(id: string, starred: boolean): Promise<void>;
+    /**
+     * Toggle the is_pinned field on a note.
+     */
+    pin(id: string, pinned: boolean): Promise<void>;
+    /**
+     * Toggle the is_archived field on a note.
+     */
+    archive(id: string, archived: boolean): Promise<void>;
+    /**
+     * Get revision history for a note, ordered by revision_number descending.
+     */
+    getRevisions(noteId: string): Promise<NoteRevision[]>;
+}
+
+/**
+ * SearchRepository — full-text search using DatabaseClient tsvector/tsquery,
+ * with optional semantic search (pgvector) and hybrid (BM25 + vector RRF).
+ *
+ * Search strategy:
+ *  - Title match uses the STORED tsvector column (weight A).
+ *  - Content match uses an ad-hoc to_tsvector on note_revised_current.content (weight B).
+ *  - ts_rank combines both weighted vectors to rank title matches higher.
+ *  - ts_headline generates highlighted snippets from content.
+ *  - Empty / whitespace-only queries fall back to returning recent notes.
+ *  - semanticSearch uses pgvector cosine distance (<=>).
+ *  - hybridSearch combines BM25 and vector with Reciprocal Rank Fusion (k=60).
+ *  - Quoted phrases use phraseto_tsquery for exact phrase matching.
+ *
+ * @implements #64 semantic and hybrid search
+ * @implements #77 correct mode field
+ * @implements #79 date range filter
+ * @implements #80 starred/archived filters
+ * @implements #81 format/source/visibility filters
+ * @implements #82 collection filter on semantic/hybrid
+ * @implements #83 phrase search
+ * @implements #87 shared condition builder
+ * @implements #89 search mode selector
+ * @implements #94 per-result embedding status
+ */
+
+declare class SearchRepository {
+    private db;
+    private semanticAvailable;
+    constructor(db: DatabaseClient, semanticAvailable?: boolean);
+    /** Select tsquery function based on whether query contains quoted phrases */
+    private tsqueryFn;
+    /** Returns a Set of note IDs that have an embedding record */
+    private fetchEmbeddingSet;
+    /** Attach has_embedding to each SearchResult using the provided embedding set */
+    private attachEmbeddingStatus;
+    search(query: string, options?: SearchOptions, queryEmbedding?: number[]): Promise<SearchResponse>;
+    /**
+     * Semantic search using pgvector cosine distance.
+     * Returns notes ranked by vector similarity to the query embedding.
+     */
+    semanticSearch(queryEmbedding: number[], options?: SearchOptions): Promise<SearchResponse>;
+    /**
+     * Hybrid search combining BM25 (full-text) and vector similarity using
+     * Reciprocal Rank Fusion (RRF, k=60).
+     */
+    hybridSearch(query: string, queryEmbedding: number[], options?: SearchOptions): Promise<SearchResponse>;
+    private recentNotes;
+    /**
+     * Fetch faceted aggregate counts for tags and collections across all matching note IDs.
+     * Uses the full (unpaginated) result set for accurate counts.
+     */
+    private fetchFacets;
+    private fetchTagMap;
+}
+
+/**
+ * Shared SQL condition builder for note filtering.
+ * Used by both SearchRepository and NotesRepository to prevent drift
+ * when adding new filter fields.
+ *
+ * @implements #87 shared condition builder
+ */
+
+interface ConditionResult {
+    conditions: string[];
+    params: unknown[];
+    nextIdx: number;
+}
+/**
+ * Build WHERE clause conditions for note filtering.
+ * Generates parameterized SQL conditions for all shared filter fields.
+ *
+ * @param options - Filter options (any subset of SearchOptions fields)
+ * @param startIdx - Starting parameter index ($N)
+ * @param includeDeleted - Whether to include soft-deleted notes (default: false)
+ */
+declare function buildNoteConditions(options: Pick<SearchOptions, 'tags' | 'collection_id' | 'date_from' | 'date_to' | 'is_starred' | 'is_archived' | 'format' | 'source' | 'visibility'>, startIdx: number, includeDeleted?: boolean): ConditionResult;
+
+/**
+ * Job queue worker — polls job_queue for pending jobs, dispatches to registered
+ * handlers, manages status transitions and exponential backoff retries.
+ *
+ * Job types and priorities (lower = runs first):
+ *   ai_revision:        1  (LLM enriches content first, requires llm)
+ *   title_generation:   2  (generate title from enriched content)
+ *   embedding:          3  (vectorize final content, requires semantic)
+ *   concept_tagging:    4  (extract concepts from enriched content, requires llm)
+ *   linking:            5  (find related notes, requires embeddings to exist)
+ */
+
+interface JobQueueOptions {
+    /** How often to poll for new jobs (ms). Default: 5000 */
+    pollIntervalMs?: number;
+    /** Global max retries used when job.max_retries is 0. Default: 3 */
+    maxRetries?: number;
+    /** Base delay for exponential backoff (ms). Default: 1000 */
+    backoffBaseMs?: number;
+    /** Maximum backoff delay cap (ms). Default: 300000 (5 min) */
+    backoffMaxMs?: number;
+}
+interface Job {
+    id: string;
+    note_id: string;
+    job_type: string;
+    status: string;
+    priority: number;
+    required_capability: string | null;
+    retry_count: number;
+    max_retries: number;
+    error: string | null;
+    result: unknown | null;
+    created_at: Date;
+    updated_at: Date;
+}
+type JobHandler = (job: Job, db: DatabaseClient) => Promise<unknown>;
+/** Job types listed in execution priority order (lower number = runs first) */
+type JobType = 'ai_revision' | 'title_generation' | 'embedding' | 'concept_tagging' | 'linking';
+/**
+ * Job priorities — lower number = runs first.
+ * Correct dependency order:
+ *   1. ai_revision — LLM enriches content first
+ *   2. title_generation — generate title from enriched content
+ *   3. embedding — vectorize final content
+ *   4. concept_tagging — extract concepts from enriched content
+ *   5. linking — find related notes (requires embeddings to exist)
+ */
+declare const JOB_PRIORITIES: Record<JobType, number>;
+declare const JOB_CAPABILITIES: Partial<Record<JobType, string>>;
+interface EnqueueJobInput {
+    noteId: string;
+    jobType: JobType;
+    priority?: number;
+    requiredCapability?: string | null;
+}
+/** Enqueue a job into the job_queue table. Returns the new job ID. */
+declare function enqueueJob(db: DatabaseClient, input: EnqueueJobInput): Promise<string>;
+/** Enqueue the note creation pipeline: revision → title → embedding. */
+declare function enqueueNoteCreationJobs(db: DatabaseClient, noteId: string, hasTitle: boolean): Promise<void>;
+/**
+ * Enqueue the complete workflow for a note.
+ * Order: revision → title → embedding → concepts → linking.
+ * Jobs run in priority order so each step has the richest content available.
+ */
+declare function enqueueFullWorkflow(db: DatabaseClient, noteId: string): Promise<void>;
+interface JobStatus {
+    id: string;
+    note_id: string;
+    job_type: string;
+    status: string;
+    priority: number;
+    required_capability: string | null;
+    retry_count: number;
+    max_retries: number;
+    error: string | null;
+    result: unknown | null;
+    created_at: Date;
+    updated_at: Date;
+}
+/** Query job queue status. Optionally filter by note_id. */
+declare function getJobQueueStatus(db: DatabaseClient, noteId?: string): Promise<JobStatus[]>;
+declare class JobQueueWorker {
+    private db;
+    private events?;
+    private capabilityManager?;
+    private handlers;
+    private running;
+    private timer;
+    private options;
+    constructor(db: DatabaseClient, events?: TypedEventBus | undefined, options?: JobQueueOptions, capabilityManager?: CapabilityManager | undefined);
+    registerHandler(jobType: string, handler: JobHandler): void;
+    start(): Promise<void>;
+    /** Reset any 'processing' jobs back to 'pending' — they were interrupted by a restart */
+    private recoverStaleJobs;
+    stop(): void;
+    /** Process one batch of pending jobs. Useful for testing without polling. */
+    processOnce(): Promise<number>;
+    private poll;
+    private processPendingJobs;
+    getBackoffDelay(retryCount: number): number;
+}
+/** Title generation: LLM first, fallback to first-line extraction */
+declare function titleGenerationHandler(job: Job, db: DatabaseClient): Promise<unknown>;
+/** AI revision: LLM enhances note content, creates a revision record */
+declare function aiRevisionHandler(job: Job, db: DatabaseClient): Promise<unknown>;
+/** Concept tagging: LLM extracts SKOS concepts from revised content */
+declare function conceptTaggingHandler(job: Job, db: DatabaseClient): Promise<unknown>;
+/** Linking: find semantically related notes using FTS + vector RRF */
+declare function linkingHandler(job: Job, db: DatabaseClient): Promise<unknown>;
+
+/**
+ * TagsRepository — free-form tag management for notes.
+ *
+ * Responsibilities:
+ * - Add and remove tags from notes
+ * - Look up tags by note or notes by tag
+ * - List all tags with usage counts
+ */
+
+declare class TagsRepository {
+    private db;
+    constructor(db: DatabaseClient);
+    addTag(noteId: string, tag: string): Promise<void>;
+    removeTag(noteId: string, tag: string): Promise<void>;
+    getTagsForNote(noteId: string): Promise<string[]>;
+    getNotesForTag(tag: string): Promise<string[]>;
+    listAllTags(): Promise<Array<{
+        tag: string;
+        count: number;
+    }>>;
+}
+
+/**
+ * CollectionsRepository — folder/category management for notes.
+ *
+ * Responsibilities:
+ * - Create, read, update, and soft-delete collections
+ * - Prevent circular parent references
+ * - Assign and unassign notes from collections
+ * - Return flat list and shallow tree views
+ */
+
+interface CollectionRow {
+    id: string;
+    name: string;
+    description: string | null;
+    parent_id: string | null;
+    position: number;
+    created_at: Date;
+    updated_at: Date;
+    deleted_at: Date | null;
+}
+interface CollectionCreateInput {
+    name: string;
+    description?: string;
+    parent_id?: string;
+}
+declare class CollectionsRepository {
+    private db;
+    constructor(db: DatabaseClient);
+    create(input: CollectionCreateInput): Promise<CollectionRow>;
+    get(id: string): Promise<CollectionRow>;
+    list(): Promise<CollectionRow[]>;
+    listTree(): Promise<Array<CollectionRow & {
+        children: CollectionRow[];
+    }>>;
+    update(id: string, fields: Partial<Pick<CollectionRow, 'name' | 'description' | 'parent_id' | 'position'>>): Promise<CollectionRow>;
+    delete(id: string): Promise<void>;
+    assignNote(collectionId: string, noteId: string): Promise<void>;
+    unassignNote(collectionId: string, noteId: string): Promise<void>;
+    getNotesInCollection(collectionId: string): Promise<string[]>;
+}
+
+/**
+ * LinksRepository — bidirectional note link management.
+ *
+ * Responsibilities:
+ * - Create typed links between notes with duplicate prevention
+ * - Soft-delete links
+ * - Query outbound, inbound, and backlinks for a note
+ */
+
+interface LinkRow {
+    id: string;
+    source_note_id: string;
+    target_note_id: string;
+    link_type: string;
+    confidence: number | null;
+    created_at: Date;
+    updated_at: Date | null;
+    deleted_at: Date | null;
+}
+declare class LinksRepository {
+    private db;
+    constructor(db: DatabaseClient);
+    create(sourceNoteId: string, targetNoteId: string, linkType?: string): Promise<LinkRow>;
+    get(id: string): Promise<LinkRow>;
+    listForNote(noteId: string): Promise<{
+        outbound: LinkRow[];
+        inbound: LinkRow[];
+    }>;
+    getBacklinks(noteId: string): Promise<string[]>;
+    delete(id: string): Promise<void>;
+}
+
+/**
+ * SkosRepository — SKOS taxonomy management (schemes, concepts, relations).
+ *
+ * Responsibilities:
+ * - Create and soft-delete SKOS schemes (taxonomy containers)
+ * - Create, list, and soft-delete SKOS concepts within schemes
+ * - Create and query broader/narrower/related concept relations
+ */
+
+interface SkosScheme {
+    id: string;
+    title: string;
+    description: string | null;
+    created_at: Date;
+    updated_at: Date;
+    deleted_at: Date | null;
+}
+interface SkosConcept {
+    id: string;
+    scheme_id: string;
+    pref_label: string;
+    alt_labels: string[];
+    definition: string | null;
+    created_at: Date;
+    updated_at: Date;
+    deleted_at: Date | null;
+}
+interface SkosRelation {
+    id: string;
+    source_concept_id: string;
+    target_concept_id: string;
+    relation_type: string;
+    created_at: Date;
+}
+declare class SkosRepository {
+    private db;
+    constructor(db: DatabaseClient);
+    createScheme(title: string, description?: string): Promise<SkosScheme>;
+    listSchemes(): Promise<SkosScheme[]>;
+    deleteScheme(id: string): Promise<void>;
+    createConcept(schemeId: string, prefLabel: string, options?: {
+        altLabels?: string[];
+        definition?: string;
+    }): Promise<SkosConcept>;
+    listConcepts(schemeId: string): Promise<SkosConcept[]>;
+    deleteConcept(id: string): Promise<void>;
+    createRelation(sourceConceptId: string, targetConceptId: string, relationType: 'broader' | 'narrower' | 'related'): Promise<SkosRelation>;
+    getRelations(conceptId: string): Promise<SkosRelation[]>;
+}
+
+/**
+ * captureKnowledge — tool function for creating notes.
+ *
+ * Supports three sub-actions:
+ *   create        — create a single note from content
+ *   bulk_create   — create multiple notes in sequence
+ *   from_template — interpolate a template string and create a note
+ *
+ * Input is Zod-validated at entry. All writes delegate to NotesRepository.
+ */
+
+interface CaptureKnowledgeResult {
+    action: string;
+    notes: NoteFull[];
+}
+declare function captureKnowledge(db: DatabaseClient, rawInput: unknown, events?: TypedEventBus): Promise<CaptureKnowledgeResult>;
+
+/**
+ * manageNote — tool function for note lifecycle operations.
+ *
+ * Supports: update, delete, restore, archive, unarchive, star, unstar.
+ *
+ * Input is Zod-validated at entry. All mutations delegate to NotesRepository.
+ */
+
+interface ManageNoteResult {
+    action: string;
+    note_id: string;
+    note?: NoteFull;
+}
+declare function manageNote(db: DatabaseClient, rawInput: unknown, events?: TypedEventBus): Promise<ManageNoteResult>;
+
+/**
+ * searchTool — tool function wrapping SearchRepository.
+ *
+ * Only 'text' mode is currently supported. Semantic and hybrid modes throw a
+ * descriptive error so callers can surface appropriate feedback.
+ *
+ * Input is Zod-validated at entry.
+ */
+
+declare function searchTool(db: DatabaseClient, rawInput: unknown): Promise<SearchResponse>;
+
+/**
+ * Zod schemas for tool function inputs.
+ *
+ * These schemas are the contract between callers (e.g. Plinyverse bridge) and
+ * the tool functions. All inputs are validated at the tool boundary so that
+ * repository methods only receive well-typed data.
+ */
+
+declare const CaptureKnowledgeInputSchema: z.ZodObject<{
+    action: z.ZodEnum<["create", "bulk_create", "from_template"]>;
+    content: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    format: z.ZodDefault<z.ZodEnum<["markdown", "plain", "html"]>>;
+    source: z.ZodDefault<z.ZodString>;
+    visibility: z.ZodDefault<z.ZodEnum<["private", "shared", "public"]>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    archive_id: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        content: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        format: z.ZodDefault<z.ZodEnum<["markdown", "plain", "html"]>>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        format: "markdown" | "plain" | "html";
+        content: string;
+        title?: string | undefined;
+        tags?: string[] | undefined;
+    }, {
+        content: string;
+        title?: 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" | "shared" | "public";
+    action: "create" | "bulk_create" | "from_template";
+    title?: string | undefined;
+    archive_id?: string | undefined;
+    tags?: string[] | undefined;
+    content?: string | undefined;
+    notes?: {
+        format: "markdown" | "plain" | "html";
+        content: string;
+        title?: string | undefined;
+        tags?: string[] | undefined;
+    }[] | undefined;
+    template?: string | undefined;
+    variables?: Record<string, string> | undefined;
+}, {
+    action: "create" | "bulk_create" | "from_template";
+    source?: string | undefined;
+    title?: string | undefined;
+    archive_id?: string | undefined;
+    format?: "markdown" | "plain" | "html" | undefined;
+    visibility?: "private" | "shared" | "public" | undefined;
+    tags?: string[] | undefined;
+    content?: string | undefined;
+    notes?: {
+        content: string;
+        title?: string | undefined;
+        format?: "markdown" | "plain" | "html" | undefined;
+        tags?: string[] | undefined;
+    }[] | undefined;
+    template?: string | undefined;
+    variables?: Record<string, string> | undefined;
+}>;
+type CaptureKnowledgeInput = z.infer<typeof CaptureKnowledgeInputSchema>;
+declare const ManageNoteInputSchema: z.ZodObject<{
+    action: z.ZodEnum<["update", "delete", "restore", "archive", "unarchive", "star", "unstar"]>;
+    note_id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodString>;
+    visibility: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    action: "update" | "delete" | "restore" | "archive" | "unarchive" | "star" | "unstar";
+    note_id: string;
+    title?: string | undefined;
+    format?: string | undefined;
+    visibility?: string | undefined;
+    content?: string | undefined;
+}, {
+    action: "update" | "delete" | "restore" | "archive" | "unarchive" | "star" | "unstar";
+    note_id: string;
+    title?: string | undefined;
+    format?: string | undefined;
+    visibility?: string | undefined;
+    content?: string | undefined;
+}>;
+type ManageNoteInput = z.infer<typeof ManageNoteInputSchema>;
+declare const SearchInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<["text", "semantic", "hybrid"]>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    collection_id: z.ZodOptional<z.ZodString>;
+    date_from: z.ZodOptional<z.ZodDate>;
+    date_to: z.ZodOptional<z.ZodDate>;
+    is_starred: z.ZodOptional<z.ZodBoolean>;
+    is_archived: z.ZodOptional<z.ZodBoolean>;
+    format: z.ZodOptional<z.ZodEnum<["markdown", "plain", "html"]>>;
+    source: z.ZodOptional<z.ZodString>;
+    visibility: z.ZodOptional<z.ZodEnum<["private", "shared", "public"]>>;
+    include_facets: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+    include_facets: boolean;
+    mode: "semantic" | "text" | "hybrid";
+    query: string;
+    source?: string | undefined;
+    format?: "markdown" | "plain" | "html" | 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;
+}, {
+    query: string;
+    source?: string | undefined;
+    format?: "markdown" | "plain" | "html" | 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?: "semantic" | "text" | "hybrid" | undefined;
+}>;
+type SearchInput = z.infer<typeof SearchInputSchema>;
+
+/**
+ * FortemiToolManifest — registry of all Mnemos tool definitions.
+ *
+ * Defines the full set of tool schemas and provides PlinyCapability
+ * projection for bridge registration. Each tool definition follows the
+ * WHEN/WHAT/HOW/OUT description pattern so consumers understand call sites.
+ *
+ * The 10 tools defined here are the initial subset covering core Mnemos
+ * operations. Additional tools will be added incrementally as repositories
+ * are implemented.
+ */
+
+interface FortemiToolDefinition {
+    id: string;
+    name: string;
+    description: string;
+    category: 'capture' | 'search' | 'manage' | 'organize' | 'process' | 'analyze' | 'system';
+    inputSchema: ZodType;
+    tags: string[];
+    sideEffects: boolean;
+    requiredCapability?: string;
+}
+interface PlinyCapability {
+    id: string;
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    tags: string[];
+    sideEffects: boolean;
+}
+declare class FortemiToolManifest {
+    private tools;
+    constructor();
+    /** Look up a single tool by its fully-qualified id. */
+    get(id: string): FortemiToolDefinition | undefined;
+    /** Return all registered tools as a snapshot array. */
+    list(): FortemiToolDefinition[];
+    /** Return tools matching a custom predicate. */
+    filter(predicate: (tool: FortemiToolDefinition) => boolean): FortemiToolDefinition[];
+    /** Return tools belonging to a specific category. */
+    byCategory(category: string): FortemiToolDefinition[];
+    /**
+     * Full-text search across tool name, description, and tags.
+     * Case-insensitive.
+     */
+    search(query: string): FortemiToolDefinition[];
+    /** Project all tools as PlinyCapability entries for bridge registration. */
+    toPlinyCapabilities(): PlinyCapability[];
+    /** Return the count of tools in each category. */
+    getCategoryCounts(): Record<string, number>;
+}
+declare const fortemiManifest: FortemiToolManifest;
+
+declare const GetNoteInputSchema: z.ZodObject<{
+    note_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    note_id: string;
+}, {
+    note_id: string;
+}>;
+type GetNoteInput = z.infer<typeof GetNoteInputSchema>;
+declare function getNote(db: DatabaseClient, rawInput: unknown, events?: TypedEventBus): Promise<NoteFull>;
+
+declare const ListNotesInputSchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    sort: z.ZodDefault<z.ZodEnum<["created_at", "updated_at", "title"]>>;
+    order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+    is_starred: z.ZodOptional<z.ZodBoolean>;
+    is_archived: z.ZodOptional<z.ZodBoolean>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    collection_id: z.ZodOptional<z.ZodString>;
+    include_deleted: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+    sort: "created_at" | "updated_at" | "title";
+    order: "asc" | "desc";
+    is_starred?: boolean | undefined;
+    is_archived?: boolean | undefined;
+    tags?: string[] | undefined;
+    include_deleted?: boolean | undefined;
+    collection_id?: string | undefined;
+}, {
+    is_starred?: boolean | undefined;
+    is_archived?: boolean | undefined;
+    tags?: string[] | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    sort?: "created_at" | "updated_at" | "title" | undefined;
+    order?: "asc" | "desc" | undefined;
+    include_deleted?: boolean | undefined;
+    collection_id?: string | undefined;
+}>;
+type ListNotesInput = z.infer<typeof ListNotesInputSchema>;
+declare function listNotes(db: DatabaseClient, rawInput: unknown, events?: TypedEventBus): Promise<PaginatedResult<NoteSummary>>;
+
+declare const ManageTagsInputSchema: z.ZodObject<{
+    action: z.ZodEnum<["add", "remove", "list_for_note", "list_all"]>;
+    note_id: z.ZodOptional<z.ZodString>;
+    tag: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    action: "add" | "remove" | "list_for_note" | "list_all";
+    note_id?: string | undefined;
+    tag?: string | undefined;
+}, {
+    action: "add" | "remove" | "list_for_note" | "list_all";
+    note_id?: string | undefined;
+    tag?: string | undefined;
+}>;
+type ManageTagsInput = z.infer<typeof ManageTagsInputSchema>;
+interface ManageTagsResult {
+    action: string;
+    tags?: string[];
+    all_tags?: Array<{
+        tag: string;
+        count: number;
+    }>;
+}
+declare function manageTags(db: DatabaseClient, rawInput: unknown): Promise<ManageTagsResult>;
+
+declare const ManageCollectionsInputSchema: z.ZodObject<{
+    action: z.ZodEnum<["create", "list", "list_tree", "assign", "unassign", "delete"]>;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    parent_id: z.ZodOptional<z.ZodString>;
+    collection_id: z.ZodOptional<z.ZodString>;
+    note_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    action: "create" | "delete" | "list" | "assign" | "unassign" | "list_tree";
+    name?: string | undefined;
+    collection_id?: string | undefined;
+    description?: string | undefined;
+    parent_id?: string | undefined;
+    note_id?: string | undefined;
+}, {
+    action: "create" | "delete" | "list" | "assign" | "unassign" | "list_tree";
+    name?: string | undefined;
+    collection_id?: string | undefined;
+    description?: string | undefined;
+    parent_id?: string | undefined;
+    note_id?: string | undefined;
+}>;
+type ManageCollectionsInput = z.infer<typeof ManageCollectionsInputSchema>;
+interface ManageCollectionsResult {
+    action: string;
+    collection?: CollectionRow;
+    collections?: CollectionRow[];
+    tree?: Array<CollectionRow & {
+        children: CollectionRow[];
+    }>;
+    collection_id?: string;
+    note_id?: string;
+}
+declare function manageCollections(db: DatabaseClient, rawInput: unknown): Promise<ManageCollectionsResult>;
+
+declare const ManageLinksInputSchema: z.ZodObject<{
+    action: z.ZodEnum<["create", "list", "backlinks", "delete"]>;
+    source_note_id: z.ZodOptional<z.ZodString>;
+    target_note_id: z.ZodOptional<z.ZodString>;
+    link_id: z.ZodOptional<z.ZodString>;
+    link_type: z.ZodDefault<z.ZodString>;
+    note_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    action: "create" | "delete" | "list" | "backlinks";
+    link_type: string;
+    note_id?: string | undefined;
+    source_note_id?: string | undefined;
+    target_note_id?: string | undefined;
+    link_id?: string | undefined;
+}, {
+    action: "create" | "delete" | "list" | "backlinks";
+    note_id?: string | undefined;
+    source_note_id?: string | undefined;
+    target_note_id?: string | undefined;
+    link_id?: string | undefined;
+    link_type?: string | undefined;
+}>;
+type ManageLinksInput = z.infer<typeof ManageLinksInputSchema>;
+interface ManageLinksResult {
+    action: string;
+    link?: LinkRow;
+    outbound?: LinkRow[];
+    inbound?: LinkRow[];
+    backlinks?: string[];
+    link_id?: string;
+}
+declare function manageLinks(db: DatabaseClient, rawInput: unknown): Promise<ManageLinksResult>;
+
+declare const ManageArchiveInputSchema: z.ZodObject<{
+    action: z.ZodEnum<["list", "create", "switch", "delete"]>;
+    name: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    action: "create" | "delete" | "list" | "switch";
+    name?: string | undefined;
+}, {
+    action: "create" | "delete" | "list" | "switch";
+    name?: string | undefined;
+}>;
+type ManageArchiveInput = z.infer<typeof ManageArchiveInputSchema>;
+interface ManageArchiveResult {
+    action: string;
+    archives?: ArchiveInfo[];
+    current?: string;
+    name?: string;
+}
+declare function manageArchive(archiveManager: ArchiveManager, rawInput: unknown): Promise<ManageArchiveResult>;
+
+declare const ManageCapabilitiesInputSchema: z.ZodObject<{
+    action: z.ZodEnum<["list", "enable", "disable", "status"]>;
+    capability: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    action: "enable" | "disable" | "status" | "list";
+    capability?: string | undefined;
+}, {
+    action: "enable" | "disable" | "status" | "list";
+    capability?: string | undefined;
+}>;
+type ManageCapabilitiesInput = z.infer<typeof ManageCapabilitiesInputSchema>;
+interface CapabilityInfo {
+    name: CapabilityName;
+    state: CapabilityState;
+    error?: string;
+}
+interface ManageCapabilitiesResult {
+    action: string;
+    capabilities?: Array<{
+        name: CapabilityName;
+        state: CapabilityState;
+    }>;
+    capability?: CapabilityInfo;
+}
+declare function manageCapabilities(capabilityManager: CapabilityManager, rawInput: unknown): Promise<ManageCapabilitiesResult>;
+
+/**
+ * AttachmentsRepository — attach and retrieve binary files linked to notes.
+ *
+ * Responsibilities:
+ * - Content-addressed blob deduplication via SHA-256 hash
+ * - Store blob metadata in DatabaseClient (attachment_blob table)
+ * - Store binary data in a BlobStore implementation
+ * - Create/soft-delete attachment records linked to notes
+ * - List active attachments for a note
+ */
+
+interface AttachmentRow {
+    id: string;
+    note_id: string;
+    blob_id: string;
+    document_type_id: string | null;
+    filename: string;
+    display_name: string | null;
+    position: number;
+    created_at: Date;
+    deleted_at: Date | null;
+}
+interface AttachmentBlobRow {
+    id: string;
+    content_hash: string;
+    size_bytes: number;
+    storage_path: string | null;
+    created_at: Date;
+}
+interface AttachInput {
+    noteId: string;
+    data: Uint8Array;
+    filename: string;
+    mimeType?: string;
+    displayName?: string;
+}
+declare class AttachmentsRepository {
+    private db;
+    private blobStore;
+    constructor(db: DatabaseClient, blobStore: BlobStore);
+    /**
+     * Attach a binary file to a note.
+     *
+     * If a blob with the same SHA-256 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.
+     *
+     * Returns the newly created AttachmentRow.
+     */
+    attach(input: AttachInput): Promise<AttachmentRow>;
+    /**
+     * Fetch an attachment row by its ID.
+     * Throws when no row exists.
+     */
+    get(id: string): Promise<AttachmentRow>;
+    /**
+     * Retrieve the raw binary data for an attachment.
+     * Returns null if the blob cannot be found in the BlobStore.
+     */
+    getBlob(attachmentId: string): Promise<Uint8Array | null>;
+    /**
+     * List active (non-deleted) attachments for a note.
+     * Ordered by position ascending, then created_at ascending.
+     */
+    list(noteId: string): Promise<AttachmentRow[]>;
+    /**
+     * Soft-delete an attachment by setting deleted_at to the current timestamp.
+     * The underlying blob row and BlobStore data are not removed.
+     */
+    delete(id: string): Promise<void>;
+}
+
+declare const ManageAttachmentsInputSchema: z.ZodObject<{
+    action: z.ZodEnum<["attach", "list", "get", "get_blob", "delete"]>;
+    note_id: z.ZodOptional<z.ZodString>;
+    attachment_id: z.ZodOptional<z.ZodString>;
+    /** Base64-encoded file data for the 'attach' action */
+    data_base64: z.ZodOptional<z.ZodString>;
+    filename: z.ZodOptional<z.ZodString>;
+    mime_type: z.ZodOptional<z.ZodString>;
+    display_name: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    action: "delete" | "list" | "attach" | "get" | "get_blob";
+    filename?: string | undefined;
+    note_id?: string | undefined;
+    attachment_id?: string | undefined;
+    data_base64?: string | undefined;
+    mime_type?: string | undefined;
+    display_name?: string | undefined;
+}, {
+    action: "delete" | "list" | "attach" | "get" | "get_blob";
+    filename?: string | undefined;
+    note_id?: string | undefined;
+    attachment_id?: string | undefined;
+    data_base64?: string | undefined;
+    mime_type?: string | undefined;
+    display_name?: string | undefined;
+}>;
+type ManageAttachmentsInput = z.infer<typeof ManageAttachmentsInputSchema>;
+interface ManageAttachmentsResult {
+    action: string;
+    attachment?: AttachmentRow;
+    attachments?: AttachmentRow[];
+    attachment_id?: string;
+    /** Base64-encoded blob data for 'get_blob' action */
+    data_base64?: string;
+    size_bytes?: number;
+}
+declare function manageAttachments(db: DatabaseClient, blobStore: BlobStore, rawInput: unknown): Promise<ManageAttachmentsResult>;
+
+/**
+ * GPU capability detection for WebGPU-based LLM inference.
+ * Used to select appropriate model tier based on available GPU memory.
+ *
+ * @implements #61 GPU capability detection
+ */
+interface GpuCapabilities {
+    webgpuAvailable: boolean;
+    vendor: string;
+    architecture: string;
+    maxBufferSizeBytes: number;
+    supportsF16: boolean;
+}
+type VramTier = 'low' | 'medium' | 'high' | 'unknown';
+declare function detectGpuCapabilities(): Promise<GpuCapabilities>;
+declare function estimateVramTier(caps: GpuCapabilities): VramTier;
+/**
+ * Select an LLM model based on VRAM tier and f16 shader support.
+ * Uses f32 quantization when f16 shaders aren't available (e.g., SwiftShader).
+ */
+declare function selectLlmModel(tier: VramTier, supportsF16?: boolean): string;
+
+/**
+ * Enhanced inference capability detection.
+ * Extends gpu-detect.ts with VRAM estimation, model fit, Chrome AI, and WebNN detection.
+ *
+ * @implements #115 hardware capability detection improvements
+ */
+
+type RecommendedTier = 'high' | 'medium' | 'low' | 'cpu-only';
+interface InferenceCapabilities {
+    webgpu: boolean;
+    wasm: boolean;
+    webnn: boolean;
+    sharedArrayBuffer: boolean;
+    chromeAI: boolean;
+    estimatedVramMB: number;
+    recommendedTier: RecommendedTier;
+    gpu: GpuCapabilities;
+    vramTier: VramTier;
+}
+interface ModelFitResult {
+    fits: boolean;
+    estimatedVramMB: number;
+    availableVramMB: number;
+    recommendation: string;
+}
+/**
+ * Estimate VRAM in MB using known GPU heuristics.
+ * Falls back to maxBufferSize-based estimation if no match.
+ */
+declare function estimateVramMB(gpu: GpuCapabilities): number;
+/**
+ * Estimate whether a model will fit in available VRAM.
+ */
+declare function estimateModelFit(modelSizeMB: number, availableVramMB: number): ModelFitResult;
+/**
+ * Comprehensive inference capability detection.
+ * Superset of detectGpuCapabilities() — adds VRAM estimation, WebNN, Chrome AI, etc.
+ */
+declare function detectInferenceCapabilities(): Promise<InferenceCapabilities>;
+
+/**
+ * Text chunking utility for embedding generation.
+ * Splits long text into overlapping chunks suitable for embedding models.
+ *
+ * @implements #63 embedding pipeline prerequisite
+ */
+/** Split text into overlapping chunks for embedding. */
+declare function chunkText(text: string, maxChars?: number, overlap?: number): string[];
+
+/**
+ * Embedding generation job handler.
+ * Generates and stores vector embeddings for note content.
+ * Embed function is injected via setEmbedFunction — no WASM loaded by default.
+ *
+ * @implements #63 embedding generation
+ */
+
+/** Type for the embed function — injected by the semantic capability module */
+type EmbedFunction = (texts: string[]) => Promise<number[][]>;
+declare function setEmbedFunction(fn: EmbedFunction | null): void;
+declare function getEmbedFunction(): EmbedFunction | null;
+/** Job handler for embedding generation. Registered in JobQueueWorker. */
+declare function embeddingGenerationHandler(job: {
+    note_id: string;
+}, db: DatabaseClient): Promise<unknown>;
+
+/**
+ * LLM completion function injection.
+ * Provides the slot for an LLM function — injected by the llm capability module.
+ * No model loading by default (CAP-001).
+ *
+ * @implements #66 AI title generation
+ */
+/** Type for the LLM completion function — injected by the llm capability module */
+type LlmCompleteFn = (prompt: string, options?: {
+    maxTokens?: number;
+    temperature?: number;
+}) => Promise<string>;
+declare function setLlmFunction(fn: LlmCompleteFn | null): void;
+declare function getLlmFunction(): LlmCompleteFn | null;
+
+/**
+ * Auto-tagging utility using embedding similarity.
+ * Suggests tags based on cosine similarity between note and tag vocabulary embeddings.
+ *
+ * @implements #67 auto-tagging
+ */
+/** Cosine similarity between two normalized vectors (dot product) */
+declare function cosineSimilarity(a: number[], b: number[]): number;
+/**
+ * Suggest tags based on embedding similarity to tag vocabulary centroids.
+ * Returns tags sorted by descending similarity score, filtered by threshold.
+ */
+declare function suggestTags(noteEmbedding: number[], tagEmbeddings: Map<string, number[]>, threshold?: number, maxTags?: number): string[];
+
+/**
+ * Semantic capability loader — registers the embedding pipeline with CapabilityManager.
+ *
+ * In production (browser), this loads @huggingface/transformers in a Web Worker.
+ * In tests, call registerSemanticCapability() with a mock embed function.
+ *
+ * @implements #62 semantic capability loader
+ */
+
+/**
+ * Register the semantic capability with a CapabilityManager.
+ * The loader will be called when capabilityManager.enable('semantic') is invoked.
+ *
+ * @param manager - The CapabilityManager instance
+ * @param embedFn - The embedding function (from transformers.js worker or mock)
+ * @param onProgress - Optional progress callback for model download
+ */
+declare function registerSemanticCapability(manager: CapabilityManager, embedFn: EmbedFunction, onProgress?: (pct: number) => void): void;
+/**
+ * Unregister the semantic capability — clears the embed function.
+ * Called when the capability is disabled.
+ */
+declare function unregisterSemanticCapability(): void;
+
+/**
+ * LLM capability loader — registers the local LLM with CapabilityManager.
+ *
+ * In production (browser), this loads @mlc-ai/web-llm in a Web Worker.
+ * In tests, call registerLlmCapability() with a mock completion function.
+ *
+ * @implements #65 LLM capability loader
+ */
+
+interface LlmCapabilityOptions {
+    modelOverride?: string;
+    onProgress?: (pct: number, text: string) => void;
+}
+/**
+ * Register the LLM capability with a CapabilityManager.
+ * The loader checks WebGPU availability before loading.
+ *
+ * @param manager - The CapabilityManager instance
+ * @param completeFn - The LLM completion function (from WebLLM worker or mock)
+ * @param options - Optional model override and progress callback
+ */
+declare function registerLlmCapability(manager: CapabilityManager, completeFn: LlmCompleteFn, options?: LlmCapabilityOptions): void;
+/**
+ * Unregister the LLM capability — clears the completion function.
+ */
+declare function unregisterLlmCapability(): void;
+
+/**
+ * Formal InferenceProvider interface.
+ * Core contract for all inference providers — remote APIs, local servers, in-browser models.
+ * Core stays dependency-free: interface only, no implementations.
+ *
+ * @implements #112 formal InferenceProvider interface
+ */
+interface ProviderCapabilities {
+    embeddings: boolean;
+    chat: boolean;
+    streaming: boolean;
+    vision: boolean;
+    toolCalling: boolean;
+    structuredOutput: boolean;
+    maxContextTokens?: number;
+}
+interface EmbedRequest {
+    texts: string[];
+    model?: string;
+}
+interface EmbedResponse {
+    vectors: number[][];
+    model: string;
+    usage?: {
+        totalTokens: number;
+    };
+}
+interface CompletionRequest {
+    prompt: string;
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+    systemPrompt?: string;
+    stopSequences?: string[];
+}
+interface CompletionResponse {
+    text: string;
+    model: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+    };
+    finishReason?: 'stop' | 'length' | 'content_filter';
+}
+interface StreamChunk {
+    text: string;
+    done: boolean;
+}
+interface ModelInfo {
+    id: string;
+    name?: string;
+    capabilities: Partial<ProviderCapabilities>;
+    contextWindow?: number;
+    owned_by?: string;
+}
+type ProbeStatus = 'ok' | 'degraded' | 'down';
+interface ProbeResult {
+    status: ProbeStatus;
+    latencyMs: number;
+    message?: string;
+}
+type ProviderTier = 'remote' | 'local-server' | 'in-browser' | 'chrome-ai';
+interface InferenceProvider {
+    readonly id: string;
+    readonly name: string;
+    readonly tier: ProviderTier;
+    readonly capabilities: ProviderCapabilities;
+    /** Generate embeddings for text inputs */
+    embed?(request: EmbedRequest): Promise<EmbedResponse>;
+    /** Generate a completion (non-streaming) */
+    complete?(request: CompletionRequest): Promise<CompletionResponse>;
+    /** Generate a streaming completion */
+    stream?(request: CompletionRequest): AsyncIterable<StreamChunk>;
+    /** List available models from this provider */
+    listModels(): Promise<ModelInfo[]>;
+    /** Health check — probe the provider */
+    probe(): Promise<ProbeResult>;
+    /** Clean up resources */
+    dispose(): void;
+}
+
+/**
+ * ProviderRegistry — manages InferenceProvider instances.
+ * Supports add/remove/getActive/setActive and derives CapabilityManager state.
+ *
+ * @implements #112 provider registry
+ */
+
+declare class ProviderRegistry {
+    private events?;
+    private providers;
+    private activeId;
+    constructor(events?: TypedEventBus | undefined);
+    /** Register a provider. First provider with embedding capability becomes active. */
+    add(provider: InferenceProvider): void;
+    /** Remove a provider by ID. If it was active, clears active. */
+    remove(id: string): void;
+    /** Set the active provider by ID */
+    setActive(id: string): void;
+    /** Get the currently active provider */
+    getActive(): InferenceProvider | null;
+    /** Get a provider by ID */
+    get(id: string): InferenceProvider | undefined;
+    /** List all registered providers */
+    list(): InferenceProvider[];
+    /** Get provider count */
+    get size(): number;
+    /** Check if any provider supports embeddings */
+    hasEmbeddings(): boolean;
+    /** Check if any provider supports chat */
+    hasChat(): boolean;
+    /** Find first provider supporting a given capability */
+    findByCapability(cap: keyof InferenceProvider['capabilities']): InferenceProvider | undefined;
+    /** Convenience: embed using active provider */
+    embed(request: EmbedRequest): Promise<EmbedResponse>;
+    /** Convenience: complete using active provider */
+    complete(request: CompletionRequest): Promise<CompletionResponse>;
+    /** Convenience: stream using active provider */
+    stream(request: CompletionRequest): AsyncIterable<StreamChunk>;
+    /** Dispose all providers */
+    dispose(): void;
+    /**
+     * Sync the legacy bare function slots with the active provider.
+     * This maintains backward compatibility: job-queue-worker.ts and other
+     * consumers that call getEmbedFunction() / getLlmFunction() still work.
+     */
+    private syncLegacyFunctions;
+}
+/**
+ * Create an InferenceProvider from legacy bare functions.
+ * Used by setEmbedFunction/setLlmFunction backward compat layer.
+ */
+declare function createLegacyProvider(options: {
+    embedFn?: EmbedFunction | null;
+    llmFn?: LlmCompleteFn | null;
+    id?: string;
+    name?: string;
+}): InferenceProvider;
+
+/**
+ * OpenAI-compatible inference provider.
+ * Works with OpenAI, OpenRouter, Anthropic (via OpenRouter), Ollama, LM Studio,
+ * llama.cpp, vLLM, Jan, and any OpenAI-compatible endpoint.
+ *
+ * No SDK dependencies — uses raw fetch() to keep @fortemi/core lightweight.
+ *
+ * @implements #113 remote provider support
+ */
+
+interface OpenAIProviderConfig {
+    id: string;
+    name: string;
+    baseURL: string;
+    apiKey?: string;
+    defaultModel?: string;
+    defaultEmbeddingModel?: string;
+    tier?: ProviderTier;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+}
+declare class OpenAICompatibleProvider implements InferenceProvider {
+    readonly id: string;
+    readonly name: string;
+    readonly tier: ProviderTier;
+    readonly capabilities: ProviderCapabilities;
+    private baseURL;
+    private apiKey?;
+    private defaultModel;
+    private defaultEmbeddingModel;
+    private extraHeaders;
+    private timeoutMs;
+    private abortController;
+    constructor(config: OpenAIProviderConfig);
+    embed(request: EmbedRequest): Promise<EmbedResponse>;
+    complete(request: CompletionRequest): Promise<CompletionResponse>;
+    stream(request: CompletionRequest): AsyncIterable<StreamChunk>;
+    listModels(): Promise<ModelInfo[]>;
+    probe(): Promise<ProbeResult>;
+    dispose(): void;
+    private buildMessages;
+    private mapFinishReason;
+    private isEmbeddingModel;
+    private isLocalURL;
+    private fetch;
+    private rawFetch;
+}
+
+/**
+ * Local inference server auto-discovery.
+ * Probes known local endpoints (Ollama, LM Studio, llama.cpp, vLLM, Jan, LocalAI)
+ * and returns discovered providers ready for registration.
+ *
+ * @implements #116 local server auto-discovery
+ */
+
+interface LocalEndpoint {
+    id: string;
+    name: string;
+    baseURL: string;
+    defaultPort: number;
+}
+interface DiscoveredProvider {
+    id: string;
+    name: string;
+    baseURL: string;
+    models: ModelInfo[];
+}
+interface DiscoveryOptions {
+    /** Additional endpoints to probe beyond the defaults */
+    extraEndpoints?: LocalEndpoint[];
+    /** Probe timeout per endpoint in ms (default: 2000) */
+    timeoutMs?: number;
+    /** Ports to skip (e.g., if you know a port is used for something else) */
+    skipPorts?: number[];
+}
+declare const LOCAL_ENDPOINTS: LocalEndpoint[];
+type ModelCategory = 'embedding' | 'vision' | 'chat';
+/**
+ * Classify a model by its ID/name into embedding, vision, or chat.
+ */
+declare function classifyModel(modelId: string): ModelCategory;
+/**
+ * Discover local inference servers by probing known endpoints.
+ * Returns all reachable providers with their available models.
+ */
+declare function discoverLocalProviders(options?: DiscoveryOptions): Promise<DiscoveredProvider[]>;
+
+/**
+ * FallbackRouter — wraps multiple InferenceProviders with automatic failover.
+ * Routes requests to the highest-priority available provider, falling through
+ * on errors. Failed providers enter cooldown before retry.
+ *
+ * @implements #114 provider fallback chains with cooldown
+ */
+
+interface FallbackRouterConfig {
+    /** Ordered list of providers (highest priority first) */
+    providers: InferenceProvider[];
+    /** Cooldown durations by error type in ms */
+    cooldowns?: CooldownConfig;
+    /** Event bus for fallback notifications */
+    events?: TypedEventBus;
+}
+interface CooldownConfig {
+    /** Cooldown for rate limit errors (HTTP 429) — default 30s */
+    rateLimit?: number;
+    /** Cooldown for server errors (HTTP 5xx) — default 60s */
+    serverError?: number;
+    /** Cooldown for connection failures — default 300s */
+    connectionFailure?: number;
+    /** Cooldown for content policy errors — default 0 (immediate retry with next) */
+    contentPolicy?: number;
+}
+type ErrorCategory = 'rate_limit' | 'server_error' | 'connection_failure' | 'content_policy' | 'context_window' | 'unknown';
+declare function classifyError(error: unknown): ErrorCategory;
+interface FallbackEvent {
+    fromProvider: string;
+    toProvider: string;
+    errorCategory: ErrorCategory;
+    error: string;
+}
+interface CooldownEvent {
+    providerId: string;
+    errorCategory: ErrorCategory;
+    cooldownMs: number;
+    expiresAt: number;
+}
+declare class FallbackRouter implements InferenceProvider {
+    readonly id = "fallback-router";
+    readonly name = "Fallback Router";
+    readonly tier: ProviderTier;
+    private providers;
+    private cooldowns;
+    private cooldownMap;
+    private events?;
+    get capabilities(): ProviderCapabilities;
+    constructor(config: FallbackRouterConfig);
+    /** Get providers not currently in cooldown */
+    getAvailableProviders(): InferenceProvider[];
+    /** Get providers in cooldown with their expiry info */
+    getCoolingDown(): Array<{
+        providerId: string;
+        category: ErrorCategory;
+        expiresAt: number;
+    }>;
+    /** Manually clear cooldown for a provider */
+    clearCooldown(providerId: string): void;
+    /** Clear all cooldowns */
+    clearAllCooldowns(): void;
+    /** Add a provider to the chain (appended at lowest priority) */
+    addProvider(provider: InferenceProvider): void;
+    /** Remove a provider from the chain */
+    removeProvider(id: string): void;
+    /** Reorder providers (new priority order) */
+    setOrder(ids: string[]): void;
+    embed(request: EmbedRequest): Promise<EmbedResponse>;
+    complete(request: CompletionRequest): Promise<CompletionResponse>;
+    stream(request: CompletionRequest): AsyncIterable<StreamChunk>;
+    listModels(): Promise<ModelInfo[]>;
+    probe(): Promise<ProbeResult>;
+    dispose(): void;
+    private withFallback;
+    private applyCooldown;
+}
+
+type CspDirectiveName = 'default-src' | 'base-uri' | 'object-src' | 'frame-ancestors' | 'img-src' | 'font-src' | 'style-src' | 'script-src' | 'connect-src' | 'worker-src' | 'manifest-src' | 'report-uri';
+type CspDirectives = Partial<Record<CspDirectiveName, string[]>>;
+interface PluginCspOptions {
+    scriptSrc?: string[];
+    connectSrc?: string[];
+    imgSrc?: string[];
+    styleSrc?: string[];
+    reportUri?: string;
+    extraDirectives?: CspDirectives;
+}
+interface PluginScriptPolicy {
+    allowedOrigins: string[];
+    allowedUrls?: string[];
+    requireSri?: boolean;
+}
+interface PluginScriptDescriptor {
+    url: string;
+    integrity?: string;
+    crossOrigin?: 'anonymous' | 'use-credentials';
+}
+interface LoadedPluginScript {
+    url: string;
+    integrity: string;
+    bytes: Uint8Array;
+    text: string;
+}
+interface CspViolationReport {
+    documentUri?: string;
+    violatedDirective?: string;
+    effectiveDirective?: string;
+    blockedUri?: string;
+    originalPolicy?: string;
+    disposition?: string;
+    sourceFile?: string;
+    lineNumber?: number;
+    columnNumber?: number;
+    raw: unknown;
+}
+declare function buildPluginCsp(options?: PluginCspOptions): string;
+declare function computeSri(data: Uint8Array | ArrayBuffer, algorithm?: string): Promise<string>;
+declare function verifySri(data: Uint8Array | ArrayBuffer, integrity: string): Promise<boolean>;
+declare function isPluginScriptAllowed(url: string, policy: PluginScriptPolicy): boolean;
+declare function fetchPluginScript(descriptor: PluginScriptDescriptor, policy: PluginScriptPolicy, fetchFn?: typeof fetch): Promise<LoadedPluginScript>;
+declare function appendPluginScript(descriptor: PluginScriptDescriptor, policy: PluginScriptPolicy, doc?: Document): Promise<HTMLScriptElement>;
+declare function parseCspReport(body: unknown): CspViolationReport;
+declare function createCspReportHandler(onReport: (report: CspViolationReport) => void | Promise<void>): (request: Request) => Promise<Response>;
+
+/**
+ * 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';
+/** Manifest included in every shard as manifest.json. */
+interface ShardManifest {
+    version: string;
+    matric_version: string;
+    format: typeof SHARD_FORMAT;
+    created_at: string;
+    components: ShardComponent[];
+    counts: Partial<Record<ShardComponent, number>>;
+    checksums: Record<string, string>;
+    min_reader_version: string;
+}
+/** Options for shard export. */
+interface ExportOptions {
+    includeEmbeddings?: boolean;
+    /** Filter to specific collection (export only notes in this collection). */
+    collectionId?: string;
+    /** Filter to notes with this tag (e.g. 'app:research' for app-scoped export). */
+    tag?: string;
+}
+/** Conflict resolution strategy for shard import. */
+type ConflictStrategy = 'skip' | 'replace' | 'error';
+/** Options for shard import. */
+interface ImportOptions {
+    conflictStrategy?: ConflictStrategy;
+}
+/** Per-entity import counts. */
+interface ImportCounts {
+    notes: number;
+    collections: number;
+    tags: number;
+    links: number;
+    embedding_sets: number;
+    embedding_set_members: number;
+    embeddings: number;
+}
+/** Result of a shard import operation. */
+interface ImportResult {
+    success: boolean;
+    counts: ImportCounts;
+    skipped: Partial<ImportCounts>;
+    warnings: string[];
+    errors: string[];
+    duration_ms: number;
+}
+/** Note as serialized in the shard JSONL. */
+interface ShardNote {
+    id: string;
+    title: string | null;
+    original_content: string;
+    revised_content: string | null;
+    format: string;
+    source: string;
+    starred: boolean;
+    archived: boolean;
+    tags: string[];
+    created_at: string;
+    updated_at: string;
+    deleted_at: string | null;
+}
+/** Collection as serialized in the shard JSON array. */
+interface ShardCollection {
+    id: string;
+    name: string;
+    description: string | null;
+    parent_id: string | null;
+    created_at: string;
+    note_count?: number;
+}
+/** Tag as serialized in the shard JSON array. */
+interface ShardTag {
+    name: string;
+    created_at: string;
+}
+/** Link as serialized in the shard JSONL. */
+interface ShardLink {
+    id: string;
+    from_note_id: string;
+    to_note_id: string;
+    kind: string;
+    score: number | null;
+    created_at: string;
+    metadata?: Record<string, unknown>;
+}
+/** Embedding set as serialized in the shard JSON array. */
+interface ShardEmbeddingSet {
+    id: string;
+    model: string;
+    dimension: number;
+    created_at: string;
+}
+/** Embedding set member as serialized in the shard JSONL. */
+interface ShardEmbeddingSetMember {
+    embedding_set_id: string;
+    note_id: string;
+    embedding_id: string;
+}
+/** Embedding as serialized in the shard JSONL. */
+interface ShardEmbedding {
+    id: string;
+    note_id: string;
+    embedding_set_id: string;
+    vector: number[];
+    created_at: string;
+}
+
+/**
+ * Minimal tar + gzip packing/unpacking for shard archives.
+ *
+ * Uses fflate for gzip compression and implements a lightweight POSIX tar
+ * encoder/decoder (512-byte block headers, ustar format).
+ */
+/**
+ * Pack files into a gzip-compressed tar archive.
+ *
+ * @param files Map of filename → file contents
+ * @returns Compressed archive bytes (suitable for .shard file)
+ */
+declare function packTarGz(files: Map<string, Uint8Array>): Uint8Array;
+/**
+ * Unpack a gzip-compressed tar archive.
+ *
+ * @param data Compressed archive bytes
+ * @returns Map of filename → file contents
+ */
+declare function unpackTarGz(data: Uint8Array): Map<string, Uint8Array>;
+
+/**
+ * SHA-256 checksum utilities for shard integrity verification.
+ * Uses the Web Crypto API (browser-native, no extra dependencies).
+ */
+/**
+ * Compute SHA-256 hex digest of a Uint8Array.
+ * Returns lowercase hex string (64 characters).
+ */
+declare function sha256Hex(data: Uint8Array): Promise<string>;
+/**
+ * Validate checksums listed in a shard manifest against actual file contents.
+ *
+ * @returns Object with `valid` flag and list of failed filenames.
+ */
+declare function validateChecksums(checksums: Record<string, string>, files: Map<string, Uint8Array>): Promise<{
+    valid: boolean;
+    failures: string[];
+}>;
+
+/**
+ * Field mapper — converts between browser schema and shard (server) schema.
+ *
+ * The browser uses different field names than the server shard format.
+ * This module handles all rename transforms bidirectionally.
+ */
+
+/** Browser-format note row from the export query (denormalized). */
+interface BrowserNoteExport {
+    id: string;
+    title: string | null;
+    format: string;
+    source: string;
+    is_starred: boolean;
+    is_archived: boolean;
+    created_at: Date | string;
+    updated_at: Date | string;
+    deleted_at: Date | string | null;
+    original_content: string;
+    revised_content: string | null;
+    tags: string[];
+}
+/** Convert a browser note to shard format. */
+declare function noteToShard(note: BrowserNoteExport): ShardNote;
+/** Convert a shard note back to browser-insertable format. */
+declare function noteFromShard(shard: ShardNote): BrowserNoteExport;
+/** Convert a browser link to shard format. */
+declare function linkToShard(link: LinkRow): 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;
+    link_type: string;
+    confidence: number | null;
+    created_at: string;
+};
+/** Convert a browser collection to shard format. */
+declare function collectionToShard(collection: CollectionRow, noteCount?: number): ShardCollection;
+/** Convert a shard collection back to browser-insertable format. */
+declare function collectionFromShard(shard: ShardCollection): {
+    id: string;
+    name: string;
+    description: string | null;
+    parent_id: string | null;
+    created_at: string;
+};
+/**
+ * Convert SKOS concepts + note_tag associations into shard flat tag format.
+ * Shard tags are simple string arrays — deduplicated across all notes.
+ */
+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 embedding_set to shard format. */
+declare function embeddingSetToShard(set: {
+    id: string;
+    model_name: string;
+    dimensions: number;
+    created_at: Date | string;
+}): ShardEmbeddingSet;
+/** Convert a shard embedding set back to browser format. */
+declare function embeddingSetFromShard(shard: ShardEmbeddingSet): {
+    id: string;
+    model_name: string;
+    dimensions: number;
+    created_at: string;
+};
+/** Convert a browser embedding_set_member to shard format. */
+declare function embeddingSetMemberToShard(member: {
+    embedding_set_id: string;
+    note_id: string;
+    embedding_id: string;
+}): ShardEmbeddingSetMember;
+/** Convert a browser embedding to shard format. */
+declare function embeddingToShard(emb: {
+    id: string;
+    note_id: string;
+    embedding_set_id: string;
+    vector: string | number[];
+    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;
+    vector: string;
+    created_at: string;
+};
+
+/**
+ * Shard export pipeline — query all entities, serialize, pack into .shard archive.
+ *
+ * Pipeline: query DB → field-map → serialize (JSONL/JSON) → compute checksums → build manifest → tar.gz
+ */
+
+/**
+ * Export knowledge data from the database as a .shard archive (Uint8Array).
+ *
+ * @param db DatabaseClient database instance
+ * @param options Export options (includeEmbeddings, collectionId filter)
+ * @returns Compressed shard archive bytes
+ */
+declare function exportShard(db: DatabaseClient, options?: ExportOptions): Promise<Uint8Array>;
+
+/**
+ * Shard import pipeline — unpack, validate, field-map, transactional insert.
+ *
+ * Pipeline: ArrayBuffer → gunzip → untar → parse manifest → validate checksums →
+ *           parse components → field-map → BEGIN transaction → INSERT all → COMMIT
+ */
+
+/**
+ * Import a .shard archive into the database.
+ *
+ * The entire import is wrapped in a single transaction — if anything fails,
+ * all changes are rolled back.
+ *
+ * @param db DatabaseClient database instance
+ * @param data Raw archive bytes (from File API or fetch)
+ * @param options Import options (conflict strategy)
+ * @returns Import result with counts, warnings, and errors
+ */
+declare function importShard(db: DatabaseClient, data: Uint8Array | ArrayBuffer, options?: ImportOptions): Promise<ImportResult>;
+
+declare const VERSION = "2026.5.0";
+
+export { type ArchiveInfo, ArchiveManager, type AttachInput, type AttachmentBlobRow, type AttachmentRow, AttachmentsRepository, type BlobStore, type BrowserNoteExport, CURRENT_SHARD_VERSION, type CapabilityInfo, CapabilityManager, type CapabilityName, type CapabilityState, type CaptureKnowledgeInput, CaptureKnowledgeInputSchema, type CaptureKnowledgeResult, type CollectionCreateInput, type CollectionRow, CollectionsRepository, type CompletionRequest, type CompletionResponse, type ConditionResult, type ConflictStrategy, type CooldownConfig, type CooldownEvent, type CspDirectiveName, type CspDirectives, type CspViolationReport, type DatabaseClient, type DiscoveredProvider, type DiscoveryOptions, type EmbedFunction, type EmbedRequest, type EmbedResponse, type EnqueueJobInput, type ErrorCategory, type EventMap, type ExportOptions, type FallbackEvent, FallbackRouter, type FallbackRouterConfig, type FortemiConfig, type FortemiCore, type FortemiToolDefinition, FortemiToolManifest, type GetNoteInput, GetNoteInputSchema, type GpuCapabilities, type IDisposable, type ImportCounts, type ImportOptions, 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 NoteSummary, type NoteUpdateInput, NotesRepository, OpenAICompatibleProvider, type OpenAIProviderConfig, PGliteStorageBackend, PGliteStorageBackendFactory, PGliteWorkerClient, type PaginatedResult, type PersistenceMode, type PlinyCapability, type PluginCspOptions, type PluginScriptDescriptor, type PluginScriptPolicy, type ProbeResult, type ProbeStatus, type ProviderCapabilities, ProviderRegistry, type ProviderTier, type QueryExecutor, type QueryResult, type RecommendedTier, type RouteHandler, SHARD_FORMAT, type SWRegistrationResult, type SearchFacets, type SearchInput, SearchInputSchema, type SearchOptions, SearchRepository, type SearchResponse, type SearchResult, type ShardCollection, type ShardComponent, type ShardEmbedding, type ShardEmbeddingSet, type ShardEmbeddingSetMember, type ShardLink, type ShardManifest, type ShardNote, type ShardTag, type SkosConcept, type SkosRelation, SkosRepository, type SkosScheme, type StorageBackend, type StorageBackendFactory, type StorageOpenRequest, type StorageTopology, type StreamChunk, TagsRepository, TransactionProxy, TypedEventBus, VERSION, type VramTier, type WorkerRequest, type WorkerResponse, aiRevisionHandler, allMigrations, appendPluginScript, buildNoteConditions, buildPluginCsp, captureKnowledge, chunkText, classifyError, classifyModel, collectionFromShard, collectionToShard, computeHash, computeSri, conceptTaggingHandler, cosineSimilarity, createBlobStore, createCspReportHandler, createFortemi, createLegacyProvider, createPGliteInstance, createRoutes, defaultStorageBackendFactory, detectGpuCapabilities, detectInferenceCapabilities, discoverLocalProviders, embeddingFromShard, embeddingGenerationHandler, embeddingSetFromShard, embeddingSetMemberToShard, embeddingSetToShard, embeddingToShard, enqueueFullWorkflow, enqueueJob, enqueueNoteCreationJobs, estimateModelFit, estimateVramMB, estimateVramTier, exportShard, fetchPluginScript, fortemiManifest, generateId, getEmbedFunction, getJobQueueStatus, getLlmFunction, getNote, importShard, isPluginScriptAllowed, linkFromShard, linkToShard, linkingHandler, listNotes, manageArchive, manageAttachments, manageCapabilities, manageCollections, manageLinks, manageNote, manageTags, matchRoute, noteFromShard, noteToShard, packTarGz, parseCspReport, registerLlmCapability, registerSemanticCapability, registerServiceWorker, searchTool, selectLlmModel, setEmbedFunction, setLlmFunction, sha256Hex, suggestTags, tagsFromShard, tagsToShard, titleGenerationHandler, unpackTarGz, unregisterLlmCapability, unregisterSemanticCapability, validateChecksums, verifySri };