@lunora/do 1.0.0-alpha.13 → 1.0.0-alpha.15

package/dist/packem_shared/{ReactiveCache-1hDydFyv.mjs → ReactiveCache-BYlSGY0N.mjs}

@@ -1,4 +1,4 @@
-import { stableStringify } from './stableStringify-CyHKJXre.mjs';
+import { stableStringify } from './stableStringify-MydiuScU.mjs';
 import { depKey, SCAN_DEP } from './SCAN_DEP-DLJF8dsj.mjs';
 
 const DEFAULT_MAX_ENTRIES = 1e3;

package/dist/packem_shared/{ctx-db-shapes-DVoeZpo-.mjs → ctx-db-shapes-BQapRFjB.mjs}

@@ -50,4 +50,4 @@ const selectShapeMemberIds = (sql$1, table, effectiveWhere, ids) => {
   return new Set(rows.map((row) => row.id));
 };
 
-export { selectShapeRows as a, selectShapeMemberIds as s };
+export { selectShapeMemberIds as a, selectShapeRows as s };

package/dist/packem_shared/diffExternalSource-Cx9HUPJj.mjs

@@ -0,0 +1,44 @@
+import { stableStringify } from './stableStringify-MydiuScU.mjs';
+
+const projectExternalSourceRow = (row, columns) => {
+  const projected = { _id: row._id };
+  if (columns) {
+    for (const key of columns) {
+      if (Object.hasOwn(row, key)) {
+        projected[key] = row[key];
+      }
+    }
+    return projected;
+  }
+  for (const [key, value] of Object.entries(row)) {
+    if (key !== "_id" && key !== "_creationTime") {
+      projected[key] = value;
+    }
+  }
+  return projected;
+};
+const diffExternalSource = (pulled, baseline, options) => {
+  const { columns, table } = options;
+  const changes = [];
+  const nextBaseline = /* @__PURE__ */ new Map();
+  for (const source of pulled) {
+    const value = projectExternalSourceRow(source, columns);
+    const id = String(value._id);
+    const json = stableStringify(value);
+    nextBaseline.set(id, json);
+    const before = baseline.get(id);
+    if (before === void 0) {
+      changes.push({ doc: value, id, op: "insert", seq: 0, table, ts: 0 });
+    } else if (before !== json) {
+      changes.push({ doc: value, id, op: "update", seq: 0, table, ts: 0 });
+    }
+  }
+  for (const id of baseline.keys()) {
+    if (!nextBaseline.has(id)) {
+      changes.push({ id, op: "delete", seq: 0, table, ts: 0 });
+    }
+  }
+  return { changes, nextBaseline };
+};
+
+export { diffExternalSource, projectExternalSourceRow };

package/dist/packem_shared/isSourceDue-BMTJv65e.mjs

@@ -0,0 +1,40 @@
+import { runExternalSourceTick } from './materializeExternalRows-uKBx9H0s.mjs';
+
+const liftSourceId = (row, options = {}) => {
+  const { idColumn = "id", map } = options;
+  const idValue = row[idColumn];
+  if (idValue === void 0 || idValue === null) {
+    throw new Error(`external-source: row is missing id column "${idColumn}"`);
+  }
+  if (typeof idValue !== "string" && typeof idValue !== "number" && typeof idValue !== "bigint") {
+    throw new TypeError(`external-source: id column "${idColumn}" must be a string or number`);
+  }
+  const id = String(idValue);
+  if (map) {
+    return { ...map(row), _id: id };
+  }
+  const body = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (key !== idColumn) {
+      body[key] = value;
+    }
+  }
+  return { ...body, _id: id };
+};
+const isSourceDue = (refresh, lastPolledMs, nowMs) => {
+  if (refresh === "manual") {
+    return false;
+  }
+  if (refresh === void 0 || lastPolledMs === void 0) {
+    return true;
+  }
+  return nowMs - lastPolledMs >= refresh.everyMs;
+};
+const pullExternalSourceTick = async (sql, writer, client, table, source, shardKey) => {
+  const parameters = source.tenantBy ? source.tenantBy(shardKey) : [];
+  const rows = await client.query(source.query, parameters);
+  const documents = rows.map((row) => liftSourceId(row, { idColumn: source.idColumn, map: source.map }));
+  return runExternalSourceTick(sql, writer, documents, { columns: source.columns, table });
+};
+
+export { isSourceDue, liftSourceId, pullExternalSourceTick };

package/dist/packem_shared/materializeExternalRows-uKBx9H0s.mjs

@@ -0,0 +1,23 @@
+import { applyCdcChanges } from './CDC_LOG_TABLE-DSycmnDf.mjs';
+import { s as selectShapeRows } from './ctx-db-shapes-BQapRFjB.mjs';
+import { diffExternalSource, projectExternalSourceRow } from './diffExternalSource-Cx9HUPJj.mjs';
+import { stableStringify } from './stableStringify-MydiuScU.mjs';
+
+const materializeExternalRows = async (writer, pulled, baseline, options) => {
+  const { changes, nextBaseline } = diffExternalSource(pulled, baseline, options);
+  await applyCdcChanges(writer, changes);
+  return { applied: changes.length, nextBaseline };
+};
+const readExternalSourceBaseline = (sql, table, columns) => {
+  const baseline = /* @__PURE__ */ new Map();
+  for (const { doc, id } of selectShapeRows(sql, table, void 0)) {
+    baseline.set(id, stableStringify(projectExternalSourceRow({ ...doc, _id: id }, columns)));
+  }
+  return baseline;
+};
+const runExternalSourceTick = async (sql, writer, pulled, options) => {
+  const baseline = readExternalSourceBaseline(sql, options.table, options.columns);
+  return materializeExternalRows(writer, pulled, baseline, options);
+};
+
+export { materializeExternalRows, readExternalSourceBaseline, runExternalSourceTick };

package/dist/packem_shared/{serveRelationFanout-C6lDaesn.mjs → serveRelationFanout-EZLD9-O3.mjs}

@@ -1,4 +1,4 @@
-import { RELATION_FUNCTION_PREFIX } from './ADMIN_FUNCTIONS-D_UiYJFk.mjs';
+import { RELATION_FUNCTION_PREFIX } from './ADMIN_FUNCTIONS-fMl1vyt1.mjs';
 
 const serveRelationFanout = async (schema, database, functionPath, args) => {
   const table = typeof args["table"] === "string" ? args["table"] : "";

package/dist/packem_shared/{stableStringify-CyHKJXre.mjs → stableStringify-MydiuScU.mjs}

@@ -8,12 +8,22 @@ const stableStringify = (value) => {
   if (value === void 0) {
     return "null";
   }
+  if (typeof value === "bigint") {
+    throw new TypeError("stableStringify: cannot use a bigint in a cache key (query/subscription/shape args) — pass it as a string");
+  }
   if (value === null || typeof value !== "object") {
     return JSON.stringify(value);
   }
   if (Array.isArray(value)) {
     return `[${value.map((item) => stableStringify(item)).join(",")}]`;
   }
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== null && proto !== Object.prototype) {
+    const name = value.constructor?.name ?? "value";
+    throw new TypeError(
+      `stableStringify: cannot use a ${name} in a cache key (query/subscription/shape args) — only plain objects, arrays, and JSON primitives are supported`
+    );
+  }
   const record = value;
   const keys = Object.keys(record).toSorted(compareKeys);
   const parts = [];

package/dist/packem_shared/subscription-delivery-Z6nXHvQN.mjs

@@ -0,0 +1,340 @@
+const TAG = "$lunora.wire$";
+const MAX_DEPTH = 64;
+const MAX_BIGINT_DIGITS = 1024;
+const UNSAFE_KEY = "__proto__";
+const TYPED_ARRAY_CTORS = {
+  BigInt64Array,
+  BigUint64Array,
+  Float32Array,
+  Float64Array,
+  Int8Array,
+  Int16Array,
+  Int32Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Uint16Array,
+  Uint32Array
+};
+const ERROR_CTORS = {
+  Error,
+  EvalError,
+  RangeError,
+  ReferenceError,
+  SyntaxError,
+  TypeError,
+  URIError
+};
+const toBase64 = (bytes) => {
+  let binary = "";
+  const chunk = 32768;
+  for (let index = 0; index < bytes.length; index += chunk) {
+    binary += String.fromCharCode(...bytes.subarray(index, index + chunk));
+  }
+  return btoa(binary);
+};
+const fromBase64 = (base64) => {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.codePointAt(index) ?? 0;
+  }
+  return bytes;
+};
+const encodeWire = (value, depth = 0) => {
+  if (depth > MAX_DEPTH) {
+    throw new RangeError(`wire-codec: value nesting exceeds the ${MAX_DEPTH}-level limit`);
+  }
+  if (value === void 0) {
+    return [TAG, "undefined"];
+  }
+  if (value === null) {
+    return null;
+  }
+  const kind = typeof value;
+  if (kind === "bigint") {
+    return [TAG, "bigint", value.toString()];
+  }
+  if (kind === "number") {
+    const numeric = value;
+    if (Number.isNaN(numeric)) {
+      return [TAG, "nan"];
+    }
+    if (numeric === Infinity) {
+      return [TAG, "inf"];
+    }
+    if (numeric === -Infinity) {
+      return [TAG, "-inf"];
+    }
+    return numeric;
+  }
+  if (kind !== "object") {
+    return value;
+  }
+  if (value instanceof Date) {
+    return [TAG, "date", encodeWire(value.getTime(), depth + 1)];
+  }
+  if (value instanceof Error) {
+    const error = value;
+    const properties = {};
+    for (const key of Object.keys(error)) {
+      if (error[key] !== void 0) {
+        properties[key] = encodeWire(error[key], depth + 1);
+      }
+    }
+    const encodedError = [TAG, "error", error.name, error.message, properties];
+    if (error.cause !== void 0) {
+      encodedError.push(encodeWire(error.cause, depth + 1));
+    }
+    return encodedError;
+  }
+  if (value instanceof URL) {
+    return [TAG, "url", value.href];
+  }
+  if (value instanceof Map) {
+    return [TAG, "map", [...value.entries()].map(([k, v]) => [encodeWire(k, depth + 1), encodeWire(v, depth + 1)])];
+  }
+  if (value instanceof Set) {
+    return [TAG, "set", [...value].map((item) => encodeWire(item, depth + 1))];
+  }
+  if (value instanceof ArrayBuffer) {
+    return [TAG, "bytes", toBase64(new Uint8Array(value)), "ArrayBuffer"];
+  }
+  if (ArrayBuffer.isView(value)) {
+    const view = value;
+    const ctorName = view.constructor.name;
+    const bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+    return ctorName === "Uint8Array" ? [TAG, "bytes", toBase64(bytes)] : [TAG, "bytes", toBase64(bytes), ctorName];
+  }
+  if (Array.isArray(value)) {
+    const encoded = value.map((item) => encodeWire(item, depth + 1));
+    return encoded.length > 0 && encoded[0] === TAG ? [TAG, "arr", encoded] : encoded;
+  }
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== null && proto !== Object.prototype) {
+    const name = value.constructor?.name ?? "value";
+    throw new TypeError(
+      `wire-codec: cannot encode a ${name} over the Lunora wire — only plain objects, arrays, and the supported built-ins (Date, Error, URL, Map, Set, ArrayBuffer/typed arrays, bigint) round-trip`
+    );
+  }
+  const source = value;
+  const result = {};
+  for (const key of Object.keys(source)) {
+    const field = source[key];
+    if (field !== void 0) {
+      result[key] = encodeWire(field, depth + 1);
+    }
+  }
+  return result;
+};
+const decodeWire = (value, depth = 0) => {
+  if (depth > MAX_DEPTH) {
+    throw new RangeError(`wire-codec: value nesting exceeds the ${MAX_DEPTH}-level limit`);
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    if (value[0] === TAG) {
+      const tag = value[1];
+      switch (tag) {
+        case "-inf": {
+          return -Infinity;
+        }
+        case "arr": {
+          return value[2].map((item) => decodeWire(item, depth + 1));
+        }
+        case "bigint": {
+          const raw = value[2];
+          if (typeof raw !== "string" || raw.length > MAX_BIGINT_DIGITS || !/^-?\d+$/.test(raw)) {
+            throw new RangeError(`wire-codec: invalid or over-long bigint (max ${MAX_BIGINT_DIGITS} digits)`);
+          }
+          return BigInt(raw);
+        }
+        case "date": {
+          return new Date(decodeWire(value[2], depth + 1));
+        }
+        case "map": {
+          return new Map(value[2].map(([k, v]) => [decodeWire(k, depth + 1), decodeWire(v, depth + 1)]));
+        }
+        case "set": {
+          return new Set(value[2].map((item) => decodeWire(item, depth + 1)));
+        }
+        case "url": {
+          return new URL(value[2]);
+        }
+        case "error": {
+          const name = value[2];
+          const message = value[3];
+          const Ctor = (Object.hasOwn(ERROR_CTORS, name) ? ERROR_CTORS[name] : void 0) ?? Error;
+          const error = new Ctor(message);
+          if (error.name !== name) {
+            Object.defineProperty(error, "name", { configurable: true, value: name, writable: true });
+          }
+          Object.assign(error, decodeWire(value[4], depth + 1));
+          if (value.length > 5) {
+            Object.defineProperty(error, "cause", { configurable: true, value: decodeWire(value[5], depth + 1), writable: true });
+          }
+          return error;
+        }
+        case "bytes": {
+          const bytes = fromBase64(value[2]);
+          const ctorName = value[3] ?? "Uint8Array";
+          if (ctorName === "ArrayBuffer") {
+            return bytes.buffer.byteLength === bytes.byteLength ? bytes.buffer : bytes.slice().buffer;
+          }
+          const Ctor = Object.hasOwn(TYPED_ARRAY_CTORS, ctorName) ? TYPED_ARRAY_CTORS[ctorName] : void 0;
+          return Ctor ? new Ctor(bytes.slice().buffer) : bytes;
+        }
+        case "inf": {
+          return Infinity;
+        }
+        case "nan": {
+          return Number.NaN;
+        }
+        case "undefined": {
+          return void 0;
+        }
+        default: {
+          return value.map((item) => decodeWire(item, depth + 1));
+        }
+      }
+    }
+    return value.map((item) => decodeWire(item, depth + 1));
+  }
+  const source = value;
+  const result = {};
+  for (const key of Object.keys(source)) {
+    const decoded = decodeWire(source[key], depth + 1);
+    if (key === UNSAFE_KEY) {
+      Object.defineProperty(result, key, { configurable: true, enumerable: true, value: decoded, writable: true });
+    } else {
+      result[key] = decoded;
+    }
+  }
+  return result;
+};
+
+const ROW_ID_FIELD = "_id";
+const DELTA_FALLBACK_TABLE = "__lunora__";
+const readRowId = (row) => {
+  if (typeof row !== "object" || row === null || Array.isArray(row)) {
+    return void 0;
+  }
+  const id = row[ROW_ID_FIELD];
+  return typeof id === "string" ? id : void 0;
+};
+const indexRowsById = (rows) => {
+  const byId = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const row of rows) {
+    const id = readRowId(row);
+    if (id === void 0 || byId.has(id)) {
+      return void 0;
+    }
+    byId.set(id, row);
+    order.push(id);
+  }
+  return { byId, order };
+};
+const survivorsKeepOrder = (previous, next) => {
+  const survivingPrevious = previous.order.filter((id) => next.byId.has(id));
+  const survivingNext = next.order.filter((id) => previous.byId.has(id));
+  if (survivingPrevious.length !== survivingNext.length) {
+    return false;
+  }
+  return survivingPrevious.every((id, index) => survivingNext[index] === id);
+};
+const collectDeleteDeltas = (previous, next, deltaTable, tableJson) => {
+  const out = [];
+  for (const id of previous.order) {
+    if (!next.byId.has(id)) {
+      out.push({
+        delta: { key: id, op: "delete", table: deltaTable },
+        frame: `{"key":${JSON.stringify(id)},"op":"delete","table":${tableJson}}`
+      });
+    }
+  }
+  return out;
+};
+const collectUpsertDeltas = (previous, next, deltaTable, tableJson) => {
+  const out = [];
+  for (const id of next.order) {
+    const nextRow = next.byId.get(id);
+    const previousRow = previous.byId.get(id);
+    const nextFingerprint = JSON.stringify(encodeWire(nextRow));
+    const previousFingerprint = previousRow === void 0 ? void 0 : JSON.stringify(previousRow);
+    if (previousFingerprint === nextFingerprint) {
+      continue;
+    }
+    const op = previousFingerprint === void 0 ? "insert" : "update";
+    out.push({
+      delta: { key: id, op, row: nextRow, table: deltaTable },
+      frame: `{"key":${JSON.stringify(id)},"op":"${op}","row":${nextFingerprint},"table":${tableJson}}`
+    });
+  }
+  return out;
+};
+const subscriptionListDeltas = (previousJson, nextResult, table, frames) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(previousJson);
+  } catch {
+    return void 0;
+  }
+  if (!Array.isArray(parsed) || !Array.isArray(nextResult)) {
+    return void 0;
+  }
+  const previous = indexRowsById(parsed);
+  const next = indexRowsById(nextResult);
+  if (previous === void 0 || next === void 0) {
+    return void 0;
+  }
+  if (!survivorsKeepOrder(previous, next)) {
+    return void 0;
+  }
+  const deltaTable = table === "" ? DELTA_FALLBACK_TABLE : table;
+  const tableJson = JSON.stringify(deltaTable);
+  const framed = [...collectDeleteDeltas(previous, next, deltaTable, tableJson), ...collectUpsertDeltas(previous, next, deltaTable, tableJson)];
+  if (framed.length > next.order.length) {
+    return void 0;
+  }
+  if (frames !== void 0) {
+    for (const { frame } of framed) {
+      frames.push(frame);
+    }
+  }
+  return framed.map(({ delta }) => delta);
+};
+const trySendFrame = (ws, frame) => {
+  try {
+    ws.send(frame);
+    return true;
+  } catch {
+    return false;
+  }
+};
+const sendDeltaFrames = (ws, subId, deltaFrames, cursorSuffix) => {
+  const idJson = JSON.stringify(subId);
+  let delivered = true;
+  for (const deltaBody of deltaFrames) {
+    if (!trySendFrame(ws, `{"type":"delta","id":${idJson},"delta":${deltaBody}${cursorSuffix}}`)) {
+      delivered = false;
+    }
+  }
+  return delivered;
+};
+const awaitWsDrain = async (ws) => {
+  let attempts = 0;
+  while (attempts < 100) {
+    attempts += 1;
+    const buffered = ws.bufferedAmount;
+    if (typeof buffered !== "number" || buffered < 1048576) {
+      return;
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, 20);
+    });
+  }
+};
+
+export { awaitWsDrain as a, sendDeltaFrames as b, decodeWire as d, encodeWire as e, subscriptionListDeltas as s, trySendFrame as t };

package/dist/packem_shared/subscriptionListDeltas-CXwfoEE_.mjs

@@ -0,0 +1 @@
+export { a as awaitWsDrain, b as sendDeltaFrames, s as subscriptionListDeltas, t as trySendFrame } from './subscription-delivery-Z6nXHvQN.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/do",
-  "version": "1.0.0-alpha.13",
+  "version": "1.0.0-alpha.15",
   "description": "Lunora Durable Objects: ShardDO (SQLite, OCC, hibernated WebSocket subscriptions) and SessionDO",
   "keywords": [
     "cloudflare",

package/dist/packem_shared/subscriptionListDeltas-ce84gpwL.mjs

@@ -1,111 +0,0 @@
-const ROW_ID_FIELD = "_id";
-const DELTA_FALLBACK_TABLE = "__lunora__";
-const readRowId = (row) => {
-  if (typeof row !== "object" || row === null || Array.isArray(row)) {
-    return void 0;
-  }
-  const id = row[ROW_ID_FIELD];
-  return typeof id === "string" ? id : void 0;
-};
-const indexRowsById = (rows) => {
-  const byId = /* @__PURE__ */ new Map();
-  const order = [];
-  for (const row of rows) {
-    const id = readRowId(row);
-    if (id === void 0 || byId.has(id)) {
-      return void 0;
-    }
-    byId.set(id, row);
-    order.push(id);
-  }
-  return { byId, order };
-};
-const survivorsKeepOrder = (previous, next) => {
-  const survivingPrevious = previous.order.filter((id) => next.byId.has(id));
-  const survivingNext = next.order.filter((id) => previous.byId.has(id));
-  if (survivingPrevious.length !== survivingNext.length) {
-    return false;
-  }
-  return survivingPrevious.every((id, index) => survivingNext[index] === id);
-};
-const collectDeleteDeltas = (previous, next, deltaTable, tableJson) => {
-  const out = [];
-  for (const id of previous.order) {
-    if (!next.byId.has(id)) {
-      out.push({
-        delta: { key: id, op: "delete", table: deltaTable },
-        frame: `{"key":${JSON.stringify(id)},"op":"delete","table":${tableJson}}`
-      });
-    }
-  }
-  return out;
-};
-const collectUpsertDeltas = (previous, next, deltaTable, tableJson) => {
-  const out = [];
-  for (const id of next.order) {
-    const nextRow = next.byId.get(id);
-    const previousRow = previous.byId.get(id);
-    const nextFingerprint = JSON.stringify(nextRow);
-    const previousFingerprint = previousRow === void 0 ? void 0 : JSON.stringify(previousRow);
-    if (previousFingerprint === nextFingerprint) {
-      continue;
-    }
-    const op = previousFingerprint === void 0 ? "insert" : "update";
-    out.push({
-      delta: { key: id, op, row: nextRow, table: deltaTable },
-      frame: `{"key":${JSON.stringify(id)},"op":"${op}","row":${nextFingerprint},"table":${tableJson}}`
-    });
-  }
-  return out;
-};
-const subscriptionListDeltas = (previousJson, nextResult, table, frames) => {
-  let parsed;
-  try {
-    parsed = JSON.parse(previousJson);
-  } catch {
-    return void 0;
-  }
-  if (!Array.isArray(parsed) || !Array.isArray(nextResult)) {
-    return void 0;
-  }
-  const previous = indexRowsById(parsed);
-  const next = indexRowsById(nextResult);
-  if (previous === void 0 || next === void 0) {
-    return void 0;
-  }
-  if (!survivorsKeepOrder(previous, next)) {
-    return void 0;
-  }
-  const deltaTable = table === "" ? DELTA_FALLBACK_TABLE : table;
-  const tableJson = JSON.stringify(deltaTable);
-  const framed = [...collectDeleteDeltas(previous, next, deltaTable, tableJson), ...collectUpsertDeltas(previous, next, deltaTable, tableJson)];
-  if (framed.length > next.order.length) {
-    return void 0;
-  }
-  if (frames !== void 0) {
-    for (const { frame } of framed) {
-      frames.push(frame);
-    }
-  }
-  return framed.map(({ delta }) => delta);
-};
-const trySendFrame = (ws, frame) => {
-  try {
-    ws.send(frame);
-    return true;
-  } catch {
-    return false;
-  }
-};
-const sendDeltaFrames = (ws, subId, deltaFrames, cursorSuffix) => {
-  const idJson = JSON.stringify(subId);
-  let delivered = true;
-  for (const deltaBody of deltaFrames) {
-    if (!trySendFrame(ws, `{"type":"delta","id":${idJson},"delta":${deltaBody}${cursorSuffix}}`)) {
-      delivered = false;
-    }
-  }
-  return delivered;
-};
-
-export { sendDeltaFrames, subscriptionListDeltas, trySendFrame };