@lunora/do 1.0.0-alpha.4 → 1.0.0-alpha.41

package/dist/packem_shared/stableStringify-mC40mZts.mjs

@@ -0,0 +1,40 @@
+const compareKeys = (a, b) => {
+  if (a < b) {
+    return -1;
+  }
+  return a > b ? 1 : 0;
+};
+const stableStringify = (value) => {
+  if (value === void 0) {
+    return "null";
+  }
+  if (typeof value === "bigint") {
+    throw new TypeError("stableStringify: cannot use a bigint in a stable JSON cache key — pass it as a string, or use stableWireKey");
+  }
+  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 stable JSON cache key — only plain objects, arrays, and JSON primitives are supported (wire-typed values key via stableWireKey)`
+    );
+  }
+  const record = value;
+  const keys = Object.keys(record).toSorted(compareKeys);
+  const parts = [];
+  for (const key of keys) {
+    const raw = record[key];
+    if (raw === void 0) {
+      continue;
+    }
+    parts.push(`${JSON.stringify(key)}:${stableStringify(raw)}`);
+  }
+  return `{${parts.join(",")}}`;
+};
+
+export { stableStringify };

package/dist/packem_shared/stableWireKey-DKuXO7T5.mjs

@@ -0,0 +1,6 @@
+import { stableStringify } from './stableStringify-mC40mZts.mjs';
+import { e as encodeWire } from './wire-codec-CzQc1pvf.mjs';
+
+const stableWireKey = (value) => stableStringify(encodeWire(value));
+
+export { stableWireKey };

package/dist/packem_shared/subscriptionListDeltas-CT76bYny.mjs

@@ -0,0 +1,126 @@
+import { e as encodeWire } from './wire-codec-CzQc1pvf.mjs';
+
+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, sendDeltaFrames, subscriptionListDeltas, trySendFrame };

package/dist/packem_shared/wire-codec-CzQc1pvf.mjs

@@ -0,0 +1,225 @@
+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 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 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 });
+          }
+          const props = decodeWire(value[4], depth + 1);
+          for (const key of Object.keys(props)) {
+            if (key === UNSAFE_KEY) {
+              Object.defineProperty(error, key, { configurable: true, enumerable: true, value: props[key], writable: true });
+            } else {
+              error[key] = props[key];
+            }
+          }
+          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;
+};
+
+export { decodeWire as d, encodeWire as e };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/do",
-  "version": "1.0.0-alpha.4",
+  "version": "1.0.0-alpha.41",
   "description": "Lunora Durable Objects: ShardDO (SQLite, OCC, hibernated WebSocket subscriptions) and SessionDO",
   "keywords": [
     "cloudflare",
@@ -25,7 +25,7 @@
     "directory": "packages/do"
   },
   "files": [
-    "dist",
+    "./dist",
     "README.md",
     "LICENSE.md",
     "__assets__"
@@ -46,7 +46,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@visulima/redact": "3.0.0-alpha.14",
+    "@lunora/errors": "1.0.0-alpha.7",
+    "@lunora/fingerprint": "1.0.0-alpha.3",
+    "@visulima/redact": "3.0.0",
     "drizzle-orm": "^0.45.2"
   },
   "engines": {

package/dist/packem_shared/NotFoundError-CMuMZt81.mjs

@@ -1,10 +0,0 @@
-class NotFoundError extends Error {
-  code = "NOT_FOUND";
-  status = 404;
-  constructor(message = "Document not found") {
-    super(message);
-    this.name = "NotFoundError";
-  }
-}
-
-export { NotFoundError as default };

package/dist/packem_shared/RANK_TIEBREAK-C6blLR5K.mjs

@@ -1 +0,0 @@
-export { R as RANK_TIEBREAK, e as encodePartitionKey, m as matchesRankStaticWhere, c as rankKeyFromDoc, r as rankTableName, a as resolveRankPartition, s as sortColumnName } from './rank-CrkEIpF4.mjs';