@zeronsh/orbit 0.1.0

package/dist/chunk-N2NAKHMU.js

@@ -0,0 +1,1951 @@
+// client/src/protocol.ts
+var PROTOCOL_VERSION = 51;
+function hashString(s) {
+  let h = 0;
+  for (let i = 0; i < s.length; i++) {
+    h = Math.imul(31, h) + s.charCodeAt(i) | 0;
+  }
+  return (h >>> 0).toString(36);
+}
+function hashAST(ast) {
+  return hashString(JSON.stringify(ast));
+}
+
+// client/src/query.ts
+var Query = class _Query {
+  #ast;
+  /** `.one()` was called — a related parent should treat this as singular. */
+  #singular;
+  constructor(ast, singular = false) {
+    this.#ast = ast;
+    this.#singular = singular;
+  }
+  static from(table2) {
+    return new _Query({ table: table2 });
+  }
+  where(field, op, value) {
+    const cond = {
+      type: "simple",
+      op,
+      left: { type: "column", name: field },
+      right: { type: "literal", value }
+    };
+    return new _Query({ ...this.#ast, where: and(this.#ast.where, cond) }, this.#singular);
+  }
+  whereExists(correlation, subquery, negated = false) {
+    const cond = {
+      type: "correlatedSubquery",
+      related: { correlation, subquery: subquery.ast() },
+      op: negated ? "NOT EXISTS" : "EXISTS"
+    };
+    return new _Query({ ...this.#ast, where: and(this.#ast.where, cond) }, this.#singular);
+  }
+  related(name, correlation, subquery) {
+    const sub = { ...subquery.ast(), alias: name };
+    const entry = { correlation, subquery: sub, singular: subquery.#singular || void 0 };
+    const related = [...this.#ast.related ?? [], entry];
+    return new _Query({ ...this.#ast, related }, this.#singular);
+  }
+  /** Append a fully-formed related entry (used for junction/`hidden` chains). */
+  addRelated(entry) {
+    const related = [...this.#ast.related ?? [], entry];
+    return new _Query({ ...this.#ast, related }, this.#singular);
+  }
+  orderBy(field, dir) {
+    const orderBy = [...this.#ast.orderBy ?? [], [field, dir]];
+    return new _Query({ ...this.#ast, orderBy }, this.#singular);
+  }
+  limit(n) {
+    return new _Query({ ...this.#ast, limit: n }, this.#singular);
+  }
+  one() {
+    return new _Query({ ...this.#ast, limit: 1 }, true);
+  }
+  start(row, exclusive = false) {
+    return new _Query({ ...this.#ast, start: { row, exclusive } }, this.#singular);
+  }
+  /** Whether this query was marked `.one()` (singular). */
+  isSingular() {
+    return this.#singular;
+  }
+  ast() {
+    return this.#ast;
+  }
+};
+function and(existing, next) {
+  if (!existing) return next;
+  if (existing.type === "and") return { type: "and", conditions: [...existing.conditions, next] };
+  return { type: "and", conditions: [existing, next] };
+}
+var TypedQuery = class _TypedQuery {
+  #host;
+  #q;
+  constructor(host, q) {
+    this.#host = host;
+    this.#q = q;
+  }
+  where(field, op, value) {
+    return new _TypedQuery(this.#host, this.#q.where(field, op, value));
+  }
+  whereExists(correlation, subquery, negated = false) {
+    const sub = subquery instanceof _TypedQuery ? subquery.query() : subquery;
+    return new _TypedQuery(this.#host, this.#q.whereExists(correlation, sub, negated));
+  }
+  /**
+   * Add a nested relationship. The result type gains `name`: a `R[]` array, or
+   * `R | undefined` if the child query was `.one()`.
+   */
+  related(name, correlation, subquery) {
+    return new _TypedQuery(this.#host, this.#q.related(name, correlation, subquery.query()));
+  }
+  orderBy(field, dir) {
+    return new _TypedQuery(this.#host, this.#q.orderBy(field, dir));
+  }
+  limit(n) {
+    return new _TypedQuery(this.#host, this.#q.limit(n));
+  }
+  one() {
+    return new _TypedQuery(this.#host, this.#q.one());
+  }
+  start(row, exclusive = false) {
+    return new _TypedQuery(this.#host, this.#q.start(row, exclusive));
+  }
+  /** The underlying untyped query (escape hatch). */
+  query() {
+    return this.#q;
+  }
+  ast() {
+    return this.#q.ast();
+  }
+  /** Materialize into a live, typed view. */
+  materialize() {
+    if (!this.#host) throw new Error("this query is an unbound builder; subscribe via orbit.query.<name>()");
+    return this.#host.materialize(this.#q);
+  }
+};
+var SchemaQuery = class _SchemaQuery {
+  #host;
+  #schema;
+  #table;
+  #q;
+  constructor(host, schema, table2, q) {
+    this.#host = host;
+    this.#schema = schema;
+    this.#table = table2;
+    this.#q = q;
+  }
+  #wrap(q) {
+    return new _SchemaQuery(this.#host, this.#schema, this.#table, q);
+  }
+  where(field, op, value) {
+    return this.#wrap(this.#q.where(field, op, value));
+  }
+  whereExists(correlation, subquery, negated = false) {
+    const sub = subquery instanceof _SchemaQuery ? subquery.query() : subquery;
+    return this.#wrap(this.#q.whereExists(correlation, sub, negated));
+  }
+  orderBy(field, dir) {
+    return this.#wrap(this.#q.orderBy(field, dir));
+  }
+  limit(n) {
+    return this.#wrap(this.#q.limit(n));
+  }
+  one() {
+    return this.#wrap(this.#q.one());
+  }
+  start(row, exclusive = false) {
+    return this.#wrap(this.#q.start(row, exclusive));
+  }
+  related(name, second, third) {
+    if (third !== void 0 || isCorrelation(second)) {
+      const correlation = second;
+      const sub = third;
+      const subq = sub instanceof Query ? sub : sub.query();
+      return this.#wrap(this.#q.related(name, correlation, subq));
+    }
+    const chain = this.#schema.relationships?.[this.#table]?.[name];
+    if (!chain) {
+      throw new Error(`Unknown relationship "${name}" on table "${this.#table}". Declare it with relationships() in the schema.`);
+    }
+    const cb = second;
+    const last = chain[chain.length - 1];
+    let dest = new _SchemaQuery(null, this.#schema, last.destSchema, Query.from(last.destSchema));
+    if (cb) dest = cb(dest);
+    let destAst = { ...dest.ast(), alias: name };
+    const destSingular = last.cardinality === "one" || dest.isSingular();
+    if (chain.length === 1) {
+      const entry2 = {
+        correlation: { parentField: [...last.sourceField], childField: [...last.destField] },
+        subquery: destAst,
+        singular: destSingular || void 0
+      };
+      return this.#wrap(this.#q.addRelated(entry2));
+    }
+    const [first, second2] = chain;
+    const junctionAst = {
+      table: first.destSchema,
+      alias: name,
+      related: [
+        {
+          correlation: { parentField: [...second2.sourceField], childField: [...second2.destField] },
+          subquery: destAst,
+          singular: destSingular || void 0
+        }
+      ]
+    };
+    const entry = {
+      correlation: { parentField: [...first.sourceField], childField: [...first.destField] },
+      hidden: true,
+      subquery: junctionAst
+    };
+    return this.#wrap(this.#q.addRelated(entry));
+  }
+  isSingular() {
+    return this.#q.isSingular();
+  }
+  /** The underlying untyped query (escape hatch). */
+  query() {
+    return this.#q;
+  }
+  ast() {
+    return this.#q.ast();
+  }
+  materialize() {
+    if (!this.#host) throw new Error("this query is an unbound builder; subscribe via orbit.query.<name>()");
+    return this.#host.materialize(this.#q);
+  }
+};
+function isCorrelation(v) {
+  return typeof v === "object" && v !== null && "parentField" in v && "childField" in v;
+}
+function createBuilder(schema) {
+  return buildSchemaQueries(schema, null);
+}
+function buildSchemaQueries(schema, host) {
+  const out = {};
+  for (const name of Object.keys(schema.tables)) {
+    out[name] = new SchemaQuery(host, schema, name, Query.from(name));
+  }
+  return out;
+}
+
+// client/src/schema.ts
+var string = () => ({ type: "string", optional: false });
+var number = () => ({ type: "number", optional: false });
+var boolean = () => ({ type: "boolean", optional: false });
+var json = () => ({ type: "json", optional: false });
+var optional = (c) => ({ ...c, optional: true });
+function table(name) {
+  return {
+    columns(columns) {
+      return {
+        primaryKey(...primaryKey) {
+          return { name, columns, primaryKey };
+        }
+      };
+    }
+  };
+}
+var makeConnector = (cardinality) => (...args) => args.map((a) => ({
+  sourceField: a.sourceField,
+  destField: a.destField,
+  destSchema: a.destSchema.name,
+  cardinality
+}));
+function relationships(table2, cb) {
+  const r = cb({
+    one: makeConnector("one"),
+    many: makeConnector("many")
+  });
+  return { name: table2.name, relationships: r };
+}
+function createSchema(def) {
+  const tables = {};
+  for (const t of def.tables) tables[t.name] = t;
+  const rels = {};
+  for (const r of def.relationships ?? []) rels[r.name] = r.relationships;
+  return { tables, relationships: rels };
+}
+
+// client/src/custom.ts
+function defineMutator(fn) {
+  return fn;
+}
+function defineQuery(fn) {
+  return fn;
+}
+function collectOps(schema, def, args, ctx) {
+  const pk = {};
+  for (const t of Object.values(schema.tables)) pk[t.name] = [...t.primaryKey];
+  const ops = [];
+  const mutate = new Proxy(
+    {},
+    {
+      get: (_t, table2) => {
+        const make = (op) => (value) => ops.push({ op, tableName: table2, primaryKey: pk[table2] ?? ["id"], value });
+        return { insert: make("insert"), upsert: make("upsert"), update: make("update"), delete: make("delete") };
+      }
+    }
+  );
+  const tx = { location: "client", mutate };
+  void def({ tx, args, ctx });
+  return ops;
+}
+
+// client/src/query-manager.ts
+var UNIT_MS = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
+var MAX_TTL_MS = 6e5;
+var DEFAULT_TTL = "5m";
+function parseTTL(ttl) {
+  if (ttl === "forever") return Infinity;
+  if (ttl === "none") return 0;
+  if (typeof ttl === "number") return Math.max(0, ttl);
+  const m = /^(\d+(?:\.\d+)?)(s|m|h|d)$/.exec(ttl);
+  return m ? Number(m[1]) * UNIT_MS[m[2]] : parseTTL(DEFAULT_TTL);
+}
+function clampTTL(ms) {
+  return ms === Infinity ? Infinity : Math.min(ms, MAX_TTL_MS);
+}
+var defaultScheduler = {
+  setTimeout: (fn, ms) => setTimeout(fn, ms),
+  clearTimeout: (h) => clearTimeout(h)
+};
+var QueryManager = class {
+  #entries = /* @__PURE__ */ new Map();
+  #onSubscribe;
+  #onUnsubscribe;
+  #sched;
+  constructor(opts) {
+    this.#onSubscribe = opts.onSubscribe;
+    this.#onUnsubscribe = opts.onUnsubscribe;
+    this.#sched = opts.scheduler ?? defaultScheduler;
+  }
+  /**
+   * Register interest in a query. Returns a release function (idempotent). The
+   * first registration subscribes upstream; identical queries dedupe to one.
+   */
+  add(hash, put, ttl = DEFAULT_TTL) {
+    const ttlMs = clampTTL(parseTTL(ttl));
+    let entry = this.#entries.get(hash);
+    if (entry) {
+      entry.count++;
+      entry.ttlMs = Math.max(entry.ttlMs, ttlMs);
+      this.#cancelGc(entry);
+    } else {
+      const stamped = Number.isFinite(ttlMs) ? { ...put, ttl: ttlMs } : put;
+      entry = { put: stamped, count: 1, ttlMs };
+      this.#entries.set(hash, entry);
+      this.#onSubscribe(stamped);
+    }
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.#release(hash);
+    };
+  }
+  #release(hash) {
+    const entry = this.#entries.get(hash);
+    if (!entry || --entry.count > 0) return;
+    if (entry.ttlMs === Infinity) return;
+    if (entry.ttlMs <= 0) {
+      this.#gc(hash);
+      return;
+    }
+    entry.timer = this.#sched.setTimeout(() => this.#gc(hash), entry.ttlMs);
+  }
+  #cancelGc(entry) {
+    if (entry.timer !== void 0) {
+      this.#sched.clearTimeout(entry.timer);
+      entry.timer = void 0;
+    }
+  }
+  #gc(hash) {
+    const entry = this.#entries.get(hash);
+    if (!entry || entry.count > 0) return;
+    this.#entries.delete(hash);
+    this.#onUnsubscribe(hash);
+  }
+  /** All currently-subscribed query `put` ops (for reconnect resume). */
+  active() {
+    return [...this.#entries.values()].map((e) => e.put);
+  }
+  /** Number of live (subscribed, incl. within-TTL) queries — for tests/introspection. */
+  size() {
+    return this.#entries.size;
+  }
+};
+
+// client/src/store.ts
+var Store = class {
+  /** table -> (pk-json -> row), server-synced. */
+  #tables = /* @__PURE__ */ new Map();
+  /** Optimistic, not-yet-confirmed mutations, in order. */
+  #pending = [];
+  #listeners = /* @__PURE__ */ new Set();
+  #pkByTable;
+  // persistence
+  #kv;
+  #dirtyRows = /* @__PURE__ */ new Set();
+  // "tablepkKey"
+  #dirtyPending = /* @__PURE__ */ new Set();
+  #cleared = false;
+  #flushTimer;
+  /** Effective-row keys touched since the last notify (delivered to listeners). */
+  #changed = [];
+  constructor(pkByTable = {}) {
+    this.#pkByTable = pkByTable;
+  }
+  #pkCols(table2) {
+    return this.#pkByTable[table2] ?? ["id"];
+  }
+  /** Primary-key columns for a table (for complete ordering in the evaluator). */
+  pkOf(table2) {
+    return this.#pkCols(table2);
+  }
+  /** Primary-key tuple in *declared* order — matches the IVM engine's `pkKey`. */
+  #key(table2, row) {
+    return JSON.stringify(this.#pkCols(table2).map((c) => row[c] ?? null));
+  }
+  /** Public pk-key for a row (used by the IVM-backed view to match changes). */
+  keyOf(table2, row) {
+    return this.#key(table2, row);
+  }
+  /** The effective (synced + optimistic overlay) row for a pk key, or undefined. */
+  effectiveRow(table2, key) {
+    let row = this.#table(table2).get(key);
+    for (const p of this.#pending) {
+      for (const op of p.ops) {
+        if (op.tableName !== table2 || this.#key(table2, op.value) !== key) continue;
+        if (op.op === "delete") row = void 0;
+        else if (op.op === "update") row = { ...row ?? {}, ...op.value };
+        else row = op.value;
+      }
+    }
+    return row;
+  }
+  #table(name) {
+    let t = this.#tables.get(name);
+    if (!t) {
+      t = /* @__PURE__ */ new Map();
+      this.#tables.set(name, t);
+    }
+    return t;
+  }
+  // --- server-synced state (from pokes) ------------------------------------
+  apply(op) {
+    switch (op.op) {
+      case "put": {
+        const key = this.#key(op.tableName, op.value);
+        this.#table(op.tableName).set(key, op.value);
+        this.#touch(op.tableName, key);
+        break;
+      }
+      case "update": {
+        const t = this.#table(op.tableName);
+        const key = this.#key(op.tableName, op.id);
+        const existing = t.get(key) ?? { ...op.id };
+        t.set(key, { ...existing, ...op.merge ?? {} });
+        this.#touch(op.tableName, key);
+        break;
+      }
+      case "del": {
+        const key = this.#key(op.tableName, op.id);
+        this.#table(op.tableName).delete(key);
+        this.#touch(op.tableName, key);
+        break;
+      }
+      case "clear":
+        this.#tables.clear();
+        this.#cleared = true;
+        this.#dirtyRows.clear();
+        break;
+    }
+  }
+  applyAll(ops) {
+    for (const op of ops) this.apply(op);
+    this.#scheduleFlush();
+    this.#notify();
+  }
+  // --- optimistic overlay --------------------------------------------------
+  /** Queue an optimistic mutation's CRUD ops (applied on top of synced rows). */
+  addPending(id, ops, mutation) {
+    this.#pending.push({ id, ops, mutation });
+    this.#dirtyPending.add(id);
+    for (const op of ops) this.#touch(op.tableName, this.#key(op.tableName, op.value));
+    this.#scheduleFlush();
+    this.#notify();
+  }
+  /** Drop pending mutations the server has confirmed (id <= confirmed). */
+  confirmThrough(id) {
+    const before = this.#pending.length;
+    const dropped = this.#pending.filter((p) => p.id <= id);
+    if (dropped.length === 0) return;
+    this.#pending = this.#pending.filter((p) => p.id > id);
+    for (const p of dropped) {
+      this.#dirtyPending.add(p.id);
+      for (const op of p.ops) this.#touch(op.tableName, this.#key(op.tableName, op.value));
+    }
+    if (this.#pending.length !== before) {
+      this.#scheduleFlush();
+      this.#notify();
+    }
+  }
+  /** Originating messages of still-pending mutations (for resend after reload). */
+  pendingMutations() {
+    return this.#pending.map((p) => p.mutation).filter((m) => m !== void 0);
+  }
+  /** All rows for `table` with the optimistic overlay applied. */
+  effectiveRows(table2) {
+    const merged = new Map(this.#table(table2));
+    for (const p of this.#pending) {
+      for (const op of p.ops) {
+        if (op.tableName !== table2) continue;
+        const key = this.#key(table2, op.value);
+        if (op.op === "delete") merged.delete(key);
+        else if (op.op === "update") merged.set(key, { ...merged.get(key) ?? {}, ...op.value });
+        else merged.set(key, op.value);
+      }
+    }
+    return [...merged.values()];
+  }
+  subscribe(fn) {
+    this.#listeners.add(fn);
+    return () => this.#listeners.delete(fn);
+  }
+  #notify() {
+    const changed = this.#changed;
+    this.#changed = [];
+    for (const fn of this.#listeners) fn(changed);
+  }
+  // --- persistence ---------------------------------------------------------
+  #touch(table2, pkKey2) {
+    this.#changed.push({ table: table2, key: pkKey2 });
+    this.#dirtyRows.add(`${table2}\0${pkKey2}`);
+  }
+  #scheduleFlush() {
+    if (!this.#kv || this.#flushTimer !== void 0) return;
+    this.#flushTimer = setTimeout(() => void this.flush(), 50);
+  }
+  /** Load persisted rows + pending mutations from `kv` into memory. */
+  async hydrate(kv) {
+    this.#kv = kv;
+    const loaded = [];
+    for (const [, val] of await kv.entries("e/")) {
+      const { t, k, v } = val;
+      this.#table(t).set(k, v);
+      loaded.push({ table: t, key: k });
+    }
+    const pend = (await kv.entries("p/")).map(([, v]) => v).sort((a, b) => a.id - b.id);
+    for (const p of pend) {
+      this.#pending.push(p);
+      for (const op of p.ops) loaded.push({ table: op.tableName, key: this.#key(op.tableName, op.value) });
+    }
+    this.#changed.push(...loaded);
+    this.#notify();
+  }
+  /** Flush dirty rows + pending mutations to the KV (called debounced). */
+  async flush() {
+    if (this.#flushTimer !== void 0) {
+      clearTimeout(this.#flushTimer);
+      this.#flushTimer = void 0;
+    }
+    const kv = this.#kv;
+    if (!kv) return;
+    if (this.#cleared) {
+      const dels = [];
+      for (const [k] of await kv.entries("e/")) dels.push(kv.del(k));
+      await Promise.all(dels);
+      this.#cleared = false;
+    }
+    const ps = [];
+    for (const dk of this.#dirtyRows) {
+      const sep = dk.indexOf("\0");
+      const table2 = dk.slice(0, sep);
+      const pkKey2 = dk.slice(sep + 1);
+      const row = this.#tables.get(table2)?.get(pkKey2);
+      const key = `e/${table2}/${pkKey2}`;
+      ps.push(row ? kv.set(key, { t: table2, k: pkKey2, v: row }) : kv.del(key));
+    }
+    this.#dirtyRows.clear();
+    for (const id of this.#dirtyPending) {
+      const p = this.#pending.find((x) => x.id === id);
+      ps.push(p ? kv.set(`p/${id}`, p) : kv.del(`p/${id}`));
+    }
+    this.#dirtyPending.clear();
+    await Promise.all(ps);
+  }
+};
+
+// client/src/eval.ts
+function isNull(v) {
+  return v === null || v === void 0;
+}
+function typeRank(v) {
+  if (isNull(v)) return 0;
+  switch (typeof v) {
+    case "boolean":
+      return 1;
+    case "number":
+      return 2;
+    case "string":
+      return 3;
+    default:
+      return 4;
+  }
+}
+function compareValues(a, b) {
+  if (isNull(a) && isNull(b)) return 0;
+  if (isNull(a)) return -1;
+  if (isNull(b)) return 1;
+  if (typeof a === typeof b) {
+    if (typeof a === "number") return a < b ? -1 : a > b ? 1 : 0;
+    if (typeof a === "boolean") return a === b ? 0 : a ? 1 : -1;
+    if (typeof a === "string") return a < b ? -1 : a > b ? 1 : 0;
+    return 0;
+  }
+  return typeRank(a) - typeRank(b);
+}
+function valuesEqual(a, b) {
+  if (isNull(a) || isNull(b)) return false;
+  return a === b;
+}
+function likeToRegExp(pattern, ci) {
+  let re = "";
+  for (const ch of pattern) {
+    if (ch === "%") re += ".*";
+    else if (ch === "_") re += ".";
+    else re += ch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  return new RegExp(`^${re}$`, ci ? "is" : "s");
+}
+function resolve(row, pos) {
+  if (pos.type === "column") return row[pos.name];
+  if (pos.type === "literal") return pos.value;
+  return void 0;
+}
+function evalSimple(row, op, left, right) {
+  const l = resolve(row, left);
+  const r = resolve(row, right);
+  if (l === void 0 || r === void 0) return true;
+  if (op === "IS") return isNull(l) === isNull(r) && (isNull(l) || l === r);
+  if (op === "IS NOT") return !(isNull(l) === isNull(r) && (isNull(l) || l === r));
+  if (op === "IN" || op === "NOT IN") {
+    if (isNull(l)) return false;
+    const arr = Array.isArray(r) ? r : [r];
+    const found = arr.some((x) => valuesEqual(l, x));
+    return op === "IN" ? found : !found;
+  }
+  const a = l;
+  const b = r;
+  switch (op) {
+    case "=":
+      return valuesEqual(a, b);
+    case "!=":
+      return !isNull(a) && !isNull(b) && a !== b;
+    case "<":
+      return !isNull(a) && !isNull(b) && compareValues(a, b) < 0;
+    case ">":
+      return !isNull(a) && !isNull(b) && compareValues(a, b) > 0;
+    case "<=":
+      return !isNull(a) && !isNull(b) && compareValues(a, b) <= 0;
+    case ">=":
+      return !isNull(a) && !isNull(b) && compareValues(a, b) >= 0;
+    case "LIKE":
+      return !isNull(a) && likeToRegExp(String(b), false).test(String(a));
+    case "NOT LIKE":
+      return !isNull(a) && !likeToRegExp(String(b), false).test(String(a));
+    case "ILIKE":
+      return !isNull(a) && likeToRegExp(String(b), true).test(String(a));
+    case "NOT ILIKE":
+      return !isNull(a) && !likeToRegExp(String(b), true).test(String(a));
+    default:
+      return true;
+  }
+}
+function simpleMatches(row, cond) {
+  return evalSimple(row, cond.op, cond.left, cond.right);
+}
+function compareByOrder(a, b, orderBy) {
+  for (const [field, dir] of orderBy) {
+    const c = compareValues(a[field], b[field]);
+    if (c !== 0) return dir === "asc" ? c : -c;
+  }
+  return 0;
+}
+function completeOrder(orderBy, pk) {
+  const order = [...orderBy ?? []];
+  for (const k of pk) if (!order.some(([f]) => f === k)) order.push([k, "asc"]);
+  return order;
+}
+function correlated(parent, child, c) {
+  return c.parentField.every((pf, i) => valuesEqual(parent[pf], child[c.childField[i]]));
+}
+function existsRelationships(cond) {
+  const out = [];
+  const walk = (c) => {
+    if (!c) return;
+    if (c.type === "correlatedSubquery") {
+      const alias = c.related.subquery.alias;
+      if (alias && !alias.startsWith("zsubq_")) out.push(c.related);
+    } else if (c.type === "and" || c.type === "or") {
+      for (const inner of c.conditions) walk(inner);
+    }
+  };
+  walk(cond);
+  return out;
+}
+function liftHidden(junctionRows, junctionAst) {
+  const inner = junctionAst.related?.[0];
+  if (!inner) return [];
+  const innerAlias = inner.subquery.alias ?? inner.subquery.table;
+  return junctionRows.flatMap((jr) => jr[innerAlias] ?? []);
+}
+function evaluate(getRows, ast, opts = {}) {
+  const applyWhere = opts.applyWhere ?? true;
+  const pkOf = opts.pkOf ?? (() => ["id"]);
+  const run = (node, parent, corr) => {
+    let rows = getRows(node.table);
+    if (parent && corr) rows = rows.filter((r) => correlated(parent, r, corr));
+    const evalCond = (r, cond) => {
+      switch (cond.type) {
+        case "simple":
+          return evalSimple(r, cond.op, cond.left, cond.right);
+        case "and":
+          return cond.conditions.every((c) => evalCond(r, c));
+        case "or":
+          return cond.conditions.some((c) => evalCond(r, c));
+        case "correlatedSubquery": {
+          const has = run(cond.related.subquery, r, cond.related.correlation).length > 0;
+          return cond.op === "EXISTS" ? has : !has;
+        }
+      }
+    };
+    if (applyWhere && node.where) rows = rows.filter((r) => evalCond(r, node.where));
+    rows = [...rows];
+    const order = completeOrder(node.orderBy, pkOf(node.table));
+    rows.sort((a, b) => compareByOrder(a, b, order));
+    if (node.start) {
+      const { row: cursor, exclusive } = node.start;
+      const i = rows.findIndex((r) => {
+        const c = compareByOrder(r, cursor, order);
+        return exclusive ? c > 0 : c >= 0;
+      });
+      rows = i < 0 ? [] : rows.slice(i);
+    }
+    if (node.limit != null) rows = rows.slice(0, node.limit);
+    const related = node.related ?? [];
+    const existsRels = existsRelationships(node.where);
+    if (related.length === 0 && existsRels.length === 0) return rows;
+    return rows.map((r) => {
+      const out = { ...r };
+      for (const rel of [...related, ...existsRels]) {
+        const alias = rel.subquery.alias ?? rel.subquery.table;
+        const children = run(rel.subquery, r, rel.correlation);
+        out[alias] = rel.hidden ? liftHidden(children, rel.subquery) : children;
+      }
+      return out;
+    });
+  };
+  return run(ast, null, null);
+}
+function unwrapSingular(rows, ast) {
+  const related = ast.related;
+  if (!related || related.length === 0) return rows;
+  return rows.map((r) => {
+    const out = { ...r };
+    for (const rel of related) {
+      const alias = rel.subquery.alias ?? rel.subquery.table;
+      if (rel.hidden) {
+        const inner = rel.subquery.related[0];
+        const dest = unwrapSingular(out[alias] ?? [], inner.subquery);
+        out[alias] = inner.singular ? dest[0] : dest;
+      } else {
+        const children = unwrapSingular(out[alias] ?? [], rel.subquery);
+        out[alias] = rel.singular ? children[0] : children;
+      }
+    }
+    return out;
+  });
+}
+
+// client/src/ivm/data.ts
+function deliver(op, change) {
+  const results = op.push(change);
+  const out = op.output;
+  if (out) for (const r of results) deliver(out, r);
+}
+function makeComparator(order, reverse = false) {
+  return (a, b) => {
+    for (const [field, dir] of order) {
+      const c = compareValues(a[field], b[field]);
+      if (c !== 0) {
+        const r = dir === "asc" ? c : -c;
+        return reverse ? -r : r;
+      }
+    }
+    return 0;
+  };
+}
+function completeOrder2(orderBy, pk) {
+  const order = [...orderBy ?? []];
+  for (const k of pk) if (!order.some(([f]) => f === k)) order.push([k, "asc"]);
+  return order;
+}
+function pkKey(pk, row) {
+  return JSON.stringify(pk.map((k) => row[k] ?? null));
+}
+function constraintMatches(constraint, row) {
+  for (const k of Object.keys(constraint)) {
+    if (!valuesEqual(row[k] ?? null, constraint[k])) return false;
+  }
+  return true;
+}
+function buildJoinConstraint(from, fromKeys, toKeys) {
+  const c = {};
+  for (let i = 0; i < fromKeys.length; i++) {
+    const v = from[fromKeys[i]] ?? null;
+    if (v === null) return null;
+    c[toKeys[i]] = v;
+  }
+  return c;
+}
+function rowEq(a, b) {
+  const ak = Object.keys(a);
+  const bk = Object.keys(b);
+  if (ak.length !== bk.length) return false;
+  for (const k of ak) if (a[k] !== b[k]) return false;
+  return true;
+}
+function nodeEq(a, b) {
+  if (!rowEq(a.row, b.row)) return false;
+  const ak = Object.keys(a.relationships);
+  const bk = Object.keys(b.relationships);
+  if (ak.length !== bk.length) return false;
+  for (const k of ak) {
+    const ca = a.relationships[k];
+    const cb = b.relationships[k];
+    if (!cb || ca.length !== cb.length) return false;
+    for (let i = 0; i < ca.length; i++) if (!nodeEq(ca[i], cb[i])) return false;
+  }
+  return true;
+}
+
+// client/src/ivm/operators.ts
+var Filter = class {
+  output = null;
+  #input;
+  #predicate;
+  constructor(input, predicate) {
+    this.#input = input;
+    this.#predicate = predicate;
+    input.setOutput(this);
+  }
+  fetch(req) {
+    return this.#input.fetch(req).filter((n) => this.#predicate(n.row));
+  }
+  push(change) {
+    return filterPush(change, this.#predicate);
+  }
+  setOutput(o) {
+    this.output = o;
+  }
+};
+function filterPush(change, predicate) {
+  switch (change.type) {
+    case "add":
+    case "remove":
+    case "child":
+      return predicate(change.node.row) ? [change] : [];
+    case "edit": {
+      const o = predicate(change.oldNode.row);
+      const n = predicate(change.node.row);
+      if (o && n) return [change];
+      if (o && !n) return [{ type: "remove", node: change.oldNode }];
+      if (!o && n) return [{ type: "add", node: change.node }];
+      return [];
+    }
+  }
+}
+function skip(input, bound, exclusive, cmp) {
+  return new Filter(input, (row) => {
+    const o = cmp(row, bound);
+    return exclusive ? o > 0 : o >= 0;
+  });
+}
+var CondFilter = class {
+  output = null;
+  #input;
+  #predicate;
+  #pk;
+  #passing = null;
+  constructor(input, predicate, pk) {
+    this.#input = input;
+    this.#predicate = predicate;
+    this.#pk = pk;
+    input.setOutput(this);
+  }
+  /** Lazily build the set of currently-passing primary keys from the input. */
+  #ensure() {
+    if (!this.#passing) {
+      this.#passing = /* @__PURE__ */ new Set();
+      for (const n of this.#input.fetch({})) if (this.#predicate(n)) this.#passing.add(pkKey(this.#pk, n.row));
+    }
+    return this.#passing;
+  }
+  fetch(req) {
+    const nodes = this.#input.fetch(req).filter((n) => this.#predicate(n));
+    this.#ensure();
+    return nodes;
+  }
+  /**
+   * Incremental: only the changed node's membership can flip, so process just
+   * this change instead of recomputing the whole passing set.
+   */
+  push(change) {
+    const passing = this.#ensure();
+    const key = pkKey(this.#pk, change.node.row);
+    switch (change.type) {
+      case "add":
+        if (this.#predicate(change.node)) {
+          passing.add(key);
+          return [change];
+        }
+        return [];
+      case "remove":
+        if (passing.has(key)) {
+          passing.delete(key);
+          return [change];
+        }
+        return [];
+      case "edit": {
+        const was = passing.has(key);
+        const now = this.#predicate(change.node);
+        if (was && now) return [change];
+        if (was && !now) {
+          passing.delete(key);
+          return [{ type: "remove", node: change.oldNode }];
+        }
+        if (!was && now) {
+          passing.add(key);
+          return [{ type: "add", node: change.node }];
+        }
+        return [];
+      }
+      case "child": {
+        const was = passing.has(key);
+        const now = this.#predicate(change.node);
+        if (was && now) return [change];
+        if (was && !now) {
+          passing.delete(key);
+          return [{ type: "remove", node: change.node }];
+        }
+        if (!was && now) {
+          passing.add(key);
+          return [{ type: "add", node: change.node }];
+        }
+        return [];
+      }
+    }
+  }
+  setOutput(o) {
+    this.output = o;
+  }
+};
+var Take = class {
+  output = null;
+  #input;
+  #limit;
+  #pk;
+  #partitionKey;
+  #cmp;
+  /** All rows per partition, kept in sort order (incrementally maintained). */
+  #partitions = null;
+  /** The last-emitted top-`limit` window per partition (for diffing). */
+  #windows = /* @__PURE__ */ new Map();
+  constructor(input, limit, pk, partitionKey, cmp) {
+    this.#input = input;
+    this.#limit = limit;
+    this.#pk = pk;
+    this.#partitionKey = partitionKey;
+    this.#cmp = cmp;
+    input.setOutput(this);
+  }
+  #partition(row) {
+    return this.#partitionKey ? JSON.stringify(this.#partitionKey.map((k) => row[k] ?? null)) : "";
+  }
+  #ensure() {
+    if (!this.#partitions) {
+      this.#partitions = /* @__PURE__ */ new Map();
+      for (const n of this.#input.fetch({})) {
+        const p = this.#partition(n.row);
+        const arr = this.#partitions.get(p) ?? [];
+        arr.push(n);
+        this.#partitions.set(p, arr);
+      }
+      for (const [p, arr] of this.#partitions) this.#windows.set(p, arr.slice(0, this.#limit));
+    }
+    return this.#partitions;
+  }
+  fetch(req) {
+    this.#ensure();
+    if (req.constraint || !this.#partitionKey) {
+      return this.#input.fetch(req).slice(0, this.#limit);
+    }
+    const out = [];
+    for (const arr of this.#partitions.values()) out.push(...arr.slice(0, this.#limit));
+    return out;
+  }
+  /** Incremental: touch only the affected partition(s) and diff their windows. */
+  push(change) {
+    this.#ensure();
+    const out = [];
+    switch (change.type) {
+      case "add":
+        this.#updatePartition(this.#partition(change.node.row), (arr) => insertSorted(arr, change.node, this.#cmp), out);
+        break;
+      case "remove":
+        this.#updatePartition(this.#partition(change.node.row), (arr) => removeByPk(arr, change.node.row, this.#pk), out);
+        break;
+      case "child":
+        this.#updatePartition(this.#partition(change.node.row), (arr) => replaceByPk(arr, change.node, this.#pk), out);
+        break;
+      case "edit": {
+        const po = this.#partition(change.oldNode.row);
+        const pn = this.#partition(change.node.row);
+        if (po === pn) {
+          this.#updatePartition(po, (arr) => {
+            removeByPk(arr, change.oldNode.row, this.#pk);
+            insertSorted(arr, change.node, this.#cmp);
+          }, out);
+        } else {
+          this.#updatePartition(po, (arr) => removeByPk(arr, change.oldNode.row, this.#pk), out);
+          this.#updatePartition(pn, (arr) => insertSorted(arr, change.node, this.#cmp), out);
+        }
+        break;
+      }
+    }
+    return out;
+  }
+  #updatePartition(p, mutate, out) {
+    const arr = this.#partitions.get(p) ?? [];
+    mutate(arr);
+    this.#partitions.set(p, arr);
+    const newWin = arr.slice(0, this.#limit);
+    const oldWin = this.#windows.get(p) ?? [];
+    diffWindow(oldWin, newWin, this.#pk, out);
+    this.#windows.set(p, newWin);
+  }
+  setOutput(o) {
+    this.output = o;
+  }
+};
+function insertSorted(arr, node, cmp) {
+  let lo = 0;
+  let hi = arr.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (cmp(arr[mid].row, node.row) < 0) lo = mid + 1;
+    else hi = mid;
+  }
+  arr.splice(lo, 0, node);
+}
+function removeByPk(arr, row, pk) {
+  const k = pkKey(pk, row);
+  const i = arr.findIndex((n) => pkKey(pk, n.row) === k);
+  if (i >= 0) arr.splice(i, 1);
+}
+function replaceByPk(arr, node, pk) {
+  const k = pkKey(pk, node.row);
+  const i = arr.findIndex((n) => pkKey(pk, n.row) === k);
+  if (i >= 0) arr[i] = node;
+}
+function diffWindow(oldWin, newWin, pk, out) {
+  const oldMap = new Map(oldWin.map((n) => [pkKey(pk, n.row), n]));
+  const newMap = new Map(newWin.map((n) => [pkKey(pk, n.row), n]));
+  for (const [k, o] of oldMap) {
+    const n = newMap.get(k);
+    if (!n || !nodeEq(o, n)) out.push({ type: "remove", node: o });
+  }
+  for (const [k, n] of newMap) {
+    const o = oldMap.get(k);
+    if (!o || !nodeEq(o, n)) out.push({ type: "add", node: n });
+  }
+}
+var Join = class {
+  output = null;
+  #parent;
+  #child;
+  #parentKey;
+  #childKey;
+  #rel;
+  constructor(parent, child, parentKey, childKey, relationshipName2) {
+    this.#parent = parent;
+    this.#child = child;
+    this.#parentKey = parentKey;
+    this.#childKey = childKey;
+    this.#rel = relationshipName2;
+    parent.setOutput(new JoinParentPort(this));
+    child.setOutput(new JoinChildPort(this));
+  }
+  #process(parent) {
+    const constraint = buildJoinConstraint(parent.row, this.#parentKey, this.#childKey);
+    const children = constraint ? this.#child.fetch({ constraint }) : [];
+    return { row: parent.row, relationships: { ...parent.relationships, [this.#rel]: children } };
+  }
+  fetch(req) {
+    return this.#parent.fetch(req).map((n) => this.#process(n));
+  }
+  push() {
+    throw new Error("Join is pushed via its parent/child ports");
+  }
+  setOutput(o) {
+    this.output = o;
+  }
+  pushParent(change) {
+    switch (change.type) {
+      case "add":
+        return [{ type: "add", node: this.#process(change.node) }];
+      case "remove":
+        return [{ type: "remove", node: this.#process(change.node) }];
+      case "child":
+        return [{
+          type: "child",
+          node: this.#process(change.node),
+          relationshipName: change.relationshipName,
+          change: change.change
+        }];
+      case "edit":
+        if (sameKey(change.oldNode.row, change.node.row, this.#parentKey)) {
+          return [{ type: "edit", node: this.#process(change.node), oldNode: this.#process(change.oldNode) }];
+        }
+        return [
+          { type: "remove", node: this.#process(change.oldNode) },
+          { type: "add", node: this.#process(change.node) }
+        ];
+    }
+  }
+  pushChild(change) {
+    const childRows = [change.node.row];
+    if (change.type === "edit" && !sameKey(change.oldNode.row, change.node.row, this.#childKey)) {
+      childRows[0] = change.node.row;
+      childRows.push(change.oldNode.row);
+    }
+    const out = [];
+    for (const childRow of childRows) {
+      const constraint = buildJoinConstraint(childRow, this.#childKey, this.#parentKey);
+      if (!constraint) continue;
+      for (const p of this.#parent.fetch({ constraint })) {
+        out.push({ type: "child", node: this.#process(p), relationshipName: this.#rel, change });
+      }
+    }
+    return out;
+  }
+};
+function sameKey(a, b, keys) {
+  return keys.every((k) => a[k] === b[k]);
+}
+var JoinParentPort = class {
+  #join;
+  constructor(join) {
+    this.#join = join;
+  }
+  get output() {
+    return this.#join.output;
+  }
+  set output(_o) {
+  }
+  fetch() {
+    throw new Error("join port has no fetch");
+  }
+  push(c) {
+    return this.#join.pushParent(c);
+  }
+  setOutput() {
+  }
+};
+var JoinChildPort = class {
+  #join;
+  constructor(join) {
+    this.#join = join;
+  }
+  get output() {
+    return this.#join.output;
+  }
+  set output(_o) {
+  }
+  fetch() {
+    throw new Error("join port has no fetch");
+  }
+  push(c) {
+    return this.#join.pushChild(c);
+  }
+  setOutput() {
+  }
+};
+
+// client/src/ivm/build.ts
+var SUBQ = "zsubq_";
+function buildPipeline(ast, provider, partitionKey = null) {
+  const pk = provider.pkOf(ast.table);
+  const order = completeOrder2(ast.orderBy, pk);
+  let current = provider.connect(ast.table, order);
+  if (ast.start) current = skip(current, ast.start.row, ast.start.exclusive, makeComparator(order));
+  if (ast.where) {
+    if (conditionHasExists(ast.where)) {
+      const joins = [];
+      const counter = { n: 0 };
+      const resolved = resolveCondition(ast.where, joins, counter);
+      for (const { relName, related } of joins) {
+        const child = buildPipeline(related.subquery, provider);
+        current = new Join(
+          current,
+          child,
+          related.correlation.parentField,
+          related.correlation.childField,
+          relName
+        );
+      }
+      current = new CondFilter(current, nodePredicate(resolved), pk);
+    } else {
+      current = new Filter(current, rowPredicate(ast.where));
+    }
+  }
+  for (const sub of ast.related ?? []) {
+    const child = buildPipeline(sub.subquery, provider, sub.correlation.childField);
+    current = new Join(
+      current,
+      child,
+      sub.correlation.parentField,
+      sub.correlation.childField,
+      relationshipName(sub)
+    );
+  }
+  if (ast.limit != null) current = new Take(current, ast.limit, pk, partitionKey, makeComparator(order));
+  return current;
+}
+function relationshipName(sub) {
+  const a = sub.subquery.alias;
+  if (a) return a.startsWith(SUBQ) ? a.slice(SUBQ.length) : a;
+  return sub.subquery.table;
+}
+function resolveCondition(cond, joins, counter) {
+  switch (cond.type) {
+    case "simple":
+      return { kind: "simple", cond };
+    case "and":
+      return { kind: "and", items: cond.conditions.map((c) => resolveCondition(c, joins, counter)) };
+    case "or":
+      return { kind: "or", items: cond.conditions.map((c) => resolveCondition(c, joins, counter)) };
+    case "correlatedSubquery": {
+      const relName = cond.related.subquery.alias ?? `${SUBQ}exists_${counter.n++}`;
+      joins.push({ relName, related: cond.related });
+      return { kind: "exists", relName, negated: cond.op === "NOT EXISTS" };
+    }
+  }
+}
+function nodePredicate(resolved) {
+  const evalResolved = (r, node) => {
+    switch (r.kind) {
+      case "simple":
+        return simpleMatches(node.row, r.cond);
+      case "and":
+        return r.items.every((x) => evalResolved(x, node));
+      case "or":
+        return r.items.some((x) => evalResolved(x, node));
+      case "exists": {
+        const present = (node.relationships[r.relName]?.length ?? 0) > 0;
+        return present !== r.negated;
+      }
+    }
+  };
+  return (node) => evalResolved(resolved, node);
+}
+function rowPredicate(cond) {
+  const evalRow = (c, row) => {
+    switch (c.type) {
+      case "simple":
+        return simpleMatches(row, c);
+      case "and":
+        return c.conditions.every((x) => evalRow(x, row));
+      case "or":
+        return c.conditions.some((x) => evalRow(x, row));
+      case "correlatedSubquery":
+        throw new Error("EXISTS must be handled by CondFilter");
+    }
+  };
+  return (row) => evalRow(cond, row);
+}
+function conditionHasExists(cond) {
+  switch (cond.type) {
+    case "correlatedSubquery":
+      return true;
+    case "and":
+    case "or":
+      return cond.conditions.some(conditionHasExists);
+    case "simple":
+      return false;
+  }
+}
+
+// client/src/ivm/view.ts
+var MaterializedView = class {
+  /** The current top-level result, in sort order. */
+  nodes;
+  #cmp;
+  #pk;
+  constructor(top, order, pk) {
+    this.#cmp = makeComparator(order);
+    this.#pk = pk;
+    this.nodes = top.fetch({});
+    const terminal = {
+      output: null,
+      fetch: () => [],
+      setOutput: () => {
+      },
+      push: (c) => {
+        this.#apply(c);
+        return [];
+      }
+    };
+    top.setOutput(terminal);
+  }
+  #apply(change) {
+    switch (change.type) {
+      case "add":
+        this.#insert(change.node);
+        break;
+      case "remove":
+        this.#removeByPk(change.node.row);
+        break;
+      case "edit":
+        this.#removeByPk(change.oldNode.row);
+        this.#insert(change.node);
+        break;
+      case "child": {
+        const i = this.#indexByPk(change.node.row);
+        if (i >= 0) this.nodes[i] = change.node;
+        break;
+      }
+    }
+  }
+  #insert(node) {
+    let lo = 0;
+    let hi = this.nodes.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (this.#cmp(this.nodes[mid].row, node.row) < 0) lo = mid + 1;
+      else hi = mid;
+    }
+    this.nodes.splice(lo, 0, node);
+  }
+  #indexByPk(row) {
+    const k = pkKey(this.#pk, row);
+    return this.nodes.findIndex((n) => pkKey(this.#pk, n.row) === k);
+  }
+  #removeByPk(row) {
+    const i = this.#indexByPk(row);
+    if (i >= 0) this.nodes.splice(i, 1);
+  }
+  /** The result as Zero's `{row, rels}` snapshot shape (hidden `zsubq_*` excluded). */
+  snapshot() {
+    return this.nodes.map(normNode);
+  }
+};
+function normNode(node) {
+  const rels = {};
+  for (const k of Object.keys(node.relationships).sort()) {
+    if (k.startsWith("zsubq_")) continue;
+    rels[k] = node.relationships[k].map(normNode);
+  }
+  return { row: node.row, rels };
+}
+
+// client/src/ivm/source.ts
+var MemorySource = class {
+  table;
+  pk;
+  #rows = /* @__PURE__ */ new Map();
+  #connections = [];
+  constructor(table2, pk) {
+    this.table = table2;
+    this.pk = pk;
+  }
+  insertInitial(row) {
+    this.#rows.set(pkKey(this.pk, row), row);
+  }
+  rows() {
+    return [...this.#rows.values()];
+  }
+  get(key) {
+    return this.#rows.get(key);
+  }
+  connect(order) {
+    const conn = { output: null, order, cmp: makeComparator(order) };
+    this.#connections.push(conn);
+    return new SourceConnection(this, conn);
+  }
+  fetchConn(req, conn) {
+    let rows = [...this.#rows.values()];
+    if (req.constraint) rows = rows.filter((r) => constraintMatches(req.constraint, r));
+    const cmp = req.reverse ? makeComparator(conn.order, true) : conn.cmp;
+    rows = [...rows].sort(cmp);
+    if (req.start) {
+      const { row, basis } = req.start;
+      const i = rows.findIndex((r) => {
+        const c = cmp(r, row);
+        return basis === "after" ? c > 0 : c >= 0;
+      });
+      rows = i < 0 ? [] : rows.slice(i);
+    }
+    return rows.map((r) => ({ row: r, relationships: {} }));
+  }
+  /** Apply a source change (commit-first) and propagate to all connections. */
+  push(change) {
+    if (change.type === "add") {
+      this.#rows.set(pkKey(this.pk, change.row), change.row);
+    } else if (change.type === "remove") {
+      this.#rows.delete(pkKey(this.pk, change.row));
+    } else {
+      this.#rows.delete(pkKey(this.pk, change.oldRow));
+      this.#rows.set(pkKey(this.pk, change.row), change.row);
+    }
+    for (const conn of this.#connections) {
+      if (conn.output) deliver(conn.output, toChange(change));
+    }
+  }
+};
+var MemorySourceProvider = class {
+  #sources = /* @__PURE__ */ new Map();
+  add(table2, pk, rows) {
+    const s = new MemorySource(table2, pk);
+    for (const r of rows) s.insertInitial(r);
+    this.#sources.set(table2, s);
+    return s;
+  }
+  source(table2) {
+    const s = this.#sources.get(table2);
+    if (!s) throw new Error(`no source for table ${table2}`);
+    return s;
+  }
+  pkOf(table2) {
+    return this.source(table2).pk;
+  }
+  connect(table2, order) {
+    return this.source(table2).connect(order);
+  }
+  push(table2, change) {
+    this.source(table2).push(change);
+  }
+};
+function toChange(change) {
+  if (change.type === "add") return { type: "add", node: { row: change.row, relationships: {} } };
+  if (change.type === "remove") return { type: "remove", node: { row: change.row, relationships: {} } };
+  return {
+    type: "edit",
+    node: { row: change.row, relationships: {} },
+    oldNode: { row: change.oldRow, relationships: {} }
+  };
+}
+var SourceConnection = class {
+  output = null;
+  #src;
+  #conn;
+  constructor(src, conn) {
+    this.#src = src;
+    this.#conn = conn;
+  }
+  fetch(req) {
+    return this.#src.fetchConn(req, this.#conn);
+  }
+  push() {
+    throw new Error("a source connection never receives an upstream push");
+  }
+  setOutput(o) {
+    this.output = o;
+    this.#conn.output = o;
+  }
+};
+
+// client/src/ivm/store-provider.ts
+var StoreProvider = class {
+  #store;
+  #sources = /* @__PURE__ */ new Map();
+  constructor(store) {
+    this.#store = store;
+  }
+  pkOf(table2) {
+    return this.#store.pkOf(table2);
+  }
+  connect(table2, order) {
+    return this.#ensure(table2).connect(order);
+  }
+  #ensure(table2) {
+    let s = this.#sources.get(table2);
+    if (!s) {
+      s = new MemorySource(table2, this.#store.pkOf(table2));
+      for (const row of this.#store.effectiveRows(table2)) s.insertInitial(row);
+      this.#sources.set(table2, s);
+    }
+    return s;
+  }
+  /** Push the change for one touched effective-row key into its table's source. */
+  applyChange(table2, key) {
+    const src = this.#sources.get(table2);
+    if (!src) return;
+    const next = this.#store.effectiveRow(table2, key);
+    const prev = src.get(key);
+    if (prev && next) {
+      if (!rowEq(prev, next)) src.push({ type: "edit", row: next, oldRow: prev });
+    } else if (next) {
+      src.push({ type: "add", row: next });
+    } else if (prev) {
+      src.push({ type: "remove", row: prev });
+    }
+  }
+};
+function tablesOf(ast, out = /* @__PURE__ */ new Set()) {
+  out.add(ast.table);
+  for (const rel of ast.related ?? []) tablesOf(rel.subquery, out);
+  for (const rel of existsRelationships(ast.where)) tablesOf(rel.subquery, out);
+  collectExistsTables(ast.where, out);
+  return out;
+}
+function collectExistsTables(cond, out) {
+  if (!cond) return;
+  if (cond.type === "correlatedSubquery") tablesOf(cond.related.subquery, out);
+  else if (cond.type === "and" || cond.type === "or") for (const c of cond.conditions) collectExistsTables(c, out);
+}
+function nodeToRow(node, ast) {
+  const out = { ...node.row };
+  for (const rel of ast.related ?? []) {
+    const alias = rel.subquery.alias ?? rel.subquery.table;
+    if (rel.hidden) {
+      const inner = rel.subquery.related[0];
+      const innerAlias = inner.subquery.alias ?? inner.subquery.table;
+      const junctionNodes = node.relationships[alias] ?? [];
+      const dest = junctionNodes.flatMap((jn) => (jn.relationships[innerAlias] ?? []).map((c) => nodeToRow(c, inner.subquery)));
+      out[alias] = inner.singular ? dest[0] : dest;
+    } else {
+      const children = (node.relationships[alias] ?? []).map((c) => nodeToRow(c, rel.subquery));
+      out[alias] = rel.singular ? children[0] : children;
+    }
+  }
+  for (const rel of existsRelationships(ast.where)) {
+    const alias = rel.subquery.alias;
+    out[alias] = (node.relationships[alias] ?? []).map((c) => nodeToRow(c, rel.subquery));
+  }
+  return out;
+}
+
+// client/src/client.ts
+function encodeSecProtocol(authToken) {
+  const payload = JSON.stringify({ initConnectionMessage: null, authToken });
+  const b64 = typeof btoa === "function" ? btoa(payload) : Buffer.from(payload, "utf8").toString("base64");
+  return encodeURIComponent(b64);
+}
+var View = class {
+  #ast;
+  #unsub;
+  #onDestroy;
+  #provider;
+  #mview;
+  #tables;
+  data = [];
+  #listeners = /* @__PURE__ */ new Set();
+  constructor(store, ast, applyWhere = true, onDestroy) {
+    this.#ast = applyWhere ? ast : { ...ast, where: void 0 };
+    this.#onDestroy = onDestroy;
+    this.#tables = tablesOf(this.#ast);
+    this.#provider = new StoreProvider(store);
+    const pk = store.pkOf(this.#ast.table);
+    const top = buildPipeline(this.#ast, this.#provider);
+    this.#mview = new MaterializedView(top, completeOrder2(this.#ast.orderBy, pk), pk);
+    this.#refresh();
+    this.#unsub = store.subscribe((changed) => this.#onChange(changed));
+  }
+  #onChange(changed) {
+    let touched = false;
+    for (const { table: table2, key } of changed) {
+      if (this.#tables.has(table2)) {
+        this.#provider.applyChange(table2, key);
+        touched = true;
+      }
+    }
+    if (touched) this.#refresh();
+  }
+  #refresh() {
+    this.data = this.#mview.nodes.map((n) => nodeToRow(n, this.#ast));
+    for (const fn of this.#listeners) fn();
+  }
+  subscribe(fn) {
+    this.#listeners.add(fn);
+    return () => this.#listeners.delete(fn);
+  }
+  /** Stop reacting to store changes + release the query subscription (Zero's `view.destroy()`). */
+  destroy() {
+    this.#unsub();
+    this.#listeners.clear();
+    this.#onDestroy?.();
+  }
+};
+var Orbit = class {
+  // Not `readonly`: when `persist` is enabled and no explicit id was given, these
+  // are restored from the KV in `#init` so a reload keeps the same identity (and
+  // thus resumes the same server CVR as a fast delta instead of a full resync).
+  clientID;
+  clientGroupID;
+  /** Per-table typed query builder (ad-hoc queries): `orbit.query.todo.where(...)`. */
+  query;
+  /** Custom (named) queries from the `queries` option: `orbit.queries.allTodos()`. */
+  queries;
+  /**
+   * Mutators. With a `mutators` option these are your custom mutators
+   * (`orbit.mutate.createTodo(args)`); otherwise per-table CRUD
+   * (`orbit.mutate.todo.insert(...)`).
+   */
+  mutate;
+  #ws;
+  #store;
+  #opts;
+  #pkByTable;
+  #schema;
+  #mutatorDefs;
+  #nextMutationID = 1;
+  #closed = false;
+  #connecting = false;
+  #reconnectMs = 500;
+  #maxReconnectMs;
+  #queryTTL;
+  #kv;
+  /** Last server cookie we've fully applied; sent as `baseCookie` on reconnect so
+   * the server can prove a delta resume is safe (else it full-resyncs). */
+  #cookie;
+  /** Query lifetime: dedup + TTL + GC. Its `active()` set is resent on reconnect. */
+  #queries;
+  /** Unconfirmed mutations by id — resent on (re)connect, dropped on confirm. */
+  #unconfirmedPushes = /* @__PURE__ */ new Map();
+  /** In-flight poke buffer: rows + lastMutationID changes accumulate across
+   * `pokePart`s and are applied atomically on `pokeEnd`. A mid-poke disconnect (or
+   * `pokeEnd.cancel`) discards it, so the store never holds a torn partial poke. */
+  #poke = null;
+  /** Surfaced when the server sends a terminal `error` message. */
+  #onError;
+  /** Whether the id was supplied explicitly (then we never override it from the KV). */
+  #idFromOpts;
+  constructor(opts) {
+    this.#opts = opts;
+    this.#schema = opts.schema;
+    this.#maxReconnectMs = opts.maxReconnectMs ?? 3e4;
+    this.#queryTTL = opts.queryTTL ?? "5m";
+    this.#kv = opts.persist;
+    this.#onError = opts.onError;
+    this.#queries = new QueryManager({
+      onSubscribe: (put) => this.#send(["changeDesiredQueries", { desiredQueriesPatch: [put] }]),
+      onUnsubscribe: (hash) => this.#send(["changeDesiredQueries", { desiredQueriesPatch: [{ op: "del", hash }] }])
+    });
+    this.#idFromOpts = opts.clientID != null;
+    this.clientID = opts.clientID ?? Math.random().toString(36).slice(2);
+    this.clientGroupID = opts.clientGroupID ?? this.clientID;
+    this.#pkByTable = {};
+    for (const t of Object.values(opts.schema?.tables ?? {})) {
+      this.#pkByTable[t.name] = [...t.primaryKey];
+    }
+    this.#store = new Store(this.#pkByTable);
+    const schemaForQueries = this.#schema ?? { tables: {}, relationships: {} };
+    this.query = new Proxy({}, {
+      get: (_t, table2) => new SchemaQuery(this, schemaForQueries, table2, Query.from(table2))
+    });
+    const queryDefs = opts.queries;
+    this.queries = queryDefs ? new Proxy({}, {
+      get: (_t, name) => (args) => ({
+        materialize: () => {
+          const ast = queryDefs[name]({ args, ctx: {} }).ast();
+          const argList = args === void 0 ? [] : [args];
+          return this.materializeNamed(name, argList, ast);
+        }
+      })
+    }) : {};
+    this.#mutatorDefs = opts.mutators;
+    this.mutate = this.#mutatorDefs ? new Proxy({}, {
+      get: (_t, name) => (args) => this.mutateCustom(name, args)
+    }) : new Proxy({}, {
+      get: (_t, table2) => {
+        const pk = this.#pkByTable[table2] ?? ["id"];
+        const crud = (op, value) => this.mutateCrud({ op, tableName: table2, primaryKey: pk, value });
+        return {
+          insert: (value) => crud("insert", value),
+          upsert: (value) => crud("upsert", value),
+          update: (value) => crud("update", value),
+          delete: (value) => crud("delete", value)
+        };
+      }
+    });
+    void this.#init();
+  }
+  /** Build a raw (untyped) query against `table` — escape hatch. */
+  queryRaw(table2) {
+    return Query.from(table2);
+  }
+  /** Subscribe to an ad-hoc query and return a live [`View`]. */
+  materialize(query, ttl = this.#queryTTL) {
+    const ast = query.ast();
+    const hash = hashAST(ast);
+    const release = this.#queries.add(hash, { op: "put", hash, ast }, ttl);
+    return new View(this.#store, ast, true, release);
+  }
+  /**
+   * Subscribe to a custom (named) query by name + args. The server's query
+   * endpoint resolves/authorizes it (with the connection's auth) into the actual
+   * query; the client uses the def's `ast` for local ordering/nesting/optimism.
+   *
+   * The local view DOES apply the def's `where` (applyWhere=true): the client
+   * store is shared across all subscriptions, so without it a filtered query like
+   * `issue({id})` would match every row another query synced (e.g. the issues
+   * list) and `.one()` would return the wrong row. This assumes the def's filter
+   * matches the server's resolution, which holds for ordinary parameterized
+   * queries; the store only ever holds server-authorized rows.
+   */
+  materializeNamed(name, args, ast, ttl = this.#queryTTL) {
+    const hash = hashString(JSON.stringify([name, args]));
+    const release = this.#queries.add(hash, { op: "put", hash, name, args }, ttl);
+    return new View(this.#store, ast, true, release);
+  }
+  /** Apply a single CRUD op (mirrors `z.mutate.<table>.insert(...)`). */
+  mutateCrud(op) {
+    const id = this.#nextMutationID++;
+    const mutation = {
+      type: "crud",
+      id,
+      clientID: this.clientID,
+      name: "_zero_crud",
+      args: [{ ops: [op] }],
+      timestamp: Date.now()
+    };
+    this.#store.addPending(id, [op], mutation);
+    this.#pushMutation(id, mutation);
+  }
+  /** Run a custom mutator by name (optimistically, then on the server). */
+  mutateCustom(name, args) {
+    const id = this.#nextMutationID++;
+    const mutation = {
+      type: "custom",
+      id,
+      clientID: this.clientID,
+      name,
+      args: args === void 0 ? [] : [args],
+      timestamp: Date.now()
+    };
+    const def = this.#mutatorDefs?.[name];
+    let ops = [];
+    if (def && this.#schema) {
+      try {
+        ops = collectOps(this.#schema, def, args, {});
+      } catch {
+      }
+    }
+    this.#store.addPending(id, ops, mutation);
+    this.#pushMutation(id, mutation);
+  }
+  close() {
+    this.#closed = true;
+    this.#ws?.close();
+  }
+  // --- internals ----------------------------------------------------------
+  /** Hydrate persisted state (if any), restore unconfirmed mutations, then connect. */
+  async #init() {
+    if (this.#kv) {
+      try {
+        await this.#store.hydrate(this.#kv);
+        if (!this.#idFromOpts) {
+          const savedID = await this.#kv.get("clientID");
+          if (typeof savedID === "string") {
+            this.clientID = savedID;
+            const savedGroup = await this.#kv.get("clientGroupID");
+            this.clientGroupID = typeof savedGroup === "string" ? savedGroup : savedID;
+          } else {
+            void this.#kv.set("clientID", this.clientID);
+            void this.#kv.set("clientGroupID", this.clientGroupID);
+          }
+        }
+        let maxId = 0;
+        for (const m of this.#store.pendingMutations()) {
+          maxId = Math.max(maxId, m.id);
+          this.#unconfirmedPushes.set(m.id, ["push", {
+            clientGroupID: this.clientGroupID,
+            mutations: [m],
+            pushVersion: 1,
+            timestamp: m.timestamp,
+            requestID: Math.random().toString(36).slice(2)
+          }]);
+        }
+        if (maxId >= this.#nextMutationID) this.#nextMutationID = maxId + 1;
+        const savedNextID = await this.#kv.get("nextMutationID");
+        if (typeof savedNextID === "number" && savedNextID > this.#nextMutationID) {
+          this.#nextMutationID = savedNextID;
+        }
+        const c = await this.#kv.get("cookie");
+        if (typeof c === "string") this.#cookie = c;
+      } catch {
+      }
+    }
+    await this.#connect();
+  }
+  #pushMutation(id, mutation) {
+    const msg = ["push", {
+      clientGroupID: this.clientGroupID,
+      mutations: [mutation],
+      pushVersion: 1,
+      timestamp: Date.now(),
+      requestID: Math.random().toString(36).slice(2)
+    }];
+    this.#unconfirmedPushes.set(id, msg);
+    void this.#kv?.set("nextMutationID", this.#nextMutationID);
+    this.#send(msg);
+  }
+  async #connect() {
+    if (this.#closed || this.#connecting) return;
+    if (typeof WebSocket === "undefined") return;
+    this.#connecting = true;
+    const token = typeof this.#opts.auth === "function" ? await this.#opts.auth() : this.#opts.auth;
+    if (this.#closed) {
+      this.#connecting = false;
+      return;
+    }
+    let url = `${this.#opts.server}/sync/v51/connect?clientID=${encodeURIComponent(this.clientID)}`;
+    if (this.#cookie != null) url += `&baseCookie=${encodeURIComponent(this.#cookie)}`;
+    const ws = token ? new WebSocket(url, [encodeSecProtocol(token)]) : new WebSocket(url);
+    this.#ws = ws;
+    ws.addEventListener("open", () => {
+      this.#connecting = false;
+      this.#resume(ws);
+    });
+    ws.addEventListener("message", (ev) => {
+      this.#onMessage(JSON.parse(ev.data));
+    });
+    ws.addEventListener("close", () => {
+      this.#connecting = false;
+      if (this.#ws === ws) this.#ws = void 0;
+      this.#poke = null;
+      this.#scheduleReconnect();
+    });
+    ws.addEventListener("error", () => ws.close());
+  }
+  /** Resubscribe active queries and resend unconfirmed mutations. */
+  #resume(ws) {
+    const queries = this.#queries.active();
+    if (queries.length) {
+      ws.send(JSON.stringify(["changeDesiredQueries", { desiredQueriesPatch: queries }]));
+    }
+    for (const msg of this.#unconfirmedPushes.values()) ws.send(JSON.stringify(msg));
+  }
+  #scheduleReconnect() {
+    if (this.#closed || this.#maxReconnectMs === 0) return;
+    const delay = Math.min(this.#reconnectMs, this.#maxReconnectMs);
+    this.#reconnectMs = Math.min(this.#reconnectMs * 2, this.#maxReconnectMs);
+    setTimeout(() => void this.#connect(), delay);
+  }
+  #send(msg) {
+    if (this.#ws && this.#ws.readyState === WebSocket.OPEN) {
+      this.#ws.send(JSON.stringify(msg));
+    }
+  }
+  #onMessage(msg) {
+    const [tag, body] = msg;
+    switch (tag) {
+      case "pokeStart":
+        this.#poke = { rows: [], lmids: {} };
+        return;
+      case "pokePart": {
+        const poke = this.#poke ??= { rows: [], lmids: {} };
+        if (body.rowsPatch) poke.rows.push(...body.rowsPatch);
+        if (body.lastMutationIDChanges) Object.assign(poke.lmids, body.lastMutationIDChanges);
+        return;
+      }
+      case "pokeEnd": {
+        const poke = this.#poke;
+        this.#poke = null;
+        if (!poke || body.cancel) return;
+        if (poke.rows.length) this.#store.applyAll(poke.rows);
+        const confirmed = poke.lmids[this.clientID];
+        if (confirmed != null) {
+          for (const id of this.#unconfirmedPushes.keys()) {
+            if (id <= confirmed) this.#unconfirmedPushes.delete(id);
+          }
+          this.#store.confirmThrough(confirmed);
+        }
+        this.#cookie = body.cookie;
+        void this.#kv?.set("cookie", body.cookie);
+        this.#reconnectMs = 500;
+        return;
+      }
+      case "error":
+        if (this.#onError) this.#onError(body);
+        else console.error(`orbit: server error: ${body.kind}: ${body.message}`);
+        return;
+      default:
+        return;
+    }
+  }
+};
+
+// client/src/persist.ts
+var MemoryKV = class {
+  #m = /* @__PURE__ */ new Map();
+  async get(key) {
+    return this.#m.get(key);
+  }
+  async set(key, value) {
+    this.#m.set(key, value);
+  }
+  async del(key) {
+    this.#m.delete(key);
+  }
+  async entries(prefix) {
+    return [...this.#m].filter(([k]) => k.startsWith(prefix));
+  }
+};
+function wrap(req) {
+  return new Promise((resolve2, reject) => {
+    req.onsuccess = () => resolve2(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+var IDBKV = class {
+  #dbp;
+  constructor(name = "orbit") {
+    this.#dbp = new Promise((resolve2, reject) => {
+      const r = indexedDB.open(name, 1);
+      r.onupgradeneeded = () => r.result.createObjectStore("kv");
+      r.onsuccess = () => resolve2(r.result);
+      r.onerror = () => reject(r.error);
+    });
+  }
+  async #store(mode) {
+    const db = await this.#dbp;
+    return db.transaction("kv", mode).objectStore("kv");
+  }
+  async get(key) {
+    return wrap((await this.#store("readonly")).get(key));
+  }
+  async set(key, value) {
+    await wrap((await this.#store("readwrite")).put(value, key));
+  }
+  async del(key) {
+    await wrap((await this.#store("readwrite")).delete(key));
+  }
+  async entries(prefix) {
+    const s = await this.#store("readonly");
+    const [keys, vals] = await Promise.all([wrap(s.getAllKeys()), wrap(s.getAll())]);
+    const out = [];
+    for (let i = 0; i < keys.length; i++) {
+      const k = String(keys[i]);
+      if (k.startsWith(prefix)) out.push([k, vals[i]]);
+    }
+    return out;
+  }
+};
+
+export { IDBKV, MaterializedView, MemoryKV, MemorySource, MemorySourceProvider, Orbit, PROTOCOL_VERSION, Query, QueryManager, SchemaQuery, SourceConnection, Store, StoreProvider, TypedQuery, View, boolean, buildPipeline, buildSchemaQueries, collectOps, compareValues, createBuilder, createSchema, defineMutator, defineQuery, evaluate, hashAST, hashString, json, nodeToRow, number, optional, parseTTL, relationships, string, table, tablesOf, unwrapSingular, valuesEqual };
+//# sourceMappingURL=chunk-N2NAKHMU.js.map
+//# sourceMappingURL=chunk-N2NAKHMU.js.map