@lunora/runtime 1.0.0-alpha.3 → 1.0.0-alpha.30

package/dist/index.mjs

@@ -1,13 +1,15 @@
 export { toAirbyteMessages, toFivetranResponse } from './packem_shared/toAirbyteMessages-DrHdplb4.mjs';
-export { composeWorker, createWorker, defineRpcEnvelope, withFrameworkWorker } from './packem_shared/composeWorker-CjF1xUIO.mjs';
-export { createCrossShardRelationCapabilities } from './packem_shared/createCrossShardRelationCapabilities-C0KOf7er.mjs';
-export { DEFAULT_REGISTRY_CACHE_TTL_MS, SHARD_REGISTRY_DO_NAME, createDynamicShardRegistry } from './packem_shared/DEFAULT_REGISTRY_CACHE_TTL_MS-BpCwo_mo.mjs';
-export { LunoraError, toErrorResponse } from './packem_shared/LunoraError-CL0aOtpo.mjs';
+export { composeWorker, createLunoraHandler, createWorker, defineRpcEnvelope, resolveLunoraOptions, withFrameworkWorker } from './packem_shared/composeWorker-CqUlK17X.mjs';
+export { createCrossShardRelationCapabilities } from './packem_shared/createCrossShardRelationCapabilities-CbcWjkAn.mjs';
+export { DEFAULT_REGISTRY_CACHE_TTL_MS, SHARD_REGISTRY_DO_NAME, createDynamicShardRegistry } from './packem_shared/DEFAULT_REGISTRY_CACHE_TTL_MS-B3pA7aXp.mjs';
+export { LunoraError, toErrorResponse } from './packem_shared/LunoraError-Bpb9EFJ3.mjs';
 export { emitLogEvent, emitRpcEvent } from './packem_shared/emitLogEvent-pEdtqAK8.mjs';
-export { analyticsEngineSink, combineSinks, consoleSink, sentrySink, webhookSink } from './packem_shared/analyticsEngineSink-DqEvrQs0.mjs';
-export { createQueryCoordinator, createStaticShardRegistry, mergeStrategyForAggregate } from './packem_shared/createQueryCoordinator-DbxC7iUz.mjs';
-export { resolveShard } from './packem_shared/resolveShard-DDkzWtrU.mjs';
-export { decorateResponse, enforceOrigin, handleCorsPreflight, resolveSecurity } from './packem_shared/decorateResponse-DbISh_Wi.mjs';
+export { analyticsEngineSink, combineSinks, consoleSink, otlpSink, pipelineLogSink, sentrySink, webhookSink } from './packem_shared/analyticsEngineSink-DWUhiYHC.mjs';
+export { createQueryCoordinator, createStaticShardRegistry, mergeStrategyForAggregate } from './packem_shared/createQueryCoordinator-DNCJzOZE.mjs';
+export { applyJurisdiction, resolveShard } from './packem_shared/applyJurisdiction-BkZtTkct.mjs';
+export { decorateResponse, enforceOrigin, handleCorsPreflight, resolveSecurity } from './packem_shared/decorateResponse-DRWQFNhF.mjs';
+export { NOOP_EXECUTION_CONTEXT } from './packem_shared/NOOP_EXECUTION_CONTEXT-CCTu0Bf1.mjs';
+export { composeIdentityResolvers, routeIdentityResolvers } from './packem_shared/composeIdentityResolvers-XGjO7V1J.mjs';
 
 const VERSION = "0.0.0";
 

package/dist/packem_shared/{DEFAULT_REGISTRY_CACHE_TTL_MS-BpCwo_mo.mjs → DEFAULT_REGISTRY_CACHE_TTL_MS-B3pA7aXp.mjs}

@@ -1,3 +1,6 @@
+import { LunoraError } from './LunoraError-Bpb9EFJ3.mjs';
+import { applyJurisdiction } from './applyJurisdiction-BkZtTkct.mjs';
+
 const SHARD_REGISTRY_DO_NAME = "__lunora_shard_registry__";
 const DEFAULT_REGISTRY_CACHE_TTL_MS = 3e4;
 const REGISTRY_BASE_URL = "https://shard-registry.internal";
@@ -10,9 +13,10 @@ const createDynamicShardRegistry = (options) => {
   const instanceName = options.instanceName ?? SHARD_REGISTRY_DO_NAME;
   const cacheTtlMs = options.cacheTtlMs ?? DEFAULT_REGISTRY_CACHE_TTL_MS;
   const cache = /* @__PURE__ */ new Map();
+  const namespace = applyJurisdiction(options.namespace, options.jurisdiction);
   let cachedStub;
   const stub = () => {
-    cachedStub ??= options.namespace.get(options.namespace.idFromName(instanceName));
+    cachedStub ??= namespace.get(namespace.idFromName(instanceName));
     return cachedStub;
   };
   const post = async (path, body) => stub().fetch(
@@ -39,7 +43,7 @@ const createDynamicShardRegistry = (options) => {
       }
       const response = await get(`/list?table=${encodeURIComponent(table)}`);
       if (!response.ok) {
-        throw new Error(`shard registry /list returned ${String(response.status)}`);
+        throw new LunoraError(`shard registry /list returned ${String(response.status)}`);
       }
       const { shardKeys } = await decodeJson(response);
       if (cacheTtlMs > 0) {
@@ -50,14 +54,14 @@ const createDynamicShardRegistry = (options) => {
     async register(table, shardKey) {
       const response = await post("/register", { shardKey, table });
       if (!response.ok) {
-        throw new Error(`shard registry /register returned ${String(response.status)}`);
+        throw new LunoraError(`shard registry /register returned ${String(response.status)}`);
       }
       cache.delete(table);
     },
     async snapshot() {
       const response = await get("/snapshot");
       if (!response.ok) {
-        throw new Error(`shard registry /snapshot returned ${String(response.status)}`);
+        throw new LunoraError(`shard registry /snapshot returned ${String(response.status)}`);
       }
       const { tables } = await decodeJson(response);
       return tables;
@@ -65,7 +69,7 @@ const createDynamicShardRegistry = (options) => {
     async unregister(table, shardKey) {
       const response = await post("/unregister", { shardKey, table });
       if (!response.ok) {
-        throw new Error(`shard registry /unregister returned ${String(response.status)}`);
+        throw new LunoraError(`shard registry /unregister returned ${String(response.status)}`);
       }
       cache.delete(table);
     }

package/dist/packem_shared/LunoraError-Bpb9EFJ3.mjs

@@ -0,0 +1,22 @@
+import { LunoraError as LunoraError$1, toErrorBody } from '@lunora/errors';
+
+const toErrorResponse = (error) => {
+  const { body, redacted, status } = toErrorBody(error, { fallbackCode: "INTERNAL", redactedMessage: "Internal error" });
+  if (redacted) {
+    console.error("[lunora] internal error:", error);
+  }
+  return Response.json({ error: body }, {
+    headers: { "content-type": "application/json" },
+    status
+  });
+};
+class LunoraError extends LunoraError$1 {
+  constructor(message, options) {
+    super(options?.code ?? "INTERNAL", message, { cause: options?.cause, status: options?.status });
+  }
+  toResponse() {
+    return toErrorResponse(this);
+  }
+}
+
+export { LunoraError, toErrorResponse };

package/dist/packem_shared/NOOP_EXECUTION_CONTEXT-CCTu0Bf1.mjs

@@ -0,0 +1,8 @@
+const NOOP_EXECUTION_CONTEXT = {
+  passThroughOnException: () => {
+  },
+  waitUntil: () => {
+  }
+};
+
+export { NOOP_EXECUTION_CONTEXT };

package/dist/packem_shared/analyticsEngineSink-DWUhiYHC.mjs

@@ -0,0 +1,366 @@
+import { m as mergeHeaders, w as wrapResourceSpans, o as otlpRandomHex, a as wrapResourceMetrics, c as wrapResourceLogs, e as encodeAttribute, O as OTLP_SEVERITY, d as otlpUnixNano } from './otlp-DOLuy1Aj.mjs';
+
+const stringifyFieldValue = (value) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+};
+const coerceFieldValue = (value) => typeof value === "boolean" || typeof value === "number" || typeof value === "string" ? value : stringifyFieldValue(value);
+
+const shouldSkip = (event, onlyErrors) => onlyErrors === true && event.ok;
+const otlpTraceBody = (event, serviceName, endMs) => {
+  const attributes = [encodeAttribute("lunora.function_path", event.functionPath), encodeAttribute("lunora.ok", event.ok)];
+  if (event.shardKey !== void 0) {
+    attributes.push(encodeAttribute("lunora.shard_key", event.shardKey));
+  }
+  if (event.error) {
+    attributes.push(encodeAttribute("error.type", event.error.code), encodeAttribute("lunora.error_status", event.error.status));
+  }
+  if (event.fanOut) {
+    attributes.push(
+      encodeAttribute("lunora.fanout.table", event.fanOut.table),
+      encodeAttribute("lunora.fanout.shards", event.fanOut.shards),
+      encodeAttribute("lunora.fanout.failed", event.fanOut.failed)
+    );
+  }
+  const span = {
+    attributes,
+    endTimeUnixNano: otlpUnixNano(endMs),
+    // SPAN_KIND_SERVER — a dispatched RPC is server-side request handling.
+    kind: 2,
+    name: event.functionPath,
+    // Reuse the dispatch's trace context when the runtime set it (so this span
+    // shares the id it propagated as `traceparent`); else mint fresh ids.
+    spanId: event.spanId ?? otlpRandomHex(8),
+    startTimeUnixNano: otlpUnixNano(endMs - event.durationMs),
+    // STATUS_CODE_OK (1) / STATUS_CODE_ERROR (2).
+    status: event.ok ? { code: 1 } : { code: 2, message: event.error?.message ?? "" },
+    traceId: event.traceId ?? otlpRandomHex(16)
+  };
+  return wrapResourceSpans(span, "@lunora/runtime", serviceName);
+};
+const encodeSignalAttributes = (reserved, caller) => {
+  const byKey = /* @__PURE__ */ new Map([["lunora.function_path", encodeAttribute("lunora.function_path", reserved.functionPath)]]);
+  if (reserved.shardKey !== void 0) {
+    byKey.set("lunora.shard_key", encodeAttribute("lunora.shard_key", reserved.shardKey));
+  }
+  if (reserved.userId !== void 0) {
+    byKey.set("lunora.user_id", encodeAttribute("lunora.user_id", reserved.userId));
+  }
+  if (reserved.errorType !== void 0) {
+    byKey.set("error.type", encodeAttribute("error.type", reserved.errorType));
+  }
+  for (const [key, value] of Object.entries(caller ?? {})) {
+    byKey.set(key, encodeAttribute(key, coerceFieldValue(value)));
+  }
+  return [...byKey.values()];
+};
+const otlpSpanBody = (event, serviceName) => {
+  const span = {
+    attributes: encodeSignalAttributes(
+      { errorType: event.error?.type, functionPath: event.functionPath, shardKey: event.shardKey, userId: event.userId },
+      event.attributes
+    ),
+    endTimeUnixNano: otlpUnixNano(event.startTs + event.durationMs),
+    // Always SPAN_KIND_INTERNAL: only `ctx.trace` spans reach a sink. The
+    // synthetic dispatch span is buffered for the Studio waterfall and never
+    // exported, because the runtime already emits that dispatch to `onRpc` as
+    // a SERVER span — encoding it here too would duplicate it in every trace.
+    kind: 1,
+    name: event.name,
+    parentSpanId: event.parentSpanId,
+    spanId: event.spanId,
+    startTimeUnixNano: otlpUnixNano(event.startTs),
+    // STATUS_CODE_OK (1) / STATUS_CODE_ERROR (2).
+    status: event.ok ? { code: 1 } : { code: 2, message: event.error?.message ?? "" },
+    traceId: event.traceId
+  };
+  return wrapResourceSpans(span, "@lunora/runtime", serviceName);
+};
+const otlpMetricBody = (event, serviceName) => {
+  const timeUnixNano = otlpUnixNano(event.ts);
+  const attributes = encodeSignalAttributes({ functionPath: event.functionPath, shardKey: event.shardKey }, event.attributes);
+  const dataPoint = { asDouble: event.value, attributes, timeUnixNano };
+  if (event.kind === "gauge") {
+    return wrapResourceMetrics({ gauge: { dataPoints: [dataPoint] }, name: event.name }, "@lunora/runtime", serviceName);
+  }
+  if (event.kind === "histogram") {
+    return wrapResourceMetrics(
+      {
+        histogram: {
+          aggregationTemporality: 1,
+          dataPoints: [
+            {
+              attributes,
+              bucketCounts: ["1"],
+              count: "1",
+              explicitBounds: [],
+              max: event.value,
+              min: event.value,
+              // `startTimeUnixNano` omitted for the same reason as
+              // the Sum data point above — see the comment there.
+              sum: event.value,
+              timeUnixNano
+            }
+          ]
+        },
+        name: event.name
+      },
+      "@lunora/runtime",
+      serviceName
+    );
+  }
+  return wrapResourceMetrics(
+    { name: event.name, sum: { aggregationTemporality: 1, dataPoints: [dataPoint], isMonotonic: true } },
+    "@lunora/runtime",
+    serviceName
+  );
+};
+const otlpLogBody = (event, serviceName) => {
+  const logRecord = {
+    // Caller-supplied structured fields become log-record attributes so a
+    // pipeline can filter/index on them; precedence per `encodeSignalAttributes`.
+    attributes: encodeSignalAttributes({ functionPath: event.functionPath, shardKey: event.shardKey, userId: event.userId }, event.fields),
+    body: { stringValue: event.message },
+    severityNumber: OTLP_SEVERITY[event.level],
+    severityText: event.level.toUpperCase(),
+    timeUnixNano: otlpUnixNano(event.ts)
+  };
+  if (event.traceId !== void 0) {
+    logRecord.traceId = event.traceId;
+  }
+  if (event.spanId !== void 0) {
+    logRecord.spanId = event.spanId;
+  }
+  return wrapResourceLogs(logRecord, "@lunora/runtime", serviceName);
+};
+const otlpPost = (url, body, headers, context) => {
+  try {
+    const sent = fetch(url, { body: JSON.stringify(body), headers, method: "POST" }).catch(() => {
+    });
+    if (context?.waitUntil) {
+      context.waitUntil(sent);
+    }
+  } catch {
+  }
+};
+const consoleSink = (options = {}) => {
+  const { onlyErrors } = options;
+  return {
+    onLog: (event) => {
+      if (event.level === "error" || event.level === "fatal") {
+        console.error("[lunora:log]", event.functionPath, event.message);
+      } else {
+        console.log("[lunora:log]", event.functionPath, event.message);
+      }
+    },
+    onMetric: (event) => {
+      console.log("[lunora:metric]", `${event.name}=${String(event.value)}`, event.kind, event.functionPath);
+    },
+    onRpc: (event) => {
+      if (shouldSkip(event, onlyErrors)) {
+        return;
+      }
+      if (event.ok) {
+        console.log("[lunora:rpc]", event);
+      } else {
+        console.error("[lunora:rpc]", event);
+      }
+    },
+    onSpan: (event) => {
+      const status = event.ok ? "ok" : `error ${event.error?.type ?? ""}`.trim();
+      console.log("[lunora:span]", event.name, `${String(event.durationMs)}ms`, status, event.functionPath);
+    }
+  };
+};
+const webhookSink = (options) => {
+  const { headers, onlyErrors, transform, transformLog, url } = options;
+  const mergedHeaders = mergeHeaders({ "content-type": "application/json" }, headers);
+  const post = (payload, context) => {
+    try {
+      const sent = fetch(url, { body: JSON.stringify(payload), headers: mergedHeaders, method: "POST" }).catch(() => {
+      });
+      if (context?.waitUntil) {
+        context.waitUntil(sent);
+      }
+    } catch {
+    }
+  };
+  return {
+    onLog: (event, context) => {
+      let payload = event;
+      if (transformLog) {
+        try {
+          payload = transformLog(event);
+        } catch {
+          return;
+        }
+      }
+      if (payload === null || payload === void 0) {
+        return;
+      }
+      post(payload, context);
+    },
+    onRpc: (event, context) => {
+      if (shouldSkip(event, onlyErrors)) {
+        return;
+      }
+      try {
+        let payload = event;
+        if (transform) {
+          try {
+            payload = transform(event);
+          } catch {
+            return;
+          }
+        }
+        if (payload === null || payload === void 0) {
+          return;
+        }
+        post(payload, context);
+      } catch {
+      }
+    }
+  };
+};
+const sentrySink = (options) => {
+  const { capture, captureLog } = options;
+  const onlyErrors = options.onlyErrors ?? true;
+  return {
+    // Only forward log lines when the caller wired `captureLog`; otherwise
+    // `ctx.log` output stays out of Sentry.
+    onLog: captureLog ? (event) => {
+      try {
+        captureLog(event);
+      } catch {
+      }
+    } : void 0,
+    onRpc: (event) => {
+      if (shouldSkip(event, onlyErrors)) {
+        return;
+      }
+      try {
+        capture(event);
+      } catch {
+      }
+    }
+  };
+};
+const analyticsEngineSink = (options) => {
+  const { dataset, onlyErrors } = options;
+  return {
+    onRpc: (event) => {
+      if (shouldSkip(event, onlyErrors)) {
+        return;
+      }
+      try {
+        dataset.writeDataPoint({
+          blobs: [event.functionPath, event.ok ? "ok" : "error", event.shardKey ?? "", event.error?.code ?? "", event.fanOut?.table ?? ""],
+          doubles: [event.durationMs, event.ok ? 0 : 1, event.fanOut?.shards ?? 0, event.fanOut?.failed ?? 0],
+          indexes: [event.functionPath]
+        });
+      } catch {
+      }
+    }
+  };
+};
+const pipelineLogSink = (options) => {
+  const { pipeline } = options;
+  return {
+    onLog: (event, context) => {
+      try {
+        const record = {
+          functionPath: event.functionPath,
+          level: event.level,
+          message: event.message,
+          ts: event.ts
+        };
+        if (event.fields) {
+          record.fields = event.fields;
+        }
+        if (event.shardKey !== void 0) {
+          record.shardKey = event.shardKey;
+        }
+        if (event.userId !== void 0) {
+          record.userId = event.userId;
+        }
+        if (event.traceId !== void 0) {
+          record.traceId = event.traceId;
+        }
+        if (event.spanId !== void 0) {
+          record.spanId = event.spanId;
+        }
+        const sent = pipeline.send([record]).catch(() => {
+        });
+        if (context?.waitUntil) {
+          context.waitUntil(sent);
+        }
+      } catch {
+      }
+    }
+  };
+};
+const otlpSink = (options) => {
+  const { endpoint, headers, onlyErrors, token } = options;
+  const serviceName = options.serviceName ?? "lunora";
+  let base = endpoint;
+  while (base.endsWith("/")) {
+    base = base.slice(0, -1);
+  }
+  const tracesUrl = `${base}/v1/traces`;
+  const logsUrl = `${base}/v1/logs`;
+  const metricsUrl = `${base}/v1/metrics`;
+  const mergedHeaders = mergeHeaders({ "content-type": "application/json" }, headers, token);
+  return {
+    onLog: (event, context) => {
+      otlpPost(logsUrl, otlpLogBody(event, serviceName), mergedHeaders, context);
+    },
+    onMetric: (event, context) => {
+      otlpPost(metricsUrl, otlpMetricBody(event, serviceName), mergedHeaders, context);
+    },
+    onRpc: (event, context) => {
+      if (shouldSkip(event, onlyErrors)) {
+        return;
+      }
+      otlpPost(tracesUrl, otlpTraceBody(event, serviceName, Date.now()), mergedHeaders, context);
+    },
+    onSpan: (event, context) => {
+      otlpPost(tracesUrl, otlpSpanBody(event, serviceName), mergedHeaders, context);
+    }
+  };
+};
+const combineSinks = (...sinks) => {
+  const fanOut = (method, event, context) => {
+    for (const sink of sinks) {
+      const handler = sink[method];
+      if (!handler) {
+        continue;
+      }
+      try {
+        handler.call(sink, event, context);
+      } catch {
+      }
+    }
+  };
+  return {
+    onLog: (event, context) => {
+      fanOut("onLog", event, context);
+    },
+    onMetric: (event, context) => {
+      fanOut("onMetric", event, context);
+    },
+    onRpc: (event, context) => {
+      fanOut("onRpc", event, context);
+    },
+    onSpan: (event, context) => {
+      fanOut("onSpan", event, context);
+    }
+  };
+};
+
+export { analyticsEngineSink, combineSinks, consoleSink, otlpSink, pipelineLogSink, sentrySink, webhookSink };

package/dist/packem_shared/applyJurisdiction-BkZtTkct.mjs

@@ -0,0 +1,20 @@
+const applyJurisdiction = (namespace, jurisdiction) => {
+  if (jurisdiction === void 0) {
+    return namespace;
+  }
+  if (typeof namespace.jurisdiction !== "function") {
+    throw new TypeError(
+      `@lunora/runtime: Durable Object namespace does not support jurisdiction("${jurisdiction}") — update @cloudflare/workers-types or remove the jurisdiction option`
+    );
+  }
+  return namespace.jurisdiction(jurisdiction);
+};
+const resolveShard = (namespace, shardKey) => {
+  if (typeof namespace.getByName === "function") {
+    return namespace.getByName(shardKey);
+  }
+  const id = namespace.idFromName(shardKey);
+  return namespace.get(id);
+};
+
+export { applyJurisdiction, resolveShard };

package/dist/packem_shared/composeIdentityResolvers-XGjO7V1J.mjs

@@ -0,0 +1,55 @@
+import { LunoraError } from './LunoraError-Bpb9EFJ3.mjs';
+
+const composeIdentityResolvers = (resolvers, options = {}) => {
+  const onError = options.onError ?? "fail-closed";
+  return async (request, env) => {
+    for (const resolver of resolvers) {
+      let resolved;
+      try {
+        resolved = await resolver(request, env);
+      } catch (error) {
+        if (onError === "skip") {
+          continue;
+        }
+        throw error;
+      }
+      if (resolved) {
+        return resolved;
+      }
+    }
+    return null;
+  };
+};
+const routeIdentityResolvers = (routes) => {
+  const prefixes = Object.keys(routes).filter((key) => key !== "*").toSorted((a, b) => b.length - a.length);
+  return (request, env) => {
+    const { pathname } = new URL(request.url);
+    const matched = prefixes.find((prefix) => pathname === prefix || pathname.startsWith(prefix.endsWith("/") ? prefix : `${prefix}/`));
+    const resolver = matched === void 0 ? routes["*"] : routes[matched];
+    if (resolver === void 0) {
+      return null;
+    }
+    return resolver(request, env);
+  };
+};
+const wrapResolverWithContract = (baseResolveIdentity, contract) => {
+  if (contract === void 0 || baseResolveIdentity === void 0) {
+    return baseResolveIdentity;
+  }
+  return async (request, env) => {
+    const resolved = await baseResolveIdentity(request, env);
+    if (!resolved) {
+      return resolved;
+    }
+    const result = contract.validate(resolved);
+    if (result.ok) {
+      return resolved;
+    }
+    if (contract.onInvalid === "reject") {
+      throw new LunoraError(`identity claims failed the declared contract: ${result.error}`, { code: "UNAUTHENTICATED", status: 401 });
+    }
+    return null;
+  };
+};
+
+export { composeIdentityResolvers, routeIdentityResolvers, wrapResolverWithContract };