arrowbase 0.1.1

package/dist/react.js

@@ -0,0 +1,1633 @@
+import { useMemo, useCallback, useSyncExternalStore, useRef } from 'react';
+
+// src/react.ts
+
+// src/errors.ts
+var ArrowBaseError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "ArrowBaseError";
+  }
+  code;
+};
+var ValidationError = class extends ArrowBaseError {
+  constructor(message) {
+    super(message, "E_VALIDATION");
+    this.name = "ValidationError";
+  }
+};
+
+// src/query/trackRow.ts
+function trackRow(row, deps) {
+  return new Proxy(row, {
+    get(target, prop, receiver) {
+      if (typeof prop === "string") deps.add(prop);
+      return Reflect.get(target, prop, receiver);
+    },
+    // The tracking proxy is intentionally transparent for other traps so
+    // predicates that destructure or use `in` still work as expected.
+    has(target, prop) {
+      if (typeof prop === "string") deps.add(prop);
+      return Reflect.has(target, prop);
+    }
+  });
+}
+
+// src/query/filter.ts
+function collectColumns(expr, out) {
+  switch (expr.kind) {
+    case "col":
+      out.add(expr.name);
+      return;
+    case "cmp":
+      if (expr.left.kind === "col") out.add(expr.left.name);
+      if (expr.right.kind === "col") out.add(expr.right.name);
+      return;
+    case "and":
+    case "or":
+      for (const a of expr.args) collectColumns(a, out);
+      return;
+    case "not":
+      collectColumns(expr.arg, out);
+      return;
+    case "isNull":
+      out.add(expr.col.name);
+      return;
+    case "in":
+      out.add(expr.col.name);
+      return;
+    case "str":
+      out.add(expr.col.name);
+      return;
+  }
+}
+
+// src/schema/types.ts
+var ColumnTypeCode = {
+  Bool: 1,
+  Int8: 2,
+  Int16: 3,
+  Int32: 4,
+  Int64: 5,
+  UInt8: 6,
+  UInt16: 7,
+  UInt32: 8,
+  UInt64: 9,
+  Float32: 10,
+  Float64: 11,
+  Utf8: 12,
+  DictUtf8: 13};
+
+// src/query/kernel.ts
+function isValid(validity, row) {
+  if (!validity) return true;
+  const byte = validity[row >>> 3] ?? 0;
+  return (byte & 1 << (row & 7)) !== 0;
+}
+var FilterCompileError = class extends Error {
+};
+function compileFilter(expr, scanByName) {
+  if (!expr) {
+    return { test: () => true, columns: /* @__PURE__ */ new Set() };
+  }
+  const cols = /* @__PURE__ */ new Set();
+  const test = compileExpr(expr, scanByName, cols);
+  return { test, columns: cols };
+}
+function compileExpr(expr, scanByName, cols) {
+  switch (expr.kind) {
+    case "col": {
+      const sc = requireCol(expr, scanByName, cols);
+      if (sc.typeCode !== ColumnTypeCode.Bool) {
+        throw new FilterCompileError(
+          `column ref "${expr.name}" in boolean position must be a bool column`
+        );
+      }
+      const values = sc.values;
+      const validity = sc.validity;
+      return (row) => {
+        if (!isValid(validity, row)) return false;
+        return (values[row] ?? 0) !== 0;
+      };
+    }
+    case "and": {
+      const children = expr.args.map((a) => compileExpr(a, scanByName, cols));
+      if (children.length === 0) return () => true;
+      return (row) => {
+        for (let i = 0; i < children.length; i++) {
+          if (!children[i](row)) return false;
+        }
+        return true;
+      };
+    }
+    case "or": {
+      const children = expr.args.map((a) => compileExpr(a, scanByName, cols));
+      if (children.length === 0) return () => false;
+      return (row) => {
+        for (let i = 0; i < children.length; i++) {
+          if (children[i](row)) return true;
+        }
+        return false;
+      };
+    }
+    case "not": {
+      const inner = compileExpr(expr.arg, scanByName, cols);
+      return (row) => !inner(row);
+    }
+    case "isNull": {
+      const sc = requireCol(expr.col, scanByName, cols);
+      const validity = sc.validity;
+      if (!validity) {
+        return expr.negated ? () => true : () => false;
+      }
+      if (expr.negated) return (row) => isValid(validity, row);
+      return (row) => !isValid(validity, row);
+    }
+    case "in": {
+      const tests = expr.values.map(
+        (value) => compileCmp(
+          "eq",
+          expr.col,
+          { kind: "lit", value },
+          scanByName,
+          cols
+        )
+      );
+      return (row) => {
+        for (const test of tests) if (test(row)) return true;
+        return false;
+      };
+    }
+    case "cmp":
+      return compileCmp(expr.op, expr.left, expr.right, scanByName, cols);
+    case "str":
+      return compileString(expr, scanByName, cols);
+  }
+}
+function requireCol(ref, scanByName, cols) {
+  const sc = scanByName.get(ref.name);
+  if (!sc) throw new FilterCompileError(`unknown column "${ref.name}"`);
+  cols.add(ref.name);
+  return sc;
+}
+function compileCmp(op, left, right, scanByName, cols) {
+  let ref;
+  let literal;
+  let flipped;
+  if (left.kind === "col" && right.kind === "lit") {
+    ref = left;
+    literal = right.value;
+    flipped = false;
+  } else if (left.kind === "lit" && right.kind === "col") {
+    ref = right;
+    literal = left.value;
+    flipped = true;
+  } else {
+    throw new FilterCompileError(
+      "column-column and literal-literal comparisons are not supported in filter DSL"
+    );
+  }
+  const effective = flipped ? flipCmp(op) : op;
+  return buildCmp(effective, requireCol(ref, scanByName, cols), literal);
+}
+function flipCmp(op) {
+  switch (op) {
+    case "eq":
+    case "neq":
+      return op;
+    case "gt":
+      return "lt";
+    case "gte":
+      return "lte";
+    case "lt":
+      return "gt";
+    case "lte":
+      return "gte";
+  }
+}
+function buildCmp(op, sc, literal) {
+  const code = sc.typeCode;
+  const validity = sc.validity;
+  if (isNumericTypeCode(code)) {
+    const values = sc.values;
+    if (literal === null) {
+      if (op === "eq") {
+        if (!validity) return () => false;
+        return (row) => !isValid(validity, row);
+      }
+      if (op === "neq") {
+        if (!validity) return () => true;
+        return (row) => isValid(validity, row);
+      }
+      return () => false;
+    }
+    if (typeof literal !== "number") {
+      throw new FilterCompileError(
+        `column "${sc.name}" expects numeric literal, got ${typeof literal}`
+      );
+    }
+    const lit = literal;
+    const cmp = numericCmp(op);
+    if (!validity) return (row) => cmp(values[row] ?? 0, lit);
+    return (row) => isValid(validity, row) && cmp(values[row] ?? 0, lit);
+  }
+  if (code === ColumnTypeCode.Bool) {
+    const values = sc.values;
+    if (literal === null) {
+      if (op === "eq") {
+        if (!validity) return () => false;
+        return (row) => !isValid(validity, row);
+      }
+      if (op === "neq") return validity ? (row) => isValid(validity, row) : () => true;
+      return () => false;
+    }
+    if (typeof literal !== "boolean") {
+      throw new FilterCompileError(
+        `column "${sc.name}" expects boolean literal, got ${typeof literal}`
+      );
+    }
+    const litByte = literal ? 1 : 0;
+    if (op === "eq") {
+      if (!validity) return (row) => (values[row] ?? 0) === litByte;
+      return (row) => isValid(validity, row) && (values[row] ?? 0) === litByte;
+    }
+    if (op === "neq") {
+      if (!validity) return (row) => (values[row] ?? 0) !== litByte;
+      return (row) => isValid(validity, row) && (values[row] ?? 0) !== litByte;
+    }
+    throw new FilterCompileError(
+      `bool columns only support eq/neq (got ${op})`
+    );
+  }
+  if (code === ColumnTypeCode.Int64 || code === ColumnTypeCode.UInt64) {
+    const values = sc.values;
+    if (literal === null) {
+      if (op === "eq") return validity ? (row) => !isValid(validity, row) : () => false;
+      if (op === "neq") return validity ? (row) => isValid(validity, row) : () => true;
+      return () => false;
+    }
+    if (typeof literal !== "bigint") {
+      if (typeof literal === "number" && Number.isInteger(literal)) {
+        literal = BigInt(literal);
+      } else {
+        throw new FilterCompileError(
+          `column "${sc.name}" expects bigint literal, got ${typeof literal}`
+        );
+      }
+    }
+    const lit = literal;
+    const cmp = bigintCmp(op);
+    if (!validity) return (row) => cmp(values[row], lit);
+    return (row) => isValid(validity, row) && cmp(values[row], lit);
+  }
+  if (code === ColumnTypeCode.DictUtf8) {
+    const dict = sc.dictionary;
+    const codes = sc.values;
+    if (literal === null) {
+      if (op === "eq") return validity ? (row) => !isValid(validity, row) : () => false;
+      if (op === "neq") return validity ? (row) => isValid(validity, row) : () => true;
+      return () => false;
+    }
+    if (typeof literal !== "string") {
+      throw new FilterCompileError(
+        `column "${sc.name}" expects string literal, got ${typeof literal}`
+      );
+    }
+    const matchCode = dict.lookup(literal);
+    if (op === "eq") {
+      if (matchCode === void 0) {
+        return () => false;
+      }
+      if (!validity) return (row) => codes[row] === matchCode;
+      return (row) => isValid(validity, row) && codes[row] === matchCode;
+    }
+    if (op === "neq") {
+      if (matchCode === void 0) {
+        if (!validity) return () => true;
+        return (row) => isValid(validity, row);
+      }
+      if (!validity) return (row) => codes[row] !== matchCode;
+      return (row) => isValid(validity, row) && codes[row] !== matchCode;
+    }
+    throw new FilterCompileError(
+      `dict_utf8 columns only support eq/neq (got ${op})`
+    );
+  }
+  if (code === ColumnTypeCode.Utf8) {
+    const ranges = sc.values;
+    const heap = sc.heap;
+    if (literal === null) {
+      if (op === "eq") return validity ? (row) => !isValid(validity, row) : () => false;
+      if (op === "neq") return validity ? (row) => isValid(validity, row) : () => true;
+      return () => false;
+    }
+    if (typeof literal !== "string") {
+      throw new FilterCompileError(
+        `column "${sc.name}" expects string literal, got ${typeof literal}`
+      );
+    }
+    const lit = literal;
+    const readString = (row) => {
+      const start = ranges[row * 2] ?? 0;
+      const end = ranges[row * 2 + 1] ?? 0;
+      return heap.read(start, end);
+    };
+    if (op === "eq") {
+      if (!validity) return (row) => readString(row) === lit;
+      return (row) => isValid(validity, row) && readString(row) === lit;
+    }
+    if (op === "neq") {
+      if (!validity) return (row) => readString(row) !== lit;
+      return (row) => isValid(validity, row) && readString(row) !== lit;
+    }
+    throw new FilterCompileError(
+      `utf8 columns only support eq/neq (got ${op})`
+    );
+  }
+  throw new FilterCompileError(
+    `filter DSL does not support column type code ${code}`
+  );
+}
+function compileString(expr, scanByName, cols) {
+  const sc = requireCol(expr.col, scanByName, cols);
+  const code = sc.typeCode;
+  if (code !== ColumnTypeCode.Utf8 && code !== ColumnTypeCode.DictUtf8) {
+    throw new FilterCompileError(
+      `string predicates require a utf8 or dict_utf8 column; "${sc.name}" is not a string column`
+    );
+  }
+  const validity = sc.validity;
+  const negated = expr.negated === true;
+  const stringPredicate = buildStringPredicate(expr);
+  if (code === ColumnTypeCode.DictUtf8) {
+    const dict = sc.dictionary;
+    const codes = sc.values;
+    const matchSet = /* @__PURE__ */ new Set();
+    for (const [codeVal, str] of dict.entries()) {
+      if (stringPredicate(str)) matchSet.add(codeVal);
+    }
+    if (matchSet.size === 0) {
+      const constResult = negated;
+      if (!validity) return () => constResult;
+      return (row) => isValid(validity, row) ? constResult : false;
+    }
+    if (!validity) {
+      if (!negated) return (row) => matchSet.has(codes[row]);
+      return (row) => !matchSet.has(codes[row]);
+    }
+    if (!negated) {
+      return (row) => isValid(validity, row) && matchSet.has(codes[row]);
+    }
+    return (row) => isValid(validity, row) && !matchSet.has(codes[row]);
+  }
+  const ranges = sc.values;
+  const heap = sc.heap;
+  const readString = (row) => {
+    const start = ranges[row * 2] ?? 0;
+    const end = ranges[row * 2 + 1] ?? 0;
+    return heap.read(start, end);
+  };
+  if (!validity) {
+    if (!negated) return (row) => stringPredicate(readString(row));
+    return (row) => !stringPredicate(readString(row));
+  }
+  if (!negated) {
+    return (row) => isValid(validity, row) && stringPredicate(readString(row));
+  }
+  return (row) => isValid(validity, row) && !stringPredicate(readString(row));
+}
+function buildStringPredicate(expr) {
+  switch (expr.op) {
+    case "contains":
+      return compileSubstring(expr.value, expr.caseInsensitive ?? false, "contains");
+    case "startsWith":
+      return compileSubstring(expr.value, expr.caseInsensitive ?? false, "startsWith");
+    case "endsWith":
+      return compileSubstring(expr.value, expr.caseInsensitive ?? false, "endsWith");
+    case "like":
+      return compileLike(expr.value, expr.caseInsensitive ?? false);
+    case "matches":
+      return compileRegex(expr.value, expr.flags);
+  }
+}
+function compileSubstring(needle, caseInsensitive, mode) {
+  if (caseInsensitive) {
+    const needleL = asciiToLower(needle);
+    switch (mode) {
+      case "contains":
+        return (s) => asciiToLower(s).includes(needleL);
+      case "startsWith":
+        return (s) => asciiToLower(s).startsWith(needleL);
+      case "endsWith":
+        return (s) => asciiToLower(s).endsWith(needleL);
+    }
+  }
+  switch (mode) {
+    case "contains":
+      return (s) => s.includes(needle);
+    case "startsWith":
+      return (s) => s.startsWith(needle);
+    case "endsWith":
+      return (s) => s.endsWith(needle);
+  }
+}
+function compileLike(pattern, caseInsensitive) {
+  const simple = parseSimpleLike(pattern);
+  if (simple !== void 0) {
+    const { literal, leadingWildcard, trailingWildcard } = simple;
+    if (leadingWildcard && trailingWildcard) {
+      return compileSubstring(literal, caseInsensitive, "contains");
+    }
+    if (leadingWildcard) return compileSubstring(literal, caseInsensitive, "endsWith");
+    if (trailingWildcard) return compileSubstring(literal, caseInsensitive, "startsWith");
+    if (caseInsensitive) {
+      const expected = asciiToLower(literal);
+      return (s) => asciiToLower(s) === expected;
+    }
+    return (s) => s === literal;
+  }
+  let src = "^";
+  let i = 0;
+  while (i < pattern.length) {
+    const c = pattern[i];
+    if (c === "\\" && i + 1 < pattern.length) {
+      const next = pattern[i + 1];
+      if (next === "%" || next === "_" || next === "\\") {
+        src += escapeRegexChar(next);
+        i += 2;
+        continue;
+      }
+    }
+    if (c === "%") {
+      src += ".*";
+    } else if (c === "_") {
+      src += ".";
+    } else {
+      src += escapeRegexChar(c);
+    }
+    i++;
+  }
+  src += "$";
+  const re = new RegExp(src, caseInsensitive ? "is" : "s");
+  return (s) => re.test(s);
+}
+function parseSimpleLike(pattern) {
+  let literal = "";
+  let leadingWildcard = false;
+  let pendingWildcard = false;
+  let sawLiteral = false;
+  for (let i = 0; i < pattern.length; i++) {
+    const char = pattern[i];
+    if (char === "\\" && i + 1 < pattern.length) {
+      const next = pattern[i + 1];
+      if (next === "%" || next === "_" || next === "\\") {
+        if (pendingWildcard && sawLiteral) return void 0;
+        pendingWildcard = false;
+        literal += next;
+        sawLiteral = true;
+        i++;
+        continue;
+      }
+    }
+    if (char === "_") return void 0;
+    if (char === "%") {
+      if (sawLiteral) pendingWildcard = true;
+      else leadingWildcard = true;
+      continue;
+    }
+    if (pendingWildcard && sawLiteral) return void 0;
+    pendingWildcard = false;
+    literal += char;
+    sawLiteral = true;
+  }
+  return { literal, leadingWildcard, trailingWildcard: pendingWildcard };
+}
+function compileRegex(source, flags) {
+  let re;
+  try {
+    re = new RegExp(source, flags);
+  } catch (err) {
+    throw new FilterCompileError(
+      `invalid regex "${source}"${flags ? ` (flags "${flags}")` : ""}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return (s) => re.test(s);
+}
+function escapeRegexChar(c) {
+  if ("^$.|?*+()[]{}\\/".includes(c)) return "\\" + c;
+  return c;
+}
+function asciiToLower(s) {
+  let out = "";
+  let changed = false;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c >= 65 && c <= 90) {
+      if (!changed) {
+        out = s.slice(0, i);
+        changed = true;
+      }
+      out += String.fromCharCode(c + 32);
+    } else if (changed) {
+      out += s[i];
+    }
+  }
+  return changed ? out : s;
+}
+function isNumericTypeCode(code) {
+  switch (code) {
+    case ColumnTypeCode.Int8:
+    case ColumnTypeCode.Int16:
+    case ColumnTypeCode.Int32:
+    case ColumnTypeCode.UInt8:
+    case ColumnTypeCode.UInt16:
+    case ColumnTypeCode.UInt32:
+    case ColumnTypeCode.Float32:
+    case ColumnTypeCode.Float64:
+      return true;
+    default:
+      return false;
+  }
+}
+function numericCmp(op) {
+  switch (op) {
+    case "eq":
+      return (a, b) => a === b;
+    case "neq":
+      return (a, b) => a !== b;
+    case "gt":
+      return (a, b) => a > b;
+    case "gte":
+      return (a, b) => a >= b;
+    case "lt":
+      return (a, b) => a < b;
+    case "lte":
+      return (a, b) => a <= b;
+  }
+}
+function bigintCmp(op) {
+  switch (op) {
+    case "eq":
+      return (a, b) => a === b;
+    case "neq":
+      return (a, b) => a !== b;
+    case "gt":
+      return (a, b) => a > b;
+    case "gte":
+      return (a, b) => a >= b;
+    case "lt":
+      return (a, b) => a < b;
+    case "lte":
+      return (a, b) => a <= b;
+  }
+}
+function scanOrdinals(liveOrdinals, test) {
+  const buf = [];
+  for (const r of liveOrdinals) {
+    if (test(r)) buf.push(r);
+  }
+  const out = new Uint32Array(buf.length);
+  for (let i = 0; i < buf.length; i++) out[i] = buf[i];
+  return out;
+}
+function sortOrdinals(ordinals, order, scanByName, readCell) {
+  if (order.length === 0) return ordinals;
+  if (order.length === 1) {
+    const spec = order[0];
+    const sc = scanByName.get(spec.column);
+    if (sc && isNumericTypeCode(sc.typeCode) && !sc.nullable) {
+      const values = sc.values;
+      const n = ordinals.length;
+      const keys = new Float64Array(n);
+      for (let i = 0; i < n; i++) keys[i] = values[ordinals[i]] ?? 0;
+      const idx = new Uint32Array(n);
+      for (let i = 0; i < n; i++) idx[i] = i;
+      const asc = spec.dir === "asc";
+      const arr2 = Array.from(idx);
+      arr2.sort((a, b) => {
+        const av = keys[a];
+        const bv = keys[b];
+        if (av === bv) return a - b;
+        return asc ? av < bv ? -1 : 1 : av < bv ? 1 : -1;
+      });
+      const out2 = new Uint32Array(n);
+      for (let i = 0; i < n; i++) out2[i] = ordinals[arr2[i]];
+      return out2;
+    }
+  }
+  const arr = Array.from(ordinals);
+  arr.sort((ra, rb) => {
+    for (const spec of order) {
+      const av = readCell(ra, spec.column);
+      const bv = readCell(rb, spec.column);
+      const c = compareScalars(av, bv);
+      if (c !== 0) return spec.dir === "asc" ? c : -c;
+    }
+    return ra - rb;
+  });
+  const out = new Uint32Array(arr.length);
+  for (let i = 0; i < arr.length; i++) out[i] = arr[i];
+  return out;
+}
+function compareScalars(a, b) {
+  if (a === b) return 0;
+  if (a === null || a === void 0) return -1;
+  if (b === null || b === void 0) return 1;
+  if (typeof a === "bigint" && typeof b === "bigint") return a < b ? -1 : a > b ? 1 : 0;
+  if (typeof a === "number" && typeof b === "number") return a < b ? -1 : a > b ? 1 : 0;
+  if (typeof a === "boolean" && typeof b === "boolean") return (a ? 1 : 0) - (b ? 1 : 0);
+  const sa = String(a);
+  const sb = String(b);
+  return sa < sb ? -1 : sa > sb ? 1 : 0;
+}
+function materialize(collection, ordinals, offset, limit, selection) {
+  const end = limit === null ? ordinals.length : Math.min(ordinals.length, offset + limit);
+  const n = Math.max(0, end - offset);
+  const out = new Array(n);
+  const cols = selection ?? collection.columnNames();
+  for (let i = 0; i < n; i++) {
+    const row = ordinals[offset + i];
+    const obj = {};
+    for (let c = 0; c < cols.length; c++) {
+      const name = cols[c];
+      obj[name] = collection._internalReadCell(name, row);
+    }
+    out[i] = obj;
+  }
+  return out;
+}
+
+// src/query/fnCompile.ts
+function tryCompileFnToFilterExpr(fn, options = {}) {
+  try {
+    const source = fn.toString();
+    const tokens = tokenize(source);
+    const parser = new FnParser(
+      tokens,
+      source,
+      options.knownColumns ?? null,
+      options.namespaceAlias ?? null
+    );
+    return parser.parseTopLevel();
+  } catch {
+    return null;
+  }
+}
+var MULTI_OPS = [
+  "===",
+  "!==",
+  "==",
+  "!=",
+  ">=",
+  "<=",
+  "&&",
+  "||",
+  "=>"
+];
+var SINGLE_OPS = /* @__PURE__ */ new Set(["!", ">", "<", "-"]);
+var PUNCT = /* @__PURE__ */ new Set(["(", ")", "{", "}", "[", "]", ",", ";", "."]);
+var KEYWORDS = /* @__PURE__ */ new Set(["true", "false", "null", "undefined", "return"]);
+function tokenize(src) {
+  const tokens = [];
+  let i = 0;
+  const n = src.length;
+  while (i < n) {
+    const ch = src[i];
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+      i++;
+      continue;
+    }
+    if (ch === "/" && src[i + 1] === "/") {
+      while (i < n && src[i] !== "\n") i++;
+      continue;
+    }
+    if (ch === "/" && src[i + 1] === "*") {
+      i += 2;
+      while (i < n && !(src[i] === "*" && src[i + 1] === "/")) i++;
+      i += 2;
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`") {
+      const quote = ch;
+      const start = i;
+      i++;
+      let value = "";
+      while (i < n && src[i] !== quote) {
+        if (src[i] === "\\" && i + 1 < n) {
+          const esc = src[i + 1];
+          if (esc === "n") value += "\n";
+          else if (esc === "t") value += "	";
+          else if (esc === "r") value += "\r";
+          else if (esc === "\\") value += "\\";
+          else if (esc === "'") value += "'";
+          else if (esc === '"') value += '"';
+          else if (esc === "`") value += "`";
+          else if (esc === "0") value += "\0";
+          else value += esc;
+          i += 2;
+          continue;
+        }
+        if (quote === "`" && src[i] === "$" && src[i + 1] === "{") {
+          throw new Error("template interpolation unsupported");
+        }
+        value += src[i];
+        i++;
+      }
+      if (src[i] !== quote) throw new Error("unterminated string");
+      i++;
+      tokens.push({ kind: "str", text: value, start });
+      continue;
+    }
+    if (ch >= "0" && ch <= "9" || ch === "." && isDigit(src[i + 1])) {
+      const start = i;
+      while (i < n && (isDigit(src[i]) || src[i] === "." || src[i] === "e" || src[i] === "E" || src[i] === "+" || src[i] === "-")) {
+        const c = src[i];
+        if ((c === "+" || c === "-") && !(src[i - 1] === "e" || src[i - 1] === "E")) break;
+        i++;
+      }
+      tokens.push({ kind: "num", text: src.slice(start, i), start });
+      continue;
+    }
+    if (isIdentStart(ch)) {
+      const start = i;
+      while (i < n && isIdentCont(src[i])) i++;
+      const text = src.slice(start, i);
+      if (KEYWORDS.has(text)) {
+        tokens.push({ kind: "keyword", text, start });
+      } else {
+        tokens.push({ kind: "ident", text, start });
+      }
+      continue;
+    }
+    let matched = false;
+    for (const op of MULTI_OPS) {
+      if (src.startsWith(op, i)) {
+        tokens.push({ kind: op === "=>" ? "arrow" : "op", text: op, start: i });
+        i += op.length;
+        matched = true;
+        break;
+      }
+    }
+    if (matched) continue;
+    if (SINGLE_OPS.has(ch)) {
+      tokens.push({ kind: "op", text: ch, start: i });
+      i++;
+      continue;
+    }
+    if (PUNCT.has(ch)) {
+      tokens.push({ kind: "punct", text: ch, start: i });
+      i++;
+      continue;
+    }
+    throw new Error(`unexpected char '${ch}' at ${i}`);
+  }
+  tokens.push({ kind: "eof", text: "", start: n });
+  return tokens;
+}
+function isDigit(c) {
+  return c !== void 0 && c >= "0" && c <= "9";
+}
+function isIdentStart(c) {
+  return c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c === "_" || c === "$";
+}
+function isIdentCont(c) {
+  return isIdentStart(c) || c >= "0" && c <= "9";
+}
+var FnParser = class {
+  constructor(tokens, _source, knownColumns, namespaceAlias) {
+    this.tokens = tokens;
+    this.knownColumns = knownColumns;
+    this.namespaceAlias = namespaceAlias;
+  }
+  tokens;
+  knownColumns;
+  namespaceAlias;
+  pos = 0;
+  paramName = "";
+  peek(off = 0) {
+    return this.tokens[this.pos + off] ?? this.tokens[this.tokens.length - 1];
+  }
+  advance() {
+    const t = this.tokens[this.pos];
+    this.pos++;
+    return t;
+  }
+  consumeText(text) {
+    const t = this.peek();
+    if (t.text === text) {
+      this.pos++;
+      return true;
+    }
+    return false;
+  }
+  expectText(text) {
+    if (!this.consumeText(text)) {
+      throw new Error(`expected '${text}' at token ${this.pos}`);
+    }
+  }
+  /**
+   * Parse the whole arrow function; accept two shapes:
+   *   `function (row) { return <expr>; }`  — legacy fn form
+   *   `(row) => <expr-or-block>`           — arrow form
+   *
+   * Returns null (via caller) on any unsupported shape.
+   */
+  parseTopLevel() {
+    try {
+      if (this.peek().text === "function") {
+        this.advance();
+        if (this.peek().kind === "ident") this.advance();
+        this.expectText("(");
+        if (this.peek().kind !== "ident") return null;
+        this.paramName = this.advance().text;
+        this.expectText(")");
+        this.expectText("{");
+        this.expectText("return");
+        const expr = this.parseExpr();
+        this.consumeText(";");
+        this.expectText("}");
+        return expr;
+      }
+      if (this.consumeText("(")) {
+        if (this.peek().kind !== "ident") return null;
+        this.paramName = this.advance().text;
+        this.expectText(")");
+      } else {
+        if (this.peek().kind !== "ident") return null;
+        this.paramName = this.advance().text;
+      }
+      if (this.peek().kind !== "arrow") return null;
+      this.advance();
+      if (this.consumeText("{")) {
+        this.expectText("return");
+        const expr = this.parseExpr();
+        this.consumeText(";");
+        this.expectText("}");
+        return expr;
+      }
+      return this.parseExpr();
+    } catch {
+      return null;
+    }
+  }
+  // OrExpr
+  parseExpr() {
+    let left = this.parseAnd();
+    while (this.peek().text === "||") {
+      this.advance();
+      const right = this.parseAnd();
+      left = { kind: "or", args: flatten("or", [left, right]) };
+    }
+    return left;
+  }
+  parseAnd() {
+    let left = this.parseNot();
+    while (this.peek().text === "&&") {
+      this.advance();
+      const right = this.parseNot();
+      left = { kind: "and", args: flatten("and", [left, right]) };
+    }
+    return left;
+  }
+  parseNot() {
+    if (this.peek().text === "!") {
+      this.advance();
+      const arg = this.parseNot();
+      if (arg.kind === "isNull") {
+        return { kind: "isNull", col: arg.col, negated: !arg.negated };
+      }
+      return { kind: "not", arg };
+    }
+    return this.parseEquality();
+  }
+  parseEquality() {
+    const left = this.parseRelational();
+    const t = this.peek();
+    if (t.text === "===" || t.text === "!==" || t.text === "==" || t.text === "!=") {
+      this.advance();
+      const right = this.parseRelational();
+      return this.buildCompare(t.text, left, right);
+    }
+    return left;
+  }
+  parseRelational() {
+    const left = this.parseUnary();
+    const t = this.peek();
+    if (t.text === ">" || t.text === ">=" || t.text === "<" || t.text === "<=") {
+      this.advance();
+      const right = this.parseUnary();
+      return this.buildCompare(t.text, left, right);
+    }
+    return left;
+  }
+  parseUnary() {
+    if (this.peek().text === "-") {
+      this.advance();
+      const next = this.peek();
+      if (next.kind !== "num") throw new Error("unary minus requires numeric literal");
+      this.advance();
+      return {
+        kind: "lit",
+        value: -parseFloat(next.text)
+      };
+    }
+    return this.parseAtom();
+  }
+  parseAtom() {
+    const t = this.peek();
+    if (t.kind === "keyword") {
+      if (t.text === "true" || t.text === "false") {
+        this.advance();
+        return { kind: "lit", value: t.text === "true" };
+      }
+      if (t.text === "null" || t.text === "undefined") {
+        this.advance();
+        return { kind: "lit", value: null };
+      }
+    }
+    if (t.kind === "num") {
+      this.advance();
+      return { kind: "lit", value: parseFloat(t.text) };
+    }
+    if (t.kind === "str") {
+      this.advance();
+      return { kind: "lit", value: t.text };
+    }
+    if (t.kind === "punct" && t.text === "(") {
+      this.advance();
+      const inner = this.parseExpr();
+      this.expectText(")");
+      return inner;
+    }
+    if (t.kind === "ident") {
+      if (t.text !== this.paramName) {
+        throw new Error(`unsupported identifier '${t.text}'`);
+      }
+      this.advance();
+      const ref = this.parseColumnRef();
+      if (ref.kind === "col" && this.peek().text === ".") {
+        const strOp = this.parseStringMethodTail(ref);
+        if (strOp) return strOp;
+        throw new Error("nested field access unsupported");
+      }
+      return ref;
+    }
+    throw new Error(`unexpected token '${t.text}'`);
+  }
+  /**
+   * After `ref = row.col`, peek a trailing `.method(...)` call. We only
+   * recognize a narrow whitelist of String.prototype methods that map
+   * cleanly to FilterExpr nodes. Returns null if the tail doesn't look
+   * like any supported method call — the caller will then treat the
+   * dangling `.` as unsupported nested access.
+   */
+  parseStringMethodTail(col) {
+    const saved = this.pos;
+    if (this.peek().text !== ".") return null;
+    this.advance();
+    const method = this.peek();
+    if (method.kind !== "ident") {
+      this.pos = saved;
+      return null;
+    }
+    const name = method.text;
+    const MAPPING = {
+      includes: "contains",
+      startsWith: "startsWith",
+      endsWith: "endsWith"
+    };
+    const mapped = MAPPING[name];
+    if (!mapped) {
+      this.pos = saved;
+      return null;
+    }
+    this.advance();
+    if (this.peek().text !== "(") {
+      this.pos = saved;
+      return null;
+    }
+    this.advance();
+    const arg = this.peek();
+    if (arg.kind !== "str") {
+      this.pos = saved;
+      return null;
+    }
+    this.advance();
+    if (this.peek().text === ",") {
+      this.pos = saved;
+      return null;
+    }
+    if (this.peek().text !== ")") {
+      this.pos = saved;
+      return null;
+    }
+    this.advance();
+    return {
+      kind: "str",
+      op: mapped,
+      col,
+      value: arg.text
+    };
+  }
+  parseColumnRef() {
+    const t = this.peek();
+    let colName;
+    if (t.kind === "punct" && t.text === ".") {
+      this.advance();
+      const id = this.advance();
+      if (id.kind !== "ident") throw new Error("expected identifier after .");
+      colName = id.text;
+    } else if (t.kind === "punct" && t.text === "[") {
+      this.advance();
+      const lit = this.advance();
+      if (lit.kind !== "str") throw new Error("computed access must be string literal");
+      colName = lit.text;
+      this.expectText("]");
+    } else {
+      throw new Error("bare param unsupported");
+    }
+    if (this.namespaceAlias !== null) {
+      if (colName !== this.namespaceAlias) throw new Error(`unknown namespace '${colName}'`);
+      this.expectText(".");
+      const field = this.advance();
+      if (field.kind !== "ident") throw new Error("expected column after namespace alias");
+      colName = field.text;
+    }
+    const next = this.peek();
+    if (next.text === "[") {
+      throw new Error("nested index access unsupported");
+    }
+    if (next.text === ".") ;
+    if (this.knownColumns && !this.knownColumns.has(colName)) {
+      throw new Error(`unknown column '${colName}'`);
+    }
+    return { kind: "col", name: colName };
+  }
+  // Build a cmp node; rewrite `col ==/!== null` into isNull / isNotNull.
+  buildCompare(op, left, right) {
+    const normOp = op === "==" ? "===" : op === "!=" ? "!==" : op;
+    const nullEq = detectNullEquality(left, right);
+    if (nullEq) {
+      return {
+        kind: "isNull",
+        col: nullEq.col,
+        negated: normOp === "!==" || normOp === "!="
+      };
+    }
+    const cmpOp = OP_TO_CMP[normOp];
+    if (!cmpOp) throw new Error(`bad op '${op}'`);
+    const leftOp = asOperand(left);
+    const rightOp = asOperand(right);
+    if (!leftOp || !rightOp) throw new Error("operand not a column or literal");
+    if (leftOp.kind === "col" && rightOp.kind === "col") {
+      throw new Error("col vs col unsupported");
+    }
+    if (leftOp.kind === "lit" && rightOp.kind === "lit") {
+      throw new Error("lit vs lit unsupported");
+    }
+    if (leftOp.kind === "lit") {
+      return {
+        kind: "cmp",
+        op: flipOp(cmpOp),
+        left: rightOp,
+        right: leftOp
+      };
+    }
+    return { kind: "cmp", op: cmpOp, left: leftOp, right: rightOp };
+  }
+};
+var OP_TO_CMP = {
+  "===": "eq",
+  "!==": "neq",
+  ">": "gt",
+  ">=": "gte",
+  "<": "lt",
+  "<=": "lte"
+};
+function flipOp(op) {
+  switch (op) {
+    case "gt":
+      return "lt";
+    case "gte":
+      return "lte";
+    case "lt":
+      return "gt";
+    case "lte":
+      return "gte";
+    default:
+      return op;
+  }
+}
+function asOperand(node) {
+  if (node.kind === "col") return node;
+  const raw = node;
+  if (raw.kind === "lit") return raw;
+  return null;
+}
+function detectNullEquality(left, right) {
+  const isNullLit = (n) => {
+    const raw = n;
+    return raw.kind === "lit" && raw.value === null;
+  };
+  if (left.kind === "col" && isNullLit(right)) return { col: left };
+  if (right.kind === "col" && isNullLit(left)) return { col: right };
+  return null;
+}
+function flatten(kind, args) {
+  const out = [];
+  for (const a of args) {
+    if (a.kind === kind) out.push(...a.args);
+    else out.push(a);
+  }
+  return out;
+}
+var Query = class _Query {
+  collection;
+  predicate;
+  /** Column-op filter DSL expression (vectorizable). */
+  filterExpr;
+  selection;
+  order;
+  limitN;
+  offsetN;
+  /** Explicit deps override. If null, deps are inferred. */
+  explicitDeps;
+  constructor(collection, predicate = null, selection = null, order = [], limitN = null, offsetN = 0, explicitDeps = null, filterExpr = null) {
+    this.collection = collection;
+    this.predicate = predicate;
+    this.filterExpr = filterExpr;
+    this.selection = selection;
+    this.order = order;
+    this.limitN = limitN;
+    this.offsetN = offsetN;
+    this.explicitDeps = explicitDeps;
+  }
+  where(predicate) {
+    const next = this.predicate ? (row) => this.predicate(row) && predicate(row) : predicate;
+    const lowered = tryCompileFnToFilterExpr(
+      predicate,
+      { knownColumns: new Set(this.collection.schema.columnsByName.keys()) }
+    );
+    const composedExpr = lowered === null ? this.filterExpr : this.filterExpr ? { kind: "and", args: [this.filterExpr, lowered] } : lowered;
+    const keepFn = lowered === null;
+    return new _Query(
+      this.collection,
+      keepFn ? next : this.predicate,
+      this.selection,
+      this.order,
+      this.limitN,
+      this.offsetN,
+      this.explicitDeps,
+      composedExpr
+    );
+  }
+  /**
+   * Add a vectorizable column-op filter. Composes with prior `filter()`
+   * calls via AND. Anything that fits the `FilterExpr` DSL takes the
+   * vectorized fast path in `QueryExecutor`; combine with `.where(fn)`
+   * when you need an escape hatch for logic outside the DSL — the fast
+   * path still runs first for the DSL portion.
+   */
+  filter(expr) {
+    const next = this.filterExpr ? { kind: "and", args: [this.filterExpr, expr] } : expr;
+    return new _Query(
+      this.collection,
+      this.predicate,
+      this.selection,
+      this.order,
+      this.limitN,
+      this.offsetN,
+      this.explicitDeps,
+      next
+    );
+  }
+  select(columns) {
+    for (const c of columns) this.requireKnownColumn(c);
+    return new _Query(
+      this.collection,
+      this.predicate,
+      [...columns],
+      this.order,
+      this.limitN,
+      this.offsetN,
+      this.explicitDeps,
+      this.filterExpr
+    );
+  }
+  orderBy(column, dir = "asc") {
+    this.requireKnownColumn(column);
+    return new _Query(
+      this.collection,
+      this.predicate,
+      this.selection,
+      [...this.order, { column, dir }],
+      this.limitN,
+      this.offsetN,
+      this.explicitDeps,
+      this.filterExpr
+    );
+  }
+  limit(n) {
+    if (!Number.isInteger(n) || n < 0) {
+      throw new ValidationError(`limit must be a non-negative integer, got ${n}`);
+    }
+    return new _Query(
+      this.collection,
+      this.predicate,
+      this.selection,
+      this.order,
+      n,
+      this.offsetN,
+      this.explicitDeps,
+      this.filterExpr
+    );
+  }
+  offset(n) {
+    if (!Number.isInteger(n) || n < 0) {
+      throw new ValidationError(`offset must be a non-negative integer, got ${n}`);
+    }
+    return new _Query(
+      this.collection,
+      this.predicate,
+      this.selection,
+      this.order,
+      this.limitN,
+      n,
+      this.explicitDeps,
+      this.filterExpr
+    );
+  }
+  /**
+   * Equijoin against another collection. Returns a `JoinQuery` that
+   * exposes the post-join builder surface (where / select / orderBy /
+   * limit / offset).
+   *
+   * ```ts
+   * query(orders)
+   *   .filter(f('amount').gt(100))
+   *   .join(users, { on: { left: 'userId', right: '__id' }, as: 'user' })
+   *   .orderBy('user.name')
+   *   .select(['id', 'amount', 'user.name']);
+   * ```
+   *
+   * Implementation: to avoid a static cycle between query.ts and
+   * join.ts, join.ts registers its factory via `registerJoinFactory`
+   * at module-load time. Importing `arrowbase` (or
+   * `arrowbase/query/join`) before calling `.join()` is sufficient.
+   */
+  join(right, spec) {
+    {
+      throw new Error(
+        `Query.join: join module not loaded. Import it (via \`import 'arrowbase'\` or \`import { join } from 'arrowbase'\`) before use.`
+      );
+    }
+  }
+  /**
+   * Explicit dep override. Use this when:
+   *   - your predicate reads columns conditionally and you want stable deps
+   *   - you want to force reactivity on a superset of columns
+   */
+  deps(columns) {
+    for (const c of columns) this.requireKnownColumn(c);
+    return new _Query(
+      this.collection,
+      this.predicate,
+      this.selection,
+      this.order,
+      this.limitN,
+      this.offsetN,
+      new Set(columns),
+      this.filterExpr
+    );
+  }
+  /** Columns that must be materialized for this query (deps + filter + selection + order). */
+  requiredColumns(inferredDeps) {
+    const out = /* @__PURE__ */ new Set();
+    const src = this.explicitDeps ?? inferredDeps;
+    for (const c of src) out.add(c);
+    if (this.filterExpr) collectColumns(this.filterExpr, out);
+    if (this.selection) for (const c of this.selection) out.add(c);
+    for (const o of this.order) out.add(o.column);
+    return out;
+  }
+  // -----------------------------------------------------------------
+  requireKnownColumn(name) {
+    if (!this.collection.schema.columnsByName.has(name)) {
+      throw new ValidationError(
+        `unknown column "${name}" on collection "${this.collection.schema.name}"`
+      );
+    }
+  }
+};
+var QueryExecutor = class {
+  constructor(query) {
+    this.query = query;
+    if (query.explicitDeps) {
+      for (const c of query.explicitDeps) this.deps.add(c);
+    }
+    if (query.filterExpr) {
+      collectColumns(query.filterExpr, this.deps);
+    }
+    this.unsubscribePassive = query.collection.subscribe((event) => {
+      if (event.op !== "update") this.staleFromInsertOrDelete = true;
+    });
+  }
+  query;
+  deps = /* @__PURE__ */ new Set();
+  cachedSnapshot = null;
+  /** Per-column version seen at the time `cachedSnapshot` was produced. */
+  cachedVersions = /* @__PURE__ */ new Map();
+  /**
+   * When the predicate trips (throws) during the tracking dry-run, we
+   * fall back to `deps = all`. We still try inference again after the
+   * predicate changes, but a single Query instance keeps this bit sticky.
+   */
+  depsAreAll = false;
+  /**
+   * Inserts, deletes, and rollbacks invalidate any cached snapshot because
+   * they may change the live row set even when no observed value column
+   * moves (soft-delete notwithstanding). We flip this flag from a passive
+   * change listener and clear it on recompute.
+   */
+  staleFromInsertOrDelete = false;
+  unsubscribePassive;
+  /** Release the passive change listener. */
+  dispose() {
+    this.unsubscribePassive();
+  }
+  /** True if the cached snapshot is still valid given current column versions. */
+  cacheIsFresh() {
+    if (!this.cachedSnapshot) return false;
+    if (this.staleFromInsertOrDelete) return false;
+    const c = this.query.collection;
+    for (const name of this.observedColumns()) {
+      if (!c.schema.columnsByName.has(name)) continue;
+      const prev = this.cachedVersions.get(name);
+      if (prev === void 0) return false;
+      if (c.columnVersion(name) !== prev) return false;
+    }
+    return true;
+  }
+  /**
+   * Columns this query observes for invalidation purposes. Includes:
+   *   - inferred or explicit deps (from predicate / .deps())
+   *   - selection columns (stale projection otherwise)
+   *   - order-by columns (stale sort otherwise)
+   */
+  observedColumns() {
+    if (this.depsAreAll) return this.query.collection.columnNames();
+    const union = /* @__PURE__ */ new Set();
+    const base = this.query.explicitDeps ?? this.deps;
+    for (const c of base) union.add(c);
+    if (this.query.filterExpr) collectColumns(this.query.filterExpr, union);
+    if (this.query.selection) for (const c of this.query.selection) union.add(c);
+    for (const o of this.query.order) union.add(o.column);
+    return union;
+  }
+  /** Lazily compile the filterExpr. Cached for executor lifetime. */
+  compiledFilter = null;
+  compiledFilterExpr = null;
+  compiledFilterError = null;
+  getCompiledFilter() {
+    const expr = this.query.filterExpr;
+    if (!expr) return null;
+    if (this.compiledFilterExpr === expr && this.compiledFilter) {
+      return this.compiledFilter;
+    }
+    if (this.compiledFilterError) throw this.compiledFilterError;
+    const c = this.query.collection;
+    const scanByName = /* @__PURE__ */ new Map();
+    const scanCols = c._internalScanColumns();
+    for (const sc of scanCols) scanByName.set(sc.name, sc);
+    try {
+      this.compiledFilter = compileFilter(expr, scanByName);
+      this.compiledFilterExpr = expr;
+      return this.compiledFilter;
+    } catch (err) {
+      if (err instanceof FilterCompileError) {
+        this.compiledFilterError = err;
+      }
+      throw err;
+    }
+  }
+  /** Recompute the snapshot, updating cache. */
+  recompute() {
+    const q = this.query;
+    const c = q.collection;
+    const pred = q.predicate;
+    const filterExpr = q.filterExpr;
+    let ordinals;
+    let needsFnPredicate = pred !== null;
+    if (filterExpr) {
+      const compiled = this.getCompiledFilter();
+      ordinals = scanOrdinals(c._internalLiveOrdinals(), compiled.test);
+    } else if (!pred) {
+      ordinals = scanOrdinals(c._internalLiveOrdinals(), () => true);
+    } else {
+      ordinals = this.legacyScan();
+      needsFnPredicate = false;
+    }
+    if (needsFnPredicate) {
+      ordinals = this.applyFnPredicate(ordinals);
+    }
+    const scanByName = /* @__PURE__ */ new Map();
+    for (const sc of c._internalScanColumns()) scanByName.set(sc.name, sc);
+    const sorted = sortOrdinals(
+      ordinals,
+      q.order,
+      scanByName,
+      (row, col) => c._internalReadCell(col, row)
+    );
+    const out = materialize(c, sorted, q.offsetN, q.limitN, q.selection);
+    this.cachedVersions.clear();
+    for (const name of this.observedColumns()) {
+      if (!c.schema.columnsByName.has(name)) continue;
+      this.cachedVersions.set(name, c.columnVersion(name));
+    }
+    this.staleFromInsertOrDelete = false;
+    const snap = {
+      rows: out,
+      version: c.globalVersion
+    };
+    this.cachedSnapshot = snap;
+    return snap;
+  }
+  /** Legacy scan: materialize + run fn predicate with dep tracking. Returns ordinals of survivors. */
+  legacyScan() {
+    const q = this.query;
+    const c = q.collection;
+    const pred = q.predicate;
+    const matched = [];
+    let idx = 0;
+    for (const row of c.rows()) {
+      const rowOrdinal = this.getOrdinalFor(idx++, row);
+      try {
+        const tracked = q.explicitDeps || this.depsAreAll ? row : trackRow(row, this.deps);
+        if (pred(tracked)) matched.push(rowOrdinal);
+      } catch (err) {
+        this.depsAreAll = true;
+        try {
+          if (pred(row)) matched.push(rowOrdinal);
+        } catch {
+          throw err;
+        }
+      }
+    }
+    return toU32(matched);
+  }
+  /**
+   * Map the sequential index returned by `rows()` to the live row
+   * ordinal. `rows()` yields in the same order as `_internalLiveOrdinals()`,
+   * so we lazily keep a parallel ordinal buffer.
+   */
+  cachedOrdinalBuffer = null;
+  cachedOrdinalVersion = -1;
+  getOrdinalFor(idx, _row) {
+    const c = this.query.collection;
+    if (this.cachedOrdinalVersion !== c.globalVersion || !this.cachedOrdinalBuffer) {
+      const arr = [];
+      for (const r of c._internalLiveOrdinals()) arr.push(r);
+      this.cachedOrdinalBuffer = toU32(arr);
+      this.cachedOrdinalVersion = c.globalVersion;
+    }
+    return this.cachedOrdinalBuffer[idx] ?? -1;
+  }
+  /** Apply the fn predicate to a candidate ordinal set (post-kernel filter). */
+  applyFnPredicate(candidates) {
+    const q = this.query;
+    q.collection;
+    const pred = q.predicate;
+    const kept = [];
+    for (let i = 0; i < candidates.length; i++) {
+      const ord = candidates[i];
+      const row = this.materializeFullRow(ord);
+      try {
+        const tracked = q.explicitDeps || this.depsAreAll ? row : trackRow(row, this.deps);
+        if (pred(tracked)) kept.push(ord);
+      } catch (err) {
+        this.depsAreAll = true;
+        try {
+          if (pred(row)) kept.push(ord);
+        } catch {
+          throw err;
+        }
+      }
+    }
+    return toU32(kept);
+  }
+  materializeFullRow(ord) {
+    const c = this.query.collection;
+    const out = {};
+    for (const name of c.columnNames()) out[name] = c._internalReadCell(name, ord);
+    return out;
+  }
+  /** Return a snapshot, reusing the cached one if all observed columns are unchanged. */
+  snapshot() {
+    if (this.cacheIsFresh()) return this.cachedSnapshot;
+    return this.recompute();
+  }
+  /**
+   * Subscribe to reactive updates. `listener` fires once with the initial
+   * snapshot and then again after every mutation that touches an observed
+   * column. Returns an unsubscribe function.
+   */
+  subscribe(listener) {
+    listener(this.snapshot());
+    const unsub = this.query.collection.subscribe((event) => {
+      if (!this.shouldReact(event)) return;
+      listener(this.snapshot());
+    });
+    return unsub;
+  }
+  /** Visible for tests: introspect current inferred deps. */
+  get inferredDeps() {
+    return this.deps;
+  }
+  get isDepsAll() {
+    return this.depsAreAll;
+  }
+  shouldReact(event) {
+    if (event.columns === "all" || this.depsAreAll) return true;
+    if (!this.cachedSnapshot) return true;
+    if (event.op === "insert" || event.op === "delete" || event.op === "rollback" || event.op === "compact") {
+      return true;
+    }
+    const observed = new Set(this.observedColumns());
+    for (const c of event.columns) {
+      if (observed.has(c)) return true;
+    }
+    return false;
+  }
+};
+function run(q) {
+  return new QueryExecutor(q);
+}
+function toU32(arr) {
+  const out = new Uint32Array(arr.length);
+  for (let i = 0; i < arr.length; i++) out[i] = arr[i];
+  return out;
+}
+
+// src/react.ts
+function useLiveQuery(query, options = {}) {
+  const executor = useExecutorForQuery(query);
+  return useExecutorSnapshot(executor, options);
+}
+function useLiveQueryResult(collection, build, deps = [], options = {}) {
+  const query = useMemo(
+    () => build(new Query(collection)),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [collection, ...deps]
+  );
+  const executor = useExecutorForQuery(query);
+  return useExecutorSnapshot(executor, options);
+}
+function useCollectionVersion(collection) {
+  const subscribe = useCallback(
+    (onChange) => collection.subscribe(() => onChange()),
+    [collection]
+  );
+  const getSnapshot = useCallback(() => collection.globalVersion, [collection]);
+  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+function useExecutorForQuery(query) {
+  const ref = useRef(null);
+  if (ref.current === null || ref.current.query !== query) {
+    if (ref.current) ref.current.executor.dispose();
+    ref.current = { query, executor: run(query) };
+  }
+  return ref.current.executor;
+}
+function useExecutorSnapshot(executor, options) {
+  const subscribe = useCallback(
+    (onChange) => {
+      let seenInitial = false;
+      return executor.subscribe(() => {
+        if (!seenInitial) {
+          seenInitial = true;
+          return;
+        }
+        onChange();
+      });
+    },
+    [executor]
+  );
+  const getSnapshot = useCallback(() => executor.snapshot(), [executor]);
+  const getServerSnapshot = useCallback(
+    () => options.ssrSnapshot ?? EMPTY_SNAPSHOT_TYPED(),
+    [options.ssrSnapshot]
+  );
+  return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+}
+var EMPTY_SNAPSHOT = Object.freeze({
+  rows: Object.freeze([]),
+  version: 0
+});
+function EMPTY_SNAPSHOT_TYPED() {
+  return EMPTY_SNAPSHOT;
+}
+
+export { useCollectionVersion, useLiveQuery, useLiveQueryResult };
+//# sourceMappingURL=react.js.map
+//# sourceMappingURL=react.js.map