@nextlyhq/plugin-form-builder 0.0.2-alpha.60 → 0.0.2-alpha.64

package/dist/index.js

@@ -2,9 +2,11 @@ import {
   BUILT_IN_FORM_FIELD_TYPES,
   DEFAULT_FORM_SETTINGS,
   DEFAULT_NOTIFICATION_SETTINGS,
+  ENFORCED_VALIDATION_RULES,
   applyFieldDefaults,
   applyFormDefaults,
   createFormConfig,
+  documentReachability,
   downloadFile,
   evaluateConditions,
   evaluateSingleCondition,
@@ -24,13 +26,19 @@ import {
   isTextFormField,
   isValidComparisonOperator,
   normalizeFormSettings,
+  parseFieldRef,
+  parseRedirectReference,
+  pickedDocumentField,
   pluralize,
   toTitleCase
-} from "./chunk-XCICDELK.js";
+} from "./chunk-W6NLZFHH.js";
 
 // src/plugin.ts
 import { createRequire } from "module";
-import { definePlugin } from "@nextlyhq/plugin-sdk";
+import {
+  definePlugin,
+  NextlyError as NextlyError2
+} from "@nextlyhq/plugin-sdk";
 
 // src/collections/forms.ts
 import { NextlyError } from "@nextlyhq/plugin-sdk";
@@ -39,18 +47,284 @@ import {
   textarea,
   select,
   checkbox,
+  date,
   group,
   json,
   relationship
 } from "nextly";
+
+// src/utils/redirect-target.ts
+import { previewUrlFromTemplate } from "nextly/config";
+var DEFAULT_REDIRECT_PATTERN = "/{slug}";
+function normalizeRedirectRelationships(option2) {
+  if (!option2) return {};
+  const entries = Array.isArray(option2) ? option2.map((collection) => [collection, DEFAULT_REDIRECT_PATTERN]) : Object.entries(option2);
+  return Object.fromEntries(
+    entries.filter(
+      ([, pattern]) => typeof pattern !== "string" || pattern.trim()
+    )
+  );
+}
+function applyRedirectPattern(pattern, document) {
+  if (typeof pattern === "function") {
+    const produced = pattern(document);
+    return produced ? produced : void 0;
+  }
+  return previewUrlFromTemplate(pattern)(document) ?? void 0;
+}
+
+// src/collections/access-defaults.ts
+var authenticated = ({ user }) => !!user;
+var administrative = ({ roles }) => roles.includes("admin") || roles.includes("super-admin");
+function accessWithDefaults(overrides, defaults = {}) {
+  return {
+    read: overrides?.read ?? defaults.read ?? authenticated,
+    create: overrides?.create ?? defaults.create ?? authenticated,
+    update: overrides?.update ?? authenticated,
+    // Deleting is administrative in both collections; the DB permission layer
+    // remains the backstop underneath it.
+    delete: overrides?.delete ?? administrative
+  };
+}
+
+// src/collections/forms.ts
+function withHostHooks(pluginHooks, hostHooks, trailing = {}) {
+  const host = { ...hostHooks };
+  const asList = (value) => Array.isArray(value) ? value : value === void 0 ? [] : [value];
+  const merged = { ...host };
+  for (const [phase, handlers] of Object.entries(
+    pluginHooks
+  )) {
+    merged[phase] = [...asList(handlers), ...asList(host[phase])];
+  }
+  for (const [phase, handlers] of Object.entries(trailing)) {
+    merged[phase] = [...asList(merged[phase]), ...asList(handlers)];
+  }
+  return merged;
+}
+function documentRedirectSettings(settings) {
+  if (typeof settings !== "object" || settings === null) return null;
+  const record = settings;
+  const field = pickedDocumentField(record);
+  return field ? { settings: record, field } : null;
+}
+function pageRedirectSettings(data, operation) {
+  if (!data) return null;
+  if (operation !== "create" && data.settings === void 0) return null;
+  return documentRedirectSettings(data.settings);
+}
+function formAcceptsSubmissions(data, originalData) {
+  return (data?.status ?? originalData?.status) === "published";
+}
+function storedSettings(value) {
+  if (typeof value === "string") {
+    try {
+      return documentRedirectSettings(JSON.parse(value));
+    } catch {
+      return null;
+    }
+  }
+  return documentRedirectSettings(value);
+}
+function storedRedirectReference(originalData, patterns) {
+  const picked = storedSettings(originalData?.settings);
+  if (!picked) return null;
+  const collections = Object.keys(patterns);
+  const reference = parseRedirectReference(
+    picked.settings[picked.field],
+    collections
+  );
+  if (!reference) return null;
+  return {
+    reference,
+    field: picked.field,
+    configured: collections.includes(reference.collection)
+  };
+}
+function normalizeStoredReference(settings, field, reference) {
+  const stored = settings[field];
+  if (typeof stored === "string") {
+    if (stored !== reference.id) settings[field] = reference.id;
+    return;
+  }
+  if (typeof stored !== "object" || stored === null || Array.isArray(stored)) {
+    return;
+  }
+  const record = stored;
+  if (record.relationTo !== reference.collection) {
+    settings[field] = { ...record, relationTo: reference.collection };
+  }
+}
+function namedRedirectReference(data, operation, patterns) {
+  const picked = pageRedirectSettings(data, operation);
+  if (!picked) return null;
+  const { settings, field } = picked;
+  const collections = Object.keys(patterns);
+  const reference = parseRedirectReference(settings[field], collections);
+  if (reference) normalizeStoredReference(settings, field, reference);
+  return {
+    settings,
+    field,
+    reference,
+    configured: reference !== null && collections.includes(reference.collection)
+  };
+}
+function wouldStrandVisitors(data, originalData, target, targetCollectionIsLocalized) {
+  return formAcceptsSubmissions(data, originalData) && documentReachability(target, targetCollectionIsLocalized) === "unreachable";
+}
+function publishesForm(data, originalData) {
+  if (data?.status !== "published") return false;
+  return originalData?.status !== "published";
+}
+function sameTarget(named, stored) {
+  if (!named.reference || !stored) return false;
+  return stored.field === named.field && stored.reference.collection === named.reference.collection && stored.reference.id === named.reference.id;
+}
+function judgeNamedReference(named, stored) {
+  if (sameTarget(named, stored) && named.reference) {
+    return {
+      reference: named.reference,
+      field: named.field,
+      chosen: false,
+      configured: named.configured
+    };
+  }
+  if (!named.reference || !named.configured) {
+    throw redirectRefusal(
+      "Choose a page to redirect to, or pick a different confirmation.",
+      named.field
+    );
+  }
+  return {
+    reference: named.reference,
+    field: named.field,
+    chosen: true,
+    configured: true
+  };
+}
+function redirectReferenceForWrite(context, patterns) {
+  const stored = storedRedirectReference(
+    context.originalData,
+    patterns
+  );
+  const named = namedRedirectReference(
+    context.data,
+    context.operation,
+    patterns
+  );
+  if (named) return judgeNamedReference(named, stored);
+  const data = context.data;
+  if (data?.settings !== void 0) return null;
+  return stored ? { ...stored, chosen: false } : null;
+}
+function assertPatternBuildsUrl(patterns, reference, field, target) {
+  let url2;
+  try {
+    url2 = applyRedirectPattern(patterns[reference.collection], target);
+  } catch {
+    return;
+  }
+  if (url2) return;
+  throw redirectRefusal(
+    `No URL could be built for that page from the pattern configured for "${reference.collection}". Choose another page, or ask a developer to check that collection's redirect pattern.`,
+    field
+  );
+}
+async function assertRedirectTargetUsable(context, patterns, localization) {
+  const write = redirectReferenceForWrite(context, patterns);
+  if (!write) return;
+  const { reference, field, chosen, configured } = write;
+  if (!configured) {
+    if (publishesForm(
+      context.data,
+      context.originalData
+    )) {
+      throw redirectRefusal(
+        `This form redirects to "${reference.collection}", which is no longer configured as a redirect target, so it has nowhere to send anyone. Choose another page, or pick a different confirmation.`,
+        field
+      );
+    }
+    return;
+  }
+  const nextly = context.req?.nextly;
+  if (!nextly) return;
+  if (context.executor) return;
+  const found = await readRedirectTarget(nextly, reference);
+  if (found.status === "unreadable") return;
+  if (found.status === "missing") {
+    if (!chosen && !publishesForm(
+      context.data,
+      context.originalData
+    )) {
+      return;
+    }
+    throw redirectRefusal(
+      `That page no longer exists in "${reference.collection}". Pick another.`,
+      field
+    );
+  }
+  const judged = chosen || publishesForm(
+    context.data,
+    context.originalData
+  );
+  if (judged && wouldStrandVisitors(
+    context.data,
+    context.originalData,
+    found.document,
+    localization[reference.collection]
+  )) {
+    throw redirectRefusal(
+      `That page is not published yet, and this form is. A visitor sent there would reach a "page not found". Publish the page, or save this form as a draft until you do.`,
+      field
+    );
+  }
+  if (chosen)
+    assertPatternBuildsUrl(patterns, reference, field, found.document);
+}
+async function readRedirectTarget(nextly, reference) {
+  try {
+    const row = await nextly.findByID({
+      collection: reference.collection,
+      id: reference.id
+    });
+    return row ? { status: "ok", document: row } : { status: "missing" };
+  } catch (error) {
+    return isMissingTarget(error) ? { status: "missing" } : { status: "unreadable" };
+  }
+}
+function isMissingTarget(error) {
+  return typeof error === "object" && error !== null && error.code === "NOT_FOUND";
+}
+function stampFirstPublish(context) {
+  const data = context.data;
+  if (!data) return;
+  const stored = context.originalData;
+  delete data.wentLiveAt;
+  if (recordedStamp(stored) !== void 0) return;
+  if (data.status === "published" || stored?.status === "published") {
+    data.wentLiveAt = /* @__PURE__ */ new Date();
+  }
+}
+function recordedStamp(stored) {
+  const value = stored?.wentLiveAt;
+  return value === null || value === "" ? void 0 : value;
+}
+function redirectRefusal(message, field) {
+  return NextlyError.validation({
+    errors: [{ path: `settings.${field}`, code: "REQUIRED", message }]
+  });
+}
 function formsCollection(pluginConfig) {
   const {
     slug,
     labels,
     fields: additionalFields,
     access: accessOverrides,
+    hooks: hookOverrides,
+    admin: adminOverrides,
     ...overrides
   } = pluginConfig.formOverrides;
+  const redirectCollections = Object.keys(pluginConfig.redirectRelationships);
   const settingsFields = [
     text({
       name: "submitButtonText",
@@ -67,7 +341,7 @@ function formsCollection(pluginConfig) {
       options: [
         { label: "Show Message", value: "message" },
         { label: "Redirect to URL", value: "redirect" },
-        ...pluginConfig.redirectRelationships.length > 0 ? [{ label: "Redirect to Page", value: "relationship" }] : []
+        ...redirectCollections.length > 0 ? [{ label: "Redirect to Page", value: "relationship" }] : []
       ],
       admin: {
         description: "What happens after a successful form submission"
@@ -97,12 +371,12 @@ function formsCollection(pluginConfig) {
       }
     })
   ];
-  if (pluginConfig.redirectRelationships.length > 0) {
+  if (redirectCollections.length > 0) {
     settingsFields.push(
       relationship({
         name: "redirectPage",
         label: "Redirect Page",
-        relationTo: pluginConfig.redirectRelationships,
+        relationTo: redirectCollections,
         admin: {
           description: "Select a page to redirect to after submission",
           condition: {
@@ -224,6 +498,19 @@ function formsCollection(pluginConfig) {
         description: "Only published forms can receive submissions. Closed forms display a message instead."
       }
     }),
+    // NOT `firstPublishedAt`, which is the obvious name and the one to reach
+    // for next. The framework owns that name on collections it manages the
+    // publish lifecycle for, and a write naming it from a plugin collection is
+    // stripped on the way to the insert — silently, leaving the column null and
+    // every closed form reading as one that was never public.
+    date({
+      name: "wentLiveAt",
+      label: "First Published",
+      admin: {
+        readOnly: true,
+        description: "When this form first went live. Written once and never changed."
+      }
+    }),
     textarea({
       name: "closedMessage",
       label: "Closed Form Message",
@@ -265,49 +552,75 @@ function formsCollection(pluginConfig) {
           }
         }
       },
-      ...overrides.admin
+      ...adminOverrides
     },
     // Access control with sensible defaults
-    access: {
-      // Anyone can read forms (needed for frontend rendering)
-      read: accessOverrides?.read ?? true,
-      // Only authenticated users can create/update forms
-      create: accessOverrides?.create ?? (({ user }) => !!user),
-      update: accessOverrides?.update ?? (({ user }) => !!user),
-      // Only admins can delete forms (falls back to DB permissions)
-      delete: accessOverrides?.delete ?? (({ roles }) => roles.includes("admin") || roles.includes("super-admin"))
-    },
-    hooks: {
-      // Auto-generate slug from name if not provided
-      beforeValidate: [
-        (context) => {
-          const { data, operation } = context;
-          if (operation === "create" && data && !data.slug && data.name) {
-            data.slug = String(data.name).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+    // `read: true` — a form is public because a site renders it. The rest are
+    // the shared defaults.
+    access: accessWithDefaults(accessOverrides, { read: true }),
+    hooks: withHostHooks(
+      {
+        // Auto-generate slug from name if not provided
+        beforeValidate: [
+          (context) => {
+            const { data, operation } = context;
+            if (operation === "create" && data && !data.slug && data.name) {
+              data.slug = String(data.name).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+            }
+            const setsFields = operation === "create" || data?.fields !== void 0;
+            if (data && setsFields && (data.fields === void 0 || Array.isArray(data.fields) && data.fields.length === 0)) {
+              throw NextlyError.validation({
+                errors: [
+                  {
+                    path: "fields",
+                    code: "REQUIRED",
+                    message: "Form must have at least one field."
+                  }
+                ]
+              });
+            }
+            namedRedirectReference(
+              data,
+              operation,
+              pluginConfig.redirectRelationships
+            );
+            return data;
           }
-          const setsFields = operation === "create" || data?.fields !== void 0;
-          if (data && setsFields && (data.fields === void 0 || Array.isArray(data.fields) && data.fields.length === 0)) {
-            throw NextlyError.validation({
-              errors: [
-                {
-                  path: "fields",
-                  code: "REQUIRED",
-                  message: "Form must have at least one field."
-                }
-              ]
-            });
+        ]
+      },
+      hookOverrides,
+      {
+        // The last COLLECTION-level phase, after every host handler in it. A
+        // host `beforeValidate` may rewrite the payload once the earlier call
+        // has passed, so the check has to run again here.
+        //
+        // It is not the last mutating point in the write, and saying so would
+        // be false: `collection-mutation-service` runs FIELD-level
+        // `beforeChange` hooks after this one, and a host may contribute a
+        // field through `formOverrides.fields`. Nothing collection-level can
+        // sit after that — the next steps are hashing and the insert. What
+        // bounds the consequence is the submit path, which resolves an
+        // unusable target to NO redirect and logs it, never to a wrong one.
+        beforeChange: [
+          async (context) => {
+            await assertRedirectTargetUsable(
+              context,
+              pluginConfig.redirectRelationships,
+              pluginConfig.redirectTargetLocalization
+            );
+            stampFirstPublish(context);
+            return context.data;
           }
-          return data;
-        }
-      ]
-    },
+        ]
+      }
+    ),
     // Spread any additional overrides (excluding already used properties)
     ...overrides
   };
 }
 
 // src/collections/submissions.ts
-import { text as text2, textarea as textarea2, select as select2, json as json2, date, relationship as relationship2 } from "nextly";
+import { text as text2, textarea as textarea2, select as select2, json as json2, date as date2, relationship as relationship2 } from "nextly";
 function submissionsCollection(pluginConfig) {
   const {
     slug,
@@ -400,7 +713,7 @@ function submissionsCollection(pluginConfig) {
         description: "Browser/device information of the submitter"
       }
     }),
-    date({
+    date2({
       name: "submittedAt",
       label: "Submitted At",
       required: true,
@@ -411,7 +724,7 @@ function submissionsCollection(pluginConfig) {
     }),
     // Honesty stamps for admin edits of submitted data: a corrected
     // submission must never be indistinguishable from what the visitor sent.
-    date({
+    date2({
       name: "editedAt",
       label: "Edited At",
       admin: {
@@ -475,16 +788,9 @@ function submissionsCollection(pluginConfig) {
     },
     // Access control with sensible defaults
     // Public can create (submit forms), but only authenticated users can read/update/delete
-    access: {
-      // Anyone can submit forms (public access)
-      create: accessOverrides?.create ?? true,
-      // Only authenticated users can view submissions
-      read: accessOverrides?.read ?? (({ user }) => !!user),
-      // Only authenticated users can update submissions (e.g., change status, add notes)
-      update: accessOverrides?.update ?? (({ user }) => !!user),
-      // Only admins can delete submissions (falls back to DB permissions)
-      delete: accessOverrides?.delete ?? (({ roles }) => roles.includes("admin") || roles.includes("super-admin"))
-    },
+    // `create: true` — a visitor submits without an account. Reading, updating
+    // and deleting are the shared defaults.
+    access: accessWithDefaults(accessOverrides, { create: true }),
     hooks: {
       // Auto-set submittedAt timestamp on creation. (The edit stamp for
       // updates is registered in plugin.ts init — direct registry hooks are
@@ -521,140 +827,527 @@ function asFormDocument(row) {
   return row;
 }
 
-// src/plugin.ts
-var { version: PLUGIN_VERSION } = createRequire(import.meta.url)(
-  "../package.json"
-);
-function resolveConfig(options) {
-  const formOverrides = options.formOverrides || {};
-  const submissionOverrides = options.formSubmissionOverrides || {};
-  return {
-    formOverrides: {
-      ...formOverrides,
-      slug: formOverrides.slug || "forms",
-      labels: {
-        singular: formOverrides.labels?.singular || "Form",
-        plural: formOverrides.labels?.plural || "Forms"
-      }
-    },
-    formSubmissionOverrides: {
-      ...submissionOverrides,
-      slug: submissionOverrides.slug || "form-submissions",
-      labels: {
-        singular: submissionOverrides.labels?.singular || "Submission",
-        plural: submissionOverrides.labels?.plural || "Submissions"
-      }
-    },
-    fields: {
-      text: options.fields?.text ?? true,
-      email: options.fields?.email ?? true,
-      number: options.fields?.number ?? true,
-      phone: options.fields?.phone ?? true,
-      url: options.fields?.url ?? true,
-      textarea: options.fields?.textarea ?? true,
-      select: options.fields?.select ?? true,
-      checkbox: options.fields?.checkbox ?? true,
-      radio: options.fields?.radio ?? true,
-      file: options.fields?.file ?? true,
-      date: options.fields?.date ?? true,
-      time: options.fields?.time ?? true,
-      hidden: options.fields?.hidden ?? true
-    },
-    redirectRelationships: options.redirectRelationships || [],
-    beforeEmail: options.beforeEmail,
-    notifications: {
-      defaultFrom: options.notifications?.defaultFrom,
-      defaultToEmail: options.notifications?.defaultToEmail,
-      enabled: options.notifications?.enabled ?? true
-    },
-    spamProtection: {
-      honeypot: options.spamProtection?.honeypot ?? true,
-      recaptcha: options.spamProtection?.recaptcha ?? { enabled: false },
-      rateLimit: {
-        maxSubmissions: options.spamProtection?.rateLimit?.maxSubmissions ?? 10,
-        windowMs: options.spamProtection?.rateLimit?.windowMs ?? 6e4
-      }
-    },
-    uploads: {
-      maxFileSize: options.uploads?.maxFileSize ?? 10485760,
-      // 10 MB
-      allowedMimeTypes: options.uploads?.allowedMimeTypes ?? [
-        "image/*",
-        "application/pdf",
-        "text/*"
-      ],
-      uploadCollection: options.uploads?.uploadCollection ?? "media"
-    },
-    features: {
-      builder: options.features?.builder ?? true,
-      conditionalLogic: options.features?.conditionalLogic ?? true,
-      fileUploads: options.features?.fileUploads ?? true
+// src/handlers/prepare-submission.ts
+import { stripHtmlTags } from "nextly";
+
+// src/utils/generate-schema.ts
+import { z } from "zod";
+function generateZodSchema(fields) {
+  const schemaShape = {};
+  for (const field of fields) {
+    if (!isKnownFormField(field)) {
+      schemaShape[field.name] = field.required ? z.unknown().refine(
+        (value) => value !== void 0 && value !== null && value !== "",
+        { message: `${field.label || field.name} is required` }
+      ) : z.unknown();
+      continue;
     }
-  };
+    if (field.type === "hidden" && !field.required) {
+      schemaShape[field.name] = z.string().optional();
+      continue;
+    }
+    const fieldSchema = generateFieldSchema(field);
+    if (fieldSchema) {
+      schemaShape[field.name] = fieldSchema;
+    }
+  }
+  return z.object(schemaShape);
 }
-function formBuilder(options = {}) {
-  const resolvedConfig = resolveConfig(options);
-  const formsCol = formsCollection(resolvedConfig);
-  const submissionsCol = submissionsCollection(resolvedConfig);
-  const plugin = definePlugin({
-    name: "@nextlyhq/plugin-form-builder",
-    version: PLUGIN_VERSION,
-    nextly: ">=0.0.2-alpha.21",
-    // Identity metadata for the admin plugins page, mirroring package.json.
-    author: "Nextly",
-    homepage: "https://nextlyhq.com",
-    repository: "https://github.com/nextlyhq/nextly",
-    license: "MIT",
-    category: "forms",
-    tags: ["forms", "submissions", "email-notifications"],
-    // Declarative schema: the merged pipeline folds these into the
-    // app schema — no manual `setup()` append needed. Just register the plugin.
-    contributes: {
-      collections: [formsCol, submissionsCol],
-      // Custom permission — gates submission export beyond CRUD. The
-      // canonical example third-party plugin authors copy.
-      permissions: [
-        {
-          action: "export",
-          resource: "submissions",
-          label: "Export Submissions",
-          description: "Export form submissions as CSV/JSON",
-          // No `group`: the admin already files this under the plugin that
-          // declared it, so naming the plugin again would nest it inside
-          // itself. `group` is for a plugin with enough permissions to sort
-          // its own into headings, which one is not.
-          //
-          // `danger` because the point of the permission is to take
-          // submissions — names, emails, whatever a form asked for — out of
-          // the site in a file.
-          danger: true
-        }
-      ],
-      // HTTP route — exported at
-      // /api/plugins/@nextlyhq/plugin-form-builder/submissions/export. Secure by
-      // default: gated by the custom `export-submissions` permission. Reads
-      // via the secure-by-default service path as the authed user and
-      // resolves its OWN slug through `ctx.self`. The canonical
-      // contributes.routes example for third-party authors.
-      routes: [
-        {
-          method: "GET",
-          path: "/submissions/export",
-          requiredPermission: "export-submissions",
-          handler: async (req, ctx) => {
-            const declaredSlug = resolvedConfig.formSubmissionOverrides.slug;
-            const slug = ctx.self.collections[declaredSlug] ?? declaredSlug;
-            const url2 = new URL(req.url);
-            const format = url2.searchParams.get("format") ?? "json";
-            const formId = url2.searchParams.get("form");
-            const status = url2.searchParams.get("status");
-            const where = {};
-            if (formId) where.form = { equals: formId };
-            if (status) where.status = { equals: status };
-            else where.status = { not_equals: "spam" };
-            const opts = { as: "user", user: ctx.user ?? void 0 };
-            let form;
-            if (format === "csv") {
+function generateFieldSchema(field) {
+  switch (field.type) {
+    case "text":
+      return generateTextSchema(field);
+    case "email":
+      return generateEmailSchema(field);
+    case "number":
+      return generateNumberSchema(field);
+    case "phone":
+      return generatePhoneSchema(field);
+    case "url":
+      return generateUrlSchema(field);
+    case "textarea":
+      return generateTextareaSchema(field);
+    case "select":
+      return generateSelectSchema(field);
+    case "checkbox":
+      return generateCheckboxSchema(field);
+    case "radio":
+      return generateRadioSchema(field);
+    case "file":
+      return generateFileSchema(field);
+    case "date":
+      return generateDateSchema(field);
+    case "time":
+      return generateTimeSchema(field);
+    case "hidden":
+      return generateHiddenSchema(field);
+    default:
+      return z.unknown();
+  }
+}
+function customMessage(field) {
+  const enforced = ENFORCED_VALIDATION_RULES[field.type] ?? [];
+  if (!enforced.includes("message")) return void 0;
+  return field.validation?.errorMessage;
+}
+function enforcedValidation(field) {
+  const stored = field.validation ?? {};
+  return { ...stored, errorMessage: customMessage(field) };
+}
+var STRING_RULE_APPLIERS = {
+  minLength: (schema, validation) => validation.minLength === void 0 ? schema : schema.min(
+    validation.minLength,
+    validation.errorMessage || `Minimum ${validation.minLength} characters required`
+  ),
+  maxLength: (schema, validation) => validation.maxLength === void 0 ? schema : schema.max(
+    validation.maxLength,
+    validation.errorMessage || `Maximum ${validation.maxLength} characters allowed`
+  ),
+  pattern: (schema, validation, fallback) => validation.pattern ? schema.regex(
+    new RegExp(validation.pattern),
+    validation.errorMessage || fallback
+  ) : schema
+};
+var NUMBER_RULE_APPLIERS = {
+  min: (schema, validation) => validation.min === void 0 ? schema : schema.min(
+    validation.min,
+    validation.errorMessage || `Minimum value is ${validation.min}`
+  ),
+  max: (schema, validation) => validation.max === void 0 ? schema : schema.max(
+    validation.max,
+    validation.errorMessage || `Maximum value is ${validation.max}`
+  )
+};
+function overridesPattern(field) {
+  const enforced = ENFORCED_VALIDATION_RULES[field.type] ?? [];
+  if (!enforced.includes("pattern")) return false;
+  const validation = field.validation ?? {};
+  return Boolean(validation.pattern);
+}
+function applyStringRules(schema, field, patternMessage) {
+  const validation = enforcedValidation(field);
+  let constrained = schema;
+  for (const rule of ENFORCED_VALIDATION_RULES[field.type] ?? []) {
+    const apply = STRING_RULE_APPLIERS[rule];
+    if (apply) constrained = apply(constrained, validation, patternMessage);
+  }
+  return constrained;
+}
+function generateTextSchema(field) {
+  const schema = applyStringRules(z.string(), field, "Invalid format");
+  return applyRequired(schema, field.required, customMessage(field));
+}
+function generateEmailSchema(field) {
+  const schema = applyStringRules(
+    z.string().email(customMessage(field) || "Invalid email address"),
+    field,
+    "Invalid email format"
+  );
+  return applyRequired(schema, field.required, customMessage(field));
+}
+function generateNumberSchema(field) {
+  let schema = z.number({
+    error: (issue) => issue.input === void 0 ? customMessage(field) || "This field is required" : "Must be a number"
+  });
+  const validation = enforcedValidation(field);
+  for (const rule of ENFORCED_VALIDATION_RULES[field.type] ?? []) {
+    const apply = NUMBER_RULE_APPLIERS[rule];
+    if (apply) schema = apply(schema, validation);
+  }
+  if (field.required) {
+    return schema;
+  }
+  return schema.optional().nullable();
+}
+function generatePhoneSchema(field) {
+  const base = overridesPattern(field) ? z.string() : z.string().regex(
+    /^[\d\s\-+()]+$/,
+    customMessage(field) || "Invalid phone number"
+  );
+  const schema = applyStringRules(base, field, "Invalid phone number format");
+  return applyRequired(schema, field.required, customMessage(field));
+}
+function generateUrlSchema(field) {
+  const schema = applyStringRules(
+    z.string().url(customMessage(field) || "Invalid URL"),
+    field,
+    "Invalid URL format"
+  );
+  return applyRequired(schema, field.required, customMessage(field));
+}
+function generateTextareaSchema(field) {
+  const schema = applyStringRules(z.string(), field, "Invalid format");
+  return applyRequired(schema, field.required, customMessage(field));
+}
+function generateSelectSchema(field) {
+  const validValues = field.options.map((opt) => opt.value);
+  if (field.allowMultiple) {
+    const schema2 = z.array(z.enum(validValues));
+    if (field.required) {
+      return schema2.min(
+        1,
+        customMessage(field) || "Please select at least one option"
+      );
+    }
+    return schema2.optional();
+  }
+  const schema = z.enum(validValues, {
+    error: () => customMessage(field) || "Please select a valid option"
+  });
+  if (field.required) {
+    return schema;
+  }
+  return schema.optional();
+}
+function generateCheckboxSchema(field) {
+  const schema = z.boolean();
+  if (field.required) {
+    return schema.refine((val) => val === true, {
+      message: customMessage(field) || "This field is required"
+    });
+  }
+  return schema.optional();
+}
+function generateRadioSchema(field) {
+  const validValues = field.options.map((opt) => opt.value);
+  const schema = z.enum(validValues, {
+    error: () => customMessage(field) || "Please select an option"
+  });
+  if (field.required) {
+    return schema;
+  }
+  return schema.optional();
+}
+function generateFileSchema(field) {
+  if (field.multiple) {
+    const schema2 = z.array(z.string());
+    if (field.required) {
+      return schema2.min(
+        1,
+        customMessage(field) || "Please upload at least one file"
+      );
+    }
+    return schema2.optional();
+  }
+  const schema = z.string();
+  return applyRequired(schema, field.required, customMessage(field));
+}
+function generateDateSchema(field) {
+  let schema = z.string();
+  schema = schema.refine(
+    (val) => {
+      if (!val) return true;
+      const date4 = new Date(val);
+      return !isNaN(date4.getTime());
+    },
+    { message: customMessage(field) || "Invalid date" }
+  );
+  if (field.min || field.max) {
+    schema = schema.refine(
+      (val) => {
+        if (!val) return true;
+        const date4 = new Date(val);
+        if (field.min && date4 < new Date(field.min)) return false;
+        if (field.max && date4 > new Date(field.max)) return false;
+        return true;
+      },
+      {
+        message: customMessage(field) || `Date must be between ${field.min || "any"} and ${field.max || "any"}`
+      }
+    );
+  }
+  if (field.required) {
+    return schema.refine(
+      (val) => val !== void 0 && val !== null && val !== "",
+      { message: customMessage(field) || "This field is required" }
+    );
+  }
+  return schema.optional().or(z.literal(""));
+}
+function generateTimeSchema(field) {
+  const schema = z.string().regex(
+    /^([0-1]?[0-9]|2[0-3]):[0-5][0-9]$/,
+    customMessage(field) || "Invalid time format (HH:mm)"
+  );
+  return applyRequired(schema, field.required, customMessage(field));
+}
+function generateHiddenSchema(field) {
+  const schema = z.string();
+  return applyRequired(schema, field.required, customMessage(field));
+}
+function applyRequired(schema, required, errorMessage) {
+  if (required) {
+    return schema.min(1, errorMessage || "This field is required");
+  }
+  return schema.optional().or(z.literal(""));
+}
+function transformFormData(data, fields) {
+  const transformed = {};
+  for (const field of fields) {
+    const value = data[field.name];
+    if (value === void 0) {
+      continue;
+    }
+    transformed[field.name] = isKnownFormField(field) ? transformFieldValue(value, field) : value;
+  }
+  return transformed;
+}
+function transformFieldValue(value, field) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  switch (field.type) {
+    case "number":
+      if (typeof value === "string") {
+        const num = parseFloat(value);
+        return isNaN(num) ? value : num;
+      }
+      return value;
+    case "checkbox":
+      if (typeof value === "string") {
+        return value === "true" || value === "1" || value === "on";
+      }
+      return Boolean(value);
+    case "text":
+    case "email":
+    case "phone":
+    case "url":
+    case "textarea":
+    case "hidden":
+      if (typeof value === "string") {
+        return value.trim();
+      }
+      return value;
+    case "select":
+      if (field.allowMultiple) {
+        if (!Array.isArray(value)) {
+          return value ? [value] : [];
+        }
+      }
+      return value;
+    default:
+      return value;
+  }
+}
+function validateFormData(data, fields) {
+  const transformed = transformFormData(data, fields);
+  const schema = generateZodSchema(fields);
+  return schema.safeParse(transformed);
+}
+function getValidationErrors(result) {
+  if (result.success) {
+    return {};
+  }
+  const errors = {};
+  for (const error of result.error.issues) {
+    const path = error.path.join(".");
+    if (!errors[path]) {
+      errors[path] = error.message;
+    }
+  }
+  return errors;
+}
+
+// src/handlers/prepare-submission.ts
+var TEXT_FORM_FIELDS = /* @__PURE__ */ new Set([
+  "text",
+  "email",
+  "textarea",
+  "phone",
+  "url",
+  "hidden"
+]);
+function sanitizeSubmissionData(data, fields) {
+  for (const field of fields) {
+    if (!TEXT_FORM_FIELDS.has(field.type)) continue;
+    const value = data[field.name];
+    if (typeof value !== "string") continue;
+    data[field.name] = stripHtmlTags(value);
+  }
+}
+var PLUGIN_SUBMISSION = Symbol.for("nextly.plugin-form-builder.submission");
+function asPluginSubmission(row, marks) {
+  return Object.defineProperty(row, PLUGIN_SUBMISSION, {
+    value: marks,
+    enumerable: true,
+    configurable: true
+  });
+}
+function submissionMarks(row) {
+  return row[PLUGIN_SUBMISSION];
+}
+function sameValue(left, right) {
+  if (Object.is(left, right)) return true;
+  if (left instanceof Date && right instanceof Date) {
+    return left.getTime() === right.getTime();
+  }
+  if (Array.isArray(left) && Array.isArray(right)) {
+    return left.length === right.length && left.every((value, index) => sameValue(value, right[index]));
+  }
+  return false;
+}
+function sameSubmittedPayload(granted, incoming) {
+  const answers = Object.entries(granted);
+  if (answers.length !== Object.keys(incoming).length) return false;
+  return answers.every(([field, answer]) => sameValue(answer, incoming[field]));
+}
+function prepareSubmission({
+  data,
+  fields,
+  validate
+}) {
+  const transformed = transformFormData(data, fields);
+  sanitizeSubmissionData(transformed, fields);
+  if (!validate) {
+    return { data: transformed };
+  }
+  const result = generateZodSchema(fields).safeParse(transformed);
+  if (!result.success) {
+    return { data: transformed, validationErrors: getValidationErrors(result) };
+  }
+  return { data: result.data };
+}
+
+// src/plugin.ts
+var { version: PLUGIN_VERSION } = createRequire(import.meta.url)(
+  "../package.json"
+);
+function resolveConfig(options) {
+  const formOverrides = options.formOverrides || {};
+  const submissionOverrides = options.formSubmissionOverrides || {};
+  return {
+    formOverrides: {
+      ...formOverrides,
+      slug: formOverrides.slug || "forms",
+      labels: {
+        singular: formOverrides.labels?.singular || "Form",
+        plural: formOverrides.labels?.plural || "Forms"
+      }
+    },
+    formSubmissionOverrides: {
+      ...submissionOverrides,
+      slug: submissionOverrides.slug || "form-submissions",
+      labels: {
+        singular: submissionOverrides.labels?.singular || "Submission",
+        plural: submissionOverrides.labels?.plural || "Submissions"
+      }
+    },
+    fields: {
+      text: options.fields?.text ?? true,
+      email: options.fields?.email ?? true,
+      number: options.fields?.number ?? true,
+      phone: options.fields?.phone ?? true,
+      url: options.fields?.url ?? true,
+      textarea: options.fields?.textarea ?? true,
+      select: options.fields?.select ?? true,
+      checkbox: options.fields?.checkbox ?? true,
+      radio: options.fields?.radio ?? true,
+      file: options.fields?.file ?? true,
+      date: options.fields?.date ?? true,
+      time: options.fields?.time ?? true,
+      hidden: options.fields?.hidden ?? true
+    },
+    redirectRelationships: normalizeRedirectRelationships(
+      options.redirectRelationships
+    ),
+    // Filled at `init` from each collection's own metadata. Empty until then,
+    // and a slug that stays absent reads as unknown rather than as not
+    // localized — see `ResolvedFormBuilderConfig`.
+    redirectTargetLocalization: {},
+    beforeEmail: options.beforeEmail,
+    notifications: {
+      defaultFrom: options.notifications?.defaultFrom,
+      defaultToEmail: options.notifications?.defaultToEmail,
+      enabled: options.notifications?.enabled ?? true
+    },
+    spamProtection: {
+      honeypot: options.spamProtection?.honeypot ?? true,
+      recaptcha: options.spamProtection?.recaptcha ?? { enabled: false },
+      rateLimit: {
+        maxSubmissions: options.spamProtection?.rateLimit?.maxSubmissions ?? 10,
+        windowMs: options.spamProtection?.rateLimit?.windowMs ?? 6e4
+      }
+    },
+    uploads: {
+      maxFileSize: options.uploads?.maxFileSize ?? 10485760,
+      // 10 MB
+      allowedMimeTypes: options.uploads?.allowedMimeTypes ?? [
+        "image/*",
+        "application/pdf",
+        "text/*"
+      ],
+      uploadCollection: options.uploads?.uploadCollection ?? "media"
+    },
+    features: {
+      builder: options.features?.builder ?? true,
+      conditionalLogic: options.features?.conditionalLogic ?? true,
+      fileUploads: options.features?.fileUploads ?? true
+    }
+  };
+}
+function formBuilder(options = {}) {
+  const resolvedConfig = resolveConfig(options);
+  const formsCol = formsCollection(resolvedConfig);
+  const submissionsCol = submissionsCollection(resolvedConfig);
+  const plugin = definePlugin({
+    name: "@nextlyhq/plugin-form-builder",
+    version: PLUGIN_VERSION,
+    nextly: ">=0.0.2-alpha.21",
+    // Identity metadata for the admin plugins page, mirroring package.json.
+    author: "Nextly",
+    homepage: "https://nextlyhq.com",
+    repository: "https://github.com/nextlyhq/nextly",
+    license: "MIT",
+    category: "forms",
+    tags: ["forms", "submissions", "email-notifications"],
+    // Declarative schema: the merged pipeline folds these into the
+    // app schema — no manual `setup()` append needed. Just register the plugin.
+    contributes: {
+      collections: [formsCol, submissionsCol],
+      // Custom permission — gates submission export beyond CRUD. The
+      // canonical example third-party plugin authors copy.
+      permissions: [
+        {
+          action: "export",
+          resource: "submissions",
+          label: "Export Submissions",
+          description: "Export form submissions as CSV/JSON",
+          // No `group`: the admin already files this under the plugin that
+          // declared it, so naming the plugin again would nest it inside
+          // itself. `group` is for a plugin with enough permissions to sort
+          // its own into headings, which one is not.
+          //
+          // `danger` because the point of the permission is to take
+          // submissions — names, emails, whatever a form asked for — out of
+          // the site in a file.
+          danger: true
+        }
+      ],
+      // HTTP route — exported at
+      // /api/plugins/@nextlyhq/plugin-form-builder/submissions/export. Secure by
+      // default: gated by the custom `export-submissions` permission. Reads
+      // via the secure-by-default service path as the authed user and
+      // resolves its OWN slug through `ctx.self`. The canonical
+      // contributes.routes example for third-party authors.
+      routes: [
+        {
+          method: "GET",
+          path: "/submissions/export",
+          requiredPermission: "export-submissions",
+          handler: async (req, ctx) => {
+            const declaredSlug = resolvedConfig.formSubmissionOverrides.slug;
+            const slug = ctx.self.collections[declaredSlug] ?? declaredSlug;
+            const url2 = new URL(req.url);
+            const format = url2.searchParams.get("format") ?? "json";
+            const formId = url2.searchParams.get("form");
+            const status = url2.searchParams.get("status");
+            const where = {};
+            if (formId) where.form = { equals: formId };
+            if (status) where.status = { equals: status };
+            else where.status = { not_equals: "spam" };
+            const opts = { as: "user", user: ctx.user ?? void 0 };
+            let form;
+            if (format === "csv") {
               if (!formId) {
                 return Response.json(
                   {
@@ -750,6 +1443,12 @@ function formBuilder(options = {}) {
               // Runtime-resolved collection slugs (through ctx.self, so a
               // framework .rename() is honored too) — admin components
               // never hardcode "forms"/"form-submissions".
+              // Names only. A pattern may be a function, which does not
+              // survive JSON and which the browser has no use for — the
+              // admin picks a document, the server builds the URL.
+              redirectCollections: Object.keys(
+                resolvedConfig.redirectRelationships
+              ),
               slugs: {
                 forms: ctx.self.collections[resolvedConfig.formOverrides.slug] ?? resolvedConfig.formOverrides.slug,
                 submissions: ctx.self.collections[resolvedConfig.formSubmissionOverrides.slug] ?? resolvedConfig.formSubmissionOverrides.slug
@@ -776,7 +1475,7 @@ function formBuilder(options = {}) {
     },
     // -- Init ----------------------------------------------------------------
     // Registers an afterCreate hook on submissions to send email notifications.
-    init(nextly) {
+    async init(nextly) {
       const declaredSubmissionsSlug = resolvedConfig.formSubmissionOverrides.slug;
       const submissionSlug = nextly.self.collections[declaredSubmissionsSlug] ?? declaredSubmissionsSlug;
       nextly.logger.info("Form Builder plugin initialized", {
@@ -784,6 +1483,30 @@ function formBuilder(options = {}) {
         submissionsCollection: submissionSlug,
         enabledFields: Object.entries(resolvedConfig.fields).filter(([, on]) => on).map(([name]) => name)
       });
+      for (const slug of Object.keys(
+        resolvedConfig.redirectTargetLocalization
+      )) {
+        delete resolvedConfig.redirectTargetLocalization[slug];
+      }
+      await Promise.all(
+        Object.keys(resolvedConfig.redirectRelationships).map(
+          async (declared) => {
+            const slug = nextly.self.collections[declared] ?? declared;
+            try {
+              const collection = await nextly.services.collections.getCollection(slug, {});
+              const localized = collection?.localized;
+              if (typeof localized === "boolean") {
+                resolvedConfig.redirectTargetLocalization[declared] = localized;
+              }
+            } catch {
+              nextly.logger.debug?.(
+                "Redirect target localization could not be read",
+                { collection: slug }
+              );
+            }
+          }
+        )
+      );
       nextly.__formBuilderConfig = resolvedConfig;
       if (resolvedConfig.beforeEmail) {
         nextly.filters.add(
@@ -796,6 +1519,13 @@ function formBuilder(options = {}) {
           })
         );
       }
+      const declaredFormsSlug = resolvedConfig.formOverrides.slug;
+      const formsSlug = nextly.self.collections[declaredFormsSlug] ?? declaredFormsSlug;
+      nextly.hooks.on(
+        "beforeChange",
+        submissionSlug,
+        async (context) => prepareSubmissionForWrite(context, formsSlug, nextly)
+      );
       nextly.hooks.on(
         "afterCreate",
         submissionSlug,
@@ -811,8 +1541,6 @@ function formBuilder(options = {}) {
         }
         return ctx.data;
       });
-      const declaredFormsSlug = resolvedConfig.formOverrides.slug;
-      const formsSlug = nextly.self.collections[declaredFormsSlug] ?? declaredFormsSlug;
       nextly.hooks.on("afterRead", formsSlug, async (context) => {
         const data = context.data;
         const records = Array.isArray(data) ? data : data ? [data] : [];
@@ -850,9 +1578,9 @@ function getFormBuilderConfig(nextly) {
   return nextly.__formBuilderConfig;
 }
 function resolveFieldRef(ref, data) {
-  const match = ref.match(/^\{\{(\w+)\}\}$/);
-  if (!match) return ref;
-  const value = data[match[1]];
+  const name = parseFieldRef(ref);
+  if (name === null) return ref;
+  const value = data[name];
   return typeof value === "string" ? value : "";
 }
 function collectAttachmentInputs(fields, submittedData) {
@@ -923,858 +1651,644 @@ function buildNotificationEmails(input) {
     const bcc = normalizeAddressList(notification.bcc);
     const from = notification.senderEmail?.trim() || defaultFrom?.trim() || void 0;
     const replyTo = notification.replyTo ? resolveFieldRef(notification.replyTo, submittedData).trim() || void 0 : void 0;
-    emails.push({
-      to,
-      templateSlug: notification.templateSlug,
-      variables: {
-        ...submittedData,
-        formName,
-        submissionId
-      },
-      providerId: notification.providerId,
-      from,
-      replyTo,
-      cc,
-      bcc,
-      notificationId: notification.id
-    });
-  }
-  return { emails, skipped };
-}
-async function handleSubmissionCreated(context, config, nextly) {
-  if (!config.notifications.enabled) return;
-  const submission = context.data;
-  if (!submission) return;
-  if (submission.status === "spam") return;
-  const rawFormId = submission.form;
-  let formId = null;
-  if (typeof rawFormId === "string") {
-    formId = rawFormId;
-  } else if (rawFormId && typeof rawFormId === "object") {
-    const maybeId = rawFormId.id;
-    if (typeof maybeId === "string") formId = maybeId;
-  }
-  if (!formId) return;
-  const form = await fetchParentForm(config, formId, nextly);
-  if (!form) return;
-  const notifications = Array.isArray(form.notifications) ? form.notifications : [];
-  if (notifications.length === 0) return;
-  const emailService = nextly.services.email;
-  if (!emailService) return;
-  const submittedData = parseJsonColumn(submission.data);
-  const formFields = Array.isArray(form.fields) ? form.fields : [];
-  const fileAttachments = collectAttachmentInputs(formFields, submittedData);
-  const { emails, skipped } = buildNotificationEmails({
-    notifications,
-    submittedData,
-    formName: form.name,
-    submissionId: submission.id,
-    defaultFrom: config.notifications.defaultFrom
-  });
-  for (const skip of skipped) {
-    if (skip.reason === "empty-recipient") {
-      nextly.logger.warn?.(
-        "Form Builder: empty recipient, skipping notification",
-        { notificationId: skip.notificationId, formSlug: form.slug }
-      );
-    } else {
-      nextly.logger.debug?.("Form Builder: notification skipped", {
-        notificationId: skip.notificationId,
-        formSlug: form.slug,
-        reason: skip.reason
-      });
-    }
-  }
-  if (emails.length === 0) return;
-  const finalEmails = await nextly.filters.apply("form-builder.beforeEmail", emails, { form, submission });
-  for (const email2 of finalEmails) {
-    try {
-      await emailService.sendWithTemplate(
-        email2.templateSlug,
-        email2.to,
-        email2.variables,
-        {
-          providerId: email2.providerId,
-          from: email2.from,
-          replyTo: email2.replyTo,
-          cc: email2.cc,
-          bcc: email2.bcc,
-          attachments: fileAttachments.length > 0 ? fileAttachments : void 0
-        }
-      );
-      nextly.logger.info?.("Form Builder: notification sent", {
-        formSlug: form.slug,
-        to: email2.to,
-        templateSlug: email2.templateSlug,
-        notificationId: email2.notificationId,
-        attachmentCount: fileAttachments.length
-      });
-    } catch (err) {
-      nextly.logger.error?.("Form Builder: notification failed", {
-        to: email2.to,
-        templateSlug: email2.templateSlug,
-        notificationId: email2.notificationId,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-}
-async function fetchParentForm(config, formId, nextly) {
-  try {
-    const form = await nextly.services.collections.findEntryById(
-      config.formOverrides.slug,
-      formId,
-      { as: "system" }
-    );
-    return form;
-  } catch (err) {
-    nextly.logger.error?.("Form Builder: failed to fetch form", {
-      formId,
-      error: err instanceof Error ? err.message : String(err)
-    });
-    return null;
-  }
-}
-
-// src/config/validate-form.ts
-import { isPluginFieldTypeOnSurface } from "nextly";
-var RESERVED_FORM_SLUGS = [
-  // API routes
-  "api",
-  "submit",
-  "submissions",
-  "export",
-  // System slugs
-  "admin",
-  "new",
-  "create",
-  "edit",
-  "delete"
-];
-var RESERVED_SLUGS_SET = new Set(RESERVED_FORM_SLUGS);
-var SLUG_PATTERN = /^[a-z][a-z0-9_-]*$/;
-var FIELD_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_]*$/;
-var VALID_FIELD_TYPES = BUILT_IN_FORM_FIELD_TYPES;
-var VALID_FIELD_TYPES_SET = new Set(VALID_FIELD_TYPES);
-function isReservedSlug(slug) {
-  return RESERVED_SLUGS_SET.has(slug.toLowerCase());
-}
-function validateSlug(slug, errors) {
-  const path = "slug";
-  if (!slug) {
-    errors.push({
-      path,
-      message: "Form slug is required",
-      code: "SLUG_REQUIRED"
-    });
-    return;
-  }
-  if (typeof slug !== "string") {
-    errors.push({
-      path,
-      message: "Form slug must be a string",
-      code: "SLUG_INVALID_TYPE"
-    });
-    return;
-  }
-  if (slug.length < 1) {
-    errors.push({
-      path,
-      message: "Form slug must be at least 1 character",
-      code: "SLUG_TOO_SHORT"
-    });
-  }
-  if (slug.length > 50) {
-    errors.push({
-      path,
-      message: "Form slug must be at most 50 characters",
-      code: "SLUG_TOO_LONG"
-    });
-  }
-  if (!SLUG_PATTERN.test(slug)) {
-    errors.push({
-      path,
-      message: "Form slug must start with a lowercase letter and contain only lowercase letters, numbers, hyphens, and underscores",
-      code: "SLUG_INVALID_FORMAT"
-    });
-  }
-  if (isReservedSlug(slug)) {
-    errors.push({
-      path,
-      message: `Form slug '${slug}' is reserved and cannot be used`,
-      code: "SLUG_RESERVED"
-    });
-  }
-}
-function validateFieldName(name, path, errors, seenNames) {
-  if (!name) {
-    errors.push({
-      path: `${path}.name`,
-      message: "Field name is required",
-      code: "FIELD_NAME_REQUIRED"
-    });
-    return;
-  }
-  if (typeof name !== "string") {
-    errors.push({
-      path: `${path}.name`,
-      message: "Field name must be a string",
-      code: "FIELD_NAME_REQUIRED"
-    });
-    return;
-  }
-  if (!FIELD_NAME_PATTERN.test(name)) {
-    errors.push({
-      path: `${path}.name`,
-      message: `Field name '${name}' must start with a letter and contain only letters, numbers, and underscores`,
-      code: "FIELD_NAME_INVALID_FORMAT"
-    });
-  }
-  const nameLower = name.toLowerCase();
-  if (seenNames.has(nameLower)) {
-    errors.push({
-      path: `${path}.name`,
-      message: `Duplicate field name '${name}'`,
-      code: "FIELD_NAME_DUPLICATE"
+    emails.push({
+      to,
+      templateSlug: notification.templateSlug,
+      variables: {
+        ...submittedData,
+        formName,
+        submissionId
+      },
+      providerId: notification.providerId,
+      from,
+      replyTo,
+      cc,
+      bcc,
+      notificationId: notification.id
     });
-  } else {
-    seenNames.add(nameLower);
   }
+  return { emails, skipped };
 }
-function validateFieldLabel(label, path, errors) {
-  if (!label || typeof label === "string" && label.trim() === "") {
-    errors.push({
-      path: `${path}.label`,
-      message: "Field label is required",
-      code: "FIELD_LABEL_REQUIRED"
-    });
+function parentFormId(submission) {
+  const raw = submission.form;
+  if (typeof raw === "string") return raw;
+  if (raw && typeof raw === "object") {
+    const maybeId = raw.id;
+    if (typeof maybeId === "string") return maybeId;
   }
+  return null;
 }
-function validateOptions(field, path, errors) {
-  const fieldWithOptions = field;
-  const options = fieldWithOptions.options;
-  if (!options) {
-    errors.push({
-      path: `${path}.options`,
-      message: `${field.type} field must have an 'options' array`,
-      code: "OPTIONS_REQUIRED"
-    });
-    return;
+function submittedPayload(raw) {
+  if (typeof raw === "string") {
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
+  } else if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    return raw;
   }
-  if (!Array.isArray(options)) {
-    errors.push({
-      path: `${path}.options`,
-      message: `${field.type} field 'options' must be an array`,
-      code: "OPTIONS_REQUIRED"
+  throw NextlyError2.validation({
+    errors: [
+      {
+        path: "data",
+        code: "INVALID",
+        message: "Submission data must be an object."
+      }
+    ]
+  });
+}
+function updateNeedsChecking(submission, stored) {
+  if (submission.data !== void 0) return true;
+  if (stored?.data === void 0) return false;
+  if (submission.form !== void 0) return true;
+  return stored.status === "spam" && submission.status !== void 0 && submission.status !== "spam";
+}
+async function prepareSubmissionForWrite(context, formsSlug, nextly) {
+  const ctx = context;
+  const submission = ctx.data;
+  if (!submission || typeof submission !== "object") return ctx.data;
+  const stored = ctx.originalData;
+  const formId = parentFormId(submission) ?? (stored ? parentFormId(stored) : null);
+  if (!formId) return ctx.data;
+  if (ctx.operation !== "create" && !updateNeedsChecking(submission, stored)) {
+    return ctx.data;
+  }
+  const incoming = submittedPayload(
+    submission.data !== void 0 ? submission.data : stored?.data
+  );
+  const marks = submissionMarks(submission);
+  const fields = await fieldsToCheckAgainst(marks, formsSlug, formId, nextly);
+  const prepared = prepareSubmission({
+    data: incoming,
+    fields,
+    validate: marks?.keepAsEvidence !== true
+  });
+  if (prepared.validationErrors) {
+    throw NextlyError2.validation({
+      errors: Object.entries(prepared.validationErrors).map(
+        ([path, message]) => ({ path, code: "INVALID", message })
+      )
     });
-    return;
   }
-  if (options.length === 0) {
-    errors.push({
-      path: `${path}.options`,
-      message: `${field.type} field must have at least one option`,
-      code: "OPTIONS_EMPTY"
-    });
+  ctx.data = { ...submission, data: prepared.data };
+  if (ctx.operation !== "create" && submission.data === void 0) {
+    stampDerivedEdit(ctx.data, ctx.user, incoming, prepared.data);
   }
+  return ctx.data;
 }
-function validateConditionalLogic(field, path, errors) {
-  const { conditionalLogic } = field;
-  if (!conditionalLogic || !conditionalLogic.enabled) {
-    return;
-  }
-  if (!conditionalLogic.conditions || conditionalLogic.conditions.length === 0) {
-    errors.push({
-      path: `${path}.conditionalLogic.conditions`,
-      message: "Conditional logic must have at least one condition",
-      code: "CONDITIONS_REQUIRED"
+async function fieldsToCheckAgainst(marks, formsSlug, formId, nextly) {
+  const handedOver = marks?.form?.id === formId ? marks.form : null;
+  const form = handedOver ?? await fetchParentForm(formsSlug, formId, nextly);
+  if (!form || !Array.isArray(form.fields)) {
+    throw NextlyError2.validation({
+      errors: [
+        {
+          path: "form",
+          code: "INVALID",
+          message: "The form this submission belongs to could not be read, so the submission could not be checked against it."
+        }
+      ]
     });
-    return;
   }
-  conditionalLogic.conditions.forEach((condition, index) => {
-    const conditionPath = `${path}.conditionalLogic.conditions[${index}]`;
-    if (!condition.field) {
-      errors.push({
-        path: `${conditionPath}.field`,
-        message: "Condition must specify a field name",
-        code: "CONDITION_FIELD_REQUIRED"
-      });
-    }
-    if (!condition.comparison) {
-      errors.push({
-        path: `${conditionPath}.comparison`,
-        message: "Condition must specify a comparison operator",
-        code: "CONDITION_COMPARISON_REQUIRED"
-      });
-    }
-  });
+  return form.fields;
 }
-function validateFieldByType(field, path, errors) {
-  switch (field.type) {
-    case "select":
-    case "radio":
-      validateOptions(field, path, errors);
-      break;
-    case "number": {
-      const numberField = field;
-      if (numberField.validation) {
-        const { min, max } = numberField.validation;
-        if (min !== void 0 && max !== void 0 && min > max) {
-          errors.push({
-            path: `${path}.validation`,
-            message: "Min value cannot be greater than max value",
-            code: "MIN_GREATER_THAN_MAX"
-          });
-        }
-      }
-      break;
+function stampDerivedEdit(row, user, before, after) {
+  if (sameSubmittedPayload(before, after)) return;
+  row.editedAt = /* @__PURE__ */ new Date();
+  row.editedBy = user?.id ?? null;
+}
+async function handleSubmissionCreated(context, config, nextly) {
+  if (!config.notifications.enabled) return;
+  const submission = context.data;
+  if (!submission) return;
+  if (submission.status === "spam") return;
+  const formId = parentFormId(submission);
+  if (!formId) return;
+  const declaredFormsSlug = config.formOverrides.slug;
+  const form = await fetchParentForm(
+    nextly.self.collections[declaredFormsSlug] ?? declaredFormsSlug,
+    formId,
+    nextly
+  );
+  if (!form) return;
+  const notifications = Array.isArray(form.notifications) ? form.notifications : [];
+  if (notifications.length === 0) return;
+  const emailService = nextly.services.email;
+  if (!emailService) return;
+  const submittedData = parseJsonColumn(submission.data);
+  const formFields = Array.isArray(form.fields) ? form.fields : [];
+  const fileAttachments = collectAttachmentInputs(formFields, submittedData);
+  const { emails, skipped } = buildNotificationEmails({
+    notifications,
+    submittedData,
+    formName: form.name,
+    submissionId: submission.id,
+    defaultFrom: config.notifications.defaultFrom
+  });
+  for (const skip of skipped) {
+    if (skip.reason === "empty-recipient") {
+      nextly.logger.warn?.(
+        "Form Builder: empty recipient, skipping notification",
+        { notificationId: skip.notificationId, formSlug: form.slug }
+      );
+    } else {
+      nextly.logger.debug?.("Form Builder: notification skipped", {
+        notificationId: skip.notificationId,
+        formSlug: form.slug,
+        reason: skip.reason
+      });
     }
-    case "text":
-    case "textarea": {
-      const textField = field;
-      if (textField.validation) {
-        const { minLength, maxLength } = textField.validation;
-        if (minLength !== void 0 && maxLength !== void 0 && minLength > maxLength) {
-          errors.push({
-            path: `${path}.validation`,
-            message: "Min length cannot be greater than max length",
-            code: "MIN_LENGTH_GREATER_THAN_MAX"
-          });
+  }
+  if (emails.length === 0) return;
+  const finalEmails = await nextly.filters.apply("form-builder.beforeEmail", emails, { form, submission });
+  for (const email2 of finalEmails) {
+    try {
+      await emailService.sendWithTemplate(
+        email2.templateSlug,
+        email2.to,
+        email2.variables,
+        {
+          providerId: email2.providerId,
+          from: email2.from,
+          replyTo: email2.replyTo,
+          cc: email2.cc,
+          bcc: email2.bcc,
+          attachments: fileAttachments.length > 0 ? fileAttachments : void 0
         }
-      }
-      break;
-    }
-    case "file": {
-      const fileField = field;
-      if (fileField.maxFileSize !== void 0 && fileField.maxFileSize <= 0) {
-        errors.push({
-          path: `${path}.maxFileSize`,
-          message: "File maxFileSize must be a positive number",
-          code: "FILE_MAX_SIZE_INVALID"
-        });
-      }
-      break;
+      );
+      nextly.logger.info?.("Form Builder: notification sent", {
+        formSlug: form.slug,
+        to: email2.to,
+        templateSlug: email2.templateSlug,
+        notificationId: email2.notificationId,
+        attachmentCount: fileAttachments.length
+      });
+    } catch (err) {
+      nextly.logger.error?.("Form Builder: notification failed", {
+        to: email2.to,
+        templateSlug: email2.templateSlug,
+        notificationId: email2.notificationId,
+        error: err instanceof Error ? err.message : String(err)
+      });
     }
   }
 }
-function validateField(field, path, errors, seenNames) {
-  if (!field || typeof field !== "object") {
-    return;
-  }
-  const f = field;
-  const fieldType = f.type;
-  if (!fieldType) {
-    errors.push({
-      path: `${path}.type`,
-      message: "Field type is required",
-      code: "FIELD_TYPE_REQUIRED"
-    });
-    return;
-  }
-  const isValidType = typeof fieldType === "string" && (VALID_FIELD_TYPES_SET.has(fieldType) || isPluginFieldTypeOnSurface(fieldType, "forms"));
-  if (!isValidType) {
-    let fieldTypeRepr;
-    if (typeof fieldType === "object" && fieldType !== null) {
-      fieldTypeRepr = JSON.stringify(fieldType);
-    } else {
-      fieldTypeRepr = String(fieldType);
-    }
-    errors.push({
-      path: `${path}.type`,
-      message: `Invalid field type '${fieldTypeRepr}'. Valid types: ${VALID_FIELD_TYPES.join(", ")}`,
-      code: "FIELD_TYPE_INVALID"
+async function fetchParentForm(formsSlug, formId, nextly) {
+  try {
+    const form = await nextly.services.collections.findEntryById(
+      formsSlug,
+      formId,
+      { as: "system" }
+    );
+    return form;
+  } catch (err) {
+    if (!NextlyError2.isNotFound(err)) throw err;
+    nextly.logger.error?.("Form Builder: form not found", {
+      formId,
+      error: err instanceof Error ? err.message : String(err)
     });
-    return;
-  }
-  validateFieldName(f.name, path, errors, seenNames);
-  if (fieldType !== "hidden") {
-    validateFieldLabel(f.label, path, errors);
-  }
-  validateFieldByType(field, path, errors);
-  if (f.conditionalLogic) {
-    validateConditionalLogic(field, path, errors);
+    return null;
   }
 }
-function validateFieldsArray(fields, basePath, errors) {
-  const seenNames = /* @__PURE__ */ new Set();
-  fields.forEach((field, index) => {
-    const fieldPath = `${basePath}[${index}]`;
-    validateField(field, fieldPath, errors, seenNames);
-  });
+
+// src/config/validate-form.ts
+import { isPluginFieldTypeOnSurface } from "nextly";
+var RESERVED_FORM_SLUGS = [
+  // API routes
+  "api",
+  "submit",
+  "submissions",
+  "export",
+  // System slugs
+  "admin",
+  "new",
+  "create",
+  "edit",
+  "delete"
+];
+var RESERVED_SLUGS_SET = new Set(RESERVED_FORM_SLUGS);
+var SLUG_PATTERN = /^[a-z][a-z0-9_-]*$/;
+var FIELD_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+var VALID_FIELD_TYPES = BUILT_IN_FORM_FIELD_TYPES;
+var VALID_FIELD_TYPES_SET = new Set(VALID_FIELD_TYPES);
+function isReservedSlug(slug) {
+  return RESERVED_SLUGS_SET.has(slug.toLowerCase());
 }
-function validateFields(fields, errors) {
-  const path = "fields";
-  if (!fields) {
+function validateSlug(slug, errors) {
+  const path = "slug";
+  if (!slug) {
     errors.push({
       path,
-      message: "Form must have at least one field",
-      code: "FIELDS_REQUIRED"
+      message: "Form slug is required",
+      code: "SLUG_REQUIRED"
     });
     return;
   }
-  if (!Array.isArray(fields)) {
+  if (typeof slug !== "string") {
     errors.push({
       path,
-      message: "Form fields must be an array",
-      code: "FIELDS_INVALID_TYPE"
+      message: "Form slug must be a string",
+      code: "SLUG_INVALID_TYPE"
     });
     return;
   }
-  if (fields.length === 0) {
+  if (slug.length < 1) {
     errors.push({
       path,
-      message: "Form must have at least one field",
-      code: "FIELDS_EMPTY"
+      message: "Form slug must be at least 1 character",
+      code: "SLUG_TOO_SHORT"
     });
-    return;
   }
-  validateFieldsArray(fields, path, errors);
-}
-function validateSettings(settings, errors) {
-  if (!settings) {
-    return;
+  if (slug.length > 50) {
+    errors.push({
+      path,
+      message: "Form slug must be at most 50 characters",
+      code: "SLUG_TOO_LONG"
+    });
   }
-  if (typeof settings !== "object" || Array.isArray(settings)) {
+  if (!SLUG_PATTERN.test(slug)) {
     errors.push({
-      path: "settings",
-      message: "Form settings must be an object",
-      code: "SETTINGS_INVALID_TYPE"
+      path,
+      message: "Form slug must start with a lowercase letter and contain only lowercase letters, numbers, hyphens, and underscores",
+      code: "SLUG_INVALID_FORMAT"
     });
-    return;
   }
-  const s = settings;
-  if (s.confirmationType === "redirect") {
-    if (!s.redirectUrl && !s.redirectRelation) {
-      errors.push({
-        path: "settings.redirectUrl",
-        message: "Redirect URL or redirect relation is required when confirmation type is 'redirect'",
-        code: "REDIRECT_URL_REQUIRED"
-      });
-    }
+  if (isReservedSlug(slug)) {
+    errors.push({
+      path,
+      message: `Form slug '${slug}' is reserved and cannot be used`,
+      code: "SLUG_RESERVED"
+    });
   }
 }
-function validateAccess(access, errors) {
-  if (!access) {
+function validateFieldName(name, path, errors, seenNames) {
+  if (!name) {
+    errors.push({
+      path: `${path}.name`,
+      message: "Field name is required",
+      code: "FIELD_NAME_REQUIRED"
+    });
     return;
   }
-  if (typeof access !== "object" || Array.isArray(access)) {
+  if (typeof name !== "string") {
     errors.push({
-      path: "access",
-      message: "Access control must be an object",
-      code: "ACCESS_INVALID_TYPE"
+      path: `${path}.name`,
+      message: "Field name must be a string",
+      code: "FIELD_NAME_REQUIRED"
     });
     return;
   }
-  const accessObj = access;
-  const validAccessKeys = ["submit", "read"];
-  for (const key of validAccessKeys) {
-    const fn = accessObj[key];
-    if (fn !== void 0 && typeof fn !== "function") {
-      errors.push({
-        path: `access.${key}`,
-        message: `Access control '${key}' must be a function`,
-        code: "ACCESS_FUNCTION_INVALID"
-      });
-    }
-  }
-}
-function validateFormConfig(config) {
-  const errors = [];
-  validateSlug(config.slug, errors);
-  validateFields(config.fields, errors);
-  validateSettings(config.settings, errors);
-  validateAccess(config.access, errors);
-  return {
-    valid: errors.length === 0,
-    errors
-  };
-}
-function assertValidFormConfig(config) {
-  const result = validateFormConfig(config);
-  if (!result.valid) {
-    const errorMessages = result.errors.map((err) => `  - [${err.code}] ${err.path}: ${err.message}`).join("\n");
-    throw new Error(
-      `Invalid form config for '${config.slug || "unknown"}':
-${errorMessages}`
-    );
-  }
-}
-
-// src/config/field-helpers.ts
-var option = (label, value) => ({
-  label,
-  value: value ?? label.toLowerCase().replace(/\s+/g, "_")
-});
-var text3 = (config) => ({
-  ...config,
-  type: "text"
-});
-var email = (config) => ({
-  ...config,
-  type: "email"
-});
-var phone = (config) => ({
-  ...config,
-  type: "phone"
-});
-var url = (config) => ({
-  ...config,
-  type: "url"
-});
-var textarea3 = (config) => ({
-  ...config,
-  type: "textarea"
-});
-var number = (config) => ({
-  ...config,
-  type: "number"
-});
-var select3 = (config) => ({
-  ...config,
-  type: "select"
-});
-var checkbox2 = (config) => ({
-  ...config,
-  type: "checkbox"
-});
-var radio = (config) => ({
-  ...config,
-  type: "radio"
-});
-var file = (config) => ({
-  ...config,
-  type: "file"
-});
-var date2 = (config) => ({
-  ...config,
-  type: "date"
-});
-var time = (config) => ({
-  ...config,
-  type: "time"
-});
-var hidden = (config) => ({
-  ...config,
-  type: "hidden"
-});
-
-// src/utils/generate-schema.ts
-import { z } from "zod";
-function generateZodSchema(fields) {
-  const schemaShape = {};
-  for (const field of fields) {
-    if (!isKnownFormField(field)) {
-      schemaShape[field.name] = field.required ? z.unknown().refine(
-        (value) => value !== void 0 && value !== null && value !== "",
-        { message: `${field.label || field.name} is required` }
-      ) : z.unknown();
-      continue;
-    }
-    if (field.type === "hidden" && !field.required) {
-      schemaShape[field.name] = z.string().optional();
-      continue;
-    }
-    const fieldSchema = generateFieldSchema(field);
-    if (fieldSchema) {
-      schemaShape[field.name] = fieldSchema;
-    }
-  }
-  return z.object(schemaShape);
-}
-function generateFieldSchema(field) {
-  switch (field.type) {
-    case "text":
-      return generateTextSchema(field);
-    case "email":
-      return generateEmailSchema(field);
-    case "number":
-      return generateNumberSchema(field);
-    case "phone":
-      return generatePhoneSchema(field);
-    case "url":
-      return generateUrlSchema(field);
-    case "textarea":
-      return generateTextareaSchema(field);
-    case "select":
-      return generateSelectSchema(field);
-    case "checkbox":
-      return generateCheckboxSchema(field);
-    case "radio":
-      return generateRadioSchema(field);
-    case "file":
-      return generateFileSchema(field);
-    case "date":
-      return generateDateSchema(field);
-    case "time":
-      return generateTimeSchema(field);
-    case "hidden":
-      return generateHiddenSchema(field);
-    default:
-      return z.unknown();
-  }
-}
-function generateTextSchema(field) {
-  let schema = z.string();
-  if (field.validation?.minLength !== void 0) {
-    schema = schema.min(
-      field.validation.minLength,
-      field.validation.errorMessage || `Minimum ${field.validation.minLength} characters required`
-    );
-  }
-  if (field.validation?.maxLength !== void 0) {
-    schema = schema.max(
-      field.validation.maxLength,
-      field.validation.errorMessage || `Maximum ${field.validation.maxLength} characters allowed`
-    );
+  if (!FIELD_NAME_PATTERN.test(name)) {
+    errors.push({
+      path: `${path}.name`,
+      message: `Field name '${name}' must start with a letter and contain only letters, numbers, and underscores`,
+      code: "FIELD_NAME_INVALID_FORMAT"
+    });
   }
-  if (field.validation?.pattern) {
-    schema = schema.regex(
-      new RegExp(field.validation.pattern),
-      field.validation.errorMessage || "Invalid format"
-    );
+  const nameLower = name.toLowerCase();
+  if (seenNames.has(nameLower)) {
+    errors.push({
+      path: `${path}.name`,
+      message: `Duplicate field name '${name}'`,
+      code: "FIELD_NAME_DUPLICATE"
+    });
+  } else {
+    seenNames.add(nameLower);
   }
-  return applyRequired(schema, field.required, field.validation?.errorMessage);
 }
-function generateEmailSchema(field) {
-  let schema = z.string().email(field.validation?.errorMessage || "Invalid email address");
-  if (field.validation?.pattern) {
-    schema = schema.regex(
-      new RegExp(field.validation.pattern),
-      field.validation.errorMessage || "Invalid email format"
-    );
+function validateFieldLabel(label, path, errors) {
+  if (!label || typeof label === "string" && label.trim() === "") {
+    errors.push({
+      path: `${path}.label`,
+      message: "Field label is required",
+      code: "FIELD_LABEL_REQUIRED"
+    });
   }
-  return applyRequired(schema, field.required, field.validation?.errorMessage);
 }
-function generateNumberSchema(field) {
-  let schema = z.number({
-    error: (issue) => issue.input === void 0 ? field.validation?.errorMessage || "This field is required" : "Must be a number"
-  });
-  if (field.validation?.min !== void 0) {
-    schema = schema.min(
-      field.validation.min,
-      field.validation.errorMessage || `Minimum value is ${field.validation.min}`
-    );
+function validateOptions(field, path, errors) {
+  const fieldWithOptions = field;
+  const options = fieldWithOptions.options;
+  if (!options) {
+    errors.push({
+      path: `${path}.options`,
+      message: `${field.type} field must have an 'options' array`,
+      code: "OPTIONS_REQUIRED"
+    });
+    return;
   }
-  if (field.validation?.max !== void 0) {
-    schema = schema.max(
-      field.validation.max,
-      field.validation.errorMessage || `Maximum value is ${field.validation.max}`
-    );
+  if (!Array.isArray(options)) {
+    errors.push({
+      path: `${path}.options`,
+      message: `${field.type} field 'options' must be an array`,
+      code: "OPTIONS_REQUIRED"
+    });
+    return;
   }
-  if (field.required) {
-    return schema;
+  if (options.length === 0) {
+    errors.push({
+      path: `${path}.options`,
+      message: `${field.type} field must have at least one option`,
+      code: "OPTIONS_EMPTY"
+    });
   }
-  return schema.optional().nullable();
 }
-function generatePhoneSchema(field) {
-  let schema = z.string();
-  if (field.validation?.pattern) {
-    schema = schema.regex(
-      new RegExp(field.validation.pattern),
-      field.validation.errorMessage || "Invalid phone number format"
-    );
-  } else {
-    schema = schema.regex(
-      /^[\d\s\-+()]+$/,
-      field.validation?.errorMessage || "Invalid phone number"
-    );
+function validateConditionalLogic(field, path, errors) {
+  const { conditionalLogic } = field;
+  if (!conditionalLogic || !conditionalLogic.enabled) {
+    return;
+  }
+  if (!conditionalLogic.conditions || conditionalLogic.conditions.length === 0) {
+    errors.push({
+      path: `${path}.conditionalLogic.conditions`,
+      message: "Conditional logic must have at least one condition",
+      code: "CONDITIONS_REQUIRED"
+    });
+    return;
   }
-  return applyRequired(schema, field.required, field.validation?.errorMessage);
+  conditionalLogic.conditions.forEach((condition, index) => {
+    const conditionPath = `${path}.conditionalLogic.conditions[${index}]`;
+    if (!condition.field) {
+      errors.push({
+        path: `${conditionPath}.field`,
+        message: "Condition must specify a field name",
+        code: "CONDITION_FIELD_REQUIRED"
+      });
+    }
+    if (!condition.comparison) {
+      errors.push({
+        path: `${conditionPath}.comparison`,
+        message: "Condition must specify a comparison operator",
+        code: "CONDITION_COMPARISON_REQUIRED"
+      });
+    }
+  });
 }
-function generateUrlSchema(field) {
-  let schema = z.string().url(field.validation?.errorMessage || "Invalid URL");
-  if (field.validation?.pattern) {
-    schema = schema.regex(
-      new RegExp(field.validation.pattern),
-      field.validation.errorMessage || "Invalid URL format"
-    );
+function validateFieldByType(field, path, errors) {
+  switch (field.type) {
+    case "select":
+    case "radio":
+      validateOptions(field, path, errors);
+      break;
+    case "number": {
+      const numberField = field;
+      if (numberField.validation) {
+        const { min, max } = numberField.validation;
+        if (min !== void 0 && max !== void 0 && min > max) {
+          errors.push({
+            path: `${path}.validation`,
+            message: "Min value cannot be greater than max value",
+            code: "MIN_GREATER_THAN_MAX"
+          });
+        }
+      }
+      break;
+    }
+    case "text":
+    case "textarea": {
+      const textField = field;
+      if (textField.validation) {
+        const { minLength, maxLength } = textField.validation;
+        if (minLength !== void 0 && maxLength !== void 0 && minLength > maxLength) {
+          errors.push({
+            path: `${path}.validation`,
+            message: "Min length cannot be greater than max length",
+            code: "MIN_LENGTH_GREATER_THAN_MAX"
+          });
+        }
+      }
+      break;
+    }
+    case "file": {
+      const fileField = field;
+      if (fileField.maxFileSize !== void 0 && fileField.maxFileSize <= 0) {
+        errors.push({
+          path: `${path}.maxFileSize`,
+          message: "File maxFileSize must be a positive number",
+          code: "FILE_MAX_SIZE_INVALID"
+        });
+      }
+      break;
+    }
   }
-  return applyRequired(schema, field.required, field.validation?.errorMessage);
 }
-function generateTextareaSchema(field) {
-  let schema = z.string();
-  if (field.validation?.minLength !== void 0) {
-    schema = schema.min(
-      field.validation.minLength,
-      field.validation.errorMessage || `Minimum ${field.validation.minLength} characters required`
-    );
+function validateField(field, path, errors, seenNames) {
+  if (!field || typeof field !== "object") {
+    return;
   }
-  if (field.validation?.maxLength !== void 0) {
-    schema = schema.max(
-      field.validation.maxLength,
-      field.validation.errorMessage || `Maximum ${field.validation.maxLength} characters allowed`
-    );
+  const f = field;
+  const fieldType = f.type;
+  if (!fieldType) {
+    errors.push({
+      path: `${path}.type`,
+      message: "Field type is required",
+      code: "FIELD_TYPE_REQUIRED"
+    });
+    return;
   }
-  return applyRequired(schema, field.required, field.validation?.errorMessage);
-}
-function generateSelectSchema(field) {
-  const validValues = field.options.map((opt) => opt.value);
-  if (field.allowMultiple) {
-    const schema2 = z.array(z.enum(validValues));
-    if (field.required) {
-      return schema2.min(
-        1,
-        field.validation?.errorMessage || "Please select at least one option"
-      );
+  const isValidType = typeof fieldType === "string" && (VALID_FIELD_TYPES_SET.has(fieldType) || isPluginFieldTypeOnSurface(fieldType, "forms"));
+  if (!isValidType) {
+    let fieldTypeRepr;
+    if (typeof fieldType === "object" && fieldType !== null) {
+      fieldTypeRepr = JSON.stringify(fieldType);
+    } else {
+      fieldTypeRepr = String(fieldType);
     }
-    return schema2.optional();
+    errors.push({
+      path: `${path}.type`,
+      message: `Invalid field type '${fieldTypeRepr}'. Valid types: ${VALID_FIELD_TYPES.join(", ")}`,
+      code: "FIELD_TYPE_INVALID"
+    });
+    return;
   }
-  const schema = z.enum(validValues, {
-    error: () => field.validation?.errorMessage || "Please select a valid option"
-  });
-  if (field.required) {
-    return schema;
+  validateFieldName(f.name, path, errors, seenNames);
+  if (fieldType !== "hidden") {
+    validateFieldLabel(f.label, path, errors);
   }
-  return schema.optional();
-}
-function generateCheckboxSchema(field) {
-  const schema = z.boolean();
-  if (field.required) {
-    return schema.refine((val) => val === true, {
-      message: field.validation?.errorMessage || "This field is required"
-    });
+  validateFieldByType(field, path, errors);
+  if (f.conditionalLogic) {
+    validateConditionalLogic(field, path, errors);
   }
-  return schema.optional();
 }
-function generateRadioSchema(field) {
-  const validValues = field.options.map((opt) => opt.value);
-  const schema = z.enum(validValues, {
-    error: () => field.validation?.errorMessage || "Please select an option"
+function validateFieldsArray(fields, basePath, errors) {
+  const seenNames = /* @__PURE__ */ new Set();
+  fields.forEach((field, index) => {
+    const fieldPath = `${basePath}[${index}]`;
+    validateField(field, fieldPath, errors, seenNames);
   });
-  if (field.required) {
-    return schema;
-  }
-  return schema.optional();
-}
-function generateFileSchema(field) {
-  if (field.multiple) {
-    const schema2 = z.array(z.string());
-    if (field.required) {
-      return schema2.min(
-        1,
-        field.validation?.errorMessage || "Please upload at least one file"
-      );
-    }
-    return schema2.optional();
-  }
-  const schema = z.string();
-  return applyRequired(schema, field.required, field.validation?.errorMessage);
 }
-function generateDateSchema(field) {
-  let schema = z.string();
-  schema = schema.refine(
-    (val) => {
-      if (!val) return true;
-      const date3 = new Date(val);
-      return !isNaN(date3.getTime());
-    },
-    { message: field.validation?.errorMessage || "Invalid date" }
-  );
-  if (field.min || field.max) {
-    schema = schema.refine(
-      (val) => {
-        if (!val) return true;
-        const date3 = new Date(val);
-        if (field.min && date3 < new Date(field.min)) return false;
-        if (field.max && date3 > new Date(field.max)) return false;
-        return true;
-      },
-      {
-        message: field.validation?.errorMessage || `Date must be between ${field.min || "any"} and ${field.max || "any"}`
-      }
-    );
+function validateFields(fields, errors) {
+  const path = "fields";
+  if (!fields) {
+    errors.push({
+      path,
+      message: "Form must have at least one field",
+      code: "FIELDS_REQUIRED"
+    });
+    return;
   }
-  if (field.required) {
-    return schema.refine(
-      (val) => val !== void 0 && val !== null && val !== "",
-      { message: field.validation?.errorMessage || "This field is required" }
-    );
+  if (!Array.isArray(fields)) {
+    errors.push({
+      path,
+      message: "Form fields must be an array",
+      code: "FIELDS_INVALID_TYPE"
+    });
+    return;
   }
-  return schema.optional().or(z.literal(""));
-}
-function generateTimeSchema(field) {
-  const schema = z.string().regex(
-    /^([0-1]?[0-9]|2[0-3]):[0-5][0-9]$/,
-    field.validation?.errorMessage || "Invalid time format (HH:mm)"
-  );
-  return applyRequired(schema, field.required, field.validation?.errorMessage);
-}
-function generateHiddenSchema(field) {
-  const schema = z.string();
-  return applyRequired(schema, field.required, field.validation?.errorMessage);
-}
-function applyRequired(schema, required, errorMessage) {
-  if (required) {
-    return schema.min(1, errorMessage || "This field is required");
+  if (fields.length === 0) {
+    errors.push({
+      path,
+      message: "Form must have at least one field",
+      code: "FIELDS_EMPTY"
+    });
+    return;
   }
-  return schema.optional().or(z.literal(""));
+  validateFieldsArray(fields, path, errors);
 }
-function transformFormData(data, fields) {
-  const transformed = {};
-  for (const field of fields) {
-    const value = data[field.name];
-    if (value === void 0) {
-      continue;
-    }
-    transformed[field.name] = isKnownFormField(field) ? transformFieldValue(value, field) : value;
+function validateSettings(settings, errors) {
+  if (!settings) {
+    return;
   }
-  return transformed;
-}
-function transformFieldValue(value, field) {
-  if (value === null || value === void 0) {
-    return value;
+  if (typeof settings !== "object" || Array.isArray(settings)) {
+    errors.push({
+      path: "settings",
+      message: "Form settings must be an object",
+      code: "SETTINGS_INVALID_TYPE"
+    });
+    return;
   }
-  switch (field.type) {
-    case "number":
-      if (typeof value === "string") {
-        const num = parseFloat(value);
-        return isNaN(num) ? value : num;
-      }
-      return value;
-    case "checkbox":
-      if (typeof value === "string") {
-        return value === "true" || value === "1" || value === "on";
-      }
-      return Boolean(value);
-    case "text":
-    case "email":
-    case "phone":
-    case "url":
-    case "textarea":
-    case "hidden":
-      if (typeof value === "string") {
-        return value.trim();
-      }
-      return value;
-    case "select":
-      if (field.allowMultiple) {
-        if (!Array.isArray(value)) {
-          return value ? [value] : [];
-        }
-      }
-      return value;
-    default:
-      return value;
+  const s = settings;
+  if (s.confirmationType === "redirect") {
+    if (!s.redirectUrl && !s.redirectRelation) {
+      errors.push({
+        path: "settings.redirectUrl",
+        message: "Redirect URL or redirect relation is required when confirmation type is 'redirect'",
+        code: "REDIRECT_URL_REQUIRED"
+      });
+    }
+  }
+  if (s.confirmationType === "relationship" && !namesADocument(s.redirectPage)) {
+    errors.push({
+      path: "settings.redirectPage",
+      message: "A page is required when confirmation type is 'relationship'",
+      code: "REDIRECT_PAGE_REQUIRED"
+    });
   }
 }
-function validateFormData(data, fields) {
-  const transformed = transformFormData(data, fields);
-  const schema = generateZodSchema(fields);
-  return schema.safeParse(transformed);
+function namesADocument(value) {
+  if (typeof value === "string") return value.length > 0;
+  return parseRedirectReference(value, []) !== null;
 }
-function getValidationErrors(result) {
-  if (result.success) {
-    return {};
+function validateAccess(access, errors) {
+  if (!access) {
+    return;
   }
-  const errors = {};
-  for (const error of result.error.issues) {
-    const path = error.path.join(".");
-    if (!errors[path]) {
-      errors[path] = error.message;
+  if (typeof access !== "object" || Array.isArray(access)) {
+    errors.push({
+      path: "access",
+      message: "Access control must be an object",
+      code: "ACCESS_INVALID_TYPE"
+    });
+    return;
+  }
+  const accessObj = access;
+  const validAccessKeys = ["submit", "read"];
+  for (const key of validAccessKeys) {
+    const fn = accessObj[key];
+    if (fn !== void 0 && typeof fn !== "function") {
+      errors.push({
+        path: `access.${key}`,
+        message: `Access control '${key}' must be a function`,
+        code: "ACCESS_FUNCTION_INVALID"
+      });
     }
   }
-  return errors;
+}
+function validateFormConfig(config) {
+  const errors = [];
+  validateSlug(config.slug, errors);
+  validateFields(config.fields, errors);
+  validateSettings(config.settings, errors);
+  validateAccess(config.access, errors);
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function assertValidFormConfig(config) {
+  const result = validateFormConfig(config);
+  if (!result.valid) {
+    const errorMessages = result.errors.map((err) => `  - [${err.code}] ${err.path}: ${err.message}`).join("\n");
+    throw new Error(
+      `Invalid form config for '${config.slug || "unknown"}':
+${errorMessages}`
+    );
+  }
 }
 
+// src/config/field-helpers.ts
+var option = (label, value) => ({
+  label,
+  value: value ?? label.toLowerCase().replace(/\s+/g, "_")
+});
+var text3 = (config) => ({
+  ...config,
+  type: "text"
+});
+var email = (config) => ({
+  ...config,
+  type: "email"
+});
+var phone = (config) => ({
+  ...config,
+  type: "phone"
+});
+var url = (config) => ({
+  ...config,
+  type: "url"
+});
+var textarea3 = (config) => ({
+  ...config,
+  type: "textarea"
+});
+var number = (config) => ({
+  ...config,
+  type: "number"
+});
+var select3 = (config) => ({
+  ...config,
+  type: "select"
+});
+var checkbox2 = (config) => ({
+  ...config,
+  type: "checkbox"
+});
+var radio = (config) => ({
+  ...config,
+  type: "radio"
+});
+var file = (config) => ({
+  ...config,
+  type: "file"
+});
+var date3 = (config) => ({
+  ...config,
+  type: "date"
+});
+var time = (config) => ({
+  ...config,
+  type: "time"
+});
+var hidden = (config) => ({
+  ...config,
+  type: "hidden"
+});
+
+// src/handlers/submit-form.ts
+import { formAvailability, NO_SUCH_FORM } from "nextly";
+
 // src/handlers/spam-detection.ts
 var rateLimitStore = /* @__PURE__ */ new Map();
 async function checkSpam(options) {
@@ -1899,19 +2413,18 @@ async function submitForm(options, context) {
       logger.warn?.("Form submission attempted for non-existent form", {
         formSlug
       });
-      return {
-        success: false,
-        error: "Form not found"
-      };
+      return { success: false, error: NO_SUCH_FORM };
     }
-    if (form.status !== "published") {
-      logger.info?.("Form submission rejected - form not published", {
+    const availability = formAvailability(form);
+    if (availability.kind !== "open") {
+      logger.info?.("Form submission rejected - form not accepting", {
         formSlug,
-        status: form.status
+        status: form.status,
+        availability: availability.kind
       });
       return {
         success: false,
-        error: "This form is not currently accepting submissions"
+        error: availability.kind === "closed" ? availability.message : NO_SUCH_FORM
       };
     }
     const settings = normalizeFormSettings(form.settings);
@@ -1970,34 +2483,30 @@ async function submitForm(options, context) {
       return { success: true };
     }
     const isContentSpam = spamResult.isSpam;
-    const transformedData = transformFormData(data, form.fields);
-    let storedData;
     if (isContentSpam) {
       logger.info?.("Spam submission detected \u2014 storing flagged", {
         formSlug,
         reason: spamResult.reason,
         ipAddress: metadata?.ipAddress
       });
-      sanitizeSubmissionData(transformedData, form.fields);
-      storedData = transformedData;
-    } else {
-      const schema = generateZodSchema(form.fields);
-      const validationResult = schema.safeParse(transformedData);
-      if (!validationResult.success) {
-        const validationErrors = getValidationErrors(validationResult);
-        logger.debug?.("Form validation failed", {
-          formSlug,
-          errors: validationErrors
-        });
-        return {
-          success: false,
-          error: "Validation failed",
-          validationErrors
-        };
-      }
-      sanitizeSubmissionData(validationResult.data, form.fields);
-      storedData = validationResult.data;
     }
+    const prepared = prepareSubmission({
+      data,
+      fields: form.fields,
+      validate: !isContentSpam
+    });
+    if (prepared.validationErrors) {
+      logger.debug?.("Form validation failed", {
+        formSlug,
+        errors: prepared.validationErrors
+      });
+      return {
+        success: false,
+        error: "Validation failed",
+        validationErrors: prepared.validationErrors
+      };
+    }
+    const storedData = prepared.data;
     const submissionData = {
       form: form.id,
       data: storedData,
@@ -2009,7 +2518,10 @@ async function submitForm(options, context) {
     };
     const submission = await collections.createEntry(
       pluginConfig.formSubmissionOverrides.slug,
-      submissionData,
+      asPluginSubmission(submissionData, {
+        keepAsEvidence: isContentSpam,
+        form: { id: form.id, fields: form.fields }
+      }),
       // Public form submission — create as system. No ambient user; an
       // empty context already resolves to system, but be explicit.
       { as: "system" }
@@ -2026,7 +2538,11 @@ async function submitForm(options, context) {
         warnings: submission.warnings
       });
     }
-    const redirect = determineRedirectUrl(form);
+    const redirect = await resolveRedirectUrl(
+      form,
+      pluginConfig,
+      pluginContext
+    );
     if (isContentSpam) {
       return { success: true, redirect };
     }
@@ -2064,21 +2580,100 @@ async function fetchFormBySlug(slug, pluginConfig, pluginContext) {
     return null;
   }
 }
-function determineRedirectUrl(form) {
-  if (!form.settings) {
+async function resolveRedirectUrl(form, pluginConfig, pluginContext) {
+  const settings = form.settings;
+  if (!settings) return void 0;
+  if (settings.confirmationType === "redirect" && settings.redirectUrl) {
+    return settings.redirectUrl;
+  }
+  const field = pickedDocumentField(settings);
+  if (!field) return void 0;
+  return urlForPickedDocument(
+    settings[field],
+    form,
+    pluginConfig,
+    pluginContext
+  );
+}
+async function urlForPickedDocument(stored, form, pluginConfig, pluginContext) {
+  const { logger } = pluginContext;
+  const patterns = pluginConfig.redirectRelationships;
+  const reference = parseRedirectReference(stored, Object.keys(patterns));
+  if (!reference) {
+    logger.warn?.("Form redirects to a page, but names no readable document", {
+      form: form.slug
+    });
+    return void 0;
+  }
+  const pattern = patterns[reference.collection];
+  if (!pattern) {
+    logger.warn?.(
+      "Form redirects to a collection that is not in redirectRelationships",
+      { form: form.slug, collection: reference.collection }
+    );
+    return void 0;
+  }
+  const target = await readTarget(reference, form, pluginContext);
+  if (!target) return void 0;
+  if (documentReachability(
+    target,
+    pluginConfig.redirectTargetLocalization[reference.collection]
+  ) === "unreachable") {
+    logger.warn?.("Form redirects to a page that has never been published", {
+      form: form.slug,
+      collection: reference.collection,
+      target: reference.id
+    });
     return void 0;
   }
-  if (form.settings.confirmationType !== "redirect") {
+  return buildUrl(pattern, target, reference.collection, form, pluginContext);
+}
+function buildUrl(pattern, target, collection, form, pluginContext) {
+  const { logger } = pluginContext;
+  try {
+    const url2 = applyRedirectPattern(pattern, target);
+    if (!url2) {
+      logger.warn?.(
+        "Form redirect pattern could not be filled from the target document",
+        { form: form.slug, collection }
+      );
+    }
+    return url2;
+  } catch (error) {
+    logger.warn?.("Form redirect pattern threw while building a URL", {
+      form: form.slug,
+      collection,
+      error: error instanceof Error ? error.message : String(error)
+    });
     return void 0;
   }
-  if (form.settings.redirectUrl) {
-    return form.settings.redirectUrl;
+}
+async function readTarget(reference, form, pluginContext) {
+  const { logger } = pluginContext;
+  const context = {
+    form: form.slug,
+    collection: reference.collection,
+    id: reference.id
+  };
+  let row;
+  try {
+    row = await pluginContext.services.collections.findEntryById(
+      reference.collection,
+      reference.id,
+      { as: "system" }
+    );
+  } catch (error) {
+    logger.warn?.("Form redirect target could not be read", {
+      ...context,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return void 0;
   }
-  if (form.settings.redirectRelation) {
-    const { relationTo, value } = form.settings.redirectRelation;
-    return `relationship://${relationTo}/${value}`;
+  if (!row || typeof row !== "object") {
+    logger.warn?.("Form redirect target no longer exists", context);
+    return void 0;
   }
-  return void 0;
+  return row;
 }
 async function validateSubmission(formSlug, data, context) {
   const { pluginContext, pluginConfig } = context;
@@ -2086,15 +2681,17 @@ async function validateSubmission(formSlug, data, context) {
   if (!form) {
     return { valid: false, errors: { _form: "Form not found" } };
   }
-  const transformedData = transformFormData(data, form.fields);
-  const schema = generateZodSchema(form.fields);
-  const result = schema.safeParse(transformedData);
-  if (result.success) {
+  const prepared = prepareSubmission({
+    data,
+    fields: form.fields,
+    validate: true
+  });
+  if (!prepared.validationErrors) {
     return { valid: true };
   }
   return {
     valid: false,
-    errors: getValidationErrors(result)
+    errors: prepared.validationErrors
   };
 }
 async function isFormAcceptingSubmissions(formSlug, context) {
@@ -2105,25 +2702,6 @@ async function isFormAcceptingSubmissions(formSlug, context) {
   }
   return form.status === "published";
 }
-var TEXT_FORM_FIELDS = /* @__PURE__ */ new Set([
-  "text",
-  "email",
-  "textarea",
-  "phone",
-  "url",
-  "hidden"
-]);
-function stripHtmlTags(input) {
-  return input.replace(/<[^>]*(?:>|$)/g, "").replace(/\s+/g, " ").trim();
-}
-function sanitizeSubmissionData(data, fields) {
-  for (const field of fields) {
-    if (!TEXT_FORM_FIELDS.has(field.type)) continue;
-    const value = data[field.name];
-    if (typeof value !== "string") continue;
-    data[field.name] = stripHtmlTags(value);
-  }
-}
 async function getFormSubmissionStats(formSlug, context) {
   const { pluginContext, pluginConfig } = context;
   const { collections } = pluginContext.services;
@@ -2352,7 +2930,7 @@ export {
   cleanupRateLimitStore,
   clearRateLimitStore,
   createFormConfig,
-  date2 as date,
+  date3 as date,
   downloadFile,
   email,
   evaluateConditions,