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

package/dist/index.mjs

@@ -1,14 +1,17 @@
 export { toAirbyteMessages, toFivetranResponse } from './packem_shared/toAirbyteMessages-DrHdplb4.mjs';
-export { composeWorker, createLunoraHandler, createWorker, defineRpcEnvelope, resolveLunoraOptions, withFrameworkWorker } from './packem_shared/composeWorker-DAwO9LLs.mjs';
+export { composeWorker, createLunoraHandler, createWorker, defineRpcEnvelope, resolveLunoraOptions, withFrameworkWorker } from './packem_shared/composeWorker-DiWwOXXt.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 { createKvCursorStore, createMemoryCursorStore, defineExportSink, r2Sink, runExportTap, sanitizeChange, webhookExportSink } from './packem_shared/createKvCursorStore-g8aA6B4L.mjs';
+export { HEALTH_PATH, HEALTH_READY_PATH, buildHealthRoutes, d1Probe, durableObjectProbe, presenceProbe } from './packem_shared/HEALTH_PATH-e5J_NHBx.mjs';
 export { LOG_ARCHIVE_PATH, resolveLogArchiveFromEnv } from './packem_shared/LOG_ARCHIVE_PATH-CNs0bznX.mjs';
-export { emitLogEvent, emitRpcEvent } from './packem_shared/emitLogEvent-pEdtqAK8.mjs';
-export { analyticsEngineSink, combineSinks, consoleSink, otlpSink, pipelineLogSink, sentrySink, webhookSink } from './packem_shared/analyticsEngineSink-DE48mQA9.mjs';
+export { e as emitLogEvent, a as emitRpcEvent } from './packem_shared/observability--NOFYBFc.mjs';
+export { analyticsEngineSink, combineSinks, consoleSink, otlpSink, pipelineLogSink, sentrySink, webhookSink } from './packem_shared/analyticsEngineSink-yLFNjHDt.mjs';
 export { D as DEFAULT_LOG_COLUMNS, a as DEFAULT_LOG_LIMIT, c as createPipelineLogReader } from './packem_shared/pipeline-log-reader-BXULGNC3.mjs';
 export { createQueryCoordinator, createStaticShardRegistry, mergeStrategyForAggregate } from './packem_shared/createQueryCoordinator-DNCJzOZE.mjs';
 export { applyJurisdiction, resolveShard } from './packem_shared/applyJurisdiction-BkZtTkct.mjs';
+export { argsFromQuery, buildRestRoutes, createRestRateLimit, readShardKey, restSurfaceFromRegistry } from './packem_shared/argsFromQuery-c-U1WRy-.mjs';
 export { decorateResponse, enforceOrigin, handleCorsPreflight, resolveSecurity } from './packem_shared/decorateResponse-DRWQFNhF.mjs';
 export { LOG_ARCHIVE_NOT_CONFIGURED } from './packem_shared/LOG_ARCHIVE_NOT_CONFIGURED-acNcguqc.mjs';
 export { NOOP_EXECUTION_CONTEXT } from './packem_shared/NOOP_EXECUTION_CONTEXT-CCTu0Bf1.mjs';

package/dist/packem_shared/HEALTH_PATH-e5J_NHBx.mjs

@@ -0,0 +1,150 @@
+import { LunoraError } from './LunoraError-Bpb9EFJ3.mjs';
+import { m as methodGuard } from './method-guard-Qzw99aCj.mjs';
+
+const HEALTH_PATH = "/_lunora/health";
+const HEALTH_READY_PATH = "/_lunora/health/ready";
+const toCheckerType = (kind) => {
+  if (kind === "liveness") {
+    return ["liveness"];
+  }
+  if (kind === "readiness") {
+    return ["readiness"];
+  }
+  return ["liveness", "readiness"];
+};
+class HealthRegistry {
+  #checkers = /* @__PURE__ */ new Map();
+  addChecker(name, run, options) {
+    this.#checkers.set(name, { run, types: options.type });
+  }
+  async getReport(filter) {
+    const selected = [...this.#checkers].filter(([, checker]) => filter === void 0 || checker.types.includes(filter));
+    const entries = await Promise.all(selected.map(async ([name, checker]) => [name, await checker.run()]));
+    return {
+      healthy: entries.every(([, result]) => result.health.healthy),
+      report: Object.fromEntries(entries)
+    };
+  }
+}
+const buildRegistry = (probes) => {
+  const registry = new HealthRegistry();
+  const criticalNames = /* @__PURE__ */ new Set();
+  for (const probe of probes) {
+    if (probe.critical) {
+      criticalNames.add(probe.name);
+    }
+    registry.addChecker(
+      probe.name,
+      async () => {
+        let result;
+        try {
+          result = await probe.check();
+        } catch (error) {
+          result = { healthy: false, message: error instanceof Error ? error.message : "probe failed" };
+        }
+        return {
+          health: {
+            healthy: result.healthy,
+            ...result.message === void 0 ? {} : { message: result.message }
+          }
+        };
+      },
+      { type: toCheckerType(probe.kind) }
+    );
+  }
+  return { criticalNames, registry };
+};
+const buildBody = (report, criticalNames, posture, appName, appVersion) => {
+  const checks = [];
+  let anyCriticalDown = false;
+  let anyDown = false;
+  for (const [name, entry] of Object.entries(report)) {
+    const critical = criticalNames.has(name);
+    const up = entry.health.healthy;
+    if (!up) {
+      anyDown = true;
+      if (critical) {
+        anyCriticalDown = true;
+      }
+    }
+    checks.push({
+      critical,
+      ...posture === "admin" && entry.health.message !== void 0 ? { message: entry.health.message } : {},
+      name,
+      status: up ? "up" : "down"
+    });
+  }
+  checks.sort((a, b) => a.name.localeCompare(b.name));
+  let status = "healthy";
+  if (anyCriticalDown) {
+    status = "unhealthy";
+  } else if (anyDown) {
+    status = "degraded";
+  }
+  return {
+    anyCriticalDown,
+    body: { appName, appVersion, checks, status, timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+  };
+};
+const buildHealthRoutes = (deps) => {
+  const { appName = "lunora", appVersion = "0.0.0", auth = "public", isAdmin, resolveProbes } = deps;
+  const gate = (request) => {
+    if (auth === "admin" && !isAdmin(request)) {
+      throw new LunoraError("health endpoint requires a valid admin bearer", { code: "ADMIN_FORBIDDEN", status: 403 });
+    }
+  };
+  const respond = async (request, env, probeKind) => {
+    const wrongMethod = methodGuard(request, ["GET", "HEAD"]);
+    if (wrongMethod) {
+      return wrongMethod;
+    }
+    gate(request);
+    const { criticalNames, registry } = buildRegistry(resolveProbes(env));
+    const { healthy, report } = await registry.getReport(probeKind === "readiness" ? "readiness" : void 0);
+    const { anyCriticalDown, body } = buildBody(report, criticalNames, auth, appName, appVersion);
+    const down = probeKind === "readiness" ? !healthy : anyCriticalDown;
+    return Response.json(body, { headers: { "cache-control": "no-store" }, status: down ? 503 : 200 });
+  };
+  return {
+    [HEALTH_PATH]: (request, env) => respond(request, env, "aggregate"),
+    [HEALTH_READY_PATH]: (request, env) => respond(request, env, "readiness")
+  };
+};
+const durableObjectProbe = (name, namespace, shardKey) => {
+  return {
+    check: async () => {
+      try {
+        const stub = namespace.get(namespace.idFromName(shardKey));
+        await stub.fetch(new Request("https://shard.internal/_lunora/status", { method: "GET" }));
+        return { healthy: true };
+      } catch {
+        return { healthy: false, message: "durable object unreachable" };
+      }
+    },
+    critical: true,
+    name
+  };
+};
+const d1Probe = (name, database) => {
+  return {
+    check: async () => {
+      try {
+        await database.prepare("SELECT 1").first();
+        return { healthy: true };
+      } catch {
+        return { healthy: false, message: "d1 query failed" };
+      }
+    },
+    critical: true,
+    name
+  };
+};
+const presenceProbe = (name, bound) => {
+  return {
+    check: () => bound ? { healthy: true } : { healthy: false, message: "binding not configured" },
+    critical: false,
+    name
+  };
+};
+
+export { HEALTH_PATH, HEALTH_READY_PATH, buildHealthRoutes, d1Probe, durableObjectProbe, presenceProbe };

package/dist/packem_shared/{analyticsEngineSink-DE48mQA9.mjs → analyticsEngineSink-yLFNjHDt.mjs}

@@ -1,4 +1,4 @@
-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';
+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") {
@@ -12,12 +12,31 @@ const stringifyFieldValue = (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 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));
   }
@@ -42,7 +61,22 @@ const otlpTraceBody = (event, serviceName, endMs) => {
     status: event.ok ? { code: 1 } : { code: 2, message: event.error?.message ?? "" },
     traceId: event.traceId ?? otlpRandomHex(16)
   };
-  return wrapResourceSpans(span, "@lunora/runtime", serviceName);
+  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)]]);
@@ -60,7 +94,7 @@ const encodeSignalAttributes = (reserved, caller) => {
   }
   return [...byKey.values()];
 };
-const otlpSpanBody = (event, serviceName) => {
+const otlpSpanBody = (event, serviceName, resourceAttributes) => {
   const span = {
     attributes: encodeSignalAttributes(
       { errorType: event.error?.type, functionPath: event.functionPath, shardKey: event.shardKey, userId: event.userId },
@@ -80,14 +114,14 @@ const otlpSpanBody = (event, serviceName) => {
     status: event.ok ? { code: 1 } : { code: 2, message: event.error?.message ?? "" },
     traceId: event.traceId
   };
-  return wrapResourceSpans(span, "@lunora/runtime", serviceName);
+  return wrapResourceSpans(span, "@lunora/runtime", serviceName, resourceAttributes);
 };
-const otlpMetricBody = (event, serviceName) => {
+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);
+    return wrapResourceMetrics({ gauge: { dataPoints: [dataPoint] }, name: event.name }, "@lunora/runtime", serviceName, resourceAttributes);
   }
   if (event.kind === "histogram") {
     return wrapResourceMetrics(
@@ -112,16 +146,18 @@ const otlpMetricBody = (event, serviceName) => {
         name: event.name
       },
       "@lunora/runtime",
-      serviceName
+      serviceName,
+      resourceAttributes
     );
   }
   return wrapResourceMetrics(
     { name: event.name, sum: { aggregationTemporality: 1, dataPoints: [dataPoint], isMonotonic: true } },
     "@lunora/runtime",
-    serviceName
+    serviceName,
+    resourceAttributes
   );
 };
-const otlpLogBody = (event, serviceName) => {
+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`.
@@ -137,7 +173,7 @@ const otlpLogBody = (event, serviceName) => {
   if (event.spanId !== void 0) {
     logRecord.spanId = event.spanId;
   }
-  return wrapResourceLogs(logRecord, "@lunora/runtime", serviceName);
+  return wrapResourceLogs(logRecord, "@lunora/runtime", serviceName, resourceAttributes);
 };
 const OTLP_GZIP_THRESHOLD = 1024;
 const gzipEncode = async (text) => {
@@ -155,6 +191,8 @@ const otlpPost = (url, body, headers, context) => {
   } catch {
   }
 };
+
+const shouldSkip = (event, onlyErrors) => onlyErrors === true && event.ok;
 const consoleSink = (options = {}) => {
   const { onlyErrors } = options;
   return {
@@ -312,8 +350,27 @@ const pipelineLogSink = (options) => {
   };
 };
 const otlpSink = (options) => {
-  const { endpoint, headers, onlyErrors, token } = 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);
@@ -324,19 +381,19 @@ const otlpSink = (options) => {
   const mergedHeaders = mergeHeaders({ "content-type": "application/json" }, headers, token);
   return {
     onLog: (event, context) => {
-      otlpPost(logsUrl, otlpLogBody(event, serviceName), mergedHeaders, context);
+      otlpPost(logsUrl, otlpLogBody(event, serviceName, resourceAttributesFor(context)), mergedHeaders, context);
     },
     onMetric: (event, context) => {
-      otlpPost(metricsUrl, otlpMetricBody(event, serviceName), mergedHeaders, 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()), mergedHeaders, context);
+      otlpPost(tracesUrl, otlpTraceBody(event, serviceName, Date.now(), resourceAttributesFor(context)), mergedHeaders, context);
     },
     onSpan: (event, context) => {
-      otlpPost(tracesUrl, otlpSpanBody(event, serviceName), mergedHeaders, context);
+      otlpPost(tracesUrl, otlpSpanBody(event, serviceName, resourceAttributesFor(context)), mergedHeaders, context);
     }
   };
 };

package/dist/packem_shared/argsFromQuery-c-U1WRy-.mjs

@@ -0,0 +1,121 @@
+import { m as methodGuard } from './method-guard-Qzw99aCj.mjs';
+
+const REST_PATH_PREFIX = "/_lunora/rest";
+const splitFunctionPath = (functionPath) => {
+  const colon = functionPath.indexOf(":");
+  if (colon <= 0 || colon >= functionPath.length - 1 || functionPath.indexOf(":", colon + 1) !== -1) {
+    return void 0;
+  }
+  return { name: functionPath.slice(colon + 1), namespace: functionPath.slice(0, colon) };
+};
+const restPathForFunction = (functionPath) => {
+  const parts = splitFunctionPath(functionPath);
+  if (parts === void 0) {
+    return void 0;
+  }
+  return `${REST_PATH_PREFIX}/${parts.namespace}/${parts.name}`;
+};
+const restMethodForKind = (kind) => kind === "query" ? "GET" : "POST";
+const describeRestSurface = (procedures) => {
+  const entries = [];
+  for (const procedure of procedures) {
+    if (procedure.exposure?.rest !== true || procedure.kind === "stream") {
+      continue;
+    }
+    const parts = splitFunctionPath(procedure.functionPath);
+    const path = restPathForFunction(procedure.functionPath);
+    if (parts === void 0 || path === void 0) {
+      continue;
+    }
+    entries.push({
+      functionPath: procedure.functionPath,
+      kind: procedure.kind,
+      method: restMethodForKind(procedure.kind),
+      name: parts.name,
+      namespace: parts.namespace,
+      path
+    });
+  }
+  entries.sort((a, b) => a.path.localeCompare(b.path));
+  return entries;
+};
+
+const registryToSurfaceInput = (functions) => Object.entries(functions).map(([functionPath, entry]) => {
+  return { exposure: entry.expose, functionPath, kind: entry.kind };
+});
+const restSurfaceFromRegistry = (functions) => describeRestSurface(registryToSurfaceInput(functions));
+const readShardKey = (url, request) => {
+  const fromQuery = url.searchParams.get("shardKey");
+  if (fromQuery !== null && fromQuery !== "") {
+    return fromQuery;
+  }
+  const fromHeader = request.headers.get("x-lunora-shard-key");
+  return fromHeader === null || fromHeader === "" ? void 0 : fromHeader;
+};
+const argsFromQuery = (url) => {
+  const args = {};
+  for (const [key, value] of url.searchParams.entries()) {
+    if (key === "shardKey") {
+      continue;
+    }
+    try {
+      args[key] = JSON.parse(value);
+    } catch {
+      args[key] = value;
+    }
+  }
+  return args;
+};
+const buildRestRoutes = (deps) => {
+  const { functions, invoke, rateLimit, readJsonBody } = deps;
+  const routes = {};
+  for (const entry of restSurfaceFromRegistry(functions)) {
+    const allowed = entry.kind === "query" ? ["GET", "POST"] : ["POST"];
+    routes[entry.path] = async (request, env, _url, context) => {
+      const wrongMethod = methodGuard(request, allowed);
+      if (wrongMethod) {
+        return wrongMethod;
+      }
+      const url = new URL(request.url);
+      if (rateLimit) {
+        const limited = await rateLimit(request, entry.functionPath);
+        if (limited) {
+          return limited;
+        }
+      }
+      let args;
+      if (request.method === "GET") {
+        args = argsFromQuery(url);
+      } else {
+        args = request.body === null ? {} : await readJsonBody(request);
+      }
+      const shardKey = readShardKey(url, request);
+      return invoke({
+        args,
+        env,
+        functionPath: entry.functionPath,
+        request,
+        ...shardKey === void 0 ? {} : { shardKey },
+        ...context?.waitUntil === void 0 ? {} : { waitUntil: (promise) => context.waitUntil?.(promise) }
+      });
+    };
+  }
+  return routes;
+};
+const createRestRateLimit = (limiter, options) => async (request, functionPath) => {
+  const key = options.key ? options.key(request, functionPath) : request.headers.get("cf-connecting-ip") ?? void 0;
+  const status = await limiter.limit(options.name, key === void 0 ? {} : { key });
+  if (status.ok) {
+    return void 0;
+  }
+  const retryAfterSeconds = Math.max(1, Math.ceil(status.retryAfter / 1e3));
+  return Response.json(
+    { error: { code: "RATE_LIMITED", message: "Rate limit exceeded" } },
+    {
+      headers: { "content-type": "application/json", "retry-after": String(retryAfterSeconds) },
+      status: 429
+    }
+  );
+};
+
+export { argsFromQuery, buildRestRoutes, createRestRateLimit, readShardKey, restSurfaceFromRegistry };