@feltdb/core 0.12.2 → 0.13.0

package/dist/build-identity.json

@@ -1,13 +1,13 @@
 {
   "schema": "feltdb.build-identity.v2",
   "package": "@feltdb/core",
-  "version": "0.12.2",
+  "version": "0.13.0",
   "git": {
-    "sha1": "7a632f5b3e79d800ff27359f7f1a7c081dc7cb69",
+    "sha1": "b67312f73ea647ffea6f87337303c170d40d541d",
     "dirty": false
   },
   "path_in_vcs": "packages/core",
-  "source_digest": "sha256:9db516ed9702dde647cd8d9723e1d997be999a39ddebfcb337dc0c1d721c8110",
+  "source_digest": "sha256:7435af3423598673fcce76eb77444ee1e160f39f3fd83a0a788517e315bd3444",
   "inputs": [
     "Cargo.lock",
     "Cargo.toml",
@@ -20,7 +20,7 @@
     "tools/cli",
     "tools/create-feltdb"
   ],
-  "files": 770,
+  "files": 776,
   "build": {
     "command": "npm run build",
     "node": "v24.9.0"

package/dist/cli/commands.js

@@ -1834,11 +1834,16 @@ async function handleStudio(args, onReady) {
         : process.env.VITE_FELTDB_MANAGED_APPLICATION_ID || managedProject.applicationId || '';
     const environment = args.includes('--environment')
         ? args[args.indexOf('--environment') + 1] || 'production'
-        : managedProject.environment || 'production';
+        // A development session's authority is the local environment; asking it
+        // for `production` names an environment the session does not have.
+        : managedProject.environment || (args.includes('--session-id') && runtime !== 'managed' ? 'local' : 'production');
     const appUrl = args.includes('--app-url')
         ? args[args.indexOf('--app-url') + 1]
         : undefined;
     const sessionValue = (name) => args.includes(name) ? args[args.indexOf(name) + 1] : undefined;
+    // The connection parameters Studio is opened with. Served to a page opened
+    // without them (a bookmark, a pasted path) so it reconnects to this session.
+    let studioQuery = '';
     const session = {
         sessionId: sessionValue('--session-id'),
         workspaceId: sessionValue('--workspace-id'),
@@ -1889,7 +1894,7 @@ async function handleStudio(args, onReady) {
                 environment: managedProject.environment || 'production',
                 publishEndpoint: '/_feltdb/publish',
             } : undefined;
-            response.end(JSON.stringify({ token: connectUrl ? process.env.VITE_FELTDB_API_KEY || '' : '', managedPublish, session, sourceSync: { enabled: true, webllmEnabled, previewOnly, token: studioMutationToken, aiModel: publicAiModelConfiguration() } }));
+            response.end(JSON.stringify({ token: connectUrl ? process.env.VITE_FELTDB_API_KEY || '' : '', managedPublish, session, studioQuery, sourceSync: { enabled: true, webllmEnabled, previewOnly, token: studioMutationToken, aiModel: publicAiModelConfiguration() } }));
             return;
         }
         if (pathname === '/_feltdb/contract') {
@@ -2219,6 +2224,7 @@ async function handleStudio(args, onReady) {
     if (session.pairingUrl)
         parameters.set('pairing', session.pairingUrl);
     const query = `?${parameters.toString()}`;
+    studioQuery = parameters.toString();
     const studioUrl = `http://localhost:${port}/${query}`;
     console.log(`FeltDB Studio ready at ${studioUrl}`);
     onReady?.(studioUrl);

package/dist/cli/workspace-integration.js

@@ -12,6 +12,7 @@ import path from 'path';
 import { randomBytes } from 'crypto';
 import http from 'http';
 import { spawnSync } from 'child_process';
+import { developmentConnectionMatches } from '@feltdb/core';
 export const DEVELOPMENT_OBSERVATION_HISTORY_LIMIT = 1000;
 const FELTDB_IGNORE_PATTERN = /^\/?\.feltdb\/?$/;
 /**
@@ -82,6 +83,12 @@ export function startPairingDiscoveryServer(token, port = 7799, host = '127.0.0.
                     runtimeJson(response, 409, { error: 'RUNTIME_IDENTITY_MISMATCH' });
                     return;
                 }
+                // The session identity above is echoed back by every client; what the
+                // database is actually connected to is the part worth checking.
+                if (body.connection && !developmentConnectionMatches(runtimeSession, body.connection)) {
+                    runtimeJson(response, 409, { error: 'RUNTIME_CONNECTION_MISMATCH', connection: body.connection });
+                    return;
+                }
                 if (!body.runtimeInstanceId || !body.applicationId) {
                     runtimeJson(response, 400, { error: 'RUNTIME_IDENTITY_REQUIRED' });
                     return;
@@ -97,6 +104,7 @@ export function startPairingDiscoveryServer(token, port = 7799, host = '127.0.0.
                     runtime: runtimeSession.runtime,
                     authorityUrl: runtimeSession.authorityUrl,
                     applicationUrl: body.applicationUrl || runtimeSession.applicationUrl,
+                    ...(body.connection ? { connection: body.connection } : {}),
                     registeredAt: previous?.registeredAt ?? now,
                     lastSeenAt: now,
                     expiresAt: now + runtimeTtlMs,

package/dist/create/build-identity.json

@@ -1,13 +1,13 @@
 {
   "schema": "feltdb.build-identity.v2",
   "package": "create-feltdb",
-  "version": "0.12.2",
+  "version": "0.13.0",
   "git": {
-    "sha1": "7a632f5b3e79d800ff27359f7f1a7c081dc7cb69",
+    "sha1": "b67312f73ea647ffea6f87337303c170d40d541d",
     "dirty": false
   },
   "path_in_vcs": "tools/create-feltdb",
-  "source_digest": "sha256:9db516ed9702dde647cd8d9723e1d997be999a39ddebfcb337dc0c1d721c8110",
+  "source_digest": "sha256:7435af3423598673fcce76eb77444ee1e160f39f3fd83a0a788517e315bd3444",
   "inputs": [
     "Cargo.lock",
     "Cargo.toml",
@@ -20,7 +20,7 @@
     "tools/cli",
     "tools/create-feltdb"
   ],
-  "files": 770,
+  "files": 776,
   "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
@@ -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>

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

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

@@ -494,7 +494,7 @@ checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
 
 [[package]]
 name = "feltdb"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -513,7 +513,7 @@ dependencies = [
 
 [[package]]
 name = "feltdb-client"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "feltdb",
  "reqwest",
@@ -526,7 +526,7 @@ dependencies = [
 
 [[package]]
 name = "feltdb-server"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "argon2",
  "async-stream",
@@ -552,7 +552,7 @@ dependencies = [
 
 [[package]]
 name = "feltdb-wasm"
-version = "0.2.1"
+version = "0.2.2"
 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.2.2"
 edition = "2021"

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

@@ -486,6 +486,48 @@ impl WorkerMeshStore {
         }
         self.persist()
     }
+    /// Recover work whose claim lease expired, and release those claims from
+    /// the workers that held them so their capacity is not held by work they
+    /// no longer own. Recovery itself — `WorkerLost`, the attempt budget, the
+    /// decision — is `WorkloadStore::recover_expired`. Worker liveness is not
+    /// judged here; that is `detect_failures`.
+    pub fn recover_expired_work(
+        &mut self,
+        now: i64,
+        workloads: &mut WorkloadStore,
+    ) -> Result<Vec<String>, WorkerMeshError> {
+        let expired: Vec<(String, String, String)> = workloads
+            .workloads
+            .values()
+            .filter_map(|w| w.current_claim.as_ref().map(|claim| (w, claim)))
+            .filter(|(_, claim)| claim.expires_at <= now)
+            .map(|(w, claim)| {
+                (
+                    w.workload_id.clone(),
+                    claim.worker_id.clone(),
+                    claim.claim_id.clone(),
+                )
+            })
+            .collect();
+        let recovered = workloads.recover_expired(now)?;
+        for (workload_id, worker_id, claim_id) in expired {
+            // Release a claim only once the committed workload no longer holds
+            // it, whichever writer of the store recovered it.
+            let still_current = workloads
+                .workloads
+                .get(&workload_id)
+                .and_then(|w| w.current_claim.as_ref())
+                .is_some_and(|claim| claim.claim_id == claim_id);
+            let held = self
+                .workers
+                .get(&worker_id)
+                .is_some_and(|worker| worker.claims.contains(&claim_id));
+            if held && !still_current {
+                self.release_claim(&worker_id, &claim_id)?;
+            }
+        }
+        Ok(recovered)
+    }
     pub fn detect_failures(
         &mut self,
         now: i64,
@@ -507,7 +549,7 @@ impl WorkerMeshStore {
                 worker.claims.clear();
             }
         }
-        workloads.recover_expired(now)?;
+        self.recover_expired_work(now, workloads)?;
         self.persist()?;
         Ok(failed)
     }
@@ -852,6 +894,167 @@ mod tests {
         let _ = fs::remove_file(w);
     }
     #[test]
+    fn a_claim_recovered_by_another_writer_is_still_released() {
+        let (m, wpath, mut mesh, mut workloads, grant) = setup("release-raced");
+        let worker = register(&mut mesh, grant.clone());
+        let heartbeat = |timestamp| WorkerHeartbeat {
+            worker_id: worker.worker_id.clone(),
+            version: "1".into(),
+            capability_version: 1,
+            capacity: WorkerCapacity {
+                concurrency: 1,
+                active: 0,
+            },
+            health: WorkerHealth::Healthy,
+            timestamp,
+            running_claims: BTreeSet::new(),
+        };
+        mesh.heartbeat(&worker.worker_id, heartbeat(11), 2).unwrap();
+        let subject = grant.grant.subject.clone();
+        let create = |key: &str| CreateWorkload {
+            tenant_id: "t".into(),
+            application_id: "a".into(),
+            environment: "production".into(),
+            definition_id: "extract".into(),
+            definition_revision: "r".into(),
+            trigger: "manual".into(),
+            input: serde_json::json!({"file": key}),
+            requested_by: subject.clone(),
+            session_id: None,
+            authorization_snapshot: grant.clone(),
+            capability_snapshot: ["documents.extract".into()].into(),
+            connection_scopes: BTreeSet::new(),
+            priority: 0,
+            idempotency_key: key.into(),
+            retry_policy: WorkloadRetryPolicy::default(),
+            timeouts: WorkloadTimeouts::default(),
+            dependencies: vec![],
+            not_before: None,
+            created_at: 11,
+        };
+        let first = workloads.create(create("first")).unwrap();
+        let second = workloads.create(create("second")).unwrap();
+        mesh.place_and_claim(
+            &mut workloads,
+            &first.workload_id,
+            &worker.worker_id,
+            12,
+            1000,
+        )
+        .unwrap();
+        assert_eq!(mesh.workers[&worker.worker_id].capacity.active, 1);
+        // Another writer of the same store recovers the work first.
+        let mut other = WorkloadStore::from_db(workloads.db_for_tests()).unwrap();
+        assert_eq!(
+            other.recover_expired(14).unwrap(),
+            vec![first.workload_id.clone()]
+        );
+        // This node's pass loses the guarded commit, adopts the committed
+        // workload, does not report it as its own recovery, and still frees the
+        // worker, whose claim is no longer the workload's.
+        assert!(mesh
+            .recover_expired_work(14, &mut workloads)
+            .unwrap()
+            .is_empty());
+        let recovered = workloads.get(&first.workload_id).unwrap();
+        assert_eq!(recovered.state, crate::workload::WorkloadState::Ready);
+        assert_eq!(
+            recovered
+                .execution_history
+                .iter()
+                .filter(|event| event.to == crate::workload::WorkloadState::Recovering)
+                .count(),
+            1
+        );
+        assert!(mesh.workers[&worker.worker_id].claims.is_empty());
+        assert_eq!(mesh.workers[&worker.worker_id].capacity.active, 0);
+        let _ = second;
+        let _ = fs::remove_file(m);
+        let _ = fs::remove_file(wpath);
+    }
+    #[test]
+    fn recovering_an_expired_claim_releases_it_from_a_live_worker() {
+        let (m, wpath, mut mesh, mut workloads, grant) = setup("release-expired");
+        let worker = register(&mut mesh, grant.clone());
+        let heartbeat = |timestamp| WorkerHeartbeat {
+            worker_id: worker.worker_id.clone(),
+            version: "1".into(),
+            capability_version: 1,
+            capacity: WorkerCapacity {
+                concurrency: 1,
+                active: 0,
+            },
+            health: WorkerHealth::Healthy,
+            timestamp,
+            running_claims: BTreeSet::new(),
+        };
+        mesh.heartbeat(&worker.worker_id, heartbeat(11), 2).unwrap();
+        let subject = grant.grant.subject.clone();
+        let create = |key: &str| CreateWorkload {
+            tenant_id: "t".into(),
+            application_id: "a".into(),
+            environment: "production".into(),
+            definition_id: "extract".into(),
+            definition_revision: "r".into(),
+            trigger: "manual".into(),
+            input: serde_json::json!({"file": key}),
+            requested_by: subject.clone(),
+            session_id: None,
+            authorization_snapshot: grant.clone(),
+            capability_snapshot: ["documents.extract".into()].into(),
+            connection_scopes: BTreeSet::new(),
+            priority: 0,
+            idempotency_key: key.into(),
+            retry_policy: WorkloadRetryPolicy::default(),
+            timeouts: WorkloadTimeouts::default(),
+            dependencies: vec![],
+            not_before: None,
+            created_at: 11,
+        };
+        let first = workloads.create(create("first")).unwrap();
+        let second = workloads.create(create("second")).unwrap();
+        mesh.place_and_claim(
+            &mut workloads,
+            &first.workload_id,
+            &worker.worker_id,
+            12,
+            1000,
+        )
+        .unwrap();
+        assert_eq!(mesh.workers[&worker.worker_id].capacity.active, 1);
+        // The lease expired at 13. The server's recovery is claim recovery: it
+        // recovers the work and frees the worker, and does not judge liveness.
+        let recovered = mesh.recover_expired_work(14, &mut workloads).unwrap();
+        assert_eq!(recovered, vec![first.workload_id.clone()]);
+        let live = &mesh.workers[&worker.worker_id];
+        assert!(live.claims.is_empty());
+        assert_eq!(live.capacity.active, 0);
+        assert_eq!(live.lifecycle, WorkerLifecycle::Ready);
+        assert_eq!(
+            workloads.get(&first.workload_id).unwrap().state,
+            crate::workload::WorkloadState::Ready
+        );
+        // Its capacity is usable again.
+        mesh.place_and_claim(
+            &mut workloads,
+            &second.workload_id,
+            &worker.worker_id,
+            15,
+            10_000,
+        )
+        .unwrap();
+        // Long past its heartbeat timeout, claim recovery still leaves the
+        // worker's lifecycle alone; only `detect_failures` marks it offline.
+        mesh.recover_expired_work(1_000, &mut workloads).unwrap();
+        assert_ne!(
+            mesh.workers[&worker.worker_id].lifecycle,
+            WorkerLifecycle::Offline
+        );
+        assert!(mesh.workers[&worker.worker_id].claims.is_empty());
+        let _ = fs::remove_file(m);
+        let _ = fs::remove_file(wpath);
+    }
+    #[test]
     fn placement_claim_fencing_failure_and_recovery() {
         let (m, wpath, mut mesh, mut workloads, grant) = setup("claim");
         let worker = register(&mut mesh, grant.clone());