@asaidimu/utils-workspace 6.1.0 → 6.2.1

package/index.d.ts

@@ -1,477 +1,7 @@
-import { IndexDefinition, SchemaDefinition, SchemaChange, DataTransform } from '@asaidimu/anansi';
-import { QueryFilter, PaginationOptions } from '@asaidimu/query';
-
-/**
- * Buffers write operations across one or more stores and commits them atomically.
- *
- * ## How atomicity works
- *
- * ### IndexedDB stores (same database)
- * At commit time, TransactionContext collects the names of every IDB store that
- * received operations, then opens a **single** `IDBTransaction` spanning all of
- * them via `ConnectionManager.openTransaction`. Each store's `executeInTransaction`
- * receives that shared transaction object and performs its writes against it
- * without opening a new transaction of its own. IDB commits or aborts the
- * entire multi-store transaction as one unit.
- *
- * ### MemoryStore
- * MemoryStore's `executeInTransaction` receives `null` for the shared transaction.
- * It applies ops against an internal staging map and returns. If a later
- * participant fails, TransactionContext calls `rollbackMemory` on each
- * MemoryStore that already applied its staged ops. MemoryStore restores its
- * pre-transaction snapshot.
- *
- * ### Mixed (IDB + Memory in the same transaction)
- * All IDB stores are committed first as a single atomic IDB transaction, then
- * each MemoryStore is committed. If a MemoryStore fails after IDB has already
- * committed, the IDB side cannot be rolled back — this is an inherent limitation
- * of mixing two different storage engines. In practice the schema store is
- * always MemoryStore-or-IDB consistently, so mixed transactions should not arise
- * in normal usage.
- */
-declare class TransactionContext {
-    readonly id: string;
-    /**
-     * Flat list of every operation staged so far, in the order they were added.
-     * We keep the store reference alongside the op so commit() can group them.
-     */
-    private staged;
-    private done;
-    constructor();
-    /**
-     * Stages a single write operation against a store.
-     * Does NOT touch the store — no I/O happens until commit().
-     */
-    addOp<T extends Record<string, any>>(store: Store$1<T>, type: "put" | "delete" | "add", data: any): Promise<void>;
-    /**
-     * Commits all staged operations atomically.
-     *
-     * For IDB stores: opens one shared IDBTransaction across all participating
-     * stores, then dispatches ops to each store's executeInTransaction.
-     * For MemoryStores: dispatches sequentially; rolls back on failure.
-     */
-    commit(): Promise<void>;
-    /**
-     * Discards all staged operations. No I/O has occurred so there is nothing
-     * to undo — we simply clear the buffer.
-     */
-    rollback(): void;
-    /**
-     * Opens ONE IDBTransaction across all participating IDB stores and lets
-     * each store execute its ops against the shared transaction handle.
-     *
-     * We obtain the IDBDatabase from the first store (they all share the same
-     * ConnectionManager / database) and open the transaction ourselves so that
-     * the commit/abort lifecycle belongs entirely to this method.
-     */
-    private commitIDB;
-    /**
-     * Commits MemoryStore groups sequentially.
-     * Maintains a list of stores that have already applied their ops; if any
-     * store throws, all previously-applied stores are rolled back via the
-     * store-level `_rollbackMemory(snapshot)` escape hatch.
-     */
-    private commitMemory;
-    completed(): boolean;
-}
-
-interface CursorCallbackResult<T> {
-    value: T | null;
-    done: boolean;
-    offset?: number;
-}
-/**
- * Callback function for cursor iteration over store records.
- *
- * @template T - The type of records stored.
- * @param value - The current record value (cloned, not a live reference).
- * @param key - The key (ID) of the current record.
- * @param cursor - The underlying cursor object (implementation-specific; may be `null` in memory adapters).
- * @returns A promise resolving to an object indicating whether iteration should stop,
- *          and an optional offset to advance.
- */
-type CursorCallback<T> = (value: T, key: string | number, cursor: any) => Promise<CursorCallbackResult<T>>;
-/**
- * A generic representation of a key range, replacing the browser-specific IDBKeyRange.
- */
-interface StoreKeyRange {
-    lower?: any;
-    upper?: any;
-    lowerOpen?: boolean;
-    upperOpen?: boolean;
-}
-/**
- * A single buffered operation staged inside a TransactionContext.
- * Kept intentionally minimal — the context only needs to know what to
- * replay against a store during commit.
- */
-type BufferedOperation<T> = {
-    type: "add" | "put";
-    data: T | T[];
-} | {
-    type: "delete";
-    data: string | number | (string | number)[];
-};
-/**
- * Storage adapter interface for a single object store (collection).
- *
- * Stores own their indexes. Index lifecycle (create, drop) and index-aware reads
- * (findByIndex) are part of this contract so that both MemoryStore and IndexedDBStore
- * implement them natively — MemoryStore via in-memory index maps, IndexedDB via its
- * native index mechanism.
- *
- * @template T - The type of objects stored. Must include the key path property.
- */
-interface Store$1<T extends Record<string, any> = Record<string, any>> {
-    /**
-     * Returns the name of this store (the IDB object store / collection name).
-     * Used by TransactionContext to group operations and open a correctly-scoped
-     * multi-store IDB transaction at commit time.
-     */
-    name(): string;
-    /**
-     * Opens the store, ensuring underlying storage structures exist.
-     */
-    open(): Promise<void>;
-    /**
-     * Adds one or more records to the store.
-     * If a record does not have a value for the store's key path, an automatic
-     * key may be assigned. Throws if a record with the same key already exists.
-     */
-    add(data: T | T[]): Promise<string | number | (string | number)[]>;
-    /**
-     * Removes all records from the store without destroying index structures.
-     */
-    clear(): Promise<void>;
-    /**
-     * Returns the total number of records in the store.
-     */
-    count(): Promise<number>;
-    /**
-     * Deletes one or more records by their keys.
-     */
-    delete(id: string | number | (string | number)[]): Promise<void>;
-    /**
-     * Retrieves a single record by its primary key.
-     */
-    getById(id: string | number): Promise<T | undefined>;
-    /**
-     * Retrieves the first record matching an exact index key (point lookup).
-     * Useful for unique indexes — returns the single matching record or undefined.
-     *
-     * @param indexName - The name of the index to query.
-     * @param key - The exact key value to look up.
-     */
-    getByIndex(indexName: string, key: any): Promise<T | undefined>;
-    /**
-     * Retrieves all records from a named index, optionally filtered by a key range.
-     * Use this for range scans over an index (e.g. all records where age >= 18).
-     *
-     * @param indexName - The name of the index to query.
-     * @param keyRange - Optional range to filter results.
-     */
-    getByKeyRange(indexName: string, keyRange?: StoreKeyRange): Promise<T[]>;
-    /**
-     * Retrieves all records from the store without index involvement.
-     */
-    getAll(): Promise<T[]>;
-    /**
-     * Inserts or replaces a record. Validates OCC if a record with the same key exists.
-     */
-    put(data: T): Promise<string | number>;
-    /**
-     * Iterates over records using a cursor, allowing early termination and skipping.
-     *
-     * @param callback - Invoked for each record; return `{ done: true }` to stop,
-     *                   `{ offset: n }` to skip ahead n records.
-     * @param direction - Iteration order.
-     * @param keyRange - Optional range to restrict iteration.
-     */
-    cursor(callback: CursorCallback<T>, direction?: "forward" | "backward", keyRange?: StoreKeyRange): Promise<T | null>;
-    /**
-     * Executes a batch of write operations atomically within this store.
-     * All operations succeed or fail together.
-     *
-     * Used for standalone (single-store) atomic writes. For cross-store atomicity,
-     * use executeInTransaction instead.
-     */
-    batch(operations: Array<{
-        type: "add" | "put";
-        data: T | T[];
-    } | {
-        type: "delete";
-        data: string | number | (string | number)[];
-    }>): Promise<void>;
-    /**
-     * Registers a new index on the store. Idempotent — no-op if the index already exists.
-     * For IndexedDB, this triggers a database version upgrade.
-     * For MemoryStore, this builds the index map from existing records.
-     *
-     * @param definition - The full index definition from the schema.
-     */
-    createIndex(definition: IndexDefinition): Promise<void>;
-    /**
-     * Removes a named index from the store.
-     * For IndexedDB, this triggers a database version upgrade.
-     * For MemoryStore, this drops the in-memory index map.
-     *
-     * @param name - The index name as declared in IndexDefinition.name.
-     */
-    dropIndex(name: string): Promise<void>;
-    /**
-     * Returns all records matching an exact index key.
-     * Unlike getByIndex (which returns only the first match), this returns all matches —
-     * essential for non-unique indexes where multiple records share the same indexed value.
-     *
-     * @param indexName - The name of the index to query.
-     * @param value - The exact value to look up.
-     */
-    findByIndex(indexName: string, value: any): Promise<T[]>;
-    /**
-     * Executes a set of buffered operations as part of a cross-store atomic transaction.
-     *
-     * For IndexedDBStore: `sharedTx` is the single IDBTransaction opened across all
-     * participating stores. Operations are applied directly to `sharedTx.objectStore(name)`
-     * without opening a new transaction — IDB commits or aborts the whole thing atomically.
-     *
-     * For MemoryStore: `sharedTx` is null. The store applies ops against its own staging
-     * area. The caller (TransactionContext) is responsible for coordinating rollback across
-     * all MemoryStores if any participant fails.
-     *
-     * This method must NOT open, commit, or abort any transaction itself.
-     *
-     * @param ops - The buffered operations to apply.
-     * @param sharedTx - The shared IDBTransaction (IndexedDB only), or null (MemoryStore).
-     */
-    executeInTransaction(ops: BufferedOperation<T>[], sharedTx: IDBTransaction | null): Promise<void>;
-}
-interface Collection<T> {
-    /**
-     * Finds a single document matching the query.
-     */
-    find: (query: QueryFilter<T>) => Promise<Document<T> | null>;
-    /**
-     * Lists documents with pagination. Returns an AsyncIterator so consumers can
-     * wrap it in their own iteration protocol (e.g. for-await-of via AsyncIterable).
-     */
-    list: (query: PaginationOptions) => Promise<AsyncIterator<Document<T>[]>>;
-    /**
-     * Filters all documents matching the query.
-     */
-    filter: (query: QueryFilter<T>) => Promise<Document<T>[]>;
-    /**
-     * Creates a new document in the collection.
-     *
-     * When a TransactionContext is provided the initial store.add is buffered into
-     * the transaction rather than written immediately. The document is returned in
-     * its fully initialised in-memory state regardless — callers can use it before
-     * the transaction commits.
-     *
-     * @param initial - The initial data for the document.
-     * @param tx - Optional transaction to buffer the write into.
-     */
-    create: (initial: T, tx?: TransactionContext) => Promise<Document<T>>;
-    /**
-     * Updates all documents matching the query with the provided partial data.
-     * Returns the number of documents updated.
-     */
-    update: (query: QueryFilter<T>, data: Partial<T>, tx?: TransactionContext) => Promise<number>;
-    /**
-     * Deletes all documents matching the query.
-     * Returns the number of documents deleted.
-     */
-    delete: (query: QueryFilter<T>, tx?: TransactionContext) => Promise<number>;
-    /**
-     * Subscribes to collection-level events.
-     */
-    subscribe: (event: CollectionEventType | TelemetryEventType, callback: (event: CollectionEvent<T> | TelemetryEvent) => void) => () => void;
-    /**
-     * Validates data against the collection's schema.
-     */
-    validate(data: Record<string, any>): Promise<{
-        value?: any;
-        issues: Array<{
-            message: string;
-            path: Array<string>;
-        }>;
-    }>;
-    invalidate(): void;
-}
-/**
- * Event payload for Collection events.
- */
-type CollectionEventType = "document:create" | "collection:read" | "migration:start" | "migration:end";
-type CollectionEvent<T> = {
-    type: CollectionEventType;
-    document?: T;
-    model?: string;
-    method?: keyof Collection<T>;
-    metadata?: Record<string, unknown>;
-    timestamp: number;
-};
-interface Database {
-    /**
-     * Opens an existing collection by name.
-     */
-    collection: <T>(schemaName: string) => Promise<Collection<T>>;
-    /**
-     * Creates a new collection from a schema definition.
-     */
-    createCollection: <T>(schema: SchemaDefinition) => Promise<Collection<T>>;
-    /**
-     * Deletes a collection and its schema record.
-     */
-    deleteCollection: (schemaName: string) => Promise<boolean>;
-    /**
-     * Updates an existing collection's schema record.
-     */
-    updateCollection: (schema: SchemaDefinition) => Promise<boolean>;
-    /**
-     * Migrates an existing collection's data and schema definition.
-     * Processes data in a streaming fashion to avoid loading the full collection
-     * into memory.
-     */
-    migrateCollection: <T>(name: string, opts: CollectionMigrationOptions, batchSize?: number) => Promise<Collection<T>>;
-    /**
-     * Executes a callback within a TransactionContext.
-     * Writes buffered inside the callback are flushed atomically on commit.
-     * If the callback throws, the buffer is discarded (no writes are flushed).
-     */
-    transaction: (callback: (tx: TransactionContext) => Promise<void>) => Promise<void>;
-    /**
-     * Subscribes to database-level events.
-     */
-    subscribe: (event: DatabaseEventType | "telemetry", callback: (event: DatabaseEvent | TelemetryEvent) => void) => () => void;
-    /**
-     * Releases in-memory references and event bus subscriptions.
-     * Does not delete any persisted data.
-     */
-    close: () => void;
-    clear: () => Promise<void>;
-    /**
-     * Ensures a collection exists; creates it if it doesn't. Idempotent.
-     */
-    ensureCollection: (schema: SchemaDefinition) => Promise<void>;
-    /**
-     * Ensures multiple collections exist; creates any that don't. Idempotent.
-     */
-    setupCollections: (schemas: SchemaDefinition[]) => Promise<void>;
-}
-type CollectionMigrationOptions = {
-    changes: SchemaChange<any>[];
-    description: string;
-    rollback?: SchemaChange<any>[];
-    transform?: string | DataTransform<any, any>;
-};
-type DatabaseEventType = "collection:create" | "collection:delete" | "collection:update" | "collection:read" | "migrate";
-type DatabaseEvent = {
-    type: DatabaseEventType;
-    schema?: SchemaDefinition | Partial<SchemaDefinition>;
-    timestamp: number;
-};
-type DocumentMetadata = {
-    $id?: string;
-    $created?: string | Date;
-    $updated?: string | Date;
-    $version?: number;
-};
-type Document<T> = {
-    readonly [K in keyof T]: T[K];
-} & DocumentMetadata & {
-    read: () => Promise<boolean>;
-    save: (tx?: TransactionContext) => Promise<boolean>;
-    update: (props: Partial<T>, tx?: TransactionContext) => Promise<boolean>;
-    delete: (tx?: TransactionContext) => Promise<boolean>;
-    subscribe: (event: DocumentEventType | TelemetryEventType, callback: (event: DocumentEvent<T> | TelemetryEvent) => void) => () => void;
-    state(): T;
-    $metadata(): DocumentMetadata;
-};
-type DocumentEventType = "document:create" | "document:write" | "document:update" | "document:delete" | "document:read";
-type DocumentEvent<T> = {
-    type: DocumentEventType;
-    data?: Partial<T>;
-    timestamp: number;
-};
-type TelemetryEventType = "telemetry";
-type TelemetryEvent = {
-    type: TelemetryEventType;
-    method: string;
-    timestamp: number;
-    source: any;
-    metadata: {
-        args: any[];
-        performance: {
-            durationMs: number;
-        };
-        source: {
-            level: "database" | "collection" | "document";
-            collection?: string;
-            document?: string;
-        };
-        result?: {
-            type: "array" | string;
-            size?: number;
-        };
-        error: {
-            message: string;
-            name: string;
-            stack?: string;
-        } | null;
-    };
-};
-
-/**
- * Interface defining the shape of the EventBus.
- * @template TEventMap - A record mapping event names to their respective payload types.
- */
-interface EventBus<TEventMap extends Record<string, any>> {
-    /**
-     * Subscribes to a specific event by name.
-     * @param eventName - The name of the event to subscribe to.
-     * @param callback - The function to call when the event is emitted.
-     * @returns A function to unsubscribe from the event.
-     */
-    subscribe: <TEventName extends keyof TEventMap>(eventName: TEventName, callback: (payload: TEventMap[TEventName]) => void) => () => void;
-    /**
-     * Subscribes to an event and automatically unsubscribes after it fires once.
-     * @param eventName - The name of the event to subscribe to.
-     * @param callback - The function to call when the event is emitted.
-     * @returns A function to cancel the one-shot subscription before it fires.
-     */
-    once: <TEventName extends keyof TEventMap>(eventName: TEventName, callback: (payload: TEventMap[TEventName]) => void) => () => void;
-    /**
-     * Emits an event with a payload to all subscribed listeners.
-     * @param event - An object containing the event name and payload.
-     */
-    emit: <TEventName extends keyof TEventMap>(event: {
-        name: TEventName;
-        payload: TEventMap[TEventName];
-    }) => void;
-    /**
-     * Retrieves metrics about event bus usage.
-     * @returns An object containing various metrics.
-     */
-    metrics: () => EventMetrics;
-    /**
-     * Clears all subscriptions and resets metrics.
-     * After calling clear(), the bus is fully reset and can be reused —
-     * cross-tab communication is re-established if it was previously enabled.
-     */
-    clear: () => void;
-}
-/**
- * Interface defining the metrics tracked by the EventBus.
- */
-interface EventMetrics {
-    /** Total number of events emitted (both sync and deferred paths). */
-    totalEvents: number;
-    /** Number of active subscriptions across all event names. */
-    activeSubscriptions: number;
-    /** Map of event names to their emission counts. */
-    eventCounts: Map<string, number>;
-    /** Average duration of event dispatch in milliseconds. */
-    averageEmitDuration: number;
-}
+import { SchemaDefinition } from '@asaidimu/anansi';
+import { Collection, Database, Document } from '@core/database';
+import { EventBus } from '@core/events';
+import { GenerateContentParameters, GoogleGenAI, GenerateContentResponse, Content, Part } from '@google/genai';
 
 /**
  * Utility type for representing partial updates to the state, allowing deep nesting.
@@ -883,44 +413,45 @@ interface Preference {
     /** UTC timestamp of when this preference was established or last updated. */
     timestamp: Timestamp;
 }
-/** Discriminated union of types that can be injected into the AI context. */
-type ContextContent = {
-    /** Denotes raw, unstructured text. */
+/** Supported payload for text-based context. */
+type TextContextContent = {
     kind: "text";
-    /** The text payload to inject. */
     value: string;
-} | {
-    /** Denotes structured JSON data. */
+};
+/** Supported payload for structured JSON context. */
+type JsonContextContent = {
     kind: "json";
-    /** The JSON payload. */
     value: unknown;
-} | {
-    /** Denotes a reference to a registered blob in the workspace store. */
+};
+/** Supported payload for blob-based context. */
+type BlobContextContent = {
     kind: "blob";
-    /** The hash linking to the full blob record. */
     sha256: SHA256;
-    /** The mime-type of the blob. */
     mediaType: BlobMediaType;
-    /** File size in bytes. */
     sizeBytes: number;
-    /** Human-readable filename. */
     filename?: string;
-} | {
-    /** Denotes data living at an external HTTP URI. */
+};
+/** Supported payload for remote URI context. */
+type RemoteContextContent = {
     kind: "remote";
-    /** The fully qualified URI to the external resource. */
     uri: URI;
-    /** Optional hint for the expected mime-type at the remote destination. */
     mediaType?: BlobMediaType;
 };
+/** Union of built-in context types. */
+type DefaultContextContent = TextContextContent | JsonContextContent | BlobContextContent | RemoteContextContent;
+/**
+ * Discriminated union of types that can be injected into the AI context.
+ * Extensions provide their own T which MUST include a unique 'kind' discriminator.
+ */
+type ContextContent<T = any> = DefaultContextContent | T;
 /** A contextual item (file, snippet, or data) attached to a session or prompt. */
-interface Context {
+interface Context<T = any> {
     /** Unique lookup key for this context entry. */
     key: string;
     /** Topics linking this context to relevant sessions or roles. */
     topics: string[];
     /** The actual payload of the context block. */
-    content: ContextContent;
+    content: ContextContent<T>;
     /** UTC timestamp of when the context was added. */
     timestamp: Timestamp;
     /** Extensible key-value store for application-specific contextual metadata. */
@@ -988,6 +519,8 @@ interface PreferenceSummary {
 interface ContextSummary {
     /** The unique key for the context item. */
     key: string;
+    /** The kind of context (e.g. 'text', 'blob', 'task'). Used for routing. */
+    kind: string;
     /** Associated semantic topics. */
     topics: string[];
     /** UTC timestamp of addition. */
@@ -1475,200 +1008,37 @@ interface SessionSnapshot {
 }
 
 /**
- * Output of PromptBuilder.build(). Input to LLMAdapter.resolve().
- *
- * Contains fully ranked and conflict-resolved preferences, context, and a
- * catalogue of blob references — but is NOT truncated and does NOT contain
- * resolved binary blob data. The adapter is responsible for:
- *   - Deciding what fits within the model's context window.
- *   - Resolving only the BlobRefs that survive truncation.
- *   - Uploading inline blobs to the provider where required.
+ * Registry for managing context kind definitions and their behaviors.
  */
-interface Prompt {
-    /** Model identifier (e.g., "claude-sonnet-4-6", "gemini-2.0-flash"). */
-    model?: string;
-    /** Correlates this prompt to its session for logging and evaluation. */
-    session: UUID;
-    /** System-level instructions, context, and preferences. */
-    system: {
-        /** The active role's persona string. */
-        persona: string;
-        /** Global or session-level instructions. */
-        instructions?: string;
-        /** Conflict-resolved, relevance-ordered preferences. */
-        preferences: Preference[];
-        /** Ranked context entries (text and json kinds only). Blob context is
-         *  represented as referential blocks in the transcript instead. */
-        context: Context[];
-    };
-    /** Active conversation chain, oldest to newest. May include synthetic turns.
-     *  Image and document blocks carry a BlobRef only; the adapter resolves them. */
-    transcript: Turn[];
+declare class ContextRegistry {
+    private readonly store;
+    constructor();
+    private registerDefaults;
     /**
-     * Lightweight catalogue of every blob referenced anywhere in this prompt
-     * (system.context or transcript), keyed by SHA256.
-     *
-     * Values are BlobRefs — metadata only, no binary data. The adapter uses
-     * this catalogue to resolve or upload blobs for whichever turns and context
-     * entries survive its truncation pass.
+     * Registers a new context definition.
+     * @param definition The context definition to register.
      */
-    blobs: Map<SHA256, BlobRef>;
-    /** The role object — for inspection and adapter use. */
-    role: Role;
-    /** Model constraints to be merged by the adapter (turn > session > role). */
-    constraints: ModelConstraintMap;
+    register(definition: ContextDefinition): void;
     /**
-     * Non-fatal warnings generated during the build phase.
-     * Adapters and callers should surface or log these.
-     * Examples: summarizer failures, unresolvable blob refs.
+     * Retrieves a context definition by kind.
+     * @param kind The context kind to retrieve.
      */
-    warnings: string[];
+    get(kind: string): ContextDefinition | undefined;
+    /**
+     * Lists all registered context definitions.
+     */
+    list(): ContextDefinition[];
 }
+
 /**
- * Reflects the current state of the LLM adapter (limits, headroom, and readiness).
- */
-interface AdapterStatus {
-    /** Provider name (e.g., "google", "anthropic", "openai"). */
-    provider: string;
-    /** Model identifier (e.g., "claude-sonnet-4-6", "gemini-2.0-flash"). */
-    model: string;
-    /** Whether the adapter is currently able to accept requests. */
-    ready: boolean;
-    /** Token window limits and current usage. */
-    window: {
-        /** Total context window size in tokens. */
-        size: number;
-        /** Maximum output tokens for this model. */
-        out: number;
-        /** Tokens remaining — estimated or as reported by the provider. */
-        free?: number;
-    };
-    /** Capability flags for this model. */
-    feature: {
-        /** Whether the model can process image inputs. */
-        vision: boolean;
-        /** Whether the model supports tool/function calling. */
-        tools: boolean;
-        /** Whether the model supports structured JSON output mode. */
-        json: boolean;
-        /** Whether the provider supports prompt caching. */
-        cache: boolean;
-        /** Whether the adapter supports streaming. */
-        streaming: boolean;
-        /** Whether the model supports extended thinking/reasoning tokens. */
-        thinking: boolean;
-    };
-    /** Pricing tiers for this model. */
-    pricing: Array<{
-        unit: 'token' | 'call' | "image";
-        /** Exponent: price is per 10^scale units. */
-        scale: number;
-        /** Price per unit in USD. */
-        cost: {
-            input: number;
-            output: number;
-            cache?: {
-                read: number;
-                write: number;
-            };
-        };
-    }>;
-    /** Current rate limit state. */
-    rate: {
-        /** Current saturation as a fraction of the most constrained limit (0.0 to 1.0). */
-        load: number;
-        /** Milliseconds until the next request is permitted. */
-        timeout?: number;
-        /** The hard limits enforced by the provider. */
-        capacity: Array<{
-            unit: 'token' | 'call' | string;
-            /** Maximum units allowed per period. */
-            max: number;
-            /** Period length in seconds. */
-            period: number;
-        }>;
-    };
-    /** Adapter-level notes, e.g. model deprecation warnings. */
-    notes?: string[];
-}
-/**
- * The result of `PreparedPrompt.execute()`. Contains the turn and derived effects.
- */
-interface ExecuteResult {
-    /** The newly generated assistant turn. */
-    turn: Turn;
-    /** Side-effect commands to dispatch against the workspace. */
-    effects: BaseCommand[];
-}
-/**
- * A single labelled section of the system prompt.
- * Mirrors PreparedPrompt.system exactly — the assembler's output is stored
- * there directly, giving callers full inspection without re-parsing the string.
- */
-interface PromptSection {
-    /**
-     * Origin label for this section.
-     * Core sections use fixed labels: 'operating-system' | 'persona' |
-     * 'preferences' | 'context' | 'instructions'.
-     * Extensions carry whatever label the injector provides.
-     */
-    label: string;
-    /** Text content exactly as it will be sent to the model. */
-    content: string;
-    /** Optional structured metadata for richer UI display or tooling. */
-    metadata?: Record<string, any>;
-}
-/**
- * The complete, final prompt exactly as the model will receive it.
- * Generic, provider-agnostic, fully inspectable, and executable.
- */
-interface PreparedPrompt {
-    /** Model identifier (e.g., "claude-sonnet-4-6", "gemini-2.0-flash"). */
-    model: string;
-    /** The complete system instruction broken into labelled sections for inspection. */
-    instructions: Array<PromptSection>;
-    /** Final transcript turns that will be sent after adapter-level truncation. */
-    transcript: Turn[];
-    /** Final context entries included after adapter-level truncation. */
-    context: Context[];
-    /** Final preferences included after adapter-level truncation. */
-    preferences: Preference[];
-    /** The resolved model constraints for this request. */
-    constraints: ModelConstraint;
-    /** Token accounting (estimated or exact). */
-    tokens: {
-        /** Breakdown by section. Keys are adapter-defined. */
-        breakdown: Record<string, number>;
-        /** Total input tokens — estimated or exact. */
-        total: number;
-        /** Whether total is an estimate or exact (provider-supplied). */
-        source: 'estimated' | 'exact';
-        /** Maximum output tokens configured for this request. */
-        output?: number;
-        /** Tokens remaining in the context window after this prompt. */
-        remaining?: number;
-    };
-    /**
-     * Sends this prompt to the model.
-     * @returns The parsed assistant Turn plus any execution side-effects.
-     */
-    execute(): Promise<Result<ExecuteResult, WorkspaceError>>;
-    /**
-     * Streaming variant of execute(). Yields partial turns as tokens arrive.
-     * Present only if the adapter and model support streaming.
-     */
-    executeStream?(): AsyncIterable<Partial<Turn> | ExecuteResult>;
-}
-
-/**
- * Optional filter passed to schema(), description(), and rules() to control
- * which block definitions are included in the output.
- *
- * Resolution order:
- *   1. `emittable` gate is always applied first — non-emittable blocks never
- *      appear in schema/description/rules regardless of other filters.
- *   2. If `only` is provided, only those types are included. `exclude` is ignored.
- *   3. If `exclude` is provided (and `only` is not), those types are removed.
+ * Optional filter passed to schema(), description(), and rules() to control
+ * which block definitions are included in the output.
+ *
+ * Resolution order:
+ *   1. `emittable` gate is always applied first — non-emittable blocks never
+ *      appear in schema/description/rules regardless of other filters.
+ *   2. If `only` is provided, only those types are included. `exclude` is ignored.
+ *   3. If `exclude` is provided (and `only` is not), those types are removed.
  */
 interface BlockFilter {
     /**
@@ -1819,6 +1189,18 @@ interface SystemPromptAssembler {
      */
     join(sections: PromptSection[]): string;
 }
+type BlockMapper = {
+    /**
+     * Convert a workspace block into a provider-specific part.
+     * The return type is `unknown` — the adapter casts it internally.
+     */
+    to(block: BaseContentBlock<string>): unknown;
+    /**
+     * Convert a provider-extracted raw JSON object into a workspace block.
+     * Return `null` if parsing fails.
+     */
+    from(raw: any): BaseContentBlock<any> | null;
+};
 /**
  * A registered content block — self-contained and provider-agnostic.
  */
@@ -1886,12 +1268,204 @@ interface WorkspaceServices {
      * Self-describing catalogue of all known content block types.
      */
     blockRegistry: ContentBlockRegistry;
+    /**
+     * Registry for managing custom context kinds.
+     */
+    contextRegistry: ContextRegistry;
     /**
      * Model registry
      */
     models: ModelRegistry;
 }
 
+/**
+ * Output of PromptBuilder.build(). Input to LLMAdapter.resolve().
+ *
+ * Contains fully ranked and conflict-resolved preferences, context, and a
+ * catalogue of blob references — but is NOT truncated and does NOT contain
+ * resolved binary blob data. The adapter is responsible for:
+ *   - Deciding what fits within the model's context window.
+ *   - Resolving only the BlobRefs that survive truncation.
+ *   - Uploading inline blobs to the provider where required.
+ */
+interface Prompt {
+    /** Model identifier (e.g., "claude-sonnet-4-6", "gemini-2.0-flash"). */
+    model?: string;
+    /** Correlates this prompt to its session for logging and evaluation. */
+    session: UUID;
+    /** System-level instructions, context, and preferences. */
+    system: {
+        /** The active role's persona string. */
+        persona: string;
+        /** Global or session-level instructions. */
+        instructions?: string;
+        /** Conflict-resolved, relevance-ordered preferences. */
+        preferences: Preference[];
+        /** Ranked context entries (text and json kinds only). Blob context is
+         *  represented as referential blocks in the transcript instead. */
+        context: Context[];
+        /** Additional sections injected by the adapter or application layer. */
+        extensions?: AssemblerExtension[];
+    };
+    /** Active conversation chain, oldest to newest. May include synthetic turns.
+     *  Image and document blocks carry a BlobRef only; the adapter resolves them. */
+    transcript: Turn[];
+    /**
+     * Lightweight catalogue of every blob referenced anywhere in this prompt
+     * (system.context or transcript), keyed by SHA256.
+     *
+     * Values are BlobRefs — metadata only, no binary data. The adapter uses
+     * this catalogue to resolve or upload blobs for whichever turns and context
+     * entries survive its truncation pass.
+     */
+    blobs: Map<SHA256, BlobRef>;
+    /** The role object — for inspection and adapter use. */
+    role: Role;
+    /** Model constraints to be merged by the adapter (turn > session > role). */
+    constraints: ModelConstraintMap;
+    /**
+     * Non-fatal warnings generated during the build phase.
+     * Adapters and callers should surface or log these.
+     * Examples: summarizer failures, unresolvable blob refs.
+     */
+    warnings: string[];
+}
+/**
+ * Reflects the current state of the LLM adapter (limits, headroom, and readiness).
+ */
+interface AdapterStatus {
+    /** Provider name (e.g., "google", "anthropic", "openai"). */
+    provider: string;
+    /** Model identifier (e.g., "claude-sonnet-4-6", "gemini-2.0-flash"). */
+    model: string;
+    /** Whether the adapter is currently able to accept requests. */
+    ready: boolean;
+    /** Token window limits and current usage. */
+    window: {
+        /** Total context window size in tokens. */
+        size: number;
+        /** Maximum output tokens for this model. */
+        out: number;
+        /** Tokens remaining — estimated or as reported by the provider. */
+        free?: number;
+    };
+    /** Capability flags for this model. */
+    feature: {
+        /** Whether the model can process image inputs. */
+        vision: boolean;
+        /** Whether the model supports tool/function calling. */
+        tools: boolean;
+        /** Whether the model supports structured JSON output mode. */
+        json: boolean;
+        /** Whether the provider supports prompt caching. */
+        cache: boolean;
+        /** Whether the adapter supports streaming. */
+        streaming: boolean;
+        /** Whether the model supports extended thinking/reasoning tokens. */
+        thinking: boolean;
+    };
+    /** Pricing tiers for this model. */
+    pricing: Array<{
+        unit: "token" | "call" | "image";
+        /** Exponent: price is per 10^scale units. */
+        scale: number;
+        /** Price per unit in USD. */
+        cost: {
+            input: number;
+            output: number;
+            cache?: {
+                read: number;
+                write: number;
+            };
+        };
+    }>;
+    /** Current rate limit state. */
+    rate: {
+        /** Current saturation as a fraction of the most constrained limit (0.0 to 1.0). */
+        load: number;
+        /** Milliseconds until the next request is permitted. */
+        timeout?: number;
+        /** The hard limits enforced by the provider. */
+        capacity: Array<{
+            unit: "token" | "call" | string;
+            /** Maximum units allowed per period. */
+            max: number;
+            /** Period length in seconds. */
+            period: number;
+        }>;
+    };
+    /** Adapter-level notes, e.g. model deprecation warnings. */
+    notes?: string[];
+}
+/**
+ * The result of `PreparedPrompt.execute()`. Contains the turn and derived effects.
+ */
+interface ExecuteResult {
+    /** The newly generated assistant turn. */
+    turn: Turn;
+    /** Side-effect commands to dispatch against the workspace. */
+    effects: BaseCommand[];
+}
+/**
+ * A single labelled section of the system prompt.
+ * Mirrors PreparedPrompt.system exactly — the assembler's output is stored
+ * there directly, giving callers full inspection without re-parsing the string.
+ */
+interface PromptSection {
+    /**
+     * Origin label for this section.
+     * Core sections use fixed labels: 'operating-system' | 'persona' |
+     * 'preferences' | 'context' | 'instructions'.
+     * Extensions carry whatever label the injector provides.
+     */
+    label: string;
+    /** Text content exactly as it will be sent to the model. */
+    content: string;
+    /** Optional structured metadata for richer UI display or tooling. */
+    metadata?: Record<string, any>;
+}
+/**
+ * The complete, final prompt exactly as the model will receive it.
+ * Generic, provider-agnostic, fully inspectable, and executable.
+ */
+interface PreparedPrompt {
+    /** Model identifier (e.g., "claude-sonnet-4-6", "gemini-2.0-flash"). */
+    model: string;
+    /** The complete system instruction broken into labelled sections for inspection. */
+    instructions: Array<PromptSection>;
+    /** Final transcript turns that will be sent after adapter-level truncation. */
+    transcript: Turn[];
+    /** Final context entries included after adapter-level truncation. */
+    context: Context[];
+    /** Final preferences included after adapter-level truncation. */
+    preferences: Preference[];
+    /** The resolved model constraints for this request. */
+    constraints: ModelConstraint;
+    /** Token accounting (estimated or exact). */
+    tokens: {
+        /** Breakdown by section. Keys are adapter-defined. */
+        breakdown: Record<string, number>;
+        /** Total input tokens — estimated or exact. */
+        total: number;
+        /** Whether total is an estimate or exact (provider-supplied). */
+        source: "estimated" | "exact";
+        /** Maximum output tokens configured for this request. */
+        output?: number;
+        /** Tokens remaining in the context window after this prompt. */
+        remaining?: number;
+    };
+    /**
+     * Sends this prompt to the model.
+     * @returns The parsed assistant Turn plus any execution side-effects.
+     */
+    execute(): Promise<Result<ExecuteResult, WorkspaceError>>;
+    /**
+     * Streaming variant of execute(). Yields partial turns as tokens arrive.
+     * Present only if the adapter and model support streaming.
+     */
+    executeStream?(): AsyncIterable<Partial<Turn> | ExecuteResult>;
+}
+
 /**
  * A simple LRU (Least Recently Used) cache implementation.
  * Used for caching frequently accessed entities in memory.
@@ -2048,17 +1622,23 @@ declare const COLLECTIONS: {
     readonly BLOB: "blob";
     readonly TOPIC: "topic";
 };
-type Collections = typeof COLLECTIONS[keyof typeof COLLECTIONS];
+type Collections = (typeof COLLECTIONS)[keyof typeof COLLECTIONS];
 
 declare class ContextStore implements Store<Context, ContextSummary, string> {
     private readonly collection;
     private readonly cache;
-    constructor(collection: Collection<Context>, cache: LRUCache<string, Context>);
-    get(key: string): Promise<Context | null>;
+    private readonly registry?;
+    private readonly delegates;
+    constructor(collection: Collection<Context>, cache: LRUCache<string, Context>, registry?: ContextRegistry | undefined);
+    /**
+     * Registers a specialized store for a specific context kind.
+     */
+    registerDelegate(kind: string, store: Store<Context, ContextSummary, string>): void;
+    get(key: string, kind?: string): Promise<Context | null>;
     add(context: Context): Promise<void>;
     list(): Promise<Context[]>;
-    update(key: string, updates: Partial<Context>): Promise<Context | null>;
-    delete(key: string): Promise<boolean>;
+    update(key: string, updates: Partial<Context>, kind?: string): Promise<Context | null>;
+    delete(key: string, kind?: string): Promise<boolean>;
     /**
      * Retrieves all context items referenced by the given topics using the in-memory index.
      */
@@ -2183,6 +1763,38 @@ declare class WorkspaceStore implements Store<WorkspaceMetadata, WorkspaceMetada
  * A function that rebuilds a portion of the workspace index from persistent storage.
  */
 type Indexer = (ctx: WorkspaceContext) => Promise<DeepPartial<Workspace>>;
+/**
+ * Definition of a specific kind of context and how the system interacts with it.
+ */
+interface ContextDefinition<T = any> {
+    /** Unique discriminator for this context kind (e.g., 'text', 'blob', 'task'). */
+    kind: string;
+    /**
+     * Where this context prefers to live in the prompt.
+     * 'system' -> Rendered into the system instructions.
+     * 'transcript' -> Rendered as a synthetic turn prefixing the transcript.
+     */
+    target: "system" | "transcript";
+    /**
+     * Transforms the context item into one or more content blocks.
+     * If these blocks contain BlobRefs, the PromptBuilder will automatically
+     * catalogue them for the adapter.
+     */
+    render(context: Context<T>): ContentBlock | ContentBlock[];
+    /**
+     * Returns a plain text representation for the RAG/retriever system.
+     */
+    toString(context: Context<T>): string;
+    /**
+     * Produces a condensed summary for the workspace index projection.
+     */
+    summarize(context: Context<T>): ContextSummary;
+    /**
+     * Optional factory for a custom store for this context kind.
+     * If omitted, the default 'context' collection is used.
+     */
+    store?: (ctx: WorkspaceContext) => Store<Context<T>, ContextSummary, string>;
+}
 /**
  * A bundle of domain-specific logic that can be plugged into the workspace.
  * Allows app builders to group related schemas, reducers, stores, and blocks.
@@ -2200,6 +1812,8 @@ interface WorkspaceExtension {
     stores?: (ctx: Omit<WorkspaceContext, "workspace">) => Record<string, Store<any>> | Promise<Record<string, Store<any>>>;
     /** Content block definitions for the LLM adapter. */
     blocks?: ContentBlockDefinition[];
+    /** Custom context kind definitions. */
+    contexts?: ContextDefinition[];
 }
 /**
  * The full set of stores passed to every reducer and middleware call.
@@ -2627,12 +2241,153 @@ declare function computeSHA256(data: Uint8Array): Promise<SHA256>;
  */
 declare function bufferToBase64(buffer: Uint8Array): string;
 /**
-* Short, deterministic hash of a string (4 chars in base36).
-* Suitable for AI-friendly reference tokens.
-*/
+ * Short, deterministic hash of a string (4 chars in base36).
+ * Suitable for AI-friendly reference tokens.
+ */
 declare function shortHash(s: string, length?: number): string;
 declare function getExtension<K extends string, V>(index: Index, key: K): Record<string, V>;
 
+declare const createEmptySession: (overrides?: Partial<SessionMetadata>) => SessionMetadata;
+declare const createEmptyTurn: (overrides?: Partial<Turn>, session?: SessionMetadata) => Turn;
+/**
+ * Creates a new, empty workspace with default values.
+ * All indices (roles, preferences, context, sessions, topics, blobs, tools) are empty objects.
+ *
+ * @param overrides - Partial workspace fields to override the default empty workspace.
+ * @returns A fully formed Workspace object ready for use.
+ */
+declare const createEmptyWorkspace: (overrides?: DeepPartial<Workspace>) => Workspace;
+
+/**
+ * In-process implementation backed by plain Maps.
+ * Suitable for development, testing, and server-side runtimes without
+ * access to IndexedDB.
+ */
+declare class MemoryBlobStorage implements BlobStorage {
+    private readonly bytes;
+    private readonly records;
+    storeBytes(sha256: SHA256, data: Uint8Array): Promise<void>;
+    loadBytes(sha256: SHA256): Promise<Uint8Array | null>;
+    hasBytes(sha256: SHA256): Promise<boolean>;
+    deleteBytes(sha256: SHA256): Promise<void>;
+    saveRecord(record: BlobRecord): Promise<void>;
+    loadRecord(sha256: SHA256): Promise<BlobRecord | null>;
+    deleteRecord(sha256: SHA256): Promise<void>;
+    listRecords(): Promise<BlobRecord[]>;
+    exportAllBytes(): Promise<Array<[SHA256, Uint8Array]>>;
+    /**
+     * Atomic register for MemoryBlobStorage — sequential ops are atomic
+     * in a single-threaded JS runtime, so this is equivalent to two separate
+     * calls, but we implement it for interface consistency.
+     */
+    registerBlob(record: BlobRecord, data: Uint8Array): Promise<void>;
+}
+
+interface IndexedDBBlobConfig {
+    /** Name of the IndexedDB database. Defaults to 'aiworkspace-blobs'. */
+    dbName?: string;
+}
+/**
+ * IndexedDB-backed blob storage.
+ *
+ * Bytes are stored as raw Uint8Array — IndexedDB handles binary natively,
+ * no base64 encoding at rest. This is important for large files.
+ *
+ * Transaction discipline: never await inside an active transaction.
+ * All multi-step operations chain synchronous IDB request handlers
+ * inside a single Promise.
+ */
+declare class IndexedDBBlobStorage implements BlobStorage {
+    private readonly dbName;
+    private db;
+    constructor(config?: IndexedDBBlobConfig);
+    open(): Promise<void>;
+    private createSchema;
+    close(): void;
+    deleteDatabase(): Promise<void>;
+    private getDB;
+    private readTx;
+    private writeTx;
+    storeBytes(sha256: SHA256, data: Uint8Array): Promise<void>;
+    loadBytes(sha256: SHA256): Promise<Uint8Array | null>;
+    hasBytes(sha256: SHA256): Promise<boolean>;
+    deleteBytes(sha256: SHA256): Promise<void>;
+    saveRecord(record: BlobRecord): Promise<void>;
+    loadRecord(sha256: SHA256): Promise<BlobRecord | null>;
+    deleteRecord(sha256: SHA256): Promise<void>;
+    listRecords(): Promise<BlobRecord[]>;
+    exportAllBytes(): Promise<Array<[SHA256, Uint8Array]>>;
+    /**
+     * Atomically stores bytes and saves a record together.
+     * Preferred over calling storeBytes + saveRecord separately when both
+     * are new — avoids a window where bytes exist without a record.
+     */
+    registerBlob(record: BlobRecord, data: Uint8Array): Promise<void>;
+}
+
+declare class GoogleGenAIAdapter implements LLMAdapter<GenerateContentParameters> {
+    private readonly client;
+    private readonly services;
+    private readonly model;
+    private readonly _models;
+    constructor(client: GoogleGenAI, services: WorkspaceServices, options?: {
+        model: string;
+        models?: Array<ModelProfile>;
+    });
+    private registerGeminiMappings;
+    status(_?: string): Promise<AdapterStatus>;
+    resolve(params: {
+        prompt: Prompt;
+    } & Partial<GenerateContentParameters>): Promise<PreparedPrompt>;
+    static provider(): string;
+    static models(): ModelProfile[];
+}
+
+declare const mappings: Record<string, BlockMapper>;
+
+declare const GOOGLE_MODELS: Array<ModelProfile>;
+
+/**
+ * Extracts workspace ContentBlocks from a Gemini GenerateContentResponse.
+ *
+ * Responsibility split:
+ *   - This function owns the Gemini wire format (candidates, parts, thought flag).
+ *   - Block validation and construction is fully delegated to the registry.
+ *     Unknown block types returned by the model are silently dropped (registry
+ *     returns null for unregistered types) and logged by the registry itself.
+ */
+declare function parseModelResponse(response: GenerateContentResponse, registry: ContentBlockRegistry): Result<ContentBlock[], WorkspaceError>;
+
+/**
+ * Maps a workspace Turn into a Gemini Content object.
+ *
+ * Blob blocks (image, document) are resolved to inline or remote Parts via
+ * mapBlobRefToPart. All other blocks are dispatched through the registry's
+ * provider mapping for provider() — a missing mapping is a programming error
+ * and throws immediately rather than silently degrading.
+ */
+declare function mapTurnToContent(turn: Turn, resolveBlob: BlobResolver, registry: ContentBlockRegistry): Promise<Content>;
+/**
+ * Maps a single workspace block to a Gemini Part via the registry's provider mapping.
+ *
+ * Throws if no mapping is registered for provider() — every block type that can
+ * appear in a transcript must have a Gemini mapping registered by the adapter at
+ * initialisation time. There is no silent fallback: an unmapped block is a gap in
+ * the adapter's setup, not a recoverable runtime condition.
+ */
+declare function mapBlockToPart(block: BaseContentBlock<string>, registry: ContentBlockRegistry): Part | null;
+
+declare const index_GOOGLE_MODELS: typeof GOOGLE_MODELS;
+type index_GoogleGenAIAdapter = GoogleGenAIAdapter;
+declare const index_GoogleGenAIAdapter: typeof GoogleGenAIAdapter;
+declare const index_mapBlockToPart: typeof mapBlockToPart;
+declare const index_mapTurnToContent: typeof mapTurnToContent;
+declare const index_mappings: typeof mappings;
+declare const index_parseModelResponse: typeof parseModelResponse;
+declare namespace index {
+  export { index_GOOGLE_MODELS as GOOGLE_MODELS, index_GoogleGenAIAdapter as GoogleGenAIAdapter, index_mapBlockToPart as mapBlockToPart, index_mapTurnToContent as mapTurnToContent, index_mappings as mappings, index_parseModelResponse as parseModelResponse };
+}
+
 interface CreateWorkspaceParams {
     db: Database;
     blobStorage: BlobStorage;
@@ -2666,4 +2421,4 @@ declare function createWorkspace(params: CreateWorkspaceParams): Promise<{
     services: WorkspaceServices;
 }>;
 
-export { type AddContext, type AddPreference, type AddRole, type AddSessionTopics, type AddTopic, type AddTurn, type AuthRequest, type BackendError, type BaseCommand, type BaseContentBlock, type BlobCommand, type BlobError, type BlobMediaType, type BlobRecord, type BlobRef, type BlobResolver, type BranchInfo, type BranchTurn, COLLECTIONS, type Collections, type Command, type ContentBlock, type Context, type ContextContent, type ContextRetriever, type ContextSummary, type CreateSession, type CreateWorkspace, type CreateWorkspaceParams, type DeepPartial, type DeleteContext, type DeletePreference, type DeleteRole, type DeleteSession, type DeleteTopic, type DeleteTurn, type DocumentBlock, type DocumentMediaType, type DuplicateKeyError, EMPTY_SYSTEM_ROLE, type EditTurn, type ForkSession, type ImageBlock, type ImageMediaType, type Index, type IndexExtensions, type Indexer, type InvalidCommandError, type LLMAdapter, type LLMAdapterStatic, LRUCache, type MergeTopics, type ModelConstraint, type ModelConstraintMap, type ModelName, type ModelProfile, type ModelRegistry, type NotFoundError, type OverrideSessionPreferences, type PermissionDeniedError, type PermissionGuard, type Preference, type PreferenceSummary, type Project, type PromptBuilder, type PromptBuilderOptions, type PurgeBlob, type RecordBlobRemoteId, type RegisterBlob, type ReleaseBlob, type ResolvedBlob, type ResolvedSession, type Result, type RetainBlob, type Role, type RoleSummary, type RoleTransitionBlock, type SHA256, Session, SessionManager, type SessionMetadata, type SessionSnapshot, type Settings, type Store, type Summarizer, type SummaryBlock, type SwitchSessionRole, type SyncWorkspace, type SystemActor, type TextBlock, type ThinkingBlock, type Timestamp, type ToolCall, type ToolCallCommand, type ToolRegistry, type ToolResultBlock, type ToolSummary, type ToolUseBlock, type Topic, type TopicIndex, type Turn, TurnBuilder, type TurnKey, type TurnNode, type TurnProcessor, type TurnRef, TurnTree, type URI, type UUID, type UpdateContext, type UpdatePreference, type UpdateRole, type UpdateSession, type UpdateTopic, type UpdateTurn, type Workspace, type WorkspaceBundle, type WorkspaceContext, type WorkspaceDatabase, type WorkspaceError, type WorkspaceEvents, type WorkspaceExtension, WorkspaceManager, type WorkspaceMiddleware, type WorkspaceReducer, bufferToBase64, computeSHA256, createWorkspace, createWorkspaceDatabase, del, error, getExtension, merge, ok, omitNullUndefined, shortHash, success };
+export { type AddContext, type AddPreference, type AddRole, type AddSessionTopics, type AddTopic, type AddTurn, type AuthRequest, type BackendError, type BaseCommand, type BaseContentBlock, type BlobCommand, type BlobContextContent, type BlobError, type BlobMediaType, type BlobRecord, type BlobRef, type BlobResolver, type BranchInfo, type BranchTurn, COLLECTIONS, type Collections, type Command, type ContentBlock, type Context, type ContextContent, type ContextDefinition, type ContextRetriever, type ContextSummary, type CreateSession, type CreateWorkspace, type CreateWorkspaceParams, type DeepPartial, type DefaultContextContent, type DeleteContext, type DeletePreference, type DeleteRole, type DeleteSession, type DeleteTopic, type DeleteTurn, type DocumentBlock, type DocumentMediaType, type DuplicateKeyError, EMPTY_SYSTEM_ROLE, type EditTurn, type ForkSession, index as GoogleAdapter, type ImageBlock, type ImageMediaType, type Index, type IndexExtensions, type IndexedDBBlobConfig, IndexedDBBlobStorage, type Indexer, type InvalidCommandError, type JsonContextContent, type LLMAdapter, type LLMAdapterStatic, LRUCache, MemoryBlobStorage, type MergeTopics, type ModelConstraint, type ModelConstraintMap, type ModelName, type ModelProfile, type ModelRegistry, type NotFoundError, type OverrideSessionPreferences, type PermissionDeniedError, type PermissionGuard, type Preference, type PreferenceSummary, type Project, type PromptBuilder, type PromptBuilderOptions, type PurgeBlob, type RecordBlobRemoteId, type RegisterBlob, type ReleaseBlob, type RemoteContextContent, type ResolvedBlob, type ResolvedSession, type Result, type RetainBlob, type Role, type RoleSummary, type RoleTransitionBlock, type SHA256, Session, SessionManager, type SessionMetadata, type SessionSnapshot, type Settings, type Store, type Summarizer, type SummaryBlock, type SwitchSessionRole, type SyncWorkspace, type SystemActor, type TextBlock, type TextContextContent, type ThinkingBlock, type Timestamp, type ToolCall, type ToolCallCommand, type ToolRegistry, type ToolResultBlock, type ToolSummary, type ToolUseBlock, type Topic, type TopicIndex, type Turn, TurnBuilder, type TurnKey, type TurnNode, type TurnProcessor, type TurnRef, TurnTree, type URI, type UUID, type UpdateContext, type UpdatePreference, type UpdateRole, type UpdateSession, type UpdateTopic, type UpdateTurn, type Workspace, type WorkspaceBundle, type WorkspaceContext, type WorkspaceDatabase, type WorkspaceError, type WorkspaceEvents, type WorkspaceExtension, WorkspaceManager, type WorkspaceMiddleware, type WorkspaceReducer, bufferToBase64, computeSHA256, createEmptySession, createEmptyTurn, createEmptyWorkspace, createWorkspace, createWorkspaceDatabase, del, error, getExtension, merge, ok, omitNullUndefined, shortHash, success };