@minnowdb/core 0.7.10 → 0.9.0

package/dist/engine/windows.js

@@ -0,0 +1,387 @@
+import { QueryMemoryContext } from "./memory.js";
+import { buildSortKeyColumn, sortKeyIndexes } from "./sort-keys.js";
+import { compareSqlValues, defineSqlResultProperty } from "./sql-semantics.js";
+import { exactNumericBinary, exactNumericValue, isExactNumeric } from "./sql-domains.js";
+import { throwIfAborted } from "./cancellation.js";
+class FrameAggregate {
+  #width;
+  #values;
+  #counts;
+  #window;
+  #exact;
+  #prefixEnd = 0;
+  #prefixTotal = null;
+  #prefixCount = 0;
+  constructor(values, window, memory, prefix) {
+    this.#window = window;
+    this.#exact = values.some(isExactNumeric);
+    if (prefix) {
+      this.#width = 0;
+      this.#values = values;
+      this.#counts = new Uint32Array(0);
+      return;
+    }
+    const width = 2 ** Math.ceil(Math.log2(Math.max(1, values.length)));
+    this.#width = width;
+    memory.tally(width * 2 * 20, "Window aggregate tree");
+    this.#values = new Array(width * 2).fill(null);
+    this.#counts = new Uint32Array(width * 2);
+    for (let index = 0; index < values.length; index += 1) {
+      const value = values[index] ?? null;
+      this.#values[width + index] = value;
+      this.#counts[width + index] = value === null ? 0 : 1;
+    }
+    for (let index = width - 1; index > 0; index -= 1) {
+      this.#counts[index] = (this.#counts[index * 2] ?? 0) + (this.#counts[index * 2 + 1] ?? 0);
+      this.#values[index] = this.#combine(this.#values[index * 2] ?? null, this.#values[index * 2 + 1] ?? null);
+    }
+  }
+  #combine(left, right) {
+    if (left === null)
+      return right;
+    if (right === null)
+      return left;
+    if (this.#window.name === "COUNT")
+      return null;
+    if (this.#window.name === "MIN")
+      return compareSqlValues(left, right) <= 0 ? left : right;
+    if (this.#window.name === "MAX")
+      return compareSqlValues(left, right) >= 0 ? left : right;
+    if (this.#exact) {
+      const total = exactNumericBinary("+", left, right);
+      if (total === void 0)
+        throw new TypeError("Window SUM requires numeric values");
+      return total;
+    }
+    if (typeof left !== "number" || typeof right !== "number")
+      throw new TypeError("Window SUM requires numeric values");
+    return left + right;
+  }
+  prefixValue(end, scale) {
+    while (this.#prefixEnd < end) {
+      const value = this.#values[this.#prefixEnd] ?? null;
+      this.#prefixEnd += 1;
+      if (value === null)
+        continue;
+      this.#prefixCount += 1;
+      this.#prefixTotal = this.#combine(this.#prefixTotal, value);
+    }
+    return this.#finish(this.#prefixTotal, this.#prefixCount, scale);
+  }
+  value(ranges, scale) {
+    let total = null;
+    let count = 0;
+    for (const [from, to] of ranges) {
+      let low = from + this.#width;
+      let high = to + this.#width;
+      let left = null;
+      let right = null;
+      while (low < high) {
+        if (low % 2 === 1) {
+          count += this.#counts[low] ?? 0;
+          left = this.#combine(left, this.#values[low] ?? null);
+          low += 1;
+        }
+        if (high % 2 === 1) {
+          high -= 1;
+          count += this.#counts[high] ?? 0;
+          right = this.#combine(this.#values[high] ?? null, right);
+        }
+        low = Math.floor(low / 2);
+        high = Math.floor(high / 2);
+      }
+      total = this.#combine(total, this.#combine(left, right));
+    }
+    return this.#finish(total, count, scale);
+  }
+  #finish(total, count, scale) {
+    if (this.#window.name === "COUNT")
+      return count;
+    if (count === 0)
+      return null;
+    if (this.#window.name !== "AVG")
+      return total;
+    if (this.#exact)
+      return exactNumericBinary("/", total ?? exactNumericValue(0), count, scale) ?? null;
+    if (typeof total !== "number")
+      throw new TypeError("Window AVG requires numeric values");
+    return total / count;
+  }
+}
+function frameRanges(partition, window, position) {
+  const size = partition.indexes.length;
+  const frame = window.frame ?? {
+    unit: "range",
+    start: { kind: "unbounded-preceding" },
+    end: { kind: window.orderAliases.length === 0 ? "unbounded-following" : "current-row" }
+  };
+  const groupEdge = (group) => group < 0 ? 0 : partition.groupStarts[group] ?? size;
+  const bound = (edge, start) => {
+    switch (edge.kind) {
+      case "unbounded-preceding":
+        return 0;
+      case "unbounded-following":
+        return size;
+      case "current-row":
+        return frame.unit === "rows" ? position + (start ? 0 : 1) : start ? partition.peerStart[position] ?? 0 : partition.peerEnd[position] ?? size;
+      case "preceding":
+      case "following": {
+        const delta = (edge.offset ?? 0) * (edge.kind === "preceding" ? -1 : 1);
+        if (frame.unit === "range") {
+          const current = partition.orderValues[position] ?? null;
+          if (current === null)
+            return start ? partition.peerStart[position] ?? 0 : partition.peerEnd[position] ?? size;
+          if (typeof current !== "number" && !isExactNumeric(current))
+            throw new TypeError("Offset RANGE frames require numeric ORDER BY values");
+          const order = window.orderAliases[0];
+          if (window.orderAliases.length !== 1 || order === void 0)
+            throw new TypeError("Offset RANGE frames require exactly one ORDER BY expression");
+          const descending = order.direction === "desc";
+          const distance = descending ? -delta : delta;
+          const target = isExactNumeric(current) ? exactNumericBinary("+", current, distance) ?? null : current + distance;
+          let low2 = 0;
+          let high2 = size;
+          while (low2 < high2) {
+            const middle = Math.floor((low2 + high2) / 2);
+            const value = partition.orderValues[middle] ?? null;
+            const comparison = value === null ? (order.nulls ?? (descending ? "first" : "last")) === "first" ? -1 : 1 : compareSqlValues(value, target) * (descending ? -1 : 1);
+            if (comparison < 0 || !start && comparison === 0)
+              low2 = middle + 1;
+            else
+              high2 = middle;
+          }
+          return low2;
+        }
+        return frame.unit === "groups" ? groupEdge((partition.groupOrdinal[position] ?? 0) + delta + (start ? 0 : 1)) : position + delta + (start ? 0 : 1);
+      }
+    }
+  };
+  const low = Math.max(0, Math.min(size, bound(frame.start, true)));
+  const high = Math.max(0, Math.min(size, bound(frame.end, false)));
+  if (high <= low)
+    return [];
+  if (frame.exclude === void 0 || frame.exclude === "no-others")
+    return [[low, high]];
+  const from = frame.exclude === "current-row" ? position : partition.peerStart[position] ?? position;
+  const to = frame.exclude === "current-row" ? position + 1 : partition.peerEnd[position] ?? position + 1;
+  const ranges = [];
+  if (low < Math.min(high, from))
+    ranges.push([low, Math.min(high, from)]);
+  if (frame.exclude === "ties" && position >= low && position < high)
+    ranges.push([position, position + 1]);
+  if (Math.max(low, to) < high)
+    ranges.push([Math.max(low, to), high]);
+  return ranges;
+}
+function* applyPartition(rows, partition, window, result, memory) {
+  const { indexes, peerStart, peerEnd, groupOrdinal } = partition;
+  const size = indexes.length;
+  memory.tally(size * 8, "Window argument values");
+  const values = Array.from(indexes, (index) => window.argumentAlias === void 0 ? 1 : rows[index]?.[window.argumentAlias] ?? null);
+  const aggregates = /* @__PURE__ */ new Set(["SUM", "AVG", "COUNT", "MIN", "MAX"]);
+  const frame = window.frame;
+  const prefix = frame === void 0 || (frame.exclude === void 0 || frame.exclude === "no-others") && frame.start.kind === "unbounded-preceding" && (frame.end.kind === "current-row" || frame.end.kind === "unbounded-following");
+  const whole = frame?.end.kind === "unbounded-following" || frame === void 0 && window.orderAliases.length === 0;
+  const aggregate = aggregates.has(window.name) ? new FrameAggregate(values, window, memory, prefix) : void 0;
+  const domain = result.columnDomains[result.columns.indexOf(window.argumentAlias ?? "")];
+  for (let position = 0; position < size; position += 1) {
+    if (position % 2048 === 0)
+      yield;
+    let value;
+    switch (window.name) {
+      case "ROW_NUMBER":
+        value = position + 1;
+        break;
+      case "RANK":
+        value = (peerStart[position] ?? 0) + 1;
+        break;
+      case "DENSE_RANK":
+        value = (groupOrdinal[position] ?? 0) + 1;
+        break;
+      case "PERCENT_RANK":
+        value = size === 1 ? 0 : (peerStart[position] ?? 0) / (size - 1);
+        break;
+      case "CUME_DIST":
+        value = (peerEnd[position] ?? size) / size;
+        break;
+      case "NTILE": {
+        const buckets = window.offset ?? 1;
+        const width = Math.floor(size / buckets);
+        const extra = size % buckets;
+        const larger = (width + 1) * extra;
+        value = position < larger ? Math.floor(position / (width + 1)) + 1 : extra + Math.floor((position - larger) / width) + 1;
+        break;
+      }
+      case "LAG":
+      case "LEAD": {
+        const target = position + (window.offset ?? 1) * (window.name === "LAG" ? -1 : 1);
+        value = target < 0 || target >= size ? window.fallback ?? null : values[target] ?? null;
+        break;
+      }
+      default: {
+        if (aggregate !== void 0 && prefix) {
+          const end = whole ? size : frame?.unit === "rows" ? position + 1 : peerEnd[position] ?? size;
+          value = aggregate.prefixValue(end, domain?.kind === "numeric" ? domain.scale : void 0);
+          break;
+        }
+        const ranges = frameRanges(partition, window, position);
+        if (aggregate !== void 0)
+          value = aggregate.value(ranges, domain?.kind === "numeric" ? domain.scale : void 0);
+        else {
+          let remaining = window.name === "NTH_VALUE" ? window.offset ?? 1 : 1;
+          value = null;
+          if (window.name === "LAST_VALUE") {
+            const last = ranges.at(-1);
+            value = last === void 0 ? null : values[last[1] - 1] ?? null;
+          } else {
+            for (const [from, to] of ranges) {
+              if (remaining <= to - from) {
+                value = values[from + remaining - 1] ?? null;
+                break;
+              }
+              remaining -= to - from;
+            }
+          }
+        }
+      }
+    }
+    const row = rows[indexes[position] ?? -1];
+    if (row !== void 0) {
+      if (window.alias in row)
+        defineSqlResultProperty(row, window.alias, value);
+      else
+        row[window.alias] = value;
+    }
+  }
+}
+function* windowSteps(result, windows, options) {
+  const memory = options.memoryContext ?? new QueryMemoryContext();
+  const owned = options.memoryContext === void 0;
+  const rows = [];
+  try {
+    memory.tally(result.rows.length * (24 + windows.length * 16 + (options.copyRows === false ? 0 : 48 + result.columns.length * 16)), "Window result rows");
+    for (let index = 0; index < result.rows.length; index += 1) {
+      if (index % 2048 === 0)
+        yield;
+      const row = result.rows[index] ?? {};
+      rows.push(options.copyRows === false ? row : { ...row });
+    }
+    const groups = /* @__PURE__ */ new Map();
+    for (const window of windows) {
+      const key = JSON.stringify([window.partitionAliases, window.orderAliases]);
+      const group = groups.get(key);
+      if (group === void 0)
+        groups.set(key, [window]);
+      else
+        group.push(window);
+    }
+    for (const group of groups.values()) {
+      const window = group[0];
+      if (window === void 0)
+        continue;
+      const work = memory.createChild();
+      try {
+        const aliases = [
+          ...window.partitionAliases,
+          ...window.orderAliases.map(({ alias }) => alias)
+        ];
+        const peers = group.some((member) => !["ROW_NUMBER", "NTILE", "LAG", "LEAD"].includes(member.name) && (["RANK", "DENSE_RANK", "PERCENT_RANK", "CUME_DIST"].includes(member.name) || member.frame?.unit !== "rows" || member.frame.exclude === "group" || member.frame.exclude === "ties"));
+        const range = group.some((member) => member.frame?.unit === "range");
+        work.tally(rows.length * (20 + (peers ? 20 : 0) + (range ? 8 : 0) + aliases.length * 40), "Window sort and partition buffers");
+        const columns = aliases.map((alias) => buildSortKeyColumn(rows.length, (index) => rows[index]?.[alias] ?? null));
+        yield;
+        const indexes = sortKeyIndexes(rows.length, columns.map((column, index) => {
+          const order = window.orderAliases[index - window.partitionAliases.length];
+          return { column, descending: order?.direction === "desc", nulls: order?.nulls };
+        }));
+        const partitions = columns.slice(0, window.partitionAliases.length);
+        const orders = columns.slice(window.partitionAliases.length);
+        let start = 0;
+        while (start < indexes.length) {
+          let end = start + 1;
+          while (end < indexes.length && partitions.every((column) => column.compare(indexes[start] ?? 0, indexes[end] ?? 0) === 0)) {
+            if (end % 2048 === 0)
+              yield;
+            end += 1;
+          }
+          const size = end - start;
+          const partition = {
+            indexes: indexes.subarray(start, end),
+            peerStart: new Int32Array(peers ? size : 0),
+            peerEnd: new Int32Array(peers ? size : 0),
+            groupOrdinal: new Int32Array(peers ? size : 0),
+            groupStarts: [],
+            orderValues: range ? Array.from(indexes.subarray(start, end), (index) => rows[index]?.[window.orderAliases[0]?.alias ?? ""] ?? null) : []
+          };
+          let begin = 0;
+          for (let position = 1; peers && position <= size; position += 1) {
+            if (position % 2048 === 0)
+              yield;
+            if (position === size || orders.some((column) => column.compare(indexes[start + begin] ?? 0, indexes[start + position] ?? 0) !== 0)) {
+              const ordinal = partition.groupStarts.length;
+              partition.groupStarts.push(begin);
+              partition.peerStart.fill(begin, begin, position);
+              partition.peerEnd.fill(position, begin, position);
+              partition.groupOrdinal.fill(ordinal, begin, position);
+              begin = position;
+            }
+          }
+          for (const member of group) {
+            const frameMemory = work.createChild();
+            try {
+              yield* applyPartition(rows, partition, member, result, frameMemory);
+            } finally {
+              frameMemory.close();
+            }
+          }
+          start = end;
+        }
+      } finally {
+        work.close();
+      }
+    }
+    return {
+      columns: [...result.columns, ...windows.map(({ alias }) => alias)],
+      columnDomains: [...result.columnDomains, ...windows.map(() => null)],
+      rows
+    };
+  } finally {
+    if (owned)
+      memory.close();
+  }
+}
+function applyWindowFunctions(result, windows, options = {}) {
+  const steps = windowSteps(result, windows, options);
+  try {
+    for (; ; ) {
+      throwIfAborted(options.signal);
+      const step = steps.next();
+      if (step.done)
+        return step.value;
+    }
+  } finally {
+    steps.return({ columns: [], columnDomains: [], rows: [] });
+  }
+}
+async function applyWindowFunctionsAsync(result, windows, options = {}) {
+  const steps = windowSteps(result, windows, options);
+  let yieldedAt = performance.now();
+  try {
+    for (; ; ) {
+      throwIfAborted(options.signal);
+      const step = steps.next();
+      if (step.done)
+        return step.value;
+      if (performance.now() - yieldedAt >= 8) {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        yieldedAt = performance.now();
+      }
+    }
+  } finally {
+    steps.return({ columns: [], columnDomains: [], rows: [] });
+  }
+}
+export {
+  applyWindowFunctions,
+  applyWindowFunctionsAsync
+};

package/dist/engine/worker-server.d.ts

@@ -26,7 +26,7 @@ export type StoreDescriptor = {
     durability?: "relaxed" | "strict";
 };
 /** The cloneable subset of MinnowDatabaseOptions; function-valued seams stay worker-side. */
-export type WireDatabaseOptions = Pick<MinnowDatabaseOptions, "compression" | "targetBlockBytes" | "rowsPerBlock" | "maxCommitRetries" | "spillOwnerLeaseMs" | "transactionOwnerLeaseMs" | "transactionIdleTimeoutMs" | "bufferPoolBytes" | "executionMemoryBudgetBytes" | "autoCollectDebtLimitCommits" | "autoCollect" | "autoCompact">;
+export type WireDatabaseOptions = Pick<MinnowDatabaseOptions, "compression" | "targetBlockBytes" | "rowsPerBlock" | "maxCommitRetries" | "coordinateWrites" | "spillOwnerLeaseMs" | "transactionOwnerLeaseMs" | "transactionIdleTimeoutMs" | "bufferPoolBytes" | "executionMemoryBudgetBytes" | "autoCollectDebtLimitCommits" | "autoCollect" | "autoCompact">;
 export interface DatabaseInitPayload {
     store: StoreDescriptor;
     options?: WireDatabaseOptions;

package/dist/engine/worker-server.js

@@ -455,7 +455,9 @@ class DatabaseRpcServer {
       resolveVersion = resolve;
       rejectVersion = reject;
     });
+    let snapshotSession;
     const done = this.database.snapshot(async (session) => {
+      snapshotSession = session;
       resolveVersion(session.version);
       await new Promise((resolveRelease) => {
         release = resolveRelease;
@@ -466,7 +468,7 @@ class DatabaseRpcServer {
       const version = await versionReady;
       if (release === void 0)
         throw new Error("Snapshot scope did not install its release");
-      this.#publishHandle(handleId, { type: "snapshot", release, done });
+      this.#publishHandle(handleId, { type: "snapshot", session: snapshotSession, release, done });
       return { handleId, version };
     } catch (error) {
       release?.();
@@ -494,6 +496,9 @@ class DatabaseRpcServer {
     }
     switch (handle.type) {
       case "snapshot": {
+        if (method === "query") {
+          return this.#querySession(handle.session, args, context);
+        }
         if (method !== "close")
           throw new Error(`Unsupported snapshot method: ${method}`);
         handle.release();
@@ -537,19 +542,21 @@ class DatabaseRpcServer {
       }
     }
   }
+  async #querySession(session, args, context) {
+    const [sql, options, reportStats = false] = args;
+    return new ColumnarResult(encodeQueryResult(await session.query(sql, {
+      ...options,
+      signal: context.signal,
+      ...reportStats ? {
+        onStats: (stats) => {
+          this.scope.postMessage(rpcEvent(context.requestId, "stats", stats));
+        }
+      } : {}
+    })));
+  }
   async #callWriteHandle(handleId, handle, method, args, context) {
-    if (method === "query") {
-      const [sql, options, reportStats = false] = args;
-      return new ColumnarResult(encodeQueryResult(await handle.session.query(sql, {
-        ...options,
-        signal: context.signal,
-        ...reportStats ? {
-          onStats: (stats) => {
-            this.scope.postMessage(rpcEvent(context.requestId, "stats", stats));
-          }
-        } : {}
-      })));
-    }
+    if (method === "query")
+      return this.#querySession(handle.session, args, context);
     if (method === "execute") {
       const [sql, params] = args;
       return handle.session.execute(sql, params);
@@ -665,15 +672,21 @@ class DatabaseRpcServer {
       case "subscribe": {
         const subscriptionId = this.#claimHandleId(args[0]);
         const query = args[1];
+        const patches = args[2]?.patches === true;
         let subscription;
         try {
           subscription = await handle.set.subscribe(query, {
             onChange: (result, delivery) => {
-              const encoded = encodeQueryResult(result);
+              const patch = patches && !delivery.initial && delivery.retained !== void 0;
+              const encoded = encodeQueryResult(patch ? {
+                columns: result.columns,
+                columnDomains: result.columnDomains,
+                rows: result.rows.filter((_, index) => (delivery.retained?.[index] ?? -1) < 0)
+              } : result);
               const retained = delivery.retained?.slice();
               if (retained !== void 0)
                 encoded.transfer.push(retained.buffer);
-              this.scope.postMessage(rpcEvent(subscriptionId, "change", {
+              this.scope.postMessage(rpcEvent(subscriptionId, patch ? "patch" : "change", {
                 result: encoded.payload,
                 delivery: retained === void 0 ? delivery : { ...delivery, retained }
               }), { transfer: encoded.transfer });

package/dist/engine/write-coordinator.js

@@ -0,0 +1,54 @@
+const anonymous = /* @__PURE__ */ new WeakMap();
+const named = /* @__PURE__ */ new Map();
+async function coordinateWrite(store, run, signal) {
+  signal.throwIfAborted();
+  const name = store.liveQueryChannelName;
+  let queue = name === void 0 ? anonymous.get(store) : named.get(name);
+  if (queue === void 0) {
+    queue = { tail: Promise.resolve() };
+    if (name === void 0)
+      anonymous.set(store, queue);
+    else
+      named.set(name, queue);
+  }
+  const locks = typeof navigator === "undefined" ? void 0 : navigator.locks;
+  const lockController = new AbortController();
+  let admitted = false;
+  const enter = () => {
+    signal.throwIfAborted();
+    admitted = true;
+    return run();
+  };
+  const operation = queue.tail.then(async () => {
+    signal.throwIfAborted();
+    return name !== void 0 && locks !== void 0 ? await locks.request(`minnowdb-write:${name}`, { signal: lockController.signal }, enter) : await enter();
+  });
+  const settled = operation.then(() => void 0, () => void 0);
+  queue.tail = settled;
+  void settled.then(() => {
+    if (queue.tail !== settled)
+      return;
+    if (name === void 0)
+      anonymous.delete(store);
+    else
+      named.delete(name);
+  });
+  let abort = () => void 0;
+  const cancelled = new Promise((_resolve, reject) => {
+    abort = () => {
+      if (!admitted) {
+        lockController.abort(signal.reason);
+        reject(signal.reason instanceof Error ? signal.reason : new Error("Write admission cancelled", { cause: signal.reason }));
+      }
+    };
+    signal.addEventListener("abort", abort, { once: true });
+  });
+  try {
+    return await Promise.race([operation, cancelled]);
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+}
+export {
+  coordinateWrite
+};

package/dist/plan/model.d.ts

@@ -17,7 +17,7 @@ export type ComparisonOperator = "=" | "!=" | "<>" | ">" | ">=" | "<" | "<=";
 export type AggregateName = "COUNT" | "SUM" | "AVG" | "MIN" | "MAX" | "JSON_ARRAYAGG" | "STRING_AGG"
 /** Optimizer-only aggregate that enforces scalar-subquery cardinality. */
  | "MINNOW_SINGLE_VALUE";
-export type ScalarFunctionName = "ROUND" | "COALESCE" | "DATE_TRUNC" | "DATE_ADD" | "UPPER" | "LOWER" | "LENGTH" | "ABS" | "TRIM" | "LTRIM" | "RTRIM" | "SUBSTR" | "REPLACE" | "INSTR" | "NULLIF" | "GREATEST" | "LEAST" | "FLOOR" | "CEIL" | "MOD" | "POWER" | "SQRT" | "EXTRACT" | "CAST" | "OCTET_LENGTH" | "LPAD" | "RPAD" | "OVERLAY" | "CURRENT_DATE" | "CURRENT_TIMESTAMP" | "LOCALTIME" | "GROUPING" | "JSON_VALUE" | "JSON_QUERY" | "JSON_EXISTS" | "JSON_OBJECT" | "JSON_ARRAY" | "TO_JSON" | "IS_JSON" | "ARRAY"
+export type ScalarFunctionName = "ROUND" | "COALESCE" | "DATE_TRUNC" | "DATE_ADD" | "UPPER" | "LOWER" | "LENGTH" | "ABS" | "TRIM" | "LTRIM" | "RTRIM" | "SUBSTR" | "REPLACE" | "INSTR" | "NULLIF" | "GREATEST" | "LEAST" | "FLOOR" | "CEIL" | "MOD" | "POWER" | "SQRT" | "EXTRACT" | "CAST" | "OCTET_LENGTH" | "LPAD" | "RPAD" | "OVERLAY" | "CURRENT_DATE" | "CURRENT_TIMESTAMP" | "LOCALTIME" | "GROUPING" | "JSON_VALUE" | "JSON_QUERY" | "JSON_EXISTS" | "JSON_OBJECT" | "JSON_ARRAY" | "TO_JSON" | "IS_JSON" | "MINNOW_ARRAY_AT" | "MINNOW_ARRAY_FROM_JSON" | "MINNOW_ARRAY_ELEMENT" | "ARRAY"
 /** Parser-produced `->` JSON member/element access returning a JSON value. */
  | "MINNOW_JSON_GET"
 /** Parser-produced `->>` JSON member/element access returning text. */