@lunora/runtime 1.0.0-alpha.1 → 1.0.0-alpha.11

package/dist/packem_shared/{composeWorker-BYHiNH_V.mjs → composeWorker-BNYeYQqL.mjs}

@@ -1,8 +1,12 @@
+import { NOOP_EXECUTION_CONTEXT } from './NOOP_EXECUTION_CONTEXT-CCTu0Bf1.mjs';
 import { LunoraError, toErrorResponse, isStructuralLunoraError, isStructuralConflictError } from './LunoraError-CL0aOtpo.mjs';
-import { emitRpcEvent } from './emitRpcEvent-pEdtqAK8.mjs';
-import { resolveShard } from './resolveShard-DDkzWtrU.mjs';
+import { emitRpcEvent } from './emitLogEvent-pEdtqAK8.mjs';
+import { resolveShard, applyJurisdiction } from './applyJurisdiction-BkZtTkct.mjs';
 import { resolveSecurity, handleCorsPreflight, enforceOrigin, decorateResponse } from './decorateResponse-DbISh_Wi.mjs';
 
+const RELAY_NAME_INFIX = "::relay::";
+const relayName = (ownerKey, index) => `${ownerKey}${RELAY_NAME_INFIX}${String(index)}`;
+
 const AUTH_BASE = "/_lunora/admin/auth";
 const AUTH_ADMIN_ERROR_STATUS = {
   PASSWORD_TOO_LONG: 400,
@@ -278,6 +282,45 @@ const buildAuthAdminRoutes = (deps) => {
   return routes;
 };
 
+const MAX_BATCH_ENTRIES = 500;
+
+const normalizeBatchCall = (raw, index, defaultShard) => {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new LunoraError("each batch call must be an object", { code: "BAD_REQUEST", status: 400 });
+  }
+  const call = raw;
+  if (typeof call.functionPath !== "string") {
+    throw new LunoraError("each batch call needs a string `functionPath`", { code: "BAD_REQUEST", status: 400 });
+  }
+  if (call.functionPath.startsWith("__lunora_relation__:") || call.functionPath.startsWith("__lunora_admin__")) {
+    throw new LunoraError("reserved function path cannot be batched", { code: "FORBIDDEN", status: 403 });
+  }
+  return {
+    entry: {
+      args: call.args === void 0 ? {} : call.args,
+      clientId: typeof call.clientId === "string" ? call.clientId : void 0,
+      clientSeq: typeof call.clientSeq === "number" ? call.clientSeq : void 0,
+      functionPath: call.functionPath,
+      id: typeof call.id === "number" ? call.id : index,
+      mutationId: typeof call.mutationId === "string" ? call.mutationId : void 0
+    },
+    shardKey: typeof call.shardKey === "string" ? call.shardKey : defaultShard
+  };
+};
+const groupBatchCallsByShard = (calls, defaultShard) => {
+  if (calls.length > MAX_BATCH_ENTRIES) {
+    throw new LunoraError(`RPC batch exceeds the ${String(MAX_BATCH_ENTRIES)}-call limit`, { code: "BAD_REQUEST", status: 400 });
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const [index, raw] of calls.entries()) {
+    const { entry, shardKey } = normalizeBatchCall(raw, index, defaultShard);
+    const group = groups.get(shardKey) ?? [];
+    group.push(entry);
+    groups.set(shardKey, group);
+  }
+  return groups;
+};
+
 const MAX_BODY_BYTES = 1048576;
 const readBodyTextWithLimit = async (request, limit = MAX_BODY_BYTES) => {
   if (!request.body) {
@@ -597,14 +640,14 @@ const partitionExportTables = (options, tables) => {
   }
   return { globalTables, shardLocalTables };
 };
-const exportShardLocalRows = async (options, coordinator, forwardedHeaders, tables, shardLocalTables, writeRow) => {
+const exportShardLocalRows = async (options, coordinator, forwardedHeaders, tables, shardLocalTables, writeRow, namespace) => {
   if (tables !== void 0 && shardLocalTables.length === 0) {
     return;
   }
   const exportTables = tables === void 0 ? [] : shardLocalTables;
   const probeFallback = tables === void 0 ? collectKnownTables() : [];
   const probeTables = exportTables.length > 0 ? exportTables : probeFallback;
-  const result = await coordinator.orchestrateExport(options.shardDO, {
+  const result = await coordinator.orchestrateExport(namespace, {
     args: { tables: exportTables },
     headers: forwardedHeaders,
     tables: probeTables
@@ -618,9 +661,9 @@ const exportShardLocalRows = async (options, coordinator, forwardedHeaders, tabl
     }
   }
 };
-const streamExportRows = async (options, coordinator, forwardedHeaders, tables, writeRow) => {
+const streamExportRows = async (options, coordinator, forwardedHeaders, tables, writeRow, namespace) => {
   const { globalTables, shardLocalTables } = partitionExportTables(options, tables);
-  await exportShardLocalRows(options, coordinator, forwardedHeaders, tables, shardLocalTables, writeRow);
+  await exportShardLocalRows(options, coordinator, forwardedHeaders, tables, shardLocalTables, writeRow, namespace);
   const exportGlobalsFunction = options.exportGlobals;
   const wantGlobals = tables === void 0 || globalTables.length > 0;
   if (wantGlobals && exportGlobalsFunction) {
@@ -740,7 +783,7 @@ const mergeImportResult = (totals, result) => {
   }
   totals.conflicts += result.conflicts;
 };
-const streamingImport = async (request, options, forwardedHeaders) => {
+const streamingImport = async (request, options, forwardedHeaders, namespace) => {
   const defaultShard = options.defaultShardKey ?? "__root__";
   const { errors, globalRows, perShard } = await bucketImportStream(request, options, defaultShard);
   const totals = { conflicts: 0, errors, inserted: {} };
@@ -749,7 +792,7 @@ const streamingImport = async (request, options, forwardedHeaders) => {
     if (!coordinator) {
       throw new LunoraError("Import endpoint requires a `queryCoordinator` on the worker", { code: "BAD_REQUEST", status: 400 });
     }
-    const result = await coordinator.orchestrateImport(options.shardDO, {
+    const result = await coordinator.orchestrateImport(namespace, {
       batches: [...perShard.values()],
       headers: forwardedHeaders
     });
@@ -966,7 +1009,7 @@ const buildIntrospectionAdminRoutes = (deps) => {
   };
 };
 
-const MIGRATE_PATH = "/_lunora/migrate";
+const MIGRATE_PATH$1 = "/_lunora/migrate";
 const PITR_PATH = "/_lunora/admin/pitr";
 const RANK_PATH = "/_lunora/admin/rank";
 const RANKPAGE_PATH = "/_lunora/admin/rankpage";
@@ -1223,7 +1266,7 @@ const buildOrchestrationAdminRoutes = (deps) => {
     return forwardToShard(shardDO, pitr.shardKey ?? defaultShard, forwarded);
   };
   return {
-    [MIGRATE_PATH]: handleMigrate,
+    [MIGRATE_PATH$1]: handleMigrate,
     [PITR_PATH]: handlePitr,
     [RANK_PATH]: handleRank,
     [RANKPAGE_PATH]: handleRankPage,
@@ -1502,7 +1545,7 @@ const buildWorkflowsAdminRoutes = (deps) => {
     assertAdmin(request);
     const client = resolveWorkflowsClient(env);
     if (!client) {
-      return throwNotConfigured();
+      return Response.json({ configured: false, instances: [], page: 1, perPage: 0, totalCount: 0 });
     }
     const workflowName = requireQuery(url, "name");
     const status = toInstanceStatus(url.searchParams.get("status"));
@@ -1554,9 +1597,13 @@ const buildWorkflowsAdminRoutes = (deps) => {
 
 const NDJSON_ENCODER = new TextEncoder();
 const RPC_PATH = "/_lunora/rpc";
+const RPC_BATCH_PATH = "/_lunora/rpc-batch";
 const WS_PATH = "/_lunora/ws";
 const SCHEDULER_DISPATCH_PATH = "/_lunora/scheduler/dispatch";
 const CRON_JOBS_RUN_PATH = "/_lunora/admin/cron-jobs/run";
+const ADMIN_PATH_PREFIX = "/_lunora/admin/";
+const MIGRATE_PATH = "/_lunora/migrate";
+const isAdminPath = (pathname) => pathname.startsWith(ADMIN_PATH_PREFIX) || pathname === MIGRATE_PATH;
 const DEFAULT_AUTH_BASE_PATH = "/api/auth";
 const RECORD_AUTH_EVENT_OP = "__lunora_admin__:recordAuthEvent";
 const AUTH_ATTEMPT_SEGMENTS = ["/sign-in", "/sign-up", "/callback"];
@@ -1598,6 +1645,8 @@ const resolveForwardContext = async (request, env, resolveIdentity) => {
   const cookie = request.headers.get("cookie");
   const bookmark = request.headers.get("x-d1-bookmark");
   const mutationId = request.headers.get("x-lunora-mutation-id");
+  const clientId = request.headers.get("x-lunora-client-id");
+  const clientSeq = request.headers.get("x-lunora-client-seq");
   if (authorization) {
     headers["authorization"] = authorization;
   }
@@ -1610,6 +1659,12 @@ const resolveForwardContext = async (request, env, resolveIdentity) => {
   if (mutationId) {
     headers["x-lunora-mutation-id"] = mutationId;
   }
+  if (clientId) {
+    headers["x-lunora-client-id"] = clientId;
+  }
+  if (clientSeq) {
+    headers["x-lunora-client-seq"] = clientSeq;
+  }
   const clientIp = request.headers.get("cf-connecting-ip");
   if (clientIp) {
     headers["x-lunora-client-ip"] = clientIp;
@@ -1662,6 +1717,12 @@ const validateFanOut = (fanOut) => {
   }
   return spec;
 };
+const logRpcDebug = (env, envelope) => {
+  if (!env?.LUNORA_DEBUG_RPC) {
+    return;
+  }
+  console.warn(`[lunora:rpc] ${envelope.fanOut ? "fan-out" : `shard=${envelope.shardKey ?? "(root)"}`} ${envelope.functionPath}`);
+};
 const parseEnvelope = async (request) => {
   const text = await readBodyTextWithLimit(request);
   let body;
@@ -1692,6 +1753,41 @@ const forwardToShard = async (namespace, shardKey, request) => {
   const stub = resolveShard(namespace, shardKey);
   return stub.fetch(request);
 };
+const relayProbeCache = /* @__PURE__ */ new Map();
+const RELAY_PROBE_TTL_MS = 5e3;
+const probeRelayCount = async (namespace, shardKey) => {
+  const now = Date.now();
+  const cached = relayProbeCache.get(shardKey);
+  if (cached !== void 0 && cached.expiresMs > now) {
+    return cached.relayCount;
+  }
+  let relayCount = 0;
+  try {
+    const response = await resolveShard(namespace, shardKey).fetch(new Request("https://shard.internal/_lunora/route"));
+    if (response.ok) {
+      const body = await response.json();
+      const reported = body.relayCount;
+      if (typeof reported === "number" && reported > 0) {
+        relayCount = Math.floor(reported);
+      }
+    }
+  } catch {
+    relayCount = 0;
+  }
+  relayProbeCache.set(shardKey, { expiresMs: now + RELAY_PROBE_TTL_MS, relayCount });
+  return relayCount;
+};
+const resolveShardBindingName = (env, namespace) => {
+  if (env === null || typeof env !== "object") {
+    return void 0;
+  }
+  for (const [key, value] of Object.entries(env)) {
+    if (value === namespace) {
+      return key;
+    }
+  }
+  return void 0;
+};
 const constantTimeEqual = (expected, supplied) => {
   const max = Math.max(expected.length, supplied.length);
   let diff = expected.length ^ supplied.length;
@@ -1740,6 +1836,31 @@ const checkAdminWsToken = (request, expected) => {
 };
 const createWorker = (options) => {
   const defaultShard = options.defaultShardKey ?? "__root__";
+  const shardDO = applyJurisdiction(options.shardDO, options.jurisdiction);
+  const schedulerDO = options.schedulerDO === void 0 ? void 0 : applyJurisdiction(options.schedulerDO, options.jurisdiction);
+  let envAdminToken;
+  const effectiveAdminToken = () => options.adminToken ?? envAdminToken;
+  const resolveAdminTokenFromEnv = (env) => {
+    if (envAdminToken !== void 0 || options.adminToken !== void 0) {
+      return;
+    }
+    const value = (env ?? {})["LUNORA_ADMIN_TOKEN"];
+    if (typeof value === "string" && value.length > 0) {
+      envAdminToken = value;
+    }
+  };
+  const accessAdminGrants = /* @__PURE__ */ new WeakSet();
+  const requestIsAdmin = (request) => checkAdminAuth(request, effectiveAdminToken()) || accessAdminGrants.has(request);
+  const resolveAdminForwardContext = async (request, env) => {
+    const context = await resolveForwardContext(request, env, options.resolveIdentity);
+    if (accessAdminGrants.has(request) && context.headers["authorization"] === void 0) {
+      const token = effectiveAdminToken();
+      if (token !== void 0) {
+        context.headers["authorization"] = `Bearer ${token}`;
+      }
+    }
+    return context;
+  };
   const hasAnyShardAuth = Boolean(options.authorizeShard) || Boolean(options.authorizeFanOut);
   let warnedUnauthenticatedShardAccess = false;
   const warnUnauthenticatedShardAccessOnce = (kind) => {
@@ -1758,10 +1879,10 @@ const createWorker = (options) => {
   const orchestrationAdminRoutes = buildOrchestrationAdminRoutes({
     defaultShard,
     forwardToShard,
-    isAdmin: (request) => checkAdminAuth(request, options.adminToken),
+    isAdmin: requestIsAdmin,
     queryCoordinator: options.queryCoordinator,
-    resolveForwardContext: (request, env) => resolveForwardContext(request, env, options.resolveIdentity),
-    shardDO: options.shardDO
+    resolveForwardContext: resolveAdminForwardContext,
+    shardDO
   });
   const dispatchToShard = async (functionPath, args, shardKey) => {
     if (options.authorizeShard) {
@@ -1779,7 +1900,7 @@ const createWorker = (options) => {
       headers: { "content-type": "application/json", "x-lunora-system": "1" },
       method: "POST"
     });
-    return forwardToShard(options.shardDO, shardKey, forwarded);
+    return forwardToShard(shardDO, shardKey, forwarded);
   };
   const startCronWorkflow = async (binding, job, env) => {
     const candidate = env?.[binding];
@@ -1824,7 +1945,7 @@ const createWorker = (options) => {
     }
   };
   const handleRunCronJob = async (request, env) => {
-    if (!checkAdminAuth(request, options.adminToken)) {
+    if (!requestIsAdmin(request)) {
       throw new LunoraError("admin endpoint requires a valid admin bearer", { code: "ADMIN_FORBIDDEN", status: 403 });
     }
     if (request.method !== "POST") {
@@ -1847,12 +1968,12 @@ const createWorker = (options) => {
   };
   const releasePoolSlot = async (candidate) => {
     const pool = typeof candidate.pool === "string" && candidate.pool.length > 0 ? candidate.pool : void 0;
-    if (!pool || !options.schedulerDO || typeof candidate.id !== "string") {
+    if (!pool || !schedulerDO || typeof candidate.id !== "string") {
       return;
     }
     const instanceName = typeof candidate.instanceName === "string" && candidate.instanceName.length > 0 ? candidate.instanceName : "default";
     try {
-      await options.schedulerDO.get(options.schedulerDO.idFromName(instanceName)).fetch(
+      await schedulerDO.get(schedulerDO.idFromName(instanceName)).fetch(
         new Request("https://scheduler.internal/complete", {
           body: JSON.stringify({ id: candidate.id, pool }),
           headers: { "content-type": "application/json" },
@@ -1898,17 +2019,17 @@ const createWorker = (options) => {
   };
   const dataMovementAdminRoutes = buildDataMovementAdminRoutes({
     applyGlobals: options.applyGlobals,
-    isAdmin: (request) => checkAdminAuth(request, options.adminToken),
+    isAdmin: requestIsAdmin,
     knownTables: () => collectKnownTables(),
     queryCoordinator: options.queryCoordinator,
-    resolveForwardContext: (request, env) => resolveForwardContext(request, env, options.resolveIdentity),
-    shardDO: options.shardDO,
-    streamExportRows: (coordinator, headers, tables, writeRow) => streamExportRows(options, coordinator, headers, tables, writeRow),
-    streamingImport: (request, headers) => streamingImport(request, options, headers),
+    resolveForwardContext: resolveAdminForwardContext,
+    shardDO,
+    streamExportRows: (coordinator, headers, tables, writeRow) => streamExportRows(options, coordinator, headers, tables, writeRow, shardDO),
+    streamingImport: (request, headers) => streamingImport(request, options, headers, shardDO),
     syncGlobals: options.syncGlobals
   });
   const assertAdminAuthorized = (request) => {
-    if (!checkAdminAuth(request, options.adminToken)) {
+    if (!requestIsAdmin(request)) {
       throw new LunoraError("admin endpoint requires a valid admin bearer", { code: "ADMIN_FORBIDDEN", status: 403 });
     }
   };
@@ -1935,17 +2056,17 @@ const createWorker = (options) => {
     };
   };
   const requireSchedulerNamespace = () => {
-    if (options.schedulerDO === void 0) {
+    if (schedulerDO === void 0) {
       throw new LunoraError("scheduled endpoints require a `schedulerDO` namespace on the worker", { code: "SCHEDULER_NOT_CONFIGURED", status: 400 });
     }
-    return options.schedulerDO;
+    return schedulerDO;
   };
   const resolveSchedulerStub = (request) => {
     assertAdminAuthorized(request);
     return resolveShard(requireSchedulerNamespace(), options.schedulerInstanceName ?? "default");
   };
   const scheduledAdminRoutes = buildScheduledAdminRoutes({
-    checkWsAdmin: (request) => checkAdminAuth(request, options.adminToken) || checkAdminWsToken(request, options.adminToken),
+    checkWsAdmin: (request) => requestIsAdmin(request) || checkAdminWsToken(request, effectiveAdminToken()),
     requireSchedulerNamespace,
     resolveSchedulerStub,
     schedulerInstanceName: options.schedulerInstanceName ?? "default"
@@ -1998,7 +2119,7 @@ const createWorker = (options) => {
         headers,
         method: "POST"
       });
-      const response = await forwardToShard(options.shardDO, defaultShard, forwarded);
+      const response = await forwardToShard(shardDO, defaultShard, forwarded);
       const payload = await response.json();
       if (payload.error) {
         throw new LunoraError(payload.error.message ?? "shard RPC failed", {
@@ -2061,7 +2182,16 @@ const createWorker = (options) => {
     if (forwardedExp !== void 0) {
       upgradeHeaders.set("x-lunora-identity-exp", forwardedExp);
     }
-    return forwardToShard(options.shardDO, shardKey, new Request(request, { headers: upgradeHeaders }));
+    const binding = resolveShardBindingName(env, options.shardDO);
+    if (binding !== void 0) {
+      upgradeHeaders.set("x-lunora-shard-binding", binding);
+      const relayCount = await probeRelayCount(shardDO, shardKey);
+      if (relayCount > 0) {
+        const target = relayName(shardKey, Math.floor(Math.random() * relayCount));
+        return forwardToShard(shardDO, target, new Request(request, { headers: upgradeHeaders }));
+      }
+    }
+    return forwardToShard(shardDO, shardKey, new Request(request, { headers: upgradeHeaders }));
   };
   const authorizeRpcEnvelope = async (envelope, identity) => {
     if (envelope.fanOut) {
@@ -2107,7 +2237,7 @@ const createWorker = (options) => {
       method: "POST"
     });
     try {
-      const response = await forwardToShard(options.shardDO, shardKey, forwarded);
+      const response = await forwardToShard(shardDO, shardKey, forwarded);
       emitRpcEvent(
         observability,
         {
@@ -2136,6 +2266,7 @@ const createWorker = (options) => {
       throw new LunoraError("RPC endpoint requires POST", { code: "METHOD_NOT_ALLOWED", status: 405 });
     }
     const envelope = await parseEnvelope(request);
+    logRpcDebug(env, envelope);
     if (envelope.fanOut && envelope.shardKey) {
       throw new LunoraError("RPC envelope cannot set both `shardKey` and `fanOut`", { code: "BAD_REQUEST", status: 400 });
     }
@@ -2158,7 +2289,7 @@ const createWorker = (options) => {
       const { observability } = options;
       const sinkContext = context ? {
         waitUntil: (promise) => {
-          context.waitUntil(promise);
+          context.waitUntil?.(promise);
         }
       } : void 0;
       if (envelope.fanOut) {
@@ -2170,7 +2301,7 @@ const createWorker = (options) => {
           });
         }
         try {
-          const result = await coordinator.fanOut(options.shardDO, {
+          const result = await coordinator.fanOut(shardDO, {
             args: envelope.args ?? {},
             fanOut: envelope.fanOut,
             functionPath: envelope.functionPath,
@@ -2207,6 +2338,119 @@ const createWorker = (options) => {
       return dispatchSingleShard(envelope.functionPath, envelope.args ?? {}, shardKey, forwardedHeaders, sinkContext);
     }
   };
+  const handleBatchRpc = async (request, env, context) => {
+    if (request.method !== "POST") {
+      throw new LunoraError("RPC batch endpoint requires POST", { code: "METHOD_NOT_ALLOWED", status: 405 });
+    }
+    const text = await readBodyTextWithLimit(request);
+    let body;
+    try {
+      body = JSON.parse(text);
+    } catch {
+      throw new LunoraError("RPC batch body must be valid JSON", { code: "BAD_REQUEST", status: 400 });
+    }
+    if (typeof body !== "object" || body === null || Array.isArray(body)) {
+      throw new LunoraError("RPC batch body must be an object", { code: "BAD_REQUEST", status: 400 });
+    }
+    const { calls } = body;
+    if (!Array.isArray(calls)) {
+      throw new LunoraError("RPC batch `calls` must be an array", { code: "BAD_REQUEST", status: 400 });
+    }
+    const { headers: forwardedHeaders, identity } = await resolveForwardContext(request, env, options.resolveIdentity);
+    const groups = groupBatchCallsByShard(calls, defaultShard);
+    await Promise.all(
+      [...groups.entries()].flatMap(
+        ([shardKey, entries]) => entries.map((entry) => authorizeRpcEnvelope({ functionPath: entry.functionPath, shardKey }, identity))
+      )
+    );
+    const { observability } = options;
+    const sinkContext = context ? {
+      waitUntil: (promise) => {
+        context.waitUntil?.(promise);
+      }
+    } : void 0;
+    const results = [];
+    let latestBookmark;
+    const slotError = (entry, status, code, message) => {
+      return { body: { error: { code, message } }, id: entry.id, status };
+    };
+    const failSubBatch = (entries, status, code, message, eventFor) => {
+      for (const entry of entries) {
+        emitRpcEvent(observability, eventFor(entry), sinkContext);
+        results.push(slotError(entry, status, code, message));
+      }
+    };
+    const emitEntryEvents = (entries, shardKey, durationMs, statusById, fallbackStatus) => {
+      for (const entry of entries) {
+        const status = statusById.get(entry.id) ?? fallbackStatus;
+        const ok = status < 400;
+        emitRpcEvent(
+          observability,
+          {
+            durationMs,
+            functionPath: entry.functionPath,
+            ok,
+            shardKey,
+            ...ok ? {} : { error: { code: "SHARD_ERROR", message: `batched call returned ${String(status)}`, status } }
+          },
+          sinkContext
+        );
+      }
+    };
+    await Promise.all(
+      [...groups.entries()].map(async ([shardKey, entries]) => {
+        const headers = new Headers(forwardedHeaders);
+        headers.set("content-type", "application/json");
+        const subRequest = new Request("https://shard.internal/rpc-batch", { body: JSON.stringify({ calls: entries }), headers, method: "POST" });
+        const subStartedAt = Date.now();
+        let response;
+        try {
+          response = await forwardToShard(shardDO, shardKey, subRequest);
+        } catch (error) {
+          const durationMs2 = Date.now() - subStartedAt;
+          const message = error instanceof Error ? error.message : String(error);
+          failSubBatch(entries, 502, "SHARD_UNAVAILABLE", message, (entry) => buildErrorEvent(entry.functionPath, durationMs2, error, { shardKey }));
+          return;
+        }
+        const durationMs = Date.now() - subStartedAt;
+        const bookmark = response.headers.get("x-d1-bookmark");
+        if (bookmark) {
+          latestBookmark = bookmark;
+        }
+        let parsed;
+        try {
+          parsed = await response.json();
+        } catch {
+          const message = `shard batch returned a non-JSON response (${String(response.status)})`;
+          failSubBatch(entries, response.status, "SHARD_ERROR", message, (entry) => {
+            return {
+              durationMs,
+              error: { code: "SHARD_ERROR", message, status: response.status },
+              functionPath: entry.functionPath,
+              ok: false,
+              shardKey
+            };
+          });
+          return;
+        }
+        const entryResults = Array.isArray(parsed.results) ? parsed.results : [];
+        const statusById = new Map(entryResults.map((entry) => [entry.id, entry.status ?? response.status]));
+        const seenIds = new Set(entryResults.map((entry) => entry.id));
+        emitEntryEvents(entries, shardKey, durationMs, statusById, response.status);
+        results.push(...entryResults);
+        for (const entry of entries) {
+          if (!seenIds.has(entry.id)) {
+            results.push(slotError(entry, response.status, "SHARD_ERROR", `shard batch omitted result for call ${String(entry.id)}`));
+          }
+        }
+      })
+    );
+    const responseHeaders = { "content-type": "application/json" };
+    if (latestBookmark !== void 0) {
+      responseHeaders["x-d1-bookmark"] = latestBookmark;
+    }
+    return Response.json({ results }, { headers: responseHeaders, status: 200 });
+  };
   const serverQuery = async (request, env, reference, args = {}, callOptions = {}) => {
     try {
       const functionPath = reference.__lunoraRef;
@@ -2279,7 +2523,7 @@ const createWorker = (options) => {
           streamController.enqueue(encoded);
         };
         try {
-          await streamExportRows(options, coordinator, forwardedHeaders, tables, writeRow);
+          await streamExportRows(options, coordinator, forwardedHeaders, tables, writeRow, shardDO);
           streamController.close();
         } catch (error) {
           streamError = error instanceof Error ? error : new Error(String(error));
@@ -2348,7 +2592,7 @@ const createWorker = (options) => {
         headers: { authorization: `Bearer ${adminBearer}`, "content-type": "application/json" },
         method: "POST"
       });
-      await forwardToShard(options.shardDO, defaultShard, recordRequest);
+      await forwardToShard(shardDO, defaultShard, recordRequest);
     } catch {
     }
   };
@@ -2362,13 +2606,15 @@ const createWorker = (options) => {
     }
     const basePath = options.authBasePath ?? DEFAULT_AUTH_BASE_PATH;
     if (isAuthAttemptPath(url.pathname, basePath)) {
-      context.waitUntil(recordAuthAttempt(env, authResponse.status >= 400 ? "fail" : "ok"));
+      context.waitUntil?.(recordAuthAttempt(env, authResponse.status >= 400 ? "fail" : "ok"));
     }
     return authResponse;
   };
+  const customRoutes = options.routes !== void 0 && Object.keys(options.routes).length > 0 ? options.routes : void 0;
   const internalRoutes = {
     [WS_PATH]: (request, env, url) => handleWebSocketUpgrade(request, env, url),
     [RPC_PATH]: (request, env, _url, context) => handleRpc(request, env, context),
+    [RPC_BATCH_PATH]: (request, env, _url, context) => handleBatchRpc(request, env, context),
     [SCHEDULER_DISPATCH_PATH]: (request, env) => handleSchedulerDispatch(request, env),
     [CRON_JOBS_RUN_PATH]: (request, env) => handleRunCronJob(request, env),
     // Extracted handler clusters built above, merged in (mirroring the auth
@@ -2402,6 +2648,17 @@ const createWorker = (options) => {
       resolvedSecurity = resolveSecurity(options.security, env ?? {});
     }
   };
+  const applyAdminGate = async (request, pathname) => {
+    if (options.adminGate === void 0 || !isAdminPath(pathname)) {
+      return;
+    }
+    try {
+      if (await options.adminGate(request)) {
+        accessAdminGrants.add(request);
+      }
+    } catch {
+    }
+  };
   const handle = async (request, env, context) => {
     const url = new URL(request.url);
     if (request.method === "POST" || request.method === "PUT") {
@@ -2414,13 +2671,16 @@ const createWorker = (options) => {
     if (authResponse) {
       return authResponse;
     }
-    const methodAndPath = `${request.method} ${url.pathname}`;
-    const route = options.routes?.[methodAndPath] ?? options.routes?.[url.pathname];
-    if (route) {
-      return route(request, env, context);
+    if (customRoutes) {
+      const methodAndPath = `${request.method} ${url.pathname}`;
+      const route = customRoutes[methodAndPath] ?? customRoutes[url.pathname];
+      if (route) {
+        return route(request, env, context);
+      }
     }
     const internalRoute = internalRoutes[url.pathname];
     if (internalRoute) {
+      await applyAdminGate(request, url.pathname);
       return internalRoute(request, env, url, context);
     }
     const httpRouteResponse = await dispatchHttpRoute(request, env, context);
@@ -2432,9 +2692,10 @@ const createWorker = (options) => {
   return {
     async fetch(request, env, context) {
       if (options.passThroughOnException) {
-        context.passThroughOnException();
+        context.passThroughOnException?.();
       }
       ensureSecurityResolved(env);
+      resolveAdminTokenFromEnv(env);
       const preflight = handleCorsPreflight(request, resolvedSecurity);
       if (preflight) {
         return preflight;
@@ -2450,6 +2711,9 @@ const createWorker = (options) => {
         return decorateResponse(toErrorResponse(error), request, resolvedSecurity);
       }
     },
+    async queue(batch, env, context) {
+      await options.queue?.(batch, env, context);
+    },
     async scheduled(controller, env, context) {
       await handleScheduled(controller, env, context);
     },
@@ -2480,10 +2744,24 @@ const withFrameworkWorker = (host, optionsInput) => {
   const optionsFactory = optionsInput;
   return {
     fetch: (request, env, context) => build(optionsFactory(env)).fetch(request, env, context),
+    queue: (batch, env, context) => build(optionsFactory(env)).queue?.(batch, env, context) ?? Promise.resolve(),
     scheduled: (controller, env, context) => build(optionsFactory(env)).scheduled(controller, env, context),
     serverQuery: (request, env, reference, args, options) => build(optionsFactory(env)).serverQuery(request, env, reference, args, options)
   };
 };
+const resolveLunoraOptions = (options, env) => {
+  if (typeof options === "function") {
+    return options(env);
+  }
+  const shardDO = options.shardDO ?? env?.SHARD;
+  if (!shardDO) {
+    throw new Error(
+      "@lunora/runtime: no shard Durable Object namespace found. Bind `SHARD` in wrangler.jsonc, or pass `createLunoraHandler({ shardDO: env.MY_SHARD })`."
+    );
+  }
+  return { ...options, shardDO };
+};
+const createLunoraHandler = (options = {}) => (request, env, context) => createWorker(resolveLunoraOptions(options, env)).fetch(request, env, context ?? NOOP_EXECUTION_CONTEXT);
 const defineRpcEnvelope = (envelope) => envelope;
 
-export { composeWorker, createWorker, defineRpcEnvelope, withFrameworkWorker };
+export { NOOP_EXECUTION_CONTEXT, composeWorker, createLunoraHandler, createWorker, defineRpcEnvelope, resolveLunoraOptions, withFrameworkWorker };

package/dist/packem_shared/{createQueryCoordinator-DbxC7iUz.mjs → createQueryCoordinator-Cbds9cUI.mjs}

@@ -1,5 +1,5 @@
 import { LunoraError } from './LunoraError-CL0aOtpo.mjs';
-import { resolveShard } from './resolveShard-DDkzWtrU.mjs';
+import { resolveShard } from './applyJurisdiction-BkZtTkct.mjs';
 
 const createStaticShardRegistry = (table_to_keys) => {
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/runtime",
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0-alpha.11",
   "description": "Lunora Worker runtime: the RPC router, shard resolver, and query coordinator",
   "keywords": [
     "cloudflare",
@@ -25,7 +25,7 @@
     "directory": "packages/runtime"
   },
   "files": [
-    "dist",
+    "./dist",
     "README.md",
     "LICENSE.md",
     "__assets__"

package/dist/packem_shared/resolveShard-DDkzWtrU.mjs

@@ -1,9 +0,0 @@
-const resolveShard = (namespace, shardKey) => {
-  if (typeof namespace.getByName === "function") {
-    return namespace.getByName(shardKey);
-  }
-  const id = namespace.idFromName(shardKey);
-  return namespace.get(id);
-};
-
-export { resolveShard };