@feltdb/core 0.2.0

package/dist/http-db.js

@@ -0,0 +1,205 @@
+/** Network adapter implementing the same collection runtime contract as WASM. */
+export class HttpJsDb {
+    constructor(options) {
+        this.url = options.url.replace(/\/$/, '');
+        this.token = options.token;
+    }
+    headers(json = false) {
+        return {
+            Authorization: `Bearer ${this.token}`,
+            'FeltDB-Protocol': '1',
+            ...(json ? { 'Content-Type': 'application/json' } : {}),
+        };
+    }
+    splitKey(key) {
+        const separator = key.indexOf(':');
+        if (separator < 1 || separator === key.length - 1) {
+            throw new Error(`Invalid FeltDB key: ${key}`);
+        }
+        return [key.slice(0, separator), key.slice(separator + 1)];
+    }
+    async get(key) {
+        try {
+            const [collection, id] = this.splitKey(key);
+            const response = await fetch(`${this.url}/collections/${encodeURIComponent(collection)}/${encodeURIComponent(id)}`, {
+                headers: this.headers(),
+            });
+            if (response.status === 404)
+                return { success: true };
+            if (!response.ok)
+                return this.failure(response);
+            const record = await response.json();
+            return { success: true, data: JSON.stringify(record.value) };
+        }
+        catch (error) {
+            return { success: false, error: String(error) };
+        }
+    }
+    async query(collection) {
+        try {
+            const response = await fetch(`${this.url}/collections/${encodeURIComponent(collection)}`, {
+                headers: this.headers(),
+            });
+            if (!response.ok)
+                return this.failure(response);
+            const records = await response.json();
+            return { success: true, data: JSON.stringify(records.map(record => record.value)) };
+        }
+        catch (error) {
+            return { success: false, error: String(error) };
+        }
+    }
+    async insert(key, value) {
+        try {
+            const [collection, id] = this.splitKey(key);
+            const record = JSON.parse(value);
+            const response = await fetch(`${this.url}/collections/${encodeURIComponent(collection)}`, {
+                method: 'POST',
+                headers: this.headers(true),
+                body: JSON.stringify({ ...record, id }),
+            });
+            if (!response.ok)
+                return this.failure(response);
+            return { success: true, data: key };
+        }
+        catch (error) {
+            return { success: false, error: String(error) };
+        }
+    }
+    async update(key, value) {
+        try {
+            const [collection, id] = this.splitKey(key);
+            const response = await fetch(`${this.url}/collections/${encodeURIComponent(collection)}/${encodeURIComponent(id)}`, {
+                method: 'PATCH',
+                headers: this.headers(true),
+                body: value,
+            });
+            if (!response.ok)
+                return this.failure(response);
+            return { success: true, data: key };
+        }
+        catch (error) {
+            return { success: false, error: String(error) };
+        }
+    }
+    async delete(key) {
+        try {
+            const [collection, id] = this.splitKey(key);
+            const response = await fetch(`${this.url}/collections/${encodeURIComponent(collection)}/${encodeURIComponent(id)}`, {
+                method: 'DELETE',
+                headers: this.headers(),
+            });
+            return response.ok ? { success: true, data: key } : this.failure(response);
+        }
+        catch (error) {
+            return { success: false, error: String(error) };
+        }
+    }
+    /** Acquire a reference through the server's causal peer fabric. */
+    async acquire(collection, id) {
+        const response = await fetch(`${this.url}/refs/${encodeURIComponent(collection)}/${encodeURIComponent(id)}`, { headers: this.headers() });
+        if (response.status === 404)
+            return null;
+        if (!response.ok)
+            throw new Error((await this.failure(response)).error);
+        return (await response.json()).value;
+    }
+    /** Execute the built-in state-derived search capability remotely. */
+    async search(collection, query, limit = 50) {
+        const response = await fetch(`${this.url}/capabilities/search/${encodeURIComponent(collection)}`, {
+            method: 'POST', headers: this.headers(true), body: JSON.stringify({ query, limit }),
+        });
+        if (!response.ok)
+            throw new Error((await this.failure(response)).error);
+        return (await response.json()).map(record => record.value);
+    }
+    async provenance(collection, id) {
+        const response = await fetch(`${this.url}/provenance/${encodeURIComponent(collection)}/${encodeURIComponent(id)}`, { headers: this.headers() });
+        if (!response.ok)
+            throw new Error((await this.failure(response)).error);
+        return response.json();
+    }
+    async storeContent(content) {
+        const response = await fetch(`${this.url}/content`, { method: 'PUT', headers: this.headers(), body: content });
+        if (!response.ok)
+            throw new Error((await this.failure(response)).error);
+        return response.json();
+    }
+    async acquireContent(hash) {
+        const response = await fetch(`${this.url}/content/${encodeURIComponent(hash)}`, { headers: this.headers() });
+        if (response.status === 404)
+            return null;
+        if (!response.ok)
+            throw new Error((await this.failure(response)).error);
+        return new Uint8Array(await response.arrayBuffer());
+    }
+    async command(path, body) {
+        const response = await fetch(`${this.url}${path}`, {
+            method: 'POST', headers: this.headers(true), body: JSON.stringify(body),
+        });
+        if (!response.ok)
+            throw new Error((await this.failure(response)).error);
+        return response.status === 204 ? undefined : response.json();
+    }
+    subscribe_changes(callback) {
+        const controller = new AbortController();
+        void this.consumeEvents(controller, callback);
+        return () => controller.abort();
+    }
+    async consumeEvents(controller, callback) {
+        while (!controller.signal.aborted) {
+            try {
+                const response = await fetch(`${this.url}/events`, {
+                    headers: this.headers(),
+                    signal: controller.signal,
+                });
+                if (!response.ok || !response.body)
+                    throw new Error(`Event stream failed: HTTP ${response.status}`);
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = '';
+                while (!controller.signal.aborted) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true }).replace(/\r\n/g, '\n');
+                    const frames = buffer.split('\n\n');
+                    buffer = frames.pop() ?? '';
+                    for (const frame of frames) {
+                        const data = frame.split('\n').filter(line => line.startsWith('data:')).map(line => line.slice(5).trim()).join('\n');
+                        if (!data)
+                            continue;
+                        const event = JSON.parse(data);
+                        if (event.change?.capability)
+                            callback(event.change.capability);
+                    }
+                }
+            }
+            catch (error) {
+                if (controller.signal.aborted)
+                    return;
+            }
+            await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+    }
+    async failure(response) {
+        let detail = `HTTP ${response.status}`;
+        try {
+            const body = await response.json();
+            if (body.error)
+                detail = body.error;
+        }
+        catch { /* response was not JSON */ }
+        return { success: false, error: detail };
+    }
+    get_capability_records(capability) { return this.query(capability); }
+    execute_op() { return { success: false, error: 'Raw operation execution is internal to the server fabric' }; }
+    sync_info() { return { success: false, error: 'Use the server runtime endpoint for diagnostics' }; }
+    add_peer() { return { success: false, error: 'Peer topology is server-managed' }; }
+    add_sync_peer() { return { success: false, error: 'Peer topology is server-managed' }; }
+    remove_sync_peer() { return { success: false, error: 'Peer topology is server-managed' }; }
+    get_pending_for_peer() { return { success: false, error: 'Operation transport is server-managed' }; }
+    acknowledge_peer_operations() { return { success: false, error: 'Operation transport is server-managed' }; }
+    instance_id() { return `remote:${this.url}`; }
+    get_sequence() { return 0; }
+}

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @feltdb/core - FeltDB Application-Facing API
+ *
+ * The primary interface for developers using FeltDB.
+ * Provides a simple, state-first API for data persistence,
+ * reactivity, and distributed operations.
+ */
+export * from './db.js';
+export * from './collection.js';
+export * from './reactive-graph.js';
+export * from './recovery.js';
+export * from './execution.js';
+export * from './workflow.js';
+export * from './capability.js';
+export * from './memory-db.js';
+export * from './http-db.js';
+export * from './indexeddb-db.js';
+export * from './flowspec.js';
+/**
+ * Agent Runtime APIs
+ */
+export * from './agent.js';
+export * from './agent-observation.js';
+export * from './agent-decision.js';
+export * from './agent-memory.js';
+export * from './agent-registry.js';
+export * from './agent-runtime.js';
+/**
+ * Observability and inspection APIs
+ */
+export type { ProvenanceGraph, ProvenanceNode, ProvenanceEdge, ProvenanceEdgeType, RuntimeDiagnostics, } from './db.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAE9B;;GAEG;AACH,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AAEnC;;GAEG;AACH,YAAY,EACV,eAAe,EACf,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,27 @@
+/**
+ * @feltdb/core - FeltDB Application-Facing API
+ *
+ * The primary interface for developers using FeltDB.
+ * Provides a simple, state-first API for data persistence,
+ * reactivity, and distributed operations.
+ */
+export * from './db.js';
+export * from './collection.js';
+export * from './reactive-graph.js';
+export * from './recovery.js';
+export * from './execution.js';
+export * from './workflow.js';
+export * from './capability.js';
+export * from './memory-db.js';
+export * from './http-db.js';
+export * from './indexeddb-db.js';
+export * from './flowspec.js';
+/**
+ * Agent Runtime APIs
+ */
+export * from './agent.js';
+export * from './agent-observation.js';
+export * from './agent-decision.js';
+export * from './agent-memory.js';
+export * from './agent-registry.js';
+export * from './agent-runtime.js';

package/dist/indexeddb-db.d.ts

@@ -0,0 +1,54 @@
+import type { JsDb } from './feltdb.js';
+interface JsResult {
+    success: boolean;
+    data?: string;
+    error?: string;
+}
+interface ChangeRecord {
+    sequence?: number;
+    collection: string;
+    key: string;
+    type: 'put' | 'delete';
+    timestamp: number;
+    id: string;
+    origin: string;
+    value?: unknown;
+}
+/** Durable browser runtime. Every mutation resolves only after its IndexedDB transaction commits. */
+export declare class IndexedDbJsDb implements JsDb {
+    private readonly database;
+    private readonly channel?;
+    private sequence;
+    private readonly origin;
+    private readonly peers;
+    constructor(namespace: string);
+    private open;
+    private splitKey;
+    private mutate;
+    insert(key: string, value: string): Promise<JsResult>;
+    update(key: string, value: string): Promise<JsResult>;
+    delete(key: string): Promise<JsResult>;
+    get(key: string): Promise<JsResult>;
+    query(collection: string): Promise<JsResult>;
+    private request;
+    subscribe_changes(callback: (collection: string) => void): () => void;
+    close(): void;
+    get_capability_records(capability: string): Promise<JsResult>;
+    execute_op(): JsResult;
+    sync_info(): JsResult;
+    add_peer(): JsResult;
+    add_sync_peer(peerId: string): JsResult;
+    remove_sync_peer(peerId: string): JsResult;
+    get_pending_for_peer(): JsResult;
+    acknowledge_peer_operations(): JsResult;
+    instance_id(): string;
+    get_sequence(): number;
+    audit_events(): Promise<ChangeRecord[]>;
+    export_operations(sinceSequence: number): Promise<ChangeRecord[]>;
+    apply_remote_operations(operations: ChangeRecord[]): Promise<{
+        applied: number;
+        ignored: number;
+    }>;
+}
+export {};
+//# sourceMappingURL=indexeddb-db.d.ts.map

package/dist/indexeddb-db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexeddb-db.d.ts","sourceRoot":"","sources":["../src/indexeddb-db.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC,UAAU,QAAQ;IAAG,OAAO,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE;AACtE,UAAU,YAAY;IAAG,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,KAAK,GAAG,QAAQ,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE;AAErK,qGAAqG;AACrG,qBAAa,aAAc,YAAW,IAAI;IACxC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAuB;IAChD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAmB;IAC5C,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;gBAE/B,SAAS,EAAE,MAAM;IAO7B,OAAO,CAAC,IAAI;IAcZ,OAAO,CAAC,QAAQ;YAMF,MAAM;IA2BpB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IACrD,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IACrD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAEhC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAKnC,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;YAapC,OAAO;IAKrB,iBAAiB,CAAC,QAAQ,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,IAAI;IAuBrE,KAAK,IAAI,IAAI;IACb,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAC7D,UAAU,IAAI,QAAQ;IACtB,SAAS,IAAI,QAAQ;IACrB,QAAQ,IAAI,QAAQ;IACpB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ;IACvC,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ;IAC1C,oBAAoB,IAAI,QAAQ;IAChC,2BAA2B,IAAI,QAAQ;IACvC,WAAW,IAAI,MAAM;IACrB,YAAY,IAAI,MAAM;IAChB,YAAY,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;IACvC,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IACjE,uBAAuB,CAAC,UAAU,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CAqBzG"}

package/dist/indexeddb-db.js

@@ -0,0 +1,175 @@
+/** Durable browser runtime. Every mutation resolves only after its IndexedDB transaction commits. */
+export class IndexedDbJsDb {
+    constructor(namespace) {
+        this.sequence = 0;
+        this.peers = new Set();
+        if (typeof indexedDB === 'undefined')
+            throw new Error('IndexedDB is unavailable in this browser');
+        this.database = this.open(`feltdb:${namespace}`);
+        this.origin = `browser:${namespace}`;
+        if (typeof BroadcastChannel !== 'undefined')
+            this.channel = new BroadcastChannel(`feltdb:${namespace}:changes`);
+    }
+    open(name) {
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(name, 1);
+            request.onupgradeneeded = () => {
+                const db = request.result;
+                if (!db.objectStoreNames.contains('rows'))
+                    db.createObjectStore('rows');
+                if (!db.objectStoreNames.contains('changes'))
+                    db.createObjectStore('changes', { keyPath: 'sequence', autoIncrement: true });
+            };
+            request.onsuccess = () => resolve(request.result);
+            request.onerror = () => reject(request.error ?? new Error('open IndexedDB failed'));
+            request.onblocked = () => reject(new Error('IndexedDB upgrade blocked by another tab'));
+        });
+    }
+    splitKey(key) {
+        const separator = key.indexOf(':');
+        if (separator < 1)
+            throw new Error(`Invalid FeltDB key: ${key}`);
+        return key.slice(0, separator);
+    }
+    async mutate(key, value, type) {
+        try {
+            const db = await this.database;
+            const collection = this.splitKey(key);
+            await new Promise((resolve, reject) => {
+                let transaction;
+                try {
+                    transaction = db.transaction(['rows', 'changes'], 'readwrite', { durability: 'strict' });
+                }
+                catch {
+                    transaction = db.transaction(['rows', 'changes'], 'readwrite');
+                }
+                if (type === 'delete')
+                    transaction.objectStore('rows').delete(key);
+                else
+                    transaction.objectStore('rows').put(value, key);
+                const changes = transaction.objectStore('changes');
+                const timestamp = Date.now();
+                const change = changes.add({ collection, key, type, value, timestamp, origin: this.origin, id: `${this.origin}:${timestamp}:${Math.random().toString(36).slice(2)}` });
+                change.onsuccess = () => {
+                    const sequence = Number(change.result);
+                    if (sequence > 10000)
+                        changes.delete(IDBKeyRange.upperBound(sequence - 10000));
+                };
+                transaction.oncomplete = () => resolve();
+                transaction.onerror = () => reject(transaction.error ?? new Error('IndexedDB mutation failed'));
+                transaction.onabort = () => reject(transaction.error ?? new Error('IndexedDB mutation aborted'));
+            });
+            this.sequence += 1;
+            this.channel?.postMessage({ collection });
+            return { success: true, data: key };
+        }
+        catch (error) {
+            return { success: false, error: String(error) };
+        }
+    }
+    insert(key, value) { return this.mutate(key, JSON.parse(value), 'put'); }
+    update(key, value) { return this.mutate(key, JSON.parse(value), 'put'); }
+    delete(key) { return this.mutate(key, undefined, 'delete'); }
+    async get(key) {
+        try {
+            const value = await this.request('rows', store => store.get(key));
+            return { success: true, data: value === undefined ? undefined : JSON.stringify(value) };
+        }
+        catch (error) {
+            return { success: false, error: String(error) };
+        }
+    }
+    async query(collection) {
+        try {
+            const db = await this.database;
+            const values = await new Promise((resolve, reject) => {
+                const request = db.transaction('rows').objectStore('rows').openCursor();
+                const output = [];
+                request.onsuccess = () => { const cursor = request.result; if (!cursor)
+                    return resolve(output); if (String(cursor.key).startsWith(`${collection}:`))
+                    output.push(cursor.value); cursor.continue(); };
+                request.onerror = () => reject(request.error);
+            });
+            return { success: true, data: JSON.stringify(values) };
+        }
+        catch (error) {
+            return { success: false, error: String(error) };
+        }
+    }
+    async request(storeName, create) {
+        const db = await this.database;
+        return new Promise((resolve, reject) => { const request = create(db.transaction(storeName).objectStore(storeName)); request.onsuccess = () => resolve(request.result); request.onerror = () => reject(request.error); });
+    }
+    subscribe_changes(callback) {
+        let stopped = false;
+        let cursor = 0;
+        const receive = (event) => callback(event.data.collection);
+        this.channel?.addEventListener('message', receive);
+        const poll = async () => {
+            while (!stopped) {
+                try {
+                    const db = await this.database;
+                    await new Promise((resolve, reject) => {
+                        const range = cursor ? IDBKeyRange.lowerBound(cursor, true) : undefined;
+                        const request = db.transaction('changes').objectStore('changes').openCursor(range);
+                        request.onsuccess = () => { const item = request.result; if (!item)
+                            return resolve(); cursor = Number(item.key); callback(item.value.collection); item.continue(); };
+                        request.onerror = () => reject(request.error);
+                    });
+                }
+                catch { /* a later poll retries durable events */ }
+                await new Promise(resolve => setTimeout(resolve, 500));
+            }
+        };
+        void poll();
+        return () => { stopped = true; this.channel?.removeEventListener('message', receive); };
+    }
+    close() { void this.database.then(db => db.close()); this.channel?.close(); }
+    get_capability_records(capability) { return this.query(capability); }
+    execute_op() { return { success: false, error: 'Raw operations are unavailable in IndexedDB' }; }
+    sync_info() { return { success: true, data: JSON.stringify({ instance_id: this.origin, sequence: this.sequence, connected_peers: [...this.peers], pending_operations: 0, operations_sent: 0, operations_received: 0, conflicts_detected: 0, last_sync_ms: 0, is_connected: this.peers.size > 0 }) }; }
+    add_peer() { return { success: false, error: 'Use a remote runtime for peer sync' }; }
+    add_sync_peer(peerId) { this.peers.add(peerId); return { success: true }; }
+    remove_sync_peer(peerId) { this.peers.delete(peerId); return { success: true }; }
+    get_pending_for_peer() { return { success: true, data: '[]' }; }
+    acknowledge_peer_operations() { return { success: true }; }
+    instance_id() { return this.origin; }
+    get_sequence() { return this.sequence; }
+    async audit_events() { return (await this.request('changes', store => store.getAll())).map((value, index) => ({ ...value, sequence: value.sequence ?? index + 1 })); }
+    async export_operations(sinceSequence) { return (await this.audit_events()).filter(value => (value.sequence ?? 0) > sinceSequence); }
+    async apply_remote_operations(operations) {
+        const db = await this.database;
+        let applied = 0, ignored = 0;
+        for (const operation of operations) {
+            const history = await this.audit_events();
+            if (history.some(event => event.id === operation.id)) {
+                ignored++;
+                continue;
+            }
+            const current = history.filter(event => event.key === operation.key).sort((a, b) => (b.sequence ?? 0) - (a.sequence ?? 0))[0];
+            const incomingOrder = `${String(operation.timestamp).padStart(16, '0')}:${operation.origin}:${operation.id}`;
+            const currentOrder = current ? `${String(current.timestamp).padStart(16, '0')}:${current.origin}:${current.id}` : '';
+            const accepted = incomingOrder >= currentOrder;
+            await new Promise((resolve, reject) => {
+                const transaction = db.transaction(['rows', 'changes'], 'readwrite');
+                if (accepted) {
+                    if (operation.type === 'delete')
+                        transaction.objectStore('rows').delete(operation.key);
+                    else
+                        transaction.objectStore('rows').put(operation.value, operation.key);
+                }
+                const { sequence: _sequence, ...portable } = operation;
+                transaction.objectStore('changes').add(portable);
+                transaction.oncomplete = () => resolve();
+                transaction.onerror = () => reject(transaction.error);
+                transaction.onabort = () => reject(transaction.error);
+            });
+            this.channel?.postMessage({ collection: operation.collection });
+            if (accepted)
+                applied++;
+            else
+                ignored++;
+        }
+        return { applied, ignored };
+    }
+}

package/dist/memory-db.d.ts

@@ -0,0 +1,49 @@
+import type { JsDb } from './feltdb.js';
+interface JsResult {
+    success: boolean;
+    data?: string;
+    error?: string;
+}
+interface PortableEvent {
+    sequence: number;
+    collection: string;
+    key: string;
+    type: 'put' | 'delete';
+    timestamp: number;
+    id: string;
+    origin: string;
+    value?: unknown;
+}
+/** In-process runtime used by the synchronous createFeltDB API. */
+export declare class MemoryJsDb implements JsDb {
+    private readonly rows;
+    private readonly events;
+    private sequence;
+    private readonly origin;
+    private readonly peers;
+    constructor(namespace: string);
+    private event;
+    insert(key: string, value: string): JsResult;
+    update(key: string, value: string): JsResult;
+    get(key: string): JsResult;
+    delete(key: string): JsResult;
+    query(capability: string): JsResult;
+    get_capability_records(capability: string): JsResult;
+    execute_op(): JsResult;
+    sync_info(): JsResult;
+    add_peer(): JsResult;
+    add_sync_peer(peerId: string): JsResult;
+    remove_sync_peer(peerId: string): JsResult;
+    acknowledge_peer_operations(): JsResult;
+    get_pending_for_peer(): JsResult;
+    instance_id(): string;
+    get_sequence(): number;
+    audit_events(): PortableEvent[];
+    export_operations(sinceSequence: number): PortableEvent[];
+    apply_remote_operations(operations: PortableEvent[]): {
+        applied: number;
+        ignored: number;
+    };
+}
+export {};
+//# sourceMappingURL=memory-db.d.ts.map

package/dist/memory-db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-db.d.ts","sourceRoot":"","sources":["../src/memory-db.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC,UAAU,QAAQ;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,aAAa;IAAG,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,KAAK,GAAG,QAAQ,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE;AAIrK,mEAAmE;AACnE,qBAAa,UAAW,YAAW,IAAI;IACrC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAuB;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuB;IAC9C,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;gBAE/B,SAAS,EAAE,MAAM;IAU7B,OAAO,CAAC,KAAK;IAMb,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,QAAQ;IAU5C,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,QAAQ;IAO5C,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ;IAO1B,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ;IAM7B,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,QAAQ;IAQnC,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,QAAQ;IAIpD,UAAU,IAAI,QAAQ;IAItB,SAAS,IAAI,QAAQ;IAIrB,QAAQ,IAAI,QAAQ;IACpB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ;IACvC,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ;IAC1C,2BAA2B,IAAI,QAAQ;IACvC,oBAAoB,IAAI,QAAQ;IAChC,WAAW,IAAI,MAAM;IACrB,YAAY,IAAI,MAAM;IACtB,YAAY;IACZ,iBAAiB,CAAC,aAAa,EAAE,MAAM;IACvC,uBAAuB,CAAC,UAAU,EAAE,aAAa,EAAE;;;;CAapD"}

package/dist/memory-db.js

@@ -0,0 +1,97 @@
+const namespaces = new Map();
+/** In-process runtime used by the synchronous createFeltDB API. */
+export class MemoryJsDb {
+    constructor(namespace) {
+        this.events = [];
+        this.sequence = 0;
+        this.peers = new Set();
+        let rows = namespaces.get(namespace);
+        if (!rows) {
+            rows = new Map();
+            namespaces.set(namespace, rows);
+        }
+        this.rows = rows;
+        this.origin = `memory:${namespace}`;
+    }
+    event(collection, key, type, value) {
+        this.sequence += 1;
+        const timestamp = Date.now();
+        this.events.push({ sequence: this.sequence, collection, key, type, value, timestamp, origin: this.origin, id: `${this.origin}:${timestamp}:${this.sequence}` });
+    }
+    insert(key, value) {
+        try {
+            this.rows.set(key, JSON.parse(value));
+            this.event(key.split(':')[0], key, 'put', JSON.parse(value));
+            return { success: true, data: key };
+        }
+        catch (error) {
+            return { success: false, error: String(error) };
+        }
+    }
+    update(key, value) {
+        if (!this.rows.has(key)) {
+            return { success: false, error: `Record ${key} not found` };
+        }
+        return this.insert(key, value);
+    }
+    get(key) {
+        const value = this.rows.get(key);
+        return value === undefined
+            ? { success: true }
+            : { success: true, data: JSON.stringify(value) };
+    }
+    delete(key) {
+        this.rows.delete(key);
+        this.event(key.split(':')[0], key, 'delete');
+        return { success: true, data: key };
+    }
+    query(capability) {
+        const prefix = `${capability}:`;
+        const values = [...this.rows]
+            .filter(([key]) => key.startsWith(prefix))
+            .map(([, value]) => value);
+        return { success: true, data: JSON.stringify(values) };
+    }
+    get_capability_records(capability) {
+        return this.query(capability);
+    }
+    execute_op() {
+        return { success: false, error: 'Raw operations are unavailable in the memory runtime' };
+    }
+    sync_info() {
+        return { success: true, data: JSON.stringify({ instance_id: this.origin, sequence: this.sequence, connected_peers: [...this.peers], pending_operations: 0, operations_sent: 0, operations_received: 0, conflicts_detected: 0, last_sync_ms: 0, is_connected: this.peers.size > 0 }) };
+    }
+    add_peer() { return { success: true }; }
+    add_sync_peer(peerId) { this.peers.add(peerId); return { success: true }; }
+    remove_sync_peer(peerId) { this.peers.delete(peerId); return { success: true }; }
+    acknowledge_peer_operations() { return { success: true }; }
+    get_pending_for_peer() { return { success: true, data: '[]' }; }
+    instance_id() { return this.origin; }
+    get_sequence() { return this.sequence; }
+    audit_events() { return [...this.events]; }
+    export_operations(sinceSequence) { return this.events.filter(event => event.sequence > sinceSequence); }
+    apply_remote_operations(operations) {
+        let applied = 0, ignored = 0;
+        for (const operation of operations) {
+            if (this.events.some(event => event.id === operation.id)) {
+                ignored++;
+                continue;
+            }
+            const current = [...this.events].reverse().find(event => event.key === operation.key);
+            const incomingOrder = `${String(operation.timestamp).padStart(16, '0')}:${operation.origin}:${operation.id}`;
+            const currentOrder = current ? `${String(current.timestamp).padStart(16, '0')}:${current.origin}:${current.id}` : '';
+            this.sequence += 1;
+            this.events.push({ ...operation, sequence: this.sequence });
+            if (incomingOrder >= currentOrder) {
+                if (operation.type === 'delete')
+                    this.rows.delete(operation.key);
+                else
+                    this.rows.set(operation.key, operation.value);
+                applied++;
+            }
+            else
+                ignored++;
+        }
+        return { applied, ignored };
+    }
+}