mnemosyne-core 2.0.0 → 2.0.1

package/dist/index-B2oTMNlL.d.ts

@@ -0,0 +1,115 @@
+import * as node_events from 'node:events';
+import * as node_stream_promises from 'node:stream/promises';
+import * as node_stream from 'node:stream';
+import * as node_stream_web from 'node:stream/web';
+import * as node_http from 'node:http';
+import { C as Config, S as Store, f as Project, c as Atom } from './Store-BtdYuiUx.js';
+
+/**
+ * Mnemosyne Configuration
+ * Loads config.yaml with a minimal parser. Supports env overrides.
+ */
+
+declare function loadConfig(configPath?: string, baseDir?: string): Config;
+declare class MnemosyneConfig {
+    readonly config: Config;
+    private baseDir;
+    constructor(options?: {
+        configPath?: string;
+        baseDir?: string;
+        overrides?: Partial<Config>;
+    });
+    get dbPath(): string;
+    get filesDir(): string;
+    get backupsDir(): string;
+    get baseDirPath(): string;
+}
+
+/**
+ * Mnemosyne Core Engine
+ * Main orchestrator class. Owns lifecycle (init, close).
+ * Store owns SQLite operations. Config owns settings.
+ */
+
+interface MnemosyneOptions {
+    dbPath?: string;
+    configPath?: string;
+    baseDir?: string;
+    autoBackup?: boolean;
+}
+declare class Mnemosyne {
+    store: Store;
+    config: MnemosyneConfig;
+    vecEnabled: boolean;
+    private db;
+    constructor(options?: MnemosyneOptions);
+    init(): Promise<void>;
+    close(): Promise<void>;
+    createProject(name: string, description?: string): Project;
+    createAtom(projectId: string, title: string, type: string, createdBy: string, opts?: Parameters<Store["createAtom"]>[4]): Atom;
+}
+
+interface ServerOptions {
+    port?: number;
+    host?: string;
+    dashboard?: boolean;
+    mcp?: boolean;
+    websocket?: boolean;
+}
+declare class MnemosyneServer {
+    store: Store;
+    private api;
+    private wsHandler?;
+    private httpServer;
+    private brain?;
+    constructor(options?: ServerOptions, brain?: Mnemosyne);
+    private serveDashboard;
+    getHandler(): node_http.Server<typeof node_http.IncomingMessage, {
+        new (req: node_http.IncomingMessage): node_http.ServerResponse<node_http.IncomingMessage>;
+        fromWeb(writableStream: node_stream_web.WritableStream, options?: Pick<node_stream.WritableOptions, "decodeStrings" | "highWaterMark" | "objectMode" | "signal">): node_stream.Writable;
+        toWeb(streamWritable: NodeJS.WritableStream): node_stream_web.WritableStream;
+        promises: typeof node_stream_promises;
+        Stream: typeof node_stream;
+        duplexPair(options?: node_stream.DuplexOptions): [node_stream.Duplex, node_stream.Duplex];
+        addAbortSignal<T extends NodeJS.ReadableStream | NodeJS.WritableStream | node_stream_web.ReadableStream | node_stream_web.WritableStream>(signal: AbortSignal, stream: T): T;
+        getDefaultHighWaterMark(objectMode: boolean): number;
+        setDefaultHighWaterMark(objectMode: boolean, value: number): void;
+        finished: typeof node_stream.finished;
+        pipeline: typeof node_stream.pipeline;
+        compose(stream: node_stream.ComposeSource<any> | node_stream.ComposeDestination<any>): node_stream.Duplex;
+        compose<S extends node_stream.ComposeSource<any> | node_stream.ComposeTransform<any, any>, D extends node_stream.ComposeTransform<S, any> | node_stream.ComposeDestination<S>>(source: S, destination: D): node_stream.Duplex;
+        compose<S extends node_stream.ComposeSource<any> | node_stream.ComposeTransform<any, any>, T extends node_stream.ComposeTransform<S, any>, D extends node_stream.ComposeTransform<T, any> | node_stream.ComposeDestination<T>>(source: S, transform: T, destination: D): node_stream.Duplex;
+        compose<S extends node_stream.ComposeSource<any> | node_stream.ComposeTransform<any, any>, T1 extends node_stream.ComposeTransform<S, any>, T2 extends node_stream.ComposeTransform<T1, any>, D extends node_stream.ComposeTransform<T2, any> | node_stream.ComposeDestination<T2>>(source: S, transform1: T1, transform2: T2, destination: D): node_stream.Duplex;
+        compose<S extends node_stream.ComposeSource<any> | node_stream.ComposeTransform<any, any>, T1 extends node_stream.ComposeTransform<S, any>, T2 extends node_stream.ComposeTransform<T1, any>, T3 extends node_stream.ComposeTransform<T2, any>, D extends node_stream.ComposeTransform<T3, any> | node_stream.ComposeDestination<T3>>(source: S, transform1: T1, transform2: T2, transform3: T3, destination: D): node_stream.Duplex;
+        compose<S extends node_stream.ComposeSource<any> | node_stream.ComposeTransform<any, any>, T1 extends node_stream.ComposeTransform<S, any>, T2 extends node_stream.ComposeTransform<T1, any>, T3 extends node_stream.ComposeTransform<T2, any>, T4 extends node_stream.ComposeTransform<T3, any>, D extends node_stream.ComposeTransform<T4, any> | node_stream.ComposeDestination<T4>>(source: S, transform1: T1, transform2: T2, transform3: T3, transform4: T4, destination: D): node_stream.Duplex;
+        compose(...streams: [node_stream.ComposeSource<any>, ...node_stream.ComposeTransform<any, any>[], node_stream.ComposeDestination<any>]): node_stream.Duplex;
+        isErrored(stream: NodeJS.ReadableStream | NodeJS.WritableStream | node_stream_web.ReadableStream | node_stream_web.WritableStream): boolean;
+        isReadable(stream: NodeJS.ReadableStream | node_stream_web.ReadableStream): boolean | null;
+        isWritable(stream: NodeJS.WritableStream | node_stream_web.WritableStream): boolean | null;
+        Readable: typeof node_stream.Readable;
+        Writable: typeof node_stream.Writable;
+        Duplex: typeof node_stream.Duplex;
+        Transform: typeof node_stream.Transform;
+        PassThrough: typeof node_stream.PassThrough;
+        EventEmitter: typeof node_events;
+        addAbortListener(signal: AbortSignal, resource: (event: Event) => void): Disposable;
+        getEventListeners(emitter: node_events, name: string | symbol): ((...args: any[]) => void)[];
+        getEventListeners(emitter: EventTarget, name: string): ((...args: any[]) => void)[];
+        getMaxListeners(emitter: node_events | EventTarget): number;
+        listenerCount(emitter: node_events, eventName: string | symbol): number;
+        listenerCount(emitter: EventTarget, eventName: string): number;
+        on(emitter: node_events, eventName: string | symbol, options?: node_events.OnOptions): NodeJS.AsyncIterator<any[]>;
+        on(emitter: EventTarget, eventName: string, options?: node_events.OnOptions): NodeJS.AsyncIterator<any[]>;
+        once(emitter: node_events, eventName: string | symbol, options?: node_events.OnceOptions): Promise<any[]>;
+        once(emitter: EventTarget, eventName: string, options?: node_events.OnceOptions): Promise<any[]>;
+        setMaxListeners(n: number, ...eventTargets: ReadonlyArray<node_events | EventTarget>): void;
+        readonly captureRejectionSymbol: typeof node_events.captureRejectionSymbol;
+        captureRejections: boolean;
+        defaultMaxListeners: number;
+        readonly errorMonitor: typeof node_events.errorMonitor;
+        EventEmitterAsyncResource: typeof node_events.EventEmitterAsyncResource;
+    }>;
+    close(): Promise<void>;
+}
+
+export { Mnemosyne as M, type ServerOptions as S, MnemosyneConfig as a, type MnemosyneOptions as b, MnemosyneServer as c, loadConfig as l };

package/dist/index-B8PTQKy9.d.mts

@@ -0,0 +1,115 @@
+import * as node_events from 'node:events';
+import * as node_stream_promises from 'node:stream/promises';
+import * as node_stream from 'node:stream';
+import * as node_stream_web from 'node:stream/web';
+import * as node_http from 'node:http';
+import { C as Config, S as Store, f as Project, c as Atom } from './Store-BtdYuiUx.mjs';
+
+/**
+ * Mnemosyne Configuration
+ * Loads config.yaml with a minimal parser. Supports env overrides.
+ */
+
+declare function loadConfig(configPath?: string, baseDir?: string): Config;
+declare class MnemosyneConfig {
+    readonly config: Config;
+    private baseDir;
+    constructor(options?: {
+        configPath?: string;
+        baseDir?: string;
+        overrides?: Partial<Config>;
+    });
+    get dbPath(): string;
+    get filesDir(): string;
+    get backupsDir(): string;
+    get baseDirPath(): string;
+}
+
+/**
+ * Mnemosyne Core Engine
+ * Main orchestrator class. Owns lifecycle (init, close).
+ * Store owns SQLite operations. Config owns settings.
+ */
+
+interface MnemosyneOptions {
+    dbPath?: string;
+    configPath?: string;
+    baseDir?: string;
+    autoBackup?: boolean;
+}
+declare class Mnemosyne {
+    store: Store;
+    config: MnemosyneConfig;
+    vecEnabled: boolean;
+    private db;
+    constructor(options?: MnemosyneOptions);
+    init(): Promise<void>;
+    close(): Promise<void>;
+    createProject(name: string, description?: string): Project;
+    createAtom(projectId: string, title: string, type: string, createdBy: string, opts?: Parameters<Store["createAtom"]>[4]): Atom;
+}
+
+interface ServerOptions {
+    port?: number;
+    host?: string;
+    dashboard?: boolean;
+    mcp?: boolean;
+    websocket?: boolean;
+}
+declare class MnemosyneServer {
+    store: Store;
+    private api;
+    private wsHandler?;
+    private httpServer;
+    private brain?;
+    constructor(options?: ServerOptions, brain?: Mnemosyne);
+    private serveDashboard;
+    getHandler(): node_http.Server<typeof node_http.IncomingMessage, {
+        new (req: node_http.IncomingMessage): node_http.ServerResponse<node_http.IncomingMessage>;
+        fromWeb(writableStream: node_stream_web.WritableStream, options?: Pick<node_stream.WritableOptions, "decodeStrings" | "highWaterMark" | "objectMode" | "signal">): node_stream.Writable;
+        toWeb(streamWritable: NodeJS.WritableStream): node_stream_web.WritableStream;
+        promises: typeof node_stream_promises;
+        Stream: typeof node_stream;
+        duplexPair(options?: node_stream.DuplexOptions): [node_stream.Duplex, node_stream.Duplex];
+        addAbortSignal<T extends NodeJS.ReadableStream | NodeJS.WritableStream | node_stream_web.ReadableStream | node_stream_web.WritableStream>(signal: AbortSignal, stream: T): T;
+        getDefaultHighWaterMark(objectMode: boolean): number;
+        setDefaultHighWaterMark(objectMode: boolean, value: number): void;
+        finished: typeof node_stream.finished;
+        pipeline: typeof node_stream.pipeline;
+        compose(stream: node_stream.ComposeSource<any> | node_stream.ComposeDestination<any>): node_stream.Duplex;
+        compose<S extends node_stream.ComposeSource<any> | node_stream.ComposeTransform<any, any>, D extends node_stream.ComposeTransform<S, any> | node_stream.ComposeDestination<S>>(source: S, destination: D): node_stream.Duplex;
+        compose<S extends node_stream.ComposeSource<any> | node_stream.ComposeTransform<any, any>, T extends node_stream.ComposeTransform<S, any>, D extends node_stream.ComposeTransform<T, any> | node_stream.ComposeDestination<T>>(source: S, transform: T, destination: D): node_stream.Duplex;
+        compose<S extends node_stream.ComposeSource<any> | node_stream.ComposeTransform<any, any>, T1 extends node_stream.ComposeTransform<S, any>, T2 extends node_stream.ComposeTransform<T1, any>, D extends node_stream.ComposeTransform<T2, any> | node_stream.ComposeDestination<T2>>(source: S, transform1: T1, transform2: T2, destination: D): node_stream.Duplex;
+        compose<S extends node_stream.ComposeSource<any> | node_stream.ComposeTransform<any, any>, T1 extends node_stream.ComposeTransform<S, any>, T2 extends node_stream.ComposeTransform<T1, any>, T3 extends node_stream.ComposeTransform<T2, any>, D extends node_stream.ComposeTransform<T3, any> | node_stream.ComposeDestination<T3>>(source: S, transform1: T1, transform2: T2, transform3: T3, destination: D): node_stream.Duplex;
+        compose<S extends node_stream.ComposeSource<any> | node_stream.ComposeTransform<any, any>, T1 extends node_stream.ComposeTransform<S, any>, T2 extends node_stream.ComposeTransform<T1, any>, T3 extends node_stream.ComposeTransform<T2, any>, T4 extends node_stream.ComposeTransform<T3, any>, D extends node_stream.ComposeTransform<T4, any> | node_stream.ComposeDestination<T4>>(source: S, transform1: T1, transform2: T2, transform3: T3, transform4: T4, destination: D): node_stream.Duplex;
+        compose(...streams: [node_stream.ComposeSource<any>, ...node_stream.ComposeTransform<any, any>[], node_stream.ComposeDestination<any>]): node_stream.Duplex;
+        isErrored(stream: NodeJS.ReadableStream | NodeJS.WritableStream | node_stream_web.ReadableStream | node_stream_web.WritableStream): boolean;
+        isReadable(stream: NodeJS.ReadableStream | node_stream_web.ReadableStream): boolean | null;
+        isWritable(stream: NodeJS.WritableStream | node_stream_web.WritableStream): boolean | null;
+        Readable: typeof node_stream.Readable;
+        Writable: typeof node_stream.Writable;
+        Duplex: typeof node_stream.Duplex;
+        Transform: typeof node_stream.Transform;
+        PassThrough: typeof node_stream.PassThrough;
+        EventEmitter: typeof node_events;
+        addAbortListener(signal: AbortSignal, resource: (event: Event) => void): Disposable;
+        getEventListeners(emitter: node_events, name: string | symbol): ((...args: any[]) => void)[];
+        getEventListeners(emitter: EventTarget, name: string): ((...args: any[]) => void)[];
+        getMaxListeners(emitter: node_events | EventTarget): number;
+        listenerCount(emitter: node_events, eventName: string | symbol): number;
+        listenerCount(emitter: EventTarget, eventName: string): number;
+        on(emitter: node_events, eventName: string | symbol, options?: node_events.OnOptions): NodeJS.AsyncIterator<any[]>;
+        on(emitter: EventTarget, eventName: string, options?: node_events.OnOptions): NodeJS.AsyncIterator<any[]>;
+        once(emitter: node_events, eventName: string | symbol, options?: node_events.OnceOptions): Promise<any[]>;
+        once(emitter: EventTarget, eventName: string, options?: node_events.OnceOptions): Promise<any[]>;
+        setMaxListeners(n: number, ...eventTargets: ReadonlyArray<node_events | EventTarget>): void;
+        readonly captureRejectionSymbol: typeof node_events.captureRejectionSymbol;
+        captureRejections: boolean;
+        defaultMaxListeners: number;
+        readonly errorMonitor: typeof node_events.errorMonitor;
+        EventEmitterAsyncResource: typeof node_events.EventEmitterAsyncResource;
+    }>;
+    close(): Promise<void>;
+}
+
+export { Mnemosyne as M, type ServerOptions as S, MnemosyneConfig as a, type MnemosyneOptions as b, MnemosyneServer as c, loadConfig as l };

package/dist/index-DWk78ifo.d.ts

@@ -0,0 +1,98 @@
+import { S as Store } from './Store-BtdYuiUx.js';
+import * as http from 'http';
+
+/**
+ * MCP Protocol Types
+ */
+interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    method: string;
+    params?: any;
+}
+interface JsonRpcResponse {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    result?: any;
+    error?: {
+        code: number;
+        message: string;
+        data?: any;
+    };
+}
+interface McpTool {
+    name: string;
+    description: string;
+    inputSchema: any;
+    handler: (args: any, store: Store) => any;
+}
+interface McpTransport {
+    name: string;
+    start(handler: (message: JsonRpcRequest) => Promise<JsonRpcResponse | null> | JsonRpcResponse | null): void;
+    send(message: JsonRpcResponse): void;
+}
+
+/**
+ * MCP Server
+ * JSON-RPC handler for Model Context Protocol.
+ */
+
+declare class McpServer {
+    private store;
+    private toolMap;
+    constructor(store: Store);
+    /**
+     * Returns `null` for notifications (no response needed).
+     */
+    handleRequest(req: JsonRpcRequest): JsonRpcResponse | null;
+    getManifest(): {
+        name: string;
+        version: string;
+        description: string;
+        protocol: string;
+        transport: string[];
+        endpoints: {
+            sse: string;
+            messages: string;
+        };
+        tools: {
+            name: string;
+            description: string;
+        }[];
+    };
+    private ok;
+    private err;
+}
+
+declare class McpSseTransport {
+    private server;
+    private sessions;
+    private sessionCounter;
+    constructor(server: McpServer);
+    handleSse(req: http.IncomingMessage, res: http.ServerResponse): void;
+    handleMessage(req: http.IncomingMessage, res: http.ServerResponse, body: any): void;
+    private sendSse;
+}
+
+/**
+ * MCP Stdio Transport
+ * Line-delimited JSON-RPC over stdin/stdout.
+ * This is what Claude Desktop uses to communicate with MCP servers.
+ */
+
+declare class McpStdioTransport {
+    private server;
+    private buffer;
+    constructor(server: McpServer);
+    start(): void;
+    send(message: JsonRpcResponse): void;
+}
+
+/**
+ * MCP Tool Definitions
+ * All tools exposed to MCP clients (Claude Desktop, Cursor, etc.)
+ */
+
+declare const TOOLS: McpTool[];
+
+export { type JsonRpcRequest as J, McpServer as M, TOOLS as T, type JsonRpcResponse as a, McpSseTransport as b, McpStdioTransport as c, type McpTool as d, type McpTransport as e };

package/dist/index-yTOihMUk.d.mts

@@ -0,0 +1,98 @@
+import { S as Store } from './Store-BtdYuiUx.mjs';
+import * as http from 'http';
+
+/**
+ * MCP Protocol Types
+ */
+interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    method: string;
+    params?: any;
+}
+interface JsonRpcResponse {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    result?: any;
+    error?: {
+        code: number;
+        message: string;
+        data?: any;
+    };
+}
+interface McpTool {
+    name: string;
+    description: string;
+    inputSchema: any;
+    handler: (args: any, store: Store) => any;
+}
+interface McpTransport {
+    name: string;
+    start(handler: (message: JsonRpcRequest) => Promise<JsonRpcResponse | null> | JsonRpcResponse | null): void;
+    send(message: JsonRpcResponse): void;
+}
+
+/**
+ * MCP Server
+ * JSON-RPC handler for Model Context Protocol.
+ */
+
+declare class McpServer {
+    private store;
+    private toolMap;
+    constructor(store: Store);
+    /**
+     * Returns `null` for notifications (no response needed).
+     */
+    handleRequest(req: JsonRpcRequest): JsonRpcResponse | null;
+    getManifest(): {
+        name: string;
+        version: string;
+        description: string;
+        protocol: string;
+        transport: string[];
+        endpoints: {
+            sse: string;
+            messages: string;
+        };
+        tools: {
+            name: string;
+            description: string;
+        }[];
+    };
+    private ok;
+    private err;
+}
+
+declare class McpSseTransport {
+    private server;
+    private sessions;
+    private sessionCounter;
+    constructor(server: McpServer);
+    handleSse(req: http.IncomingMessage, res: http.ServerResponse): void;
+    handleMessage(req: http.IncomingMessage, res: http.ServerResponse, body: any): void;
+    private sendSse;
+}
+
+/**
+ * MCP Stdio Transport
+ * Line-delimited JSON-RPC over stdin/stdout.
+ * This is what Claude Desktop uses to communicate with MCP servers.
+ */
+
+declare class McpStdioTransport {
+    private server;
+    private buffer;
+    constructor(server: McpServer);
+    start(): void;
+    send(message: JsonRpcResponse): void;
+}
+
+/**
+ * MCP Tool Definitions
+ * All tools exposed to MCP clients (Claude Desktop, Cursor, etc.)
+ */
+
+declare const TOOLS: McpTool[];
+
+export { type JsonRpcRequest as J, McpServer as M, TOOLS as T, type JsonRpcResponse as a, McpSseTransport as b, McpStdioTransport as c, type McpTool as d, type McpTransport as e };

package/dist/index.d.mts

@@ -0,0 +1,45 @@
+export { M as Mnemosyne, a as MnemosyneConfig, b as MnemosyneOptions, c as MnemosyneServer, l as loadConfig } from './index-B8PTQKy9.mjs';
+import { S as Store, A as Assistant } from './Store-BtdYuiUx.mjs';
+export { a as Action, b as AssistantRole, c as Atom, B as Block, d as Bond, C as Config, E as EventLogEntry, P as PRIORITY, e as PermissionLevel, f as Project, Q as QueueEntry, R as ROLE_PERMISSIONS, T as TEMPLATES } from './Store-BtdYuiUx.mjs';
+export { API, API as ApiRouter } from './server/api.mjs';
+import * as http from 'http';
+export { J as JsonRpcRequest, a as JsonRpcResponse, M as McpServer, b as McpSseTransport, c as McpStdioTransport, d as McpTool, e as McpTransport, T as TOOLS } from './index-yTOihMUk.mjs';
+export { WebSocketHandler, createWebSocketServer } from './server/websocket.mjs';
+export { EventBroadcaster } from './ws/index.mjs';
+import 'node:events';
+import 'node:stream/promises';
+import 'node:stream';
+import 'node:stream/web';
+import 'node:http';
+import 'better-sqlite3';
+import 'ws';
+
+declare class RateLimiter {
+    private rates;
+    private limit;
+    private windowMs;
+    constructor(limit: number, windowMs: number);
+    check(token: string): boolean;
+    private cleanup;
+}
+declare function authenticate(store: Store, req: http.IncomingMessage): Assistant | undefined;
+
+declare function json(res: http.ServerResponse, status: number, data: any): void;
+declare function readBody(req: http.IncomingMessage): Promise<any>;
+declare function resolveProjectId(store: Store, idOrName: string): string;
+declare function serializeAtom(store: Store, atom: any, compact?: boolean): any;
+
+/**
+ * Content-Addressed Storage (CAS)
+ * Files stored by SHA256 hash, sharded by first 2 hex chars.
+ */
+declare function computeHash(buffer: Buffer): string;
+declare function saveFile(buffer: Buffer, _fileName: string): {
+    hash: string;
+    size: number;
+    path: string;
+};
+declare function getFile(hash: string): Buffer | null;
+declare function fileExists(hash: string): boolean;
+
+export { Assistant, RateLimiter, Store, authenticate, computeHash, fileExists, getFile, json, readBody, resolveProjectId, saveFile, serializeAtom };

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+export { M as Mnemosyne, a as MnemosyneConfig, b as MnemosyneOptions, c as MnemosyneServer, l as loadConfig } from './index-B2oTMNlL.js';
+import { S as Store, A as Assistant } from './Store-BtdYuiUx.js';
+export { a as Action, b as AssistantRole, c as Atom, B as Block, d as Bond, C as Config, E as EventLogEntry, P as PRIORITY, e as PermissionLevel, f as Project, Q as QueueEntry, R as ROLE_PERMISSIONS, T as TEMPLATES } from './Store-BtdYuiUx.js';
+export { API, API as ApiRouter } from './server/api.js';
+import * as http from 'http';
+export { J as JsonRpcRequest, a as JsonRpcResponse, M as McpServer, b as McpSseTransport, c as McpStdioTransport, d as McpTool, e as McpTransport, T as TOOLS } from './index-DWk78ifo.js';
+export { WebSocketHandler, createWebSocketServer } from './server/websocket.js';
+export { EventBroadcaster } from './ws/index.js';
+import 'node:events';
+import 'node:stream/promises';
+import 'node:stream';
+import 'node:stream/web';
+import 'node:http';
+import 'better-sqlite3';
+import 'ws';
+
+declare class RateLimiter {
+    private rates;
+    private limit;
+    private windowMs;
+    constructor(limit: number, windowMs: number);
+    check(token: string): boolean;
+    private cleanup;
+}
+declare function authenticate(store: Store, req: http.IncomingMessage): Assistant | undefined;
+
+declare function json(res: http.ServerResponse, status: number, data: any): void;
+declare function readBody(req: http.IncomingMessage): Promise<any>;
+declare function resolveProjectId(store: Store, idOrName: string): string;
+declare function serializeAtom(store: Store, atom: any, compact?: boolean): any;
+
+/**
+ * Content-Addressed Storage (CAS)
+ * Files stored by SHA256 hash, sharded by first 2 hex chars.
+ */
+declare function computeHash(buffer: Buffer): string;
+declare function saveFile(buffer: Buffer, _fileName: string): {
+    hash: string;
+    size: number;
+    path: string;
+};
+declare function getFile(hash: string): Buffer | null;
+declare function fileExists(hash: string): boolean;
+
+export { Assistant, RateLimiter, Store, authenticate, computeHash, fileExists, getFile, json, readBody, resolveProjectId, saveFile, serializeAtom };