@cosmicdrift/kumiko-bundled-features 0.352.0 → 0.354.0

package/dist/ledger/entity.d.ts

@@ -3,6 +3,7 @@ export declare const accountEntity: import("@cosmicdrift/kumiko-types/fields").E
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -32,15 +33,16 @@ export declare const accountEntity: import("@cosmicdrift/kumiko-types/fields").E
         readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
         readonly display?: "radio" | "dropdown";
         readonly optionTones?: {
-            readonly asset?: import("@cosmicdrift/kumiko-types/fields").SelectOptionTone | undefined;
-            readonly equity?: import("@cosmicdrift/kumiko-types/fields").SelectOptionTone | undefined;
-            readonly expense?: import("@cosmicdrift/kumiko-types/fields").SelectOptionTone | undefined;
-            readonly income?: import("@cosmicdrift/kumiko-types/fields").SelectOptionTone | undefined;
-            readonly liability?: import("@cosmicdrift/kumiko-types/fields").SelectOptionTone | undefined;
+            readonly asset?: "bad" | "neutral" | "ok" | "warn" | undefined;
+            readonly equity?: "bad" | "neutral" | "ok" | "warn" | undefined;
+            readonly expense?: "bad" | "neutral" | "ok" | "warn" | undefined;
+            readonly income?: "bad" | "neutral" | "ok" | "warn" | undefined;
+            readonly liability?: "bad" | "neutral" | "ok" | "warn" | undefined;
         } | undefined;
         readonly optionsQuery?: string;
         readonly optionsQueryPayload?: import("@cosmicdrift/kumiko-types/fields").OptionsQueryPayload;
         readonly optionsAvailabilityQuery?: string;
+        readonly conditionalOptions?: readonly import("@cosmicdrift/kumiko-types/fields").SelectConditionalOptions<"asset" | "equity" | "expense" | "income" | "liability">[] | undefined;
     } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
         required: true;
     };
@@ -48,6 +50,7 @@ export declare const accountEntity: import("@cosmicdrift/kumiko-types/fields").E
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -69,6 +72,7 @@ export declare const accountEntity: import("@cosmicdrift/kumiko-types/fields").E
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -106,6 +110,7 @@ export declare const transactionEntity: import("@cosmicdrift/kumiko-types/fields
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -127,6 +132,7 @@ export declare const transactionEntity: import("@cosmicdrift/kumiko-types/fields
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -156,12 +162,13 @@ export declare const transactionEntity: import("@cosmicdrift/kumiko-types/fields
         readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
         readonly display?: "radio" | "dropdown";
         readonly optionTones?: {
-            readonly draft?: import("@cosmicdrift/kumiko-types/fields").SelectOptionTone | undefined;
-            readonly posted?: import("@cosmicdrift/kumiko-types/fields").SelectOptionTone | undefined;
+            readonly draft?: "bad" | "neutral" | "ok" | "warn" | undefined;
+            readonly posted?: "bad" | "neutral" | "ok" | "warn" | undefined;
         } | undefined;
         readonly optionsQuery?: string;
         readonly optionsQueryPayload?: import("@cosmicdrift/kumiko-types/fields").OptionsQueryPayload;
         readonly optionsAvailabilityQuery?: string;
+        readonly conditionalOptions?: readonly import("@cosmicdrift/kumiko-types/fields").SelectConditionalOptions<"draft" | "posted">[] | undefined;
     } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
         required: true;
     };
@@ -185,6 +192,7 @@ export declare const transactionEntity: import("@cosmicdrift/kumiko-types/fields
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -206,6 +214,7 @@ export declare const transactionEntity: import("@cosmicdrift/kumiko-types/fields
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -229,6 +238,7 @@ export declare const scheduleEntity: import("@cosmicdrift/kumiko-types/fields").
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -286,11 +296,12 @@ export declare const scheduleEntity: import("@cosmicdrift/kumiko-types/fields").
         readonly access?: import("@cosmicdrift/kumiko-types/fields").FieldAccess;
         readonly display?: "radio" | "dropdown";
         readonly optionTones?: {
-            readonly monthly?: import("@cosmicdrift/kumiko-types/fields").SelectOptionTone | undefined;
+            readonly monthly?: "bad" | "neutral" | "ok" | "warn" | undefined;
         } | undefined;
         readonly optionsQuery?: string;
         readonly optionsQueryPayload?: import("@cosmicdrift/kumiko-types/fields").OptionsQueryPayload;
         readonly optionsAvailabilityQuery?: string;
+        readonly conditionalOptions?: readonly import("@cosmicdrift/kumiko-types/fields").SelectConditionalOptions<"monthly">[] | undefined;
     } & import("@cosmicdrift/kumiko-types/fields").ResolvedPiiFlags & {
         required: true;
     };
@@ -317,6 +328,7 @@ export declare const scheduleEntity: import("@cosmicdrift/kumiko-types/fields").
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -338,6 +350,7 @@ export declare const scheduleEntity: import("@cosmicdrift/kumiko-types/fields").
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -359,6 +372,7 @@ export declare const scheduleEntity: import("@cosmicdrift/kumiko-types/fields").
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -380,6 +394,7 @@ export declare const scheduleEntity: import("@cosmicdrift/kumiko-types/fields").
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -401,6 +416,7 @@ export declare const scheduleEntity: import("@cosmicdrift/kumiko-types/fields").
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;

package/dist/ledger/entity.js

@@ -80,18 +80,22 @@ export const transactionEntity = createEntity({
         // Optional business-object reference (e.g. a lease contract) so entries can
         // be filtered by what they're about, not just grepped out of `reference`.
         subjectType: createTextField({
+            minLength: 1,
             maxLength: 64,
             personal: false,
             reason: "technical_reference",
             filterable: true,
         }),
         subjectId: createTextField({
+            minLength: 1,
             maxLength: 128,
             personal: false,
             reason: "technical_reference",
             filterable: true,
         }),
     },
+    // Subject ids are only unique within their type, so lookups filter on both
+    // columns; a subjectId-only filter would not be served by this index.
     indexes: [{ columns: ["tenantId", "subjectType", "subjectId"] }],
 });
 // schedule — a recurring booking template (Dauerauftrag): "book `amount` from
@@ -131,20 +135,22 @@ export const scheduleEntity = createEntity({
         // Confirmed periods inherit this from the schedule (see
         // confirm-schedule-period.write.ts) rather than repeating it per period.
         subjectType: createTextField({
+            minLength: 1,
             maxLength: 64,
             personal: false,
             reason: "technical_reference",
             filterable: true,
         }),
         subjectId: createTextField({
+            minLength: 1,
             maxLength: 128,
             personal: false,
             reason: "technical_reference",
             filterable: true,
         }),
         // Caller-assigned stable key (e.g. one id per lease position) to find the
-        // schedule again. Not unique: callers keep their own find-then-create;
-        // `description` stays pure display text instead of a lookup key.
+        // schedule again; unique per tenant when set. `description` stays pure
+        // display text instead of a lookup key.
         sourceRef: createTextField({
             maxLength: 128,
             personal: false,
@@ -152,10 +158,16 @@ export const scheduleEntity = createEntity({
             filterable: true,
         }),
     },
-    // A separate non-unique index: changing the subject index would drop and
-    // recreate it, an additional one is a plain CREATE INDEX.
+    // Find-then-create by sourceRef races across tabs/devices; only the DB closes
+    // that gap. Partial because sourceRef is optional. A new name (not the old
+    // non-unique default) keeps the migration an in-place CREATE UNIQUE INDEX.
     indexes: [
         { columns: ["tenantId", "subjectType", "subjectId"] },
-        { columns: ["tenantId", "sourceRef"] },
+        {
+            columns: ["tenantId", "sourceRef"],
+            unique: true,
+            where: sql `"source_ref" IS NOT NULL`,
+            name: "read_ledger_schedules_tenant_id_source_ref_uidx",
+        },
     ],
 });

package/dist/ledger/feature.js

@@ -18,6 +18,7 @@ import { createConfirmSchedulePeriodHandler } from "./handlers/confirm-schedule-
 import { createCreateTransactionHandler } from "./handlers/create-transaction.write.js";
 import { createBalanceSheetHandler, createBalancesReportHandler, createIncomeStatementHandler, } from "./handlers/reports.query.js";
 import { createReverseTransactionHandler } from "./handlers/reverse-transaction.write.js";
+import { requireScheduleSubjectPair } from "./schedule-subject-pair.js";
 function registerLedger(r, access, toggleable) {
     r.describe("Double-entry bookkeeping primitive. Owns two event-sourced entities — the per-tenant `account` chart of accounts (`read_ledger_accounts`, self-referential via parentId, typed asset/liability/equity/income/expense) and immutable `transaction` journal entries (`read_ledger_transactions`) whose balanced posting lines are embedded as jsonb (Σ amount = 0, signed integer minor units). The account catalog uses the generic entity handlers (create, update, list, detail); create-transaction books a balanced entry (Σ=0 and ≥2 distinct accounts enforced at the command boundary, referential integrity against accounts checked) and reverse-transaction books its Storno mirror — there is deliberately NO transaction update/delete, so a posted entry is an immutable fact and the audit trail stays intact. Recurring schedules (`read_ledger_schedules`) layer Dauerauftrag templates on top — a schedule names debit/credit accounts, an amount, a monthly interval and an optional caller-assigned `sourceRef` key (filterable, to find a schedule again), from which the Soll (forecast) is a pure projection (projectSchedule) needing no bookings, and confirm-schedule-period materialises one period as an idempotent, reversal-aware balanced entry referencing scheduleReference(id, period); only confirming writes. Balances and reports (balance sheet, P&L, cashflow) derive as pure queries over the postings. Everything financial — banking, accounting, rent cashflow, credits, invoices — models as accounts + balanced transactions on top. Pin roles with createLedgerFeature({ roles }) or adopt the host model with { access }; pass { toggleable: { default: false } } to tier-gate the whole feature.");
     r.uiHints({
@@ -72,6 +73,8 @@ function registerLedger(r, access, toggleable) {
         access,
         description: "Changes a recurring booking template's description, accounts, amount, interval or date window; use it when a standing order's terms change, already confirmed periods stay booked as they were.",
     }));
+    r.hook("preSave", "schedule:create", requireScheduleSubjectPair);
+    r.hook("preSave", "schedule:update", requireScheduleSubjectPair);
     r.writeHandler(createConfirmSchedulePeriodHandler(access));
     r.queryHandler(defineEntityListHandler("schedule", scheduleEntity, {
         access,

package/dist/ledger/handlers/confirm-schedule-period.write.js

@@ -1,3 +1,4 @@
+import { acquireNamespacedAdvisoryLock } from "@cosmicdrift/kumiko-framework/db";
 import { NotFoundError, writeFailure } from "@cosmicdrift/kumiko-framework/errors";
 import { generateId } from "@cosmicdrift/kumiko-framework/utils";
 import { DEFAULT_LEDGER_ACCESS } from "../constants.js";
@@ -5,6 +6,10 @@ import { accountExecutor, scheduleExecutor, transactionExecutor, transactionTabl
 import { findReversedIds, isoMonth, scheduleReference } from "../recurring.js";
 import { confirmSchedulePeriodPayloadSchema, } from "../schemas.js";
 import { readSubjectReference } from "../subject-reference.js";
+// pg_advisory_xact_lock namespace (int4): 'lcsp' as ASCII, disjoint from the
+// framework's other fixed advisory-lock keys.
+const CONFIRM_PERIOD_LOCK_NAMESPACE = 0x6c637370;
+const CONFIRM_PERIOD_LOCK_REASON = "takes the per-(tenant, reference) advisory lock so parallel confirms cannot both pass the already-booked check; TenantDb has no lock API";
 // confirm-schedule-period — turn ONE projected period of a schedule into a posted,
 // balanced transaction (debit +amount / credit −amount), tagged with
 // scheduleReference(scheduleId, period) so the host can merge Soll vs. Ist.
@@ -19,6 +24,7 @@ export function createConfirmSchedulePeriodHandler(access = DEFAULT_LEDGER_ACCES
         name: "confirm-schedule-period",
         schema: confirmSchedulePeriodPayloadSchema,
         access,
+        escapeHatch: { grants: ["unsafeRaw"], reason: CONFIRM_PERIOD_LOCK_REASON },
         description: "Turns one month of a recurring schedule into a posted balanced entry between its debit and credit account, returning the existing booking instead when that period is already booked and not reversed; use it to move a forecast period into the actual books.",
         handler: async (event, ctx) => {
             const payload = event.payload; // @cast-boundary engine-payload
@@ -42,9 +48,9 @@ export function createConfirmSchedulePeriodHandler(access = DEFAULT_LEDGER_ACCES
             // normally 0 or 1 row, never O(tenant's-full-history); (2) any Storno
             // that mirrors one of those candidates (a tx is reversed when ANOTHER
             // tx's `reference` names its id).
-            // ponytail: read-then-write, so two confirms racing the same period could
-            // double-book; add a unique index on (tenantId, reference) when concurrent
-            // confirms become real.
+            // No unique index on (tenantId, reference): a Storno makes re-confirming the
+            // same reference legitimate, so the check-then-write is serialized by a lock.
+            await acquireNamespacedAdvisoryLock(ctx.db.unsafeRaw(), CONFIRM_PERIOD_LOCK_NAMESPACE, `${event.user.tenantId}:${reference}`);
             const candidates = await ctx.db.selectMany(transactionTable, {
                 tenantId: event.user.tenantId,
                 reference,

package/dist/ledger/handlers/create-transaction.write.js

@@ -14,6 +14,7 @@ export function createCreateTransactionHandler(access = DEFAULT_LEDGER_ACCESS) {
         schema: createTransactionPayloadSchema,
         access,
         description: "Books one balanced journal entry from a date, description and at least two posting lines summing to zero, after verifying every named account exists; use it to record any financial movement in the tenant's books.",
+        agent: { risk: "high" },
         handler: async (event, ctx) => {
             const payload = event.payload; // @cast-boundary engine-payload
             for (const accountId of new Set(payload.lines.map((l) => l.accountId))) {

package/dist/ledger/handlers/reverse-transaction.write.js

@@ -16,6 +16,7 @@ export function createReverseTransactionHandler(access = DEFAULT_LEDGER_ACCESS)
         schema: reverseTransactionPayloadSchema,
         access,
         description: "Books the mirror image of a posted journal entry as a new entry referencing the original, refusing entries that are not posted or already reversed; use it as the only way to correct a booking, since entries themselves are immutable.",
+        agent: { risk: "high" },
         handler: async (event, ctx) => {
             const payload = event.payload; // @cast-boundary engine-payload
             const original = await transactionExecutor.detail({ id: payload.id }, event.user, ctx.db);

package/dist/ledger/schedule-subject-pair.d.ts

@@ -0,0 +1,2 @@
+import type { PreSaveHookFn } from "@cosmicdrift/kumiko-framework/engine";
+export declare const requireScheduleSubjectPair: PreSaveHookFn;

package/dist/ledger/schedule-subject-pair.js

@@ -0,0 +1,24 @@
+import { ValidationError } from "@cosmicdrift/kumiko-framework/errors";
+function isSet(value) {
+    return value !== undefined && value !== null && value !== "";
+}
+// subjectId is only unique within its subjectType, so a schedule with one of
+// the two would be found by a lone-subjectId filter among other object types.
+// The effective pair is checked (changes over the stored row) because an
+// update may touch only one of the two fields.
+export const requireScheduleSubjectPair = async (changes, ctx) => {
+    const effective = (key) => key in changes ? changes[key] : ctx.previous[key];
+    const hasType = isSet(effective("subjectType"));
+    const hasId = isSet(effective("subjectId"));
+    if (hasType === hasId)
+        return changes;
+    throw new ValidationError({
+        fields: [
+            {
+                path: hasType ? "subjectId" : "subjectType",
+                code: "required",
+                i18nKey: "errors.validation.required",
+            },
+        ],
+    });
+};

package/dist/ledger/schemas.js

@@ -21,8 +21,14 @@ export const createTransactionPayloadSchema = z
     status: z.enum(TRANSACTION_STATUS).optional(),
     lines: z.array(postingSchema).min(2),
     // Business-object reference (e.g. a lease contract) this entry is about.
-    subjectType: z.string().max(64).optional(),
-    subjectId: z.string().max(128).optional(),
+    subjectType: z.string().min(1).max(64).optional(),
+    subjectId: z.string().min(1).max(128).optional(),
+})
+    // Ids are only unique within their type, so a lone subjectId would match
+    // bookings of a different object type.
+    .refine((p) => (p.subjectType === undefined) === (p.subjectId === undefined), {
+    message: "subjectType and subjectId must be set together",
+    path: ["subjectId"],
 })
     .refine((p) => sumIsZero(p.lines), {
     message: "Transaction must balance: Σ of posting amounts must equal 0",

package/dist/mail-transport-smtp/feature.d.ts

@@ -1,8 +1,7 @@
 import type { lookup } from "node:dns/promises";
-import * as z from "zod";
-export declare const mailTransportSmtpEnvSchema: z.ZodObject<{
-    KUMIKO_MAIL_ALLOWED_PRIVATE_HOSTS: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+export declare const mailTransportSmtpEnvSchema: import("zod").ZodObject<{
+    KUMIKO_MAIL_ALLOWED_PRIVATE_HOSTS: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>;
 export declare function setSmtpMailHostLookup(fn: typeof lookup | undefined): void;
 export declare const mailTransportSmtpFeature: import("@cosmicdrift/kumiko-types/feature").FeatureDefinition & {
     readonly exports: {

package/dist/mail-transport-smtp/feature.js

@@ -25,29 +25,20 @@
 //   - `config` — für die Tenant-Config-Keys
 //   - `secrets` — für das verschlüsselte SMTP-Password
 import { createSmtpTransport, } from "@cosmicdrift/kumiko-bundled-features/channel-email";
-import { BlockedHostError, HostResolutionError, MAIL_ALLOWED_PRIVATE_HOSTS_ENV_VAR, readAllowedPrivateMailHostsFromEnv, requireDefined, requireNonEmpty, requireSecretSet, resolveMailConnectTarget, } from "@cosmicdrift/kumiko-bundled-features/foundation-shared";
+import { BlockedHostError, HostResolutionError, mailAllowedPrivateHostsEnvSchema, readAllowedPrivateMailHostsFromEnv, requireDefined, requireNonEmpty, requireSecretSet, resolveMailConnectTarget, } from "@cosmicdrift/kumiko-bundled-features/foundation-shared";
 import { MAIL_TRANSPORT_EXTENSION, } from "@cosmicdrift/kumiko-bundled-features/mail-foundation";
 import { requireSecretsContext } from "@cosmicdrift/kumiko-bundled-features/secrets";
 import { access, createTenantConfig, defineFeature } from "@cosmicdrift/kumiko-framework/engine";
 import { UnconfiguredError } from "@cosmicdrift/kumiko-framework/errors";
 import { createFallbackLogger } from "@cosmicdrift/kumiko-framework/logging";
-import * as z from "zod";
 const FEATURE_NAME = "mail-transport-smtp";
 const log = createFallbackLogger(FEATURE_NAME);
 // Operator escape hatch for an internal relay or a dev/test SMTP server
 // (mailpit, MailHog): KUMIKO_MAIL_ALLOWED_PRIVATE_HOSTS, an operator env
 // var never a tenant-config value, so a tenant can never grant themselves
-// the private-host bypass. Declared here (not duplicated in
-// inbound-provider-imap's envSchema) since both features read the same
-// var and composeEnvSchema rejects two features declaring the same key —
-// see foundation-shared/mail-host-policy.ts for the shared reader + the
-// guard this feeds.
-export const mailTransportSmtpEnvSchema = z.object({
-    [MAIL_ALLOWED_PRIVATE_HOSTS_ENV_VAR]: z
-        .string()
-        .optional()
-        .describe("Comma-separated operator allowlist of private/internal hosts (e.g. a local mailpit/greenmail dev server) that bypass the public-address check for SMTP and IMAP host config. Shared with inbound-provider-imap — never a tenant-config value."),
-});
+// the private-host bypass. The schema instance is shared with
+// inbound-provider-imap (see foundation-shared/mail-host-policy.ts).
+export const mailTransportSmtpEnvSchema = mailAllowedPrivateHostsEnvSchema;
 // Test-only DNS seam — production never calls this, resolveMailConnectTarget
 // defaults to the real resolver. Lets tests pin deterministic, network-free
 // host resolutions instead of depending on real DNS for a placeholder host.

package/dist/managed-pages/feature.js

@@ -1,6 +1,8 @@
 import { computeRevisionEtag, etagMatches } from "@cosmicdrift/kumiko-framework/api";
 import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
+import { RateLimitError } from "@cosmicdrift/kumiko-framework/errors";
 import { cachedSecurePageResponse, EMPTY_BRANDING, renderSafeMarkdown, wrapInLayout, } from "../page-render/index.js";
+import { rateLimitedTextResponse } from "../shared/index.js";
 import { BRANDING_KEYS, BRANDING_QUERY_QN, CUSTOM_CSS_KEY, coerceBranding } from "./branding.js";
 import { createBrandingQuery } from "./handlers/branding.query.js";
 import { bySlugQuery } from "./handlers/by-slug.query.js";
@@ -28,14 +30,17 @@ function brandingRevisionSeed(branding) {
         branding.customCss,
     ]);
 }
-// Never throws: a query failure or malformed result degrades to the
-// unbranded default (branding is decoration, not a hard dependency of the
-// page render).
+// A query failure or malformed result degrades to the unbranded default
+// (branding is decoration, not a hard dependency of the page render). A rate
+// limit is rethrown so the route answers 429 instead of serving (and caching)
+// an unbranded page.
 async function readBrandingViaSystemQuery(systemQuery, tenantId) {
     try {
         return coerceBranding(await systemQuery(BRANDING_QUERY_QN, {}, tenantId));
     }
-    catch {
+    catch (error) {
+        if (error instanceof RateLimitError)
+            throw error;
         return EMPTY_BRANDING;
     }
 }
@@ -125,12 +130,25 @@ export function createManagedPagesFeature(opts) {
                 // von resolverTrust: "authoritative" zurecht abgelehnt; siehe
                 // systemQuery's Doc in http-route.ts). Branding ist Deko → ein
                 // Fehlschlag degradiert zum unbranded Default, blockt nie die Page.
-                const [pageSettled, brandingResult] = await Promise.all([
-                    systemQuery(BY_SLUG_QN, { slug, lang }, tenantId)
-                        .then((data) => ({ ok: true, data: data }))
-                        .catch(() => ({ ok: false, data: null })),
-                    readBrandingViaSystemQuery(systemQuery, tenantId),
-                ]);
+                let pageSettled;
+                let brandingResult;
+                try {
+                    [pageSettled, brandingResult] = await Promise.all([
+                        systemQuery(BY_SLUG_QN, { slug, lang }, tenantId)
+                            .then((data) => ({ ok: true, data: data }))
+                            .catch((error) => {
+                            if (error instanceof RateLimitError)
+                                throw error;
+                            return { ok: false };
+                        }),
+                        readBrandingViaSystemQuery(systemQuery, tenantId),
+                    ]);
+                }
+                catch (error) {
+                    if (error instanceof RateLimitError)
+                        return rateLimitedTextResponse(error);
+                    throw error;
+                }
                 if (!pageSettled.ok)
                     return c.text("page unavailable", 503);
                 const data = pageSettled.data;

package/dist/managed-pages/table.d.ts

@@ -3,6 +3,7 @@ export declare const pageEntity: import("@cosmicdrift/kumiko-types/fields").Enti
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -24,6 +25,7 @@ export declare const pageEntity: import("@cosmicdrift/kumiko-types/fields").Enti
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -45,6 +47,7 @@ export declare const pageEntity: import("@cosmicdrift/kumiko-types/fields").Enti
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -66,6 +69,7 @@ export declare const pageEntity: import("@cosmicdrift/kumiko-types/fields").Enti
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -87,6 +91,7 @@ export declare const pageEntity: import("@cosmicdrift/kumiko-types/fields").Enti
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -108,6 +113,7 @@ export declare const pageEntity: import("@cosmicdrift/kumiko-types/fields").Enti
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -134,6 +140,7 @@ export declare const pagesTable: import("@cosmicdrift/kumiko-framework/db").Enti
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -155,6 +162,7 @@ export declare const pagesTable: import("@cosmicdrift/kumiko-framework/db").Enti
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -176,6 +184,7 @@ export declare const pagesTable: import("@cosmicdrift/kumiko-framework/db").Enti
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -197,6 +206,7 @@ export declare const pagesTable: import("@cosmicdrift/kumiko-framework/db").Enti
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -218,6 +228,7 @@ export declare const pagesTable: import("@cosmicdrift/kumiko-framework/db").Enti
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -239,6 +250,7 @@ export declare const pagesTable: import("@cosmicdrift/kumiko-framework/db").Enti
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;

package/dist/notes-history/entity.d.ts

@@ -4,6 +4,7 @@ export declare function createNoteEntryEntity(access?: EntityDefinition["access"
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -25,6 +26,7 @@ export declare function createNoteEntryEntity(access?: EntityDefinition["access"
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -46,6 +48,7 @@ export declare function createNoteEntryEntity(access?: EntityDefinition["access"
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -67,6 +70,7 @@ export declare function createNoteEntryEntity(access?: EntityDefinition["access"
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -106,6 +110,7 @@ export declare const noteEntryEntity: EntityDefinition<{
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -127,6 +132,7 @@ export declare const noteEntryEntity: EntityDefinition<{
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -148,6 +154,7 @@ export declare const noteEntryEntity: EntityDefinition<{
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -169,6 +176,7 @@ export declare const noteEntryEntity: EntityDefinition<{
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -208,6 +216,7 @@ export declare function createNoteMentionEntity(): EntityDefinition<{
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -229,6 +238,7 @@ export declare function createNoteMentionEntity(): EntityDefinition<{
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -252,6 +262,7 @@ export declare const noteMentionEntity: EntityDefinition<{
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;
@@ -273,6 +284,7 @@ export declare const noteMentionEntity: EntityDefinition<{
         readonly type: "text";
         readonly description?: string;
         readonly maxLength?: number;
+        readonly minLength?: number;
         readonly required?: boolean;
         readonly searchable?: boolean;
         readonly sortable?: boolean;