@cosmicdrift/kumiko-types 0.386.0 → 0.387.0

package/LICENSE

@@ -1,57 +1,21 @@
-Business Source License 1.1
-
-Parameters
-
-Licensor:             Marc Frost
-
-Licensed Work:        @cosmicdrift/kumiko-types
-                      The Licensed Work is © 2026 Marc Frost.
-
-Additional Use Grant: 
-You may use the Licensed Work in production for any purpose, including 
-commercially, EXCEPT for the Restricted Use. 
-
-"Restricted Use" is defined as using the Licensed Work to provide a platform 
-or service to third parties that allows them to host, deploy, or run their 
-own applications built with the Licensed Work. This includes, but is not 
-limited to: managed hosting services, software-as-a-service (SaaS) platforms, 
-platform-as-a-service (PaaS), developer platforms, or any multi-tenant 
-managed offering of the Licensed Work.
-
-This restriction does not apply to the Licensor, any entity controlled by, 
-controlling, or under common control with the Licensor ("Affiliates"), or 
-contractors acting on their behalf. The Licensor remains free to use the 
-Licensed Work for any purpose, including for the operation of kumiko.rocks.
-
-Change Date:          2030-05-05
-Change License:       Apache License, Version 2.0
-
-
-Terms
-
-The Licensor hereby grants you the right to copy, modify, create derivative works, 
-redistribute, and make non-production use of the Licensed Work. The Licensor may 
-make an Additional Use Grant, above, permitting limited production use.
-
-Effective on the Change Date, or the fourth anniversary of the first publicly 
-available distribution of the Licensed Work under this License, whichever comes 
-first, this License will convert to the Change License.
-
-This Business Source License governs use of the Licensed Work in all cases, except 
-as to any use that is explicitly granted in the Additional Use Grant above or 
-under the Change License after the Change Date.
-
-If your use of the Licensed Work does not comply with the requirements of this 
-License, you must cease use of the Licensed Work immediately.
-
-All copies of the Licensed Work, and all derivative works thereof, must include 
-this License.
-
-This License does not grant you any right, title, or interest in any trademark, 
-logo, or branding of the Licensor, except as required to comply with this License.
-
-TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON AN 
-“AS IS” BASIS. LICENSOR DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING 
-WITHOUT LIMITATION WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, 
-TITLE, AND NON-INFRINGEMENT. IN NO EVENT WILL LICENSOR BE LIABLE FOR ANY DAMAGES 
-ARISING OUT OF OR RELATED TO THIS LICENSE OR THE USE OF THE LICENSED WORK.
+MIT License
+
+Copyright (c) 2026 Marc Frost
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,6 +1,6 @@
 # @cosmicdrift/kumiko-types
 
-[![License: BUSL-1.1](https://img.shields.io/badge/License-BUSL--1.1-blue.svg)](../../LICENSE)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](../../LICENSE)
 [![TypeScript](https://img.shields.io/badge/TypeScript-strict-blue.svg)](https://www.typescriptlang.org/)
 
 Framework type definitions for Kumiko — `FeatureDefinition`, boot-check types,

package/dist/config.d.ts

@@ -50,7 +50,7 @@ export type ConfigKeyDefinition<T extends ConfigKeyType = ConfigKeyType> = {
      *  encrypted under the DEK of the scope actually written to (tenant-row
      *  → tenant subject, user-row → user subject). Only on `type: "text"`,
      *  `scope !== "system"` (no subject there), and mutually exclusive with
-     *  `encrypted` (kumiko-platform#231/#459). */
+     *  `encrypted`. */
     readonly piiEncrypted?: boolean;
     readonly options?: readonly string[];
     /** Only on `type: "select"`: loads the options from this query (QN), contract

package/dist/entity-table-meta-types.js

@@ -2,6 +2,6 @@
 // Plain-data types for EntityTableMeta — split from the runtime
 // (deriveEntityTableMeta, resolveTableName, defineUnmanagedTable) in
 // entity-table-meta.ts. Prep step for the types-only package extraction
-// (#1283) — this file must have ONLY `import type`, no value imports
+// — this file must have ONLY `import type`, no value imports
 // (crypto/DB deps).
 export {};

package/dist/event-store-executor-types.d.ts

@@ -64,7 +64,7 @@ export type EventStoreExecutor<Row extends Record<string, unknown> = Record<stri
             readonly value: unknown;
         }> | undefined;
     }, user: SessionUser, db: TenantDb, 
-    /** Tier 2.7e audit fix: per-call SearchAdapter override. When the
+    /** Per-call SearchAdapter override. When the
      *  executor didn't get a SearchAdapter via Options at build time
      *  (defaultEntityQueryHandler path), the caller (handler) can pass
      *  one from ctx.searchAdapter here at runtime.

package/dist/event-store-types.js

@@ -3,5 +3,5 @@ export function isPersonalDataGated(origin) {
 }
 // Stamped when an append runs outside any attributed scope (seed scripts,
 // tests, direct event-store use). A distinct value, not an omission —
-// omitted would be indistinguishable from a pre-#3043 row.
+// omitted would be indistinguishable from an earlier row.
 export const UNATTRIBUTED_ORIGIN = "unknown";

package/dist/event-type-map.js

@@ -1,18 +1,18 @@
-// Cross-Feature Compile-Time-Type-Map.
+// Cross-Feature Compile-Time Type Map.
 //
-// Zweck: ctx.appendEvent / ctx.queryProjection / dispatcher.write gegen ein
-// statisch bekanntes Schema-Bild prüfen, statt erst zur Boot- oder Runtime
-// (zod-validate) zu scheitern. Designer/AI-Layer profitiert dadurch sofort:
-// Autocomplete kennt alle Event-Typen aller geladenen Features, payload-
-// Shape-Mismatches werden im Editor angezeigt, nicht erst beim Boot.
+// Purpose: check ctx.appendEvent / ctx.queryProjection / dispatcher.write against a
+// statically known schema image instead of failing only at boot or runtime
+// (zod-validate). The Designer/AI layer benefits immediately: autocomplete knows all
+// event types from all loaded features, and payload-shape mismatches appear in the
+// editor rather than only at boot.
 //
-// Befüllung erfolgt per Feature über `declare module "@cosmicdrift/kumiko-framework/engine"`
-// — entweder hand-geschrieben (für stabile Frameworks-Internals) oder vom
-// Codegen-Skript erzeugt (für apps/bundled-features). Empty defaults sind
-// kein Bug: ein Feature ohne Augmentation ist runtime-pluggable und nutzt
-// die Fallback-Overload mit `unknown` payload.
+// Each feature populates the map through `declare module "@cosmicdrift/kumiko-framework/engine"`
+// — either manually (for stable framework internals) or through the code-generation
+// script (for apps/bundled-features). Empty defaults are not a bug: a feature without
+// augmentation is runtime-pluggable and uses the fallback overload with `unknown`
+// payload.
 //
-// Pattern für hand-geschriebene Augmentation am File-Top:
+// Pattern for a manually written augmentation at the top of the file:
 //
 //   declare module "@cosmicdrift/kumiko-framework/engine" {
 //     interface KumikoEventTypeMap {

package/dist/feature.d.ts

@@ -79,7 +79,7 @@ export type StoreTableOptions = {
     /** Direct-write stores skip the executor, so the executor's PII
      *  encryption never runs for them — a feature whose meta carries
      *  piiSubjectFields must encrypt those fields itself before every
-     *  insert/update and declare that here, or boot fails (#820). */
+     *  insert/update and declare that here, or boot fails. */
     readonly piiEncryptedOnWrite?: true;
 };
 /** Per-feature store-table registration. `meta` is the `EntityTableMeta`
@@ -152,17 +152,17 @@ export type FeatureDefinition = {
     readonly extensionSelectors: readonly ExtensionSelectorDef[];
     /**
      * Cross-feature API names this feature exposes via `r.exposesApi(name)`.
-     * Pure Marker-Deklaration — die echte Implementation wird als
-     * Query-/Write-Handler unter dem QN-Pattern registriert (z.B.
-     * `compliance-profiles:query:effective-profile`). Boot-Validator prüft
-     * dass jedes `r.usesApi(name)` einen passenden Exposer hier findet —
-     * Tippfehler oder Drop-Refactorings werden zu Boot-Fail statt Runtime-Crash.
+     * Pure marker declaration — the implementation is registered separately as
+     * a query or write handler under the QN pattern (for example,
+     * `compliance-profiles:query:effective-profile`). The boot validator checks
+     * that every `r.usesApi(name)` finds a matching exposer, so typos or dropped
+     * refactors fail at boot instead of causing a runtime crash.
      */
     readonly exposedApis: ReadonlySet<string>;
     /**
-     * Cross-feature API names this feature calls. Pflicht-Boot-Check:
-     * jeder Eintrag muss in `exposedApis` irgendeines Features auftauchen
-     * UND das Provider-Feature muss in requires/optionalRequires sein.
+     * Cross-feature API names this feature calls. The boot check requires every
+     * entry to appear in some feature's `exposedApis` and the provider feature
+     * to be listed in requires/optionalRequires.
      */
     readonly usedApis: ReadonlySet<string>;
     /**
@@ -406,30 +406,30 @@ export type FeatureRegistrar<TFeature extends string = string> = {
         readonly panels?: readonly ExtensionSelectorPanel[];
     }): void;
     /**
-     * Marker-Deklaration: dieses Feature stellt eine Cross-Feature-API
-     * unter dem genannten Namen bereit. Die eigentliche Implementation
-     * wird separat als Query- oder Write-Handler unter dem QN-Pattern
-     * registriert; `r.exposesApi` ist reine Boot-Check-Surface.
+     * Marker declaration: this feature provides a cross-feature API under the
+     * given name. The implementation is registered separately as a query or
+     * write handler under the QN pattern; `r.exposesApi` is only a boot-check
+     * surface.
      *
-     * Boot-Validator prüft, dass jedes `r.usesApi(name)` einen passenden
-     * Exposer findet, dass das Exposer-Feature in requires/optionalRequires
-     * gelisted ist und dass kein API-Name doppelt exposed wird.
+     * The boot validator checks that every `r.usesApi(name)` finds a matching
+     * exposer, that the exposer feature is listed in requires/optionalRequires,
+     * and that no API name is exposed more than once.
      *
      * ```ts
      * defineFeature("compliance-profiles", (r) => {
      *   r.exposesApi("compliance.forTenant");
      *   r.queryHandler({
      *     name: "compliance:query:for-tenant",
-     *     // ... echte Implementation
+     *     // ... actual implementation
      *   });
      * });
      * ```
      */
     exposesApi(apiName: string): void;
     /**
-     * Declares that this feature calls a cross-feature API. Boot-Validator
-     * checkt dass irgendein anderes Feature `r.exposesApi(apiName)` macht
-     * und dass dieses Feature `r.requires/optionalRequires` darauf hat.
+     * Declares that this feature calls a cross-feature API. The boot validator
+     * checks that another feature provides `r.exposesApi(apiName)` and that
+     * this feature lists it in `r.requires/optionalRequires`.
      *
      * ```ts
      * defineFeature("user-data-rights", (r) => {
@@ -447,9 +447,9 @@ export type FeatureRegistrar<TFeature extends string = string> = {
      * Use for cross-feature invariants that `r.requires` can't express
      * because they're conditional (only fail when the feature has a
      * specific shape), e.g. "if this feature has PII entities, some
-     * user-data-hook feature must be mounted" (the prompt-store trap,
-     * kumiko-enterprise#229 — a UserData feature was written but never
-     * mounted, and nothing caught it at boot):
+     * user-data-hook feature must be mounted" (the prompt-store trap —
+     * a UserData feature was written but never mounted, and nothing caught
+     * it at boot):
      *
      * ```ts
      * defineFeature("prompt-store", (r) => {

package/dist/fields.d.ts

@@ -17,11 +17,10 @@ export type ResolvedPiiFlags = {
     readonly recordOwned?: true;
     readonly anonymize?: () => unknown | Promise<unknown>;
     readonly allowPlaintext?: string;
-    /** Equality-Lookups (fetchOne/filter eq) bleiben trotz Verschluesselung
-     *  moeglich: generierte `<snake>_bidx`-Spalte traegt einen HMAC-Blind-
-     *  Index, Query-Compiler matchen `(col = $1 OR col_bidx = $2)`. Nur auf
-     *  text-Feldern MIT Subject-Annotation erlaubt (Boot-Validator).
-     *  Siehe docs/plans/datenschutz/blind-index.md (kumiko-framework#818). */
+    /** Equality lookups (`fetchOne`/`filter eq`) remain possible despite encryption:
+     *  the generated `<snake>_bidx` column carries an HMAC blind index, and the
+     *  query compiler matches `(col = $1 OR col_bidx = $2)`. Allowed only on text
+     *  fields with subject annotations, as enforced by the boot validator. */
     readonly lookupable?: true;
     /** Foreign key into the `user` entity (authorId, assigneeId, ...) with no
      *  annotated content of its own. Triggers no encryption — feeds only the
@@ -94,9 +93,9 @@ export type TextFieldDef = {
     readonly required?: boolean;
     readonly searchable?: boolean;
     readonly sortable?: boolean;
-    /** Author erlaubt Screen-Filter auf diesem Feld (Tier 2.7c).
-     *  Boot-Validator weist Filter mit `filterable !== true` zurück.
-     *  Default: false — analog zu `sortable`, opt-in. */
+    /** Allows screen filters on this field.
+     *  The boot validator rejects filters with `filterable !== true`.
+     *  Default: false, analogous to `sortable`, and therefore opt-in. */
     readonly filterable?: boolean;
     readonly encrypted?: boolean;
     readonly sensitive?: boolean;
@@ -125,40 +124,38 @@ export type TextFieldDef = {
     readonly format?: "email" | "url" | "phone" | "password" | "month" | "iban";
     readonly default?: string;
     readonly access?: FieldAccess;
-    /** Mehrzeiliger Text — DefaultInput rendert dann ein <textarea> statt
-     *  <input type="text">. `true` = Default 4 Zeilen, `{ rows: N }` =
-     *  explizite Höhe. Search/sort/encrypt verhalten sich unverändert
-     *  identisch zu single-line — nur die Render-Surface wechselt. */
+    /** Multiline text causes DefaultInput to render a <textarea> instead of
+     *  <input type="text">. `true` uses four rows by default; `{ rows: N }`
+     *  sets an explicit height. Search, sort, and encryption remain unchanged;
+     *  only the rendering surface differs. */
     readonly multiline?: boolean | {
         readonly rows?: number;
     };
 } & ResolvedPiiFlags;
 /**
- * Long-form text content — source-code, markdown, blog-posts, email-
- * templates, anything that can be megabytes large. Bewusst MINIMALE
- * Surface gegen `text`:
+ * Long-form text content — source code, markdown, blog posts, email
+ * templates, and anything that can be megabytes large. Its surface is
+ * intentionally minimal compared with `text`:
  *
- *   - **Kein `sortable`**: ORDER BY auf 100 KB-Strings kostet I/O ohne
- *     sinnvolles UX-Outcome (lex-Sortierung von Code ist Nonsense).
- *   - **Kein `searchable`**: ILIKE/Substring-Suche auf langen Texten
- *     skaliert nicht. Wer wirklich Volltextsuche will, nimmt den
- *     SearchAdapter (Meilisearch) — der hat eine eigene Pipeline mit
- *     Tokenizer + Index, NICHT diesen field-flag.
- *   - **Kein `filterable`**: WHERE auf langen Strings same Story wie
- *     sortable.
- *   - **Kein `format`**: email/url/phone sind kurz definierte Inputs,
- *     longText ist per Definition unstrukturiert.
+ *   - **No `sortable`**: ordering 100 KB strings costs I/O without useful UX;
+ *     lexicographic ordering of code is not meaningful.
+ *   - **No `searchable`**: ILIKE/substring searches do not scale on long text.
+ *     Full-text search should use the SearchAdapter (Meilisearch), which has
+ *     its own tokenizer and index rather than this field flag.
+ *   - **No `filterable`**: filtering long strings has the same issue as sorting.
+ *   - **No `format`**: email/url/phone are short, structured inputs, whereas
+ *     longText is unstructured by definition.
  *
- * Type-level enforcement statt convention: wer sortable/searchable
- * braucht, nimmt `text` (mit den entsprechenden Skalierungs-Trade-offs).
- * DB-mapping ist identisch zu text (Postgres `text` ist unbounded).
+ * Type-level enforcement means callers who need sorting or searching must use
+ * `text` and accept its scaling trade-offs. Database mapping is identical to
+ * `text` (Postgres `text` is unbounded).
  */
 export type LongTextFieldDef = {
     readonly type: "longText";
     readonly description?: string;
-    /** Optionale soft-Cap. Default unbounded (= Postgres-text-limit, 1 GB).
-     *  Nützlich für defensive Caps wie 1 MB damit ein verirrter Browser-
-     *  Paste nicht die DB sprengt. */
+    /** Optional soft cap. Default is unbounded (= Postgres text limit, 1 GB).
+     *  Useful for defensive limits such as 1 MB so an accidental browser paste
+     *  does not overwhelm the database. */
     readonly maxLength?: number;
     readonly required?: boolean;
     readonly encrypted?: boolean;
@@ -265,7 +262,7 @@ export type MultiSelectFieldDef<TOptions extends readonly string[] = readonly st
     readonly required?: boolean;
     readonly filterable?: boolean;
     readonly sensitive?: boolean;
-    /** Default-Auswahl. Jeder Eintrag muss in `options` sein (Boot-Validator). */
+    /** Default selection. Every entry must occur in `options` (boot validator). */
     readonly default?: readonly TOptions[number][];
     readonly access?: FieldAccess;
     /** Renderer metadata: `"checkboxes"` renders every option as a visible
@@ -321,16 +318,15 @@ export type NumberFieldDef = {
     readonly grouping?: boolean;
 } & ResolvedPiiFlags;
 /**
- * 64-bit-Integer-Spalte fuer Audit-Counter, Byte-Sizes, Event-IDs und
- * andere Werte die >2^31 (~2.1 Mrd) wandern koennen. Storage als
- * Postgres `bigint`, JS-Round-trip als `number` (mode:"number" — sicher
- * bis 2^53 ≈ 9 PB, JSON-serialisierbar). Wer >2^53 braucht (rare),
- * nutzt einen `text`-Field mit eigenem Codec.
+ * 64-bit integer field for audit counters, byte sizes, event IDs, and other
+ * values that can exceed 2^31 (~2.1 billion). Stored as Postgres `bigint`,
+ * with a JavaScript `number` round trip (`mode:"number"`, safe through 2^53
+ * ≈ 9 PB and JSON-serializable). Values above 2^53 should use a `text` field
+ * with a custom codec.
  *
- * Vorrang vor `NumberFieldDef`-(integer 32-bit-Cap, ~2.1 GB) immer dann
- * wenn der Wert physisch ueber dieses Limit klettern kann: Bytes,
- * Events, Counters in High-Throughput-Apps, Cumulative-Sums. Money
- * hat dafuer den eigenen `MoneyFieldDef` (mit Currency-Spalte).
+ * Prefer this over `NumberFieldDef`'s 32-bit integer cap whenever a value can
+ * physically exceed that limit: bytes, events, high-throughput counters, and
+ * cumulative sums. Money has its own `MoneyFieldDef` with a currency column.
  */
 export type BigIntFieldDef = {
     readonly type: "bigInt";
@@ -368,9 +364,9 @@ export type DecimalFieldDef = {
 } & ResolvedPiiFlags;
 /** Where a money field's currency comes from. `"tenant"` is the
  *  tenant-settings bundle's per-tenant currency (`tenant-settings:config:
- *  currency`, kumiko-framework#2933); `"literal"` names a fixed ISO code and
- *  is checked against the app's `currencies` list at boot
- *  (kumiko-framework#2839). Discriminated union so a `{ kind: "field", of }`
+ *  currency`); `"literal"` names a fixed ISO code and
+ *  is checked against the app's `currencies` list at boot.
+ *  Discriminated union so a `{ kind: "field", of }`
  *  variant (amount and currency-picker side by side) can still be added
  *  without a breaking change, once a multi-currency form actually exists. */
 export type MoneyCurrencySource = {
@@ -382,7 +378,7 @@ export type MoneyCurrencySource = {
 /** Qualified config key a `{ kind: "tenant" }` MoneyCurrencySource resolves
  *  against — the tenant-settings bundle's per-tenant currency. Lives here
  *  (client-safe) rather than framework/engine so renderer code can read it
- *  without a runtime-only import (kumiko-framework#2937). */
+ *  without a runtime-only import. */
 export declare const TENANT_CURRENCY_CONFIG_KEY = "tenant-settings:config:currency";
 export type MoneyFieldDef = {
     readonly type: "money";
@@ -406,27 +402,27 @@ export type ReferenceFieldDef = {
     readonly filterable?: boolean;
     readonly sensitive?: boolean;
     readonly access?: FieldAccess;
-    /** Welches Feld der referenced Entity als Display-Label im
-     *  Select-Dropdown erscheint. Default: "id". Boot-Validator pinst
-     *  dass das Feld auf der referenced Entity existiert. */
+    /** Field of the referenced entity displayed as the Select dropdown label.
+     *  Default: "id". The boot validator ensures that the field exists on the
+     *  referenced entity. */
     readonly labelField?: string;
-    /** Multi-Reference (Tier 2.7e-Multi): Wert ist ein Array von UUIDs
-     *  statt single UUID. Storage als jsonb-Array<uuid>. UI rendert
-     *  Multi-Select-Combobox mit Tag-Anzeige der gewählten Items. */
+    /** Multi-reference: the value is an array of UUIDs rather than a single UUID.
+     *  Stored as a jsonb array of UUIDs; the UI renders a multi-select combobox
+     *  with tags for the selected items. */
     readonly multiple?: boolean;
     /** Include a row in this entity's result set on a text-search hit against
      *  the referenced entity's `labelField`, instead of only matching the UUID
-     *  column itself (fw#2660). Requires an explicit `labelField` — the boot
+     *  column itself. Requires an explicit `labelField` — the boot
      *  validator rejects it otherwise, since the default "id" is a UUID column
      *  and ILIKE against it would crash at runtime. */
     readonly searchable?: true;
     /** Order a list by the referenced entity's `labelField` instead of by the raw
-     *  UUID column (fw#2741). Requires an explicit, non-"id" `labelField` — the
+     *  UUID column. Requires an explicit, non-"id" `labelField` — the
      *  boot validator rejects it otherwise, since ordering by a UUID produces a
      *  sequence that looks meaningful to the user but is arbitrary. */
     readonly sortable?: true;
     /** Fill the picker from this query handler instead of the referenced
-     *  entity's own list handler (fw#2780) — for targets whose identity is
+     *  entity's own list handler — for targets whose identity is
      *  composed from joined rows, where no single column of the referenced
      *  entity is a readable label. Fully-qualified QN
      *  ("<feature>:query:<short>"), boot-validated against the registered
@@ -481,7 +477,7 @@ export type EmbeddedSubFieldDef = (EmbeddedSubFieldBase & {
     readonly type: "reference";
     readonly entity: string;
     readonly labelField?: string;
-    /** Same contract as `ReferenceFieldDef.optionsQuery` (fw#2780). */
+    /** Same contract as `ReferenceFieldDef.optionsQuery`. */
     readonly optionsQuery?: string;
 });
 /** A cell computed from other cells of the same row. `from` names the
@@ -535,7 +531,7 @@ export type EmbeddedFieldDef = {
      *  field's amount. Validated both client- and server-side (schema-builder
      *  superRefine). Only meaningful with `multiple: true`. Compares against
      *  rounded `derived` cells, i.e. "sum-of-rounded" not "round-of-sum" —
-     *  see kumiko-framework#1866. */
+     *  see the embedded-list totals-matching behavior. */
     readonly totalsMatch?: Readonly<Record<string, string>>;
 } & ResolvedPiiFlags;
 export type JsonbFieldDef = {
@@ -557,13 +553,13 @@ export type DateFieldDef = {
     readonly filterable?: boolean;
     readonly sensitive?: boolean;
     readonly access?: FieldAccess;
-    /** Erlaubte Datumsgrenzen als ISO `yyyy-mm-dd` (z.B. Geburtsdatum nicht
-     *  in der Zukunft: `max` = heute). Begrenzt den Picker und wird vom
-     *  Zod-Schema beim Write durchgesetzt. */
+    /** Permitted date bounds as ISO `yyyy-mm-dd` (for example, a birth date
+     *  cannot be in the future when `max` is today). The bounds constrain the
+     *  picker and are enforced by the Zod schema on write. */
     readonly min?: string;
     readonly max?: string;
-    /** Format/Locale-Override für Anzeige und Eingabe-Parsing (z.B.
-     *  "de-DE"). Default = App-Locale. */
+    /** Format/locale override for display and input parsing (for example,
+     *  "de-DE"). Default: app locale. */
     readonly locale?: string;
 } & ResolvedPiiFlags;
 export type TimestampFieldDef = {
@@ -575,21 +571,20 @@ export type TimestampFieldDef = {
     readonly sensitive?: boolean;
     readonly access?: FieldAccess;
     /**
-     * Marker: dieses Timestamp-Feld ist Wall-Clock-Zeit an einem Ort.
-     * Wert ist der Name des begleitenden tz-Felds (IANA-Zone).
+     * Marker: this timestamp field represents wall-clock time at a location.
+     * The value is the name of the accompanying tz field (IANA zone).
      *
-     * Beispiel: manuelles Pair
+     * Example: manual pair
      *   { pickupAt: { type: "timestamp", locatedBy: "pickupTz" }, pickupTz: { type: "tz" } }
-     * — bevorzuge stattdessen `createLocatedTimestampField()`.
+     * — prefer `createLocatedTimestampField()` instead.
      */
     readonly locatedBy?: string;
-    /** Erlaubte Grenzen als ISO-Datetime. Begrenzt den Picker auf
-     *  Tages-Granularität; die exakte Uhrzeit-Grenze setzt das Zod-Schema
-     *  beim Write durch. */
+    /** Permitted bounds as ISO datetime values. The picker is limited to day
+     *  granularity; the Zod schema enforces the exact time bound on write. */
     readonly min?: string;
     readonly max?: string;
-    /** Format/Locale-Override für Anzeige und Eingabe-Parsing. Default =
-     *  App-Locale. */
+    /** Format/locale override for display and input parsing. Default: app
+     *  locale. */
     readonly locale?: string;
 } & ResolvedPiiFlags;
 export type TzFieldDef = {
@@ -607,13 +602,13 @@ export type LocatedTimestampFieldDef = {
     readonly filterable?: boolean;
     readonly sensitive?: boolean;
     readonly access?: FieldAccess;
-    /** Erlaubte Grenzen als ISO-Datetime (Wall-Clock). Begrenzt den Picker
-     *  auf Tages-Granularität; die exakte Uhrzeit-Grenze setzt das Zod-Schema
-     *  beim Write durch. */
+    /** Permitted bounds as ISO datetime values (wall-clock time). The picker is
+     *  limited to day granularity; the Zod schema enforces the exact time bound
+     *  on write. */
     readonly min?: string;
     readonly max?: string;
-    /** Format/Locale-Override für Anzeige und Eingabe-Parsing. Default =
-     *  App-Locale. */
+    /** Format/locale override for display and input parsing. Default: app
+     *  locale. */
     readonly locale?: string;
 } & ResolvedPiiFlags;
 export type FileFieldDef = {
@@ -673,7 +668,7 @@ export declare const FIELD_TYPE_NAMES: readonly FieldDefinition["type"][];
  *  secretMint) may declare it: a `money` field there has no entity to borrow
  *  `defaultCurrency` from, so it must name its own currency source, or the
  *  form seeds a bare `0` that the handler's zod schema then rejects
- *  (kumiko-framework#2839). Entity fields keep the optional `currency` —
+ *  . Entity fields keep the optional `currency` —
  *  `entity.defaultCurrency` is already boot-enforced for them. */
 export type FormFieldDefinition = Exclude<FieldDefinition, MoneyFieldDef> | (MoneyFieldDef & {
     readonly currency: MoneyCurrencySource;
@@ -707,35 +702,35 @@ export type DerivedFieldsMap = Readonly<Record<string, DerivedFieldDef>>;
  *  DerivedFieldDef` cast lying about a field that's actually missing. */
 export type ClientDerivedFieldDef = Pick<DerivedFieldDef, "valueType">;
 export type TransitionMap = Readonly<Record<string, readonly string[]>>;
-/** Composite-Index auf einer Entity. Spalten werden via field-Name
- *  referenziert (camelCase). buildEntityTable mapped sie auf snake_case-
- *  Spaltennamen und benennt den Index nach Convention:
+/** Composite index on an entity. Columns are referenced by field name
+ *  (camelCase). `buildEntityTable` maps them to snake_case column names and
+ *  names the index by convention:
  *
  *    <table>_<col1>_<col2>_idx          (non-unique)
  *    <table>_<col1>_<col2>_unique       (unique)
  *
- *  Eine `name`-Override ist erlaubt — Convention-Bruch in Bestandscode
- *  vermeidet Migration-Churn beim Refactor.
+ *  A `name` override is allowed to avoid migration churn when refactoring
+ *  existing code.
  *
- *  Single-column indices über `tenantId` sind redundant (buildEntityTable
- *  legt die immer automatisch an); die Boot-Validation warnt (außer
- *  `{ unique: true }` — semantische 1:1-Constraint, kein Performance-Hint). */
+ *  Single-column indexes over `tenantId` are redundant because
+ *  `buildEntityTable` creates them automatically; boot validation warns about
+ *  them unless `{ unique: true }`, which expresses a semantic 1:1 constraint
+ *  rather than a performance hint. */
 export type EntityIndexDef = {
     readonly columns: readonly [string, ...string[]];
     readonly unique?: boolean;
     readonly name?: string;
     /**
-     * Optional SQL-Fragment fuer Partial-Index — `CREATE [UNIQUE] INDEX
-     * ... WHERE <condition>`. Postgres-Pattern fuer "Index nur unter
-     * bestimmten Bedingungen", typisches Beispiel: ExportJob-Idempotency
-     * `UNIQUE(userId) WHERE status IN ('pending', 'running')`.
+     * Optional SQL fragment for a partial index — `CREATE [UNIQUE] INDEX
+     * ... WHERE <condition>`. This is PostgreSQL's pattern for indexing only
+     * rows that meet specified conditions; a typical example is export-job
+     * idempotency: `UNIQUE(userId) WHERE status IN ('pending', 'running')`.
      *
-     * Caller baut das Fragment via drizzle-orm `sql\`...\``-Tagged-
-     * Template. table-builder.ts emittiert `.where(def.where)` auf den
-     * Drizzle-IndexBuilder — wirkt sowohl fuer unique- als auch fuer
-     * non-unique-Indexes (PG erlaubt beides; non-unique partial nutzt
-     * man z.B. fuer scharfe BTREE-Indexes nur auf einer Status-Teilmenge
-     * statt voller Tabelle).
+     * Callers build the fragment with the drizzle-orm `sql\`...\`` tagged
+     * template. table-builder.ts emits `.where(def.where)` on the Drizzle
+     * IndexBuilder. It applies to both unique and non-unique indexes; a
+     * non-unique partial index can target a status subset instead of the full
+     * table.
      */
     readonly where?: unknown;
 };
@@ -800,17 +795,20 @@ export type EntityDefinition<F extends FieldsMap = FieldsMap, T extends EntityTe
     readonly lockedWhen?: FieldCondition;
     /** Allowed state transitions per field. Boot validates against select options. */
     readonly transitions?: Readonly<Record<string, TransitionMap>>;
-    /** Composite-Indices über mehrere Felder. Single-column FK-Indices und
-     *  der tenant_id-Index werden weiterhin automatisch von buildEntityTable
-     *  angelegt — diese Liste ist nur für Custom-Indices die der Author
-     *  explizit deklariert (z.B. `{ unique: true, columns: ["key", "tenantId", "userId"] }`). */
+    /** Composite indexes over multiple fields. Single-column foreign-key indexes
+     *  and the tenant_id index are still created automatically by
+     *  `buildEntityTable`; this list is only for custom indexes explicitly
+     *  declared by the author (for example,
+     *  `{ unique: true, columns: ["key", "tenantId", "userId"] }`). */
     readonly indexes?: readonly EntityIndexDef[];
     /**
-     * PK-Typ der Entity.
-     * - `"serial"` (default): bigserial integer — schneller, kompakter, perfekt für klassische CRUD-Entities.
-     * - `"uuid"`: uuid mit `gen_random_uuid()` default — verpflichtend für Entities deren `id` als
-     *   Foreign-Key-Wert in multi-tenant Kontexten reist (z.B. `tenant.id` IS der `tenantId`). Auch für
-     *   ES-Aggregate (Phase 2+) notwendig, da Events per UUID aggregiert werden.
+     * Entity primary-key type.
+     * - `"serial"` (default): bigserial integer — faster and more compact, suitable
+     *   for classic CRUD entities.
+     * - `"uuid"`: UUID with a `gen_random_uuid()` default — required for entities
+     *   whose `id` travels as a foreign-key value in multi-tenant contexts (for
+     *   example, `tenant.id` is the `tenantId`). Also required for event-sourced
+     *   aggregates because events are grouped by UUID.
      */
     readonly idType?: "serial" | "uuid";
     /**
@@ -837,19 +835,19 @@ export type EntityDefinition<F extends FieldsMap = FieldsMap, T extends EntityTe
      */
     readonly parentRef?: ParentRefDef;
     /**
-     * Default-Retention-Policy fuer diese Entity. Tenant-Admin kann via
-     * Compliance-Profile + Tenant-Override (Sprint 2) uebersteuern.
-     * Cleanup-Job (Sprint 2) verarbeitet die Strategy:
+     * Default retention policy for this entity. Tenant administrators can
+     *   override it through compliance profiles and tenant overrides.
+     *   The cleanup job applies these strategies:
      *
-     *   - "hardDelete" → Row physisch weg nach keepFor
-     *   - "softDelete" → deletedAt = now() (mit core-soft-delete-Feature)
-     *   - "anonymize"  → Felder mit `anonymize`-Funktion ueberschrieben,
-     *                    Row bleibt
-     *   - "blockDelete" → Cleanup-Job ignoriert; User-Forget loest
-     *                     stattdessen anonymize aus. Buchhaltung, Mandate,
-     *                     Patientenakten.
+     *   - "hardDelete" → physically remove the row after `keepFor`
+     *   - "softDelete" → set `deletedAt = now()` (with the core-soft-delete feature)
+     *   - "anonymize"  → overwrite fields with an `anonymize` function while the
+     *                    row remains
+     *   - "blockDelete" → the cleanup job skips the row; user forget instead
+     *                    triggers anonymization. Accounting records, mandates,
+     *                    and patient records.
      *
-     * Siehe docs/plans/features/core-data-retention.md.
+     * See docs/plans/features/core-data-retention.md.
      */
     readonly retention?: RetentionDef;
     /**
@@ -862,7 +860,7 @@ export type EntityDefinition<F extends FieldsMap = FieldsMap, T extends EntityTe
     readonly description?: string;
     /**
      * Opts this entity's rows into the `tenant-handover` bundled feature
-     * (kumiko-framework#3035): a row-bound-grant-legitimated ownership change
+     *: a row-bound-grant-legitimated ownership change
      * from an anonymous/public tenant to a freshly signed-up account's tenant.
      * An entity reachable from a transfer's root — the root itself, or any
      * entity whose `parentRef` names the root's type — that is NOT declared

package/dist/fields.js

@@ -12,7 +12,7 @@ export function optionsQueryFieldRefs(payload) {
 /** Qualified config key a `{ kind: "tenant" }` MoneyCurrencySource resolves
  *  against — the tenant-settings bundle's per-tenant currency. Lives here
  *  (client-safe) rather than framework/engine so renderer code can read it
- *  without a runtime-only import (kumiko-framework#2937). */
+ *  without a runtime-only import. */
 export const TENANT_CURRENCY_CONFIG_KEY = "tenant-settings:config:currency";
 // Exhaustive catalogue of `FieldDefinition["type"]` values, derived from a
 // `Record` so an added/removed union member fails to compile here instead of
@@ -41,13 +41,16 @@ const FIELD_TYPE_NAME_FLAGS = {
     files: true,
     images: true,
 };
-export const FIELD_TYPE_NAMES = Object.keys(FIELD_TYPE_NAME_FLAGS);
+function isFieldTypeName(name) {
+    return Object.hasOwn(FIELD_TYPE_NAME_FLAGS, name);
+}
+export const FIELD_TYPE_NAMES = Object.keys(FIELD_TYPE_NAME_FLAGS).filter(isFieldTypeName);
 // Field types with no bound, editable widget on the auto-wired entityEdit
 // path (render-field.tsx renders a read-only banner instead) — shared by
 // the boot validator (packages/framework/src/engine/boot-validator/screens.ts)
 // and the client-side required-field check (packages/renderer/src/app/form-schema.ts).
 // Embedded LIST fields (`multiple: true`) are the one exception — they get
-// their own EmbeddedListField grid widget (#1838) — callers must check that
+// their own EmbeddedListField grid widget — callers must check that
 // separately, this array alone doesn't distinguish plain embedded from embedded lists.
 // A plain array, not a Set: kumiko-types stays free of module-scope runtime
 // identity (guard-types-class-free.test.ts) since a consumer may resolve two

package/dist/handlers.d.ts

@@ -268,23 +268,23 @@ export type AppContext = SharedContextFields & {
         readonly id: string;
         readonly tenantId: TenantId;
     } | null;
-    /** Bei Job-Handler-Aufrufen die aus einem Event-Trigger heraus laufen
-     *  (r.job mit `trigger: { on: ... }`): der Name des Handlers der das
-     *  Event ausgelöst hat. Bei Multi-Trigger-Jobs (`on: [...]`) ist das
-     *  die einzige Möglichkeit für den Handler zu wissen WELCHER Trigger
-     *  gefeuert hat. Cron- und manual-Jobs lassen das Feld undefined. */
+    /** For job-handler calls triggered by an event
+     *  (`r.job` with `trigger: { on: ... }`): the name of the handler that
+     *  emitted the event. For multi-trigger jobs (`on: [...]`), this is the
+     *  only way for the handler to know which trigger fired. Cron and manual
+     *  jobs leave the field undefined. */
     readonly triggerName?: string;
-    /** Optionaler Geo→Zone-Adapter. Wenn gesetzt (via buildServer-context oder
-     *  runProdApp/runDevApp extraContext), reicht der Dispatcher ihn an
-     *  ctx.tz.fromCoordinates / fromAddress weiter. Ohne Provider werfen diese. */
+    /** Optional Geo→zone adapter. When set (via buildServer context or
+     *  `runProdApp`/`runDevApp` `extraContext`), the dispatcher passes it to
+     *  `ctx.tz.fromCoordinates` / `fromAddress`. These methods throw without
+     *  a provider. */
     readonly geoTzProvider?: GeoTzProvider;
     /** Overrides the system clock behind ctx.tz in handlers and jobs; tests inject a fixed time. */
     readonly clock?: Clock;
-    /** Tenant des aktuellen Pipeline-Calls. Wird vom Dispatcher beim Bauen
-     *  des HandlerContext aus `user.tenantId` gespiegelt, damit lifecycle-
-     *  pipeline + system-hooks den Wert ohne Zugriff auf user-Object haben.
-     *  Sprint-8a Tier-Composition: `effectiveFeatures(ctx._tenantId)`-call
-     *  in den hook-filter-Stellen. */
+    /** Tenant of the current pipeline call. The dispatcher mirrors
+     *  `user.tenantId` here when building HandlerContext so the lifecycle
+     *  pipeline and system hooks can access it without the user object.
+     *  `effectiveFeatures(ctx._tenantId)` uses it at hook-filter points. */
     readonly _tenantId?: TenantId;
     /** Boot-configured default locale (BCP-47). Last fallback in ctx.locale's
      *  Request-Locale → Boot-Default chain (dispatch-shared.ts) — used when
@@ -307,13 +307,11 @@ export type HandlerContext<TMap extends object = KumikoEventTypeMap> = SharedCon
     readonly systemDb?: UncheckedSystemDb;
     readonly crossTenantReads?: CrossTenantReads;
     readonly registry: Registry;
-    /** Aktiver SessionUser des Handler-Aufrufs — Convenience-Alias zu
-     *  `event.user`. Existiert weil Handler intuitiv `ctx.user.tenantId`
-     *  schreiben (Context = "kennt seinen User") und der Pfad sonst nur
-     *  über `event.user` läuft, was typo-anfällig ist und stillschweigend
-     *  zu `internal_error` führt wenn der falsche Pfad gewählt wird.
-     *  Identisch zum event.user-Wert; Identity-Switches nutzen
-     *  weiterhin queryAs/writeAs. */
+    /** The active SessionUser for the handler call, exposed as a convenience
+     *  alias for `event.user`. Handlers naturally write `ctx.user.tenantId`;
+     *  without the alias that path does not exist and silently ends in `internal_error`.
+     *  The value is identical to `event.user`; identity switches still use
+     *  `queryAs`/`writeAs`. */
     readonly user: SessionUser;
     readonly systemUser?: SessionUser;
     readonly log?: Logger;
@@ -676,7 +674,7 @@ export type QueryHandlerDef = {
      *  the boot-validator skips any column-reference check that would need
      *  it (screens.ts projectionList/relatedList `columns`, projectionDetail
      *  `header`/`metrics`, dashboard `valueField`/`subField`/etc.) rather
-     *  than requiring it retroactively. See fw#2493. */
+     *  than requiring it retroactively. */
     readonly outputSchema?: ZodType;
     /** Entities whose changes this query reflects. Anonymous callers with
      *  access to this query receive /api/sse change signals (no field values)

package/dist/http-route.d.ts

@@ -1,19 +1,19 @@
 import type { Context } from "hono";
 import type { RateLimitOption } from "./handlers.ts";
-/** Subset von HTTP-Methoden den wir aktiv unterstützen. Hono spricht
- *  alle, aber das hier sind die einzigen die ein Feature-Author
- *  realistisch deklariert. */
+/** Subset of HTTP methods actively supported. Hono supports all methods,
+ *  but these are the only ones a feature author is expected to declare. */
 export type HttpRouteMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
-/** Dependencies die der Handler vom Framework bekommt. App-Author kann
- *  die App selbst aufrufen (`deps.app.fetch(...)` für intern-call) oder
- *  direkt per dispatcher Daten ziehen. Db/Redis sind die rohen Connections
- *  — wer Tenant-Scope braucht muss durch dispatcher.query gehen.
+/** Dependencies provided to the handler by the framework. The app can be
+ *  called directly (`deps.app.fetch(...)` for internal calls), or data can
+ *  be fetched through the dispatcher. Db/Redis are raw connections — tenant
+ *  scoping requires going through dispatcher.query.
  *
- *  Hono-typing: `Context<any, any>` weil das Hono-Type-Param-Setup nur
- *  intern relevant ist. Concrete Hono-app wird im Boot-Path zugewiesen. */
+ *  Hono typing: `Context<any, any>` is used because Hono's type-parameter
+ *  setup is only relevant internally. The concrete Hono app is assigned
+ *  during boot. */
 export type HttpRouteHandlerDeps = {
-    /** Die Hono-app — Handler kann via app.fetch(...) interne Routes
-     *  ansprechen (z.B. /api/query mit der vollen Auth-/Anonymous-Chain). */
+    /** The Hono app — the handler can use app.fetch(...) to call internal routes
+     *  (e.g. /api/query with the full auth/anonymous chain). */
     readonly app: import("hono").Hono<any, any>;
     /** Run a query handler in-process, forcing a SPECIFIC tenant — WITHOUT
      *  going through the public /api/query HTTP layer (no header parsing, no
@@ -45,9 +45,9 @@ export type HttpRouteRateLimit = Omit<RateLimitOption, "per"> & {
     readonly per: "ip" | "ip+handler";
 };
 export type HttpRouteDefinition = {
-    /** HTTP-Methode — bei Hono-Mount via app.{get,post,...}(path). */
+    /** HTTP method — mounted in Hono via app.{get,post,...}(path). */
     readonly method: HttpRouteMethod;
-    /** URL-Pfad (Hono-Pattern, z.B. "/feed.xml" oder "/og/:tenantId.png"). */
+    /** URL path (Hono pattern, e.g. "/feed.xml" or "/og/:tenantId.png"). */
     readonly path: string;
     /** true = public, no session required. false = mounted behind the
      *  session auth chain (global IP rate limit when configured, PII
@@ -56,8 +56,8 @@ export type HttpRouteDefinition = {
      *  `/api/*` chain only. A request without a session gets 401. The
      *  handler reads the caller via getUser(c). */
     readonly anonymous: boolean;
-    /** Hono-Handler. Bekommt Hono-Context + Framework-Deps; returnt
-     *  Response (sync oder async). */
+    /** Hono handler. Receives the Hono context and framework dependencies;
+     *  returns a Response synchronously or asynchronously. */
     readonly handler: HttpRouteHandler;
     /** Enforced before the route's guards through the server's rate-limit
      *  resolver (fail-open like the global L1 limiter: a limiter outage

package/dist/http-route.js

@@ -4,7 +4,7 @@
 // feature author controls the wire format themselves.
 //
 // Pattern symmetric to r.queryHandler / r.writeHandler: definition as
-// part of the feature (not the app bootstrapping). Phase-3 multi-tenant
+// part of the feature (not the app bootstrapping). Multi-tenant support
 // becomes trivial because tenant context is picked up via host resolution.
 //
 // Escape-hatch stays: runProdApp.extraRoutes (declarative list with

package/dist/screen-action-form.d.ts

@@ -55,7 +55,7 @@ export type ActionFormScreenDefinition = {
      *  validator).
      *
      *  A `money` field here must name its own currency source: this screen
-     *  has no entity whose `defaultCurrency` it could inherit (fw#2839). */
+     *  has no entity whose `defaultCurrency` it could inherit. */
     readonly fields: Readonly<Record<string, FormFieldDefinition>>;
     /** Fields computed from other fields, shown read-only and recomputed on every
      *  change. A `listSum` over an empty list without `whenEmpty` leaves the field
@@ -109,7 +109,7 @@ export type ActionFormScreenDefinition = {
      *  The object form additionally names the success-payload field the
      *  navigation id comes from (`ActionFormRedirect.idFrom`) — needed when
      *  the handler creates a child record but the target screen is the
-     *  parent's detail screen (fw#2670). */
+     *  parent's detail screen. */
     readonly redirect?: string | ActionFormRedirect;
     /** Links shown in the success box after a successful submit while the
      *  screen stays put. Targets resolve like `redirect` (the id comes from the
@@ -164,7 +164,7 @@ export type ActionFormFooterAction = {
  *  id. The write-handler reports the id of what it wrote (`data.id`); when
  *  that record is a child and the target screen shows its parent, the
  *  parent id has to be read from a different field instead of forcing the
- *  handler to misreport its own result (fw#2670). */
+ *  handler to misreport its own result. */
 export type ActionFormRedirect = {
     /** Same target forms as the string `redirect`: short screen ID
      *  (same-feature) or a fully-qualified cross-feature screen QN. */

package/dist/screen-custom-config.d.ts

@@ -21,14 +21,13 @@ export type CustomScreenDefinition = {
     readonly access?: AccessRule;
     /** This screen is registered without a self-owned `r.nav()` entry by
      *  design — an app opts in by navving it explicitly (e.g. a settings-area
-     *  self-service screen). `createKumikoApp`'s boot diagnostic
-     *  (kumiko-framework#2025) skips dormant screens instead of flagging
-     *  every consumer that doesn't mount the client plugin as a false
-     *  positive (kumiko-framework#2034). Only set this on screens the
-     *  feature itself never navs — a screen the feature DOES nav still needs
-     *  its client plugin mounted by every consumer, and should keep
-     *  triggering the diagnostic if it's missing. Also gates the
-     *  boot-validator's nav-area check, same as `dormant` on other screens. */
+     *  self-service screen). `createKumikoApp`'s boot diagnostic skips dormant
+     *  screens instead of flagging every consumer that doesn't mount the client
+     *  plugin as a false positive. Only set this on screens the feature itself
+     *  never navs — a screen the feature DOES nav still needs its client plugin
+     *  mounted by every consumer, and should keep triggering the diagnostic if
+     *  it's missing. Also gates the boot-validator's nav-area check, same as
+     *  `dormant` on other screens. */
     readonly dormant?: boolean;
     /** UI-only gate, also on direct URL access; handlers still enforce access. Unmet or failed renders `fallback`. */
     readonly visibleWhen?: DashboardPanelVisibility;

package/dist/screen-entity-edit.d.ts

@@ -149,7 +149,7 @@ export type EditExtensionSection = {
      *  surrounding form's Save button should activate for its dirty state.
      *  Omit/false for extensions that persist through their own dispatcher
      *  writes (e.g. notes-history NotesSection) — otherwise a read-only form
-     *  shows a Save button that does nothing (fw#2359). */
+     *  shows a Save button that does nothing. */
     readonly contributesToFormSubmit?: boolean;
     /** Overrides the host-derived entity name passed to the mounted component.
      *  Required on `projectionDetail` (which has no real entity — the host

package/dist/screen-entity-list.d.ts

@@ -105,7 +105,7 @@ export type RowActionWriteHandler = {
     readonly kind?: "writeHandler";
     /** Stable id per screen — kebab-case, unique within the action set. */
     readonly id: string;
-    /** Anzeige-Text (i18n-Key). */
+    /** Display text (i18n key). */
     readonly label: string;
     /** Qualified name of the server handler, e.g.
      *  "publicstatus:write:maintenance:start". Dispatched via
@@ -188,7 +188,7 @@ export type RowActionNavigate = RowActionNavigateBase & ({
     readonly screen: string;
     readonly entity?: never;
 } | {
-    /** Entity name instead of screen id (fw#2228) — resolves at boot time to
+    /** Entity name instead of screen id — resolves at boot time to
      *  the screen that declares `detailFor: "<entity>"` (see ObjectTarget/
      *  resolveTarget in @cosmicdrift/kumiko-renderer's nav.tsx). */
     readonly entity: string;

package/dist/screen-projection.d.ts

@@ -86,7 +86,7 @@ export type ProjectionListScreenDefinition = {
      *  param present). Same type serves author and wire schema (no separate
      *  client-facing screen type exists), so this stays structurally
      *  writable — validateProjectionListScreens rejects any hand-authored
-     *  value at boot (fw#2165). */
+     *  value at boot. */
     readonly sortable?: boolean;
     /** Derived by buildAppSchema from the query handler's Zod schema (`cursor`
      *  or `offset` param present). See `sortable` doc for why this is
@@ -212,6 +212,6 @@ export type ProjectionDetailScreenDefinition = {
     /** How head fields render. Default "text" — plain text instead of a
      *  disabled Input, since every field on this screen type is forced
      *  readOnly anyway (there is no write path, see the shim doc above).
-     *  Set "form" to opt back into the disabled-Input look (fw#2245). */
+     *  Set "form" to opt back into the disabled-Input look. */
     readonly valueDisplay?: "form" | "text";
 };

package/dist/screen.d.ts

@@ -91,7 +91,7 @@ export type ScreenSlots = {
     readonly sidebar?: PlatformComponent;
     readonly footer?: PlatformComponent;
     /** entityEdit wizard: marks `footer` as the sticky-footer primary action
-     *  (fw#1918's pinned `max-sm:fixed` group on mobile) instead of the
+     *  (pinned `max-sm:fixed` group on mobile) instead of the
      *  non-sticky secondary bucket it falls into by default alongside
      *  Back/Cancel. Set this when `footer` renders the screen's actual
      *  submit-type action (e.g. a custom "Publish" button standing in for, or

package/dist/step.d.ts

@@ -39,7 +39,7 @@ export type PipelineCtx<TPayload = unknown, TMap extends object = KumikoEventTyp
          */
         readonly retryAttempt?: number;
         /**
-         * Q7 Snapshot-at-Start fingerprint of the workflow definition that
+         * Snapshot-at-Start fingerprint of the workflow definition that
          * started this run. Propagated into every suspension event payload so
          * the resume-loop can detect library-upgrades that changed the closure
          * source and surface them as a typed failure instead of running a

package/dist/target-ref.js

@@ -1,16 +1,13 @@
-// TargetRef — runtime-Repräsentation eines typed buildTarget-Outputs.
-// Wird vom Visual-Tree-Component (renderer/web) an einen Target-Resolver
-// dispatcht; der Resolver findet die Editor-Maske via featureId.
+// TargetRef — runtime representation of a typed buildTarget output.
+// It is dispatched by the Visual Tree component (renderer/web) to a target
+// resolver, which finds the editor form via featureId.
 //
-// **Compile-time-Safety:** TargetRef wird niemals hand-getippt. Stattdessen
-// erzeugt der typed buildTarget-Builder (engine/build-target.ts) einen
-// TargetRef, dessen action + args gegen die treeActions-Map des Ziel-
-// Features validiert sind.
+// **Compile-time safety:** TargetRef is never written by hand. Instead, the
+// typed buildTarget builder (engine/build-target.ts) creates a TargetRef whose
+// action + args are validated against the target feature's treeActions map.
 //
-// **Runtime:** args sind hier untyped (Record<string, unknown>), weil
-// TargetRef die erased-runtime-Version ist. Der Resolver kennt das
-// Ziel-Feature und kann args entsprechend casten — ähnlich wie Event-
-// Payloads im Event-Store.
-//
-// Siehe docs/plans/architecture/visual-tree.md A5.
+// **Runtime:** args are untyped here (Record<string, unknown>) because
+// TargetRef is the erased runtime version. The resolver knows the target
+// feature and can cast args accordingly, similar to event payloads in the
+// event store.
 export {};

package/dist/tree-node.js

@@ -1,22 +1,22 @@
-// TreeNode — single Knoten im Client-navProvider-Tree. Provider liefern
-// entweder statische readonly TreeNode[] oder dynamische TreeChildrenSubscribe.
+// TreeNode — a single node in the client nav-provider tree. Providers return
+// either static readonly TreeNode[] or dynamic TreeChildrenSubscribe.
 //
-// **Mental-Modell** (VS-Code-Explorer):
+// **Mental model** (VS Code Explorer):
 //   [icon] [label] [...hover-actions]
-// optional ein target zum Klicken (öffnet Editor-Maske via
-// Target-Resolver) und optional children als nested tree.
+// An optional target makes the node clickable (opening an editor form via
+// the target resolver), and optional children form a nested tree.
 //
-// **State** markiert Visual-Modus für Skeleton-Pattern:
-//   - "filled" (default) — schwarz, Knoten hat Inhalt
-//   - "stub" — hellgrau, existing aber leer (Designer-Stub-File)
-//   - "empty" — Platzhalter für "+ create"-Affordance
-//   - "loading" — Children werden gerade aufgelöst
-//   - "error" — Provider hat Fehler emittiert
-// Provider die kein Skeleton-Pattern brauchen müssen state nicht setzen.
+// **State** selects the visual mode for the skeleton pattern:
+//   - "filled" (default) — black; the node has content
+//   - "stub" — light gray; existing but empty (designer stub file)
+//   - "empty" — placeholder for the "+ create" affordance
+//   - "loading" — children are currently being resolved
+//   - "error" — the provider emitted an error
+// Providers that do not need the skeleton pattern can omit state.
 //
-// **Subscribe-Form** für dynamic Children: Provider erhält emit(),
-// gibt unsubscribe() zurück. Initial-Emit synchron oder async, weitere
-// Emits beliebig oft (z.B. wenn Entity-Row neu erscheint via SSE).
-// Spielt natürlich mit existing SSE-Frame: ein Provider kann intern
-// auf Entity-Update-Events abonnieren und bei Änderung emit() aufrufen.
+// **Subscribe form** for dynamic children: the provider receives emit()
+// and returns unsubscribe(). The initial emit may be synchronous or async;
+// further emits may occur arbitrarily often (for example, when an entity row
+// appears through SSE). This works with the existing SSE frame: a provider
+// can subscribe internally to entity-update events and call emit() on change.
 export {};

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@cosmicdrift/kumiko-types",
-  "version": "0.386.0",
+  "version": "0.387.0",
   "description": "Framework-Type-Definitions für Kumiko — FeatureDefinition, BootCheck-Types und die reinen Engine-Types. Erlaubt Downstream-Konsumenten, gegen die Type-Contracts zu bauen, ohne das ganze Framework-Package zu importieren. Enthaelt keine identitaets-sensitiven Runtime-Werte mehr (Error-Klassen leben seit #1629 in kumiko-framework, Brand-Symbole nutzen Symbol.for) und ist deshalb eine plain dependency, keine peerDependency.",
-  "license": "BUSL-1.1",
+  "license": "MIT",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
   "repository": {
     "type": "git",