@cosmicdrift/kumiko-framework 0.365.1 → 0.366.0

package/AGENTS.md

@@ -55,8 +55,8 @@ need an access rule for both sides, `write: { access }` and
 overrides a single verb. Without them boot stops. Turn single
 verbs off with `verbs: { delete: false }` and register them yourself when
 they need different access or logic. Custom logic goes into
-`r.writeHandler(qn, schema, fn, { access })` and
-`r.queryHandler(qn, schema, fn, { access })`; inside, use the entity
+`r.writeHandler({ name, schema, handler, access })` and
+`r.queryHandler({ name, schema, handler, access })`; inside, use the entity
 executor from `createEntityExecutor(name, entity)`.
 
 **Screen.** A declarative page: `r.screen({ id, type, ... })`. Types include

package/agents/examples/access-control.md

@@ -72,12 +72,18 @@ describe("default-deny: refuses handlers without access", () => {
     expect(() =>
       defineFeature("broken-feature", (r) => {
         // @ts-expect-error — No { access: ... }: registration must reject this.
-        r.writeHandler("forgotAccess", z.object({ name: z.string() }), async () => ({
-          isSuccess: true as const,
-          data: {},
-        }));
+        r.writeHandler({
+          name: "forgotAccess",
+          schema: z.object({ name: z.string() }),
+          handler: async () => ({
+            isSuccess: true as const,
+            data: {},
+          }),
+        });
       }),
-    ).toThrow(/requires schema \+ handler \+ options\.access/);
+    ).toThrow(
+      /\[Feature broken-feature\] r\.writeHandler\(\{ name: "forgotAccess" \}\) requires an access rule/,
+    );
   });
 });
 
@@ -273,8 +279,8 @@ export const taskTable = buildEntityTable("task", taskEntity, {
 });
 
 export const accessControlFeature = defineFeature("access-control", (r) => {
-  r.entity("project", projectEntity);
-  r.entity("task", taskEntity);
+  r.entity({ name: "project", ...projectEntity });
+  r.entity({ name: "task", ...taskEntity });
   r.relation("task", "project", taskRelations.project);
 
   // Admin-only: standard create — no business logic, helper handles schema +
@@ -289,14 +295,14 @@ export const accessControlFeature = defineFeature("access-control", (r) => {
   // hand-write this handler instead of using the helper. The framework helpers
   // are deliberately scope-limited — opt out the moment you need defaults.
   const taskExecutor = createEventStoreExecutor(taskTable, taskEntity, { entityName: "task" });
-  r.writeHandler(
-    "task:create",
-    z.object({
+  r.writeHandler({
+    name: "task:create",
+    schema: z.object({
       title: z.string().min(1),
       projectId: z.uuid(),
       assigneeId: z.uuid().optional(),
     }),
-    async (event, ctx) =>
+    handler: async (event, ctx) =>
       taskExecutor.create(
         {
           ...event.payload,
@@ -305,22 +311,20 @@ export const accessControlFeature = defineFeature("access-control", (r) => {
         event.user,
         ctx.db,
       ),
-    {
-      access: {
-        openToAll: {
-          reason:
-            "any signed-in tenant user may create a task; assigneeId defaults to the caller when omitted",
-        },
+    access: {
+      openToAll: {
+        reason:
+          "any signed-in tenant user may create a task; assigneeId defaults to the caller when omitted",
       },
     },
-  );
+  });
 
   // Update requires version — optimistic locking is the default and this
   // narrowed schema (only title + assigneeId mutable) is stricter than the
   // helper's generic update schema, so we keep it hand-written.
-  r.writeHandler(
-    "task:update",
-    z.object({
+  r.writeHandler({
+    name: "task:update",
+    schema: z.object({
       id: z.uuid(),
       version: z.number(),
       changes: z.object({
@@ -328,17 +332,15 @@ export const accessControlFeature = defineFeature("access-control", (r) => {
         assigneeId: z.uuid().optional(),
       }),
     }),
-    async (event, ctx) => taskExecutor.update(event.payload, event.user, ctx.db),
-    {
-      access: {
-        openToAll: {
-          reason:
-            "any signed-in tenant user may update a task; optimistic locking (version) " +
-            "guards against concurrent overwrites, not caller identity",
-        },
+    handler: async (event, ctx) => taskExecutor.update(event.payload, event.user, ctx.db),
+    access: {
+      openToAll: {
+        reason:
+          "any signed-in tenant user may update a task; optimistic locking (version) " +
+          "guards against concurrent overwrites, not caller identity",
       },
     },
-  );
+  });
 
   // Self-service list — no custom logic.
   r.queryHandler(

package/agents/examples/anonymous-access-multitenant.md

@@ -304,34 +304,32 @@ export const productEntity = createEntity({
 export const productTable = buildEntityTable("product", productEntity);
 
 export const multiTenantShopFeature = defineFeature("mtshop", (r) => {
-  r.entity("product", productEntity);
+  r.entity({ name: "product", ...productEntity });
 
   // Public listing — every tenant has its own products, scoped by tenantId
   // automatically via the framework's tenant-isolation. Anonymous visitors
   // see only the tenant they landed on.
-  r.queryHandler(
-    "product:list",
-    z.object({}),
-    async (_event, ctx) => ctx.db.selectMany(productTable),
-    {
-      access: { roles: [...access.anonymous, "User", "Admin"] },
-      rateLimit: { per: "ip+handler", limit: 60, windowSeconds: 60 },
-    },
-  );
+  r.queryHandler({
+    name: "product:list",
+    schema: z.object({}),
+    handler: async (_event, ctx) => ctx.db.selectMany(productTable),
+    access: { roles: [...access.anonymous, "User", "Admin"] },
+    rateLimit: { per: "ip+handler", limit: 60, windowSeconds: 60 },
+  });
 
   // Admin-only — proves role-gating still works on top of the multi-tenant
   // anonymous resolution.
-  r.writeHandler(
-    "product:create",
-    z.object({ name: z.string().min(1) }),
-    async (event, ctx) => {
+  r.writeHandler({
+    name: "product:create",
+    schema: z.object({ name: z.string().min(1) }),
+    handler: async (event, ctx) => {
       const exec = createEventStoreExecutor(productTable, productEntity, {
         entityName: "product",
       });
       return exec.create(event.payload, event.user, ctx.db);
     },
-    { access: { roles: ["Admin"] } },
-  );
+    access: { roles: ["Admin"] },
+  });
 });
 ```
 

package/agents/examples/anonymous-access.md

@@ -207,41 +207,37 @@ export const productTable = buildEntityTable("product", productEntity);
 export const guestOrderTable = buildEntityTable("guest-order", guestOrderEntity);
 
 export const anonymousAccessFeature = defineFeature("shop", (r) => {
-  r.entity("product", productEntity);
-  r.entity("guest-order", guestOrderEntity);
+  r.entity({ name: "product", ...productEntity });
+  r.entity({ name: "guest-order", ...guestOrderEntity });
 
   // Public listing: anonymous + authenticated customers see it. Combining
   // the roles in one handler is preferred over duplicating the read path —
   // the handler body can branch on `event.user.id === "anonymous"` if it
   // needs to personalise (e.g. show a sign-in CTA, hide a wishlist button).
-  r.queryHandler(
-    "product:list",
-    z.object({}),
-    async (_event, ctx) => ctx.db.selectMany(productTable),
-    {
-      access: { roles: [...access.anonymous, "User", "Admin"] },
-      rateLimit: { per: "ip+handler", limit: 60, windowSeconds: 60 },
-    },
-  );
+  r.queryHandler({
+    name: "product:list",
+    schema: z.object({}),
+    handler: async (_event, ctx) => ctx.db.selectMany(productTable),
+    access: { roles: [...access.anonymous, "User", "Admin"] },
+    rateLimit: { per: "ip+handler", limit: 60, windowSeconds: 60 },
+  });
 
   // Authenticated-only listing — same data, different access rule. The
   // openToAll declaration here is the regression-guard: even with
   // anonymousAccess enabled on the server, this endpoint stays gated to
   // logged-in users.
-  r.queryHandler(
-    "product:authenticated-only",
-    z.object({}),
-    async (_event, ctx) => ctx.db.selectMany(productTable),
-    {
-      access: {
-        openToAll: {
-          reason:
-            "any signed-in (non-anonymous) user may list products here; this handler is " +
-            "the regression-guard proving anonymousAccess never silently exposes an authenticated-only endpoint",
-        },
+  r.queryHandler({
+    name: "product:authenticated-only",
+    schema: z.object({}),
+    handler: async (_event, ctx) => ctx.db.selectMany(productTable),
+    access: {
+      openToAll: {
+        reason:
+          "any signed-in (non-anonymous) user may list products here; this handler is " +
+          "the regression-guard proving anonymousAccess never silently exposes an authenticated-only endpoint",
       },
     },
-  );
+  });
 
   // Anonymous + authenticated guest checkout. Stores the synthesised user-id
   // ("anonymous") in `placedBy` so audit-trail / support queries can tell
@@ -252,37 +248,34 @@ export const anonymousAccessFeature = defineFeature("shop", (r) => {
   const guestOrderExecutor = createEventStoreExecutor(guestOrderTable, guestOrderEntity, {
     entityName: "guest-order",
   });
-  r.writeHandler(
-    "guest-order:place",
-    z.object({
+  r.writeHandler({
+    name: "guest-order:place",
+    schema: z.object({
       productId: z.uuid(),
       email: z.string().email(),
     }),
-    async (event, ctx) =>
-      guestOrderExecutor.create({ ...event.payload, placedBy: event.user.id }, event.user, ctx.db),
-    {
-      // `email` is recordOwned PII (personal: { of: "id" }) written by an
-      // anonymous root handler — the runtime personal-data gate
-      // (write-origin.ts) requires this explicit opt-in, the same way the
-      // boot validator would reject an openToAll declaration missing it.
-      access: { roles: [...access.anonymous, "User"], personalData: "public-intake" },
-      rateLimit: { per: "ip+handler", limit: 30, windowSeconds: 60 },
-    },
-  );
+    handler: async (event, ctx) =>
+      guestOrderExecutor.create({ ...event.payload, placedBy: event.user.id }, event.user, ctx.db), // `email` is recordOwned PII (personal: { of: "id" }) written by an
+    // anonymous root handler — the runtime personal-data gate
+    // (write-origin.ts) requires this explicit opt-in, the same way the
+    // boot validator would reject an openToAll declaration missing it.
+    access: { roles: [...access.anonymous, "User"], personalData: "public-intake" },
+    rateLimit: { per: "ip+handler", limit: 30, windowSeconds: 60 },
+  });
 
   // Admin-only product CRUD — proves role-gated handlers still reject
   // anonymous callers. Same shape as any other handler in the framework:
   // anonymous is just a regular role, not a special case.
-  r.writeHandler(
-    "product:create",
-    z.object({ name: z.string().min(1), priceCents: z.string() }),
-    async (event, ctx) => {
+  r.writeHandler({
+    name: "product:create",
+    schema: z.object({ name: z.string().min(1), priceCents: z.string() }),
+    handler: async (event, ctx) => {
       const exec = createEventStoreExecutor(productTable, productEntity, {
         entityName: "product",
       });
       return exec.create(event.payload, event.user, ctx.db);
     },
-    { access: { roles: ["Admin"] } },
-  );
+    access: { roles: ["Admin"] },
+  });
 });
 ```

package/agents/examples/auth-foundation-providers.md

@@ -125,7 +125,7 @@ export function createSubdomainTenantRoutingFeature(
   const reserved = new Set(opts.reservedSubdomains ?? ["www", "app", "api", "admin"]);
 
   return defineFeature("sample-subdomain-tenant-routing", (r) => {
-    r.requires("auth-foundation");
+    r.requires({ features: ["auth-foundation"] });
 
     const resolverPlugin: TenantResolverProvider = {
       trust,

package/agents/examples/basic-entity.md

@@ -36,7 +36,7 @@ task-management → single feature, single `task` entity, six CRUD handlers
 ```
 
 No bundled features required — this is the baseline before you add
-`r.requires("tenant")`, auth, or cross-feature extensions.
+`r.requires({ features: ["tenant"] })`, auth, or cross-feature extensions.
 
 ## Flow
 

package/agents/examples/boot-check.md

@@ -21,7 +21,7 @@ never mounted, and nothing caught it — until now.
   feature-prefixed message.
 - **Conditional invariants `r.requires` can't express** — the check only
   fails when *this* feature's own shape demands it (has a PII field), not
-  unconditionally. A plain `r.requires("user-data-hook")` would fail even
+  unconditionally. A plain `r.requires({ features: ["user-data-hook"] })` would fail even
   for a prompt-store variant with no PII fields at all.
 - **`validateBoot`** — the framework's boot-time validator, run directly
   against a feature list. `bootCheck` has no DB dependency, so this is the
@@ -98,7 +98,7 @@ import { createEntity, createTextField, defineFeature } from "@cosmicdrift/kumik
 
 // A prompt-store integration trap: a feature with a PII field was mounted
 // without its required companion feature, and nothing caught it at boot.
-// r.requires("user-data-hook") can't express this — it would
+// r.requires({ features: ["user-data-hook"] }) can't express this — it would
 // fail even for a prompt-store variant with no PII fields at all.
 const promptFields = {
   text: createTextField({
@@ -108,7 +108,7 @@ const promptFields = {
 };
 
 export const promptStoreFeature = defineFeature("prompt-store", (r) => {
-  r.entity("prompt", createEntity({ fields: promptFields }));
+  r.entity({ name: "prompt", ...createEntity({ fields: promptFields }) });
   r.bootCheck(({ features }) => {
     const hasPiiField = Object.values(promptFields).some((field) => field.pii);
     const hasUserDataHook = features.some((f) => f.name === "user-data-hook");

package/agents/examples/chat-channels.md

@@ -229,7 +229,7 @@ import * as z from "zod";
 export const OPS_ANNOUNCEMENT_TYPE = qn("ops", "notify", "announcement");
 
 export const opsFeature = defineFeature("ops", (r) => {
-  r.requires("delivery");
+  r.requires({ features: ["delivery"] });
 
   r.writeHandler(
     defineWriteHandler({

package/agents/examples/cross-feature-events.md

@@ -258,7 +258,7 @@ export const capturedEvents: CapturedEvent[] = [];
 // --- Feature ---
 
 export const pubsubOrderFeature = defineFeature("pubsubOrders", (r) => {
-  r.entity("pubsub-order", orderEntity);
+  r.entity({ name: "pubsub-order", ...orderEntity });
 
   // Define the event shape once. The returned `.name` is the qualified
   // name ("pubsub-orders:event:order-placed") — pass it to ctx.appendEvent.
@@ -270,10 +270,10 @@ export const pubsubOrderFeature = defineFeature("pubsubOrders", (r) => {
 
   const { executor: orderExecutor } = createEntityExecutor("pubsub-order", orderEntity);
 
-  r.writeHandler(
-    "order:place",
-    z.object({ customer: z.string().min(1), product: z.string().min(1) }),
-    async (event, ctx) => {
+  r.writeHandler({
+    name: "order:place",
+    schema: z.object({ customer: z.string().min(1), product: z.string().min(1) }),
+    handler: async (event, ctx) => {
       const result = await orderExecutor.create(event.payload, event.user, ctx.db);
       if (result.isSuccess) {
         // emitEvent runs inside the executor's TX and is typed against
@@ -294,8 +294,8 @@ export const pubsubOrderFeature = defineFeature("pubsubOrders", (r) => {
       }
       return result;
     },
-    { access: { roles: ["Admin", "Customer"] } },
-  );
+    access: { roles: ["Admin", "Customer"] },
+  });
 
   // Async consumer — Marten-style. Fires after commit, via the event-
   // dispatcher. No `table` means this MSP is pure side-effect (no state

package/agents/examples/currencies-global.md

@@ -453,9 +453,9 @@ const CURRENCY_CATALOG = [
 ] as const;
 
 export const currenciesGlobalFeature = defineFeature("currenciesGlobal", (r) => {
-  const currency = r.entity("currency", currencyEntity);
-  r.entity("tenant-currency", tenantCurrencyEntity);
-  r.entity("invoice", invoiceEntity);
+  const currency = r.entity({ name: "currency", ...currencyEntity });
+  r.entity({ name: "tenant-currency", ...tenantCurrencyEntity });
+  r.entity({ name: "invoice", ...invoiceEntity });
 
   // Seed global currency table — available for all tenants to pick from
   r.referenceData(currency, [...CURRENCY_CATALOG], { upsertKey: "code" });

package/agents/examples/currencies-per-tenant.md

@@ -318,8 +318,8 @@ export { currencyEntity } from "./entities/currency";
 export { invoiceEntity } from "./entities/invoice";
 
 export const currenciesPerTenantFeature = defineFeature("currenciesPerTenant", (r) => {
-  r.entity("currency", currencyEntity);
-  r.entity("invoice", invoiceEntity);
+  r.entity({ name: "currency", ...currencyEntity });
+  r.entity({ name: "invoice", ...invoiceEntity });
 
   // No r.referenceData() — tenants create currencies themselves
   r.writeHandler(currencyCreate);

package/agents/examples/custom-fields-basic.md

@@ -44,7 +44,7 @@ property-management    → our feature: opts the `property` entity into
                          custom-fields via wireCustomFieldsFor
 ```
 
-The `property-management` feature `r.requires("custom-fields")` — the
+The `property-management` feature `r.requires({ features: ["custom-fields"] })` — the
 bundle is non-optional for this recipe because the wired entity would
 otherwise have an empty jsonb column and no way to write into it.
 
@@ -269,9 +269,10 @@ function propertyExecutor() {
 // --- Feature ---
 
 export const propertyFeature = defineFeature("property-management", (r) => {
-  r.requires("custom-fields");
+  r.requires({ features: ["custom-fields"] });
 
-  r.entity("property", {
+  r.entity({
+    name: "property",
     table: "read_sample_cf_properties",
     fields: {
       name: { type: "text", required: true, maxLength: 200 },

package/agents/examples/custom-handlers.md

@@ -21,9 +21,9 @@ logic is yours.
 
 ## What it shows
 
-- **`r.writeHandler(name, schema, handler, options)`** — the positional
-  inline form, useful when the handler body is short and stays close to
-  its registration.
+- **`r.writeHandler({ name, schema, handler, access })`** — the inline
+  form, useful when the handler body is short and stays close to its
+  registration.
 - **Read-modify-write with optimistic locking** — `increment` reads the
   current count, computes the new one, and updates with the version it
   read. Two concurrent increments cannot both succeed.
@@ -341,7 +341,7 @@ export const counterEntity = createEntity({
 });
 
 export const counterFeature = defineFeature("counters", (r) => {
-  r.entity("counter", counterEntity);
+  r.entity({ name: "counter", ...counterEntity });
 
   // createEntityExecutor bundles buildEntityTable + createEventStoreExecutor —
   // the same pair every custom write-handler opens with. Collapses 3 lines
@@ -349,19 +349,19 @@ export const counterFeature = defineFeature("counters", (r) => {
   const { executor: counterExecutor } = createEntityExecutor("counter", counterEntity);
 
   // Standard create
-  r.writeHandler(
-    "counter:create",
-    z.object({ name: z.string().min(1) }),
-    async (event, ctx) =>
+  r.writeHandler({
+    name: "counter:create",
+    schema: z.object({ name: z.string().min(1) }),
+    handler: async (event, ctx) =>
       counterExecutor.create({ ...event.payload, count: 0 }, event.user, ctx.db),
-    { access: { roles: ["Admin"] } },
-  );
+    access: { roles: ["Admin"] },
+  });
 
   // Custom handler: increment with business logic
-  r.writeHandler(
-    "counter:increment",
-    z.object({ id: z.uuid(), amount: z.number().min(1).max(100) }),
-    async (event, ctx) => {
+  r.writeHandler({
+    name: "counter:increment",
+    schema: z.object({ id: z.uuid(), amount: z.number().min(1).max(100) }),
+    handler: async (event, ctx) => {
       const current = await counterExecutor.detail({ id: event.payload.id }, event.user, ctx.db);
       if (!current) {
         return failNotFound("counter", event.payload.id);
@@ -381,14 +381,14 @@ export const counterFeature = defineFeature("counters", (r) => {
         ctx.db,
       );
     },
-    { access: { roles: ["Admin", "User"] } },
-  );
+    access: { roles: ["Admin", "User"] },
+  });
 
   // Custom handler: reset to zero
-  r.writeHandler(
-    "counter:reset",
-    z.object({ id: z.uuid() }),
-    async (event, ctx) =>
+  r.writeHandler({
+    name: "counter:reset",
+    schema: z.object({ id: z.uuid() }),
+    handler: async (event, ctx) =>
       // Admin reset: last-writer-wins is intentional — there's no useful
       // concurrent-reset race to guard against.
       counterExecutor.update(
@@ -397,16 +397,16 @@ export const counterFeature = defineFeature("counters", (r) => {
         ctx.db,
         { skipOptimisticLock: true },
       ),
-    { access: { roles: ["Admin"] } },
-  );
+    access: { roles: ["Admin"] },
+  });
 
   // Custom query: only counters above a threshold. list() returns one page
   // (default 50, max 200, MAX_LIST_LIMIT), so a JS filter would miss rows after
   // page 1; filter in the query instead. totalCount counts over the whole WHERE.
-  r.queryHandler(
-    "counter:active",
-    z.object({ minCount: z.number().int().default(1), cursor: z.string().optional() }),
-    async (query, ctx) =>
+  r.queryHandler({
+    name: "counter:active",
+    schema: z.object({ minCount: z.number().int().default(1), cursor: z.string().optional() }),
+    handler: async (query, ctx) =>
       counterExecutor.list(
         {
           filter: { field: "count", op: "gte", value: query.payload.minCount },
@@ -416,29 +416,25 @@ export const counterFeature = defineFeature("counters", (r) => {
         query.user,
         ctx.db,
       ),
-    {
-      access: {
-        openToAll: {
-          reason:
-            "any signed-in user may list active counters; the sample has no per-user counter ownership",
-        },
+    access: {
+      openToAll: {
+        reason:
+          "any signed-in user may list active counters; the sample has no per-user counter ownership",
       },
     },
-  );
+  });
 
   // Standard detail
-  r.queryHandler(
-    "counter:detail",
-    z.object({ id: z.uuid() }),
-    async (query, ctx) => counterExecutor.detail(query.payload, query.user, ctx.db),
-    {
-      access: {
-        openToAll: {
-          reason:
-            "any signed-in user may read a counter by id; the sample has no per-user counter ownership",
-        },
+  r.queryHandler({
+    name: "counter:detail",
+    schema: z.object({ id: z.uuid() }),
+    handler: async (query, ctx) => counterExecutor.detail(query.payload, query.user, ctx.db),
+    access: {
+      openToAll: {
+        reason:
+          "any signed-in user may read a counter by id; the sample has no per-user counter ownership",
       },
     },
-  );
+  });
 });
 ```

package/agents/examples/dashboard-stats.md

@@ -160,10 +160,10 @@ export const ticketFeature = defineFeature("tickets", (r) => {
   // Flat result: each dashboard stat reads one field via its valueField.
   // limit: 1 keeps the page tiny; totalCount counts over the whole WHERE in
   // the database, so no rows are loaded just to be counted.
-  r.queryHandler(
-    "ticket:stats",
-    z.object({}),
-    async (query, ctx) => {
+  r.queryHandler({
+    name: "ticket:stats",
+    schema: z.object({}),
+    handler: async (query, ctx) => {
       const countWithStatus = async (status: (typeof TICKET_STATUSES)[number]): Promise<number> => {
         const page = await ticketExecutor.list(
           { filter: { field: "status", op: "eq", value: status }, limit: 1, totalCount: true },
@@ -178,8 +178,8 @@ export const ticketFeature = defineFeature("tickets", (r) => {
       ]);
       return { open, closed, total: open + closed };
     },
-    { access: readerRoles },
-  );
+    access: readerRoles,
+  });
 
   r.translations({
     keys: {

package/agents/examples/delivery-notifications.md

@@ -36,7 +36,7 @@ channel-inApp / channel-email / channel-push
 support           → our business logic (tickets + the notification declaration)
 ```
 
-The `support` feature `r.requires("delivery")`: channels are features that attach to delivery, but `support` doesn't need to know them.
+The `support` feature `r.requires({ features: ["delivery"] })`: channels are features that attach to delivery, but `support` doesn't need to know them.
 
 ## Flow
 
@@ -364,9 +364,9 @@ function ticketExecutor() {
 export const TICKET_ASSIGNED = qn("support", QnTypes.notify, "ticket-assigned");
 
 export const supportFeature = defineFeature("support", (r) => {
-  r.requires("delivery");
+  r.requires({ features: ["delivery"] });
 
-  r.entity("ticket", ticketEntity);
+  r.entity({ name: "ticket", ...ticketEntity });
 
   r.notification("ticket-assigned", {
     variables: {
@@ -396,16 +396,16 @@ export const supportFeature = defineFeature("support", (r) => {
     },
   });
 
-  r.writeHandler(
-    "ticket:create",
-    z.object({
+  r.writeHandler({
+    name: "ticket:create",
+    schema: z.object({
       title: z.string().min(1),
       description: z.string().optional(),
       assigneeId: z.uuid().optional(),
       priority: z.enum(["low", "normal", "critical"]),
       status: z.string().default("open"),
     }),
-    async (event, ctx) => {
+    handler: async (event, ctx) => {
       const created = await ticketExecutor().create(event.payload, event.user, ctx.db);
       const assigneeId = event.payload.assigneeId;
       // No assignee, no notification.
@@ -426,7 +426,7 @@ export const supportFeature = defineFeature("support", (r) => {
       });
       return created;
     },
-    { access: { roles: ["Admin", "Support"] } },
-  );
+    access: { roles: ["Admin", "Support"] },
+  });
 });
 ```