@fonoster/common 0.27.0 → 0.31.0

package/dist/validators/sipnet/trunks.d.ts

@@ -20,7 +20,7 @@ import { Transport } from "@fonoster/types";
 import { z } from "zod";
 declare const createTrunkRequestSchema: z.ZodObject<{
     name: z.ZodString;
-    sendRegister: z.ZodBoolean;
+    sendRegister: z.ZodOptional<z.ZodBoolean>;
     inboundUri: z.ZodEffects<z.ZodString, string, string>;
     uris: z.ZodArray<z.ZodObject<{
         host: z.ZodEffects<z.ZodString, string, string>;
@@ -29,49 +29,49 @@ declare const createTrunkRequestSchema: z.ZodObject<{
         user: z.ZodOptional<z.ZodString>;
         weight: z.ZodNumber;
         priority: z.ZodNumber;
-        enabled: z.ZodBoolean;
+        enabled: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
+        transport?: Transport;
         host?: string;
         port?: number;
-        priority?: number;
-        enabled?: boolean;
-        transport?: Transport;
         user?: string;
+        enabled?: boolean;
         weight?: number;
+        priority?: number;
     }, {
+        transport?: Transport;
         host?: string;
         port?: number;
-        priority?: number;
-        enabled?: boolean;
-        transport?: Transport;
         user?: string;
+        enabled?: boolean;
         weight?: number;
+        priority?: number;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     name?: string;
     sendRegister?: boolean;
     inboundUri?: string;
     uris?: {
+        transport?: Transport;
         host?: string;
         port?: number;
-        priority?: number;
-        enabled?: boolean;
-        transport?: Transport;
         user?: string;
+        enabled?: boolean;
         weight?: number;
+        priority?: number;
     }[];
 }, {
     name?: string;
     sendRegister?: boolean;
     inboundUri?: string;
     uris?: {
+        transport?: Transport;
         host?: string;
         port?: number;
-        priority?: number;
-        enabled?: boolean;
-        transport?: Transport;
         user?: string;
+        enabled?: boolean;
         weight?: number;
+        priority?: number;
     }[];
 }>;
 declare const updateTrunkRequestSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;

package/dist/validators/sipnet/trunks.js

@@ -61,9 +61,11 @@ const hostOrIPSchema = zod_1.z
     .refine((host) => Validator.isIP(host, 4) || Validator.isFQDN(host), {
     message: "Must be a valid IP or FQDN"
 });
+// Booleans are optional: the gRPC loader drops proto3 defaults, so `false`
+// arrives as a missing field.
 const createTrunkRequestSchema = zod_1.z.object({
     name: common_1.nameSchema,
-    sendRegister: zod_1.z.boolean(),
+    sendRegister: zod_1.z.boolean().optional(),
     inboundUri: hostOrIPSchema,
     uris: zod_1.z.array(zod_1.z.object({
         host: hostOrIPSchema,
@@ -72,7 +74,7 @@ const createTrunkRequestSchema = zod_1.z.object({
         user: zod_1.z.string().optional(),
         weight: zod_1.z.number(),
         priority: zod_1.z.number(),
-        enabled: zod_1.z.boolean()
+        enabled: zod_1.z.boolean().optional()
     }))
 });
 exports.createTrunkRequestSchema = createTrunkRequestSchema;

package/dist/webhooks/Dispatcher.d.ts

@@ -0,0 +1,87 @@
+import { WebhookEvent, WebhookEventType } from "./events";
+export type WebhookEndpoint = {
+    id: string;
+    workspaceRef: string;
+    url: string;
+    events: WebhookEventType[];
+    secret: string;
+    /** The previous secret stays valid until `previousUntil` (rotation window). */
+    previousSecret?: string;
+    previousUntil?: number;
+};
+export type Delivery = {
+    id: string;
+    endpointId: string;
+    event: WebhookEvent;
+    status: "pending" | "succeeded" | "failed";
+    attempts: number;
+    firstAttemptAt?: number;
+    lastAttemptAt?: number;
+    lastStatus?: number;
+    nextAttemptAt: number;
+};
+export interface WebhookStore {
+    endpoints(workspaceRef?: string): WebhookEndpoint[];
+    putEndpoint(e: WebhookEndpoint): void;
+    deleteEndpoint(id: string): void;
+    deliveries(endpointId?: string): Delivery[];
+    putDelivery(d: Delivery): void;
+}
+export declare class MemoryWebhookStore implements WebhookStore {
+    private e;
+    private d;
+    endpoints(workspaceRef?: string): WebhookEndpoint[];
+    putEndpoint(x: WebhookEndpoint): void;
+    deleteEndpoint(id: string): void;
+    deliveries(endpointId?: string): Delivery[];
+    putDelivery(x: Delivery): void;
+}
+export declare class WebhookError extends Error {
+}
+/**
+ * The id of an event's delivery to one endpoint. It depends only on the two, so the same event
+ * fanned out again (a bus message redelivered after a replica died, or published twice) finds
+ * the delivery it already made instead of making a second one (ST-2).
+ */
+export declare function deliveryId(eventId: string, endpointId: string): string;
+export type DispatcherOptions = {
+    store: WebhookStore;
+    /** Per-attempt timeout (design OQ3 proposal: 10 s). */
+    attemptTimeoutMs?: number;
+    /** First retry delay; each next one doubles, capped at maxDelayMs (OQ2: from 10 s). */
+    firstDelayMs?: number;
+    maxDelayMs?: number;
+    /** Retries stop this long after the first attempt (OQ2: 24 h). */
+    retryPeriodMs?: number;
+    /** Lets tests use plain http:// receivers. Never in production. */
+    allowInsecureUrls?: boolean;
+    /**
+     * Private destinations (host names, IPs, CIDRs) endpoints may use; defaults to
+     * FONOSTER_ALLOWED_DESTINATIONS. Everything else must be public (RV-B2).
+     */
+    allowedDestinations?: string[];
+    now?: () => number;
+};
+export declare class WebhookDispatcher {
+    private readonly options;
+    constructor(options: DispatcherOptions);
+    private policy;
+    private now;
+    /** Registers an endpoint; the returned secret is the only time it is shown. */
+    createEndpoint(input: {
+        workspaceRef: string;
+        url: string;
+        events: WebhookEventType[];
+    }): WebhookEndpoint;
+    /** New secret; the old one keeps verifying for `windowMs`. Returns the new secret. */
+    rotateSecret(endpointId: string, windowMs?: number): string;
+    /** The deliveries an event makes, one per subscribed endpoint of its workspace (not stored). */
+    plan(event: WebhookEvent): Delivery[];
+    /** Fans an event out to every endpoint of its workspace subscribed to its type. */
+    publish(event: WebhookEvent): Delivery[];
+    /** Attempts every pending delivery that is due; returns how many were attempted. */
+    runDue(): Promise<number>;
+    /** Sends a delivery again now, with the original event id and a fresh signature. */
+    resend(deliveryId: string): Promise<Delivery>;
+    private attempt;
+}

package/dist/webhooks/Dispatcher.js

@@ -0,0 +1,225 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookDispatcher = exports.WebhookError = exports.MemoryWebhookStore = void 0;
+exports.deliveryId = deliveryId;
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const crypto_1 = require("crypto");
+const url_1 = require("url");
+const net_1 = require("../net");
+const events_1 = require("./events");
+const signing_1 = require("./signing");
+class MemoryWebhookStore {
+    constructor() {
+        this.e = new Map();
+        this.d = new Map();
+    }
+    endpoints(workspaceRef) {
+        return [...this.e.values()].filter((x) => !workspaceRef || x.workspaceRef === workspaceRef);
+    }
+    putEndpoint(x) {
+        this.e.set(x.id, x);
+    }
+    deleteEndpoint(id) {
+        this.e.delete(id);
+    }
+    deliveries(endpointId) {
+        return [...this.d.values()].filter((x) => !endpointId || x.endpointId === endpointId);
+    }
+    putDelivery(x) {
+        this.d.set(x.id, x);
+    }
+}
+exports.MemoryWebhookStore = MemoryWebhookStore;
+class WebhookError extends Error {
+}
+exports.WebhookError = WebhookError;
+/**
+ * The id of an event's delivery to one endpoint. It depends only on the two, so the same event
+ * fanned out again (a bus message redelivered after a replica died, or published twice) finds
+ * the delivery it already made instead of making a second one (ST-2).
+ */
+function deliveryId(eventId, endpointId) {
+    const h = (0, crypto_1.createHash)("sha256")
+        .update(`${eventId}\0${endpointId}`)
+        .digest("hex");
+    return `whd_${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;
+}
+class WebhookDispatcher {
+    constructor(options) {
+        this.options = options;
+    }
+    policy() {
+        return this.options.allowedDestinations
+            ? { allow: this.options.allowedDestinations }
+            : undefined;
+    }
+    now() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.options).now) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : Date.now();
+    }
+    /** Registers an endpoint; the returned secret is the only time it is shown. */
+    createEndpoint(input) {
+        let url;
+        try {
+            url = new url_1.URL(input.url);
+        }
+        catch (_a) {
+            throw new WebhookError("invalid webhook URL");
+        }
+        if (url.protocol !== "https:" &&
+            !(this.options.allowInsecureUrls && url.protocol === "http:")) {
+            throw new WebhookError("webhook URLs must use HTTPS");
+        }
+        try {
+            (0, net_1.assertPublicUrlShape)(url, this.policy());
+        }
+        catch (e) {
+            throw new WebhookError(`webhook URL not allowed: ${e.message}`);
+        }
+        const unknown = input.events.filter((e) => !events_1.WEBHOOK_EVENT_TYPES.includes(e));
+        const retired = unknown.filter((e) => events_1.RETIRED_EVENT_TYPES[e]);
+        if (retired.length)
+            throw new WebhookError(`retired event types: ${retired
+                .map((e) => `${e} (use ${events_1.RETIRED_EVENT_TYPES[e].join(" or ")})`)
+                .join(", ")}; the conversation's transcript and recording are in the call record`);
+        if (unknown.length)
+            throw new WebhookError(`unknown event types: ${unknown.join(", ")}`);
+        const endpoint = {
+            id: `whe_${(0, crypto_1.randomUUID)()}`,
+            workspaceRef: input.workspaceRef,
+            url: input.url,
+            events: input.events,
+            secret: `whsec_${(0, crypto_1.randomBytes)(24).toString("base64url")}`
+        };
+        this.options.store.putEndpoint(endpoint);
+        return endpoint;
+    }
+    /** New secret; the old one keeps verifying for `windowMs`. Returns the new secret. */
+    rotateSecret(endpointId, windowMs = 24 * 3600 * 1000) {
+        const e = this.options.store.endpoints().find((x) => x.id === endpointId);
+        if (!e)
+            throw new WebhookError(`no endpoint ${endpointId}`);
+        const secret = `whsec_${(0, crypto_1.randomBytes)(24).toString("base64url")}`;
+        this.options.store.putEndpoint(Object.assign(Object.assign({}, e), { secret, previousSecret: e.secret, previousUntil: this.now() + windowMs }));
+        return secret;
+    }
+    /** The deliveries an event makes, one per subscribed endpoint of its workspace (not stored). */
+    plan(event) {
+        return this.options.store
+            .endpoints(event.workspaceRef)
+            .filter((e) => e.events.includes(event.type))
+            .map((e) => ({
+            id: deliveryId(event.id, e.id),
+            endpointId: e.id,
+            event,
+            status: "pending",
+            attempts: 0,
+            nextAttemptAt: this.now()
+        }));
+    }
+    /** Fans an event out to every endpoint of its workspace subscribed to its type. */
+    publish(event) {
+        const deliveries = this.plan(event);
+        deliveries.forEach((d) => this.options.store.putDelivery(d));
+        return deliveries;
+    }
+    /** Attempts every pending delivery that is due; returns how many were attempted. */
+    runDue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const due = this.options.store
+                .deliveries()
+                .filter((d) => d.status === "pending" && d.nextAttemptAt <= this.now());
+            yield Promise.all(due.map((d) => this.attempt(d)));
+            return due.length;
+        });
+    }
+    /** Sends a delivery again now, with the original event id and a fresh signature. */
+    resend(deliveryId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const d = this.options.store.deliveries().find((x) => x.id === deliveryId);
+            if (!d)
+                throw new WebhookError(`no delivery ${deliveryId}`);
+            const again = Object.assign(Object.assign({}, d), { status: "pending", nextAttemptAt: this.now(), firstAttemptAt: this.now() });
+            this.options.store.putDelivery(again);
+            return this.attempt(again);
+        });
+    }
+    attempt(d) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
+            const endpoint = this.options.store
+                .endpoints()
+                .find((e) => e.id === d.endpointId);
+            if (!endpoint) {
+                const failed = Object.assign(Object.assign({}, d), { status: "failed" });
+                this.options.store.putDelivery(failed);
+                return failed;
+            }
+            const now = this.now();
+            const secrets = [endpoint.secret];
+            if (endpoint.previousSecret && ((_a = endpoint.previousUntil) !== null && _a !== void 0 ? _a : 0) > now)
+                secrets.push(endpoint.previousSecret);
+            const body = JSON.stringify(d.event);
+            let status = 0;
+            try {
+                // Checked again at delivery: DNS may have changed since the endpoint was created.
+                const res = yield (0, net_1.safeFetch)(endpoint.url, {
+                    method: "POST",
+                    headers: Object.assign({ "content-type": "application/json" }, (0, signing_1.webhookHeaders)(body, secrets, Math.floor(now / 1000))),
+                    body,
+                    timeoutMs: (_b = this.options.attemptTimeoutMs) !== null && _b !== void 0 ? _b : 10000,
+                    maxRedirects: 0,
+                    policy: this.policy()
+                });
+                status = res.status;
+                yield res.arrayBuffer().catch(() => undefined);
+            }
+            catch (_g) {
+                status = 0;
+            }
+            const attempts = d.attempts + 1;
+            const firstAttemptAt = (_c = d.firstAttemptAt) !== null && _c !== void 0 ? _c : now;
+            let next;
+            if (status >= 200 && status < 300) {
+                next = Object.assign(Object.assign({}, d), { status: "succeeded", attempts,
+                    firstAttemptAt, lastAttemptAt: now, lastStatus: status });
+            }
+            else {
+                const delay = Math.min(((_d = this.options.firstDelayMs) !== null && _d !== void 0 ? _d : 10000) * Math.pow(2, (attempts - 1)), (_e = this.options.maxDelayMs) !== null && _e !== void 0 ? _e : 3600000);
+                const giveUp = now + delay - firstAttemptAt >
+                    ((_f = this.options.retryPeriodMs) !== null && _f !== void 0 ? _f : 24 * 3600000);
+                next = Object.assign(Object.assign({}, d), { status: giveUp ? "failed" : "pending", attempts,
+                    firstAttemptAt, lastAttemptAt: now, lastStatus: status, nextAttemptAt: now + delay });
+            }
+            this.options.store.putDelivery(next);
+            return next;
+        });
+    }
+}
+exports.WebhookDispatcher = WebhookDispatcher;

package/dist/webhooks/bus.d.ts

@@ -0,0 +1,68 @@
+import { Delivery } from "./Dispatcher";
+import { WebhookEvent } from "./events";
+export declare const WEBHOOK_EVENTS_SUBJECT = "webhooks.events";
+/** The slice of a NATS connection the bus uses (so `@fonoster/common` needs no NATS client). */
+export type BusConnection = {
+    publish(subject: string, data: Uint8Array): void;
+    subscribe(subject: string, opts: {
+        queue?: string;
+        callback: (err: Error | null, msg: {
+            data: Uint8Array;
+        }) => void;
+    }): {
+        unsubscribe(): void;
+    };
+};
+/** A producer that publishes events on the bus instead of delivering them itself. */
+export declare function busWebhookPublisher(nc: Pick<BusConnection, "publish">): (event: WebhookEvent) => void;
+/** Parses a bus message; undefined for anything that is not a v1 webhook event. */
+export declare function parseBusEvent(data: Uint8Array): WebhookEvent | undefined;
+/** Where Roomr nodes publish a call's events (`roomr.events.<call_ref>`; room events have one more token). */
+export declare const ROOMR_CALL_EVENTS_SUBJECT = "roomr.events.*";
+/**
+ * The `call.failed` reasons an unanswered outbound call can end with (the node's `cause`); any
+ * other cause is reported as `node_error`.
+ */
+export declare const UNANSWERED_CALL_REASONS: readonly ["busy", "no_answer", "rejected", "removed", "node_error"];
+/** An outbound call the callee never answered, as its node's `call.ended` tells it. */
+export type UnansweredCall = {
+    callRef: string;
+    appRef: string;
+    from: string;
+    to: string;
+    reason: (typeof UNANSWERED_CALL_REASONS)[number];
+    sipStatus?: number;
+    nodeRef: string;
+};
+/**
+ * The unanswered outbound call a Roomr node's event on `subject` (`roomr.events.<call_ref>`)
+ * reports, or undefined: only a `call.ended` with `answered: false` of a call the control plane
+ * placed (its `metadata.app_ref`, passed through by the node) for the subject's own call. The
+ * parties come from the metadata the control plane set; the node never chooses the workspace
+ * (left for the fan-out to resolve from the app), the event type or extra data (M6).
+ */
+export declare function unansweredOutboundCall(subject: string, event: Record<string, unknown> | undefined): UnansweredCall | undefined;
+/**
+ * The `call.failed` event for an unanswered outbound call. Its id depends on the call only, so
+ * every replica that sees the node's `call.ended` builds the same event and each endpoint gets one
+ * delivery.
+ */
+export declare function unansweredCallFailed(call: UnansweredCall, now?: Date): WebhookEvent;
+export type FanoutOptions = {
+    /** Usually `WebhookDispatcher.publish`: stores one pending delivery per subscribed endpoint. */
+    publish(event: WebhookEvent): Delivery[];
+    /**
+     * The workspace of an app, for events whose producer did not know it (empty or `default`
+     * workspaceRef with a `data.appRef`).
+     */
+    workspaceOfApp?(appRef: string): Promise<string | undefined>;
+    /** Called after an event was fanned out (e.g. to attempt the new deliveries at once). */
+    onPublished?(event: WebhookEvent, deliveries: Delivery[]): void;
+    onError?(e: Error): void;
+    /** Queue group: one replica handles each event. */
+    queue?: string;
+};
+/** Fills in a missing workspace from the app; undefined when it cannot be known. */
+export declare function resolveWorkspace(event: WebhookEvent, workspaceOfApp?: FanoutOptions["workspaceOfApp"]): Promise<WebhookEvent | undefined>;
+/** Subscribes to the bus and fans every event out; returns the unsubscribe function. */
+export declare function subscribeWebhookFanout(nc: Pick<BusConnection, "subscribe">, options: FanoutOptions): () => void;

package/dist/webhooks/bus.js

@@ -0,0 +1,178 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNANSWERED_CALL_REASONS = exports.ROOMR_CALL_EVENTS_SUBJECT = exports.WEBHOOK_EVENTS_SUBJECT = void 0;
+exports.busWebhookPublisher = busWebhookPublisher;
+exports.parseBusEvent = parseBusEvent;
+exports.unansweredOutboundCall = unansweredOutboundCall;
+exports.unansweredCallFailed = unansweredCallFailed;
+exports.resolveWorkspace = resolveWorkspace;
+exports.subscribeWebhookFanout = subscribeWebhookFanout;
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const crypto_1 = require("crypto");
+const util_1 = require("util");
+const events_1 = require("./events");
+// Event fan-out from the event bus (add-workspace-webhooks task 2.2, build log LO-B1). Producers
+// that have no database (Roomr nodes, appbridges in bus mode, other regions) publish events on
+// `webhooks.events`; one control-plane replica per event (queue group) fans each event out to the
+// workspace's subscribed endpoints. A producer that does not know the workspace leaves
+// `workspaceRef` empty and the fan-out resolves it from `data.appRef`.
+//
+// Roomr nodes may not publish `webhooks.events` (M6: a node could otherwise forge any event for
+// any workspace). An outbound call that is never answered reaches no AppBridge; the control plane
+// builds its call.failed from the node's own `call.ended` on `roomr.events.<call_ref>`
+// (unansweredOutboundCall), with the workspace taken from the app and nothing else trusted.
+exports.WEBHOOK_EVENTS_SUBJECT = "webhooks.events";
+const encoder = new util_1.TextEncoder();
+const decoder = new util_1.TextDecoder();
+/** A producer that publishes events on the bus instead of delivering them itself. */
+function busWebhookPublisher(nc) {
+    return (event) => nc.publish(exports.WEBHOOK_EVENTS_SUBJECT, encoder.encode(JSON.stringify(event)));
+}
+/** Parses a bus message; undefined for anything that is not a v1 webhook event. */
+function parseBusEvent(data) {
+    let e;
+    try {
+        e = JSON.parse(decoder.decode(data));
+    }
+    catch (_a) {
+        return undefined;
+    }
+    if (!e ||
+        typeof e.id !== "string" ||
+        !/^evt_[\w-]+$/.test(e.id) ||
+        !events_1.WEBHOOK_EVENT_TYPES.includes(e.type) ||
+        typeof e.data !== "object" ||
+        e.data === null)
+        return undefined;
+    return e;
+}
+/** Where Roomr nodes publish a call's events (`roomr.events.<call_ref>`; room events have one more token). */
+exports.ROOMR_CALL_EVENTS_SUBJECT = "roomr.events.*";
+/**
+ * The `call.failed` reasons an unanswered outbound call can end with (the node's `cause`); any
+ * other cause is reported as `node_error`.
+ */
+exports.UNANSWERED_CALL_REASONS = [
+    "busy",
+    "no_answer",
+    "rejected",
+    "removed",
+    "node_error"
+];
+const MAX_FIELD = 256;
+const field = (v, required = false) => typeof v === "string" && v.length <= MAX_FIELD && (!required || v.length > 0)
+    ? v
+    : undefined;
+/**
+ * The unanswered outbound call a Roomr node's event on `subject` (`roomr.events.<call_ref>`)
+ * reports, or undefined: only a `call.ended` with `answered: false` of a call the control plane
+ * placed (its `metadata.app_ref`, passed through by the node) for the subject's own call. The
+ * parties come from the metadata the control plane set; the node never chooses the workspace
+ * (left for the fan-out to resolve from the app), the event type or extra data (M6).
+ */
+function unansweredOutboundCall(subject, event) {
+    var _a, _b, _c, _d;
+    const tokens = subject.split(".");
+    if (tokens.length !== 3 || tokens[0] !== "roomr" || tokens[1] !== "events")
+        return undefined;
+    if (!event || typeof event !== "object" || event.type !== "call.ended")
+        return undefined;
+    if (event.answered !== false)
+        return undefined;
+    const callRef = field(event.call_ref, true);
+    if (!callRef || callRef !== tokens[2])
+        return undefined;
+    const metadata = (event.metadata && typeof event.metadata === "object" ? event.metadata : {});
+    const appRef = field(metadata.app_ref, true);
+    if (!appRef)
+        return undefined;
+    const cause = String((_a = event.cause) !== null && _a !== void 0 ? _a : "");
+    const reason = exports.UNANSWERED_CALL_REASONS.includes(cause)
+        ? cause
+        : "node_error";
+    const sipStatus = Number(event.sip_status);
+    return Object.assign(Object.assign({ callRef,
+        appRef, from: (_b = field(metadata.from)) !== null && _b !== void 0 ? _b : "", to: (_c = field(metadata.to)) !== null && _c !== void 0 ? _c : "", reason }, (Number.isInteger(sipStatus) && sipStatus > 0 ? { sipStatus } : {})), { nodeRef: (_d = field(event.node_ref)) !== null && _d !== void 0 ? _d : "" });
+}
+/**
+ * The `call.failed` event for an unanswered outbound call. Its id depends on the call only, so
+ * every replica that sees the node's `call.ended` builds the same event and each endpoint gets one
+ * delivery.
+ */
+function unansweredCallFailed(call, now = new Date()) {
+    const event = (0, events_1.callFailed)("", {
+        callRef: call.callRef,
+        appRef: call.appRef,
+        from: call.from,
+        to: call.to,
+        direction: "outbound",
+        reason: call.reason
+    });
+    const digest = (0, crypto_1.createHash)("sha256")
+        .update(`call.failed\n${call.callRef}`)
+        .digest("hex")
+        .slice(0, 32);
+    return Object.assign(Object.assign({}, event), { id: `evt_node_${digest}`, createdAt: now.toISOString() });
+}
+/** Fills in a missing workspace from the app; undefined when it cannot be known. */
+function resolveWorkspace(event, workspaceOfApp) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (event.workspaceRef && event.workspaceRef !== "default")
+            return event;
+        const appRef = event.data.appRef;
+        if (typeof appRef !== "string" || !appRef || !workspaceOfApp)
+            return undefined;
+        const workspaceRef = yield workspaceOfApp(appRef);
+        return workspaceRef ? Object.assign(Object.assign({}, event), { workspaceRef }) : undefined;
+    });
+}
+/** Subscribes to the bus and fans every event out; returns the unsubscribe function. */
+function subscribeWebhookFanout(nc, options) {
+    var _a;
+    const sub = nc.subscribe(exports.WEBHOOK_EVENTS_SUBJECT, {
+        queue: (_a = options.queue) !== null && _a !== void 0 ? _a : "webhooks-fanout",
+        callback: (err, msg) => {
+            if (err)
+                return;
+            const event = parseBusEvent(msg.data);
+            if (!event)
+                return;
+            resolveWorkspace(event, options.workspaceOfApp)
+                .then((resolved) => {
+                var _a;
+                if (!resolved)
+                    return;
+                const deliveries = options.publish(resolved);
+                (_a = options.onPublished) === null || _a === void 0 ? void 0 : _a.call(options, resolved, deliveries);
+            })
+                .catch((e) => { var _a; return (_a = options.onError) === null || _a === void 0 ? void 0 : _a.call(options, e); });
+        }
+    });
+    return () => sub.unsubscribe();
+}