@absolutejs/sync 1.8.0 → 1.9.0

package/dist/engine/devtools.d.ts

@@ -35,6 +35,18 @@ export type EngineInspection = {
         table: string;
         op: RowOp;
     }[];
+    /**
+     * Registered sync packs (see {@link SyncEngine.registerPack}). Each
+     * entry reports the pack's name, version, the tables it owns, and the
+     * tables it reads but does not own. Surfaced for devtools and for
+     * conflict diagnostics.
+     */
+    packs: {
+        name: string;
+        version: string;
+        ownsTables: string[];
+        readsTables: string[];
+    }[];
 };
 /**
  * A live engine event (see {@link SyncEngine.onActivity}): a committed change or
@@ -63,4 +75,19 @@ export type EngineActivity = {
     delayMs: number;
     errorName: string;
     errorMessage: string;
+} | {
+    type: 'schedule';
+    at: number;
+    name: string;
+    status: 'ok' | 'error';
+} | {
+    /** Emitted between attempts of a retried schedule. Mirrors
+     * {@link mutationRetry}. */
+    type: 'scheduleRetry';
+    at: number;
+    name: string;
+    attempt: number;
+    delayMs: number;
+    errorName: string;
+    errorMessage: string;
 };

package/dist/engine/index.d.ts

@@ -40,6 +40,8 @@ export { createVectorIndex } from './vectorIndex';
 export type { VectorIndexOptions, VectorMetric } from './vectorIndex';
 export { defineSchedule } from './schedule';
 export type { ScheduleContext, ScheduleDefinition } from './schedule';
+export { defineSyncPack, PackMissingDependencyError, PackTableConflictError } from './pack';
+export type { CrdtFieldsMap, RegisteredPack, SyncPack } from './pack';
 export { defineMutation } from './mutation';
 export type { MutationActions, MutationDefinition, MutationHandler, TableWriter, TransactionRunner } from './mutation';
 export type { BridgeFetchConfig, BridgeFetchEndpoint, BridgeFetchResponse, HandlerMetricsHook, HandlerMetricsRecord, SandboxConfig } from './sandbox';

package/dist/engine/index.js

@@ -1056,6 +1056,31 @@ var createVectorIndex = (options) => {
 };
 // src/engine/schedule.ts
 var defineSchedule = (definition) => definition;
+// src/engine/pack.ts
+class PackTableConflictError extends Error {
+  table;
+  existingPack;
+  newPack;
+  constructor(table, existingPack, newPack) {
+    super(`Pack "${newPack}" claims table "${table}", but "${existingPack}" already owns it. Use a tablePrefix on one of them.`);
+    this.name = "PackTableConflictError";
+    this.table = table;
+    this.existingPack = existingPack;
+    this.newPack = newPack;
+  }
+}
+
+class PackMissingDependencyError extends Error {
+  pack;
+  missingTable;
+  constructor(pack, missingTable) {
+    super(`Pack "${pack}" requires a reader for table "${missingTable}" but none is registered. Call engine.registerReader("${missingTable}", ...) before engine.registerPack.`);
+    this.name = "PackMissingDependencyError";
+    this.pack = pack;
+    this.missingTable = missingTable;
+  }
+}
+var defineSyncPack = (pack) => pack;
 // src/engine/mutation.ts
 var defineMutation = (definition) => definition;
 // src/engine/retry.ts
@@ -1127,12 +1152,7 @@ var wrap = (source) => `
 	}
 `;
 var compile = async (source, config, bridgeFetch) => {
-  const { createIsolate, Reference } = await loadIsolatedJsc();
-  const isolate = await createIsolate({
-    backend: config.backend ?? "auto",
-    memoryLimit: config.memoryLimit ?? 32
-  });
-  const context = await isolate.createContext();
+  const { Reference, createIsolatedRunner, resolveIsolatePolicy } = await loadIsolatedJsc();
   const callMap = new Map;
   const dispatch = new Reference((callId, op, ...rest) => {
     const a = callMap.get(callId);
@@ -1156,15 +1176,25 @@ var compile = async (source, config, bridgeFetch) => {
         throw new Error(`unknown sandbox action op: ${String(op)}`);
     }
   });
-  await context.setGlobal("__dispatch", dispatch);
-  const callable = await context.compileCallable(wrap(source));
+  const timeoutMs = config.timeout ?? 5000;
+  const sourceToCall = wrap(source);
+  const policy = resolveIsolatePolicy("tenant-script", {
+    allowWorkerFallback: true,
+    backend: config.backend ?? "auto",
+    memoryLimit: config.memoryLimit ?? 32,
+    timeout: timeoutMs
+  });
+  const runner = createIsolatedRunner({
+    globals: { __dispatch: dispatch },
+    policy
+  });
+  await runner.precompile("sandboxedHandler", sourceToCall);
   return {
-    callable,
     callMap,
-    context,
-    isolate,
     nextCallId: 1,
-    timeoutMs: config.timeout ?? 5000
+    runner,
+    source: sourceToCall,
+    timeoutMs
   };
 };
 var runBridgeFetch = async (config, url, init) => {
@@ -1220,10 +1250,7 @@ var makeSandboxedHandler = (source, config = {}, engineExtras) => {
   const bridgeFetch = engineExtras?.bridgeFetch;
   const getCompiled = async () => {
     if (pending !== undefined) {
-      const compiled = await pending;
-      if (!compiled.isolate.isDisposed)
-        return compiled;
-      pending = undefined;
+      return pending;
     }
     pending = compile(source, config, bridgeFetch);
     return pending;
@@ -1234,9 +1261,13 @@ var makeSandboxedHandler = (source, config = {}, engineExtras) => {
     compiled.callMap.set(callId, actions);
     if (metricsHook === undefined) {
       try {
-        return await compiled.callable.call([callId, args, ctx], {
-          timeout: compiled.timeoutMs
-        });
+        return await compiled.runner.call("sandboxedHandler", compiled.source, [callId, args, ctx], { run: { timeout: compiled.timeoutMs } });
+      } catch (error) {
+        if (isIsolateDisposalError(error)) {
+          pending = undefined;
+          await disposeCompiled(compiled);
+        }
+        throw error;
       } finally {
         compiled.callMap.delete(callId);
       }
@@ -1244,8 +1275,9 @@ var makeSandboxedHandler = (source, config = {}, engineExtras) => {
     const startedAt = performance.now();
     const id = makeRandomId();
     try {
-      const { result, metrics } = await compiled.callable.callWithMetrics([callId, args, ctx], { timeout: compiled.timeoutMs });
+      const { result, metrics } = await compiled.runner.call("sandboxedHandler", compiled.source, [callId, args, ctx], { run: { timeout: compiled.timeoutMs }, withMetrics: true });
       fireMetrics(metricsHook.onMetrics, {
+        backend: metrics.backend,
         cpuMs: metrics.cpuMs,
         durationMs: performance.now() - startedAt,
         heapBytes: metrics.heapBytes,
@@ -1256,6 +1288,10 @@ var makeSandboxedHandler = (source, config = {}, engineExtras) => {
       });
       return result;
     } catch (error) {
+      if (isIsolateDisposalError(error)) {
+        pending = undefined;
+        await disposeCompiled(compiled);
+      }
       fireMetrics(metricsHook.onMetrics, {
         cpuMs: 0,
         durationMs: performance.now() - startedAt,
@@ -1274,6 +1310,12 @@ var makeSandboxedHandler = (source, config = {}, engineExtras) => {
   };
 };
 var makeRandomId = () => `hm_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
+var isIsolateDisposalError = (error) => error instanceof Error && (error.name === "TimeoutError" || error.name === "MemoryLimitError" || error.name === "IsolateDisposedError");
+var disposeCompiled = async (compiled) => {
+  try {
+    await compiled.runner.dispose();
+  } catch {}
+};
 var fireMetrics = (hook, record) => {
   let outcome;
   try {
@@ -1388,6 +1430,8 @@ var createSyncEngine = (options = {}) => {
   const writers = new Map;
   const readers = new Map;
   const schedules = new Map;
+  const packTableOwners = new Map;
+  const registeredPacks = [];
   const permissions = new Map;
   for (const [table, rules] of Object.entries(options.permissions ?? {})) {
     permissions.set(table, rules);
@@ -2119,7 +2163,7 @@ var createSyncEngine = (options = {}) => {
       }
     };
   };
-  return {
+  const engine = {
     register: (collection) => {
       registry.set(collection.name, collection);
       for (const table of collection.tables ?? [collection.name]) {
@@ -2394,13 +2438,136 @@ var createSyncEngine = (options = {}) => {
         throw new Error(`Unknown schedule "${name}"`);
       }
       const runHandler = async (tx) => {
-        const { actions, buffered: buffered2 } = makeActions(tx, {}, false);
+        const { actions, buffered } = makeActions(tx, {}, false);
         const db = makeReadHandle({}, new Set, new Set, [], false);
         await schedule.run({ actions, db });
-        return buffered2;
+        return buffered;
       };
-      const buffered = runInTransaction !== undefined ? await runInTransaction((tx) => runHandler(tx)) : await runHandler(undefined);
-      await applyChangeBatch(buffered);
+      const retry = schedule.retry;
+      const maxAttempts = retry === undefined ? 1 : retry.maxAttempts ?? 5;
+      const isRetryable = retry?.isRetryable ?? isSerializationFailure;
+      const computeDelay = retry?.backoff ?? exponentialBackoff();
+      const maxElapsedMs = retry?.maxElapsedMs ?? 30000;
+      const startedAt = Date.now();
+      let lastError;
+      let attemptsMade = 0;
+      for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+        attemptsMade = attempt;
+        try {
+          const buffered = runInTransaction !== undefined ? await runInTransaction((tx) => runHandler(tx)) : await runHandler(undefined);
+          await applyChangeBatch(buffered);
+          emitActivity({
+            type: "schedule",
+            at: Date.now(),
+            name,
+            status: "ok"
+          });
+          return;
+        } catch (error) {
+          lastError = error;
+          const elapsedMs = Date.now() - startedAt;
+          const canRetry = attempt < maxAttempts && isRetryable(error) && elapsedMs < maxElapsedMs;
+          if (!canRetry)
+            break;
+          const rawDelay = computeDelay(attempt);
+          const remaining = maxElapsedMs - elapsedMs;
+          if (remaining <= 0)
+            break;
+          const delayMs = Math.max(0, Math.min(rawDelay, remaining));
+          emitActivity({
+            type: "scheduleRetry",
+            at: Date.now(),
+            name,
+            attempt,
+            delayMs,
+            errorName: error instanceof Error ? error.name : "Error",
+            errorMessage: error instanceof Error ? error.message : String(error)
+          });
+          if (delayMs > 0) {
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+          }
+        }
+      }
+      emitActivity({
+        type: "schedule",
+        at: Date.now(),
+        name,
+        status: "error"
+      });
+      if (attemptsMade > 1) {
+        throw new RetriesExhaustedError(attemptsMade, Date.now() - startedAt, lastError);
+      }
+      throw lastError;
+    },
+    registerPack: (pack) => {
+      for (const table of pack.ownsTables) {
+        const existing = packTableOwners.get(table);
+        if (existing !== undefined) {
+          throw new PackTableConflictError(table, existing, pack.name);
+        }
+      }
+      if (pack.requireDependencies === true) {
+        for (const table of pack.readsTables ?? []) {
+          if (!readers.has(table)) {
+            throw new PackMissingDependencyError(pack.name, table);
+          }
+        }
+      }
+      if (pack.schemas !== undefined) {
+        for (const [table, schema] of Object.entries(pack.schemas)) {
+          engine.registerSchema(table, schema);
+        }
+      }
+      if (pack.permissions !== undefined) {
+        for (const [table, rules] of Object.entries(pack.permissions)) {
+          engine.registerPermissions(table, rules);
+        }
+      }
+      if (pack.readers !== undefined) {
+        for (const [table, reader] of Object.entries(pack.readers)) {
+          engine.registerReader(table, reader);
+        }
+      }
+      if (pack.writers !== undefined) {
+        for (const [table, writer] of Object.entries(pack.writers)) {
+          engine.registerWriter(table, writer);
+        }
+      }
+      if (pack.crdt !== undefined) {
+        for (const [table, fields] of Object.entries(pack.crdt)) {
+          engine.registerCrdt(table, fields);
+        }
+      }
+      for (const collection of pack.collections ?? []) {
+        engine.register(collection);
+      }
+      for (const collection of pack.joinCollections ?? []) {
+        engine.registerJoin(collection);
+      }
+      for (const collection of pack.graphCollections ?? []) {
+        engine.registerGraph(collection);
+      }
+      for (const collection of pack.searchCollections ?? []) {
+        engine.registerSearch(collection);
+      }
+      for (const query2 of pack.reactiveQueries ?? []) {
+        engine.registerReactive(query2);
+      }
+      for (const mutation of pack.mutations ?? []) {
+        engine.registerMutation(mutation);
+      }
+      for (const schedule of pack.schedules ?? []) {
+        engine.registerSchedule(schedule);
+      }
+      for (const table of pack.ownsTables) {
+        packTableOwners.set(table, pack.name);
+      }
+      registeredPacks.push({
+        name: pack.name,
+        version: pack.version,
+        ownsTables: [...pack.ownsTables],
+        readsTables: [...pack.readsTables ?? []]
+      });
     },
     inspect: () => {
       const collections = [...registry.entries()].map(([name, def]) => {
@@ -2440,6 +2607,12 @@ var createSyncEngine = (options = {}) => {
           version: entry.version,
           table: entry.table,
           op: entry.change.op
+        })),
+        packs: registeredPacks.map((pack) => ({
+          name: pack.name,
+          version: pack.version,
+          ownsTables: [...pack.ownsTables],
+          readsTables: [...pack.readsTables]
         }))
       };
     },
@@ -2526,6 +2699,7 @@ var createSyncEngine = (options = {}) => {
       };
     }
   };
+  return engine;
 };
 // src/engine/cdc.ts
 import { Elysia } from "elysia";
@@ -2875,6 +3049,7 @@ export {
   filterOp,
   field,
   exponentialBackoff,
+  defineSyncPack,
   defineSearchCollection,
   defineSchema,
   defineSchedule,
@@ -2900,9 +3075,11 @@ export {
   SchemaError,
   SEARCH_SCORE_FIELD,
   RetriesExhaustedError,
+  PackTableConflictError,
+  PackMissingDependencyError,
   MissedChangesError,
   CdcConsumerSlowError
 };
 
-//# debugId=783626175939945A64756E2164756E21
+//# debugId=3D4E309EDB79002E64756E2164756E21
 //# sourceMappingURL=index.js.map