@requence/service 0.8.5-edge.1210 → 0.8.5-edge.1212

package/build/index.js

@@ -1,26 +1,57 @@
 import {
-  CAPABILITY_HEADER_KEYS,
-  PayloadTooLargeError,
-  RequenceConnectionError,
-  RequenceUnreachableError,
-  UITooLargeError,
-  UnsupportedCapabilityError,
-  __commonJS,
-  __toESM,
-  assertReachable,
-  buildServiceClientProperties,
-  buildServiceIdentityHeaders,
-  deobfuscate,
-  isUnreachableStatus,
   obfuscate,
-  reachableFetch,
-  readRequiredCapabilities,
+  deobfuscate,
   simple_default,
-  unsupportedCapabilities
-} from "./chunk-n7ayk1td.js";
+  buildServiceClientProperties,
+  CAPABILITY_HEADER_KEYS,
+  readRequiredCapabilities,
+  unsupportedCapabilities,
+  buildServiceIdentityHeaders,
+  RequenceConnectionError2,
+  RequenceUnreachableError2,
+  isUnreachableStatus2,
+  assertReachable2,
+  reachableFetch2,
+  UITooLargeError2,
+  UnsupportedCapabilityError2,
+  PayloadTooLargeError2
+} from "./chunk-6dx6x31h.js";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 
 // ../../node_modules/.bun/dlv@1.1.3/node_modules/dlv/dist/dlv.js
-var require_dlv = __commonJS((exports, module) => {
+var require_dlv = __commonJS(function(exports, module) {
   module.exports = function(t, e, l, n, o) {
     for (e = e.split ? e.split(".") : e, n = 0;n < e.length; n++)
       t = t ? t[e[n]] : o;
@@ -54,45 +85,45 @@ class AbortMapData extends Error {
 }
 function mapData(data, visitors) {
   let aborted = false;
-  const traverseData = (data2, path) => {
+  const traverseData = (data, path) => {
     if (aborted) {
-      return data2;
+      return data;
     }
     try {
-      if (Array.isArray(data2)) {
-        return resolve(visitors.Array?.(data2, path), (resolvedData) => {
+      if (Array.isArray(data)) {
+        return resolve(visitors.Array?.(data, path), (resolvedData) => {
           if (resolvedData) {
             return resolvedData;
           }
-          const items = data2.map((item, index) => traverseData(item, [...path, index]));
+          const items = data.map((item, index) => traverseData(item, [...path, index]));
           if (items.some((item) => item instanceof Promise)) {
             return Promise.all(items);
           }
           return items;
         });
       }
-      if (data2 === null) {
-        return notUndefined(visitors.Null?.(data2, path), data2);
+      if (data === null) {
+        return notUndefined(visitors.Null?.(data, path), data);
       }
       const runtimeBuffer = globalThis.Buffer;
-      if (runtimeBuffer?.isBuffer(data2)) {
-        return notUndefined(visitors.Buffer?.(data2, path), data2);
+      if (runtimeBuffer?.isBuffer(data)) {
+        return notUndefined(visitors.Buffer?.(data, path), data);
       }
-      if (typeof data2 === "string") {
-        return notUndefined(visitors.String?.(data2, path), data2);
+      if (typeof data === "string") {
+        return notUndefined(visitors.String?.(data, path), data);
       }
-      if (typeof data2 === "number") {
-        return notUndefined(visitors.Number?.(data2, path), data2);
+      if (typeof data === "number") {
+        return notUndefined(visitors.Number?.(data, path), data);
       }
-      if (typeof data2 === "symbol") {
-        return notUndefined(visitors.Symbol?.(data2, path), data2);
+      if (typeof data === "symbol") {
+        return notUndefined(visitors.Symbol?.(data, path), data);
       }
-      if (typeof data2 === "function") {
-        return notUndefined(visitors.Function?.(data2, path), data2);
+      if (typeof data === "function") {
+        return notUndefined(visitors.Function?.(data, path), data);
       }
-      if (isRecord(data2)) {
-        return resolve(visitors.Object?.({ ...data2 }, path), (resolvedData) => {
-          const nextData = resolvedData ?? data2;
+      if (isRecord(data)) {
+        return resolve(visitors.Object?.({ ...data }, path), (resolvedData) => {
+          const nextData = resolvedData ?? data;
           if (!isRecord(nextData)) {
             return nextData;
           }
@@ -101,19 +132,19 @@ function mapData(data, visitors) {
             traverseData(value, [...path, key])
           ]);
           if (entries.some(([, value]) => value instanceof Promise)) {
-            return Promise.all(entries.map(([key, value]) => Promise.resolve().then(() => value).then((resolvedValue) => [key, resolvedValue]))).then((entries2) => Object.fromEntries(entries2));
+            return Promise.all(entries.map(([key, value]) => Promise.resolve().then(() => value).then((resolvedValue) => [key, resolvedValue]))).then((entries) => Object.fromEntries(entries));
           }
           return Object.fromEntries(entries);
         });
       }
-      if (typeof data2 === "object" && data2) {
-        return notUndefined(visitors.Object?.(data2, path), data2);
+      if (typeof data === "object" && data) {
+        return notUndefined(visitors.Object?.(data, path), data);
       }
-      return data2;
+      return data;
     } catch (error) {
       if (error instanceof AbortMapData) {
         aborted = true;
-        return data2;
+        return data;
       }
       throw error;
     }
@@ -203,10 +234,10 @@ function isCallbackObject(data) {
   return callbackObjectSchema.safeParse(data).success;
 }
 function createCallback(callback) {
-  const { promise, resolve: resolve2 } = Promise.withResolvers();
+  const { promise, resolve } = Promise.withResolvers();
   const executor = (arg) => {
     const value = arg === undefined ? null : arg;
-    resolve2(value);
+    resolve(value);
     callback?.(value);
   };
   return Object.assign(executor, {
@@ -1336,9 +1367,9 @@ function createOutboundBoundary(base) {
       };
       if (opts.bestEffort) {
         try {
-          const { value: value2, done: done2 } = await withRequenceStreams(() => transformer.outbound(sanitizeLogData(data), ctx));
-          ledger.push(done2.then(() => {}, (error) => warn("log stream upload failed:", error)));
-          return value2;
+          const { value, done } = await withRequenceStreams(() => transformer.outbound(sanitizeLogData(data), ctx));
+          ledger.push(done.then(() => {}, (error) => warn("log stream upload failed:", error)));
+          return value;
         } catch (error) {
           warn("log offload errored:", error);
           return;
@@ -2008,7 +2039,7 @@ function createConnection({
       clientProperties: {
         ...connectionOptions?.clientProperties,
         ...buildServiceClientProperties({
-          libVersion: "javascript@0.8.5-edge.1210",
+          libVersion: "javascript@0.8.5-edge.1212",
           serviceVersion: version,
           connectionId,
           prefetch,
@@ -2033,7 +2064,7 @@ function createConnection({
     hasConnected = true;
     onConnectionStateChange?.({ connected: true });
   });
-  const connectedPromise = new Promise((resolve2, reject) => {
+  const connectedPromise = new Promise((resolve, reject) => {
     const unsubscribe = () => {
       clearTimeout(timeout);
       connection.removeListener("connect", handleConnect);
@@ -2041,17 +2072,17 @@ function createConnection({
     };
     const timeout = setTimeout(() => {
       handleConnectFailed({
-        err: new RequenceConnectionError("Requence connection timeout")
+        err: new RequenceConnectionError2("Requence connection timeout")
       });
     }, connectionTimeout);
     const handleConnect = () => {
       unsubscribe();
-      resolve2();
+      resolve();
     };
     const handleConnectFailed = ({ err }) => {
       unsubscribe();
       if (err.message.startsWith("Handshake terminated by server: 403 (ACCESS-REFUSED)")) {
-        reject(new RequenceConnectionError("Invalid service credentials"));
+        reject(new RequenceConnectionError2("Invalid service credentials"));
       } else {
         reject(err);
       }
@@ -2099,7 +2130,7 @@ function createConnection({
           case "callback": {
             const { surface } = backchannelMessage.payload;
             const { taskId } = backchannelMessage;
-            const report = surface && taskId ? (message2) => reportInteractionFailure({ taskId, surface, message: message2 }) : () => {};
+            const report = surface && taskId ? (message) => reportInteractionFailure({ taskId, surface, message }) : () => {};
             const entry = callbacks.get(backchannelMessage.payload.callbackId);
             if (!entry) {
               simple_default.warn(`Requence: dropped an invocation of callback |${backchannelMessage.payload.callbackId}| — nothing is registered under it, so the message that registered it has settled`);
@@ -2156,10 +2187,10 @@ function createConnection({
       simple_default.error("Requence: cannot report a failed durable callback — the invocation names no task and node");
       return;
     }
-    const { taskId, nodeId, name: name2 } = parsed.data;
+    const { taskId, nodeId, name } = parsed.data;
     channelWrapper.publish(exchange, "", Buffer.from(JSON.stringify({
       nodeId,
-      name: name2,
+      name,
       message: (error instanceof Error ? error.message : String(error)).slice(0, MAX_DURABLE_CALLBACK_ERROR_CHARS)
     })), {
       contentType: "application/json",
@@ -2169,7 +2200,7 @@ function createConnection({
         [DURABLE_CALLBACK_ERROR_HEADER]: true
       }
     }).catch((publishError) => {
-      simple_default.error(`Requence: could not report the failed durable callback |${name2}| of task |${taskId}|:`, publishError instanceof Error ? publishError.message : publishError);
+      simple_default.error(`Requence: could not report the failed durable callback |${name}| of task |${taskId}|:`, publishError instanceof Error ? publishError.message : publishError);
     });
   };
   const announceResume = (params) => {
@@ -2218,8 +2249,8 @@ function createConnection({
       simple_default.error("Requence: dropped a malformed surface handler invocation:", parsed.error.message);
       return;
     }
-    const { taskId, surface, uiId, path: path2, arg } = parsed.data;
-    const where = `UI |${uiId}| prop |${path2.join(".") || "<root>"}| (task |${taskId}|)`;
+    const { taskId, surface, uiId, path, arg } = parsed.data;
+    const where = `UI |${uiId}| prop |${path.join(".") || "<root>"}| (task |${taskId}|)`;
     const report = (message) => reportInteractionFailure({ taskId, surface, message });
     const ui = findUIById(uiId);
     if (!ui) {
@@ -2227,10 +2258,10 @@ function createConnection({
       report(`the service has no component registered as "${uiId}", so nothing ran the handler`);
       return;
     }
-    const handler = getByPath(ui.defaults, path2);
+    const handler = getByPath(ui.defaults, path);
     if (typeof handler !== "function") {
       simple_default.error(`Requence: no handler at ${where} — the component's defaults have ${handler === undefined ? "nothing" : typeof handler} there`);
-      report(`this component has no handler at "${path2.join(".") || "<root>"}", so nothing ran`);
+      report(`this component has no handler at "${path.join(".") || "<root>"}", so nothing ran`);
       return;
     }
     try {
@@ -2265,12 +2296,12 @@ function createConnection({
       simple_default.error("Requence: dropped a malformed durable callback invocation — it does not name a callback this build can run");
       return;
     }
-    const { name: name2, bound, arg, configuration, taskId, nodeId } = parsed.data;
-    const registration = findDurableCallback(name2);
+    const { name, bound, arg, configuration, taskId, nodeId } = parsed.data;
+    const registration = findDurableCallback(name);
     if (!registration) {
-      throw new Error(`no durable callback registered as "${name2}" — a reference naming it was emitted by node ${nodeId} of task ${taskId}, and this version declares none`);
+      throw new Error(`no durable callback registered as "${name}" — a reference naming it was emitted by node ${nodeId} of task ${taskId}, and this version declares none`);
     }
-    await registration.handler(arg, durableCallbackContext(name2, bound, configuration));
+    await registration.handler(arg, durableCallbackContext(name, bound, configuration));
   }
   const callbackQueue = serviceCallbackQueueName(queue);
   const callbackChannelWrapper = connection.createChannel({
@@ -2313,7 +2344,7 @@ function createConnection({
   }) => {
     const { body, contentType } = encodeWireBody(data ?? null, messageCodecs.get(messageId) ?? "json");
     if (body.byteLength > maxMessageSize) {
-      return Promise.reject(new PayloadTooLargeError(body.byteLength, maxMessageSize));
+      return Promise.reject(new PayloadTooLargeError2(body.byteLength, maxMessageSize));
     }
     return channelWrapper.publish(exchange, "", body, {
       correlationId: messageId,
@@ -2368,13 +2399,13 @@ function createConnection({
   };
   const buildRender = (deps) => {
     const registerSurfaceHandler = (ui, handler, payloadPath) => {
-      const [layer, ...path2] = payloadPath;
+      const [layer, ...path] = payloadPath;
       if (layer === "defaults") {
         return {
           __REQUENCE_type: SURFACE_HANDLER_TAG,
           lifetime: "durable",
           uiId: ui.id,
-          path: path2
+          path
         };
       }
       if (layer !== "props") {
@@ -2385,7 +2416,7 @@ function createConnection({
         __REQUENCE_type: SURFACE_HANDLER_TAG,
         lifetime: "connection",
         uiId: ui.id,
-        path: path2,
+        path,
         connectionId: sourceId,
         handlerId: callbackId
       };
@@ -2410,7 +2441,7 @@ function createConnection({
       }, {
         outputName: null,
         inlineKeys: ["component", "defaults"],
-        onSurfaceHandler: (handler, path2) => registerSurfaceHandler(params.ui, handler, path2)
+        onSurfaceHandler: (handler, path) => registerSurfaceHandler(params.ui, handler, path)
       }).then((data) => publish({
         index,
         version,
@@ -2448,7 +2479,7 @@ function createConnection({
         messageIdForCleanup = messageId;
         const unsupported = unsupportedCapabilities(readRequiredCapabilities(message.properties.headers));
         if (unsupported.length > 0) {
-          throw new UnsupportedCapabilityError(unsupported);
+          throw new UnsupportedCapabilityError2(unsupported);
         }
         const dispatchCodec = wireCodecFromContentType(message.properties.contentType);
         messageCodecs.set(messageId, dispatchCodec);
@@ -2465,14 +2496,14 @@ function createConnection({
         const payload = payloadSchema.parse(message);
         const abortController = new AbortController;
         const growth = callbackGrowth.forDelivery({ taskId });
-        const registerCallback = (callback, path2) => {
+        const registerCallback = (callback, path) => {
           const callbackId = crypto.randomUUID();
           registeredCallbackIds.add(callbackId);
           callbacks.set(callbackId, {
             callback,
             onCallbackInvoke: dispatchInvocation
           });
-          growth.record(path2);
+          growth.record(path);
           return { sourceId: connectionId, callbackId };
         };
         const outbound = createOutboundBoundary({
@@ -2569,7 +2600,7 @@ function createConnection({
           begin: true,
           epoch,
           ...buildServiceIdentityHeaders({
-            libVersion: "javascript@0.8.5-edge.1210",
+            libVersion: "javascript@0.8.5-edge.1212",
             name,
             holdsSlot: !(isGeneratorHandler && mode === "CONTINUOUS")
           })
@@ -2660,7 +2691,7 @@ function createConnection({
             });
           }
         }
-        await new Promise((resolve2, reject) => {
+        await new Promise((resolve, reject) => {
           setImmediate(async () => {
             try {
               if (!deferred) {
@@ -2680,7 +2711,7 @@ function createConnection({
               if (!acked) {
                 safeAck(channel, message);
               }
-              resolve2();
+              resolve();
             } catch (error) {
               reject(error);
             }
@@ -2708,7 +2739,7 @@ function createConnection({
           });
           return;
         }
-        if (error instanceof UnsupportedCapabilityError) {
+        if (error instanceof UnsupportedCapabilityError2) {
           if (!silent) {
             simple_default.error(error.message);
           }
@@ -2816,14 +2847,14 @@ function createConnection({
         const registeredCallbackIds = new Set;
         const outbound = createOutboundBoundary(options);
         const growth = callbackGrowth.forDelivery({ taskId });
-        const registerCallback = (callback, path2) => {
+        const registerCallback = (callback, path) => {
           const callbackId = crypto.randomUUID();
           registeredCallbackIds.add(callbackId);
           callbacks.set(callbackId, {
             callback,
             onCallbackInvoke: dispatchInvocation
           });
-          growth.record(path2);
+          growth.record(path);
           return { sourceId: connectionId, callbackId };
         };
         const dispatchInvocation = (invocation) => {
@@ -2888,7 +2919,7 @@ function createConnection({
           } else if (result !== undefined) {
             await sendApi.send(result);
           }
-          await new Promise((resolve2) => setImmediate(resolve2));
+          await new Promise((resolve) => setImmediate(resolve));
           await activeMessage();
           await outbound.settle();
         } catch (error) {
@@ -2926,18 +2957,18 @@ function createUI(target, defaults) {
   if (!(options?.url instanceof URL) || options.url.protocol !== "file:") {
     throw new Error("createUI needs a file URL to the built component: new URL('./component.js', import.meta.url)");
   }
-  const path2 = fileURLToPath(options.url);
-  const bundle = fs2.readFileSync(path2);
+  const path = fileURLToPath(options.url);
+  const bundle = fs2.readFileSync(path);
   if (bundle.byteLength > MAX_UI_SOURCE_BYTES) {
-    throw new UITooLargeError(path2, bundle.byteLength, MAX_UI_SOURCE_BYTES);
+    throw new UITooLargeError2(path, bundle.byteLength, MAX_UI_SOURCE_BYTES);
   }
   const ui = {
-    id: options.id ?? basename(path2),
+    id: options.id ?? basename(path),
     hash: createHash3("sha256").update(bundle).digest("hex"),
     source: bundle.toString("utf-8"),
     ...defaults === undefined ? {} : { defaults: { ...defaults } }
   };
-  registerUI(ui, path2);
+  registerUI(ui, path);
   return ui;
 }
 // src/utils.ts
@@ -2998,9 +3029,9 @@ function asyncEventEmitter(initial = []) {
   return {
     push: (value) => {
       if (waiting) {
-        const resolve2 = waiting;
+        const resolve = waiting;
         waiting = null;
-        resolve2(value);
+        resolve(value);
         return;
       }
       queue.push(value);
@@ -3073,15 +3104,15 @@ function createService(optionsOrVersion, optionalMessageHandler) {
   let token = options.accessToken ?? process.env.REQUENCE_SERVICE_ACCESS_TOKEN ?? process.env.REQUENCE_ACCESS_TOKEN;
   if (!token) {
     try {
-      const pkgJson2 = loadPkgJson();
-      token = pkgJson2.requence?.service?.accessToken ?? pkgJson2.requence?.accessToken;
+      const pkgJson = loadPkgJson();
+      token = pkgJson.requence?.service?.accessToken ?? pkgJson.requence?.accessToken;
     } catch {}
   }
   let devToken = options.devToken ?? process.env.REQUENCE_SERVICE_DEV_TOKEN ?? process.env.REQUENCE_DEV_TOKEN;
   if (!devToken) {
     try {
-      const pkgJson2 = loadPkgJson();
-      devToken = pkgJson2.requence?.service?.devToken ?? pkgJson2.requence?.devToken;
+      const pkgJson = loadPkgJson();
+      devToken = pkgJson.requence?.service?.devToken ?? pkgJson.requence?.devToken;
     } catch {}
   }
   if (!token) {
@@ -3120,31 +3151,31 @@ function createService(optionsOrVersion, optionalMessageHandler) {
   }, messageHandler);
 }
 export {
-  wrapIterable,
-  reachableFetch,
-  isUnreachableStatus,
-  createUI,
-  createService,
-  createDurableCallback,
-  createCallback,
-  asyncEventEmitter,
-  assertReachable,
-  UnsupportedCapabilityError,
-  UITooLargeError,
-  StoreValueTooLargeError,
-  StoreValueNotStorableError,
-  StoreUnavailableError,
-  StoreUnauthorizedError,
-  StoreTaskNotAllowedError,
-  StoreRequestError,
-  StoreError,
-  StoreAddressFullError,
-  RequenceUnreachableError,
-  RequenceStream,
+  PayloadTooLargeError2 as PayloadTooLargeError,
+  RequenceConnectionError2 as RequenceConnectionError,
   RequenceFile,
-  RequenceConnectionError,
-  PayloadTooLargeError
+  RequenceStream,
+  RequenceUnreachableError2 as RequenceUnreachableError,
+  StoreAddressFullError,
+  StoreError,
+  StoreRequestError,
+  StoreTaskNotAllowedError,
+  StoreUnauthorizedError,
+  StoreUnavailableError,
+  StoreValueNotStorableError,
+  StoreValueTooLargeError,
+  UITooLargeError2 as UITooLargeError,
+  UnsupportedCapabilityError2 as UnsupportedCapabilityError,
+  assertReachable2 as assertReachable,
+  asyncEventEmitter,
+  createCallback,
+  createDurableCallback,
+  createService,
+  createUI,
+  isUnreachableStatus2 as isUnreachableStatus,
+  reachableFetch2 as reachableFetch,
+  wrapIterable
 };
 
-//# debugId=5B4FC3328BB74A1C64756E2164756E21
+//# debugId=A2BCC6DE93A6FAB664756E2164756E21
 //# sourceMappingURL=index.js.map