@requence/service 0.8.2-edge.1157 → 0.8.2-edge.1160

package/build/index.js

@@ -400,7 +400,7 @@ function wireBodyByteLength(value, codec) {
 
 // src/createAmqpConnection.ts
 import { connect } from "amqp-connection-manager";
-import { z as z9 } from "zod/v4";
+import { z as z10 } from "zod/v4";
 
 // ../files/src/errors.ts
 class RequenceStreamTruncatedError extends Error {
@@ -1527,6 +1527,7 @@ async function createContextHelper(options) {
       };
     },
     defer: options.onDefer,
+    store: options.store,
     render(ui, props, renderOptions) {
       options.onRender({
         ui,
@@ -1564,6 +1565,187 @@ async function createContextHelper(options) {
 }
 var handlerStorage = new AsyncLocalStorage2;
 
+// ../store/src/address.ts
+import { z as z9 } from "zod/v4";
+// ../store/src/capability.ts
+function encode(value) {
+  return Buffer.from(JSON.stringify(value), "utf8").toString("base64url");
+}
+function composeStoreCapability(signature, context) {
+  return `${signature}.${encode({
+    taskId: context.taskId,
+    nodeId: context.nodeId,
+    ...context.configuration ? { configuration: true } : {}
+  })}`;
+}
+// ../store/src/errors.ts
+class StoreError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StoreError";
+  }
+}
+
+class StoreUnavailableError extends StoreError {
+  constructor(message = "the store is unavailable") {
+    super(message);
+    this.name = "StoreUnavailableError";
+  }
+}
+
+class StoreRequestError extends StoreError {
+  constructor(message = "invalid store request") {
+    super(message);
+    this.name = "StoreRequestError";
+  }
+}
+
+class StoreUnauthorizedError extends StoreError {
+  constructor(message = "the store rejected the capability") {
+    super(message);
+    this.name = "StoreUnauthorizedError";
+  }
+}
+
+class StoreTaskNotAllowedError extends StoreError {
+  constructor(message = "this task is not allowed to use the store") {
+    super(message);
+    this.name = "StoreTaskNotAllowedError";
+  }
+}
+
+class StoreAddressFullError extends StoreError {
+  constructor(message = "this node already stores 64 keys") {
+    super(message);
+    this.name = "StoreAddressFullError";
+  }
+}
+
+class StoreValueTooLargeError extends StoreError {
+  constructor(message = "the value is too large") {
+    super(message);
+    this.name = "StoreValueTooLargeError";
+  }
+}
+
+class StoreValueNotStorableError extends StoreError {
+  constructor(message = "the value is not storable") {
+    super(message);
+    this.name = "StoreValueNotStorableError";
+  }
+}
+function storeErrorForStatus(status, message) {
+  switch (status) {
+    case 400:
+      return new StoreRequestError(message);
+    case 401:
+      return new StoreUnauthorizedError(message);
+    case 403:
+      return new StoreTaskNotAllowedError(message);
+    case 409:
+      return new StoreAddressFullError(message);
+    case 413:
+      return new StoreValueTooLargeError(message);
+    case 422:
+      return new StoreValueNotStorableError(message);
+    default:
+      return new StoreUnavailableError(message);
+  }
+}
+
+// ../store/src/client.ts
+async function refusalMessage(response) {
+  try {
+    const body = await response.json();
+    if (typeof body.error === "string" && body.error.length > 0) {
+      return body.error;
+    }
+  } catch {}
+  return `the store answered ${response.status}`;
+}
+function createStoreClient(options) {
+  const doFetch = options.fetch ?? globalThis.fetch;
+  const capability = composeStoreCapability(options.signature, {
+    taskId: options.taskId,
+    nodeId: options.nodeId,
+    configuration: options.configuration
+  });
+  const base = options.url.endsWith("/") ? options.url.slice(0, -1) : options.url;
+  async function call(operation, body) {
+    let response;
+    try {
+      response = await doFetch(`${base}/node/${operation}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${capability}`
+        },
+        body: JSON.stringify(body)
+      });
+    } catch (error) {
+      throw new StoreUnavailableError(`the store at ${base} could not be reached: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!response.ok) {
+      throw storeErrorForStatus(response.status, await refusalMessage(response));
+    }
+    return response;
+  }
+  return {
+    async get(ownership, binding, key) {
+      const response = await call("get", { ownership, binding, key });
+      const body = await response.json();
+      return body.value ?? null;
+    },
+    async set(ownership, binding, key, value) {
+      await call("set", { ownership, binding, key, value: value ?? null });
+    },
+    async delete(ownership, binding, key) {
+      await call("delete", { ownership, binding, key });
+    }
+  };
+}
+// src/store.ts
+function createStore(dispatch) {
+  let client;
+  function connect() {
+    if (!client) {
+      if (!dispatch.url || !dispatch.signature || !dispatch.nodeId) {
+        throw new StoreUnavailableError("this dispatch carries no store capability, so the store cannot be reached from this node — the task was started before the store existed, or by a Requence instance that has none");
+      }
+      client = createStoreClient({
+        url: dispatch.url,
+        signature: dispatch.signature,
+        taskId: dispatch.taskId,
+        nodeId: dispatch.nodeId,
+        configuration: dispatch.configuration,
+        fetch: dispatch.fetch
+      });
+    }
+    return client;
+  }
+  function slot(ownership, key, binding) {
+    return {
+      async get() {
+        return connect().get(ownership, binding, key);
+      },
+      async set(value) {
+        await connect().set(ownership, binding, key, value);
+      },
+      async delete() {
+        await connect().delete(ownership, binding, key);
+      }
+    };
+  }
+  return {
+    private(key, binding = "task") {
+      return slot("private", key, binding);
+    },
+    shared(key, binding = "task") {
+      return slot("shared", key, binding);
+    }
+  };
+}
+
 // src/uiWatch.ts
 import { createHash } from "node:crypto";
 import fs from "node:fs";
@@ -1662,7 +1844,7 @@ function reload(registration) {
 function errorText(error) {
   return error instanceof Error ? error.message : String(error);
 }
-var messageKeySchema = z9.string().transform((str) => deobfuscate(str)).pipe(z9.tuple([z9.uuid(), z9.uuid()]).rest(z9.string())).transform((arr) => ({
+var messageKeySchema = z10.string().transform((str) => deobfuscate(str)).pipe(z10.tuple([z10.uuid(), z10.uuid()]).rest(z10.string())).transform((arr) => ({
   taskId: arr[0],
   messageId: arr[1],
   uploadUrl: arr[2] || undefined,
@@ -1671,12 +1853,12 @@ var messageKeySchema = z9.string().transform((str) => deobfuscate(str)).pipe(z9.
   maxFileSize: arr[5] && Number.isFinite(Number(arr[5])) ? Number(arr[5]) : undefined,
   nodeId: arr[6] || undefined
 }));
-var headerSchema = z9.object({
-  properties: z9.object({
-    correlationId: z9.uuid(),
-    headers: z9.object({
-      taskId: z9.uuid(),
-      mode: z9.enum(["LINEAR", "CONTINUOUS"]).default("LINEAR")
+var headerSchema = z10.object({
+  properties: z10.object({
+    correlationId: z10.uuid(),
+    headers: z10.object({
+      taskId: z10.uuid(),
+      mode: z10.enum(["LINEAR", "CONTINUOUS"]).default("LINEAR")
     })
   })
 }).transform((msg) => ({
@@ -1684,45 +1866,48 @@ var headerSchema = z9.object({
   taskId: msg.properties.headers.taskId,
   mode: msg.properties.headers.mode
 }));
-var payloadSchema = z9.object({
-  content: z9.instanceof(Buffer),
-  properties: z9.object({ contentType: z9.string().optional() })
-}).transform((msg) => decodeWireBody(msg.content, msg.properties.contentType)).pipe(z9.object({
-  input: z9.unknown().optional(),
-  configuration: z9.unknown().optional(),
-  nodeId: z9.string().optional(),
-  options: z9.object({
-    uploadUrl: z9.url().optional(),
-    streamUrl: z9.url().optional(),
-    maxPayloadSize: z9.number().optional(),
-    maxFileSize: z9.number().optional()
+var payloadSchema = z10.object({
+  content: z10.instanceof(Buffer),
+  properties: z10.object({ contentType: z10.string().optional() })
+}).transform((msg) => decodeWireBody(msg.content, msg.properties.contentType)).pipe(z10.object({
+  input: z10.unknown().optional(),
+  configuration: z10.unknown().optional(),
+  nodeId: z10.string().optional(),
+  configurationEval: z10.boolean().optional(),
+  options: z10.object({
+    uploadUrl: z10.url().optional(),
+    streamUrl: z10.url().optional(),
+    maxPayloadSize: z10.number().optional(),
+    maxFileSize: z10.number().optional(),
+    storeUrl: z10.string().optional(),
+    storeSignature: z10.string().optional()
   })
 }));
-var backchannelMessageSchema = z9.object({
-  content: z9.instanceof(Buffer),
-  properties: z9.object({
-    correlationId: z9.string(),
-    contentType: z9.string().optional(),
-    headers: z9.object({ taskId: z9.uuid().optional() }).optional().catch(undefined)
+var backchannelMessageSchema = z10.object({
+  content: z10.instanceof(Buffer),
+  properties: z10.object({
+    correlationId: z10.string(),
+    contentType: z10.string().optional(),
+    headers: z10.object({ taskId: z10.uuid().optional() }).optional().catch(undefined)
   })
 }).transform((message) => ({
   ...message,
   content: decodeWireBody(message.content, message.properties.contentType)
-})).pipe(z9.object({
-  content: z9.discriminatedUnion("type", [
-    z9.object({
-      type: z9.literal("stop")
+})).pipe(z10.object({
+  content: z10.discriminatedUnion("type", [
+    z10.object({
+      type: z10.literal("stop")
     }),
-    z9.object({
-      type: z9.literal("callback"),
-      callbackId: z9.uuid(),
-      arg: z9.any().optional(),
-      surface: z9.uuid().optional()
+    z10.object({
+      type: z10.literal("callback"),
+      callbackId: z10.uuid(),
+      arg: z10.any().optional(),
+      surface: z10.uuid().optional()
     })
   ]),
-  properties: z9.object({
-    correlationId: z9.string(),
-    headers: z9.object({ taskId: z9.uuid().optional() }).optional().catch(undefined)
+  properties: z10.object({
+    correlationId: z10.string(),
+    headers: z10.object({ taskId: z10.uuid().optional() }).optional().catch(undefined)
   })
 })).transform((message) => ({
   payload: message.content,
@@ -1730,21 +1915,21 @@ var backchannelMessageSchema = z9.object({
   taskId: message.properties.headers?.taskId
 }));
 var abortSymbol = Symbol();
-var connectionOptionsSchema = z9.object({
-  url: z9.union([
-    z9.string().regex(/^amqps?:\/\/(.+):(.+)@(.+)$/).transform((str) => new URL(str)),
-    z9.instanceof(URL).refine((url) => url.protocol.match(/^amqps?:/), "Wrong protocol")
+var connectionOptionsSchema = z10.object({
+  url: z10.union([
+    z10.string().regex(/^amqps?:\/\/(.+):(.+)@(.+)$/).transform((str) => new URL(str)),
+    z10.instanceof(URL).refine((url) => url.protocol.match(/^amqps?:/), "Wrong protocol")
   ]),
-  version: z9.string(),
-  name: z9.string().optional(),
-  devOverlay: z9.string().optional(),
-  silent: z9.boolean().optional(),
-  prefetch: z9.number().int().optional(),
-  connectionTimeout: z9.number().positive().default(3000),
-  heartbeatInterval: z9.number().int().positive().optional(),
-  connectionOptions: z9.any().optional(),
-  maxMessageSize: z9.number().int().positive().default(128 * 1024 * 1024),
-  passthroughByteReferences: z9.boolean().optional()
+  version: z10.string(),
+  name: z10.string().optional(),
+  devOverlay: z10.string().optional(),
+  silent: z10.boolean().optional(),
+  prefetch: z10.number().int().optional(),
+  connectionTimeout: z10.number().positive().default(3000),
+  heartbeatInterval: z10.number().int().positive().optional(),
+  connectionOptions: z10.any().optional(),
+  maxMessageSize: z10.number().int().positive().default(128 * 1024 * 1024),
+  passthroughByteReferences: z10.boolean().optional()
 });
 function isMessageHandlerGenerator(handler) {
   return handler.constructor.name === "GeneratorFunction" || handler.constructor.name === "AsyncGeneratorFunction";
@@ -1806,7 +1991,7 @@ function createConnection({
       clientProperties: {
         ...connectionOptions?.clientProperties,
         ...buildServiceClientProperties({
-          libVersion: "javascript@0.8.2-edge.1157",
+          libVersion: "javascript@0.8.2-edge.1160",
           serviceVersion: version,
           name,
           devOverlay: Boolean(devOverlay)
@@ -2122,18 +2307,6 @@ function createConnection({
           ...options?.overwrite ? { overwrite: true } : {},
           ...base
         }));
-      },
-      async sendState(state) {
-        await deps.gate?.();
-        deps.outbound.track(publish({
-          index: 0,
-          version,
-          messageId: deps.messageId,
-          taskId: deps.taskId,
-          data: await deps.outbound.send(state, { outputName: null }),
-          state: true,
-          ...base
-        }));
       }
     };
   };
@@ -2293,6 +2466,13 @@ function createConnection({
           configuration: payload.configuration,
           abortController,
           passthroughByteReferences,
+          store: createStore({
+            url: payload.options.storeUrl,
+            signature: payload.options.storeSignature,
+            taskId,
+            nodeId: payload.nodeId,
+            configuration: payload.configurationEval
+          }),
           sends: {
             ...buildSendApi(publishDeps),
             invokeCallback: (ref, arg) => dispatchInvocation({ ...ref, arg }),
@@ -2333,7 +2513,7 @@ function createConnection({
           begin: true,
           epoch,
           ...buildServiceIdentityHeaders({
-            libVersion: "javascript@0.8.2-edge.1157",
+            libVersion: "javascript@0.8.2-edge.1160",
             name
           })
         });
@@ -2887,6 +3067,14 @@ export {
   assertReachable,
   UnsupportedCapabilityError,
   UITooLargeError,
+  StoreValueTooLargeError,
+  StoreValueNotStorableError,
+  StoreUnavailableError,
+  StoreUnauthorizedError,
+  StoreTaskNotAllowedError,
+  StoreRequestError,
+  StoreError,
+  StoreAddressFullError,
   RequenceUnreachableError,
   RequenceStream,
   RequenceFile,
@@ -2894,5 +3082,5 @@ export {
   PayloadTooLargeError
 };
 
-//# debugId=B9ACB95FA979832B64756E2164756E21
+//# debugId=2EE6F97FF9F3150464756E2164756E21
 //# sourceMappingURL=index.js.map