@ydtb/tk-scope-capture 0.22.0 → 0.23.6

package/dist/src/server/api/router.js

@@ -4,14 +4,53 @@ import "@ydtb/core-layer-postgres";
 import { and, desc, eq, gte, isNull, sql } from "@ydtb/tk-scope-db/schema";
 import { base, requirePermission, scopeAuthed } from "@ydtb/tk-scope-extension/orpc";
 import { z } from "zod";
-import { captureActionRuns, captureAnswers, captureDefinitions, capturePublications, captureSubmissions, } from "../../shared/db/schema.js";
-import { getVisibleCaptureFields } from "../../shared/conditions.js";
-import { REFERENCE_CAPTURE_FIELD_TYPES, normalizeCaptureAnswer, validateCaptureAnswer } from "../../shared/field-types.js";
+import { captureActionRuns, captureAnswers, captureDefinitions, captureItemViews, captureSubmissionViews, capturePublications, captureSubmissions, } from "../../shared/db/schema.js";
+import { evaluateCaptureCondition, getVisibleCaptureFields } from "../../shared/conditions.js";
+import { deriveCaptureDocumentFromFields, extractCaptureAnswerFields, normalizeCaptureDocumentForPersistence, resolveCaptureDocument, } from "../../shared/document.js";
+import { REFERENCE_CAPTURE_FIELD_TYPES, isHiddenCaptureField, isHoneypotCaptureField, normalizeCaptureAnswer, validateCaptureAnswer } from "../../shared/field-types.js";
+import { validateCaptureFieldRules } from "../../shared/validation.js";
 import { evaluateQuizOutcome } from "../../shared/scoring.js";
-import { emailActionAdapter, emailActionConfigSchema, executeWorkflowAction, workflowActionAdapter, workflowActionConfigSchema } from "./action-adapters.js";
+import { buildWorkflowSubmissionPayload, emailActionAdapter, emailActionConfigSchema, executeWorkflowAction, workflowActionAdapter, workflowActionConfigSchema } from "./action-adapters.js";
 function getDb() {
     return getLayer("database").db;
 }
+async function resolveCaptureStorageImageUrls(args) {
+    const storageItems = args.document.items.filter((item) => {
+        if (item.kind !== "content.image")
+            return false;
+        return item.source?.type === "storage" && !!item.source.storageItemId;
+    });
+    if (storageItems.length === 0)
+        return args.document;
+    const resolvedUrls = new Map();
+    await Promise.all(storageItems.map(async (item) => {
+        const storageItemId = item.source?.storageItemId;
+        if (!storageItemId)
+            return;
+        try {
+            const result = await getHooks().doAction("storage:get-download-url", {
+                scope: args.scope,
+                scopeId: args.scopeId,
+                itemId: storageItemId,
+            });
+            if (result?.url)
+                resolvedUrls.set(item.id, result.url);
+        }
+        catch {
+            // Missing/unavailable storage should not make the whole public
+            // form unavailable. The renderer falls back to the image
+            // placeholder for unresolved decorative content.
+        }
+    }));
+    if (resolvedUrls.size === 0)
+        return args.document;
+    return {
+        ...args.document,
+        items: args.document.items.map((item) => item.kind === "content.image" && resolvedUrls.has(item.id)
+            ? { ...item, imageUrl: resolvedUrls.get(item.id) }
+            : item),
+    };
+}
 const fieldTypeSchema = z.string().min(1).max(80);
 const answerValueSchema = z.union([
     z.string(),
@@ -20,12 +59,71 @@ const answerValueSchema = z.union([
     z.null(),
     z.array(z.string()),
 ]);
-const conditionSchema = z.object({
+const legacyConditionSchema = z.object({
     fieldId: z.string().min(1).max(80),
     fieldKey: z.string().min(1).max(80),
     operator: z.enum(["equals", "notEquals", "isEmpty", "isNotEmpty"]),
     value: answerValueSchema.optional(),
 });
+const filterConditionSchema = z.object({
+    id: z.string().min(1).max(80),
+    fieldKey: z.string().min(1).max(80),
+    operator: z.enum([
+        "is",
+        "is_not",
+        "contains",
+        "does_not_contain",
+        "starts_with",
+        "ends_with",
+        "is_empty",
+        "is_not_empty",
+        "greater_than",
+        "less_than",
+        "greater_than_or_equal",
+        "less_than_or_equal",
+    ]),
+    value: z.string().optional(),
+});
+const conditionGroupSchema = z.lazy(() => z.object({
+    id: z.string().min(1).max(80),
+    logic: z.enum(["and", "or"]),
+    conditions: z.array(z.union([filterConditionSchema, conditionGroupSchema])),
+}));
+const conditionSchema = z.union([legacyConditionSchema, conditionGroupSchema]);
+const validationOperatorSchema = z.enum([
+    "is",
+    "is_not",
+    "contains",
+    "does_not_contain",
+    "starts_with",
+    "ends_with",
+    "regex",
+    "is_empty",
+    "is_not_empty",
+    "greater_than",
+    "less_than",
+    "greater_than_or_equal",
+    "less_than_or_equal",
+]);
+const validationExpressionSchema = z.lazy(() => z.union([
+    z.object({
+        id: z.string().min(1).max(80),
+        fieldKey: z.string().min(1).max(80),
+        operator: validationOperatorSchema,
+        value: z.string().max(500).optional(),
+        valueFieldKey: z.string().min(1).max(80).optional(),
+    }),
+    z.object({
+        id: z.string().min(1).max(80),
+        logic: z.enum(["and", "or"]),
+        conditions: z.array(validationExpressionSchema),
+    }),
+]));
+const validationRuleSchema = z.object({
+    id: z.string().min(1).max(80),
+    message: z.string().min(1).max(300),
+    expression: validationExpressionSchema,
+});
 const fieldSchema = z.object({
     id: z.string().min(1).max(80),
     key: z.string().min(1).max(80),
@@ -34,7 +132,116 @@ const fieldSchema = z.object({
     required: z.boolean().default(false),
     options: z.array(z.string().min(1).max(120)).optional(),
     metadata: z.record(z.string(), z.unknown()).optional(),
+    hidden: z.boolean().optional(),
+    visibleWhen: conditionSchema.optional(),
+    validationRules: z.array(validationRuleSchema).max(1).optional(),
+});
+const documentPageSchema = z.object({
+    id: z.string().min(1).max(80),
+    title: z.string().min(1).max(160),
+    preHeading: z.string().max(80).optional(),
+    description: z.string().max(500).optional(),
+    headerVisible: z.boolean().optional(),
+    headerContentInitialized: z.boolean().optional(),
+    hidden: z.boolean().optional(),
     visibleWhen: conditionSchema.optional(),
+    order: z.number().int().min(0),
+});
+const inputItemSchema = fieldSchema.extend({
+    kind: z.literal("input"),
+    pageId: z.string().min(1).max(80),
+    order: z.number().int().min(0),
+});
+const textBlockItemSchema = z.object({
+    id: z.string().min(1).max(80),
+    kind: z.literal("content.text"),
+    pageId: z.string().min(1).max(80),
+    order: z.number().int().min(0),
+    title: z.string().max(160).optional(),
+    body: z.string().max(5000),
+    hidden: z.boolean().optional(),
+    visibleWhen: conditionSchema.optional(),
+});
+const imageBlockItemSchema = z.object({
+    id: z.string().min(1).max(80),
+    kind: z.literal("content.image"),
+    pageId: z.string().min(1).max(80),
+    order: z.number().int().min(0),
+    imageUrl: z.string().max(500_000),
+    altText: z.string().max(300).optional(),
+    caption: z.string().max(500).optional(),
+    shape: z.enum(["square", "circle"]).optional(),
+    align: z.enum(["left", "center", "right"]).optional(),
+    size: z.enum(["small", "medium", "large", "full"]).optional(),
+    fit: z.enum(["cover", "contain"]).optional(),
+    source: z.object({
+        type: z.enum(["url", "upload", "storage"]),
+        storageItemId: z.string().min(1).optional(),
+    }).optional(),
+    hidden: z.boolean().optional(),
+    visibleWhen: conditionSchema.optional(),
+});
+const iconBlockItemSchema = z.object({
+    id: z.string().min(1).max(80),
+    kind: z.literal("content.icon"),
+    pageId: z.string().min(1).max(80),
+    order: z.number().int().min(0),
+    icon: z.string().min(1).max(120),
+    iconColor: z.string().max(40).optional(),
+    align: z.enum(["left", "center", "right"]),
+    hidden: z.boolean().optional(),
+    visibleWhen: conditionSchema.optional(),
+});
+const dividerBlockItemSchema = z.object({
+    id: z.string().min(1).max(80),
+    kind: z.literal("content.divider"),
+    pageId: z.string().min(1).max(80),
+    order: z.number().int().min(0),
+    hidden: z.boolean().optional(),
+    visibleWhen: conditionSchema.optional(),
+});
+const pageHeaderBlockItemSchema = z.object({
+    id: z.string().min(1).max(80),
+    kind: z.literal("content.page-header"),
+    pageId: z.string().min(1).max(80),
+    order: z.number().int().min(0),
+    preHeading: z.string().max(80).optional(),
+    title: z.string().min(1).max(160),
+    description: z.string().max(500).optional(),
+    hidden: z.boolean().optional(),
+    visibleWhen: conditionSchema.optional(),
+});
+const pageProgressBlockItemSchema = z.object({
+    id: z.string().min(1).max(80),
+    kind: z.literal("content.page-progress"),
+    pageId: z.string().min(1).max(80),
+    order: z.number().int().min(0),
+    hidden: z.boolean().optional(),
+    visibleWhen: conditionSchema.optional(),
+});
+const formDocumentSchema = z.object({
+    version: z.literal(1),
+    pages: z.array(documentPageSchema).min(1).max(50),
+    items: z.array(z.discriminatedUnion("kind", [
+        inputItemSchema,
+        textBlockItemSchema,
+        imageBlockItemSchema,
+        iconBlockItemSchema,
+        dividerBlockItemSchema,
+        pageHeaderBlockItemSchema,
+        pageProgressBlockItemSchema,
+    ])).max(200),
+}).superRefine((document, context) => {
+    const pageIds = new Set(document.pages.map((page) => page.id));
+    const inputCount = document.items.filter((item) => item.kind === "input").length;
+    if (inputCount > 50) {
+        context.addIssue({ code: "custom", message: "Capture forms can have at most 50 answer fields", path: ["items"] });
+    }
+    for (const [index, item] of document.items.entries()) {
+        if (!pageIds.has(item.pageId)) {
+            context.addIssue({ code: "custom", message: "Document item references an unknown page", path: ["items", index, "pageId"] });
+        }
+    }
 });
 const contactsActionConfigSchema = z.object({
     enabled: z.boolean().default(false),
@@ -62,6 +269,25 @@ const quizScoringConfigSchema = z.object({
         outcomeKey: z.string().optional(),
     })).default([]),
 });
+const captureItemViewColumnSchema = z.object({
+    fieldKey: z.string().min(1).max(80),
+    visible: z.boolean(),
+    position: z.number().int().min(0),
+});
+const captureItemViewSortSchema = z.object({
+    field: z.string().min(1).max(80),
+    direction: z.enum(["asc", "desc"]),
+});
+const captureItemViewStateSchema = z.object({
+    filters: conditionGroupSchema.optional().nullable(),
+    sorts: z.array(captureItemViewSortSchema).max(3).optional().nullable(),
+    columns: z.array(captureItemViewColumnSchema).max(24).optional().nullable(),
+});
+const captureSubmissionViewStateSchema = z.object({
+    filters: conditionGroupSchema.optional().nullable(),
+    sorts: z.array(captureItemViewSortSchema).max(3).optional().nullable(),
+    columns: z.array(captureItemViewColumnSchema).max(80).optional().nullable(),
+});
 const actionConfigSchema = z.object({
     contacts: contactsActionConfigSchema.optional(),
     email: emailActionConfigSchema.optional(),
@@ -82,6 +308,19 @@ const defaultPublicationSecurity = {
     repeatPolicy: "allow",
 };
 const answersSchema = z.record(z.string().min(1), answerValueSchema);
+function normalizeDefinitionTags(tags) {
+    const seen = new Set();
+    const normalized = [];
+    for (const tag of tags) {
+        const value = tag.trim().replace(/\s+/g, " ").slice(0, 60);
+        const key = value.toLowerCase();
+        if (!value || seen.has(key))
+            continue;
+        seen.add(key);
+        normalized.push(value);
+    }
+    return normalized;
+}
 function slugify(value) {
     const slug = value
         .toLowerCase()
@@ -98,9 +337,14 @@ function summarizeDefinition(row) {
         name: row.name,
         slug: row.slug,
         status: row.status,
+        tags: row.tags ?? [],
+        fields: row.fields,
+        actionConfig: row.actionConfig ?? {},
         fieldCount: row.fields.length,
+        submissionCount: row.submissionCount ?? 0,
         createdAt: row.createdAt,
         updatedAt: row.updatedAt,
+        publicationId: row.publicationId ?? undefined,
         publicationSlug: row.publicationSlug ?? undefined,
     };
 }
@@ -127,14 +371,20 @@ const listDefinitions = scopeAuthed.handler(async ({ context }) => {
         name: captureDefinitions.name,
         slug: captureDefinitions.slug,
         status: captureDefinitions.status,
+        tags: captureDefinitions.tags,
         fields: captureDefinitions.fields,
+        actionConfig: captureDefinitions.actionConfig,
         createdAt: captureDefinitions.createdAt,
         updatedAt: captureDefinitions.updatedAt,
+        publicationId: capturePublications.id,
         publicationSlug: capturePublications.slug,
+        submissionCount: sql `count(${captureSubmissions.id})::int`,
     })
         .from(captureDefinitions)
         .leftJoin(capturePublications, eq(capturePublications.definitionId, captureDefinitions.id))
+        .leftJoin(captureSubmissions, eq(captureSubmissions.definitionId, captureDefinitions.id))
         .where(and(eq(captureDefinitions.scope, context.scopeType), eq(captureDefinitions.scopeId, context.scopeId)))
+        .groupBy(captureDefinitions.id, captureDefinitions.scope, captureDefinitions.scopeId, captureDefinitions.surface, captureDefinitions.name, captureDefinitions.slug, captureDefinitions.status, captureDefinitions.tags, captureDefinitions.fields, captureDefinitions.actionConfig, captureDefinitions.createdAt, captureDefinitions.updatedAt, capturePublications.id, capturePublications.slug)
         .orderBy(desc(captureDefinitions.createdAt));
     return rows.map(summarizeDefinition);
 });
@@ -154,6 +404,7 @@ const createDefinition = scopeAuthed
         slug,
         status: "draft",
         fields: [],
+        document: deriveCaptureDocumentFromFields([]),
         actionConfig: {},
     })
         .returning();
@@ -162,6 +413,116 @@ const createDefinition = scopeAuthed
     }
     return row;
 });
+const resolveStorageImageUrl = scopeAuthed
+    .input(z.object({ itemId: z.string().min(1) }))
+    .handler(async ({ context, input }) => {
+    const result = await getHooks().doAction("storage:get-download-url", {
+        scope: context.scopeType,
+        scopeId: context.scopeId,
+        itemId: input.itemId,
+    });
+    if (!result?.url) {
+        throw new ORPCError("NOT_FOUND", { message: "Storage image not found" });
+    }
+    return { url: result.url };
+});
+const listItemViews = scopeAuthed.handler(async ({ context }) => {
+    const db = getDb();
+    return db
+        .select()
+        .from(captureItemViews)
+        .where(and(eq(captureItemViews.scope, context.scopeType), eq(captureItemViews.scopeId, context.scopeId)))
+        .orderBy(desc(captureItemViews.updatedAt));
+});
+const createItemView = scopeAuthed
+    .input(z.object({ name: z.string().min(1).max(80), icon: z.string().max(40).optional() }).merge(captureItemViewStateSchema))
+    .handler(async ({ context, input }) => {
+    const db = getDb();
+    const [row] = await db.insert(captureItemViews).values({
+        scope: context.scopeType,
+        scopeId: context.scopeId,
+        name: input.name,
+        icon: input.icon ?? "list",
+        filters: input.filters ?? null,
+        sorts: input.sorts ?? null,
+        columns: input.columns ?? null,
+    }).returning();
+    return row;
+});
+const updateItemView = scopeAuthed
+    .input(z.object({ id: z.string().min(1), name: z.string().min(1).max(80).optional(), icon: z.string().max(40).optional() }).merge(captureItemViewStateSchema.partial()))
+    .handler(async ({ context, input }) => {
+    const db = getDb();
+    const [row] = await db.update(captureItemViews).set({
+        ...(input.name !== undefined ? { name: input.name } : {}),
+        ...(input.icon !== undefined ? { icon: input.icon } : {}),
+        ...(input.filters !== undefined ? { filters: input.filters } : {}),
+        ...(input.sorts !== undefined ? { sorts: input.sorts } : {}),
+        ...(input.columns !== undefined ? { columns: input.columns } : {}),
+        updatedAt: new Date(),
+    }).where(and(eq(captureItemViews.id, input.id), eq(captureItemViews.scope, context.scopeType), eq(captureItemViews.scopeId, context.scopeId))).returning();
+    if (!row)
+        throw new ORPCError("NOT_FOUND", { message: "Capture item view not found" });
+    return row;
+});
+const deleteItemView = scopeAuthed
+    .input(z.object({ id: z.string().min(1) }))
+    .handler(async ({ context, input }) => {
+    const db = getDb();
+    await db.delete(captureItemViews).where(and(eq(captureItemViews.id, input.id), eq(captureItemViews.scope, context.scopeType), eq(captureItemViews.scopeId, context.scopeId)));
+    return { ok: true };
+});
+const listSubmissionViews = scopeAuthed
+    .input(z.object({ definitionId: z.string().min(1) }))
+    .handler(async ({ context, input }) => {
+    await ensureDefinitionInScope({ id: input.definitionId, scope: context.scopeType, scopeId: context.scopeId });
+    const db = getDb();
+    return db
+        .select()
+        .from(captureSubmissionViews)
+        .where(and(eq(captureSubmissionViews.scope, context.scopeType), eq(captureSubmissionViews.scopeId, context.scopeId), eq(captureSubmissionViews.definitionId, input.definitionId)))
+        .orderBy(desc(captureSubmissionViews.updatedAt));
+});
+const createSubmissionView = scopeAuthed
+    .input(z.object({ definitionId: z.string().min(1), name: z.string().min(1).max(80), icon: z.string().max(40).optional() }).merge(captureSubmissionViewStateSchema))
+    .handler(async ({ context, input }) => {
+    await ensureDefinitionInScope({ id: input.definitionId, scope: context.scopeType, scopeId: context.scopeId });
+    const db = getDb();
+    const [row] = await db.insert(captureSubmissionViews).values({
+        scope: context.scopeType,
+        scopeId: context.scopeId,
+        definitionId: input.definitionId,
+        name: input.name,
+        icon: input.icon ?? "list",
+        filters: input.filters ?? null,
+        sorts: input.sorts ?? null,
+        columns: input.columns ?? null,
+    }).returning();
+    return row;
+});
+const updateSubmissionView = scopeAuthed
+    .input(z.object({ id: z.string().min(1), name: z.string().min(1).max(80).optional(), icon: z.string().max(40).optional() }).merge(captureSubmissionViewStateSchema.partial()))
+    .handler(async ({ context, input }) => {
+    const db = getDb();
+    const [row] = await db.update(captureSubmissionViews).set({
+        ...(input.name !== undefined ? { name: input.name } : {}),
+        ...(input.icon !== undefined ? { icon: input.icon } : {}),
+        ...(input.filters !== undefined ? { filters: input.filters } : {}),
+        ...(input.sorts !== undefined ? { sorts: input.sorts } : {}),
+        ...(input.columns !== undefined ? { columns: input.columns } : {}),
+        updatedAt: new Date(),
+    }).where(and(eq(captureSubmissionViews.id, input.id), eq(captureSubmissionViews.scope, context.scopeType), eq(captureSubmissionViews.scopeId, context.scopeId))).returning();
+    if (!row)
+        throw new ORPCError("NOT_FOUND", { message: "Capture submission view not found" });
+    return row;
+});
+const deleteSubmissionView = scopeAuthed
+    .input(z.object({ id: z.string().min(1) }))
+    .handler(async ({ context, input }) => {
+    const db = getDb();
+    await db.delete(captureSubmissionViews).where(and(eq(captureSubmissionViews.id, input.id), eq(captureSubmissionViews.scope, context.scopeType), eq(captureSubmissionViews.scopeId, context.scopeId)));
+    return { ok: true };
+});
 const getDefinition = scopeAuthed
     .input(z.object({ id: z.string().min(1) }))
     .handler(async ({ context, input }) => {
@@ -176,21 +537,68 @@ const getDefinition = scopeAuthed
         .from(capturePublications)
         .where(eq(capturePublications.definitionId, definition.id))
         .limit(1);
-    return { ...definition, publicationSlug: publication?.slug ?? null };
+    const document = resolveCaptureDocument(definition.fields, definition.document);
+    return {
+        ...definition,
+        document: await resolveCaptureStorageImageUrls({
+            scope: definition.scope,
+            scopeId: definition.scopeId,
+            document,
+        }),
+        publicationId: publication?.id ?? null,
+        publicationSlug: publication?.slug ?? null,
+    };
+});
+const updateDefinitionTags = scopeAuthed
+    .input(z.object({ id: z.string().min(1), tags: z.array(z.string().min(1).max(60)).max(30) }))
+    .handler(async ({ context, input }) => {
+    await ensureDefinitionInScope({ id: input.id, scope: context.scopeType, scopeId: context.scopeId });
+    const tags = normalizeDefinitionTags(input.tags);
+    const db = getDb();
+    const [row] = await db
+        .update(captureDefinitions)
+        .set({ tags, updatedAt: new Date() })
+        .where(eq(captureDefinitions.id, input.id))
+        .returning();
+    if (!row)
+        throw new ORPCError("INTERNAL_SERVER_ERROR", { message: "Failed to update Capture item tags" });
+    return summarizeDefinition(row);
+});
+const updateDefinitionActionConfig = scopeAuthed
+    .input(z.object({ id: z.string().min(1), actionConfig: actionConfigSchema.default({}) }))
+    .handler(async ({ context, input }) => {
+    await ensureDefinitionInScope({ id: input.id, scope: context.scopeType, scopeId: context.scopeId });
+    const db = getDb();
+    const [row] = await db
+        .update(captureDefinitions)
+        .set({ actionConfig: input.actionConfig, updatedAt: new Date() })
+        .where(eq(captureDefinitions.id, input.id))
+        .returning();
+    if (!row)
+        throw new ORPCError("INTERNAL_SERVER_ERROR", { message: "Failed to update Capture item actions" });
+    return summarizeDefinition(row);
 });
 const updateDefinition = scopeAuthed
     .input(z.object({
     id: z.string().min(1),
     name: z.string().min(1).max(160),
     fields: z.array(fieldSchema).max(50),
+    document: formDocumentSchema.optional(),
     actionConfig: actionConfigSchema.default({}),
 }))
     .handler(async ({ context, input }) => {
     await ensureDefinitionInScope({ id: input.id, scope: context.scopeType, scopeId: context.scopeId });
+    const persistedDocument = normalizeCaptureDocumentForPersistence(input.fields, input.document);
     const db = getDb();
     const [row] = await db
         .update(captureDefinitions)
-        .set({ name: input.name, fields: input.fields, actionConfig: input.actionConfig, updatedAt: new Date() })
+        .set({
+        name: input.name,
+        fields: persistedDocument.fields,
+        document: persistedDocument.document,
+        actionConfig: input.actionConfig,
+        updatedAt: new Date(),
+    })
         .where(eq(captureDefinitions.id, input.id))
         .returning();
     if (!row) {
@@ -337,6 +745,41 @@ const listWorkflowDefinitions = scopeAuthed
         throw error;
     }
 });
+function parseContactCustomFieldRows(rows) {
+    if (!Array.isArray(rows))
+        return [];
+    return rows.flatMap((row) => {
+        const record = asRecord(row);
+        if (!record)
+            return [];
+        const id = typeof record.id === "string" ? record.id : null;
+        const key = typeof record.slug === "string" ? record.slug : null;
+        const label = typeof record.name === "string" ? record.name : key;
+        const type = typeof record.type === "string" ? record.type : "text";
+        if (!id || !key || !label)
+            return [];
+        return [{ id, key, label, type }];
+    });
+}
+const listContactCustomFields = scopeAuthed
+    .input(z.object({}))
+    .handler(async ({ context }) => {
+    try {
+        const rows = await getDb().execute(sql `
+        SELECT id, slug, name, type
+        FROM contact_custom_fields
+        WHERE scope = ${context.scopeType} AND "scopeId" = ${context.scopeId} AND "builtIn" = false
+        ORDER BY position ASC, name ASC
+      `);
+        return parseContactCustomFieldRows(rows);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("contact_custom_fields"))
+            return [];
+        throw error;
+    }
+});
 const listSubmissions = scopeAuthed.handler(async ({ context }) => {
     const db = getDb();
     const rows = await db
@@ -582,7 +1025,18 @@ async function loadPublicForm(input, headers) {
         throw new ORPCError("NOT_FOUND", { message: "Form not found" });
     }
     enforceOrigin(headers, row.publication.security);
-    return row;
+    const document = resolveCaptureDocument(row.definition.fields, row.definition.document);
+    return {
+        publication: row.publication,
+        definition: {
+            ...row.definition,
+            document: await resolveCaptureStorageImageUrls({
+                scope: row.definition.scope,
+                scopeId: row.definition.scopeId,
+                document,
+            }),
+        },
+    };
 }
 const getPublicForm = base
     .input(publicFormLookupSchema)
@@ -593,7 +1047,8 @@ const getPublicForm = base
         publicationId: row.publication.id,
         title: row.definition.name,
         slug: row.publication.slug,
-        fields: row.definition.fields,
+        fields: extractCaptureAnswerFields(row.definition.document),
+        document: row.definition.document,
         security: {
             minSubmitSeconds: row.publication.security.minSubmitSeconds ?? defaultPublicationSecurity.minSubmitSeconds,
             honeypotFieldName: row.publication.security.honeypotFieldName ?? defaultPublicationSecurity.honeypotFieldName,
@@ -714,12 +1169,47 @@ async function executeConfiguredActionByType(args) {
     }
     throw new Error(`Unsupported action type: ${args.actionType}`);
 }
+const CAPTURE_SUBMISSION_TRIGGER_TYPE = "capture-submission-trigger";
+async function dispatchCaptureSubmissionWorkflowTriggers(context) {
+    const input = buildWorkflowSubmissionPayload(context);
+    const result = await getHooks().tryAction("workflows:trigger.dispatch", {
+        scope: context.scope,
+        scopeId: context.scopeId,
+        triggerType: CAPTURE_SUBMISSION_TRIGGER_TYPE,
+        input,
+        match: {
+            definitionId: context.definitionId,
+            surface: context.definitionSurface,
+        },
+        idempotencyKey: `capture:${context.submissionId}:trigger:${CAPTURE_SUBMISSION_TRIGGER_TYPE}`,
+        callerId: "capture",
+        runTags: {
+            event: "capture.submission.completed",
+            captureDefinitionId: context.definitionId,
+            captureSubmissionId: context.submissionId,
+        },
+        runMetadata: {
+            captureDefinitionName: context.definitionName,
+        },
+        execute: true,
+    });
+    const started = result?.started ?? [];
+    return {
+        message: result == null
+            ? "Workflows tool is not enabled"
+            : started.length === 0
+                ? "No matching workflow trigger found"
+                : `Started ${started.length} workflow run${started.length === 1 ? "" : "s"}`,
+        workflowRuns: started,
+    };
+}
 async function runConfiguredActions(args) {
     const context = {
         scope: args.definition.scope,
         scopeId: args.definition.scopeId,
         definitionId: args.definition.id,
         definitionName: args.definition.name,
+        definitionSurface: args.definition.surface,
         submissionId: args.submissionId,
         fields: args.definition.fields,
         answers: withOutcomeAnswers(args.answers, args.outcome),
@@ -747,15 +1237,11 @@ async function runConfiguredActions(args) {
             execute: () => emailActionAdapter.execute({ config: parsedConfig, context }),
         });
     }
-    const workflowConfig = args.config.workflow;
-    if (workflowConfig && workflowActionAdapter.isEnabled(workflowConfig)) {
-        const parsedConfig = workflowActionAdapter.configSchema.parse(workflowConfig);
-        await recordActionRun({
-            context,
-            actionType: workflowActionAdapter.type,
-            execute: () => workflowActionAdapter.execute({ config: parsedConfig, context }),
-        });
-    }
+    await recordActionRun({
+        context,
+        actionType: "workflows.trigger.dispatch",
+        execute: () => dispatchCaptureSubmissionWorkflowTriggers(context),
+    });
 }
 async function enforcePublicSubmitGuards(args) {
     const security = { ...defaultPublicationSecurity, ...args.publication.security };
@@ -799,8 +1285,24 @@ const submitPublicForm = base
         honeypot: input.honeypot,
     });
     const normalizedAnswers = {};
-    const visibleFields = getVisibleCaptureFields(definition.fields, input.answers);
-    for (const field of visibleFields) {
+    const answerFields = extractCaptureAnswerFields(definition.document);
+    const visiblePageIds = new Set(definition.document.pages
+        .filter((page) => !page.hidden && evaluateCaptureCondition(page.visibleWhen, answerFields, input.answers))
+        .map((page) => page.id));
+    const itemPageById = new Map(definition.document.items.map((item) => [item.id, item.pageId]));
+    const visibleFields = getVisibleCaptureFields(answerFields, input.answers)
+        .filter((field) => !field.hidden)
+        .filter((field) => !isHiddenCaptureField(field))
+        .filter((field) => visiblePageIds.has(itemPageById.get(field.id) ?? ""));
+    const hiddenFields = answerFields.filter((field) => !field.hidden && isHiddenCaptureField(field));
+    const submittedFields = [...new Map([...visibleFields, ...hiddenFields].map((field) => [field.id, field])).values()];
+    for (const field of hiddenFields.filter(isHoneypotCaptureField)) {
+        const value = normalizeCaptureAnswer(field, input.answers[field.key], REFERENCE_CAPTURE_FIELD_TYPES);
+        if (typeof value === "string" && value.trim().length > 0) {
+            throw new ORPCError("BAD_REQUEST", { message: "Unable to submit form" });
+        }
+    }
+    for (const field of submittedFields.filter((field) => !isHoneypotCaptureField(field))) {
         const value = normalizeCaptureAnswer(field, input.answers[field.key], REFERENCE_CAPTURE_FIELD_TYPES);
         const validationError = validateCaptureAnswer(field, value, REFERENCE_CAPTURE_FIELD_TYPES);
         if (validationError) {
@@ -808,12 +1310,19 @@ const submitPublicForm = base
         }
         normalizedAnswers[field.key] = value;
     }
+    for (const field of submittedFields.filter((field) => !isHoneypotCaptureField(field))) {
+        const ruleError = validateCaptureFieldRules(field, answerFields, normalizedAnswers);
+        if (ruleError) {
+            throw new ORPCError("BAD_REQUEST", { message: ruleError });
+        }
+    }
     const outcome = input.source === "quiz" ? evaluateQuizOutcome(definition.actionConfig.quiz, normalizedAnswers) : undefined;
     const db = getDb();
     const snapshot = {
         definitionId: definition.id,
         title: definition.name,
-        fields: definition.fields,
+        fields: answerFields,
+        document: definition.document,
         answers: normalizedAnswers,
         ...(outcome ? { outcome } : {}),
     };
@@ -858,7 +1367,7 @@ const submitPublicForm = base
     if (existingSubmission && repeatPolicy === "update") {
         await db.delete(captureAnswers).where(eq(captureAnswers.submissionId, submission.id));
     }
-    const answerRows = visibleFields.map((field) => ({
+    const answerRows = submittedFields.filter((field) => !isHoneypotCaptureField(field)).map((field) => ({
         scope: definition.scope,
         scopeId: definition.scopeId,
         submissionId: submission.id,
@@ -882,15 +1391,31 @@ const submitPublicForm = base
 const captureRouter = {
     definitions: {
         list: listDefinitions,
+        views: {
+            list: listItemViews,
+            create: createItemView,
+            update: updateItemView,
+            delete: deleteItemView,
+        },
         create: createDefinition,
         get: getDefinition,
         update: updateDefinition,
+        updateTags: updateDefinitionTags,
+        updateActionConfig: updateDefinitionActionConfig,
         publish: publishDefinition,
+        resolveStorageImageUrl,
         updatePublication,
         listWorkflows: listWorkflowDefinitions,
+        listContactCustomFields,
     },
     submissions: {
         list: listSubmissions,
+        views: {
+            list: listSubmissionViews,
+            create: createSubmissionView,
+            update: updateSubmissionView,
+            delete: deleteSubmissionView,
+        },
         get: getSubmission,
         retryAction: retryActionRun,
     },