@cosmicdrift/kumiko-bundled-features 0.37.0 → 0.38.0

package/src/custom-fields/run-retention.ts

@@ -16,22 +16,14 @@
 // jsonb shape, which would be a breaking schema change.
 
 import type { DbRunner } from "@cosmicdrift/kumiko-framework/db";
+import { extractTableName } from "@cosmicdrift/kumiko-framework/db";
 import { getTemporal } from "@cosmicdrift/kumiko-framework/time";
 import {
   applyRetentionRemovals,
   selectFieldDefinitionsWithSerialized,
   selectHostRowsWithCustomFields,
 } from "./db/queries/retention";
-import { parseSerializedField } from "./lib/parse-serialized-field";
-
-const KUMIKO_NAME_SYMBOL = Symbol.for("kumiko:schema:Name");
-function getTableName(table: unknown): string {
-  if (typeof table === "object" && table !== null) {
-    const sym = (table as Record<symbol, unknown>)[KUMIKO_NAME_SYMBOL];
-    if (typeof sym === "string") return sym;
-  }
-  throw new Error("custom-fields/run-retention: table missing kumiko:schema:Name symbol");
-}
+import { isFieldDefinitionRow, parseSerializedField } from "./lib/parse-serialized-field";
 
 type Instant = InstanceType<ReturnType<typeof getTemporal>["Instant"]>;
 
@@ -87,7 +79,7 @@ export async function runCustomFieldsRetention(
     return { rowsScanned: 0, rowsUpdated: 0, removalsByFieldKey: {} };
   }
 
-  const tableName = getTableName(opts.entityTable);
+  const tableName = extractTableName(opts.entityTable, "custom-fields/run-retention");
   const rows = await selectHostRowsWithCustomFields(opts.db, tableName, opts.tenantId);
 
   const removalsByFieldKey: Record<string, number> = {};
@@ -159,17 +151,6 @@ function asHostRow(value: unknown): HostRow | null {
   };
 }
 
-interface FieldDefinitionRow {
-  readonly field_key: string;
-  readonly serialized_field: unknown;
-}
-
-function isFieldDefinitionRow(value: unknown): value is FieldDefinitionRow {
-  if (!value || typeof value !== "object") return false;
-  if (!("field_key" in value)) return false;
-  return typeof value.field_key === "string";
-}
-
 async function loadRetentionPolicies(
   db: DbRunner,
   tenantId: string,
@@ -192,6 +173,7 @@ interface InstantLike {
   readonly epochMilliseconds: number;
 }
 
+// guard:dup-ok — false positive: gleiche TypeGuard-Struktur wie isFieldDefinitionRow, völlig andere Semantik
 function isInstantLike(value: unknown): value is InstantLike {
   if (!value || typeof value !== "object") return false;
   if (!("epochMilliseconds" in value)) return false;

package/src/custom-fields/web/__tests__/custom-fields-form-section.test.tsx

@@ -234,3 +234,151 @@ describe("CustomFieldsFormSection", () => {
     expect(saveBtn.textContent).toBe("Save custom fields");
   });
 });
+
+describe("CustomFieldsFormSection — clear-Pfad", () => {
+  test("Leeren eines gespeicherten Werts dispatched clear-custom-field (nicht skip)", async () => {
+    mockedQueryRows = [
+      {
+        id: "f1",
+        entityName: "component",
+        fieldKey: "vendor",
+        type: "text",
+        required: false,
+        displayOrder: 1,
+      },
+    ];
+    dispatchSpy.mockClear();
+
+    render(
+      <Wrapper>
+        <CustomFieldsFormSection
+          entityName="component"
+          entityId="row-42"
+          initialValues={{ vendor: "Hetzner" }}
+        />
+      </Wrapper>,
+    );
+
+    const vendorInput = document.getElementById("custom-field-vendor") as HTMLInputElement;
+    expect(vendorInput.value).toBe("Hetzner");
+
+    fireEvent.change(vendorInput, { target: { value: "" } });
+    fireEvent.click(screen.getByTestId("custom-fields-form-save"));
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(dispatchSpy).toHaveBeenCalledTimes(1);
+    expect(dispatchSpy).toHaveBeenCalledWith("custom-fields:write:clear-custom-field", {
+      entityName: "component",
+      entityId: "row-42",
+      fieldKey: "vendor",
+    });
+  });
+
+  test("unveränderter Bestandswert wird beim Save NICHT erneut geschrieben", async () => {
+    mockedQueryRows = [
+      {
+        id: "f1",
+        entityName: "component",
+        fieldKey: "vendor",
+        type: "text",
+        required: false,
+        displayOrder: 1,
+      },
+    ];
+    dispatchSpy.mockClear();
+
+    render(
+      <Wrapper>
+        <CustomFieldsFormSection
+          entityName="component"
+          entityId="row-42"
+          initialValues={{ vendor: "Hetzner" }}
+        />
+      </Wrapper>,
+    );
+
+    const vendorInput = document.getElementById("custom-field-vendor") as HTMLInputElement;
+    // Tippen + zurück auf den Bestandswert → nicht dirty, kein Write.
+    fireEvent.change(vendorInput, { target: { value: "Hetzner2" } });
+    fireEvent.change(vendorInput, { target: { value: "Hetzner" } });
+    fireEvent.click(screen.getByTestId("custom-fields-form-save"));
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(dispatchSpy).not.toHaveBeenCalled();
+  });
+});
+
+describe("CustomFieldsFormSection — boolean/date-Pfade", () => {
+  test("boolean: Bestand wird als true/false-String angezeigt, Save coerced zu boolean", async () => {
+    mockedQueryRows = [
+      {
+        id: "f1",
+        entityName: "component",
+        fieldKey: "active",
+        type: "boolean",
+        required: false,
+        displayOrder: 1,
+      },
+    ];
+    dispatchSpy.mockClear();
+
+    render(
+      <Wrapper>
+        <CustomFieldsFormSection
+          entityName="component"
+          entityId="row-42"
+          initialValues={{ active: true }}
+        />
+      </Wrapper>,
+    );
+
+    // boolean rendert als Checkbox — Bestand steckt in checked, nicht value.
+    const input = document.getElementById("custom-field-active") as HTMLInputElement;
+    expect(input.checked).toBe(true);
+
+    fireEvent.click(input);
+    fireEvent.click(screen.getByTestId("custom-fields-form-save"));
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(dispatchSpy).toHaveBeenCalledWith("custom-fields:write:set-custom-field", {
+      entityName: "component",
+      entityId: "row-42",
+      fieldKey: "active",
+      value: false,
+    });
+  });
+
+  test("date: Bestand erreicht den DateInput-Trigger (lokalisierte Anzeige)", () => {
+    mockedQueryRows = [
+      {
+        id: "f1",
+        entityName: "component",
+        fieldKey: "launchedAt",
+        type: "date",
+        required: false,
+        displayOrder: 1,
+      },
+    ];
+    dispatchSpy.mockClear();
+
+    render(
+      <Wrapper>
+        <CustomFieldsFormSection
+          entityName="component"
+          entityId="row-42"
+          initialValues={{ launchedAt: "2026-01-15" }}
+        />
+      </Wrapper>,
+    );
+
+    // DateInput ist ein Kalender-Trigger-Button (kein <input value>) mit
+    // lokalisierter Anzeige — der Kalender-Flow selbst ist jsdom-untauglich
+    // (Popover), hier zählt: der Bestand kommt im Trigger an, nicht "—".
+    const trigger = document.getElementById("custom-field-launchedAt") as HTMLButtonElement;
+    expect(trigger.textContent).toContain("2026");
+    expect(trigger.textContent).not.toContain("—");
+  });
+});

package/src/custom-fields/web/custom-fields-form-section.tsx

@@ -92,20 +92,35 @@ export function CustomFieldsFormSection({
     );
   }
 
+  // Dirty heißt: weicht vom GESPEICHERTEN Wert ab — nicht von "". Sonst ist
+  // das Leeren eines gespeicherten Werts unsichtbar (Button disabled) und
+  // handleSave würde es überspringen statt zu clearen.
+  const initialDisplay = (field: (typeof matchingFields)[number]): string =>
+    displayValue(field.type, initialValues?.[field.fieldKey]);
+  const changedFields = matchingFields.filter((field) => {
+    const raw = pending[field.fieldKey];
+    return raw !== undefined && raw !== initialDisplay(field);
+  });
+
   const handleSave = async (): Promise<void> => {
     setSaving(true);
     setErrorKey(null);
     try {
-      for (const field of matchingFields) {
-        const raw = pending[field.fieldKey];
-        if (raw === undefined || raw === "") continue;
-        const value = coerceValue(field.type, raw);
-        const result = await dispatcher.write(CustomFieldsHandlers.setCustomField, {
-          entityName,
-          entityId,
-          fieldKey: field.fieldKey,
-          value,
-        });
+      for (const field of changedFields) {
+        const raw = pending[field.fieldKey] ?? "";
+        const result =
+          raw === ""
+            ? await dispatcher.write(CustomFieldsHandlers.clearCustomField, {
+                entityName,
+                entityId,
+                fieldKey: field.fieldKey,
+              })
+            : await dispatcher.write(CustomFieldsHandlers.setCustomField, {
+                entityName,
+                entityId,
+                fieldKey: field.fieldKey,
+                value: coerceValue(field.type, raw),
+              });
         if (!result.isSuccess) {
           setErrorKey(result.error?.i18nKey ?? "custom-fields.errors.saveFailed");
           return;
@@ -117,7 +132,7 @@ export function CustomFieldsFormSection({
     }
   };
 
-  const dirty = Object.values(pending).some((v) => v !== "");
+  const dirty = changedFields.length > 0;
 
   return (
     <div data-testid="custom-fields-form-section">
@@ -204,6 +219,5 @@ function coerceValue(type: string, raw: string): unknown {
 function displayValue(type: string, value: unknown): string {
   if (value === undefined || value === null) return "";
   if (type === "boolean") return value === true ? "true" : "false";
-  if (type === "number") return typeof value === "number" ? String(value) : String(value);
   return String(value);
 }

package/src/custom-fields/wire-for-entity.ts

@@ -1,3 +1,4 @@
+import { extractTableName } from "@cosmicdrift/kumiko-framework/db";
 import {
   createJsonbField,
   type FeatureRegistrar,
@@ -13,15 +14,6 @@ import {
   setCustomFieldValue,
 } from "./db/queries/projection";
 
-const KUMIKO_NAME_SYMBOL = Symbol.for("kumiko:schema:Name");
-function getTableName(table: unknown): string {
-  if (typeof table === "object" && table !== null) {
-    const sym = (table as Record<symbol, unknown>)[KUMIKO_NAME_SYMBOL];
-    if (typeof sym === "string") return sym;
-  }
-  throw new Error("wire-for-entity: table missing kumiko:schema:Name symbol");
-}
-
 import type { CustomFieldClearedPayload, CustomFieldSetPayload } from "./events";
 import { customFieldsFeature } from "./feature";
 
@@ -107,7 +99,7 @@ export function wireCustomFieldsFor<TReg extends FeatureRegistrar<string>>(
         // jsonb_set: setze key auf value. Wenn key noch nicht existiert →
         // wird angelegt (create_missing=true ist default). value muss als
         // jsonb-literal kommen.
-        const tableName = getTableName(entityTable);
+        const tableName = extractTableName(entityTable, "custom-fields/wire-for-entity");
         await setCustomFieldValue(
           tx,
           tableName,
@@ -124,7 +116,7 @@ export function wireCustomFieldsFor<TReg extends FeatureRegistrar<string>>(
         const payload = event.payload as CustomFieldClearedPayload; // @cast-boundary engine-payload
 
         // jsonb minus operator (`-`) entfernt key aus jsonb-object.
-        const tableName = getTableName(entityTable);
+        const tableName = extractTableName(entityTable, "custom-fields/wire-for-entity");
         await clearCustomFieldKey(
           tx,
           tableName,
@@ -147,7 +139,7 @@ export function wireCustomFieldsFor<TReg extends FeatureRegistrar<string>>(
         // ihre Rows.
         if (payload.entityName !== entityName) return;
 
-        const tableName = getTableName(entityTable);
+        const tableName = extractTableName(entityTable, "custom-fields/wire-for-entity");
         // Scope cleanup to the deleted definition's owning tenant. System-scope
         // definitions apply to every tenant → cascade across all rows; tenant-
         // scope deletions must only touch that tenant's rows, else deleting one

package/src/custom-fields/wire-user-data-rights.ts

@@ -1,5 +1,6 @@
 // T1.5c — user-data-rights wiring for custom-fields.
 
+import { extractTableName } from "@cosmicdrift/kumiko-framework/db";
 import type { UserDataDeleteHook, UserDataExportHook } from "@cosmicdrift/kumiko-framework/engine";
 import { EXT_USER_DATA, type FeatureRegistrar } from "@cosmicdrift/kumiko-framework/engine";
 import {
@@ -7,16 +8,7 @@ import {
   selectFieldDefinitionsForEntity,
   stripSensitiveCustomFieldKeys,
 } from "./db/queries/user-data-rights";
-import { parseSerializedField } from "./lib/parse-serialized-field";
-
-const KUMIKO_NAME_SYMBOL = Symbol.for("kumiko:schema:Name");
-function getTableName(table: unknown): string {
-  if (typeof table === "object" && table !== null) {
-    const sym = (table as Record<symbol, unknown>)[KUMIKO_NAME_SYMBOL];
-    if (typeof sym === "string") return sym;
-  }
-  throw new Error("wire-user-data-rights: table missing kumiko:schema:Name symbol");
-}
+import { isFieldDefinitionRow, parseSerializedField } from "./lib/parse-serialized-field";
 
 export interface WireCustomFieldsUserDataRightsOptions {
   readonly entityName: string;
@@ -52,7 +44,7 @@ export function wireCustomFieldsUserDataRightsFor<TReg extends FeatureRegistrar<
   r: TReg,
   opts: WireCustomFieldsUserDataRightsOptions,
 ): void {
-  const tableName = getTableName(opts.entityTable);
+  const tableName = extractTableName(opts.entityTable, "custom-fields/wire-user-data-rights");
 
   const exportHook: UserDataExportHook = async (ctx) => {
     const rows = await selectCustomFieldsHostRows(
@@ -100,17 +92,6 @@ export function wireCustomFieldsUserDataRightsFor<TReg extends FeatureRegistrar<
   });
 }
 
-interface FieldDefinitionRow {
-  readonly field_key: string;
-  readonly serialized_field: unknown;
-}
-
-function isFieldDefinitionRow(value: unknown): value is FieldDefinitionRow {
-  if (!value || typeof value !== "object") return false;
-  if (!("field_key" in value)) return false;
-  return typeof value.field_key === "string";
-}
-
 async function loadSensitiveFieldKeys(
   db: Parameters<UserDataExportHook>[0]["db"],
   tenantId: string,

package/src/data-retention/__tests__/data-retention.integration.test.ts

@@ -36,11 +36,11 @@ describe("data-retention :: feature-definition smoke", () => {
   });
 
   test("tenantRetentionOverride-Entity ist registriert", () => {
-    expect(feature.entities["tenant-retention-override"]).toBeDefined();
+    expect(feature.entities?.["tenant-retention-override"]).toBeDefined();
   });
 
   test("Entity-Definition hat UNIQUE(tenantId, entityName) als 1:1-Constraint", () => {
-    const entity = feature.entities["tenant-retention-override"];
+    const entity = feature.entities?.["tenant-retention-override"];
     const indexes = entity?.indexes ?? [];
     const uniqueIndex = indexes.find((i) => i.unique === true);
     expect(uniqueIndex).toBeDefined();

package/src/file-foundation/feature.ts

@@ -85,6 +85,12 @@ export type FileProviderPlugin = {
   readonly build: (ctx: FileProviderContext, tenantId: string) => Promise<FileStorageProvider>;
 };
 
+// extension-usage `options` is engine-payload (unknown) — structurally validate
+// instead of casting blind.
+export function isFileProviderPlugin(o: unknown): o is FileProviderPlugin {
+  return typeof o === "object" && o !== null && "build" in o && typeof o.build === "function";
+}
+
 // =============================================================================
 // Feature-definition
 // =============================================================================
@@ -163,7 +169,11 @@ export async function createFileProviderForTenant(
     );
   }
 
-  // @cast-boundary engine-payload — extension-usage carries unknown options
-  const plugin = usage.options as FileProviderPlugin;
-  return plugin.build(ctx, tenantId);
+  if (!isFileProviderPlugin(usage.options)) {
+    throw new Error(
+      `${FEATURE_NAME}: provider "${provider}" registered without a build() — ` +
+        `extension options must be a FileProviderPlugin.`,
+    );
+  }
+  return usage.options.build(ctx, tenantId);
 }

package/src/file-foundation/index.ts

@@ -5,4 +5,5 @@ export {
   type FileProviderContext,
   type FileProviderPlugin,
   fileFoundationFeature,
+  isFileProviderPlugin,
 } from "./feature";

package/src/file-provider-inmemory/__tests__/feature.test.ts

@@ -1,7 +1,10 @@
 // feature.ts contract tests for file-provider-inmemory.
 
 import { describe, expect, test } from "bun:test";
-import type { FileProviderPlugin } from "@cosmicdrift/kumiko-bundled-features/file-foundation";
+import {
+  type FileProviderPlugin,
+  isFileProviderPlugin,
+} from "@cosmicdrift/kumiko-bundled-features/file-foundation";
 import { clearStorage, fileProviderInMemoryFeature, listKeys } from "../feature";
 
 describe("fileProviderInMemoryFeature — shape", () => {
@@ -35,12 +38,6 @@ describe("listKeys / clearStorage — per-tenant store helpers", () => {
   });
 });
 
-// extension-usage `options` is engine-payload (unknown) — structurally validate
-// instead of casting blind.
-function isFileProviderPlugin(o: unknown): o is FileProviderPlugin {
-  return typeof o === "object" && o !== null && "build" in o && typeof o.build === "function";
-}
-
 function inmemoryPlugin(): FileProviderPlugin {
   const options = fileProviderInMemoryFeature.extensionUsages.find(
     (u) => u.extensionName === "fileProvider" && u.entityName === "inmemory",

package/src/file-provider-s3/__tests__/feature.test.ts

@@ -1,7 +1,10 @@
 // feature.ts contract tests for file-provider-s3.
 
 import { describe, expect, test } from "bun:test";
-import type { FileProviderPlugin } from "@cosmicdrift/kumiko-bundled-features/file-foundation";
+import {
+  type FileProviderPlugin,
+  isFileProviderPlugin,
+} from "@cosmicdrift/kumiko-bundled-features/file-foundation";
 import { fileProviderS3Feature, S3_SECRET_ACCESS_KEY } from "../feature";
 
 describe("fileProviderS3Feature — shape", () => {
@@ -54,11 +57,6 @@ describe("fileProviderS3Feature — plugin-registration", () => {
   });
 });
 
-// extension-usage `options` is engine-payload (unknown) — structurally validate.
-function isFileProviderPlugin(o: unknown): o is FileProviderPlugin {
-  return typeof o === "object" && o !== null && "build" in o && typeof o.build === "function";
-}
-
 function s3Plugin(): FileProviderPlugin {
   const options = fileProviderS3Feature.extensionUsages.find(
     (u) => u.extensionName === "fileProvider" && u.entityName === "s3",

package/src/files/README.md

@@ -46,5 +46,5 @@ Sprint 4).
 
 ## Tests
 
-`__tests__/files.integration.ts` — 5 Tests die beweisen dass die Feature-
+`__tests__/files.integration.test.ts` — 5 Tests die beweisen dass die Feature-
 Definition clean lädt + die PII-Markers + Tabellenname stimmen.

package/src/subscription-stripe/feature.ts

@@ -65,8 +65,11 @@ export const subscriptionStripeEnvSchema = z.object({
     .meta({ kumiko: { pulumi: { secret: true } } }),
   STRIPE_API_KEY: z
     .string()
-    .regex(/^sk_(test|live)_/, "STRIPE_API_KEY must start with 'sk_test_' or 'sk_live_'")
-    .describe("Stripe API key (`sk_live_...` / `sk_test_...`).")
+    .regex(
+      /^(sk|rk)_(test|live)_/,
+      "STRIPE_API_KEY must start with 'sk_test_'/'sk_live_' or a restricted 'rk_test_'/'rk_live_' key",
+    )
+    .describe("Stripe API key (`sk_live_...` / `sk_test_...`, restricted `rk_...` keys allowed).")
     .meta({ kumiko: { pulumi: { secret: true } } }),
 });
 

package/src/template-resolver/feature.ts

@@ -1,8 +1,7 @@
 import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { archiveWrite } from "./handlers/archive.write";
 import { findByIdQuery } from "./handlers/find-by-id.query";
 import { listQuery } from "./handlers/list.query";
-import { publishWrite } from "./handlers/publish.write";
+import { archiveWrite, publishWrite } from "./handlers/toggle-status.write";
 import { upsertSystemWrite } from "./handlers/upsert-system.write";
 import { upsertTenantWrite } from "./handlers/upsert-tenant.write";
 import { templateResourceEntity } from "./table";

package/src/template-resolver/handlers/list.query.ts

@@ -1,5 +1,5 @@
 import { selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
-import { defineQueryHandler, SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framework/engine";
+import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
 import { z } from "zod";
 import { RENDER_KINDS, TEMPLATE_STATUSES } from "../constants";
 import { type TemplateResourceRow, templateResourcesTable } from "../table";
@@ -17,14 +17,13 @@ export const listQuery = defineQueryHandler({
   }),
   access: { roles: ["TenantAdmin", "SystemAdmin", "User"] },
   handler: async (query, ctx) => {
-    const isSystemAdmin = query.user.roles.includes("SystemAdmin");
     const where: Record<string, unknown> = {};
 
-    // TenantDb scopes non-SystemAdmin reads to [own tenant, SYSTEM reference] and
-    // refuses a caller-narrowed where.tenantId (enforced isolation). SystemAdmin
-    // uses a system-scoped db that sees every tenant, so narrow to own explicitly
-    // when they don't want the cross-tenant view.
-    if (isSystemAdmin && !query.payload.includeSystem) {
+    // includeSystem=false narrows to own tenant AT THE DB — for non-SystemAdmin
+    // TenantDb permits narrowing within its enforced [own, SYSTEM] scope, for
+    // SystemAdmin (system-scoped db) the where applies verbatim. Filtering at
+    // the DB keeps the limit meaningful (no post-filter starvation).
+    if (!query.payload.includeSystem) {
       where["tenantId"] = query.user.tenantId;
     }
 
@@ -44,13 +43,7 @@ export const listQuery = defineQueryHandler({
       limit: 500,
     })) as TemplateResourceRow[];
 
-    // TenantDb always surfaces SYSTEM reference rows alongside the tenant's own;
-    // includeSystem=false drops them here since they can't be excluded at the DB.
-    const visible = query.payload.includeSystem
-      ? rows
-      : rows.filter((row) => row.tenantId !== SYSTEM_TENANT_ID);
-
-    return visible.map((row) => ({
+    return rows.map((row) => ({
       id: String(row.id),
       tenantId: row.tenantId,
       slug: row.slug,

package/src/template-resolver/handlers/toggle-status.write.ts

@@ -0,0 +1,37 @@
+import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
+import { defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { NotFoundError, writeFailure } from "@cosmicdrift/kumiko-framework/errors";
+import { z } from "zod";
+import type { TemplateResourceRow } from "../table";
+import { templateResourcesTable } from "../table";
+import { executor } from "./shared";
+
+type TemplateStatus = "active" | "archived";
+
+function createStatusUpdateHandler(name: string, status: TemplateStatus) {
+  return defineWriteHandler({
+    name,
+    schema: z.object({ id: z.string().min(1) }),
+    access: { roles: ["TenantAdmin", "SystemAdmin"] },
+    handler: async (event, ctx) => {
+      // ctx.db is tenant-scoped: a foreign tenant's id reads as absent → NotFound.
+      // Cross-tenant toggling needs SystemAdmin with tenantIdOverride.
+      const existing = await fetchOne<TemplateResourceRow>(ctx.db, templateResourcesTable, {
+        id: event.payload.id,
+      });
+      if (!existing) {
+        return writeFailure(new NotFoundError("template-resource", event.payload.id));
+      }
+      const result = await executor.update(
+        { id: existing.id, version: existing.version, changes: { status } },
+        event.user,
+        ctx.db,
+      );
+      if (!result.isSuccess) return result;
+      return { isSuccess: true as const, data: { id: String(existing.id), status } };
+    },
+  });
+}
+
+export const archiveWrite = createStatusUpdateHandler("archive", "archived");
+export const publishWrite = createStatusUpdateHandler("publish", "active");

package/src/tenant/command-schemas.ts

@@ -22,8 +22,8 @@
 
 import { addMemberWrite } from "./handlers/add-member.write";
 import { createWrite } from "./handlers/create.write";
-import { disableWrite } from "./handlers/disable.write";
 import { removeMemberWrite } from "./handlers/remove-member.write";
+import { disableWrite } from "./handlers/toggle-enabled.write";
 import { updateWrite } from "./handlers/update.write";
 import { updateMemberRolesWrite } from "./handlers/update-member-roles.write";
 

package/src/tenant/feature.ts

@@ -9,8 +9,6 @@ import { activeTenantIdsQuery } from "./handlers/active-tenant-ids.query";
 import { addMemberWrite } from "./handlers/add-member.write";
 import { cancelInvitationWrite } from "./handlers/cancel-invitation.write";
 import { createWrite } from "./handlers/create.write";
-import { disableWrite } from "./handlers/disable.write";
-import { enableWrite } from "./handlers/enable.write";
 import { invitationsQuery } from "./handlers/invitations.query";
 import { listQuery } from "./handlers/list.query";
 import { meQuery } from "./handlers/me.query";
@@ -18,6 +16,7 @@ import { membersQuery } from "./handlers/members.query";
 import { membershipsQuery } from "./handlers/memberships.query";
 import { removeMemberWrite } from "./handlers/remove-member.write";
 import { resolveUserIdsQuery } from "./handlers/resolve-user-ids.query";
+import { disableWrite, enableWrite } from "./handlers/toggle-enabled.write";
 import { updateWrite } from "./handlers/update.write";
 import { updateMemberRolesWrite } from "./handlers/update-member-roles.write";
 import { tenantInvitationEntity } from "./invitation-table";

package/src/tenant/handlers/toggle-enabled.write.ts

@@ -0,0 +1,23 @@
+import { createEventStoreExecutor } from "@cosmicdrift/kumiko-framework/db";
+import { defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { z } from "zod";
+import { tenantEntity, tenantTable } from "../schema/tenant";
+
+const crud = createEventStoreExecutor(tenantTable, tenantEntity, { entityName: "tenant" });
+
+// Admin flip: last-writer-wins is fine. SystemAdmin is the only caller and
+// there's no meaningful concurrent-edit race on this single boolean.
+function createToggleTenantHandler(enable: boolean) {
+  return defineWriteHandler({
+    name: enable ? "enable" : "disable",
+    schema: z.object({ id: z.uuid() }),
+    access: { roles: ["SystemAdmin"] },
+    handler: async (event, ctx) =>
+      crud.update({ id: event.payload.id, changes: { isEnabled: enable } }, event.user, ctx.db, {
+        skipOptimisticLock: true,
+      }),
+  });
+}
+
+export const enableWrite = createToggleTenantHandler(true);
+export const disableWrite = createToggleTenantHandler(false);