@cosmicdrift/kumiko-framework 0.350.0 → 0.352.0

package/dist/bun-db/query.js

@@ -19,9 +19,9 @@
 //     drizzle's getTableName + getTableColumns (drizzle kept only as a type
 //     reference, never as a runtime API call)
 import { KUMIKO_META_SYMBOL } from "@cosmicdrift/kumiko-types/schema-table-types";
-// Static polyfill import (not getTemporal()): coercion results stay on one
-// Temporal implementation repo-wide, even when Bun exposes a global (#1480).
-import { Temporal } from "temporal-polyfill";
+// Static import (not getTemporal()): coercion works without an installed
+// global and returns the same Temporal classes as the rest of the repo (#1480).
+import { Temporal } from "@cosmicdrift/kumiko-types/temporal";
 import { requestContext } from "../api/request-context.js";
 import { computeBlindIndex, configuredBlindIndexKey } from "../crypto/blind-index.js";
 import { isPiiCiphertext } from "../crypto/pii-ciphertext-format.js";

package/dist/db/dialect.d.ts

@@ -1,5 +1,5 @@
 import { type ColumnHandle, type SchemaTable } from "@cosmicdrift/kumiko-types/schema-table-types";
-import { Temporal } from "temporal-polyfill";
+import { Temporal } from "@cosmicdrift/kumiko-types/temporal";
 import type { PgType } from "./entity-table-meta.js";
 export type { ColumnHandle, SchemaTable } from "@cosmicdrift/kumiko-types/schema-table-types";
 export type TableColumns<_T = any> = SchemaTable;

package/dist/db/dialect.js

@@ -13,10 +13,11 @@
 // The framework no longer imports drizzle-orm at runtime — schema-files
 // use only this module.
 //
-// Static import, not the ambient global: Bun doesn't expose Temporal on
-// globalThis, so instantToDriver crashed on timestamptz writes (#1480).
+// Static import of the shared Temporal module, not the ambient global: the
+// global may be absent (Hermes/Safari) or torn down in tests, and instantToDriver
+// crashed on timestamptz writes without it (#1480).
 import { KUMIKO_COLUMNS_SYMBOL, KUMIKO_META_SYMBOL, KUMIKO_NAME_SYMBOL, } from "@cosmicdrift/kumiko-types/schema-table-types";
-import { Temporal } from "temporal-polyfill";
+import { Temporal } from "@cosmicdrift/kumiko-types/temporal";
 function isNumericPgType(t) {
     return t.startsWith("numeric(");
 }

package/dist/db/located-timestamp.js

@@ -11,7 +11,7 @@
 // Static import, not the ambient global: Bun doesn't expose Temporal on
 // globalThis, so this crashed with "Temporal is not defined" outside boot
 // paths that install it (#1480).
-import { Temporal } from "temporal-polyfill";
+import { Temporal } from "@cosmicdrift/kumiko-types/temporal";
 // Sprint F: <name>Utc-Spalte ist jetzt instant() (siehe dialect.ts) —
 // Drizzle gibt direkt Temporal.Instant zurück. Vor Sprint F kam ein PG-
 // Wire-Format-String "2026-04-15 09:00:00+00" rein der via String-Massage

package/dist/db/queries/seed-context.d.ts

@@ -1,3 +1,4 @@
+import type { DbRunner } from "../connection.js";
 import type { AnyDb } from "../query.js";
 export type SeedUserRow = {
     readonly id: string;
@@ -18,3 +19,19 @@ export type SeedTenantDbRow = {
 export declare function selectUserByEmail(db: AnyDb, email: string): Promise<SeedUserRow | null>;
 export declare function selectMembershipsOfUser(db: AnyDb, userId: string): Promise<readonly SeedMembershipDbRow[]>;
 export declare function selectAllTenants(db: AnyDb): Promise<readonly SeedTenantDbRow[]>;
+export type SeedTemplateResourceDbRow = {
+    readonly id: string;
+    readonly tenant_id: string;
+    readonly slug: string;
+    readonly kind: string;
+    readonly locale: string;
+    readonly status: string;
+};
+export type SeedTemplateResourceDbFilter = {
+    readonly tenantId: string;
+    readonly slug?: string;
+    readonly kind?: string;
+    readonly status?: string;
+    readonly locale?: string;
+};
+export declare function selectTemplateResources(db: DbRunner, filter: SeedTemplateResourceDbFilter): Promise<readonly SeedTemplateResourceDbRow[]>;

package/dist/db/queries/seed-context.js

@@ -1,4 +1,6 @@
 import { unsafeReadRetrying } from "../query.js";
+import { tableExists } from "../schema-inspection.js";
+import { SOFT_DELETE_LIVE_ROW_PREDICATE } from "../table-builder.js";
 export async function selectUserByEmail(db, email) {
     const rows = await unsafeReadRetrying(db, `SELECT id::text AS id, email, tenant_id::text AS tenant_id
      FROM read_users
@@ -23,3 +25,27 @@ export async function selectAllTenants(db) {
      FROM read_tenants
      ORDER BY inserted_at`, []);
 }
+// Column names are fixed fragments; every filter value is a bound parameter.
+// template-resolver is an optional feature — without its table the answer is
+// "no templates", not an error.
+export async function selectTemplateResources(db, filter) {
+    if (!(await tableExists(db, "read_template_resources")))
+        return [];
+    const conditions = ["tenant_id = $1", SOFT_DELETE_LIVE_ROW_PREDICATE];
+    const params = [filter.tenantId];
+    for (const [column, value] of [
+        ["slug", filter.slug],
+        ["kind", filter.kind],
+        ["status", filter.status],
+        ["locale", filter.locale],
+    ]) {
+        if (value === undefined)
+            continue;
+        params.push(value);
+        conditions.push(`${column} = $${params.length}`);
+    }
+    return unsafeReadRetrying(db, `SELECT id::text AS id, tenant_id::text AS tenant_id, slug, kind, locale, status
+     FROM read_template_resources
+     WHERE ${conditions.join(" AND ")}
+     ORDER BY slug, locale`, params);
+}

package/dist/db/table-builder.d.ts

@@ -167,20 +167,20 @@ export declare function buildBaseColumns(softDelete: boolean, idType?: "serial"
     id: ColumnBuilder<string> | ColumnBuilder<number>;
     tenantId: ColumnBuilder<string>;
     version: ColumnBuilder<number>;
-    insertedAt: ColumnBuilder<import("temporal-spec").Temporal.Instant>;
-    modifiedAt: ColumnBuilder<import("temporal-spec").Temporal.Instant>;
+    insertedAt: ColumnBuilder<Temporal.Instant>;
+    modifiedAt: ColumnBuilder<Temporal.Instant>;
     insertedById: ColumnBuilder<string>;
     modifiedById: ColumnBuilder<string>;
 } | {
     id: ColumnBuilder<string> | ColumnBuilder<number>;
     tenantId: ColumnBuilder<string>;
     version: ColumnBuilder<number>;
-    insertedAt: ColumnBuilder<import("temporal-spec").Temporal.Instant>;
-    modifiedAt: ColumnBuilder<import("temporal-spec").Temporal.Instant>;
+    insertedAt: ColumnBuilder<Temporal.Instant>;
+    modifiedAt: ColumnBuilder<Temporal.Instant>;
     insertedById: ColumnBuilder<string>;
     modifiedById: ColumnBuilder<string>;
     isDeleted: ColumnBuilder<boolean>;
-    deletedAt: ColumnBuilder<import("temporal-spec").Temporal.Instant>;
+    deletedAt: ColumnBuilder<Temporal.Instant>;
     deletedById: ColumnBuilder<string>;
 };
 export declare function rowMetaFieldNames(softDelete: boolean): ReadonlySet<string>;

package/dist/engine/boot-validator/entity-handler.d.ts

@@ -19,6 +19,7 @@ export declare function validateFileFields(feature: FeatureDefinition): boolean;
 export declare function validateReferenceFields(feature: FeatureDefinition, featureMap: ReadonlyMap<string, FeatureDefinition>, queryHandlers: ReadonlyMap<string, QueryHandlerDef>): void;
 export declare function validateEmbeddedFields(feature: FeatureDefinition, featureMap: ReadonlyMap<string, FeatureDefinition>, queryHandlers: ReadonlyMap<string, QueryHandlerDef>): void;
 export declare function validateEntitySelectOptionsQuery(feature: FeatureDefinition): void;
+export declare function validateEntitySelectAvailabilityQuery(feature: FeatureDefinition, queryHandlers: ReadonlyMap<string, QueryHandlerDef>): void;
 export declare function validateMultiSelectFields(feature: FeatureDefinition): void;
 export declare function validateImageVariants(feature: FeatureDefinition): void;
 export declare function validateTransitions(feature: FeatureDefinition): void;

package/dist/engine/boot-validator/entity-handler.js

@@ -692,6 +692,23 @@ function assertNoSelectOptionsQuery(field, path, featureName) {
         throw new Error(`[Feature ${featureName}] Entity select field "${path}" declares optionsQuery — not supported on entity fields because the stored value would not be validated against the query result. Use static options, or a reference field.`);
     }
 }
+// A typo'd availability QN would only surface as a failed query when the form
+// mounts, so it is pinned at boot like the other option queries.
+export function validateEntitySelectAvailabilityQuery(feature, queryHandlers) {
+    for (const [entityName, entity] of Object.entries(feature.entities ?? {})) {
+        for (const [fieldName, field] of Object.entries(entity.fields)) {
+            if (field.type !== "select" || field.optionsAvailabilityQuery === undefined)
+                continue;
+            const query = field.optionsAvailabilityQuery;
+            if (query.length === 0 || !queryHandlers.has(query)) {
+                throw new Error(`[Feature ${feature.name}] Select field "${fieldName}" on entity "${entityName}" ` +
+                    `declares optionsAvailabilityQuery "${query}" which is not a registered query-handler. ` +
+                    `Check the QN spelling (expected "<feature>:query:<short>") and that the handler ` +
+                    `is declared via r.queryHandler(...).`);
+            }
+        }
+    }
+}
 export function validateMultiSelectFields(feature) {
     for (const [entityName, entity] of Object.entries(feature.entities ?? {})) {
         for (const [fieldName, field] of Object.entries(entity.fields)) {

package/dist/engine/boot-validator/index.js

@@ -9,7 +9,7 @@ import { validateApiExposureMatching, validateExtensionUsages } from "./api-ext.
 import { validateFeatureBootChecks } from "./boot-check.js";
 import { validateCircularDeps, validateConfigKeyAllowPerRequest, validateConfigKeyBacking, validateConfigKeyBounds, validateConfigKeyComputed, validateConfigKeyOptionsQuery, validateConfigKeyPiiEncrypted, validateConfigKeyRequired, validateConfigReads, warnOnToggleableDependencies, } from "./config-deps.js";
 import { collectDetailForScreens } from "./detail-screens.js";
-import { validateDerivedFieldCollisions, validateEmbeddedFields, validateEncryptedFields, validateEntityIndexes, validateEntitySelectOptionsQuery, validateExtendSchemaCollisions, validateExtensionPreSaveWiring, validateFileFields, validateHandlerAccess, validateImageVariants, validateLocatedTimestamps, validateMultiSelectFields, validateMultiStreamProjections, validateReferenceFields, validateSearchableFieldReadAccess, validateTransitions, } from "./entity-handler.js";
+import { validateDerivedFieldCollisions, validateEmbeddedFields, validateEncryptedFields, validateEntityIndexes, validateEntitySelectAvailabilityQuery, validateEntitySelectOptionsQuery, validateExtendSchemaCollisions, validateExtensionPreSaveWiring, validateFileFields, validateHandlerAccess, validateImageVariants, validateLocatedTimestamps, validateMultiSelectFields, validateMultiStreamProjections, validateReferenceFields, validateSearchableFieldReadAccess, validateTransitions, } from "./entity-handler.js";
 import { validateEntityListScreens } from "./entity-list-screens.js";
 import { validateGdprStoragePersistence } from "./gdpr-storage.js";
 import { validateGlobalTenancyEntities } from "./global-tenancy.js";
@@ -169,6 +169,7 @@ export function validateBoot(rawFeatures, options) {
         validateRecordOwnedSubjects(feature);
         validateApiExposureMatching(feature, allExposedApis, featureMap);
         validateEntitySelectOptionsQuery(feature);
+        validateEntitySelectAvailabilityQuery(feature, queryHandlerQns);
         validateEmbeddedFields(feature, featureMap, queryHandlerQns);
         validateMultiSelectFields(feature);
         validateImageVariants(feature);

package/dist/engine/boot-validator/query-output-columns.js

@@ -175,6 +175,9 @@ function checkVisibleWhenField(queryHandlers, visibleWhen, owner) {
 }
 function checkDashboardOutputFields(queryHandlers, featureName, screenId, screen) {
     for (const panel of screen.panels) {
+        if (panel.kind !== "custom") {
+            checkVisibleWhenField(queryHandlers, panel.visibleWhen, `[Feature ${featureName}] Screen "${screenId}" (dashboard) ${panel.kind === "screen" ? "screen-panel" : "panel"} "${panel.id}"`);
+        }
         if (panel.kind === "stat") {
             checkDashboardStatPanelFields(queryHandlers, featureName, screenId, panel);
         }
@@ -183,9 +186,6 @@ function checkDashboardOutputFields(queryHandlers, featureName, screenId, screen
                 checkDashboardStatPanelFields(queryHandlers, featureName, screenId, stat);
             }
         }
-        else if (panel.kind === "screen") {
-            checkVisibleWhenField(queryHandlers, panel.visibleWhen, `[Feature ${featureName}] Screen "${screenId}" (dashboard) screen-panel "${panel.id}"`);
-        }
         else if (panel.kind === "list") {
             const rowShape = resolveListRowShape(queryHandlers, panel.query, `[Feature ${featureName}] Screen "${screenId}" (dashboard) panel "${panel.id}"`);
             for (const column of panel.columns) {

package/dist/engine/boot-validator/query-refs.js

@@ -26,12 +26,11 @@ function checkDashboardQueryRefs(queryHandlers, featureName, screenId, screen) {
     for (const panel of screen.panels) {
         if (panel.kind === "custom")
             continue;
-        if (panel.kind === "screen") {
-            if (panel.visibleWhen !== undefined) {
-                checkQueryRef(queryHandlers, panel.visibleWhen.query, () => `[Feature ${featureName}] Screen "${screenId}" (dashboard) screen-panel "${panel.id}" visibleWhen`);
-            }
-            continue;
+        if (panel.visibleWhen !== undefined) {
+            checkQueryRef(queryHandlers, panel.visibleWhen.query, () => `[Feature ${featureName}] Screen "${screenId}" (dashboard) ${panel.kind === "screen" ? "screen-panel" : "panel"} "${panel.id}" visibleWhen`);
         }
+        if (panel.kind === "screen")
+            continue;
         if (panel.kind === "stat-group") {
             for (const stat of panel.stats) {
                 checkQueryRef(queryHandlers, stat.query, () => `[Feature ${featureName}] Screen "${screenId}" (dashboard) stat-group "${panel.id}" child "${stat.id}"`);
@@ -46,9 +45,14 @@ function checkDashboardQueryRefs(queryHandlers, featureName, screenId, screen) {
 }
 function checkFormFieldQueryRefs(queryHandlers, featureName, screenId, screenType, fields) {
     for (const [fieldName, field] of Object.entries(fields)) {
-        if (field.type !== "select" || field.optionsQuery === undefined)
+        if (field.type !== "select")
             continue;
-        checkQueryRef(queryHandlers, field.optionsQuery, () => `[Feature ${featureName}] Screen "${screenId}" (${screenType}) select field "${fieldName}" optionsQuery`);
+        if (field.optionsQuery !== undefined) {
+            checkQueryRef(queryHandlers, field.optionsQuery, () => `[Feature ${featureName}] Screen "${screenId}" (${screenType}) select field "${fieldName}" optionsQuery`);
+        }
+        if (field.optionsAvailabilityQuery !== undefined) {
+            checkQueryRef(queryHandlers, field.optionsAvailabilityQuery, () => `[Feature ${featureName}] Screen "${screenId}" (${screenType}) select field "${fieldName}" optionsAvailabilityQuery`);
+        }
     }
 }
 function checkScreenQueryRefs(queryHandlers, featureName, screenId, screen) {

package/dist/engine/boot-validator/screens.js

@@ -493,7 +493,8 @@ function rejectWriteOnlyFormField(featureName, screenId, context, fieldName, fde
     }
 }
 // Static options XOR optionsQuery on inline-form select fields, and `{ field }`
-// payload refs must name another field of the same form. The QN existence check
+// payload refs must name another field of the same form (the payload also feeds
+// optionsAvailabilityQuery). The QN existence check
 // lives in query-refs.ts with the other query refs.
 function validateFormSelectOptions(featureName, screenId, context, fieldName, fdef, siblingFieldNames) {
     if (fdef.type === "select") {
@@ -507,6 +508,12 @@ function validateFormSelectOptions(featureName, screenId, context, fieldName, fd
             }
             validateOptionsQueryFieldRefs(where, fieldName, fdef.optionsQueryPayload, siblingFieldNames);
         }
+        else if (fdef.optionsAvailabilityQuery !== undefined) {
+            if (fdef.optionsAvailabilityQuery.length === 0) {
+                throw new Error(`${where} has an empty optionsAvailabilityQuery`);
+            }
+            validateOptionsQueryFieldRefs(where, fieldName, fdef.optionsQueryPayload, siblingFieldNames);
+        }
         else if (fdef.optionsQueryPayload !== undefined) {
             throw new Error(`${where} has optionsQueryPayload without optionsQuery`);
         }
@@ -1729,17 +1736,33 @@ export function validateDashboardScreenPanel(featureName, screenId, panel, featu
             `navigate away from the dashboard on submit or cancel. Embed a screen without redirect and ` +
             `with cancelTarget: false (or omitted).`);
     }
-    const visibleWhen = panel.visibleWhen;
+    validateDashboardPanelVisibleWhen(context, panel.visibleWhen);
+}
+function validateDashboardPanelVisibleWhen(context, visibleWhen) {
     if (visibleWhen !== undefined && (visibleWhen.query === "" || visibleWhen.field === "")) {
         throw new Error(`${context} visibleWhen needs a non-empty query and field.`);
     }
 }
+function validateDashboardPanelSpan(featureName, screenId, panel) {
+    if (panel.span !== undefined && panel.span !== "half" && panel.span !== "full") {
+        throw new Error(`[Feature ${featureName}] Screen "${screenId}" (dashboard) panel "${panel.id}" has span "${String(panel.span)}" — expected "half" or "full".`);
+    }
+}
 function validateDashboardStatGroupPanel(featureName, screenId, panel, addPanelId) {
+    const context = `[Feature ${featureName}] Screen "${screenId}" (dashboard) stat-group "${panel.id}"`;
     if (panel.stats.length === 0) {
-        throw new Error(`[Feature ${featureName}] Screen "${screenId}" (dashboard) stat-group "${panel.id}" has an empty stats list.`);
+        throw new Error(`${context} has an empty stats list.`);
     }
+    if (panel.subtitle !== undefined && panel.label === undefined) {
+        throw new Error(`${context} sets subtitle without label — an unlabeled group renders as a KPI strip without a header.`);
+    }
+    validateDashboardPanelSpan(featureName, screenId, panel);
+    validateDashboardPanelVisibleWhen(context, panel.visibleWhen);
     for (const stat of panel.stats) {
         addPanelId(stat.id, "stat-group child");
+        if (stat.visibleWhen !== undefined) {
+            throw new Error(`${context} child "${stat.id}" sets visibleWhen — gate the whole group instead; a hidden cell would leave a gap in the strip.`);
+        }
         if (!stat.query || typeof stat.query !== "string") {
             throw new Error(`[Feature ${featureName}] Screen "${screenId}" (dashboard) stat-group "${panel.id}" child "${stat.id}" has empty or non-string query.`);
         }
@@ -1758,6 +1781,67 @@ function validateDashboardChartDisplay(featureName, screenId, panel) {
     if (panel.scrollable === true && panel.chart !== "stacked-area") {
         throw new Error(`${where} sets scrollable on chart "${panel.chart}" — only "stacked-area" supports it.`);
     }
+    validateStackedAreaOnlyProps(where, panel);
+    if (panel.legendTotals !== undefined && typeof panel.legendTotals !== "boolean") {
+        throw new Error(`${where} has a non-boolean legendTotals.`);
+    }
+    for (const [key, color] of Object.entries(panel.seriesColors ?? {})) {
+        if (typeof color !== "string" || color.trim() === "") {
+            throw new Error(`${where} seriesColors["${key}"] must be a non-empty CSS color.`);
+        }
+    }
+    for (const [kind, look] of Object.entries(panel.markerKinds ?? {})) {
+        validateDashboardChartMarkerKind(`${where} markerKinds["${kind}"]`, look);
+    }
+    if (panel.ranges !== undefined)
+        validateDashboardChartRanges(`${where} ranges`, panel.ranges);
+}
+function validateStackedAreaOnlyProps(where, panel) {
+    // skip: stacked-area is the one chart kind that supports these props
+    if (panel.chart === "stacked-area")
+        return;
+    const stackedAreaOnly = ["markerKinds", "legendTotals", "ranges"].filter((prop) => panel[prop] !== undefined);
+    if (stackedAreaOnly.length > 0) {
+        throw new Error(`${where} sets ${stackedAreaOnly.join(", ")} on chart "${panel.chart}" — only "stacked-area" supports it.`);
+    }
+}
+const DASHBOARD_CHART_TONES = new Set([
+    "positive",
+    "negative",
+    "active",
+    "neutral",
+]);
+function validateDashboardChartMarkerKind(where, look) {
+    if (look.tone === undefined && look.color === undefined) {
+        throw new Error(`${where} needs a tone or a color.`);
+    }
+    if (look.tone !== undefined && !DASHBOARD_CHART_TONES.has(look.tone)) {
+        throw new Error(`${where}.tone "${String(look.tone)}" is not one of ${[...DASHBOARD_CHART_TONES].join(", ")}.`);
+    }
+    if (look.color !== undefined && (typeof look.color !== "string" || look.color.trim() === "")) {
+        throw new Error(`${where}.color must be a non-empty CSS color.`);
+    }
+}
+function validateDashboardChartRanges(where, ranges) {
+    if (ranges.options.length === 0) {
+        throw new Error(`${where}.options is empty — declare at least one option.`);
+    }
+    const values = new Set();
+    for (const option of ranges.options) {
+        if (option.value.length === 0 || option.label.length === 0) {
+            throw new Error(`${where} option needs a non-empty value and label.`);
+        }
+        if (values.has(option.value)) {
+            throw new Error(`${where}.options has duplicate value "${option.value}".`);
+        }
+        if (option.months !== undefined && (!Number.isInteger(option.months) || option.months <= 0)) {
+            throw new Error(`${where} option "${option.value}" months "${String(option.months)}" must be a positive integer.`);
+        }
+        values.add(option.value);
+    }
+    if (!values.has(ranges.default)) {
+        throw new Error(`${where}.default "${ranges.default}" is not among the options (${[...values].join(", ")}).`);
+    }
 }
 const CURRENCY_CODE_RE = /^[A-Z]{3}$/;
 const MAX_VALUE_FORMAT_FRACTION_DIGITS = 4;
@@ -1785,18 +1869,14 @@ function validateDashboardQueryPanel(featureName, screenId, panel, featureMap) {
     if (!panel.query || typeof panel.query !== "string") {
         throw new Error(`[Feature ${featureName}] Screen "${screenId}" (dashboard) panel "${panel.id}" has empty or non-string query.`);
     }
-    if ("span" in panel &&
-        panel.span !== undefined &&
-        panel.span !== "half" &&
-        panel.span !== "full") {
-        throw new Error(`[Feature ${featureName}] Screen "${screenId}" (dashboard) panel "${panel.id}" has span "${String(panel.span)}" — expected "half" or "full".`);
-    }
+    validateDashboardPanelSpan(featureName, screenId, panel);
     if (panel.kind === "stat") {
         if (panel.valueField.length === 0) {
             throw new Error(`[Feature ${featureName}] Screen "${screenId}" (dashboard) stat-panel "${panel.id}" has empty valueField.`);
         }
         validateDashboardValueFormat(featureName, screenId, panel.id, panel.valueFormat);
     }
+    validateDashboardPanelVisibleWhen(`[Feature ${featureName}] Screen "${screenId}" (dashboard) panel "${panel.id}"`, panel.visibleWhen);
     if (panel.kind === "chart")
         validateDashboardChartDisplay(featureName, screenId, panel);
     if (panel.kind === "list") {

package/dist/engine/build-app-schema.js

@@ -428,6 +428,9 @@ function projectField(fieldDef) {
     // fw#2780: author-supplied picker source — without it the client falls back to the list handler.
     if (typeof def["optionsQuery"] === "string")
         out["optionsQuery"] = def["optionsQuery"];
+    // Select: tier/tenant availability of the static options, loaded by the renderer.
+    if (typeof def["optionsAvailabilityQuery"] === "string")
+        out["optionsAvailabilityQuery"] = def["optionsAvailabilityQuery"];
     if (typeof def["multiple"] === "boolean")
         out["multiple"] = def["multiple"];
     // MultiSelect: display picks checkboxes vs. combobox in the renderer,

package/dist/engine/steps/_duration-utils.js

@@ -1,7 +1,7 @@
 // ISO-8601 duration arithmetic — shared by wait and waitForEvent steps.
 // Accepts "P1D", "PT1H", "P1Y2M3DT4H5M6S" etc.
 // Uses approximate calendar math (365d/year, 30d/month). See #23.
-import { Temporal } from "temporal-polyfill";
+import { Temporal } from "@cosmicdrift/kumiko-types/temporal";
 export function addDuration(baseIso, duration) {
     const pattern = /^P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/;
     const match = duration.match(pattern);

package/dist/engine/types/index.d.ts

@@ -17,7 +17,7 @@ export type { ContentCollectionDefinition, NavDefinition, NavIconKey, } from "@c
 export type { FromRule, FromRuleKind, OwnershipClause, OwnershipMap, OwnershipRef, OwnershipRule, SqlFragment, WhereRule, WhereRuleContext, } from "@cosmicdrift/kumiko-types/ownership";
 export type { EntityProjectionExtension, MspErrorMode, MspErrorPolicy, MultiStreamApplyFn, MultiStreamProjectionDefinition, ProjectionDefinition, ProjectionRowIdOf, ProjectionTable, SingleStreamApplyFn, } from "@cosmicdrift/kumiko-types/projection";
 export type { BelongsToRelation, EntityRelations, HasManyRelation, ManyToManyRelation, RelationDefinition, } from "@cosmicdrift/kumiko-types/relations";
-export type { ActionFormScreenDefinition, ConfigEditScreenDefinition, CustomScreenDefinition, CustomScreenRoute, DashboardChartPanel, DashboardCustomPanel, DashboardDateParam, DashboardFeedPanel, DashboardFilterDefinition, DashboardI18nText, DashboardListPanel, DashboardMoneyParam, DashboardPanelDefinition, DashboardPanelVisibility, DashboardProgressListPanel, DashboardScreenDefinition, DashboardScreenPanel, DashboardStatGroupPanel, DashboardStatPanel, DashboardText, DashboardTextParam, DashboardValueFormat, EditExtensionSection, EditFieldSpec, EditFieldsSection, EditLayout, EditRelatedListSection, EditSectionSpec, EditWriteFormSection, EntityEditScreenDefinition, EntityListExpandableRow, EntityListScreenDefinition, FieldCondition, FieldFormatRegistry, FieldRenderer, FormatSpec, FormWidth, ListColumnSpec, ListFacetSpec, ListPaginationMode, ListSortDir, ListSortSpec, MetricNavigate, MetricSpec, PlatformComponent, ProjectionDetailScreenDefinition, ProjectionListScreenDefinition, RecordHeaderSpec, RecordHeaderSubtitlePart, RowAction, RowActionNavigate, RowActionNavigateBase, RowActionWriteHandler, RowFieldExtractor, ScreenDefinition, ScreenFilter, ScreenFilterOp, ScreenNavSugar, ScreenSlots, SecretMintConfirmStep, SecretMintScreenDefinition, SecretReveal, SecretRevealField, SecretsEditScreenDefinition, SecretsEditSection, ToolbarAction, UnitKey, } from "@cosmicdrift/kumiko-types/screen";
+export type { ActionFormScreenDefinition, ConfigEditScreenDefinition, CustomScreenDefinition, CustomScreenRoute, DashboardChartMarkerKind, DashboardChartPanel, DashboardChartRangeOption, DashboardChartRanges, DashboardCustomPanel, DashboardDateParam, DashboardFeedPanel, DashboardFilterDefinition, DashboardI18nText, DashboardListPanel, DashboardMoneyParam, DashboardPanelDefinition, DashboardPanelGate, DashboardPanelVisibility, DashboardProgressListPanel, DashboardScreenDefinition, DashboardScreenPanel, DashboardStatGroupPanel, DashboardStatPanel, DashboardText, DashboardTextParam, DashboardValueFormat, EditExtensionSection, EditFieldSpec, EditFieldsSection, EditLayout, EditRelatedListSection, EditSectionSpec, EditWriteFormSection, EntityEditScreenDefinition, EntityListExpandableRow, EntityListScreenDefinition, FieldCondition, FieldFormatRegistry, FieldRenderer, FormatSpec, FormWidth, ListColumnSpec, ListFacetSpec, ListPaginationMode, ListSortDir, ListSortSpec, MetricNavigate, MetricSpec, PlatformComponent, ProjectionDetailScreenDefinition, ProjectionListScreenDefinition, RecordHeaderSpec, RecordHeaderSubtitlePart, RowAction, RowActionNavigate, RowActionNavigateBase, RowActionWriteHandler, RowFieldExtractor, ScreenDefinition, ScreenFilter, ScreenFilterOp, ScreenNavSugar, ScreenSlots, SecretMintConfirmStep, SecretMintScreenDefinition, SecretReveal, SecretRevealField, SecretsEditScreenDefinition, SecretsEditSection, ToolbarAction, UnitKey, } from "@cosmicdrift/kumiko-types/screen";
 export { metricField, relatedListGroupHeaderLabel, relatedListGroupKey, } from "@cosmicdrift/kumiko-types/screen";
 export type { TargetRef } from "@cosmicdrift/kumiko-types/target-ref";
 export type { Subscribe, TreeAction, TreeActionDef, TreeActionsHandle, TreeChildrenSubscribe, TreeNode, TreeNodeState, } from "@cosmicdrift/kumiko-types/tree-node";

package/dist/es-ops/context.js

@@ -6,7 +6,7 @@
 // SystemUser bypassed Access-Checks (Standard-Seed-Pattern, siehe
 // config-seed.ts:40). Events haben createdBy = SYSTEM_TENANT_ID-User
 // → audit-fähig.
-import { selectAllTenants, selectMembershipsOfUser, selectUserByEmail, } from "../db/queries/seed-context.js";
+import { selectAllTenants, selectMembershipsOfUser, selectTemplateResources, selectUserByEmail, } from "../db/queries/seed-context.js";
 import { createSystemUser, SYSTEM_TENANT_ID } from "../engine/index.js";
 import { parseStringArrayJson } from "../utils/parse-string-array-json.js";
 /** Builder: gibt eine factory-function zurück die der Runner pro-Migration
@@ -65,6 +65,20 @@ export function createSeedMigrationContext(args) {
             const rows = await selectAllTenants(args.dbRunner);
             return rows.map((r) => ({ id: r.id, name: r.name, tenantKey: r.tenant_key }));
         },
+        findTemplateResources: async (filter) => {
+            const rows = await selectTemplateResources(args.dbRunner, {
+                ...filter,
+                tenantId: filter?.tenantId ?? SYSTEM_TENANT_ID,
+            });
+            return rows.map((r) => ({
+                id: r.id,
+                tenantId: r.tenant_id,
+                slug: r.slug,
+                kind: r.kind,
+                locale: r.locale,
+                status: r.status,
+            }));
+        },
         db: args.dbRunner,
     };
 }

package/dist/es-ops/index.d.ts

@@ -1,4 +1,4 @@
 export { type CreateSeedMigrationContextArgs, createSeedMigrationContext, } from "./context.js";
 export { createEsOperationsTable, type EsOperationAppliedBy, type EsOperationType, esOperationsTable, } from "./operations-schema.js";
 export { type RunPendingSeedMigrationsArgs, type RunPendingSeedMigrationsResult, runPendingSeedMigrations, } from "./runner.js";
-export type { SeedMembershipRow, SeedMigration, SeedMigrationContext, SeedTenantRow, SeedUserRow, } from "./types.js";
+export type { SeedMembershipRow, SeedMigration, SeedMigrationContext, SeedTemplateResourceFilter, SeedTemplateResourceRow, SeedTenantRow, SeedUserRow, } from "./types.js";

package/dist/es-ops/types.d.ts

@@ -51,6 +51,23 @@ export type SeedTenantRow = {
     readonly name: string;
     readonly tenantKey: string;
 };
+/** Read-shape of a template-resolver row as exposed to seeds. */
+export type SeedTemplateResourceRow = {
+    readonly id: string;
+    readonly tenantId: string;
+    readonly slug: string;
+    readonly kind: string;
+    readonly locale: string;
+    readonly status: string;
+};
+export type SeedTemplateResourceFilter = {
+    /** Defaults to the system tenant, where seeded system templates live. */
+    readonly tenantId?: TenantId;
+    readonly slug?: string;
+    readonly kind?: string;
+    readonly status?: string;
+    readonly locale?: string;
+};
 export type SeedMigrationContext = {
     /** Event-Store-konformer Write via existing write-handler. System-User
      *  als Executor bypassed Access-Check (Standard-Seed-Pattern). Events
@@ -84,6 +101,9 @@ export type SeedMigrationContext = {
     readonly findUserByEmail: (email: string) => Promise<SeedUserRow | null>;
     readonly findMembershipsOfUser: (userId: string) => Promise<readonly SeedMembershipRow[]>;
     readonly findTenants: () => Promise<readonly SeedTenantRow[]>;
+    /** Template rows ordered by slug, locale. Empty list when the
+     *  template-resolver feature (its table) is not present. */
+    readonly findTemplateResources: (filter?: SeedTemplateResourceFilter) => Promise<readonly SeedTemplateResourceRow[]>;
     /** Escape-Hatch — direkter DB-Zugang. Nur für READ-only Lookups die der
      *  Context nicht standard-mäßig anbietet. WRITES via systemWriteAs!
      *  Type ist DbRunner (Connection oder aktive Tx) weil der Runner den

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

@@ -1,5 +1,6 @@
 /// <reference types="temporal-polyfill/global" preserve="true" />
 import { type EventMetadata, type StoredEvent } from "@cosmicdrift/kumiko-types/event-store-types";
+import { Temporal } from "@cosmicdrift/kumiko-types/temporal";
 import type { DbRunner } from "../db/index.js";
 import type { TenantId } from "../engine/types/index.js";
 export type { EventMetadata, StoredEvent } from "@cosmicdrift/kumiko-types/event-store-types";

package/dist/event-store/event-store.js

@@ -1,12 +1,6 @@
 /// <reference types="temporal-polyfill/global" preserve="true" />
 import { isPersonalDataGated, UNATTRIBUTED_ORIGIN, } from "@cosmicdrift/kumiko-types/event-store-types";
-// Value-only import, aliased to avoid shadowing the ambient global
-// `Temporal` TYPE this file's other Temporal.Instant annotations resolve
-// against (StoredEvent.createdAt et al. — importing the bare name here
-// conflicts with that ambient type, see #1438). Bun doesn't expose Temporal
-// as a runtime value on globalThis, so the un-aliased call below crashed
-// with "Temporal is not defined" outside boot paths that install it (#1480).
-import { Temporal as TemporalPolyfill } from "temporal-polyfill";
+import { Temporal } from "@cosmicdrift/kumiko-types/temporal";
 import { requestContext } from "../api/request-context.js";
 import { encryptEventPayloadPii } from "../crypto/event-pii.js";
 import { constraintOf, isUniqueViolation } from "../db/pg-error.js";
@@ -150,18 +144,11 @@ async function insertSubsequentEvent(db, event, newVersion, eventVersion, seedCr
     if (!row)
         throw new VersionConflictError(event.aggregateId, event.expectedVersion);
     const createdAt = row.created_at instanceof Date
-        ? TemporalPolyfill.Instant.fromEpochMilliseconds(row.created_at.getTime())
-        : TemporalPolyfill.Instant.from(row.created_at);
+        ? Temporal.Instant.fromEpochMilliseconds(row.created_at.getTime())
+        : Temporal.Instant.from(row.created_at);
     return {
         id: typeof row.id === "bigint" ? row.id : BigInt(row.id),
-        // @cast-boundary temporal-polyfill-vs-ambient: same TC39 Temporal.Instant
-        // at runtime, two separate .d.ts sources (temporal-polyfill's bundled
-        // types vs the ambient temporal-spec global) disagree on a couple of
-        // method-overload signatures (until/equals argument types), so TS treats
-        // them as nominally distinct. Safe: this value is only ever consumed as
-        // a Temporal.Instant (comparisons, .toString(), arithmetic), never
-        // narrowed on the specific overload shape that differs.
-        createdAt: createdAt,
+        createdAt,
     };
 }
 function buildStoredEvent(event, newVersion, eventVersion, row) {

package/dist/event-store/index.d.ts

@@ -9,6 +9,7 @@ export { createRebuildDeadLetterTable, listRebuildDeadLetters, type RebuildDeadL
 export { toStoredEvent } from "./row-to-stored-event.js";
 export { assertSeedModeNotInProduction, isSeedModeEnabled, runSeedWritesAt, SEED_MODE_ENV, SeedModeDisabledError, } from "./seed-clock.js";
 export { createSnapshotsTable, type LoadAggregateWithSnapshotOptions, type LoadAggregateWithSnapshotResult, loadAggregateWithSnapshot, loadLatestSnapshot, type SaveSnapshotArgs, type Snapshot, type SnapshotReducer, saveSnapshot, snapshotsTable, } from "./snapshot.js";
+export { type AppendEventInTenantDbOptions, appendEventInTenantDb, getStreamVersionInTenantDb, } from "./tenant-db-append.js";
 export { AGGREGATE_TRANSFER_STREAM_TYPE, AGGREGATE_TRANSFERRED_EVENT_TYPE, type TransferAggregateStreamsArgs, transferAggregateStreams, } from "./transfer.js";
 export { type EventUpcasters, makeUpcastCtx, type UpcasterErrorPolicy, type UpcastOptions, upcastStoredEvent, upcastStoredEvents, } from "./upcaster.js";
 export { createUpcasterDeadLetterTable, type DeadLetterRow, listDeadLetters, recordUpcasterDeadLetter, upcasterDeadLetterTable, } from "./upcaster-dead-letter.js";

package/dist/event-store/index.js

@@ -9,6 +9,7 @@ export { createRebuildDeadLetterTable, listRebuildDeadLetters, rebuildDeadLetter
 export { toStoredEvent } from "./row-to-stored-event.js";
 export { assertSeedModeNotInProduction, isSeedModeEnabled, runSeedWritesAt, SEED_MODE_ENV, SeedModeDisabledError, } from "./seed-clock.js";
 export { createSnapshotsTable, loadAggregateWithSnapshot, loadLatestSnapshot, saveSnapshot, snapshotsTable, } from "./snapshot.js";
+export { appendEventInTenantDb, getStreamVersionInTenantDb, } from "./tenant-db-append.js";
 export { AGGREGATE_TRANSFER_STREAM_TYPE, AGGREGATE_TRANSFERRED_EVENT_TYPE, transferAggregateStreams, } from "./transfer.js";
 export { makeUpcastCtx, upcastStoredEvent, upcastStoredEvents, } from "./upcaster.js";
 export { createUpcasterDeadLetterTable, listDeadLetters, recordUpcasterDeadLetter, upcasterDeadLetterTable, } from "./upcaster-dead-letter.js";

package/dist/event-store/tenant-db-append.d.ts

@@ -0,0 +1,8 @@
+import type { TenantDb } from "@cosmicdrift/kumiko-types/tenant-db-types";
+import type { Registry } from "../engine/types/index.js";
+import { type EventToAppend, type StoredEvent } from "./event-store.js";
+export type AppendEventInTenantDbOptions = {
+    readonly registry?: Registry;
+};
+export declare function appendEventInTenantDb(tenantDb: TenantDb, event: Omit<EventToAppend, "tenantId">, options?: AppendEventInTenantDbOptions): Promise<StoredEvent>;
+export declare function getStreamVersionInTenantDb(tenantDb: TenantDb, aggregateId: string): Promise<number>;

package/dist/event-store/tenant-db-append.js

@@ -0,0 +1,16 @@
+import { tenantDbRunner } from "../db/tenant-db-runner.js";
+import { runProjectionsForEvent } from "../pipeline/projections-runner.js";
+import { append, getStreamVersion } from "./event-store.js";
+// Appends on the connection or transaction the TenantDb is bound to. The tenant is always the
+// TenantDb's own, so a caller cannot write into another tenant's stream; a TenantDb the framework
+// did not build (or a fail-closed systemScope guard) is rejected by tenantDbRunner.
+export async function appendEventInTenantDb(tenantDb, event, options = {}) {
+    const runner = tenantDbRunner(tenantDb);
+    const stored = await append(runner, { ...event, tenantId: tenantDb.tenantId });
+    if (options.registry)
+        await runProjectionsForEvent(stored, options.registry, runner);
+    return stored;
+}
+export async function getStreamVersionInTenantDb(tenantDb, aggregateId) {
+    return getStreamVersion(tenantDbRunner(tenantDb), aggregateId, tenantDb.tenantId);
+}

package/dist/i18n/required-surface-keys.js

@@ -90,8 +90,10 @@ function pushDashboardPanelKeys(out, panel) {
     if (panel.kind === "custom")
         return;
     pushKey(out, panel.label);
-    if (panel.kind === "chart")
+    if (panel.kind === "chart" || panel.kind === "stat-group")
         pushKey(out, panel.subtitle);
+    if (panel.kind === "chart")
+        pushDashboardChartRangeKeys(out, panel);
     if (panel.kind === "chart" ||
         panel.kind === "list" ||
         panel.kind === "feed" ||
@@ -111,6 +113,10 @@ function pushDashboardPanelKeys(out, panel) {
         }
     }
 }
+function pushDashboardChartRangeKeys(out, panel) {
+    for (const option of panel.ranges?.options ?? [])
+        pushKey(out, option.label);
+}
 function pushDashboardFilterKeys(out, filter) {
     pushKey(out, filter.label);
     if (filter.allLabel !== undefined)