@fonoster/common 0.27.0 → 0.30.0

package/dist/telemetry.d.ts

@@ -0,0 +1,76 @@
+/**
+ * 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.
+ */
+/**
+ * OpenTelemetry bootstrap shared by the TypeScript services (add-platform, observability).
+ *
+ * Driven by the standard OTEL_* variables and a complete no-op when no OTLP endpoint is set:
+ * nothing is loaded, nothing is sent, and the service only writes its normal logs. Signals go
+ * over OTLP/HTTP with JSON bodies (collector port 4318) using only `@opentelemetry/api`,
+ * `sdk-trace-base`, `sdk-trace-node` and `resources`, so no exporter package is needed.
+ *
+ * Every call-scoped span, log record and metric carries `fonoster.call_ref`.
+ */
+export declare const CALL_REF_ATTR = "fonoster.call_ref";
+type Attrs = Record<string, string | number | boolean>;
+export interface CallSpan {
+    /** Adds a timeline event to the call's span. */
+    event(name: string, attrs?: Attrs): void;
+    /** Ends the span; `error` marks it failed. */
+    end(attrs?: Attrs, error?: string): void;
+}
+/** A span not tied to a call (a gRPC request, a registry command), optionally continuing a trace. */
+export interface Span extends CallSpan {
+    /** The W3C `traceparent` of this span, to send with outgoing messages ("" when disabled). */
+    traceparent: string;
+}
+/** NATS/gRPC header carrying the W3C trace context between services. */
+export declare const TRACEPARENT_HEADER = "traceparent";
+export interface Telemetry {
+    enabled: boolean;
+    /**
+     * Starts the span of one call; the returned handle is a no-op when disabled. `parent` (a W3C
+     * traceparent from another service, e.g. the media node) makes it a child in that trace.
+     */
+    startCall(callRef: string, name: string, attrs?: Attrs, parent?: string): CallSpan;
+    /**
+     * Starts a span; with `parent` (a W3C traceparent received from another service) it joins that
+     * trace. A no-op handle when disabled.
+     */
+    startSpan(name: string, attrs?: Attrs, parent?: string): Span;
+    /** The W3C traceparent of a call's span (to propagate over NATS), when one is active. */
+    traceparent(callRef: string): string | undefined;
+    /** An OTLP log record correlated by call ref (and the active trace, when any). */
+    log(level: "debug" | "info" | "warn" | "error", message: string, attrs?: Attrs & {
+        callRef?: string;
+    }): void;
+    /** Adds to a monotonic counter. */
+    count(name: string, value?: number, attrs?: Attrs): void;
+    /** Reads `fn` at every export and reports it as a gauge. */
+    gauge(name: string, fn: () => number, attrs?: Attrs): void;
+    /** Flushes and stops the exporters. */
+    shutdown(): Promise<void>;
+}
+/** True when any OTLP endpoint is configured and the SDK is not disabled. */
+export declare function telemetryEnabled(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Starts telemetry for one service. Safe to call once at startup; returns a no-op handle when no
+ * OTLP endpoint is configured or the OpenTelemetry packages are not installed.
+ */
+export declare function initTelemetry(service: string, instanceId?: string, env?: Record<string, string | undefined>): Telemetry;
+export {};

package/dist/telemetry.js

@@ -0,0 +1,360 @@
+"use strict";
+/**
+ * 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.
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-require-imports */
+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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRACEPARENT_HEADER = exports.CALL_REF_ATTR = void 0;
+exports.telemetryEnabled = telemetryEnabled;
+exports.initTelemetry = initTelemetry;
+/**
+ * OpenTelemetry bootstrap shared by the TypeScript services (add-platform, observability).
+ *
+ * Driven by the standard OTEL_* variables and a complete no-op when no OTLP endpoint is set:
+ * nothing is loaded, nothing is sent, and the service only writes its normal logs. Signals go
+ * over OTLP/HTTP with JSON bodies (collector port 4318) using only `@opentelemetry/api`,
+ * `sdk-trace-base`, `sdk-trace-node` and `resources`, so no exporter package is needed.
+ *
+ * Every call-scoped span, log record and metric carries `fonoster.call_ref`.
+ */
+exports.CALL_REF_ATTR = "fonoster.call_ref";
+/** NATS/gRPC header carrying the W3C trace context between services. */
+exports.TRACEPARENT_HEADER = "traceparent";
+const NOOP_SPAN = {
+    event: () => undefined,
+    end: () => undefined,
+    traceparent: ""
+};
+const NOOP = {
+    enabled: false,
+    startCall: () => NOOP_SPAN,
+    startSpan: () => NOOP_SPAN,
+    traceparent: () => undefined,
+    log: () => undefined,
+    count: () => undefined,
+    gauge: () => undefined,
+    shutdown: () => __awaiter(void 0, void 0, void 0, function* () { return undefined; })
+};
+/** True when any OTLP endpoint is configured and the SDK is not disabled. */
+function telemetryEnabled(env = process.env) {
+    if (env.OTEL_SDK_DISABLED === "true")
+        return false;
+    return [
+        "OTEL_EXPORTER_OTLP_ENDPOINT",
+        "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT",
+        "OTEL_EXPORTER_OTLP_METRICS_ENDPOINT",
+        "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT"
+    ].some((k) => !!env[k]);
+}
+function toValue(v) {
+    if (typeof v === "number")
+        return Number.isInteger(v) ? { intValue: String(v) } : { doubleValue: v };
+    if (typeof v === "boolean")
+        return { boolValue: v };
+    return { stringValue: String(v) };
+}
+function toAttrs(a = {}) {
+    return Object.entries(a)
+        .filter(([, v]) => v !== undefined && v !== null)
+        .map(([key, value]) => ({ key, value: toValue(value) }));
+}
+const hrToNano = (t) => (BigInt(t[0]) * BigInt(1000000000) + BigInt(t[1])).toString();
+function signalUrl(env, signal) {
+    const specific = env[`OTEL_EXPORTER_OTLP_${signal.toUpperCase()}_ENDPOINT`];
+    if (specific)
+        return specific;
+    const base = env.OTEL_EXPORTER_OTLP_ENDPOINT;
+    return base ? `${base.replace(/\/$/, "")}/v1/${signal}` : undefined;
+}
+function headers(env) {
+    var _a;
+    const h = { "content-type": "application/json" };
+    for (const pair of ((_a = env.OTEL_EXPORTER_OTLP_HEADERS) !== null && _a !== void 0 ? _a : "")
+        .split(",")
+        .filter(Boolean)) {
+        const i = pair.indexOf("=");
+        if (i > 0)
+            h[pair.slice(0, i).trim()] = pair.slice(i + 1).trim();
+    }
+    return h;
+}
+/**
+ * Starts telemetry for one service. Safe to call once at startup; returns a no-op handle when no
+ * OTLP endpoint is configured or the OpenTelemetry packages are not installed.
+ */
+function initTelemetry(service, instanceId, env) {
+    var _a, _b, _c;
+    if (instanceId === void 0) { instanceId = (_a = process.env.HOSTNAME) !== null && _a !== void 0 ? _a : String(process.pid); }
+    if (env === void 0) { env = process.env; }
+    if (!telemetryEnabled(env))
+        return NOOP;
+    let api, base, nodeSdk, resources;
+    try {
+        api = require("@opentelemetry/api");
+        base = require("@opentelemetry/sdk-trace-base");
+        nodeSdk = require("@opentelemetry/sdk-trace-node");
+        resources = require("@opentelemetry/resources");
+    }
+    catch (_d) {
+        return NOOP;
+    }
+    const resourceAttrs = {
+        "service.name": (_b = env.OTEL_SERVICE_NAME) !== null && _b !== void 0 ? _b : service,
+        "service.instance.id": instanceId
+    };
+    const resource = { attributes: toAttrs(resourceAttrs) };
+    const hdrs = headers(env);
+    const post = (url, body) => {
+        if (!url)
+            return Promise.resolve();
+        return fetch(url, {
+            method: "POST",
+            headers: hdrs,
+            body: JSON.stringify(body)
+        })
+            .then(() => undefined)
+            .catch(() => undefined);
+    };
+    // Traces
+    const tracesUrl = signalUrl(env, "traces");
+    const exporter = {
+        export(spans, done) {
+            const body = {
+                resourceSpans: [
+                    {
+                        resource,
+                        scopeSpans: [
+                            {
+                                scope: { name: "fonoster" },
+                                spans: spans.map((s) => {
+                                    var _a, _b;
+                                    return ({
+                                        traceId: s.spanContext().traceId,
+                                        spanId: s.spanContext().spanId,
+                                        parentSpanId: ((_a = s.parentSpanContext) === null || _a === void 0 ? void 0 : _a.spanId) || undefined,
+                                        name: s.name,
+                                        kind: 1 + ((_b = s.kind) !== null && _b !== void 0 ? _b : 0),
+                                        startTimeUnixNano: hrToNano(s.startTime),
+                                        endTimeUnixNano: hrToNano(s.endTime),
+                                        attributes: toAttrs(s.attributes),
+                                        events: s.events.map((e) => ({
+                                            name: e.name,
+                                            timeUnixNano: hrToNano(e.time),
+                                            attributes: toAttrs(e.attributes)
+                                        })),
+                                        status: s.status.code === 2
+                                            ? { code: 2, message: s.status.message }
+                                            : { code: s.status.code }
+                                    });
+                                })
+                            }
+                        ]
+                    }
+                ]
+            };
+            void post(tracesUrl, body).then(() => done({ code: 0 }));
+        },
+        shutdown: () => __awaiter(this, void 0, void 0, function* () { return undefined; })
+    };
+    const provider = new nodeSdk.NodeTracerProvider({
+        resource: resources.resourceFromAttributes(resourceAttrs),
+        spanProcessors: [new base.BatchSpanProcessor(exporter)]
+    });
+    provider.register();
+    // The provider's own tracer: the global one stays the first registered (tests init twice).
+    const tracer = provider.getTracer("fonoster");
+    // Logs
+    const logsUrl = signalUrl(env, "logs");
+    const logQueue = [];
+    const severity = { debug: 5, info: 9, warn: 13, error: 17 };
+    const flushLogs = () => {
+        if (!logQueue.length)
+            return Promise.resolve();
+        const records = logQueue.splice(0);
+        return post(logsUrl, {
+            resourceLogs: [
+                {
+                    resource,
+                    scopeLogs: [{ scope: { name: "fonoster" }, logRecords: records }]
+                }
+            ]
+        });
+    };
+    // Metrics
+    const metricsUrl = signalUrl(env, "metrics");
+    const startNs = (BigInt(Date.now()) * BigInt(1000000)).toString();
+    const counters = new Map();
+    const gauges = [];
+    const flushMetrics = () => {
+        const now = (BigInt(Date.now()) * BigInt(1000000)).toString();
+        const metrics = [];
+        for (const [name, series] of counters) {
+            metrics.push({
+                name,
+                sum: {
+                    aggregationTemporality: 2,
+                    isMonotonic: true,
+                    dataPoints: series.map((s) => ({
+                        asInt: String(s.value),
+                        startTimeUnixNano: startNs,
+                        timeUnixNano: now,
+                        attributes: toAttrs(s.attrs)
+                    }))
+                }
+            });
+        }
+        for (const g of gauges) {
+            let v = 0;
+            try {
+                v = g.fn();
+            }
+            catch (_a) {
+                continue;
+            }
+            metrics.push({
+                name: g.name,
+                gauge: {
+                    dataPoints: [
+                        { asDouble: v, timeUnixNano: now, attributes: toAttrs(g.attrs) }
+                    ]
+                }
+            });
+        }
+        if (!metrics.length)
+            return Promise.resolve();
+        return post(metricsUrl, {
+            resourceMetrics: [
+                {
+                    resource,
+                    scopeMetrics: [{ scope: { name: "fonoster" }, metrics }]
+                }
+            ]
+        });
+    };
+    const timer = setInterval(() => {
+        void flushLogs();
+        void flushMetrics();
+    }, Number((_c = env.OTEL_METRIC_EXPORT_INTERVAL) !== null && _c !== void 0 ? _c : 15000));
+    timer.unref();
+    const spanOf = new Map();
+    const contextOf = (parent) => parent
+        ? api.propagation.extract(api.context.active(), {
+            [exports.TRACEPARENT_HEADER]: parent
+        })
+        : api.context.active();
+    const traceparentOf = (span) => {
+        var _a;
+        const carrier = {};
+        api.propagation.inject(api.trace.setSpan(api.context.active(), span), carrier);
+        return (_a = carrier[exports.TRACEPARENT_HEADER]) !== null && _a !== void 0 ? _a : "";
+    };
+    return {
+        enabled: true,
+        startSpan(name, attrs, parent) {
+            const span = tracer.startSpan(name, { attributes: attrs }, contextOf(parent));
+            return {
+                traceparent: traceparentOf(span),
+                event: (n, a) => span.addEvent(n, a),
+                end: (a, error) => {
+                    if (a)
+                        span.setAttributes(a);
+                    if (error)
+                        span.setStatus({ code: 2, message: error });
+                    span.end();
+                }
+            };
+        },
+        traceparent(callRef) {
+            const span = spanOf.get(callRef);
+            return span ? traceparentOf(span) : undefined;
+        },
+        startCall(callRef, name, attrs, parent) {
+            const span = tracer.startSpan(name, { attributes: Object.assign({ [exports.CALL_REF_ATTR]: callRef }, attrs) }, contextOf(parent));
+            spanOf.set(callRef, span);
+            return {
+                event: (n, a) => span.addEvent(n, Object.assign({ [exports.CALL_REF_ATTR]: callRef }, a)),
+                end: (a, error) => {
+                    if (a)
+                        span.setAttributes(a);
+                    if (error)
+                        span.setStatus({ code: 2, message: error });
+                    span.end();
+                    spanOf.delete(callRef);
+                }
+            };
+        },
+        log(level, message, attrs = {}) {
+            var _a, _b, _c;
+            const { callRef } = attrs, rest = __rest(attrs, ["callRef"]);
+            const span = callRef ? spanOf.get(callRef) : undefined;
+            const ctx = (_b = (_a = span === null || span === void 0 ? void 0 : span.spanContext) === null || _a === void 0 ? void 0 : _a.call(span)) !== null && _b !== void 0 ? _b : (_c = api.trace.getActiveSpan()) === null || _c === void 0 ? void 0 : _c.spanContext();
+            logQueue.push({
+                timeUnixNano: (BigInt(Date.now()) * BigInt(1000000)).toString(),
+                severityNumber: severity[level],
+                severityText: level.toUpperCase(),
+                body: { stringValue: message },
+                attributes: toAttrs(callRef ? Object.assign({ [exports.CALL_REF_ATTR]: callRef }, rest) : rest),
+                traceId: ctx === null || ctx === void 0 ? void 0 : ctx.traceId,
+                spanId: ctx === null || ctx === void 0 ? void 0 : ctx.spanId
+            });
+            if (logQueue.length >= 100)
+                void flushLogs();
+        },
+        count(name, value = 1, attrs = {}) {
+            var _a;
+            const series = (_a = counters.get(name)) !== null && _a !== void 0 ? _a : [];
+            const key = JSON.stringify(attrs);
+            const hit = series.find((s) => JSON.stringify(s.attrs) === key);
+            if (hit)
+                hit.value += value;
+            else
+                series.push({ attrs, value });
+            counters.set(name, series);
+        },
+        gauge(name, fn, attrs) {
+            gauges.push({ name, fn, attrs });
+        },
+        shutdown() {
+            return __awaiter(this, void 0, void 0, function* () {
+                clearInterval(timer);
+                yield provider.shutdown().catch(() => undefined);
+                yield Promise.all([flushLogs(), flushMetrics()]);
+            });
+        }
+    };
+}

package/dist/types.d.ts

@@ -19,9 +19,7 @@
 type NumberPreconditionsCheck = (request: {
     appRef?: string;
     agentAor?: string;
+    /** The caller's workspace: an appRef must belong to it (RV-B4). */
+    accessKeyId?: string;
 }) => Promise<void>;
-type IntegrationConfig = {
-    productRef: string;
-    credentials: Record<string, unknown>;
-};
-export { NumberPreconditionsCheck, IntegrationConfig };
+export { NumberPreconditionsCheck };

package/dist/utils/{findIntegrationsCredentials.js → WriteBehind.d.ts}

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findIntegrationsCredentials = findIntegrationsCredentials;
 /**
  * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
  * http://github.com/fonoster/fonoster
@@ -19,11 +16,17 @@ exports.findIntegrationsCredentials = findIntegrationsCredentials;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-function findIntegrationsCredentials(integrations, engine) {
-    var _a;
-    const integration = (_a = integrations.find((i) => i.productRef === engine)) === null || _a === void 0 ? void 0 : _a.credentials;
-    if (!integration) {
-        throw new Error(`Integration ${engine} not found`);
-    }
-    return integration;
+/**
+ * Runs database writes one after another, in the order they were queued, behind a synchronous
+ * store interface (the registry and webhook stores are synchronous; see P-B1 in
+ * add-provider-registry/build-log.md). `flush()` waits for every queued write and throws the
+ * first failure.
+ */
+export declare class WriteBehind {
+    private readonly onError?;
+    private tail;
+    private failure?;
+    constructor(onError?: (e: unknown) => void);
+    push(write: () => Promise<unknown>): void;
+    flush(): Promise<void>;
 }

package/dist/utils/WriteBehind.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * 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.
+ */
+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.WriteBehind = void 0;
+/**
+ * Runs database writes one after another, in the order they were queued, behind a synchronous
+ * store interface (the registry and webhook stores are synchronous; see P-B1 in
+ * add-provider-registry/build-log.md). `flush()` waits for every queued write and throws the
+ * first failure.
+ */
+class WriteBehind {
+    constructor(onError) {
+        this.onError = onError;
+        this.tail = Promise.resolve();
+    }
+    push(write) {
+        this.tail = this.tail.then(() => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                yield write();
+            }
+            catch (e) {
+                (_a = this.failure) !== null && _a !== void 0 ? _a : (this.failure = e);
+                (_b = this.onError) === null || _b === void 0 ? void 0 : _b.call(this, e);
+            }
+        }));
+    }
+    flush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.tail;
+            const failure = this.failure;
+            this.failure = undefined;
+            if (failure)
+                throw failure;
+        });
+    }
+}
+exports.WriteBehind = WriteBehind;

package/dist/utils/index.d.ts

@@ -29,5 +29,5 @@ export * from "./withErrorHandlingAndValidation";
 export * from "./withValidation";
 export * from "./types";
 export * from "./createFetchSingleCallByCallId";
-export * from "./findIntegrationsCredentials";
 export * from "./sendHttpRequest";
+export * from "./logUnhandledRejections";

package/dist/utils/index.js

@@ -45,5 +45,5 @@ __exportStar(require("./withErrorHandlingAndValidation"), exports);
 __exportStar(require("./withValidation"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./createFetchSingleCallByCallId"), exports);
-__exportStar(require("./findIntegrationsCredentials"), exports);
 __exportStar(require("./sendHttpRequest"), exports);
+__exportStar(require("./logUnhandledRejections"), exports);

package/dist/{voice/Play.d.ts → utils/logUnhandledRejections.d.ts}

@@ -16,15 +16,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { VerbRequest } from "./Verb";
-type PlayOptions = {
-    playbackRef?: string;
-};
-type PlayRequest = VerbRequest & {
-    url: string;
-} & PlayOptions;
-type PlayResponse = {
-    mediaSessionRef: string;
-    playbackRef: string;
-};
-export { PlayOptions, PlayRequest, PlayResponse };
+/**
+ * Keeps a service up when a promise somewhere rejects without a handler (RV-B5): the reason is
+ * logged and the process keeps serving, instead of Node's default of exiting. Install once in a
+ * service's main.
+ */
+export declare function logUnhandledRejections(logger: {
+    error: (message: string, meta?: Record<string, unknown>) => unknown;
+}): () => NodeJS.Process;

package/dist/utils/logUnhandledRejections.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logUnhandledRejections = logUnhandledRejections;
+/**
+ * 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.
+ */
+/**
+ * Keeps a service up when a promise somewhere rejects without a handler (RV-B5): the reason is
+ * logged and the process keeps serving, instead of Node's default of exiting. Install once in a
+ * service's main.
+ */
+function logUnhandledRejections(logger) {
+    const handler = (reason) => {
+        var _a;
+        const e = reason;
+        logger.error(`unhandled rejection: ${(_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : String(reason)}`, {
+            stack: e === null || e === void 0 ? void 0 : e.stack
+        });
+    };
+    process.on("unhandledRejection", handler);
+    return () => process.off("unhandledRejection", handler);
+}

package/dist/validators/calls.d.ts

@@ -27,14 +27,14 @@ declare const createCallRequestSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     timeout?: number;
     metadata?: Record<string, any>;
-    to?: string;
     from?: string;
+    to?: string;
     appRef?: string;
 }, {
     timeout?: number;
     metadata?: Record<string, any>;
-    to?: string;
     from?: string;
+    to?: string;
     appRef?: string;
 }>;
 declare const getCallRequestSchema: z.ZodObject<{

package/dist/validators/calls.js

@@ -22,9 +22,12 @@ exports.listCallsRequestSchema = exports.getCallRequestSchema = exports.createCa
 const types_1 = require("@fonoster/types");
 const zod_1 = require("zod");
 const messages_1 = require("../messages");
+const sip_1 = require("./sip");
+// `from` is one of the workspace's Numbers (the Calls service checks ownership); it travels as
+// X-Dod-Number and picks the trunk, so it is an E.164 number. `to` is what the media node dials.
 const createCallRequestSchema = zod_1.z.object({
-    from: zod_1.z.string(),
-    to: zod_1.z.string(),
+    from: sip_1.e164Schema,
+    to: sip_1.sipTargetSchema,
     appRef: zod_1.z.string().uuid({ message: "Invalid call reference" }),
     timeout: zod_1.z
         .number()