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

package/dist/packem_shared/{ReactiveCache-ByVzgH3d.mjs → ReactiveCache-DnSvbjil.mjs}

@@ -1,11 +1,7 @@
+import { stableWireKey } from './stableWireKey-DKuXO7T5.mjs';
 import { depKey, SCAN_DEP } from './SCAN_DEP-DLJF8dsj.mjs';
+export { stableStringify } from './stableStringify-mC40mZts.mjs';
 
-const compareKeys = (a, b) => {
-  if (a < b) {
-    return -1;
-  }
-  return a > b ? 1 : 0;
-};
 const DEFAULT_MAX_ENTRIES = 1e3;
 const DEFAULT_MAX_BYTES = 4 * 1024 * 1024;
 const estimateBytes = (value) => {
@@ -232,28 +228,6 @@ class ReactiveCache {
     }
   }
 }
-const stableStringify = (value) => {
-  if (value === void 0) {
-    return "null";
-  }
-  if (value === null || typeof value !== "object") {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
-  }
-  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(",")}}`;
-};
-const reactiveCacheKey = (functionPath, args, identity) => `${identity ?? "\0anon"}\0${functionPath}:${stableStringify(args)}`;
+const reactiveCacheKey = (functionPath, args, identity) => `${identity ?? "\0anon"}\0${functionPath}:${stableWireKey(args)}`;
 
-export { ReactiveCache, reactiveCacheKey, stableStringify };
+export { ReactiveCache, reactiveCacheKey, stableWireKey };

package/dist/packem_shared/{SESSION_DO_TTL_DEFAULT-ilPZsVwu.mjs → SESSION_DO_TTL_DEFAULT-BnSKgVO4.mjs}

@@ -1,3 +1,6 @@
+import { c as constantTimeEqual } from './constant-time-equal-BVRWZgES.mjs';
+import { j as jsonResponse } from './json-response-BdbtpOhm.mjs';
+
 const SESSION_DO_TTL_DEFAULT = 7 * 24 * 60 * 60;
 const SESSION_DO_TTL_MAX = 90 * 24 * 60 * 60;
 const SESSION_GC_INTERVAL_MS = 24 * 60 * 60 * 1e3;
@@ -7,20 +10,6 @@ const SESSION_TOKEN_PATTERN = /^[\w-]+$/;
 const MIN_TOKEN_LENGTH = 32;
 const MAX_TOKEN_LENGTH = 256;
 const MAX_USER_ID_LENGTH = 256;
-const jsonResponse = (status, body) => Response.json(body, {
-  headers: { "content-type": "application/json" },
-  status
-});
-const constantTimeEqual = (a, b) => {
-  const max = Math.max(a.length, b.length);
-  let diff = a.length ^ b.length;
-  for (let index = 0; index < max; index += 1) {
-    const charA = index < a.length ? a.charCodeAt(index) : 0;
-    const charB = index < b.length ? b.charCodeAt(index) : 0;
-    diff |= charA ^ charB;
-  }
-  return diff === 0;
-};
 const isAuthorized = (request, env) => {
   const expected = env.SESSION_DO_SECRET;
   if (typeof expected !== "string" || expected.length === 0) {
@@ -68,7 +57,7 @@ class SessionDO {
   async fetch(request) {
     const env = this.env ?? {};
     if (!isAuthorized(request, env)) {
-      return jsonResponse(401, { error: { code: "UNAUTHORIZED", message: "missing or invalid SessionDO secret" } });
+      return jsonResponse({ error: { code: "UNAUTHORIZED", message: "missing or invalid SessionDO secret" } }, 401);
     }
     const url = new URL(request.url);
     if (request.method === "POST" && url.pathname === "/create") {
@@ -80,7 +69,7 @@ class SessionDO {
     if (request.method === "DELETE" && url.pathname === "/revoke") {
       return this.handleRevoke(request);
     }
-    return jsonResponse(404, { error: { code: "NOT_FOUND", message: "no such session route" } });
+    return jsonResponse({ error: { code: "NOT_FOUND", message: "no such session route" } }, 404);
   }
   /**
    * Sweep expired session records. Lazy expiry-on-read ({@link handleGet})
@@ -116,25 +105,25 @@ class SessionDO {
     try {
       body = await request.json();
     } catch {
-      return jsonResponse(400, { error: "invalid_request" });
+      return jsonResponse({ error: "invalid_request" }, 400);
     }
     const token = validateToken(body.token);
     if (token === void 0) {
-      return jsonResponse(400, { error: "invalid_request" });
+      return jsonResponse({ error: "invalid_request" }, 400);
     }
     const { userId } = body;
     if (typeof userId !== "string" || userId.length === 0 || userId.length > MAX_USER_ID_LENGTH) {
-      return jsonResponse(400, { error: "invalid_request" });
+      return jsonResponse({ error: "invalid_request" }, 400);
     }
     const ttlSeconds = resolveTtlSeconds(body.ttlSeconds);
     if (ttlSeconds === void 0) {
-      return jsonResponse(400, { error: "invalid_request" });
+      return jsonResponse({ error: "invalid_request" }, 400);
     }
     const now = Date.now();
     const record = { createdAt: now, expiresAt: now + ttlSeconds * 1e3, userId };
     await this.state.storage.put(`s:${token}`, record);
     await this.armGcAlarm();
-    return jsonResponse(201, { token, ...record });
+    return jsonResponse({ token, ...record }, 201);
   }
   /**
    * Ensure a GC alarm is pending. Only sets one when none is currently
@@ -155,25 +144,25 @@ class SessionDO {
   async handleGet(request) {
     const token = request.headers.get(SESSION_TOKEN_HEADER);
     if (!token) {
-      return jsonResponse(400, { error: { code: "INVALID_INPUT", message: "token required" } });
+      return jsonResponse({ error: { code: "INVALID_INPUT", message: "token required" } }, 400);
     }
     const record = await this.state.storage.get(`s:${token}`);
     if (!record) {
-      return jsonResponse(404, { error: { code: "NOT_FOUND", message: "session not found" } });
+      return jsonResponse({ error: { code: "NOT_FOUND", message: "session not found" } }, 404);
     }
     if (record.expiresAt < Date.now()) {
       await this.state.storage.delete(`s:${token}`);
-      return jsonResponse(404, { error: { code: "EXPIRED", message: "session expired" } });
+      return jsonResponse({ error: { code: "EXPIRED", message: "session expired" } }, 404);
     }
-    return jsonResponse(200, { token, ...record });
+    return jsonResponse({ token, ...record }, 200);
   }
   async handleRevoke(request) {
     const token = request.headers.get(SESSION_TOKEN_HEADER);
     if (!token) {
-      return jsonResponse(400, { error: { code: "INVALID_INPUT", message: "token required" } });
+      return jsonResponse({ error: { code: "INVALID_INPUT", message: "token required" } }, 400);
     }
     await this.state.storage.delete(`s:${token}`);
-    return jsonResponse(200, { ok: true });
+    return jsonResponse({ ok: true }, 200);
   }
 }
 

package/dist/packem_shared/{SHARD_REGISTRY_DO_NAME-BsAbi5Mn.mjs → SHARD_REGISTRY_DO_NAME-D99roc-r.mjs}

@@ -1,22 +1,20 @@
+import { j as jsonResponse } from './json-response-BdbtpOhm.mjs';
+
 const SHARD_REGISTRY_DO_NAME = "__lunora_shard_registry__";
 const STORAGE_KEY = "__tables__";
-const jsonResponse = (status, body) => Response.json(body, {
-  headers: { "content-type": "application/json" },
-  status
-});
 const readTableShardBody = async (request) => {
   let body;
   try {
     body = await request.json();
   } catch {
-    return { kind: "error", response: jsonResponse(400, { error: { code: "BAD_REQUEST", message: "invalid JSON body" } }) };
+    return { kind: "error", response: jsonResponse({ error: { code: "BAD_REQUEST", message: "invalid JSON body" } }, 400) };
   }
   const table = typeof body.table === "string" ? body.table.trim() : "";
   const shardKey = typeof body.shardKey === "string" ? body.shardKey.trim() : "";
   if (!table || !shardKey) {
     return {
       kind: "error",
-      response: jsonResponse(400, { error: { code: "BAD_REQUEST", message: "table and shardKey required" } })
+      response: jsonResponse({ error: { code: "BAD_REQUEST", message: "table and shardKey required" } }, 400)
     };
   }
   return { kind: "ok", value: { shardKey, table } };
@@ -56,7 +54,7 @@ class ShardRegistryDO {
     if (request.method === "GET" && url.pathname === "/snapshot") {
       return this.handleSnapshot();
     }
-    return jsonResponse(404, { error: { code: "NOT_FOUND", message: `unknown shard-registry route ${request.method} ${url.pathname}` } });
+    return jsonResponse({ error: { code: "NOT_FOUND", message: `unknown shard-registry route ${request.method} ${url.pathname}` } }, 404);
   }
   /**
    * Load the persisted snapshot exactly once. `blockConcurrencyWhile`
@@ -83,9 +81,9 @@ class ShardRegistryDO {
   handleList(url) {
     const table = url.searchParams.get("table");
     if (!table) {
-      return jsonResponse(400, { error: { code: "BAD_REQUEST", message: "missing required query parameter: table" } });
+      return jsonResponse({ error: { code: "BAD_REQUEST", message: "missing required query parameter: table" } }, 400);
     }
-    return jsonResponse(200, { shardKeys: [...this.tables.get(table) ?? []] });
+    return jsonResponse({ shardKeys: [...this.tables.get(table) ?? []] }, 200);
   }
   async handleRegister(request) {
     const parsed = await readTableShardBody(request);
@@ -100,11 +98,11 @@ class ShardRegistryDO {
         this.tables.set(table, set);
       }
       if (set.has(shardKey)) {
-        return jsonResponse(200, { changed: false, ok: true });
+        return jsonResponse({ changed: false, ok: true }, 200);
       }
       set.add(shardKey);
       await this.persist();
-      return jsonResponse(200, { changed: true, ok: true });
+      return jsonResponse({ changed: true, ok: true }, 200);
     });
   }
   handleSnapshot() {
@@ -112,7 +110,7 @@ class ShardRegistryDO {
     for (const [table, set] of this.tables) {
       out[table] = [...set];
     }
-    return jsonResponse(200, { tables: out });
+    return jsonResponse({ tables: out }, 200);
   }
   async handleUnregister(request) {
     const parsed = await readTableShardBody(request);
@@ -123,14 +121,14 @@ class ShardRegistryDO {
     return this.state.blockConcurrencyWhile(async () => {
       const set = this.tables.get(table);
       if (!set?.has(shardKey)) {
-        return jsonResponse(200, { changed: false, ok: true });
+        return jsonResponse({ changed: false, ok: true }, 200);
       }
       set.delete(shardKey);
       if (set.size === 0) {
         this.tables.delete(table);
       }
       await this.persist();
-      return jsonResponse(200, { changed: true, ok: true });
+      return jsonResponse({ changed: true, ok: true }, 200);
     });
   }
   /** Serialize the in-memory map to a single JSON-safe object and put. */

package/dist/packem_shared/{applyOnDelete-CMif2RKw.mjs → applyOnDelete-BXSq3S70.mjs}

@@ -1,3 +1,16 @@
+import { LunoraError } from '@lunora/errors';
+import { applySelect } from './applySelect-WQY8m62C.mjs';
+
+const projectChildren = (documents, nested) => nested.select ? applySelect(documents, nested.select, nested.with) : documents;
+const fanOutScalarCounts = async (counter, tableName, whereField, values, policyWhere) => {
+  const pairs = await Promise.all(
+    values.map(async (value) => {
+      const countWhere = policyWhere ? { AND: [{ [whereField]: value }, policyWhere] } : { [whereField]: value };
+      return [value, await counter(tableName, countWhere)];
+    })
+  );
+  return new Map(pairs);
+};
 const distinctValues = (rows, field) => {
   const seen = /* @__PURE__ */ new Set();
   for (const row of rows) {
@@ -9,19 +22,19 @@ const distinctValues = (rows, field) => {
   return [...seen];
 };
 const resolveWith = async (options) => {
-  const { counter, fetcher, parents, relationBaseWhere, schema, tableName, with: withInput } = options;
+  const { groupedCounter, fetcher, parents, relationBaseWhere, schema, tableName, with: withInput } = options;
   if (parents.length === 0) {
     return;
   }
   const parentDefinition = schema.tables[tableName];
   if (!parentDefinition) {
-    throw new Error(`unknown table: ${tableName}`);
+    throw new LunoraError("INTERNAL", `unknown table: ${tableName}`);
   }
   const relationMap = parentDefinition.relationMap ?? {};
   const requireRelation = (name) => {
     const relation = relationMap[name];
     if (!relation) {
-      throw new Error(`unknown relation "${name}" on table "${tableName}"`);
+      throw new LunoraError("INTERNAL", `unknown relation "${name}" on table "${tableName}"`);
     }
     return relation;
   };
@@ -44,7 +57,8 @@ const resolveWith = async (options) => {
       byReference.set(child[relation.references], child);
     }
     for (const parent of parents) {
-      parent[name] = byReference.get(parent[relation.field]) ?? null;
+      const child = byReference.get(parent[relation.field]);
+      parent[name] = child ? projectChildren([child], nested)[0] ?? null : null;
     }
   };
   const loadMany = async (name, relation, nested) => {
@@ -77,19 +91,16 @@ const resolveWith = async (options) => {
     const cap = typeof nested.limit === "number" ? Math.max(0, Math.floor(nested.limit)) : void 0;
     for (const parent of parents) {
       const group = groups.get(parent[relation.references]) ?? [];
-      parent[name] = cap === void 0 ? group : group.slice(0, cap);
+      parent[name] = projectChildren(cap === void 0 ? group : group.slice(0, cap), nested);
     }
   };
   const resolveCounts = async (countInput) => {
     for (const name of Object.keys(countInput)) {
       const relation = requireRelation(name);
       const [whereField, parentField] = relation.kind === "many" ? [relation.field, relation.references] : [relation.references, relation.field];
-      const countByValue = /* @__PURE__ */ new Map();
       const policyWhere = relationBaseWhere?.(relation.table);
-      for (const value of distinctValues(parents, parentField)) {
-        const countWhere = policyWhere ? { AND: [{ [whereField]: value }, policyWhere] } : { [whereField]: value };
-        countByValue.set(value, await counter(relation.table, countWhere));
-      }
+      const values = distinctValues(parents, parentField);
+      const countByValue = values.length === 0 ? /* @__PURE__ */ new Map() : await groupedCounter(relation.table, whereField, values, policyWhere);
       for (const parent of parents) {
         const counts = parent["_count"] ?? {};
         const parentValue = parent[parentField];
@@ -135,7 +146,7 @@ const applyRelationOnDelete = async (options, holderTable, relation) => {
 const applyOnDelete = async (options) => {
   const { schema, tableName } = options;
   if (!schema.tables[tableName]) {
-    throw new Error(`unknown table: ${tableName}`);
+    throw new LunoraError("INTERNAL", `unknown table: ${tableName}`);
   }
   for (const [holderTable, holderDefinition] of Object.entries(schema.tables)) {
     const relations = holderDefinition.relationMap;
@@ -162,4 +173,4 @@ const runRowValidators = (definition, document) => {
   }
 };
 
-export { applyOnDelete, distinctValues, resolveWith, runRowValidators };
+export { applyOnDelete, distinctValues, fanOutScalarCounts, resolveWith, runRowValidators };

package/dist/packem_shared/{buildSeekWhere-lVsNXSLy.mjs → applySelect-WQY8m62C.mjs}

@@ -1,3 +1,5 @@
+import { LunoraError } from '@lunora/errors';
+
 const TIEBREAK_FIELD = "id";
 const ID_FIELDS = /* @__PURE__ */ new Set(["_id", "id"]);
 const normalizeOrderKeys = (orderBy) => {
@@ -30,7 +32,7 @@ const encodeCursor = (record, keys) => {
   values.push(record["_id"]);
   return toBase64(JSON.stringify(values));
 };
-const invalidCursor = () => Object.assign(new TypeError("invalid cursor"), { code: "BAD_REQUEST", name: "LunoraError", status: 400 });
+const invalidCursor = () => new LunoraError("BAD_REQUEST", "invalid cursor");
 const decodeCursor = (cursor) => {
   let decoded;
   try {
@@ -80,5 +82,22 @@ const buildSeekBeforeWhere = (keys, cursorValues) => {
   }
   return { OR: branches };
 };
+const SELECT_SYSTEM_FIELDS = ["_id", "_creationTime"];
+const applySelect = (page, select, withInput) => {
+  if (!select) {
+    return page;
+  }
+  const keep = /* @__PURE__ */ new Set([...select, ...SELECT_SYSTEM_FIELDS, ...withInput ? Object.keys(withInput) : []]);
+  return page.map((document) => {
+    const projected = {};
+    for (const key of keep) {
+      if (key in document) {
+        projected[key] = document[key];
+      }
+    }
+    return projected;
+  });
+};
+const softDeleteScope = (softDeleteMode, includeDeleted) => softDeleteMode && includeDeleted !== true ? { [softDeleteMode.field]: { isNull: true } } : void 0;
 
-export { buildSeekBeforeWhere, buildSeekWhere, decodeCursor, encodeCursor, normalizeOrderKeys };
+export { applySelect, buildSeekBeforeWhere, buildSeekWhere, decodeCursor, encodeCursor, normalizeOrderKeys, softDeleteScope };

package/dist/packem_shared/{armRestore-BJk53Ro8.mjs → armRestore-4Px61hHS.mjs}

@@ -1,3 +1,5 @@
+import { LunoraError } from '@lunora/errors';
+
 const pitrUnavailable = () => Object.assign(
   new Error("native PITR is unavailable here (local dev or a non-SQLite Durable Object); use `lunora backup restore` for off-platform recovery"),
   {
@@ -12,11 +14,7 @@ const toTime = (time) => {
   }
   const parsed = Date.parse(time);
   if (Number.isNaN(parsed)) {
-    throw Object.assign(new Error(`pitr: invalid time "${time}" — expected epoch-ms or an ISO timestamp`), {
-      code: "BAD_REQUEST",
-      name: "LunoraError",
-      status: 400
-    });
+    throw new LunoraError("BAD_REQUEST", `pitr: invalid time "${time}" — expected epoch-ms or an ISO timestamp`);
   }
   return parsed;
 };
@@ -37,11 +35,7 @@ const armRestore = async (storage, args) => {
   let target = args.bookmark;
   if (target === void 0) {
     if (args.time === void 0) {
-      throw Object.assign(new Error("pitrRestore: provide a `bookmark` or a `time` to restore to"), {
-        code: "BAD_REQUEST",
-        name: "LunoraError",
-        status: 400
-      });
+      throw new LunoraError("BAD_REQUEST", "pitrRestore: provide a `bookmark` or a `time` to restore to");
     }
     if (!storage.getBookmarkForTime) {
       throw pitrUnavailable();

package/dist/packem_shared/{backfillAggregateIndexes-BbVPvciS.mjs → backfillAggregateIndexes-BGTwynwh.mjs}

@@ -1,10 +1,11 @@
 import { sql } from 'drizzle-orm';
-import { matchesStaticWhere } from './AGGREGATE_SQL_FUNCTION-CFk6adSu.mjs';
+import { matchesStaticWhere } from './AGGREGATE_SQL_FUNCTION-CQsu2Xga.mjs';
 import { encodeAggregateKey, foldAggregateTally, aggregateTableName } from './aggregateTableName-CxNqY1Sl.mjs';
 import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
-import { D as DOC_COLUMN, r as rowToDocument, A as AGG_KEY, a as AGG_VALUE, b as AGG_COUNT } from './do-sql-BCHCWtrD.mjs';
+import { D as DOC_COLUMN, r as rowToDocument, A as AGG_KEY, a as AGG_VALUE, b as AGG_COUNT } from './do-sql-CGAgiQUz.mjs';
 import { param } from './renderSql-D6eUcn2N.mjs';
-import { s as sortColumnName, m as matchesRankStaticWhere, e as encodePartitionKey, b as serializeSqlValue, r as rankTableName } from './rank-CrkEIpF4.mjs';
+import { sortColumnName, matchesRankStaticWhere, encodePartitionKey, rankTableName } from './RANK_TIEBREAK-CXhdcA1o.mjs';
+import { s as serializeSqlValue } from './serialize-sql-BlRUoiQe.mjs';
 
 const backfillAggregateIndex = (sql$1, tableName, index) => {
   const aggTable = aggregateTableName(tableName, index.name);

package/dist/packem_shared/{compileWhereSql-CXrhFA3G.mjs → compileWhereSql-DE6yfRcQ.mjs}

@@ -1,3 +1,4 @@
+import { LunoraError } from '@lunora/errors';
 import { sql } from 'drizzle-orm';
 
 const RELATION_EXISTS_KEY = "__relationExists";
@@ -11,9 +12,10 @@ const isOperatorObject = (value) => {
   const keys = Object.keys(value);
   return keys.length > 0 && keys.every((key) => OPERATOR_KEY_SET.has(key));
 };
+const escapeLikeTerm = (value) => typeof value === "string" ? value.replaceAll(/[\\%_]/g, (character) => `\\${character}`) : value;
 const compileContains = (reference, value, strategy) => {
-  const term = sql`${strategy.serialize(value)}`;
-  return strategy.likeContains ? strategy.likeContains(reference, term) : sql`${reference} LIKE '%' || ${term} || '%'`;
+  const term = sql`${strategy.serialize(escapeLikeTerm(value))}`;
+  return strategy.likeContains ? strategy.likeContains(reference, term) : sql`${reference} LIKE '%' || ${term} || '%' ESCAPE '\\'`;
 };
 const compileComparator = (reference, operator, comparator, value, strategy) => {
   if (value === null) {
@@ -93,7 +95,7 @@ const STRUCTURAL_KEYS = /* @__PURE__ */ new Set(["AND", "NOT", "OR", RELATION_EX
 const compileStructuralKey = (key, value, strategy) => {
   if (key === RELATION_EXISTS_KEY) {
     if (!strategy.relationExists) {
-      throw new Error("encountered a relation EXISTS marker without a relationExists strategy hook");
+      throw new LunoraError("INTERNAL", "encountered a relation EXISTS marker without a relationExists strategy hook");
     }
     return strategy.relationExists(value);
   }

package/dist/packem_shared/constant-time-equal-BVRWZgES.mjs

@@ -0,0 +1,12 @@
+const constantTimeEqual = (a, b) => {
+  const max = Math.max(a.length, b.length);
+  let diff = a.length ^ b.length;
+  for (let index = 0; index < max; index += 1) {
+    const charA = index < a.length ? a.charCodeAt(index) : 0;
+    const charB = index < b.length ? b.charCodeAt(index) : 0;
+    diff |= charA ^ charB;
+  }
+  return diff === 0;
+};
+
+export { constantTimeEqual as c };

package/dist/packem_shared/context-telemetry-CDpyil58.mjs

@@ -0,0 +1,223 @@
+import { isLunoraError } from '@lunora/errors';
+
+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 normalizeLogFields = (perCall, bound) => {
+  if (perCall === void 0 && bound === void 0) {
+    return void 0;
+  }
+  const merged = {};
+  if (bound !== void 0) {
+    for (const [key, value] of Object.entries(bound)) {
+      merged[key] = coerceFieldValue(value);
+    }
+  }
+  if (perCall !== void 0) {
+    for (const [key, value] of Object.entries(perCall)) {
+      merged[key] = coerceFieldValue(value);
+    }
+  }
+  return Object.keys(merged).length === 0 ? void 0 : merged;
+};
+
+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 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 resolveTraceAnchor = (traceparent) => {
+  const inbound = parseTraceparent(traceparent);
+  return { rootSpanId: inbound?.parentSpanId ?? otlpRandomHex(8), traceId: inbound?.traceId ?? otlpRandomHex(16) };
+};
+const toErrorType = (error) => {
+  if (isLunoraError(error)) {
+    return error.code;
+  }
+  return error instanceof Error ? error.constructor.name : "Error";
+};
+
+const applyCloudflareSpanAttributes = (span, meta) => {
+  if (!span.isTraced) {
+    return;
+  }
+  span.setAttribute("lunora.function_path", meta.functionPath);
+  span.setAttribute("lunora.ok", meta.ok);
+  span.setAttribute("lunora.duration_ms", meta.durationMs);
+  if (meta.shardKey !== void 0) {
+    span.setAttribute("lunora.shard_key", meta.shardKey);
+  }
+  if (meta.userId !== void 0) {
+    span.setAttribute("lunora.user_id", meta.userId);
+  }
+  if (meta.error !== void 0) {
+    span.setAttribute("lunora.error.type", meta.error.type);
+    span.setAttribute("lunora.error.message", meta.error.message);
+  }
+  for (const [key, value] of Object.entries(meta.attributes)) {
+    if (typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+      span.setAttribute(`lunora.attr.${key}`, value);
+    }
+  }
+};
+const createTracer = (deps) => {
+  const { anchor, fuseCloudflareSpans, functionPath, record, resolveCloudflareTracing, shardKey, userId } = deps;
+  const tracerFor = (parentSpanId) => async (name, function_, attributes) => {
+    const spanId = otlpRandomHex(8);
+    const startTs = Date.now();
+    const normalized = normalizeLogFields(attributes);
+    const collected = {};
+    const spanHandle = {
+      setAttribute: (key, value) => {
+        Object.assign(collected, normalizeLogFields({ [key]: value }));
+      },
+      setAttributes: (fields) => {
+        Object.assign(collected, normalizeLogFields(fields));
+      }
+    };
+    const runRecorded = async (cfSpan) => {
+      let ok = true;
+      let error;
+      try {
+        return await function_(tracerFor(spanId), spanHandle);
+      } catch (error_) {
+        ok = false;
+        error = {
+          message: error_ instanceof Error ? error_.message : String(error_),
+          // Prefer a LunoraError's stable `code` over the class name
+          // so spans group by the same taxonomy the RPC spans use.
+          type: toErrorType(error_)
+        };
+        throw error_;
+      } finally {
+        const durationMs = Date.now() - startTs;
+        const resolvedUserId = userId();
+        const merged = { ...normalized, ...collected };
+        try {
+          record({
+            ...Object.keys(merged).length === 0 ? {} : { attributes: merged },
+            durationMs,
+            ...error === void 0 ? {} : { error },
+            functionPath,
+            name,
+            ok,
+            parentSpanId,
+            shardKey,
+            spanId,
+            startTs,
+            traceId: anchor.traceId,
+            userId: resolvedUserId
+          });
+        } catch {
+        }
+        if (cfSpan !== void 0) {
+          try {
+            applyCloudflareSpanAttributes(cfSpan, {
+              attributes: merged,
+              durationMs,
+              error,
+              functionPath,
+              ok,
+              shardKey,
+              userId: resolvedUserId
+            });
+          } catch {
+          }
+        }
+      }
+    };
+    if (fuseCloudflareSpans === true && resolveCloudflareTracing !== void 0) {
+      const cfTracing = await resolveCloudflareTracing();
+      if (cfTracing !== void 0 && typeof cfTracing.enterSpan === "function") {
+        return await cfTracing.enterSpan(name, (span) => runRecorded(span));
+      }
+    }
+    return await runRecorded();
+  };
+  return tracerFor(anchor.rootSpanId);
+};
+const createMetrics = (deps) => {
+  const { functionPath, record, shardKey } = deps;
+  const emit = (kind, name, value, attributes) => {
+    if (!Number.isFinite(value)) {
+      return;
+    }
+    const normalized = normalizeLogFields(attributes);
+    try {
+      record({
+        ...normalized === void 0 ? {} : { attributes: normalized },
+        functionPath,
+        kind,
+        name,
+        shardKey,
+        ts: Date.now(),
+        value
+      });
+    } catch {
+    }
+  };
+  return {
+    count: (name, value = 1, attributes) => {
+      emit("counter", name, value, attributes);
+    },
+    gauge: (name, value, attributes) => {
+      emit("gauge", name, value, attributes);
+    },
+    record: (name, value, attributes) => {
+      emit("histogram", name, value, attributes);
+    }
+  };
+};
+const dispatchRootSpan = (input) => {
+  const { anchor, durationMs, failure, functionPath, shardKey, startTs, userId } = input;
+  return {
+    dispatch: true,
+    durationMs,
+    ...failure === void 0 ? {} : {
+      error: {
+        message: failure.thrown instanceof Error ? failure.thrown.message : String(failure.thrown),
+        type: toErrorType(failure.thrown)
+      }
+    },
+    functionPath,
+    name: functionPath,
+    ok: failure === void 0,
+    // Empty: this span IS the trace's root locally. The worker's own RPC span
+    // sits above it in a full collector-side trace, but it is not in this
+    // buffer, so naming it here would dangle.
+    parentSpanId: "",
+    shardKey,
+    spanId: anchor.rootSpanId,
+    startTs,
+    traceId: anchor.traceId,
+    userId
+  };
+};
+
+export { createTracer as a, applyCloudflareSpanAttributes as b, createMetrics as c, dispatchRootSpan as d, normalizeLogFields as n, parseTraceparent as p, resolveTraceAnchor as r };