@dicabrio/durable-sdk 0.1.0

package/README.md

@@ -0,0 +1,83 @@
+# @dicabrio/durable-sdk
+
+TypeScript SDK for [Durable](https://durable.dicabrio.com) — a self-hosted
+durable-execution engine. Write workflows as ordinary async code; the engine
+memoizes each step and replays your function, so runs survive crashes, deploys,
+retries, and long sleeps.
+
+The engine never runs your code. Your app embeds this SDK and exposes one HTTP
+endpoint; the Durable service calls it back, one step per round-trip.
+
+## Install
+
+```bash
+npm install @dicabrio/durable-sdk
+```
+
+Zero runtime dependencies. Ships ESM + CommonJS with type definitions.
+
+## Define a function
+
+```ts
+import { createFunction } from "@dicabrio/durable-sdk";
+
+export const onboarding = createFunction({
+  id: "onboarding",
+  trigger: { event: "user.created" },
+  handler: async ({ event, step }) => {
+    const user = await step.run("load-user", async () => {
+      return { id: event.data.id, email: `${event.data.id}@example.com` };
+    });
+
+    await step.sleep("cooldown", "5s");
+
+    await step.run("send-email", async () => {
+      // ...send the welcome email
+      return { sentTo: user.email };
+    });
+
+    return { ok: true };
+  },
+});
+```
+
+Each `step.run` result is persisted and memoized: on replay the engine returns
+the stored value instead of re-executing the step.
+
+## Serve the callback and send events
+
+```ts
+import express from "express";
+import { serve, DurableClient } from "@dicabrio/durable-sdk";
+import { onboarding } from "./onboarding.js";
+
+const signingKey = process.env.DURABLE_APP_KEY!;
+
+const app = express();
+// The service POSTs invocations here; serve() verifies the HMAC over the raw body.
+app.post("/api/durable", serve([onboarding], { signingKey }));
+app.listen(4000);
+
+const client = new DurableClient({
+  baseUrl: "https://app.durable.dicabrio.com",
+  appId: process.env.APP_ID!,
+  signingKey,
+  appUrl: "https://my-app.example.com/api/durable",
+});
+
+// Register functions + callback URL with the service, then fire an event.
+await client.sync([onboarding]);
+await client.send({ name: "user.created", data: { id: "alice" } });
+```
+
+## Step primitives
+
+| Primitive | What it does |
+|---|---|
+| `step.run(id, fn)` | Run once, memoize the result, skip on replay |
+| `step.sleep(id, "5s")` | Durable delay — survives restarts |
+| `step.waitForEvent(id, opts)` | Park the run until a matching event arrives (or times out) |
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,239 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DurableClient: () => DurableClient,
+  StepInterrupt: () => StepInterrupt,
+  createFunction: () => createFunction,
+  createStep: () => createStep,
+  parseDuration: () => parseDuration,
+  runInvocation: () => runInvocation,
+  serve: () => serve
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/step.ts
+var StepInterrupt = class extends Error {
+  constructor(response) {
+    super("durable:step-interrupt");
+    this.response = response;
+  }
+  response;
+};
+var UNITS = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+function parseDuration(d) {
+  if (typeof d === "number") return d;
+  const m = /^(\d+)\s*(ms|s|m|h|d)$/.exec(d.trim());
+  if (!m) throw new Error(`invalid duration: ${d}`);
+  return Number(m[1]) * UNITS[m[2]];
+}
+function message(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function createStep(memoized) {
+  return {
+    async run(id, cb) {
+      const memo = memoized[id];
+      if (memo) {
+        if (memo.type !== "run") {
+          throw new Error(`step "${id}" already used as a ${memo.type}`);
+        }
+        return memo.data;
+      }
+      let data;
+      try {
+        data = await cb();
+      } catch (err) {
+        throw new StepInterrupt({
+          op: "error",
+          id,
+          message: message(err),
+          retryable: true
+        });
+      }
+      throw new StepInterrupt({ op: "step", id, data });
+    },
+    async sleep(id, duration) {
+      const memo = memoized[id];
+      if (memo) {
+        if (memo.type !== "sleep") {
+          throw new Error(`step "${id}" already used as a ${memo.type}`);
+        }
+        return;
+      }
+      const until = new Date(Date.now() + parseDuration(duration)).toISOString();
+      throw new StepInterrupt({ op: "sleep", id, until });
+    },
+    async waitForEvent(id, opts) {
+      const memo = memoized[id];
+      if (memo) {
+        if (memo.type !== "wait") {
+          throw new Error(`step "${id}" already used as a ${memo.type}`);
+        }
+        return memo.data ?? null;
+      }
+      const until = new Date(Date.now() + parseDuration(opts.timeout)).toISOString();
+      throw new StepInterrupt({
+        op: "wait",
+        id,
+        event: opts.event,
+        match: opts.match ?? null,
+        until
+      });
+    }
+  };
+}
+
+// src/function.ts
+function createFunction(def) {
+  return def;
+}
+async function runInvocation(fn, req) {
+  const step = createStep(req.steps);
+  try {
+    const data = await fn.handler({ event: req.event, step });
+    return { op: "done", data };
+  } catch (err) {
+    if (err instanceof StepInterrupt) return err.response;
+    const message2 = err instanceof Error ? err.message : String(err);
+    return { op: "error", id: null, message: message2, retryable: true };
+  }
+}
+
+// ../shared/src/protocol.ts
+var SIGNATURE_HEADER = "x-durable-signature";
+var APP_HEADER = "x-durable-app";
+
+// ../shared/src/hmac.ts
+var import_node_crypto = require("crypto");
+function sign(body, key) {
+  return (0, import_node_crypto.createHmac)("sha256", key).update(body).digest("hex");
+}
+function verify(body, signature, key) {
+  const expected = sign(body, key);
+  const a = Buffer.from(expected);
+  const b = Buffer.from(signature);
+  if (a.length !== b.length) return false;
+  return (0, import_node_crypto.timingSafeEqual)(a, b);
+}
+
+// src/serve.ts
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+}
+function serve(functions, opts) {
+  return async (req, res) => {
+    try {
+      const raw = await readBody(req);
+      const sig = req.headers[SIGNATURE_HEADER];
+      if (typeof sig !== "string" || !verify(raw, sig, opts.signingKey)) {
+        res.writeHead(401).end("invalid signature");
+        return;
+      }
+      const body = JSON.parse(raw);
+      const fn = functions.find((f) => f.id === body.functionId);
+      const response = fn ? await runInvocation(fn, body) : {
+        op: "error",
+        id: null,
+        message: `unknown function ${body.functionId}`,
+        retryable: false
+      };
+      const out = JSON.stringify(response);
+      res.writeHead(200, {
+        "content-type": "application/json",
+        [SIGNATURE_HEADER]: sign(out, opts.signingKey)
+      }).end(out);
+    } catch (err) {
+      res.writeHead(500).end(err instanceof Error ? err.message : String(err));
+    }
+  };
+}
+
+// src/client.ts
+function toWindow(w) {
+  return w ? { limit: w.limit, periodMs: parseDuration(w.period), key: w.key } : void 0;
+}
+var DurableClient = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  async post(path, payload) {
+    const body = JSON.stringify(payload);
+    const res = await fetch(this.opts.baseUrl + path, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        [APP_HEADER]: this.opts.appId,
+        [SIGNATURE_HEADER]: sign(body, this.opts.signingKey)
+      },
+      body
+    });
+    if (!res.ok) {
+      throw new Error(
+        `durable ${path} failed: ${res.status} ${await res.text()}`
+      );
+    }
+  }
+  /** Register this app's functions and callback URL with the service. */
+  async sync(functions) {
+    const payload = {
+      url: this.opts.appUrl,
+      functions: functions.map((f) => ({
+        id: f.id,
+        trigger: f.trigger,
+        concurrency: f.concurrency,
+        priority: f.priority,
+        throttle: toWindow(f.throttle),
+        rateLimit: toWindow(f.rateLimit),
+        debounce: f.debounce ? { periodMs: parseDuration(f.debounce.period), key: f.debounce.key } : void 0,
+        batch: f.batch ? { maxSize: f.batch.maxSize, timeoutMs: parseDuration(f.batch.timeout), key: f.batch.key } : void 0
+      }))
+    };
+    await this.post("/fn/sync", payload);
+  }
+  /** Send an event to the service. */
+  async send(event) {
+    await this.post("/e", { name: event.name, data: event.data ?? {} });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DurableClient,
+  StepInterrupt,
+  createFunction,
+  createStep,
+  parseDuration,
+  runInvocation,
+  serve
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/step.ts","../src/function.ts","../../shared/src/protocol.ts","../../shared/src/hmac.ts","../src/serve.ts","../src/client.ts"],"sourcesContent":["export { createFunction, runInvocation } from \"./function.js\";\nexport type { DurableFunction, FunctionContext } from \"./function.js\";\nexport { createStep, parseDuration, StepInterrupt } from \"./step.js\";\nexport type { StepTools, WaitForEventOptions } from \"./step.js\";\nexport { serve } from \"./serve.js\";\nexport { DurableClient } from \"./client.js\";\nexport type { DurableClientOptions } from \"./client.js\";\n","import type { DurableEvent, InvokeResponse, MemoizedStep } from \"@durable/shared\";\n\n/**\n * Thrown to unwind the handler the moment it reaches a new operation. The\n * carried response is exactly what the SDK reports to the service. Using an\n * exception means at most one *new* step executes per invocation — everything\n * after it is skipped until the service re-invokes with that step memoized.\n */\nexport class StepInterrupt extends Error {\n  constructor(public readonly response: InvokeResponse) {\n    super(\"durable:step-interrupt\");\n  }\n}\n\nexport interface WaitForEventOptions {\n  /** The event name to wait for. */\n  event: string;\n  /** Key/value pairs the incoming event.data must contain to match. */\n  match?: Record<string, unknown>;\n  /** How long to wait before giving up (e.g. \"7d\", \"1h\", or ms). */\n  timeout: string | number;\n}\n\nexport interface StepTools {\n  /** Run a side-effecting step once; its result is memoized and replayed. */\n  run<T>(id: string, cb: () => Promise<T> | T): Promise<T>;\n  /** Pause the run until the duration elapses (e.g. \"10s\", \"2d\", or ms). */\n  sleep(id: string, duration: string | number): Promise<void>;\n  /**\n   * Pause the run until a matching event arrives, or the timeout elapses.\n   * Resolves with the matched event, or `null` if it timed out.\n   */\n  waitForEvent(id: string, opts: WaitForEventOptions): Promise<DurableEvent | null>;\n}\n\nconst UNITS: Record<string, number> = {\n  ms: 1,\n  s: 1000,\n  m: 60_000,\n  h: 3_600_000,\n  d: 86_400_000,\n};\n\nexport function parseDuration(d: string | number): number {\n  if (typeof d === \"number\") return d;\n  const m = /^(\\d+)\\s*(ms|s|m|h|d)$/.exec(d.trim());\n  if (!m) throw new Error(`invalid duration: ${d}`);\n  return Number(m[1]) * UNITS[m[2]];\n}\n\nfunction message(err: unknown): string {\n  return err instanceof Error ? err.message : String(err);\n}\n\n/** Build the step tools bound to the steps already memoized for this run. */\nexport function createStep(memoized: Record<string, MemoizedStep>): StepTools {\n  return {\n    async run<T>(id: string, cb: () => Promise<T> | T): Promise<T> {\n      const memo = memoized[id];\n      if (memo) {\n        if (memo.type !== \"run\") {\n          throw new Error(`step \"${id}\" already used as a ${memo.type}`);\n        }\n        return memo.data as T; // replay: free, no side effect\n      }\n      let data: T;\n      try {\n        data = await cb();\n      } catch (err) {\n        // A genuine failure inside the step: let the service decide on retry.\n        throw new StepInterrupt({\n          op: \"error\",\n          id,\n          message: message(err),\n          retryable: true,\n        });\n      }\n      throw new StepInterrupt({ op: \"step\", id, data });\n    },\n\n    async sleep(id: string, duration: string | number): Promise<void> {\n      const memo = memoized[id];\n      if (memo) {\n        if (memo.type !== \"sleep\") {\n          throw new Error(`step \"${id}\" already used as a ${memo.type}`);\n        }\n        return; // sleep already satisfied\n      }\n      const until = new Date(Date.now() + parseDuration(duration)).toISOString();\n      throw new StepInterrupt({ op: \"sleep\", id, until });\n    },\n\n    async waitForEvent(id, opts): Promise<DurableEvent | null> {\n      const memo = memoized[id];\n      if (memo) {\n        if (memo.type !== \"wait\") {\n          throw new Error(`step \"${id}\" already used as a ${memo.type}`);\n        }\n        return (memo.data as DurableEvent | null) ?? null; // event, or null on timeout\n      }\n      const until = new Date(Date.now() + parseDuration(opts.timeout)).toISOString();\n      throw new StepInterrupt({\n        op: \"wait\",\n        id,\n        event: opts.event,\n        match: opts.match ?? null,\n        until,\n      });\n    },\n  };\n}\n","import type {\n  Concurrency,\n  DurableEvent,\n  InvokeRequest,\n  InvokeResponse,\n  Trigger,\n} from \"@durable/shared\";\nimport { createStep, StepInterrupt, type StepTools } from \"./step.js\";\n\nexport interface FunctionContext {\n  event: DurableEvent;\n  step: StepTools;\n}\n\nexport interface DurableFunction {\n  id: string;\n  /** Triggered by an event name (`{ event }`) or a cron expression (`{ cron }`). */\n  trigger: Trigger;\n  /** Optional cap on how many runs execute at once (per key, if given). */\n  concurrency?: Concurrency;\n  /** Higher runs sooner when jobs compete in the queue (default 0). */\n  priority?: number;\n  /** Spread run starts over time: max `limit` per `period` (excess delayed). */\n  throttle?: { limit: number; period: string | number; key?: string };\n  /** Cap new runs: max `limit` per `period` (excess dropped). */\n  rateLimit?: { limit: number; period: string | number; key?: string };\n  /** Collapse rapid events: one run with the LAST event, once quiet for `period`. */\n  debounce?: { period: string | number; key?: string };\n  /**\n   * Group events: ONE run receives event.data = the whole list, flushed at\n   * `maxSize` events or `timeout` after the first (event.name = \"$batch\").\n   */\n  batch?: { maxSize: number; timeout: string | number; key?: string };\n  handler: (ctx: FunctionContext) => Promise<unknown>;\n}\n\nexport function createFunction(def: DurableFunction): DurableFunction {\n  return def;\n}\n\n/**\n * Replay a single invocation: run the handler from the top, returning the next\n * operation it reaches (a new step, a sleep, completion, or an error).\n */\nexport async function runInvocation(\n  fn: DurableFunction,\n  req: InvokeRequest,\n): Promise<InvokeResponse> {\n  const step = createStep(req.steps);\n  try {\n    const data = await fn.handler({ event: req.event, step });\n    return { op: \"done\", data };\n  } catch (err) {\n    if (err instanceof StepInterrupt) return err.response;\n    // Error thrown outside any step.run (in the handler body itself).\n    const message = err instanceof Error ? err.message : String(err);\n    return { op: \"error\", id: null, message, retryable: true };\n  }\n}\n","/**\n * Wire protocol between the Durable service and the app SDK.\n *\n * One HTTP round-trip advances a run by at most one *new* step. The service\n * sends the run state (event + already-memoized steps); the SDK replays the\n * cached steps for free, executes the next new operation, and reports it back.\n */\n\n/** An event that triggered (or can trigger) a run. */\nexport interface DurableEvent {\n  id: string;\n  name: string;\n  data: unknown;\n}\n\n/** A previously-completed step, keyed by its user-supplied step id. */\nexport interface MemoizedStep {\n  /**\n   * \"run\"   = a step.run result,\n   * \"sleep\" = a satisfied step.sleep marker,\n   * \"wait\"  = a settled step.waitForEvent (data = the event, or null on timeout).\n   */\n  type: \"run\" | \"sleep\" | \"wait\";\n  /** Output of step.run, or the matched event for \"wait\". Null otherwise. */\n  data: unknown;\n}\n\n/** Service -> SDK: \"advance this run\". */\nexport interface InvokeRequest {\n  runId: string;\n  functionId: string;\n  event: DurableEvent;\n  /** Completed steps so far, keyed by step id. */\n  steps: Record<string, MemoizedStep>;\n}\n\n/**\n * SDK -> service: the next operation the function reached.\n *\n *  - step  : a new step.run executed; persist `data` under `id`, then re-invoke.\n *  - sleep : function wants to pause until `until`; arm a timer.\n *  - done  : function returned; the run is complete with `data`.\n *  - error : the current step threw; retry (if retryable) or fail the run.\n */\nexport type InvokeResponse =\n  | { op: \"step\"; id: string; data: unknown }\n  | { op: \"sleep\"; id: string; until: string /* ISO timestamp */ }\n  | {\n      op: \"wait\";\n      id: string;\n      event: string;\n      /** Key/value pairs the incoming event.data must contain; null = any. */\n      match: Record<string, unknown> | null;\n      until: string /* ISO timestamp timeout */;\n    }\n  | { op: \"done\"; data: unknown }\n  | { op: \"error\"; id: string | null; message: string; retryable: boolean };\n\n/** A function is triggered by either an event name or a cron expression. */\nexport type Trigger = { event: string } | { cron: string };\n\n/** Optional concurrency cap for a function. */\nexport interface Concurrency {\n  /** Max runs executing at once (per key, if given). */\n  limit: number;\n  /** event.data field name to scope the limit by (e.g. \"tenantId\"). */\n  key?: string;\n}\n\n/** Wire form of a throttle/rate-limit rule (period already in ms). */\nexport interface WindowLimit {\n  limit: number;\n  periodMs: number;\n  key?: string;\n}\n\n/** Wire form of a debounce rule (period already in ms). */\nexport interface DebounceRule {\n  periodMs: number;\n  key?: string;\n}\n\n/** Wire form of a batch rule (timeout already in ms). */\nexport interface BatchRule {\n  maxSize: number;\n  timeoutMs: number;\n  key?: string;\n}\n\n/** Registry sync: app -> service, \"here are my functions and where to reach me\". */\nexport interface SyncRequest {\n  /** Base URL the service should POST invocations to (callback endpoint). */\n  url: string;\n  functions: Array<{\n    id: string;\n    trigger: Trigger;\n    concurrency?: Concurrency;\n    priority?: number;\n    throttle?: WindowLimit;\n    rateLimit?: WindowLimit;\n    debounce?: DebounceRule;\n    batch?: BatchRule;\n  }>;\n}\n\n/** Header carrying the HMAC signature on every service<->app request body. */\nexport const SIGNATURE_HEADER = \"x-durable-signature\";\n\n/** Header carrying the app id on app -> service requests. */\nexport const APP_HEADER = \"x-durable-app\";\n","import { createHmac, timingSafeEqual } from \"node:crypto\";\n\n/** Compute the hex HMAC-SHA256 of a raw request body. */\nexport function sign(body: string, key: string): string {\n  return createHmac(\"sha256\", key).update(body).digest(\"hex\");\n}\n\n/** Constant-time verify of a signature against a raw body. */\nexport function verify(body: string, signature: string, key: string): boolean {\n  const expected = sign(body, key);\n  const a = Buffer.from(expected);\n  const b = Buffer.from(signature);\n  if (a.length !== b.length) return false;\n  return timingSafeEqual(a, b);\n}\n","import type { IncomingMessage, ServerResponse } from \"node:http\";\nimport {\n  sign,\n  verify,\n  SIGNATURE_HEADER,\n  type InvokeRequest,\n} from \"@durable/shared\";\nimport { runInvocation, type DurableFunction } from \"./function.js\";\n\nfunction readBody(req: IncomingMessage): Promise<string> {\n  return new Promise((resolve, reject) => {\n    const chunks: Buffer[] = [];\n    req.on(\"data\", (c) => chunks.push(c as Buffer));\n    req.on(\"end\", () => resolve(Buffer.concat(chunks).toString(\"utf8\")));\n    req.on(\"error\", reject);\n  });\n}\n\n/**\n * Returns a Node HTTP handler (also usable directly as an Express route) that\n * the Durable service POSTs invocations to. Verifies the HMAC, replays the run,\n * and returns the next operation — itself signed so the service can trust it.\n *\n * Mount this route WITHOUT a JSON body parser; the handler reads the raw stream\n * so it can verify the signature over the exact bytes.\n */\nexport function serve(\n  functions: DurableFunction[],\n  opts: { signingKey: string },\n) {\n  return async (req: IncomingMessage, res: ServerResponse): Promise<void> => {\n    try {\n      const raw = await readBody(req);\n      const sig = req.headers[SIGNATURE_HEADER];\n      if (typeof sig !== \"string\" || !verify(raw, sig, opts.signingKey)) {\n        res.writeHead(401).end(\"invalid signature\");\n        return;\n      }\n\n      const body = JSON.parse(raw) as InvokeRequest;\n      const fn = functions.find((f) => f.id === body.functionId);\n      const response = fn\n        ? await runInvocation(fn, body)\n        : ({\n            op: \"error\" as const,\n            id: null,\n            message: `unknown function ${body.functionId}`,\n            retryable: false,\n          });\n\n      const out = JSON.stringify(response);\n      res\n        .writeHead(200, {\n          \"content-type\": \"application/json\",\n          [SIGNATURE_HEADER]: sign(out, opts.signingKey),\n        })\n        .end(out);\n    } catch (err) {\n      res.writeHead(500).end(err instanceof Error ? err.message : String(err));\n    }\n  };\n}\n","import {\n  sign,\n  SIGNATURE_HEADER,\n  APP_HEADER,\n  type SyncRequest,\n  type WindowLimit,\n} from \"@durable/shared\";\nimport type { DurableFunction } from \"./function.js\";\nimport { parseDuration } from \"./step.js\";\n\nfunction toWindow(w?: { limit: number; period: string | number; key?: string }): WindowLimit | undefined {\n  return w ? { limit: w.limit, periodMs: parseDuration(w.period), key: w.key } : undefined;\n}\n\nexport interface DurableClientOptions {\n  /** Base URL of the Durable service. */\n  baseUrl: string;\n  /** This app's id (from the dashboard). */\n  appId: string;\n  /** This app's signing key (from the dashboard). */\n  signingKey: string;\n  /** This app's callback base URL, where the service POSTs invocations. */\n  appUrl: string;\n}\n\nexport class DurableClient {\n  constructor(private readonly opts: DurableClientOptions) {}\n\n  private async post(path: string, payload: unknown): Promise<void> {\n    const body = JSON.stringify(payload);\n    const res = await fetch(this.opts.baseUrl + path, {\n      method: \"POST\",\n      headers: {\n        \"content-type\": \"application/json\",\n        [APP_HEADER]: this.opts.appId,\n        [SIGNATURE_HEADER]: sign(body, this.opts.signingKey),\n      },\n      body,\n    });\n    if (!res.ok) {\n      throw new Error(\n        `durable ${path} failed: ${res.status} ${await res.text()}`,\n      );\n    }\n  }\n\n  /** Register this app's functions and callback URL with the service. */\n  async sync(functions: DurableFunction[]): Promise<void> {\n    const payload: SyncRequest = {\n      url: this.opts.appUrl,\n      functions: functions.map((f) => ({\n        id: f.id,\n        trigger: f.trigger,\n        concurrency: f.concurrency,\n        priority: f.priority,\n        throttle: toWindow(f.throttle),\n        rateLimit: toWindow(f.rateLimit),\n        debounce: f.debounce\n          ? { periodMs: parseDuration(f.debounce.period), key: f.debounce.key }\n          : undefined,\n        batch: f.batch\n          ? { maxSize: f.batch.maxSize, timeoutMs: parseDuration(f.batch.timeout), key: f.batch.key }\n          : undefined,\n      })),\n    };\n    await this.post(\"/fn/sync\", payload);\n  }\n\n  /** Send an event to the service. */\n  async send(event: { name: string; data?: unknown }): Promise<void> {\n    await this.post(\"/e\", { name: event.name, data: event.data ?? {} });\n  }\n}\n"],"mappings":"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","names":["message"]}

package/dist/index.d.cts

@@ -0,0 +1,119 @@
+import { DurableEvent, InvokeResponse, MemoizedStep, Trigger, Concurrency, InvokeRequest } from '@durable/shared';
+import { IncomingMessage, ServerResponse } from 'node:http';
+
+/**
+ * Thrown to unwind the handler the moment it reaches a new operation. The
+ * carried response is exactly what the SDK reports to the service. Using an
+ * exception means at most one *new* step executes per invocation — everything
+ * after it is skipped until the service re-invokes with that step memoized.
+ */
+declare class StepInterrupt extends Error {
+    readonly response: InvokeResponse;
+    constructor(response: InvokeResponse);
+}
+interface WaitForEventOptions {
+    /** The event name to wait for. */
+    event: string;
+    /** Key/value pairs the incoming event.data must contain to match. */
+    match?: Record<string, unknown>;
+    /** How long to wait before giving up (e.g. "7d", "1h", or ms). */
+    timeout: string | number;
+}
+interface StepTools {
+    /** Run a side-effecting step once; its result is memoized and replayed. */
+    run<T>(id: string, cb: () => Promise<T> | T): Promise<T>;
+    /** Pause the run until the duration elapses (e.g. "10s", "2d", or ms). */
+    sleep(id: string, duration: string | number): Promise<void>;
+    /**
+     * Pause the run until a matching event arrives, or the timeout elapses.
+     * Resolves with the matched event, or `null` if it timed out.
+     */
+    waitForEvent(id: string, opts: WaitForEventOptions): Promise<DurableEvent | null>;
+}
+declare function parseDuration(d: string | number): number;
+/** Build the step tools bound to the steps already memoized for this run. */
+declare function createStep(memoized: Record<string, MemoizedStep>): StepTools;
+
+interface FunctionContext {
+    event: DurableEvent;
+    step: StepTools;
+}
+interface DurableFunction {
+    id: string;
+    /** Triggered by an event name (`{ event }`) or a cron expression (`{ cron }`). */
+    trigger: Trigger;
+    /** Optional cap on how many runs execute at once (per key, if given). */
+    concurrency?: Concurrency;
+    /** Higher runs sooner when jobs compete in the queue (default 0). */
+    priority?: number;
+    /** Spread run starts over time: max `limit` per `period` (excess delayed). */
+    throttle?: {
+        limit: number;
+        period: string | number;
+        key?: string;
+    };
+    /** Cap new runs: max `limit` per `period` (excess dropped). */
+    rateLimit?: {
+        limit: number;
+        period: string | number;
+        key?: string;
+    };
+    /** Collapse rapid events: one run with the LAST event, once quiet for `period`. */
+    debounce?: {
+        period: string | number;
+        key?: string;
+    };
+    /**
+     * Group events: ONE run receives event.data = the whole list, flushed at
+     * `maxSize` events or `timeout` after the first (event.name = "$batch").
+     */
+    batch?: {
+        maxSize: number;
+        timeout: string | number;
+        key?: string;
+    };
+    handler: (ctx: FunctionContext) => Promise<unknown>;
+}
+declare function createFunction(def: DurableFunction): DurableFunction;
+/**
+ * Replay a single invocation: run the handler from the top, returning the next
+ * operation it reaches (a new step, a sleep, completion, or an error).
+ */
+declare function runInvocation(fn: DurableFunction, req: InvokeRequest): Promise<InvokeResponse>;
+
+/**
+ * Returns a Node HTTP handler (also usable directly as an Express route) that
+ * the Durable service POSTs invocations to. Verifies the HMAC, replays the run,
+ * and returns the next operation — itself signed so the service can trust it.
+ *
+ * Mount this route WITHOUT a JSON body parser; the handler reads the raw stream
+ * so it can verify the signature over the exact bytes.
+ */
+declare function serve(functions: DurableFunction[], opts: {
+    signingKey: string;
+}): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+
+interface DurableClientOptions {
+    /** Base URL of the Durable service. */
+    baseUrl: string;
+    /** This app's id (from the dashboard). */
+    appId: string;
+    /** This app's signing key (from the dashboard). */
+    signingKey: string;
+    /** This app's callback base URL, where the service POSTs invocations. */
+    appUrl: string;
+}
+declare class DurableClient {
+    private readonly opts;
+    constructor(opts: DurableClientOptions);
+    private post;
+    /** Register this app's functions and callback URL with the service. */
+    sync(functions: DurableFunction[]): Promise<void>;
+    /** Send an event to the service. */
+    send(event: {
+        name: string;
+        data?: unknown;
+    }): Promise<void>;
+}
+
+export { DurableClient, type DurableClientOptions, type DurableFunction, type FunctionContext, StepInterrupt, type StepTools, type WaitForEventOptions, createFunction, createStep, parseDuration, runInvocation, serve };

package/dist/index.d.ts

@@ -0,0 +1,119 @@
+import { DurableEvent, InvokeResponse, MemoizedStep, Trigger, Concurrency, InvokeRequest } from '@durable/shared';
+import { IncomingMessage, ServerResponse } from 'node:http';
+
+/**
+ * Thrown to unwind the handler the moment it reaches a new operation. The
+ * carried response is exactly what the SDK reports to the service. Using an
+ * exception means at most one *new* step executes per invocation — everything
+ * after it is skipped until the service re-invokes with that step memoized.
+ */
+declare class StepInterrupt extends Error {
+    readonly response: InvokeResponse;
+    constructor(response: InvokeResponse);
+}
+interface WaitForEventOptions {
+    /** The event name to wait for. */
+    event: string;
+    /** Key/value pairs the incoming event.data must contain to match. */
+    match?: Record<string, unknown>;
+    /** How long to wait before giving up (e.g. "7d", "1h", or ms). */
+    timeout: string | number;
+}
+interface StepTools {
+    /** Run a side-effecting step once; its result is memoized and replayed. */
+    run<T>(id: string, cb: () => Promise<T> | T): Promise<T>;
+    /** Pause the run until the duration elapses (e.g. "10s", "2d", or ms). */
+    sleep(id: string, duration: string | number): Promise<void>;
+    /**
+     * Pause the run until a matching event arrives, or the timeout elapses.
+     * Resolves with the matched event, or `null` if it timed out.
+     */
+    waitForEvent(id: string, opts: WaitForEventOptions): Promise<DurableEvent | null>;
+}
+declare function parseDuration(d: string | number): number;
+/** Build the step tools bound to the steps already memoized for this run. */
+declare function createStep(memoized: Record<string, MemoizedStep>): StepTools;
+
+interface FunctionContext {
+    event: DurableEvent;
+    step: StepTools;
+}
+interface DurableFunction {
+    id: string;
+    /** Triggered by an event name (`{ event }`) or a cron expression (`{ cron }`). */
+    trigger: Trigger;
+    /** Optional cap on how many runs execute at once (per key, if given). */
+    concurrency?: Concurrency;
+    /** Higher runs sooner when jobs compete in the queue (default 0). */
+    priority?: number;
+    /** Spread run starts over time: max `limit` per `period` (excess delayed). */
+    throttle?: {
+        limit: number;
+        period: string | number;
+        key?: string;
+    };
+    /** Cap new runs: max `limit` per `period` (excess dropped). */
+    rateLimit?: {
+        limit: number;
+        period: string | number;
+        key?: string;
+    };
+    /** Collapse rapid events: one run with the LAST event, once quiet for `period`. */
+    debounce?: {
+        period: string | number;
+        key?: string;
+    };
+    /**
+     * Group events: ONE run receives event.data = the whole list, flushed at
+     * `maxSize` events or `timeout` after the first (event.name = "$batch").
+     */
+    batch?: {
+        maxSize: number;
+        timeout: string | number;
+        key?: string;
+    };
+    handler: (ctx: FunctionContext) => Promise<unknown>;
+}
+declare function createFunction(def: DurableFunction): DurableFunction;
+/**
+ * Replay a single invocation: run the handler from the top, returning the next
+ * operation it reaches (a new step, a sleep, completion, or an error).
+ */
+declare function runInvocation(fn: DurableFunction, req: InvokeRequest): Promise<InvokeResponse>;
+
+/**
+ * Returns a Node HTTP handler (also usable directly as an Express route) that
+ * the Durable service POSTs invocations to. Verifies the HMAC, replays the run,
+ * and returns the next operation — itself signed so the service can trust it.
+ *
+ * Mount this route WITHOUT a JSON body parser; the handler reads the raw stream
+ * so it can verify the signature over the exact bytes.
+ */
+declare function serve(functions: DurableFunction[], opts: {
+    signingKey: string;
+}): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+
+interface DurableClientOptions {
+    /** Base URL of the Durable service. */
+    baseUrl: string;
+    /** This app's id (from the dashboard). */
+    appId: string;
+    /** This app's signing key (from the dashboard). */
+    signingKey: string;
+    /** This app's callback base URL, where the service POSTs invocations. */
+    appUrl: string;
+}
+declare class DurableClient {
+    private readonly opts;
+    constructor(opts: DurableClientOptions);
+    private post;
+    /** Register this app's functions and callback URL with the service. */
+    sync(functions: DurableFunction[]): Promise<void>;
+    /** Send an event to the service. */
+    send(event: {
+        name: string;
+        data?: unknown;
+    }): Promise<void>;
+}
+
+export { DurableClient, type DurableClientOptions, type DurableFunction, type FunctionContext, StepInterrupt, type StepTools, type WaitForEventOptions, createFunction, createStep, parseDuration, runInvocation, serve };

package/dist/index.js

@@ -0,0 +1,206 @@
+// src/step.ts
+var StepInterrupt = class extends Error {
+  constructor(response) {
+    super("durable:step-interrupt");
+    this.response = response;
+  }
+  response;
+};
+var UNITS = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+function parseDuration(d) {
+  if (typeof d === "number") return d;
+  const m = /^(\d+)\s*(ms|s|m|h|d)$/.exec(d.trim());
+  if (!m) throw new Error(`invalid duration: ${d}`);
+  return Number(m[1]) * UNITS[m[2]];
+}
+function message(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function createStep(memoized) {
+  return {
+    async run(id, cb) {
+      const memo = memoized[id];
+      if (memo) {
+        if (memo.type !== "run") {
+          throw new Error(`step "${id}" already used as a ${memo.type}`);
+        }
+        return memo.data;
+      }
+      let data;
+      try {
+        data = await cb();
+      } catch (err) {
+        throw new StepInterrupt({
+          op: "error",
+          id,
+          message: message(err),
+          retryable: true
+        });
+      }
+      throw new StepInterrupt({ op: "step", id, data });
+    },
+    async sleep(id, duration) {
+      const memo = memoized[id];
+      if (memo) {
+        if (memo.type !== "sleep") {
+          throw new Error(`step "${id}" already used as a ${memo.type}`);
+        }
+        return;
+      }
+      const until = new Date(Date.now() + parseDuration(duration)).toISOString();
+      throw new StepInterrupt({ op: "sleep", id, until });
+    },
+    async waitForEvent(id, opts) {
+      const memo = memoized[id];
+      if (memo) {
+        if (memo.type !== "wait") {
+          throw new Error(`step "${id}" already used as a ${memo.type}`);
+        }
+        return memo.data ?? null;
+      }
+      const until = new Date(Date.now() + parseDuration(opts.timeout)).toISOString();
+      throw new StepInterrupt({
+        op: "wait",
+        id,
+        event: opts.event,
+        match: opts.match ?? null,
+        until
+      });
+    }
+  };
+}
+
+// src/function.ts
+function createFunction(def) {
+  return def;
+}
+async function runInvocation(fn, req) {
+  const step = createStep(req.steps);
+  try {
+    const data = await fn.handler({ event: req.event, step });
+    return { op: "done", data };
+  } catch (err) {
+    if (err instanceof StepInterrupt) return err.response;
+    const message2 = err instanceof Error ? err.message : String(err);
+    return { op: "error", id: null, message: message2, retryable: true };
+  }
+}
+
+// ../shared/src/protocol.ts
+var SIGNATURE_HEADER = "x-durable-signature";
+var APP_HEADER = "x-durable-app";
+
+// ../shared/src/hmac.ts
+import { createHmac, timingSafeEqual } from "crypto";
+function sign(body, key) {
+  return createHmac("sha256", key).update(body).digest("hex");
+}
+function verify(body, signature, key) {
+  const expected = sign(body, key);
+  const a = Buffer.from(expected);
+  const b = Buffer.from(signature);
+  if (a.length !== b.length) return false;
+  return timingSafeEqual(a, b);
+}
+
+// src/serve.ts
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+}
+function serve(functions, opts) {
+  return async (req, res) => {
+    try {
+      const raw = await readBody(req);
+      const sig = req.headers[SIGNATURE_HEADER];
+      if (typeof sig !== "string" || !verify(raw, sig, opts.signingKey)) {
+        res.writeHead(401).end("invalid signature");
+        return;
+      }
+      const body = JSON.parse(raw);
+      const fn = functions.find((f) => f.id === body.functionId);
+      const response = fn ? await runInvocation(fn, body) : {
+        op: "error",
+        id: null,
+        message: `unknown function ${body.functionId}`,
+        retryable: false
+      };
+      const out = JSON.stringify(response);
+      res.writeHead(200, {
+        "content-type": "application/json",
+        [SIGNATURE_HEADER]: sign(out, opts.signingKey)
+      }).end(out);
+    } catch (err) {
+      res.writeHead(500).end(err instanceof Error ? err.message : String(err));
+    }
+  };
+}
+
+// src/client.ts
+function toWindow(w) {
+  return w ? { limit: w.limit, periodMs: parseDuration(w.period), key: w.key } : void 0;
+}
+var DurableClient = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  async post(path, payload) {
+    const body = JSON.stringify(payload);
+    const res = await fetch(this.opts.baseUrl + path, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        [APP_HEADER]: this.opts.appId,
+        [SIGNATURE_HEADER]: sign(body, this.opts.signingKey)
+      },
+      body
+    });
+    if (!res.ok) {
+      throw new Error(
+        `durable ${path} failed: ${res.status} ${await res.text()}`
+      );
+    }
+  }
+  /** Register this app's functions and callback URL with the service. */
+  async sync(functions) {
+    const payload = {
+      url: this.opts.appUrl,
+      functions: functions.map((f) => ({
+        id: f.id,
+        trigger: f.trigger,
+        concurrency: f.concurrency,
+        priority: f.priority,
+        throttle: toWindow(f.throttle),
+        rateLimit: toWindow(f.rateLimit),
+        debounce: f.debounce ? { periodMs: parseDuration(f.debounce.period), key: f.debounce.key } : void 0,
+        batch: f.batch ? { maxSize: f.batch.maxSize, timeoutMs: parseDuration(f.batch.timeout), key: f.batch.key } : void 0
+      }))
+    };
+    await this.post("/fn/sync", payload);
+  }
+  /** Send an event to the service. */
+  async send(event) {
+    await this.post("/e", { name: event.name, data: event.data ?? {} });
+  }
+};
+export {
+  DurableClient,
+  StepInterrupt,
+  createFunction,
+  createStep,
+  parseDuration,
+  runInvocation,
+  serve
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/step.ts","../src/function.ts","../../shared/src/protocol.ts","../../shared/src/hmac.ts","../src/serve.ts","../src/client.ts"],"sourcesContent":["import type { DurableEvent, InvokeResponse, MemoizedStep } from \"@durable/shared\";\n\n/**\n * Thrown to unwind the handler the moment it reaches a new operation. The\n * carried response is exactly what the SDK reports to the service. Using an\n * exception means at most one *new* step executes per invocation — everything\n * after it is skipped until the service re-invokes with that step memoized.\n */\nexport class StepInterrupt extends Error {\n  constructor(public readonly response: InvokeResponse) {\n    super(\"durable:step-interrupt\");\n  }\n}\n\nexport interface WaitForEventOptions {\n  /** The event name to wait for. */\n  event: string;\n  /** Key/value pairs the incoming event.data must contain to match. */\n  match?: Record<string, unknown>;\n  /** How long to wait before giving up (e.g. \"7d\", \"1h\", or ms). */\n  timeout: string | number;\n}\n\nexport interface StepTools {\n  /** Run a side-effecting step once; its result is memoized and replayed. */\n  run<T>(id: string, cb: () => Promise<T> | T): Promise<T>;\n  /** Pause the run until the duration elapses (e.g. \"10s\", \"2d\", or ms). */\n  sleep(id: string, duration: string | number): Promise<void>;\n  /**\n   * Pause the run until a matching event arrives, or the timeout elapses.\n   * Resolves with the matched event, or `null` if it timed out.\n   */\n  waitForEvent(id: string, opts: WaitForEventOptions): Promise<DurableEvent | null>;\n}\n\nconst UNITS: Record<string, number> = {\n  ms: 1,\n  s: 1000,\n  m: 60_000,\n  h: 3_600_000,\n  d: 86_400_000,\n};\n\nexport function parseDuration(d: string | number): number {\n  if (typeof d === \"number\") return d;\n  const m = /^(\\d+)\\s*(ms|s|m|h|d)$/.exec(d.trim());\n  if (!m) throw new Error(`invalid duration: ${d}`);\n  return Number(m[1]) * UNITS[m[2]];\n}\n\nfunction message(err: unknown): string {\n  return err instanceof Error ? err.message : String(err);\n}\n\n/** Build the step tools bound to the steps already memoized for this run. */\nexport function createStep(memoized: Record<string, MemoizedStep>): StepTools {\n  return {\n    async run<T>(id: string, cb: () => Promise<T> | T): Promise<T> {\n      const memo = memoized[id];\n      if (memo) {\n        if (memo.type !== \"run\") {\n          throw new Error(`step \"${id}\" already used as a ${memo.type}`);\n        }\n        return memo.data as T; // replay: free, no side effect\n      }\n      let data: T;\n      try {\n        data = await cb();\n      } catch (err) {\n        // A genuine failure inside the step: let the service decide on retry.\n        throw new StepInterrupt({\n          op: \"error\",\n          id,\n          message: message(err),\n          retryable: true,\n        });\n      }\n      throw new StepInterrupt({ op: \"step\", id, data });\n    },\n\n    async sleep(id: string, duration: string | number): Promise<void> {\n      const memo = memoized[id];\n      if (memo) {\n        if (memo.type !== \"sleep\") {\n          throw new Error(`step \"${id}\" already used as a ${memo.type}`);\n        }\n        return; // sleep already satisfied\n      }\n      const until = new Date(Date.now() + parseDuration(duration)).toISOString();\n      throw new StepInterrupt({ op: \"sleep\", id, until });\n    },\n\n    async waitForEvent(id, opts): Promise<DurableEvent | null> {\n      const memo = memoized[id];\n      if (memo) {\n        if (memo.type !== \"wait\") {\n          throw new Error(`step \"${id}\" already used as a ${memo.type}`);\n        }\n        return (memo.data as DurableEvent | null) ?? null; // event, or null on timeout\n      }\n      const until = new Date(Date.now() + parseDuration(opts.timeout)).toISOString();\n      throw new StepInterrupt({\n        op: \"wait\",\n        id,\n        event: opts.event,\n        match: opts.match ?? null,\n        until,\n      });\n    },\n  };\n}\n","import type {\n  Concurrency,\n  DurableEvent,\n  InvokeRequest,\n  InvokeResponse,\n  Trigger,\n} from \"@durable/shared\";\nimport { createStep, StepInterrupt, type StepTools } from \"./step.js\";\n\nexport interface FunctionContext {\n  event: DurableEvent;\n  step: StepTools;\n}\n\nexport interface DurableFunction {\n  id: string;\n  /** Triggered by an event name (`{ event }`) or a cron expression (`{ cron }`). */\n  trigger: Trigger;\n  /** Optional cap on how many runs execute at once (per key, if given). */\n  concurrency?: Concurrency;\n  /** Higher runs sooner when jobs compete in the queue (default 0). */\n  priority?: number;\n  /** Spread run starts over time: max `limit` per `period` (excess delayed). */\n  throttle?: { limit: number; period: string | number; key?: string };\n  /** Cap new runs: max `limit` per `period` (excess dropped). */\n  rateLimit?: { limit: number; period: string | number; key?: string };\n  /** Collapse rapid events: one run with the LAST event, once quiet for `period`. */\n  debounce?: { period: string | number; key?: string };\n  /**\n   * Group events: ONE run receives event.data = the whole list, flushed at\n   * `maxSize` events or `timeout` after the first (event.name = \"$batch\").\n   */\n  batch?: { maxSize: number; timeout: string | number; key?: string };\n  handler: (ctx: FunctionContext) => Promise<unknown>;\n}\n\nexport function createFunction(def: DurableFunction): DurableFunction {\n  return def;\n}\n\n/**\n * Replay a single invocation: run the handler from the top, returning the next\n * operation it reaches (a new step, a sleep, completion, or an error).\n */\nexport async function runInvocation(\n  fn: DurableFunction,\n  req: InvokeRequest,\n): Promise<InvokeResponse> {\n  const step = createStep(req.steps);\n  try {\n    const data = await fn.handler({ event: req.event, step });\n    return { op: \"done\", data };\n  } catch (err) {\n    if (err instanceof StepInterrupt) return err.response;\n    // Error thrown outside any step.run (in the handler body itself).\n    const message = err instanceof Error ? err.message : String(err);\n    return { op: \"error\", id: null, message, retryable: true };\n  }\n}\n","/**\n * Wire protocol between the Durable service and the app SDK.\n *\n * One HTTP round-trip advances a run by at most one *new* step. The service\n * sends the run state (event + already-memoized steps); the SDK replays the\n * cached steps for free, executes the next new operation, and reports it back.\n */\n\n/** An event that triggered (or can trigger) a run. */\nexport interface DurableEvent {\n  id: string;\n  name: string;\n  data: unknown;\n}\n\n/** A previously-completed step, keyed by its user-supplied step id. */\nexport interface MemoizedStep {\n  /**\n   * \"run\"   = a step.run result,\n   * \"sleep\" = a satisfied step.sleep marker,\n   * \"wait\"  = a settled step.waitForEvent (data = the event, or null on timeout).\n   */\n  type: \"run\" | \"sleep\" | \"wait\";\n  /** Output of step.run, or the matched event for \"wait\". Null otherwise. */\n  data: unknown;\n}\n\n/** Service -> SDK: \"advance this run\". */\nexport interface InvokeRequest {\n  runId: string;\n  functionId: string;\n  event: DurableEvent;\n  /** Completed steps so far, keyed by step id. */\n  steps: Record<string, MemoizedStep>;\n}\n\n/**\n * SDK -> service: the next operation the function reached.\n *\n *  - step  : a new step.run executed; persist `data` under `id`, then re-invoke.\n *  - sleep : function wants to pause until `until`; arm a timer.\n *  - done  : function returned; the run is complete with `data`.\n *  - error : the current step threw; retry (if retryable) or fail the run.\n */\nexport type InvokeResponse =\n  | { op: \"step\"; id: string; data: unknown }\n  | { op: \"sleep\"; id: string; until: string /* ISO timestamp */ }\n  | {\n      op: \"wait\";\n      id: string;\n      event: string;\n      /** Key/value pairs the incoming event.data must contain; null = any. */\n      match: Record<string, unknown> | null;\n      until: string /* ISO timestamp timeout */;\n    }\n  | { op: \"done\"; data: unknown }\n  | { op: \"error\"; id: string | null; message: string; retryable: boolean };\n\n/** A function is triggered by either an event name or a cron expression. */\nexport type Trigger = { event: string } | { cron: string };\n\n/** Optional concurrency cap for a function. */\nexport interface Concurrency {\n  /** Max runs executing at once (per key, if given). */\n  limit: number;\n  /** event.data field name to scope the limit by (e.g. \"tenantId\"). */\n  key?: string;\n}\n\n/** Wire form of a throttle/rate-limit rule (period already in ms). */\nexport interface WindowLimit {\n  limit: number;\n  periodMs: number;\n  key?: string;\n}\n\n/** Wire form of a debounce rule (period already in ms). */\nexport interface DebounceRule {\n  periodMs: number;\n  key?: string;\n}\n\n/** Wire form of a batch rule (timeout already in ms). */\nexport interface BatchRule {\n  maxSize: number;\n  timeoutMs: number;\n  key?: string;\n}\n\n/** Registry sync: app -> service, \"here are my functions and where to reach me\". */\nexport interface SyncRequest {\n  /** Base URL the service should POST invocations to (callback endpoint). */\n  url: string;\n  functions: Array<{\n    id: string;\n    trigger: Trigger;\n    concurrency?: Concurrency;\n    priority?: number;\n    throttle?: WindowLimit;\n    rateLimit?: WindowLimit;\n    debounce?: DebounceRule;\n    batch?: BatchRule;\n  }>;\n}\n\n/** Header carrying the HMAC signature on every service<->app request body. */\nexport const SIGNATURE_HEADER = \"x-durable-signature\";\n\n/** Header carrying the app id on app -> service requests. */\nexport const APP_HEADER = \"x-durable-app\";\n","import { createHmac, timingSafeEqual } from \"node:crypto\";\n\n/** Compute the hex HMAC-SHA256 of a raw request body. */\nexport function sign(body: string, key: string): string {\n  return createHmac(\"sha256\", key).update(body).digest(\"hex\");\n}\n\n/** Constant-time verify of a signature against a raw body. */\nexport function verify(body: string, signature: string, key: string): boolean {\n  const expected = sign(body, key);\n  const a = Buffer.from(expected);\n  const b = Buffer.from(signature);\n  if (a.length !== b.length) return false;\n  return timingSafeEqual(a, b);\n}\n","import type { IncomingMessage, ServerResponse } from \"node:http\";\nimport {\n  sign,\n  verify,\n  SIGNATURE_HEADER,\n  type InvokeRequest,\n} from \"@durable/shared\";\nimport { runInvocation, type DurableFunction } from \"./function.js\";\n\nfunction readBody(req: IncomingMessage): Promise<string> {\n  return new Promise((resolve, reject) => {\n    const chunks: Buffer[] = [];\n    req.on(\"data\", (c) => chunks.push(c as Buffer));\n    req.on(\"end\", () => resolve(Buffer.concat(chunks).toString(\"utf8\")));\n    req.on(\"error\", reject);\n  });\n}\n\n/**\n * Returns a Node HTTP handler (also usable directly as an Express route) that\n * the Durable service POSTs invocations to. Verifies the HMAC, replays the run,\n * and returns the next operation — itself signed so the service can trust it.\n *\n * Mount this route WITHOUT a JSON body parser; the handler reads the raw stream\n * so it can verify the signature over the exact bytes.\n */\nexport function serve(\n  functions: DurableFunction[],\n  opts: { signingKey: string },\n) {\n  return async (req: IncomingMessage, res: ServerResponse): Promise<void> => {\n    try {\n      const raw = await readBody(req);\n      const sig = req.headers[SIGNATURE_HEADER];\n      if (typeof sig !== \"string\" || !verify(raw, sig, opts.signingKey)) {\n        res.writeHead(401).end(\"invalid signature\");\n        return;\n      }\n\n      const body = JSON.parse(raw) as InvokeRequest;\n      const fn = functions.find((f) => f.id === body.functionId);\n      const response = fn\n        ? await runInvocation(fn, body)\n        : ({\n            op: \"error\" as const,\n            id: null,\n            message: `unknown function ${body.functionId}`,\n            retryable: false,\n          });\n\n      const out = JSON.stringify(response);\n      res\n        .writeHead(200, {\n          \"content-type\": \"application/json\",\n          [SIGNATURE_HEADER]: sign(out, opts.signingKey),\n        })\n        .end(out);\n    } catch (err) {\n      res.writeHead(500).end(err instanceof Error ? err.message : String(err));\n    }\n  };\n}\n","import {\n  sign,\n  SIGNATURE_HEADER,\n  APP_HEADER,\n  type SyncRequest,\n  type WindowLimit,\n} from \"@durable/shared\";\nimport type { DurableFunction } from \"./function.js\";\nimport { parseDuration } from \"./step.js\";\n\nfunction toWindow(w?: { limit: number; period: string | number; key?: string }): WindowLimit | undefined {\n  return w ? { limit: w.limit, periodMs: parseDuration(w.period), key: w.key } : undefined;\n}\n\nexport interface DurableClientOptions {\n  /** Base URL of the Durable service. */\n  baseUrl: string;\n  /** This app's id (from the dashboard). */\n  appId: string;\n  /** This app's signing key (from the dashboard). */\n  signingKey: string;\n  /** This app's callback base URL, where the service POSTs invocations. */\n  appUrl: string;\n}\n\nexport class DurableClient {\n  constructor(private readonly opts: DurableClientOptions) {}\n\n  private async post(path: string, payload: unknown): Promise<void> {\n    const body = JSON.stringify(payload);\n    const res = await fetch(this.opts.baseUrl + path, {\n      method: \"POST\",\n      headers: {\n        \"content-type\": \"application/json\",\n        [APP_HEADER]: this.opts.appId,\n        [SIGNATURE_HEADER]: sign(body, this.opts.signingKey),\n      },\n      body,\n    });\n    if (!res.ok) {\n      throw new Error(\n        `durable ${path} failed: ${res.status} ${await res.text()}`,\n      );\n    }\n  }\n\n  /** Register this app's functions and callback URL with the service. */\n  async sync(functions: DurableFunction[]): Promise<void> {\n    const payload: SyncRequest = {\n      url: this.opts.appUrl,\n      functions: functions.map((f) => ({\n        id: f.id,\n        trigger: f.trigger,\n        concurrency: f.concurrency,\n        priority: f.priority,\n        throttle: toWindow(f.throttle),\n        rateLimit: toWindow(f.rateLimit),\n        debounce: f.debounce\n          ? { periodMs: parseDuration(f.debounce.period), key: f.debounce.key }\n          : undefined,\n        batch: f.batch\n          ? { maxSize: f.batch.maxSize, timeoutMs: parseDuration(f.batch.timeout), key: f.batch.key }\n          : undefined,\n      })),\n    };\n    await this.post(\"/fn/sync\", payload);\n  }\n\n  /** Send an event to the service. */\n  async send(event: { name: string; data?: unknown }): Promise<void> {\n    await this.post(\"/e\", { name: event.name, data: event.data ?? {} });\n  }\n}\n"],"mappings":"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","names":["message"]}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@dicabrio/durable-sdk",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "TypeScript SDK for the Durable execution engine: define durable functions, sync them, send events, and serve the replay callback.",
+  "license": "MIT",
+  "author": "dicabrio",
+  "homepage": "https://durable.dicabrio.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://bitbucket.org/dicabriocom/durable.git",
+    "directory": "packages/sdk"
+  },
+  "keywords": [
+    "durable",
+    "durable-execution",
+    "workflow",
+    "step-functions",
+    "background-jobs",
+    "inngest"
+  ],
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "prepublishOnly": "tsup"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}