@cosmicdrift/kumiko-bundled-features 0.377.0 → 0.378.0

package/dist/template-resolver/handlers/collection-set.write.js

@@ -3,9 +3,9 @@ import { defineWriteHandler, } from "@cosmicdrift/kumiko-framework/engine";
 import { ValidationError, writeFailure } from "@cosmicdrift/kumiko-framework/errors";
 import * as z from "zod";
 import { requireForTenant } from "../../shared/index.js";
-import { isCollectionRefusedKind } from "../constants.js";
+import { DEFAULT_COLLECTION_ACCESS, isCollectionRefusedKind } from "../constants.js";
 import { documentViolationsToFieldIssues, sanitizeTemplateBody } from "../document-sanitizer.js";
-import { collectionStore, DEFAULT_COLLECTION_ACCESS, } from "./collection-shared.js";
+import { collectionStore } from "./collection-shared.js";
 import { contentFormatSchema, folderSchema, localeSchema, slugSchema } from "./shared.js";
 // Upsert inside one collection. Mirrors set.write for text-blocks, but the
 // kind comes from the declaration and the access rule is the collection's own,

package/dist/template-resolver/handlers/collection-shared.d.ts

@@ -1,9 +1,8 @@
 import type { EventStoreExecutor } from "@cosmicdrift/kumiko-framework/db";
-import type { AccessRule, ContentCollectionDefinition, SessionUser, TenantId } from "@cosmicdrift/kumiko-framework/engine";
+import type { ContentCollectionDefinition, SessionUser, TenantId } from "@cosmicdrift/kumiko-framework/engine";
 import type { Temporal } from "@cosmicdrift/kumiko-types/temporal";
 import { templateResourcesTable } from "../table.ts";
 import { userContentEntriesTable } from "../user-content-table.ts";
-export declare const DEFAULT_COLLECTION_ACCESS: AccessRule;
 export type CollectionEntryRow = {
     readonly id: string | number;
     readonly version: number;

package/dist/template-resolver/handlers/collection-shared.js

@@ -2,10 +2,6 @@ import { createEventStoreExecutor } from "@cosmicdrift/kumiko-framework/db";
 import { SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framework/engine";
 import { templateResourceEntity, templateResourcesTable } from "../table.js";
 import { userContentEntriesTable, userContentEntryEntity } from "../user-content-table.js";
-// Applies when an app mounts a collection without saying who may reach it.
-// Deliberately narrow: a collection whose access nobody decided should be
-// invisible to normal users rather than open by default.
-export const DEFAULT_COLLECTION_ACCESS = { roles: ["TenantAdmin", "SystemAdmin"] };
 const templateExecutor = createEventStoreExecutor(templateResourcesTable, templateResourceEntity, {
     entityName: "template-resource",
 });

package/dist/template-resolver/handlers/copy-locale.write.d.ts

@@ -1,5 +1,6 @@
 import * as z from "zod";
-export declare const copyLocaleWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<"copy-locale", z.ZodObject<{
+import { type TemplateEditPolicy } from "../template-edit-policy.ts";
+export declare function makeCopyLocaleWrite(policy: TemplateEditPolicy): import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<"copy-locale", z.ZodObject<{
     slug: z.ZodString;
     kind: z.ZodEnum<{
         "ai-prompt": "ai-prompt";

package/dist/template-resolver/handlers/copy-locale.write.js

@@ -10,6 +10,7 @@ import { TemplateResolverErrors } from "../qualified-names.js";
 import { createLinkedResourceCopies, prepareLinkedResourceCopiesBeforeTransaction, } from "../store-template-resource.js";
 import { templateResourcesTable } from "../table.js";
 import { toWorkingRow } from "../template-draft.js";
+import { refuseTemplateEdit, templateEditAccess, } from "../template-edit-policy.js";
 import { attachTemplateResources } from "../template-resources.js";
 import { resolveTemplateVariables } from "../template-validation.js";
 import { targetExistsIssue } from "./bundle-import.js";
@@ -50,7 +51,7 @@ const copyLocaleSchema = z.object({
     scope: z.enum(["tenant", "system"]).default("tenant"),
 });
 // Runs before the upload (reject early, store nothing) and again in the transaction on the fresh rows.
-async function checkCopyRequest(ctx, event) {
+async function checkCopyRequest(ctx, policy, event) {
     const { slug, kind, fromLocale, toLocale, overwrite, scope } = event.payload;
     if (scope === "system" && !event.user.roles.includes("SystemAdmin")) {
         return writeFailure(new AccessDeniedError({
@@ -59,7 +60,8 @@ async function checkCopyRequest(ctx, event) {
         }));
     }
     const tenantId = scope === "system" ? SYSTEM_TENANT_ID : event.user.tenantId;
-    const refused = refuseTenantScopeUnderSystemTenant(scope, tenantId) ??
+    const refused = (scope === "tenant" ? refuseTemplateEdit(policy, event.user, { slug, kind }) : null) ??
+        refuseTenantScopeUnderSystemTenant(scope, tenantId) ??
         refuseSystemOnlyTenantOverride(ctx.registry, scope, slug, kind);
     if (refused !== null)
         return refused;
@@ -99,65 +101,67 @@ async function checkCopyRequest(ctx, event) {
         },
     };
 }
-export const copyLocaleWrite = defineWriteHandler({
-    name: "copy-locale",
-    schema: copyLocaleSchema,
-    access: { roles: ["TenantAdmin", "SystemAdmin"] },
-    description: "Copies the text of one locale of a template into another locale as a draft override of the caller's tenant, taking the tenant's own row or else the system default as the source; use it as the starting point for a translation. It refuses an existing target unless overwrite is set. With scope system (SystemAdmin only) both source and target are system-default rows and the target lands as a system draft; any other caller gets a 403.",
-    beforeTransaction: async (event, ctx) => {
-        const request = await checkCopyRequest(ctx, event);
-        if (!request.isSuccess)
-            return request;
-        if (!request.data.sourceIsForeign)
-            return { isSuccess: true, data: [] };
-        return prepareLinkedResourceCopiesBeforeTransaction({
-            ctx,
-            user: event.user,
-            tenantId: request.data.tenantId,
-            resources: request.data.sourceResources,
-        });
-    },
-    handler: async (event, ctx) => {
-        const { slug, kind, toLocale } = event.payload;
-        const request = await checkCopyRequest(ctx, event);
-        if (!request.isSuccess)
-            return request;
-        const { scope, tenantId, source, contentFormat, sourceResources, sourceIsForeign } = request.data;
-        const variableSchema = storedRecord(source.variableSchema);
-        const written = await writeTemplateRow({
-            ctx,
-            user: event.user,
-            tenantId,
-            scope,
-            status: "draft",
-            variables: resolveTemplateVariables(ctx.registry, slug, variableSchema),
-            payload: {
-                slug,
-                kind,
-                locale: toLocale,
-                content: source.content,
-                contentFormat,
-                variableSchema,
-                meta: parseStoredJson(source.meta),
-                title: source.title,
-                folder: source.folder,
-            },
-        });
-        if (!written.isSuccess)
+export function makeCopyLocaleWrite(policy) {
+    return defineWriteHandler({
+        name: "copy-locale",
+        schema: copyLocaleSchema,
+        access: templateEditAccess(policy.tenantEditable),
+        description: "Copies the text of one locale of a template into another locale as a draft override of the caller's tenant, taking the tenant's own row or else the system default as the source; use it as the starting point for a translation. It refuses an existing target unless overwrite is set. With scope system (SystemAdmin only) both source and target are system-default rows and the target lands as a system draft; any other caller gets a 403. A TenantAdmin may copy only templates the app lists in tenantEditable, otherwise SystemAdmin only.",
+        beforeTransaction: async (event, ctx) => {
+            const request = await checkCopyRequest(ctx, policy, event);
+            if (!request.isSuccess)
+                return request;
+            if (!request.data.sourceIsForeign)
+                return { isSuccess: true, data: [] };
+            return prepareLinkedResourceCopiesBeforeTransaction({
+                ctx,
+                user: event.user,
+                tenantId: request.data.tenantId,
+                resources: request.data.sourceResources,
+            });
+        },
+        handler: async (event, ctx) => {
+            const { slug, kind, toLocale } = event.payload;
+            const request = await checkCopyRequest(ctx, policy, event);
+            if (!request.isSuccess)
+                return request;
+            const { scope, tenantId, source, contentFormat, sourceResources, sourceIsForeign } = request.data;
+            const variableSchema = storedRecord(source.variableSchema);
+            const written = await writeTemplateRow({
+                ctx,
+                user: event.user,
+                tenantId,
+                scope,
+                status: "draft",
+                variables: resolveTemplateVariables(ctx.registry, slug, variableSchema),
+                payload: {
+                    slug,
+                    kind,
+                    locale: toLocale,
+                    content: source.content,
+                    contentFormat,
+                    variableSchema,
+                    meta: parseStoredJson(source.meta),
+                    title: source.title,
+                    folder: source.folder,
+                },
+            });
+            if (!written.isSuccess)
+                return written;
+            const resources = sourceIsForeign
+                ? await createLinkedResourceCopies({ ctx, user: event.user, tenantId }, event.prepared)
+                : { isSuccess: true, data: sourceResources };
+            if (!resources.isSuccess)
+                return resources;
+            const attached = await attachTemplateResources(ctx, {
+                user: event.user,
+                tenantId,
+                templateId: written.data.id,
+                resources: resources.data,
+            });
+            if (!attached.isSuccess)
+                return attached;
             return written;
-        const resources = sourceIsForeign
-            ? await createLinkedResourceCopies({ ctx, user: event.user, tenantId }, event.prepared)
-            : { isSuccess: true, data: sourceResources };
-        if (!resources.isSuccess)
-            return resources;
-        const attached = await attachTemplateResources(ctx, {
-            user: event.user,
-            tenantId,
-            templateId: written.data.id,
-            resources: resources.data,
-        });
-        if (!attached.isSuccess)
-            return attached;
-        return written;
-    },
-});
+        },
+    });
+}

package/dist/template-resolver/handlers/discard-draft.write.d.ts

@@ -1,11 +1,12 @@
 import * as z from "zod";
-export declare const discardDraftWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<string, z.ZodObject<{
+import { type TemplateEditPolicy } from "../template-edit-policy.ts";
+export declare function makeDiscardDraftWrite(policy: TemplateEditPolicy): import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<string, z.ZodObject<{
     id: z.ZodString;
 }, z.core.$strip>, {
     id: string;
     discarded: boolean;
 }, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap, undefined>;
-export declare const discardDraftSystemWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<string, z.ZodObject<{
+export declare function makeDiscardDraftSystemWrite(policy: TemplateEditPolicy): import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<string, z.ZodObject<{
     id: z.ZodString;
 }, z.core.$strip>, {
     id: string;

package/dist/template-resolver/handlers/discard-draft.write.js

@@ -2,19 +2,27 @@ import { defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
 import { NotFoundError, ValidationError, writeFailure } from "@cosmicdrift/kumiko-framework/errors";
 import * as z from "zod";
 import { TemplateResolverErrors } from "../qualified-names.js";
+import { refuseMissingTemplate, refuseTemplateEdit, } from "../template-edit-policy.js";
 import { executor } from "./shared.js";
 import { loadTargetRow, writeAccessFor } from "./toggle-status.write.js";
-function createDiscardDraftHandler(name, target, description) {
+function createDiscardDraftHandler(policy, name, target, description) {
     return defineWriteHandler({
         name,
         schema: z.object({ id: z.string().min(1) }),
-        access: writeAccessFor(target),
+        access: writeAccessFor(target, policy),
         ...(target === "system" ? { agent: { risk: "high" } } : {}),
         description,
         handler: async (event, ctx) => {
             const { db, scoped, row } = await loadTargetRow(ctx, target, event.user, event.payload.id);
-            if (!row)
-                return writeFailure(new NotFoundError("template-resource", event.payload.id));
+            if (!row) {
+                const refused = target === "own" ? refuseMissingTemplate(policy, event.user) : null;
+                return refused ?? writeFailure(new NotFoundError("template-resource", event.payload.id));
+            }
+            if (target === "own") {
+                const refused = refuseTemplateEdit(policy, event.user, row);
+                if (refused !== null)
+                    return refused;
+            }
             if (row.draft === null) {
                 return writeFailure(new ValidationError({
                     fields: [
@@ -33,5 +41,9 @@ function createDiscardDraftHandler(name, target, description) {
         },
     });
 }
-export const discardDraftWrite = createDiscardDraftHandler("discard-draft", "own", "Throws away the open draft of one template resource of the caller's tenant so the editor shows the active version again; the served version is untouched. Refused with no_draft when there is no draft.");
-export const discardDraftSystemWrite = createDiscardDraftHandler("discard-draft-system", "system", "Throws away the open draft of one system-default template; the served version stays. SystemAdmin only, refused with no_draft when there is no draft.");
+export function makeDiscardDraftWrite(policy) {
+    return createDiscardDraftHandler(policy, "discard-draft", "own", "Throws away the open draft of one template resource of the caller's tenant so the editor shows the active version again; the served version is untouched. Refused with no_draft when there is no draft. Outside the templates the app lists in tenantEditable only a SystemAdmin may use it.");
+}
+export function makeDiscardDraftSystemWrite(policy) {
+    return createDiscardDraftHandler(policy, "discard-draft-system", "system", "Throws away the open draft of one system-default template; the served version stays. SystemAdmin only, refused with no_draft when there is no draft.");
+}

package/dist/template-resolver/handlers/import-bundle.write.d.ts

@@ -1,5 +1,6 @@
 import * as z from "zod";
-export declare const importBundleWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<"import-bundle", z.ZodObject<{
+import { type TemplateEditPolicy } from "../template-edit-policy.ts";
+export declare function makeImportBundleWrite(policy: TemplateEditPolicy): import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<"import-bundle", z.ZodObject<{
     bundle: z.ZodObject<{
         slug: z.ZodString;
         kind: z.ZodEnum<{

package/dist/template-resolver/handlers/import-bundle.write.js

@@ -1,29 +1,34 @@
 import { defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
 import * as z from "zod";
 import { templateBundleSchema } from "../template-bundle.js";
+import { refuseTemplateEdit, templateEditAccess, } from "../template-edit-policy.js";
 import { importTemplateBundle, prepareTemplateBundleBeforeTransaction } from "./bundle-import.js";
-export const importBundleWrite = defineWriteHandler({
-    name: "import-bundle",
-    schema: z.object({ bundle: templateBundleSchema, overwrite: z.boolean().default(false) }),
-    access: { roles: ["TenantAdmin", "SystemAdmin"] },
-    description: "Imports a template bundle (all locales plus resource files, as produced by export-bundle) into the caller's tenant as drafts; it refuses a locale that already has an override unless overwrite is set, and publish makes the drafts live.",
-    beforeTransaction: (event, ctx) => prepareTemplateBundleBeforeTransaction({
-        ctx,
-        user: event.user,
-        tenantId: event.user.tenantId,
-        scope: "tenant",
-        status: "draft",
-        bundle: event.payload.bundle,
-        overwrite: event.payload.overwrite,
-    }),
-    handler: (event, ctx) => importTemplateBundle({
-        ctx,
-        user: event.user,
-        tenantId: event.user.tenantId,
-        scope: "tenant",
-        status: "draft",
-        bundle: event.payload.bundle,
-        overwrite: event.payload.overwrite,
-        prepared: event.prepared,
-    }),
-});
+export function makeImportBundleWrite(policy) {
+    return defineWriteHandler({
+        name: "import-bundle",
+        schema: z.object({ bundle: templateBundleSchema, overwrite: z.boolean().default(false) }),
+        access: templateEditAccess(policy.tenantEditable),
+        description: "Imports a template bundle (all locales plus resource files, as produced by export-bundle) into the caller's tenant as drafts; it refuses a locale that already has an override unless overwrite is set, and publish makes the drafts live. Outside the templates the app lists in tenantEditable only a SystemAdmin may use it.",
+        beforeTransaction: async (event, ctx) => refuseTemplateEdit(policy, event.user, event.payload.bundle) ??
+            prepareTemplateBundleBeforeTransaction({
+                ctx,
+                user: event.user,
+                tenantId: event.user.tenantId,
+                scope: "tenant",
+                status: "draft",
+                bundle: event.payload.bundle,
+                overwrite: event.payload.overwrite,
+            }),
+        handler: async (event, ctx) => refuseTemplateEdit(policy, event.user, event.payload.bundle) ??
+            importTemplateBundle({
+                ctx,
+                user: event.user,
+                tenantId: event.user.tenantId,
+                scope: "tenant",
+                status: "draft",
+                bundle: event.payload.bundle,
+                overwrite: event.payload.overwrite,
+                prepared: event.prepared,
+            }),
+    });
+}

package/dist/template-resolver/handlers/overview.query.d.ts

@@ -1,6 +1,7 @@
 import * as z from "zod";
 import { type TemplateStatus } from "../constants.ts";
 import { type TemplateResourceRow } from "../table.ts";
+import { type TemplateEditPolicy } from "../template-edit-policy.ts";
 import { type EffectiveMailLayoutSlugs } from "../template-usage.ts";
 declare const OVERVIEW_KINDS: readonly ["mail", "document-pdf", "mail-layout", "pdf-layout"];
 type OverviewKind = (typeof OVERVIEW_KINDS)[number];
@@ -38,7 +39,7 @@ export type OverviewResponse = {
     readonly truncated: boolean;
 };
 export declare function effectiveMailLayoutSlugs(rows: readonly TemplateResourceRow[]): EffectiveMailLayoutSlugs;
-export declare const overviewQuery: import("@cosmicdrift/kumiko-types/define-handler").QueryHandlerDefinition<"overview", z.ZodObject<{
+export declare function makeOverviewQuery(policy: TemplateEditPolicy): import("@cosmicdrift/kumiko-types/define-handler").QueryHandlerDefinition<"overview", z.ZodObject<{
     search: z.ZodOptional<z.ZodString>;
     filters: z.ZodOptional<z.ZodArray<z.ZodObject<{
         field: z.ZodEnum<{

package/dist/template-resolver/handlers/overview.query.js

@@ -4,6 +4,7 @@ import * as z from "zod";
 import { DEFAULT_MAIL_LAYOUT_SLUG, FALLBACK_LOCALE } from "../constants.js";
 import { templateResourcesTable } from "../table.js";
 import { activeSinceOf, activeVersionOf, draftViewerTenantId, isHiddenSystemDraft, parseTemplateDraft, servedVersionOf, } from "../template-draft.js";
+import { mayEditTemplate } from "../template-edit-policy.js";
 import { isSystemOnlyTemplateHiddenFrom } from "../template-system-only.js";
 import { collectTemplateUsage } from "../template-usage.js";
 import { storedRecord } from "./template-gates.js";
@@ -171,45 +172,48 @@ const filterSchema = z.object({
     op: z.literal("in"),
     value: z.array(z.string()),
 });
-export const overviewQuery = defineQueryHandler({
-    name: "overview",
-    schema: z.object({
-        search: z.string().optional(),
-        filters: z.array(filterSchema).optional(),
-        layoutSlug: z.string().optional(),
-        sort: z.string().optional(),
-        sortDirection: z.enum(["asc", "desc"]).optional(),
-        limit: z.number().int().min(1).max(200).default(50),
-        offset: z.number().int().min(0).optional(),
-        totalCount: z.boolean().optional(),
-    }),
-    access: { roles: ["TenantAdmin", "SystemAdmin"] },
-    description: "Lists mail, PDF and layout templates as one row per slug and kind for the caller's tenant (optionally only the mails and PDFs using one layout slug): where the effective version comes from (own override or system), its locales, status and version (the served one; `draftVersion` is set when an unpublished draft waits beside it, `activeSince` says since when the served version applies), the system version it overrides, the layout it uses and which notifications or templates use it; templates of notifications registered with `systemOnly` are listed for SystemAdmins only; use it to browse and filter all templates at a glance.",
-    handler: async (query, ctx) => {
-        const payload = query.payload;
-        const fetchedRows = await selectMany(ctx.db, templateResourcesTable, { kind: { in: [...OVERVIEW_KINDS] } }, { orderBy: { col: "id", direction: "asc" }, limit: OVERVIEW_ROW_LIMIT + 1 });
-        const truncated = fetchedRows.length > OVERVIEW_ROW_LIMIT;
-        const rows = truncated ? fetchedRows.slice(0, OVERVIEW_ROW_LIMIT) : fetchedRows;
-        if (truncated) {
-            ctx.log?.warn("template overview: row limit reached, result is incomplete", {
-                limit: OVERVIEW_ROW_LIMIT,
-            });
-        }
-        const visibleRows = rows.filter((row) => !isHiddenSystemDraft(query.user, row) &&
-            !isSystemOnlyTemplateHiddenFrom(query.user, ctx.registry, row));
-        const { drafts, layoutSlugByDocument } = buildDrafts(groupBySlugAndKind(visibleRows), query.user);
-        const effectiveLayouts = effectiveMailLayoutSlugs(visibleRows);
-        const overviewRows = drafts.map((draft) => withUsage(draft, layoutSlugByDocument, ctx.registry, effectiveLayouts));
-        const filtered = filterRows(overviewRows, payload.search, payload.filters ?? [], payload.layoutSlug);
-        const sortField = payload.sort !== undefined && isSortField(payload.sort) ? payload.sort : "modifiedAt";
-        const direction = (payload.sortDirection ?? "desc") === "desc" ? -1 : 1;
-        filtered.sort((a, b) => direction * compareBy(sortField, a, b) || a.id.localeCompare(b.id));
-        const offset = payload.offset ?? 0;
-        return {
-            rows: filtered.slice(offset, offset + payload.limit),
-            nextCursor: null,
-            total: filtered.length,
-            truncated,
-        };
-    },
-});
+export function makeOverviewQuery(policy) {
+    return defineQueryHandler({
+        name: "overview",
+        schema: z.object({
+            search: z.string().optional(),
+            filters: z.array(filterSchema).optional(),
+            layoutSlug: z.string().optional(),
+            sort: z.string().optional(),
+            sortDirection: z.enum(["asc", "desc"]).optional(),
+            limit: z.number().int().min(1).max(200).default(50),
+            offset: z.number().int().min(0).optional(),
+            totalCount: z.boolean().optional(),
+        }),
+        access: { roles: ["TenantAdmin", "SystemAdmin"] },
+        description: "Lists mail, PDF and layout templates as one row per slug and kind for the caller's tenant (optionally only the mails and PDFs using one layout slug): where the effective version comes from (own override or system), its locales, status and version (the served one; `draftVersion` is set when an unpublished draft waits beside it, `activeSince` says since when the served version applies), the system version it overrides, the layout it uses and which notifications or templates use it; templates of notifications registered with `systemOnly` are listed for SystemAdmins only, and a TenantAdmin sees only the templates the app lists in tenantEditable; use it to browse and filter all templates at a glance.",
+        handler: async (query, ctx) => {
+            const payload = query.payload;
+            const fetchedRows = await selectMany(ctx.db, templateResourcesTable, { kind: { in: [...OVERVIEW_KINDS] } }, { orderBy: { col: "id", direction: "asc" }, limit: OVERVIEW_ROW_LIMIT + 1 });
+            const truncated = fetchedRows.length > OVERVIEW_ROW_LIMIT;
+            const rows = truncated ? fetchedRows.slice(0, OVERVIEW_ROW_LIMIT) : fetchedRows;
+            if (truncated) {
+                ctx.log?.warn("template overview: row limit reached, result is incomplete", {
+                    limit: OVERVIEW_ROW_LIMIT,
+                });
+            }
+            const visibleRows = rows.filter((row) => !isHiddenSystemDraft(query.user, row) &&
+                !isSystemOnlyTemplateHiddenFrom(query.user, ctx.registry, row) &&
+                mayEditTemplate(policy, query.user, row));
+            const { drafts, layoutSlugByDocument } = buildDrafts(groupBySlugAndKind(visibleRows), query.user);
+            const effectiveLayouts = effectiveMailLayoutSlugs(visibleRows);
+            const overviewRows = drafts.map((draft) => withUsage(draft, layoutSlugByDocument, ctx.registry, effectiveLayouts));
+            const filtered = filterRows(overviewRows, payload.search, payload.filters ?? [], payload.layoutSlug);
+            const sortField = payload.sort !== undefined && isSortField(payload.sort) ? payload.sort : "modifiedAt";
+            const direction = (payload.sortDirection ?? "desc") === "desc" ? -1 : 1;
+            filtered.sort((a, b) => direction * compareBy(sortField, a, b) || a.id.localeCompare(b.id));
+            const offset = payload.offset ?? 0;
+            return {
+                rows: filtered.slice(offset, offset + payload.limit),
+                nextCursor: null,
+                total: filtered.length,
+                truncated,
+            };
+        },
+    });
+}

package/dist/template-resolver/handlers/patch-draft.write.d.ts

@@ -1,5 +1,6 @@
 import * as z from "zod";
-export declare const patchDraftWrite: import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<"patch-draft", z.ZodObject<{
+import { type TemplateEditPolicy } from "../template-edit-policy.ts";
+export declare function makePatchDraftWrite(policy: TemplateEditPolicy): import("@cosmicdrift/kumiko-types/define-handler").WriteHandlerDefinition<"patch-draft", z.ZodObject<{
     slug: z.ZodString;
     kind: z.ZodEnum<{
         "document-pdf": "document-pdf";