@feltdb/core 0.10.0 → 0.11.1

package/dist/cli/commands.js

@@ -9,7 +9,7 @@ import { createRequire } from 'node:module';
 import { spawn, spawnSync } from 'child_process';
 import { randomBytes } from 'crypto';
 import { createInterface } from 'node:readline/promises';
-import { createFeltDB, diffFlowSpec, formatFlowSpec, InvestigationLifecycleManager, listFeltDBModules, parseFlowSpec, planFlowSpecMigration, renderConvergenceDiagnostic, renderProposalDiagnostic, resolveFeltDBModule, resolveModuleIntent, startLocalDevelopmentAuthority, validateFlowSpec, verifyProposalConvergence } from '@feltdb/core';
+import { createFeltDB, diffFlowSpec, emptyFlowSpec, formatFlowSpec, InvestigationLifecycleManager, listFeltDBModules, parseFlowSpec, planFlowSpecMigration, renderConvergenceDiagnostic, renderProposalDiagnostic, resolveFeltDBModule, resolveModuleIntent, startLocalDevelopmentAuthority, validateFlowSpec, verifyProposalConvergence } from '@feltdb/core';
 import { collectApplicationUnderstanding } from '@feltdb/core';
 import { collectRepositoryEvidence } from './repository-evidence.js';
 import { discoverWorkspace, ensureWorkspaceGitIgnored, generatePairingToken, persistPairingToken, displayWorkspaceStatus, initializeWorkspace, startPairingDiscoveryServer } from './workspace-integration.js';
@@ -24,6 +24,7 @@ import { proposalService } from './proposal-client.js';
 import { resolveManagedAuthorityEnvironment } from './managed-environment.js';
 import { readManagedProjectState } from './managed-project.js';
 import { resolveCanonicalStudioArtifact } from './studio-artifact.js';
+import { configureManagedAccount, finalizeManagedProvisioning } from '../create/index.js';
 function loadProjectEnvironment(file = path.resolve('.env.local')) {
     if (!fs.existsSync(file))
         return;
@@ -61,6 +62,8 @@ export async function handleCommand(command, args) {
             return handleServer(args);
         case 'keys':
             return handleKeys(args);
+        case 'init-managed':
+            return handleInitManaged(args);
         case 'connect':
             return handleConnect(args);
         case 'status':
@@ -864,6 +867,155 @@ async function handleConnect(args) {
     console.log(`Health:       ${health.status || 'healthy'}\n`);
     console.log('Use: feltdb status  (to check connection)\n');
 }
+async function promptSecret(message) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return '';
+    const input = process.stdin;
+    const output = process.stdout;
+    const wasRaw = input.isRaw;
+    const readline = await import('node:readline');
+    readline.emitKeypressEvents(input);
+    input.setRawMode(true);
+    input.resume();
+    output.write(message);
+    return new Promise(resolve => {
+        let value = '';
+        const finish = () => {
+            input.off('keypress', onKeypress);
+            input.setRawMode(Boolean(wasRaw));
+            input.pause();
+            output.write('\n');
+            resolve(value);
+        };
+        const onKeypress = (character, key) => {
+            if (key.ctrl && key.name === 'c')
+                process.exit(130);
+            if (key.name === 'return' || key.name === 'enter')
+                return finish();
+            if (key.name === 'backspace') {
+                value = value.slice(0, -1);
+                return;
+            }
+            if (!key.ctrl && !key.meta && character)
+                value += character;
+        };
+        input.on('keypress', onKeypress);
+    });
+}
+export function ensureManagedProjectContract(projectDir) {
+    const projectName = path.basename(projectDir);
+    const flowApp = projectName.replace(/[^A-Za-z0-9_]/g, '_').replace(/^[^A-Za-z_]/, '_$&');
+    const configPath = path.join(projectDir, 'feltdb.config.json');
+    const flowPath = path.join(projectDir, 'feltdb.flow');
+    const created = { config: false, flow: false };
+    if (!fs.existsSync(configPath)) {
+        fs.writeFileSync(configPath, `${JSON.stringify({
+            namespace: projectName,
+            mode: 'remote',
+            runtime: 'managed',
+            storage: 'managed',
+            application: { lifecycle: 'managed' },
+        }, null, 2)}\n`);
+        created.config = true;
+    }
+    if (!fs.existsSync(flowPath)) {
+        const draft = formatFlowSpec(emptyFlowSpec(flowApp)).replace(/\n\napp /, '\n\n// Recovery draft: define the application contract before publishing.\napp ');
+        fs.writeFileSync(flowPath, draft);
+        created.flow = true;
+    }
+    return { ...created, configPath, flowPath };
+}
+async function handleInitManaged(args) {
+    loadProjectEnvironment();
+    const projectDir = process.cwd();
+    const initialized = ensureManagedProjectContract(projectDir);
+    if (initialized.config)
+        console.log('✓ Created feltdb.config.json');
+    if (initialized.flow) {
+        console.log('⚠️  feltdb.flow was missing; created an empty recovery draft.');
+        console.log('   FeltDB cannot infer the application authority from source code.');
+        console.log('   Review and complete feltdb.flow before publishing.\n');
+    }
+    // Check if already managed
+    const managedState = readManagedProjectState(projectDir);
+    if (managedState.applicationId) {
+        console.log('✅ This project is already configured for managed FeltDB\n');
+        console.log(`Application: ${managedState.applicationId}`);
+        console.log(`Namespace:   ${managedState.namespace}`);
+        console.log(`URL:         ${managedState.url}`);
+        if (managedState.revisionId) {
+            console.log(`Revision:    ${managedState.revisionId}`);
+        }
+        console.log('\nTo publish the local authority contract, run:');
+        console.log('  feltdb publish --approve-destructive-changes --yes\n');
+        return;
+    }
+    // Prompt for credentials
+    console.log('☁️  Setting up managed FeltDB for this project\n');
+    const prompt = await import('node:readline/promises').then(m => m.createInterface({ input: process.stdin, output: process.stdout }));
+    const email = args[0] || await prompt.question('Email: ');
+    if (!email)
+        throw new Error('Email is required');
+    const password = args[1] || await promptSecret('Password (8+ characters): ');
+    if (password.length < 8)
+        throw new Error('Password must be at least 8 characters');
+    prompt.close();
+    console.log('\nProvisioning managed account...\n');
+    try {
+        const projectConfig = JSON.parse(fs.readFileSync(initialized.configPath, 'utf8'));
+        const namespace = projectConfig.namespace || path.basename(projectDir);
+        const applicationName = projectConfig.name || path.basename(projectDir);
+        const managed = await configureManagedAccount({
+            projectDir,
+            applicationName,
+            namespace,
+            email,
+            password,
+        });
+        console.log(`✓ Managed application: ${managed.application.name}`);
+        console.log(`✓ Namespace: ${managed.application.namespace || namespace}`);
+        console.log(`✓ Environment configured in .env.local\n`);
+        if (initialized.flow) {
+            console.log('✅ Managed connection setup complete.');
+            console.log('Automatic publication was skipped because feltdb.flow had to be recovered.');
+            console.log('Review feltdb.flow, then run:');
+            console.log('  feltdb validate');
+            console.log('  feltdb publish --approve-destructive-changes --yes\n');
+            return;
+        }
+        // Ask if user wants to publish the initial revision
+        const publishPrompt = await import('node:readline/promises').then(m => m.createInterface({ input: process.stdin, output: process.stdout }));
+        const shouldPublish = await publishPrompt.question('Publish initial application revision now? [Y/n] ');
+        publishPrompt.close();
+        if (!/^(n|no)$/i.test(shouldPublish.trim())) {
+            console.log('\n🔨 Building and publishing initial revision...\n');
+            await publishApplication({
+                cwd: projectDir,
+                yes: true,
+                approveDestructive: true,
+            });
+            console.log('\n✓ Initial revision published\n');
+            // Finalize and verify
+            try {
+                const finalized = await finalizeManagedProvisioning({ projectDir });
+                console.log(`✓ Managed runtime verified at revision ${finalized.revisionId}\n`);
+            }
+            catch (error) {
+                console.log('⚠️  Revision published but verification skipped.\n');
+                console.log('Your application is ready to use. Run: npm run dev\n');
+            }
+        }
+        else {
+            console.log('\n✅ Managed setup complete!\n');
+            console.log('Next steps:');
+            console.log('  1. feltdb publish --approve-destructive-changes --yes (to publish your initial revision)');
+            console.log('  2. npm run dev (to start development)\n');
+        }
+    }
+    catch (error) {
+        throw error;
+    }
+}
 async function handleExplain(args) {
     const flowRef = args[0];
     if (!flowRef || !flowRef.startsWith('flow://')) {
@@ -2017,6 +2169,7 @@ Commands:
   diff [file]           Diff FlowSpec against the last deployed model
   deploy [file]         Validate, version, and deploy FlowSpec
   publish [file]        Build and publish/update a managed application
+  init-managed          Set up managed FeltDB for an existing project
   ai                    Open the canonical interactive local-AI workflow
   ai --dry-run          Open an ephemeral preview-only AI session
   ai model show         Show the selected local or user-provided model
@@ -2066,7 +2219,15 @@ API Key Commands:
   feltdb keys revoke <key-id>
 
 Connection:
-  feltdb connect <url>
+  feltdb connect <url>                    Connect to a running FeltDB server
+
+Managed FeltDB Setup (Existing Projects):
+  feltdb init-managed                     Set up managed FeltDB for an existing project
+                                          Prompts for email and password, provisions resources,
+                                          and optionally publishes the initial revision
+  feltdb init-managed <email> <password>  Non-interactive setup with provided credentials
+
+Development:
   dev         Start development server
   build       Build FeltDB application
   check       Validate configuration
@@ -2100,6 +2261,8 @@ Examples:
   feltdb studio --connect http://localhost:7700
   feltdb server --port 7700 --data ./data
   feltdb keys create --name development
+  feltdb init-managed                     (interactive - prompts for email/password)
+  feltdb init-managed user@example.com secret123
   feltdb connect http://localhost:7700
   feltdb status
   feltdb dev

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.8.0';
+const VERSION = '0.9.0';
 function prompt(question) {
     const rl = readline.createInterface({
         input: process.stdin,

package/dist/collection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../src/collection.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAIL,KAAK,mBAAmB,EACxB,KAAK,QAAQ,EACd,MAAM,gBAAgB,CAAC;AAKxB,OAAO,KAAK,EAAE,WAAW,EAAc,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAErF,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC;AAChD,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC;AAiBjD;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,gGAAgG;IAChG,UAAU,EAAE,UAAU,GAAG,SAAS,CAAC;IACnC,4EAA4E;IAC5E,eAAe,EAAE,OAAO,CAAC;IACzB,oEAAoE;IACpE,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,mCAAmC;IACnC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,qBAAqB,CAAC,CAAC;IACtC,mCAAmC;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,iEAAiE;IACjE,IAAI,CAAC,EAAE,CAAC,GAAG;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IACjC,+DAA+D;IAC/D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,wDAAwD;IACxD,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;GAKG;AACH,qBAAa,UAAU,CAAC,CAAC;IACvB,OAAO,CAAC,EAAE,CAAO;IACjB,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,SAAS,CAA6B;IAC9C,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,WAAW,CAAiC;IACpD,OAAO,CAAC,MAAM,CAA8B;IAC5C,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,oBAAoB,CAA8B;IAC1D,OAAO,CAAC,gBAAgB,CAA6B;IACrD,OAAO,CAAC,kBAAkB,CAA6B;IACvD,OAAO,CAAC,YAAY,CAAoC;IACxD,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,aAAa,CAAS;IAC9B,mFAAmF;IACnF,OAAO,CAAC,eAAe,CAAK;IAC5B,gFAAgF;IAChF,OAAO,CAAC,iBAAiB,CAAM;IAC/B,OAAO,CAAC,QAAQ,CAAoC;IACpD,oEAAoE;IACpE,OAAO,CAAC,WAAW,CAA+B;IAClD,kFAAkF;IAClF,OAAO,CAAC,eAAe,CAAuB;IAC9C;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc,CAAyB;IAC/C,yEAAyE;IACzE,OAAO,CAAC,aAAa,CAA+B;gBAExC,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,WAAW,UAAO;IAoBxG;;OAEG;YACW,oBAAoB;IAalC;;;OAGG;IACG,GAAG,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC;IAKzB,qEAAqE;IAC/D,IAAI,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC;IAI1B;;;;;;;;;;;;;OAaG;IACG,IAAI,CAAC,KAAK,GAAE,OAAO,CAAC,CAAC,CAAM,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAoEhD,6EAA6E;IACvE,KAAK,CAAC,KAAK,GAAE,OAAO,CAAC,CAAC,CAAM,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAIjD;;;;;OAKG;IACH,aAAa,IAAI,mBAAmB,GAAG,IAAI;IAI3C,wEAAwE;IACxE,OAAO,CAAC,QAAQ;IAWhB;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAiBvB;;;;;;OAMG;IACH,OAAO,CAAC,wBAAwB;IA0BhC;;;;;OAKG;IACH,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;IAWtC;;OAEG;IACH,WAAW,IAAI,WAAW,EAAE;IAI5B;;;OAGG;IACG,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAYrC;;OAEG;IACG,eAAe,IAAI,OAAO,CAAC,OAAO,CAAC;IAazC;;OAEG;IACG,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAYjD;;;OAGG;IACH,KAAK,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;IAO7C;;;OAGG;IACG,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA4BrE,qEAAqE;IAC/D,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIlE;;OAEG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IA+BrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACG,eAAe,CACnB,EAAE,EAAE,MAAM,GAAG,MAAM,EACnB,eAAe,EAAE,MAAM,EACvB,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,aAAa,CAAC,EAAE,MAAM,EACtB,eAAe,CAAC,EAAE,MAAM,EACxB,gBAAgB,CAAC,EAAE,OAAO,EAC1B,YAAY,CAAC,EAAE,CAAC,GACf,OAAO,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC;IA2EpC;;OAEG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA2BhD;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;IAK9B;;OAEG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAKnD;;;;;;OAMG;IACH,OAAO,CAAC,SAAS;IAKjB;;;;;;;;OAQG;YACW,6BAA6B;IAkC3C;;;;;OAKG;YACW,iCAAiC;IAyE/C;;;;;;;;;;;;;OAaG;IACG,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;QAAE,QAAQ,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,CAAC,CAAA;KAAE,CAAC;IAsClG;;;OAGG;IACH,SAAS,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,IAAI;IA6CxE,mEAAmE;IACnE,KAAK,IAAI,IAAI;IASb;;;;;;;;;;;OAWG;IACH,SAAS,IAAI,OAAO,CAAC,mBAAmB,CAAC;IAIzC;;;;;;OAMG;IACH,kBAAkB,IAAI,cAAc,GAAG,IAAI;IAI3C;;;;;;;;;OASG;YACW,eAAe;IAQ7B;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CA2E/B;AAED;;GAEG;AACH,qBAAa,YAAY,CAAC,MAAM,EAAE,KAAK;IACrC,OAAO,CAAC,QAAQ,CAAO;IACvB,OAAO,CAAC,OAAO,CAAO;IACtB,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,UAAU,CAAoC;gBAGpD,QAAQ,EAAE,IAAI,EACd,OAAO,EAAE,IAAI,EACb,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,GAAG,MAAM;IAQ/C;;OAEG;IACG,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;CAoBxD"}
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../src/collection.ts"],"names":[],"mappings":"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"}

package/dist/collection.js

@@ -484,10 +484,12 @@ export class Collection {
                 conflictCode: casResult.conflictCode,
             };
         }
-        // Use the item returned by cas() which has the correct incremented version
-        const finalItem = (casResult.item || updated);
-        // CAS operation on backend increments version atomically - update finalItem to match
-        finalItem.__version = casResult.currentVersion;
+        // Use the item returned by cas() if available (file-db, memory-db), otherwise use local copy
+        // When cas() returns the item, it's the authoritative post-commit state from the backend.
+        // When it doesn't, we reconstruct from our local updated object and the returned version.
+        const finalItem = casResult.item
+            ? casResult.item
+            : { ...updated, __version: casResult.currentVersion };
         // Update indexes
         this.indexBackend.updateRecord(String(id), current, finalItem);
         // Emit change through reactive dependency graph

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.10.0';
+export const FELTDB_PACKAGE_VERSION = '0.11.1';
 export const feltdbPackageRange = `^${FELTDB_PACKAGE_VERSION}`;

package/dist/create/server-source/crates/feltdb/src/lib.rs

@@ -287,12 +287,12 @@ use std::any::type_name;
 use std::collections::hash_map::DefaultHasher;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, VecDeque};
 use std::fmt::{Display, Formatter};
-use std::fs::{self, OpenOptions};
+use std::fs::{self, File, OpenOptions};
 use std::hash::{Hash, Hasher};
 use std::io::{BufRead, BufReader, Write};
 use std::ops::Bound::{Excluded, Unbounded};
 use std::path::{Path, PathBuf};
-use std::sync::{Arc, Mutex};
+use std::sync::{Arc, Mutex, OnceLock, Weak};
 use std::time::{SystemTime, UNIX_EPOCH};
 use tokio::sync::broadcast;
 
@@ -369,8 +369,17 @@ impl From<String> for FlowError {
 pub struct FeltDb {
     inner: Arc<Mutex<Inner>>,
     event_tx: broadcast::Sender<ChangeEvent>,
+    _ownership: Arc<File>,
 }
 
+struct OpenDatabase {
+    inner: Weak<Mutex<Inner>>,
+    event_tx: broadcast::Sender<ChangeEvent>,
+    ownership: Weak<File>,
+}
+
+static OPEN_DATABASES: OnceLock<Mutex<HashMap<PathBuf, OpenDatabase>>> = OnceLock::new();
+
 #[derive(Default)]
 #[allow(dead_code)] // Reserved runtime subsystems are initialized before their public APIs land.
 struct Inner {
@@ -1968,7 +1977,56 @@ struct RetentionRecord {
 
 impl FeltDb {
     pub fn open<P: AsRef<Path>>(path: P) -> Result<Self> {
-        let path = path.as_ref().to_path_buf();
+        let requested_path = path.as_ref();
+        let parent = requested_path
+            .parent()
+            .filter(|parent| !parent.as_os_str().is_empty())
+            .unwrap_or_else(|| Path::new("."));
+        fs::create_dir_all(parent)?;
+        let path = if requested_path.exists() {
+            fs::canonicalize(requested_path)?
+        } else {
+            let file_name = requested_path.file_name().ok_or_else(|| {
+                std::io::Error::new(
+                    std::io::ErrorKind::InvalidInput,
+                    "FeltDB database path has no file name",
+                )
+            })?;
+            fs::canonicalize(parent)?.join(file_name)
+        };
+
+        let databases = OPEN_DATABASES.get_or_init(|| Mutex::new(HashMap::new()));
+        let mut databases = databases.lock().expect("open database registry poisoned");
+        if let Some(open) = databases.get(&path) {
+            if let (Some(inner), Some(ownership)) =
+                (open.inner.upgrade(), open.ownership.upgrade())
+            {
+                return Ok(Self {
+                    inner,
+                    event_tx: open.event_tx.clone(),
+                    _ownership: ownership,
+                });
+            }
+        }
+        databases.remove(&path);
+
+        let mut ownership_path = path.as_os_str().to_os_string();
+        ownership_path.push(".lock");
+        let ownership = OpenOptions::new()
+            .create(true)
+            .read(true)
+            .write(true)
+            .open(PathBuf::from(ownership_path))?;
+        ownership.try_lock().map_err(|error| match error {
+            std::fs::TryLockError::WouldBlock => std::io::Error::new(
+                std::io::ErrorKind::WouldBlock,
+                format!(
+                    "FeltDB database {} is already owned by another process",
+                    path.display()
+                ),
+            ),
+            std::fs::TryLockError::Error(error) => error,
+        })?;
 
         // Fail closed. The format is decided before any record is interpreted
         // and before anything is written, so a database this build does not
@@ -1981,9 +2039,6 @@ impl FeltDb {
             FormatCompatibility::Compatible(format) => format,
         };
 
-        if let Some(parent) = path.parent() {
-            fs::create_dir_all(parent)?;
-        }
         if !path.exists() {
             let mut file = OpenOptions::new().create(true).append(true).open(&path)?;
             // A new database states its format in its first record, so it never
@@ -2019,10 +2074,20 @@ impl FeltDb {
 
         let (event_tx, _) = broadcast::channel(1024);
 
-        Ok(Self {
+        let database = Self {
             inner: Arc::new(Mutex::new(inner)),
             event_tx,
-        })
+            _ownership: Arc::new(ownership),
+        };
+        databases.insert(
+            path,
+            OpenDatabase {
+                inner: Arc::downgrade(&database.inner),
+                event_tx: database.event_tx.clone(),
+                ownership: Arc::downgrade(&database._ownership),
+            },
+        );
+        Ok(database)
     }
 
     /// Write a self-contained durable backup artifact.
@@ -2264,10 +2329,21 @@ impl FeltDb {
             .map(|(cap, _)| cap)
             .unwrap_or("default")
             .to_string();
-        self.insert_internal(capability, key.to_string(), value)?;
+        self.insert_internal(capability, key.to_string(), value, false)?;
         Ok(())
     }
 
+    /// Insert only if the logical record is absent, deciding presence under the
+    /// same lock that appends the operation and mints its first revision.
+    pub fn insert_if_absent<T: Serialize>(&self, key: &str, value: T) -> Result<()> {
+        let capability = key
+            .split_once(':')
+            .map(|(cap, _)| cap)
+            .unwrap_or("default")
+            .to_string();
+        self.insert_internal(capability, key.to_string(), value, true)
+    }
+
     /// Update an existing record with vector clock tracking
     pub fn update<T: Serialize>(&self, key: &str, value: T) -> Result<()> {
         let capability = key
@@ -2480,7 +2556,7 @@ impl FeltDb {
         }
 
         // Authorized: apply mutation
-        self.insert_internal(capability, key.to_string(), value)?;
+        self.insert_internal(capability, key.to_string(), value, false)?;
         Ok(())
     }
 
@@ -3195,6 +3271,7 @@ impl FeltDb {
         capability: String,
         key: String,
         value: T,
+        require_absent: bool,
     ) -> Result<()> {
         let rust_type = type_name::<T>().to_string();
         let value_json = serde_json::to_value(value)?;
@@ -3216,6 +3293,21 @@ impl FeltDb {
         {
             let mut inner = self.state();
 
+            if require_absent
+                && inner
+                    .rows
+                    .get(&capability)
+                    .and_then(|bucket| bucket.get(&key))
+                    .is_some()
+            {
+                return Err(FlowError::PreconditionFailed(Box::new(
+                    PreconditionFailure::Present {
+                        collection: capability,
+                        key,
+                    },
+                )));
+            }
+
             // Increment sequence number
             inner.sequence += 1;
 
@@ -4497,7 +4589,7 @@ impl Capability {
             key
         };
         self.db
-            .insert_internal(self.name.clone(), key.clone(), value)?;
+            .insert_internal(self.name.clone(), key.clone(), value, false)?;
         Ok(key)
     }
 
@@ -4507,7 +4599,8 @@ impl Capability {
         } else {
             format!("{}:{key}", self.name)
         };
-        self.db.insert_internal(self.name.clone(), full_key, value)
+        self.db
+            .insert_internal(self.name.clone(), full_key, value, false)
     }
 
     pub fn update<T: Serialize>(&self, key: &str, value: T) -> Result<()> {

package/dist/create/server-source/crates/feltdb/tests/local_process_ownership.rs

@@ -0,0 +1,69 @@
+use std::process::Command;
+
+use feltdb::{AtomicMutation, FeltDb};
+use serde_json::json;
+use tempfile::TempDir;
+
+const CHILD_ENV: &str = "FELTDB_OWNERSHIP_CHILD";
+const PATH_ENV: &str = "FELTDB_OWNERSHIP_PATH";
+const EXPECT_LOCKED_ENV: &str = "FELTDB_EXPECT_LOCKED";
+
+#[test]
+fn ownership_child() {
+    if std::env::var_os(CHILD_ENV).is_none() {
+        return;
+    }
+    let path = std::env::var(PATH_ENV).unwrap();
+    let expect_locked = std::env::var_os(EXPECT_LOCKED_ENV).is_some();
+    match FeltDb::open(path) {
+        Ok(database) => {
+            assert!(!expect_locked, "a second owner opened the database");
+            let mutation = AtomicMutation {
+                capability: "probe".into(),
+                key: "probe:child".into(),
+                value: Some(json!({ "owner": "child" })),
+            };
+            database
+                .apply_atomic_transaction("child", None, &[], &[mutation], None)
+                .unwrap();
+        }
+        Err(error) => {
+            assert!(expect_locked, "an unowned database failed to open: {error}");
+            assert!(error.to_string().contains("already owned"));
+        }
+    }
+}
+
+fn child(path: &std::path::Path, expect_locked: bool) -> std::process::ExitStatus {
+    let mut command = Command::new(std::env::current_exe().unwrap());
+    command
+        .arg("--exact")
+        .arg("ownership_child")
+        .arg("--nocapture")
+        .env(CHILD_ENV, "1")
+        .env(PATH_ENV, path);
+    if expect_locked {
+        command.env(EXPECT_LOCKED_ENV, "1");
+    }
+    command.status().unwrap()
+}
+
+#[test]
+fn another_process_cannot_read_write_or_transact_while_owned() {
+    let directory = TempDir::new().unwrap();
+    let path = directory.path().join("shared.db");
+    let _owner = FeltDb::open(&path).unwrap();
+    assert!(child(&path, true).success());
+}
+
+#[test]
+fn ownership_is_released_when_the_process_exits() {
+    let directory = TempDir::new().unwrap();
+    let path = directory.path().join("shared.db");
+    assert!(child(&path, false).success());
+    let database = FeltDb::open(path).unwrap();
+    assert_eq!(
+        database.get::<serde_json::Value>("probe:child").unwrap(),
+        Some(json!({ "owner": "child" }))
+    );
+}

package/dist/create/server-source/crates/feltdb/tests/revision_retention_boundary_evidence.rs

@@ -203,7 +203,7 @@ fn each_compaction_rewrites_the_whole_revision_history() {
 /// The compacted log is linear in both the revision count and the state size:
 ///
 /// ```text
-/// bytes = header + count × (fixed_overhead + 2 × |content|)
+/// bytes ≈ header + count × (fixed_overhead + 2 × |content|)
 /// ```
 ///
 /// The fixed part is not incidental — it is a 64-character hex identity, a
@@ -218,10 +218,11 @@ fn each_compaction_rewrites_the_whole_revision_history() {
 /// design.
 #[test]
 fn a_revision_costs_a_fixed_overhead_plus_one_copy_of_its_state() {
-    let small_ten = compacted_log_after_revisions(10, 0).len();
+    let small_ten_log = compacted_log_after_revisions(10, 0);
+    let small_ten = small_ten_log.len();
     let small_twenty = compacted_log_after_revisions(20, 0).len();
-    let padded_hundred = compacted_log_after_revisions(10, 100).len();
-    let padded_thousand = compacted_log_after_revisions(10, 1000).len();
+    let padded_hundred_log = compacted_log_after_revisions(10, 100);
+    let padded_thousand_log = compacted_log_after_revisions(10, 1000);
 
     // Ten more revisions of a 16-byte state cost ten more per-revision records.
     // Indices 10..19 are one digit wider than 0..9, hence the ten-byte term.
@@ -239,17 +240,31 @@ fn a_revision_costs_a_fixed_overhead_plus_one_copy_of_its_state() {
     );
 
     // Content is represented in both the revision and its canonical
-    // transaction attribution: growing each state by N bytes grows the log by
-    // exactly count × 2N.
+    // transaction attribution. Count those copies directly instead of
+    // requiring unrelated encoded metadata to have byte-for-byte identical
+    // size across platforms and runs.
     assert_eq!(
-        padded_hundred - small_ten,
-        10 * 2 * 100,
-        "state appears in the revision and canonical transaction attribution"
+        padded_hundred_log.matches("x".repeat(100).as_str()).count(),
+        10 * 2,
+        "each state appears in its revision and canonical transaction attribution"
     );
     assert_eq!(
-        padded_thousand - small_ten,
-        10 * 2 * 1000,
-        "the relationship stays exactly linear at a kilobyte of state"
+        padded_thousand_log
+            .matches("x".repeat(1000).as_str())
+            .count(),
+        10 * 2,
+        "the two-copy relationship remains direct at a kilobyte of state"
+    );
+
+    let hundred_growth = padded_hundred_log.len() - small_ten;
+    let thousand_growth = padded_thousand_log.len() - small_ten;
+    assert!(
+        hundred_growth.abs_diff(10 * 2 * 100) <= 100,
+        "the measured 100-byte content term was {hundred_growth} bytes"
+    );
+    assert!(
+        thousand_growth.abs_diff(10 * 2 * 1000) <= 1_000,
+        "the measured 1,000-byte content term was {thousand_growth} bytes"
     );
 }
 

package/dist/create/server-source/crates/feltdb-server/src/main.rs

@@ -13536,17 +13536,19 @@ async fn create_record(
         .take()
         .unwrap_or_else(|| state.ids.fetch_add(1, Ordering::Relaxed).to_string());
     let key = record_key(&collection, &id)?;
-    if state.db.get_value(&key)?.is_some() {
-        return Err(ApiError(
-            StatusCode::CONFLICT,
-            "record already exists".to_string(),
-        ));
-    }
     record
         .value
         .insert("id".to_string(), Value::String(id.clone()));
     let value = Value::Object(record.value);
-    state.db.insert(&key, &value)?;
+    state
+        .db
+        .insert_if_absent(&key, &value)
+        .map_err(|error| match error {
+            FlowError::PreconditionFailed(_) => {
+                ApiError(StatusCode::CONFLICT, "record already exists".to_string())
+            }
+            other => ApiError(StatusCode::CONFLICT, other.to_string()),
+        })?;
     Ok((
         StatusCode::CREATED,
         Json(RecordResponse {
@@ -14700,7 +14702,7 @@ async fn control_plane_record_provenance(
         "attribution": {
             "actor": transactions.first().and_then(|attribution| attribution.subject.clone()),
             "authority": row.operation.as_ref().map(|operation| operation.instance_id.clone()),
-            "source": if transactions.first().is_some() { "transaction" } else if row.operation.is_some() { "authority" } else { "unknown" },
+            "source": if capability == collection && row.operation.is_some() { "authority" } else if transactions.first().is_some() { "transaction" } else if row.operation.is_some() { "authority" } else { "unknown" },
         },
     })))
 }

package/dist/file-db.d.ts

@@ -29,6 +29,7 @@ export declare class FileJsDb implements JsDb {
     private readonly applied;
     constructor(path: string);
     private loadState;
+    private loadStateFromBackup;
     private initializeState;
     private restorePeers;
     private isStalelock;
@@ -112,6 +113,7 @@ export declare class FileJsDb implements JsDb {
         currentVersion: number;
         currentEpoch?: number;
         conflictCode?: string;
+        item?: any;
     }>;
     close(): void;
 }