@arbitro/client 0.2.0 → 0.5.0

package/README.md

@@ -41,14 +41,14 @@ npm install @arbitro/client
 The broker ships as a public Docker image (musl-static, ~3 MB, scratch base):
 
 ```bash
-docker run --rm -p 9898:9898 ghcr.io/arbitro-io/arbitro-server:0.1.0
+docker run --rm -p 9898:9898 ghcr.io/arbitro-io/arbitro-server:latest
 ```
 
 Pin a major/minor tag for production:
 
-- `ghcr.io/arbitro-io/arbitro-server:0.1.0` — immutable, recommended for prod
+- `ghcr.io/arbitro-io/arbitro-server:0.1.0` — immutable release tag
 - `ghcr.io/arbitro-io/arbitro-server:0.1`   — auto-updates within `0.1.*`
-- `ghcr.io/arbitro-io/arbitro-server:latest` — last tagged release
+- `ghcr.io/arbitro-io/arbitro-server:latest` — latest tagged release
 
 ## Quick start
 
@@ -219,33 +219,111 @@ const sub = await client
 
 `zod` is an optional peer dependency. `@arbitro/client` references zod only via `import type`, so users who never call `zodCodec` pay zero runtime cost and don't need zod installed.
 
-## Reconnect behavior
+## Cron Scheduling
 
-The TS client reconnects transport automatically and reattaches active subscriptions after reconnect. That behavior lives in the client, not in the benchmarks. This matters for:
+Register distributed cron jobs with queue semantics — multiple workers, single delivery per fire.
 
-- Docker restarts
-- broker failover tests
-- chaos scenarios with durable consumers
+```typescript
+const cron = await client.cron("billing-monthly")
+    .every("0 0 1 * *")
+    .tz("America/New_York")
+    .run(async (ctx) => {
+        console.log(`fire #${ctx.fireCount} at ${ctx.fireTime}`);
+        await processBilling();
+    });
+
+// Stop when done
+await cron.stop();
+```
 
-## Benchmarks
+Crons re-register automatically on reconnect. No persistence — if the broker restarts, clients re-register their crons when they reconnect.
 
-Three primary bench families:
+## Delayed Publish
 
-| File | npm script | What it measures |
-|---|---|---|
-| `benches/throughput.ts` | `npm run bench` | Publish + delivery throughput across modes (fire-and-forget, batch, sync, replay-ack, replay-noack). |
-| `benches/limits.ts` | `npm run bench:limit` | Behaviour under `maxSubjectInflights` saturation. |
-| `benches/chaos.ts` | `npm run bench:chaos` | Restart / reconnect / persistence under failure injection. |
+Schedule message delivery for the future:
 
-Examples:
+```typescript
+await client.publishDelayed("ORDERS", "orders.reminder", payload, 5000); // 5s delay
+```
 
-```bash
-npx tsx benches/throughput.ts --mode fire-and-forget --msgs 20000
-npx tsx benches/throughput.ts --mode perf --seconds 10 --rate 20000 --container arbitro-server
-npx tsx benches/limits.ts
-npx tsx benches/chaos.ts --duration 8 --rate 50 --container arbitro-server
+Messages are persisted immediately — survives broker restart.
+
+## Workflow Orchestration
+
+Client-side linear pipelines over Arbitro streams. The broker has no workflow-specific code -- everything uses streams, consumer groups, and idempotent publish.
+
+### WorkflowBuilder API
+
+| Method | Signature | Description |
+|--------|-----------|-------------|
+| `trigger` | `(subject: string) => this` | Subject pattern that triggers new instances. Required. |
+| `triggerStream` | *(not yet implemented)* | Planned: auto-subscribe to an external stream for trigger. |
+| `step` | `(name: string, handler: StepHandler) => this` | Append a processing step. |
+| `compensate` | *(not yet implemented)* | Planned: rollback handler per step (saga pattern). |
+| `maxRetries` | *(not yet implemented)* | Planned: attempts before DLQ. |
+| `maxContextSize` | *(not yet implemented)* | Planned: max context payload in bytes. |
+| `ackWait` | `(ms: number) => this` | Ack timeout for failover (default: 30000). |
+| `inflight` | `(n: number) => this` | Concurrent tasks per worker (default: 10). |
+| `start` | `() => Promise<WorkflowHandle>` | Register streams, consumer, and start processing. |
+
+### WorkflowHandle API
+
+| Method | Signature | Description |
+|--------|-----------|-------------|
+| `trigger` | `(client: ArbitroClient, context: Buffer) => Promise<number>` | Trigger a new workflow instance. Returns the instance ID. |
+| `name` | `string` (getter) | Workflow name. |
+
+### Complete Example
+
+```typescript
+import { ArbitroClient, WorkflowBuilder } from '@arbitro/client'
+import type { StepContext, StepResult } from '@arbitro/client'
+
+const client = new ArbitroClient({ servers: ['127.0.0.1:9898'] })
+await client.connect()
+
+const wf = await new WorkflowBuilder(client, 'order-process')
+  .trigger('orders.created')
+  // Step 1: validate
+  .step('validate', async (ctx: StepContext): Promise<StepResult> => {
+    const validated = await validateOrder(ctx.context)
+    return { context: validated }
+  })
+  // Step 2: charge
+  .step('charge', async (ctx: StepContext): Promise<StepResult> => {
+    const receipt = await chargePayment(ctx.context)
+    return { context: receipt }
+  })
+  // Step 3: ship
+  .step('ship', async (ctx: StepContext): Promise<StepResult> => {
+    const tracking = await createShipment(ctx.context)
+    return { context: tracking }
+  })
+  .ackWait(30_000)
+  .inflight(10)
+  .start()
+
+// Manual trigger
+const instanceId = await wf.trigger(client, Buffer.from('order-123-payload'))
+console.log(`started instance ${instanceId}`)
 ```
 
+### Internals
+
+- Tasks flow through `_wf.{name}.tasks` stream with a consumer `_wf.{name}.workers`.
+- Each step transition publishes with `msgId` format `wf:{instance}:{step}:{attempt}` for deduplication.
+- `ackWait` enables failover: if a worker dies, the broker redelivers to another subscriber.
+
+> **Note:** The TypeScript workflow module currently implements the core step pipeline. Compensation (saga), DLQ, `triggerStream`, `maxRetries`, and `maxContextSize` are available in the Rust client and planned for the TS client.
+
+## Reconnect behavior
+
+The TS client reconnects transport automatically and reattaches active subscriptions and cron jobs after reconnect. That behavior lives in the client, not in the benchmarks. This matters for:
+
+- Docker restarts
+- broker failover tests
+- chaos scenarios with durable consumers
+
 ## Validation
 
 ```bash

package/dist/chunk-C2QLJBAC.mjs

@@ -0,0 +1,102 @@
+// src/proto/constants.ts
+var MAGIC_V2 = 843207233;
+var HELLO_SIZE = 8;
+var CURRENT_VERSION = 2;
+var Role = /* @__PURE__ */ ((Role2) => {
+  Role2[Role2["Client"] = 0] = "Client";
+  Role2[Role2["Server"] = 1] = "Server";
+  return Role2;
+})(Role || {});
+var Cap = /* @__PURE__ */ ((Cap2) => {
+  Cap2[Cap2["Headers"] = 1] = "Headers";
+  Cap2[Cap2["Reply"] = 2] = "Reply";
+  Cap2[Cap2["BatchHeaders"] = 4] = "BatchHeaders";
+  Cap2[Cap2["CompressedPayload"] = 8] = "CompressedPayload";
+  return Cap2;
+})(Cap || {});
+var HEADER_SIZE = 16;
+var OFF_ACTION = 0;
+var OFF_FLAGS = 2;
+var OFF_ENTRY_FLAGS = 3;
+var OFF_MSG_LEN = 4;
+var OFF_SEQ = 8;
+var Flag = /* @__PURE__ */ ((Flag2) => {
+  Flag2[Flag2["None"] = 0] = "None";
+  Flag2[Flag2["AckReq"] = 1] = "AckReq";
+  Flag2[Flag2["Dup"] = 2] = "Dup";
+  Flag2[Flag2["PriorityHigh"] = 4] = "PriorityHigh";
+  return Flag2;
+})(Flag || {});
+var EntryFlag = /* @__PURE__ */ ((EntryFlag2) => {
+  EntryFlag2[EntryFlag2["None"] = 0] = "None";
+  EntryFlag2[EntryFlag2["Retain"] = 1] = "Retain";
+  EntryFlag2[EntryFlag2["Compressed"] = 2] = "Compressed";
+  EntryFlag2[EntryFlag2["NoBackpressure"] = 4] = "NoBackpressure";
+  return EntryFlag2;
+})(EntryFlag || {});
+var Action = /* @__PURE__ */ ((Action2) => {
+  Action2[Action2["Hello"] = 1] = "Hello";
+  Action2[Action2["Auth"] = 2] = "Auth";
+  Action2[Action2["Publish"] = 257] = "Publish";
+  Action2[Action2["PublishAccumulate"] = 258] = "PublishAccumulate";
+  Action2[Action2["PublishBatch"] = 259] = "PublishBatch";
+  Action2[Action2["PublishWithReply"] = 260] = "PublishWithReply";
+  Action2[Action2["PublishWithHeaders"] = 261] = "PublishWithHeaders";
+  Action2[Action2["PublishBatchWithHeaders"] = 262] = "PublishBatchWithHeaders";
+  Action2[Action2["Deliver"] = 512] = "Deliver";
+  Action2[Action2["Ack"] = 513] = "Ack";
+  Action2[Action2["Nack"] = 514] = "Nack";
+  Action2[Action2["RepOk"] = 515] = "RepOk";
+  Action2[Action2["RepError"] = 516] = "RepError";
+  Action2[Action2["RepBatch"] = 517] = "RepBatch";
+  Action2[Action2["BatchAck"] = 518] = "BatchAck";
+  Action2[Action2["FanoutBatch"] = 519] = "FanoutBatch";
+  Action2[Action2["AckSync"] = 520] = "AckSync";
+  Action2[Action2["BatchAckSync"] = 521] = "BatchAckSync";
+  Action2[Action2["BatchNack"] = 522] = "BatchNack";
+  Action2[Action2["Subscribe"] = 769] = "Subscribe";
+  Action2[Action2["Unsubscribe"] = 770] = "Unsubscribe";
+  Action2[Action2["CreateStream"] = 1025] = "CreateStream";
+  Action2[Action2["DeleteStream"] = 1026] = "DeleteStream";
+  Action2[Action2["GetStream"] = 1027] = "GetStream";
+  Action2[Action2["ListStreams"] = 1028] = "ListStreams";
+  Action2[Action2["PurgeStream"] = 1029] = "PurgeStream";
+  Action2[Action2["DrainSubject"] = 1030] = "DrainSubject";
+  Action2[Action2["CreateConsumer"] = 1281] = "CreateConsumer";
+  Action2[Action2["DeleteConsumer"] = 1282] = "DeleteConsumer";
+  Action2[Action2["GetConsumer"] = 1283] = "GetConsumer";
+  Action2[Action2["ListConsumers"] = 1284] = "ListConsumers";
+  Action2[Action2["ConsumerStats"] = 1285] = "ConsumerStats";
+  Action2[Action2["PauseConsumer"] = 1286] = "PauseConsumer";
+  Action2[Action2["ResumeConsumer"] = 1287] = "ResumeConsumer";
+  Action2[Action2["PublishDelayed"] = 2049] = "PublishDelayed";
+  Action2[Action2["Ping"] = 1537] = "Ping";
+  Action2[Action2["Pong"] = 1538] = "Pong";
+  Action2[Action2["Connect"] = 1539] = "Connect";
+  Action2[Action2["Connected"] = 1540] = "Connected";
+  Action2[Action2["Disconnect"] = 1541] = "Disconnect";
+  Action2[Action2["CreateCron"] = 1793] = "CreateCron";
+  Action2[Action2["DeleteCron"] = 1794] = "DeleteCron";
+  Action2[Action2["ListCrons"] = 1795] = "ListCrons";
+  Action2[Action2["CronFire"] = 1796] = "CronFire";
+  Action2[Action2["CronAck"] = 1797] = "CronAck";
+  return Action2;
+})(Action || {});
+
+export {
+  MAGIC_V2,
+  HELLO_SIZE,
+  CURRENT_VERSION,
+  Role,
+  Cap,
+  HEADER_SIZE,
+  OFF_ACTION,
+  OFF_FLAGS,
+  OFF_ENTRY_FLAGS,
+  OFF_MSG_LEN,
+  OFF_SEQ,
+  Flag,
+  EntryFlag,
+  Action
+};
+//# sourceMappingURL=chunk-C2QLJBAC.mjs.map

package/dist/chunk-C2QLJBAC.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/proto/constants.ts"],"sourcesContent":["// V2 wire protocol constants — must match arbitro-proto/src/action.rs exactly.\n\n// ── Hello handshake (only frame without a Header) ───────────────────────\nexport const MAGIC_V2       = 0x32425241  // \"ARB2\" as u32 LE\nexport const HELLO_SIZE     = 8\nexport const CURRENT_VERSION = 2\n\nexport const enum Role {\n  Client = 0,\n  Server = 1,\n}\n\nexport const enum Cap {\n  Headers          = 1 << 0,\n  Reply            = 1 << 1,\n  BatchHeaders     = 1 << 2,\n  CompressedPayload = 1 << 3,\n}\n\n// ── Header (16 bytes, every frame after Hello) ──────────────────────────\nexport const HEADER_SIZE     = 16\n\n// Byte offsets within the 16-byte header\nexport const OFF_ACTION      = 0   // u16 LE\nexport const OFF_FLAGS       = 2   // u8\nexport const OFF_ENTRY_FLAGS = 3   // u8\nexport const OFF_MSG_LEN     = 4   // u32 LE\nexport const OFF_SEQ         = 8   // u64 LE\n\n// ── Transport flags (header.flags, offset 2) ────────────────────────────\nexport const enum Flag {\n  None         = 0x00,\n  AckReq       = 0x01,\n  Dup          = 0x02,\n  PriorityHigh = 0x04,\n}\n\n// ── Per-message flags (header.entry_flags, offset 3) ────────────────────\nexport const enum EntryFlag {\n  None           = 0x00,\n  Retain         = 0x01,\n  Compressed     = 0x02,\n  NoBackpressure = 0x04,\n}\n\n// ── Action codes (0xFFGG: FF=family, GG=variant) ────────────────────────\nexport const enum Action {\n  // 0x00xx — Handshake / control\n  Hello           = 0x0001,\n  Auth            = 0x0002,\n\n  // 0x01xx — Publish family\n  Publish                 = 0x0101,\n  PublishAccumulate       = 0x0102,\n  PublishBatch            = 0x0103,\n  PublishWithReply        = 0x0104,\n  PublishWithHeaders      = 0x0105,\n  PublishBatchWithHeaders = 0x0106,\n\n  // 0x02xx — Delivery / Ack\n  Deliver      = 0x0200,\n  Ack          = 0x0201,\n  Nack         = 0x0202,\n  RepOk        = 0x0203,\n  RepError     = 0x0204,\n  RepBatch     = 0x0205,\n  BatchAck     = 0x0206,\n  FanoutBatch  = 0x0207,\n  AckSync      = 0x0208,\n  BatchAckSync = 0x0209,\n  BatchNack    = 0x020A,\n\n  // 0x03xx — Subscription\n  Subscribe   = 0x0301,\n  Unsubscribe = 0x0302,\n\n  // 0x04xx — Stream management\n  CreateStream = 0x0401,\n  DeleteStream = 0x0402,\n  GetStream    = 0x0403,\n  ListStreams  = 0x0404,\n  PurgeStream  = 0x0405,\n  DrainSubject = 0x0406,\n\n  // 0x05xx — Consumer management\n  CreateConsumer = 0x0501,\n  DeleteConsumer = 0x0502,\n  GetConsumer    = 0x0503,\n  ListConsumers  = 0x0504,\n  ConsumerStats  = 0x0505,\n  PauseConsumer  = 0x0506,\n  ResumeConsumer = 0x0507,\n\n  // 0x08xx — Delayed publish\n  PublishDelayed = 0x0801,\n\n  // 0x06xx — System\n  Ping       = 0x0601,\n  Pong       = 0x0602,\n  Connect    = 0x0603,\n  Connected  = 0x0604,\n  Disconnect = 0x0605,\n\n  // 0x07xx — Cron scheduling\n  CreateCron = 0x0701,\n  DeleteCron = 0x0702,\n  ListCrons  = 0x0703,\n  CronFire   = 0x0704,\n  CronAck    = 0x0705,\n\n  // 0x09xx reserved (workflow removed — now a client-side library).\n}\n"],"mappings":"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","names":["Role","Cap","Flag","EntryFlag","Action"]}

package/dist/chunk-GW36GP2C.mjs

@@ -0,0 +1,124 @@
+import {
+  CURRENT_VERSION,
+  HEADER_SIZE,
+  HELLO_SIZE,
+  MAGIC_V2,
+  OFF_ACTION,
+  OFF_ENTRY_FLAGS,
+  OFF_FLAGS,
+  OFF_MSG_LEN,
+  OFF_SEQ
+} from "./chunk-C2QLJBAC.mjs";
+
+// src/proto/frame.ts
+function frame(action, seq, bodyLen, flags = 0, entryFlags = 0) {
+  const buf = Buffer.allocUnsafe(HEADER_SIZE + bodyLen);
+  buf.writeUInt16LE(action, OFF_ACTION);
+  buf[OFF_FLAGS] = flags;
+  buf[OFF_ENTRY_FLAGS] = entryFlags;
+  buf.writeUInt32LE(bodyLen, OFF_MSG_LEN);
+  buf.writeBigUInt64LE(seq, OFF_SEQ);
+  return buf;
+}
+function packHello(caps = 2 /* Reply */) {
+  const buf = Buffer.allocUnsafe(HELLO_SIZE);
+  buf.writeUInt32LE(MAGIC_V2, 0);
+  buf[4] = CURRENT_VERSION;
+  buf[5] = 0 /* Client */;
+  buf.writeUInt16LE(caps, 6);
+  return buf;
+}
+function packDisconnect(seq) {
+  return frame(1541 /* Disconnect */, seq, 0);
+}
+
+// src/proto/publish.ts
+var EMPTY = Buffer.alloc(0);
+function packPublish(seq, streamId, subject, payload, flags = 0, entryFlags = 0, msgId = EMPTY) {
+  const buf = frame(
+    257 /* Publish */,
+    seq,
+    8 + subject.length + msgId.length + payload.length,
+    flags,
+    entryFlags
+  );
+  buf.writeUInt32LE(streamId, HEADER_SIZE);
+  buf.writeUInt16LE(subject.length, HEADER_SIZE + 4);
+  buf.writeUInt16LE(msgId.length, HEADER_SIZE + 6);
+  let off = HEADER_SIZE + 8;
+  subject.copy(buf, off);
+  off += subject.length;
+  msgId.copy(buf, off);
+  off += msgId.length;
+  payload.copy(buf, off);
+  return buf;
+}
+function packPublishWithReply(seq, streamId, subject, replyTo, payload, flags = 0, entryFlags = 0) {
+  const tail = subject.length + replyTo.length + payload.length;
+  const buf = frame(260 /* PublishWithReply */, seq, 12 + tail, flags, entryFlags);
+  buf.writeUInt32LE(streamId, HEADER_SIZE);
+  buf.writeUInt16LE(subject.length, HEADER_SIZE + 4);
+  buf.writeUInt16LE(replyTo.length, HEADER_SIZE + 6);
+  buf.writeUInt32LE(0, HEADER_SIZE + 8);
+  let off = HEADER_SIZE + 12;
+  subject.copy(buf, off);
+  off += subject.length;
+  replyTo.copy(buf, off);
+  off += replyTo.length;
+  payload.copy(buf, off);
+  return buf;
+}
+function packPublishDelayed(seq, streamId, subject, payload, delayMs, flags = 0, entryFlags = 0) {
+  const buf = frame(
+    2049 /* PublishDelayed */,
+    seq,
+    16 + subject.length + payload.length,
+    flags,
+    entryFlags
+  );
+  buf.writeUInt32LE(streamId, HEADER_SIZE);
+  buf.writeUInt16LE(subject.length, HEADER_SIZE + 4);
+  buf.writeUInt16LE(0, HEADER_SIZE + 6);
+  buf.writeBigUInt64LE(delayMs, HEADER_SIZE + 8);
+  let off = HEADER_SIZE + 16;
+  subject.copy(buf, off);
+  off += subject.length;
+  payload.copy(buf, off);
+  return buf;
+}
+function packPublishBatch(seq, streamId, entries, flags = 0, entryFlags = 0) {
+  let tail = 0;
+  for (const e of entries) {
+    const midLen = e.msgId ? e.msgId.length : 0;
+    tail += 8 + e.subject.length + midLen + e.payload.length;
+  }
+  const buf = frame(259 /* PublishBatch */, seq, 8 + tail, flags, entryFlags);
+  buf.writeUInt32LE(streamId, HEADER_SIZE);
+  buf.writeUInt32LE(entries.length, HEADER_SIZE + 4);
+  let off = HEADER_SIZE + 8;
+  for (const e of entries) {
+    const mid = e.msgId ?? EMPTY;
+    buf.writeUInt16LE(e.subject.length, off);
+    buf.writeUInt16LE(mid.length, off + 2);
+    buf.writeUInt32LE(e.payload.length, off + 4);
+    off += 8;
+    buf.write(e.subject, off);
+    off += e.subject.length;
+    mid.copy(buf, off);
+    off += mid.length;
+    e.payload.copy(buf, off);
+    off += e.payload.length;
+  }
+  return buf;
+}
+
+export {
+  frame,
+  packHello,
+  packDisconnect,
+  packPublish,
+  packPublishWithReply,
+  packPublishDelayed,
+  packPublishBatch
+};
+//# sourceMappingURL=chunk-GW36GP2C.mjs.map

package/dist/chunk-GW36GP2C.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/proto/frame.ts","../src/proto/publish.ts"],"sourcesContent":["// Core frame allocator — single source for header layout.\n\nimport {\n  HEADER_SIZE, HELLO_SIZE, MAGIC_V2, CURRENT_VERSION,\n  OFF_ACTION, OFF_FLAGS, OFF_ENTRY_FLAGS, OFF_MSG_LEN, OFF_SEQ,\n  Action, Role, Cap,\n} from './constants'\n\n/** Allocate HEADER_SIZE + bodyLen, write the 16-byte header, return buf. */\nexport function frame(\n  action: Action, seq: bigint, bodyLen: number,\n  flags = 0, entryFlags = 0,\n): Buffer {\n  const buf = Buffer.allocUnsafe(HEADER_SIZE + bodyLen)\n  buf.writeUInt16LE(action, OFF_ACTION)\n  buf[OFF_FLAGS]       = flags\n  buf[OFF_ENTRY_FLAGS] = entryFlags\n  buf.writeUInt32LE(bodyLen, OFF_MSG_LEN)\n  buf.writeBigUInt64LE(seq, OFF_SEQ)\n  return buf\n}\n\n/** Hello handshake — 8 bytes, no Header prefix. */\nexport function packHello(caps: number = Cap.Reply): Buffer {\n  const buf = Buffer.allocUnsafe(HELLO_SIZE)\n  buf.writeUInt32LE(MAGIC_V2, 0)\n  buf[4] = CURRENT_VERSION\n  buf[5] = Role.Client\n  buf.writeUInt16LE(caps, 6)\n  return buf\n}\n\nexport function packPing(seq: bigint): Buffer {\n  return frame(Action.Ping, seq, 0)\n}\n\nexport function packDisconnect(seq: bigint): Buffer {\n  return frame(Action.Disconnect, seq, 0)\n}\n","// Publish family — Publish (0x0101), PublishWithReply (0x0104), PublishBatch (0x0103).\n\nimport { HEADER_SIZE, Action } from './constants'\nimport { frame } from './frame'\n\n/**\n * One entry of a `publishBatch` call.\n *\n * `msgId` (optional) is an opaque byte string the broker uses for\n * per-stream deduplication when the target stream was created with\n * `idempotencyWindowMs > 0`. Leaving it empty/undefined disables\n * dedup for this entry (mixing dedup + non-dedup entries in a single\n * batch is allowed).\n */\nexport interface BatchPublishEntry {\n  subject: string\n  payload: Buffer\n  msgId?:  Buffer\n}\n\nconst EMPTY = Buffer.alloc(0)\n\n// Body: stream_id(4) + subject_len(2) + msg_id_len(2) = 8B + subject + msg_id + payload\nexport function packPublish(\n  seq: bigint, streamId: number,\n  subject: Buffer, payload: Buffer,\n  flags = 0, entryFlags = 0,\n  msgId: Buffer = EMPTY,\n): Buffer {\n  const buf = frame(\n    Action.Publish, seq,\n    8 + subject.length + msgId.length + payload.length,\n    flags, entryFlags,\n  )\n  buf.writeUInt32LE(streamId, HEADER_SIZE)\n  buf.writeUInt16LE(subject.length, HEADER_SIZE + 4)\n  buf.writeUInt16LE(msgId.length, HEADER_SIZE + 6)\n  let off = HEADER_SIZE + 8\n  subject.copy(buf, off); off += subject.length\n  msgId.copy(buf, off);   off += msgId.length\n  payload.copy(buf, off)\n  return buf\n}\n\n// Body: stream_id(4) + subject_len(2) + reply_len(2) + _pad(4) = 12B\nexport function packPublishWithReply(\n  seq: bigint, streamId: number,\n  subject: Buffer, replyTo: Buffer, payload: Buffer,\n  flags = 0, entryFlags = 0,\n): Buffer {\n  const tail = subject.length + replyTo.length + payload.length\n  const buf = frame(Action.PublishWithReply, seq, 12 + tail, flags, entryFlags)\n  buf.writeUInt32LE(streamId, HEADER_SIZE)\n  buf.writeUInt16LE(subject.length, HEADER_SIZE + 4)\n  buf.writeUInt16LE(replyTo.length, HEADER_SIZE + 6)\n  buf.writeUInt32LE(0, HEADER_SIZE + 8)\n  let off = HEADER_SIZE + 12\n  subject.copy(buf, off); off += subject.length\n  replyTo.copy(buf, off); off += replyTo.length\n  payload.copy(buf, off)\n  return buf\n}\n\n// Body: stream_id(4) + subject_len(2) + msg_id_len(2) + delay_ms(8) = 16B + subject + msg_id + payload\nexport function packPublishDelayed(\n  seq: bigint, streamId: number,\n  subject: Buffer, payload: Buffer,\n  delayMs: bigint,\n  flags = 0, entryFlags = 0,\n): Buffer {\n  const buf = frame(\n    Action.PublishDelayed, seq,\n    16 + subject.length + payload.length,\n    flags, entryFlags,\n  )\n  buf.writeUInt32LE(streamId, HEADER_SIZE)\n  buf.writeUInt16LE(subject.length, HEADER_SIZE + 4)\n  buf.writeUInt16LE(0, HEADER_SIZE + 6) // msg_id_len = 0\n  buf.writeBigUInt64LE(delayMs, HEADER_SIZE + 8)\n  let off = HEADER_SIZE + 16\n  subject.copy(buf, off); off += subject.length\n  payload.copy(buf, off)\n  return buf\n}\n\n// Body: stream_id(4) + count(4) = 8B\n// + entries[subject_len(2)+msg_id_len(2)+payload_len(4) + subject + msg_id + payload]\nexport function packPublishBatch(\n  seq: bigint, streamId: number,\n  entries: ReadonlyArray<BatchPublishEntry>,\n  flags = 0, entryFlags = 0,\n): Buffer {\n  let tail = 0\n  for (const e of entries) {\n    const midLen = e.msgId ? e.msgId.length : 0\n    tail += 8 + e.subject.length + midLen + e.payload.length\n  }\n  const buf = frame(Action.PublishBatch, seq, 8 + tail, flags, entryFlags)\n  buf.writeUInt32LE(streamId, HEADER_SIZE)\n  buf.writeUInt32LE(entries.length, HEADER_SIZE + 4)\n  let off = HEADER_SIZE + 8\n  for (const e of entries) {\n    const mid = e.msgId ?? EMPTY\n    buf.writeUInt16LE(e.subject.length, off)\n    buf.writeUInt16LE(mid.length,       off + 2)\n    buf.writeUInt32LE(e.payload.length, off + 4)\n    off += 8\n    buf.write(e.subject, off); off += e.subject.length\n    mid.copy(buf, off);        off += mid.length\n    e.payload.copy(buf, off);  off += e.payload.length\n  }\n  return buf\n}\n"],"mappings":"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","names":[]}

package/dist/constants-57DO6N3H.mjs

@@ -0,0 +1,33 @@
+import {
+  Action,
+  CURRENT_VERSION,
+  Cap,
+  EntryFlag,
+  Flag,
+  HEADER_SIZE,
+  HELLO_SIZE,
+  MAGIC_V2,
+  OFF_ACTION,
+  OFF_ENTRY_FLAGS,
+  OFF_FLAGS,
+  OFF_MSG_LEN,
+  OFF_SEQ,
+  Role
+} from "./chunk-C2QLJBAC.mjs";
+export {
+  Action,
+  CURRENT_VERSION,
+  Cap,
+  EntryFlag,
+  Flag,
+  HEADER_SIZE,
+  HELLO_SIZE,
+  MAGIC_V2,
+  OFF_ACTION,
+  OFF_ENTRY_FLAGS,
+  OFF_FLAGS,
+  OFF_MSG_LEN,
+  OFF_SEQ,
+  Role
+};
+//# sourceMappingURL=constants-57DO6N3H.mjs.map

package/dist/constants-57DO6N3H.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.mts

@@ -86,6 +86,8 @@ interface SubjectInflightLimit {
 }
 interface ConsumerConfig {
     name?: string;
+    /** Shared consumer group name for round-robin delivery. Defaults to `name`. */
+    group?: string;
     filter?: string;
     fanout?: boolean;
     /** Consumer-side ACK policy. None = fire-and-forget delivery, Explicit = consumer must ACK. */
@@ -220,6 +222,35 @@ declare class ClientMetrics {
     snapshot(): ClientMetricsSnapshot;
 }
 
+interface CreateCronBody {
+    readonly name: string;
+    readonly every: string;
+    readonly tz?: string | undefined;
+    readonly timeout_ms: number;
+    readonly overlap: boolean;
+}
+
+type CronHandler = (ctx: CronContext) => Promise<void>;
+/** Context passed to the cron handler on each fire. */
+interface CronContext {
+    /** Cron job name. */
+    readonly name: string;
+    /** UTC timestamp (ms since epoch) when the broker intended this fire. */
+    readonly fireTime: bigint;
+    /** Monotonic fire counter (1-based). */
+    readonly fireCount: bigint;
+}
+declare class CronState {
+    private readonly handlers;
+    register(name: string, config: CreateCronBody, handler: CronHandler): void;
+    remove(name: string): void;
+    getHandler(name: string): CronHandler | undefined;
+    allConfigs(): ReadonlyArray<{
+        name: string;
+        config: CreateCronBody;
+    }>;
+}
+
 type DeliveryHandler = (frame: Buffer) => void;
 declare class Connection {
     private readonly reconnectAddr?;
@@ -234,6 +265,7 @@ declare class Connection {
     private readonly log;
     private activeSubs;
     private metrics?;
+    private cronState?;
     private constructor();
     private attachSocket;
     static connect(addr: string, timeoutMs?: number, tlsCfg?: TlsConfig, reconnectCfg?: ReconnectConfig, logger?: Logger): Promise<Connection>;
@@ -244,13 +276,17 @@ declare class Connection {
      * entry and `reconnects` on successful reconnections. Unset = no-op.
      */
     setMetrics(m: ClientMetrics): void;
+    /** Attach cron state so the connection can dispatch CronFire frames. */
+    setCronState(s: CronState): void;
     private resolvePending;
     private rejectPending;
     private onFrame;
     private handleBatchDeliver;
+    private dispatchCronFire;
     sendSubscribeV2(consumerId: number, filter: Buffer, handler: DeliveryHandler, onRenew?: (newConsumerId: number) => void): Promise<number>;
     cancelSubscription(consumerId: number): void;
     private resubscribeAll;
+    private replayCrons;
     registerRoute(consumerId: number, handler: DeliveryHandler): void;
     unregisterRoute(consumerId: number): void;
     send(frame: Buffer): void;
@@ -431,6 +467,30 @@ declare class Consumer {
     subscribe<T extends Record<string, unknown>>(codec: Encoding<T>, cb: (msg: LazyMessage<T>) => void, opts?: SubscribeOptions): Promise<Subscription>;
 }
 
+declare class CronBuilder {
+    private readonly conn;
+    private readonly cronState;
+    private readonly cronName;
+    private expr;
+    private timezone;
+    private timeoutMs;
+    private allowOverlap;
+    constructor(conn: Connection, cronState: CronState, cronName: string);
+    every(expression: string): this;
+    tz(timezone: string): this;
+    timeout(ms: number): this;
+    overlap(allow: boolean): this;
+    run(handler: CronHandler): Promise<CronHandle>;
+}
+declare class CronHandle {
+    private readonly conn;
+    private readonly cronState;
+    private readonly cronName;
+    constructor(conn: Connection, cronState: CronState, cronName: string);
+    get name(): string;
+    stop(): Promise<void>;
+}
+
 type MsgCallback = (msg: Message) => void;
 declare class ArbitroClient {
     private conn;
@@ -439,6 +499,7 @@ declare class ArbitroClient {
     private readonly logger;
     private readonly sidCache;
     private readonly _metrics;
+    private readonly _cronState;
     constructor(config: ClientConfig);
     connect(): Promise<this>;
     /**
@@ -494,6 +555,13 @@ declare class ArbitroClient {
     publishBatch(streamName: string, messages: BatchPublishEntry[]): Promise<bigint>;
     /** Request-reply. */
     request(streamName: string, subject: string, data: Buffer, timeoutMs?: number): Promise<Buffer>;
+    /**
+     * Publish a message with a delivery delay. The broker parks the message
+     * in its delayed journal and delivers it to consumers after `delayMs`
+     * milliseconds. Returns a Promise that resolves once the broker confirms
+     * receipt.
+     */
+    publishDelayed(streamName: string, subject: string, data: Buffer, delayMs: number): Promise<void>;
     /** Subscribe with explicit consumer config. */
     subscribe(streamName: string, config: ConsumerConfig, callback?: MsgCallback, opts?: SubscribeOptions): Promise<Subscription>;
     /** Subscribe by consumer name only (consumer must already exist). */
@@ -533,6 +601,8 @@ declare class ArbitroClient {
     /** Pre-resolve stream_id from server (GetStream). Required before sync publish(). */
     resolveStream(name: string): Promise<void>;
     stream(name: string, config?: StreamConfig): Stream;
+    /** Start building a cron job. Call `.every()` then `.run()` to register. */
+    cron(name: string): CronBuilder;
     close(): Promise<void>;
 }
 
@@ -586,6 +656,64 @@ declare class Topic<T extends Record<string, unknown>> {
 
 declare function streamId(name: Buffer | string): number;
 
+declare class WorkflowHandle {
+    private readonly workflowName;
+    private readonly taskStreamName;
+    private readonly dlqStreamName;
+    private readonly sub;
+    private readonly triggerSub;
+    constructor(workflowName: string, taskStreamName: string, dlqStreamName: string, sub: unknown, triggerSub: unknown | undefined);
+    get name(): string;
+    get taskStream(): string;
+    get dlqStream(): string;
+    trigger(client: ArbitroClient, context: Buffer): Promise<number>;
+}
+
+interface StepContext {
+    readonly name: string;
+    readonly instanceId: number;
+    readonly stepIndex: number;
+    readonly attempt: number;
+    readonly context: Buffer;
+}
+interface StepResult {
+    readonly context: Buffer;
+}
+type StepHandler = (ctx: StepContext) => Promise<StepResult>;
+declare class WorkflowBuilder {
+    private readonly client;
+    private readonly workflowName;
+    private triggerSubject;
+    private triggerStreamName;
+    private readonly steps;
+    private ackWaitMs;
+    private maxInflightVal;
+    private maxRetriesVal;
+    private maxContextSizeVal;
+    constructor(client: ArbitroClient, workflowName: string);
+    trigger(subject: string): this;
+    triggerStream(streamName: string): this;
+    step(name: string, handler: StepHandler): this;
+    /** Compensation handler for the most recently added step. */
+    compensate(_stepName: string, handler: StepHandler): this;
+    ackWait(ms: number): this;
+    inflight(n: number): this;
+    maxRetries(n: number): this;
+    maxContextSize(bytes: number): this;
+    start(): Promise<WorkflowHandle>;
+    private subscribeWorker;
+    private subscribeTrigger;
+}
+
+/** Bit flag set on stepIndex to mark compensation tasks. */
+declare const COMPENSATION_BIT = 32768;
+interface DecodedTask {
+    readonly instanceId: number;
+    readonly stepIndex: number;
+    readonly attempt: number;
+    readonly context: Buffer;
+}
+
 /** Wraps a ZodObject schema as an Encoding<T>.
  *
  *  - encode: msgpack (no Zod overhead — bytes out)
@@ -599,4 +727,4 @@ declare function zodCodec<S extends ZodRawShape>(zodSchema: ZodObject<S>): Encod
     readonly fields: string[];
 };
 
-export { AckPolicy, ArbitroClient, ArbitroError, type BatchPublishEntry, type ClientConfig, type ClientMetricsSnapshot, Codec, Consumer, type ConsumerConfig, type ConsumerInfo, type DeleteStreamOpts, DeliverPolicy, type Encoding, ErrorCode, type ErrorCodeValue, type FieldType, type FieldTypeMap, type FlushConfig, type InferSchema, type JournalConfig, JournalType, JsonCodec, type LazyMessage, type LogFn, type Logger, Message, type PublishOpts, type ReconnectConfig, type Schema, Stream, type StreamConfig, type StreamInfo, StringCodec, type SubjectInflightLimit, type SubscribeOptions, Subscription, type TlsConfig, Topic, decodeJson, decodeString, encodeJson, encodeString, makeLazyMessage, schema, streamId, zodCodec };
+export { AckPolicy, ArbitroClient, ArbitroError, type BatchPublishEntry, COMPENSATION_BIT, type ClientConfig, type ClientMetricsSnapshot, Codec, Consumer, type ConsumerConfig, type ConsumerInfo, CronBuilder, type CronContext, CronHandle, type CronHandler, type DecodedTask, type DeleteStreamOpts, DeliverPolicy, type Encoding, ErrorCode, type ErrorCodeValue, type FieldType, type FieldTypeMap, type FlushConfig, type InferSchema, type JournalConfig, JournalType, JsonCodec, type LazyMessage, type LogFn, type Logger, Message, type PublishOpts, type ReconnectConfig, type Schema, type StepContext, type StepHandler, type StepResult, Stream, type StreamConfig, type StreamInfo, StringCodec, type SubjectInflightLimit, type SubscribeOptions, Subscription, type TlsConfig, Topic, WorkflowBuilder, WorkflowHandle, decodeJson, decodeString, encodeJson, encodeString, makeLazyMessage, schema, streamId, zodCodec };