@absolutejs/sync 2.2.2 → 2.4.0

package/dist/platform.js

@@ -0,0 +1,3162 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = import.meta.require;
+
+// src/platform.ts
+import { Type } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+import { Elysia as Elysia3 } from "elysia";
+
+// node_modules/@absolutejs/telemetry/dist/index.js
+var NOOP_SPAN_CONTEXT = {
+  spanId: "0000000000000000",
+  traceFlags: 0,
+  traceId: "00000000000000000000000000000000"
+};
+var noopSpan = {
+  addEvent: () => noopSpan,
+  end: () => {},
+  isRecording: () => false,
+  recordException: () => {},
+  setAttribute: () => noopSpan,
+  setAttributes: () => noopSpan,
+  setStatus: () => noopSpan,
+  spanContext: () => NOOP_SPAN_CONTEXT,
+  updateName: () => noopSpan
+};
+var startActiveSpanNoop = (_name, optionsOrFn, maybeFn) => {
+  const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+  return fn(noopSpan);
+};
+var noopTracer = {
+  startActiveSpan: startActiveSpanNoop,
+  startSpan: () => noopSpan
+};
+var tracerOrNoop = (provider, name, version) => provider !== undefined ? provider.getTracer(name, version) : noopTracer;
+var ABS_ATTRS = {
+  tenant: "abs.tenant",
+  shardId: "abs.shard.id",
+  engineId: "abs.engine.id",
+  collection: "abs.collection",
+  mutation: "abs.mutation",
+  mutationAttempt: "abs.mutation.attempt",
+  subscriptionId: "abs.subscription.id",
+  batchSize: "abs.batch.size",
+  clusterMessageOrigin: "abs.cluster.origin",
+  jobId: "abs.job.id",
+  jobKind: "abs.job.kind",
+  jobAttempt: "abs.job.attempt",
+  jobMaxAttempts: "abs.job.max_attempts",
+  workerId: "abs.worker.id",
+  runtimeKey: "abs.runtime.key",
+  runtimePid: "abs.runtime.pid",
+  runtimePort: "abs.runtime.port",
+  runtimeExitReason: "abs.runtime.exit_reason",
+  runtimeReadinessMs: "abs.runtime.readiness_ms",
+  routeShard: "abs.route.shard",
+  routeDecision: "abs.route.decision",
+  secretName: "abs.secret.name",
+  secretFingerprint: "abs.secret.fingerprint",
+  auditKind: "abs.audit.kind"
+};
+
+// src/engine/equiJoin.ts
+var shallowEqual = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+    return false;
+  }
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  return aKeys.length === bKeys.length && aKeys.every((key) => a[key] === b[key]);
+};
+var addToIndex = (index, joinValue, key) => {
+  let bucket = index.get(joinValue);
+  if (bucket === undefined) {
+    bucket = new Set;
+    index.set(joinValue, bucket);
+  }
+  bucket.add(key);
+};
+var removeFromIndex = (index, joinValue, key) => {
+  const bucket = index.get(joinValue);
+  if (bucket === undefined) {
+    return;
+  }
+  bucket.delete(key);
+  if (bucket.size === 0) {
+    index.delete(joinValue);
+  }
+};
+var createEquiJoin = (options) => {
+  const { leftKey, rightKey, leftOn, rightOn, select, selectUnmatched } = options;
+  const equals = options.equals ?? shallowEqual;
+  const lefts = new Map;
+  const rights = new Map;
+  const leftByJoin = new Map;
+  const rightByJoin = new Map;
+  const output = new Map;
+  const outByLeft = new Map;
+  const outKey = (lk, rk) => `${lk} ${rk}`;
+  const unmatchedKey = (lk) => `${lk}  ~`;
+  const leftOutputs = (lk, left) => {
+    const result = new Map;
+    const rks = rightByJoin.get(leftOn(left));
+    if (rks !== undefined && rks.size > 0) {
+      for (const rk of rks) {
+        const right = rights.get(rk);
+        if (right !== undefined) {
+          result.set(outKey(lk, rk), select(left, right));
+        }
+      }
+    } else if (selectUnmatched !== undefined) {
+      result.set(unmatchedKey(lk), selectUnmatched(left));
+    }
+    return result;
+  };
+  const reconcileLeft = (lk, after) => {
+    const before = outByLeft.get(lk) ?? new Set;
+    const added = [];
+    const removed = [];
+    const changed = [];
+    for (const [ok, value] of after) {
+      const previous = output.get(ok);
+      if (previous === undefined) {
+        added.push(value);
+      } else if (!equals(previous, value)) {
+        changed.push(value);
+      }
+      output.set(ok, value);
+    }
+    for (const ok of before) {
+      if (!after.has(ok)) {
+        const previous = output.get(ok);
+        if (previous !== undefined) {
+          removed.push(previous);
+          output.delete(ok);
+        }
+      }
+    }
+    if (after.size === 0) {
+      outByLeft.delete(lk);
+    } else {
+      outByLeft.set(lk, new Set(after.keys()));
+    }
+    return { added, removed, changed };
+  };
+  const mergeInto = (target, diff) => {
+    target.added.push(...diff.added);
+    target.removed.push(...diff.removed);
+    target.changed.push(...diff.changed);
+  };
+  return {
+    hydrate: (left, right) => {
+      lefts.clear();
+      rights.clear();
+      leftByJoin.clear();
+      rightByJoin.clear();
+      output.clear();
+      outByLeft.clear();
+      for (const right_ of right) {
+        const rk = rightKey(right_);
+        rights.set(rk, right_);
+        addToIndex(rightByJoin, rightOn(right_), rk);
+      }
+      for (const left_ of left) {
+        const lk = leftKey(left_);
+        lefts.set(lk, left_);
+        addToIndex(leftByJoin, leftOn(left_), lk);
+        const outs = leftOutputs(lk, left_);
+        for (const [ok, value] of outs) {
+          output.set(ok, value);
+        }
+        if (outs.size > 0) {
+          outByLeft.set(lk, new Set(outs.keys()));
+        }
+      }
+    },
+    applyLeft: ({ op, row }) => {
+      const lk = leftKey(row);
+      const existing = lefts.get(lk);
+      if (existing !== undefined) {
+        removeFromIndex(leftByJoin, leftOn(existing), lk);
+      }
+      if (op === "delete") {
+        lefts.delete(lk);
+      } else {
+        lefts.set(lk, row);
+        addToIndex(leftByJoin, leftOn(row), lk);
+      }
+      const after = op === "delete" ? new Map : leftOutputs(lk, row);
+      return reconcileLeft(lk, after);
+    },
+    applyRight: ({ op, row }) => {
+      const rk = rightKey(row);
+      const existing = rights.get(rk);
+      const affected = new Set;
+      const addAffected = (joinValue) => {
+        for (const lk of leftByJoin.get(joinValue) ?? []) {
+          affected.add(lk);
+        }
+      };
+      if (existing !== undefined) {
+        addAffected(rightOn(existing));
+        removeFromIndex(rightByJoin, rightOn(existing), rk);
+      }
+      if (op === "delete") {
+        rights.delete(rk);
+      } else {
+        rights.set(rk, row);
+        addToIndex(rightByJoin, rightOn(row), rk);
+        addAffected(rightOn(row));
+      }
+      const diff = { added: [], removed: [], changed: [] };
+      for (const lk of affected) {
+        const left = lefts.get(lk);
+        if (left !== undefined) {
+          mergeInto(diff, reconcileLeft(lk, leftOutputs(lk, left)));
+        }
+      }
+      return diff;
+    },
+    rows: () => [...output.values()],
+    size: () => output.size
+  };
+};
+
+// src/engine/materializedView.ts
+var emptyDiff = () => ({
+  added: [],
+  removed: [],
+  changed: []
+});
+var shallowEqual2 = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+    return false;
+  }
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) {
+    return false;
+  }
+  return aKeys.every((key) => a[key] === b[key]);
+};
+var isEmptyViewDiff = (diff) => diff.added.length === 0 && diff.removed.length === 0 && diff.changed.length === 0;
+var createMaterializedView = (options) => {
+  const { key, match } = options;
+  const equals = options.equals ?? shallowEqual2;
+  const set = new Map;
+  return {
+    hydrate: (rows) => {
+      set.clear();
+      for (const row of rows) {
+        set.set(key(row), row);
+      }
+    },
+    reset: (rows) => {
+      const next = new Map;
+      const added = [];
+      const changed = [];
+      for (const row of rows) {
+        const rowKey = key(row);
+        next.set(rowKey, row);
+        const previous = set.get(rowKey);
+        if (previous === undefined) {
+          added.push(row);
+        } else if (!equals(previous, row)) {
+          changed.push(row);
+        }
+      }
+      const removed = [];
+      for (const [rowKey, previous] of set) {
+        if (!next.has(rowKey)) {
+          removed.push(previous);
+        }
+      }
+      set.clear();
+      for (const [rowKey, row] of next) {
+        set.set(rowKey, row);
+      }
+      return { added, removed, changed };
+    },
+    apply: ({ op, row }) => {
+      const rowKey = key(row);
+      const existing = set.get(rowKey);
+      if (op === "delete") {
+        if (existing === undefined) {
+          return emptyDiff();
+        }
+        set.delete(rowKey);
+        return { added: [], removed: [existing], changed: [] };
+      }
+      if (match(row)) {
+        set.set(rowKey, row);
+        return existing === undefined ? { added: [row], removed: [], changed: [] } : { added: [], removed: [], changed: [row] };
+      }
+      if (existing !== undefined) {
+        set.delete(rowKey);
+        return { added: [], removed: [existing], changed: [] };
+      }
+      return emptyDiff();
+    },
+    rows: () => [...set.values()],
+    size: () => set.size
+  };
+};
+
+// src/engine/retry.ts
+var PG_RETRY_CODES = new Set(["40001", "40P01"]);
+var isSerializationFailure = (error) => {
+  if (error === null || typeof error !== "object")
+    return false;
+  const code = error.code;
+  if (typeof code === "string" && PG_RETRY_CODES.has(code))
+    return true;
+  const cause = error.cause;
+  if (cause !== undefined)
+    return isSerializationFailure(cause);
+  return false;
+};
+var exponentialBackoff = (options = {}) => (attempt) => {
+  const base = options.baseMs ?? 25;
+  const factor = options.factor ?? 2;
+  const max = options.maxMs ?? 1000;
+  const jitter = options.jitter ?? 0.2;
+  const raw = Math.min(max, base * factor ** Math.max(0, attempt - 1));
+  const spread = raw * jitter;
+  return raw + (Math.random() * 2 - 1) * spread;
+};
+
+class RetriesExhaustedError extends Error {
+  attempts;
+  elapsedMs;
+  cause;
+  constructor(attempts, elapsedMs, cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    super(`retries exhausted after ${attempts} attempts (${elapsedMs}ms): ${message}`);
+    this.name = "RetriesExhaustedError";
+    this.attempts = attempts;
+    this.elapsedMs = elapsedMs;
+    this.cause = cause;
+  }
+}
+
+// src/engine/sandbox.ts
+var isolatedJscModule;
+var loadIsolatedJsc = async () => {
+  if (isolatedJscModule !== undefined)
+    return isolatedJscModule;
+  try {
+    isolatedJscModule = await import("@absolutejs/isolated-jsc");
+    return isolatedJscModule;
+  } catch (error) {
+    throw new Error('sandboxedHandler requires the optional peer "@absolutejs/isolated-jsc". Install it with: bun add @absolutejs/isolated-jsc', { cause: error });
+  }
+};
+var wrap = (source) => `
+	function (__callId, args, ctx) {
+		const userFn = (${source});
+		if (typeof userFn !== 'function') {
+			throw new Error(
+				'sandboxedHandler must evaluate to (args, ctx, actions, unsafeHost) => result; got ' +
+					typeof userFn
+			);
+		}
+		const actions = {
+			insert: (table, data) => __dispatch(__callId, 'insert', table, data),
+			update: (table, data) => __dispatch(__callId, 'update', table, data),
+			delete: (table, row) => __dispatch(__callId, 'delete', table, row),
+			change: (collection, change) => __dispatch(__callId, 'change', collection, change),
+			now: () => __dispatch(__callId, 'now'),
+			fetch: (url, init) => __dispatch(__callId, 'fetch', url, init)
+		};
+		// Escape hatch \u2014 host fns the mutation explicitly opted in to.
+		// The Proxy means every property access is a host call; the
+		// engine throws if the property name isn't declared in the
+		// mutation's sandbox.unsafeHost map.
+		const unsafeHost = new Proxy({}, {
+			get: (_target, fnName) => {
+				if (typeof fnName !== 'string') return undefined;
+				return (...callArgs) =>
+					__dispatch(__callId, 'unsafeHost', fnName, callArgs);
+			}
+		});
+		return userFn(args, ctx, actions, unsafeHost);
+	}
+`;
+var compile = async (source, config, bridgeFetch) => {
+  const { Reference, createIsolatedRunner, resolveIsolatePolicy } = await loadIsolatedJsc();
+  const callMap = new Map;
+  const unsafeHost = config.unsafeHost;
+  const dispatch = new Reference((callId, op, ...rest) => {
+    const a = callMap.get(callId);
+    if (a === undefined) {
+      throw new Error(`__dispatch invoked for orphan callId ${String(callId)}`);
+    }
+    switch (op) {
+      case "insert":
+        return a.insert(rest[0], rest[1]);
+      case "update":
+        return a.update(rest[0], rest[1]);
+      case "delete":
+        return a.delete(rest[0], rest[1]);
+      case "change":
+        return a.change(rest[0], rest[1]);
+      case "now":
+        return a.now();
+      case "fetch":
+        return runBridgeFetch(bridgeFetch, rest[0], rest[1]);
+      case "unsafeHost": {
+        const fnName = rest[0];
+        const callArgs = rest[1] ?? [];
+        if (unsafeHost === undefined || typeof unsafeHost[fnName] !== "function") {
+          throw new Error(`sandboxedHandler called unsafeHost.${fnName}() but it was not declared in the mutation's sandbox.unsafeHost config. Declare it (and only the host fns you intend to expose) to opt in to the escape hatch.`);
+        }
+        return unsafeHost[fnName](...callArgs);
+      }
+      default:
+        throw new Error(`unknown sandbox action op: ${String(op)}`);
+    }
+  });
+  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 {
+    callMap,
+    nextCallId: 1,
+    runner,
+    source: sourceToCall,
+    timeoutMs
+  };
+};
+var runBridgeFetch = async (config, url, init) => {
+  if (config === undefined) {
+    throw new Error("actions.fetch called but the engine has no `bridgeFetch` config \u2014 " + "pass `bridgeFetch: { ... }` to createSyncEngine.");
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`actions.fetch: invalid URL "${String(url)}"`);
+  }
+  const endpoint = config[parsed.hostname] ?? (Object.prototype.hasOwnProperty.call(config, "*") ? config["*"] : undefined);
+  if (endpoint === undefined) {
+    throw new Error(`actions.fetch: hostname "${parsed.hostname}" is not allowlisted in bridgeFetch config`);
+  }
+  const headers = { ...endpoint.headers ?? {} };
+  if (init?.headers !== undefined) {
+    const incoming = init.headers;
+    for (const [name, value] of Object.entries(incoming)) {
+      if (name.toLowerCase() === "authorization")
+        continue;
+      headers[name] = value;
+    }
+  }
+  if (endpoint.authorization !== undefined) {
+    let auth;
+    try {
+      auth = await endpoint.authorization();
+    } catch {
+      throw new Error("actions.fetch: authorization callback failed");
+    }
+    headers.Authorization = auth;
+  }
+  const response = await fetch(url, { ...init, headers });
+  const responseHeaders = {};
+  response.headers.forEach((value, name) => {
+    responseHeaders[name] = value;
+  });
+  const body = await response.text();
+  return {
+    body,
+    headers: responseHeaders,
+    ok: response.ok,
+    status: response.status,
+    statusText: response.statusText,
+    url: response.url
+  };
+};
+var makeSandboxedHandler = (source, config = {}, engineExtras) => {
+  let pending;
+  const metricsHook = engineExtras?.metricsHook;
+  const bridgeFetch = engineExtras?.bridgeFetch;
+  const getCompiled = async () => {
+    if (pending !== undefined) {
+      return pending;
+    }
+    pending = compile(source, config, bridgeFetch);
+    return pending;
+  };
+  return async (args, ctx, actions) => {
+    const compiled = await getCompiled();
+    const callId = compiled.nextCallId++;
+    compiled.callMap.set(callId, actions);
+    if (metricsHook === undefined) {
+      try {
+        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);
+      }
+    }
+    const startedAt = performance.now();
+    const id = makeRandomId();
+    try {
+      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,
+        id,
+        mutationName: metricsHook.mutationName,
+        ok: true,
+        timestamp: Date.now()
+      });
+      return result;
+    } catch (error) {
+      if (isIsolateDisposalError(error)) {
+        pending = undefined;
+        await disposeCompiled(compiled);
+      }
+      fireMetrics(metricsHook.onMetrics, {
+        cpuMs: 0,
+        durationMs: performance.now() - startedAt,
+        errorMessage: error instanceof Error ? error.message : String(error),
+        errorName: error instanceof Error ? error.name : "Error",
+        heapBytes: 0,
+        id,
+        mutationName: metricsHook.mutationName,
+        ok: false,
+        timestamp: Date.now()
+      });
+      throw error;
+    } finally {
+      compiled.callMap.delete(callId);
+    }
+  };
+};
+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 {
+    outcome = hook(record);
+  } catch {
+    return;
+  }
+  if (outcome instanceof Promise) {
+    outcome.catch(() => {});
+  }
+};
+
+// 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/search.ts
+var SEARCH_SCORE_FIELD = "_score";
+var defineSearchCollection = (definition) => ({
+  ...definition,
+  kind: "search"
+});
+
+// src/engine/migrate.ts
+class EngineFencedError extends Error {
+  reason;
+  constructor(reason) {
+    super(`[sync] Engine is fenced for migration: ${reason}`);
+    this.name = "EngineFencedError";
+    this.reason = reason;
+  }
+}
+
+// src/engine/syncEngine.ts
+class UnauthorizedError extends Error {
+  constructor(subject) {
+    super(`Not authorized: ${subject}`);
+    this.name = "UnauthorizedError";
+  }
+}
+
+class AbortError extends Error {
+  constructor(reason) {
+    super(reason ?? "Aborted");
+    this.name = "AbortError";
+  }
+}
+var checkAborted = (signal) => {
+  if (signal?.aborted) {
+    throw new AbortError(signal.reason instanceof Error ? signal.reason.message : typeof signal.reason === "string" ? signal.reason : "Aborted");
+  }
+};
+var linkAbortToUnsubscribe = (signal, unsubscribe) => {
+  if (signal === undefined)
+    return;
+  if (signal.aborted) {
+    unsubscribe();
+    return;
+  }
+  const handler = () => {
+    try {
+      unsubscribe();
+    } catch {}
+  };
+  signal.addEventListener("abort", handler, { once: true });
+};
+
+class SchemaError extends Error {
+  constructor(table, fieldName) {
+    super(`Schema violation on "${table}": invalid field "${fieldName}"`);
+    this.name = "SchemaError";
+  }
+}
+
+class MissedChangesError extends Error {
+  requestedSince;
+  availableSince;
+  constructor(requestedSince, availableSince) {
+    super(`Change log no longer covers version ${requestedSince}; oldest available is ${availableSince}. ` + `Re-bootstrap and resume from ${availableSince}.`);
+    this.name = "MissedChangesError";
+    this.requestedSince = requestedSince;
+    this.availableSince = availableSince;
+  }
+}
+
+class CdcConsumerSlowError extends Error {
+  maxBuffer;
+  lastDeliveredVersion;
+  constructor(maxBuffer, lastDeliveredVersion) {
+    super(`CDC stream buffer overflowed (max ${maxBuffer}); consumer fell behind. ` + `Last delivered version: ${lastDeliveredVersion}. Resubscribe with since=${lastDeliveredVersion}.`);
+    this.name = "CdcConsumerSlowError";
+    this.maxBuffer = maxBuffer;
+    this.lastDeliveredVersion = lastDeliveredVersion;
+  }
+}
+
+class MutationQueueOverflowError extends Error {
+  queueLimit;
+  constructor(queueLimit) {
+    super(`Mutation queue overflowed (limit ${queueLimit}); the engine is at ` + `its mutationConcurrency cap and the waiting queue is full. ` + `Retry later or shed load at the gateway.`);
+    this.name = "MutationQueueOverflowError";
+    this.queueLimit = queueLimit;
+  }
+}
+
+class SubscriptionLimitError extends Error {
+  tenantKey;
+  limit;
+  active;
+  constructor(tenantKey, limit, active) {
+    super(`Tenant "${tenantKey}" is at the subscription cap ` + `(${active}/${limit}). Close an existing subscription before opening another.`);
+    this.name = "SubscriptionLimitError";
+    this.tenantKey = tenantKey;
+    this.limit = limit;
+    this.active = active;
+  }
+}
+var defaultKey = (row) => row.id;
+var shallowEqual3 = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+    return false;
+  }
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  return aKeys.length === bKeys.length && aKeys.every((k) => a[k] === b[k]);
+};
+var subKeyIds = new WeakMap;
+var subKeyCounter = 0;
+var stableValueKey = (value) => {
+  if (value === undefined)
+    return "u";
+  if (value === null)
+    return "n";
+  const tag = typeof value;
+  if (tag === "string")
+    return `s:${value}`;
+  if (tag === "number" || tag === "boolean" || tag === "bigint") {
+    return `${tag[0]}:${String(value)}`;
+  }
+  if (tag !== "object")
+    return `${tag[0]}:fn`;
+  try {
+    return `o:${JSON.stringify(value, (_k, v) => {
+      if (v === null || typeof v !== "object" || Array.isArray(v))
+        return v;
+      const record = v;
+      const sorted = {};
+      for (const key of Object.keys(record).sort()) {
+        sorted[key] = record[key];
+      }
+      return sorted;
+    })}`;
+  } catch {
+    const obj = value;
+    let id = subKeyIds.get(obj);
+    if (id === undefined) {
+      subKeyCounter += 1;
+      id = `i${subKeyCounter}`;
+      subKeyIds.set(obj, id);
+    }
+    return `i:${id}`;
+  }
+};
+var stableSubKey = (collection, params, ctx) => `${collection}|${stableValueKey(params)}|${stableValueKey(ctx)}`;
+var equalsIgnoringScore = (a, b) => {
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+    return a === b;
+  }
+  const strip = (value) => Object.keys(value).filter((k) => k !== SEARCH_SCORE_FIELD);
+  const aKeys = strip(a);
+  const bKeys = strip(b);
+  return aKeys.length === bKeys.length && aKeys.every((k) => a[k] === b[k]);
+};
+var createSyncEngine = (options = {}) => {
+  const registry = new Map;
+  const mutations = new Map;
+  const sandboxRunners = new Map;
+  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);
+  }
+  const readRuleFor = (table) => permissions.get(table)?.read;
+  const writeRuleFor = (table, op) => {
+    const rules = permissions.get(table);
+    return rules?.[op] ?? rules?.write;
+  };
+  const schemas = new Map;
+  for (const [table, schema] of Object.entries(options.schemas ?? {})) {
+    schemas.set(table, schema);
+  }
+  const crdtFields = new Map;
+  const validateWrite = (table, op, row) => {
+    const schema = schemas.get(table);
+    if (schema === undefined || typeof row !== "object" || row === null) {
+      return;
+    }
+    const record = row;
+    for (const [fieldName, validate] of Object.entries(schema.fields)) {
+      const present = fieldName in record;
+      if (op === "update" && !present) {
+        continue;
+      }
+      if (!validate(record[fieldName])) {
+        throw new SchemaError(table, fieldName);
+      }
+    }
+  };
+  const migrateRow = (table, row) => {
+    const migrate = schemas.get(table)?.migrate;
+    return migrate ? migrate(row) : row;
+  };
+  const reactiveSubs = new Set;
+  const searchSubs = new Set;
+  const searchIndexes = new Map;
+  const active = new Map;
+  const tableIndex = new Map;
+  const changeLogSize = options.changeLogSize ?? 1024;
+  const changeLogRetainMs = options.changeLogRetainMs ?? null;
+  const changeLog = [];
+  let version = 0;
+  const engineStartedAt = Date.now();
+  let mutationsCompleted = 0;
+  let mutationsFailed = 0;
+  let mutationsRetried = 0;
+  let mutationsInFlight = 0;
+  let connectedSources = 0;
+  let sourceChangesReceived = 0;
+  let sourceLastChangeAt = null;
+  const mutationWaiters = [];
+  let mutationsQueued = 0;
+  const activeFences = new Set;
+  const acquireMutationSlot = async () => {
+    const limit = options.mutationConcurrency;
+    if (limit === undefined) {
+      mutationsInFlight += 1;
+      return;
+    }
+    if (mutationsInFlight < limit && mutationWaiters.length === 0) {
+      mutationsInFlight += 1;
+      return;
+    }
+    const queueLimit = options.mutationQueueLimit;
+    if (queueLimit !== undefined && mutationsQueued >= queueLimit) {
+      throw new MutationQueueOverflowError(queueLimit);
+    }
+    mutationsQueued += 1;
+    try {
+      await new Promise((resolve) => {
+        mutationWaiters.push(resolve);
+      });
+    } finally {
+      mutationsQueued -= 1;
+    }
+    mutationsInFlight += 1;
+  };
+  const releaseMutationSlot = () => {
+    mutationsInFlight -= 1;
+    if (options.mutationConcurrency === undefined)
+      return;
+    const next = mutationWaiters.shift();
+    if (next !== undefined)
+      next();
+  };
+  const subscriptionsByTenant = new Map;
+  const acquireSubscriptionSlot = (ctx, args) => {
+    const cap = options.subscriptionLimit;
+    if (cap === undefined)
+      return;
+    const tenantKey = cap.key(ctx, args);
+    if (tenantKey === undefined)
+      return;
+    const active2 = subscriptionsByTenant.get(tenantKey) ?? 0;
+    if (active2 >= cap.max) {
+      throw new SubscriptionLimitError(tenantKey, cap.max, active2);
+    }
+    subscriptionsByTenant.set(tenantKey, active2 + 1);
+    return tenantKey;
+  };
+  const releaseSubscriptionSlot = (tenantKey) => {
+    if (tenantKey === undefined)
+      return;
+    const active2 = subscriptionsByTenant.get(tenantKey);
+    if (active2 === undefined || active2 <= 1) {
+      subscriptionsByTenant.delete(tenantKey);
+    } else {
+      subscriptionsByTenant.set(tenantKey, active2 - 1);
+    }
+  };
+  const reactiveCacheMax = options.reactiveCache?.max ?? 256;
+  const reactiveCacheTtlMs = options.reactiveCache?.ttlMs ?? 60000;
+  const cachedReruns = new Map;
+  const touchCacheEntry = (key, entry) => {
+    cachedReruns.delete(key);
+    cachedReruns.set(key, entry);
+  };
+  const readCacheEntry = (key) => {
+    if (reactiveCacheMax <= 0)
+      return;
+    const entry = cachedReruns.get(key);
+    if (entry === undefined)
+      return;
+    if (reactiveCacheTtlMs > 0 && entry.expiresAt < Date.now()) {
+      cachedReruns.delete(key);
+      return;
+    }
+    touchCacheEntry(key, entry);
+    return entry;
+  };
+  const writeCacheEntry = (entry) => {
+    if (reactiveCacheMax <= 0)
+      return;
+    cachedReruns.set(entry.rerunKey, entry);
+    while (cachedReruns.size > reactiveCacheMax) {
+      const oldest = cachedReruns.keys().next().value;
+      if (oldest === undefined)
+        break;
+      cachedReruns.delete(oldest);
+    }
+  };
+  const activityListeners = new Set;
+  const emitActivity = (event) => {
+    for (const listener of activityListeners) {
+      listener(event);
+    }
+  };
+  const streamSubscribers = new Set;
+  const runInTransaction = options.transaction;
+  const instanceId = options.instanceId ?? globalThis.crypto?.randomUUID?.() ?? `i${Math.random()}`;
+  let clusterBus;
+  const tracer = tracerOrNoop(options.tracerProvider, "@absolutejs/sync");
+  const importChangeLog = (snapshot) => {
+    if (version !== 0) {
+      throw new Error(`[sync] importChangeLog: engine already has version ${version}; ` + `restore must happen before any local writes commit.`);
+    }
+    if (snapshot.instanceId !== instanceId) {
+      throw new Error(`[sync] importChangeLog: snapshot instanceId "${snapshot.instanceId}" ` + `does not match this engine's instanceId "${instanceId}". ` + `Pass options.instanceId = "${snapshot.instanceId}" to createSyncEngine.`);
+    }
+    version = snapshot.version;
+    for (const entry of snapshot.entries) {
+      changeLog.push(entry);
+    }
+    while (changeLog.length > changeLogSize) {
+      changeLog.shift();
+    }
+    if (changeLogRetainMs !== null && changeLogRetainMs > 0) {
+      const cutoff = Date.now() - changeLogRetainMs;
+      while (changeLog.length > 0 && changeLog[0].at < cutoff) {
+        changeLog.shift();
+      }
+    }
+    return snapshot.entries.length;
+  };
+  if (options.initialChangeLog !== undefined) {
+    importChangeLog(options.initialChangeLog);
+  }
+  const broadcast = (changes, originVersion) => {
+    if (clusterBus !== undefined && changes.length > 0) {
+      clusterBus.publish({
+        changes,
+        origin: instanceId,
+        originVersion
+      });
+    }
+  };
+  const subsFor = (collection) => {
+    let set = active.get(collection);
+    if (set === undefined) {
+      set = new Set;
+      active.set(collection, set);
+    }
+    return set;
+  };
+  const addTableIndex = (table, name) => {
+    let set = tableIndex.get(table);
+    if (set === undefined) {
+      set = new Set;
+      tableIndex.set(table, set);
+    }
+    set.add(name);
+  };
+  const sideChange = (change, match) => change.op !== "delete" && match !== undefined && !match(change.row) ? { op: "delete", row: change.row } : change;
+  const EMPTY_DIFF = {
+    added: [],
+    removed: [],
+    changed: []
+  };
+  const subscriptionDiff = async (subscription, table, change) => {
+    if (subscription.kind === "graph") {
+      return subscription.instance.applyChange(table, change);
+    }
+    if (subscription.kind === "join") {
+      const js = subscription.join;
+      if (table === js.leftTable) {
+        return js.op.applyLeft(sideChange(change, js.leftMatch));
+      }
+      if (table === js.rightTable) {
+        return js.op.applyRight(sideChange(change, js.rightMatch));
+      }
+      return EMPTY_DIFF;
+    }
+    if (subscription.kind === "reactive") {
+      return EMPTY_DIFF;
+    }
+    if (subscription.kind === "search") {
+      return EMPTY_DIFF;
+    }
+    if (subscription.incremental) {
+      try {
+        return subscription.view.apply(change);
+      } catch {
+        return subscription.view.reset(await subscription.rehydrate());
+      }
+    }
+    if (subscription.affects && !subscription.affects(change)) {
+      return EMPTY_DIFF;
+    }
+    return subscription.view.reset(await subscription.rehydrate());
+  };
+  const subscriptionsForTable = function* (table) {
+    const names = tableIndex.get(table);
+    if (names === undefined) {
+      return;
+    }
+    for (const name of names) {
+      const set = active.get(name);
+      if (set === undefined) {
+        continue;
+      }
+      yield* set;
+    }
+  };
+  const mergeViewDiffs = (diffs, key) => {
+    const net = new Map;
+    for (const diff of diffs) {
+      for (const row of diff.removed) {
+        const previous = net.get(key(row));
+        if (previous?.state === "added") {
+          net.delete(key(row));
+        } else {
+          net.set(key(row), { state: "removed", row });
+        }
+      }
+      for (const row of diff.added) {
+        const previous = net.get(key(row));
+        net.set(key(row), {
+          state: previous?.state === "removed" ? "changed" : "added",
+          row
+        });
+      }
+      for (const row of diff.changed) {
+        const previous = net.get(key(row));
+        net.set(key(row), {
+          state: previous?.state === "added" ? "added" : "changed",
+          row
+        });
+      }
+    }
+    const added = [];
+    const changed = [];
+    const removed = [];
+    for (const { state, row } of net.values()) {
+      if (state === "added") {
+        added.push(row);
+      } else if (state === "changed") {
+        changed.push(row);
+      } else {
+        removed.push(row);
+      }
+    }
+    return { added, changed, removed };
+  };
+  const depKey = (table, key) => `${table} ${key}`;
+  const changedKeyFor = (table, change) => readers.get(table)?.key?.(change.row);
+  const makeReadHandle = (ctx, readTables, readKeys, rangeDeps, applyRules = true) => {
+    const readerFor = (table) => {
+      const reader = readers.get(table);
+      if (reader === undefined) {
+        throw new Error(`No reader registered for table "${table}" \u2014 register one with engine.registerReader`);
+      }
+      return reader;
+    };
+    const ruleFor = (table) => applyRules ? readRuleFor(table) : undefined;
+    return {
+      all: async (table) => {
+        readTables.add(table);
+        const rows = [...await readerFor(table).all(ctx)].map((row) => migrateRow(table, row));
+        const rule = ruleFor(table);
+        return rule ? rows.filter((row) => rule(ctx, row)) : rows;
+      },
+      get: async (table, key) => {
+        const reader = readerFor(table);
+        if (reader.get === undefined) {
+          throw new Error(`Reader for table "${table}" has no get(); use db.all() or add get`);
+        }
+        if (reader.key !== undefined) {
+          readKeys.add(depKey(table, key));
+        } else {
+          readTables.add(table);
+        }
+        const raw = await reader.get(key, ctx);
+        const row = raw === undefined ? undefined : migrateRow(table, raw);
+        const rule = ruleFor(table);
+        return rule && row !== undefined && !rule(ctx, row) ? undefined : row;
+      },
+      where: async (table, predicate) => {
+        const reader = readerFor(table);
+        const rule = ruleFor(table);
+        const effective = rule ? (row) => predicate(row) && rule(ctx, row) : predicate;
+        const matched = [...await reader.all(ctx)].map((row) => migrateRow(table, row)).filter(effective);
+        if (reader.key !== undefined) {
+          const key = reader.key;
+          rangeDeps.push({
+            table,
+            predicate: effective,
+            keys: new Set(matched.map(key))
+          });
+        } else {
+          readTables.add(table);
+        }
+        return matched;
+      }
+    };
+  };
+  const writerFor = (table) => {
+    const writer = writers.get(table);
+    if (writer === undefined) {
+      throw new Error(`No writer registered for table "${table}" \u2014 register one with engine.registerWriter, or use actions.change`);
+    }
+    return writer;
+  };
+  const readExisting = async (table, value, ctx) => {
+    const reader = readers.get(table);
+    if (reader?.get === undefined) {
+      return;
+    }
+    const id = reader.key ? reader.key(value) : value.id;
+    return id === undefined ? undefined : reader.get(id, ctx);
+  };
+  const authorizeWrite = async (table, op, value, ctx) => {
+    const rule = writeRuleFor(table, op);
+    if (rule === undefined) {
+      return;
+    }
+    let subject = value;
+    if (op !== "insert") {
+      const existing = await readExisting(table, value, ctx);
+      if (existing !== undefined) {
+        subject = existing;
+      }
+    }
+    if (!rule(ctx, subject)) {
+      throw new UnauthorizedError(`${op} on table "${table}"`);
+    }
+  };
+  const mergeCrdtFields = async (table, op, data, ctx) => {
+    const fields = crdtFields.get(table);
+    if (fields === undefined || data === null || typeof data !== "object") {
+      return data;
+    }
+    const incoming = data;
+    const existing = op === "update" ? await readExisting(table, data, ctx) : undefined;
+    const base = existing !== null && typeof existing === "object" ? existing : undefined;
+    const merged = { ...incoming };
+    for (const [field, adapter] of Object.entries(fields)) {
+      if (incoming[field] === undefined) {
+        continue;
+      }
+      merged[field] = adapter.merge(base?.[field] ?? adapter.empty(), incoming[field]);
+    }
+    return merged;
+  };
+  const makeActions = (tx, ctx, enforce) => {
+    const buffered = [];
+    const actions = {
+      change: (collection, change) => {
+        buffered.push({
+          table: collection,
+          change
+        });
+        return Promise.resolve();
+      },
+      insert: async (table, data) => {
+        validateWrite(table, "insert", data);
+        if (enforce) {
+          await authorizeWrite(table, "insert", data, ctx);
+        }
+        const merged = await mergeCrdtFields(table, "insert", data, ctx);
+        const row = await writerFor(table).insert(merged, ctx, tx);
+        buffered.push({ table, change: { op: "insert", row } });
+        return row;
+      },
+      update: async (table, data) => {
+        validateWrite(table, "update", data);
+        if (enforce) {
+          await authorizeWrite(table, "update", data, ctx);
+        }
+        const merged = await mergeCrdtFields(table, "update", data, ctx);
+        const row = await writerFor(table).update(merged, ctx, tx);
+        buffered.push({ table, change: { op: "update", row } });
+        return row;
+      },
+      delete: async (table, row) => {
+        if (enforce) {
+          await authorizeWrite(table, "delete", row, ctx);
+        }
+        await writerFor(table).delete(row, ctx, tx);
+        buffered.push({ table, change: { op: "delete", row } });
+      },
+      now: () => Date.now()
+    };
+    return { actions, buffered };
+  };
+  const diffRerun = (sub, rows, equals = shallowEqual3) => {
+    const next = new Map;
+    for (const row of rows) {
+      next.set(sub.key(row), row);
+    }
+    const added = [];
+    const removed = [];
+    const changed = [];
+    for (const [rowKey, row] of next) {
+      const previous = sub.current.get(rowKey);
+      if (previous === undefined) {
+        added.push(row);
+      } else if (!equals(previous, row)) {
+        changed.push(row);
+      }
+    }
+    for (const [rowKey, row] of sub.current) {
+      if (!next.has(rowKey)) {
+        removed.push(row);
+      }
+    }
+    sub.current = next;
+    return { added, removed, changed };
+  };
+  const inRange = (dep, change) => dep.table === change.table && (change.key !== undefined && dep.keys.has(change.key) || dep.predicate(change.row));
+  const readSetOverlaps = (readTables, readKeys, rangeDeps, changes) => changes.some((change) => readTables.has(change.table) || change.key !== undefined && readKeys.has(depKey(change.table, change.key)) || rangeDeps.some((dep) => inRange(dep, change)));
+  const isReactiveAffected = (sub, changes) => readSetOverlaps(sub.readTables, sub.readKeys, sub.rangeDeps, changes);
+  const invalidateCacheForChanges = (changes) => {
+    if (cachedReruns.size === 0)
+      return;
+    for (const [key, entry] of cachedReruns) {
+      if (readSetOverlaps(entry.readTables, entry.readKeys, entry.rangeDeps, changes)) {
+        cachedReruns.delete(key);
+      }
+    }
+  };
+  const reactivePairs = async (changes) => {
+    invalidateCacheForChanges(changes);
+    const pairs = [];
+    const sharedRuns = new Map;
+    for (const sub of reactiveSubs) {
+      if (!isReactiveAffected(sub, changes)) {
+        continue;
+      }
+      let runPromise = sharedRuns.get(sub.rerunKey);
+      if (runPromise === undefined) {
+        runPromise = sub.rerun();
+        sharedRuns.set(sub.rerunKey, runPromise);
+      }
+      const { rows, readTables, readKeys, rangeDeps } = await runPromise;
+      sub.readTables = readTables;
+      sub.readKeys = readKeys;
+      sub.rangeDeps = rangeDeps;
+      const diff = diffRerun(sub, rows);
+      if (!isEmptyViewDiff(diff)) {
+        pairs.push([sub, diff]);
+      }
+    }
+    for (const [key, runPromise] of sharedRuns) {
+      runPromise.then(({ rows, readTables, readKeys, rangeDeps }) => {
+        writeCacheEntry({
+          expiresAt: Date.now() + reactiveCacheTtlMs,
+          rangeDeps,
+          readKeys,
+          readTables,
+          rerunKey: key,
+          rows,
+          version
+        });
+      }).catch(() => {});
+    }
+    return pairs;
+  };
+  const ensureSearchIndex = async (definition) => {
+    let entry = searchIndexes.get(definition.name);
+    if (entry === undefined) {
+      entry = { index: definition.index(), definition, hydrated: false };
+      searchIndexes.set(definition.name, entry);
+    }
+    if (!entry.hydrated) {
+      for (const row of await definition.source()) {
+        entry.index.add(row);
+      }
+      entry.hydrated = true;
+    }
+    return entry;
+  };
+  const searchPairs = (changes) => {
+    const touched = new Set;
+    for (const { table, change } of changes) {
+      for (const entry of searchIndexes.values()) {
+        if (!entry.hydrated || entry.definition.table !== table) {
+          continue;
+        }
+        if (change.op === "delete") {
+          entry.index.remove(entry.definition.key(change.row));
+        } else {
+          entry.index.add(change.row);
+        }
+        touched.add(entry.definition.name);
+      }
+    }
+    const pairs = [];
+    for (const sub of searchSubs) {
+      if (!touched.has(sub.collection)) {
+        continue;
+      }
+      const diff = diffRerun(sub, sub.rerun(), equalsIgnoringScore);
+      if (!isEmptyViewDiff(diff)) {
+        pairs.push([sub, diff]);
+      }
+    }
+    return pairs;
+  };
+  const logChange = (changeVersion, entry) => {
+    changeLog.push(entry);
+    if (changeLog.length > changeLogSize) {
+      changeLog.shift();
+    }
+    if (changeLogRetainMs !== null && changeLogRetainMs > 0) {
+      const cutoff = entry.at - changeLogRetainMs;
+      while (changeLog.length > 0 && changeLog[0].at < cutoff) {
+        changeLog.shift();
+      }
+    }
+    for (const subscriber of streamSubscribers) {
+      subscriber(entry);
+    }
+  };
+  const encodeCursor = (versions) => JSON.stringify(versions);
+  const decodeCursor = (cursor) => {
+    try {
+      const parsed = JSON.parse(cursor);
+      if (typeof parsed !== "object" || parsed === null)
+        return null;
+      const out = {};
+      for (const [k, v] of Object.entries(parsed)) {
+        if (typeof v === "number")
+          out[k] = v;
+      }
+      return out;
+    } catch {
+      return null;
+    }
+  };
+  const currentCursor = () => {
+    const versions = { [instanceId]: version };
+    for (let i = changeLog.length - 1;i >= 0; i--) {
+      const entry = changeLog[i];
+      if (versions[entry.origin] === undefined) {
+        versions[entry.origin] = entry.originVersion;
+      }
+    }
+    return encodeCursor(versions);
+  };
+  const applyChange = async (table, change, shouldBroadcast = true) => {
+    version += 1;
+    const changeVersion = version;
+    const at = Date.now();
+    logChange(changeVersion, {
+      version: changeVersion,
+      table,
+      change,
+      at,
+      origin: instanceId,
+      originVersion: changeVersion
+    });
+    emitActivity({
+      type: "change",
+      at,
+      table,
+      op: change.op,
+      version: changeVersion
+    });
+    const emissions = [];
+    for (const subscription of subscriptionsForTable(table)) {
+      const diff = await subscriptionDiff(subscription, table, change);
+      if (!isEmptyViewDiff(diff)) {
+        emissions.push([subscription, diff]);
+      }
+    }
+    emissions.push(...await reactivePairs([
+      { table, key: changedKeyFor(table, change), row: change.row }
+    ]));
+    emissions.push(...searchPairs([{ table, change }]));
+    const cursorForBatch = currentCursor();
+    for (const [subscription, diff] of emissions) {
+      subscription.onDiff(diff, changeVersion, cursorForBatch);
+    }
+    if (shouldBroadcast) {
+      broadcast([{ table, change }], changeVersion);
+    }
+  };
+  const applyChangeBatch = async (changes, shouldBroadcast = true, peerOrigin) => {
+    if (changes.length === 0) {
+      return;
+    }
+    version += 1;
+    const batchVersion = version;
+    const perSubscription = new Map;
+    const reactiveChanges = [];
+    const batchAt = Date.now();
+    const batchOrigin = peerOrigin?.origin ?? instanceId;
+    const batchOriginVersion = peerOrigin?.originVersion ?? batchVersion;
+    for (const { table, change } of changes) {
+      logChange(batchVersion, {
+        version: batchVersion,
+        table,
+        change,
+        at: batchAt,
+        origin: batchOrigin,
+        originVersion: batchOriginVersion
+      });
+      emitActivity({
+        type: "change",
+        at: batchAt,
+        table,
+        op: change.op,
+        version: batchVersion
+      });
+      reactiveChanges.push({
+        table,
+        key: changedKeyFor(table, change),
+        row: change.row
+      });
+      for (const subscription of subscriptionsForTable(table)) {
+        const diff = await subscriptionDiff(subscription, table, change);
+        const list = perSubscription.get(subscription);
+        if (list === undefined) {
+          perSubscription.set(subscription, [diff]);
+        } else {
+          list.push(diff);
+        }
+      }
+    }
+    const emissions = [];
+    for (const [subscription, diffs] of perSubscription) {
+      const merged = diffs.length === 1 ? diffs[0] : mergeViewDiffs(diffs, subscription.key);
+      if (!isEmptyViewDiff(merged)) {
+        emissions.push([subscription, merged]);
+      }
+    }
+    emissions.push(...await reactivePairs(reactiveChanges));
+    emissions.push(...searchPairs(changes));
+    const cursorForBatch = currentCursor();
+    for (const [subscription, diff] of emissions) {
+      subscription.onDiff(diff, batchVersion, cursorForBatch);
+    }
+    if (shouldBroadcast) {
+      broadcast(changes, batchVersion);
+    }
+  };
+  const normalizeSince = (since) => {
+    if (typeof since === "number") {
+      return { [instanceId]: since };
+    }
+    return decodeCursor(since);
+  };
+  const canResume = (since, incremental) => {
+    if (!incremental) {
+      return false;
+    }
+    const sinceVec = normalizeSince(since);
+    if (sinceVec === null) {
+      return false;
+    }
+    const oldestPerOrigin = new Map;
+    for (const entry of changeLog) {
+      const current = oldestPerOrigin.get(entry.origin);
+      if (current === undefined || entry.originVersion < current) {
+        oldestPerOrigin.set(entry.origin, entry.originVersion);
+      }
+    }
+    const oldestLogVersion = changeLog[0]?.version;
+    for (const [origin, lastSeen] of Object.entries(sinceVec)) {
+      if (origin === instanceId) {
+        if (lastSeen >= version)
+          continue;
+        const oldestLocal = oldestPerOrigin.get(instanceId);
+        if (oldestLocal !== undefined) {
+          if (oldestLocal > lastSeen + 1)
+            return false;
+          continue;
+        }
+        if (oldestLogVersion !== undefined && oldestLogVersion > lastSeen + 1) {
+          return false;
+        }
+      } else {
+        const oldestPeer = oldestPerOrigin.get(origin);
+        if (oldestPeer === undefined) {
+          if (lastSeen > 0)
+            return false;
+        } else if (oldestPeer > lastSeen + 1) {
+          return false;
+        }
+      }
+    }
+    return true;
+  };
+  const buildCatchup = (since, tables, key, match) => {
+    const sinceVec = normalizeSince(since) ?? {};
+    const latest = new Map;
+    for (const entry of changeLog) {
+      if (!tables.includes(entry.table))
+        continue;
+      const lastSeen = sinceVec[entry.origin];
+      if (lastSeen !== undefined && entry.originVersion <= lastSeen)
+        continue;
+      const row = entry.change.row;
+      const present = entry.change.op !== "delete" && match(row) ? "upsert" : "remove";
+      latest.set(key(row), { op: present, row });
+    }
+    const changed = [];
+    const removed = [];
+    for (const { op, row } of latest.values()) {
+      (op === "upsert" ? changed : removed).push(row);
+    }
+    return { added: [], removed, changed };
+  };
+  const subscribeJoin = async (collection, definition, params, ctx, onDiff, set) => {
+    if (definition.authorize !== undefined) {
+      const allowed = await definition.authorize(params, ctx);
+      if (!allowed) {
+        throw new UnauthorizedError(`subscribe to collection "${collection}"`);
+      }
+    }
+    const { left, right } = definition;
+    const op = createEquiJoin({
+      leftKey: left.key,
+      rightKey: right.key,
+      leftOn: left.on,
+      rightOn: right.on,
+      select: definition.select
+    });
+    op.hydrate([...await left.hydrate(params, ctx)], [...await right.hydrate(params, ctx)]);
+    const atVersion = version;
+    const subscription = {
+      kind: "join",
+      collection,
+      join: {
+        op,
+        leftTable: left.table,
+        rightTable: right.table,
+        leftMatch: left.match ? (row) => left.match(row, params, ctx) : undefined,
+        rightMatch: right.match ? (row) => right.match(row, params, ctx) : undefined
+      },
+      key: definition.key,
+      onDiff
+    };
+    set.add(subscription);
+    return {
+      initial: op.rows(),
+      cursor: currentCursor(),
+      version: atVersion,
+      unsubscribe: () => {
+        set.delete(subscription);
+      }
+    };
+  };
+  const subscribeGraph = async (collection, definition, params, ctx, onDiff, set) => {
+    if (definition.authorize !== undefined) {
+      const allowed = await definition.authorize(params, ctx);
+      if (!allowed) {
+        throw new UnauthorizedError(`subscribe to collection "${collection}"`);
+      }
+    }
+    const instance = definition.query.instantiate(params, ctx);
+    const initial = await instance.hydrate();
+    const atVersion = version;
+    const subscription = {
+      kind: "graph",
+      collection,
+      instance,
+      key: definition.key,
+      onDiff
+    };
+    set.add(subscription);
+    return {
+      initial,
+      cursor: currentCursor(),
+      version: atVersion,
+      unsubscribe: () => {
+        set.delete(subscription);
+      }
+    };
+  };
+  const subscribeReactive = async (collection, definition, params, ctx, onDiff, set) => {
+    if (definition.authorize !== undefined) {
+      const allowed = await definition.authorize(params, ctx);
+      if (!allowed) {
+        throw new UnauthorizedError(`subscribe to collection "${collection}"`);
+      }
+    }
+    const rerun = async () => {
+      const readTables = new Set;
+      const readKeys = new Set;
+      const rangeDeps = [];
+      const db = makeReadHandle(ctx, readTables, readKeys, rangeDeps);
+      const rows = [...await definition.run({ ctx, db, params })];
+      return { rangeDeps, readKeys, readTables, rows };
+    };
+    const rerunKey = stableSubKey(collection, params, ctx);
+    const cached = readCacheEntry(rerunKey);
+    const first = cached !== undefined ? {
+      rangeDeps: cached.rangeDeps,
+      readKeys: cached.readKeys,
+      readTables: cached.readTables,
+      rows: cached.rows
+    } : await rerun();
+    if (cached === undefined) {
+      writeCacheEntry({
+        expiresAt: Date.now() + reactiveCacheTtlMs,
+        rangeDeps: first.rangeDeps,
+        readKeys: first.readKeys,
+        readTables: first.readTables,
+        rerunKey,
+        rows: first.rows,
+        version
+      });
+    }
+    const current = new Map;
+    for (const row of first.rows) {
+      current.set(definition.key(row), row);
+    }
+    const atVersion = version;
+    const subscription = {
+      kind: "reactive",
+      collection,
+      key: definition.key,
+      rerun,
+      rerunKey,
+      current,
+      readTables: first.readTables,
+      readKeys: first.readKeys,
+      rangeDeps: first.rangeDeps,
+      onDiff
+    };
+    set.add(subscription);
+    reactiveSubs.add(subscription);
+    return {
+      initial: first.rows,
+      cursor: currentCursor(),
+      version: atVersion,
+      unsubscribe: () => {
+        set.delete(subscription);
+        reactiveSubs.delete(subscription);
+      }
+    };
+  };
+  const subscribeSearch = async (collection, definition, params, ctx, onDiff, set) => {
+    const query = params;
+    if (definition.authorize !== undefined) {
+      const allowed = await definition.authorize(query, ctx);
+      if (!allowed) {
+        throw new UnauthorizedError(`subscribe to collection "${collection}"`);
+      }
+    }
+    const entry = await ensureSearchIndex(definition);
+    const limit = definition.limit ?? 20;
+    const readRule = readRuleFor(definition.table);
+    const rerun = () => {
+      const candidates = entry.index.search(query, readRule ? limit * 5 : limit);
+      const visible = readRule ? candidates.filter((hit) => readRule(ctx, hit.row)) : candidates;
+      return visible.slice(0, limit).map((hit) => ({
+        ...hit.row,
+        [SEARCH_SCORE_FIELD]: hit.score
+      }));
+    };
+    const initial = rerun();
+    const current = new Map;
+    for (const row of initial) {
+      current.set(definition.key(row), row);
+    }
+    const atVersion = version;
+    const subscription = {
+      kind: "search",
+      collection,
+      key: definition.key,
+      rerun,
+      current,
+      onDiff
+    };
+    set.add(subscription);
+    searchSubs.add(subscription);
+    return {
+      initial,
+      cursor: currentCursor(),
+      version: atVersion,
+      unsubscribe: () => {
+        set.delete(subscription);
+        searchSubs.delete(subscription);
+      }
+    };
+  };
+  const engine = {
+    register: (collection) => {
+      registry.set(collection.name, collection);
+      for (const table of collection.tables ?? [collection.name]) {
+        addTableIndex(table, collection.name);
+      }
+    },
+    registerJoin: (collection) => {
+      registry.set(collection.name, collection);
+      addTableIndex(collection.left.table, collection.name);
+      addTableIndex(collection.right.table, collection.name);
+    },
+    registerGraph: (collection) => {
+      registry.set(collection.name, collection);
+      for (const table of collection.query.tables()) {
+        addTableIndex(table, collection.name);
+      }
+    },
+    registerSearch: (collection) => {
+      registry.set(collection.name, collection);
+    },
+    subscribe: async ({
+      collection,
+      params,
+      ctx,
+      onDiff,
+      since,
+      signal
+    }) => {
+      const subscribeSpan = tracer.startSpan("sync.subscribe", {
+        attributes: {
+          [ABS_ATTRS.engineId]: instanceId,
+          [ABS_ATTRS.collection]: collection
+        }
+      });
+      try {
+        checkAborted(signal);
+        const registered = registry.get(collection);
+        if (registered === undefined) {
+          throw new Error(`Unknown collection "${collection}"`);
+        }
+        const tenantSlot = acquireSubscriptionSlot(ctx, { collection });
+        let slotHandedOff = false;
+        try {
+          const typedOnDiff = onDiff;
+          const subscribeSet = subsFor(collection);
+          const wrapReturn = (sub) => {
+            checkAborted(signal);
+            const innerUnsubscribe = sub.unsubscribe;
+            let released = false;
+            const wrappedUnsubscribe = () => {
+              if (released)
+                return;
+              released = true;
+              releaseSubscriptionSlot(tenantSlot);
+              innerUnsubscribe();
+            };
+            const wrapped = {
+              ...sub,
+              unsubscribe: wrappedUnsubscribe
+            };
+            linkAbortToUnsubscribe(signal, wrappedUnsubscribe);
+            slotHandedOff = true;
+            return wrapped;
+          };
+          const registeredKind = registered.kind;
+          if (registeredKind === "join") {
+            const joined = await subscribeJoin(collection, registered, params, ctx, typedOnDiff, subscribeSet);
+            return wrapReturn(joined);
+          }
+          if (registeredKind === "graph") {
+            const graphed = await subscribeGraph(collection, registered, params, ctx, typedOnDiff, subscribeSet);
+            return wrapReturn(graphed);
+          }
+          if (registeredKind === "reactive") {
+            const reactived = await subscribeReactive(collection, registered, params, ctx, typedOnDiff, subscribeSet);
+            return wrapReturn(reactived);
+          }
+          if (registeredKind === "search") {
+            const searched = await subscribeSearch(collection, registered, params, ctx, typedOnDiff, subscribeSet);
+            return wrapReturn(searched);
+          }
+          const definition = registered;
+          if (definition.authorize !== undefined) {
+            const allowed = await definition.authorize(params, ctx);
+            if (!allowed) {
+              throw new UnauthorizedError(`subscribe to collection "${collection}"`);
+            }
+          }
+          const key = definition.key ?? defaultKey;
+          const match = definition.match;
+          const tables = definition.tables ?? [collection];
+          const scopedTable = tables.length === 1 ? tables[0] : undefined;
+          const readRule = scopedTable !== undefined ? readRuleFor(scopedTable) : undefined;
+          const rehydrate = async () => {
+            const raw = [
+              ...await definition.hydrate(params, ctx)
+            ];
+            const rows = scopedTable !== undefined ? raw.map((row) => migrateRow(scopedTable, row)) : raw;
+            return readRule ? rows.filter((row) => readRule(ctx, row)) : rows;
+          };
+          const incremental = match !== undefined && tables.length === 1;
+          const boundAffects = !incremental && definition.affects ? (change) => definition.affects(change, params, ctx) : undefined;
+          const boundMatch = incremental ? (row) => match(row, params, ctx) && (readRule ? readRule(ctx, row) : true) : () => true;
+          const view = createMaterializedView({
+            key,
+            match: boundMatch
+          });
+          const resuming = since !== undefined && canResume(since, incremental);
+          view.hydrate([...await rehydrate()]);
+          const atVersion = version;
+          const subscription = {
+            kind: "view",
+            collection,
+            view,
+            incremental,
+            rehydrate,
+            ...boundAffects ? { affects: boundAffects } : {},
+            key,
+            onDiff: typedOnDiff
+          };
+          subscribeSet.add(subscription);
+          const unsubscribe = () => {
+            subscribeSet.delete(subscription);
+          };
+          if (resuming) {
+            return wrapReturn({
+              initial: [],
+              catchup: buildCatchup(since, tables, key, boundMatch),
+              cursor: currentCursor(),
+              version: atVersion,
+              unsubscribe
+            });
+          }
+          return wrapReturn({
+            initial: view.rows(),
+            cursor: currentCursor(),
+            version: atVersion,
+            unsubscribe
+          });
+        } catch (error) {
+          if (!slotHandedOff)
+            releaseSubscriptionSlot(tenantSlot);
+          throw error;
+        }
+      } catch (spanError) {
+        subscribeSpan.recordException(spanError);
+        subscribeSpan.setStatus({
+          code: 2,
+          message: spanError instanceof Error ? spanError.message : String(spanError)
+        });
+        throw spanError;
+      } finally {
+        subscribeSpan.end();
+      }
+    },
+    hydrate: async (collection, params, ctx, options2) => {
+      const signal = options2?.signal;
+      checkAborted(signal);
+      const definition = registry.get(collection);
+      if (definition === undefined) {
+        throw new Error(`Unknown collection "${collection}"`);
+      }
+      if (definition.authorize !== undefined) {
+        const allowed = await definition.authorize(params, ctx);
+        checkAborted(signal);
+        if (!allowed) {
+          throw new UnauthorizedError(`hydrate collection "${collection}"`);
+        }
+      }
+      const raw = [...await definition.hydrate(params, ctx)];
+      checkAborted(signal);
+      const tables = definition.tables ?? [collection];
+      const scopedTable = tables.length === 1 ? tables[0] : undefined;
+      const rows = scopedTable !== undefined ? raw.map((row) => migrateRow(scopedTable, row)) : raw;
+      const readRule = scopedTable !== undefined ? readRuleFor(scopedTable) : undefined;
+      return readRule ? rows.filter((row) => readRule(ctx, row)) : rows;
+    },
+    applyChange: (table, change) => applyChange(table, change),
+    connectSource: async (source) => {
+      await source.start((table, change) => {
+        sourceChangesReceived += 1;
+        sourceLastChangeAt = Date.now();
+        return applyChange(table, change);
+      });
+      connectedSources += 1;
+      let stopped = false;
+      return async () => {
+        if (!stopped) {
+          stopped = true;
+          connectedSources -= 1;
+        }
+        await source.stop();
+      };
+    },
+    connectCluster: async (bus) => {
+      const unsubscribe = await bus.subscribe((message) => {
+        if (message.origin === instanceId) {
+          return;
+        }
+        applyChangeBatch(message.changes, false, {
+          origin: message.origin,
+          originVersion: message.originVersion ?? 0
+        });
+      });
+      clusterBus = bus;
+      return async () => {
+        clusterBus = undefined;
+        await unsubscribe();
+      };
+    },
+    subscriptionCount: (collection) => {
+      if (collection !== undefined) {
+        return active.get(collection)?.size ?? 0;
+      }
+      let total = 0;
+      for (const set of active.values()) {
+        total += set.size;
+      }
+      return total;
+    },
+    registerMutation: (mutation) => {
+      if (mutation.handler === undefined && mutation.sandboxedHandler === undefined) {
+        throw new Error(`Mutation "${mutation.name}" must define either \`handler\` or \`sandboxedHandler\``);
+      }
+      if (mutation.handler !== undefined && mutation.sandboxedHandler !== undefined) {
+        throw new Error(`Mutation "${mutation.name}" defines both \`handler\` and \`sandboxedHandler\` \u2014 pick one`);
+      }
+      mutations.set(mutation.name, mutation);
+      if (mutation.sandboxedHandler !== undefined) {
+        sandboxRunners.set(mutation.name, makeSandboxedHandler(mutation.sandboxedHandler, mutation.sandbox, {
+          bridgeFetch: options.bridgeFetch,
+          metricsHook: options.handlerMetrics === undefined ? undefined : {
+            mutationName: mutation.name,
+            onMetrics: options.handlerMetrics
+          }
+        }));
+      }
+    },
+    registerWriter: (table, writer) => {
+      writers.set(table, writer);
+    },
+    registerReactive: (query) => {
+      registry.set(query.name, query);
+    },
+    registerReader: (table, reader) => {
+      readers.set(table, reader);
+    },
+    registerPermissions: (table, rules) => {
+      permissions.set(table, rules);
+    },
+    registerSchema: (table, schema) => {
+      schemas.set(table, schema);
+    },
+    registerCrdt: (table, fields) => {
+      crdtFields.set(table, fields);
+      const name = `${table}:merge`;
+      mutations.set(name, {
+        handler: async (args, ctx, actions) => {
+          const existing = await readExisting(table, args, ctx);
+          return existing === undefined ? actions.insert(table, args) : actions.update(table, args);
+        },
+        name
+      });
+    },
+    migrate: (table, row) => migrateRow(table, row),
+    runMutation: async (name, args, ctx) => {
+      const span = tracer.startSpan("sync.runMutation", {
+        attributes: {
+          [ABS_ATTRS.engineId]: instanceId,
+          [ABS_ATTRS.mutation]: name
+        }
+      });
+      try {
+        if (activeFences.size > 0) {
+          const oldest = activeFences.values().next().value;
+          throw new EngineFencedError(oldest.reason);
+        }
+        const mutation = mutations.get(name);
+        if (mutation === undefined) {
+          throw new Error(`Unknown mutation "${name}"`);
+        }
+        if (mutation.authorize !== undefined) {
+          const allowed = await mutation.authorize(args, ctx);
+          if (!allowed) {
+            throw new UnauthorizedError(`run mutation "${name}"`);
+          }
+        }
+        await acquireMutationSlot();
+        const sandboxRunner = sandboxRunners.get(name);
+        const invokeHandler = sandboxRunner !== undefined ? sandboxRunner : (a, c, actions) => Promise.resolve(mutation.handler(a, c, actions));
+        const runHandler = async (tx) => {
+          const { actions, buffered } = makeActions(tx, ctx, true);
+          const result = await invokeHandler(args, ctx, actions);
+          return { buffered, result };
+        };
+        const retry = mutation.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;
+        try {
+          for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+            attemptsMade = attempt;
+            try {
+              const { buffered, result } = runInTransaction !== undefined ? await runInTransaction((tx) => runHandler(tx)) : await runHandler(undefined);
+              await applyChangeBatch(buffered);
+              mutationsCompleted += 1;
+              emitActivity({
+                type: "mutation",
+                at: Date.now(),
+                name,
+                status: "ok"
+              });
+              return result;
+            } catch (error) {
+              lastError = error;
+              const elapsedMs = Date.now() - startedAt;
+              const canRetry = attempt < maxAttempts && isRetryable(error) && elapsedMs < maxElapsedMs;
+              if (!canRetry)
+                break;
+              mutationsRetried += 1;
+              const rawDelay = computeDelay(attempt);
+              const remaining = maxElapsedMs - elapsedMs;
+              if (remaining <= 0)
+                break;
+              const delayMs = Math.max(0, Math.min(rawDelay, remaining));
+              emitActivity({
+                type: "mutationRetry",
+                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));
+              }
+            }
+          }
+          mutationsFailed += 1;
+          emitActivity({
+            type: "mutation",
+            at: Date.now(),
+            name,
+            status: "error"
+          });
+          if (attemptsMade > 1) {
+            throw new RetriesExhaustedError(attemptsMade, Date.now() - startedAt, lastError);
+          }
+          throw lastError;
+        } finally {
+          releaseMutationSlot();
+        }
+      } catch (spanError) {
+        span.recordException(spanError);
+        span.setStatus({
+          code: 2,
+          message: spanError instanceof Error ? spanError.message : String(spanError)
+        });
+        throw spanError;
+      } finally {
+        span.end();
+      }
+    },
+    runMutations: async (specs, ctx) => {
+      if (specs.length === 0)
+        return [];
+      const resolved = specs.map((spec) => {
+        const mutation = mutations.get(spec.name);
+        if (mutation === undefined) {
+          throw new Error(`Unknown mutation "${spec.name}"`);
+        }
+        return { args: spec.args, mutation, name: spec.name };
+      });
+      await acquireMutationSlot();
+      const runBatch = async (tx) => {
+        const results = [];
+        const accumulated = [];
+        for (const { args, mutation, name } of resolved) {
+          if (mutation.authorize !== undefined) {
+            const allowed = await mutation.authorize(args, ctx);
+            if (!allowed) {
+              throw new UnauthorizedError(`run mutation "${name}"`);
+            }
+          }
+          const sandboxRunner = sandboxRunners.get(name);
+          const invokeHandler = sandboxRunner !== undefined ? sandboxRunner : (a, c, actions2) => Promise.resolve(mutation.handler(a, c, actions2));
+          const { actions, buffered } = makeActions(tx, ctx, true);
+          const result = await invokeHandler(args, ctx, actions);
+          results.push(result);
+          accumulated.push(...buffered);
+        }
+        return { accumulated, results };
+      };
+      try {
+        const { accumulated, results } = runInTransaction !== undefined ? await runInTransaction((tx) => runBatch(tx)) : await runBatch(undefined);
+        await applyChangeBatch(accumulated);
+        emitActivity({
+          type: "mutationBatch",
+          at: Date.now(),
+          names: resolved.map((entry) => entry.name),
+          status: "ok"
+        });
+        return results;
+      } catch (error) {
+        emitActivity({
+          type: "mutationBatch",
+          at: Date.now(),
+          names: resolved.map((entry) => entry.name),
+          status: "error"
+        });
+        throw error;
+      } finally {
+        releaseMutationSlot();
+      }
+    },
+    registerSchedule: (schedule) => {
+      schedules.set(schedule.name, schedule);
+    },
+    listSchedules: () => [...schedules.values()],
+    runSchedule: async (name) => {
+      const schedule = schedules.get(name);
+      if (schedule === undefined) {
+        throw new Error(`Unknown schedule "${name}"`);
+      }
+      const runHandler = async (tx) => {
+        const { actions, buffered } = makeActions(tx, {}, false);
+        const db = makeReadHandle({}, new Set, new Set, [], false);
+        await schedule.run({ actions, db });
+        return 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 query of pack.reactiveQueries ?? []) {
+        engine.registerReactive(query);
+      }
+      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]) => {
+        const kind = def.kind ?? "view";
+        let tables = [];
+        if (kind === "join") {
+          const join = def;
+          tables = [join.left.table, join.right.table];
+        } else if (kind === "graph") {
+          tables = def.query.tables();
+        } else if (kind === "search") {
+          tables = [
+            def.table
+          ];
+        } else if (kind === "view") {
+          tables = def.tables ?? [name];
+        }
+        return {
+          name,
+          kind,
+          tables,
+          subscriptions: active.get(name)?.size ?? 0
+        };
+      });
+      const DEVTOOLS_RECENT = 50;
+      return {
+        version,
+        collections,
+        mutations: [...mutations.keys()],
+        schedules: [...schedules.values()].map((schedule) => ({
+          name: schedule.name,
+          pattern: schedule.pattern
+        })),
+        readers: [...readers.keys()],
+        writers: [...writers.keys()],
+        recentChanges: changeLog.slice(-DEVTOOLS_RECENT).map((entry) => ({
+          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]
+        }))
+      };
+    },
+    exportChangeLog: () => ({
+      entries: changeLog.slice(),
+      exportedAt: Date.now(),
+      instanceId,
+      version
+    }),
+    importChangeLog,
+    replayTo: async ({ at, tables }) => {
+      const filterTables = tables !== undefined ? new Set(tables) : undefined;
+      const state = new Map;
+      let asOfVersion = 0;
+      let asOfAt = 0;
+      const oldest = changeLog[0];
+      const truncated = oldest !== undefined && oldest.version > 1 && oldest.at > at;
+      for (const entry of changeLog) {
+        if (entry.at > at)
+          break;
+        if (filterTables !== undefined && !filterTables.has(entry.table)) {
+          continue;
+        }
+        let tableState = state.get(entry.table);
+        if (tableState === undefined) {
+          tableState = new Map;
+          state.set(entry.table, tableState);
+        }
+        const reader = readers.get(entry.table);
+        const key = reader?.key?.(entry.change.row) ?? entry.change.row?.id;
+        if (key === undefined) {
+          continue;
+        }
+        if (entry.change.op === "delete") {
+          tableState.delete(key);
+        } else {
+          tableState.set(key, entry.change.row);
+        }
+        asOfVersion = entry.version;
+        asOfAt = entry.at;
+      }
+      const rows = {};
+      for (const [table, map] of state) {
+        rows[table] = [...map.values()];
+      }
+      return { asOfAt, asOfVersion, rows, truncated };
+    },
+    fence: ({ reason }) => {
+      const handle = {
+        fencedAt: Date.now(),
+        reason,
+        lift: () => {
+          activeFences.delete(handle);
+        }
+      };
+      activeFences.add(handle);
+      return handle;
+    },
+    exportSnapshot: async ({
+      tables,
+      ctx = {}
+    } = {}) => {
+      const tableFilter = tables !== undefined ? new Set(tables) : undefined;
+      const rows = {};
+      for (const [table, reader] of readers) {
+        if (tableFilter !== undefined && !tableFilter.has(table)) {
+          continue;
+        }
+        const iterable = await reader.all(ctx);
+        rows[table] = [...iterable];
+      }
+      return {
+        exportedAt: Date.now(),
+        sourceInstanceId: instanceId,
+        tables: rows,
+        version
+      };
+    },
+    importSnapshot: async (snapshot, { tables, onProgress, ctx = {} } = {}) => {
+      const tableFilter = tables !== undefined ? new Set(tables) : undefined;
+      const perTable = {};
+      const skipped = [];
+      let tablesImported = 0;
+      let rowsImported = 0;
+      for (const [table, snapshotRows] of Object.entries(snapshot.tables)) {
+        if (tableFilter !== undefined && !tableFilter.has(table)) {
+          continue;
+        }
+        const writer = writers.get(table);
+        if (writer === undefined) {
+          skipped.push(table);
+          continue;
+        }
+        const total = snapshotRows.length;
+        let done = 0;
+        for (const row of snapshotRows) {
+          await writer.insert(row, ctx, undefined);
+          done += 1;
+          rowsImported += 1;
+          if (onProgress !== undefined) {
+            onProgress(table, done, total);
+          }
+        }
+        perTable[table] = done;
+        if (done > 0)
+          tablesImported += 1;
+      }
+      return {
+        perTable,
+        rowsImported,
+        skipped,
+        tablesImported
+      };
+    },
+    metrics: () => {
+      const now = Date.now();
+      const byCollection = {};
+      let totalSubscriptions = 0;
+      for (const [name, subs] of active) {
+        byCollection[name] = subs.size;
+        totalSubscriptions += subs.size;
+      }
+      const oldest = changeLog[0];
+      return {
+        at: now,
+        changeLog: {
+          capacity: changeLogSize,
+          entries: changeLog.length,
+          oldestAgeMs: oldest ? now - oldest.at : null,
+          oldestVersion: oldest ? oldest.version : null,
+          retainMs: changeLogRetainMs
+        },
+        mutations: {
+          completed: mutationsCompleted,
+          failed: mutationsFailed,
+          inFlight: mutationsInFlight,
+          queued: mutationsQueued,
+          retried: mutationsRetried
+        },
+        reactiveCache: {
+          capacity: reactiveCacheMax,
+          entries: cachedReruns.size
+        },
+        schedules: {
+          registered: schedules.size
+        },
+        source: {
+          changesReceived: sourceChangesReceived,
+          connected: connectedSources,
+          lastChangeAgeMs: sourceLastChangeAt === null ? null : now - sourceLastChangeAt,
+          lastChangeAt: sourceLastChangeAt
+        },
+        subscriptions: {
+          byCollection,
+          byTenant: Object.fromEntries(subscriptionsByTenant),
+          total: totalSubscriptions
+        },
+        uptimeMs: now - engineStartedAt,
+        version
+      };
+    },
+    onActivity: (listener) => {
+      activityListeners.add(listener);
+      return () => {
+        activityListeners.delete(listener);
+      };
+    },
+    streamChanges: ({
+      since = 0,
+      signal,
+      maxBuffer = 1e4
+    } = {}) => {
+      const oldest = changeLog[0];
+      if (since > 0 && oldest !== undefined && oldest.version > since + 1) {
+        const err = new MissedChangesError(since, oldest.version);
+        return {
+          [Symbol.asyncIterator]() {
+            return {
+              next: () => Promise.reject(err)
+            };
+          }
+        };
+      }
+      const buffer = [];
+      let waiter = null;
+      let overflow = false;
+      const wake = () => {
+        if (waiter !== null) {
+          const resume = waiter;
+          waiter = null;
+          resume();
+        }
+      };
+      const subscriber = (entry) => {
+        if (buffer.length >= maxBuffer) {
+          overflow = true;
+          wake();
+          return;
+        }
+        buffer.push(entry);
+        wake();
+      };
+      streamSubscribers.add(subscriber);
+      const onAbort = () => wake();
+      signal?.addEventListener("abort", onAbort, { once: true });
+      let lastDelivered = since;
+      return {
+        async* [Symbol.asyncIterator]() {
+          try {
+            const history = [...changeLog];
+            const headVersion = history.length > 0 ? history[history.length - 1].version : since;
+            for (const entry of history) {
+              if (signal?.aborted)
+                return;
+              if (entry.version > since) {
+                lastDelivered = entry.version;
+                yield entry;
+              }
+            }
+            while (!signal?.aborted) {
+              while (buffer.length > 0) {
+                const entry = buffer.shift();
+                if (entry.version > headVersion) {
+                  lastDelivered = entry.version;
+                  yield entry;
+                }
+              }
+              if (overflow) {
+                throw new CdcConsumerSlowError(maxBuffer, lastDelivered);
+              }
+              if (signal?.aborted)
+                return;
+              await new Promise((resolve) => {
+                waiter = resolve;
+              });
+            }
+          } finally {
+            streamSubscribers.delete(subscriber);
+            signal?.removeEventListener("abort", onAbort);
+          }
+        }
+      };
+    }
+  };
+  return engine;
+};
+
+// src/engine/socket.ts
+import { Elysia } from "elysia";
+
+// src/serializer.ts
+var jsonSerializer = {
+  decode: (raw) => {
+    if (typeof raw === "string") {
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return null;
+      }
+    }
+    if (raw instanceof Uint8Array) {
+      try {
+        return JSON.parse(new TextDecoder().decode(raw));
+      } catch {
+        return null;
+      }
+    }
+    if (raw instanceof ArrayBuffer) {
+      try {
+        return JSON.parse(new TextDecoder().decode(new Uint8Array(raw)));
+      } catch {
+        return null;
+      }
+    }
+    return raw;
+  },
+  encodeClient: (frame) => JSON.stringify(frame),
+  encodeServer: (frame) => JSON.stringify(frame)
+};
+
+// src/engine/connection.ts
+var parseFrame = (raw, serializer) => {
+  let value = raw;
+  if (typeof value === "string" || value instanceof Uint8Array || value instanceof ArrayBuffer) {
+    value = serializer.decode(raw);
+    if (value === null)
+      return;
+  }
+  if (typeof value !== "object" || value === null) {
+    return;
+  }
+  const frame = value;
+  if (frame.type === "subscribe") {
+    const since = typeof frame.since === "number" || typeof frame.since === "string" ? frame.since : undefined;
+    return typeof frame.id === "string" && typeof frame.collection === "string" ? {
+      type: "subscribe",
+      id: frame.id,
+      collection: frame.collection,
+      params: frame.params,
+      since
+    } : undefined;
+  }
+  if (frame.type === "unsubscribe") {
+    return typeof frame.id === "string" ? { type: "unsubscribe", id: frame.id } : undefined;
+  }
+  if (frame.type === "mutate") {
+    return typeof frame.mutationId === "number" && typeof frame.name === "string" ? {
+      type: "mutate",
+      mutationId: frame.mutationId,
+      name: frame.name,
+      args: frame.args
+    } : undefined;
+  }
+  if (frame.type === "presence-join") {
+    return typeof frame.room === "string" && typeof frame.memberId === "string" ? {
+      type: "presence-join",
+      room: frame.room,
+      memberId: frame.memberId,
+      state: frame.state
+    } : undefined;
+  }
+  if (frame.type === "presence-set") {
+    return typeof frame.room === "string" ? { type: "presence-set", room: frame.room, state: frame.state } : undefined;
+  }
+  if (frame.type === "presence-leave") {
+    return typeof frame.room === "string" ? { type: "presence-leave", room: frame.room } : undefined;
+  }
+  return;
+};
+var createSyncConnection = ({
+  engine,
+  ctx,
+  send: rawSend,
+  presence,
+  serializer = jsonSerializer
+}) => {
+  const subscriptions = new Map;
+  const presenceRooms = new Map;
+  let framesSent = 0;
+  let slowSendsRecent = 0;
+  const send = (frame) => {
+    const ret = rawSend(frame);
+    if (ret === -1) {
+      slowSendsRecent += 1;
+    } else {
+      framesSent += 1;
+      slowSendsRecent = 0;
+    }
+  };
+  let pending = [];
+  let pendingVersion;
+  let pendingCursor;
+  let flushScheduled = false;
+  const flush = () => {
+    if (pending.length === 0) {
+      return;
+    }
+    const diffs = pending;
+    const version = pendingVersion;
+    const cursor = pendingCursor;
+    pending = [];
+    pendingVersion = undefined;
+    pendingCursor = undefined;
+    if (diffs.length === 1) {
+      const only = diffs[0];
+      send({
+        type: "diff",
+        id: only.id,
+        added: only.added,
+        removed: only.removed,
+        changed: only.changed,
+        version,
+        cursor
+      });
+    } else {
+      send({ type: "frame", diffs, version, cursor });
+    }
+  };
+  const scheduleFlush = () => {
+    if (flushScheduled) {
+      return;
+    }
+    flushScheduled = true;
+    queueMicrotask(() => {
+      flushScheduled = false;
+      flush();
+    });
+  };
+  const bufferDiff = (diff, diffVersion, cursor) => {
+    if (pending.length > 0 && pendingVersion !== diffVersion) {
+      flush();
+    }
+    pending.push(diff);
+    pendingVersion = diffVersion;
+    if (cursor !== undefined)
+      pendingCursor = cursor;
+    scheduleFlush();
+  };
+  const handle = async (raw) => {
+    const frame = parseFrame(raw, serializer);
+    if (frame === undefined) {
+      send({ type: "error", message: "Malformed sync frame" });
+      return;
+    }
+    if (frame.type === "mutate") {
+      try {
+        const result = await engine.runMutation(frame.name, frame.args, ctx);
+        flush();
+        send({ type: "ack", mutationId: frame.mutationId, result });
+      } catch (error) {
+        send({
+          type: "reject",
+          mutationId: frame.mutationId,
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+      return;
+    }
+    if (frame.type === "unsubscribe") {
+      subscriptions.get(frame.id)?.unsubscribe();
+      subscriptions.delete(frame.id);
+      return;
+    }
+    if (frame.type === "presence-join") {
+      if (presence === undefined) {
+        send({ type: "error", message: "Presence is not enabled" });
+        return;
+      }
+      presenceRooms.get(frame.room)?.leave();
+      const handle2 = presence.join(frame.room, frame.memberId, frame.state, (diff) => {
+        send({
+          type: "presence",
+          room: frame.room,
+          joined: diff.joined,
+          updated: diff.updated,
+          left: diff.left
+        });
+      });
+      presenceRooms.set(frame.room, handle2);
+      send({
+        type: "presence",
+        room: frame.room,
+        joined: handle2.members,
+        updated: [],
+        left: []
+      });
+      return;
+    }
+    if (frame.type === "presence-set") {
+      presenceRooms.get(frame.room)?.set(frame.state);
+      return;
+    }
+    if (frame.type === "presence-leave") {
+      presenceRooms.get(frame.room)?.leave();
+      presenceRooms.delete(frame.room);
+      return;
+    }
+    if (subscriptions.has(frame.id)) {
+      send({
+        type: "error",
+        id: frame.id,
+        message: `Subscription id "${frame.id}" already in use`
+      });
+      return;
+    }
+    try {
+      const subscription = await engine.subscribe({
+        collection: frame.collection,
+        params: frame.params,
+        ctx,
+        since: frame.since,
+        onDiff: (diff, diffVersion, cursor) => {
+          bufferDiff({
+            id: frame.id,
+            added: diff.added,
+            removed: diff.removed,
+            changed: diff.changed
+          }, diffVersion, cursor);
+        }
+      });
+      subscriptions.set(frame.id, subscription);
+      if (subscription.catchup !== undefined) {
+        send({
+          type: "diff",
+          id: frame.id,
+          added: subscription.catchup.added,
+          removed: subscription.catchup.removed,
+          changed: subscription.catchup.changed,
+          version: subscription.version,
+          cursor: subscription.cursor
+        });
+      } else {
+        send({
+          type: "snapshot",
+          id: frame.id,
+          rows: subscription.initial,
+          version: subscription.version,
+          cursor: subscription.cursor
+        });
+      }
+    } catch (error) {
+      send({
+        type: "error",
+        id: frame.id,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  };
+  const close = () => {
+    for (const subscription of subscriptions.values()) {
+      subscription.unsubscribe();
+    }
+    subscriptions.clear();
+    for (const handle2 of presenceRooms.values()) {
+      handle2.leave();
+    }
+    presenceRooms.clear();
+  };
+  const stats = () => ({
+    framesSent,
+    presenceRoomCount: presenceRooms.size,
+    slowSendsRecent,
+    subscriptionCount: subscriptions.size
+  });
+  return { close, handle, stats };
+};
+
+// src/engine/socket.ts
+var syncSocket = ({
+  engine,
+  path = "/sync/ws",
+  resolveContext,
+  presence,
+  maxBufferedBytes,
+  onSlow,
+  closeOnSlow = false,
+  serializer = jsonSerializer
+}) => {
+  const connections = new Map;
+  const threshold = maxBufferedBytes ?? Infinity;
+  const fireSlow = (event) => {
+    if (!onSlow)
+      return;
+    try {
+      const ret = onSlow(event);
+      if (ret && typeof ret.then === "function") {
+        ret.catch((error) => {
+          console.error("[sync/socket] onSlow rejected:", error);
+        });
+      }
+    } catch (error) {
+      console.error("[sync/socket] onSlow threw:", error);
+    }
+  };
+  return new Elysia({ name: "@absolutejs/sync/socket" }).ws(path, {
+    async open(ws) {
+      const bunWs = ws;
+      const tracked = {
+        connection: null,
+        pending: [],
+        slowSignaled: false
+      };
+      connections.set(bunWs.id, tracked);
+      const ctx = resolveContext ? await resolveContext(ws.data) : {};
+      const connection = createSyncConnection({
+        engine,
+        ctx,
+        presence,
+        serializer,
+        send: (frame) => {
+          const payload = serializer.encodeServer(frame);
+          const ret = bunWs.send(typeof payload === "string" ? payload : payload);
+          const buffered2 = bunWs.getBufferedAmount?.() ?? 0;
+          const overBuffer = buffered2 > threshold;
+          const backpressure = ret === -1;
+          if ((overBuffer || backpressure) && !tracked.slowSignaled) {
+            tracked.slowSignaled = true;
+            fireSlow({
+              bufferedAmount: buffered2,
+              reason: backpressure ? "send-backpressure" : "buffer-threshold",
+              stats: connection.stats(),
+              wsId: bunWs.id
+            });
+            if (closeOnSlow)
+              bunWs.close?.();
+          }
+          return ret;
+        }
+      });
+      if (!connections.has(bunWs.id)) {
+        connection.close();
+        return;
+      }
+      tracked.connection = connection;
+      const buffered = tracked.pending;
+      tracked.pending = [];
+      for (const frame of buffered) {
+        await connection.handle(frame);
+      }
+    },
+    async message(ws, message) {
+      const tracked = connections.get(ws.id);
+      if (!tracked)
+        return;
+      if (tracked.connection) {
+        await tracked.connection.handle(message);
+      } else {
+        tracked.pending.push(message);
+      }
+    },
+    drain(ws) {
+      const tracked = connections.get(ws.id);
+      if (tracked)
+        tracked.slowSignaled = false;
+    },
+    close(ws) {
+      const tracked = connections.get(ws.id);
+      if (tracked) {
+        tracked.connection?.close();
+        connections.delete(ws.id);
+      }
+    }
+  });
+};
+
+// src/plugin.ts
+import { Elysia as Elysia2 } from "elysia";
+
+// src/reactiveHub.ts
+var SYNC_OPEN_TOPIC = "@absolutejs/sync:open";
+var createReactiveHub = () => {
+  const subscriptions = new Set;
+  const matches = (subscription, topic) => {
+    if (subscription.exact.has(topic)) {
+      return true;
+    }
+    return subscription.prefixes.some((prefix) => topic.startsWith(prefix));
+  };
+  return {
+    publish: (topic, payload) => {
+      const event = { topic, at: Date.now(), payload };
+      for (const subscription of subscriptions) {
+        if (matches(subscription, topic)) {
+          subscription.listener(event);
+        }
+      }
+    },
+    subscribe: (topics, listener) => {
+      const exact = new Set;
+      const prefixes = [];
+      for (const topic of topics) {
+        if (topic.endsWith("*")) {
+          prefixes.push(topic.slice(0, -1));
+        } else {
+          exact.add(topic);
+        }
+      }
+      const subscription = { exact, prefixes, listener };
+      subscriptions.add(subscription);
+      return () => {
+        subscriptions.delete(subscription);
+      };
+    },
+    subscriberCount: (topic) => {
+      if (topic === undefined) {
+        return subscriptions.size;
+      }
+      let count = 0;
+      for (const subscription of subscriptions) {
+        if (matches(subscription, topic)) {
+          count += 1;
+        }
+      }
+      return count;
+    }
+  };
+};
+
+// src/plugin.ts
+var defaultResolveTopics = (context) => (context.query.topics ?? "").split(",").map((topic) => topic.trim()).filter(Boolean);
+var sync = ({
+  hub,
+  path = "/sync",
+  resolveTopics = defaultResolveTopics,
+  heartbeatMs = 25000
+}) => {
+  const app = new Elysia2({ name: "@absolutejs/sync" }).get(path, (context) => {
+    const topics = resolveTopics({
+      query: context.query,
+      request: context.request
+    });
+    const encoder = new TextEncoder;
+    const stream = new ReadableStream({
+      start(controller) {
+        const write = (chunk) => {
+          try {
+            controller.enqueue(encoder.encode(chunk));
+          } catch {}
+        };
+        const send = (event) => {
+          write(`data: ${JSON.stringify(event)}
+
+`);
+        };
+        send({
+          topic: SYNC_OPEN_TOPIC,
+          at: Date.now(),
+          payload: { topics }
+        });
+        const unsubscribe = topics.length > 0 ? hub.subscribe(topics, send) : () => {};
+        const heartbeat = setInterval(() => write(`: ping
+
+`), heartbeatMs);
+        context.request.signal.addEventListener("abort", () => {
+          clearInterval(heartbeat);
+          unsubscribe();
+          try {
+            controller.close();
+          } catch {}
+        }, { once: true });
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "cache-control": "no-cache, no-transform",
+        connection: "keep-alive",
+        "content-type": "text/event-stream",
+        "x-accel-buffering": "no"
+      }
+    });
+  });
+  return app;
+};
+
+// src/platform.ts
+var PLATFORM_SYNC_ENVIRONMENT_KEY = "ABSOLUTE_SYNC_RUNTIME";
+var PLATFORM_SYNC_HEALTH_PATH = "/.well-known/absolute/sync";
+var PlatformSyncConfigurationSchema = Type.Object({
+  changeLogRetainMs: Type.Integer({
+    maximum: 604800000,
+    minimum: 1000
+  }),
+  changeLogSize: Type.Integer({ maximum: 1e4, minimum: 1 }),
+  closeOnSlow: Type.Boolean(),
+  heartbeatMs: Type.Integer({ maximum: 120000, minimum: 1000 }),
+  instanceId: Type.String({
+    maxLength: 128,
+    minLength: 1,
+    pattern: "^[A-Za-z0-9_.:-]+$"
+  }),
+  maxBufferedBytes: Type.Integer({
+    maximum: 16777216,
+    minimum: 65536
+  }),
+  mutationConcurrency: Type.Integer({ maximum: 64, minimum: 1 }),
+  mutationQueueLimit: Type.Integer({ maximum: 1e4, minimum: 0 }),
+  pushPath: Type.String({
+    maxLength: 128,
+    minLength: 1,
+    pattern: "^/[^?#]*$"
+  }),
+  socketPath: Type.String({
+    maxLength: 128,
+    minLength: 1,
+    pattern: "^/[^?#]*$"
+  }),
+  tier: Type.Union([
+    Type.Literal("push"),
+    Type.Literal("engine"),
+    Type.Literal("both")
+  ]),
+  version: Type.Literal(1)
+}, { additionalProperties: false });
+
+class PlatformSyncConfigurationError extends Error {
+}
+var readPlatformSyncConfiguration = (environment = process.env) => {
+  const serialized = environment[PLATFORM_SYNC_ENVIRONMENT_KEY]?.trim();
+  if (!serialized)
+    return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(serialized);
+  } catch {
+    throw new PlatformSyncConfigurationError("Platform Sync configuration is not valid JSON");
+  }
+  if (!Value.Check(PlatformSyncConfigurationSchema, parsed))
+    throw new PlatformSyncConfigurationError("Platform Sync configuration is invalid");
+  return parsed;
+};
+var createPlatformSyncRuntime = (options = {}) => {
+  const configuration = options.configuration ?? readPlatformSyncConfiguration();
+  if (!configuration)
+    throw new PlatformSyncConfigurationError("Platform Sync is not configured");
+  const pushEnabled = configuration.tier !== "engine";
+  const engineEnabled = configuration.tier !== "push";
+  const hub = pushEnabled ? options.hub ?? createReactiveHub() : undefined;
+  const engine = engineEnabled ? createSyncEngine({
+    ...options.engineOptions,
+    changeLogRetainMs: configuration.changeLogRetainMs,
+    changeLogSize: configuration.changeLogSize,
+    instanceId: configuration.instanceId,
+    mutationConcurrency: configuration.mutationConcurrency,
+    mutationQueueLimit: configuration.mutationQueueLimit
+  }) : undefined;
+  const app = new Elysia3({ name: "@absolutejs/sync/platform" }).use(hub ? sync({
+    heartbeatMs: configuration.heartbeatMs,
+    hub,
+    path: configuration.pushPath,
+    ...options.resolveTopics ? { resolveTopics: options.resolveTopics } : {}
+  }) : new Elysia3({ name: "@absolutejs/sync/platform/no-push" })).use(engine ? syncSocket({
+    closeOnSlow: configuration.closeOnSlow,
+    engine,
+    maxBufferedBytes: configuration.maxBufferedBytes,
+    path: configuration.socketPath,
+    ...options.onSlow ? { onSlow: options.onSlow } : {},
+    ...options.resolveContext ? { resolveContext: options.resolveContext } : {}
+  }) : new Elysia3({ name: "@absolutejs/sync/platform/no-engine" })).get(PLATFORM_SYNC_HEALTH_PATH, () => ({
+    contract: 1,
+    instanceId: configuration.instanceId,
+    ready: true,
+    tier: configuration.tier
+  }));
+  return {
+    app,
+    configuration,
+    engine,
+    hub,
+    metrics: () => engine?.metrics() ?? null
+  };
+};
+export {
+  readPlatformSyncConfiguration,
+  createPlatformSyncRuntime,
+  PlatformSyncConfigurationSchema,
+  PlatformSyncConfigurationError,
+  PLATFORM_SYNC_HEALTH_PATH,
+  PLATFORM_SYNC_ENVIRONMENT_KEY
+};
+
+//# debugId=49D1023B83CB5B7D64756E2164756E21
+//# sourceMappingURL=platform.js.map