@opencxh/domain 1.172.1 → 1.172.2

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

@@ -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/storage.d.ts

@@ -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;