@smthrs/triggers 0.0.0-stage → 1.0.0-rc.3

package/dist/cjs/Webhook.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Verified webhook ingestion through the authoritative Control boundary.
+ *
+ * @see packages/smithers/agent/triggers/docs/api.md
+ * @since 0.1.0
+ */
+import * as ControlChannels from "@smthrs/control/Channels";
+import type { ControlError } from "@smthrs/control/ControlError";
+import type { Receipt, RunSummary } from "@smthrs/control/ControlSchema";
+import type { CredentialRef } from "@smthrs/control/Credential";
+import * as Effect from "effect/Effect";
+import type * as Redacted from "effect/Redacted";
+import type * as Channel from "./Channel.ts";
+import { TriggerError } from "./TriggerError.ts";
+/**
+ * Compares a supplied byte string against the expected one without returning
+ * early on a mismatch.
+ *
+ * The loop runs exactly `expected.length` times, so its iteration count is
+ * fixed by the secret side of the comparison and never by the caller's. Reading
+ * the longer of the two instead let a caller lengthen its input until the work
+ * stopped growing, which reports the expected signature's length. The length
+ * difference is folded into the result, so inputs of unequal length always
+ * disagree.
+ *
+ * @category verification
+ * @since 0.1.0
+ */
+export declare const constantTimeEqual: (expected: Uint8Array, supplied: Uint8Array) => boolean;
+/**
+ * Configuration for a raw-byte signature verifier.
+ *
+ * `expected` receives a private copy of the request bytes and the redacted
+ * credential reference the channel was declared with, and answers with the
+ * signature bytes the request must carry in `header`. It returns an Effect so
+ * the secret is resolved through the host's resolver per request rather than
+ * captured in a closure at declaration time, and so a resolution or HMAC
+ * failure arrives as a typed `verification_failed` instead of a defect that
+ * kills the fiber.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface SignatureConfig {
+    readonly header: string;
+    readonly expected: (body: Uint8Array, credential: Redacted.Redacted<CredentialRef>) => Effect.Effect<Uint8Array, TriggerError>;
+}
+/**
+ * Builds a verifier that compares a signature header in constant time.
+ *
+ * An absent or empty header is refused before `expected` runs, and an
+ * `expected` that answers with zero bytes is refused after it. Neither is a
+ * comparison the constant-time equality can decide: it agrees on two empty
+ * byte strings, so a request carrying no signature at all would have
+ * authenticated against a secret that resolved to the empty string. A
+ * zero-length expected signature is a misconfigured credential, never a valid
+ * one, so the door stays closed instead of opening for everyone.
+ *
+ * Every refusal carries the same message, `webhook signature in <header> did
+ * not verify`, whatever the reason. A failure raised by `expected` is kept in
+ * `cause` only: its message names the credential reference or the resolver
+ * that could not produce a secret, which is a host detail, and the refusal
+ * that answers a bad signature answers a broken resolver the same way.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const makeSignatureVerifier: (config: SignatureConfig) => Channel.Verify;
+/**
+ * Webhook declaration configuration.
+ *
+ * `credential` is required. It used to default to a reference named after the
+ * channel, so a webhook declared without one verified against whatever
+ * credential happened to share its name instead of being refused, and two
+ * declarations differing only in credential verified identically.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Config<Payload, Outbound = never> extends Channel.Config<Payload, RunSummary, Outbound> {
+    readonly credential: Redacted.Redacted<CredentialRef>;
+}
+/**
+ * A webhook door that can only ingest through `Channels` and `Control`.
+ *
+ * @category services
+ * @since 0.1.0
+ */
+export interface Webhook {
+    readonly name: string;
+    readonly register: Effect.Effect<void, never, ControlChannels.Channels>;
+    readonly ingest: (raw: Channel.RawInbound) => Effect.Effect<Receipt, ControlError | TriggerError, ControlChannels.Channels>;
+}
+/**
+ * Builds a webhook door whose only dispatch path is the Control channel
+ * coordinator.
+ *
+ * Verification occurs inside `Channels.ingest` before the adapter's JSON or
+ * schema decoder and before any Control operation.
+ *
+ * `ingest` does not register: a channel is registered once, deliberately,
+ * through {@link Webhook.register}, so traffic to an unregistered channel is
+ * reported as unavailable rather than silently self-registering the door it
+ * arrived at.
+ *
+ * `ingest` also copies `body`, `headers`, and `idempotencyKey` before anything
+ * reads them. Verification, delivery fingerprinting, and decoding then all see
+ * one private snapshot, so a verifier that edits the bytes it was handed, or a
+ * caller that mutates its own object between building this Effect and running
+ * it, cannot authenticate one payload and have another decoded. A
+ * `SharedArrayBuffer`-backed view is copied out of shared memory by the same
+ * step.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: <Payload, Outbound = never>(config: Config<Payload, Outbound>) => Webhook;
+//# sourceMappingURL=Webhook.d.ts.map

package/dist/cjs/Webhook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Webhook.d.ts","sourceRoot":"","sources":["../../src/Webhook.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,eAAe,MAAM,0BAA0B,CAAA;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAEhE,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAA;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAE/D,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAEhD,OAAO,KAAK,KAAK,OAAO,MAAM,cAAc,CAAA;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAEhD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,GAAI,UAAU,UAAU,EAAE,UAAU,UAAU,KAAG,OAM9E,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,QAAQ,EAAE,CACjB,IAAI,EAAE,UAAU,EAChB,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,aAAa,CAAC,KACzC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;CAC7C;AAcD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,qBAAqB,GAAI,QAAQ,eAAe,KAAG,OAAO,CAAC,MA2BvE,CAAA;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,MAAM,CAAC,OAAO,EAAE,QAAQ,GAAG,KAAK,CAAE,SAAQ,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,CAAC;IACtG,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAA;CACtD;AAED;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAA;IACvE,QAAQ,CAAC,MAAM,EAAE,CACf,GAAG,EAAE,OAAO,CAAC,UAAU,KACpB,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,YAAY,GAAG,YAAY,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAA;CACnF;AA6DD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,IAAI,GAAI,OAAO,EAAE,QAAQ,GAAG,KAAK,EAC5C,QAAQ,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,KAChC,OAgCF,CAAA"}

package/dist/cjs/Webhook.js

@@ -0,0 +1,153 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Webhook_exports = {};
+__export(Webhook_exports, {
+  constantTimeEqual: () => constantTimeEqual,
+  make: () => make,
+  makeSignatureVerifier: () => makeSignatureVerifier
+});
+module.exports = __toCommonJS(Webhook_exports);
+var ControlChannels = __toESM(require("@smthrs/control/Channels"), 1);
+var import_ControlError = require("@smthrs/control/ControlError");
+var ControlWebhook = __toESM(require("@smthrs/control/WebhookChannel"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var import_TriggerError = require("./TriggerError.js");
+const constantTimeEqual = (expected, supplied) => {
+  let difference = expected.length ^ supplied.length;
+  for (const [index, byte] of expected.entries()) {
+    difference |= byte ^ (supplied[index] ?? 0);
+  }
+  return difference === 0;
+};
+const ownedCopy = (body) => Uint8Array.from(body);
+const makeSignatureVerifier = (config) => (raw, credential) => {
+  const refuse = (cause) => Effect.fail(
+    new import_TriggerError.TriggerError({
+      code: "verification_failed",
+      message: `webhook signature in ${config.header} did not verify`,
+      ...cause === void 0 ? {} : { cause }
+    })
+  );
+  return Effect.suspend(() => {
+    const supplied = raw.headers[config.header.toLowerCase()] ?? raw.headers[config.header];
+    if (supplied === void 0 || supplied.length === 0) {
+      return refuse();
+    }
+    const actual = new TextEncoder().encode(supplied);
+    return config.expected(ownedCopy(raw.body), credential).pipe(
+      Effect.matchEffect({
+        onFailure: (error) => refuse(error),
+        onSuccess: (expected) => expected.length > 0 && constantTimeEqual(expected, actual) ? Effect.void : refuse()
+      })
+    );
+  });
+};
+const invalidInput = (issue) => new import_ControlError.InvalidInput({ issue });
+const toControlChannel = (config) => {
+  const channel = ControlWebhook.make({
+    name: config.name,
+    schema: config.schema,
+    credential: config.credential,
+    // The message is fixed here rather than forwarded from the verifier: a
+    // custom `verify` may say why it refused, and that reason travels toward
+    // the unauthenticated sender on the same error that answers a bad
+    // signature. `Unauthorized` carries no cause, so nothing else survives
+    // the crossing.
+    verify: (raw, credential) => config.verify(raw, credential).pipe(
+      Effect.mapError(() => new import_ControlError.Unauthorized({ message: `webhook ${config.name} did not verify the request` }))
+    ),
+    map: (payload) => {
+      const inbound = config.inbound(payload);
+      if ("start" in inbound) {
+        return Effect.succeed({
+          _tag: "Start",
+          flowId: inbound.start.flowId,
+          input: inbound.start.input
+        });
+      }
+      return Schema.decodeUnknownEffect(Schema.Json)(inbound.signal.value).pipe(
+        Effect.map(
+          (value) => ({
+            _tag: "Signal",
+            runId: inbound.signal.runId,
+            signal: {
+              name: inbound.signal.stepId,
+              payload: value
+            }
+          })
+        ),
+        Effect.mapError((error) => invalidInput(String(error)))
+      );
+    },
+    project: (run) => {
+      if (config.outbound === void 0) {
+        return {
+          cursor: String(run.updatedAt),
+          operation: "noop",
+          message: null
+        };
+      }
+      return {
+        cursor: String(run.updatedAt),
+        operation: "post",
+        message: config.outbound(run)
+      };
+    }
+  });
+  return channel;
+};
+const make = (config) => {
+  const channel = toControlChannel(config);
+  const register = Effect.flatMap(ControlChannels.Channels, (channels) => channels.register(channel));
+  return {
+    name: config.name,
+    register,
+    ingest: (raw) => {
+      const snapshot = {
+        body: ownedCopy(raw.body),
+        headers: { ...raw.headers },
+        idempotencyKey: raw.idempotencyKey
+      };
+      return Effect.gen(function* () {
+        const channels = yield* ControlChannels.Channels;
+        return yield* channels.ingest({ channel: config.name, raw: snapshot });
+      }).pipe(
+        Effect.mapError(
+          (error) => error instanceof import_ControlError.Unauthorized ? new import_TriggerError.TriggerError({
+            code: "verification_failed",
+            message: `webhook ${config.name} did not verify the request`,
+            cause: error
+          }) : error
+        )
+      );
+    }
+  };
+};
+//# sourceMappingURL=Webhook.js.map

package/dist/cjs/Webhook.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Webhook.ts"],
+  "sourcesContent": ["/**\n * Verified webhook ingestion through the authoritative Control boundary.\n *\n * @see packages/smithers/agent/triggers/docs/api.md\n * @since 0.1.0\n */\n\nimport * as ControlChannels from \"@smthrs/control/Channels\"\nimport type { ControlError } from \"@smthrs/control/ControlError\"\nimport { InvalidInput, Unauthorized } from \"@smthrs/control/ControlError\"\nimport type { Receipt, RunSummary } from \"@smthrs/control/ControlSchema\"\nimport type { CredentialRef } from \"@smthrs/control/Credential\"\nimport * as ControlWebhook from \"@smthrs/control/WebhookChannel\"\nimport * as Effect from \"effect/Effect\"\nimport type * as Redacted from \"effect/Redacted\"\nimport * as Schema from \"effect/Schema\"\nimport type * as Channel from \"./Channel.ts\"\nimport { TriggerError } from \"./TriggerError.ts\"\n\n/**\n * Compares a supplied byte string against the expected one without returning\n * early on a mismatch.\n *\n * The loop runs exactly `expected.length` times, so its iteration count is\n * fixed by the secret side of the comparison and never by the caller's. Reading\n * the longer of the two instead let a caller lengthen its input until the work\n * stopped growing, which reports the expected signature's length. The length\n * difference is folded into the result, so inputs of unequal length always\n * disagree.\n *\n * @category verification\n * @since 0.1.0\n */\nexport const constantTimeEqual = (expected: Uint8Array, supplied: Uint8Array): boolean => {\n  let difference = expected.length ^ supplied.length\n  for (const [index, byte] of expected.entries()) {\n    difference |= byte ^ (supplied[index] ?? 0)\n  }\n  return difference === 0\n}\n\n/**\n * Configuration for a raw-byte signature verifier.\n *\n * `expected` receives a private copy of the request bytes and the redacted\n * credential reference the channel was declared with, and answers with the\n * signature bytes the request must carry in `header`. It returns an Effect so\n * the secret is resolved through the host's resolver per request rather than\n * captured in a closure at declaration time, and so a resolution or HMAC\n * failure arrives as a typed `verification_failed` instead of a defect that\n * kills the fiber.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface SignatureConfig {\n  readonly header: string\n  readonly expected: (\n    body: Uint8Array,\n    credential: Redacted.Redacted<CredentialRef>\n  ) => Effect.Effect<Uint8Array, TriggerError>\n}\n\n/**\n * Copies request bytes into memory nobody else holds.\n *\n * `body.slice()` is not enough: a Node `Buffer` is a `Uint8Array` whose\n * `slice` is an alias of `subarray` and answers with a view over the same\n * memory, so a caller that reused its `Buffer` after handing it over changed\n * what got verified, and a verifier that edited the bytes it was handed edited\n * the caller's. `Uint8Array.from` always allocates, and it copies only the\n * viewed range of an offset view and only a snapshot of a `SharedArrayBuffer`.\n */\nconst ownedCopy = (body: Uint8Array): Uint8Array => Uint8Array.from(body)\n\n/**\n * Builds a verifier that compares a signature header in constant time.\n *\n * An absent or empty header is refused before `expected` runs, and an\n * `expected` that answers with zero bytes is refused after it. Neither is a\n * comparison the constant-time equality can decide: it agrees on two empty\n * byte strings, so a request carrying no signature at all would have\n * authenticated against a secret that resolved to the empty string. A\n * zero-length expected signature is a misconfigured credential, never a valid\n * one, so the door stays closed instead of opening for everyone.\n *\n * Every refusal carries the same message, `webhook signature in <header> did\n * not verify`, whatever the reason. A failure raised by `expected` is kept in\n * `cause` only: its message names the credential reference or the resolver\n * that could not produce a secret, which is a host detail, and the refusal\n * that answers a bad signature answers a broken resolver the same way.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const makeSignatureVerifier = (config: SignatureConfig): Channel.Verify => (raw, credential) => {\n  const refuse = (cause?: TriggerError) =>\n    Effect.fail(\n      new TriggerError({\n        code: \"verification_failed\",\n        message: `webhook signature in ${config.header} did not verify`,\n        ...(cause === undefined ? {} : { cause })\n      })\n    )\n  return Effect.suspend(() => {\n    const supplied = raw.headers[config.header.toLowerCase()] ?? raw.headers[config.header]\n    if (supplied === undefined || supplied.length === 0) {\n      return refuse()\n    }\n    const actual = new TextEncoder().encode(supplied)\n    // The verifier gets its own copy: nothing it does to these bytes can reach\n    // the buffer that is about to be fingerprinted and decoded.\n    return config.expected(ownedCopy(raw.body), credential).pipe(\n      Effect.matchEffect({\n        onFailure: (error) => refuse(error),\n        onSuccess: (expected) =>\n          expected.length > 0 && constantTimeEqual(expected, actual)\n            ? Effect.void\n            : refuse()\n      })\n    )\n  })\n}\n\n/**\n * Webhook declaration configuration.\n *\n * `credential` is required. It used to default to a reference named after the\n * channel, so a webhook declared without one verified against whatever\n * credential happened to share its name instead of being refused, and two\n * declarations differing only in credential verified identically.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Config<Payload, Outbound = never> extends Channel.Config<Payload, RunSummary, Outbound> {\n  readonly credential: Redacted.Redacted<CredentialRef>\n}\n\n/**\n * A webhook door that can only ingest through `Channels` and `Control`.\n *\n * @category services\n * @since 0.1.0\n */\nexport interface Webhook {\n  readonly name: string\n  readonly register: Effect.Effect<void, never, ControlChannels.Channels>\n  readonly ingest: (\n    raw: Channel.RawInbound\n  ) => Effect.Effect<Receipt, ControlError | TriggerError, ControlChannels.Channels>\n}\n\nconst invalidInput = (issue: string): InvalidInput => new InvalidInput({ issue })\n\nconst toControlChannel = <Payload, Outbound>(\n  config: Config<Payload, Outbound>\n): ControlChannels.Channel<Payload> => {\n  const channel = ControlWebhook.make({\n    name: config.name,\n    schema: config.schema,\n    credential: config.credential,\n    // The message is fixed here rather than forwarded from the verifier: a\n    // custom `verify` may say why it refused, and that reason travels toward\n    // the unauthenticated sender on the same error that answers a bad\n    // signature. `Unauthorized` carries no cause, so nothing else survives\n    // the crossing.\n    verify: (raw, credential) =>\n      config.verify(raw, credential).pipe(\n        Effect.mapError(() => new Unauthorized({ message: `webhook ${config.name} did not verify the request` }))\n      ),\n    map: (payload) => {\n      const inbound = config.inbound(payload)\n      if (\"start\" in inbound) {\n        return Effect.succeed({\n          _tag: \"Start\" as const,\n          flowId: inbound.start.flowId,\n          input: inbound.start.input\n        })\n      }\n      return Schema.decodeUnknownEffect(Schema.Json)(inbound.signal.value).pipe(\n        Effect.map(\n          (value) => ({\n            _tag: \"Signal\" as const,\n            runId: inbound.signal.runId,\n            signal: {\n              name: inbound.signal.stepId,\n              payload: value\n            }\n          })\n        ),\n        Effect.mapError((error) => invalidInput(String(error)))\n      )\n    },\n    project: (run) => {\n      if (config.outbound === undefined) {\n        return {\n          cursor: String(run.updatedAt),\n          operation: \"noop\" as const,\n          message: null\n        }\n      }\n      return {\n        cursor: String(run.updatedAt),\n        operation: \"post\" as const,\n        message: config.outbound(run)\n      }\n    }\n  })\n  return channel\n}\n\n/**\n * Builds a webhook door whose only dispatch path is the Control channel\n * coordinator.\n *\n * Verification occurs inside `Channels.ingest` before the adapter's JSON or\n * schema decoder and before any Control operation.\n *\n * `ingest` does not register: a channel is registered once, deliberately,\n * through {@link Webhook.register}, so traffic to an unregistered channel is\n * reported as unavailable rather than silently self-registering the door it\n * arrived at.\n *\n * `ingest` also copies `body`, `headers`, and `idempotencyKey` before anything\n * reads them. Verification, delivery fingerprinting, and decoding then all see\n * one private snapshot, so a verifier that edits the bytes it was handed, or a\n * caller that mutates its own object between building this Effect and running\n * it, cannot authenticate one payload and have another decoded. A\n * `SharedArrayBuffer`-backed view is copied out of shared memory by the same\n * step.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make = <Payload, Outbound = never>(\n  config: Config<Payload, Outbound>\n): Webhook => {\n  const channel = toControlChannel(config)\n  const register = Effect.flatMap(ControlChannels.Channels, (channels) => channels.register(channel))\n  return {\n    name: config.name,\n    register,\n    ingest: (raw) => {\n      // Copied here rather than inside the Effect: the copy has to happen when\n      // the caller hands the request over, not when the returned Effect\n      // eventually runs, or a caller that reuses its own buffer in between\n      // changes what gets authenticated.\n      const snapshot: Channel.RawInbound = {\n        body: ownedCopy(raw.body),\n        headers: { ...raw.headers },\n        idempotencyKey: raw.idempotencyKey\n      }\n      return Effect.gen(function*() {\n        const channels = yield* ControlChannels.Channels\n        return yield* channels.ingest({ channel: config.name, raw: snapshot })\n      }).pipe(\n        Effect.mapError((error) =>\n          error instanceof Unauthorized\n            ? new TriggerError({\n              code: \"verification_failed\",\n              message: `webhook ${config.name} did not verify the request`,\n              cause: error\n            })\n            : error\n        )\n      )\n    }\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,sBAAiC;AAEjC,0BAA2C;AAG3C,qBAAgC;AAChC,aAAwB;AAExB,aAAwB;AAExB,0BAA6B;AAgBtB,MAAM,oBAAoB,CAAC,UAAsB,aAAkC;AACxF,MAAI,aAAa,SAAS,SAAS,SAAS;AAC5C,aAAW,CAAC,OAAO,IAAI,KAAK,SAAS,QAAQ,GAAG;AAC9C,kBAAc,QAAQ,SAAS,KAAK,KAAK;AAAA,EAC3C;AACA,SAAO,eAAe;AACxB;AAkCA,MAAM,YAAY,CAAC,SAAiC,WAAW,KAAK,IAAI;AAsBjE,MAAM,wBAAwB,CAAC,WAA4C,CAAC,KAAK,eAAe;AACrG,QAAM,SAAS,CAAC,UACd,OAAO;AAAA,IACL,IAAI,iCAAa;AAAA,MACf,MAAM;AAAA,MACN,SAAS,wBAAwB,OAAO,MAAM;AAAA,MAC9C,GAAI,UAAU,SAAY,CAAC,IAAI,EAAE,MAAM;AAAA,IACzC,CAAC;AAAA,EACH;AACF,SAAO,OAAO,QAAQ,MAAM;AAC1B,UAAM,WAAW,IAAI,QAAQ,OAAO,OAAO,YAAY,CAAC,KAAK,IAAI,QAAQ,OAAO,MAAM;AACtF,QAAI,aAAa,UAAa,SAAS,WAAW,GAAG;AACnD,aAAO,OAAO;AAAA,IAChB;AACA,UAAM,SAAS,IAAI,YAAY,EAAE,OAAO,QAAQ;AAGhD,WAAO,OAAO,SAAS,UAAU,IAAI,IAAI,GAAG,UAAU,EAAE;AAAA,MACtD,OAAO,YAAY;AAAA,QACjB,WAAW,CAAC,UAAU,OAAO,KAAK;AAAA,QAClC,WAAW,CAAC,aACV,SAAS,SAAS,KAAK,kBAAkB,UAAU,MAAM,IACrD,OAAO,OACP,OAAO;AAAA,MACf,CAAC;AAAA,IACH;AAAA,EACF,CAAC;AACH;AA+BA,MAAM,eAAe,CAAC,UAAgC,IAAI,iCAAa,EAAE,MAAM,CAAC;AAEhF,MAAM,mBAAmB,CACvB,WACqC;AACrC,QAAM,UAAU,eAAe,KAAK;AAAA,IAClC,MAAM,OAAO;AAAA,IACb,QAAQ,OAAO;AAAA,IACf,YAAY,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMnB,QAAQ,CAAC,KAAK,eACZ,OAAO,OAAO,KAAK,UAAU,EAAE;AAAA,MAC7B,OAAO,SAAS,MAAM,IAAI,iCAAa,EAAE,SAAS,WAAW,OAAO,IAAI,8BAA8B,CAAC,CAAC;AAAA,IAC1G;AAAA,IACF,KAAK,CAAC,YAAY;AAChB,YAAM,UAAU,OAAO,QAAQ,OAAO;AACtC,UAAI,WAAW,SAAS;AACtB,eAAO,OAAO,QAAQ;AAAA,UACpB,MAAM;AAAA,UACN,QAAQ,QAAQ,MAAM;AAAA,UACtB,OAAO,QAAQ,MAAM;AAAA,QACvB,CAAC;AAAA,MACH;AACA,aAAO,OAAO,oBAAoB,OAAO,IAAI,EAAE,QAAQ,OAAO,KAAK,EAAE;AAAA,QACnE,OAAO;AAAA,UACL,CAAC,WAAW;AAAA,YACV,MAAM;AAAA,YACN,OAAO,QAAQ,OAAO;AAAA,YACtB,QAAQ;AAAA,cACN,MAAM,QAAQ,OAAO;AAAA,cACrB,SAAS;AAAA,YACX;AAAA,UACF;AAAA,QACF;AAAA,QACA,OAAO,SAAS,CAAC,UAAU,aAAa,OAAO,KAAK,CAAC,CAAC;AAAA,MACxD;AAAA,IACF;AAAA,IACA,SAAS,CAAC,QAAQ;AAChB,UAAI,OAAO,aAAa,QAAW;AACjC,eAAO;AAAA,UACL,QAAQ,OAAO,IAAI,SAAS;AAAA,UAC5B,WAAW;AAAA,UACX,SAAS;AAAA,QACX;AAAA,MACF;AACA,aAAO;AAAA,QACL,QAAQ,OAAO,IAAI,SAAS;AAAA,QAC5B,WAAW;AAAA,QACX,SAAS,OAAO,SAAS,GAAG;AAAA,MAC9B;AAAA,IACF;AAAA,EACF,CAAC;AACD,SAAO;AACT;AAyBO,MAAM,OAAO,CAClB,WACY;AACZ,QAAM,UAAU,iBAAiB,MAAM;AACvC,QAAM,WAAW,OAAO,QAAQ,gBAAgB,UAAU,CAAC,aAAa,SAAS,SAAS,OAAO,CAAC;AAClG,SAAO;AAAA,IACL,MAAM,OAAO;AAAA,IACb;AAAA,IACA,QAAQ,CAAC,QAAQ;AAKf,YAAM,WAA+B;AAAA,QACnC,MAAM,UAAU,IAAI,IAAI;AAAA,QACxB,SAAS,EAAE,GAAG,IAAI,QAAQ;AAAA,QAC1B,gBAAgB,IAAI;AAAA,MACtB;AACA,aAAO,OAAO,IAAI,aAAY;AAC5B,cAAM,WAAW,OAAO,gBAAgB;AACxC,eAAO,OAAO,SAAS,OAAO,EAAE,SAAS,OAAO,MAAM,KAAK,SAAS,CAAC;AAAA,MACvE,CAAC,EAAE;AAAA,QACD,OAAO;AAAA,UAAS,CAAC,UACf,iBAAiB,mCACb,IAAI,iCAAa;AAAA,YACjB,MAAM;AAAA,YACN,SAAS,WAAW,OAAO,IAAI;AAAA,YAC/B,OAAO;AAAA,UACT,CAAC,IACC;AAAA,QACN;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `/triggers` — durable schedules and verified inbound channels.
+ *
+ * @since 0.1.0
+ */
+/** @category errors @since 0.1.0 */
+export * as TriggerError from "./TriggerError.ts";
+/** @category schedules @since 0.1.0 */
+export * as Cron from "./Cron.ts";
+/** @category declarations @since 0.1.0 */
+export * as Trigger from "./Trigger.ts";
+/** @category declarations @since 0.1.0 */
+export * as Schedule from "./Schedule.ts";
+/** @category policies @since 0.1.0 */
+export * as Overlap from "./Overlap.ts";
+/** @category policies @since 0.1.0 */
+export * as CatchUp from "./CatchUp.ts";
+/** @category services @since 0.1.0 */
+export * as TriggerStore from "./TriggerStore.ts";
+/** @category services @since 0.1.0 */
+export * as SqlTriggerStore from "./SqlTriggerStore.ts";
+/** @category scheduling @since 0.1.0 */
+export * as Scheduler from "./Scheduler.ts";
+/** @category services @since 1.0.0-rc.0 */
+export * as DispatchReader from "./DispatchReader.ts";
+/** @category channels @since 0.1.0 */
+export * as Channel from "./Channel.ts";
+/** @category webhooks @since 0.1.0 */
+export * as Webhook from "./Webhook.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,oCAAoC;AACpC,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AACjD,uCAAuC;AACvC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,0CAA0C;AAC1C,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,0CAA0C;AAC1C,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,sCAAsC;AACtC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,sCAAsC;AACtC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,sCAAsC;AACtC,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AACjD,sCAAsC;AACtC,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AACvD,wCAAwC;AACxC,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C,2CAA2C;AAC3C,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD,sCAAsC;AACtC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,sCAAsC;AACtC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA"}

package/dist/cjs/index.js

@@ -0,0 +1,57 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  CatchUp: () => CatchUp,
+  Channel: () => Channel,
+  Cron: () => Cron,
+  DispatchReader: () => DispatchReader,
+  Overlap: () => Overlap,
+  Schedule: () => Schedule,
+  Scheduler: () => Scheduler,
+  SqlTriggerStore: () => SqlTriggerStore,
+  Trigger: () => Trigger,
+  TriggerError: () => TriggerError,
+  TriggerStore: () => TriggerStore,
+  Webhook: () => Webhook
+});
+module.exports = __toCommonJS(index_exports);
+var TriggerError = __toESM(require("./TriggerError.js"), 1);
+var Cron = __toESM(require("./Cron.js"), 1);
+var Trigger = __toESM(require("./Trigger.js"), 1);
+var Schedule = __toESM(require("./Schedule.js"), 1);
+var Overlap = __toESM(require("./Overlap.js"), 1);
+var CatchUp = __toESM(require("./CatchUp.js"), 1);
+var TriggerStore = __toESM(require("./TriggerStore.js"), 1);
+var SqlTriggerStore = __toESM(require("./SqlTriggerStore.js"), 1);
+var Scheduler = __toESM(require("./Scheduler.js"), 1);
+var DispatchReader = __toESM(require("./DispatchReader.js"), 1);
+var Channel = __toESM(require("./Channel.js"), 1);
+var Webhook = __toESM(require("./Webhook.js"), 1);
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": ["/**\n * `/triggers` \u2014 durable schedules and verified inbound channels.\n *\n * @since 0.1.0\n */\n\n/** @category errors @since 0.1.0 */\nexport * as TriggerError from \"./TriggerError.ts\"\n/** @category schedules @since 0.1.0 */\nexport * as Cron from \"./Cron.ts\"\n/** @category declarations @since 0.1.0 */\nexport * as Trigger from \"./Trigger.ts\"\n/** @category declarations @since 0.1.0 */\nexport * as Schedule from \"./Schedule.ts\"\n/** @category policies @since 0.1.0 */\nexport * as Overlap from \"./Overlap.ts\"\n/** @category policies @since 0.1.0 */\nexport * as CatchUp from \"./CatchUp.ts\"\n/** @category services @since 0.1.0 */\nexport * as TriggerStore from \"./TriggerStore.ts\"\n/** @category services @since 0.1.0 */\nexport * as SqlTriggerStore from \"./SqlTriggerStore.ts\"\n/** @category scheduling @since 0.1.0 */\nexport * as Scheduler from \"./Scheduler.ts\"\n/** @category services @since 1.0.0-rc.0 */\nexport * as DispatchReader from \"./DispatchReader.ts\"\n/** @category channels @since 0.1.0 */\nexport * as Channel from \"./Channel.ts\"\n/** @category webhooks @since 0.1.0 */\nexport * as Webhook from \"./Webhook.ts\"\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,mBAA8B;AAE9B,WAAsB;AAEtB,cAAyB;AAEzB,eAA0B;AAE1B,cAAyB;AAEzB,cAAyB;AAEzB,mBAA8B;AAE9B,sBAAiC;AAEjC,gBAA2B;AAE3B,qBAAgC;AAEhC,cAAyB;AAEzB,cAAyB;",
+  "names": []
+}

package/dist/cjs/internal/ActiveRuns.d.ts

@@ -0,0 +1,51 @@
+/**
+ * What one scheduler process knows about the run each trigger owns.
+ *
+ * @since 1.0.0-rc.0
+ */
+import * as Effect from "effect/Effect";
+import type * as Fiber from "effect/Fiber";
+/**
+ * What this process knows about the run one trigger currently owns: which
+ * occurrence claimed it, the reservation or run id the store holds for it, and
+ * the monitor fiber when this process is the one watching it.
+ *
+ * `runId` is always known. A claim that hands out work names the reservation it
+ * wrote, and a recovered entry is read back from the store, so an entry with
+ * nothing to release cannot be constructed.
+ *
+ * @private
+ * @since 1.0.0-rc.0
+ */
+export interface Active {
+    readonly occurrence: number;
+    readonly runId: string;
+    readonly fiber?: Fiber.Fiber<void> | undefined;
+}
+/**
+ * The entries of one scheduler, keyed by trigger id.
+ *
+ * `take` is the only unfenced write: an occurrence that claimed the trigger,
+ * or a run recovered from the store, replaces whatever entry was there. Every
+ * later write is fenced on the occurrence that took the entry, so one guard
+ * states the rule once: a launch that has been superseded, or whose run
+ * already settled, no longer owns the entry and must not write to it. Spelling
+ * the fence out at each site is how the three copies of it drifted apart.
+ *
+ * @private
+ * @since 1.0.0-rc.0
+ */
+export interface ActiveRuns {
+    readonly get: (triggerId: string) => Effect.Effect<Active | undefined>;
+    readonly take: (triggerId: string, entry: Active) => Effect.Effect<void>;
+    readonly update: (triggerId: string, occurrence: number, change: (entry: Active) => Active) => Effect.Effect<void>;
+    readonly remove: (triggerId: string, occurrence: number) => Effect.Effect<void>;
+}
+/**
+ * Allocates an empty set of entries.
+ *
+ * @private
+ * @since 1.0.0-rc.0
+ */
+export declare const make: Effect.Effect<ActiveRuns>;
+//# sourceMappingURL=ActiveRuns.d.ts.map

package/dist/cjs/internal/ActiveRuns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActiveRuns.d.ts","sourceRoot":"","sources":["../../../src/internal/ActiveRuns.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAG1C;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,SAAS,CAAA;CAC/C;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,GAAG,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;IACtE,QAAQ,CAAC,IAAI,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACxE,QAAQ,CAAC,MAAM,EAAE,CACf,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,KAC9B,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;CAChF;AAED;;;;;GAKG;AACH,eAAO,MAAM,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,CAwB1C,CAAA"}

package/dist/cjs/internal/ActiveRuns.js

@@ -0,0 +1,56 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ActiveRuns_exports = {};
+__export(ActiveRuns_exports, {
+  make: () => make
+});
+module.exports = __toCommonJS(ActiveRuns_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Ref = __toESM(require("effect/Ref"), 1);
+const make = Effect.map(
+  Ref.make(/* @__PURE__ */ new Map()),
+  (entries) => {
+    const fenced = (triggerId, occurrence, change) => Ref.update(entries, (current) => {
+      const entry = current.get(triggerId);
+      if (entry?.occurrence !== occurrence) return current;
+      const next = new Map(current);
+      const updated = change(entry);
+      if (updated === void 0) next.delete(triggerId);
+      else next.set(triggerId, updated);
+      return next;
+    });
+    return {
+      get: (triggerId) => Effect.map(Ref.get(entries), (current) => current.get(triggerId)),
+      take: (triggerId, entry) => Ref.update(entries, (current) => new Map(current).set(triggerId, entry)),
+      update: fenced,
+      remove: (triggerId, occurrence) => fenced(triggerId, occurrence, () => void 0)
+    };
+  }
+);
+//# sourceMappingURL=ActiveRuns.js.map

package/dist/cjs/internal/ActiveRuns.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/ActiveRuns.ts"],
+  "sourcesContent": ["/**\n * What one scheduler process knows about the run each trigger owns.\n *\n * @since 1.0.0-rc.0\n */\n\nimport * as Effect from \"effect/Effect\"\nimport type * as Fiber from \"effect/Fiber\"\nimport * as Ref from \"effect/Ref\"\n\n/**\n * What this process knows about the run one trigger currently owns: which\n * occurrence claimed it, the reservation or run id the store holds for it, and\n * the monitor fiber when this process is the one watching it.\n *\n * `runId` is always known. A claim that hands out work names the reservation it\n * wrote, and a recovered entry is read back from the store, so an entry with\n * nothing to release cannot be constructed.\n *\n * @private\n * @since 1.0.0-rc.0\n */\nexport interface Active {\n  readonly occurrence: number\n  readonly runId: string\n  readonly fiber?: Fiber.Fiber<void> | undefined\n}\n\n/**\n * The entries of one scheduler, keyed by trigger id.\n *\n * `take` is the only unfenced write: an occurrence that claimed the trigger,\n * or a run recovered from the store, replaces whatever entry was there. Every\n * later write is fenced on the occurrence that took the entry, so one guard\n * states the rule once: a launch that has been superseded, or whose run\n * already settled, no longer owns the entry and must not write to it. Spelling\n * the fence out at each site is how the three copies of it drifted apart.\n *\n * @private\n * @since 1.0.0-rc.0\n */\nexport interface ActiveRuns {\n  readonly get: (triggerId: string) => Effect.Effect<Active | undefined>\n  readonly take: (triggerId: string, entry: Active) => Effect.Effect<void>\n  readonly update: (\n    triggerId: string,\n    occurrence: number,\n    change: (entry: Active) => Active\n  ) => Effect.Effect<void>\n  readonly remove: (triggerId: string, occurrence: number) => Effect.Effect<void>\n}\n\n/**\n * Allocates an empty set of entries.\n *\n * @private\n * @since 1.0.0-rc.0\n */\nexport const make: Effect.Effect<ActiveRuns> = Effect.map(\n  Ref.make<ReadonlyMap<string, Active>>(new Map()),\n  (entries) => {\n    const fenced = (\n      triggerId: string,\n      occurrence: number,\n      change: (entry: Active) => Active | undefined\n    ): Effect.Effect<void> =>\n      Ref.update(entries, (current) => {\n        const entry = current.get(triggerId)\n        if (entry?.occurrence !== occurrence) return current\n        const next = new Map(current)\n        const updated = change(entry)\n        if (updated === undefined) next.delete(triggerId)\n        else next.set(triggerId, updated)\n        return next\n      })\n    return {\n      get: (triggerId) => Effect.map(Ref.get(entries), (current) => current.get(triggerId)),\n      take: (triggerId, entry) => Ref.update(entries, (current) => new Map(current).set(triggerId, entry)),\n      update: fenced,\n      remove: (triggerId, occurrence) => fenced(triggerId, occurrence, () => undefined)\n    }\n  }\n)\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,aAAwB;AAExB,UAAqB;AAkDd,MAAM,OAAkC,OAAO;AAAA,EACpD,IAAI,KAAkC,oBAAI,IAAI,CAAC;AAAA,EAC/C,CAAC,YAAY;AACX,UAAM,SAAS,CACb,WACA,YACA,WAEA,IAAI,OAAO,SAAS,CAAC,YAAY;AAC/B,YAAM,QAAQ,QAAQ,IAAI,SAAS;AACnC,UAAI,OAAO,eAAe,WAAY,QAAO;AAC7C,YAAM,OAAO,IAAI,IAAI,OAAO;AAC5B,YAAM,UAAU,OAAO,KAAK;AAC5B,UAAI,YAAY,OAAW,MAAK,OAAO,SAAS;AAAA,UAC3C,MAAK,IAAI,WAAW,OAAO;AAChC,aAAO;AAAA,IACT,CAAC;AACH,WAAO;AAAA,MACL,KAAK,CAAC,cAAc,OAAO,IAAI,IAAI,IAAI,OAAO,GAAG,CAAC,YAAY,QAAQ,IAAI,SAAS,CAAC;AAAA,MACpF,MAAM,CAAC,WAAW,UAAU,IAAI,OAAO,SAAS,CAAC,YAAY,IAAI,IAAI,OAAO,EAAE,IAAI,WAAW,KAAK,CAAC;AAAA,MACnG,QAAQ;AAAA,MACR,QAAQ,CAAC,WAAW,eAAe,OAAO,WAAW,YAAY,MAAM,MAAS;AAAA,IAClF;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/cjs/internal/DueOccurrences.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Which occurrences one scheduler tick owes a trigger.
+ *
+ * @since 1.0.0-rc.0
+ */
+import * as Effect from "effect/Effect";
+import type { TriggerError } from "../TriggerError.ts";
+import type { Registered } from "../TriggerStore.ts";
+/**
+ * The occurrences to claim, oldest first, and the watermark that stands once
+ * every one of them has been dispatched.
+ *
+ * @private
+ * @since 1.0.0-rc.0
+ */
+export interface Due {
+    readonly occurrences: ReadonlyArray<number>;
+    readonly watermark: number;
+}
+/**
+ * Computes what a trigger owes at `now`, given the watermark this process has
+ * already dispatched through, or `undefined` on first sight of the trigger.
+ *
+ * The answer depends on nothing but its arguments. The watermark is the
+ * caller's to keep: it only moves forward, and only past occurrences the
+ * caller finished dispatching.
+ *
+ * @private
+ * @since 1.0.0-rc.0
+ */
+export declare const compute: (trigger: Registered, now: number, observed: number | undefined) => Effect.Effect<Due, TriggerError>;
+//# sourceMappingURL=DueOccurrences.d.ts.map

package/dist/cjs/internal/DueOccurrences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DueOccurrences.d.ts","sourceRoot":"","sources":["../../../src/internal/DueOccurrences.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAEpD;;;;;;GAMG;AACH,MAAM,WAAW,GAAG;IAClB,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC3C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAoBD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,OAAO,GAClB,SAAS,UAAU,EACnB,KAAK,MAAM,EACX,UAAU,MAAM,GAAG,SAAS,KAC3B,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,YAAY,CA2C9B,CAAA"}