@absolutejs/sync 0.0.1 → 0.2.0

package/dist/engine/index.js

@@ -0,0 +1,1774 @@
+// @bun
+// src/engine/materializedView.ts
+var emptyDiff = () => ({
+  added: [],
+  removed: [],
+  changed: []
+});
+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);
+  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 ?? shallowEqual;
+  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/aggregate.ts
+var newGroupState = () => ({
+  count: 0,
+  sum: 0,
+  valueCounts: new Map,
+  min: undefined,
+  max: undefined
+});
+var recomputeExtremes = (state) => {
+  if (state.valueCounts.size === 0) {
+    state.min = undefined;
+    state.max = undefined;
+    return;
+  }
+  let min = Infinity;
+  let max = -Infinity;
+  for (const value of state.valueCounts.keys()) {
+    if (value < min) {
+      min = value;
+    }
+    if (value > max) {
+      max = value;
+    }
+  }
+  state.min = min;
+  state.max = max;
+};
+var summarize = (group, state) => ({
+  group,
+  count: state.count,
+  sum: state.sum,
+  avg: state.count > 0 ? state.sum / state.count : 0,
+  min: state.min,
+  max: state.max
+});
+var createAggregate = (options) => {
+  const { key, groupBy, value } = options;
+  const groups = new Map;
+  const contributions = new Map;
+  const add = (group, contribution) => {
+    let state = groups.get(group);
+    if (state === undefined) {
+      state = newGroupState();
+      groups.set(group, state);
+    }
+    state.count += 1;
+    if (contribution === undefined) {
+      return;
+    }
+    state.sum += contribution;
+    state.valueCounts.set(contribution, (state.valueCounts.get(contribution) ?? 0) + 1);
+    state.min = state.min === undefined ? contribution : Math.min(state.min, contribution);
+    state.max = state.max === undefined ? contribution : Math.max(state.max, contribution);
+  };
+  const remove = (group, contribution) => {
+    const state = groups.get(group);
+    if (state === undefined) {
+      return;
+    }
+    state.count -= 1;
+    if (contribution !== undefined) {
+      state.sum -= contribution;
+      const remaining = (state.valueCounts.get(contribution) ?? 0) - 1;
+      if (remaining <= 0) {
+        state.valueCounts.delete(contribution);
+        if (contribution === state.min || contribution === state.max) {
+          recomputeExtremes(state);
+        }
+      } else {
+        state.valueCounts.set(contribution, remaining);
+      }
+    }
+    if (state.count <= 0) {
+      groups.delete(group);
+    }
+  };
+  const apply = (change) => {
+    const rowKey = key(change.row);
+    const previous = contributions.get(rowKey);
+    if (change.op === "delete") {
+      if (previous !== undefined) {
+        remove(previous.group, previous.value);
+        contributions.delete(rowKey);
+      }
+      return;
+    }
+    const group = groupBy ? groupBy(change.row) : "";
+    const contribution = value ? value(change.row) : undefined;
+    if (previous !== undefined) {
+      remove(previous.group, previous.value);
+    }
+    add(group, contribution);
+    contributions.set(rowKey, { group, value: contribution });
+  };
+  return {
+    hydrate: (rows) => {
+      groups.clear();
+      contributions.clear();
+      for (const row of rows) {
+        apply({ op: "insert", row });
+      }
+    },
+    apply,
+    groups: () => [...groups.entries()].map(([group, state]) => summarize(group, state)),
+    group: (group) => {
+      const state = groups.get(group);
+      return state === undefined ? undefined : summarize(group, state);
+    }
+  };
+};
+// src/engine/equiJoin.ts
+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);
+  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 ?? shallowEqual2;
+  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/dataflow.ts
+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((key) => a[key] === b[key]);
+};
+var fromRowChange = (change, key) => ({
+  op: change.op === "delete" ? "delete" : "upsert",
+  key: key(change.row),
+  row: change.row
+});
+var filterOp = (predicate) => ({
+  push: (changes) => changes.map((change) => change.op === "upsert" && !predicate(change.row) ? { op: "delete", key: change.key, row: change.row } : change)
+});
+var mapOp = (transform, rekey) => ({
+  push: (changes) => changes.map((change) => {
+    const row = transform(change.row);
+    return {
+      op: change.op,
+      key: rekey ? rekey(row) : change.key,
+      row
+    };
+  })
+});
+var chain = (a, b) => ({
+  push: (changes) => b.push(a.push(changes))
+});
+var aggregateOp = (options) => {
+  const aggregate = createAggregate(options);
+  const groupOf = new Map;
+  return {
+    push: (changes) => {
+      const affected = new Set;
+      for (const change of changes) {
+        const inputKey = options.key(change.row);
+        const previousGroup = groupOf.get(inputKey);
+        if (previousGroup !== undefined) {
+          affected.add(previousGroup);
+        }
+        if (change.op === "delete") {
+          aggregate.apply({ op: "delete", row: change.row });
+          groupOf.delete(inputKey);
+        } else {
+          const group = options.groupBy ? options.groupBy(change.row) : "";
+          affected.add(group);
+          aggregate.apply({ op: "update", row: change.row });
+          groupOf.set(inputKey, group);
+        }
+      }
+      const out = [];
+      for (const group of affected) {
+        const summary = aggregate.group(group);
+        if (summary === undefined) {
+          out.push({
+            op: "delete",
+            key: group,
+            row: {
+              group,
+              count: 0,
+              sum: 0,
+              avg: 0,
+              min: undefined,
+              max: undefined
+            }
+          });
+        } else {
+          out.push({ op: "upsert", key: group, row: summary });
+        }
+      }
+      return out;
+    }
+  };
+};
+var orderByOp = (options) => {
+  const { key, compare } = options;
+  const offset = options.offset ?? 0;
+  const limit = options.limit ?? Number.POSITIVE_INFINITY;
+  const all = new Map;
+  let window = new Map;
+  return {
+    push: (changes) => {
+      for (const change of changes) {
+        if (change.op === "delete") {
+          all.delete(change.key);
+        } else {
+          all.set(change.key, change.row);
+        }
+      }
+      const windowed = [...all.values()].sort(compare).slice(offset, offset + limit);
+      const next = new Map;
+      for (const row of windowed) {
+        next.set(key(row), row);
+      }
+      const out = [];
+      for (const [rowKey, row] of window) {
+        if (!next.has(rowKey)) {
+          out.push({ op: "delete", key: rowKey, row });
+        }
+      }
+      for (const [rowKey, row] of next) {
+        out.push({ op: "upsert", key: rowKey, row });
+      }
+      window = next;
+      return out;
+    }
+  };
+};
+var joinNode = (options) => {
+  const join = createEquiJoin(options);
+  const key = options.key;
+  const toChanges = (diff) => {
+    const changes = [];
+    for (const row of diff.removed) {
+      changes.push({ op: "delete", key: key(row), row });
+    }
+    for (const row of diff.added) {
+      changes.push({ op: "upsert", key: key(row), row });
+    }
+    for (const row of diff.changed) {
+      changes.push({ op: "upsert", key: key(row), row });
+    }
+    return changes;
+  };
+  const asRowChange = (change) => ({
+    op: change.op === "delete" ? "delete" : "update",
+    row: change.row
+  });
+  return {
+    hydrate: (left, right) => join.hydrate(left, right),
+    pushLeft: (changes) => changes.flatMap((change) => toChanges(join.applyLeft(asRowChange(change)))),
+    pushRight: (changes) => changes.flatMap((change) => toChanges(join.applyRight(asRowChange(change)))),
+    rows: () => join.rows()
+  };
+};
+var materialize = (key, equals = shallowEqual3) => {
+  const set = new Map;
+  return {
+    hydrate: (rows) => {
+      set.clear();
+      for (const row of rows) {
+        set.set(key(row), row);
+      }
+    },
+    apply: (changes) => {
+      const added = [];
+      const removed = [];
+      const changed = [];
+      for (const change of changes) {
+        if (change.op === "delete") {
+          const previous2 = set.get(change.key);
+          if (previous2 !== undefined) {
+            removed.push(previous2);
+            set.delete(change.key);
+          }
+          continue;
+        }
+        const previous = set.get(change.key);
+        set.set(change.key, change.row);
+        if (previous === undefined) {
+          added.push(change.row);
+        } else if (!equals(previous, change.row)) {
+          changed.push(change.row);
+        }
+      }
+      return { added, removed, changed };
+    },
+    rows: () => [...set.values()]
+  };
+};
+// src/engine/pollingSource.ts
+var OP_BY_NAME = {
+  insert: "insert",
+  INSERT: "insert",
+  update: "update",
+  UPDATE: "update",
+  delete: "delete",
+  DELETE: "delete"
+};
+var parseOutboxRow = (row) => {
+  if (typeof row.tbl !== "string") {
+    return;
+  }
+  const op = OP_BY_NAME[row.op];
+  if (op === undefined) {
+    return;
+  }
+  let payload = row.payload;
+  if (typeof payload === "string") {
+    try {
+      payload = JSON.parse(payload);
+    } catch {
+      return;
+    }
+  }
+  if (typeof payload !== "object" || payload === null) {
+    return;
+  }
+  return { table: row.tbl, change: { op, row: payload } };
+};
+var createPollingChangeSource = (options) => {
+  const intervalMs = options.intervalMs ?? 1000;
+  const parse = options.parse ?? parseOutboxRow;
+  const onError = options.onError ?? ((error) => {
+    console.warn("[sync] polling change source error:", error);
+  });
+  let cursor = options.startSeq ?? 0;
+  let running = false;
+  let timer;
+  const tick = async (emit) => {
+    if (!running) {
+      return;
+    }
+    try {
+      const rows = await options.poll(cursor);
+      for (const row of rows) {
+        const parsed = parse(row);
+        if (parsed !== undefined) {
+          await emit(parsed.table, parsed.change);
+        }
+        if (typeof row.seq === "number" && row.seq > cursor) {
+          cursor = row.seq;
+        }
+      }
+      if (rows.length > 0) {
+        await options.onProcessed?.(cursor);
+      }
+    } catch (error) {
+      onError(error);
+    }
+    if (running) {
+      timer = setTimeout(() => {
+        tick(emit);
+      }, intervalMs);
+    }
+  };
+  return {
+    start: async (emit) => {
+      if (running) {
+        return;
+      }
+      running = true;
+      await tick(emit);
+    },
+    stop: () => {
+      running = false;
+      if (timer !== undefined) {
+        clearTimeout(timer);
+        timer = undefined;
+      }
+    }
+  };
+};
+// src/engine/cluster.ts
+var createInMemoryClusterBus = () => {
+  const listeners = new Set;
+  return {
+    publish: (message) => {
+      for (const listener of listeners) {
+        listener(message);
+      }
+    },
+    subscribe: (onMessage) => {
+      listeners.add(onMessage);
+      return () => {
+        listeners.delete(onMessage);
+      };
+    }
+  };
+};
+// src/engine/presence.ts
+var createPresenceHub = () => {
+  const rooms = new Map;
+  const roomMembers = (room) => {
+    const members = rooms.get(room);
+    if (members === undefined) {
+      return [];
+    }
+    return [...members].map(([id, member]) => ({
+      id,
+      state: member.state
+    }));
+  };
+  const notify = (room, diff, exceptId) => {
+    const members = rooms.get(room);
+    if (members === undefined) {
+      return;
+    }
+    for (const [id, member] of members) {
+      if (id !== exceptId) {
+        member.onDiff(diff);
+      }
+    }
+  };
+  return {
+    join: (room, memberId, state, onDiff) => {
+      let members = rooms.get(room);
+      if (members === undefined) {
+        members = new Map;
+        rooms.set(room, members);
+      }
+      members.set(memberId, {
+        state,
+        onDiff
+      });
+      notify(room, { joined: [{ id: memberId, state }], updated: [], left: [] }, memberId);
+      const snapshot = roomMembers(room);
+      return {
+        members: snapshot,
+        set: (next) => {
+          const current = rooms.get(room)?.get(memberId);
+          if (current === undefined) {
+            return;
+          }
+          current.state = next;
+          notify(room, {
+            joined: [],
+            updated: [{ id: memberId, state: next }],
+            left: []
+          }, memberId);
+        },
+        leave: () => {
+          const roomNow = rooms.get(room);
+          if (roomNow?.delete(memberId) !== true) {
+            return;
+          }
+          notify(room, { joined: [], updated: [], left: [memberId] }, memberId);
+          if (roomNow.size === 0) {
+            rooms.delete(room);
+          }
+        }
+      };
+    },
+    members: (room) => roomMembers(room),
+    count: (room) => rooms.get(room)?.size ?? 0
+  };
+};
+// src/engine/collection.ts
+var defineCollection = (definition) => definition;
+var defineJoinCollection = (definition) => ({
+  ...definition,
+  kind: "join"
+});
+// src/engine/reactive.ts
+var defineReactiveQuery = (definition) => ({ ...definition, kind: "reactive" });
+// src/engine/graph.ts
+var PLANS = new WeakMap;
+var planTables = (plan) => {
+  const tables = [plan.source.table];
+  for (const step of plan.steps) {
+    if (step.kind === "join") {
+      tables.push(...planTables(step.rightPlan));
+    }
+  }
+  return [...new Set(tables)];
+};
+var instantiateStream = (source, steps, params, ctx) => {
+  const stages = [];
+  let currentKey = source.key;
+  for (const step of steps) {
+    if (step.kind === "filter") {
+      const predicate = step.predicate;
+      stages.push({
+        kind: "op",
+        op: filterOp((row) => predicate(row, params, ctx))
+      });
+    } else if (step.kind === "map") {
+      stages.push({ kind: "op", op: mapOp(step.transform, step.rekey) });
+      if (step.rekey) {
+        currentKey = step.rekey;
+      }
+    } else if (step.kind === "join") {
+      const right = instantiateStream(step.rightPlan.source, step.rightPlan.steps, params, ctx);
+      stages.push({
+        kind: "join",
+        node: joinNode({
+          leftKey: currentKey,
+          rightKey: right.outKey,
+          leftOn: step.on,
+          rightOn: step.rightOn,
+          select: step.select,
+          selectUnmatched: step.selectUnmatched,
+          key: step.key
+        }),
+        right
+      });
+      currentKey = step.key;
+    } else if (step.kind === "aggregate") {
+      stages.push({
+        kind: "op",
+        op: aggregateOp({
+          key: step.key,
+          groupBy: step.groupBy,
+          value: step.value
+        })
+      });
+      currentKey = (group) => group.group;
+    } else {
+      stages.push({
+        kind: "op",
+        op: orderByOp({
+          key: step.key,
+          compare: step.compare,
+          limit: step.limit,
+          offset: step.offset
+        })
+      });
+      currentKey = step.key;
+    }
+  }
+  const propagate = (changes, fromStage, side) => {
+    let cs = changes;
+    for (let i = fromStage;i < stages.length; i += 1) {
+      const stage = stages[i];
+      if (stage.kind === "join") {
+        cs = i === fromStage && side === "right" ? stage.node.pushRight(cs) : stage.node.pushLeft(cs);
+      } else {
+        cs = stage.op.push(cs);
+      }
+    }
+    return cs;
+  };
+  const sourceChange = (change) => {
+    const key = source.key(change.row);
+    if (change.op === "delete" || source.match !== undefined && !source.match(change.row, params, ctx)) {
+      return { op: "delete", key, row: change.row };
+    }
+    return { op: "upsert", key, row: change.row };
+  };
+  const entries = new Map;
+  const addEntry = (table, entry) => {
+    const list = entries.get(table);
+    if (list === undefined) {
+      entries.set(table, [entry]);
+    } else {
+      list.push(entry);
+    }
+  };
+  addEntry(source.table, {
+    stageIndex: 0,
+    side: "left",
+    produce: (change) => [sourceChange(change)]
+  });
+  stages.forEach((stage, index) => {
+    if (stage.kind === "join") {
+      for (const table of stage.right.tables) {
+        addEntry(table, {
+          stageIndex: index,
+          side: "right",
+          produce: (change) => stage.right.applyStream(table, change)
+        });
+      }
+    }
+  });
+  return {
+    tables: planTables({ source, steps }),
+    outKey: currentKey,
+    hydrateStream: async () => {
+      for (let i = 0;i < stages.length; i += 1) {
+        const stage = stages[i];
+        if (stage.kind === "join") {
+          propagate(await stage.right.hydrateStream(), i, "right");
+        }
+      }
+      const rootRows = [...await source.hydrate(params, ctx)];
+      return propagate(rootRows.map((row) => ({
+        op: "upsert",
+        key: source.key(row),
+        row
+      })), 0, "left");
+    },
+    applyStream: (table, change) => {
+      const list = entries.get(table);
+      if (list === undefined) {
+        return [];
+      }
+      const out = [];
+      for (const entry of list) {
+        out.push(...propagate(entry.produce(change), entry.stageIndex, entry.side));
+      }
+      return out;
+    }
+  };
+};
+var instantiate = (source, steps, params, ctx) => {
+  const graph = instantiateStream(source, steps, params, ctx);
+  const sink = materialize(graph.outKey);
+  return {
+    tables: graph.tables,
+    hydrate: async () => {
+      sink.apply(await graph.hydrateStream());
+      return sink.rows();
+    },
+    applyChange: (table, change) => sink.apply(graph.applyStream(table, change))
+  };
+};
+var makeQuery = (source, steps) => {
+  const addJoin = (right, options) => {
+    const rightPlan = PLANS.get(right) ?? {
+      source: right,
+      steps: []
+    };
+    return makeQuery(source, [
+      ...steps,
+      { kind: "join", rightPlan, ...options }
+    ]);
+  };
+  const queryInstance = {
+    filter: (predicate) => makeQuery(source, [...steps, { kind: "filter", predicate }]),
+    map: (transform, rekey) => makeQuery(source, [...steps, { kind: "map", transform, rekey }]),
+    join: (right, options) => addJoin(right, options),
+    leftJoin: (right, options) => addJoin(right, options),
+    groupBy: (options) => makeQuery(source, [...steps, { kind: "aggregate", ...options }]),
+    orderBy: (options) => makeQuery(source, [...steps, { kind: "orderBy", ...options }]),
+    tables: () => planTables({ source, steps }),
+    instantiate: (params, ctx) => instantiate(source, steps, params, ctx)
+  };
+  PLANS.set(queryInstance, { source, steps });
+  return queryInstance;
+};
+var query = (source) => makeQuery(source, []);
+var defineGraphCollection = (definition) => ({ ...definition, kind: "graph" });
+// src/engine/mutation.ts
+var defineMutation = (definition) => definition;
+// src/engine/syncEngine.ts
+class UnauthorizedError extends Error {
+  constructor(subject) {
+    super(`Not authorized: ${subject}`);
+    this.name = "UnauthorizedError";
+  }
+}
+var defaultKey = (row) => row.id;
+var shallowEqual4 = (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 createSyncEngine = (options = {}) => {
+  const registry = new Map;
+  const mutations = new Map;
+  const writers = new Map;
+  const readers = new Map;
+  const reactiveSubs = new Set;
+  const active = new Map;
+  const tableIndex = new Map;
+  const changeLogSize = options.changeLogSize ?? 1024;
+  const changeLog = [];
+  let version = 0;
+  const runInTransaction = options.transaction;
+  const instanceId = globalThis.crypto?.randomUUID?.() ?? `i${Math.random()}`;
+  let clusterBus;
+  const broadcast = (changes) => {
+    if (clusterBus !== undefined && changes.length > 0) {
+      clusterBus.publish({ changes, origin: instanceId });
+    }
+  };
+  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.incremental) {
+      try {
+        return subscription.view.apply(change);
+      } catch {
+        return subscription.view.reset(await subscription.rehydrate());
+      }
+    }
+    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) => {
+    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;
+    };
+    return {
+      all: async (table) => {
+        readTables.add(table);
+        return [...await readerFor(table).all(ctx)];
+      },
+      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);
+        }
+        return await reader.get(key, ctx);
+      },
+      where: async (table, predicate) => {
+        const reader = readerFor(table);
+        const matched = [...await reader.all(ctx)].filter(predicate);
+        if (reader.key !== undefined) {
+          const key = reader.key;
+          rangeDeps.push({
+            table,
+            predicate,
+            keys: new Set(matched.map(key))
+          });
+        } else {
+          readTables.add(table);
+        }
+        return matched;
+      }
+    };
+  };
+  const diffRerun = (sub, rows) => {
+    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 (!shallowEqual4(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 isReactiveAffected = (sub, changes) => changes.some((change) => sub.readTables.has(change.table) || change.key !== undefined && sub.readKeys.has(depKey(change.table, change.key)) || sub.rangeDeps.some((dep) => inRange(dep, change)));
+  const reactivePairs = async (changes) => {
+    const pairs = [];
+    for (const sub of reactiveSubs) {
+      if (!isReactiveAffected(sub, changes)) {
+        continue;
+      }
+      const { rows, readTables, readKeys, rangeDeps } = await sub.rerun();
+      sub.readTables = readTables;
+      sub.readKeys = readKeys;
+      sub.rangeDeps = rangeDeps;
+      const diff = diffRerun(sub, rows);
+      if (!isEmptyViewDiff(diff)) {
+        pairs.push([sub, diff]);
+      }
+    }
+    return pairs;
+  };
+  const logChange = (changeVersion, entry) => {
+    changeLog.push(entry);
+    if (changeLog.length > changeLogSize) {
+      changeLog.shift();
+    }
+  };
+  const applyChange = async (table, change, shouldBroadcast = true) => {
+    version += 1;
+    const changeVersion = version;
+    logChange(changeVersion, { version: changeVersion, table, change });
+    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 }
+    ]));
+    for (const [subscription, diff] of emissions) {
+      subscription.onDiff(diff, changeVersion);
+    }
+    if (shouldBroadcast) {
+      broadcast([{ table, change }]);
+    }
+  };
+  const applyChangeBatch = async (changes, shouldBroadcast = true) => {
+    if (changes.length === 0) {
+      return;
+    }
+    version += 1;
+    const batchVersion = version;
+    const perSubscription = new Map;
+    const reactiveChanges = [];
+    for (const { table, change } of changes) {
+      logChange(batchVersion, { version: batchVersion, table, change });
+      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));
+    for (const [subscription, diff] of emissions) {
+      subscription.onDiff(diff, batchVersion);
+    }
+    if (shouldBroadcast) {
+      broadcast(changes);
+    }
+  };
+  const canResume = (since, incremental) => {
+    if (!incremental) {
+      return false;
+    }
+    if (since >= version) {
+      return true;
+    }
+    const oldest = changeLog[0];
+    return oldest !== undefined && oldest.version <= since + 1;
+  };
+  const buildCatchup = (since, tables, key, match) => {
+    const latest = new Map;
+    for (const entry of changeLog) {
+      if (entry.version <= since || !tables.includes(entry.table)) {
+        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(),
+      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,
+      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 first = await rerun();
+    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,
+      current,
+      readTables: first.readTables,
+      readKeys: first.readKeys,
+      rangeDeps: first.rangeDeps,
+      onDiff
+    };
+    set.add(subscription);
+    reactiveSubs.add(subscription);
+    return {
+      initial: first.rows,
+      version: atVersion,
+      unsubscribe: () => {
+        set.delete(subscription);
+        reactiveSubs.delete(subscription);
+      }
+    };
+  };
+  return {
+    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);
+      }
+    },
+    subscribe: async ({ collection, params, ctx, onDiff, since }) => {
+      const registered = registry.get(collection);
+      if (registered === undefined) {
+        throw new Error(`Unknown collection "${collection}"`);
+      }
+      const typedOnDiff = onDiff;
+      const subscribeSet = subsFor(collection);
+      const registeredKind = registered.kind;
+      if (registeredKind === "join") {
+        const joined = await subscribeJoin(collection, registered, params, ctx, typedOnDiff, subscribeSet);
+        return joined;
+      }
+      if (registeredKind === "graph") {
+        const graphed = await subscribeGraph(collection, registered, params, ctx, typedOnDiff, subscribeSet);
+        return graphed;
+      }
+      if (registeredKind === "reactive") {
+        const reactived = await subscribeReactive(collection, registered, params, ctx, typedOnDiff, subscribeSet);
+        return reactived;
+      }
+      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 rehydrate = async () => definition.hydrate(params, ctx);
+      const match = definition.match;
+      const tables = definition.tables ?? [collection];
+      const incremental = match !== undefined && tables.length === 1;
+      const boundMatch = incremental ? (row) => match(row, params, ctx) : () => 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,
+        key,
+        onDiff: typedOnDiff
+      };
+      subscribeSet.add(subscription);
+      const unsubscribe = () => {
+        subscribeSet.delete(subscription);
+      };
+      if (resuming) {
+        return {
+          initial: [],
+          catchup: buildCatchup(since, tables, key, boundMatch),
+          version: atVersion,
+          unsubscribe
+        };
+      }
+      return {
+        initial: view.rows(),
+        version: atVersion,
+        unsubscribe
+      };
+    },
+    hydrate: async (collection, params, ctx) => {
+      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);
+        if (!allowed) {
+          throw new UnauthorizedError(`hydrate collection "${collection}"`);
+        }
+      }
+      return [...await definition.hydrate(params, ctx)];
+    },
+    applyChange: (table, change) => applyChange(table, change),
+    connectSource: async (source) => {
+      await source.start((table, change) => applyChange(table, change));
+      return async () => {
+        await source.stop();
+      };
+    },
+    connectCluster: async (bus) => {
+      const unsubscribe = await bus.subscribe((message) => {
+        if (message.origin === instanceId) {
+          return;
+        }
+        applyChangeBatch(message.changes, false);
+      });
+      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) => {
+      mutations.set(mutation.name, mutation);
+    },
+    registerWriter: (table, writer) => {
+      writers.set(table, writer);
+    },
+    registerReactive: (query2) => {
+      registry.set(query2.name, query2);
+    },
+    registerReader: (table, reader) => {
+      readers.set(table, reader);
+    },
+    runMutation: async (name, args, ctx) => {
+      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}"`);
+        }
+      }
+      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 runHandler = async (tx) => {
+        const buffered2 = [];
+        const actions = {
+          change: (collection, change) => {
+            buffered2.push({
+              table: collection,
+              change
+            });
+            return Promise.resolve();
+          },
+          insert: async (table, data) => {
+            const row = await writerFor(table).insert(data, ctx, tx);
+            buffered2.push({ table, change: { op: "insert", row } });
+            return row;
+          },
+          update: async (table, data) => {
+            const row = await writerFor(table).update(data, ctx, tx);
+            buffered2.push({ table, change: { op: "update", row } });
+            return row;
+          },
+          delete: async (table, row) => {
+            await writerFor(table).delete(row, ctx, tx);
+            buffered2.push({ table, change: { op: "delete", row } });
+          }
+        };
+        const handlerResult = await mutation.handler(args, ctx, actions);
+        return { buffered: buffered2, result: handlerResult };
+      };
+      const { buffered, result } = runInTransaction !== undefined ? await runInTransaction((tx) => runHandler(tx)) : await runHandler(undefined);
+      await applyChangeBatch(buffered);
+      return result;
+    }
+  };
+};
+// src/engine/routes.ts
+var emptyContext = () => ({});
+var hydrateRoute = (engine, collection, resolveContext = emptyContext) => {
+  return async (context) => {
+    const rows = await engine.hydrate(collection.name, context.query, resolveContext(context));
+    return rows;
+  };
+};
+var mutateRoute = (engine, mutation, resolveContext = emptyContext) => {
+  return async (context) => {
+    const result = await engine.runMutation(mutation.name, context.body, resolveContext(context));
+    return result;
+  };
+};
+// src/engine/connection.ts
+var parseFrame = (raw) => {
+  let value = raw;
+  if (typeof value === "string") {
+    try {
+      value = JSON.parse(value);
+    } catch {
+      return;
+    }
+  }
+  if (typeof value !== "object" || value === null) {
+    return;
+  }
+  const frame = value;
+  if (frame.type === "subscribe") {
+    return typeof frame.id === "string" && typeof frame.collection === "string" ? {
+      type: "subscribe",
+      id: frame.id,
+      collection: frame.collection,
+      params: frame.params,
+      since: typeof frame.since === "number" ? frame.since : undefined
+    } : 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,
+  presence
+}) => {
+  const subscriptions = new Map;
+  const presenceRooms = new Map;
+  let pending = [];
+  let pendingVersion;
+  let flushScheduled = false;
+  const flush = () => {
+    if (pending.length === 0) {
+      return;
+    }
+    const diffs = pending;
+    const version = pendingVersion;
+    pending = [];
+    pendingVersion = 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
+      });
+    } else {
+      send({ type: "frame", diffs, version });
+    }
+  };
+  const scheduleFlush = () => {
+    if (flushScheduled) {
+      return;
+    }
+    flushScheduled = true;
+    queueMicrotask(() => {
+      flushScheduled = false;
+      flush();
+    });
+  };
+  const bufferDiff = (diff, diffVersion) => {
+    if (pending.length > 0 && pendingVersion !== diffVersion) {
+      flush();
+    }
+    pending.push(diff);
+    pendingVersion = diffVersion;
+    scheduleFlush();
+  };
+  const handle = async (raw) => {
+    const frame = parseFrame(raw);
+    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) => {
+          bufferDiff({
+            id: frame.id,
+            added: diff.added,
+            removed: diff.removed,
+            changed: diff.changed
+          }, diffVersion);
+        }
+      });
+      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
+        });
+      } else {
+        send({
+          type: "snapshot",
+          id: frame.id,
+          rows: subscription.initial,
+          version: subscription.version
+        });
+      }
+    } 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();
+  };
+  return { handle, close };
+};
+export {
+  query,
+  parseOutboxRow,
+  orderByOp,
+  mutateRoute,
+  materialize,
+  mapOp,
+  joinNode,
+  isEmptyViewDiff,
+  hydrateRoute,
+  fromRowChange,
+  filterOp,
+  defineReactiveQuery,
+  defineMutation,
+  defineJoinCollection,
+  defineGraphCollection,
+  defineCollection,
+  createSyncEngine,
+  createSyncConnection,
+  createPresenceHub,
+  createPollingChangeSource,
+  createMaterializedView,
+  createInMemoryClusterBus,
+  createEquiJoin,
+  createAggregate,
+  chain,
+  aggregateOp,
+  UnauthorizedError
+};
+
+//# debugId=4ADB152722C87EA464756E2164756E21
+//# sourceMappingURL=index.js.map