@feltdb/core 0.12.2 → 0.15.0

package/dist/collection.js

@@ -129,7 +129,9 @@ export class Collection {
      * Returns cached results (live-updated).
      */
     async all() {
-        await this.refresh();
+        // A read the authority refused, or could not answer, is raised typed --
+        // never answered from whatever this handle last cached.
+        await this.refresh({ strict: true });
         return [...this.cache];
     }
     /** List records through the canonical application collection API. */
@@ -375,7 +377,7 @@ export class Collection {
         const key = `${this.name}:${id}`;
         const result = await this.db.get(key);
         if (!result.success) {
-            throw new Error(result.error || `Failed to read record ${id}`);
+            throw runtimeFailure(result, result.error || `Failed to read record ${id}`);
         }
         if (result.data) {
             return JSON.parse(result.data);
@@ -421,7 +423,7 @@ export class Collection {
             const stored = { ...data, id: recordId, __version: 1 };
             const result = await this.db.insert(key, JSON.stringify(stored));
             if (!result.success) {
-                throw new Error(`Insert failed: ${result.error}`);
+                throw runtimeFailure(result, `Insert failed: ${result.error}`);
             }
             await this.publish('insert', key, String(recordId), null, stored);
             return String(recordId);
@@ -614,9 +616,11 @@ export class Collection {
         const result = await this.db.delete(key);
         if (!result.success) {
             const message = `Delete failed: ${result.error}`;
-            throw /not found/i.test(String(result.error))
-                ? new FeltDBServiceError(message, FeltDBErrorCode.NOT_FOUND)
-                : new Error(message);
+            throw result.cause
+                ? runtimeFailure(result, message)
+                : /not found/i.test(String(result.error))
+                    ? new FeltDBServiceError(message, FeltDBErrorCode.NOT_FOUND)
+                    : new Error(message);
         }
         // Update indexes - find and remove the deleted record
         const deleted = await this.get(id);
@@ -686,7 +690,7 @@ export class Collection {
                 throw error;
             const existing = await this.db.get(key);
             if (!existing.success) {
-                throw new Error(existing.error || `could not read the record that won ${key}`);
+                throw runtimeFailure(existing, existing.error || `could not read the record that won ${key}`);
             }
             if (!existing.data) {
                 throw new Error(`${key} was created and then removed while resolving a conditional create`);
@@ -914,7 +918,7 @@ export class Collection {
     /**
      * Refresh data from the database and notify subscribers.
      */
-    async refresh() {
+    async refresh(options = {}) {
         try {
             // The revision is read *before* the query, so it can only ever be older
             // than the data it ends up labelling. The reverse ordering would let a
@@ -980,14 +984,32 @@ export class Collection {
                 }
             }
             else if (!result.success) {
+                if (options.strict)
+                    throw runtimeFailure(result, result.error || `Failed to read ${this.name}`);
                 console.error('Query failed:', result.error);
             }
         }
         catch (err) {
+            if (options.strict)
+                throw err;
             console.error('Refresh error:', err);
         }
     }
 }
+/**
+ * The error a failed runtime result is raised as. A remote runtime attaches
+ * the authority's typed refusal (`cause`): its stable code, status, request id
+ * and body travel on, so an unauthenticated, cross-application or interrupted
+ * operation is never a bare `Error` with the code only in its message.
+ */
+function runtimeFailure(result, message) {
+    const cause = result.cause;
+    if (!(cause instanceof FeltDBServiceError))
+        return new Error(message);
+    const error = new FeltDBServiceError(message, cause.code, cause.requestId, cause.status, cause.body);
+    error.cause = cause;
+    return error;
+}
 /**
  * Relationship helper for loading related data.
  */

package/dist/create/build-identity.json

@@ -1,13 +1,13 @@
 {
   "schema": "feltdb.build-identity.v2",
   "package": "create-feltdb",
-  "version": "0.12.2",
+  "version": "0.15.0",
   "git": {
-    "sha1": "7a632f5b3e79d800ff27359f7f1a7c081dc7cb69",
+    "sha1": "5ad54972a9e31a5459cadbb471428111624ec9c6",
     "dirty": false
   },
   "path_in_vcs": "tools/create-feltdb",
-  "source_digest": "sha256:9db516ed9702dde647cd8d9723e1d997be999a39ddebfcb337dc0c1d721c8110",
+  "source_digest": "sha256:01efc5737aae1fef37c976e5841df3bb9b615d034f31d27b038f7fd4ca202428",
   "inputs": [
     "Cargo.lock",
     "Cargo.toml",
@@ -20,7 +20,7 @@
     "tools/cli",
     "tools/create-feltdb"
   ],
-  "files": 770,
+  "files": 789,
   "build": {
     "command": "npm run build",
     "node": "v24.9.0"

package/dist/create/cli.js

@@ -11,15 +11,18 @@ import { spawn, spawnSync } from 'child_process';
 import { createProject } from './create.js';
 import { FELTDB_PACKAGE_VERSION } from './package-versions.js';
 import { configureManagedAccount, finalizeManagedProvisioning } from './managed-account.js';
+import { RUNTIME_CHOICES, agentsIncluded, describeSetup } from './setup-summary.js';
 import { localFeltdbExecutable } from './development-handoff.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 function parseArgs(args) {
     const options = {
         runtime: 'browser',
         framework: 'react',
-        distributed: true,
+        // Distribution and the browser AI builder add services and downloads a
+        // first project does not need; each is one flag away.
+        distributed: false,
         agents: true,
-        webllm: true,
+        webllm: false,
         capabilities: 'search',
     };
     for (let i = 0; i < args.length; i++) {
@@ -42,6 +45,9 @@ function parseArgs(args) {
             case '--framework':
                 options.framework = args[++i];
                 break;
+            case '--distributed':
+                options.distributed = true;
+                break;
             case '--no-distributed':
                 options.distributed = false;
                 break;
@@ -164,29 +170,28 @@ async function promptForOptions(defaults) {
         { label: 'Yes', value: true },
         { label: 'No', value: false },
     ];
-    return {
-        runtime: await select('Where should FeltDB run?', [
-            { label: 'Browser', value: 'browser', description: 'local-first with durable browser storage' },
-            { label: 'Node.js', value: 'node', description: 'application server or worker' },
-            { label: 'Self-hosted', value: 'self-hosted', description: 'dedicated FeltDB server' },
-            { label: 'Managed', value: 'managed', description: 'FeltDB-hosted persistence, sync, and workloads' },
-        ], defaults.runtime),
-        framework: await select('Choose an application framework:', [
-            { label: 'React', value: 'react' },
-            { label: 'Vanilla TypeScript', value: 'vanilla' },
-        ], defaults.framework),
-        distributed: await select('Enable distributed operation?', yesNo, defaults.distributed),
-        agents: await select('Include an autonomous agent example?', yesNo, defaults.agents),
-        webllm: await select('Install WebLLM for private natural-language app building?', [
-            { label: 'Yes', value: true, description: 'build FeltDB schemas, capabilities, workflows, and UI locally with AI' },
-            { label: 'No', value: false, description: 'skip the browser model and AI builder' },
-        ], defaults.webllm),
-        capabilities: await select('Choose starter capabilities:', [
+    const runtime = await select('Where does your application\'s data live?', RUNTIME_CHOICES.map(choice => ({ label: choice.label, value: choice.value, description: choice.summary })), defaults.runtime);
+    const framework = await select('Choose an application framework:', [
+        { label: 'React', value: 'react', description: 'a complete starter: sign-up, projects, invitations, activity, assistants' },
+        { label: 'Vanilla TypeScript', value: 'vanilla', description: 'a minimal page over the same database' },
+    ], defaults.framework);
+    // The React starter's assistants are part of its tour and need no model, so
+    // only the vanilla template asks; its capabilities are chosen here too.
+    const agents = framework === 'react' ? true
+        : await select('Include an agent example?', yesNo, defaults.agents);
+    const capabilities = framework === 'react' ? defaults.capabilities
+        : await select('Choose starter capabilities:', [
             { label: 'Search', value: 'search' },
             { label: 'Vector search', value: 'vector' },
             { label: 'Search + vector search', value: 'search,vector' },
-        ], defaults.capabilities),
-    };
+        ], defaults.capabilities);
+    const webllm = await select('Add the private AI app builder (WebLLM)?', [
+        { label: 'No', value: false, description: 'add it later with npm install @feltdb/webllm' },
+        { label: 'Yes', value: true, description: 'builds schemas and UI with a model that runs in your browser: a download of a few hundred MB on first use, and WebGPU' },
+    ], defaults.webllm);
+    // Distribution is a deployment decision, not a first-run one: `--distributed`
+    // records it, and development always runs one local authority.
+    return { runtime, framework, distributed: defaults.distributed, agents, webllm, capabilities };
 }
 async function main() {
     const args = process.argv.slice(2);
@@ -211,9 +216,9 @@ Deployment Target (Explicit):
                           Best for: Client-side apps, offline-first experiences
                           No server required, full offline capability
 
-  --server                Node.js server runtime with server-side FeltDB authority
-                          Best for: Server-side applications, API servers
-                          Requires production FeltDB instance or self-host
+  --server                Data lives in a FeltDB authority the application connects to
+                          Best for: shared state, server-side work, a path to self-hosting
+                          \`feltdb dev\` runs a local authority; deploy to feltdb-server
 
   --self-host             Dedicated FeltDB server with Docker Compose
                           Best for: Staging first, then explicit production promotion
@@ -221,7 +226,7 @@ Deployment Target (Explicit):
 
   --managed               Managed FeltDB runtime
                           Best for: Production without operating servers
-                          Requires VITE_FELTDB_URL and VITE_FELTDB_API_KEY
+                          Requires VITE_FELTDB_URL; server-side FELTDB_TOKEN only
 
 Options:
   --browser                Explicit: Browser runtime with IndexedDB
@@ -230,11 +235,15 @@ Options:
   --managed                Explicit: Managed FeltDB service
   --runtime <runtime>      Alternative: Set runtime (browser, node, self-hosted, managed)
   --framework <framework>  Choose framework: react or vanilla (default: react)
-  --no-distributed         Disable distributed operation
-  --no-agents              Exclude agent examples
-  --webllm                 Include the private natural-language FeltDB app builder (default)
-  --no-webllm              Do not install WebLLM or generate the AI builder
-  --capabilities <list>    Choose capabilities: search, vector, or search,vector
+  --distributed            Record that the application will be deployed to several
+                           feltdb-server nodes (development always runs one)
+  --no-distributed         Do not record distributed deployment (default)
+  --no-agents              Exclude the agent example (vanilla template; the React
+                           starter always includes its assistants)
+  --webllm                 Include the private natural-language app builder; downloads
+                           a model into the browser on first use and needs WebGPU
+  --no-webllm              Do not install WebLLM (default)
+  --capabilities <list>    Vanilla template capabilities: search, vector, or search,vector
   --no-install             Skip npm install
   --no-start               Skip automatic feltdb dev startup
   -y, --yes                Use all defaults (non-interactive mode)
@@ -294,13 +303,13 @@ Learn more: https://github.com/rkendel1/feltdb`);
     console.log('\n═══════════════════════════════════════════════');
     console.log('📦 DEPLOYMENT TARGET');
     console.log('═══════════════════════════════════════════════');
-    console.log(`\nRuntime:       ${options.runtime.toUpperCase()}`);
-    console.log(`Description:   ${runtimeDescriptions[options.runtime]}`);
-    console.log(`Framework:     ${options.framework}`);
-    console.log(`Distributed:   ${options.distributed ? 'yes' : 'no'}`);
-    console.log(`Agents:        ${options.agents ? 'yes' : 'no'}`);
-    console.log(`WebLLM:        ${options.webllm ? 'yes — natural-language app builder' : 'no'}`);
-    console.log(`Capabilities:  ${options.capabilities}`);
+    if (options.framework === 'react' && !options.agents) {
+        console.log('\nNote: the React starter always includes its assistants; --no-agents applies to the vanilla template.');
+    }
+    options.agents = agentsIncluded(options);
+    console.log('');
+    for (const line of describeSetup(options))
+        console.log(line);
     console.log('\n═══════════════════════════════════════════════\n');
     const projectDir = path.resolve(process.cwd(), projectName);
     let projectCreated = false;

package/dist/create/create.js

@@ -196,12 +196,25 @@ ${hasAgents ? `  agent WorkspaceAssistant {
         tsconfig.compilerOptions.types = ['vite/client'];
     }
     fs.writeFileSync(path.join(projectDir, 'tsconfig.json'), JSON.stringify(tsconfig, null, 2));
-    // Browsers do not expose VITE_* through process.env, so a local database must be handed its
+    // Browsers do not expose VITE_* through process.env, so the database must be handed its
     // namespace explicitly; otherwise it opens the shared `default` store and `feltdb dev` cannot
     // recognise the application. A managed (remote) runtime resolves its target from its URL.
+    //
+    // The generated application runs in the browser whatever the deployment target. For a
+    // browser target its state is the browser's own (IndexedDB). For a Node.js or self-hosted
+    // target the state lives in a FeltDB authority, so the browser application connects to it:
+    // the URL the developer configured, else the authority `feltdb dev` started. Opening a
+    // browser store there instead would leave the application writing data Studio and the
+    // authority never see.
+    const namespaceExpression = `import.meta.env.VITE_FELTDB_NAMESPACE || ${JSON.stringify(applicationName)}`;
     const createDatabaseCall = runtime === 'managed'
         ? 'createFeltDB()'
-        : `createFeltDB({ namespace: import.meta.env.VITE_FELTDB_NAMESPACE || ${JSON.stringify(applicationName)} })`;
+        : runtime === 'browser'
+            ? `createFeltDB({ namespace: ${namespaceExpression} })`
+            : `createFeltDB({
+  namespace: ${namespaceExpression},
+  server: { url: import.meta.env.VITE_FELTDB_URL || import.meta.env.VITE_FELTDB_AUTHORITY_URL || 'http://127.0.0.1:7700' },
+})`;
     // Create main application files
     const feltdbTs = `import { configureDevelopmentRuntimeBridge, createFeltDB } from '@feltdb/core';
 
@@ -1222,6 +1235,8 @@ main().catch(console.error);
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <!-- An inline icon: without one the browser requests /favicon.ico and logs a 404. -->
+  <link rel="icon" href="data:,">
   <title>${applicationName}</title>
 </head>
 <body>
@@ -1244,10 +1259,9 @@ main().catch(console.error);
   # FeltDB Server URL (self-hosted or managed runtime)
   VITE_FELTDB_URL=http://localhost:7700
 
-  # Optional credential for authenticated remote browser access
-  VITE_FELTDB_TOKEN=
-  # Legacy alias accepted by older tooling
-  VITE_FELTDB_API_KEY=
+  # Browser code authenticates users with db.auth.signIn() (end-user sessions).
+  # Never put a FeltDB service key (fdb_live_…) in a VITE_ variable: Vite
+  # inlines every VITE_* value into the browser bundle.
 
   # Managed example: https://runtime.your-app.feltdb.com
   VITE_FELTDB_MANAGED_URL=
@@ -1493,7 +1507,7 @@ npm run feltdb:import
 
 ### Self-Hosted
 - \`VITE_FELTDB_URL\`: Docker container URL (default: http://localhost:7700)
-- \`VITE_FELTDB_API_KEY\`: API token for authentication
+- \`FELTDB_TOKEN\`: API key for server-side code only (never a \`VITE_\` variable; browsers use \`db.auth.signIn()\`)
 - \`FELTDB_IMAGE\`: Docker image to use (optional override)
 - \`DOCKER_NETWORK\`: Custom Docker network (optional)
 
@@ -1686,7 +1700,6 @@ Configuration is in \`feltdb.config.json\`:
 Create a \`.env.local\` file (copy from \`.env.example\`):
 
 \`\`\`
-VITE_FELTDB_API_KEY=your_api_key_here
 VITE_FELTDB_URL=http://localhost:7700
 VITE_FELTDB_MANAGED_URL=https://api.feltdb.com
 VITE_FELTDB_MANAGED_APPLICATION_ID=your_application_id

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

package/dist/create/server-source/Cargo.lock

@@ -219,9 +219,9 @@ checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527"
 
 [[package]]
 name = "chacha20"
-version = "0.10.1"
+version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d524456ba66e72eb8b115ff89e01e497f8e6d11d78b70b1aa13c0fbd97540a81"
+checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06"
 dependencies = [
  "cfg-if",
  "cpufeatures 0.3.0",
@@ -494,7 +494,7 @@ checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
 
 [[package]]
 name = "feltdb"
-version = "0.2.1"
+version = "0.3.0"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -513,7 +513,7 @@ dependencies = [
 
 [[package]]
 name = "feltdb-client"
-version = "0.2.1"
+version = "0.3.0"
 dependencies = [
  "feltdb",
  "reqwest",
@@ -526,7 +526,7 @@ dependencies = [
 
 [[package]]
 name = "feltdb-server"
-version = "0.2.1"
+version = "0.3.0"
 dependencies = [
  "argon2",
  "async-stream",
@@ -552,7 +552,7 @@ dependencies = [
 
 [[package]]
 name = "feltdb-wasm"
-version = "0.2.1"
+version = "0.3.0"
 dependencies = [
  "feltdb",
  "getrandom 0.2.17",

package/dist/create/server-source/Cargo.toml

@@ -14,5 +14,5 @@ exclude = [
 resolver = "2"
 
 [workspace.package]
-version = "0.2.1"
+version = "0.3.0"
 edition = "2021"

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

@@ -1133,6 +1133,48 @@ impl PreconditionFailure {
     }
 }
 
+impl PreconditionFailure {
+    /// The refusal as every transport serializes it: `predicate`, the
+    /// application's `collection` (never a storage namespace), the record `id`,
+    /// its `key` as `collection:id`, and `expected` / `actual` where the
+    /// predicate has them. A fence names the first fenced collection and
+    /// `key: "read-basis"`, with no `id` and no tokens.
+    ///
+    /// `layout` is where the authority addressed the record: the direct route
+    /// keys rows `collection:id` under `collection`; an application namespace
+    /// keys them by id under `namespace:collection`.
+    pub fn public_json(&self, layout: &ReadLayout) -> Value {
+        let mut value = serde_json::to_value(self).unwrap_or(Value::Null);
+        if matches!(self, Self::Fence { .. }) {
+            return value;
+        }
+        let (collection, id) = match layout {
+            ReadLayout::Direct => {
+                let collection = self.collection().to_string();
+                let id = self
+                    .key()
+                    .strip_prefix(&format!("{collection}:"))
+                    .unwrap_or(self.key())
+                    .to_string();
+                (collection, id)
+            }
+            ReadLayout::Namespace(namespace) => (
+                self.collection()
+                    .strip_prefix(&format!("{namespace}:"))
+                    .unwrap_or(self.collection())
+                    .to_string(),
+                self.key().to_string(),
+            ),
+        };
+        if let Some(object) = value.as_object_mut() {
+            object.insert("key".into(), Value::String(format!("{collection}:{id}")));
+            object.insert("collection".into(), Value::String(collection));
+            object.insert("id".into(), Value::String(id));
+        }
+        value
+    }
+}
+
 impl Display for PreconditionFailure {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -3225,6 +3267,20 @@ impl FeltDb {
             .collect()
     }
 
+    /// The original commit of a transaction id, if it committed, exactly as a
+    /// retry of it through `apply_atomic_transaction_*` would report it: the
+    /// original revisions and positions (`duplicate: true`), or
+    /// `TransactionIdPayloadMismatch` when `payload_hash` differs from the one
+    /// the id was committed with. Read-only.
+    pub fn committed_transaction(
+        &self,
+        transaction_id: &str,
+        payload_hash: Option<&str>,
+    ) -> Result<Option<AtomicCommit>> {
+        let inner = self.state();
+        committed_transaction_locked(&inner, transaction_id, payload_hash).transpose()
+    }
+
     pub fn has_applied_transaction(&self, transaction_id: &str) -> Result<bool> {
         Ok(self
             .inner
@@ -3385,41 +3441,10 @@ impl FeltDb {
     ) -> Result<AtomicCommit> {
         let (commit, events) = {
             let mut inner = self.state();
-            if inner.applied_transactions.contains(transaction_id) {
-                if let Some(expected_hash) = payload_hash {
-                    if inner
-                        .transaction_payload_hashes
-                        .get(transaction_id)
-                        .map(String::as_str)
-                        != Some(expected_hash)
-                    {
-                        return Err(FlowError::TransactionIdPayloadMismatch {
-                            transaction_id: transaction_id.to_string(),
-                        });
-                    }
-                }
-                let (base_revision, commit_revision) = inner
-                    .transaction_revisions
-                    .get(transaction_id)
-                    .copied()
-                    .unwrap_or((inner.authority_revision, inner.authority_revision));
-                let (state_before, state_after) = inner
-                    .transaction_history
-                    .iter()
-                    .find(|attribution| attribution.transaction_id == transaction_id)
-                    .map(|attribution| (attribution.state_before, attribution.state_after))
-                    .unwrap_or((inner.sequence, inner.sequence));
-                return Ok(AtomicCommit {
-                    transaction_id: transaction_id.into(),
-                    base_revision,
-                    commit_revision,
-                    status: TransactionStatus::Committed,
-                    state_before,
-                    state_after,
-                    rows: vec![],
-                    duplicate: true,
-                    payload_binding: payload_hash.map(|_| PayloadBinding::Verified),
-                });
+            if let Some(duplicate) =
+                committed_transaction_locked(&inner, transaction_id, payload_hash)
+            {
+                return duplicate;
             }
             // Record preconditions, evaluated before anything is staged and
             // under the same lock the writes take. A caller reads state,
@@ -4167,6 +4192,21 @@ impl FeltDb {
         self.get::<Value>(key)
     }
 
+    /// One live row of a collection by its key, cloned under the state lock.
+    ///
+    /// A keyed lookup, not a scan: callers that know the canonical key of the
+    /// record they need (Durable Work's projection refresh, for one) use this
+    /// rather than a predicate over the whole collection.
+    pub(crate) fn live_row(&self, capability: &str, key: &str) -> Option<StoredRow> {
+        let inner = self.state();
+        inner
+            .rows
+            .get(capability)
+            .and_then(|rows| rows.get(key))
+            .filter(|row| !row.deleted)
+            .cloned()
+    }
+
     /// List the canonical values in one collection/capability namespace.
     ///
     /// This clones the whole collection, so its cost is linear in collection
@@ -6021,6 +6061,57 @@ fn append_event_with(
     Ok(())
 }
 
+/// The answer to a retried transaction id, read under the commit lock.
+///
+/// `None` when the id has not committed. Otherwise the *original* commit's
+/// revisions and positions, never the store's current ones, or
+/// `TransactionIdPayloadMismatch` when a payload hash is given and differs from
+/// the one the id was committed with. Nothing is evaluated and nothing is
+/// applied: a duplicate is answered before any precondition is read.
+fn committed_transaction_locked(
+    inner: &Inner,
+    transaction_id: &str,
+    payload_hash: Option<&str>,
+) -> Option<Result<AtomicCommit>> {
+    if !inner.applied_transactions.contains(transaction_id) {
+        return None;
+    }
+    if let Some(expected_hash) = payload_hash {
+        if inner
+            .transaction_payload_hashes
+            .get(transaction_id)
+            .map(String::as_str)
+            != Some(expected_hash)
+        {
+            return Some(Err(FlowError::TransactionIdPayloadMismatch {
+                transaction_id: transaction_id.to_string(),
+            }));
+        }
+    }
+    let (base_revision, commit_revision) = inner
+        .transaction_revisions
+        .get(transaction_id)
+        .copied()
+        .unwrap_or((inner.authority_revision, inner.authority_revision));
+    let (state_before, state_after) = inner
+        .transaction_history
+        .iter()
+        .find(|attribution| attribution.transaction_id == transaction_id)
+        .map(|attribution| (attribution.state_before, attribution.state_after))
+        .unwrap_or((inner.sequence, inner.sequence));
+    Some(Ok(AtomicCommit {
+        transaction_id: transaction_id.into(),
+        base_revision,
+        commit_revision,
+        status: TransactionStatus::Committed,
+        state_before,
+        state_after,
+        rows: vec![],
+        duplicate: true,
+        payload_binding: payload_hash.map(|_| PayloadBinding::Verified),
+    }))
+}
+
 fn append_transaction(path: &Path, transaction: &TransactionLogRecord) -> Result<()> {
     // A transaction commit fsyncs. This span therefore includes the fsync, which
     // is the point: it is the durability cost of a commit, measured rather than