@feltdb/core 0.6.9 → 0.6.11

package/dist/indexeddb-db.js

@@ -1,3 +1,5 @@
+import { FreshnessContractViolation } from './freshness.js';
+import { decideTransaction, embeddedResult, EmbeddedTransactionRejected, } from './embedded-transaction.js';
 /** Durable browser runtime. Every mutation resolves only after its IndexedDB transaction commits. */
 export class IndexedDbJsDb {
     constructor(namespace) {
@@ -30,13 +32,16 @@ export class IndexedDbJsDb {
     }
     open(name) {
         return new Promise((resolve, reject) => {
-            const request = indexedDB.open(name, 1);
+            const request = indexedDB.open(name, 2);
             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 });
+                // Committed transaction ids, so redelivery after a reload is a no-op.
+                if (!db.objectStoreNames.contains('transactions'))
+                    db.createObjectStore('transactions');
             };
             request.onsuccess = () => resolve(request.result);
             request.onerror = () => reject(request.error ?? new Error('open IndexedDB failed'));
@@ -91,6 +96,107 @@ export class IndexedDbJsDb {
     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'); }
+    /**
+     * Commit several operations atomically and durably.
+     *
+     * Reads, precondition checks, and writes all happen inside a single
+     * IndexedDB readwrite transaction, which is the browser's own atomic commit
+     * boundary. If any step fails the transaction aborts and nothing is written,
+     * and the promise resolves only after the transaction has committed.
+     */
+    async commit_transaction(request) {
+        const db = await this.database;
+        const before = this.sequence;
+        // Structural problems — no operations, the same record written twice, an
+        // invalid name — do not depend on stored state, so they are settled before
+        // opening a transaction. Without this an empty transaction would open a
+        // transaction that reads nothing and therefore never reaches a decision.
+        const structural = decideTransaction(request, { exists: () => false, hasApplied: () => false });
+        if (structural.kind === 'reject')
+            throw new EmbeddedTransactionRejected(structural.reason);
+        // Applied transaction ids live in their own store so identity survives a
+        // page reload the same way records do.
+        const alreadyApplied = await this.request('transactions', store => store.get(request.transactionId));
+        if (alreadyApplied !== undefined) {
+            return embeddedResult(request, true, before, this.sequence);
+        }
+        const plan = await new Promise((resolve, reject) => {
+            let transaction;
+            try {
+                transaction = db.transaction(['rows', 'changes', 'transactions'], 'readwrite', { durability: 'strict' });
+            }
+            catch {
+                transaction = db.transaction(['rows', 'changes', 'transactions'], 'readwrite');
+            }
+            const rows = transaction.objectStore('rows');
+            const changes = transaction.objectStore('changes');
+            const transactions = transaction.objectStore('transactions');
+            // Read every touched record inside the transaction, so the precondition
+            // check and the write cannot be separated by another writer.
+            const present = new Map();
+            let pending = request.operations.length;
+            let decided = null;
+            const finish = () => {
+                const plan = decideTransaction(request, {
+                    exists: key => present.get(key) === true,
+                    hasApplied: () => false,
+                });
+                decided = plan;
+                if (plan.kind !== 'apply') {
+                    transaction.abort();
+                    return;
+                }
+                const timestamp = Date.now();
+                for (const mutation of plan.mutations) {
+                    if (mutation.value === undefined)
+                        rows.delete(mutation.key);
+                    else
+                        rows.put(mutation.value, mutation.key);
+                    changes.add({
+                        collection: mutation.collection,
+                        key: mutation.key,
+                        type: mutation.value === undefined ? 'delete' : 'put',
+                        value: mutation.value,
+                        timestamp,
+                        origin: this.origin,
+                        id: `${this.origin}:${timestamp}:${Math.random().toString(36).slice(2)}`,
+                    });
+                }
+                transactions.put({ transactionId: request.transactionId, committedAt: timestamp }, request.transactionId);
+            };
+            for (const operation of request.operations) {
+                const key = `${operation.collection}:${operation.id}`;
+                const lookup = rows.getKey(key);
+                lookup.onsuccess = () => {
+                    present.set(key, lookup.result !== undefined);
+                    pending -= 1;
+                    if (pending === 0)
+                        finish();
+                };
+                lookup.onerror = () => reject(lookup.error ?? new Error('IndexedDB read failed'));
+            }
+            transaction.oncomplete = () => resolve(decided ?? { kind: 'reject', reason: 'transaction did not decide' });
+            transaction.onabort = () => {
+                if (decided && decided.kind !== 'apply')
+                    resolve(decided);
+                else
+                    reject(transaction.error ?? new Error('IndexedDB transaction aborted'));
+            };
+            transaction.onerror = () => {
+                if (decided && decided.kind !== 'apply')
+                    return;
+                reject(transaction.error ?? new Error('IndexedDB transaction failed'));
+            };
+        });
+        if (plan.kind === 'duplicate')
+            return embeddedResult(request, true, before, this.sequence);
+        if (plan.kind === 'reject')
+            throw new EmbeddedTransactionRejected(plan.reason);
+        this.sequence += plan.mutations.length;
+        for (const mutation of plan.mutations)
+            this.announceLocalChange(mutation.collection, this.sequence);
+        return embeddedResult(request, false, before, this.sequence);
+    }
     async cas(params) {
         try {
             const db = await this.database;
@@ -342,6 +448,50 @@ export class IndexedDbJsDb {
     acknowledge_peer_operations() { return { success: true }; }
     instance_id() { return this.origin; }
     get_sequence() { return this.sequence; }
+    /**
+     * IndexedDB is the serialization authority for this database.
+     *
+     * The `changes` store is `autoIncrement`, so its key is assigned by the
+     * storage engine inside the same readwrite transaction that writes the record,
+     * and the browser serializes readwrite transactions on an object store across
+     * tabs. A second tab's commit therefore advances the same durable counter,
+     * with no coordination code of our own.
+     *
+     * Note what is *not* used here: `this.sequence` counts what this handle wrote
+     * and would miss every other tab. The durable key is the authoritative value.
+     */
+    freshness() {
+        if (this.peers.size > 0) {
+            return {
+                domain: 'replicated',
+                validation: 'refresh',
+                invalidation: true,
+                reason: 'sync peers order operations causally, so the local autoIncrement key is not authoritative across replicas',
+            };
+        }
+        return {
+            domain: 'local-first',
+            validation: 'revision',
+            invalidation: true,
+            revisionScope: this.origin,
+        };
+    }
+    /**
+     * The highest durable `changes` key.
+     *
+     * Read from the store rather than from memory so a write committed by another
+     * tab is included. An empty store is revision 0, which is a real value: it
+     * means nothing has been committed, and a cache built at 0 is still current.
+     */
+    async revision() {
+        const capability = this.freshness();
+        if (capability.validation !== 'revision') {
+            throw new FreshnessContractViolation(`browser runtime: ${capability.reason}`);
+        }
+        const key = await this.request('changes', store => store.openKeyCursor(null, 'prev'));
+        const cursor = key;
+        return { value: cursor ? Number(cursor.key) : 0, scope: this.origin };
+    }
     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) {

package/dist/memory-db.d.ts

@@ -1,4 +1,6 @@
 import type { JsDb } from './feltdb.js';
+import { type FreshnessCapability, type Revision } from './freshness.js';
+import type { AtomicTransactionRequest, AtomicTransactionResult } from './transaction.js';
 interface JsResult {
     success: boolean;
     data?: string;
@@ -20,9 +22,23 @@ export declare class MemoryJsDb implements JsDb {
     private readonly events;
     private sequence;
     private readonly origin;
+    private readonly revisionState;
     private readonly peers;
+    private readonly applied;
     constructor(namespace: string);
     private event;
+    /**
+     * Commit several operations atomically.
+     *
+     * The plan is decided against current state before anything is written, and
+     * the writes then happen with no `await` between them, so no other caller
+     * can observe a partially applied transaction.
+     *
+     * This runtime is atomic but not durable: nothing survives process exit.
+     * That is a property of an in-memory store, not a weaker transaction
+     * contract.
+     */
+    commit_transaction(request: AtomicTransactionRequest): Promise<AtomicTransactionResult>;
     insert(key: string, value: string): JsResult;
     update(key: string, value: string): JsResult;
     get(key: string): JsResult;
@@ -52,6 +68,16 @@ export declare class MemoryJsDb implements JsDb {
     get_pending_for_peer(): JsResult;
     instance_id(): string;
     get_sequence(): number;
+    /**
+     * One process, one event loop, one shared namespace record.
+     *
+     * Nothing outside this process can write these rows, and every handle on the
+     * namespace advances the same counter, so the counter is authoritative for
+     * the domain it represents. That stops being true the moment replication
+     * touches the namespace.
+     */
+    freshness(): FreshnessCapability;
+    revision(): Promise<Revision>;
     audit_events(): PortableEvent[];
     export_operations(sinceSequence: number): PortableEvent[];
     apply_remote_operations(operations: PortableEvent[]): {

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

@@ -1 +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,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,QAAQ,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAiBtF,GAAG,CAAC,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAiC1K,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"}
+{"version":3,"file":"memory-db.d.ts","sourceRoot":"","sources":["../src/memory-db.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAA8B,KAAK,mBAAmB,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACrG,OAAO,KAAK,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAO1F,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;AA6BrK,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,aAAa,CAAoB;IAClD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;IAC3C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;gBAEjC,SAAS,EAAE,MAAM;IAW7B,OAAO,CAAC,KAAK;IAOb;;;;;;;;;;OAUG;IACG,kBAAkB,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAuB7F,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,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,QAAQ,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAiBtF,GAAG,CAAC,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAiC1K,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;IAEtB;;;;;;;OAOG;IACH,SAAS,IAAI,mBAAmB;IAiB1B,QAAQ,IAAI,OAAO,CAAC,QAAQ,CAAC;IAQnC,YAAY;IACZ,iBAAiB,CAAC,aAAa,EAAE,MAAM;IACvC,uBAAuB,CAAC,UAAU,EAAE,aAAa,EAAE;;;;CAmBpD"}

package/dist/memory-db.js

@@ -1,23 +1,71 @@
+import { FreshnessContractViolation } from './freshness.js';
+import { decideTransaction, embeddedResult, EmbeddedTransactionRejected, } from './embedded-transaction.js';
 const namespaces = new Map();
+const revisions = new Map();
+function namespaceRevision(namespace) {
+    let revision = revisions.get(namespace);
+    if (!revision) {
+        revision = { value: 0, replicated: false };
+        revisions.set(namespace, revision);
+    }
+    return revision;
+}
 /** In-process runtime used by the synchronous createFeltDB API. */
 export class MemoryJsDb {
     constructor(namespace) {
         this.events = [];
         this.sequence = 0;
         this.peers = new Set();
+        this.applied = new Set();
         let rows = namespaces.get(namespace);
         if (!rows) {
             rows = new Map();
             namespaces.set(namespace, rows);
         }
         this.rows = rows;
+        this.revisionState = namespaceRevision(namespace);
         this.origin = `memory:${namespace}`;
     }
     event(collection, key, type, value) {
         this.sequence += 1;
+        this.revisionState.value += 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}` });
     }
+    /**
+     * Commit several operations atomically.
+     *
+     * The plan is decided against current state before anything is written, and
+     * the writes then happen with no `await` between them, so no other caller
+     * can observe a partially applied transaction.
+     *
+     * This runtime is atomic but not durable: nothing survives process exit.
+     * That is a property of an in-memory store, not a weaker transaction
+     * contract.
+     */
+    async commit_transaction(request) {
+        const before = this.sequence;
+        const plan = decideTransaction(request, {
+            exists: key => this.rows.has(key),
+            hasApplied: transactionId => this.applied.has(transactionId),
+        });
+        if (plan.kind === 'duplicate')
+            return embeddedResult(request, true, before, this.sequence);
+        if (plan.kind === 'reject')
+            throw new EmbeddedTransactionRejected(plan.reason);
+        for (const mutation of plan.mutations) {
+            if (mutation.value === undefined) {
+                this.rows.delete(mutation.key);
+                this.event(mutation.collection, mutation.key, 'delete');
+            }
+            else {
+                this.rows.set(mutation.key, mutation.value);
+                this.event(mutation.collection, mutation.key, 'put', mutation.value);
+            }
+        }
+        this.applied.add(request.transactionId);
+        return embeddedResult(request, false, before, this.sequence);
+    }
     insert(key, value) {
         try {
             this.rows.set(key, JSON.parse(value));
@@ -110,9 +158,47 @@ export class MemoryJsDb {
     get_pending_for_peer() { return { success: true, data: '[]' }; }
     instance_id() { return this.origin; }
     get_sequence() { return this.sequence; }
+    /**
+     * One process, one event loop, one shared namespace record.
+     *
+     * Nothing outside this process can write these rows, and every handle on the
+     * namespace advances the same counter, so the counter is authoritative for
+     * the domain it represents. That stops being true the moment replication
+     * touches the namespace.
+     */
+    freshness() {
+        if (this.revisionState.replicated || this.peers.size > 0) {
+            return {
+                domain: 'replicated',
+                validation: 'refresh',
+                invalidation: false,
+                reason: 'remote operations order causally across replicas, so a local counter is not an authoritative revision',
+            };
+        }
+        return {
+            domain: 'single-process',
+            validation: 'revision',
+            invalidation: false,
+            revisionScope: this.origin,
+        };
+    }
+    async revision() {
+        const capability = this.freshness();
+        if (capability.validation !== 'revision') {
+            throw new FreshnessContractViolation(`memory runtime: ${capability.reason}`);
+        }
+        return { value: this.revisionState.value, scope: this.origin };
+    }
     audit_events() { return [...this.events]; }
     export_operations(sinceSequence) { return this.events.filter(event => event.sequence > sinceSequence); }
     apply_remote_operations(operations) {
+        // Once state can arrive from another replica this namespace is causally
+        // ordered, and the local counter stops being an authoritative revision.
+        // Latched rather than derived from the current call, because the loss of
+        // authority is permanent for this namespace: a later empty batch does not
+        // restore it.
+        if (operations.length > 0)
+            this.revisionState.replicated = true;
         let applied = 0, ignored = 0;
         for (const operation of operations) {
             if (this.events.some(event => event.id === operation.id)) {

package/dist/runtime-registry.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Registry for storage runtimes that only exist on some platforms.
+ *
+ * `createFeltDB` is synchronous, so it cannot `await import()` a runtime on
+ * demand. Instead, a platform entry point registers the runtimes it can
+ * provide, and `createFeltDB` looks them up.
+ *
+ * This exists for one reason: the file runtime imports Node's `fs` and `path`.
+ * A static import of it anywhere in the public entry's module graph makes the
+ * whole package unloadable in a browser, because a browser cannot resolve a
+ * bare `fs` specifier. Keeping that import out of the shared graph is what
+ * lets a browser application import `@feltdb/core` at all.
+ */
+import type { JsDb } from './feltdb.js';
+/** Builds a runtime from the option that selected it. */
+export type RuntimeFactory = (target: string) => JsDb;
+/**
+ * Make a runtime available to `createFeltDB`.
+ *
+ * Called by a platform entry point for the runtimes that platform supports.
+ */
+export declare function registerRuntime(name: string, factory: RuntimeFactory): void;
+export declare function resolveRuntime(name: string): RuntimeFactory | undefined;
+/**
+ * Build a runtime, or explain precisely why this platform cannot.
+ *
+ * The message names the alternative rather than reporting a missing module,
+ * because "cannot resolve fs" is not an actionable error for someone who just
+ * wants a database in a browser.
+ */
+export declare function requireRuntime(name: string, target: string, guidance: string): JsDb;
+//# sourceMappingURL=runtime-registry.d.ts.map

package/dist/runtime-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-registry.d.ts","sourceRoot":"","sources":["../src/runtime-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC,yDAAyD;AACzD,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;AAItD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,IAAI,CAE3E;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAEvE;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAInF"}

package/dist/runtime-registry.js

@@ -0,0 +1,38 @@
+/**
+ * Registry for storage runtimes that only exist on some platforms.
+ *
+ * `createFeltDB` is synchronous, so it cannot `await import()` a runtime on
+ * demand. Instead, a platform entry point registers the runtimes it can
+ * provide, and `createFeltDB` looks them up.
+ *
+ * This exists for one reason: the file runtime imports Node's `fs` and `path`.
+ * A static import of it anywhere in the public entry's module graph makes the
+ * whole package unloadable in a browser, because a browser cannot resolve a
+ * bare `fs` specifier. Keeping that import out of the shared graph is what
+ * lets a browser application import `@feltdb/core` at all.
+ */
+const runtimes = new Map();
+/**
+ * Make a runtime available to `createFeltDB`.
+ *
+ * Called by a platform entry point for the runtimes that platform supports.
+ */
+export function registerRuntime(name, factory) {
+    runtimes.set(name, factory);
+}
+export function resolveRuntime(name) {
+    return runtimes.get(name);
+}
+/**
+ * Build a runtime, or explain precisely why this platform cannot.
+ *
+ * The message names the alternative rather than reporting a missing module,
+ * because "cannot resolve fs" is not an actionable error for someone who just
+ * wants a database in a browser.
+ */
+export function requireRuntime(name, target, guidance) {
+    const factory = resolveRuntime(name);
+    if (!factory)
+        throw new Error(guidance);
+    return factory(target);
+}

package/dist/studio/app.d.ts

@@ -7,8 +7,9 @@ export interface StudioAppProps {
     namespace?: string;
     deploymentRuntime?: string;
     applicationUrl?: string;
+    developmentSession?: Record<string, string>;
     onConnect?: (url: string, token: string) => void;
 }
-export declare function StudioApp({ db, remoteUrl, token, namespace, deploymentRuntime, applicationUrl, onConnect }: StudioAppProps): React.JSX.Element;
+export declare function StudioApp({ db, remoteUrl, token, namespace, deploymentRuntime, applicationUrl, developmentSession, onConnect }: StudioAppProps): React.JSX.Element;
 export default StudioApp;
 //# sourceMappingURL=app.d.ts.map

package/dist/studio/app.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.tsx"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAA8B,MAAM,OAAO,CAAC;AAmBnD,OAAO,EAAgC,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAC/E,OAAO,WAAW,CAAC;AAEnB,MAAM,WAAW,cAAc;IAC7B,EAAE,CAAC,EAAE,YAAY,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAClD;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,EAAE,SAAc,EAAE,KAAU,EAAE,SAAqB,EAAE,iBAA6B,EAAE,cAAmB,EAAE,SAAS,EAAE,EAAE,cAAc,qBAgGjK;AAED,eAAe,SAAS,CAAC"}
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.tsx"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAA8B,MAAM,OAAO,CAAC;AAmBnD,OAAO,EAAgC,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAC/E,OAAO,WAAW,CAAC;AAEnB,MAAM,WAAW,cAAc;IAC7B,EAAE,CAAC,EAAE,YAAY,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5C,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAClD;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,EAAE,SAAc,EAAE,KAAU,EAAE,SAAqB,EAAE,iBAA6B,EAAE,cAAmB,EAAE,kBAAkB,EAAE,SAAS,EAAE,EAAE,cAAc,qBA6IrL;AAED,eAAe,SAAS,CAAC"}

package/dist/studio/components/StateExplorer.d.ts

@@ -5,7 +5,8 @@ export interface StateExplorerProps {
     model?: FlowSpec | null;
     namespace?: string;
     applicationUrl?: string;
+    developmentSession?: Record<string, string>;
 }
-export declare function StateExplorer({ db, model, namespace, applicationUrl }: StateExplorerProps): React.JSX.Element;
+export declare function StateExplorer({ db, model, namespace, applicationUrl, developmentSession }: StateExplorerProps): React.JSX.Element;
 export default StateExplorer;
 //# sourceMappingURL=StateExplorer.d.ts.map

package/dist/studio/components/StateExplorer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StateExplorer.d.ts","sourceRoot":"","sources":["../../src/components/StateExplorer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsC,MAAM,OAAO,CAAC;AAC3D,OAAO,KAAK,EAAkB,QAAQ,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG3E,MAAM,WAAW,kBAAkB;IAAG,EAAE,CAAC,EAAE,YAAY,CAAC;IAAC,KAAK,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE;AAoB/H,wBAAgB,aAAa,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,SAAqB,EAAE,cAAmB,EAAE,EAAE,kBAAkB,qBAuB1G;AACD,eAAe,aAAa,CAAC"}
+{"version":3,"file":"StateExplorer.d.ts","sourceRoot":"","sources":["../../src/components/StateExplorer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsC,MAAM,OAAO,CAAC;AAC3D,OAAO,KAAK,EAAkB,QAAQ,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG3E,MAAM,WAAW,kBAAkB;IAAG,EAAE,CAAC,EAAE,YAAY,CAAC;IAAC,KAAK,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE;AAoB5K,wBAAgB,aAAa,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,SAAqB,EAAE,cAAmB,EAAE,kBAAkB,EAAE,EAAE,kBAAkB,qBA0B9H;AACD,eAAe,aAAa,CAAC"}

package/dist/studio/components/index.js

@@ -1,4 +1,4 @@
-import { a as e, c as t, d as n, f as r, i, l as a, m as o, n as s, o as c, p as l, r as u, s as d, t as f, u as p, x as m } from "../components-9kDSWiGL.js";
+import { a as e, c as t, d as n, f as r, i, l as a, m as o, n as s, o as c, p as l, r as u, s as d, t as f, u as p, x as m } from "../components-C5p2TfIU.js";
 import { t as h } from "../KeyManagementPanel-DZuSeWBK.js";
 import { ManagedInstancePanel as g } from "./ManagedInstancePanel.js";
 export { c as AgentExplorer, f as ApplicationDesigner, p as CapabilityExplorer, t as ConflictExplorer, a as ExecutionViewer, s as GlobalSearch, i as HealthCenter, h as KeyManagementPanel, g as ManagedInstancePanel, r as OperationsExplorer, m as OverviewDashboard, n as PeerMap, e as ProvenanceViewer, l as ReferenceExplorer, u as SettingsPanel, o as StateExplorer, d as WorkflowVisualizer };

package/dist/studio/{components-9kDSWiGL.js → components-C5p2TfIU.js}

@@ -281,22 +281,27 @@ function C({ db: e, definition: t, namespace: n, bridgedItems: r }) {
 		]
 	});
 }
-function w({ db: e, model: t, namespace: r = "default", applicationUrl: o = "" }) {
-	let l = i(null), [u, d] = a(null);
+function w({ db: e, model: t, namespace: r = "default", applicationUrl: o = "", developmentSession: l }) {
+	let u = i(null), [d, f] = a(null);
 	return n(() => {
 		if (!o) return;
-		let e = new URL(o).origin, t = () => l.current?.contentWindow?.postMessage({
-			type: "feltdb:studio:read",
-			requestId: "live"
-		}, e), n = (n) => {
-			n.origin === e && (n.data?.type === "feltdb:studio:ready" && t(), n.data?.type === "feltdb:studio:data" && d(n.data.records));
+		let e = new URL(o).origin, t = () => {
+			l?.sessionId && u.current?.contentWindow?.postMessage({
+				type: "feltdb:dev-session",
+				session: l
+			}, e), u.current?.contentWindow?.postMessage({
+				type: "feltdb:studio:read",
+				requestId: "live"
+			}, e);
+		}, n = (n) => {
+			n.origin === e && (n.data?.type === "feltdb:studio:ready" && t(), n.data?.type === "feltdb:studio:data" && f(n.data.records));
 		};
 		window.addEventListener("message", n);
 		let r = window.setInterval(t, 1500);
 		return () => {
 			window.removeEventListener("message", n), window.clearInterval(r);
 		};
-	}, [o]), /* @__PURE__ */ c("div", {
+	}, [o, l]), /* @__PURE__ */ c("div", {
 		className: "studio-model-page",
 		children: [
 			/* @__PURE__ */ c("header", { children: [
@@ -308,14 +313,20 @@ function w({ db: e, model: t, namespace: r = "default", applicationUrl: o = "" }
 				/* @__PURE__ */ s("p", { children: "Live application records grouped by collection. Select a record to inspect every field." })
 			] }),
 			o && /* @__PURE__ */ s("iframe", {
-				ref: l,
+				ref: u,
 				className: "studio-data-bridge",
 				src: o,
 				title: "FeltDB application data bridge",
-				onLoad: () => l.current?.contentWindow?.postMessage({
-					type: "feltdb:studio:read",
-					requestId: "initial"
-				}, new URL(o).origin)
+				onLoad: () => {
+					let e = new URL(o).origin;
+					l?.sessionId && u.current?.contentWindow?.postMessage({
+						type: "feltdb:dev-session",
+						session: l
+					}, e), u.current?.contentWindow?.postMessage({
+						type: "feltdb:studio:read",
+						requestId: "initial"
+					}, e);
+				}
 			}),
 			/* @__PURE__ */ c("div", {
 				className: "model-summary",
@@ -331,7 +342,7 @@ function w({ db: e, model: t, namespace: r = "default", applicationUrl: o = "" }
 					db: e ?? null,
 					definition: t,
 					namespace: r,
-					bridgedItems: u?.[t.name]
+					bridgedItems: d?.[t.name]
 				}, t.name)), !t?.collections.length && /* @__PURE__ */ c("div", {
 					className: "model-empty",
 					children: [