@lunora/runtime 1.0.0-alpha.34 → 1.0.0-alpha.36

package/dist/packem_shared/createKvCursorStore-g8aA6B4L.mjs

@@ -0,0 +1,165 @@
+const defaultSleep = (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+const sanitizeChange = (raw) => {
+  const table = typeof raw["table"] === "string" ? raw["table"] : "";
+  const rawOp = typeof raw["op"] === "string" ? raw["op"] : "";
+  const op = rawOp === "delete" || rawOp === "insert" || rawOp === "update" ? rawOp : "upsert";
+  const id = typeof raw["id"] === "string" ? raw["id"] : void 0;
+  const documentRow = raw["doc"] && typeof raw["doc"] === "object" ? raw["doc"] : void 0;
+  const seq = typeof raw["seq"] === "number" && Number.isFinite(raw["seq"]) ? raw["seq"] : void 0;
+  const ts = typeof raw["ts"] === "number" && Number.isFinite(raw["ts"]) ? raw["ts"] : void 0;
+  return {
+    op,
+    table,
+    ...documentRow === void 0 ? {} : { doc: documentRow },
+    ...id === void 0 ? {} : { id },
+    ...seq === void 0 ? {} : { seq },
+    ...ts === void 0 ? {} : { ts }
+  };
+};
+const deliverWithRetry = async (sink, batch, maxRetries, initialBackoffMs, maxBackoffMs, sleep) => {
+  let attempt = 0;
+  while (true) {
+    try {
+      await sink.deliver(batch);
+      return;
+    } catch (error) {
+      if (attempt >= maxRetries) {
+        throw error instanceof Error ? error : new Error(String(error));
+      }
+      const delay = Math.min(initialBackoffMs * 2 ** attempt, maxBackoffMs);
+      await sleep(delay);
+      attempt += 1;
+    }
+  }
+};
+const runExportTap = async (options) => {
+  const {
+    coordinator,
+    cursorStore,
+    headers,
+    initialBackoffMs = 100,
+    limit,
+    maxBackoffMs = 5e3,
+    maxRetries = 3,
+    shardDO,
+    sink,
+    sleep = defaultSleep,
+    tables
+  } = options;
+  const priorCursors = await cursorStore.read(sink.name);
+  const feed = await coordinator.orchestrateCdcSync(shardDO, { cursors: priorCursors, headers, limit, tables });
+  const nextCursors = { ...priorCursors };
+  const failures = [];
+  let delivered = 0;
+  let hasMore = false;
+  for (const shard of feed.shards) {
+    if (shard.error) {
+      failures.push({ error: shard.error.message, shardKey: shard.shardKey });
+      hasMore = true;
+      continue;
+    }
+    const rawChanges = shard.changes ?? [];
+    if (rawChanges.length === 0) {
+      nextCursors[shard.shardKey] = shard.cursor;
+      continue;
+    }
+    const changes = rawChanges.map((change) => sanitizeChange(change));
+    const batch = { changes, cursor: shard.cursor, shardKey: shard.shardKey, sink: sink.name };
+    try {
+      await deliverWithRetry(sink, batch, maxRetries, initialBackoffMs, maxBackoffMs, sleep);
+      nextCursors[shard.shardKey] = shard.cursor;
+      delivered += changes.length;
+      if (limit !== void 0 && rawChanges.length >= limit) {
+        hasMore = true;
+      }
+    } catch (error) {
+      failures.push({ error: error instanceof Error ? error.message : String(error), shardKey: shard.shardKey });
+      hasMore = true;
+    }
+  }
+  await cursorStore.write(sink.name, nextCursors);
+  return { cursors: nextCursors, delivered, failures, hasMore, shards: feed.shards.length };
+};
+const defineExportSink = (config) => {
+  if (typeof config.name !== "string" || config.name.length === 0) {
+    throw new Error("defineExportSink: `name` must be a non-empty string");
+  }
+  if (typeof config.deliver !== "function") {
+    throw new TypeError("defineExportSink: `deliver` must be a function");
+  }
+  return { deliver: config.deliver, name: config.name };
+};
+const encodeNdjson = (changes) => `${changes.map((change) => JSON.stringify(change)).join("\n")}
+`;
+const webhookExportSink = (config) => {
+  const fetchImpl = config.fetchImpl ?? ((input, init) => fetch(input, init));
+  return defineExportSink({
+    deliver: async (batch) => {
+      const response = await fetchImpl(config.url, {
+        body: encodeNdjson(batch.changes),
+        headers: {
+          "content-type": "application/x-ndjson",
+          "x-lunora-cursor": String(batch.cursor),
+          "x-lunora-shard": batch.shardKey,
+          "x-lunora-sink": batch.sink,
+          ...config.headers
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(`webhook export sink "${config.name}" returned ${String(response.status)}`);
+      }
+    },
+    name: config.name
+  });
+};
+const r2Sink = (config) => {
+  let prefix = config.prefix ?? "cdc";
+  while (prefix.endsWith("/")) {
+    prefix = prefix.slice(0, -1);
+  }
+  return defineExportSink({
+    deliver: async (batch) => {
+      const key = `${prefix}/${batch.shardKey}/${String(batch.cursor)}.ndjson`;
+      await config.bucket.put(key, encodeNdjson(batch.changes), { httpMetadata: { contentType: "application/x-ndjson" } });
+    },
+    name: config.name
+  });
+};
+const createMemoryCursorStore = () => {
+  const state = {};
+  return {
+    read: (sink) => Promise.resolve({ ...state[sink] }),
+    snapshot: () => structuredClone(state),
+    write: (sink, cursors) => {
+      state[sink] = { ...cursors };
+      return Promise.resolve();
+    }
+  };
+};
+const createKvCursorStore = (kv, options) => {
+  const keyPrefix = options?.keyPrefix ?? "__lunora_source_cursor:export";
+  const keyFor = (sink) => `${keyPrefix}:${sink}`;
+  return {
+    read: async (sink) => {
+      const raw = await kv.get(keyFor(sink), "json");
+      if (raw === null || typeof raw !== "object") {
+        return {};
+      }
+      const cursors = {};
+      for (const [shardKey, value] of Object.entries(raw)) {
+        if (typeof value === "number" && Number.isFinite(value)) {
+          cursors[shardKey] = value;
+        }
+      }
+      return cursors;
+    },
+    write: async (sink, cursors) => {
+      await kv.put(keyFor(sink), JSON.stringify(cursors));
+    }
+  };
+};
+
+export { createKvCursorStore, createMemoryCursorStore, defineExportSink, r2Sink, runExportTap, sanitizeChange, webhookExportSink };

package/dist/packem_shared/emitLogEvent-BlGMnKZK.mjs

@@ -0,0 +1 @@
+export { e as emitLogEvent, a as emitRpcEvent } from './observability--NOFYBFc.mjs';

package/dist/packem_shared/method-guard-Qzw99aCj.mjs

@@ -0,0 +1,3 @@
+const methodGuard = (request, allowed) => allowed.includes(request.method) ? void 0 : new Response(void 0, { headers: { allow: allowed.join(", ") }, status: 405 });
+
+export { methodGuard as m };

package/dist/packem_shared/observability--NOFYBFc.mjs

@@ -0,0 +1,47 @@
+const DEFAULT_TRACE_HEAD_RATE = 1;
+const traceIdToUnitInterval = (traceId) => {
+  const int = Number.parseInt(traceId.slice(0, 8), 16);
+  return Number.isFinite(int) ? int / 4294967296 : 0;
+};
+const isTraceHeadSampled = (traceId, headRate = DEFAULT_TRACE_HEAD_RATE) => {
+  if (headRate >= 1) {
+    return true;
+  }
+  if (headRate <= 0) {
+    return false;
+  }
+  return traceIdToUnitInterval(traceId) < headRate;
+};
+const resolveTraceSampling = (config, traceId) => {
+  return {
+    isTraced: isTraceHeadSampled(traceId, config?.headRate ?? DEFAULT_TRACE_HEAD_RATE),
+    keepErrors: config?.alwaysSampleErrors ?? true
+  };
+};
+const shouldExportTrace = (decision, traceHasError) => {
+  return decision.isTraced || decision.keepErrors && traceHasError;
+};
+
+const emitRpcEvent = (sink, event, context, sampling) => {
+  if (!sink?.onRpc) {
+    return;
+  }
+  if (sampling !== void 0 && event.traceId !== void 0 && !shouldExportTrace(resolveTraceSampling(sampling, event.traceId), !event.ok)) {
+    return;
+  }
+  try {
+    sink.onRpc(event, context);
+  } catch {
+  }
+};
+const emitLogEvent = (sink, event, context) => {
+  if (!sink?.onLog) {
+    return;
+  }
+  try {
+    sink.onLog(event, context);
+  } catch {
+  }
+};
+
+export { emitRpcEvent as a, emitLogEvent as e, resolveTraceSampling as r };

package/dist/packem_shared/otlp-resource-Dow6-F_u.mjs

@@ -0,0 +1,163 @@
+const OTLP_SEVERITY = {
+  debug: 5,
+  // DEBUG
+  error: 17,
+  // ERROR
+  fatal: 21,
+  // FATAL
+  info: 9,
+  // INFO
+  log: 9,
+  // INFO
+  trace: 1,
+  // TRACE
+  warn: 13
+  // WARN
+};
+const otlpUnixNano = (ms) => `${String(Math.round(ms))}000000`;
+const otlpRandomHex = (bytes) => {
+  const buffer = new Uint8Array(bytes);
+  crypto.getRandomValues(buffer);
+  let hex = "";
+  for (const byte of buffer) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return hex;
+};
+const HEX_ONLY = /^[0-9a-f]+$/;
+const buildTraceparent = (traceId, spanId, sampled = true) => `00-${traceId}-${spanId}-${sampled ? "01" : "00"}`;
+const parseTraceparent = (header) => {
+  if (header === null || header === void 0) {
+    return void 0;
+  }
+  const parts = header.trim().toLowerCase().split("-");
+  const [version, traceId, parentSpanId, flags] = parts;
+  if (parts.length < 4 || version === void 0 || version.length !== 2 || !HEX_ONLY.test(version) || version === "ff" || // Version 00 forbids trailing fields; only a future version may carry them.
+  version === "00" && parts.length !== 4 || traceId === void 0 || parentSpanId === void 0 || flags === void 0 || flags.length !== 2 || !HEX_ONLY.test(flags) || traceId.length !== 32 || parentSpanId.length !== 16 || !HEX_ONLY.test(traceId) || !HEX_ONLY.test(parentSpanId) || traceId === "00000000000000000000000000000000" || parentSpanId === "0000000000000000") {
+    return void 0;
+  }
+  return { parentSpanId, sampled: (Number.parseInt(flags, 16) & 1) === 1, traceId };
+};
+const encodeAttribute = (key, value) => {
+  if (typeof value === "boolean") {
+    return { key, value: { boolValue: value } };
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      return { key, value: { stringValue: String(value) } };
+    }
+    return Number.isSafeInteger(value) ? { key, value: { intValue: String(value) } } : { key, value: { doubleValue: value } };
+  }
+  return { key, value: { stringValue: value } };
+};
+const mergeHeaders = (defaults, overrides, token) => {
+  const merged = {};
+  const seen = /* @__PURE__ */ new Map();
+  const put = (name, value) => {
+    const lower = name.toLowerCase();
+    const existing = seen.get(lower);
+    if (existing === void 0) {
+      seen.set(lower, name);
+      merged[name] = value;
+    } else {
+      merged[existing] = value;
+    }
+  };
+  for (const [name, value] of Object.entries(defaults)) {
+    put(name, value);
+  }
+  for (const [name, value] of Object.entries(overrides ?? {})) {
+    put(name, value);
+  }
+  if (token !== void 0 && token.length > 0) {
+    put("authorization", `Bearer ${token}`);
+  }
+  return merged;
+};
+const buildResourceAttributes = (serviceName, extra) => {
+  const merged = { "service.name": serviceName };
+  for (const [key, value] of Object.entries(extra ?? {})) {
+    merged[key] = value;
+  }
+  return Object.entries(merged).map(([key, value]) => encodeAttribute(key, value));
+};
+const wrapResourceSpans = (span, scopeName, serviceName, resourceAttributes) => {
+  return {
+    resourceSpans: [
+      {
+        resource: { attributes: buildResourceAttributes(serviceName, resourceAttributes) },
+        scopeSpans: [{ scope: { name: scopeName }, spans: [span] }]
+      }
+    ]
+  };
+};
+const wrapResourceLogs = (logRecord, scopeName, serviceName, resourceAttributes) => {
+  return {
+    resourceLogs: [
+      {
+        resource: { attributes: buildResourceAttributes(serviceName, resourceAttributes) },
+        scopeLogs: [{ logRecords: [logRecord], scope: { name: scopeName } }]
+      }
+    ]
+  };
+};
+const wrapResourceMetrics = (metric, scopeName, serviceName, resourceAttributes) => {
+  return {
+    resourceMetrics: [
+      {
+        resource: { attributes: buildResourceAttributes(serviceName, resourceAttributes) },
+        scopeMetrics: [{ metrics: [metric], scope: { name: scopeName } }]
+      }
+    ]
+  };
+};
+
+const readerFromRecord = (environment) => (key) => {
+  const value = environment?.[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+};
+const stringProperty = (object, key) => {
+  if (typeof object !== "object" || object === null) {
+    return void 0;
+  }
+  const value = object[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+};
+const detectServiceResource = (read) => {
+  const detected = {};
+  const serviceVersion = read("SERVICE_VERSION") ?? read("CF_VERSION_METADATA") ?? read("VERCEL_GIT_COMMIT_SHA") ?? read("GITHUB_SHA") ?? read("COMMIT_SHA");
+  if (serviceVersion !== void 0) {
+    detected["service.version"] = serviceVersion;
+  }
+  const deploymentEnvironment = read("DEPLOYMENT_ENVIRONMENT") ?? read("ENVIRONMENT") ?? read("NODE_ENV");
+  if (deploymentEnvironment !== void 0) {
+    detected["deployment.environment"] = deploymentEnvironment;
+  }
+  return detected;
+};
+const detectCloudflareResource = (read, cf) => {
+  const isCloudflare = cf !== void 0 || read("CLOUDFLARE") !== void 0 || read("CF_ACCOUNT_ID") !== void 0;
+  if (!isCloudflare) {
+    return {};
+  }
+  const detected = { "cloud.provider": "cloudflare" };
+  const colo = stringProperty(cf, "colo") ?? read("CF_COLO") ?? read("CLOUDFLARE_COLO");
+  if (colo !== void 0) {
+    detected["cloud.region"] = colo;
+  }
+  return detected;
+};
+const mergeResourceAttributes = (...bags) => {
+  const merged = {};
+  for (const bag of bags) {
+    if (bag === void 0) {
+      continue;
+    }
+    for (const [key, value] of Object.entries(bag)) {
+      merged[key] = value;
+    }
+  }
+  return merged;
+};
+
+export { OTLP_SEVERITY as O, detectServiceResource as a, buildTraceparent as b, wrapResourceMetrics as c, detectCloudflareResource as d, wrapResourceLogs as e, encodeAttribute as f, otlpUnixNano as g, mergeHeaders as h, mergeResourceAttributes as m, otlpRandomHex as o, parseTraceparent as p, readerFromRecord as r, wrapResourceSpans as w };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/runtime",
-  "version": "1.0.0-alpha.34",
+  "version": "1.0.0-alpha.36",
   "description": "Lunora Worker runtime: the RPC router, shard resolver, and query coordinator",
   "keywords": [
     "cloudflare",
@@ -46,8 +46,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/bindings": "1.0.0-alpha.9",
-    "@lunora/errors": "1.0.0-alpha.6"
+    "@lunora/bindings": "1.0.0-alpha.10",
+    "@lunora/errors": "1.0.0-alpha.7"
   },
   "engines": {
     "node": "^22.15.0 || >=24.11.0"

package/dist/packem_shared/emitLogEvent-pEdtqAK8.mjs

@@ -1,20 +0,0 @@
-const emitRpcEvent = (sink, event, context) => {
-  if (!sink?.onRpc) {
-    return;
-  }
-  try {
-    sink.onRpc(event, context);
-  } catch {
-  }
-};
-const emitLogEvent = (sink, event, context) => {
-  if (!sink?.onLog) {
-    return;
-  }
-  try {
-    sink.onLog(event, context);
-  } catch {
-  }
-};
-
-export { emitLogEvent, emitRpcEvent };

package/dist/packem_shared/otlp-DOLuy1Aj.mjs

@@ -1,95 +0,0 @@
-const OTLP_SEVERITY = {
-  debug: 5,
-  // DEBUG
-  error: 17,
-  // ERROR
-  fatal: 21,
-  // FATAL
-  info: 9,
-  // INFO
-  log: 9,
-  // INFO
-  trace: 1,
-  // TRACE
-  warn: 13
-  // WARN
-};
-const otlpUnixNano = (ms) => `${String(Math.round(ms))}000000`;
-const otlpRandomHex = (bytes) => {
-  const buffer = new Uint8Array(bytes);
-  crypto.getRandomValues(buffer);
-  let hex = "";
-  for (const byte of buffer) {
-    hex += byte.toString(16).padStart(2, "0");
-  }
-  return hex;
-};
-const buildTraceparent = (traceId, spanId) => `00-${traceId}-${spanId}-01`;
-const encodeAttribute = (key, value) => {
-  if (typeof value === "boolean") {
-    return { key, value: { boolValue: value } };
-  }
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      return { key, value: { stringValue: String(value) } };
-    }
-    return Number.isSafeInteger(value) ? { key, value: { intValue: String(value) } } : { key, value: { doubleValue: value } };
-  }
-  return { key, value: { stringValue: value } };
-};
-const mergeHeaders = (defaults, overrides, token) => {
-  const merged = {};
-  const seen = /* @__PURE__ */ new Map();
-  const put = (name, value) => {
-    const lower = name.toLowerCase();
-    const existing = seen.get(lower);
-    if (existing === void 0) {
-      seen.set(lower, name);
-      merged[name] = value;
-    } else {
-      merged[existing] = value;
-    }
-  };
-  for (const [name, value] of Object.entries(defaults)) {
-    put(name, value);
-  }
-  for (const [name, value] of Object.entries(overrides ?? {})) {
-    put(name, value);
-  }
-  if (token !== void 0 && token.length > 0) {
-    put("authorization", `Bearer ${token}`);
-  }
-  return merged;
-};
-const wrapResourceSpans = (span, scopeName, serviceName) => {
-  return {
-    resourceSpans: [
-      {
-        resource: { attributes: [encodeAttribute("service.name", serviceName)] },
-        scopeSpans: [{ scope: { name: scopeName }, spans: [span] }]
-      }
-    ]
-  };
-};
-const wrapResourceLogs = (logRecord, scopeName, serviceName) => {
-  return {
-    resourceLogs: [
-      {
-        resource: { attributes: [encodeAttribute("service.name", serviceName)] },
-        scopeLogs: [{ logRecords: [logRecord], scope: { name: scopeName } }]
-      }
-    ]
-  };
-};
-const wrapResourceMetrics = (metric, scopeName, serviceName) => {
-  return {
-    resourceMetrics: [
-      {
-        resource: { attributes: [encodeAttribute("service.name", serviceName)] },
-        scopeMetrics: [{ metrics: [metric], scope: { name: scopeName } }]
-      }
-    ]
-  };
-};
-
-export { OTLP_SEVERITY as O, wrapResourceMetrics as a, buildTraceparent as b, wrapResourceLogs as c, otlpUnixNano as d, encodeAttribute as e, mergeHeaders as m, otlpRandomHex as o, wrapResourceSpans as w };