@feltdb/core 0.7.4 → 0.8.0

package/dist/cli/source-sync.js

@@ -19,17 +19,40 @@ function gitDirty(cwd, files) {
         return [];
     return result.stdout.split(/\r?\n/).filter(Boolean).map(line => line.slice(3));
 }
+export async function repositoryContext(cwd = process.cwd(), plannedFiles = [FLOW_FILE, GENERATED_FILE]) {
+    const git = (args) => spawnSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    const rootResult = git(['rev-parse', '--show-toplevel']);
+    const root = rootResult.status === 0 ? rootResult.stdout.trim() : path.resolve(cwd);
+    const branchResult = git(['branch', '--show-current']);
+    const commitResult = git(['rev-parse', 'HEAD']);
+    const context = await loadLocalDevelopmentContract(root);
+    return { root, branch: branchResult.status === 0 ? branchResult.stdout.trim() || undefined : undefined,
+        commit: commitResult.status === 0 ? commitResult.stdout.trim() : undefined, dirty: gitDirty(root, plannedFiles),
+        flowPath: path.join(root, FLOW_FILE), flowHash: context.flowHash };
+}
+export function assertProposalSourcePlan(sourcePlan) {
+    const allowed = new Set([FLOW_FILE, GENERATED_FILE]);
+    if (!sourcePlan?.files?.length)
+        throw new Error('SOURCE_PLAN_BLOCKED: Proposal has no source operations');
+    for (const operation of sourcePlan.files) {
+        if (!allowed.has(operation.path) || !['add', 'modify'].includes(operation.operation))
+            throw new Error(`SOURCE_PLAN_BLOCKED: unsupported ${operation.operation} operation for ${operation.path}`);
+    }
+    if (!sourcePlan.files.some(value => value.path === FLOW_FILE))
+        throw new Error(`SOURCE_PLAN_BLOCKED: ${FLOW_FILE} synchronization is required`);
+}
 export async function loadLocalDevelopmentContract(cwd = process.cwd()) {
     const flowPath = path.join(cwd, FLOW_FILE);
     if (!fs.existsSync(flowPath))
         throw new Error(`${FLOW_FILE} is required`);
     const source = fs.readFileSync(flowPath, 'utf8');
     const project = readJson(path.join(cwd, 'feltdb.config.json')) ?? {};
+    const managed = readJson(path.join(cwd, '.feltdb', 'managed.json')) ?? {};
     const published = readJson(path.join(cwd, '.feltdb', 'last-published.json'));
     const applicationId = process.env.VITE_FELTDB_MANAGED_APPLICATION_ID
-        || published?.applicationId || project.applicationId || parseFlowSpec(source).app;
-    const tenantId = process.env.VITE_FELTDB_MANAGED_TENANT_ID || published?.tenantId || 'local';
-    const environment = process.env.VITE_FELTDB_MANAGED_ENVIRONMENT || published?.environment || 'local';
+        || managed.applicationId || published?.applicationId || project.applicationId || parseFlowSpec(source).app;
+    const tenantId = managed.tenantId || published?.tenantId || 'local';
+    const environment = managed.environment || published?.environment || 'local';
     const contract = await compileApplicationContract(parseFlowSpec(source), tenantId, applicationId);
     return {
         source,
@@ -124,6 +147,27 @@ export async function applyFlowProposal(proposal, cwd = process.cwd(), options =
     const synchronized = options.syncSource === false ? { written: [] } : syncGeneratedSource(review, cwd, { replace: options.replaceGenerated });
     return { ...review, written: [FLOW_FILE, ...synchronized.written] };
 }
+/** Apply and verify as one developer-visible transaction, restoring exact prior bytes on failure. */
+export async function applyFlowProposalAtomic(proposal, cwd = process.cwd(), options = {}) {
+    const files = [FLOW_FILE, GENERATED_FILE, SYNC_STATE].map(relative => ({ relative, absolute: path.join(cwd, relative) }));
+    const before = files.map(file => ({ ...file, existed: fs.existsSync(file.absolute), bytes: fs.existsSync(file.absolute) ? fs.readFileSync(file.absolute) : undefined }));
+    try {
+        const result = await applyFlowProposal(proposal, cwd, options);
+        options.verify?.();
+        return result;
+    }
+    catch (error) {
+        for (const file of before) {
+            if (file.existed && file.bytes) {
+                fs.mkdirSync(path.dirname(file.absolute), { recursive: true });
+                fs.writeFileSync(file.absolute, file.bytes);
+            }
+            else if (fs.existsSync(file.absolute))
+                fs.rmSync(file.absolute, { force: true });
+        }
+        throw error;
+    }
+}
 export function describeProposal(review) {
     return [
         ...review.diff.added.map(value => `+ ${value}`),

package/dist/create/cli.js

@@ -10,7 +10,7 @@ import readline from 'readline';
 import { spawn, spawnSync } from 'child_process';
 import { createProject } from './create.js';
 import { FELTDB_PACKAGE_VERSION } from './package-versions.js';
-import { configureManagedAccount } from './managed-account.js';
+import { configureManagedAccount, finalizeManagedProvisioning } from './managed-account.js';
 import { localFeltdbExecutable } from './development-handoff.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 function parseArgs(args) {
@@ -331,9 +331,18 @@ Learn more: https://github.com/rkendel1/feltdb`);
         }
         console.log('\n✅ FeltDB application created successfully!\n');
         const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+        if (options.runtime === 'managed' && !shouldInstall) {
+            throw new Error('Managed provisioning requires dependency installation so the initial revision can be built, published, promoted, and verified. Remove --no-install.');
+        }
         if (shouldInstall) {
             console.log(`📦 Installing application, Studio${options.webllm ? ', and local WebLLM app builder' : ''} dependencies...\n`);
             await run(npm, ['install'], projectDir);
+            if (options.runtime === 'managed') {
+                console.log('\n☁️  Publishing and verifying the initial managed revision...\n');
+                await run(localFeltdbExecutable(projectDir), ['publish', '--yes', '--approve-destructive-changes'], projectDir);
+                const finalized = await finalizeManagedProvisioning({ projectDir });
+                console.log(`✓ Managed runtime verified at revision ${finalized.revisionId}`);
+            }
         }
         if (shouldStart) {
             if (!shouldInstall) {

package/dist/create/create.js

@@ -198,7 +198,7 @@ ${hasAgents ? `  agent WorkspaceAssistant {
     const runtimeOptions = runtime === 'browser'
         ? "{ namespace: import.meta.env.VITE_FELTDB_NAMESPACE || '" + applicationName + "', browser: true }"
         : runtime === 'managed'
-            ? "{ namespace: import.meta.env.VITE_FELTDB_MANAGED_NAMESPACE || import.meta.env.VITE_FELTDB_NAMESPACE || '" + applicationName + "', server: { url: import.meta.env.VITE_FELTDB_MANAGED_URL || import.meta.env.VITE_FELTDB_URL || '', token: import.meta.env.VITE_FELTDB_MANAGED_API_KEY || import.meta.env.VITE_FELTDB_API_KEY || '', applicationId: import.meta.env.VITE_FELTDB_MANAGED_APPLICATION_ID, environment: import.meta.env.VITE_FELTDB_MANAGED_ENVIRONMENT || 'production' } }"
+            ? "{ namespace: '" + applicationName + "', server: { url: import.meta.env.VITE_FELTDB_MANAGED_URL || '', applicationId: import.meta.env.VITE_FELTDB_MANAGED_APPLICATION_ID, environment: 'production' } }"
             : runtime === 'self-hosted'
                 ? "{ namespace: import.meta.env.VITE_FELTDB_NAMESPACE || '" + applicationName + "', server: { url: import.meta.env.VITE_FELTDB_URL || 'http://localhost:7700', token: import.meta.env.VITE_FELTDB_API_KEY || '' } }"
                 : "{ namespace: import.meta.env.VITE_FELTDB_NAMESPACE || '" + applicationName + "', memory: true }";
@@ -1234,8 +1234,7 @@ main().catch(console.error);
     const envExample = `# FeltDB Configuration
 # Copy this file to .env.local and update the values
 
-# API Key for authenticating with FeltDB servers
-# Leave empty for browser runtime; required for authenticated self-hosted and managed runtimes
+# API key for authenticated self-hosted browser access
 VITE_FELTDB_API_KEY=
 
 # FeltDB Server URL (self-hosted or managed runtime)
@@ -1243,13 +1242,10 @@ VITE_FELTDB_URL=http://localhost:7700
 
 # Managed example: https://runtime.your-app.feltdb.com
 VITE_FELTDB_MANAGED_URL=
-VITE_FELTDB_MANAGED_API_KEY=
+VITE_FELTDB_MANAGED_APPLICATION_ID=
 # Server/control-plane only. Never rename with a VITE_ prefix.
 FELTDB_MANAGED_CONTROL_API_KEY=
-VITE_FELTDB_MANAGED_TENANT_ID=
-VITE_FELTDB_MANAGED_APPLICATION_ID=
-VITE_FELTDB_MANAGED_NAMESPACE=
-VITE_FELTDB_MANAGED_ENVIRONMENT=production
+FELTDB_TOKEN=
 
 # Override the default self-hosted container image
 # By default the server image is built locally from the bundled source.
@@ -1388,7 +1384,7 @@ The self-hosted instance runs on \`http://localhost:7700\` by default.
 }
 \`\`\`
 
-Managed mode uses the same application API with a FeltDB-hosted endpoint. The CLI creates \`.env.local\` with \`VITE_FELTDB_MANAGED_URL\` and \`VITE_FELTDB_MANAGED_API_KEY\` after account setup. Studio uses that same connection for state, health, operations, and API-key administration.
+Managed mode uses the same application API with a FeltDB-hosted endpoint. The CLI writes only the public URL and application ID plus separate server-only publish and runtime credentials. Tenant, namespace, environment, and active revision are discovered deployment metadata under \`.feltdb/managed.json\`.
 
 ## Vector Search Status
 
@@ -1657,7 +1653,7 @@ FeltDB runs through a dedicated server with Docker Compose and persistent data v
 
 ### Managed Runtime
 
-FeltDB provides the runtime endpoint, durable storage, synchronization, and background workload infrastructure. The CLI configures \`VITE_FELTDB_MANAGED_URL\` and \`VITE_FELTDB_MANAGED_API_KEY\` in \`.env.local\`.
+FeltDB provides the runtime endpoint, durable storage, synchronization, and background workload infrastructure. The CLI configures the public \`VITE_FELTDB_MANAGED_*\` identity, separate server-only control and data-plane credentials, and the promoted revision in \`.env.local\`. The browser API-key value stays empty because browser users receive short-lived actor sessions.
 
 ## Configuration
 
@@ -1687,12 +1683,14 @@ 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_API_KEY=your_managed_api_key_here
 VITE_FELTDB_MANAGED_URL=https://api.feltdb.com
+VITE_FELTDB_MANAGED_APPLICATION_ID=your_application_id
+FELTDB_MANAGED_CONTROL_API_KEY=your_server_only_control_key
+FELTDB_TOKEN=your_server_only_application_data_key
 VITE_FELTDB_WEBSOCKET_URL=ws://localhost:7700
 \`\`\`
 
-These are required when connecting to an authenticated self-hosted or managed FeltDB instance.
+Never expose \`FELTDB_MANAGED_CONTROL_API_KEY\` or \`FELTDB_TOKEN\` through a \`VITE_\` variable. Managed browser access uses \`db.auth.signUp()\` and \`db.auth.signIn()\`; the active revision is discovered rather than configured.
 
 ## Development
 

package/dist/create/managed-account.js

@@ -1,5 +1,20 @@
 import fs from 'fs';
 import path from 'path';
+function loadEnvironment(file) {
+    const values = {};
+    for (const raw of fs.readFileSync(file, 'utf8').split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        const separator = line.indexOf('=');
+        if (separator > 0)
+            values[line.slice(0, separator)] = line.slice(separator + 1);
+    }
+    return values;
+}
+function managedStateFile(projectDir) {
+    return path.join(projectDir, '.feltdb', 'managed.json');
+}
 async function responseJson(response, fallback) {
     const body = await response.json().catch(() => ({}));
     if (!response.ok)
@@ -47,7 +62,8 @@ export async function configureManagedAccount(options) {
         method: 'POST', headers,
         body: JSON.stringify({
             id: `${options.applicationName}-control`,
-            namespace: options.namespace,
+            namespace: application.namespace || options.namespace,
+            application_id: application.id,
             scopes: [
                 'application:read', 'application:write', 'application:revision:create',
                 'application:revision:read', 'application:revision:promote',
@@ -57,19 +73,67 @@ export async function configureManagedAccount(options) {
     }), 'Could not create the managed control-plane key');
     if (!controlKey.secret)
         throw new Error('Managed key service did not return the control-plane credential');
+    const dataKey = await responseJson(await request(`${sessionOrigin}/api/keys`, {
+        method: 'POST', headers,
+        body: JSON.stringify({
+            id: `${options.applicationName}-runtime`,
+            namespace: application.namespace || options.namespace,
+            application_id: application.id,
+            scopes: [
+                'application:read', 'application:revision:read',
+                'state:read', 'state:write', 'events:read',
+                'workflows:run', 'agents:run', 'capabilities:run',
+            ],
+        }),
+    }), 'Could not create the managed application data key');
+    if (!dataKey.secret)
+        throw new Error('Managed key service did not return the application data credential');
+    try {
+        await responseJson(await request(`${apiUrl}/api/applications/${encodeURIComponent(application.id)}/revisions`, {
+            headers: { Authorization: `Bearer ${controlKey.secret}` },
+        }), 'Managed control-plane credential was created but is not accepted by the managed API');
+    }
+    catch (error) {
+        await Promise.allSettled([controlKey.id, dataKey.id].filter(Boolean).map(id => request(`${sessionOrigin}/api/keys/${encodeURIComponent(id)}`, { method: 'DELETE', headers })));
+        throw error;
+    }
     const environment = [
         '# Generated by create-feltdb managed setup. Do not commit this file.',
         `VITE_FELTDB_MANAGED_URL=${apiUrl}`,
-        '# Browser authentication uses short-lived actor sessions; no long-lived data key is embedded.',
-        'VITE_FELTDB_MANAGED_API_KEY=',
+        `VITE_FELTDB_MANAGED_APPLICATION_ID=${application.id}`,
         '# Control-plane credential. Never prefix this with VITE_ or expose it to browser code.',
         `FELTDB_MANAGED_CONTROL_API_KEY=${controlKey.secret}`,
-        `VITE_FELTDB_MANAGED_TENANT_ID=${tenant.id}`,
-        `VITE_FELTDB_MANAGED_APPLICATION_ID=${application.id}`,
-        `VITE_FELTDB_MANAGED_NAMESPACE=${application.namespace || options.namespace}`,
-        'VITE_FELTDB_MANAGED_ENVIRONMENT=production',
+        '# Server/deployment data-plane credential. Never prefix this with VITE_.',
+        `FELTDB_TOKEN=${dataKey.secret}`,
         '',
     ].join('\n');
     fs.writeFileSync(path.join(options.projectDir, '.env.local'), environment, { mode: 0o600 });
+    fs.mkdirSync(path.dirname(managedStateFile(options.projectDir)), { recursive: true });
+    fs.writeFileSync(managedStateFile(options.projectDir), `${JSON.stringify({
+        url: apiUrl,
+        tenantId: tenant.id,
+        applicationId: application.id,
+        namespace: application.namespace || options.namespace,
+        environment: 'production',
+    }, null, 2)}\n`, { mode: 0o600 });
     return { tenant, application, apiUrl };
 }
+export async function finalizeManagedProvisioning(options) {
+    const publishedFile = path.join(options.projectDir, '.feltdb', 'last-published.json');
+    if (!fs.existsSync(publishedFile))
+        throw new Error('Managed provisioning did not produce .feltdb/last-published.json');
+    const published = JSON.parse(fs.readFileSync(publishedFile, 'utf8'));
+    if (!published.revisionId)
+        throw new Error('Managed provisioning did not promote an application revision');
+    const environmentFile = path.join(options.projectDir, '.env.local');
+    const environment = loadEnvironment(environmentFile);
+    const managedFile = managedStateFile(options.projectDir);
+    const managed = JSON.parse(fs.readFileSync(managedFile, 'utf8'));
+    const request = options.fetchImpl || fetch;
+    const discovery = await responseJson(await request(`${managed.url}/v1/application?application_id=${encodeURIComponent(managed.applicationId)}&environment=${encodeURIComponent(managed.environment)}`, { headers: { Authorization: `Bearer ${environment.FELTDB_TOKEN}` } }), 'Managed application data credential is not accepted by the promoted runtime');
+    if (discovery.revision_id !== published.revisionId) {
+        throw new Error('Managed runtime revision does not match the revision promoted during provisioning');
+    }
+    fs.writeFileSync(managedFile, `${JSON.stringify({ ...managed, revisionId: published.revisionId }, null, 2)}\n`, { mode: 0o600 });
+    return { revisionId: published.revisionId };
+}

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

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

@@ -272,6 +272,9 @@ pub struct ApplicationManifest {
     pub agents: Vec<AgentDefinition>,
     #[serde(default)]
     pub capabilities: Vec<CapabilityBinding>,
+    /// Resolved, provider-neutral module semantic contracts. Secret values are forbidden.
+    #[serde(default)]
+    pub modules: Vec<serde_json::Value>,
     #[serde(default)]
     pub connections: Vec<ConnectionBinding>,
     #[serde(default)]
@@ -313,6 +316,7 @@ impl ApplicationManifest {
             schedules: vec![],
             agents: vec![],
             capabilities: vec![],
+            modules: vec![],
             connections: vec![],
             policies: vec![],
             ui: UiApplicationModel::default(),
@@ -733,6 +737,11 @@ pub fn validate_manifest(
             }
         }
     }
+    for (index, module) in manifest.modules.iter().enumerate() {
+        if contains_plaintext_secret(module) || module.get("value").is_some() {
+            issues.push(issue("security", format!("modules.{index}"), "module contracts may declare secret requirements but never secret values"));
+        }
+    }
     for environment in &manifest.environments {
         if environment.configuration.iter().any(|(key, value)| {
             matches!(
@@ -868,6 +877,7 @@ fn sorted(mut manifest: ApplicationManifest) -> ApplicationManifest {
         agent.capabilities.sort();
     }
     sort_name!(manifest.capabilities);
+    manifest.modules.sort_by(|a, b| a.get("id").and_then(Value::as_str).cmp(&b.get("id").and_then(Value::as_str)));
     sort_name!(manifest.connections);
     sort_name!(manifest.policies);
     sort_name!(manifest.ui.bindings);

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

@@ -246,7 +246,8 @@ use serde_json::Value;
 use sha2::{Digest, Sha256};
 use std::any::type_name;
 use std::collections::hash_map::DefaultHasher;
-use std::collections::{HashMap, HashSet};
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::ops::Bound::{Excluded, Unbounded};
 use std::fmt::{Display, Formatter};
 use std::fs::{self, OpenOptions};
 use std::hash::{Hash, Hasher};
@@ -315,7 +316,7 @@ pub struct FeltDb {
 #[allow(dead_code)] // Reserved runtime subsystems are initialized before their public APIs land.
 struct Inner {
     path: PathBuf,
-    rows: HashMap<String, HashMap<String, StoredRow>>,
+    rows: HashMap<String, BTreeMap<String, StoredRow>>,
     key_counters: HashMap<String, u64>,
     query_count_by_type: HashMap<String, usize>,
     adaptive_indexes: HashSet<String>,
@@ -1721,6 +1722,23 @@ impl FeltDb {
             .unwrap_or_default())
     }
 
+    /// Traverse one collection in immutable record-key order without materializing it.
+    pub fn list_collection_page(&self, capability: &str, after: Option<&str>, limit: usize) -> Result<Vec<StoredRow>> {
+        let inner = self.inner.lock().expect("lock poisoned");
+        let Some(rows) = inner.rows.get(capability) else { return Ok(vec![]) };
+        let values: Box<dyn Iterator<Item = &StoredRow>> = match after {
+            Some(key) => Box::new(rows.range::<str, _>((Excluded(key), Unbounded)).map(|(_, row)| row)),
+            None => Box::new(rows.values()),
+        };
+        Ok(values.filter(|row| !row.deleted).take(limit).cloned().collect())
+    }
+
+    /// Fetch one live collection record without materializing collection state.
+    pub fn get_collection_record(&self, capability: &str, key: &str) -> Result<Option<StoredRow>> {
+        let inner = self.inner.lock().expect("lock poisoned");
+        Ok(inner.rows.get(capability).and_then(|rows| rows.get(key)).filter(|row| !row.deleted).cloned())
+    }
+
     /// Subscribe to canonical mutation events.
     pub fn subscribe_changes(&self) -> broadcast::Receiver<ChangeEvent> {
         self.event_tx.subscribe()

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

@@ -1,10 +1,10 @@
+use serde_json::Value;
 use std::path::PathBuf;
 use std::{
     collections::HashMap,
     sync::{atomic::AtomicU64, Arc},
     time::Instant,
 };
-use serde_json::Value;
 
 #[derive(Clone)]
 pub struct BoundedQueryCursor {
@@ -16,34 +16,22 @@ pub struct BoundedQueryCursor {
     pub created_at: u64,
 }
 
+use crate::{
+    application_contract::ApplicationContractStore, artifacts::ArtifactStore, audit::AuditLog,
+    auth::KeyStore, causal::CausalStore, clock::LeaseClock, cluster::ClusterStore,
+    connections::ConnectionStore, content::ContentStore, identity::IdentityStore,
+    leases::LeaseStore, metrics::Metrics, portable_bundle::BundleStore, principals::PrincipalStore,
+    providers::ProviderStore, releases::ReleaseStore, sessions::SessionVerifier,
+    tenancy::TenancyStore,
+};
 use feltdb::{
-    FeltDb,
     application::ApplicationStore,
+    application_runtime::RuntimeStore,
     authorization::{GrantSigner, GrantStore},
     sync_contract::SyncStore,
-    workload::WorkloadStore,
     worker_mesh::WorkerMeshStore,
-    application_runtime::RuntimeStore,
-};
-use crate::{
-    artifacts::ArtifactStore,
-    audit::AuditLog,
-    auth::KeyStore,
-    causal::CausalStore,
-    cluster::ClusterStore,
-    connections::ConnectionStore,
-    content::ContentStore,
-    identity::IdentityStore,
-    leases::LeaseStore,
-    metrics::Metrics,
-    portable_bundle::BundleStore,
-    principals::PrincipalStore,
-    providers::ProviderStore,
-    releases::ReleaseStore,
-    sessions::SessionVerifier,
-    tenancy::TenancyStore,
-    application_contract::ApplicationContractStore,
-    clock::LeaseClock,
+    workload::WorkloadStore,
+    FeltDb,
 };
 
 #[derive(Clone)]

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

@@ -283,10 +283,18 @@ impl ApplicationContractStore {
                     confidence: 0.0,
                     evidence_required: vec!["contract evidence".into()],
                     suggested_questions: vec![match p {
-                        "actors" => "Who will use this application, and what roles do they have?".into(),
-                        "entities" => "What information or records should the application keep track of?".into(),
+                        "actors" => {
+                            "Who will use this application, and what roles do they have?".into()
+                        }
+                        "entities" => {
+                            "What information or records should the application keep track of?"
+                                .into()
+                        }
                         "actions" => "What should people be able to do with those records?".into(),
-                        "permissions" => "Who can view, create, edit, delete, or administer this information?".into(),
+                        "permissions" => {
+                            "Who can view, create, edit, delete, or administer this information?"
+                                .into()
+                        }
                         _ => format!("What should FeltDB understand about {p}?"),
                     }],
                     candidate_resolutions: vec![],

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

@@ -154,7 +154,6 @@ fn now() -> u64 {
         .as_secs()
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;

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

@@ -224,10 +224,7 @@ impl CertificationHarness {
 
     /// Gets the count of tests in a category.
     pub fn test_count(&self, category: TestCategory) -> usize {
-        self.results
-            .get(&category)
-            .map(|v| v.len())
-            .unwrap_or(0)
+        self.results.get(&category).map(|v| v.len()).unwrap_or(0)
     }
 
     /// Gets all failed tests.
@@ -439,13 +436,10 @@ mod tests {
 
     #[test]
     fn test_execution_plan_builder() {
-        let plan = TestExecutionPlan::new(
-            TestSuiteDefinition::standard(),
-            TestEnvironment::Local,
-        )
-        .with_parallel()
-        .with_timeout(600)
-        .with_retry(3);
+        let plan = TestExecutionPlan::new(TestSuiteDefinition::standard(), TestEnvironment::Local)
+            .with_parallel()
+            .with_timeout(600)
+            .with_retry(3);
 
         assert!(plan.parallel_execution);
         assert_eq!(plan.timeout_secs, 600);
@@ -480,19 +474,18 @@ mod tests {
     fn test_environment_strings() {
         assert_eq!(TestEnvironment::Local.as_str(), "local");
         assert_eq!(TestEnvironment::ManagedStaging.as_str(), "managed_staging");
-        assert_eq!(TestEnvironment::ManagedProduction.as_str(), "managed_production");
+        assert_eq!(
+            TestEnvironment::ManagedProduction.as_str(),
+            "managed_production"
+        );
     }
 
     #[test]
     fn certification_report_serialization() {
         let mut harness = CertificationHarness::new(TestEnvironment::Local);
 
-        let result = TestResult::new(
-            "test_1".into(),
-            TestCategory::Operations,
-            "test_1".into(),
-        )
-        .passed(50);
+        let result =
+            TestResult::new("test_1".into(), TestCategory::Operations, "test_1".into()).passed(50);
 
         harness.record_result(result);
 
@@ -512,11 +505,19 @@ mod tests {
 
         for i in 0..3 {
             let result = if i == 1 {
-                TestResult::new(format!("test_{}", i), TestCategory::Authorization, format!("test_{}", i))
-                    .failed("test failed".into(), 50)
+                TestResult::new(
+                    format!("test_{}", i),
+                    TestCategory::Authorization,
+                    format!("test_{}", i),
+                )
+                .failed("test failed".into(), 50)
             } else {
-                TestResult::new(format!("test_{}", i), TestCategory::Authorization, format!("test_{}", i))
-                    .passed(50)
+                TestResult::new(
+                    format!("test_{}", i),
+                    TestCategory::Authorization,
+                    format!("test_{}", i),
+                )
+                .passed(50)
             };
             harness.record_result(result);
         }

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

@@ -132,10 +132,7 @@ impl DelegationTokenIssuer {
         let payload = self.canonicalize_for_signing(&token)?;
         let signature = self.sign(&payload)?;
 
-        Ok(DelegationToken {
-            signature,
-            ..token
-        })
+        Ok(DelegationToken { signature, ..token })
     }
 
     /// Canonicalizes token for consistent signing/verification.
@@ -180,11 +177,7 @@ impl DelegationTokenIssuer {
 
 impl DelegationTokenValidator {
     /// Creates a new token validator.
-    pub fn new(
-        expected_issuer: String,
-        expected_audience: String,
-        shared_secret: Vec<u8>,
-    ) -> Self {
+    pub fn new(expected_issuer: String, expected_audience: String, shared_secret: Vec<u8>) -> Self {
         Self {
             expected_issuer,
             expected_audience,
@@ -316,8 +309,7 @@ mod tests {
     fn issue_and_validate_delegation_token() {
         let secret = test_shared_secret();
         let issuer = DelegationTokenIssuer::new("sherpa".into(), secret.clone());
-        let validator =
-            DelegationTokenValidator::new("sherpa".into(), "feltdb".into(), secret);
+        let validator = DelegationTokenValidator::new("sherpa".into(), "feltdb".into(), secret);
 
         let token = issuer
             .issue(
@@ -337,8 +329,7 @@ mod tests {
     fn reject_expired_token() {
         let secret = test_shared_secret();
         let issuer = DelegationTokenIssuer::new("sherpa".into(), secret.clone());
-        let validator =
-            DelegationTokenValidator::new("sherpa".into(), "feltdb".into(), secret);
+        let validator = DelegationTokenValidator::new("sherpa".into(), "feltdb".into(), secret);
 
         let mut token = issuer
             .issue(
@@ -450,8 +441,7 @@ mod tests {
     fn tampering_invalidates_signature() {
         let secret = test_shared_secret();
         let issuer = DelegationTokenIssuer::new("sherpa".into(), secret.clone());
-        let validator =
-            DelegationTokenValidator::new("sherpa".into(), "feltdb".into(), secret);
+        let validator = DelegationTokenValidator::new("sherpa".into(), "feltdb".into(), secret);
 
         let mut token = issuer
             .issue(