@spooky-sync/core 0.0.1-canary.147 → 0.0.1-canary.149

package/dist/index.d.ts

@@ -584,44 +584,13 @@ declare class DataModule<S extends SchemaStructure> {
   notifyQuerySynced(queryHash: string): Promise<void>;
   run<B extends BackendNames<S>, R extends BackendRoutes<S, B>>(backend: B, path: R, data: RoutePayload<S, B, R>, options?: RunOptions): Promise<void>;
   /**
-   * Build the outbox job record + resolve its table for a backend route. Shared
-   * by `run` (one-shot) and `runRecurring` (durable schedule).
+   * Build the outbox job record + resolve its table for a backend route.
+   *
+   * Every job is a single execution. Recurring work is declared server-side
+   * (`schedules:` in sp00ky.yml) and the scheduler creates a fresh row per cycle,
+   * so nothing here needs to know about schedules.
    */
   private buildJobRecord;
-  /**
-   * Deterministic id for the single recurring-schedule row of a given
-   * (assigned_to, path). One row per pair => calling `runRecurring` twice cannot
-   * fork a second schedule, and `poke`/`cancel` address the same row.
-   */
-  private recurringJobId;
-  /**
-   * Register a RECURRING job: one durable row per (assigned_to, path) that
-   * re-runs every `options.interval` ms (measured from each run's completion).
-   * Idempotent: if the schedule already exists it is left untouched, so calling
-   * this on every connect/re-login never forks a second schedule. The first run
-   * fires immediately (`next_run_at = now`), then every interval thereafter.
-   */
-  runRecurring<B extends BackendNames<S>, R extends BackendRoutes<S, B>>(backend: B, path: R, data: RoutePayload<S, B, R>, options: RunOptions & {
-    interval: number;
-    assignedTo: string;
-  }): Promise<void>;
-  /**
-   * Manually trigger a recurring job NOW and reset its interval clock. Sets
-   * `next_run_at = now` on the schedule row; the SSP ingest picks up the update
-   * and dispatches an immediate run, after which the runner re-arms the clock
-   * from that run's completion. No-op if no schedule exists (caller should have
-   * created one via `runRecurring`).
-   */
-  pokeRecurring<B extends BackendNames<S>>(backend: B, path: BackendRoutes<S, B>, options: {
-    assignedTo: string;
-  }): Promise<void>;
-  /**
-   * Cancel a recurring schedule: delete the single schedule row so it stops
-   * being dispatched server-side.
-   */
-  cancelRecurring<B extends BackendNames<S>>(backend: B, path: BackendRoutes<S, B>, options: {
-    assignedTo: string;
-  }): Promise<void>;
   /**
    * Create a new record
    */
@@ -1427,16 +1396,6 @@ declare class Sp00kyClient<S extends SchemaStructure> {
    */
   reportFrontendTiming(queryHash: string, ms: number): void;
   run<B extends BackendNames<S>, R extends BackendRoutes<S, B>>(backend: B, path: R, payload: RoutePayload<S, B, R>, options?: RunOptions): Promise<void>;
-  runRecurring<B extends BackendNames<S>, R extends BackendRoutes<S, B>>(backend: B, path: R, payload: RoutePayload<S, B, R>, options: RunOptions & {
-    interval: number;
-    assignedTo: string;
-  }): Promise<void>;
-  pokeRecurring<B extends BackendNames<S>>(backend: B, path: BackendRoutes<S, B>, options: {
-    assignedTo: string;
-  }): Promise<void>;
-  cancelRecurring<B extends BackendNames<S>>(backend: B, path: BackendRoutes<S, B>, options: {
-    assignedTo: string;
-  }): Promise<void>;
   bucket<B extends BucketNames<S>>(name: B): BucketHandle;
   create(id: string, data: Record<string, unknown>): Promise<Record<string, unknown>>;
   update(table: string, id: string, data: Record<string, unknown>, options?: UpdateOptions): Promise<{

package/dist/index.js

@@ -2989,8 +2989,11 @@ var DataModule = class {
 		await this.create(recordId, record);
 	}
 	/**
-	* Build the outbox job record + resolve its table for a backend route. Shared
-	* by `run` (one-shot) and `runRecurring` (durable schedule).
+	* Build the outbox job record + resolve its table for a backend route.
+	*
+	* Every job is a single execution. Recurring work is declared server-side
+	* (`schedules:` in sp00ky.yml) and the scheduler creates a fresh row per cycle,
+	* so nothing here needs to know about schedules.
 	*/
 	buildJobRecord(backend, path, data, options) {
 		const route = this.schema.backends?.[backend]?.routes?.[path];
@@ -3019,70 +3022,6 @@ var DataModule = class {
 		};
 	}
 	/**
-	* Deterministic id for the single recurring-schedule row of a given
-	* (assigned_to, path). One row per pair => calling `runRecurring` twice cannot
-	* fork a second schedule, and `poke`/`cancel` address the same row.
-	*/
-	recurringJobId(tableName, assignedTo, path) {
-		return `${tableName}:${`${assignedTo}_${path}`.replace(/[^A-Za-z0-9]+/g, "_").replace(/^_+|_+$/g, "")}`;
-	}
-	/**
-	* Register a RECURRING job: one durable row per (assigned_to, path) that
-	* re-runs every `options.interval` ms (measured from each run's completion).
-	* Idempotent: if the schedule already exists it is left untouched, so calling
-	* this on every connect/re-login never forks a second schedule. The first run
-	* fires immediately (`next_run_at = now`), then every interval thereafter.
-	*/
-	async runRecurring(backend, path, data, options) {
-		if (options?.interval == null) throw new Error("runRecurring requires options.interval (ms)");
-		if (!options?.assignedTo) throw new Error("runRecurring requires options.assignedTo");
-		const { tableName, record } = this.buildJobRecord(backend, path, data, options);
-		const recordId = this.recurringJobId(tableName, options.assignedTo, path);
-		const rid = parseRecordIdString(recordId);
-		const [existing] = await withRetry(this.logger, () => this.local.query("SELECT id FROM ONLY $id", { id: rid }));
-		if (existing) return;
-		record.recurring = true;
-		record.interval = options.interval;
-		record.next_run_at = /* @__PURE__ */ new Date();
-		try {
-			await this.create(recordId, record);
-		} catch (err) {
-			this.logger.debug({
-				id: recordId,
-				err: err?.message,
-				Category: "sp00ky-client::DataModule::runRecurring"
-			}, "runRecurring create skipped (schedule likely already exists)");
-		}
-	}
-	/**
-	* Manually trigger a recurring job NOW and reset its interval clock. Sets
-	* `next_run_at = now` on the schedule row; the SSP ingest picks up the update
-	* and dispatches an immediate run, after which the runner re-arms the clock
-	* from that run's completion. No-op if no schedule exists (caller should have
-	* created one via `runRecurring`).
-	*/
-	async pokeRecurring(backend, path, options) {
-		if (!options?.assignedTo) throw new Error("pokeRecurring requires options.assignedTo");
-		const tableName = this.schema.backends?.[backend]?.outboxTable;
-		if (!tableName) throw new Error(`Outbox table for backend ${backend} not found`);
-		const recordId = this.recurringJobId(tableName, options.assignedTo, path);
-		const rid = parseRecordIdString(recordId);
-		const [existing] = await withRetry(this.logger, () => this.local.query("SELECT id FROM ONLY $id", { id: rid }));
-		if (!existing) return;
-		await this.update(tableName, recordId, { next_run_at: /* @__PURE__ */ new Date() });
-	}
-	/**
-	* Cancel a recurring schedule: delete the single schedule row so it stops
-	* being dispatched server-side.
-	*/
-	async cancelRecurring(backend, path, options) {
-		if (!options?.assignedTo) throw new Error("cancelRecurring requires options.assignedTo");
-		const tableName = this.schema.backends?.[backend]?.outboxTable;
-		if (!tableName) throw new Error(`Outbox table for backend ${backend} not found`);
-		const recordId = this.recurringJobId(tableName, options.assignedTo, path);
-		await this.delete(tableName, recordId);
-	}
-	/**
 	* Create a new record
 	*/
 	async create(id, data) {
@@ -5112,8 +5051,8 @@ function parseBackendInfo(raw) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.147";
-const WASM_VERSION = "0.0.1-canary.147";
+const CORE_VERSION = "0.0.1-canary.149";
+const WASM_VERSION = "0.0.1-canary.149";
 const SURREAL_VERSION = "3.0.3";
 var DevToolsService = class {
 	eventsHistory = [];
@@ -7734,15 +7673,6 @@ var Sp00kyClient = class {
 	run(backend, path, payload, options) {
 		return this.dataModule.run(backend, path, payload, options);
 	}
-	runRecurring(backend, path, payload, options) {
-		return this.dataModule.runRecurring(backend, path, payload, options);
-	}
-	pokeRecurring(backend, path, options) {
-		return this.dataModule.pokeRecurring(backend, path, options);
-	}
-	cancelRecurring(backend, path, options) {
-		return this.dataModule.cancelRecurring(backend, path, options);
-	}
 	bucket(name) {
 		return new BucketHandle(name, this.remote);
 	}

package/dist/types.d.ts

@@ -727,12 +727,6 @@ interface RunOptions {
    * delayed the job stays pending (enqueued) and can still be killed.
    */
   delay?: number;
-  /**
-   * Interval in milliseconds for a RECURRING job (see `runRecurring`). When set,
-   * the job re-runs `interval` ms after each run COMPLETES (drift-free from
-   * completion, not wall-clock). Ignored by the plain `run`.
-   */
-  interval?: number;
 }
 /**
  * Options for update operations.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spooky-sync/core",
-  "version": "0.0.1-canary.147",
+  "version": "0.0.1-canary.149",
   "type": "module",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -60,8 +60,8 @@
     }
   },
   "dependencies": {
-    "@spooky-sync/query-builder": "0.0.1-canary.147",
-    "@spooky-sync/ssp-wasm": "0.0.1-canary.147",
+    "@spooky-sync/query-builder": "0.0.1-canary.149",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.149",
     "@sqlite.org/sqlite-wasm": "3.53.0-build1",
     "@surrealdb/wasm": "^3.0.3",
     "fast-json-patch": "^3.1.1",

package/src/modules/data/data.run.test.ts

@@ -0,0 +1,113 @@
+import { describe, it, expect, vi } from 'vitest';
+import { DataModule } from './index';
+
+/**
+ * Tests for `DataModule.run`, the one-shot outbox API.
+ *
+ * Recurring jobs used to live here too (`runRecurring` / `pokeRecurring` /
+ * `cancelRecurring`, which wrote a single durable row the runner re-armed
+ * forever). They are gone: schedules are now declared server-side under
+ * `schedules:` in sp00ky.yml, and the scheduler creates a fresh job row per
+ * cycle — so every row this API writes is exactly one execution.
+ *
+ * The create/update pipeline is spied, so these assert the orchestration
+ * (table resolution, argument validation, field building) without a real engine.
+ */
+
+function makeLogger(): any {
+  const noop = () => {};
+  const logger: any = { debug: noop, info: noop, warn: noop, error: noop, trace: noop };
+  logger.child = () => logger;
+  return logger;
+}
+
+const schema = {
+  tables: [{ name: 'job', columns: {} }],
+  backends: {
+    gamesync: {
+      outboxTable: 'job',
+      routes: {
+        '/syncGames': {
+          args: { connection: { optional: false }, since: { optional: true } },
+        },
+      },
+    },
+    noOutbox: {
+      routes: { '/whatever': { args: {} } },
+    },
+  },
+};
+
+const CONN = 'connection:CONN_abc';
+
+function makeDm() {
+  const local = { query: vi.fn().mockResolvedValue([]) };
+  const dm = new DataModule({} as any, local as any, schema as any, makeLogger(), 100);
+  const create = vi.spyOn(dm, 'create').mockResolvedValue(undefined as any);
+  return { dm, local, create };
+}
+
+describe('DataModule.run', () => {
+  it('creates the one-shot job with status pending so the optimistic row reads in-flight', async () => {
+    const { dm, create } = makeDm();
+    await dm.run('gamesync' as any, '/syncGames' as any, { connection: CONN } as any, {
+      assignedTo: CONN,
+    });
+
+    expect(create).toHaveBeenCalledTimes(1);
+    const [id, record] = create.mock.calls[0] as [string, any];
+    expect(id.startsWith('job:')).toBe(true);
+    // The schema's DEFAULT ALWAYS "pending" only runs server-side; without the
+    // explicit field the local optimistic row has status undefined and
+    // in-flight indicators miss it until the first server echo.
+    expect(record.status).toBe('pending');
+  });
+
+  it('gives each call its own row', async () => {
+    const { dm, create } = makeDm();
+    await dm.run('gamesync' as any, '/syncGames' as any, { connection: CONN } as any);
+    await dm.run('gamesync' as any, '/syncGames' as any, { connection: CONN } as any);
+
+    const [firstId] = create.mock.calls[0] as [string, any];
+    const [secondId] = create.mock.calls[1] as [string, any];
+    expect(firstId).not.toBe(secondId);
+  });
+
+  it('carries the retry, timeout and delay options onto the row', async () => {
+    const { dm, create } = makeDm();
+    await dm.run('gamesync' as any, '/syncGames' as any, { connection: CONN } as any, {
+      assignedTo: CONN,
+      max_retries: 5,
+      retry_strategy: 'exponential',
+      timeout: 30,
+      delay: 60_000,
+    });
+
+    const [, record] = create.mock.calls[0] as [string, any];
+    expect(record.max_retries).toBe(5);
+    expect(record.retry_strategy).toBe('exponential');
+    expect(record.timeout).toBe(30);
+    expect(record.delay).toBe(60_000);
+  });
+
+  it('serializes the payload and rejects a missing required argument', async () => {
+    const { dm, create } = makeDm();
+    await dm.run('gamesync' as any, '/syncGames' as any, { connection: CONN } as any);
+    const [, record] = create.mock.calls[0] as [string, any];
+    expect(JSON.parse(record.payload)).toEqual({ connection: CONN });
+
+    await expect(
+      dm.run('gamesync' as any, '/syncGames' as any, {} as any)
+    ).rejects.toThrow(/connection/);
+  });
+
+  it('rejects an unknown route and a backend with no outbox table', async () => {
+    const { dm } = makeDm();
+    await expect(
+      dm.run('gamesync' as any, '/nope' as any, {} as any)
+    ).rejects.toThrow(/not found/);
+    await expect(
+      dm.run('noOutbox' as any, '/whatever' as any, {} as any)
+    ).rejects.toThrow(/Outbox table/);
+  });
+});

package/src/modules/data/index.ts

@@ -1174,8 +1174,11 @@ export class DataModule<S extends SchemaStructure> {
   }
 
   /**
-   * Build the outbox job record + resolve its table for a backend route. Shared
-   * by `run` (one-shot) and `runRecurring` (durable schedule).
+   * Build the outbox job record + resolve its table for a backend route.
+   *
+   * Every job is a single execution. Recurring work is declared server-side
+   * (`schedules:` in sp00ky.yml) and the scheduler creates a fresh row per cycle,
+   * so nothing here needs to know about schedules.
    */
   private buildJobRecord<B extends BackendNames<S>, R extends BackendRoutes<S, B>>(
     backend: B,
@@ -1229,113 +1232,6 @@ export class DataModule<S extends SchemaStructure> {
     return { tableName, record };
   }
 
-  /**
-   * Deterministic id for the single recurring-schedule row of a given
-   * (assigned_to, path). One row per pair => calling `runRecurring` twice cannot
-   * fork a second schedule, and `poke`/`cancel` address the same row.
-   */
-  private recurringJobId(tableName: string, assignedTo: string, path: string): string {
-    const suffix = `${assignedTo}_${path}`.replace(/[^A-Za-z0-9]+/g, '_').replace(/^_+|_+$/g, '');
-    return `${tableName}:${suffix}`;
-  }
-
-  /**
-   * Register a RECURRING job: one durable row per (assigned_to, path) that
-   * re-runs every `options.interval` ms (measured from each run's completion).
-   * Idempotent: if the schedule already exists it is left untouched, so calling
-   * this on every connect/re-login never forks a second schedule. The first run
-   * fires immediately (`next_run_at = now`), then every interval thereafter.
-   */
-  async runRecurring<B extends BackendNames<S>, R extends BackendRoutes<S, B>>(
-    backend: B,
-    path: R,
-    data: RoutePayload<S, B, R>,
-    options: RunOptions & { interval: number; assignedTo: string }
-  ): Promise<void> {
-    if (options?.interval == null) {
-      throw new Error('runRecurring requires options.interval (ms)');
-    }
-    if (!options?.assignedTo) {
-      throw new Error('runRecurring requires options.assignedTo');
-    }
-
-    const { tableName, record } = this.buildJobRecord(backend, path, data, options);
-    const recordId = this.recurringJobId(tableName, options.assignedTo, path);
-    const rid = parseRecordIdString(recordId);
-
-    // Single schedule per key: if the row already exists, do nothing.
-    const [existing] = await withRetry(this.logger, () =>
-      this.local.query<[unknown]>('SELECT id FROM ONLY $id', { id: rid })
-    );
-    if (existing) return;
-
-    record.recurring = true;
-    record.interval = options.interval;
-    record.next_run_at = new Date(); // run now, then re-arm to now + interval on completion
-    try {
-      await this.create(recordId, record);
-    } catch (err) {
-      // The local existence check can miss a row that exists on the server but
-      // hasn't synced into this session yet (e.g. a re-login before catch-up).
-      // The deterministic id makes that CREATE collide; treat it as "schedule
-      // already exists" and keep runRecurring idempotent rather than throwing.
-      this.logger.debug(
-        { id: recordId, err: (err as Error)?.message, Category: 'sp00ky-client::DataModule::runRecurring' },
-        'runRecurring create skipped (schedule likely already exists)'
-      );
-    }
-  }
-
-  /**
-   * Manually trigger a recurring job NOW and reset its interval clock. Sets
-   * `next_run_at = now` on the schedule row; the SSP ingest picks up the update
-   * and dispatches an immediate run, after which the runner re-arms the clock
-   * from that run's completion. No-op if no schedule exists (caller should have
-   * created one via `runRecurring`).
-   */
-  async pokeRecurring<B extends BackendNames<S>>(
-    backend: B,
-    path: BackendRoutes<S, B>,
-    options: { assignedTo: string }
-  ): Promise<void> {
-    if (!options?.assignedTo) {
-      throw new Error('pokeRecurring requires options.assignedTo');
-    }
-    const tableName = this.schema.backends?.[backend]?.outboxTable;
-    if (!tableName) {
-      throw new Error(`Outbox table for backend ${backend} not found`);
-    }
-    const recordId = this.recurringJobId(tableName, options.assignedTo, path as string);
-    const rid = parseRecordIdString(recordId);
-
-    const [existing] = await withRetry(this.logger, () =>
-      this.local.query<[unknown]>('SELECT id FROM ONLY $id', { id: rid })
-    );
-    if (!existing) return;
-
-    await this.update(tableName, recordId, { next_run_at: new Date() });
-  }
-
-  /**
-   * Cancel a recurring schedule: delete the single schedule row so it stops
-   * being dispatched server-side.
-   */
-  async cancelRecurring<B extends BackendNames<S>>(
-    backend: B,
-    path: BackendRoutes<S, B>,
-    options: { assignedTo: string }
-  ): Promise<void> {
-    if (!options?.assignedTo) {
-      throw new Error('cancelRecurring requires options.assignedTo');
-    }
-    const tableName = this.schema.backends?.[backend]?.outboxTable;
-    if (!tableName) {
-      throw new Error(`Outbox table for backend ${backend} not found`);
-    }
-    const recordId = this.recurringJobId(tableName, options.assignedTo, path as string);
-    await this.delete(tableName, recordId);
-  }
-
   // ==================== MUTATION MANAGEMENT ====================
 
   /**

package/src/sp00ky.ts

@@ -959,34 +959,6 @@ export class Sp00kyClient<S extends SchemaStructure> {
     return this.dataModule.run(backend, path, payload, options);
   }
 
-  runRecurring<
-    B extends BackendNames<S>,
-    R extends BackendRoutes<S, B>,
-  >(
-    backend: B,
-    path: R,
-    payload: RoutePayload<S, B, R>,
-    options: RunOptions & { interval: number; assignedTo: string }
-  ) {
-    return this.dataModule.runRecurring(backend, path, payload, options);
-  }
-
-  pokeRecurring<B extends BackendNames<S>>(
-    backend: B,
-    path: BackendRoutes<S, B>,
-    options: { assignedTo: string }
-  ) {
-    return this.dataModule.pokeRecurring(backend, path, options);
-  }
-
-  cancelRecurring<B extends BackendNames<S>>(
-    backend: B,
-    path: BackendRoutes<S, B>,
-    options: { assignedTo: string }
-  ) {
-    return this.dataModule.cancelRecurring(backend, path, options);
-  }
-
   bucket<B extends BucketNames<S>>(name: B): BucketHandle {
     return new BucketHandle(name, this.remote);
   }

package/src/types.ts

@@ -461,12 +461,6 @@ export interface RunOptions {
    * delayed the job stays pending (enqueued) and can still be killed.
    */
   delay?: number;
-  /**
-   * Interval in milliseconds for a RECURRING job (see `runRecurring`). When set,
-   * the job re-runs `interval` ms after each run COMPLETES (drift-free from
-   * completion, not wall-clock). Ignored by the plain `run`.
-   */
-  interval?: number;
 }
 
 /**

package/src/modules/data/data.recurring.test.ts

@@ -1,153 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { DataModule } from './index';
-
-/**
- * Tests for the recurring-outbox API added to DataModule: runRecurring builds a
- * single deterministic schedule row (idempotent, swallows a duplicate CREATE);
- * pokeRecurring bumps next_run_at only when the schedule exists; cancelRecurring
- * deletes it. The heavy create/update/delete pipeline is spied so these assert
- * the orchestration (deterministic id, field-building, existence gating) without
- * a real engine.
- */
-
-function makeLogger(): any {
-  const noop = () => {};
-  const logger: any = { debug: noop, info: noop, warn: noop, error: noop, trace: noop };
-  logger.child = () => logger;
-  return logger;
-}
-
-const schema = {
-  tables: [{ name: 'job', columns: {} }],
-  backends: {
-    gamesync: {
-      outboxTable: 'job',
-      routes: { '/syncGames': { args: { connection: { optional: false } } } },
-    },
-  },
-};
-
-const CONN = 'connection:CONN_abc';
-
-// localQueryResult drives the existence check ([] = absent, [row] = present).
-function makeDm(localQueryResult: unknown[]) {
-  const local = { query: vi.fn().mockResolvedValue(localQueryResult) };
-  const dm = new DataModule({} as any, local as any, schema as any, makeLogger(), 100);
-  const create = vi.spyOn(dm, 'create').mockResolvedValue(undefined as any);
-  const update = vi.spyOn(dm, 'update').mockResolvedValue(undefined as any);
-  const del = vi.spyOn(dm, 'delete').mockResolvedValue(undefined as any);
-  return { dm, local, create, update, del };
-}
-
-describe('DataModule.runRecurring', () => {
-  it('creates a single deterministic schedule row with the recurring fields', async () => {
-    const { dm, create } = makeDm([]); // no existing row
-    await dm.runRecurring(
-      'gamesync' as any,
-      '/syncGames' as any,
-      { connection: CONN } as any,
-      { assignedTo: CONN, interval: 300000 }
-    );
-
-    expect(create).toHaveBeenCalledTimes(1);
-    const [id, record] = create.mock.calls[0] as [string, any];
-    expect(id.startsWith('job:')).toBe(true);
-    expect(record.recurring).toBe(true);
-    expect(record.interval).toBe(300000);
-    expect(record.next_run_at).toBeInstanceOf(Date);
-    expect(record.assigned_to).toBe(CONN);
-    expect(record.path).toBe('/syncGames');
-    expect(record.status).toBe('pending');
-    expect(JSON.parse(record.payload)).toEqual({ connection: CONN });
-  });
-
-  it('is idempotent: does nothing when a schedule already exists', async () => {
-    const { dm, create } = makeDm([{ id: 'job:x' }]); // existing row
-    await dm.runRecurring(
-      'gamesync' as any,
-      '/syncGames' as any,
-      { connection: CONN } as any,
-      { assignedTo: CONN, interval: 300000 }
-    );
-    expect(create).not.toHaveBeenCalled();
-  });
-
-  it('swallows a duplicate CREATE (row exists on server but not yet synced locally)', async () => {
-    const { dm, create } = makeDm([]); // local says absent
-    create.mockRejectedValueOnce(new Error('record already exists'));
-    await expect(
-      dm.runRecurring(
-        'gamesync' as any,
-        '/syncGames' as any,
-        { connection: CONN } as any,
-        { assignedTo: CONN, interval: 300000 }
-      )
-    ).resolves.toBeUndefined();
-  });
-
-  it('uses a stable id per (assignedTo, path)', async () => {
-    const a = makeDm([]);
-    await a.dm.runRecurring('gamesync' as any, '/syncGames' as any, { connection: CONN } as any, { assignedTo: CONN, interval: 300000 });
-    const b = makeDm([]);
-    await b.dm.runRecurring('gamesync' as any, '/syncGames' as any, { connection: CONN } as any, { assignedTo: CONN, interval: 300000 });
-    expect(a.create.mock.calls[0][0]).toBe(b.create.mock.calls[0][0]);
-  });
-
-  it('validates required options', async () => {
-    const { dm } = makeDm([]);
-    await expect(
-      dm.runRecurring('gamesync' as any, '/syncGames' as any, { connection: CONN } as any, { assignedTo: CONN } as any)
-    ).rejects.toThrow(/interval/);
-    await expect(
-      dm.runRecurring('gamesync' as any, '/syncGames' as any, { connection: CONN } as any, { interval: 300000 } as any)
-    ).rejects.toThrow(/assignedTo/);
-  });
-});
-
-describe('DataModule.run', () => {
-  it('creates the one-shot job with status pending so the optimistic row reads in-flight', async () => {
-    const { dm, create } = makeDm([]);
-    await dm.run('gamesync' as any, '/syncGames' as any, { connection: CONN } as any, { assignedTo: CONN });
-
-    expect(create).toHaveBeenCalledTimes(1);
-    const [id, record] = create.mock.calls[0] as [string, any];
-    expect(id.startsWith('job:')).toBe(true);
-    // The schema's DEFAULT ALWAYS "pending" only runs server-side; without the
-    // explicit field the local optimistic row has status undefined and
-    // in-flight indicators miss it until the first server echo.
-    expect(record.status).toBe('pending');
-  });
-});
-
-describe('DataModule.pokeRecurring', () => {
-  it('bumps next_run_at on the existing schedule row', async () => {
-    const { dm, update } = makeDm([{ id: 'job:x' }]);
-    await dm.pokeRecurring('gamesync' as any, '/syncGames' as any, { assignedTo: CONN });
-    expect(update).toHaveBeenCalledTimes(1);
-    const [table, id, data] = update.mock.calls[0] as [string, string, any];
-    expect(table).toBe('job');
-    expect(id.startsWith('job:')).toBe(true);
-    expect(data.next_run_at).toBeInstanceOf(Date);
-  });
-
-  it('is a no-op when no schedule exists', async () => {
-    const { dm, update } = makeDm([]);
-    await dm.pokeRecurring('gamesync' as any, '/syncGames' as any, { assignedTo: CONN });
-    expect(update).not.toHaveBeenCalled();
-  });
-});
-
-describe('DataModule.cancelRecurring', () => {
-  it('deletes the deterministic schedule row', async () => {
-    const { dm, del, create } = makeDm([]);
-    // Capture the id runRecurring would create, to prove cancel targets the same.
-    await dm.runRecurring('gamesync' as any, '/syncGames' as any, { connection: CONN } as any, { assignedTo: CONN, interval: 300000 });
-    const createdId = create.mock.calls[0][0];
-
-    await dm.cancelRecurring('gamesync' as any, '/syncGames' as any, { assignedTo: CONN });
-    expect(del).toHaveBeenCalledTimes(1);
-    const [table, id] = del.mock.calls[0] as [string, string];
-    expect(table).toBe('job');
-    expect(id).toBe(createdId);
-  });
-});