@smthrs/notifications 0.0.0-stage → 1.0.0-rc.12

package/dist/esm/AlertSink.d.ts

@@ -0,0 +1,101 @@
+/**
+ * The alert sink port: where a raised alert is sent, and why a send failed.
+ *
+ * The port is a tag and an error so a deployment supplies the transport and
+ * the policy needs none. `./layerWebhook.ts` is the transport this package
+ * ships, and {@link layerNoop} is the one a test composes.
+ *
+ * @since 1.0.0
+ */
+import { Context, Effect, Layer, Schema } from "effect";
+import type { Alert } from "./AlertPolicy.ts";
+/**
+ * Why a sink did not take an alert.
+ *
+ * `sink_rejected` is an answer that refused the page, `sink_unreachable` a
+ * request that never got one, and `sink_timeout` one that got no answer inside
+ * the sink's bound. `sink_misconfigured` is an endpoint the sink may not POST
+ * to at all; it is raised when the layer is built, before any alert exists,
+ * so it never reaches a journal.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export declare const FailureCode: Schema.Literals<readonly ["sink_rejected", "sink_unreachable", "sink_timeout", "sink_misconfigured"]>;
+/**
+ * Why a sink did not take an alert.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type FailureCode = typeof FailureCode.Type;
+declare const AlertError_base: Schema.Class<AlertError, Schema.TaggedStruct<"/notifications/AlertError", {
+    readonly code: Schema.withConstructorDefault<Schema.Literals<readonly ["sink_rejected", "sink_unreachable", "sink_timeout", "sink_misconfigured"]>>;
+    readonly message: Schema.String;
+    /** The HTTP status that refused the page, when the sink speaks HTTP. */
+    readonly status: Schema.optional<Schema.Int>;
+    /** A short, credential-free description of the transport failure. */
+    readonly reason: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A sink refused or could not take an alert.
+ *
+ * The error carries a code, the answering status when there was one, and a
+ * short reason. It deliberately holds no request: a webhook request carries
+ * the credential the deployment handed {@link layerWebhook}, and an error is
+ * logged, encoded, and journaled in places a credential must never reach.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class AlertError extends AlertError_base {
+}
+/**
+ * Where a raised alert is sent.
+ *
+ * Injected rather than fixed, because who gets paged is a deployment's
+ * decision and the policy is not: the same rules feed a webhook in production
+ * and nothing at all in a test.
+ *
+ * @category services
+ * @since 0.1.0
+ */
+export interface SinkService {
+    /**
+     * Sends one alert, and does so idempotently on {@link alertId}.
+     *
+     * Delivery is at-least-once: the `flows.alerts.delivered` record is written
+     * after this effect succeeds, so a process that dies in between pages again
+     * on the next tick. Every field of the alert, {@link Alert.firedAt}
+     * included, is derived from the journal, so the same alert is byte-identical
+     * on every attempt and `alertId(alert)` is the deduplication key a receiving
+     * system should key on. A sink that cannot dedupe is a sink that will
+     * occasionally page twice about one condition.
+     *
+     * A failure means the page did not go out. Succeeding on a page that was
+     * dropped is the one thing this port must never do.
+     */
+    readonly deliver: (alert: Alert) => Effect.Effect<void, AlertError>;
+}
+declare const Sink_base: Context.ServiceClass<Sink, "/notifications/AlertSink", SinkService>;
+/**
+ * The {@link SinkService} tag.
+ *
+ * @category services
+ * @since 0.1.0
+ */
+export declare class Sink extends Sink_base {
+}
+/**
+ * A sink that accepts every alert and sends it nowhere.
+ *
+ * The admission and the delivery record still happen, so a composition without
+ * an outbound channel still has the durable evidence of what it would have
+ * paged about.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerNoop: Layer.Layer<Sink>;
+export {};
+//# sourceMappingURL=AlertSink.d.ts.map

package/dist/esm/AlertSink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlertSink.d.ts","sourceRoot":"","sources":["../../src/AlertSink.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAE7C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,uGAA+F,CAAA;AAEvH;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,IAAI,CAAA;;;;IAkB7C,wEAAwE;;IAExE,qEAAqE;;;AAlBzE;;;;;;;;;;GAUG;AACH,qBAAa,UAAW,SAAQ,eAU/B;CAAG;AAEJ;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;CACpE;;AAED;;;;;GAKG;AACH,qBAAa,IAAK,SAAQ,SAAgE;CAAG;AAE7F;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAAuD,CAAA"}

package/dist/esm/AlertSink.js

@@ -0,0 +1,63 @@
+/**
+ * The alert sink port: where a raised alert is sent, and why a send failed.
+ *
+ * The port is a tag and an error so a deployment supplies the transport and
+ * the policy needs none. `./layerWebhook.ts` is the transport this package
+ * ships, and {@link layerNoop} is the one a test composes.
+ *
+ * @since 1.0.0
+ */
+import { Context, Effect, Layer, Schema } from "effect";
+/**
+ * Why a sink did not take an alert.
+ *
+ * `sink_rejected` is an answer that refused the page, `sink_unreachable` a
+ * request that never got one, and `sink_timeout` one that got no answer inside
+ * the sink's bound. `sink_misconfigured` is an endpoint the sink may not POST
+ * to at all; it is raised when the layer is built, before any alert exists,
+ * so it never reaches a journal.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export const FailureCode = Schema.Literals(["sink_rejected", "sink_unreachable", "sink_timeout", "sink_misconfigured"]);
+/**
+ * A sink refused or could not take an alert.
+ *
+ * The error carries a code, the answering status when there was one, and a
+ * short reason. It deliberately holds no request: a webhook request carries
+ * the credential the deployment handed {@link layerWebhook}, and an error is
+ * logged, encoded, and journaled in places a credential must never reach.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export class AlertError extends Schema.TaggedError()("/notifications/AlertError", {
+    code: FailureCode.pipe(Schema.withConstructorDefault(Effect.succeed("sink_rejected"))),
+    message: Schema.String,
+    /** The HTTP status that refused the page, when the sink speaks HTTP. */
+    status: Schema.optional(Schema.Int),
+    /** A short, credential-free description of the transport failure. */
+    reason: Schema.optional(Schema.String)
+}) {
+}
+/**
+ * The {@link SinkService} tag.
+ *
+ * @category services
+ * @since 0.1.0
+ */
+export class Sink extends Context.Service()("/notifications/AlertSink") {
+}
+/**
+ * A sink that accepts every alert and sends it nowhere.
+ *
+ * The admission and the delivery record still happen, so a composition without
+ * an outbound channel still has the durable evidence of what it would have
+ * paged about.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export const layerNoop = Layer.succeed(Sink)({ deliver: () => Effect.void });
+//# sourceMappingURL=AlertSink.js.map

package/dist/esm/AlertSink.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlertSink.js","sourceRoot":"","sources":["../../src/AlertSink.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAGvD;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,eAAe,EAAE,kBAAkB,EAAE,cAAc,EAAE,oBAAoB,CAAC,CAAC,CAAA;AAUvH;;;;;;;;;;GAUG;AACH,MAAM,OAAO,UAAW,SAAQ,MAAM,CAAC,WAAW,EAAc,CAC9D,2BAA2B,EAC3B;IACE,IAAI,EAAE,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,sBAAsB,CAAC,MAAM,CAAC,OAAO,CAAC,eAAwB,CAAC,CAAC,CAAC;IAC/F,OAAO,EAAE,MAAM,CAAC,MAAM;IACtB,wEAAwE;IACxE,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC;IACnC,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC;CACvC,CACF;CAAG;AA8BJ;;;;;GAKG;AACH,MAAM,OAAO,IAAK,SAAQ,OAAO,CAAC,OAAO,EAAqB,CAAC,0BAA0B,CAAC;CAAG;AAE7F;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,SAAS,GAAsB,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAA","sourcesContent":["/**\n * The alert sink port: where a raised alert is sent, and why a send failed.\n *\n * The port is a tag and an error so a deployment supplies the transport and\n * the policy needs none. `./layerWebhook.ts` is the transport this package\n * ships, and {@link layerNoop} is the one a test composes.\n *\n * @since 1.0.0\n */\n\nimport { Context, Effect, Layer, Schema } from \"effect\"\nimport type { Alert } from \"./AlertPolicy.ts\"\n\n/**\n * Why a sink did not take an alert.\n *\n * `sink_rejected` is an answer that refused the page, `sink_unreachable` a\n * request that never got one, and `sink_timeout` one that got no answer inside\n * the sink's bound. `sink_misconfigured` is an endpoint the sink may not POST\n * to at all; it is raised when the layer is built, before any alert exists,\n * so it never reaches a journal.\n *\n * @category models\n * @since 1.0.0\n */\nexport const FailureCode = Schema.Literals([\"sink_rejected\", \"sink_unreachable\", \"sink_timeout\", \"sink_misconfigured\"])\n\n/**\n * Why a sink did not take an alert.\n *\n * @category models\n * @since 1.0.0\n */\nexport type FailureCode = typeof FailureCode.Type\n\n/**\n * A sink refused or could not take an alert.\n *\n * The error carries a code, the answering status when there was one, and a\n * short reason. It deliberately holds no request: a webhook request carries\n * the credential the deployment handed {@link layerWebhook}, and an error is\n * logged, encoded, and journaled in places a credential must never reach.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class AlertError extends Schema.TaggedError<AlertError>()(\n  \"/notifications/AlertError\",\n  {\n    code: FailureCode.pipe(Schema.withConstructorDefault(Effect.succeed(\"sink_rejected\" as const))),\n    message: Schema.String,\n    /** The HTTP status that refused the page, when the sink speaks HTTP. */\n    status: Schema.optional(Schema.Int),\n    /** A short, credential-free description of the transport failure. */\n    reason: Schema.optional(Schema.String)\n  }\n) {}\n\n/**\n * Where a raised alert is sent.\n *\n * Injected rather than fixed, because who gets paged is a deployment's\n * decision and the policy is not: the same rules feed a webhook in production\n * and nothing at all in a test.\n *\n * @category services\n * @since 0.1.0\n */\nexport interface SinkService {\n  /**\n   * Sends one alert, and does so idempotently on {@link alertId}.\n   *\n   * Delivery is at-least-once: the `flows.alerts.delivered` record is written\n   * after this effect succeeds, so a process that dies in between pages again\n   * on the next tick. Every field of the alert, {@link Alert.firedAt}\n   * included, is derived from the journal, so the same alert is byte-identical\n   * on every attempt and `alertId(alert)` is the deduplication key a receiving\n   * system should key on. A sink that cannot dedupe is a sink that will\n   * occasionally page twice about one condition.\n   *\n   * A failure means the page did not go out. Succeeding on a page that was\n   * dropped is the one thing this port must never do.\n   */\n  readonly deliver: (alert: Alert) => Effect.Effect<void, AlertError>\n}\n\n/**\n * The {@link SinkService} tag.\n *\n * @category services\n * @since 0.1.0\n */\nexport class Sink extends Context.Service<Sink, SinkService>()(\"/notifications/AlertSink\") {}\n\n/**\n * A sink that accepts every alert and sends it nowhere.\n *\n * The admission and the delivery record still happen, so a composition without\n * an outbound channel still has the durable evidence of what it would have\n * paged about.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerNoop: Layer.Layer<Sink> = Layer.succeed(Sink)({ deliver: () => Effect.void })\n"]}

package/dist/esm/Alerts.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Alert policy: run conditions that have lasted too long, turned into durable,
+ * coalesced, delivered-once notifications.
+ *
+ * A notification queue answers "tell this run something". An alert answers the
+ * question nobody is around to ask: a run has been waiting for an approval for
+ * an hour, and the person who could grant it does not know. The two are the
+ * same machinery, since an alert is admitted as a coalesced system event, and
+ * they differ only in who decides to write one.
+ *
+ * ## Journal time, not wall time
+ *
+ * A condition's clock starts at the journal entry that opened it, which makes
+ * the decision replayable: the same journal produces the same alerts, whatever
+ * process reads it and whenever. A restart re-derives every open condition
+ * from the entries rather than from a timer it lost.
+ *
+ * ## Delivered at least once
+ *
+ * The admission is idempotent on the notification id, so re-admitting the same
+ * alert writes nothing new, and `flows.alerts.delivered` is journaled AFTER
+ * the sink accepted the page and is checked before the sink is called again.
+ * That ordering is deliberate and it is the reason the guarantee is
+ * at-least-once rather than exactly-once: a process that dies between the
+ * accepted send and the delivery record has paged, left no evidence of it, and
+ * will page again on the next tick. Recording the delivery first turns the
+ * same crash into a page nobody ever receives, which for an alert is the worse
+ * failure.
+ *
+ * So the sink owns the last mile: {@link SinkService.deliver} MUST be
+ * idempotent on {@link alertId}, which is stable for the life of one condition
+ * and reaches the sink on every alert it is handed. A sink that fails journals
+ * `flows.alerts.failed` once per failure code and the alert is retried on the
+ * next tick, because a refused page is not a delivered page.
+ *
+ * ## What a refusal costs
+ *
+ * The queue can refuse the admission when a run already holds its capacity of
+ * pending notifications. A tick that is refused pages nobody: the alert comes
+ * back in {@link Tick.refused}, the refusal is journaled, and the next tick
+ * tries again once a boundary has drained. Calling the sink anyway would page
+ * about an alert the run will never see.
+ *
+ * ## Conditions are data
+ *
+ * A condition is a payload field with a value: `status` is `waiting-approval`,
+ * `health` is `stalled`. Those are the fields control-plane entries and monitor
+ * beats already carry, so a deployment that journals a different vocabulary
+ * supplies its own detectors instead of a fork of this module.
+ *
+ * @since 0.1.0
+ */
+export { type Alert, alertId, coalescingKey, conditions, decide, defaultDetectors, deliveredEventType, Detector, failedEventType, type Open, Policy, Rule, Severity } from "./AlertPolicy.ts";
+export { AlertRuntime, layer, type RuntimeService, type Tick } from "./AlertRuntime.ts";
+export { AlertError, FailureCode, layerNoop, Sink, type SinkService } from "./AlertSink.ts";
+export { defaultWebhookTimeout, layerWebhook } from "./layerWebhook.ts";
+//# sourceMappingURL=Alerts.d.ts.map

package/dist/esm/Alerts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Alerts.d.ts","sourceRoot":"","sources":["../../src/Alerts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH,OAAO,EACL,KAAK,KAAK,EACV,OAAO,EACP,aAAa,EACb,UAAU,EACV,MAAM,EACN,gBAAgB,EAChB,kBAAkB,EAClB,QAAQ,EACR,eAAe,EACf,KAAK,IAAI,EACT,MAAM,EACN,IAAI,EACJ,QAAQ,EACT,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,cAAc,EAAE,KAAK,IAAI,EAAE,MAAM,mBAAmB,CAAA;AACvF,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC3F,OAAO,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA"}

package/dist/esm/Alerts.js

@@ -0,0 +1,57 @@
+/**
+ * Alert policy: run conditions that have lasted too long, turned into durable,
+ * coalesced, delivered-once notifications.
+ *
+ * A notification queue answers "tell this run something". An alert answers the
+ * question nobody is around to ask: a run has been waiting for an approval for
+ * an hour, and the person who could grant it does not know. The two are the
+ * same machinery, since an alert is admitted as a coalesced system event, and
+ * they differ only in who decides to write one.
+ *
+ * ## Journal time, not wall time
+ *
+ * A condition's clock starts at the journal entry that opened it, which makes
+ * the decision replayable: the same journal produces the same alerts, whatever
+ * process reads it and whenever. A restart re-derives every open condition
+ * from the entries rather than from a timer it lost.
+ *
+ * ## Delivered at least once
+ *
+ * The admission is idempotent on the notification id, so re-admitting the same
+ * alert writes nothing new, and `flows.alerts.delivered` is journaled AFTER
+ * the sink accepted the page and is checked before the sink is called again.
+ * That ordering is deliberate and it is the reason the guarantee is
+ * at-least-once rather than exactly-once: a process that dies between the
+ * accepted send and the delivery record has paged, left no evidence of it, and
+ * will page again on the next tick. Recording the delivery first turns the
+ * same crash into a page nobody ever receives, which for an alert is the worse
+ * failure.
+ *
+ * So the sink owns the last mile: {@link SinkService.deliver} MUST be
+ * idempotent on {@link alertId}, which is stable for the life of one condition
+ * and reaches the sink on every alert it is handed. A sink that fails journals
+ * `flows.alerts.failed` once per failure code and the alert is retried on the
+ * next tick, because a refused page is not a delivered page.
+ *
+ * ## What a refusal costs
+ *
+ * The queue can refuse the admission when a run already holds its capacity of
+ * pending notifications. A tick that is refused pages nobody: the alert comes
+ * back in {@link Tick.refused}, the refusal is journaled, and the next tick
+ * tries again once a boundary has drained. Calling the sink anyway would page
+ * about an alert the run will never see.
+ *
+ * ## Conditions are data
+ *
+ * A condition is a payload field with a value: `status` is `waiting-approval`,
+ * `health` is `stalled`. Those are the fields control-plane entries and monitor
+ * beats already carry, so a deployment that journals a different vocabulary
+ * supplies its own detectors instead of a fork of this module.
+ *
+ * @since 0.1.0
+ */
+export { alertId, coalescingKey, conditions, decide, defaultDetectors, deliveredEventType, Detector, failedEventType, Policy, Rule, Severity } from "./AlertPolicy.js";
+export { AlertRuntime, layer } from "./AlertRuntime.js";
+export { AlertError, FailureCode, layerNoop, Sink } from "./AlertSink.js";
+export { defaultWebhookTimeout, layerWebhook } from "./layerWebhook.js";
+//# sourceMappingURL=Alerts.js.map

package/dist/esm/Alerts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Alerts.js","sourceRoot":"","sources":["../../src/Alerts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH,OAAO,EAEL,OAAO,EACP,aAAa,EACb,UAAU,EACV,MAAM,EACN,gBAAgB,EAChB,kBAAkB,EAClB,QAAQ,EACR,eAAe,EAEf,MAAM,EACN,IAAI,EACJ,QAAQ,EACT,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,YAAY,EAAE,KAAK,EAAkC,MAAM,mBAAmB,CAAA;AACvF,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,SAAS,EAAE,IAAI,EAAoB,MAAM,gBAAgB,CAAA;AAC3F,OAAO,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA","sourcesContent":["/**\n * Alert policy: run conditions that have lasted too long, turned into durable,\n * coalesced, delivered-once notifications.\n *\n * A notification queue answers \"tell this run something\". An alert answers the\n * question nobody is around to ask: a run has been waiting for an approval for\n * an hour, and the person who could grant it does not know. The two are the\n * same machinery, since an alert is admitted as a coalesced system event, and\n * they differ only in who decides to write one.\n *\n * ## Journal time, not wall time\n *\n * A condition's clock starts at the journal entry that opened it, which makes\n * the decision replayable: the same journal produces the same alerts, whatever\n * process reads it and whenever. A restart re-derives every open condition\n * from the entries rather than from a timer it lost.\n *\n * ## Delivered at least once\n *\n * The admission is idempotent on the notification id, so re-admitting the same\n * alert writes nothing new, and `flows.alerts.delivered` is journaled AFTER\n * the sink accepted the page and is checked before the sink is called again.\n * That ordering is deliberate and it is the reason the guarantee is\n * at-least-once rather than exactly-once: a process that dies between the\n * accepted send and the delivery record has paged, left no evidence of it, and\n * will page again on the next tick. Recording the delivery first turns the\n * same crash into a page nobody ever receives, which for an alert is the worse\n * failure.\n *\n * So the sink owns the last mile: {@link SinkService.deliver} MUST be\n * idempotent on {@link alertId}, which is stable for the life of one condition\n * and reaches the sink on every alert it is handed. A sink that fails journals\n * `flows.alerts.failed` once per failure code and the alert is retried on the\n * next tick, because a refused page is not a delivered page.\n *\n * ## What a refusal costs\n *\n * The queue can refuse the admission when a run already holds its capacity of\n * pending notifications. A tick that is refused pages nobody: the alert comes\n * back in {@link Tick.refused}, the refusal is journaled, and the next tick\n * tries again once a boundary has drained. Calling the sink anyway would page\n * about an alert the run will never see.\n *\n * ## Conditions are data\n *\n * A condition is a payload field with a value: `status` is `waiting-approval`,\n * `health` is `stalled`. Those are the fields control-plane entries and monitor\n * beats already carry, so a deployment that journals a different vocabulary\n * supplies its own detectors instead of a fork of this module.\n *\n * @since 0.1.0\n */\n\nexport {\n  type Alert,\n  alertId,\n  coalescingKey,\n  conditions,\n  decide,\n  defaultDetectors,\n  deliveredEventType,\n  Detector,\n  failedEventType,\n  type Open,\n  Policy,\n  Rule,\n  Severity\n} from \"./AlertPolicy.ts\"\nexport { AlertRuntime, layer, type RuntimeService, type Tick } from \"./AlertRuntime.ts\"\nexport { AlertError, FailureCode, layerNoop, Sink, type SinkService } from \"./AlertSink.ts\"\nexport { defaultWebhookTimeout, layerWebhook } from \"./layerWebhook.ts\"\n"]}

package/dist/esm/Notification.d.ts

@@ -0,0 +1,214 @@
+/**
+ * Durable notification payloads and their admission classification.
+ *
+ * @since 0.1.0
+ */
+import { Schema } from "effect";
+/**
+ * Producer-supplied attribution carried as data alongside the authenticated
+ * source actor. These labels never authorize a notification or a model action.
+ * They pass through the journal's ordinary redaction policy.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export declare const Attribution: Schema.$Record<Schema.String, Schema.String>;
+/**
+ * Durable origin of a notification: who said it, from where, and at which
+ * turn.
+ *
+ * Provenance travels with the notification because the run that receives one
+ * is not the run that wrote it. An operator steer, a parent run's event, and a
+ * webhook all arrive on the same queue, and only these fields say which is
+ * which after the fact.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare const Provenance: Schema.Struct<{
+    readonly sourceRunId: Schema.String;
+    readonly sourceLineageId: Schema.String;
+    readonly sourceTurn: Schema.Int;
+    readonly sourceActor: Schema.String;
+    readonly attribution: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+}>;
+/**
+ * The decoded form of {@link Provenance}.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Provenance = typeof Provenance.Type;
+/**
+ * A human message that must reach the model before the current turn closes.
+ *
+ * `id` is the caller's idempotency key: admitting it twice with the same
+ * content is one notification, and admitting it with different content is a
+ * producer bug the queue refuses. New admissions fingerprint the validated
+ * content before journal redaction, so redaction does not change retry identity.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare const HumanSteer: Schema.TaggedStruct<"human-steer", {
+    readonly delivery: Schema.Literal<"steer">;
+    readonly id: Schema.NonEmptyString;
+    readonly targetLineageId: Schema.NonEmptyString;
+    readonly provenance: Schema.Struct<{
+        readonly sourceRunId: Schema.String;
+        readonly sourceLineageId: Schema.String;
+        readonly sourceTurn: Schema.Int;
+        readonly sourceActor: Schema.String;
+        readonly attribution: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+/**
+ * The decoded form of {@link HumanSteer}.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type HumanSteer = typeof HumanSteer.Type;
+/**
+ * A human message that waits for the run to become idle.
+ *
+ * The delivery class is the whole difference from {@link HumanSteer}: a
+ * follow-up is not urgent enough to interrupt the turn in flight, so it is
+ * promoted one at a time when the run would otherwise have nothing to do.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare const HumanFollowup: Schema.TaggedStruct<"human-followup", {
+    readonly delivery: Schema.Literal<"queue">;
+    readonly id: Schema.NonEmptyString;
+    readonly targetLineageId: Schema.NonEmptyString;
+    readonly provenance: Schema.Struct<{
+        readonly sourceRunId: Schema.String;
+        readonly sourceLineageId: Schema.String;
+        readonly sourceTurn: Schema.Int;
+        readonly sourceActor: Schema.String;
+        readonly attribution: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+/**
+ * The decoded form of {@link HumanFollowup}.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type HumanFollowup = typeof HumanFollowup.Type;
+/**
+ * A machine-originated event. Events sharing a coalescing key and a target
+ * lineage collapse to the most recent one while pending.
+ *
+ * Coalescing is what keeps a chatty producer from filling the queue: ten
+ * updates about one condition are one pending notification carrying the latest
+ * of them. The key is scoped to `targetLineageId`, so two branches reporting
+ * one condition under the same ordinary key each keep their own event. An
+ * event with no key never coalesces.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare const SystemEvent: Schema.TaggedStruct<"system-event", {
+    readonly delivery: Schema.Literal<"queue">;
+    readonly coalescingKey: Schema.optional<Schema.String>;
+    readonly id: Schema.NonEmptyString;
+    readonly targetLineageId: Schema.NonEmptyString;
+    readonly provenance: Schema.Struct<{
+        readonly sourceRunId: Schema.String;
+        readonly sourceLineageId: Schema.String;
+        readonly sourceTurn: Schema.Int;
+        readonly sourceActor: Schema.String;
+        readonly attribution: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+/**
+ * The decoded form of {@link SystemEvent}.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type SystemEvent = typeof SystemEvent.Type;
+/**
+ * Any durable notification retained by the pending queue.
+ *
+ * `NotificationQueue.admit` decodes its argument against this union before it
+ * journals anything, so a value that does not match it is refused rather than
+ * acknowledged and then skipped by every replay. Journal-backed queues deeply
+ * freeze decoded notifications, including payloads, before returning them from
+ * `pending` or `drain`.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare const Notification: Schema.Union<readonly [Schema.TaggedStruct<"human-steer", {
+    readonly delivery: Schema.Literal<"steer">;
+    readonly id: Schema.NonEmptyString;
+    readonly targetLineageId: Schema.NonEmptyString;
+    readonly provenance: Schema.Struct<{
+        readonly sourceRunId: Schema.String;
+        readonly sourceLineageId: Schema.String;
+        readonly sourceTurn: Schema.Int;
+        readonly sourceActor: Schema.String;
+        readonly attribution: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.TaggedStruct<"human-followup", {
+    readonly delivery: Schema.Literal<"queue">;
+    readonly id: Schema.NonEmptyString;
+    readonly targetLineageId: Schema.NonEmptyString;
+    readonly provenance: Schema.Struct<{
+        readonly sourceRunId: Schema.String;
+        readonly sourceLineageId: Schema.String;
+        readonly sourceTurn: Schema.Int;
+        readonly sourceActor: Schema.String;
+        readonly attribution: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.TaggedStruct<"system-event", {
+    readonly delivery: Schema.Literal<"queue">;
+    readonly coalescingKey: Schema.optional<Schema.String>;
+    readonly id: Schema.NonEmptyString;
+    readonly targetLineageId: Schema.NonEmptyString;
+    readonly provenance: Schema.Struct<{
+        readonly sourceRunId: Schema.String;
+        readonly sourceLineageId: Schema.String;
+        readonly sourceTurn: Schema.Int;
+        readonly sourceActor: Schema.String;
+        readonly attribution: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    }>;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>]>;
+/**
+ * Any durable notification retained by the pending queue.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Notification = typeof Notification.Type;
+/**
+ * How a notification is allowed to reach the model.
+ *
+ * `steer` notifications are promoted in a batch at turn close; `queue`
+ * notifications are promoted one at a time when the run would otherwise idle.
+ *
+ * @param notification the notification to classify
+ * @category getters
+ * @since 0.1.0
+ */
+export declare const admissionClass: (notification: Notification) => "steer" | "queue";
+/**
+ * The key a pending notification coalesces on, or `null` when it must never
+ * be coalesced. Only system events coalesce, and only when they declare a key.
+ *
+ * @param notification the notification to key
+ * @category getters
+ * @since 0.1.0
+ */
+export declare const coalesceKey: (notification: Notification) => string | null;
+//# sourceMappingURL=Notification.d.ts.map

package/dist/esm/Notification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Notification.d.ts","sourceRoot":"","sources":["../../src/Notification.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,8CAA8C,CAAA;AAEtE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU;;;;;;EAMrB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAA;AAS/C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;EAGrB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAA;AAE/C;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;EAGxB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;AAErD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;EAItB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,IAAI,CAAA;AAEjD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAyD,CAAA;AAElF;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAA;AAEnD;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAI,cAAc,YAAY,KAAG,OAAO,GAAG,OAAgC,CAAA;AAEtG;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GAAI,cAAc,YAAY,KAAG,MAAM,GAAG,IACgB,CAAA"}

package/dist/esm/Notification.js

@@ -0,0 +1,121 @@
+/**
+ * Durable notification payloads and their admission classification.
+ *
+ * @since 0.1.0
+ */
+import { Schema } from "effect";
+/**
+ * Producer-supplied attribution carried as data alongside the authenticated
+ * source actor. These labels never authorize a notification or a model action.
+ * They pass through the journal's ordinary redaction policy.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export const Attribution = Schema.Record(Schema.String, Schema.String);
+/**
+ * Durable origin of a notification: who said it, from where, and at which
+ * turn.
+ *
+ * Provenance travels with the notification because the run that receives one
+ * is not the run that wrote it. An operator steer, a parent run's event, and a
+ * webhook all arrive on the same queue, and only these fields say which is
+ * which after the fact.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const Provenance = Schema.Struct({
+    sourceRunId: Schema.String,
+    sourceLineageId: Schema.String,
+    sourceTurn: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0))),
+    sourceActor: Schema.String,
+    attribution: Schema.optional(Attribution)
+});
+const common = {
+    id: Schema.NonEmptyString,
+    targetLineageId: Schema.NonEmptyString,
+    provenance: Provenance,
+    payload: Schema.Json
+};
+/**
+ * A human message that must reach the model before the current turn closes.
+ *
+ * `id` is the caller's idempotency key: admitting it twice with the same
+ * content is one notification, and admitting it with different content is a
+ * producer bug the queue refuses. New admissions fingerprint the validated
+ * content before journal redaction, so redaction does not change retry identity.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const HumanSteer = Schema.TaggedStruct("human-steer", {
+    ...common,
+    delivery: Schema.Literal("steer")
+});
+/**
+ * A human message that waits for the run to become idle.
+ *
+ * The delivery class is the whole difference from {@link HumanSteer}: a
+ * follow-up is not urgent enough to interrupt the turn in flight, so it is
+ * promoted one at a time when the run would otherwise have nothing to do.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const HumanFollowup = Schema.TaggedStruct("human-followup", {
+    ...common,
+    delivery: Schema.Literal("queue")
+});
+/**
+ * A machine-originated event. Events sharing a coalescing key and a target
+ * lineage collapse to the most recent one while pending.
+ *
+ * Coalescing is what keeps a chatty producer from filling the queue: ten
+ * updates about one condition are one pending notification carrying the latest
+ * of them. The key is scoped to `targetLineageId`, so two branches reporting
+ * one condition under the same ordinary key each keep their own event. An
+ * event with no key never coalesces.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const SystemEvent = Schema.TaggedStruct("system-event", {
+    ...common,
+    delivery: Schema.Literal("queue"),
+    coalescingKey: Schema.optional(Schema.String)
+});
+/**
+ * Any durable notification retained by the pending queue.
+ *
+ * `NotificationQueue.admit` decodes its argument against this union before it
+ * journals anything, so a value that does not match it is refused rather than
+ * acknowledged and then skipped by every replay. Journal-backed queues deeply
+ * freeze decoded notifications, including payloads, before returning them from
+ * `pending` or `drain`.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const Notification = Schema.Union([HumanSteer, HumanFollowup, SystemEvent]);
+/**
+ * How a notification is allowed to reach the model.
+ *
+ * `steer` notifications are promoted in a batch at turn close; `queue`
+ * notifications are promoted one at a time when the run would otherwise idle.
+ *
+ * @param notification the notification to classify
+ * @category getters
+ * @since 0.1.0
+ */
+export const admissionClass = (notification) => notification.delivery;
+/**
+ * The key a pending notification coalesces on, or `null` when it must never
+ * be coalesced. Only system events coalesce, and only when they declare a key.
+ *
+ * @param notification the notification to key
+ * @category getters
+ * @since 0.1.0
+ */
+export const coalesceKey = (notification) => notification._tag === "system-event" ? notification.coalescingKey ?? null : null;
+//# sourceMappingURL=Notification.js.map

package/dist/esm/Notification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Notification.js","sourceRoot":"","sources":["../../src/Notification.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;AAEtE;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC;IACtC,WAAW,EAAE,MAAM,CAAC,MAAM;IAC1B,eAAe,EAAE,MAAM,CAAC,MAAM;IAC9B,UAAU,EAAE,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3E,WAAW,EAAE,MAAM,CAAC,MAAM;IAC1B,WAAW,EAAE,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC;CAC1C,CAAC,CAAA;AAUF,MAAM,MAAM,GAAG;IACb,EAAE,EAAE,MAAM,CAAC,cAAc;IACzB,eAAe,EAAE,MAAM,CAAC,cAAc;IACtC,UAAU,EAAE,UAAU;IACtB,OAAO,EAAE,MAAM,CAAC,IAAI;CACrB,CAAA;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC,YAAY,CAAC,aAAa,EAAE;IAC3D,GAAG,MAAM;IACT,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC;CAClC,CAAC,CAAA;AAUF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC,YAAY,CAAC,gBAAgB,EAAE;IACjE,GAAG,MAAM;IACT,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC;CAClC,CAAC,CAAA;AAUF;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,MAAM,CAAC,YAAY,CAAC,cAAc,EAAE;IAC7D,GAAG,MAAM;IACT,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC;IACjC,aAAa,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC;CAC9C,CAAC,CAAA;AAUF;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,UAAU,EAAE,aAAa,EAAE,WAAW,CAAC,CAAC,CAAA;AAUlF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,YAA0B,EAAqB,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAA;AAEtG;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,YAA0B,EAAiB,EAAE,CACvE,YAAY,CAAC,IAAI,KAAK,cAAc,CAAC,CAAC,CAAC,YAAY,CAAC,aAAa,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAA","sourcesContent":["/**\n * Durable notification payloads and their admission classification.\n *\n * @since 0.1.0\n */\n\nimport { Schema } from \"effect\"\n\n/**\n * Producer-supplied attribution carried as data alongside the authenticated\n * source actor. These labels never authorize a notification or a model action.\n * They pass through the journal's ordinary redaction policy.\n *\n * @category models\n * @since 1.0.0\n */\nexport const Attribution = Schema.Record(Schema.String, Schema.String)\n\n/**\n * Durable origin of a notification: who said it, from where, and at which\n * turn.\n *\n * Provenance travels with the notification because the run that receives one\n * is not the run that wrote it. An operator steer, a parent run's event, and a\n * webhook all arrive on the same queue, and only these fields say which is\n * which after the fact.\n *\n * @category models\n * @since 0.1.0\n */\nexport const Provenance = Schema.Struct({\n  sourceRunId: Schema.String,\n  sourceLineageId: Schema.String,\n  sourceTurn: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0))),\n  sourceActor: Schema.String,\n  attribution: Schema.optional(Attribution)\n})\n\n/**\n * The decoded form of {@link Provenance}.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Provenance = typeof Provenance.Type\n\nconst common = {\n  id: Schema.NonEmptyString,\n  targetLineageId: Schema.NonEmptyString,\n  provenance: Provenance,\n  payload: Schema.Json\n}\n\n/**\n * A human message that must reach the model before the current turn closes.\n *\n * `id` is the caller's idempotency key: admitting it twice with the same\n * content is one notification, and admitting it with different content is a\n * producer bug the queue refuses. New admissions fingerprint the validated\n * content before journal redaction, so redaction does not change retry identity.\n *\n * @category models\n * @since 0.1.0\n */\nexport const HumanSteer = Schema.TaggedStruct(\"human-steer\", {\n  ...common,\n  delivery: Schema.Literal(\"steer\")\n})\n\n/**\n * The decoded form of {@link HumanSteer}.\n *\n * @category models\n * @since 0.1.0\n */\nexport type HumanSteer = typeof HumanSteer.Type\n\n/**\n * A human message that waits for the run to become idle.\n *\n * The delivery class is the whole difference from {@link HumanSteer}: a\n * follow-up is not urgent enough to interrupt the turn in flight, so it is\n * promoted one at a time when the run would otherwise have nothing to do.\n *\n * @category models\n * @since 0.1.0\n */\nexport const HumanFollowup = Schema.TaggedStruct(\"human-followup\", {\n  ...common,\n  delivery: Schema.Literal(\"queue\")\n})\n\n/**\n * The decoded form of {@link HumanFollowup}.\n *\n * @category models\n * @since 0.1.0\n */\nexport type HumanFollowup = typeof HumanFollowup.Type\n\n/**\n * A machine-originated event. Events sharing a coalescing key and a target\n * lineage collapse to the most recent one while pending.\n *\n * Coalescing is what keeps a chatty producer from filling the queue: ten\n * updates about one condition are one pending notification carrying the latest\n * of them. The key is scoped to `targetLineageId`, so two branches reporting\n * one condition under the same ordinary key each keep their own event. An\n * event with no key never coalesces.\n *\n * @category models\n * @since 0.1.0\n */\nexport const SystemEvent = Schema.TaggedStruct(\"system-event\", {\n  ...common,\n  delivery: Schema.Literal(\"queue\"),\n  coalescingKey: Schema.optional(Schema.String)\n})\n\n/**\n * The decoded form of {@link SystemEvent}.\n *\n * @category models\n * @since 0.1.0\n */\nexport type SystemEvent = typeof SystemEvent.Type\n\n/**\n * Any durable notification retained by the pending queue.\n *\n * `NotificationQueue.admit` decodes its argument against this union before it\n * journals anything, so a value that does not match it is refused rather than\n * acknowledged and then skipped by every replay. Journal-backed queues deeply\n * freeze decoded notifications, including payloads, before returning them from\n * `pending` or `drain`.\n *\n * @category models\n * @since 0.1.0\n */\nexport const Notification = Schema.Union([HumanSteer, HumanFollowup, SystemEvent])\n\n/**\n * Any durable notification retained by the pending queue.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Notification = typeof Notification.Type\n\n/**\n * How a notification is allowed to reach the model.\n *\n * `steer` notifications are promoted in a batch at turn close; `queue`\n * notifications are promoted one at a time when the run would otherwise idle.\n *\n * @param notification the notification to classify\n * @category getters\n * @since 0.1.0\n */\nexport const admissionClass = (notification: Notification): \"steer\" | \"queue\" => notification.delivery\n\n/**\n * The key a pending notification coalesces on, or `null` when it must never\n * be coalesced. Only system events coalesce, and only when they declare a key.\n *\n * @param notification the notification to key\n * @category getters\n * @since 0.1.0\n */\nexport const coalesceKey = (notification: Notification): string | null =>\n  notification._tag === \"system-event\" ? notification.coalescingKey ?? null : null\n"]}