@opencxh/domain 1.171.0 → 1.172.2

package/dist/platform/resource-source.d.ts

@@ -1,94 +1,92 @@
 /**
- * Aanwijsbare resources, over app-grenzen heen.
+ * Pointable resources, across app boundaries.
  *
- * Eén vraag die in dit platform steeds terugkwam en tot nu toe per geval werd opgelost: *welke
- * dingen kan ik hier aanwijzen, en hoe heten ze?* Een werkitem koppelen aan een gesprek, een
- * `resource_ref`-veld invullen, straks een bestand aanhaken — drie keer dezelfde vraag aan drie
- * verschillende apps.
+ * One question that kept coming back in this platform and was solved case by case until now:
+ * *which things can I point at here, and what are they called?* Linking a work item to a
+ * conversation, filling a `resource_ref` field, attaching a file later — the same question asked
+ * of three different apps three times.
  *
- * Het antwoord is een **contract op de servicebus**, niet een HTTP-providerrol: beide vragen
- * worden op de client gesteld door een gebruiker die de bron-app toch al open heeft, en die app
- * heeft zijn gesprekken en bedrijven al in een store staan. Een providerrol zou daar een
- * round-trip van maken voor gegevens die in het geheugen liggen.
+ * The answer is a **service-bus contract**, not an HTTP provider role: both questions are asked on
+ * the client by a user who has the source app open anyway, and that app already has its
+ * conversations and companies in a store. A provider role would turn that into a round trip for
+ * data sitting in memory.
  *
- * Drie sleutels, alle drie via `sdk.services.execute` (die de antwoorden van elke geïnstalleerde
- * app als array teruggeeft):
+ * Three keys, all three through `sdk.services.execute` (which returns the answers of every
+ * installed app as an array):
  *
- * | Sleutel | Params | Antwoord |
+ * | Key | Params | Answer |
  * |---|---|---|
  * | `resources.describe` | — | {@link ResourceSourceDescribe} |
  * | `resources.search` | {@link ResourceSearchParams} | {@link ResourceSummary}`[]` |
  * | `resources.resolve` | {@link ResourceResolveParams} | {@link ResourceSummary}`[]` |
  *
- * `describe` is niet cosmetisch: een kiezer tekent zijn soort-filters uit wat er daadwerkelijk
- * antwoordt. Zonder die call zou hij een vaste lijst tonen met tabbladen die leeg blijven zodra
- * een app niet geïnstalleerd is — precies de per-provider aanname die dit contract vermijdt.
+ * `describe` is not cosmetic: a picker draws its kind filters from what actually answers. Without
+ * that call it would show a fixed list with tabs that stay empty as soon as an app is not
+ * installed — exactly the per-provider assumption this contract avoids.
  */
-/** De servicebus-sleutels, als constante zodat een typefout niet stil een lege lijst oplevert. */
+/** The service-bus keys, as constants so a typo does not silently yield an empty list. */
 export declare const RESOURCE_DESCRIBE_SERVICE = "resources.describe";
 export declare const RESOURCE_SEARCH_SERVICE = "resources.search";
 export declare const RESOURCE_RESOLVE_SERVICE = "resources.resolve";
-/** Eén aanwijsbare resource, zoals de app die hem bezit hem toont. */
+/** One pointable resource, as the app that owns it shows it. */
 export interface ResourceSummary {
     /**
-     * `<kind>:<ref>` — dezelfde vorm die `ScopeAuth` autoriseert en `WorkLink.toKey` draagt.
+     * `<kind>:<ref>` — the same shape `ScopeAuth` authorizes and `WorkLink.toKey` carries.
      *
-     * Dit is de identiteit: twee aanbieders die dezelfde resource kennen (comms federeert
-     * adresboeken, crm heeft eigen contacten) leveren dezelfde sleutel, en een consument
-     * ontdubbelt daarop.
+     * This is the identity: two providers knowing the same resource (comms federates address books,
+     * crm has its own contacts) deliver the same key, and a consumer deduplicates on it.
      */
     scopeKey: string;
-    /** Het voorvoegsel van {@link ResourceSummary.scopeKey}, apart zodat filteren geen split vraagt. */
+    /** The prefix of {@link ResourceSummary.scopeKey}, separate so filtering needs no split. */
     kind: string;
     title: string;
-    /** Tweede regel: afzender, e-mailadres, bedrijfsnaam, statuslabel. */
+    /** Second line: sender, email address, company name, status label. */
     subtitle?: string;
-    /** Lucide-icoonnaam, zoals `TimeTarget.icon`. Afwezig = de consument kiest er zelf één bij de soort. */
+    /** Lucide icon name, like `TimeTarget.icon`. Absent = the consumer picks one for the kind. */
     icon?: string;
     /**
-     * Pad binnen de shell om deze resource te openen.
+     * Path inside the shell to open this resource.
      *
-     * Afwezig = de regel is niet aanklikbaar. Dat is bewust een aparte staat en geen gok: een
-     * verzonnen pad levert een doodlopende navigatie op, en dat is erger dan geen link.
+     * Absent = the row is not clickable. Deliberately a separate state and not a guess: an invented
+     * path yields a dead-end navigation, which is worse than no link.
      */
     href?: string;
-    /** Sorteerhint; recenter staat hoger. Afwezig telt als oudst. */
+    /** Sort hint; more recent ranks higher. Absent counts as oldest. */
     updatedAt?: number;
     /**
-     * Andere scopeKeys die bij deze resource horen — het contact en het bedrijf achter een
-     * gesprek, de klant achter een zaak.
+     * Other scopeKeys belonging to this resource — the contact and the company behind a
+     * conversation, the customer behind a case.
      *
-     * **De bron zegt het, de consument raadt het niet.** Comms weet dat een interactie
-     * `partyKeys` heeft; `apps/work` weet dat niet en hoort dat ook niet te weten. Zonder dit
-     * veld zou "neem het contact mee" in de koppel-flow een `if (kind === "interaction")` met
-     * een comms-specifieke veldnaam worden, en dat breekt bij de volgende aanbieder.
+     * **The source says it, the consumer does not guess it.** Comms knows an interaction has
+     * `partyKeys`; `apps/work` does not and should not. Without this field, "bring the contact
+     * along" in the link flow would become an `if (kind === "interaction")` with a comms-specific
+     * field name, and that breaks at the next provider.
      *
-     * Alleen één hop, en alleen wat de bron zelf al in handen heeft: dit is een hint voor een
-     * kiezer, geen graaf.
+     * One hop only, and only what the source already holds: this is a hint for a picker, not a graph.
      */
     related?: string[];
 }
-/** Antwoord op `resources.describe`: welke soorten deze app kan zoeken en oplossen. */
+/** Answer to `resources.describe`: which kinds this app can search and resolve. */
 export interface ResourceSourceDescribe {
     kinds: string[];
 }
-/** Params voor `resources.search`. */
+/** Params for `resources.search`. */
 export interface ResourceSearchParams {
-    /** Vrije tekst. Leeg = "wat is er recent", niet "alles". */
+    /** Free text. Empty = "what is recent", not "everything". */
     query: string;
-    /** Beperk tot deze soorten. Leeg/afwezig = alles wat de aanbieder heeft. */
+    /** Restrict to these kinds. Empty/absent = everything the provider has. */
     kinds?: string[];
-    /** Maximum per aanbieder, niet in totaal — de consument kapt zelf af na het ontdubbelen. */
+    /** Maximum per provider, not in total — the consumer truncates after deduplicating. */
     limit?: number;
 }
-/** Params voor `resources.resolve`: van sleutel naar leesbare rij. */
+/** Params for `resources.resolve`: from key to readable row. */
 export interface ResourceResolveParams {
     scopeKeys: string[];
 }
 /**
- * De soort uit een scopeKey, zonder de rest te hoeven splitsen.
+ * The kind out of a scopeKey, without having to split the rest.
  *
- * Losse helper en geen `splitScopeKey`-hergebruik: die zit in `platform-api` (server), en dit
- * contract wordt vooral op de client gelezen.
+ * A separate helper and not a reuse of `splitScopeKey`: that one sits in `platform-api` (server),
+ * and this contract is read mostly on the client.
  */
 export declare function resourceKindOf(scopeKey: string): string;

package/dist/platform/resource.d.ts

@@ -1,39 +1,33 @@
 /**
- * Waar iets **over gaat**: een verwijzing naar een resource, los van welke app hem bezit.
+ * What something is **about**: a reference to a resource, independent of which app owns it.
  *
- * Dit type stond in `entities/read-state`, met als doc "so read-state (and, later, an audit log)
- * can attach to any resource". Dat "later" is nu: een run heeft precies dezelfde verwijzing nodig.
- * Hij is daarom naar `platform/` gehesen in plaats van er een tweede naast te zetten — read-state
- * exporteert hem door, zodat geen enkele bestaande importeur verandert.
+ * The platform-wide key shape is `"<kind>:<id>"`: what `authorizeScope` accepts, what
+ * `ScopeAuthorizeRequest.scopeKey` carries, and what the file keys are made of. {@link refKey} is
+ * the bridge there.
  *
- * De platformbrede sleutelvorm is `"<soort>:<id>"`: dat is wat `authorizeScope` aanneemt, wat
- * `ScopeAuthorizeRequest.scopeKey` draagt, en waar de dossiersleutels uit bestaan. {@link refKey}
- * is de brug daarheen.
- *
- * Let op de veldnaam: `type`, terwijl de rest van de codebase `kind` gebruikt voor een
- * discriminant (`OwnerScope.kind`, `ActingIdentity.kind`, `Decider.kind`, `splitScopeKey().kind`).
- * Dat is een inconsistentie van vóór dit type, en hem hier omdopen zou read-state en de
- * resource-reminders meesleuren — een eigen opruiming, niet deze.
+ * Mind the field name: `type`, while the rest of the codebase uses `kind` for a discriminant
+ * (`OwnerScope.kind`, `ActingIdentity.kind`, `Decider.kind`, `splitScopeKey().kind`). That
+ * inconsistency predates this type, and renaming it here would drag read-state and the resource
+ * reminders along — a cleanup of its own, not this one.
  */
 export interface ResourceRef {
-    /** `"interaction"`, `"task"`, … — dezelfde soorten die een scope-provider declareert. */
+    /** `"interaction"`, `"task"`, … — the same kinds a scope provider declares. */
     type: string;
     id: string;
 }
-/** De sleutelvorm die `authorizeScope` en de dossiersleutels gebruiken. */
+/** The key shape `authorizeScope` and the file keys use. */
 export declare function refKey(ref: ResourceRef): string;
 /**
- * De soort die comms bezit, en de enige waar de engine iets extra's van weet: op een interactie
- * kun je wachten op een antwoord en een regel in de tijdlijn zetten. Andere soorten kunnen dat
- * niet, en dat is geen omissie maar het verschil tussen een gesprek en een taak.
+ * The kind comms owns, and the only one the engine knows something extra about: on an interaction
+ * you can wait for a reply and put a line in the timeline. Other kinds cannot, and that is not an
+ * omission but the difference between a conversation and a task.
  */
 export declare const INTERACTION_KIND = "interaction";
 /**
- * Het interactie-id, als dit onderwerp een gesprek is.
+ * The interaction id, when this subject is a conversation.
  *
- * Bestaat zodat de twee dingen die écht een gesprek nodig hebben (`wait-for-reply` en de
- * lifecycle-marker) daarnaar kunnen vragen zonder overal `type === "interaction"` uit te
- * schrijven — en zodat een run over een taak daar netjes `undefined` uit krijgt in plaats van
- * stilzwijgend een id dat naar het verkeerde soort wijst.
+ * Exists so the two things that really need a conversation (`wait-for-reply` and the lifecycle
+ * marker) can ask for it without spelling out `type === "interaction"` everywhere — and so a run
+ * about a task gets a clean `undefined` instead of silently an id pointing at the wrong kind.
  */
 export declare function interactionIdOf(subject: ResourceRef | undefined): string | undefined;

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 {
@@ -6,63 +6,38 @@ export interface ScopeAuth {
     shared?: boolean;
     audience?: string[];
     /**
-     * Van wie deze resource is, zoals de eigenaar-app het ziet: een persoonlijke mailbox, een
-     * teaminbox, of de organisatie.
-     *
-     * Los van `shared` en `audience`, die iets anders zeggen. `shared` gaat over of een
-     * AI-gesprek op deze scope met het team gedeeld wordt (voor een interactie altijd waar), en
-     * `audience` is de momentane ledenlijst voor SSE. Dit veld gaat over **eigenaarschap**, en
-     * dat is wat een consument nodig heeft om te beslissen of afgeleide kennis breder mag dan
-     * de resource zelf.
-     *
-     * Eerste consument is de geheugenlaag: een org-brede geheugensoort wordt bij het schrijven
-     * versmald naar `audience` als het bronsubject persoonlijk is, zodat een gesprek uit iemands
-     * eigen mailbox niet in de cross-klant-zoekresultaten van een collega opduikt. Afwezig =
-     * onbekend, en dat wordt daar als "versmallen" gelezen: de veilige kant.
+     * Who owns this resource as the owner app sees it: a personal mailbox, a
+     * team inbox, or the organization. Distinct from `shared` (whether an AI
+     * conversation on this scope is team-shared) and `audience` (current member
+     * list for SSE): this is **ownership** — what a consumer needs to decide
+     * whether derived knowledge may travel wider than the resource itself.
+     * First consumer is the memory layer: an org-wide memory kind is narrowed
+     * to `audience` at write time when the source subject is personal. Absent =
+     * unknown, read there as "narrow": the safe side.
      */
     ownerScope?: OwnerScope;
     /**
-     * De **dossiersleutels** waaronder deze resource valt: de canonieke sleutels waarmee andere
-     * apps hem in één geïndexeerde `$in` terugvinden.
-     *
-     * Dit is de ene conventie waarmee verbanden in dit platform worden uitgedrukt. Deze
-     * datastore kan niet joinen en niet recursief traverseren, dus een edge-*tabel* zou van
-     * elke vraag een keten van `$in`-hops met een groeiende idlijst maken. In plaats daarvan
-     * draagt elke contextdragende rij zijn eigen sleutels, platgeslagen op **schrijfmoment**:
-     * `Interaction.partyKeys` doet dat al, `Contact.keys`/`Company.keys` ook, en de
-     * geheugenlaag stempelt ze via dit veld op zijn items (`MemoryItem.keys`).
-     *
-     * Het vocabulaire is dat van `endpointKey`: `mailto:`, `tel:`, `domain:`, plus de
-     * vastgelegde `contact:<id>` / `company:<id>` / `interaction:<id>`. Twee rollen, één
-     * vorm — *identiteit* ("dit ben ik", `Contact.keys`) en *verwijzing* ("hier hoor ik bij",
-     * `partyKeys`).
-     *
-     * **Klein houden.** Dit is de set van de rij zelf, niet zijn hele omgeving: een company
-     * geeft zijn eigen sleutels en domeinen, níet die van tweehonderd medewerkers. Die
-     * fan-out hoort bij een expliciete zoekvraag (`keySetForCompany`), niet bij elke
-     * autorisatie — deze call zit op het hete pad van elke geheugen-schrijfactie.
-     *
-     * Afwezig = onbekend, en dat wordt gelezen als "alleen het subject zelf": minder
-     * vindbaar, nooit ruimer. Dezelfde richting als {@link ScopeAuth.ownerScope}.
+     * The **dossier keys** this resource falls under: the canonical keys other
+     * apps use to find it in one indexed `$in`. The platform's one convention for
+     * relationships — the datastore cannot join or traverse, so each
+     * context-bearing row carries its own keys, flattened at **write time**
+     * (`Interaction.partyKeys`, `Contact.keys`, `MemoryItem.keys` via this
+     * field). Vocabulary is `endpointKey` (`mailto:`, `tel:`, `domain:`) plus
+     * `contact:<id>` / `company:<id>` / `interaction:<id>`. Keep it small: the
+     * row's own keys, not its whole neighborhood — fan-out belongs to an explicit
+     * search (`keySetForCompany`), and this call sits on the hot path of every
+     * memory write. Absent = unknown, read as "only the subject itself": less
+     * findable, never wider. Same direction as {@link ScopeAuth.ownerScope}.
      */
     keys?: string[];
     /**
-     * Wie deze resource *behandelt*, als de eigenaar-app dat weet: het userId van de
-     * toegewezen behandelaar.
-     *
-     * Los van {@link ScopeAuth.ownerScope}, dat over eigenaarschap gaat (een persoonlijke
-     * mailbox, een teaminbox, de organisatie). Dit is de persoon, en het is een ander
-     * antwoord: een gesprek in een teaminbox heeft `ownerScope.kind === "team"` én een
-     * concrete behandelaar.
-     *
-     * Eerste consument is `apps/work`: werk dat de assistent uit een gesprek aanmaakt hoort
-     * bij de behandelaar van dat gesprek te landen, niet op naam van de agent die het
-     * aanmaakte. Comms leidde dat vroeger in-process af (`resolveInteractionOwnership`);
-     * cross-app is dit hetzelfde antwoord zonder een tweede endpoint, want de aanroeper heeft
-     * de interactie en de inbox hier toch al gelezen.
-     *
-     * Afwezig = onbekend, en dat leest een consument als "val terug op je eigen regels" —
-     * nooit als "niemand".
+     * Who *handles* this resource, if the owner app knows: the assigned
+     * handler's userId. Distinct from {@link ScopeAuth.ownerScope} (ownership) —
+     * a team-inbox conversation has `ownerScope.kind === "team"` *and* a
+     * concrete handler. First consumer is `apps/work`: work the assistant
+     * creates from a conversation must land with that conversation's handler,
+     * not under the creating agent's name. Absent = unknown, read by consumers
+     * as "fall back to your own rules" — never as "nobody".
      */
     ownerUserId?: string;
 }
@@ -70,22 +45,21 @@ export interface ScopeAuth {
 export interface ScopeDescribe {
     kinds: string[];
     /**
-     * Welke soorten acting identity deze provider daadwerkelijk evalueert.
-     * Afwezig = alleen het klassieke `userId`-contract.
-     *
-     * Dit is een fail-closed schakelaar, geen documentatie: een provider die
-     * `actor` negeert ziet bij een team-actor een lege `userId` en zou dat als
-     * "trusted system caller" lezen — dus volledige toegang. `authorizeIdentity`
-     * weigert daarom een `team`-actor zolang de eigenaar `"team"` niet declareert.
+     * Which acting-identity kinds this provider actually evaluates. Absent =
+     * only the classic `userId` contract. A fail-closed switch, not
+     * documentation: a provider that ignores `actor` sees an empty `userId` for
+     * a team actor and would read that as "trusted system caller" — full access.
+     * `authorizeIdentity` therefore refuses a `team` actor until the owner
+     * declares `"team"`.
      */
     actorKinds?: ActingIdentity["kind"][];
 }
 /**
  * POST /provider/scope/authorize body.
  *
- * `userId` blijft voor back-compat: bestaande providers lezen alleen dat veld, en
- * een `user`-actor vult het mee zodat zij ongewijzigd blijven werken. `userId`
- * afwezig = trusted system caller (ruim!), dus zie de waarschuwing bij
+ * `userId` stays for back-compat: existing providers read only that field, and
+ * a `user` actor fills it so they keep working unchanged. Absent `userId` =
+ * trusted system caller (broad!) — see the warning at
  * {@link ScopeDescribe.actorKinds}.
  */
 export interface ScopeAuthorizeRequest {

package/dist/platform/services.d.ts

@@ -7,21 +7,21 @@ export type ServiceMap = {
     [key: string]: ServiceDefinition;
 };
 export interface GlobalServices extends ServiceMap {
-    'platform:router:push': {
+    "platform:router:push": {
         params: {
             path: string;
             options?: any;
         };
         response: void;
     };
-    'platform:auth:expired': {
+    "platform:auth:expired": {
         params: {};
         response: void;
     };
-    'platform:ui:toast': {
+    "platform:ui:toast": {
         params: {
             message: string;
-            type: 'success' | 'error';
+            type: "success" | "error";
         };
         response: void;
     };

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`
@@ -26,7 +26,7 @@ export interface FilePointer {
     id: string;
     mountId: string;
     name: string;
-    type: 'file' | 'folder';
+    type: "file" | "folder";
     path: string;
     providerKey: string;
     mimeType: string;