@soulcraft/sdk 1.7.0 → 2.0.1

package/dist/namespaces.d.ts

@@ -0,0 +1,2942 @@
+/**
+ * @module namespaces
+ * @description The single source of truth for every SDK namespace and method.
+ *
+ * {@link SoulcraftNamespaces} defines the complete API surface that clients can
+ * call and servers must implement. Client proxies and server handlers are both
+ * derived from this contract.
+ *
+ * ## Namespace tiers
+ *
+ * - **Tier 1**: Already exists in SDK modules — the interface re-exports them.
+ * - **Tier 2**: New namespaces that absorb Workshop/Venue route handlers.
+ * - **Tier 3**: Inline endpoints absorbed into existing namespaces.
+ *
+ * ## Transport invariance
+ *
+ * Every method defined here works identically across PostMessage, HTTP, WebSocket,
+ * and local transports. The transport is the only variable — the API contract is
+ * constant.
+ *
+ * @example Client usage
+ * ```typescript
+ * import { createSoulcraftProxy } from '@soulcraft/sdk/client'
+ * const soulcraft = createSoulcraftProxy(transport)
+ * const results = await soulcraft.brainy.find({ query: 'candles' })
+ * const graph = await soulcraft.graph.getData()
+ * ```
+ *
+ * @example Server handler
+ * ```typescript
+ * import { createSoulcraftRouter } from '@soulcraft/sdk/server'
+ * const router = createSoulcraftRouter({ resolveBrain, authenticate, providers })
+ * app.route('', router)
+ * ```
+ */
+import type { SoulcraftBrainy } from './modules/brainy/types.js';
+import type { AiModule } from './modules/ai/types.js';
+import type { BillingModule } from './modules/billing/types.js';
+import type { EventsModule } from './modules/events/types.js';
+import type { SkillsModule } from './modules/skills/types.js';
+import type { KitsModule } from './modules/kits/types.js';
+import type { NotificationsModule } from './modules/notifications/types.js';
+import type { HallModule } from './modules/hall/types.js';
+/**
+ * @description A single frame in a streaming AI chat response.
+ *
+ * Discriminated on the `type` field. The stream emits zero or more `text`,
+ * `tool_use`, `tool_result`, and `status` chunks, followed by exactly one
+ * `done` or `error` chunk as the terminal frame.
+ *
+ * @example Processing a chat stream
+ * ```typescript
+ * for await (const chunk of soulcraft.chat.sendStreaming('Explain quantum entanglement')) {
+ *   switch (chunk.type) {
+ *     case 'text':   process.stdout.write(chunk.text!); break
+ *     case 'status': showSpinner(chunk.status!); break
+ *     case 'done':   console.log('Tokens:', chunk.usage); break
+ *     case 'error':  console.error(chunk.error); break
+ *   }
+ * }
+ * ```
+ */
+export interface ChatStreamChunk {
+    /** Discriminant — determines which optional fields are populated. */
+    type: 'text' | 'tool_use' | 'tool_result' | 'status' | 'done' | 'error';
+    /** Text content for `text` chunks. Each chunk is a partial token or sentence fragment. */
+    text?: string | undefined;
+    /** Tool call details for `tool_use` chunks. Claude is invoking a tool. */
+    toolCall?: {
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+    } | undefined;
+    /** Tool execution result for `tool_result` chunks. The server executed the tool. */
+    toolResult?: {
+        toolUseId: string;
+        content: string;
+    } | undefined;
+    /** Status message for `status` chunks (e.g. `'Searching entities...'`, `'Analyzing graph...'`). */
+    status?: string | undefined;
+    /** Token usage stats, present only on `done` chunks. */
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        model: string;
+    } | undefined;
+    /** Error message, present only on `error` chunks. */
+    error?: string | undefined;
+}
+/**
+ * @description Summary metadata for a chat conversation.
+ *
+ * Returned by {@link ChatNamespace.listConversations} and
+ * {@link ChatNamespace.createConversation}. Does not include message bodies —
+ * use {@link ChatNamespace.getConversation} for full message history.
+ */
+export interface ChatConversation {
+    /** Unique conversation identifier (UUID). */
+    id: string;
+    /** User-visible title, auto-generated from the first message or set manually. */
+    title: string;
+    /** ISO 8601 timestamp when the conversation was created. */
+    createdAt: string;
+    /** ISO 8601 timestamp of the most recent message. */
+    updatedAt: string;
+    /** Total number of messages (user + assistant). */
+    messageCount: number;
+}
+/**
+ * @description A single message within a chat conversation.
+ */
+export interface ChatMessage {
+    /** Who sent this message. */
+    role: 'user' | 'assistant';
+    /** The message text content. */
+    content: string;
+    /** ISO 8601 timestamp when the message was sent. */
+    timestamp: string;
+    /** The Claude model ID that generated this message (assistant messages only). */
+    model?: string | undefined;
+}
+/**
+ * @description A full conversation including all messages.
+ *
+ * Extends {@link ChatConversation} with the complete message history.
+ * Returned by {@link ChatNamespace.getConversation}.
+ */
+export interface ChatConversationDetail extends ChatConversation {
+    /** Ordered array of all messages in this conversation. */
+    messages: ChatMessage[];
+}
+/**
+ * @description Graph visualization payload containing nodes and edges.
+ *
+ * Returned by all methods on {@link GraphNamespace}. The nodes and edges are
+ * assembled from Brainy entities and relationships, suitable for rendering
+ * with Cytoscape.js, D3, or any graph visualization library.
+ */
+export interface GraphData {
+    /** All nodes (entities) in the graph. */
+    nodes: GraphNode[];
+    /** All edges (relationships) between nodes. */
+    edges: GraphEdge[];
+}
+/**
+ * @description A single node in the graph visualization.
+ *
+ * Each node represents a Brainy entity with its display label and type.
+ */
+export interface GraphNode {
+    /** The entity's unique identifier (Brainy entity ID). */
+    id: string;
+    /** Display label (typically `metadata.name`). */
+    label: string;
+    /** The entity's NounType (e.g. `'Person'`, `'Document'`, `'Concept'`). */
+    type: string;
+    /** Additional entity metadata for tooltips, filtering, and styling. */
+    metadata?: Record<string, unknown> | undefined;
+}
+/**
+ * @description A single edge in the graph visualization.
+ *
+ * Each edge represents a Brainy relationship between two entities.
+ */
+export interface GraphEdge {
+    /** Unique edge identifier (typically `{from}-{verbType}-{to}`). */
+    id: string;
+    /** Source node ID. */
+    source: string;
+    /** Target node ID. */
+    target: string;
+    /** Display label for the edge (the VerbType name). */
+    label: string;
+    /** The relationship's VerbType (e.g. `'relatedTo'`, `'partOf'`, `'createdBy'`). */
+    type: string;
+}
+/**
+ * @description Aggregate statistics about the workspace's knowledge graph.
+ *
+ * Returned by {@link GraphNamespace.getStats}.
+ */
+export interface GraphStats {
+    /** Total number of entities in the workspace. */
+    nodeCount: number;
+    /** Total number of relationships in the workspace. */
+    edgeCount: number;
+    /** Count of entities per NounType (e.g. `{ Person: 42, Document: 15 }`). */
+    typeDistribution: Record<string, number>;
+    /** Count of relationships per VerbType (e.g. `{ relatedTo: 30, partOf: 12 }`). */
+    verbDistribution: Record<string, number>;
+}
+/**
+ * @description A single result from semantic or unified search.
+ *
+ * Returned by {@link SearchNamespace.query} and {@link SearchNamespace.unified}.
+ */
+export interface SearchResult {
+    /** The entity's unique identifier. */
+    id: string;
+    /** The entity's display name. */
+    name: string;
+    /** The entity's NounType. */
+    type: string;
+    /** Relevance score (0–1, higher is more relevant). */
+    score: number;
+    /** A text snippet with the matching portion highlighted, if available. */
+    highlight?: string | undefined;
+    /** Additional entity metadata for display. */
+    metadata?: Record<string, unknown> | undefined;
+}
+/**
+ * @description A view collection — a named group of entities used to filter
+ * graph views, boards, galleries, and other explore visualizations.
+ *
+ * Returned by {@link CollectionsNamespace} CRUD methods.
+ */
+export interface ViewCollection {
+    /** Unique collection identifier (Brainy entity ID). */
+    id: string;
+    /** User-visible collection name. */
+    name: string;
+    /** Collection type (e.g. `'manual'`, `'smart'`, `'virtual'`). */
+    type: string;
+    /** Number of entities currently in this collection. */
+    memberCount: number;
+    /** Additional collection metadata (filter criteria, display settings, etc.). */
+    metadata?: Record<string, unknown> | undefined;
+}
+/**
+ * @description A code annotation — a developer note attached to a specific
+ * line range in a VFS file. Used by the Illuminate feature.
+ *
+ * Returned by {@link AnnotationsNamespace} CRUD methods.
+ */
+export interface Annotation {
+    /** Unique annotation identifier (Brainy entity ID). */
+    id: string;
+    /** The VFS file path this annotation is attached to. */
+    filePath: string;
+    /** First line of the annotated range (1-based). */
+    lineStart: number;
+    /** Last line of the annotated range (1-based, inclusive). */
+    lineEnd: number;
+    /** The annotation text (Markdown supported). */
+    content: string;
+    /** Annotation type (e.g. `'note'`, `'question'`, `'explanation'`). */
+    type: string;
+    /** ISO 8601 timestamp when the annotation was created. */
+    createdAt: string;
+}
+/**
+ * @description Metadata about a workspace.
+ *
+ * Returned by {@link WorkspaceNamespace.list} and {@link WorkspaceNamespace.get}.
+ */
+export interface WorkspaceInfo {
+    /** Unique workspace identifier. */
+    id: string;
+    /** User-visible workspace name. */
+    name: string;
+    /** The kit used to initialize this workspace, if any. */
+    kitId?: string | undefined;
+    /** ISO 8601 timestamp when the workspace was created. */
+    createdAt: string;
+    /** ISO 8601 timestamp of the most recent modification. */
+    updatedAt: string;
+    /** Number of Brainy entities in the workspace. */
+    entityCount?: number | undefined;
+    /** Number of VFS files in the workspace. */
+    fileCount?: number | undefined;
+}
+/**
+ * @description Workspace health and initialization status.
+ *
+ * Returned by {@link WorkspaceNamespace.getStatus}. The `status` field
+ * indicates whether the Brainy instance is ready to serve requests.
+ */
+export interface WorkspaceStatus {
+    /** Current state: `'ready'` (accepting requests), `'initializing'` (cold start), or `'error'`. */
+    status: 'ready' | 'initializing' | 'error';
+    /** The workspace identifier. */
+    workspaceId?: string | undefined;
+    /** The kit used to initialize this workspace, if any. */
+    kitId?: string | undefined;
+    /** Number of entities (available once status is `'ready'`). */
+    entityCount?: number | undefined;
+    /** Error description when status is `'error'`. */
+    error?: string | undefined;
+}
+/**
+ * @description A published Living Link — a shareable URL pointing to workspace content.
+ *
+ * Returned by {@link PublishNamespace} link management methods.
+ */
+export interface PublishedLink {
+    /** Unique link identifier. */
+    id: string;
+    /** URL-safe slug for the link (e.g. `'my-project'`). */
+    slug: string;
+    /** The full public URL. */
+    url: string;
+    /** Link type (e.g. `'website'`, `'document'`, `'app'`). */
+    type: string;
+    /** ISO 8601 timestamp when the link was created. */
+    createdAt: string;
+    /** ISO 8601 timestamp when the link expires, or undefined for permanent links. */
+    expiresAt?: string | undefined;
+}
+/**
+ * @description Progress event emitted during file or data import operations.
+ *
+ * Delivered as SSE chunks via {@link ImportNamespace.uploadFiles} and
+ * {@link ImportNamespace.importData}.
+ */
+export interface ImportProgress {
+    /** Current phase of the import pipeline. */
+    phase: 'parsing' | 'importing' | 'embedding' | 'done' | 'error';
+    /** Number of items processed so far in this phase. */
+    current: number;
+    /** Total items expected in this phase. */
+    total: number;
+    /** Human-readable status message (e.g. `'Importing entities...'`). */
+    message?: string | undefined;
+    /** Error description when phase is `'error'`. */
+    error?: string | undefined;
+}
+/**
+ * @description Descriptor for a supported export format.
+ *
+ * Returned by {@link ExportNamespace.getExporters}.
+ */
+export interface ExportFormat {
+    /** Format identifier (e.g. `'json'`, `'graphml'`, `'csv'`). */
+    id: string;
+    /** Human-readable format name (e.g. `'GraphML (XML)'`). */
+    name: string;
+    /** File extension including the dot (e.g. `'.graphml'`). */
+    extension: string;
+    /** MIME type for the Content-Type header. */
+    mimeType: string;
+}
+/**
+ * @description Platform-level configuration including feature flags, limits,
+ * maintenance mode, and announcements.
+ *
+ * Returned by {@link ConfigNamespace.get}.
+ */
+export interface PlatformConfig {
+    /** Feature flags — keys are feature names, values indicate enabled/disabled. */
+    features: Record<string, boolean>;
+    /** Numeric limits — keys are limit names (e.g. `'maxWorkspaces'`, `'maxFileSize'`). */
+    limits: Record<string, number>;
+    /** Maintenance mode state. When active, most API calls are blocked. */
+    maintenance?: {
+        active: boolean;
+        message?: string;
+    } | undefined;
+    /** Active platform announcements shown to users. */
+    announcements?: Array<{
+        id: string;
+        message: string;
+        type: string;
+    }> | undefined;
+}
+/**
+ * @description Redacted API key information (the actual key is never returned).
+ *
+ * Returned by {@link SettingsNamespace.getApiKey}.
+ */
+export interface ApiKeyInfo {
+    /** The AI provider this key is for (e.g. `'anthropic'`). */
+    provider: string;
+    /** Last four characters of the key for identification. */
+    lastFour: string;
+    /** ISO 8601 timestamp when the key was saved. */
+    createdAt: string;
+}
+/**
+ * @description Breakdown of storage consumption for the current workspace.
+ *
+ * Returned by {@link SettingsNamespace.getStorageUsage}.
+ */
+export interface StorageUsage {
+    /** Total bytes consumed across all categories. */
+    totalBytes: number;
+    /** Bytes consumed by Brainy entity data (the knowledge graph). */
+    entityBytes: number;
+    /** Bytes consumed by VFS files (documents, images, code, etc.). */
+    fileBytes: number;
+    /** Bytes consumed by vector indices and search metadata. */
+    indexBytes: number;
+}
+/**
+ * @description Current state of a collaborative editing session.
+ *
+ * Returned by {@link SessionNamespace.join} and {@link SessionNamespace.getState}.
+ */
+export interface SessionState {
+    /** Unique session identifier. */
+    sessionId: string;
+    /** Currently connected participants. */
+    participants: Array<{
+        userId: string;
+        name: string;
+        joinedAt: string;
+    }>;
+    /** ISO 8601 timestamp when the session was created. */
+    createdAt: string;
+}
+/**
+ * @description Result of a media upload operation.
+ *
+ * Returned by {@link MediaNamespace.upload}.
+ */
+export interface MediaUploadResult {
+    /** Unique media identifier. */
+    mediaId: string;
+    /** Public URL to access the media. */
+    url: string;
+    /** MIME type of the stored (possibly transcoded) media. */
+    mimeType: string;
+    /** File size in bytes. */
+    size: number;
+    /** Duration in seconds (audio/video only). */
+    duration?: number;
+    /** Dimensions in pixels (image/video only). */
+    dimensions?: {
+        width: number;
+        height: number;
+    };
+    /** Thumbnail URL if thumbnail generation was requested. */
+    thumbnailUrl?: string;
+}
+/**
+ * @description Metadata about a stored media item.
+ *
+ * Returned by {@link MediaNamespace.getInfo}.
+ */
+export interface MediaInfo {
+    /** Unique media identifier. */
+    mediaId: string;
+    /** MIME type. */
+    mimeType: string;
+    /** File size in bytes. */
+    size: number;
+    /** Duration in seconds (audio/video only). */
+    duration?: number;
+    /** Dimensions in pixels (image/video only). */
+    dimensions?: {
+        width: number;
+        height: number;
+    };
+    /** Whether the media was transcoded from a different format. */
+    transcoded: boolean;
+    /** ISO 8601 timestamp when the media was uploaded. */
+    uploadedAt: string;
+}
+/**
+ * @description A peer currently subscribed to a realtime topic.
+ *
+ * Returned as part of {@link RealtimeNamespace.presence}.
+ */
+export interface RealtimePeer {
+    /** Unique user identifier. */
+    id: string;
+    /** Display name. */
+    name: string;
+    /** ISO 8601 timestamp when the peer joined this topic. */
+    joinedAt: string;
+}
+/**
+ * @description A subscription handle for a realtime topic.
+ *
+ * Returned by {@link RealtimeNamespace.subscribe}.
+ */
+export interface RealtimeSubscription {
+    /** Unsubscribe from the topic. */
+    unsubscribe(): void;
+}
+/**
+ * @description A product available for purchase.
+ *
+ * Returned by {@link CommerceNamespace.getProduct} and {@link CommerceNamespace.listProducts}.
+ */
+export interface CommerceProduct {
+    /** Unique product identifier. */
+    id: string;
+    /** Product display name. */
+    name: string;
+    /** Product description. */
+    description: string;
+    /** Price in smallest currency unit (e.g. cents). */
+    priceAmount: number;
+    /** Three-letter ISO 4217 currency code (e.g. `'usd'`). */
+    currency: string;
+    /** Whether the product is currently available for purchase. */
+    active: boolean;
+    /** Optional product images. */
+    images?: string[];
+    /** Product metadata for application use. */
+    metadata?: Record<string, string>;
+}
+/**
+ * @description Result of initiating a checkout session.
+ *
+ * Returned by {@link CommerceNamespace.checkout}.
+ */
+export interface CheckoutSession {
+    /** Checkout session identifier. */
+    sessionId: string;
+    /** URL to redirect the customer to for payment. */
+    checkoutUrl: string;
+    /** ISO 8601 expiration timestamp for this checkout session. */
+    expiresAt: string;
+}
+/**
+ * @description A completed payment record.
+ *
+ * Returned by {@link CommerceNamespace.getPayment}.
+ */
+export interface PaymentRecord {
+    /** Payment identifier. */
+    id: string;
+    /** Amount in smallest currency unit. */
+    amount: number;
+    /** Three-letter ISO 4217 currency code. */
+    currency: string;
+    /** Payment status. */
+    status: 'succeeded' | 'pending' | 'failed' | 'refunded';
+    /** Customer email. */
+    customerEmail: string;
+    /** ISO 8601 timestamp. */
+    createdAt: string;
+}
+/**
+ * @description A verifiable credential with lineage tracing.
+ *
+ * Uses Brainy's graph model: the certification is a `contract` entity with
+ * `endorses`, `attributedTo`, and `dependsOn` relationships forming a lineage chain.
+ *
+ * @example Lineage chain
+ * ```
+ * Certifier ─[endorses]→ Certification ─[attributedTo]→ Learner
+ *                                        ─[dependsOn]→ Upstream Cert
+ * ```
+ */
+export interface Certification {
+    /** Unique certification identifier (Brainy entity ID). */
+    id: string;
+    /** Certification name (e.g. `'Advanced Candle Making'`). */
+    name: string;
+    /** Who issued this certification (certifier user ID). */
+    certifierId: string;
+    /** Who received this certification (learner user ID). */
+    learnerId: string;
+    /** Assessment score (0.0–1.0). */
+    score: number;
+    /** Whether the certification was AI-issued (vs. human instructor). */
+    aiIssued: boolean;
+    /** Lineage depth — how many upstream certifications in the chain. */
+    lineageDepth: number;
+    /** ISO 8601 timestamp when the certification was issued. */
+    issuedAt: string;
+    /** Optional upstream certification ID (lineage link). */
+    upstreamCertificationId?: string;
+}
+/**
+ * @description Assessment result from the graph-native scoring system.
+ *
+ * Score = demonstrated competencies / total required competencies.
+ */
+export interface AssessmentResult {
+    /** Computed score (0.0–1.0). */
+    score: number;
+    /** Whether the learner passed the threshold. */
+    passed: boolean;
+    /** Passing threshold (default: 0.8). */
+    threshold: number;
+    /** Competency IDs the learner has demonstrated. */
+    demonstratedCompetencies: string[];
+    /** Competency IDs the learner still needs. */
+    missingCompetencies: string[];
+    /** Total number of required competencies. */
+    totalCompetencies: number;
+}
+/**
+ * @description Supported output format for conversion.
+ *
+ * Returned by {@link FormatsNamespace.getOutputFormats}.
+ */
+export interface OutputFormat {
+    /** Format identifier (e.g. `'pdf'`, `'html'`, `'markdown'`). */
+    id: string;
+    /** Human-readable name. */
+    name: string;
+    /** MIME type of the output. */
+    mimeType: string;
+    /** Which source formats can convert to this output. */
+    sourceFormats: string[];
+}
+/**
+ * @description Result of a format validation.
+ *
+ * Returned by {@link FormatsNamespace.validate}.
+ */
+export interface FormatValidationResult {
+    /** Whether the document is valid. */
+    valid: boolean;
+    /** Validation errors (empty if valid). */
+    errors: Array<{
+        path: string;
+        message: string;
+    }>;
+}
+/**
+ * @description The complete Soulcraft SDK namespace surface.
+ *
+ * Every property is a namespace. Every method on a namespace is an RPC endpoint.
+ * Client proxies serialize calls as `{ ns, method, args }`. Server handlers
+ * dispatch based on this interface.
+ *
+ * Tier 1 namespaces reference existing module interfaces directly.
+ * Tier 2 namespaces define new methods that absorb Workshop/Venue route handlers.
+ */
+export interface SoulcraftNamespaces {
+    /**
+     * Full Brainy graph API — CRUD, search, embed, batch, relationships,
+     * analytics, sub-APIs (vfs, versions, neural, counts).
+     *
+     * Already implemented via recursive Proxy + LocalTransport dispatch.
+     * See {@link SoulcraftBrainy} for the full method list.
+     */
+    brainy: SoulcraftBrainy;
+    /**
+     * Claude AI — single-shot completions and streaming.
+     * See {@link AiModule} for method signatures and tool call handling.
+     */
+    ai: AiModule;
+    /**
+     * Usage metering, subscriptions, top-up credits, Stripe integration.
+     * See {@link BillingModule} for checkLimit, recordUsage, subscription management.
+     */
+    billing: BillingModule;
+    /**
+     * Platform event bus — typed publish/subscribe for entity changes, VFS events,
+     * and custom application events. See {@link EventsModule}.
+     */
+    events: EventsModule;
+    /**
+     * Skill loading and registry — load, list, install SKILL.md prompt files.
+     * See {@link SkillsModule}.
+     */
+    skills: SkillsModule;
+    /**
+     * Kit registry — load kit manifests, list kits, resolve template file paths.
+     * See {@link KitsModule}.
+     */
+    kits: KitsModule;
+    /**
+     * Email (Postmark) + SMS (Twilio) notifications with automatic dev fallback.
+     * See {@link NotificationsModule}.
+     */
+    notifications: NotificationsModule;
+    /**
+     * Real-time communication — WebRTC SFU, chat, recording, transcription via Hall server.
+     * See {@link HallModule}.
+     */
+    hall: HallModule;
+    /**
+     * AI conversation engine — full chat with streaming, tool use, conversations
+     * CRUD, memory, expertise profiles, tiered model routing, skill injection.
+     *
+     * Absorbs Workshop `routes/chat.ts` (~2000 lines).
+     */
+    chat: ChatNamespace;
+    /**
+     * Graph visualization data — full graph, stats, focused subgraph, neighbors.
+     *
+     * Absorbs Workshop `routes/graph.ts`.
+     */
+    graph: GraphNamespace;
+    /**
+     * Semantic and unified search, highlighting.
+     *
+     * Absorbs Workshop `routes/search.ts`.
+     */
+    search: SearchNamespace;
+    /**
+     * View collections, virtual collections, collection members, sample data.
+     *
+     * Absorbs Workshop `routes/collections.ts`.
+     */
+    collections: CollectionsNamespace;
+    /**
+     * Code annotations CRUD + AI-powered explanations.
+     *
+     * Absorbs Workshop `routes/annotations.ts`.
+     */
+    annotations: AnnotationsNamespace;
+    /**
+     * Workspace CRUD, backup/restore, settings, health check.
+     *
+     * Absorbs Workshop `routes/workspace.ts` + `routes/workspaces.ts`.
+     */
+    workspace: WorkspaceNamespace;
+    /**
+     * Publishing — Living Links, Venue deploy, Academy publish.
+     *
+     * Absorbs Workshop `routes/publish.ts`, `routes/deploy.ts`, `routes/academy-publish.ts`.
+     */
+    publish: PublishNamespace;
+    /**
+     * File import — smart file upload with progress, knowledge graph format import.
+     *
+     * Absorbs Workshop `routes/import.ts` + `routes/import-data.ts`.
+     */
+    import: ImportNamespace;
+    /**
+     * Export — project download, knowledge graph export, PDF export.
+     *
+     * Absorbs Workshop `routes/export.ts` + `routes/knowledge-graph.ts`.
+     */
+    export: ExportNamespace;
+    /**
+     * Platform configuration — feature flags, limits, announcements, maintenance mode.
+     *
+     * Absorbs Workshop `routes/config.ts`.
+     */
+    config: ConfigNamespace;
+    /**
+     * User settings — API key management, usage stats, storage usage.
+     *
+     * Absorbs Workshop `routes/settings.ts`.
+     */
+    settings: SettingsNamespace;
+    /**
+     * Project context (Glass Box AI transparency) + metadata repair.
+     *
+     * Absorbs Workshop `routes/project.ts`.
+     */
+    project: ProjectNamespace;
+    /**
+     * Collaborative session lifecycle — join, leave, state, history.
+     *
+     * Absorbs Workshop `routes/session.ts`.
+     */
+    session: SessionNamespace;
+    /**
+     * Analytics event forwarding (fire-and-forget).
+     *
+     * Absorbs the pulse section of Workshop `routes/app-services.ts`.
+     */
+    pulse: PulseNamespace;
+    /**
+     * Media pipeline — upload, transcode, stream audio/video/images.
+     * Backed by Hall server (hall.soulcraft.com).
+     *
+     * Enables podcast kits (record + transcribe + publish), video kits,
+     * gallery kits with image transforms.
+     */
+    media: MediaNamespace;
+    /**
+     * Real-time pub/sub — topic-based subscribe, broadcast, and presence.
+     * Backed by Hall server (hall.soulcraft.com).
+     *
+     * Enables multiplayer games, live dashboards, collaborative editors,
+     * chat applications, and any feature requiring real-time data sync.
+     */
+    realtime: RealtimeNamespace;
+    /**
+     * Commerce — products, checkout, payments. Stripe-first with pluggable
+     * provider interface for future payment processors.
+     *
+     * Enables e-commerce kits, booking kits, invoice kits with real
+     * payment processing.
+     */
+    commerce: CommerceNamespace;
+    /**
+     * Certification — issue, verify, and trace credential lineage.
+     * Graph-native verifiable credentials using Brainy's relationship model.
+     *
+     * Moved from Academy to SDK so any product or kit can issue certifications:
+     * Workshop skill completion, Venue training, game achievements, course credentials.
+     */
+    certification: CertificationNamespace;
+    /**
+     * Format conversion and validation — convert between Soulcraft portable
+     * formats (wdoc, wslide, wviz, wquiz) and output formats (PDF, HTML, etc.).
+     *
+     * Rendering stays in `@soulcraft/views`. SDK handles data conversion only.
+     */
+    formats: FormatsNamespace;
+    /**
+     * Auth session and token operations.
+     *
+     * Absorbs inline endpoints from `server-hono.ts` and `ws-token.ts`.
+     */
+    auth: AuthNamespace;
+}
+/**
+ * @description AI conversation engine with streaming, tool use, and conversation
+ * management. Handles tiered model routing (haiku → sonnet → opus based on
+ * complexity), workspace-aware skill injection, and persistent conversation state.
+ *
+ * @example Non-streaming chat
+ * ```typescript
+ * const { response, conversationId } = await soulcraft.chat.send('What entities are related to candles?', {
+ *   conversationId: 'conv-123',
+ * })
+ * console.log(response)
+ * ```
+ *
+ * @example Streaming chat
+ * ```typescript
+ * for await (const chunk of soulcraft.chat.sendStreaming('Explain the graph structure')) {
+ *   if (chunk.type === 'text') process.stdout.write(chunk.text!)
+ * }
+ * ```
+ */
+export interface ChatNamespace {
+    /**
+     * @description Send a message and receive the full response (non-streaming).
+     *
+     * The server selects the optimal Claude model based on message complexity,
+     * injects workspace-specific skills into the system prompt, and executes
+     * any tool calls (entity lookups, graph queries, etc.) before returning.
+     *
+     * @param message - The user's message text.
+     * @param options - Conversation context and configuration overrides.
+     * @param options.conversationId - Continue an existing conversation. If omitted, a new one is created.
+     * @param options.kitId - Kit to load skills from. Defaults to the workspace's kit.
+     * @param options.systemPrompt - Override the default system prompt (advanced use only).
+     * @param options.model - Force a specific Claude model ID instead of auto-selection.
+     * @returns The assistant's response with conversation ID and token usage.
+     *
+     * @example
+     * ```typescript
+     * const result = await soulcraft.chat.send('List all documents about candles')
+     * console.log(result.response)
+     * console.log(`Used ${result.usage.inputTokens + result.usage.outputTokens} tokens`)
+     * ```
+     */
+    send(message: string, options?: {
+        conversationId?: string;
+        kitId?: string;
+        systemPrompt?: string;
+        model?: string;
+    }): Promise<{
+        response: string;
+        conversationId: string;
+        usage: {
+            inputTokens: number;
+            outputTokens: number;
+            model: string;
+        };
+    }>;
+    /**
+     * @description Send a message and stream the response as chunks.
+     *
+     * Returns an `AsyncIterable<ChatStreamChunk>` that yields text tokens,
+     * tool invocations, status updates, and a terminal `done` or `error` frame.
+     * The server performs tool calls in-band — you'll see `tool_use` → `tool_result`
+     * chunks interleaved with text.
+     *
+     * @param message - The user's message text.
+     * @param options - Same options as {@link ChatNamespace.send}.
+     * @returns An async iterable of {@link ChatStreamChunk} frames.
+     *
+     * @example
+     * ```typescript
+     * let fullText = ''
+     * for await (const chunk of soulcraft.chat.sendStreaming('Explain quantum entanglement')) {
+     *   if (chunk.type === 'text') fullText += chunk.text
+     *   if (chunk.type === 'done') console.log('Model:', chunk.usage?.model)
+     * }
+     * ```
+     */
+    sendStreaming(message: string, options?: {
+        conversationId?: string;
+        kitId?: string;
+        systemPrompt?: string;
+        model?: string;
+    }): AsyncIterable<ChatStreamChunk>;
+    /**
+     * @description List all conversations for the current user in the active workspace.
+     *
+     * Returns summaries without message bodies — use {@link getConversation} for
+     * the full message history.
+     *
+     * @returns Array of conversation summaries, ordered by most recent first.
+     *
+     * @example
+     * ```typescript
+     * const conversations = await soulcraft.chat.listConversations()
+     * for (const conv of conversations) {
+     *   console.log(`${conv.title} (${conv.messageCount} messages)`)
+     * }
+     * ```
+     */
+    listConversations(): Promise<ChatConversation[]>;
+    /**
+     * @description Get a conversation with its full message history.
+     *
+     * @param conversationId - The conversation's unique identifier.
+     * @returns The full conversation with all messages, or `null` if not found.
+     *
+     * @example
+     * ```typescript
+     * const detail = await soulcraft.chat.getConversation('conv-abc123')
+     * if (detail) {
+     *   for (const msg of detail.messages) {
+     *     console.log(`[${msg.role}] ${msg.content.slice(0, 80)}...`)
+     *   }
+     * }
+     * ```
+     */
+    getConversation(conversationId: string): Promise<ChatConversationDetail | null>;
+    /**
+     * @description Create a new empty conversation.
+     *
+     * @param options - Optional title and kit association.
+     * @param options.title - Initial title. Auto-generated from the first message if omitted.
+     * @param options.kitId - Kit to associate with this conversation.
+     * @returns The newly created conversation metadata.
+     *
+     * @example
+     * ```typescript
+     * const conv = await soulcraft.chat.createConversation({ title: 'Research Notes' })
+     * const { response } = await soulcraft.chat.send('Hello!', { conversationId: conv.id })
+     * ```
+     */
+    createConversation(options?: {
+        title?: string;
+        kitId?: string;
+    }): Promise<ChatConversation>;
+    /**
+     * @description Delete a conversation and all its messages permanently.
+     *
+     * @param conversationId - The conversation to delete.
+     *
+     * @example
+     * ```typescript
+     * await soulcraft.chat.deleteConversation('conv-abc123')
+     * ```
+     */
+    deleteConversation(conversationId: string): Promise<void>;
+    /**
+     * @description Rename a conversation.
+     *
+     * @param conversationId - The conversation to rename.
+     * @param title - The new title.
+     *
+     * @example
+     * ```typescript
+     * await soulcraft.chat.renameConversation('conv-abc123', 'Candle Inventory Analysis')
+     * ```
+     */
+    renameConversation(conversationId: string, title: string): Promise<void>;
+    /**
+     * @description Get the AI's learned expertise profile for the current workspace.
+     *
+     * The expertise is accumulated over time from conversations and reflects what
+     * the AI has learned about the user's domain, preferences, and workflow.
+     *
+     * @returns Topics, skills, and insights the AI has learned.
+     *
+     * @example
+     * ```typescript
+     * const { topics, skills, insights } = await soulcraft.chat.getExpertise()
+     * console.log('Topics:', topics.join(', '))
+     * ```
+     */
+    getExpertise(): Promise<{
+        topics: string[];
+        skills: string[];
+        insights: string[];
+    }>;
+    /**
+     * @description Get the AI context summary for Glass Box transparency.
+     *
+     * Returns the system prompt, available tools, loaded skills, and memory items
+     * that the AI currently has access to. This powers the "Glass Box" feature
+     * that lets users see exactly what the AI knows and can do.
+     *
+     * @returns The full AI context.
+     *
+     * @example
+     * ```typescript
+     * const ctx = await soulcraft.chat.getContext()
+     * console.log(`Tools available: ${ctx.tools.length}`)
+     * console.log(`Skills loaded: ${ctx.skills.length}`)
+     * ```
+     */
+    getContext(): Promise<{
+        systemPrompt: string;
+        tools: string[];
+        skills: string[];
+        memory: string[];
+    }>;
+}
+/**
+ * @description Graph visualization data assembly from Brainy queries.
+ *
+ * Transforms raw Brainy entities and relationships into a format suitable for
+ * graph rendering (Cytoscape.js, D3, etc.). Supports full-graph, focused
+ * subgraph, and neighborhood queries.
+ *
+ * @example
+ * ```typescript
+ * const { nodes, edges } = await soulcraft.graph.getData({ limit: 500 })
+ * renderCytoscapeGraph(nodes, edges)
+ * ```
+ */
+export interface GraphNamespace {
+    /**
+     * @description Get the full graph (nodes + edges) for the current workspace.
+     *
+     * @param options - Filtering and pagination options.
+     * @param options.limit - Maximum number of nodes to return. Default: all.
+     * @param options.types - Filter to specific NounTypes (e.g. `['Person', 'Document']`).
+     * @returns Graph data with nodes and edges.
+     *
+     * @example
+     * ```typescript
+     * const graph = await soulcraft.graph.getData({ limit: 200, types: ['Person'] })
+     * console.log(`${graph.nodes.length} people, ${graph.edges.length} relationships`)
+     * ```
+     */
+    getData(options?: {
+        limit?: number;
+        types?: string[];
+    }): Promise<GraphData>;
+    /**
+     * @description Get aggregate statistics about the workspace's knowledge graph.
+     *
+     * @returns Node/edge counts and type distributions.
+     *
+     * @example
+     * ```typescript
+     * const stats = await soulcraft.graph.getStats()
+     * console.log(`${stats.nodeCount} entities, ${stats.edgeCount} relationships`)
+     * ```
+     */
+    getStats(): Promise<GraphStats>;
+    /**
+     * @description Get a focused subgraph centered on a specific entity.
+     *
+     * Returns the target entity plus all entities within `depth` hops,
+     * and all relationships between them.
+     *
+     * @param entityId - The center entity's ID.
+     * @param options - Traversal options.
+     * @param options.depth - Maximum traversal depth (number of hops). Default: 2.
+     * @returns The focused subgraph.
+     *
+     * @example
+     * ```typescript
+     * const subgraph = await soulcraft.graph.getFocused('entity-abc', { depth: 3 })
+     * ```
+     */
+    getFocused(entityId: string, options?: {
+        depth?: number;
+    }): Promise<GraphData>;
+    /**
+     * @description Get the immediate neighbors (1-hop) of an entity.
+     *
+     * Returns the target entity, all directly related entities, and the
+     * relationships connecting them.
+     *
+     * @param entityId - The entity whose neighbors to fetch.
+     * @returns Neighbor nodes and connecting edges.
+     *
+     * @example
+     * ```typescript
+     * const neighbors = await soulcraft.graph.getNeighbors('entity-abc')
+     * console.log(`${neighbors.nodes.length} direct connections`)
+     * ```
+     */
+    getNeighbors(entityId: string): Promise<GraphData>;
+    /**
+     * @description Batch-fetch graph data for multiple entity IDs.
+     *
+     * Returns all specified entities as nodes and all relationships between them.
+     * Useful for rendering a specific selection of entities.
+     *
+     * @param entityIds - Array of entity IDs to include.
+     * @returns Graph containing the specified entities and their inter-relationships.
+     *
+     * @example
+     * ```typescript
+     * const batch = await soulcraft.graph.getBatch(['id-1', 'id-2', 'id-3'])
+     * ```
+     */
+    getBatch(entityIds: string[]): Promise<GraphData>;
+}
+/**
+ * @description Semantic search, unified search (Command Palette), and text highlighting.
+ *
+ * Uses Brainy's vector embeddings for semantic similarity and full-text indices
+ * for keyword matching.
+ *
+ * @example
+ * ```typescript
+ * const results = await soulcraft.search.query('candle making techniques', { limit: 10 })
+ * for (const r of results) console.log(`${r.name} (${r.score.toFixed(2)})`)
+ * ```
+ */
+export interface SearchNamespace {
+    /**
+     * @description Execute a semantic search across entities in the workspace.
+     *
+     * Uses vector embeddings to find entities semantically similar to the query,
+     * regardless of exact keyword matches.
+     *
+     * @param query - Natural language search query.
+     * @param options - Search configuration.
+     * @param options.types - Filter to specific NounTypes.
+     * @param options.limit - Maximum results. Default: 20.
+     * @param options.threshold - Minimum similarity score (0–1). Default: 0.0.
+     * @returns Ranked search results with relevance scores.
+     *
+     * @example
+     * ```typescript
+     * const results = await soulcraft.search.query('how to make soy candles', {
+     *   types: ['Document', 'Note'],
+     *   limit: 5,
+     * })
+     * ```
+     */
+    query(query: string, options?: {
+        types?: string[];
+        limit?: number;
+        threshold?: number;
+    }): Promise<SearchResult[]>;
+    /**
+     * @description Unified search for the Command Palette — searches entities, files, and commands.
+     *
+     * Provides fast, fuzzy matching suitable for interactive use. Results include
+     * the category (entity, file, or command) in the metadata.
+     *
+     * @param query - Search query (can be partial/fuzzy).
+     * @param options - Search configuration.
+     * @param options.limit - Maximum results. Default: 10.
+     * @param options.categories - Filter to specific categories (e.g. `['entity', 'file']`).
+     * @returns Ranked search results across all categories.
+     *
+     * @example
+     * ```typescript
+     * const results = await soulcraft.search.unified('candle', { limit: 8 })
+     * ```
+     */
+    unified(query: string, options?: {
+        limit?: number;
+        categories?: string[];
+    }): Promise<SearchResult[]>;
+    /**
+     * @description Get highlighted text matches for a search query within a specific entity.
+     *
+     * Returns the entity's text split into alternating match/non-match segments
+     * for rendering search result previews with highlighted keywords.
+     *
+     * @param entityId - The entity to highlight within.
+     * @param query - The search query to highlight.
+     * @returns Array of text segments with match flags.
+     *
+     * @example
+     * ```typescript
+     * const { highlights } = await soulcraft.search.highlight('entity-abc', 'candle')
+     * // highlights = [{ text: 'How to make ', isMatch: false }, { text: 'candle', isMatch: true }, ...]
+     * ```
+     */
+    highlight(entityId: string, query: string): Promise<{
+        highlights: Array<{
+            text: string;
+            isMatch: boolean;
+        }>;
+    }>;
+}
+/**
+ * @description View collection management — named groups of entities used to
+ * filter explore visualizations (graph, board, gallery, timeline, etc.).
+ *
+ * Also manages sample data — demo entities pre-populated for each kit type
+ * so new users see a populated workspace immediately.
+ *
+ * @example
+ * ```typescript
+ * const collections = await soulcraft.collections.list()
+ * const members = await soulcraft.collections.getMembers(collections[0].id)
+ * ```
+ */
+export interface CollectionsNamespace {
+    /**
+     * @description List all view collections in the workspace.
+     *
+     * @param options - Filtering options.
+     * @param options.type - Filter by collection type (e.g. `'manual'`, `'smart'`).
+     * @returns All matching collections.
+     *
+     * @example
+     * ```typescript
+     * const collections = await soulcraft.collections.list({ type: 'manual' })
+     * ```
+     */
+    list(options?: {
+        type?: string;
+    }): Promise<ViewCollection[]>;
+    /**
+     * @description Get a specific collection by ID.
+     *
+     * @param collectionId - The collection's unique identifier.
+     * @returns The collection, or `null` if not found.
+     *
+     * @example
+     * ```typescript
+     * const collection = await soulcraft.collections.get('col-abc123')
+     * ```
+     */
+    get(collectionId: string): Promise<ViewCollection | null>;
+    /**
+     * @description Create a new view collection.
+     *
+     * @param options - Collection properties.
+     * @param options.name - Display name for the collection.
+     * @param options.type - Collection type (e.g. `'manual'`).
+     * @param options.metadata - Additional metadata (filter criteria, display settings).
+     * @returns The newly created collection.
+     *
+     * @example
+     * ```typescript
+     * const col = await soulcraft.collections.create({ name: 'Key People', type: 'manual' })
+     * ```
+     */
+    create(options: {
+        name: string;
+        type: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<ViewCollection>;
+    /**
+     * @description Update a collection's name or metadata.
+     *
+     * @param collectionId - The collection to update.
+     * @param updates - Fields to update (only provided fields are changed).
+     * @returns The updated collection.
+     *
+     * @example
+     * ```typescript
+     * await soulcraft.collections.update('col-abc', { name: 'Important People' })
+     * ```
+     */
+    update(collectionId: string, updates: {
+        name?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<ViewCollection>;
+    /**
+     * @description Delete a collection. Does not delete the member entities themselves.
+     *
+     * @param collectionId - The collection to delete.
+     *
+     * @example
+     * ```typescript
+     * await soulcraft.collections.delete('col-abc123')
+     * ```
+     */
+    delete(collectionId: string): Promise<void>;
+    /**
+     * @description Get the entities that belong to a collection.
+     *
+     * @param collectionId - The collection whose members to list.
+     * @returns Array of member entity summaries.
+     *
+     * @example
+     * ```typescript
+     * const members = await soulcraft.collections.getMembers('col-abc')
+     * console.log(`${members.length} entities in collection`)
+     * ```
+     */
+    getMembers(collectionId: string): Promise<Array<{
+        id: string;
+        name: string;
+        type: string;
+    }>>;
+    /**
+     * @description Add an entity to a collection.
+     *
+     * @param collectionId - The collection to add to.
+     * @param entityId - The entity to add.
+     *
+     * @example
+     * ```typescript
+     * await soulcraft.collections.addMember('col-abc', 'entity-xyz')
+     * ```
+     */
+    addMember(collectionId: string, entityId: string): Promise<void>;
+    /**
+     * @description Remove an entity from a collection. Does not delete the entity itself.
+     *
+     * @param collectionId - The collection to remove from.
+     * @param entityId - The entity to remove.
+     *
+     * @example
+     * ```typescript
+     * await soulcraft.collections.removeMember('col-abc', 'entity-xyz')
+     * ```
+     */
+    removeMember(collectionId: string, entityId: string): Promise<void>;
+    /**
+     * @description Load sample data for a kit, populating the workspace with demo entities.
+     *
+     * Idempotent — calling again after sample data exists is a no-op.
+     *
+     * @param kitId - The kit whose sample data to load.
+     * @returns The number of entities created.
+     *
+     * @example
+     * ```typescript
+     * const { count } = await soulcraft.collections.loadSampleData('wicks-and-whiskers')
+     * console.log(`Created ${count} sample entities`)
+     * ```
+     */
+    loadSampleData(kitId: string): Promise<{
+        count: number;
+    }>;
+    /**
+     * @description Clear all sample data from the workspace.
+     *
+     * Removes only entities flagged as sample data — user-created entities are
+     * never affected.
+     *
+     * @example
+     * ```typescript
+     * await soulcraft.collections.clearSampleData()
+     * ```
+     */
+    clearSampleData(): Promise<void>;
+}
+/**
+ * @description Code annotation CRUD with AI-powered explanations.
+ *
+ * Annotations are developer notes attached to specific line ranges in VFS files.
+ * The Illuminate feature uses AI to generate explanations of selected code.
+ *
+ * @example
+ * ```typescript
+ * const annotations = await soulcraft.annotations.list('/src/server.ts')
+ * const { explanation } = await soulcraft.annotations.aiExplain({
+ *   filePath: '/src/server.ts', lineStart: 10, lineEnd: 25, code: '...'
+ * })
+ * ```
+ */
+export interface AnnotationsNamespace {
+    /**
+     * @description List all annotations for a specific file.
+     *
+     * @param filePath - VFS file path (e.g. `'/src/server.ts'`).
+     * @returns All annotations attached to the file, ordered by line number.
+     *
+     * @example
+     * ```typescript
+     * const annotations = await soulcraft.annotations.list('/src/lib/utils.ts')
+     * ```
+     */
+    list(filePath: string): Promise<Annotation[]>;
+    /**
+     * @description Get a specific annotation by ID.
+     *
+     * @param annotationId - The annotation's unique identifier.
+     * @returns The annotation, or `null` if not found.
+     *
+     * @example
+     * ```typescript
+     * const annotation = await soulcraft.annotations.get('ann-abc123')
+     * ```
+     */
+    get(annotationId: string): Promise<Annotation | null>;
+    /**
+     * @description Create a new annotation on a file.
+     *
+     * @param options - Annotation properties.
+     * @param options.filePath - VFS file path to annotate.
+     * @param options.lineStart - First line of the annotated range (1-based).
+     * @param options.lineEnd - Last line of the annotated range (1-based, inclusive).
+     * @param options.content - The annotation text (Markdown supported).
+     * @param options.type - Annotation type (e.g. `'note'`, `'question'`). Default: `'note'`.
+     * @returns The created annotation.
+     *
+     * @example
+     * ```typescript
+     * const ann = await soulcraft.annotations.create({
+     *   filePath: '/src/server.ts',
+     *   lineStart: 42,
+     *   lineEnd: 55,
+     *   content: 'This function handles the Brainy cold start timeout.',
+     * })
+     * ```
+     */
+    create(options: {
+        filePath: string;
+        lineStart: number;
+        lineEnd: number;
+        content: string;
+        type?: string;
+    }): Promise<Annotation>;
+    /**
+     * @description Update an existing annotation's content or type.
+     *
+     * @param annotationId - The annotation to update.
+     * @param updates - Fields to update (only provided fields are changed).
+     * @returns The updated annotation.
+     *
+     * @example
+     * ```typescript
+     * await soulcraft.annotations.update('ann-abc', { content: 'Updated explanation' })
+     * ```
+     */
+    update(annotationId: string, updates: {
+        content?: string;
+        type?: string;
+    }): Promise<Annotation>;
+    /**
+     * @description Delete an annotation permanently.
+     *
+     * @param annotationId - The annotation to delete.
+     *
+     * @example
+     * ```typescript
+     * await soulcraft.annotations.delete('ann-abc123')
+     * ```
+     */
+    delete(annotationId: string): Promise<void>;
+    /**
+     * @description Generate an AI explanation for a selected code range.
+     *
+     * Uses Claude to analyze the code and produce a clear, educational explanation.
+     * The explanation is returned but NOT automatically saved as an annotation.
+     *
+     * @param options - The code selection to explain.
+     * @param options.filePath - VFS file path containing the code.
+     * @param options.lineStart - First line of the selection.
+     * @param options.lineEnd - Last line of the selection.
+     * @param options.code - The actual source code text to explain.
+     * @returns The AI-generated explanation.
+     *
+     * @example
+     * ```typescript
+     * const { explanation } = await soulcraft.annotations.aiExplain({
+     *   filePath: '/src/server.ts',
+     *   lineStart: 42, lineEnd: 55,
+     *   code: 'export default { port: PORT, fetch: app.fetch, idleTimeout: 255 }',
+     * })
+     * ```
+     */
+    aiExplain(options: {
+        filePath: string;
+        lineStart: number;
+        lineEnd: number;
+        code: string;
+    }): Promise<{
+        explanation: string;
+    }>;
+}
+/**
+ * @description Workspace CRUD, backup/restore, Venue connection, settings, and health checks.
+ *
+ * A workspace is an isolated Brainy instance + VFS store. Each user can have
+ * multiple workspaces, optionally initialized from a kit template.
+ *
+ * @example
+ * ```typescript
+ * const workspaces = await soulcraft.workspace.list()
+ * const status = await soulcraft.workspace.getStatus()
+ * if (status.status === 'ready') console.log(`${status.entityCount} entities`)
+ * ```
+ */
+export interface WorkspaceNamespace {
+    /**
+     * @description List all workspaces for the current user.
+     *
+     * @returns Array of workspace metadata.
+     *
+     * @example
+     * ```typescript
+     * const workspaces = await soulcraft.workspace.list()
+     * for (const ws of workspaces) console.log(`${ws.name} (${ws.entityCount} entities)`)
+     * ```
+     */
+    list(): Promise<WorkspaceInfo[]>;
+    /**
+     * @description Get a specific workspace by ID.
+     *
+     * @param workspaceId - The workspace's unique identifier.
+     * @returns The workspace metadata, or `null` if not found.
+     *
+     * @example
+     * ```typescript
+     * const ws = await soulcraft.workspace.get('ws-abc123')
+     * ```
+     */
+    get(workspaceId: string): Promise<WorkspaceInfo | null>;
+    /**
+     * @description Create a new workspace, optionally from a kit template.
+     *
+     * When `kitId` is provided, the workspace is initialized with the kit's
+     * starter files, entity types, and AI skills.
+     *
+     * @param options - Workspace creation options.
+     * @param options.name - Display name for the workspace.
+     * @param options.kitId - Kit to initialize from (e.g. `'wicks-and-whiskers'`).
+     * @returns The newly created workspace metadata.
+     *
+     * @example
+     * ```typescript
+     * const ws = await soulcraft.workspace.create({ name: 'My Candle Shop', kitId: 'wicks-and-whiskers' })
+     * ```
+     */
+    create(options: {
+        name: string;
+        kitId?: string;
+    }): Promise<WorkspaceInfo>;
+    /**
+     * @description Update workspace metadata (currently only the name).
+     *
+     * @param workspaceId - The workspace to update.
+     * @param updates - Fields to update.
+     * @returns The updated workspace metadata.
+     *
+     * @example
+     * ```typescript
+     * await soulcraft.workspace.update('ws-abc', { name: 'Candle Empire' })
+     * ```
+     */
+    update(workspaceId: string, updates: {
+        name?: string;
+    }): Promise<WorkspaceInfo>;
+    /**
+     * @description Delete a workspace and all its data permanently.
+     *
+     * This removes all entities, files, versions, and settings. Cannot be undone.
+     *
+     * @param workspaceId - The workspace to delete.
+     *
+     * @example
+     * ```typescript
+     * await soulcraft.workspace.delete('ws-abc123')
+     * ```
+     */
+    delete(workspaceId: string): Promise<void>;
+    /**
+     * @description Get the workspace's current health and initialization status.
+     *
+     * Use this to check if the Brainy instance is ready before making data calls.
+     * During cold start, status will be `'initializing'` for up to ~25 seconds.
+     *
+     * @returns The workspace status.
+     *
+     * @example
+     * ```typescript
+     * const status = await soulcraft.workspace.getStatus()
+     * if (status.status === 'initializing') showSpinner('Loading workspace...')
+     * ```
+     */
+    getStatus(): Promise<WorkspaceStatus>;
+    /**
+     * @description Create a downloadable backup of the entire workspace.
+     *
+     * The backup includes all entities, relationships, VFS files, and settings.
+     *
+     * @returns A download URL and the backup size in bytes.
+     *
+     * @example
+     * ```typescript
+     * const { downloadUrl, size } = await soulcraft.workspace.backup()
+     * console.log(`Backup ready: ${(size / 1024 / 1024).toFixed(1)} MB`)
+     * ```
+     */
+    backup(): Promise<{
+        downloadUrl: string;
+        size: number;
+    }>;
+    /**
+     * @description Restore a workspace from a backup archive.
+     *
+     * Replaces all current workspace data with the backup contents.
+     *
+     * @param backupData - The backup archive as raw binary data.
+     * @returns Counts of restored entities and files.
+     *
+     * @example
+     * ```typescript
+     * const backupBytes = await fetch(backupUrl).then(r => r.arrayBuffer())
+     * const { entityCount, fileCount } = await soulcraft.workspace.restore(backupBytes)
+     * ```
+     */
+    restore(backupData: ArrayBuffer | Uint8Array): Promise<{
+        entityCount: number;
+        fileCount: number;
+    }>;
+    /**
+     * @description Connect the workspace to a Venue site for live deployment.
+     *
+     * @param options - Venue connection details.
+     * @param options.venueHandle - The Venue organization handle (e.g. `'acme-candles'`).
+     * @param options.venueSlug - The Venue site slug (e.g. `'main'`).
+     *
+     * @example
+     * ```typescript
+     * await soulcraft.workspace.connectVenue({ venueHandle: 'acme-candles', venueSlug: 'main' })
+     * ```
+     */
+    connectVenue(options: {
+        venueHandle: string;
+        venueSlug: string;
+    }): Promise<void>;
+    /**
+     * @description Get workspace-level settings (kit config, AI preferences, display options).
+     *
+     * @returns Key-value settings object.
+     *
+     * @example
+     * ```typescript
+     * const settings = await soulcraft.workspace.getSettings()
+     * console.log('AI model:', settings.preferredModel)
+     * ```
+     */
+    getSettings(): Promise<Record<string, unknown>>;
+    /**
+     * @description Update workspace settings. Merges with existing settings.
+     *
+     * @param settings - Key-value pairs to merge into the current settings.
+     *
+     * @example
+     * ```typescript
+     * await soulcraft.workspace.updateSettings({ preferredModel: 'claude-sonnet-4-6' })
+     * ```
+     */
+    updateSettings(settings: Record<string, unknown>): Promise<void>;
+    /**
+     * @description Run a health check on the Brainy instance.
+     *
+     * Returns the instance status and round-trip latency in milliseconds.
+     *
+     * @returns Health status and latency.
+     *
+     * @example
+     * ```typescript
+     * const { status, latencyMs } = await soulcraft.workspace.healthCheck()
+     * console.log(`Brainy is ${status}, latency: ${latencyMs}ms`)
+     * ```
+     */
+    healthCheck(): Promise<{
+        status: 'ok' | 'error';
+        latencyMs: number;
+    }>;
+}
+/**
+ * @description Publishing — create Living Links for sharing, deploy to Venue sites,
+ * and publish content to Academy as courses.
+ *
+ * @example
+ * ```typescript
+ * const link = await soulcraft.publish.createLink({ type: 'website', slug: 'my-project' })
+ * console.log(`Published at: ${link.url}`)
+ * ```
+ */
+export interface PublishNamespace {
+    /**
+     * @description Create a Living Link for sharing workspace content publicly.
+     *
+     * @param options - Link configuration.
+     * @param options.type - Content type: `'website'`, `'document'`, `'app'`, `'slideshow'`.
+     * @param options.slug - URL-safe slug. Auto-generated if omitted.
+     * @param options.entityIds - Specific entities to include. All entities if omitted.
+     * @param options.expiresIn - Link expiration in seconds. Permanent if omitted.
+     * @returns The created link with its public URL.
+     *
+     * @example
+     * ```typescript
+     * const link = await soulcraft.publish.createLink({
+     *   type: 'website',
+     *   slug: 'candle-catalog',
+     *   expiresIn: 86400 * 30, // 30 days
+     * })
+     * ```
+     */
+    createLink(options: {
+        type: string;
+        slug?: string;
+        entityIds?: string[];
+        expiresIn?: number;
+    }): Promise<PublishedLink>;
+    /**
+     * @description Get an existing published link by ID.
+     *
+     * @param linkId - The link's unique identifier.
+     * @returns The link metadata, or `null` if not found or expired.
+     *
+     * @example
+     * ```typescript
+     * const link = await soulcraft.publish.getLink('link-abc123')
+     * ```
+     */
+    getLink(linkId: string): Promise<PublishedLink | null>;
+    /**
+     * @description Delete a published link, making the URL inactive.
+     *
+     * @param linkId - The link to delete.
+     *
+     * @example
+     * ```typescript
+     * await soulcraft.publish.deleteLink('link-abc123')
+     * ```
+     */
+    deleteLink(linkId: string): Promise<void>;
+    /**
+     * @description List all published links for the current workspace.
+     *
+     * @returns All active links.
+     *
+     * @example
+     * ```typescript
+     * const links = await soulcraft.publish.listLinks()
+     * ```
+     */
+    listLinks(): Promise<PublishedLink[]>;
+    /**
+     * @description Check if a URL slug is available for a new link.
+     *
+     * @param slug - The slug to check.
+     * @returns Whether the slug is available.
+     *
+     * @example
+     * ```typescript
+     * const { available } = await soulcraft.publish.checkSlug('candle-catalog')
+     * if (!available) console.log('Slug already taken')
+     * ```
+     */
+    checkSlug(slug: string): Promise<{
+        available: boolean;
+    }>;
+    /**
+     * @description Get project info relevant for publishing decisions.
+     *
+     * @returns Project name, kit, and content counts.
+     *
+     * @example
+     * ```typescript
+     * const info = await soulcraft.publish.getProjectInfo()
+     * console.log(`Publishing "${info.name}" with ${info.entityCount} entities`)
+     * ```
+     */
+    getProjectInfo(): Promise<{
+        name: string;
+        kitId: string;
+        entityCount: number;
+        fileCount: number;
+    }>;
+    /**
+     * @description Deploy the workspace as a Svelte Component Archive (SCA) to a Venue site.
+     *
+     * Bundles all workspace content and deploys it to the specified Venue site.
+     * The deploy secret authenticates the Workshop server to the Venue server.
+     *
+     * @param options - Venue deployment configuration.
+     * @param options.venueHandle - Venue organization handle.
+     * @param options.venueSlug - Venue site slug.
+     * @param options.deploySecret - Server-to-server deploy authentication secret.
+     * @returns The deployed URL and timestamp.
+     *
+     * @example
+     * ```typescript
+     * const { url } = await soulcraft.publish.deployToVenue({
+     *   venueHandle: 'acme-candles', venueSlug: 'main', deploySecret: DEPLOY_SECRET,
+     * })
+     * ```
+     */
+    deployToVenue(options: {
+        venueHandle: string;
+        venueSlug: string;
+        deploySecret: string;
+    }): Promise<{
+        url: string;
+        deployedAt: string;
+    }>;
+    /**
+     * @description Publish workspace content to Academy as a course.
+     *
+     * Projects are mapped to courses: each WDOC file becomes a lesson, each
+     * WQUIZ file becomes an assessment.
+     *
+     * @param options - Academy publish configuration.
+     * @param options.academyUrl - Academy server URL.
+     * @param options.publishSecret - Server-to-server authentication secret.
+     * @param options.courseTitle - Override the course title (defaults to project name).
+     * @param options.lessonIds - Cherry-pick specific entity IDs as lessons (all if omitted).
+     * @returns The created course ID and URL.
+     *
+     * @example
+     * ```typescript
+     * const { courseId, url } = await soulcraft.publish.publishToAcademy({
+     *   academyUrl: 'https://academy.soulcraft.com',
+     *   publishSecret: ACADEMY_SECRET,
+     * })
+     * ```
+     */
+    publishToAcademy(options: {
+        academyUrl: string;
+        publishSecret: string;
+        courseTitle?: string;
+        lessonIds?: string[];
+    }): Promise<{
+        courseId: string;
+        url: string;
+    }>;
+    /**
+     * @description Unified publish — send workspace content to any registered destination.
+     *
+     * This is the recommended high-level API for publishing. The server resolves the
+     * destination's URL and authentication from its configuration — the client only
+     * specifies the destination name and content options. Server-to-server secrets
+     * are never exposed to the client.
+     *
+     * @param destination - Target product: `'venue'` (deploy as app), `'academy'` (publish as course).
+     * @param options - Destination-specific publish options.
+     * @param options.handle - Venue org handle (required for `'venue'`).
+     * @param options.slug - Venue site slug (required for `'venue'`).
+     * @param options.courseTitle - Override course title (optional for `'academy'`).
+     * @param options.entityIds - Cherry-pick specific entities to publish. All entities if omitted.
+     * @returns The published URL and destination-specific metadata.
+     *
+     * @example Publish to Venue
+     * ```typescript
+     * const result = await soulcraft.publish.to('venue', {
+     *   handle: 'acme-candles',
+     *   slug: 'main',
+     * })
+     * console.log(`Deployed: ${result.url}`)
+     * ```
+     *
+     * @example Publish to Academy
+     * ```typescript
+     * const result = await soulcraft.publish.to('academy', {
+     *   courseTitle: 'Candle Making 101',
+     * })
+     * console.log(`Course: ${result.url}`)
+     * ```
+     */
+    to(destination: 'venue' | 'academy', options?: {
+        handle?: string;
+        slug?: string;
+        courseTitle?: string;
+        entityIds?: string[];
+    }): Promise<{
+        url: string;
+        destinationId?: string;
+        publishedAt: string;
+    }>;
+}
+/**
+ * @description File import with streaming progress — smart file upload and structured
+ * data import (JSON, CSV, GraphML, GEXF, DOT, OPML, Obsidian, Turtle, JSON-LD, etc.).
+ *
+ * Both `uploadFiles` and `importData` return async iterables that stream
+ * {@link ImportProgress} events as the import pipeline processes each phase.
+ *
+ * @example
+ * ```typescript
+ * for await (const progress of soulcraft.import.uploadFiles(files)) {
+ *   updateProgressBar(progress.current, progress.total, progress.phase)
+ * }
+ * ```
+ */
+export interface ImportNamespace {
+    /**
+     * @description Upload files for smart import with streaming progress.
+     *
+     * The server auto-detects file types and creates appropriate entities
+     * (documents, images, code files, etc.). Progress is streamed as SSE.
+     *
+     * @param files - Array of files to import.
+     * @returns An async iterable of {@link ImportProgress} events.
+     *
+     * @example
+     * ```typescript
+     * const files = [{ name: 'notes.md', content: '# My Notes\n...', mimeType: 'text/markdown' }]
+     * for await (const p of soulcraft.import.uploadFiles(files)) {
+     *   console.log(`${p.phase}: ${p.current}/${p.total}`)
+     * }
+     * ```
+     */
+    uploadFiles(files: Array<{
+        name: string;
+        content: string | ArrayBuffer;
+        mimeType: string;
+    }>): AsyncIterable<ImportProgress>;
+    /**
+     * @description Import structured data in a knowledge graph format.
+     *
+     * Parses the input data according to the specified format and creates
+     * entities and relationships in the workspace.
+     *
+     * @param options - Import configuration.
+     * @param options.format - Source format ID (e.g. `'json'`, `'csv'`, `'graphml'`, `'gexf'`, `'dot'`).
+     * @param options.data - The raw data to import.
+     * @param options.mappings - Column/field mappings for CSV or JSON (e.g. `{ name: 'title', type: 'category' }`).
+     * @returns An async iterable of {@link ImportProgress} events.
+     *
+     * @example
+     * ```typescript
+     * const graphml = await fetch('graph.graphml').then(r => r.text())
+     * for await (const p of soulcraft.import.importData({ format: 'graphml', data: graphml })) {
+     *   if (p.phase === 'done') console.log(`Imported ${p.current} entities`)
+     * }
+     * ```
+     */
+    importData(options: {
+        format: string;
+        data: string | ArrayBuffer;
+        mappings?: Record<string, string>;
+    }): AsyncIterable<ImportProgress>;
+    /**
+     * @description List all supported import formats.
+     *
+     * @returns Array of format descriptors with IDs, names, and file extensions.
+     *
+     * @example
+     * ```typescript
+     * const formats = await soulcraft.import.getFormats()
+     * // [{ id: 'graphml', name: 'GraphML', extensions: ['.graphml'], description: '...' }, ...]
+     * ```
+     */
+    getFormats(): Promise<Array<{
+        id: string;
+        name: string;
+        extensions: string[];
+        description: string;
+    }>>;
+    /**
+     * @description Auto-detect the format of uploaded data.
+     *
+     * Inspects the data content to determine the most likely format and
+     * a confidence score.
+     *
+     * @param data - The data to analyze (text content or first few KB).
+     * @returns The detected format and confidence (0–1).
+     *
+     * @example
+     * ```typescript
+     * const { format, confidence } = await soulcraft.import.detectFormat(fileContent)
+     * if (confidence > 0.8) console.log(`Detected: ${format}`)
+     * ```
+     */
+    detectFormat(data: string): Promise<{
+        format: string;
+        confidence: number;
+    }>;
+    /**
+     * @description Get progress of an ongoing import by ID.
+     *
+     * @param importId - The import operation's identifier (returned in progress events).
+     * @returns Current progress state.
+     *
+     * @example
+     * ```typescript
+     * const progress = await soulcraft.import.getProgress('imp-abc123')
+     * ```
+     */
+    getProgress(importId: string): Promise<ImportProgress>;
+    /**
+     * @description Cancel an in-progress import operation.
+     *
+     * @param importId - The import to cancel.
+     *
+     * @example
+     * ```typescript
+     * await soulcraft.import.cancel('imp-abc123')
+     * ```
+     */
+    cancel(importId: string): Promise<void>;
+}
+/**
+ * @description Export — download the full project, export the knowledge graph in
+ * standard formats (JSON, CSV, GraphML, GEXF, DOT), and generate PDFs.
+ *
+ * @example
+ * ```typescript
+ * const graphml = await soulcraft.export.exportKnowledgeGraph('graphml')
+ * const zip = await soulcraft.export.downloadProject({ format: 'zip' })
+ * ```
+ */
+export interface ExportNamespace {
+    /**
+     * @description List all available export formats.
+     *
+     * @returns Array of {@link ExportFormat} descriptors.
+     *
+     * @example
+     * ```typescript
+     * const formats = await soulcraft.export.getExporters()
+     * console.log(formats.map(f => f.name).join(', '))
+     * ```
+     */
+    getExporters(): Promise<ExportFormat[]>;
+    /**
+     * @description Download the entire project as a zip or tar archive.
+     *
+     * Includes all VFS files, entity data, and workspace settings.
+     *
+     * @param options - Export options.
+     * @param options.format - Archive format. Default: `'zip'`.
+     * @returns The archive as raw binary data.
+     *
+     * @example
+     * ```typescript
+     * const zip = await soulcraft.export.downloadProject({ format: 'zip' })
+     * saveFile('project.zip', zip)
+     * ```
+     */
+    downloadProject(options?: {
+        format?: 'zip' | 'tar';
+    }): Promise<ArrayBuffer>;
+    /**
+     * @description Export the knowledge graph in a standard interchange format.
+     *
+     * @param format - Target format: `'json'`, `'csv'`, `'graphml'`, `'gexf'`, or `'dot'`.
+     * @param options - Export options.
+     * @param options.types - Filter to specific NounTypes.
+     * @returns The serialized graph as a string (text formats) or binary (binary formats).
+     *
+     * @example
+     * ```typescript
+     * const graphml = await soulcraft.export.exportKnowledgeGraph('graphml')
+     * const csv = await soulcraft.export.exportKnowledgeGraph('csv', { types: ['Person'] })
+     * ```
+     */
+    exportKnowledgeGraph(format: string, options?: {
+        types?: string[];
+    }): Promise<string | ArrayBuffer>;
+    /**
+     * @description Generate a PDF export of selected entities.
+     *
+     * The PDF is generated server-side (via Puppeteer/Pandoc for high quality)
+     * and made available for download.
+     *
+     * @param entityIds - Entities to include in the PDF.
+     * @param options - PDF options.
+     * @param options.template - PDF template name (default: the kit's default template).
+     * @returns A download URL for the generated PDF.
+     *
+     * @example
+     * ```typescript
+     * const { downloadUrl } = await soulcraft.export.exportPdf(['entity-1', 'entity-2'])
+     * window.open(downloadUrl)
+     * ```
+     */
+    exportPdf(entityIds: string[], options?: {
+        template?: string;
+    }): Promise<{
+        downloadUrl: string;
+    }>;
+    /**
+     * @description Download a previously generated PDF by export ID.
+     *
+     * @param exportId - The export operation's identifier.
+     * @returns The PDF as raw binary data.
+     *
+     * @example
+     * ```typescript
+     * const pdfBytes = await soulcraft.export.downloadPdf('exp-abc123')
+     * ```
+     */
+    downloadPdf(exportId: string): Promise<ArrayBuffer>;
+}
+/**
+ * @description Platform configuration — feature flags, limits, announcements,
+ * and maintenance mode status.
+ *
+ * @example
+ * ```typescript
+ * const config = await soulcraft.config.get()
+ * if (config.maintenance?.active) showMaintenanceBanner(config.maintenance.message)
+ * ```
+ */
+export interface ConfigNamespace {
+    /**
+     * @description Get the full platform configuration.
+     *
+     * @returns Feature flags, numeric limits, maintenance state, and announcements.
+     *
+     * @example
+     * ```typescript
+     * const config = await soulcraft.config.get()
+     * if (config.features.hallEnabled) showVideoButton()
+     * ```
+     */
+    get(): Promise<PlatformConfig>;
+    /**
+     * @description Get user-specific configuration overrides.
+     *
+     * @returns Key-value pairs of user-level settings.
+     *
+     * @example
+     * ```typescript
+     * const userConfig = await soulcraft.config.getUser()
+     * const theme = userConfig.theme ?? 'system'
+     * ```
+     */
+    getUser(): Promise<Record<string, unknown>>;
+    /**
+     * @description Get current platform announcements to display to the user.
+     *
+     * @returns Array of active announcements.
+     *
+     * @example
+     * ```typescript
+     * const announcements = await soulcraft.config.getAnnouncements()
+     * for (const a of announcements) showBanner(a.message, a.type)
+     * ```
+     */
+    getAnnouncements(): Promise<Array<{
+        id: string;
+        message: string;
+        type: string;
+    }>>;
+    /**
+     * @description Check if maintenance mode is currently active.
+     *
+     * When active, most API calls will fail — the UI should show a maintenance
+     * banner and disable interactive features.
+     *
+     * @returns `true` if maintenance mode is active.
+     *
+     * @example
+     * ```typescript
+     * if (await soulcraft.config.isMaintenanceMode()) showMaintenancePage()
+     * ```
+     */
+    isMaintenanceMode(): Promise<boolean>;
+}
+/**
+ * @description User settings — BYOK API key management, AI usage stats, and
+ * workspace storage usage.
+ *
+ * @example
+ * ```typescript
+ * await soulcraft.settings.saveApiKey({ provider: 'anthropic', key: 'sk-ant-...' })
+ * const usage = await soulcraft.settings.getStorageUsage()
+ * ```
+ */
+export interface SettingsNamespace {
+    /**
+     * @description Save a BYOK (Bring Your Own Key) API key, encrypted at rest.
+     *
+     * @param options - The key to save.
+     * @param options.provider - AI provider name (e.g. `'anthropic'`).
+     * @param options.key - The raw API key string.
+     *
+     * @example
+     * ```typescript
+     * await soulcraft.settings.saveApiKey({ provider: 'anthropic', key: 'sk-ant-abc123...' })
+     * ```
+     */
+    saveApiKey(options: {
+        provider: string;
+        key: string;
+    }): Promise<void>;
+    /**
+     * @description Get saved API key info (redacted — only last 4 chars shown).
+     *
+     * @param provider - The AI provider name.
+     * @returns Redacted key info, or `null` if no key is saved for this provider.
+     *
+     * @example
+     * ```typescript
+     * const keyInfo = await soulcraft.settings.getApiKey('anthropic')
+     * if (keyInfo) console.log(`Key ending in ${keyInfo.lastFour}`)
+     * ```
+     */
+    getApiKey(provider: string): Promise<ApiKeyInfo | null>;
+    /**
+     * @description Delete a saved API key.
+     *
+     * @param provider - The AI provider whose key to delete.
+     *
+     * @example
+     * ```typescript
+     * await soulcraft.settings.deleteApiKey('anthropic')
+     * ```
+     */
+    deleteApiKey(provider: string): Promise<void>;
+    /**
+     * @description Get AI usage statistics for the current user's billing period.
+     *
+     * @returns Message count, token totals, and the billing period identifier.
+     *
+     * @example
+     * ```typescript
+     * const stats = await soulcraft.settings.getUsageStats()
+     * console.log(`${stats.messages} messages, ${stats.tokens.input + stats.tokens.output} tokens`)
+     * ```
+     */
+    getUsageStats(): Promise<{
+        messages: number;
+        tokens: {
+            input: number;
+            output: number;
+        };
+        period: string;
+    }>;
+    /**
+     * @description Get storage consumption breakdown for the current workspace.
+     *
+     * @returns Storage usage across entities, files, and indices.
+     *
+     * @example
+     * ```typescript
+     * const usage = await soulcraft.settings.getStorageUsage()
+     * console.log(`Total: ${(usage.totalBytes / 1024 / 1024).toFixed(1)} MB`)
+     * ```
+     */
+    getStorageUsage(): Promise<StorageUsage>;
+}
+/**
+ * @description Project context for Glass Box AI transparency and metadata repair.
+ *
+ * Glass Box shows users exactly what the AI knows about their project:
+ * entity type counts, relationship types, file count, and total tokens embedded.
+ *
+ * @example
+ * ```typescript
+ * const ctx = await soulcraft.project.getContext()
+ * console.log(`Project uses kit "${ctx.kitName}" with ${ctx.fileCount} files`)
+ * ```
+ */
+export interface ProjectNamespace {
+    /**
+     * @description Get the project context for AI transparency (Glass Box).
+     *
+     * @returns Kit info, entity/relation type distributions, file count, and total embedded tokens.
+     *
+     * @example
+     * ```typescript
+     * const ctx = await soulcraft.project.getContext()
+     * console.log(`Entity types: ${Object.keys(ctx.entityTypes).join(', ')}`)
+     * ```
+     */
+    getContext(): Promise<{
+        kitId: string;
+        kitName: string;
+        entityTypes: Record<string, number>;
+        relationTypes: Record<string, number>;
+        fileCount: number;
+        totalTokens: number;
+    }>;
+    /**
+     * @description Repair metadata inconsistencies in workspace entities.
+     *
+     * Scans all entities and fixes common issues: missing `metadata.name`,
+     * orphaned relationships, duplicate embeddings, etc.
+     *
+     * @returns Counts of repaired entities and errors encountered.
+     *
+     * @example
+     * ```typescript
+     * const { repaired, errors } = await soulcraft.project.repairMetadata()
+     * console.log(`Fixed ${repaired} entities, ${errors} errors`)
+     * ```
+     */
+    repairMetadata(): Promise<{
+        repaired: number;
+        errors: number;
+    }>;
+}
+/**
+ * @description Collaborative session lifecycle — multiple users editing the same
+ * workspace in real-time via Y.js CRDT synchronization.
+ *
+ * @example
+ * ```typescript
+ * const state = await soulcraft.session.join('session-abc', { displayName: 'Alice' })
+ * console.log(`${state.participants.length} people in session`)
+ * ```
+ */
+export interface SessionNamespace {
+    /**
+     * @description Join a collaborative session.
+     *
+     * Registers the current user as a participant. If the session doesn't exist,
+     * it is created. The returned state includes all current participants.
+     *
+     * @param sessionId - The session to join.
+     * @param options - Join options.
+     * @param options.displayName - Name shown to other participants.
+     * @returns The current session state.
+     *
+     * @example
+     * ```typescript
+     * const state = await soulcraft.session.join('session-abc', { displayName: 'Alice' })
+     * ```
+     */
+    join(sessionId: string, options?: {
+        displayName?: string;
+    }): Promise<SessionState>;
+    /**
+     * @description Leave a collaborative session.
+     *
+     * Removes the current user from the participant list. When the last
+     * participant leaves, the session is closed.
+     *
+     * @param sessionId - The session to leave.
+     *
+     * @example
+     * ```typescript
+     * await soulcraft.session.leave('session-abc')
+     * ```
+     */
+    leave(sessionId: string): Promise<void>;
+    /**
+     * @description Get the current state of a session.
+     *
+     * @param sessionId - The session to query.
+     * @returns The session state, or `null` if the session doesn't exist or has ended.
+     *
+     * @example
+     * ```typescript
+     * const state = await soulcraft.session.getState('session-abc')
+     * if (state) console.log(`${state.participants.length} participants`)
+     * ```
+     */
+    getState(sessionId: string): Promise<SessionState | null>;
+    /**
+     * @description Get the history of past collaborative sessions for this workspace.
+     *
+     * @param options - Pagination options.
+     * @param options.limit - Maximum number of sessions to return. Default: 20.
+     * @returns Array of past session summaries.
+     *
+     * @example
+     * ```typescript
+     * const history = await soulcraft.session.getHistory({ limit: 10 })
+     * for (const s of history) console.log(`${s.participantCount} people on ${s.startedAt}`)
+     * ```
+     */
+    getHistory(options?: {
+        limit?: number;
+    }): Promise<Array<{
+        sessionId: string;
+        startedAt: string;
+        endedAt: string;
+        participantCount: number;
+    }>>;
+}
+/**
+ * @description Analytics event forwarding — fire-and-forget telemetry.
+ *
+ * Events are forwarded to the configured analytics sink (Pulse). The call
+ * returns immediately; delivery is best-effort.
+ *
+ * @example
+ * ```typescript
+ * await soulcraft.pulse.track('page_view', { page: '/graph', kitId: 'wicks-and-whiskers' })
+ * ```
+ */
+export interface PulseNamespace {
+    /**
+     * @description Track an analytics event.
+     *
+     * @param event - Event name (e.g. `'page_view'`, `'entity_created'`, `'export_started'`).
+     * @param properties - Optional key-value metadata attached to the event.
+     *
+     * @example
+     * ```typescript
+     * await soulcraft.pulse.track('entity_created', { type: 'Document', kitId: 'blog-series' })
+     * ```
+     */
+    track(event: string, properties?: Record<string, unknown>): Promise<void>;
+}
+/**
+ * @description Auth session and WebSocket token operations.
+ *
+ * @example
+ * ```typescript
+ * const { user, authenticated } = await soulcraft.auth.getSession()
+ * if (authenticated) console.log(`Logged in as ${user!.name}`)
+ * ```
+ */
+export interface AuthNamespace {
+    /**
+     * @description Get the current session user and authentication status.
+     *
+     * @returns The authenticated user (or `null` if not logged in) and a boolean flag.
+     *
+     * @example
+     * ```typescript
+     * const { user, authenticated } = await soulcraft.auth.getSession()
+     * if (!authenticated) redirectToLogin()
+     * ```
+     */
+    getSession(): Promise<{
+        user: {
+            id: string;
+            email: string;
+            name: string;
+            image?: string;
+            role?: string;
+        } | null;
+        authenticated: boolean;
+    }>;
+    /**
+     * @description Get a short-lived WebSocket capability token for real-time connections.
+     *
+     * The token is used by the {@link WsTransport} to authenticate the WebSocket
+     * upgrade request. Tokens are scoped to the workspace and expire after a few minutes.
+     *
+     * @param options - Token options.
+     * @param options.scope - Workspace scope identifier. Defaults to the active workspace.
+     * @returns The token string and its ISO 8601 expiration timestamp.
+     *
+     * @example
+     * ```typescript
+     * const { token, expiresAt } = await soulcraft.auth.getWsToken({ scope: 'ws-abc123' })
+     * const ws = new WsTransport(wsUrl, token, 'ws-abc123')
+     * await ws.connect()
+     * ```
+     */
+    getWsToken(options?: {
+        scope?: string;
+    }): Promise<{
+        token: string;
+        expiresAt: string;
+    }>;
+}
+/**
+ * @description Media pipeline — upload, transcode, and stream audio, video, and images.
+ *
+ * Backed by the Hall server (hall.soulcraft.com). Supports transcoding between
+ * formats (e.g. WAV → MP3, MOV → MP4), thumbnail generation for video/images,
+ * and HTTP range-request streaming for delivery.
+ *
+ * @example Upload and transcode a podcast recording
+ * ```typescript
+ * const result = await soulcraft.media.upload(audioFile, {
+ *   transcode: 'audio/mp3',
+ *   thumbnail: false,
+ * })
+ * console.log(`Podcast at ${result.url}, ${result.duration}s`)
+ * ```
+ *
+ * @example Stream media
+ * ```typescript
+ * const stream = soulcraft.media.stream(mediaId)
+ * // Pipe to audio/video element
+ * ```
+ */
+export interface MediaNamespace {
+    /**
+     * @description Upload a media file with optional transcoding.
+     *
+     * @param file - The media file content (ArrayBuffer or Blob).
+     * @param options - Upload options.
+     * @param options.filename - Original filename for format detection.
+     * @param options.transcode - Target MIME type for transcoding (e.g. `'audio/mp3'`, `'video/mp4'`, `'image/webp'`).
+     * @param options.thumbnail - Whether to generate a thumbnail (video/images only). Default: `false`.
+     * @returns Upload result with media ID, URL, and metadata.
+     *
+     * @example
+     * ```typescript
+     * const result = await soulcraft.media.upload(videoBlob, {
+     *   filename: 'lecture.mov',
+     *   transcode: 'video/mp4',
+     *   thumbnail: true,
+     * })
+     * ```
+     */
+    upload(file: ArrayBuffer, options?: {
+        filename?: string;
+        transcode?: string;
+        thumbnail?: boolean;
+    }): Promise<MediaUploadResult>;
+    /**
+     * @description Stream a stored media item.
+     *
+     * Returns an async iterable of binary chunks for progressive download.
+     * For HTTP transports, the server uses range requests for seeking.
+     *
+     * @param mediaId - The media identifier from {@link upload}.
+     * @returns Async iterable of binary chunks.
+     *
+     * @example
+     * ```typescript
+     * for await (const chunk of soulcraft.media.stream(mediaId)) {
+     *   audioBuffer.append(chunk)
+     * }
+     * ```
+     */
+    stream(mediaId: string): AsyncIterable<ArrayBuffer>;
+    /**
+     * @description Get metadata about a stored media item.
+     *
+     * @param mediaId - The media identifier.
+     * @returns Media metadata, or `null` if not found.
+     *
+     * @example
+     * ```typescript
+     * const info = await soulcraft.media.getInfo(mediaId)
+     * if (info) console.log(`${info.mimeType}, ${info.duration}s`)
+     * ```
+     */
+    getInfo(mediaId: string): Promise<MediaInfo | null>;
+    /**
+     * @description Delete a stored media item.
+     *
+     * @param mediaId - The media identifier.
+     *
+     * @example
+     * ```typescript
+     * await soulcraft.media.delete(mediaId)
+     * ```
+     */
+    delete(mediaId: string): Promise<void>;
+}
+/**
+ * @description Real-time pub/sub — topic-based messaging, presence tracking,
+ * and broadcast. Backed by the Hall server (hall.soulcraft.com).
+ *
+ * Topics are ephemeral channels. Messages are fire-and-forget (no persistence).
+ * Presence is tracked per-topic — subscribing makes you "present."
+ *
+ * @example Multiplayer game
+ * ```typescript
+ * // Subscribe to game moves
+ * const sub = await soulcraft.realtime.subscribe('game-room-42', (data) => {
+ *   updateBoard(data.move)
+ * })
+ *
+ * // Broadcast a move
+ * await soulcraft.realtime.broadcast('game-room-42', { move: { x: 3, y: 5 } })
+ *
+ * // Check who's online
+ * const peers = await soulcraft.realtime.presence('game-room-42')
+ * ```
+ */
+export interface RealtimeNamespace {
+    /**
+     * @description Subscribe to a topic and receive messages.
+     *
+     * @param topic - Topic name (any string, e.g. `'game-room-42'`, `'inventory-updates'`).
+     * @param handler - Callback invoked for each message on this topic.
+     * @returns A subscription handle with an `unsubscribe()` method.
+     *
+     * @example
+     * ```typescript
+     * const sub = await soulcraft.realtime.subscribe('chat', (msg) => {
+     *   console.log(`${msg.user}: ${msg.text}`)
+     * })
+     * // Later:
+     * sub.unsubscribe()
+     * ```
+     */
+    subscribe(topic: string, handler: (data: unknown) => void): Promise<RealtimeSubscription>;
+    /**
+     * @description Broadcast a message to all subscribers of a topic.
+     *
+     * Fire-and-forget — the message is delivered to all current subscribers
+     * but not persisted. The sender does NOT receive their own broadcast.
+     *
+     * @param topic - Topic name.
+     * @param data - The message payload (must be JSON-serializable).
+     *
+     * @example
+     * ```typescript
+     * await soulcraft.realtime.broadcast('inventory-updates', {
+     *   productId: 'candle-42',
+     *   stock: 7,
+     * })
+     * ```
+     */
+    broadcast(topic: string, data: unknown): Promise<void>;
+    /**
+     * @description Get the list of peers currently subscribed to a topic.
+     *
+     * @param topic - Topic name.
+     * @returns Array of currently present peers.
+     *
+     * @example
+     * ```typescript
+     * const peers = await soulcraft.realtime.presence('game-room-42')
+     * console.log(`${peers.length} players online`)
+     * ```
+     */
+    presence(topic: string): Promise<RealtimePeer[]>;
+}
+/**
+ * @description Commerce — product management, checkout, and payment processing.
+ *
+ * Stripe-first implementation with a pluggable `PaymentProvider` interface for
+ * future payment processors (Square, PayPal, etc.). Products configure their
+ * Stripe account via `providers.commerce` in the SDK server config.
+ *
+ * @example Create a product and initiate checkout
+ * ```typescript
+ * const product = await soulcraft.commerce.createProduct({
+ *   name: 'Lavender Candle Kit',
+ *   description: 'Everything you need to make lavender candles',
+ *   priceAmount: 2999,
+ *   currency: 'usd',
+ * })
+ *
+ * const session = await soulcraft.commerce.checkout({
+ *   items: [{ productId: product.id, quantity: 1 }],
+ *   successUrl: '/order/success',
+ *   cancelUrl: '/shop',
+ * })
+ * window.location.href = session.checkoutUrl
+ * ```
+ */
+export interface CommerceNamespace {
+    /**
+     * @description Create a new product.
+     *
+     * @param options - Product details.
+     * @param options.name - Product display name.
+     * @param options.description - Product description.
+     * @param options.priceAmount - Price in smallest currency unit (e.g. cents).
+     * @param options.currency - Three-letter ISO 4217 currency code.
+     * @param options.images - Optional product image URLs.
+     * @param options.metadata - Optional key-value metadata.
+     * @returns The created product.
+     *
+     * @example
+     * ```typescript
+     * const product = await soulcraft.commerce.createProduct({
+     *   name: 'Workshop Pro Plan', priceAmount: 1999, currency: 'usd',
+     * })
+     * ```
+     */
+    createProduct(options: {
+        name: string;
+        description?: string;
+        priceAmount: number;
+        currency: string;
+        images?: string[];
+        metadata?: Record<string, string>;
+    }): Promise<CommerceProduct>;
+    /**
+     * @description List all products.
+     *
+     * @param options - Filter options.
+     * @param options.active - Filter by active/inactive status.
+     * @param options.limit - Maximum number of products to return. Default: 100.
+     * @returns Array of products.
+     *
+     * @example
+     * ```typescript
+     * const products = await soulcraft.commerce.listProducts({ active: true })
+     * ```
+     */
+    listProducts(options?: {
+        active?: boolean;
+        limit?: number;
+    }): Promise<CommerceProduct[]>;
+    /**
+     * @description Get a single product by ID.
+     *
+     * @param productId - The product identifier.
+     * @returns The product, or `null` if not found.
+     *
+     * @example
+     * ```typescript
+     * const product = await soulcraft.commerce.getProduct('prod_abc123')
+     * ```
+     */
+    getProduct(productId: string): Promise<CommerceProduct | null>;
+    /**
+     * @description Initiate a checkout session.
+     *
+     * Creates a Stripe Checkout Session and returns the URL for redirect.
+     *
+     * @param options - Checkout details.
+     * @param options.items - Line items with product IDs and quantities.
+     * @param options.successUrl - URL to redirect after successful payment.
+     * @param options.cancelUrl - URL to redirect if the customer cancels.
+     * @param options.customerEmail - Pre-fill the customer email.
+     * @returns The checkout session with redirect URL.
+     *
+     * @example
+     * ```typescript
+     * const session = await soulcraft.commerce.checkout({
+     *   items: [{ productId: 'prod_abc', quantity: 2 }],
+     *   successUrl: '/success',
+     *   cancelUrl: '/cart',
+     * })
+     * ```
+     */
+    checkout(options: {
+        items: Array<{
+            productId: string;
+            quantity: number;
+        }>;
+        successUrl: string;
+        cancelUrl: string;
+        customerEmail?: string;
+    }): Promise<CheckoutSession>;
+    /**
+     * @description Get a payment record by ID.
+     *
+     * @param paymentId - The payment identifier.
+     * @returns The payment record, or `null` if not found.
+     *
+     * @example
+     * ```typescript
+     * const payment = await soulcraft.commerce.getPayment('pi_abc123')
+     * if (payment?.status === 'succeeded') showReceipt(payment)
+     * ```
+     */
+    getPayment(paymentId: string): Promise<PaymentRecord | null>;
+    /**
+     * @description List payments for the current user.
+     *
+     * @param options - Filter options.
+     * @param options.limit - Maximum number of payments to return. Default: 20.
+     * @returns Array of payment records.
+     *
+     * @example
+     * ```typescript
+     * const payments = await soulcraft.commerce.listPayments({ limit: 10 })
+     * ```
+     */
+    listPayments(options?: {
+        limit?: number;
+    }): Promise<PaymentRecord[]>;
+}
+/**
+ * @description Certification — issue, verify, and trace credential lineage.
+ *
+ * Uses Brainy's graph model for verifiable credentials. Each certification is
+ * a `contract` entity linked by `endorses` (certifier → cert), `attributedTo`
+ * (cert → learner), and `dependsOn` (cert → upstream cert) relationships.
+ *
+ * Originally built for Academy (course completion credentials). Now a platform
+ * primitive: Workshop can certify skill completion, Venue can certify training,
+ * kit apps can issue achievement badges — all with verifiable lineage.
+ *
+ * @example Issue a certification
+ * ```typescript
+ * const cert = await soulcraft.certification.issue({
+ *   name: 'Advanced Candle Making',
+ *   learnerId: 'user-abc',
+ *   score: 0.95,
+ *   upstreamCertificationId: 'cert-basic',
+ * })
+ * console.log(`Certification ${cert.id} issued, lineage depth: ${cert.lineageDepth}`)
+ * ```
+ *
+ * @example Verify a certification
+ * ```typescript
+ * const result = await soulcraft.certification.verify('cert-xyz')
+ * if (result.valid) console.log(`Issued by ${result.certification.certifierId}`)
+ * ```
+ */
+export interface CertificationNamespace {
+    /**
+     * @description Issue a new certification.
+     *
+     * Creates a `contract` entity in Brainy with `endorses`, `attributedTo`,
+     * and optionally `dependsOn` relationships.
+     *
+     * @param options - Certification details.
+     * @param options.name - Certification name.
+     * @param options.learnerId - The user receiving the certification.
+     * @param options.score - Assessment score (0.0–1.0).
+     * @param options.aiIssued - Whether the certification was AI-issued. Default: `false`.
+     * @param options.upstreamCertificationId - Optional upstream cert for lineage.
+     * @returns The created certification.
+     *
+     * @example
+     * ```typescript
+     * const cert = await soulcraft.certification.issue({
+     *   name: 'Recipe Master', learnerId: 'user-abc', score: 0.92,
+     * })
+     * ```
+     */
+    issue(options: {
+        name: string;
+        learnerId: string;
+        score: number;
+        aiIssued?: boolean;
+        upstreamCertificationId?: string;
+    }): Promise<Certification>;
+    /**
+     * @description Verify a certification's validity and retrieve its details.
+     *
+     * @param certificationId - The certification ID to verify.
+     * @returns Verification result with the certification and lineage data.
+     *
+     * @example
+     * ```typescript
+     * const result = await soulcraft.certification.verify('cert-xyz')
+     * if (result.valid) console.log(`Score: ${result.certification.score}`)
+     * ```
+     */
+    verify(certificationId: string): Promise<{
+        valid: boolean;
+        certification: Certification | null;
+    }>;
+    /**
+     * @description Get a certification with its full lineage chain.
+     *
+     * Traverses the `dependsOn` relationships to build the complete
+     * certification ancestry.
+     *
+     * @param certificationId - The certification ID.
+     * @returns The certification and its ancestor chain.
+     *
+     * @example
+     * ```typescript
+     * const { certification, lineage } = await soulcraft.certification.getWithLineage('cert-xyz')
+     * console.log(`Lineage: ${lineage.map(c => c.name).join(' → ')}`)
+     * ```
+     */
+    getWithLineage(certificationId: string): Promise<{
+        certification: Certification | null;
+        lineage: Certification[];
+    }>;
+    /**
+     * @description Compute an assessment score for a learner against required competencies.
+     *
+     * Score = demonstrated competencies (via `learns` edges) / total required competencies.
+     *
+     * @param options - Assessment options.
+     * @param options.learnerId - The learner user ID.
+     * @param options.competencyIds - Required competency entity IDs.
+     * @param options.threshold - Passing threshold (0.0–1.0). Default: 0.8.
+     * @returns Assessment result with score, pass/fail, and gap analysis.
+     *
+     * @example
+     * ```typescript
+     * const result = await soulcraft.certification.assess({
+     *   learnerId: 'user-abc',
+     *   competencyIds: ['comp-1', 'comp-2', 'comp-3'],
+     *   threshold: 0.8,
+     * })
+     * if (result.passed) console.log('Ready for certification!')
+     * ```
+     */
+    assess(options: {
+        learnerId: string;
+        competencyIds: string[];
+        threshold?: number;
+    }): Promise<AssessmentResult>;
+    /**
+     * @description List certifications issued by or to a user.
+     *
+     * @param options - Filter options.
+     * @param options.issuedBy - Filter by certifier user ID.
+     * @param options.issuedTo - Filter by learner user ID.
+     * @param options.limit - Maximum number of results. Default: 50.
+     * @returns Array of certifications.
+     *
+     * @example
+     * ```typescript
+     * const myCerts = await soulcraft.certification.list({ issuedTo: userId })
+     * ```
+     */
+    list(options?: {
+        issuedBy?: string;
+        issuedTo?: string;
+        limit?: number;
+    }): Promise<Certification[]>;
+}
+/**
+ * @description Format conversion and validation for Soulcraft portable formats.
+ *
+ * Handles server-side conversion between source formats (wdoc, wslide, wviz,
+ * wquiz) and output formats (PDF, HTML, Markdown, etc.). Visual rendering
+ * stays in `@soulcraft/views` — this namespace handles data transformation only.
+ *
+ * @example Convert a document to PDF
+ * ```typescript
+ * const pdfBytes = await soulcraft.formats.convert('wdoc', 'pdf', {
+ *   content: documentJson,
+ *   options: { pageSize: 'A4', margin: '2cm' },
+ * })
+ * ```
+ *
+ * @example Validate a visualization document
+ * ```typescript
+ * const result = await soulcraft.formats.validate('wviz', vizDocument)
+ * if (!result.valid) console.error(result.errors)
+ * ```
+ */
+export interface FormatsNamespace {
+    /**
+     * @description Convert a Soulcraft format document to an output format.
+     *
+     * @param sourceFormat - Source format identifier (e.g. `'wdoc'`, `'wslide'`, `'wviz'`).
+     * @param outputFormat - Target format identifier (e.g. `'pdf'`, `'html'`, `'markdown'`).
+     * @param options - Conversion options.
+     * @param options.content - The source document (JSON object or string).
+     * @param options.options - Format-specific conversion options (page size, margins, etc.).
+     * @returns The converted content as an ArrayBuffer (binary formats) or string (text formats).
+     *
+     * @example
+     * ```typescript
+     * const html = await soulcraft.formats.convert('wslide', 'html', {
+     *   content: slideshowJson,
+     *   options: { includeNotes: false },
+     * })
+     * ```
+     */
+    convert(sourceFormat: string, outputFormat: string, options: {
+        content: unknown;
+        options?: Record<string, unknown>;
+    }): Promise<string | ArrayBuffer>;
+    /**
+     * @description Validate a document against its format schema.
+     *
+     * @param format - Format identifier (e.g. `'wdoc'`, `'wviz'`, `'wquiz'`).
+     * @param document - The document to validate.
+     * @returns Validation result with any errors.
+     *
+     * @example
+     * ```typescript
+     * const result = await soulcraft.formats.validate('wquiz', quizDocument)
+     * if (!result.valid) console.error(result.errors)
+     * ```
+     */
+    validate(format: string, document: unknown): Promise<FormatValidationResult>;
+    /**
+     * @description List available output formats and which source formats can convert to them.
+     *
+     * @returns Array of output format descriptors.
+     *
+     * @example
+     * ```typescript
+     * const formats = await soulcraft.formats.getOutputFormats()
+     * const pdfFormat = formats.find(f => f.id === 'pdf')
+     * console.log(`PDF supports: ${pdfFormat.sourceFormats.join(', ')}`)
+     * ```
+     */
+    getOutputFormats(): Promise<OutputFormat[]>;
+}
+//# sourceMappingURL=namespaces.d.ts.map