@feltdb/core 0.6.13 → 0.7.0

package/README.md

@@ -75,6 +75,38 @@ Browser mutations resolve after their IndexedDB transaction commits. The
 durable change journal replays after reload and coordinates live collections
 across tabs through `BroadcastChannel` when available.
 
+## Atomic conditional transactions
+
+Core 0.7.0 can fence a multi-record transaction on the exact version read by
+the caller. The transaction either commits every operation or writes nothing:
+
+```typescript
+import { ConditionalConflictError } from '@feltdb/core';
+
+const current = await db.collection('accounts').get('primary');
+
+try {
+  await db.transaction({
+    transactionId: 'transfer-42',
+    preconditions: [
+      { collection: 'accounts', id: 'primary', ifVersion: current.__version },
+    ],
+    operations: [
+      { collection: 'accounts', id: 'primary', value: { balance: 90 } },
+      { collection: 'ledger', id: 'transfer-42', requireAbsent: true, value: { amount: 10 } },
+    ],
+  });
+} catch (error) {
+  if (error instanceof ConditionalConflictError) {
+    console.log(error.conflict);
+  }
+}
+```
+
+Reusing a successful `transactionId` safely replays its result without
+advancing record versions twice. This API requires a FeltDB authority that
+supports transaction-level `ifVersion` preconditions.
+
 ## Durable Operation Management
 
 FeltDB provides atomic operation admission and lifecycle management for systems that need to survive process crashes with guaranteed identity stability.

package/dist/agent-registry.js

@@ -8,9 +8,7 @@
  * Registry for agent definitions and discovery
  */
 export class AgentRegistry {
-    constructor() {
-        this.agents = new Map();
-    }
+    agents = new Map();
     /**
      * Register an agent definition
      */

package/dist/agent-runtime.js

@@ -9,10 +9,8 @@ import { AgentExecutionStatus, generateExecutionId } from './agent.js';
  * Agent ownership manager for distributed execution
  */
 export class AgentOwnershipManager {
-    constructor() {
-        this.ownership = new Map(); // executionId -> peerId
-        this.locks = new Map();
-    }
+    ownership = new Map(); // executionId -> peerId
+    locks = new Map();
     /**
      * Claim ownership of an execution
      */
@@ -86,10 +84,13 @@ export class AgentOwnershipManager {
  * Manages agent lifecycle and execution across the distributed fabric.
  */
 export class AgentRuntime {
+    config;
+    registry;
+    handlers = new Map();
+    executions = new Map();
+    ownership;
+    triggers = new Map();
     constructor(registry, config) {
-        this.handlers = new Map();
-        this.executions = new Map();
-        this.triggers = new Map();
         this.registry = registry;
         this.config = config;
         this.ownership = new AgentOwnershipManager();

package/dist/analytics-backend.js

@@ -10,8 +10,9 @@ import { IndexAnalytics as TypeScriptIndexAnalytics } from './index-analytics.js
  * Analytics backend selector with dynamic WASM loading
  */
 export class AnalyticsBackend {
+    backend;
+    wasmLoaded = false;
     constructor() {
-        this.wasmLoaded = false;
         // Start with TypeScript backend, attempt WASM load async
         // Create a wrapper that implements the interface
         const tsBackend = new TypeScriptIndexAnalytics();
@@ -76,6 +77,7 @@ export class AnalyticsBackend {
  * Adapter to bridge WASM analytics to TypeScript interface
  */
 class WasmAnalyticsAdapter {
+    wasm;
     constructor(wasm) {
         this.wasm = wasm;
     }

package/dist/application-contract.js

@@ -1,4 +1,5 @@
 export class ApplicationContractClient {
+    request;
     constructor(request) {
         this.request = request;
     }

package/dist/application-manifest.js

@@ -1,4 +1,5 @@
 export class ApplicationManifestClient {
+    baseUrl;
     constructor(baseUrl = '') {
         this.baseUrl = baseUrl;
     }

package/dist/artifact.js

@@ -1,4 +1,6 @@
 export class ArtifactClient {
+    baseUrl;
+    fetcher;
     constructor(baseUrl = '', fetcher = fetch) {
         this.baseUrl = baseUrl;
         this.fetcher = fetcher;

package/dist/authorization.js

@@ -1,4 +1,6 @@
 export class AuthorizationClient {
+    baseUrl;
+    fetcher;
     constructor(baseUrl = '', fetcher = fetch) {
         this.baseUrl = baseUrl;
         this.fetcher = fetcher;

package/dist/bundle.js

@@ -1,4 +1,6 @@
 export class BundleClient {
+    baseUrl;
+    fetcher;
     constructor(baseUrl = '', fetcher = fetch) {
         this.baseUrl = baseUrl;
         this.fetcher = fetcher;

package/dist/capability.js

@@ -4,9 +4,7 @@
  * Capabilities are distributed, pluggable features like search, vector embeddings, etc.
  */
 export class CapabilityRegistry {
-    constructor() {
-        this.capabilities = new Map();
-    }
+    capabilities = new Map();
     register(capability) {
         this.capabilities.set(capability.id, capability);
     }

package/dist/cell.js

@@ -16,11 +16,16 @@ export const AUTHORITY_CONFLICT = Symbol('FELTDB_AUTHORITY_CONFLICT');
  * A replica is read-only: replication transfers knowledge, not authority.
  */
 export class CellImpl {
+    id;
+    jsDb;
+    cellCollection;
+    replicaCollection;
+    failureObservationCollection;
+    mutationQueue = [];
+    isLocked = false;
+    changeHandlers = [];
+    isReplica = false;
     constructor(jsDb, cellId) {
-        this.mutationQueue = [];
-        this.isLocked = false;
-        this.changeHandlers = [];
-        this.isReplica = false;
         this.id = cellId;
         this.jsDb = jsDb;
         this.cellCollection = new Collection(jsDb, '_cells', undefined, undefined, false);

package/dist/cli/commands.js

@@ -719,7 +719,14 @@ async function handleDev(args) {
         throw error;
     }
     let stopping = null;
+    // The development session runs until something stops it — a signal, a managed
+    // application exiting, or a failure. Its lifetime belongs to this command, so
+    // it is represented explicitly rather than borrowed from whichever service
+    // happens to be long-running.
+    let releaseSession = () => { };
+    const sessionStopped = new Promise(resolve => { releaseSession = resolve; });
     const stopAll = () => stopping ?? (stopping = (async () => {
+        releaseSession();
         if (developmentSession && developmentSession.state !== 'STOPPING' && developmentSession.state !== 'STOPPED') {
             transitionDevelopmentSession(developmentSession, 'STOPPING');
         }
@@ -830,13 +837,30 @@ async function handleDev(args) {
             }
             transitionDevelopmentSession(developmentSession, 'RUNNING');
         });
+        // Studio is one service in the session, not the session itself.
+        // `handleStudio` returns immediately when Studio's static assets are absent,
+        // and awaiting it as the session's lifetime meant a missing optional
+        // artifact tore down the authority, the pairing discovery server, and the
+        // workspace transport: the process printed "workspace is ready" and then
+        // exited, so anything reaching for the discovery endpoint afterwards got a
+        // connection failure. The session now outlives Studio either way.
+        void studio.then(() => {
+            if (!developmentSession || developmentSession.state === 'RUNNING')
+                return;
+            console.log('\u26a0\ufe0f  Studio is unavailable for this session. The authority, pairing discovery, and workspace transport are unaffected.');
+            transitionDevelopmentSession(developmentSession, 'READY');
+            console.log(`\n${developmentSessionSummary(developmentSession)}\n`);
+            transitionDevelopmentSession(developmentSession, 'RUNNING');
+        }).catch(error => {
+            console.error(`Studio failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
         if (managedApplication) {
-            await Promise.race([studio, managedApplication.exited.then(exit => {
+            await Promise.race([sessionStopped, managedApplication.exited.then(exit => {
                     throw new Error(`Managed application stopped during the development session (command: ${managedApplication.command}; exit: ${exit.code ?? exit.signal})`);
                 })]);
         }
         else
-            await studio;
+            await sessionStopped;
     }
     finally {
         await stopAll();

package/dist/cli/index.js

@@ -23,7 +23,7 @@ import * as path from 'path';
 import * as readline from 'readline';
 import { getClient } from './api-client.js';
 import { loadFeltDBConfig, createDefaultConfig, validateModel, } from './config.js';
-const VERSION = '0.6.13';
+const VERSION = '0.6.14';
 function prompt(question) {
     const rl = readline.createInterface({
         input: process.stdin,

package/dist/collection.js

@@ -18,38 +18,42 @@ import { IndexStore } from './index-store.js';
  * Uses reactive dependency graph instead of polling for efficient updates.
  */
 export class Collection {
+    db;
+    name;
+    collectionId; // Unique ID for this collection instance
+    predicate = null;
+    cache = [];
+    subscribers = new Set();
+    parent = null;
+    parentId = null;
+    isInitialized = false;
+    unsubscribeFunctions = new Set();
+    graphUnsubscribe = null;
+    runtimeUnsubscribe = null;
+    indexBackend = new IndexBackend();
+    indexStore;
+    indexesLoaded = false;
+    /** Incremented whenever `cache` is replaced, so the index can tell it is stale. */
+    cacheGeneration = 0;
+    /** The cache generation the index entries currently reflect, or -1 for none. */
+    indexedGeneration = -1;
+    lastPlan = null;
+    /** Cache records addressed by id, valid for `indexedGeneration`. */
+    recordsById = null;
+    /** Raw payload the cache was parsed from, used to detect that nothing changed. */
+    lastRawSnapshot = null;
+    /**
+     * The runtime revision the cache was built from, when the runtime offers one.
+     *
+     * Captured *before* the query that produced the cache, never after. A write
+     * landing between the two then makes this older than the data it labels,
+     * which costs one unnecessary refresh. Capturing it after would make it
+     * newer than the data, and the cache would look current forever.
+     */
+    cachedRevision = null;
+    /** How the last refresh decided the cache was usable. Reporting only. */
+    lastFreshness = null;
     constructor(db, name, predicate, parent, loadIndexes = true) {
-        this.predicate = null;
-        this.cache = [];
-        this.subscribers = new Set();
-        this.parent = null;
-        this.parentId = null;
-        this.isInitialized = false;
-        this.unsubscribeFunctions = new Set();
-        this.graphUnsubscribe = null;
-        this.runtimeUnsubscribe = null;
-        this.indexBackend = new IndexBackend();
-        this.indexesLoaded = false;
-        /** Incremented whenever `cache` is replaced, so the index can tell it is stale. */
-        this.cacheGeneration = 0;
-        /** The cache generation the index entries currently reflect, or -1 for none. */
-        this.indexedGeneration = -1;
-        this.lastPlan = null;
-        /** Cache records addressed by id, valid for `indexedGeneration`. */
-        this.recordsById = null;
-        /** Raw payload the cache was parsed from, used to detect that nothing changed. */
-        this.lastRawSnapshot = null;
-        /**
-         * The runtime revision the cache was built from, when the runtime offers one.
-         *
-         * Captured *before* the query that produced the cache, never after. A write
-         * landing between the two then makes this older than the data it labels,
-         * which costs one unnecessary refresh. Capturing it after would make it
-         * newer than the data, and the cache would look current forever.
-         */
-        this.cachedRevision = null;
-        /** How the last refresh decided the cache was usable. Reporting only. */
-        this.lastFreshness = null;
         this.db = db;
         this.name = name;
         this.collectionId = `${name}-${Math.random().toString(36).substr(2, 9)}`;
@@ -690,6 +694,10 @@ export class Collection {
  * Relationship helper for loading related data.
  */
 export class Relationship {
+    parentDb;
+    childDb;
+    childCollection;
+    foreignKey;
     constructor(parentDb, childDb, childCollection, foreignKey) {
         this.parentDb = parentDb;
         this.childDb = childDb;

package/dist/create/package-versions.js

@@ -1,4 +1,4 @@
 // One release train keeps generated applications installable. The repository
 // validation script checks these values against every workspace manifest.
-export const FELTDB_PACKAGE_VERSION = '0.6.13';
+export const FELTDB_PACKAGE_VERSION = '0.6.14';
 export const feltdbPackageRange = `^${FELTDB_PACKAGE_VERSION}`;