@opencxh/domain 1.170.0 → 1.172.1

package/dist/platform/api.d.ts

@@ -18,7 +18,9 @@ export interface InvokeOptions {
      * mutatie liep gewoon door — de composer maakte zichzelf leeg en de gebruiker dacht dat
      * het bericht verstuurd was. Elke `error:`-handler in de app was daarmee dode code.
      *
-     * Voorlopig opt-in zodat apps één voor één om kunnen; comms gaat als eerste.
+     * **Dit staat sinds 2026-08-20 aan als default.** Zet hem op `false` om één aanroep
+     * bewust stil te houden — dat is dan een keuze die in de code staat, niet de
+     * standaardstand waar iedereen in loopt.
      */
     throwOnError?: boolean;
 }

package/dist/platform/call-lines.d.ts

@@ -0,0 +1,74 @@
+import { SessionState } from './communication';
+/**
+ * Multi-line rules: which calls step aside when a new one takes the line.
+ *
+ * Kept pure and provider-agnostic because "one call has your ear at a time" is a
+ * platform rule, not a SIP rule. A phone with two live calls is a bug in any
+ * transport, and the answer must not live inside one provider's `invite`.
+ */
+/** The part of a `Session` this decision needs. */
+export interface LineSession {
+    id: string;
+    providerId: string;
+    state: SessionState;
+}
+export interface HoldOthersInput<T extends LineSession> {
+    sessions: T[];
+    /** The call taking the line — itself never held. */
+    exceptSessionId?: string;
+    /** Whether that provider actually carries out `session.hold`. */
+    canHold: (providerId: string) => boolean;
+}
+/**
+ * The calls to put on hold before a new one takes the line.
+ *
+ * Only `connected` calls qualify, and that is a substantive rule rather than a
+ * filter for tidiness:
+ *  - `ringing` / `connecting` has no established dialog, so a re-INVITE (SIP) has
+ *    nothing to renegotiate — holding it would throw, not hold.
+ *  - `on_hold` is already where we want it; re-holding it would send a needless
+ *    re-INVITE and, worse, unhold-all later would have no way to tell which calls
+ *    the user had parked themselves.
+ *  - `ended` / `failed` / `idle` have no media to step aside.
+ *
+ * Sessions from a provider that does not carry out hold are left out entirely:
+ * dispatching hold at a provider whose `dispatch` has no case for it returns
+ * quietly, and we would then show a call as parked while the caller can still
+ * hear the room.
+ */
+export declare function sessionsToHold<T extends LineSession>(input: HoldOthersInput<T>): T[];
+/**
+ * Calls that a new line will leave live because their provider cannot hold.
+ *
+ * Split out from `sessionsToHold` so the caller can say so out loud instead of
+ * quietly ending up with two live calls — the situation that started this.
+ */
+export declare function sessionsHoldCannotReach<T extends LineSession>(input: HoldOthersInput<T>): T[];
+/** Whether an incoming call may ring, and if not, what to tell the caller. */
+export type IncomingCallDecision = {
+    admit: true;
+} | {
+    admit: false;
+    reason: "busy";
+};
+/**
+ * Whether an incoming call may ring while the user already has a call.
+ *
+ * **"In gesprek" means an established call — `connected` or `on_hold`.** Both of
+ * those are a conversation you are in: a parked caller is still yours, and taking
+ * a new call means abandoning them. `connecting` and `ringing` are deliberately
+ * *not* busy, for two reasons. A call that is merely ringing is not yet a
+ * conversation, so rejecting on it would turn two near-simultaneous inbound calls
+ * into one — a queue decision that is not ours to make. And it keeps the blast
+ * radius small: were `ringing` to count, a single session that failed to clean up
+ * would silently reject every inbound call from then on.
+ *
+ * The caller gets a real busy answer rather than silence, so the PBX can roll the
+ * call to the next agent or to voicemail — see the provider that maps this to a
+ * SIP status code.
+ */
+export declare function decideIncomingCall<T extends LineSession>(input: {
+    sessions: T[];
+    /** The incoming call itself, when the provider already created a session. */
+    exceptSessionId?: string;
+}): IncomingCallDecision;

package/dist/platform/call-lines.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/platform/communication.d.ts

@@ -53,6 +53,20 @@ export interface CommsAccount<T = any> {
 }
 export interface ITransportProvider {
     readonly id: string;
+    /**
+     * The ops this provider actually carries out, when it wants to say so.
+     *
+     * `dispatch` is a switch, so an op it has no case for returns quietly — the
+     * caller cannot tell "done" from "ignored". That is fine for a button the
+     * provider's own action tray never draws, but not for something the platform
+     * does on the user's behalf: auto-holding the previous call at a provider
+     * without hold would park a call that stays live.
+     *
+     * Undeclared means unknown, and unknown is tried anyway — that is the
+     * behaviour every provider had before this field existed. Declare it to be
+     * skipped rather than silently no-op'd.
+     */
+    readonly supportedOps?: readonly TransportOpKind[];
     subscribeSessions(callback: (sessions: Session[]) => void): () => void;
     subscribeAccounts(callback: (accounts: CommsAccount[]) => void): () => void;
     subscribeStreams(callback: (data: RemoteStreamEvent) => void): () => void;
@@ -685,6 +699,8 @@ export declare const UNSUPPORTED: ServerResult;
  * door de frontend via `ITransportProvider.dispatch`. Geen server-
  * roundtrip — directe controle over de lokale stack.
  */
+/** The `kind` of a {@link TransportOp} — what a provider declares support for. */
+export type TransportOpKind = TransportOp["kind"];
 export type TransportOp = {
     kind: "session.invite";
     accountId: string;

package/dist/platform/provider.d.ts

@@ -1,18 +1,6 @@
 import { Interaction } from '../entities/interaction';
 import { Uri } from './communication';
 import { TranscriptSegment } from './media';
-export interface ProviderTranscribeRequest {
-    file: Float32Array;
-    filename: string;
-    mimeType: string;
-    accountId?: string;
-    /**
-     * Vraag segment-niveau output op (timestamps/woorden per segment). Default false:
-     * dan komt alleen `text` terug. Aan = provider levert ook `segments` als de
-     * onderliggende STT-dienst dat ondersteunt.
-     */
-    segments?: boolean;
-}
 export interface ProviderTranscribeResponse {
     /** Volledige transcript-tekst (altijd aanwezig, backwards compatible). */
     text: string;
@@ -52,11 +40,6 @@ export interface ComposePayload {
      */
     extra?: Record<string, any>;
 }
-export interface ComposeResponse {
-    messageId: string;
-    type: string;
-    payload: any;
-}
 export interface UpsertByExternalProviderIdPayload {
     providerId: string;
     externalIds: string[];
@@ -71,14 +54,6 @@ export interface SttSettings {
     providerId: string;
     providerAccountId?: string;
 }
-export interface TtsSettings {
-    providerId: string;
-    providerAccountId?: string;
-}
-export interface LlmSettings {
-    providerId: string;
-    providerAccountId?: string;
-}
 export interface FindByAddressPayload {
     addressUri: {
         scheme: string;
@@ -99,28 +74,6 @@ export interface FindActivityByExternalProviderIdPayload {
  * corresponding provider via these payloads.
  */
 export type ScheduleResponse = "accepted" | "declined" | "tentative";
-export interface SchedulePayload {
-    channelId: string;
-    /** Local CalendarEvent without storage-managed fields. */
-    event: any;
-}
-export interface ScheduleUpdatePayload {
-    channelId: string;
-    externalId: string;
-    patch: any;
-}
-export interface ScheduleCancelPayload {
-    channelId: string;
-    externalId: string;
-    comment?: string;
-}
-export interface ScheduleRespondPayload {
-    channelId: string;
-    externalId: string;
-    response: ScheduleResponse;
-    comment?: string;
-    sendResponse?: boolean;
-}
 export interface ScheduleResult {
     externalId?: string;
     /** Provider-side echo for caller persistence (e.g. Graph event id). */
@@ -142,9 +95,6 @@ export interface FileGetPayload {
     filename: string;
     path?: string;
 }
-export interface FileGetResponse {
-    file: Uint8Array;
-}
 export interface FileDeletePayload {
     accountId?: string;
     filename: string;
@@ -153,28 +103,17 @@ export interface FileDeletePayload {
 export interface FileDeleteResponse {
     success: boolean;
 }
-export interface FileListPayload {
-    accountId?: string;
-    path?: string;
-}
 export interface File {
     name: string;
     size: number;
     lastModified: number;
     type: string;
 }
-export interface FileListResponse {
-    files: File[];
-}
 export interface FolderCreatePayload {
     accountId?: string;
     name: string;
     path?: string;
 }
-export interface FolderCreateResponse {
-    success: boolean;
-    url: string;
-}
 export interface ListFilesPayload {
     mimeType?: string;
     name?: string;

package/dist/platform/scope.d.ts

@@ -1,4 +1,4 @@
-import { OwnerScope } from '../entities/contact/types';
+import { OwnerScope } from '../entities/scope/types';
 import { ActingIdentity } from './identity';
 /** Access decision + whether the scope anchor is team-shared + the SSE audience. */
 export interface ScopeAuth {

package/dist/platform/settings.d.ts

@@ -1,4 +1,3 @@
-import { Observable } from 'rxjs';
 export interface UserSettings {
     audio: {
         selectedMicrophone: string;
@@ -30,16 +29,3 @@ export interface DeviceList {
     input: MediaDeviceInfo[];
     output: MediaDeviceInfo[];
 }
-export interface ISettingsManager {
-    readonly settings$: Observable<UserSettings>;
-    get(): UserSettings;
-    update(partial: DeepPartial<UserSettings>): void;
-    getIceServers(): RTCIceServer[];
-    getAudioInputDeviceId(): string;
-    setAudioInputDeviceId(deviceId: string): void;
-    getAudioOutputDeviceId(): string;
-    setAudioOutputDeviceId(deviceId: string): void;
-    getVideoDeviceId(): string;
-    setVideoDeviceId(deviceId: string): void;
-    setIceServers(servers: RTCIceServer[]): void;
-}

package/dist/platform/storage.d.ts

@@ -1,4 +1,4 @@
-import { OwnerScope } from '../entities/contact/types';
+import { OwnerScope } from '../entities/scope/types';
 /**
  * A virtual folder: a named, scoped root that binds to a storage backend
  * (a StorageAccount on a storage provider) at a base path. Its `ownerScope`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencxh/domain",
-  "version": "1.170.0",
+  "version": "1.172.1",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -24,9 +24,6 @@
     "test:run": "vitest run",
     "test:watch": "vitest --watch"
   },
-  "peerDependencies": {
-    "rxjs": "^7.8.2"
-  },
   "devDependencies": {
     "typescript": "6.0.3",
     "vite": "7.1.7",

package/dist/entities/note/types.d.ts

@@ -1,14 +0,0 @@
-/**
- * Data model for a single Note.
- */
-export interface Note {
-    id: string;
-    organizationId: string;
-    interactionId: string;
-    serviceName: string;
-    authorId: string;
-    authorDisplayName: string;
-    content: string;
-    createdAt: Date;
-    updatedAt: Date;
-}

package/dist/entities/shopify/index.d.ts

@@ -1 +0,0 @@
-export * from './types';

package/dist/entities/shopify/types.d.ts

@@ -1,79 +0,0 @@
-/**
- * Shopify DTO's — gedeeld tussen de shopify-server (mapping uit Admin API),
- * platform-api (typed client) en de frontend-tool. Geen Shopify-SDK-types
- * lekken naar consumers; dit is de smalle, stabiele contractlaag.
- */
-export interface ShopifyCustomer {
-    id: string;
-    firstName?: string;
-    lastName?: string;
-    email?: string;
-    phone?: string;
-    ordersCount?: number;
-    totalSpent?: string;
-    currency?: string;
-    /** Klant sinds — ISO-datum uit Shopify. */
-    createdAt?: string;
-    /** Shopify-klantlabels ("wholesale", "net-30"): segment, betaaltermijn, wat de shop erin zet. */
-    tags?: string[];
-    defaultAddress?: ShopifyAddress;
-}
-export interface ShopifyLineItem {
-    title: string;
-    variantTitle?: string;
-    quantity: number;
-    price: string;
-}
-export interface ShopifyTracking {
-    company?: string;
-    number?: string;
-    url?: string;
-}
-export interface ShopifyAddress {
-    name?: string;
-    address1?: string;
-    address2?: string;
-    zip?: string;
-    city?: string;
-    province?: string;
-    country?: string;
-    phone?: string;
-}
-export interface ShopifyOrder {
-    id: string;
-    /** Human order-name, bv. "#1001". */
-    name: string;
-    createdAt: string;
-    financialStatus?: string;
-    fulfillmentStatus?: string;
-    totalPrice: string;
-    /** Opsplitsing van het totaal. Optioneel: oudere orders leveren niet elk veld. */
-    subtotalPrice?: string;
-    totalShipping?: string;
-    totalTax?: string;
-    currency: string;
-    lineItems: ShopifyLineItem[];
-    shippingAddress?: ShopifyAddress;
-    tracking: ShopifyTracking[];
-    note?: string;
-    /** Deep-link naar de order in de Shopify-admin (nieuw tabblad). */
-    adminUrl: string;
-}
-export interface ShopifyOrderEvent {
-    id: string;
-    createdAt: string;
-    /** Mensvriendelijke omschrijving van het event. */
-    message: string;
-    /** Shopify "verb" (bv. "confirmed", "fulfilled", "sale"). */
-    verb?: string;
-}
-export interface ShopifyLookupResult {
-    /** False = geen verbonden/enabled shop voor deze org (admin moet koppelen). */
-    connected: boolean;
-    /** De shop waar dit uit komt, bv. "leufgens-shop.myshopify.com". */
-    shopDomain?: string;
-    customer: ShopifyCustomer | null;
-    /** Deep-link naar de klant in de Shopify-admin. */
-    customerAdminUrl?: string;
-    orders: ShopifyOrder[];
-}

package/dist/platform/lifecycle.d.ts

@@ -1,13 +0,0 @@
-export interface AppLifecycle {
-    /** * On-load: Registreer services, menu-items en andere metadata.
-     * Wordt éénmalig uitgevoerd bij het laden van de JS.
-     */
-    setup: () => void;
-    /** * On-mount: Render de UI in de meegeleverde container.
-     * Wordt uitgevoerd wanneer de gebruiker naar de app navigeert.
-     */
-    mount: (container: HTMLElement, props?: any) => void;
-    /** * On-unmount: Ruim eventuele listeners of DOM-elementen op.
-     */
-    unmount: (container: HTMLElement) => void;
-}

package/dist/platform/reactive.d.ts

@@ -1,13 +0,0 @@
-export interface Subscriber<T> {
-    next: (value?: T) => void;
-    error?: (err: any) => void;
-    complete?: () => void;
-}
-export interface Observable<T> {
-    subscribe(subscriber: Subscriber<T>): () => void;
-}
-export interface Result<T> {
-    success: boolean;
-    value?: T;
-    error?: any;
-}

package/dist/platform/sdk.d.ts

@@ -1,172 +0,0 @@
-import { Observable } from 'rxjs';
-import { InvokeOptions, SSEMessage } from './api';
-import { CommsAccount, Session } from './communication';
-import { PlatformConfig, PlatformContext } from './kernel';
-import { AudioPipelineOptions, AudioSegment, MediaPermissionKind, MediaPermissionState, MediaPermissionStatus, TranscriptSegment } from './media';
-import { ServiceCallOptions, ServiceMap } from './services';
-import { DeepPartial, DeviceList, UserSettings } from './settings';
-import { ExtensionConfig, ToastConfig } from './ui';
-type ServiceKey<S extends ServiceMap> = keyof S;
-export type ParamsOf<S extends ServiceMap, K extends ServiceKey<S>> = S[K]['params'];
-export type PayloadOf<S extends ServiceMap, K extends ServiceKey<S>> = S[K]['payload'];
-export type ResponseOf<S extends ServiceMap, K extends ServiceKey<S>> = S[K]['response'];
-export type SSEHandlerOf<S extends ServiceMap, K extends ServiceKey<S>> = (payload: SSEMessage<PayloadOf<S, K>>) => Promise<void>;
-export interface InternalSDK<LocalServices extends ServiceMap = {}, TranslationKeys extends string = string, ModalKeys extends string = string, ExtensionKeys extends string = string> {
-    readonly context: PlatformContext;
-    readonly config: PlatformConfig;
-    readonly services: {
-        execute<K extends ServiceKey<LocalServices>>(key: K, options: ServiceCallOptions<ParamsOf<LocalServices, K>, PayloadOf<LocalServices, K>>): Promise<ResponseOf<LocalServices, K>>;
-        observe<K extends ServiceKey<LocalServices>>(key: K, options: ServiceCallOptions<ParamsOf<LocalServices, K>, PayloadOf<LocalServices, K>>): Observable<ResponseOf<LocalServices, K>>;
-    };
-    readonly http: {
-        invoke<R = any>(options: InvokeOptions): Promise<R>;
-    };
-    readonly router: {
-        /** Relative to the app's own `/apps/{appName}` prefix. */
-        navigate(path: string, options?: any): void;
-        /**
-         * Straight to a shell path, no prefix.
-         *
-         * For the app's `public: true` routes: those hang off the manifest's
-         * `publicBasePath` (`/help/…`), so the app prefix would point at a page
-         * that does not exist.
-         */
-        navigateAbsolute(path: string, options?: any): void;
-        /**
-         * Terug naar de vorige pagina — de echte, inclusief die van een andere app.
-         *
-         * Waarom dit hier hoort en niet per app: elk detailscherm heeft een terugknop, en zonder
-         * gedeelde vorm wordt dat overal een vaste route ("terug" = altijd de lijst) die liegt zodra
-         * je van een bord of uit een gesprek komt.
-         *
-         * `fallback` is app-relatief, net als {@link navigate}, en geldt alleen als er geen vorige
-         * pagina ín deze sessie is — dat is precies het geval bij een koud geopende deeplink. Geef je
-         * er geen, dan gebeurt er niets: uit het product lopen is geen taak van een terugknop.
-         */
-        back(fallback?: string): void;
-        /** Is er een vorige pagina in deze sessie? Voor een knop die zichzelf wil verbergen. */
-        canGoBack(): boolean;
-        currentPath(): string;
-        path$: Observable<string>;
-    };
-    readonly resources: {
-        get<T = any>(appName: string, resourceKey: string): Promise<T>;
-    };
-    readonly localization: {
-        /**
-         * Vertaal een sleutel.
-         *
-         * Zonder `:` is het een sleutel van deze app zelf. Mét `:` is hij al genamespaced
-         * (`"helpdesk:ticket.added.text"`) en wordt hij ongewijzigd opgezocht — nodig om tekst
-         * te tonen die een andere app meestuurde bij iets wat wij renderen.
-         */
-        t(key: TranslationKeys | `${string}:${string}`, params?: Record<string, any>): string;
-        /**
-         * De actieve taal ("nl" | "en").
-         *
-         * Nodig zodra een app zélf iets moet opmaken in plaats van een sleutel op te
-         * zoeken: `Intl.ListFormat` voor een opsomming, `toLocaleTimeString` voor een
-         * tijd. Zonder dit viel dat terug op `navigator.language`, die niet meebeweegt
-         * als de gebruiker de taal in de app omzet.
-         */
-        readonly currentLocale: string;
-    };
-    readonly ui: {
-        modals: {
-            open(key: ModalKeys, props?: any): void;
-            close(key: ModalKeys): void;
-        };
-        docks: {
-            open(key: string, props?: any): void;
-            close(key: string): void;
-            minimize(key: string, minimized?: boolean): void;
-            expand(key: string, expanded?: boolean): void;
-        };
-        settings: {
-            open(initialPageId?: string): void;
-            close(): void;
-        };
-        toasts: {
-            show(config: ToastConfig): void;
-            close(id: string): void;
-        };
-        extensions: {
-            getForSlot(slot: string): Observable<ExtensionConfig[]>;
-        };
-    };
-    readonly communication: {
-        sessions$: Observable<Session[]>;
-        accounts$: Observable<CommsAccount[]>;
-        activeSession$: Observable<Session | null>;
-        /**
-         * Routeert een TransportOp naar de provider die de gegeven session bezit.
-         * Vervangt de losse hangupSession/handleSessionAction APIs.
-         */
-        dispatchSessionOp(sessionId: string, op: import('./communication').TransportOp): Promise<void>;
-        /**
-         * Initieert een nieuwe outbound sessie via `session.invite`. Sugar
-         * voor `dispatchSessionOp` op het juiste provider; sessieId bestaat
-         * pas na invite.
-         */
-        invite(target: string, accountId: string): Promise<void>;
-        interceptStream(sessionId: string, callback: (stream: MediaStream) => void): Promise<() => void>;
-        setActiveSession(sessionId: string): Promise<void>;
-        registerAccount(organizationId: string, userId: string, providerId: string, config: any): Promise<CommsAccount>;
-        transcripts: {
-            ingest(segments: TranscriptSegment[]): void;
-            byCallSession$(sessionId: string): Observable<TranscriptSegment[]>;
-            deltas$(sessionId: string): Observable<TranscriptSegment[]>;
-            partials$(sessionId: string): Observable<TranscriptSegment>;
-            persist(sessionId: string): Promise<void>;
-            clear(sessionId: string): void;
-            /**
-             * `opts.from` is de index waar `segments` in het transcript begint: `0` is het hele
-             * transcript, hoger maakt het een delta op wat de ontvanger al heeft. Zonder dat stuurde
-             * elke flush (elke ~3s) de complete array opnieuw.
-             */
-            setPersister(fn: (sessionId: string, segments: TranscriptSegment[], opts: {
-                finalize: boolean;
-                from: number;
-            }) => Promise<void>): void;
-        };
-    };
-    readonly media: {
-        localStream$: Observable<MediaStream | null>;
-        audioSegments$: Observable<AudioSegment>;
-        devices$: Observable<DeviceList>;
-        permissions$: Observable<MediaPermissionStatus>;
-        emitAudioSegment(segment: AudioSegment): void;
-        configureAudioPipeline(opts: Partial<AudioPipelineOptions>): void;
-        setAudioPipelineEnabled(enabled: boolean): void;
-        setSessionAudioEnabled(sessionId: string, enabled: boolean): void;
-        isSessionAudioPaused(sessionId: string): boolean;
-        setInputDevice(deviceId: string): Promise<void>;
-        acquireMicStream(deviceId?: string): Promise<MediaStream>;
-        deviceChanges$: Observable<string>;
-        toggleMute(mute?: boolean): void;
-        attachProviderStream(sessionId: string, stream: MediaStream): void;
-        detachStream(sessionId: string): void;
-        setAudioOutput(deviceId: string): Promise<void>;
-        getInputDevices(): MediaDeviceInfo[];
-        getOutputDevices(): MediaDeviceInfo[];
-        enumerateDevices(): Promise<void>;
-        checkPermission(kind: MediaPermissionKind): Promise<MediaPermissionState>;
-        requestPermission(kind: MediaPermissionKind): Promise<MediaPermissionState>;
-        ensurePermission(kind: MediaPermissionKind): Promise<boolean>;
-        refreshPermissions(): Promise<MediaPermissionStatus>;
-    };
-    readonly settings: {
-        settings$: Observable<UserSettings>;
-        get(): UserSettings;
-        update(partial: DeepPartial<UserSettings>): void;
-        getIceServers(): RTCIceServer[];
-        getAudioInputDeviceId(): string;
-        setAudioInputDeviceId(deviceId: string): void;
-        getAudioOutputDeviceId(): string;
-        setAudioOutputDeviceId(deviceId: string): void;
-        getVideoDeviceId(): string;
-        setVideoDeviceId(deviceId: string): void;
-        setIceServers(servers: RTCIceServer[]): void;
-    };
-}
-export {};

package/dist/platform/service-registry.d.ts

@@ -1,13 +0,0 @@
-import { Observable } from './reactive';
-export interface Command<TParams = any, TResponse = any> {
-    params: TParams;
-    response: TResponse;
-}
-export interface Query<TParams = any, TResponse = any> {
-    params: TParams;
-    response: TResponse;
-}
-export interface ServiceRegistry<TCommands extends Record<string, Command> = any, TQueries extends Record<string, Query> = any> {
-    execute<K extends keyof TCommands>(name: K, params: TCommands[K]["params"]): Promise<TCommands[K]["response"]>;
-    observe<K extends keyof TQueries>(name: K, params: TQueries[K]["params"]): Observable<TQueries[K]["response"]>;
-}