@lunora/runtime 1.0.0-alpha.37 → 1.0.0-alpha.39

package/dist/packem_shared/LOG_ARCHIVE_PATH-CNs0bznX.mjs

@@ -1,125 +0,0 @@
-import { createR2Sql } from '@lunora/bindings/r2sql';
-import { LOG_ARCHIVE_NOT_CONFIGURED } from './LOG_ARCHIVE_NOT_CONFIGURED-acNcguqc.mjs';
-import { L as LOG_LEVEL_ORDER, c as createPipelineLogReader } from './pipeline-log-reader-BXULGNC3.mjs';
-import { LunoraError } from './LunoraError-Bpb9EFJ3.mjs';
-
-const LOG_ARCHIVE_PATH = "/_lunora/admin/logs/archive";
-const LOG_ARCHIVE_TABLE_ENV = "LUNORA_LOG_ARCHIVE_TABLE";
-const LOG_ARCHIVE_NAMESPACE_ENV = "LUNORA_LOG_ARCHIVE_NAMESPACE";
-const resolveLogArchiveFromEnv = (environment) => {
-  if (typeof environment !== "object" || environment === null) {
-    return void 0;
-  }
-  const record = environment;
-  const table = record[LOG_ARCHIVE_TABLE_ENV];
-  if (typeof table !== "string" || table === "") {
-    return void 0;
-  }
-  const namespace = record[LOG_ARCHIVE_NAMESPACE_ENV];
-  return { table, ...typeof namespace === "string" && namespace !== "" ? { namespace } : {} };
-};
-const LOG_LEVELS = new Set(LOG_LEVEL_ORDER);
-const optionalString = (value) => typeof value === "string" && value !== "" ? value : void 0;
-const parseLevel = (value, field) => {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value !== "string" || !LOG_LEVELS.has(value)) {
-    throw new LunoraError(`logs archive: invalid \`${field}\` — expected one of ${LOG_LEVEL_ORDER.join(", ")}`, { code: "BAD_REQUEST", status: 400 });
-  }
-  return value;
-};
-const parseFiniteNumber = (value, field) => {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new LunoraError(`logs archive: invalid \`${field}\` — expected a finite number`, { code: "BAD_REQUEST", status: 400 });
-  }
-  return value;
-};
-const parseQuery = (body) => {
-  const query = {};
-  const assignString = (field) => {
-    const value = optionalString(body[field]);
-    if (value !== void 0) {
-      query[field] = value;
-    }
-  };
-  assignString("functionPath");
-  assignString("functionPathPrefix");
-  assignString("traceId");
-  assignString("shardKey");
-  assignString("userId");
-  const level = parseLevel(body["level"], "level");
-  if (level !== void 0) {
-    query.level = level;
-  }
-  const minLevel = parseLevel(body["minLevel"], "minLevel");
-  if (minLevel !== void 0) {
-    query.minLevel = minLevel;
-  }
-  const sinceTs = parseFiniteNumber(body["sinceTs"], "sinceTs");
-  if (sinceTs !== void 0) {
-    query.sinceTs = sinceTs;
-  }
-  const untilTs = parseFiniteNumber(body["untilTs"], "untilTs");
-  if (untilTs !== void 0) {
-    query.untilTs = untilTs;
-  }
-  const limit = parseFiniteNumber(body["limit"], "limit");
-  if (limit !== void 0) {
-    query.limit = limit;
-  }
-  const rawCursor = body["cursor"];
-  if (typeof rawCursor === "object" && rawCursor !== null) {
-    const cursorTs = parseFiniteNumber(rawCursor["ts"], "cursor.ts");
-    if (cursorTs !== void 0) {
-      query.cursor = { ts: cursorTs };
-    }
-  }
-  return query;
-};
-const resolveCredentials = (environment) => {
-  const accountId = environment.R2_SQL_ACCOUNT_ID ?? environment.CLOUDFLARE_ACCOUNT_ID;
-  const apiToken = environment.R2_SQL_TOKEN;
-  const bucket = environment.R2_SQL_BUCKET;
-  const missing = [];
-  if (accountId === void 0 || accountId === "") {
-    missing.push("R2_SQL_ACCOUNT_ID");
-  }
-  if (apiToken === void 0 || apiToken === "") {
-    missing.push("R2_SQL_TOKEN");
-  }
-  if (bucket === void 0 || bucket === "") {
-    missing.push("R2_SQL_BUCKET");
-  }
-  if (missing.length > 0) {
-    throw new LunoraError(
-      `log archive not configured (missing ${missing.join(", ")}). The Pipeline must write to an R2 Data Catalog (Iceberg) table, and R2_SQL_ACCOUNT_ID / R2_SQL_TOKEN / R2_SQL_BUCKET must be set — see the observability docs.`,
-      { code: LOG_ARCHIVE_NOT_CONFIGURED, status: 400 }
-    );
-  }
-  return { accountId, apiToken, bucket };
-};
-const buildLogArchiveAdminRoutes = (deps) => {
-  const { createReader = createPipelineLogReader, readJsonBody, requireAdminOption } = deps;
-  const handleLogArchive = async (request, env) => {
-    if (request.method !== "POST") {
-      throw new LunoraError("Log-archive endpoint requires POST", { code: "METHOD_NOT_ALLOWED", status: 405 });
-    }
-    const config = requireAdminOption(request, deps.logArchive, {
-      code: LOG_ARCHIVE_NOT_CONFIGURED,
-      message: "log archive requires a `logArchive` config (an R2 Data Catalog table) on the worker — see the observability docs"
-    });
-    const { accountId, apiToken, bucket } = resolveCredentials(env ?? {});
-    const query = parseQuery(await readJsonBody(request));
-    const client = createR2Sql({ accountId, apiToken, bucket });
-    const reader = createReader(client, { columnMap: config.columnMap, namespace: config.namespace, table: config.table });
-    const page = await reader.query(query);
-    return Response.json(page, { headers: { "content-type": "application/json" }, status: 200 });
-  };
-  return { [LOG_ARCHIVE_PATH]: handleLogArchive };
-};
-
-export { LOG_ARCHIVE_NOT_CONFIGURED, LOG_ARCHIVE_PATH, buildLogArchiveAdminRoutes, resolveLogArchiveFromEnv };

package/dist/packem_shared/LunoraError-Bpb9EFJ3.mjs

@@ -1,22 +0,0 @@
-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

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

package/dist/packem_shared/analyticsEngineSink-yLFNjHDt.mjs

@@ -1,429 +0,0 @@
-import { w as wrapResourceSpans, o as otlpRandomHex, c as wrapResourceMetrics, e as wrapResourceLogs, f as encodeAttribute, g as otlpUnixNano, O as OTLP_SEVERITY, h as mergeHeaders, m as mergeResourceAttributes } from './otlp-resource-Dow6-F_u.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 otlpTraceBody = (event, serviceName, endMs, resourceAttributes) => {
-  const attributes = [encodeAttribute("lunora.function_path", event.functionPath), encodeAttribute("lunora.ok", event.ok)];
-  if (event.method !== void 0) {
-    attributes.push(encodeAttribute("http.request.method", event.method));
-  }
-  if (event.path !== void 0) {
-    attributes.push(encodeAttribute("url.path", event.path));
-  }
-  attributes.push(encodeAttribute("http.route", event.functionPath));
-  if (event.scheme !== void 0) {
-    attributes.push(encodeAttribute("url.scheme", event.scheme));
-  }
-  if (event.host !== void 0) {
-    attributes.push(encodeAttribute("server.address", event.host));
-  }
-  if (event.port !== void 0) {
-    attributes.push(encodeAttribute("server.port", event.port));
-  }
-  if (event.userAgent !== void 0) {
-    attributes.push(encodeAttribute("user_agent.original", event.userAgent));
-  }
-  if (event.shardKey !== void 0) {
-    attributes.push(encodeAttribute("lunora.shard_key", event.shardKey));
-  }
-  attributes.push(encodeAttribute("http.response.status_code", event.error?.status ?? 200));
-  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)
-  };
-  if (event.parentSpanId !== void 0) {
-    span.parentSpanId = event.parentSpanId;
-  }
-  if (event.traceFlags !== void 0) {
-    span.flags = event.traceFlags;
-  }
-  if (event.error) {
-    span.events = [
-      {
-        attributes: [encodeAttribute("exception.type", event.error.code), encodeAttribute("exception.message", event.error.message)],
-        name: "exception",
-        timeUnixNano: otlpUnixNano(endMs)
-      }
-    ];
-  }
-  return wrapResourceSpans(span, "@lunora/runtime", serviceName, resourceAttributes);
-};
-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, resourceAttributes) => {
-  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, resourceAttributes);
-};
-const otlpMetricBody = (event, serviceName, resourceAttributes) => {
-  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, resourceAttributes);
-  }
-  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,
-      resourceAttributes
-    );
-  }
-  return wrapResourceMetrics(
-    { name: event.name, sum: { aggregationTemporality: 1, dataPoints: [dataPoint], isMonotonic: true } },
-    "@lunora/runtime",
-    serviceName,
-    resourceAttributes
-  );
-};
-const otlpLogBody = (event, serviceName, resourceAttributes) => {
-  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, resourceAttributes);
-};
-const OTLP_GZIP_THRESHOLD = 1024;
-const gzipEncode = async (text) => {
-  const stream = new Blob([text]).stream().pipeThrough(new CompressionStream("gzip"));
-  return new Response(stream).arrayBuffer();
-};
-const otlpPost = (url, body, headers, context) => {
-  try {
-    const json = JSON.stringify(body);
-    const sent = (json.length < OTLP_GZIP_THRESHOLD ? fetch(url, { body: json, headers, method: "POST" }) : gzipEncode(json).then((gz) => fetch(url, { body: gz, headers: { ...headers, "content-encoding": "gzip" }, method: "POST" }))).catch(() => {
-    });
-    if (context?.waitUntil) {
-      context.waitUntil(sent);
-    }
-  } catch {
-  }
-};
-
-const shouldSkip = (event, onlyErrors) => onlyErrors === true && event.ok;
-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, serializeFields } = 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 = serializeFields === true ? JSON.stringify(event.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 { deploymentEnvironment, detectResources, endpoint, headers, onlyErrors, resourceAttributes, serviceNamespace, serviceVersion, token } = options;
-  const serviceName = options.serviceName ?? "lunora";
-  const staticAttributes = {
-    ...serviceVersion === void 0 ? {} : { "service.version": serviceVersion },
-    ...serviceNamespace === void 0 ? {} : { "service.namespace": serviceNamespace },
-    ...deploymentEnvironment === void 0 ? {} : { "deployment.environment": deploymentEnvironment },
-    ...resourceAttributes
-  };
-  const mergedByContext = /* @__PURE__ */ new WeakMap();
-  const resourceAttributesFor = (context) => {
-    if (detectResources !== true || context?.resourceAttributes === void 0) {
-      return staticAttributes;
-    }
-    const memoized = mergedByContext.get(context);
-    if (memoized !== void 0) {
-      return memoized;
-    }
-    const merged = mergeResourceAttributes(context.resourceAttributes(), staticAttributes);
-    mergedByContext.set(context, merged);
-    return merged;
-  };
-  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, resourceAttributesFor(context)), mergedHeaders, context);
-    },
-    onMetric: (event, context) => {
-      otlpPost(metricsUrl, otlpMetricBody(event, serviceName, resourceAttributesFor(context)), mergedHeaders, context);
-    },
-    onRpc: (event, context) => {
-      if (shouldSkip(event, onlyErrors)) {
-        return;
-      }
-      otlpPost(tracesUrl, otlpTraceBody(event, serviceName, Date.now(), resourceAttributesFor(context)), mergedHeaders, context);
-    },
-    onSpan: (event, context) => {
-      otlpPost(tracesUrl, otlpSpanBody(event, serviceName, resourceAttributesFor(context)), 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

@@ -1,20 +0,0 @@
-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 };