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

package/dist/packem_shared/{composeWorker-BYHiNH_V.mjs → composeWorker-BEv9IBWS.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,
@@ -597,14 +601,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 +622,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 +744,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 +753,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 +970,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 +1227,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 +1506,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"));
@@ -1557,6 +1561,9 @@ const RPC_PATH = "/_lunora/rpc";
 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 +1605,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 +1619,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 +1677,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 +1713,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 +1796,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 +1839,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 +1860,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 +1905,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 +1928,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 +1979,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 +2016,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 +2079,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 +2142,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 +2197,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 +2226,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 +2249,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 +2261,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,
@@ -2279,7 +2370,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 +2439,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,10 +2453,11 @@ 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),
@@ -2402,6 +2494,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 +2517,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 +2538,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 +2557,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 +2590,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.10",
   "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 };