@spooky-sync/core 0.0.0-canary.1 → 0.0.1-alpha.1

package/package.json

@@ -1,46 +1,83 @@
 {
   "name": "@spooky-sync/core",
-  "version": "0.0.0-canary.1",
+  "version": "0.0.1-alpha.1",
   "type": "module",
+  "sideEffects": false,
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./otel": {
+      "types": "./dist/otel/index.d.ts",
+      "import": "./dist/otel/index.js"
     }
   },
   "scripts": {
     "dev": "tsdown --watch",
     "dev:example": "pnpm dev",
-    "build": "tsdown",
-    "test": "vitest"
+    "build": "tsdown && node scripts/check-broker-bundle.mjs",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "type-check": "tsc --noEmit"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/mono424/spooky.git",
+    "url": "https://github.com/mono424/sp00ky.git",
     "directory": "packages/core"
   },
+  "keywords": [
+    "surrealdb",
+    "local-first",
+    "sync",
+    "tanstack-intent"
+  ],
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
+  "peerDependencies": {
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/exporter-logs-otlp-proto": "^0.211.0",
-    "@opentelemetry/resources": "^2.5.0",
+    "@opentelemetry/resources": "^2.6.0",
     "@opentelemetry/sdk-logs": "^0.211.0",
-    "@opentelemetry/semantic-conventions": "^1.39.0",
-    "@spooky-sync/query-builder": "workspace:*",
-    "@spooky-sync/ssp-wasm": "workspace:*",
-    "@surrealdb/wasm": "^3.0.0",
+    "@opentelemetry/semantic-conventions": "^1.39.0"
+  },
+  "peerDependenciesMeta": {
+    "@opentelemetry/api": {
+      "optional": true
+    },
+    "@opentelemetry/exporter-logs-otlp-proto": {
+      "optional": true
+    },
+    "@opentelemetry/resources": {
+      "optional": true
+    },
+    "@opentelemetry/sdk-logs": {
+      "optional": true
+    },
+    "@opentelemetry/semantic-conventions": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@spooky-sync/query-builder": "0.0.1-alpha.1",
+    "@spooky-sync/ssp-wasm": "0.0.1-alpha.1",
+    "@sqlite.org/sqlite-wasm": "3.53.0-build1",
+    "@surrealdb/wasm": "^3.0.3",
+    "blurhash": "^2.0.5",
     "fast-json-patch": "^3.1.1",
+    "loro-crdt": "^1.5.6",
     "pino": "^10.1.0",
-    "surrealdb": "2.0.0"
+    "surrealdb": "2.0.3"
   },
   "devDependencies": {
     "@types/node": "^22.5.2",
+    "@vitest/coverage-v8": "^3.2.4",
     "tsdown": "^0.12.4",
     "typescript": "^5.6.2",
     "vitest": "^3.2.0"
   }
-}
+}

package/scripts/check-broker-bundle.mjs

@@ -0,0 +1,33 @@
+// Build gate: dist/tabs-broker-worker.js must be self-contained ESM.
+// Bundlers cannot trace `new SharedWorker(url)` module graphs, so any
+// import statement surviving into the emitted broker file would 404 at
+// runtime in consumers (the file is fetched as a bare URL, its relative
+// chunk siblings are not copied along). Run after `tsdown` in the build.
+import { readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const dist = resolve(dirname(fileURLToPath(import.meta.url)), '../dist/tabs-broker-worker.js');
+
+let code;
+try {
+  code = readFileSync(dist, 'utf8');
+} catch {
+  console.error(`check-broker-bundle: ${dist} missing; did tsdown run?`);
+  process.exit(1);
+}
+
+const problems = [];
+// Static or dynamic imports of sibling chunks.
+const importRe = /(?:^|\n)\s*import[\s(]/;
+if (importRe.test(code)) problems.push('contains an import statement');
+if (!code.includes('onconnect')) problems.push('missing onconnect handler');
+
+if (problems.length > 0) {
+  console.error(`check-broker-bundle: dist/tabs-broker-worker.js ${problems.join('; ')}.`);
+  console.error(
+    'The broker worker must stay free of runtime imports (type-only imports are fine in source).'
+  );
+  process.exit(1);
+}
+console.log('check-broker-bundle: ok');

package/skills/sp00ky-core/SKILL.md

@@ -0,0 +1,276 @@
+---
+name: sp00ky-core
+description: >-
+  Core client for the Sp00ky reactive local-first SurrealDB framework. Use when
+  initializing Sp00kyClient, registering queries and subscriptions, performing
+  mutations (create/update/delete), handling auth (signUp/signIn/signOut),
+  working with file buckets, or using backend runs (HTTP outbox pattern).
+metadata:
+  author: sp00ky-sync
+  version: "0.0.1"
+---
+
+# Sp00ky Core
+
+`@spooky-sync/core` provides `Sp00kyClient`, the main entry point for the Sp00ky framework. It handles local-first data sync with SurrealDB, reactive queries, optimistic mutations, authentication, file storage, and backend runs.
+
+## Initialization
+
+```typescript
+import { Sp00kyClient } from '@spooky-sync/core';
+import { schema } from './generated/schema'; // Generated by `spooky generate`
+import schemaSurql from './generated/schema.surql?raw';
+
+const client = new Sp00kyClient({
+  database: {
+    endpoint: 'ws://localhost:8000',
+    namespace: 'my_ns',
+    database: 'my_db',
+    store: 'indexeddb', // or 'memory'
+  },
+  schema,
+  schemaSurql,
+  logLevel: 'info',
+});
+
+// IMPORTANT: You must call init() before using the client
+await client.init();
+
+// When done (e.g., app teardown):
+await client.close();
+```
+
+### Sp00kyConfig Options
+
+See [references/config.md](references/config.md) for all configuration options.
+
+Key fields:
+- `database.endpoint` — SurrealDB WebSocket URL
+- `database.namespace` / `database.database` — SurrealDB namespace and database
+- `database.store` — `'indexeddb'` (persistent) or `'memory'` (transient)
+- `schema` — The `SchemaStructure` object (use `as const satisfies SchemaStructure`)
+- `schemaSurql` — The compiled SURQL schema string for local DB provisioning
+- `logLevel` — `'debug' | 'info' | 'warn' | 'error'`
+- `persistenceClient` — `'surrealdb'` (default), `'localstorage'`, or a custom `PersistenceClient`
+- `streamDebounceTime` — Debounce ms for stream updates (default: 100)
+
+## Querying
+
+Queries are registered with the client and return a hash. You subscribe to the hash to receive reactive updates.
+
+```typescript
+// Register a query — returns a QueryBuilder
+const finalQuery = client.query('post', {})
+  .where({ author: 'user:alice' })
+  .orderBy('createdAt', 'desc')
+  .limit(20)
+  .build();
+
+// Run it to get the hash
+const { hash } = await finalQuery.run();
+
+// Subscribe to reactive updates
+const unsubscribe = await client.subscribe(hash, (records) => {
+  console.log('Posts:', records);
+}, { immediate: true });
+
+// Later: unsubscribe
+unsubscribe();
+```
+
+### Query TTL
+
+Queries have a time-to-live. Supported values: `'1m'`, `'5m'`, `'10m'` (default), `'15m'`, `'20m'`, `'25m'`, `'30m'`, `'1h'`–`'12h'`, `'1d'`.
+
+### Preloading
+
+`db.preload(query, { signal? })` registers a query without subscribing to it. If
+the server answered this query on this device before (a durable `_00_view` row
+exists) it resolves at once and the rows paint from the local store; otherwise
+it resolves once the server's membership and every record are local. Nothing
+to tear down: the entry is evicted a ttl after registration unless a view mounts
+the same query. `refresh` / `staleTime` are accepted but ignored.
+
+## Mutations
+
+Mutations are optimistic and automatically synced to the remote SurrealDB instance.
+
+```typescript
+// Create — pass a full "table:id" string and the record data
+await client.create('post:abc123', {
+  title: 'Hello World',
+  body: 'My first post',
+  author: 'user:alice',
+});
+
+// Update — pass table name, record ID, and partial data
+await client.update('post', 'post:abc123', { title: 'Updated Title' });
+
+// Update with debounce (useful for text fields)
+await client.update('post', 'post:abc123', { body: 'typing...' }, {
+  debounced: { key: 'recordId_x_fields', delay: 300 },
+});
+
+// Delete
+await client.delete('post', 'post:abc123');
+```
+
+### Debounced Updates
+
+Use `debounced` option for frequent updates (e.g., live typing):
+- `key: 'recordId'` — Debounce by record ID only (latest write wins, no merge)
+- `key: 'recordId_x_fields'` — Debounce by record ID + changed fields (recommended)
+
+### Failed writes
+
+A push the server rejects (permission, validation) is rolled back locally
+(create, update and delete) and moved to the `_00_failed_mutations` tray in the
+same local transaction. Network errors never do this; they retry. Inspect and
+act on the tray with `db.failedMutationCount`, `db.subscribeToFailedMutations(cb)`,
+`db.listFailedMutations()`, `db.retryFailedMutation(id)` (a fresh optimistic
+write) and `db.discardFailedMutation(id)`.
+
+## Authentication
+
+See [references/auth.md](references/auth.md) for the full auth API.
+
+```typescript
+// Sign up
+await client.auth.signUp('user_access', {
+  email: 'alice@example.com',
+  password: 'secret',
+  name: 'Alice',
+});
+
+// Sign in
+await client.auth.signIn('user_access', {
+  email: 'alice@example.com',
+  password: 'secret',
+});
+
+// Subscribe to auth state changes
+const unsub = client.auth.subscribe((userId) => {
+  console.log('Auth state:', userId); // string ID or null
+});
+
+// Sign out
+await client.auth.signOut();
+```
+
+Auth state properties: `client.auth.token`, `client.auth.currentUser`, `client.auth.isAuthenticated`, `client.auth.isLoading`.
+
+## Buckets (File Storage)
+
+```typescript
+const avatars = client.bucket('avatars');
+
+await avatars.put('alice/profile.png', fileBytes);
+const content = await avatars.get('alice/profile.png');
+const exists = await avatars.exists('alice/profile.png');
+await avatars.delete('alice/profile.png');
+await avatars.copy('alice/profile.png', 'alice/backup.png');
+await avatars.rename('old.png', 'new.png');
+const files = await avatars.list('alice/');
+```
+
+Buckets must be defined in the schema under the `buckets` array.
+
+## Backend Runs (HTTP Outbox)
+
+Backend runs let you trigger server-side HTTP operations via an **outbox pattern**. When you call `db.run()`, it creates a job record in a local outbox table. That record syncs to remote SurrealDB, where the Sp00ky Sync Platform (SSP) picks it up and calls your backend HTTP API. The result status is written back to the job record and syncs to the client reactively.
+
+### `db.run()` Signature
+
+```typescript
+db.run<B extends BackendNames<S>, R extends BackendRoutes<S, B>>(
+  backend: B,        // Backend name from sp00ky.yml (e.g., 'api')
+  route: R,          // Route path from OpenAPI spec (e.g., '/spookify')
+  payload: RoutePayload<S, B, R>,  // Typed args for the route
+  options?: RunOptions
+): Promise<void>
+```
+
+All parameters are type-safe — `backend`, `route`, and `payload` are inferred from the generated schema.
+
+### RunOptions
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `assignedTo` | `string` | `undefined` | Record ID to link the job to an entity (e.g., `'thread:abc'`) |
+| `max_retries` | `number` | `3` | Maximum retry attempts on failure |
+| `retry_strategy` | `'linear' \| 'exponential'` | `'linear'` | Backoff strategy between retries |
+
+### Entity Linking via `assignedTo`
+
+The `assignedTo` option is how you link a job to an entity. Passing a record ID:
+
+- Sets the `assigned_to` field on the job record (typed as `record<thread>` etc. in the outbox schema)
+- Enables **permission scoping** — e.g., `WHERE assigned_to.author.id = $auth.id` restricts job visibility to the entity's owner
+- Allows **querying jobs via relationships** — use `.related('jobs')` on the parent entity to reactively track job status
+
+### Full Example
+
+**1. Configure the backend in `sp00ky.yml`:**
+
+```yaml
+backends:
+  api:
+    type: http
+    spec: ../api/openapi.yml
+    baseUrl: http://host.docker.internal:3660
+    auth:
+      type: token
+      token: MY_SECRET
+    method:
+      type: outbox
+      table: job
+      schema: ./src/outbox/api.surql
+```
+
+**2. Define the outbox table in SurrealQL** (`src/outbox/api.surql`):
+
+```sql
+DEFINE TABLE job SCHEMAFULL
+PERMISSIONS
+  FOR select, create, update, delete
+  WHERE $access = "account" AND assigned_to.author.id = $auth.id;
+
+DEFINE FIELD assigned_to ON TABLE job TYPE record<thread>;
+DEFINE FIELD path ON TABLE job TYPE string;
+DEFINE FIELD payload ON TABLE job TYPE any;
+DEFINE FIELD retries ON TABLE job TYPE int DEFAULT ALWAYS 0;
+DEFINE FIELD max_retries ON TABLE job TYPE int DEFAULT ALWAYS 3;
+DEFINE FIELD retry_strategy ON TABLE job TYPE string DEFAULT ALWAYS "linear"
+  ASSERT $value IN ["linear", "exponential"];
+DEFINE FIELD status ON TABLE job TYPE string DEFAULT ALWAYS "pending"
+  ASSERT $value IN ["pending", "processing", "success", "failed"];
+DEFINE FIELD errors ON TABLE job TYPE array<object> DEFAULT ALWAYS [];
+DEFINE FIELD created_at ON TABLE job TYPE datetime VALUE time::now();
+```
+
+**3. Run `spooky generate`** — this produces the typed `backends` block in `schema.gen.ts`.
+
+**4. Call `db.run()` with entity linking:**
+
+```typescript
+// Trigger the /spookify backend route, linked to a thread
+await client.run('api', '/spookify', { id: threadId }, {
+  assignedTo: threadId,  // Links job to the thread entity
+});
+```
+
+### How It Works Under the Hood
+
+When you call `db.run('api', '/spookify', payload, options)`:
+
+1. Validates the route exists in the schema and all required args are present
+2. Creates a record in the outbox table (`job`) with fields: `path`, `payload` (JSON-stringified), `max_retries`, `retry_strategy`, and optionally `assigned_to`
+3. The record is created via the standard `client.create()` path — optimistic, synced to remote
+4. SSP detects the new job, calls your backend HTTP API, and updates the job's `status` field (`pending` → `processing` → `success`/`failed`)
+
+## Common Pitfalls
+
+1. **Must call `init()` before using the client** — All operations will fail if you skip initialization.
+2. **Schema is generated** — Use `spooky generate` to produce the schema TypeScript file and SURQL file from your `.surql` definitions.
+3. **RecordId format** — SurrealDB uses `table:id` format. When creating records, pass the full ID (e.g., `'post:abc123'`). The framework auto-converts string IDs to `RecordId` objects internally.
+4. **Queries are hash-based** — The same query always produces the same hash, enabling deduplication and caching.

package/skills/sp00ky-core/references/auth.md

@@ -0,0 +1,98 @@
+# Authentication Reference
+
+## AuthService API
+
+The `AuthService` is available on `Sp00kyClient` as `client.auth`.
+
+### Properties
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `token` | `string \| null` | Current auth token |
+| `currentUser` | `any \| null` | Current authenticated user record |
+| `isAuthenticated` | `boolean` | Whether a user is authenticated |
+| `isLoading` | `boolean` | Whether auth state is being validated |
+
+### Methods
+
+#### `signUp(accessName, params)`
+
+Create a new account using the named access definition from the schema.
+
+```typescript
+await client.auth.signUp('user_access', {
+  email: 'alice@example.com',
+  password: 'secret123',
+  name: 'Alice',
+});
+```
+
+The access definition in the schema determines what parameters are required:
+
+```typescript
+access: {
+  user_access: {
+    signup: {
+      params: {
+        email: { type: 'string', optional: false },
+        password: { type: 'string', optional: false },
+        name: { type: 'string', optional: true },
+      },
+    },
+    signIn: {
+      params: {
+        email: { type: 'string', optional: false },
+        password: { type: 'string', optional: false },
+      },
+    },
+  },
+}
+```
+
+Parameters are fully type-safe — TypeScript will infer the correct types from the schema.
+
+#### `signIn(accessName, params)`
+
+Authenticate with existing credentials.
+
+```typescript
+await client.auth.signIn('user_access', {
+  email: 'alice@example.com',
+  password: 'secret123',
+});
+```
+
+#### `signOut()`
+
+Sign out, clear the session token, and notify subscribers.
+
+```typescript
+await client.auth.signOut();
+```
+
+#### `subscribe(callback)`
+
+Subscribe to auth state changes. The callback fires immediately with the current state, then on every change.
+
+```typescript
+const unsub = client.auth.subscribe((userId: string | null) => {
+  if (userId) {
+    console.log('Logged in as', userId);
+  } else {
+    console.log('Not authenticated');
+  }
+});
+
+// Cleanup
+unsub();
+```
+
+#### `check(accessToken?)`
+
+Manually re-validate the current session. Called automatically during `init()`.
+
+```typescript
+await client.auth.check();
+// Or with a specific token:
+await client.auth.check('eyJhbGciOiJIUzI1NiJ9...');
+```

package/skills/sp00ky-core/references/config.md

@@ -0,0 +1,76 @@
+# Sp00kyConfig Reference
+
+```typescript
+interface Sp00kyConfig<S extends SchemaStructure> {
+  database: {
+    /** SurrealDB WebSocket endpoint URL */
+    endpoint?: string;
+    /** SurrealDB namespace */
+    namespace: string;
+    /** SurrealDB database name */
+    database: string;
+    /** Local store type: 'memory' (transient) or 'indexeddb' (persistent) */
+    store?: 'memory' | 'indexeddb';
+    /** Authentication token */
+    token?: string;
+  };
+  /** Unique client identifier. Auto-generated if not provided. */
+  clientId?: string;
+  /** The schema object (must use `as const satisfies SchemaStructure`) */
+  schema: S;
+  /** Compiled SURQL schema string for local DB provisioning */
+  schemaSurql: string;
+  /** Logging level */
+  logLevel: 'debug' | 'info' | 'warn' | 'error' | 'fatal' | 'silent' | 'trace';
+  /**
+   * Persistence client for local storage.
+   * - 'surrealdb': Uses the local SurrealDB instance (default)
+   * - 'localstorage': Uses browser localStorage
+   * - Custom: Provide an object implementing PersistenceClient
+   */
+  persistenceClient?: PersistenceClient | 'surrealdb' | 'localstorage';
+  /** A pino browser transmit object for forwarding logs (e.g. via @spooky-sync/core/otel) */
+  otelTransmit?: PinoTransmit;
+  /** Debounce time in ms for stream updates (default: 100) */
+  streamDebounceTime?: number;
+}
+```
+
+## PersistenceClient Interface
+
+```typescript
+interface PersistenceClient {
+  set<T>(key: string, value: T): Promise<void>;
+  get<T>(key: string): Promise<T | null>;
+  remove(key: string): Promise<void>;
+}
+```
+
+## QueryTimeToLive Values
+
+Supported TTL values for `client.query()`:
+
+`'1m'`, `'5m'`, `'10m'`, `'15m'`, `'20m'`, `'25m'`, `'30m'`, `'1h'`, `'2h'`, `'3h'`, `'4h'`, `'5h'`, `'6h'`, `'7h'`, `'8h'`, `'9h'`, `'10h'`, `'11h'`, `'12h'`, `'1d'`
+
+## RunOptions
+
+```typescript
+interface RunOptions {
+  assignedTo?: string;
+  max_retries?: number;
+  retry_strategy?: 'linear' | 'exponential';
+}
+```
+
+## UpdateOptions
+
+```typescript
+interface UpdateOptions {
+  debounced?: boolean | {
+    /** 'recordId': latest write wins. 'recordId_x_fields': merge by field (recommended). */
+    key?: 'recordId' | 'recordId_x_fields';
+    /** Debounce delay in ms */
+    delay?: number;
+  };
+}
+```

package/src/boot/auth-flip.saga.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from 'vitest';
+import { RecordId } from 'surrealdb';
+import { runPure } from '../testing/run-pure';
+import { fakeServices } from '../testing/services';
+import { buildEntry, buildState } from '../testing/build';
+import * as R from '../state/reducers';
+import { defaultEnv } from '../query/env';
+import { authFlip, persistVerifiedUser } from './auth-flip.saga';
+
+const env = defaultEnv({ tables: [{ name: 'user', columns: { id: {}, email_verified: {} } }] } as any);
+
+describe('authFlip', () => {
+  it('sets identity and $auth before the bucket work, writes the hint, switches, rotates the salt for a new principal, persists the user row', async () => {
+    const released: string[] = [];
+    const svc = fakeServices({
+      'auth.sessionAuthId': () => 'user:abc',
+      'auth.access': () => 'account',
+      'local.currentBucketId': () => 'anon',
+      'local.beginSwitch': () => () => void released.push('gate'),
+      'local.usesSurqlSchema': () => false,
+      'auth.token': () => 'jwt',
+      'auth.currentUser': () => ({ id: new RecordId('user', 'abc'), email_verified: true }),
+    });
+    const state = { ...buildState(), sessionId: 'old', saltUserId: null };
+    const out = await runPure(authFlip(env, 'user:abc'), {
+      state,
+      handlers: { service: svc.handler, 'local.query': () => [], 'local.execute': () => undefined, 'ssp.ingest': () => undefined },
+    });
+    const names = svc.names();
+    expect(names.slice(0, 5)).toEqual(['auth.sessionAuthId', 'auth.access', 'ssp.setSessionAuth', 'hint.write', 'local.currentBucketId']);
+    expect(svc.calls[3]).toEqual(['hint.write', ['abc']]);
+    expect(names).toContain('local.switchStore');
+    expect(names).toContain('crdt.setSessionId');
+    expect(released).toEqual(['gate']);
+    expect(out.state).toMatchObject({ userId: 'user:abc', saltUserId: 'user:abc', sessionId: 'salt-1', bucketId: 'abc' });
+    expect(out.state.versions.get('user:abc')).toBe(1);
+  });
+  it('same principal on the same bucket: no switch, no salt rotation', async () => {
+    const svc = fakeServices({
+      'auth.sessionAuthId': () => 'user:abc',
+      'auth.access': () => 'account',
+      'local.currentBucketId': () => 'abc',
+      'auth.currentUser': () => null,
+    });
+    const state = { ...buildState(), sessionId: 'keep', saltUserId: 'user:abc', bucketId: 'abc' };
+    const out = await runPure(authFlip(env, 'user:abc'), { state, handlers: { service: svc.handler } });
+    expect(svc.names()).not.toContain('local.switchStore');
+    expect(svc.names()).not.toContain('local.beginSwitch');
+    expect(out.state.sessionId).toBe('keep');
+  });
+});
+
+describe('persistVerifiedUser', () => {
+  it('skips when there is no verified row, an unknown table, or a bare id; writes otherwise and logs failures', async () => {
+    for (const row of [null, { id: 'user:x', a: 1 }, { id: new RecordId('user', 'x') }, { id: new RecordId('nope', 'x'), a: 1 }]) {
+      const svc = fakeServices({ 'auth.currentUser': () => row as any });
+      const out = await runPure(persistVerifiedUser(env), { state: buildState(), handlers: { service: svc.handler } });
+      expect(out.log.filter((e) => e.kind === 'local.execute')).toHaveLength(0);
+    }
+    const svc = fakeServices({ 'auth.currentUser': () => ({ id: new RecordId('user', 'x'), email_verified: true, junk: 1 }) });
+    const s = buildState([buildEntry({ def: { hash: 'q', tableName: 'user' } })], R.setVersions([['user:x', 4]]));
+    const out = await runPure(persistVerifiedUser(env), {
+      state: s,
+      handlers: {
+        service: svc.handler,
+        'local.execute': (e: any) => expect(e.vars.content0).toEqual({ email_verified: true, _00_rv: 4 }),
+        'ssp.ingest': (e: any) => expect(e.records[0].record.junk).toBeUndefined(),
+      },
+    });
+    expect(out.state.dirty.has('q')).toBe(true);
+    const failing = await runPure(persistVerifiedUser(env), {
+      state: s,
+      handlers: {
+        service: svc.handler,
+        'local.execute': () => {
+          throw new Error('locked');
+        },
+      },
+    });
+    expect(failing.emitted).toEqual([expect.objectContaining({ level: 'warn' })]);
+  });
+});