betterstart-cli 0.0.117 → 0.0.118

package/dist/cli.js

@@ -21,6 +21,7 @@ import {
   MAIN_CSS_CANDIDATES,
   PROXY_CONVENTION_FILE_NAMES,
   PROXY_FILE_NAME,
+  PUBLIC_ASSET_FILE_NAMES,
   R2_ENV_KEYS,
   RAILWAY_BUCKET_ENV_KEYS,
   REDACTED,
@@ -69,6 +70,7 @@ import {
   resolveCommandCwd,
   resolveProjectEnvVar,
   restoreFile,
+  safeCopyFile,
   safeIdentifier,
   safeWriteFile,
   singularize,
@@ -86,7 +88,7 @@ import {
   trimDotSlash,
   usesIdentifier,
   validateAdminNamespace
-} from "./chunk-FGEVDA53.js";
+} from "./chunk-BNHFSHPE.js";
 
 // cli.ts
 import * as p66 from "@clack/prompts";
@@ -1255,32 +1257,32 @@ function collectInvalidSchemaFieldTypeErrors(fields, errors) {
 }
 
 // core-engine/schema/schema-reader/collect-slot-area-errors.ts
-function collectSlotAreaErrors(value, path113, errors) {
+function collectSlotAreaErrors(value, path114, errors) {
   if (!isRecord(value)) {
-    errors.push(`${path113} must be an object with a "fields" array.`);
+    errors.push(`${path114} must be an object with a "fields" array.`);
     return;
   }
   const fields = value.fields;
   if (!Array.isArray(fields)) {
-    errors.push(`${path113}.fields must be an array.`);
+    errors.push(`${path114}.fields must be an array.`);
     return;
   }
   for (const field of fields) {
     const name = isRecord(field) && isNonEmptyString(field.name) ? field.name : "unnamed";
-    walkSlot(field, `${path113}.fields.${name}`, errors);
+    walkSlot(field, `${path114}.fields.${name}`, errors);
   }
 }
 
 // core-engine/schema/schema-reader/collect-slot-layout-errors.ts
-function collectSlotLayoutErrors(value, path113, errors) {
+function collectSlotLayoutErrors(value, path114, errors) {
   if (!isRecord(value)) {
-    errors.push(`${path113} must be an object with "main" and/or "sidebar" field groups.`);
+    errors.push(`${path114} must be an object with "main" and/or "sidebar" field groups.`);
     return;
   }
   const validKeys = /* @__PURE__ */ new Set(["main", "sidebar"]);
   for (const key of Object.keys(value)) {
     if (!validKeys.has(key)) {
-      errors.push(`${path113} has unsupported key "${key}". Expected "main" or "sidebar".`);
+      errors.push(`${path114} has unsupported key "${key}". Expected "main" or "sidebar".`);
     }
   }
   const areas = [
@@ -1291,10 +1293,10 @@ function collectSlotLayoutErrors(value, path113, errors) {
   for (const [name, area] of areas) {
     if (area === void 0) continue;
     hasArea = true;
-    collectSlotAreaErrors(area, `${path113}.${name}`, errors);
+    collectSlotAreaErrors(area, `${path114}.${name}`, errors);
   }
   if (!hasArea) {
-    errors.push(`${path113} must define at least one of "main" or "sidebar".`);
+    errors.push(`${path114} must define at least one of "main" or "sidebar".`);
   }
 }
 
@@ -3738,7 +3740,7 @@ function buildEditsForSourceFile(sourceFile, filePath, plan) {
 }
 
 // core-engine/snapshots/ast-substitution/collect-preview-changes.ts
-function collectPreviewChanges(path113, beforeContent, afterContent) {
+function collectPreviewChanges(path114, beforeContent, afterContent) {
   const beforeLines = beforeContent.split("\n");
   const afterLines = afterContent.split("\n");
   const maxLength = Math.max(beforeLines.length, afterLines.length);
@@ -3750,7 +3752,7 @@ function collectPreviewChanges(path113, beforeContent, afterContent) {
       continue;
     }
     changes.push({
-      path: path113,
+      path: path114,
       line: index + 1,
       before: before.trim(),
       after: after.trim()
@@ -4609,9 +4611,9 @@ function renderErrorMessageLineLayoutTemplate({
   indent,
   pathExpression: pathExpression2
 }) {
-  return `${indent}{getFieldErrorMessage(form.formState.errors, ${pathExpression2}) ? (
+  return `${indent}{getFieldErrorMessage(form.formState, watchedValues, revealErrors, ${pathExpression2}) ? (
 ${indent}  <p className="text-sm text-destructive">
-${indent}    {getFieldErrorMessage(form.formState.errors, ${pathExpression2})}
+${indent}    {getFieldErrorMessage(form.formState, watchedValues, revealErrors, ${pathExpression2})}
 ${indent}  </p>
 ${indent}) : null}`;
 }
@@ -5380,19 +5382,51 @@ ${innerJSX}
 
 // adapters/next/templates/renderers/generators/form-pipeline/form-component-shared/build-field-error-helper.ts
 function renderBuildFieldErrorHelperSegmentTemplate() {
-  return `function getFieldErrorMessage(errors: FieldErrors<FormValues>, path: string): string | undefined {
-  let current: unknown = errors
+  return `function readFormPath(source: unknown, path: string): unknown {
+  let current: unknown = source
   for (const segment of path.split('.')) {
     if (!current || typeof current !== 'object') {
       return undefined
     }
     current = (current as Record<string, unknown>)[segment]
   }
-  if (current && typeof current === 'object' && 'message' in current) {
-    const message = (current as { message?: unknown }).message
-    return typeof message === 'string' ? message : undefined
+  return current
+}
+
+function hasFieldValue(value: unknown): boolean {
+  if (value === null || value === undefined) {
+    return false
+  }
+  if (typeof value === 'string') {
+    return value.trim().length > 0
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0
   }
-  return undefined
+  return true
+}
+
+function getFieldErrorMessage(
+  formState: FormState<FormValues>,
+  values: unknown,
+  revealErrors: boolean,
+  path: string
+): string | undefined {
+  const error = readFormPath(formState.errors, path)
+  const message =
+    error && typeof error === 'object' && 'message' in error
+      ? (error as { message?: unknown }).message
+      : undefined
+  if (typeof message !== 'string') {
+    return undefined
+  }
+  if (revealErrors) {
+    return message
+  }
+  if (readFormPath(formState.touchedFields, path) !== true) {
+    return undefined
+  }
+  return hasFieldValue(readFormPath(values, path)) ? message : undefined
 }`;
 }
 
@@ -5484,18 +5518,24 @@ function ${pPascal}FormInner() {
     defaultValues: {
 ${pDefaults}
     },
+    mode: 'onBlur'
   })
+  const watchedValues = useWatch({ control: form.control })
+  const [stepAttempted, setStepAttempted] = React.useState(false)
+  const revealErrors = form.formState.isSubmitted || stepAttempted
 
 ${pFieldArraySetup}${pWatchSetup}
   async function handleNext() {
     const stepFields = STEPS[currentStep].fields as (keyof FormValues)[]
     const isValid = await form.trigger(stepFields, { shouldFocus: true })
+    setStepAttempted(!isValid)
     if (isValid) {
       setCurrentStep(currentStep + 1)
     }
   }
 
   function handleBack() {
+    setStepAttempted(false)
     setCurrentStep(currentStep - 1)
   }
 
@@ -5666,7 +5706,7 @@ function buildMultiStepFormComponentSource(schema, options = {}) {
   const listFields = getListFields(allFields);
   const hasListFields = listFields.length > 0;
   const { setup: watchSetup } = buildWatchDecls(allFields);
-  const rhfImport = hasListFields ? `import { Controller, useFieldArray, useForm, type FieldErrors } from 'react-hook-form'` : `import { Controller, useForm, type FieldErrors } from 'react-hook-form'`;
+  const rhfImport = hasListFields ? `import { Controller, useFieldArray, useForm, useWatch, type FormState } from 'react-hook-form'` : `import { Controller, useForm, useWatch, type FormState } from 'react-hook-form'`;
   const fieldArraySetup = hasListFields ? `
 ${buildFieldArrayDecls(listFields)}
 ` : "";
@@ -5741,7 +5781,10 @@ export function ${pascal}Form() {
     defaultValues: {
 ${defaults}
     },
+    mode: 'onBlur'
   })
+  const watchedValues = useWatch({ control: form.control })
+  const revealErrors = form.formState.isSubmitted
 ${fieldArraySetup}${watchSetup}
   function onSubmit(values: FormValues) {
     startSubmitTransition(async () => {
@@ -5806,7 +5849,7 @@ function buildSingleStepFormComponentSource(schema, options = {}) {
   const successMessage = escapeJsx(schema.successMessage || "Form submitted successfully!");
   const redirectUrl = schema.redirectUrl;
   const successHandler = redirectUrl ? `window.location.href = ${JSON.stringify(redirectUrl)}` : "setSubmitted(true)";
-  const rhfImport = hasListFields ? `import { Controller, useFieldArray, useForm, type FieldErrors } from 'react-hook-form'` : `import { Controller, useForm, type FieldErrors } from 'react-hook-form'`;
+  const rhfImport = hasListFields ? `import { Controller, useFieldArray, useForm, useWatch, type FormState } from 'react-hook-form'` : `import { Controller, useForm, useWatch, type FormState } from 'react-hook-form'`;
   const fieldArraySetup = hasListFields ? `
 ${buildFieldArrayDecls(listFields)}
 ` : "";
@@ -6072,10 +6115,10 @@ function renderCreateDevModeIntegrationArtifactImportsTemplate({
 }) {
   return `import type {
   DevModeIntegration,
-  DevModeIntegrationMetadata,
-  DevModeLifecycleHookExample,
-  DevModeSnippet
+  DevModeIntegrationMetadata
 } from '${adminImportAlias}/components/shared/dev-mode/dev-mode-types'
+import { parseDevModeLifecycleHooks } from '${adminImportAlias}/utils/dev-mode/parse-dev-mode-lifecycle-hooks'
+import { parseDevModeSnippets } from '${adminImportAlias}/utils/dev-mode/parse-dev-mode-snippets'
 
 export const ${exportName} = {
   schemaName: ${stringify},
@@ -6087,12 +6130,12 @@ export async function ${loadExportName}(): Promise<DevModeIntegration> {
   const [${join}] = await Promise.all([
 ${dynamicImports}
   ])
-  const snippets = [
+  const snippets = parseDevModeSnippets([
 ${snippetValues}
-  ] as DevModeSnippet[]
-  const lifecycleHooks = [
+  ])
+  const lifecycleHooks = parseDevModeLifecycleHooks([
 ${lifecycleHookValues}
-  ] as DevModeLifecycleHookExample[]
+  ])
 
   return {
     ...${exportName},
@@ -7568,12 +7611,7 @@ export function ${pascal}SubmissionsTable<TValue>({
               key={row.id}
               data-state={row.getIsSelected() ? 'selected' : undefined}
               className="cursor-pointer hover:bg-muted/50"
-              onClick={(e) => {
-                const target = e.target as HTMLElement
-                if (!e.currentTarget.contains(target)) return
-                if (target.closest('button, a, input, [role="checkbox"]')) return
-                onViewSubmission(row.original.id)
-              }}
+              onActivate={() => onViewSubmission(row.original.id)}
             >
               {row.getVisibleCells().map((cell) => {
                 const meta = cell.column.columnDef.meta as Record<string, unknown> | undefined
@@ -9433,10 +9471,11 @@ import {
   get${ctxSingular}SlugRetryLimit,
   is${ctxSingular}SlugConflict,
   resolveUnique${ctxSingular}Slug,
-  ${snapshotImport}
+  ${snapshotImport},
+  to${ctxSingular}
 } from './helpers'
 ${lifecycleHookImport2}
-import type { ${ctxSingular}CreateInput, ${ctxSingular}CreateResult, ${ctxSingular} } from './types'${markdownImport}
+import type { ${ctxSingular}CreateInput, ${ctxSingular}CreateResult } from './types'${markdownImport}
 
 export async function create${ctxSingular}(input: ${ctxSingular}CreateInput): Promise<${ctxSingular}CreateResult> {
   const actor = await requireRole([UserRole.ADMIN, UserRole.EDITOR])
@@ -9445,7 +9484,7 @@ export async function create${ctxSingular}(input: ${ctxSingular}CreateInput): Pr
     const actorId = actor.id
     const now = new Date().toISOString()
     const auditRequestMetadata = await getAuditRequestMetadata()
-    const changedFields = getTouchedFieldNames(input as unknown as Record<string, unknown>)
+    const changedFields = getTouchedFieldNames(input)
     const lifecycleContext = ${createContext}
     ${beforeHook2}
 ${createBeforePublishBlock}
@@ -9508,7 +9547,7 @@ ${ctxCreateMappings},${ctxHasHtmlOutputContent}${ctxHasDraftContent}
       typeof created${ctxSingular}Id === 'string'
         ? await get${ctxSingular}ById(created${ctxSingular}Id)
         : null
-    const created${ctxSingular}Data = created${ctxSingular} ?? (result[0] as unknown as ${ctxSingular})
+    const created${ctxSingular}Data = created${ctxSingular} ?? to${ctxSingular}(result[0])
     const created${ctxSingular}Context = ${createResultContext}
     ${afterHook2}
 ${createAfterPublishBlock}
@@ -9530,21 +9569,18 @@ function genCreateContent(ctx) {
   const kebabSingular = toKebabCase(ctx.singular);
   const slugSourceValue = ctx.slugSourceField ? `input.${ctx.slugSourceField}` : "undefined";
   const snapshotImport = ctx.hasM2M ? `build${ctx.Singular}VersionSnapshotWithRelationships` : `build${ctx.Singular}VersionSnapshot`;
-  const snapshotData = ctx.hasM2M ? `await build${ctx.Singular}VersionSnapshotWithRelationships(createdRow as unknown as ${ctx.Singular}, tx)` : `build${ctx.Singular}VersionSnapshot(createdRow as unknown as ${ctx.Singular})`;
+  const snapshotData = ctx.hasM2M ? `await build${ctx.Singular}VersionSnapshotWithRelationships(createdRow, tx)` : `build${ctx.Singular}VersionSnapshot(createdRow)`;
   const markdownImport = ctx.hasHtmlOutput ? `
 import { renderMarkdownSync } from './markdown'` : "";
-  const createContext = lifecycleContext(
-    ctx.plural,
-    `,
-      input: input as unknown as Record<string, unknown>,
-      changedFields`
-  );
+  const createContext = lifecycleContext(ctx.plural, `,
+      input,
+      changedFields`);
   const createResultContext = lifecycleContext(
     ctx.plural,
     `,
       entityId: created${ctx.Singular}Id,
-      input: input as unknown as Record<string, unknown>,
-      data: created${ctx.Singular}Data as unknown as Record<string, unknown>,
+      input,
+      data: created${ctx.Singular}Data,
       changedFields`
   );
   const createBeforePublishBlock = ctx.hasDraft ? `
@@ -9792,7 +9828,7 @@ export async function deleteBulk${ctxPlural}(ids: string[]): Promise<${ctxSingul
       return tx.delete(${ctxTableVar}).where(inArray(${ctxTableVar}.id, ids)).returning()
     })
     const deletedRowsById = new Map(
-      deletedRows.map((row) => [row.id, row as unknown as Record<string, unknown>])
+      deletedRows.map((row) => [row.id, row])
     )
     ${ctxCacheInvalidationFn}(${ctxCamelPlural}CacheTags.all)
     for (const id of ids) {
@@ -9899,7 +9935,7 @@ export async function delete${ctxSingular}(id: string): Promise<${ctxSingular}De
 function renderGenDeleteContentTemplate() {
   return `{
       ...lifecycleContext,
-      data: deletedRow as unknown as Record<string, unknown> | undefined
+      data: deletedRow
     }`;
 }
 function renderGenDeleteContentRenderer(request) {
@@ -10061,12 +10097,13 @@ function genGetByIdContent(ctx) {
   const dbImports = [ctx.tableVar, "user", ...ctx.relTableImports].sort();
   const drizzle = ["eq"];
   const sortedDrizzle = [...new Set(drizzle)].sort();
-  const byIdHelperImports = ["formatActionDate"];
+  const byIdHelperImports = [];
   if (ctx.hasSelectFields) byIdHelperImports.push(`resolve${ctx.Singular}SelectFields`);
   if (ctx.hasListRels) byIdHelperImports.push(`populate${ctx.Singular}ListRelationships`);
   if (ctx.hasMediaFields) byIdHelperImports.push(`resolve${ctx.Singular}MediaFields`);
-  const populateImport = byIdHelperImports.length > 0 ? `
-import { ${byIdHelperImports.join(", ")} } from './helpers'` : "";
+  const populateImport = `
+import { formatActionDate } from '@admin/utils/date/format-action-date'` + (byIdHelperImports.length > 0 ? `
+import { ${byIdHelperImports.join(", ")} } from './helpers'` : "");
   return renderGenGetByIdContentServerActionTemplate({
     join: dbImports.join(", "),
     joinText: sortedDrizzle.join(", "),
@@ -10133,12 +10170,13 @@ function genGetBySlugContent(ctx) {
   const dbImports = [ctx.tableVar, "user", ...ctx.relTableImports].sort();
   const drizzle = ["eq"];
   const sortedDrizzle = [...new Set(drizzle)].sort();
-  const bySlugHelperImports = ["formatActionDate"];
+  const bySlugHelperImports = [];
   if (ctx.hasSelectFields) bySlugHelperImports.push(`resolve${ctx.Singular}SelectFields`);
   if (ctx.hasListRels) bySlugHelperImports.push(`populate${ctx.Singular}ListRelationships`);
   if (ctx.hasMediaFields) bySlugHelperImports.push(`resolve${ctx.Singular}MediaFields`);
-  const populateImport = bySlugHelperImports.length > 0 ? `
-import { ${bySlugHelperImports.join(", ")} } from './helpers'` : "";
+  const populateImport = `
+import { formatActionDate } from '@admin/utils/date/format-action-date'` + (bySlugHelperImports.length > 0 ? `
+import { ${bySlugHelperImports.join(", ")} } from './helpers'` : "");
   return renderGenGetBySlugContentServerActionTemplate({
     join: dbImports.join(", "),
     joinText: sortedDrizzle.join(", "),
@@ -10223,15 +10261,11 @@ ${ctxSearchBlock}${ctxFilterConditions}
       ? Math.max(0, rawOffset)
       : 0
     const isPaginated = typeof limit === 'number'
-    let results: unknown[]
-    if (isPaginated) {
-      const paginatedQuery = offset > 0
-        ? orderedQuery.limit(limit).offset(offset)
-        : orderedQuery.limit(limit)
-      results = await paginatedQuery
-    } else {
-      results = await orderedQuery
-    }
+    const results = isPaginated
+      ? offset > 0
+        ? await orderedQuery.limit(limit).offset(offset)
+        : await orderedQuery.limit(limit)
+      : await orderedQuery
 
     const total = isPaginated
       ? Number((await db.select({ count: sql\`count(*)\` }).from(${ctxTableVar})${ctxWhere})[0]?.count ?? 0)
@@ -10256,13 +10290,14 @@ function genGetPluralContent(ctx) {
   drizzle.push("sql");
   if (ctx.hasRelationships) drizzle.push("eq");
   const sortedDrizzle = [...new Set(drizzle)].sort();
-  const typeImports = [`${ctx.Plural}Page`, `${ctx.Plural}Query`, `${ctx.Singular}`];
-  const helperImports = ["formatActionDate"];
+  const typeImports = [`${ctx.Plural}Page`, `${ctx.Plural}Query`];
+  const helperImports = [];
   if (ctx.hasSelectFields) helperImports.push(`resolve${ctx.Singular}SelectFields`);
   if (ctx.hasListRels) helperImports.push(`populate${ctx.Singular}ListRelationships`);
   if (ctx.hasMediaFields) helperImports.push(`resolve${ctx.Singular}MediaFields`);
-  const populateImport = helperImports.length > 0 ? `
-import { ${helperImports.join(", ")} } from './helpers'` : "";
+  const populateImport = `
+import { formatActionDate } from '@admin/utils/date/format-action-date'` + (helperImports.length > 0 ? `
+import { ${helperImports.join(", ")} } from './helpers'` : "");
   const dateRangeHelper = hasDateRangeFilters ? `
 
 ${renderExclusiveDateUpperBoundHelper()}` : "";
@@ -10330,7 +10365,14 @@ export async function get${ctxSingular}SelectOptions(
       .where(eq(${ctxSelectOptionsTableVar}.fieldName, fieldName))
       .orderBy(asc(${ctxSelectOptionsTableVar}.label))
 
-    return rows as ${ctxSingular}SelectOption[]
+    return rows.map((row) => ({
+      id: row.id,
+      fieldName,
+      label: row.label,
+      value: row.value,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    }))
   } catch (error) {
     console.error('Error fetching ${ctxSingularText} select options:', error)
     return []
@@ -10383,120 +10425,91 @@ function genGetVersionsContent(ctx) {
   });
 }
 
-// adapters/next/templates/renderers/generators/actions/action-helpers/build-format-action-date-source.ts
-function renderBuildFormatActionDateSourceDateTemplate({
-  optionsExportedExport
-}) {
-  return `${optionsExportedExport}function formatActionDate(value: unknown): string {
-  if (typeof value !== 'string') return ''
-  const date = new Date(value)
-  if (Number.isNaN(date.getTime())) return ''
-
-  return date.toLocaleDateString('en-US', {
-    month: 'short',
-    day: '2-digit',
-    year: 'numeric',
-    timeZone: 'UTC'
-  })
-}`;
-}
-
-// adapters/next/generators/actions/action-helpers/build-format-action-date-source.ts
-function buildFormatActionDateSource(options) {
-  return renderBuildFormatActionDateSourceDateTemplate({
-    optionsExportedExport: options.exported ? "export " : ""
-  });
-}
-
 // adapters/next/templates/renderers/generators/actions/entity-file-contents/generate-resolve-media-function.ts
 function renderResolveMediaFunctionIdsTemplate({
   ctxSingular,
-  collectSingle,
-  collectArrayContent,
-  map,
-  arrayFieldsContent,
-  assignSingle,
-  assignArrayContent
+  collectStatements,
+  listResolverBlock,
+  assignments
 }) {
-  return `export async function resolve${ctxSingular}MediaFields(rows: ${ctxSingular}[]): Promise<${ctxSingular}[]> {
-  if (rows.length === 0) return rows
-
+  return `export async function resolve${ctxSingular}MediaFields(rows: ${ctxSingular}MediaResolvable[]): Promise<${ctxSingular}[]> {
   const ids = new Set<string>()
-${collectSingle}${collectArrayContent}
-
-  if (ids.size === 0) {
-    for (const row of rows) {
-${map}${arrayFieldsContent}
-    }
-    return rows
+  for (const row of rows) {
+${collectStatements}
   }
 
-  const mediaRows = await db.select().from(adminMedia).where(inArray(adminMedia.id, [...ids]))
-  const mediaMap = new Map<string, AdminMedia>(mediaRows.map(m => [m.id, m]))
+  const mediaRows =
+    ids.size === 0
+      ? []
+      : await db.select().from(adminMedia).where(inArray(adminMedia.id, [...ids]))
+  const mediaMap = new Map<string, AdminMedia>(mediaRows.map((media) => [media.id, media]))
 
-  for (const row of rows) {
-${assignSingle}${assignArrayContent}
-  }
+  function resolveMedia(reference: string | null): AdminMedia | null {
+    if (!reference || reference.startsWith('http')) return null
+    const media = mediaMap.get(reference)
+    if (!media) return null
 
-  return rows
+    return {
+      ...media,
+      createdAtFormatted: formatActionDate(media.createdAt),
+      updatedAtFormatted: formatActionDate(media.updatedAt)
+    }
+  }
+${listResolverBlock}
+  return rows.map((row) => ({
+    ...row,
+${assignments}
+  }))
 }`;
 }
+function renderResolveMediaListResolverTemplate() {
+  return `
+  function resolveMediaList(references: string[]): AdminMedia[] {
+    return references
+      .map((reference) => resolveMedia(reference))
+      .filter((media): media is AdminMedia => media !== null)
+  }
+`;
+}
+function renderResolveMediaFunctionRenderer(request) {
+  switch (request.kind) {
+    case "renderResolveMediaFunctionIdsTemplate":
+      return renderResolveMediaFunctionIdsTemplate(request.props);
+    case "renderResolveMediaListResolverTemplate":
+      return renderResolveMediaListResolverTemplate();
+  }
+  throw new Error("Unsupported renderer request");
+}
 
 // adapters/next/generators/actions/entity-file-contents/generate-resolve-media-function.ts
 function generateResolveMediaFunction(ctx) {
   const singleFields = ctx.mediaFields.map((f) => f.name);
   const arrayFields = ctx.galleryFields.map((f) => f.name);
-  const collectSingle = singleFields.map(
-    (name) => `    for (const row of rows) {
-      const val = row.${name}
-      if (val && typeof val === 'string' && !val.startsWith('http')) ids.add(val)
-    }`
-  ).join("\n");
-  const collectArray = arrayFields.map(
-    (name) => `    for (const row of rows) {
-      const arr = row.${name}
-      if (Array.isArray(arr)) for (const id of arr) { if (id && !id.startsWith('http')) ids.add(id) }
+  const collectStatements = [
+    ...singleFields.map(
+      (name) => `    if (row.${name} && !row.${name}.startsWith('http')) ids.add(row.${name})`
+    ),
+    ...arrayFields.map(
+      (name) => `    for (const id of row.${name}) {
+      if (id && !id.startsWith('http')) ids.add(id)
     }`
-  ).join("\n");
-  const assignSingle = singleFields.map(
-    (name) => `    row.${name}Media = row.${name} && !row.${name}.startsWith('http')
-      ? (() => {
-          const media = mediaMap.get(row.${name})
-          if (!media) return null
-          return {
-            ...media,
-            createdAtFormatted: formatActionDate(media.createdAt),
-            updatedAtFormatted: formatActionDate(media.updatedAt)
-          }
-        })()
-      : null`
-  ).join("\n");
-  const assignArray = arrayFields.map(
-    (name) => `    row.${name}Media = Array.isArray(row.${name})
-      ? row.${name}
-          .map((id: string) => {
-            const media = mediaMap.get(id)
-            if (!media) return null
-            return {
-              ...media,
-              createdAtFormatted: formatActionDate(media.createdAt),
-              updatedAtFormatted: formatActionDate(media.updatedAt)
-            }
-          })
-          .filter(Boolean) as AdminMedia[]
-      : []`
-  ).join("\n");
-  return renderResolveMediaFunctionIdsTemplate({
-    ctxSingular: ctx.Singular,
-    collectSingle,
-    collectArrayContent: collectArray ? `
-${collectArray}` : "",
-    map: singleFields.map((name) => `      row.${name}Media = null`).join("\n"),
-    arrayFieldsContent: arrayFields.length > 0 ? `
-${arrayFields.map((name) => `      row.${name}Media = []`).join("\n")}` : "",
-    assignSingle,
-    assignArrayContent: assignArray ? `
-${assignArray}` : ""
+    )
+  ].join("\n");
+  const assignments = [
+    ...singleFields.map((name) => `    ${name}Media: resolveMedia(row.${name})`),
+    ...arrayFields.map((name) => `    ${name}Media: resolveMediaList(row.${name})`)
+  ].join(",\n");
+  return renderResolveMediaFunctionRenderer({
+    kind: "renderResolveMediaFunctionIdsTemplate",
+    props: {
+      ctxSingular: ctx.Singular,
+      collectStatements,
+      listResolverBlock: arrayFields.length > 0 ? renderResolveMediaFunctionRenderer({
+        kind: "renderResolveMediaListResolverTemplate",
+        props: {}
+      }) : "",
+      assignments
+    }
   });
 }
 
@@ -10519,12 +10532,8 @@ function renderResolveSelectFieldsSourceDynamicRowsTemplate({
   }
 `;
 }
-function renderResolveSelectFieldsSourceStaticSelectOptionLabelsTemplate({
-  staticLabelMaps,
-  exportedExport,
-  singular,
-  dynamicRowsBlock,
-  assignments
+function renderSelectOptionLabelMapsTemplate({
+  staticLabelMaps
 }) {
   return `const STATIC_SELECT_OPTION_LABELS = {
 ${staticLabelMaps}
@@ -10537,7 +10546,56 @@ function cloneSelectOptionLabelMaps(): Record<string, Record<string, string>> {
       { ...labels }
     ])
   )
+}`;
+}
+function renderResolveSelectFieldsSourceStaticSelectOptionLabelsTemplate({
+  staticLabelMaps,
+  exportedExport,
+  singular,
+  inputType,
+  outputType,
+  dynamicRowsBlock,
+  labelDeclarations,
+  assignments
+}) {
+  return `${renderSelectOptionLabelMapsTemplate({ staticLabelMaps })}
+
+function toSelectOptionValues(
+  values: string[],
+  labels: Record<string, string>
+): SelectOptionValue[] {
+  return values
+    .filter((item) => item.length > 0)
+    .map((item) => ({
+      label: labels[item] ?? item,
+      value: item
+    }))
+}
+
+${exportedExport}async function resolve${singular}SelectFields(
+  rows: ${inputType}[]
+): Promise<${outputType}[]> {
+  if (rows.length === 0) return []
+
+  const labelMaps = cloneSelectOptionLabelMaps()
+${dynamicRowsBlock}
+${labelDeclarations}
+
+  return rows.map((row) => ({
+    ...row,
+${assignments}
+  }))
+}`;
 }
+function renderResolveSelectFieldsSourceNestedTemplate({
+  staticLabelMaps,
+  exportedExport,
+  singular,
+  rowType,
+  dynamicRowsBlock,
+  assignments
+}) {
+  return `${renderSelectOptionLabelMapsTemplate({ staticLabelMaps })}
 
 function toSelectOptionValues(value: unknown, labels: Record<string, string>): SelectOptionValue[] {
   const values = Array.isArray(value) ? value : value ? [value] : []
@@ -10566,25 +10624,25 @@ function resolveSelectFieldPath(
   const value = source[fieldName]
   if (Array.isArray(value)) {
     for (const item of value) {
-      if (item && typeof item === 'object') {
-        resolveSelectFieldPath(item as Record<string, unknown>, rest, labels)
+      if (isRecord(item)) {
+        resolveSelectFieldPath(item, rest, labels)
       }
     }
     return
   }
 
-  if (value && typeof value === 'object') {
-    resolveSelectFieldPath(value as Record<string, unknown>, rest, labels)
+  if (isRecord(value)) {
+    resolveSelectFieldPath(value, rest, labels)
   }
 }
 
-${exportedExport}async function resolve${singular}SelectFields(rows: ${singular}[]): Promise<${singular}[]> {
+${exportedExport}async function resolve${singular}SelectFields(rows: ${rowType}[]): Promise<${rowType}[]> {
   if (rows.length === 0) return rows
 
   const labelMaps = cloneSelectOptionLabelMaps()
 ${dynamicRowsBlock}
   for (const row of rows) {
-    const source = row as unknown as Record<string, unknown>
+    const source: Record<string, unknown> = row
 ${assignments}
   }
 
@@ -10597,6 +10655,8 @@ function renderSelectFieldsResolverRenderer(request) {
       return renderResolveSelectFieldsSourceDynamicRowsTemplate(request.props);
     case "renderResolveSelectFieldsSourceStaticSelectOptionLabelsTemplate":
       return renderResolveSelectFieldsSourceStaticSelectOptionLabelsTemplate(request.props);
+    case "renderResolveSelectFieldsSourceNestedTemplate":
+      return renderResolveSelectFieldsSourceNestedTemplate(request.props);
   }
   throw new Error("Unsupported renderer request");
 }
@@ -10607,6 +10667,7 @@ function generateResolveSelectFieldsSource({
   selectFields,
   selectOptionsTableVar,
   hasCreatableSelectFields,
+  hasMediaFields,
   exported
 }) {
   const staticLabelMaps = selectFields.map((readField) => {
@@ -10620,17 +10681,47 @@ function generateResolveSelectFieldsSource({
       selectOptionsTableVar
     }
   }) : "";
-  const assignments = selectFields.map((readField) => {
-    const key = readField.path.join(".");
-    return `    resolveSelectFieldPath(source, ${JSON.stringify(readField.path)}, labelMaps[${JSON.stringify(key)}] ?? {})`;
-  }).join("\n");
+  const hasNestedSelectFields = selectFields.some((readField) => readField.path.length > 1);
+  const resolvedType = hasMediaFields ? `${Singular}MediaResolvable` : Singular;
+  if (hasNestedSelectFields) {
+    const assignments2 = selectFields.map((readField) => {
+      const key = readField.path.join(".");
+      return `    resolveSelectFieldPath(source, ${JSON.stringify(readField.path)}, labelMaps[${JSON.stringify(key)}] ?? {})`;
+    }).join("\n");
+    return renderSelectFieldsResolverRenderer({
+      kind: "renderResolveSelectFieldsSourceNestedTemplate",
+      props: {
+        staticLabelMaps,
+        exportedExport: exported ? "export " : "",
+        singular: Singular,
+        rowType: resolvedType,
+        dynamicRowsBlock,
+        assignments: assignments2
+      }
+    });
+  }
+  const labelVariables = new Map(
+    selectFields.map((readField) => [
+      readField.path[0],
+      `${toCamelCase(singularize(readField.path[0]))}Labels`
+    ])
+  );
+  const labelDeclarations = [...labelVariables].map(
+    ([fieldName, variable]) => `  const ${variable} = labelMaps[${JSON.stringify(fieldName)}] ?? {}`
+  ).join("\n");
+  const assignments = [...labelVariables].map(
+    ([fieldName, variable]) => `    ${fieldName}: toSelectOptionValues(row.${fieldName}, ${variable})`
+  ).join(",\n");
   return renderSelectFieldsResolverRenderer({
     kind: "renderResolveSelectFieldsSourceStaticSelectOptionLabelsTemplate",
     props: {
       staticLabelMaps,
       exportedExport: exported ? "export " : "",
       singular: Singular,
+      inputType: `${Singular}SelectResolvable`,
+      outputType: resolvedType,
       dynamicRowsBlock,
+      labelDeclarations,
       assignments
     }
   });
@@ -10643,6 +10734,7 @@ function generateResolveSelectFieldsFunction(ctx) {
     selectFields: ctx.selectFields,
     selectOptionsTableVar: ctx.selectOptionsTableVar,
     hasCreatableSelectFields: ctx.hasCreatableSelectFields,
+    hasMediaFields: ctx.hasMediaFields,
     exported: true
   });
 }
@@ -10675,11 +10767,10 @@ export function get${ctxSingular}SlugRetryLimit(): number {
 }
 
 export function is${ctxSingular}SlugConflict(error: unknown): boolean {
-  if (typeof error !== 'object' || error === null) return false
-  const record = error as Record<string, unknown>
-  if (record.code !== '23505') return false
-  const constraint = typeof record.constraint === 'string' ? record.constraint : ''
-  const message = typeof record.message === 'string' ? record.message : ''
+  if (!isRecord(error)) return false
+  if (error.code !== '23505') return false
+  const constraint = typeof error.constraint === 'string' ? error.constraint : ''
+  const message = typeof error.message === 'string' ? error.message : ''
   return constraint === SLUG_CONSTRAINT_NAME || message.includes(SLUG_CONSTRAINT_NAME)
 }
 
@@ -10728,6 +10819,59 @@ function generateSlugHelpers(ctx) {
   });
 }
 
+// adapters/next/templates/renderers/generators/actions/entity-file-contents/generate-to-entity-function.ts
+function renderToEntityFunctionTemplate({
+  ctxSingular,
+  ctxTableVar,
+  fieldMappings
+}) {
+  return `export function to${ctxSingular}(row: typeof ${ctxTableVar}.$inferSelect): ${ctxSingular} {
+  return {
+${fieldMappings}
+  }
+}`;
+}
+
+// adapters/next/generators/actions/entity-file-contents/generate-to-entity-function.ts
+function generateToEntityFunction({
+  Singular,
+  tableVar,
+  allDbFields,
+  htmlOutputFields,
+  m2mFields,
+  mediaFields,
+  galleryFields
+}) {
+  const rowExpression = (field) => {
+    if (field.type === "relationship") return field.multiple ? "[]" : "null";
+    if (field.type === "select") {
+      return field.multiple ? `(row.${field.name} ?? []).map((value) => ({ label: value, value }))` : `row.${field.name} ? [{ label: row.${field.name}, value: row.${field.name} }] : []`;
+    }
+    return `row.${field.name}`;
+  };
+  const hasTimestampFields = allDbFields.some((f) => f.name === "createdAt") && allDbFields.some((f) => f.name === "updatedAt");
+  const hasFormattedTimestampFields = allDbFields.some((f) => f.name === "createdAtFormatted");
+  const timestampMappings = hasTimestampFields && !hasFormattedTimestampFields ? [
+    "    createdAtFormatted: formatActionDate(row.createdAt)",
+    "    updatedAtFormatted: formatActionDate(row.updatedAt)"
+  ] : [];
+  const fieldMappings = [
+    ...allDbFields.map((field) => `    ${quotePropertyName(field.name)}: ${rowExpression(field)}`),
+    ...htmlOutputFields.map((field) => `    ${field.name}Html: row.${field.name}Html ?? ''`),
+    ...m2mFields.map((field) => `    ${quotePropertyName(field.name)}: []`),
+    ...mediaFields.map((field) => `    ${quotePropertyName(`${field.name}Media`)}: null`),
+    ...galleryFields.map((field) => `    ${quotePropertyName(`${field.name}Media`)}: []`),
+    ...timestampMappings,
+    "    createdByUser: null",
+    "    updatedByUser: null"
+  ].join(",\n");
+  return renderToEntityFunctionTemplate({
+    ctxSingular: Singular,
+    ctxTableVar: tableVar,
+    fieldMappings
+  });
+}
+
 // adapters/next/templates/renderers/generators/actions/entity-file-contents/generate-version-snapshot-helpers.ts
 function renderVersionSnapshotHelpersRowsTemplate({
   fieldName,
@@ -10780,7 +10924,7 @@ const VERSION_RESTORE_KEYS = [${restoreKeys}] as const
 const VERSION_M2M_KEYS = [${m2mKeys}] as const
 
 export function build${ctxSingular}VersionSnapshot(row: Partial<${ctxSingular}> | Record<string, unknown>): Record<string, unknown> {
-  const source = row as unknown as Record<string, unknown>
+  const source: Record<string, unknown> = row
   const snapshot: Record<string, unknown> = {}
 
   for (const key of VERSION_SNAPSHOT_KEYS) {
@@ -10895,12 +11039,11 @@ function genHelpersContent(ctx) {
   if (ctx.hasCreatableSelectFields) {
     schemaImports.add(ctx.selectOptionsTableVar);
   }
-  if (ctx.hasSlug) {
-    schemaImports.add(ctx.tableVar);
-  }
+  schemaImports.add(ctx.tableVar);
   if (ctx.hasM2M || ctx.hasListRels || ctx.hasMediaFields || ctx.hasCreatableSelectFields || ctx.hasSlug) {
     lines.push(`import db from '@admin/db'`);
   }
+  lines.push(`import { formatActionDate } from '@admin/utils/date/format-action-date'`);
   const tables = [...schemaImports].sort();
   if (tables.length > 0) {
     lines.push(`import { ${tables.join(", ")} } from '@admin/db/schema'`);
@@ -10914,11 +11057,17 @@ function genHelpersContent(ctx) {
   if (ctx.hasSlug) {
     lines.push(`import { slugify } from '@admin/utils/validation/slugify'`);
   }
-  const typeImports = ctx.hasSelectFields ? `${ctx.Singular}, SelectOptionValue` : ctx.Singular;
+  if (ctx.hasSlug || ctx.hasNestedSelectFields || ctx.hasListRels) {
+    lines.push(`import { isRecord } from '@admin/utils/shared/is-record'`);
+  }
+  const typeImports = [
+    ctx.Singular,
+    ...ctx.hasMediaFields ? [`${ctx.Singular}MediaResolvable`] : [],
+    ...ctx.hasSelectFields && !ctx.hasNestedSelectFields ? [`${ctx.Singular}SelectResolvable`] : [],
+    ...ctx.hasSelectFields ? ["SelectOptionValue"] : []
+  ].join(", ");
   lines.push(`import type { ${typeImports} } from './types'`);
   lines.push("");
-  lines.push(buildFormatActionDateSource({ exported: true }));
-  lines.push("");
   if (ctx.hasSlug) {
     lines.push(generateSlugHelpers(ctx));
     lines.push("");
@@ -10932,6 +11081,18 @@ function genHelpersContent(ctx) {
     lines.push(generateResolveMediaFunction(ctx));
     lines.push("");
   }
+  lines.push(
+    generateToEntityFunction({
+      Singular: ctx.Singular,
+      tableVar: ctx.tableVar,
+      allDbFields: ctx.allDbFields,
+      htmlOutputFields: ctx.htmlOutputFields,
+      m2mFields: ctx.m2mFields,
+      mediaFields: ctx.mediaFields,
+      galleryFields: ctx.galleryFields
+    })
+  );
+  lines.push("");
   if (ctx.hasSelectFields) {
     lines.push(generateResolveSelectFieldsFunction(ctx));
     lines.push("");
@@ -11162,10 +11323,12 @@ import { ${ctxCamelPlural}CacheTags } from './types'
 import { get${ctxSingular}ById } from './get-${kebabSingular}-by-id'
 import {
   build${ctxSingular}RestoreData,
-  ${snapshotImport}
+  ${snapshotImport},
+  to${ctxSingular}
 } from './helpers'
 ${lifecycleHookImport2}
-import type { ${ctxSingular}UpdateResult, ${ctxSingular} } from './types'
+import { isRecord } from '@admin/utils/shared/is-record'
+import type { ${ctxSingular}UpdateResult } from './types'
 
 export async function restore${ctxSingular}Version(
   versionId: string
@@ -11184,7 +11347,7 @@ export async function restore${ctxSingular}Version(
 
     if (!versionRow) throw new Error('${ctxSingular} version not found')
 
-    const versionData = versionRow.data as Record<string, unknown>
+    const versionData = isRecord(versionRow.data) ? versionRow.data : {}
     const restoreData = build${ctxSingular}RestoreData(versionData)
     const auditRequestMetadata = await getAuditRequestMetadata()
     const lifecycleContext = ${restoreContext}
@@ -11222,7 +11385,7 @@ ${restoreM2MContent}
 
     return {
       success: true,
-      ${ctxCamelSingular}: restored${ctxSingular} ?? (result[0] as unknown as ${ctxSingular})
+      ${ctxCamelSingular}: restored${ctxSingular} ?? to${ctxSingular}(result[0])
     }
   } catch (error) {
     console.error('Error restoring ${ctxSingularText} version:', error)
@@ -11234,7 +11397,7 @@ ${restoreM2MContent}
 function renderGenRestoreContentTemplate({ ctxSingular }) {
   return `{
       ...lifecycleContext,
-      data: (restored${ctxSingular} ?? result[0]) as unknown as Record<string, unknown>
+      data: restored${ctxSingular} ?? to${ctxSingular}(result[0])
     }`;
 }
 function renderGenRestoreContentRenderer(request) {
@@ -11300,7 +11463,7 @@ function genRestoreContent(ctx) {
       metadata: { restoredFromVersion: versionRow.version }`
   );
   const snapshotImport = ctx.hasM2M ? `build${ctx.Singular}VersionSnapshotWithRelationships` : `build${ctx.Singular}VersionSnapshot`;
-  const currentSnapshot = ctx.hasM2M ? `await build${ctx.Singular}VersionSnapshotWithRelationships(currentRow as unknown as ${ctx.Singular}, tx)` : `build${ctx.Singular}VersionSnapshot(currentRow as unknown as ${ctx.Singular})`;
+  const currentSnapshot = ctx.hasM2M ? `await build${ctx.Singular}VersionSnapshotWithRelationships(currentRow, tx)` : `build${ctx.Singular}VersionSnapshot(currentRow)`;
   const dbImports = [
     "entityVersions",
     ctx.tableVar,
@@ -11467,10 +11630,11 @@ import {
   is${ctxSingular}SlugConflict,
   resolveUnique${ctxSingular}Slug,
   ${snapshotImport},
-  has${ctxSingular}VersionChanges
+  has${ctxSingular}VersionChanges,
+  to${ctxSingular}
 } from './helpers'
 ${lifecycleHookImport2}
-import type { ${ctxSingular}UpdateInput, ${ctxSingular}UpdateResult, ${ctxSingular} } from './types'${markdownImport}
+import type { ${ctxSingular}UpdateInput, ${ctxSingular}UpdateResult } from './types'${markdownImport}
 
 export async function update${ctxSingular}(input: ${ctxSingular}UpdateInput): Promise<${ctxSingular}UpdateResult> {
   const actor = await requireRole([UserRole.ADMIN, UserRole.EDITOR])
@@ -11531,10 +11695,7 @@ ${updateBeforePublishBlock}
           }
         }
 ${htmlUpdateBlock}
-        changedFields = getChangedFieldNames(
-          previousRow as unknown as Record<string, unknown>,
-          processedData
-        )
+        changedFields = getChangedFieldNames(previousRow, processedData)
         result = await db.transaction(async (tx) => {
           const previousSnapshot = ${previousSnapshot}
           const nextSnapshot = {
@@ -11574,7 +11735,7 @@ ${htmlUpdateBlock}
     ${ctxCacheInvalidationFn}(${ctxCamelPlural}CacheTags.byId(id))
     ${ctxCacheInvalidationFn}(entityVersionsCacheTags.for('${ctxPlural}', id))
     const updated${ctxSingular} = await get${ctxSingular}ById(id)
-    const updated${ctxSingular}Data = updated${ctxSingular} ?? (result[0] as unknown as ${ctxSingular})
+    const updated${ctxSingular}Data = updated${ctxSingular} ?? to${ctxSingular}(result[0])
     const updated${ctxSingular}Context = ${updateResultContext}
 ${updateAfterPublishBlock}
     ${afterHook2}
@@ -11596,7 +11757,7 @@ function genUpdateContent(ctx) {
   const kebabSingular = toKebabCase(ctx.singular);
   const slugSourceValue = ctx.slugSourceField ? `updateData.${ctx.slugSourceField} ?? previousRow.${ctx.slugSourceField}` : "undefined";
   const snapshotImport = ctx.hasM2M ? `build${ctx.Singular}VersionSnapshotWithRelationships` : `build${ctx.Singular}VersionSnapshot`;
-  const previousSnapshot = ctx.hasM2M ? `await build${ctx.Singular}VersionSnapshotWithRelationships(previousRow as unknown as ${ctx.Singular}, tx)` : `build${ctx.Singular}VersionSnapshot(previousRow as unknown as ${ctx.Singular})`;
+  const previousSnapshot = ctx.hasM2M ? `await build${ctx.Singular}VersionSnapshotWithRelationships(previousRow, tx)` : `build${ctx.Singular}VersionSnapshot(previousRow)`;
   const markdownImport = ctx.hasHtmlOutput ? `
 import { renderMarkdownSync } from './markdown'` : "";
   const htmlUpdateBlock = ctx.hasHtmlOutput ? `
@@ -11609,14 +11770,14 @@ import { renderMarkdownSync } from './markdown'` : "";
     ctx.plural,
     `,
       entityId: id,
-      input: updateData as unknown as Record<string, unknown>`
+      input: updateData`
   );
   const updateResultContext = lifecycleContext(
     ctx.plural,
     `,
       entityId: id,
-      input: updateData as unknown as Record<string, unknown>,
-      data: updated${ctx.Singular}Data as unknown as Record<string, unknown>,
+      input: updateData,
+      data: updated${ctx.Singular}Data,
       changedFields`
   );
   const updateBeforePublishBlock = ctx.hasDraft ? `
@@ -12132,7 +12293,7 @@ ${selects}
 
 // adapters/next/templates/renderers/generators/actions/action-helpers/build-read-select-option-type.ts
 function renderBuildReadSelectOptionTypeComponentTemplate() {
-  return `export interface SelectOptionValue {
+  return `export type SelectOptionValue = {
   label: string
   value: string
 }`;
@@ -12237,19 +12398,13 @@ ${[regularSelects, relSelects, ...extraSelects].filter(Boolean).join(",\n")}
 // adapters/next/templates/renderers/generators/actions/action-helpers/build-result-mapping.ts
 function renderBuildResultMappingResultTemplate({
   plural,
-  rowDeclarations,
   rowMappings
 }) {
   return `
 
-    const mapped${plural} = results.map((rawRow) => {
-      const row = rawRow as Record<string, unknown>
-${rowDeclarations}
-
-      return {
+    const mapped${plural} = results.map((row) => ({
 ${rowMappings}
-      }
-    })`;
+    }))`;
 }
 function renderBuildResultMappingResultDetailsTemplate({
   mapBlock,
@@ -12260,7 +12415,7 @@ function renderBuildResultMappingResultDetailsTemplate({
   return `${mapBlock}
 
     const populated${plural} = await Promise.all(
-      mapped${plural}.map(record => populate${singular}ListRelationships(record as ${singular}))
+      mapped${plural}.map((record) => populate${singular}ListRelationships(record))
     )
 
     return {
@@ -12271,13 +12426,12 @@ function renderBuildResultMappingResultDetailsTemplate({
 function renderBuildResultMappingResultDetailsBranchTemplate({
   mapBlock,
   camelPlural,
-  plural,
-  singular
+  plural
 }) {
   return `${mapBlock}
 
     return {
-      ${camelPlural}: mapped${plural} as unknown as ${singular}[],
+      ${camelPlural}: mapped${plural},
       total
     }`;
 }
@@ -12298,40 +12452,58 @@ function relationshipMappingExpression(field, valueExpression) {
   return isUserRelationshipTarget(field.relationship) ? `${valueExpression}?.id ? { id: ${valueExpression}.id, name: ${valueExpression}.name ?? undefined, email: ${valueExpression}.email ?? undefined } : null` : `${valueExpression}?.id ? { id: ${valueExpression}.id, name: ${valueExpression}.name ?? undefined, title: ${valueExpression}.title ?? undefined, slug: ${valueExpression}.slug ?? undefined, label: ${valueExpression}.label ?? undefined } : null`;
 }
 
-// adapters/next/generators/actions/action-helpers/relationship-row-type.ts
-function relationshipRowType(field) {
-  return isUserRelationshipTarget(field.relationship) ? "{ id?: string | null; name?: string | null; email?: string | null }" : "{ id?: string | null; name?: string | null; title?: string | null; slug?: string | null; label?: string | null }";
+// adapters/next/generators/actions/action-helpers/build-row-mapping-entries.ts
+function buildRowMappingEntries({
+  allDbFields,
+  htmlOutputFields,
+  includeHtmlValues,
+  m2mEntries,
+  indent
+}) {
+  const excludedHtmlSources = new Set(
+    includeHtmlValues ? [] : htmlOutputFields.map((field) => field.name)
+  );
+  const valueExpression = (field) => {
+    if (excludedHtmlSources.has(field.name)) return "null";
+    if (field.type === "relationship" && !field.multiple) {
+      return relationshipMappingExpression(field, `row.${field.name}`);
+    }
+    if (field.type === "select") {
+      return field.multiple ? `row.${field.name} ?? []` : `row.${field.name} ? [row.${field.name}] : []`;
+    }
+    return `row.${field.name}`;
+  };
+  const timestampEntries = allDbFields.some((field) => field.name === "createdAtFormatted") ? [] : [
+    `${indent}createdAtFormatted: formatActionDate(row.createdAt)`,
+    `${indent}updatedAtFormatted: formatActionDate(row.updatedAt)`
+  ];
+  return [
+    ...allDbFields.map(
+      (field) => `${indent}${quotePropertyName(field.name)}: ${valueExpression(field)}`
+    ),
+    ...htmlOutputFields.map(
+      (field) => `${indent}${field.name}Html: ${includeHtmlValues ? `row.${field.name}Html ?? ''` : "''"}`
+    ),
+    ...m2mEntries.map((entry) => `${indent}${entry}`),
+    ...timestampEntries,
+    `${indent}createdByUser: row.createdByUser?.id ? { id: row.createdByUser.id, name: row.createdByUser.name, email: row.createdByUser.email } : null`,
+    `${indent}updatedByUser: row.updatedByUser?.id ? { id: row.updatedByUser.id, name: row.updatedByUser.name, email: row.updatedByUser.email } : null`
+  ];
 }
 
 // adapters/next/generators/actions/action-helpers/build-result-mapping.ts
-function buildResultMapping(allDbFields, relationshipFields, Plural, camelPlural, Singular, hasListRels = false) {
-  const relationshipDeclarations = relationshipFields.map(
-    (f) => `      const ${f.name} = row.${f.name} as ${relationshipRowType(f)} | null | undefined`
-  ).join("\n");
-  const rowDeclarations = [
-    relationshipDeclarations,
-    `      const createdByUser = row.createdByUser as { id?: string | null; name?: string | null; email?: string | null } | null | undefined`,
-    `      const updatedByUser = row.updatedByUser as { id?: string | null; name?: string | null; email?: string | null } | null | undefined`
-  ].filter(Boolean).join("\n");
-  const mappedTimestampFields = allDbFields.some((f) => f.name === "createdAtFormatted") ? [] : [
-    `        createdAtFormatted: formatActionDate(row.createdAt)`,
-    `        updatedAtFormatted: formatActionDate(row.updatedAt)`
-  ];
-  const rowMappings = allDbFields.map((f) => {
-    if (f.type === "relationship" && !f.multiple) {
-      return `        ${f.name}: ${relationshipMappingExpression(f, f.name)}`;
-    }
-    return `        ${f.name}: row.${f.name}`;
-  }).concat([
-    ...mappedTimestampFields,
-    `        createdByUser: createdByUser?.id ? { id: createdByUser.id, name: createdByUser.name ?? '', email: createdByUser.email ?? '' } : null`,
-    `        updatedByUser: updatedByUser?.id ? { id: updatedByUser.id, name: updatedByUser.name ?? '', email: updatedByUser.email ?? '' } : null`
-  ]).join(",\n");
+function buildResultMapping(allDbFields, htmlOutputFields, includeHtmlValues, m2mEntries, Plural, camelPlural, Singular, hasListRels = false) {
+  const rowMappings = buildRowMappingEntries({
+    allDbFields,
+    htmlOutputFields,
+    includeHtmlValues,
+    m2mEntries,
+    indent: "      "
+  }).join(",\n");
   const mapBlock = renderBuildResultMappingRenderer({
     kind: "renderBuildResultMappingResultTemplate",
     props: {
       plural: Plural,
-      rowDeclarations,
       rowMappings
     }
   });
@@ -12351,41 +12523,29 @@ function buildResultMapping(allDbFields, relationshipFields, Plural, camelPlural
     props: {
       mapBlock,
       camelPlural,
-      plural: Plural,
-      singular: Singular
+      plural: Plural
     }
   });
 }
 
 // adapters/next/generators/actions/action-helpers/build-single-row-mapping.ts
-function buildSingleRowMapping(allDbFields, _relationshipFields, typeName, htmlFields = []) {
-  const fieldMappings = allDbFields.map((f) => {
-    if (f.type === "relationship" && !f.multiple) {
-      return `      ${f.name}: ${relationshipMappingExpression(f, `row.${f.name}`)}`;
-    }
-    return `      ${f.name}: row.${f.name}`;
-  });
-  const htmlMappings = htmlFields.map((f) => `      ${f.name}Html: row.${f.name}Html`);
-  const singleTimestampFields = allDbFields.some((f) => f.name === "createdAtFormatted") ? [] : [
-    `      createdAtFormatted: formatActionDate(row.createdAt)`,
-    `      updatedAtFormatted: formatActionDate(row.updatedAt)`
-  ];
-  const mappings = [
-    ...fieldMappings,
-    ...htmlMappings,
-    ...singleTimestampFields,
-    `      createdByUser: row.createdByUser?.id ? { id: row.createdByUser.id, name: row.createdByUser.name, email: row.createdByUser.email } : null`,
-    `      updatedByUser: row.updatedByUser?.id ? { id: row.updatedByUser.id, name: row.updatedByUser.name, email: row.updatedByUser.email } : null`
-  ].join(",\n");
+function buildSingleRowMapping(allDbFields, htmlOutputFields = [], m2mEntries = []) {
+  const mappings = buildRowMappingEntries({
+    allDbFields,
+    htmlOutputFields,
+    includeHtmlValues: true,
+    m2mEntries,
+    indent: "      "
+  }).join(",\n");
   return `{
 ${mappings}
-    } as unknown as ${typeName}`;
+    }`;
 }
 
 // adapters/next/generators/actions/action-helpers/collect-read-select-fields.ts
-function collectReadSelectFields(fields, path113 = []) {
+function collectReadSelectFields(fields, path114 = []) {
   const matches = fields.flatMap((field) => {
-    const currentPath = [...path113, field.name];
+    const currentPath = [...path114, field.name];
     const matches2 = field.type === "select" ? [{ field, path: currentPath }] : [];
     if (field.fields) {
       matches2.push(...collectReadSelectFields(field.fields, currentPath));
@@ -12450,21 +12610,23 @@ function renderPopulateListRelsFunctionResultTemplate({
   qRelFieldName,
   qRelTable
 }) {
-  return `  const ${v}Ids = record.${qListFieldName} && Array.isArray(record.${qListFieldName})
-    ? (record.${qListFieldName} as Record<string, unknown>[])
-        .map((item) => item.${qRelFieldName})
-        .filter((id) => id != null && id !== '')
-        .map((id) => String(id))
+  return `  const ${v}Items = Array.isArray(source.${qListFieldName})
+    ? source.${qListFieldName}.filter(isRecord)
     : []
 
+  const ${v}Ids = ${v}Items
+    .map((item) => item.${qRelFieldName})
+    .filter((id) => id != null && id !== '')
+    .map((id) => String(id))
+
   const ${v}Results = ${v}Ids.length > 0
     ? await db.select().from(${qRelTable}).where(inArray(${qRelTable}.id, ${v}Ids))
     : []
 
   const ${v}Map = new Map(${v}Results.map((r) => [r.id, r]))
 
-  if (record.${qListFieldName} && Array.isArray(record.${qListFieldName})) {
-    record.${qListFieldName} = (record.${qListFieldName} as Record<string, unknown>[]).map((item) => {
+  if (${v}Items.length > 0) {
+    source.${qListFieldName} = ${v}Items.map((item) => {
       const relId = item.${qRelFieldName} ? String(item.${qRelFieldName}) : null
       return {
         ...item,
@@ -12478,7 +12640,10 @@ function renderPopulateListRelsFunctionContentTemplate({
   join
 }) {
   return `
-async function populate${singular}ListRelationships(record: ${singular}): Promise<${singular}> {
+async function populate${singular}ListRelationships<Row extends Record<string, unknown>>(
+  record: Row
+): Promise<Row> {
+  const source: Record<string, unknown> = record
 ${join}
 
   return record
@@ -12952,6 +13117,7 @@ function buildEntityContext(schema, nextMajorVersion) {
   const hasCreatableSelectFields = creatableSelectFields.length > 0;
   const selectFields = collectReadSelectFields(allDbFields);
   const hasSelectFields = selectFields.length > 0;
+  const hasNestedSelectFields = selectFields.some((readField) => readField.path.length > 1);
   const dateRangeFilterFields = new Set(
     resolvedFilters.filter((filter) => filter.type === "date-range").map((filter) => filter.field)
   );
@@ -12995,19 +13161,31 @@ import type { AdminMedia } from '@admin/types'
   const timestampFields = hasTimestampFields && !hasFormattedTimestampFields ? "\n  createdAtFormatted: string\n  updatedAtFormatted: string" : "";
   const readSelectOptionType = buildReadSelectOptionType(selectFields);
   const relationshipDataTypes = buildRelationshipDataTypes(allDbFields);
+  const mediaCompanionKeys = [...mediaFields, ...galleryFields].map((f) => JSON.stringify(`${f.name}Media`)).join(" | ");
+  const mediaResolvableType = hasMediaFields ? `
+
+export type ${Singular}MediaResolvable = Omit<${Singular}, ${mediaCompanionKeys}>` : "";
+  const selectResolvableBase = hasMediaFields ? `${Singular}MediaResolvable` : Singular;
+  const topLevelSelectKeys = selectFields.map((readField) => JSON.stringify(readField.path[0])).join(" | ");
+  const selectResolvableFields = selectFields.map((readField) => `  ${quotePropertyName(readField.path[0])}: string[]`).join("\n");
+  const selectResolvableType = hasSelectFields && !hasNestedSelectFields ? `
+
+export type ${Singular}SelectResolvable = Omit<${selectResolvableBase}, ${topLevelSelectKeys}> & {
+${selectResolvableFields}
+}` : "";
   const dataInterface = `${mediaTypeImport}${buildAuthorshipUserType()}${readSelectOptionType ? `
 
 ${readSelectOptionType}` : ""}${relationshipDataTypes ? `
 
 ${relationshipDataTypes}` : ""}
 
-export interface ${Singular} {
+export type ${Singular} = {
 ${dataFields}${htmlFieldTypes ? `
 ${htmlFieldTypes}` : ""}${m2mFieldTypes ? `
 ${m2mFieldTypes}` : ""}${mediaCompanionTypes ? `
 ${mediaCompanionTypes}` : ""}${timestampFields}
 ${buildAuthorshipDataFields()}
-}`;
+}${mediaResolvableType}${selectResolvableType}`;
   const responseInterface = `export interface ${Plural}Page {
   ${camelPlural}: ${Singular}[]
   total: number
@@ -13033,12 +13211,12 @@ ${filtersInterfaceFields}
   const createInterfaceFields = createFields.map(
     (f) => `  ${quotePropertyName(f.name)}${f.required && f.name !== "slug" ? "" : "?"}: ${getInputFieldType(f)}`
   ).join("\n");
-  const createInterface = `export interface ${Singular}CreateInput {
+  const createInterface = `export type ${Singular}CreateInput = {
 ${createInterfaceFields}${hasDraft ? `
   published?: boolean` : ""}
 }`;
   const updateInterfaceFields = createFields.map((f) => `  ${quotePropertyName(f.name)}?: ${getInputFieldType(f)}`).join("\n");
-  const updateInterface = `export interface ${Singular}UpdateInput {
+  const updateInterface = `export type ${Singular}UpdateInput = {
   id: string
 ${updateInterfaceFields}${hasDraft ? `
   published?: boolean` : ""}
@@ -13096,9 +13274,12 @@ ${searchFields.map((f) => `          ilike(${tableVar}.${f}, searchTerm)`).join(
       )
     }
 ` : "";
+  const m2mMappingEntries = m2mFields.map((f) => `${quotePropertyName(f.name)}: []`);
   const baseResultMapping = buildResultMapping(
     allDbFields,
-    relationshipFields,
+    htmlOutputFields,
+    true,
+    m2mMappingEntries,
     Plural,
     camelPlural,
     Singular,
@@ -13107,8 +13288,10 @@ ${searchFields.map((f) => `          ilike(${tableVar}.${f}, searchTerm)`).join(
   const selectResultMapping = hasSelectFields ? wrapWithSelectResolution(baseResultMapping, camelPlural, Singular) : baseResultMapping;
   const resultMapping = hasMediaFields ? wrapWithMediaResolution(selectResultMapping, camelPlural, Singular) : selectResultMapping;
   const baseListResultMapping = hasHtmlOutput ? buildResultMapping(
-    listDbFields,
-    relationshipFields,
+    allDbFields,
+    htmlOutputFields,
+    false,
+    m2mMappingEntries,
     Plural,
     camelPlural,
     Singular,
@@ -13123,12 +13306,7 @@ ${searchFields.map((f) => `          ilike(${tableVar}.${f}, searchTerm)`).join(
   const htmlCreateMappings = htmlOutputFields.map((f) => `      ${f.name}Html`).join(",\n");
   const cacheTag = `${plural}:all`;
   const baseSingleRowReturn = (() => {
-    const singleRowMapping = buildSingleRowMapping(
-      allDbFields,
-      relationshipFields,
-      Singular,
-      htmlOutputFields
-    );
+    const singleRowMapping = buildSingleRowMapping(allDbFields, htmlOutputFields, m2mMappingEntries);
     if (hasRelationships && hasListRels) {
       return `const row = result[0]
     return await populate${Singular}ListRelationships(${singleRowMapping})`;
@@ -13180,12 +13358,14 @@ ${searchFields.map((f) => `          ilike(${tableVar}.${f}, searchTerm)`).join(
     hasSearch,
     hasFilters,
     hasSelectFields,
+    hasNestedSelectFields,
     hasCreatableSelectFields,
     searchFields,
     htmlOutputFields,
     selectFields,
     creatableSelectFields,
     m2mFields,
+    allDbFields,
     filterableFields,
     relTableImports,
     listRelTableImports,
@@ -13968,7 +14148,7 @@ function renderFirstColumnDefLayoutGenerateAuthorshipValueTemplate({
             aria-label="Select row"
           />
           {label ? (
-            <span className="text-sm font-medium truncate max-w-[300px]" title={actor?.email}>
+            <span className="text-sm font-medium truncate max-w-table-cell" title={actor?.email}>
               {label}
             </span>
           ) : (
@@ -14079,7 +14259,7 @@ function renderEmailColumnCell({ columnAccessorKey }) {
             onCheckedChange={(value) => row.toggleSelected(!!value)}
             aria-label="Select row"
           />
-          <span className="text-sm font-medium truncate max-w-[300px]">{email}</span>
+          <span className="text-sm font-medium truncate max-w-table-cell">{email}</span>
         </div>
       )
     }`;
@@ -14168,7 +14348,7 @@ function renderSelectLabelCell({
             onCheckedChange={(value) => row.toggleSelected(!!value)}
             aria-label="Select row"
           />
-          <span className="truncate max-w-[300px]">
+          <span className="truncate max-w-table-cell">
             {label || 'Unavailable'}
           </span>
         </div>
@@ -14189,7 +14369,7 @@ function renderRelationshipLabelCell({
             onCheckedChange={(value) => row.toggleSelected(!!value)}
             aria-label="Select row"
           />
-          <span className="truncate max-w-[300px]">
+          <span className="truncate max-w-table-cell">
             {label || 'Unavailable'}
           </span>
         </div>
@@ -14206,7 +14386,7 @@ function renderPlainValueCell({ columnAccessorKey }) {
             onCheckedChange={(value) => row.toggleSelected(!!value)}
             aria-label="Select row"
           />
-          <span className="truncate max-w-[300px]">
+          <span className="truncate max-w-table-cell">
             {value === null || value === undefined ? 'Unavailable' : String(value)}
           </span>
         </div>
@@ -15592,6 +15772,119 @@ function buildDefaultValues2(flatFields, dataSource = "initialData", sourceField
   }).join(",\n");
 }
 
+// adapters/next/generators/form/field-jsx-nested/empty-nested-field-value.ts
+function emptyNestedFieldValue(field) {
+  if ((field.type === "group" || field.type === "section") && field.fields?.length) {
+    return objectValueForFields(field.fields);
+  }
+  if (field.type === "list" || field.type === "gallery") return "[]";
+  if (field.type === "relationship" && field.multiple) return "[]";
+  if (field.type === "select" && field.multiple) return "[]";
+  if (field.type === "boolean") return "false";
+  if (field.type === "number" || field.type === "decimal") return field.required ? "0" : "undefined";
+  return "''";
+}
+
+// adapters/next/generators/form/field-jsx-nested/object-entries-for-fields.ts
+function objectEntriesForFields(fields) {
+  return fields.flatMap((field) => {
+    const entries = [`${quotePropertyName(field.name)}: ${emptyNestedFieldValue(field)}`];
+    if (field.hasIcon) {
+      entries.push(`${quotePropertyName(`${field.name}Icon`)}: ''`);
+    }
+    return entries;
+  });
+}
+
+// adapters/next/generators/form/field-jsx-nested/object-value-for-fields.ts
+function objectValueForFields(fields) {
+  return `{${objectEntriesForFields(fields).join(", ")}}`;
+}
+
+// adapters/next/generators/form/field-jsx-nested/required-leaf-paths.ts
+function requiredLeafPaths(fields, prefix = []) {
+  return fields.flatMap((field) => {
+    if (field.hidden) return [];
+    const path114 = [...prefix, field.name];
+    if ((field.type === "group" || field.type === "section") && field.fields?.length) {
+      return requiredLeafPaths(field.fields, path114);
+    }
+    if (field.required) return [path114.join(".")];
+    return [];
+  });
+}
+
+// adapters/next/generators/form/field-jsx-nested/validation-trigger-expression.ts
+function validationTriggerExpression(basePath, requiredPaths) {
+  if (requiredPaths.length === 0) return `\`${basePath}.\${expandedIndex}\` as never`;
+  const paths = requiredPaths.map((path114) => `\`${basePath}.\${expandedIndex}.${path114}\``).join(", ");
+  return `[${paths}] as never`;
+}
+
+// adapters/next/templates/renderers/generators/form/form-shared/build-list-field-handlers.ts
+function renderListFieldHandlersTemplate({
+  fieldName,
+  pascalFieldName,
+  itemName,
+  validateExpandedItemExpression,
+  defaultItem
+}) {
+  return `  async function isExpanded${itemName}Valid() {
+    if (!${fieldName}Expanded) return true
+
+    const expandedIndex = Number(${fieldName}Expanded.replace('item-', '')) - 1
+    if (expandedIndex < 0) return true
+
+    return form.trigger(${validateExpandedItemExpression})
+  }
+
+  async function add${itemName}() {
+    if (!(await isExpanded${itemName}Valid())) return
+
+    ${fieldName}FieldArray.append(${defaultItem})
+    set${pascalFieldName}Expanded(\`item-\${${fieldName}FieldArray.fields.length + 1}\`)
+  }
+
+  async function changeExpanded${itemName}(nextValue: string[]) {
+    const nextExpanded = nextValue[0] ?? ''
+    const needsValidation = Boolean(${fieldName}Expanded && nextExpanded && nextExpanded !== ${fieldName}Expanded)
+    if (needsValidation && !(await isExpanded${itemName}Valid())) return
+
+    set${pascalFieldName}Expanded(nextExpanded)
+  }
+
+  function remove${itemName}(index: number) {
+    if (isPending) return
+    ${fieldName}FieldArray.remove(index)
+  }`;
+}
+
+// adapters/next/generators/form/form-shared/build-list-field-handlers.ts
+function buildListFieldHandlers(fields) {
+  return fields.map((field) => {
+    const itemName = toPascalCase(singularize(field.name));
+    const pascalFieldName = toPascalCase(field.name);
+    return {
+      names: [
+        `isExpanded${itemName}Valid`,
+        `add${itemName}`,
+        `changeExpanded${itemName}`,
+        `remove${itemName}`
+      ],
+      source: renderListFieldHandlersTemplate({
+        fieldName: field.name,
+        pascalFieldName,
+        itemName,
+        validateExpandedItemExpression: validationTriggerExpression(
+          field.name,
+          requiredLeafPaths(field.fields ?? [])
+        ),
+        defaultItem: objectValueForFields(field.fields ?? [])
+      })
+    };
+  });
+}
+
 // adapters/next/templates/renderers/generators/form/form-shared/build-ui-imports.ts
 function renderBuildUiImportsImportsTemplate({ join }) {
   return `import {
@@ -16071,7 +16364,7 @@ function renderFormLayoutDetailsBranchTemplate() {
               className={cn(
                 'grid grid-cols-1 gap-4 items-start h-full',
                 {
-                  'grid-cols-[1fr_360px]': hasVisibleSidebarFields
+                  'grid-cols-entity-form': hasVisibleSidebarFields
                 }
               )}
             >`;
@@ -16120,6 +16413,7 @@ function renderFormClientModuleTemplate({
   specComponentName,
   hookName,
   tabStateDestructure,
+  listFieldHandlers,
   body
 }) {
   return `'use client'
@@ -16131,7 +16425,7 @@ interface ${specComponentName}Props {
 }
 
 export function ${specComponentName}({ state }: ${specComponentName}Props) {
-${tabStateDestructure}  return (
+${tabStateDestructure}${listFieldHandlers}  return (
 ${body}
   )
 }
@@ -16145,6 +16439,7 @@ function renderEntityFormContent({
   topLevelTabsFieldTabTab,
   contentStateDestructure,
   contentSidebarVisibilityState,
+  listFieldHandlers,
   schemaName,
   hasDraftInitialData,
   topLevelTabsFieldClassName,
@@ -16163,7 +16458,7 @@ export function ${contentComponentName}({ state${topLevelTabsFieldTabTab} }: ${c
   const {
 ${contentStateDestructure}
   } = state
-${contentSidebarVisibilityState}
+${contentSidebarVisibilityState}${listFieldHandlers}
   return (
     <Form {...form}>
       <form autoComplete="off" id="${schemaName}-form" onSubmit={form.handleSubmit((values) => onSubmit(values${hasDraftInitialData}), handleErrors)} ${topLevelTabsFieldClassName}>
@@ -16231,7 +16526,7 @@ function renderFormStaticOptionsTemplate({
   return `  const [${fieldName}Open, set${fieldPascal}Open] = React.useState(false)
   const [${fieldName}Search, set${fieldPascal}Search] = React.useState('')
   const [create${fieldPascal}OptionPending, startCreate${fieldPascal}OptionTransition] = React.useTransition()
-  const { data: ${fieldName}CreatedOptions = [] as ${singular}SelectOption[] } = useQuery<${singular}SelectOption[]>({
+  const { data: ${fieldName}CreatedOptions = [] } = useQuery<${singular}SelectOption[]>({
     queryKey: ['${schemaName}', 'select-options', '${fieldName}'],
     queryFn: () => get${singular}SelectOptions('${fieldName}')
   })
@@ -16730,8 +17025,16 @@ function buildEntityFormArtifacts({
   hookReturnNames,
   contentStateDestructure,
   sidebarVisibilityState,
+  listFieldHandlers,
   formBodyJSX
 }) {
+  const handlersUsedIn = (body) => listFieldHandlers.filter((handler) => handler.names.some((name) => usesIdentifier(body, name))).map((handler) => handler.source).join("\n\n");
+  const withHandlerBlock = (handlers) => handlers ? `${handlers}
+
+` : "";
+  const withHandlerSection = (handlers) => handlers ? `
+${handlers}
+` : "";
   const needsCn = hasRelationship || hasSelectCombobox || shouldGuardSidebarByTab;
   const metadataOffsetConst = showMetadataWidget ? "const SCROLL_BORDER_OFFSET = 8;\n\n" : "";
   const metadataScrollState = showMetadataWidget ? "  const hasScrolled = usePageScrollThreshold(SCROLL_BORDER_OFFSET)\n" : "";
@@ -16779,7 +17082,11 @@ ${topLevelTabComponentImports}` : ""}` : renderEntityFormContentRenderer({
   });
   const contentSidebarVisibilityState = topLevelTabsField ? "" : sidebarVisibilityState;
   const topLevelTabComponentFiles = topLevelTabComponents.map((spec) => {
-    const tabStateNames = hookReturnNames.filter((name) => usesIdentifier(spec.body, name));
+    const tabListFieldHandlers = handlersUsedIn(spec.body);
+    const tabBodyWithHandlers = `${tabListFieldHandlers}${spec.body}`;
+    const tabStateNames = hookReturnNames.filter(
+      (name) => usesIdentifier(tabBodyWithHandlers, name)
+    );
     const tabStateDestructure = tabStateNames.length > 0 ? renderEntityFormContentRenderer({
       kind: "renderFormGeneratedValueTemplate",
       props: {
@@ -16803,6 +17110,7 @@ ${topLevelTabComponentImports}` : ""}` : renderEntityFormContentRenderer({
           specComponentName: spec.componentName,
           hookName,
           tabStateDestructure,
+          listFieldHandlers: withHandlerBlock(tabListFieldHandlers),
           body: spec.body
         }
       })
@@ -16818,6 +17126,7 @@ ${topLevelTabComponentImports}` : ""}` : renderEntityFormContentRenderer({
       topLevelTabsFieldTabTab: topLevelTabsField ? ", tab" : "",
       contentStateDestructure,
       contentSidebarVisibilityState,
+      listFieldHandlers: withHandlerSection(handlersUsedIn(formBodyJSX)),
       schemaName: schema.name,
       hasDraftInitialData: hasDraft ? ", initialData?.published ?? false" : "",
       topLevelTabsFieldClassName: topLevelTabsField ? 'className="h-full"' : 'className="space-y-6 h-full"',
@@ -16886,9 +17195,7 @@ function renderListFieldCardContentTemplate({
   formItemProps: formItemProps2,
   fieldName,
   toLowerCase,
-  validateExpandedItemExpression,
-  defaultItem,
-  pascalFieldName,
+  itemName,
   singularLabel,
   fieldLabelFieldLabel,
   label,
@@ -16905,17 +17212,7 @@ ${indent}        <p>No ${toLowerCase} added yet.</p>
 ${indent}        <Button
 ${indent}          type="button"
 ${indent}          variant="outline"
-${indent}          onClick={async () => {
-${indent}            if (${fieldName}Expanded) {
-${indent}              const expandedIndex = Number(${fieldName}Expanded.replace('item-', '')) - 1
-${indent}              if (expandedIndex >= 0) {
-${indent}                const isExpandedItemValid = await form.trigger(${validateExpandedItemExpression})
-${indent}                if (!isExpandedItemValid) return
-${indent}              }
-${indent}            }
-${indent}            ${fieldName}FieldArray.append(${defaultItem})
-${indent}            set${pascalFieldName}Expanded(\`item-\${${fieldName}FieldArray.fields.length + 1}\`)
-${indent}          }}
+${indent}          onClick={add${itemName}}
 ${indent}          disabled={isPending}
 ${indent}        >
 ${indent}          <Plus className="size-3" />
@@ -16940,17 +17237,7 @@ ${indent}        />
 ${indent}        <Button
 ${indent}          type="button"
 ${indent}          variant="outline"
-${indent}          onClick={async () => {
-${indent}            if (${fieldName}Expanded) {
-${indent}              const expandedIndex = Number(${fieldName}Expanded.replace('item-', '')) - 1
-${indent}              if (expandedIndex >= 0) {
-${indent}                const isExpandedItemValid = await form.trigger(${validateExpandedItemExpression})
-${indent}                if (!isExpandedItemValid) return
-${indent}              }
-${indent}            }
-${indent}            ${fieldName}FieldArray.append(${defaultItem})
-${indent}            set${pascalFieldName}Expanded(\`item-\${${fieldName}FieldArray.fields.length + 1}\`)
-${indent}          }}
+${indent}          onClick={add${itemName}}
 ${indent}          disabled={isPending${fieldMaxItemsFieldName}}
 ${indent}        >
 ${indent}          <Plus className="size-3" />
@@ -16960,17 +17247,7 @@ ${indent}      </div>
 
 ${indent}      <Accordion
 ${indent}        value={${fieldName}Expanded ? [${fieldName}Expanded] : []}
-${indent}        onValueChange={async (nextValue) => {
-${indent}          const nextExpanded = nextValue[0] ?? ''
-${indent}          if (${fieldName}Expanded && nextExpanded && nextExpanded !== ${fieldName}Expanded) {
-${indent}            const expandedIndex = Number(${fieldName}Expanded.replace('item-', '')) - 1
-${indent}            if (expandedIndex >= 0) {
-${indent}              const isExpandedItemValid = await form.trigger(${validateExpandedItemExpression})
-${indent}              if (!isExpandedItemValid) return
-${indent}            }
-${indent}          }
-${indent}          set${pascalFieldName}Expanded(nextExpanded)
-${indent}        }}
+${indent}        onValueChange={changeExpanded${itemName}}
 ${indent}      >
 ${indent}        {${fieldName}FieldArray.fields.map((item, index) => (
 ${indent}          <AccordionItem key={item.id} value={\`item-\${index + 1}\`}>
@@ -16984,10 +17261,7 @@ ${indent}                variant="ghost"
 ${indent}                size="icon-sm"
 ${indent}                className="absolute right-10 top-1/2 -translate-y-1/2 shrink-0"
 ${indent}                aria-label="Remove ${singularLabel}"
-${indent}                onClick={() => {
-${indent}                  if (isPending) return
-${indent}                  ${fieldName}FieldArray.remove(index)
-${indent}                }}
+${indent}                onClick={() => remove${itemName}(index)}
 ${indent}                disabled={isPending}
 ${indent}              >
 ${indent}                <X />
@@ -17034,35 +17308,6 @@ function findTitlePath(fields) {
   return null;
 }
 
-// adapters/next/generators/form/field-jsx-nested/empty-nested-field-value.ts
-function emptyNestedFieldValue(field) {
-  if ((field.type === "group" || field.type === "section") && field.fields?.length) {
-    return objectValueForFields(field.fields);
-  }
-  if (field.type === "list" || field.type === "gallery") return "[]";
-  if (field.type === "relationship" && field.multiple) return "[]";
-  if (field.type === "select" && field.multiple) return "[]";
-  if (field.type === "boolean") return "false";
-  if (field.type === "number" || field.type === "decimal") return field.required ? "0" : "undefined";
-  return "''";
-}
-
-// adapters/next/generators/form/field-jsx-nested/object-entries-for-fields.ts
-function objectEntriesForFields(fields) {
-  return fields.flatMap((field) => {
-    const entries = [`${quotePropertyName(field.name)}: ${emptyNestedFieldValue(field)}`];
-    if (field.hasIcon) {
-      entries.push(`${quotePropertyName(`${field.name}Icon`)}: ''`);
-    }
-    return entries;
-  });
-}
-
-// adapters/next/generators/form/field-jsx-nested/object-value-for-fields.ts
-function objectValueForFields(fields) {
-  return `{${objectEntriesForFields(fields).join(", ")}}`;
-}
-
 // adapters/next/generators/form/form-shared/has-visible-label.ts
 function hasVisibleLabel(field) {
   return typeof field.label === "string" ? field.label.trim().length > 0 : Boolean(field.label);
@@ -17238,16 +17483,16 @@ function renderNestedFieldRenderer(request) {
 }
 
 // adapters/next/generators/form/field-jsx-nested/path-expression.ts
-function pathExpression(path113) {
-  return `\`${path113.map((part) => typeof part === "string" ? part : `\${${part.expression}}`).join(".")}\``;
+function pathExpression(path114) {
+  return `\`${path114.map((part) => typeof part === "string" ? part : `\${${part.expression}}`).join(".")}\``;
 }
 
 // adapters/next/generators/form/field-jsx-nested/path-name-prop.ts
-function pathNameProp(path113) {
-  if (path113.every((part) => typeof part === "string")) {
-    return `"${path113.map((part) => part).join(".")}"`;
+function pathNameProp(path114) {
+  if (path114.every((part) => typeof part === "string")) {
+    return `"${path114.map((part) => part).join(".")}"`;
   }
-  return `{${pathExpression(path113)}}`;
+  return `{${pathExpression(path114)}}`;
 }
 
 // adapters/next/templates/renderers/generators/form/field-jsx-nested/render-nested-object-list-field.ts
@@ -17301,21 +17546,8 @@ function renderNestedObjectListFieldRenderer(request) {
   throw new Error("Unsupported renderer request");
 }
 
-// adapters/next/generators/form/field-jsx-nested/required-leaf-paths.ts
-function requiredLeafPaths(fields, prefix = []) {
-  return fields.flatMap((field) => {
-    if (field.hidden) return [];
-    const path113 = [...prefix, field.name];
-    if ((field.type === "group" || field.type === "section") && field.fields?.length) {
-      return requiredLeafPaths(field.fields, path113);
-    }
-    if (field.required) return [path113.join(".")];
-    return [];
-  });
-}
-
 // adapters/next/generators/form/field-jsx-nested/render-nested-object-list-field.ts
-function renderNestedObjectListField(field, indent, label, path113, depth) {
+function renderNestedObjectListField(field, indent, label, path114, depth) {
   const singularLabel = singularize(label);
   const itemIndexVar = `${safeIdentifier(field.name, "nestedList")}Index${depth}`;
   const titlePath = findTitlePath(field.fields ?? []);
@@ -17325,7 +17557,7 @@ function renderNestedObjectListField(field, indent, label, path113, depth) {
     props: {
       indent,
       itemIndexVar,
-      pathString: path113.map((part) => typeof part === "string" ? part : `\${${part.expression}}`).join("."),
+      pathString: path114.map((part) => typeof part === "string" ? part : `\${${part.expression}}`).join("."),
       titlePathSuffix,
       singularLabel
     }
@@ -17334,7 +17566,7 @@ function renderNestedObjectListField(field, indent, label, path113, depth) {
     (child) => renderNestedField(
       child,
       `${indent}      `,
-      [...path113, { expression: itemIndexVar }, child.name],
+      [...path114, { expression: itemIndexVar }, child.name],
       depth + 1
     )
   ).filter(Boolean).join("\n");
@@ -17352,7 +17584,7 @@ ${indent}  validatePaths={${JSON.stringify(validatePaths)}}` : "";
     kind: "renderNestedObjectListFieldNestedObjectListFieldTemplate",
     props: {
       indent,
-      pathExpression: pathExpression(path113),
+      pathExpression: pathExpression(path114),
       stringify: JSON.stringify(label),
       stringifySerializedValue: JSON.stringify(singularLabel),
       defaultItem,
@@ -17391,10 +17623,10 @@ ${indent}/>`;
 }
 
 // adapters/next/generators/form/field-jsx-nested/render-text-input-field.ts
-function renderTextInputField(field, indent, label, nestedHint, path113) {
+function renderTextInputField(field, indent, label, nestedHint, path114) {
   return renderTextInputFieldFormFieldTemplate({
     indent,
-    pathNameProp: pathNameProp(path113),
+    pathNameProp: pathNameProp(path114),
     formItemProps: formItemProps(field),
     labelWithDescription: labelWithDescription(
       formLabel(field, label),
@@ -17406,11 +17638,11 @@ function renderTextInputField(field, indent, label, nestedHint, path113) {
 }
 
 // adapters/next/generators/form/field-jsx-nested/render-nested-field.ts
-function renderNestedField(field, indent, path113, depth) {
+function renderNestedField(field, indent, path114, depth) {
   const nestedLabel = field.label || field.name;
   const nestedHint = field.hint ? `<FormDescription>${field.hint}</FormDescription>` : "";
   if ((field.type === "group" || field.type === "section") && field.fields?.length) {
-    const groupFields = field.fields.map((child) => renderNestedField(child, `${indent}    `, [...path113, child.name], depth)).filter(Boolean).join("\n");
+    const groupFields = field.fields.map((child) => renderNestedField(child, `${indent}    `, [...path114, child.name], depth)).filter(Boolean).join("\n");
     if (!groupFields) return "";
     const heading = nestedLabel && nestedLabel !== field.name ? `${indent}<h3 className="text-base font-medium">${nestedLabel}</h3>
 ` : "";
@@ -17426,7 +17658,7 @@ function renderNestedField(field, indent, path113, depth) {
     });
   }
   if (field.type === "list" && field.fields?.length) {
-    return renderNestedObjectListField(field, indent, nestedLabel, path113, depth);
+    return renderNestedObjectListField(field, indent, nestedLabel, path114, depth);
   }
   if (field.type === "list") {
     const hideLabelProp = field.label ? "" : `
@@ -17437,7 +17669,7 @@ ${indent}  description={${JSON.stringify(field.hint)}}` : "";
       kind: "renderNestedFieldDynamicListFieldTemplate",
       props: {
         indent,
-        pathExpression: pathExpression(path113),
+        pathExpression: pathExpression(path114),
         nestedLabel,
         hideLabelProp,
         descriptionProp,
@@ -17451,7 +17683,7 @@ ${indent}  maxItems={${field.maxItems}}` : ""
       kind: "renderNestedFieldFormFieldTemplate",
       props: {
         indent,
-        pathNameProp: pathNameProp(path113),
+        pathNameProp: pathNameProp(path114),
         formItemProps: formItemProps(field, "flex flex-row items-start space-x-3 space-y-0"),
         labelWithDescription: labelWithDescription(
           `<FormLabel>${nestedLabel}</FormLabel>`,
@@ -17467,7 +17699,7 @@ ${indent}  maxItems={${field.maxItems}}` : ""
       kind: "renderNestedFieldFormFieldDetailsTemplate",
       props: {
         indent,
-        pathNameProp: pathNameProp(path113),
+        pathNameProp: pathNameProp(path114),
         formItemProps: formItemProps(field),
         labelWithDescription: labelWithDescription(
           formLabel(field, nestedLabel),
@@ -17483,7 +17715,7 @@ ${indent}  maxItems={${field.maxItems}}` : ""
       kind: "renderNestedFieldFormFieldDetailsBranchTemplate",
       props: {
         indent,
-        pathNameProp: pathNameProp(path113),
+        pathNameProp: pathNameProp(path114),
         formItemProps: formItemProps(field),
         labelWithDescription: labelWithDescription(
           formLabel(field, nestedLabel),
@@ -17501,7 +17733,7 @@ ${indent}  maxItems={${field.maxItems}}` : ""
       kind: "renderNestedFieldFormFieldDetailsBranchBodyTemplate",
       props: {
         indent,
-        pathNameProp: pathNameProp(path113),
+        pathNameProp: pathNameProp(path114),
         formItemProps: formItemProps(field),
         labelWithDescription: labelWithDescription(
           formLabel(field, nestedLabel),
@@ -17514,14 +17746,7 @@ ${indent}  maxItems={${field.maxItems}}` : ""
       }
     });
   }
-  return renderTextInputField(field, indent, nestedLabel, nestedHint, path113);
-}
-
-// adapters/next/generators/form/field-jsx-nested/validation-trigger-expression.ts
-function validationTriggerExpression(basePath, requiredPaths) {
-  if (requiredPaths.length === 0) return `\`${basePath}.\${expandedIndex}\` as never`;
-  const paths = requiredPaths.map((path113) => `\`${basePath}.\${expandedIndex}.${path113}\``).join(", ");
-  return `[${paths}] as never`;
+  return renderTextInputField(field, indent, nestedLabel, nestedHint, path114);
 }
 
 // adapters/next/generators/form/field-jsx-nested/render-list-field.ts
@@ -17546,7 +17771,7 @@ ${indent}  maxItems={${field.maxItems}}` : ""
     });
   }
   const singularLabel = singularize(label);
-  const pascalFieldName = toPascalCase(field.name);
+  const itemName = toPascalCase(singularize(field.name));
   const titlePath = findTitlePath(field.fields);
   const accordionTitle = titlePath ? `{String(form.watch(\`${field.name}.\${index}.${titlePath.join(".")}\` as never) || \`${singularLabel} \${index + 1}\`)}` : `${singularLabel} {index + 1}`;
   const nestedFieldsJSX = field.fields.map(
@@ -17557,11 +17782,6 @@ ${indent}  maxItems={${field.maxItems}}` : ""
       0
     )
   ).join("\n");
-  const defaultItem = objectValueForFields(field.fields);
-  const validateExpandedItemExpression = validationTriggerExpression(
-    field.name,
-    requiredLeafPaths(field.fields)
-  );
   return renderListFieldRenderer({
     kind: "renderListFieldCardContentTemplate",
     props: {
@@ -17569,9 +17789,7 @@ ${indent}  maxItems={${field.maxItems}}` : ""
       formItemProps: formItemProps(field),
       fieldName: field.name,
       toLowerCase: label.toLowerCase(),
-      validateExpandedItemExpression,
-      defaultItem,
-      pascalFieldName,
+      itemName,
       singularLabel,
       fieldLabelFieldLabel: field.label ? "text-foreground" : "sr-only",
       label,
@@ -18019,7 +18237,7 @@ function renderMarkdownField(field, indent, label, hintJSX, context) {
         `${indent}      `
       ),
       onChange,
-      fillControlClass: fillControlClass(field, "min-h-[300px]"),
+      fillControlClass: fillControlClass(field, "min-h-entity-editor"),
       toLowerCase: label.toLowerCase()
     }
   });
@@ -18467,7 +18685,7 @@ function renderRichtextField(field, indent, label, hintJSX, context) {
         `${indent}      `
       ),
       onChange,
-      fillControlClass: fillControlClass(field, "min-h-[300px]"),
+      fillControlClass: fillControlClass(field, "min-h-entity-editor"),
       toLowerCase: label.toLowerCase()
     }
   });
@@ -19385,7 +19603,7 @@ function buildEntityFormLayout({
     return renderEntityFormContentRenderer({
       kind: "renderFormCardContentGridTemplate",
       props: {
-        tabSidebarEntriesGrid: tabSidebarEntries.length > 0 ? "grid-cols-[1fr_360px]" : "grid-cols-1",
+        tabSidebarEntriesGrid: tabSidebarEntries.length > 0 ? "grid-cols-entity-form" : "grid-cols-1",
         tabMainFieldsJsx: tabMainFieldsJSX,
         sidebarColumn
       }
@@ -19441,7 +19659,7 @@ function buildEntityFormLayout({
   const sidebarVisibilityState = shouldGuardSidebarByTab ? `
   const hasVisibleSidebarFields = ${sidebarTabNames.map((tabName) => `activeTab === ${JSON.stringify(tabName)}`).join(" || ")}
 ` : "";
-  const formGridOpen = shouldGuardSidebarByTab ? renderEntityFormContentRenderer({ kind: "renderFormLayoutDetailsBranchTemplate" }) : `            <div className="grid ${hasSidebarFields ? "grid-cols-[1fr_360px]" : "grid-cols-1"} gap-4 items-start h-full">`;
+  const formGridOpen = shouldGuardSidebarByTab ? renderEntityFormContentRenderer({ kind: "renderFormLayoutDetailsBranchTemplate" }) : `            <div className="grid ${hasSidebarFields ? "grid-cols-entity-form" : "grid-cols-1"} gap-4 items-start h-full">`;
   const sidebarCardJSX = !hasSidebarFields ? "" : shouldGuardSidebarByTab ? renderEntityFormContentRenderer({
     kind: "renderFormContentSidebarColumnTemplate",
     props: {
@@ -19943,6 +20161,7 @@ ${fieldArrayHooks}
     hookReturnNames,
     contentStateDestructure,
     sidebarVisibilityState,
+    listFieldHandlers: buildListFieldHandlers(listFieldsWithNested),
     formBodyJSX
   });
 }
@@ -21649,12 +21868,7 @@ ${hasEdit ? "  const router = useRouter()\n" : ""}  const [{
 }
 function renderTableRowClickHandler({ editRoutePath }) {
   return `
-                onClick={(e) => {
-                  const target = e.target as HTMLElement
-                  if (!e.currentTarget.contains(target)) return
-                  if (target.closest('button, a, input, [role="checkbox"]')) return
-                  router.push(\`${editRoutePath}/\${row.original.id}/edit\`)
-                }}`;
+                onActivate={() => router.push(\`${editRoutePath}/\${row.original.id}/edit\`)}`;
 }
 function renderTableRenderer(request) {
   switch (request.kind) {
@@ -21880,7 +22094,6 @@ function renderSingleActionsServerActionTemplate({
   hasSelectFieldsSelectOptionValue,
   authorshipAliasBlock,
   singletonId,
-  formatActionDateSource,
   selectResolutionFunctions,
   cacheLifeLine,
   selectClause,
@@ -21897,12 +22110,11 @@ import { alias } from 'drizzle-orm/pg-core'
 ${cacheReadImport}
 import { ${cacheTagsVar} } from './types'
 import type { ${singular}${hasSelectFieldsSelectOptionValue} } from './types'
+import { formatActionDate } from '@admin/utils/date/format-action-date'
 
 ${authorshipAliasBlock}
 
 const SINGLETON_ID = '${singletonId}'
-
-${formatActionDateSource}
 ${selectResolutionFunctions}
 export async function get${singular}(): Promise<${singular} | null> {
   'use cache'${cacheLifeLine}
@@ -21967,8 +22179,9 @@ import { getChangedFieldNames } from '@admin/utils/audit/get-changed-field-names
 import { getTouchedFieldNames } from '@admin/utils/audit/get-touched-field-names'
 import { ${cacheInvalidationFn} } from 'next/cache'
 import { get${singular} } from './get-${kebabSingular}'
+import { to${singular} } from './to-${kebabSingular}'
 import { ${cacheTagsVar} } from './types'
-import type { ${singular}UpsertInput, ${singular}UpsertResult, ${singular} } from './types'${markdownImport}
+import type { ${singular}UpsertInput, ${singular}UpsertResult } from './types'${markdownImport}
 
 const SINGLETON_ID = '${singletonId}'
 
@@ -22011,7 +22224,7 @@ ${htmlUpsertBlock}
       .where(eq(${tableVar}.id, SINGLETON_ID))
       .limit(1)
     const changedFields = previousRow
-      ? getChangedFieldNames(previousRow as unknown as Record<string, unknown>, processedData)
+      ? getChangedFieldNames(previousRow, processedData)
       : getTouchedFieldNames(processedData)
 
     const lifecycleContext = {
@@ -22054,12 +22267,12 @@ ${m2mWriteStatementsContent}
     const saved${singular} = await get${singular}()
     runAfterHooks(previousRow ? 'afterUpdate' : 'afterCreate', {
       ...lifecycleContext,
-      data: (saved${singular} ?? result[0]) as unknown as Record<string, unknown>
+      data: saved${singular} ?? to${singular}(result[0])
     })
 
     return {
       success: true,
-      ${camelSingular}: saved${singular} ?? (result[0] as unknown as ${singular})
+      ${camelSingular}: saved${singular} ?? to${singular}(result[0])
     }
   } catch (error) {
     console.error('Error upserting ${singularText}:', error)
@@ -22088,6 +22301,27 @@ export { get${singular} } from './get-${kebabSingular}'
 export { upsert${singular} } from './upsert-${kebabSingular}'${selectOptionFunctionExports}
 `;
 }
+function renderSingleActionsSelectResolvableTypeTemplate({
+  singular,
+  omittedKeys,
+  resolvableFields
+}) {
+  return `export type ${singular}SelectResolvable = Omit<${singular}, ${omittedKeys}> & {
+${resolvableFields}
+}`;
+}
+function renderSingleActionsToSingleTemplate({
+  singular,
+  tableVar,
+  toEntityFunction
+}) {
+  return `import type { ${singular} } from './types'
+import type { ${tableVar} } from '@admin/db/schema'
+import { formatActionDate } from '@admin/utils/date/format-action-date'
+
+${toEntityFunction}
+`;
+}
 function renderSingleActionsSingleActionsRenderer(request) {
   switch (request.kind) {
     case "renderSingleActionsContentTemplate":
@@ -22096,6 +22330,10 @@ function renderSingleActionsSingleActionsRenderer(request) {
       return renderSingleActionsRowsTemplate(request.props);
     case "renderSingleActionsServerActionTemplate":
       return renderSingleActionsServerActionTemplate(request.props);
+    case "renderSingleActionsSelectResolvableTypeTemplate":
+      return renderSingleActionsSelectResolvableTypeTemplate(request.props);
+    case "renderSingleActionsToSingleTemplate":
+      return renderSingleActionsToSingleTemplate(request.props);
     case "renderSingleActionsContentDetailsTemplate":
       return renderSingleActionsContentDetailsTemplate(request.props);
     case "renderSingleActionsServerActionSerializedValueTemplate":
@@ -22198,6 +22436,15 @@ function generateSingleActions(schema, actionsDir, options = {}) {
     selectOptionsTableVar: `${tableVar}SelectOptions`
   };
   const relationshipDataTypes = buildRelationshipDataTypes(allDbFields);
+  const hasNestedSelectFields = selectFields.some((readField) => readField.path.length > 1);
+  const selectResolvableType = hasSelectFields && !hasNestedSelectFields ? renderSingleActionsSingleActionsRenderer({
+    kind: "renderSingleActionsSelectResolvableTypeTemplate",
+    props: {
+      singular: Singular,
+      omittedKeys: selectFields.map((readField) => JSON.stringify(readField.path[0])).join(" | "),
+      resolvableFields: selectFields.map((readField) => `  ${quotePropertyName(readField.path[0])}: string[]`).join("\n")
+    }
+  }) : null;
   const typesContent = renderSingleActionsSingleActionsRenderer({
     kind: "renderSingleActionsContentTemplate",
     props: {
@@ -22205,12 +22452,13 @@ function generateSingleActions(schema, actionsDir, options = {}) {
         buildAuthorshipUserType(),
         buildReadSelectOptionType(selectFields),
         relationshipDataTypes,
-        `export interface ${Singular} {
+        `export type ${Singular} = {
 ${dataFields}${htmlFieldTypes ? `
 ${htmlFieldTypes}` : ""}${m2mFieldTypes ? `
 ${m2mFieldTypes}` : ""}${timestampFields}
 ${buildAuthorshipDataFields()}
 }`,
+        selectResolvableType,
         `export interface ${Singular}UpsertInput {
 ${allUpsertInterfaceFields}
 }`,
@@ -22242,12 +22490,11 @@ ${allUpsertInterfaceFields}
     authorshipSelects,
     authorshipJoins
   );
-  const singleRowMapping = buildSingleRowMapping(
-    allDbFields,
-    relationshipFields,
-    `${Singular}`,
-    htmlOutputFields
-  );
+  const m2mMappingEntries = m2mFields.map((field) => {
+    const { relationIdCol } = getSingleM2MContext(schema.name, field);
+    return `${quotePropertyName(field.name)}: ${field.name}Rows.map((relationRow) => relationRow.${relationIdCol})`;
+  });
+  const singleRowMapping = buildSingleRowMapping(allDbFields, htmlOutputFields, m2mMappingEntries);
   const m2mReadQueries = m2mFields.map((field) => {
     const { junctionVar, schemaIdCol, relationIdCol } = getSingleM2MContext(schema.name, field);
     return renderSingleActionsSingleActionsRenderer({
@@ -22260,19 +22507,13 @@ ${allUpsertInterfaceFields}
       }
     });
   }).join("\n");
-  const m2mAssignments = m2mFields.map((field) => {
-    const { relationIdCol } = getSingleM2MContext(schema.name, field);
-    return `    singleRow.${field.name} = ${field.name}Rows.map((relationRow) => relationRow.${relationIdCol})`;
-  }).join("\n");
   const m2mReadBlock = hasM2M ? `
-${m2mReadQueries}
-${m2mAssignments}` : "";
-  const singleRowReturn = hasSelectFields ? `const row = result[0]
-    const singleRow = ${singleRowMapping}${m2mReadBlock}
+${m2mReadQueries}` : "";
+  const singleRowReturn = hasSelectFields ? `const row = result[0]${m2mReadBlock}
+    const singleRow = ${singleRowMapping}
     const [resolvedSelectRow] = await resolve${Singular}SelectFields([singleRow])
-    return resolvedSelectRow` : `const row = result[0]
-    const singleRow = ${singleRowMapping}${m2mReadBlock}
-    return singleRow`;
+    return resolvedSelectRow` : `const row = result[0]${m2mReadBlock}
+    return ${singleRowMapping}`;
   const relationshipTableImports = relationshipFields.filter((field) => !isUserRelationshipTarget(field.relationship)).map((field) => toCamelCase(field.relationship));
   const m2mJunctionImports = m2mFields.map(
     (field) => getSingleM2MContext(schema.name, field).junctionVar
@@ -22287,7 +22528,7 @@ ${m2mAssignments}` : "";
     ])
   ).sort();
   const selectResolutionFunctions = hasSelectFields ? `
-${generateResolveSelectFieldsSource({ Singular, selectFields, selectOptionsTableVar: `${tableVar}SelectOptions`, hasCreatableSelectFields, exported: false })}
+${generateResolveSelectFieldsSource({ Singular, selectFields, selectOptionsTableVar: `${tableVar}SelectOptions`, hasCreatableSelectFields, hasMediaFields: false, exported: false })}
 ` : "";
   const getContent = renderSingleActionsSingleActionsRenderer({
     kind: "renderSingleActionsServerActionTemplate",
@@ -22299,7 +22540,6 @@ ${generateResolveSelectFieldsSource({ Singular, selectFields, selectOptionsTable
       hasSelectFieldsSelectOptionValue: hasSelectFields ? ", SelectOptionValue" : "",
       authorshipAliasBlock: buildAuthorshipAliasBlock(),
       singletonId,
-      formatActionDateSource: buildFormatActionDateSource({ exported: false }),
       selectResolutionFunctions,
       cacheLifeLine,
       selectClause,
@@ -22376,8 +22616,25 @@ ${m2mWriteStatements}
       selectOptionFunctionExports
     }
   });
+  const toSingleContent = renderSingleActionsSingleActionsRenderer({
+    kind: "renderSingleActionsToSingleTemplate",
+    props: {
+      singular: Singular,
+      tableVar,
+      toEntityFunction: generateToEntityFunction({
+        Singular,
+        tableVar,
+        allDbFields,
+        htmlOutputFields,
+        m2mFields,
+        mediaFields: [],
+        galleryFields: []
+      })
+    }
+  });
   const files = [
     { name: "types.ts", content: typesContent },
+    { name: `to-${kebabSingular}.ts`, content: toSingleContent },
     ...hasHtmlOutput ? [{ name: "markdown.ts", content: genMarkdownRendererContent() }] : [],
     { name: `get-${kebabSingular}.ts`, content: getContent },
     ...hasCreatableSelectFields ? [
@@ -22711,7 +22968,7 @@ function renderBuildGroupCreatableSelectStateStaticOptionsTemplate({
   return `  const [${fieldName}Open, set${fieldPascal}Open] = React.useState(false)
   const [${fieldName}Search, set${fieldPascal}Search] = React.useState('')
   const [create${fieldPascal}OptionPending, startCreate${fieldPascal}OptionTransition] = React.useTransition()
-  const { data: ${fieldName}CreatedOptions = [] as ${singular}SelectOption[] } = useQuery<${singular}SelectOption[]>({
+  const { data: ${fieldName}CreatedOptions = [] } = useQuery<${singular}SelectOption[]>({
     queryKey: ['${schemaName}', 'select-options', '${fieldName}'],
     queryFn: () => get${singular}SelectOptions('${fieldName}')
   })
@@ -22894,6 +23151,7 @@ function generateCardComponent(group2, schema, analysis, allFlatFields) {
     defaultValueFromSourceNames
   );
   const fieldArrayHooks = buildGroupFieldArrayHooks(analysis);
+  const listFieldHandlers = buildListFieldHandlers(analysis.listFieldsWithNested).filter((handler) => handler.names.some((name) => usesIdentifier(fieldsJSX, name))).map((handler) => handler.source).join("\n\n");
   const savedValueName = `saved${Singular}`;
   const resetValues = buildDefaultValues2(group2.flatFields, savedValueName, allFlatFields).replace(
     /^ {6}/gm,
@@ -22939,9 +23197,9 @@ ${defaultValueFromSyncFunctions}
       fieldArrayHooksContent: fieldArrayHooks ? `
 ${fieldArrayHooks}
 ` : "",
-      creatableSelectHandlersContent: creatableSelectHandlers ? `${creatableSelectHandlers}
+      creatableSelectHandlersContent: [creatableSelectHandlers, listFieldHandlers].filter(Boolean).map((block) => `${block}
 
-` : "",
+`).join(""),
       descriptionLine,
       fieldsJsx: fieldsJSX,
       groupHintText: group2.hint ? `
@@ -29285,7 +29543,7 @@ ${validationErrors.map((error) => `  - ${error}`).join("\n")}`
 import * as p61 from "@clack/prompts";
 import { execFileSync as execFileSync3 } from "child_process";
 import fs79 from "fs";
-import path92 from "path";
+import path93 from "path";
 
 // adapters/next/config/detect/detect-project.ts
 import fs52 from "fs";
@@ -29703,10 +29961,14 @@ function addStorageIntegration(integrations2, provider) {
 
 // adapters/next/init/providers/prompt-deploy-provider.ts
 import * as p48 from "@clack/prompts";
-async function promptDeployProvider(initialValue = "none") {
+async function promptDeployProvider() {
   const provider = await p48.select({
     message: "Deploy this project",
     options: [
+      {
+        value: "none",
+        label: "Not now"
+      },
       {
         value: "vercel",
         label: "Vercel"
@@ -29714,13 +29976,9 @@ async function promptDeployProvider(initialValue = "none") {
       {
         value: "railway",
         label: "Railway"
-      },
-      {
-        value: "none",
-        label: "Not now"
       }
     ],
-    initialValue
+    initialValue: "none"
   });
   if (p48.isCancel(provider)) {
     p48.cancel("Setup cancelled.");
@@ -31451,6 +31709,7 @@ function scaffoldComponents({ cwd, config }) {
     "utils/date/date-range-end-time.ts",
     "utils/date/date-range-input-format.ts",
     "utils/date/date-range-start-time.ts",
+    "utils/date/format-action-date.ts",
     "utils/date/format-date-range-input-date.ts",
     "utils/date/format-date-range-param-date.ts",
     "utils/date/format-date-range-trigger-date.ts",
@@ -31461,6 +31720,9 @@ function scaffoldComponents({ cwd, config }) {
     "utils/date/parse-date-input-value.ts",
     "utils/date/parse-editable-date-range-date.ts",
     "utils/dev-mode/code-block-height.ts",
+    "utils/dev-mode/dev-mode-json-schemas.ts",
+    "utils/dev-mode/parse-dev-mode-lifecycle-hooks.ts",
+    "utils/dev-mode/parse-dev-mode-snippets.ts",
     "utils/error/read-string-property.ts",
     "utils/error/recognize.ts",
     "utils/error/to-action-error.ts",
@@ -31627,6 +31889,7 @@ function scaffoldComponents({ cwd, config }) {
     "utils/editor/set-active-table-column-alignment.ts",
     "utils/editor/set-element-attribute.ts",
     "utils/editor/set-markdown-link-at-cursor.ts",
+    "utils/editor/set-task-item-checked.ts",
     "utils/editor/show-table-part-preview.ts",
     "utils/editor/slash-commands.ts",
     "utils/editor/slash-menu-state.ts",
@@ -31641,6 +31904,7 @@ function scaffoldComponents({ cwd, config }) {
     "utils/editor/transform-selected-markdown-lines.ts",
     "utils/editor/update-nodes-attr.ts",
     "utils/editor/update-selected-content-editor-math.ts",
+    "utils/email/email-theme.ts",
     "utils/email/escape-html.ts",
     "utils/email/form-email-delivery-input.ts",
     "utils/email/format-email-value.ts",
@@ -31675,6 +31939,7 @@ function scaffoldComponents({ cwd, config }) {
     "utils/seo/generate-article-schema.ts",
     "utils/seo/schema-to-json.ts",
     "utils/shared/cn.ts",
+    "utils/shared/is-record.ts",
     "utils/storage/build-local-storage-key.ts",
     "utils/storage/sanitize-filename.ts",
     "utils/table/default-get-id.ts",
@@ -31779,6 +32044,7 @@ function scaffoldComponents({ cwd, config }) {
   write("hooks/use-users.ts", readTemplate("hooks/use-users.ts"));
   write("hooks/use-webhooks.ts", readTemplate("hooks/use-webhooks.ts"));
   write("hooks/use-failed-image-url.ts", readTemplate("hooks/use-failed-image-url.ts"));
+  write("hooks/use-field-error-visible.ts", readTemplate("hooks/use-field-error-visible.ts"));
   write("hooks/use-media.ts", readTemplate("hooks/use-media.ts"));
   write("hooks/use-entity-versions.ts", readTemplate("hooks/use-entity-versions.ts"));
   write("hooks/use-media-filters-bar.ts", readTemplate("hooks/use-media-filters-bar.ts"));
@@ -33148,15 +33414,24 @@ function scaffoldProxy({ cwd, config }) {
   return { status: "created", path: relPath };
 }
 
+// adapters/next/init/scaffolders/public-assets.ts
+import path79 from "path";
+function scaffoldPublicAssets(cwd) {
+  const sourceDir = resolveCliAssetPath("adapters", "next", "templates", "init", "public");
+  return PUBLIC_ASSET_FILE_NAMES.filter(
+    (fileName) => safeCopyFile(path79.join(sourceDir, fileName), path79.resolve(cwd, "public", fileName))
+  ).map((fileName) => path79.join("public", fileName));
+}
+
 // adapters/next/init/scaffolders/tailwind/scaffold-tailwind.ts
 import fs67 from "fs";
 
 // adapters/next/main-css.ts
 import fs66 from "fs";
-import path79 from "path";
+import path80 from "path";
 function findMainCss(cwd) {
   for (const candidate of MAIN_CSS_CANDIDATES) {
-    const filePath = path79.join(cwd, candidate);
+    const filePath = path80.join(cwd, candidate);
     if (fs66.existsSync(filePath)) return filePath;
   }
   return void 0;
@@ -33301,7 +33576,7 @@ ${renderAdminShadowInputUtility()}
 
 // adapters/next/init/scaffolders/tsconfig/scaffold-tsconfig.ts
 import fs68 from "fs";
-import path80 from "path";
+import path81 from "path";
 
 // adapters/next/init/scaffolders/tsconfig/create-admin-path-aliases.ts
 function createAdminPathAliases(config) {
@@ -33325,7 +33600,7 @@ function createAdminPathAliases(config) {
 
 // adapters/next/init/scaffolders/tsconfig/scaffold-tsconfig.ts
 function scaffoldTsconfig(cwd, config) {
-  const tsconfigPath = path80.join(cwd, "tsconfig.json");
+  const tsconfigPath = path81.join(cwd, "tsconfig.json");
   const added = [];
   const skipped = [];
   if (!fs68.existsSync(tsconfigPath)) {
@@ -33621,9 +33896,9 @@ async function ensureVercelAuth(runner, cwd, options) {
 
 // adapters/next/init/vercel/env-guard.ts
 import fs69 from "fs";
-import path81 from "path";
+import path82 from "path";
 function guardEnvLocal(cwd) {
-  const envPath = path81.join(cwd, ".env.local");
+  const envPath = path82.join(cwd, ".env.local");
   let original;
   try {
     original = fs69.readFileSync(envPath, "utf-8");
@@ -33699,14 +33974,14 @@ import pc9 from "picocolors";
 
 // adapters/next/init/vercel/project/create-and-link-project.ts
 import fs71 from "fs";
-import path83 from "path";
+import path84 from "path";
 
 // adapters/next/init/vercel/project/read-linked-project-json.ts
 import fs70 from "fs";
-import path82 from "path";
+import path83 from "path";
 function readLinkedProjectJson(cwd) {
   try {
-    const projectJsonPath = path82.join(cwd, ".vercel", "project.json");
+    const projectJsonPath = path83.join(cwd, ".vercel", "project.json");
     if (!fs70.existsSync(projectJsonPath)) return void 0;
     const parsed = JSON.parse(fs70.readFileSync(projectJsonPath, "utf-8"));
     if (!isRecord(parsed)) return void 0;
@@ -33781,7 +34056,7 @@ ${add.stderr}`)) continue;
     break;
   }
   try {
-    fs71.rmSync(path83.join(cwd, ".vercel", "project.json"), { force: true });
+    fs71.rmSync(path84.join(cwd, ".vercel", "project.json"), { force: true });
   } catch {
   }
   let link = await runVercel(
@@ -33900,10 +34175,10 @@ ${result.stderr}`
 // adapters/next/init/vercel/env-pull.ts
 import fs72 from "fs";
 import os from "os";
-import path84 from "path";
+import path85 from "path";
 async function pullVercelEnvValue(runner, cwd, read, env, environment = "development") {
-  const tmpDir = fs72.mkdtempSync(path84.join(os.tmpdir(), "betterstart-vercel-"));
-  const tmpEnv = path84.join(tmpDir, ".env.pull");
+  const tmpDir = fs72.mkdtempSync(path85.join(os.tmpdir(), "betterstart-vercel-"));
+  const tmpEnv = path85.join(tmpDir, ".env.pull");
   try {
     const pull = await runVercel(
       runner,
@@ -34130,9 +34405,9 @@ ${deploy.stderr}`, DETAIL_MAX_LINES)
 
 // adapters/next/init/vercel/deploy/ensure-vercel-json-framework.ts
 import fs73 from "fs";
-import path85 from "path";
+import path86 from "path";
 function ensureVercelJsonFramework(cwd) {
-  const vercelJsonPath = path85.join(cwd, "vercel.json");
+  const vercelJsonPath = path86.join(cwd, "vercel.json");
   if (fs73.existsSync(vercelJsonPath)) {
     return "exists";
   }
@@ -34146,9 +34421,9 @@ function ensureVercelJsonFramework(cwd) {
 }
 
 // adapters/next/init/vercel/deploy/collect-deploy-env-vars.ts
-import path86 from "path";
+import path87 from "path";
 function collectDeployEnvVars(cwd, existingProductionKeys) {
-  const local = parseDotenvFile(path86.join(cwd, ".env.local"));
+  const local = parseDotenvFile(path87.join(cwd, ".env.local"));
   const vars = [];
   for (const [key, value] of local) {
     if (VERCEL_ENV_SYNC_SKIP_KEYS.has(key)) continue;
@@ -34547,7 +34822,7 @@ ${stderr}`;
 // adapters/next/commands/init/run-seed-script.ts
 import { spawn as spawn7 } from "child_process";
 import fs74 from "fs";
-import path87 from "path";
+import path88 from "path";
 
 // adapters/next/templates/renderers/commands/seed/build-seed-script.ts
 function renderBuildSeedScriptEnvFileTemplate({
@@ -34727,8 +35002,8 @@ function buildSeedScript(authBasePath = "/api/admin/auth") {
 
 // adapters/next/commands/init/run-seed-script.ts
 function runSeedScript(cwd, adminDir, authBasePath, envOverrides) {
-  const scriptsDir = path87.join(cwd, adminDir, "scripts");
-  const seedPath = path87.join(scriptsDir, "seed.ts");
+  const scriptsDir = path88.join(cwd, adminDir, "scripts");
+  const seedPath = path88.join(scriptsDir, "seed.ts");
   if (!fs74.existsSync(scriptsDir)) {
     fs74.mkdirSync(scriptsDir, { recursive: true });
   }
@@ -34743,7 +35018,7 @@ function runSeedScript(cwd, adminDir, authBasePath, envOverrides) {
     }
   };
   return new Promise((resolve) => {
-    const tsxBin = path87.join(cwd, "node_modules", ".bin", "tsx");
+    const tsxBin = path88.join(cwd, "node_modules", ".bin", "tsx");
     const child = spawn7(tsxBin, [seedPath], {
       cwd,
       stdio: "pipe",
@@ -34814,9 +35089,9 @@ function formatAdminIdentity(admin) {
 
 // adapters/next/commands/init/has-db-url.ts
 import fs75 from "fs";
-import path88 from "path";
+import path89 from "path";
 function hasDbUrl(cwd) {
-  const envPath = path88.join(cwd, ".env.local");
+  const envPath = path89.join(cwd, ".env.local");
   if (!fs75.existsSync(envPath)) return false;
   const content = fs75.readFileSync(envPath, "utf-8");
   for (const line of content.split("\n")) {
@@ -34881,7 +35156,7 @@ function readExistingDbUrl(cwd) {
 
 // adapters/next/commands/init/remove-existing-admin-paths.ts
 import fs76 from "fs";
-import path89 from "path";
+import path90 from "path";
 
 // adapters/next/commands/init/normalize-namespace-for-removal.ts
 function normalizeNamespaceForRemoval(value) {
@@ -34909,14 +35184,14 @@ function removeExistingAdminPaths(cwd, namespaces) {
   const nukeFiles = [CONFIG_FILE_NAME, "ADMIN.md", "drizzle.config.ts"];
   let removed = 0;
   for (const dir of nukeDirs) {
-    const fullPath = path89.resolve(cwd, dir);
+    const fullPath = path90.resolve(cwd, dir);
     if (fs76.existsSync(fullPath)) {
       fs76.rmSync(fullPath, { recursive: true, force: true });
       removed++;
     }
   }
   for (const file of nukeFiles) {
-    const fullPath = path89.resolve(cwd, file);
+    const fullPath = path90.resolve(cwd, file);
     if (fs76.existsSync(fullPath)) {
       fs76.unlinkSync(fullPath);
       removed++;
@@ -34957,11 +35232,11 @@ function renderInitBanner() {
 
 // adapters/next/commands/init/resolve-force-init-namespaces.ts
 import fs78 from "fs";
-import path91 from "path";
+import path92 from "path";
 
 // adapters/next/commands/init/read-existing-config-namespace.ts
 import fs77 from "fs";
-import path90 from "path";
+import path91 from "path";
 
 // adapters/next/commands/init/read-namespace-from-config-source.ts
 function readNamespaceFromConfigSource(source) {
@@ -34971,7 +35246,7 @@ function readNamespaceFromConfigSource(source) {
 
 // adapters/next/commands/init/read-existing-config-namespace.ts
 async function readExistingConfigNamespace(cwd) {
-  const configPath = path90.resolve(cwd, CONFIG_FILE_NAME);
+  const configPath = path91.resolve(cwd, CONFIG_FILE_NAME);
   if (!fs77.existsSync(configPath)) {
     return;
   }
@@ -34990,7 +35265,7 @@ async function readExistingConfigNamespace(cwd) {
 // adapters/next/commands/init/resolve-force-init-namespaces.ts
 async function resolveForceInitNamespaces(cwd, targetNamespace) {
   const namespaces = /* @__PURE__ */ new Set([validateAdminNamespace(targetNamespace)]);
-  const hasConfig = fs78.existsSync(path91.resolve(cwd, CONFIG_FILE_NAME));
+  const hasConfig = fs78.existsSync(path92.resolve(cwd, CONFIG_FILE_NAME));
   const existingNamespace = await readExistingConfigNamespace(cwd);
   if (existingNamespace) {
     namespaces.add(existingNamespace);
@@ -35281,7 +35556,7 @@ async function runInitCommandInternal(name, options, jsonContext) {
     exitInit("validation", message, "INVALID_OPTIONS");
   }
   let cwd = process.cwd();
-  let projectName = path92.basename(cwd);
+  let projectName = path93.basename(cwd);
   let forceMode = Boolean(options.force);
   let namespace = DEFAULT_ADMIN_NAMESPACE;
   if (options.namespace) {
@@ -35390,7 +35665,7 @@ async function runInitCommandInternal(name, options, jsonContext) {
       }
       pm = pmChoice;
     }
-    const displayName = freshProject.projectName === "." ? path92.basename(cwd) : freshProject.projectName;
+    const displayName = freshProject.projectName === "." ? path93.basename(cwd) : freshProject.projectName;
     projectName = displayName;
     const { bin, prefix } = createNextAppCommand();
     const cnaArgs = [
@@ -35428,10 +35703,10 @@ async function runInitCommandInternal(name, options, jsonContext) {
       );
       exitInit("project", createNextAppResult.error, "CREATE_NEXT_APP_FAILED");
     }
-    cwd = path92.resolve(cwd, freshProject.projectName);
-    const hasPackageJson = fs79.existsSync(path92.join(cwd, "package.json"));
+    cwd = path93.resolve(cwd, freshProject.projectName);
+    const hasPackageJson = fs79.existsSync(path93.join(cwd, "package.json"));
     const hasNextConfig = ["next.config.ts", "next.config.js", "next.config.mjs"].some(
-      (f) => fs79.existsSync(path92.join(cwd, f))
+      (f) => fs79.existsSync(path93.join(cwd, f))
     );
     if (!hasPackageJson || !hasNextConfig) {
       createNextAppSpinner.stop(`Failed to create Next.js app: ${displayName}`);
@@ -35752,6 +36027,8 @@ async function runInitCommandInternal(name, options, jsonContext) {
   scaffoldAuth({ cwd, config });
   s.message("Components");
   scaffoldComponents({ cwd, config });
+  s.message("Static assets");
+  scaffoldPublicAssets(cwd);
   s.message("Pages & layouts");
   scaffoldLayout({ cwd, config });
   s.message("API routes");
@@ -35773,10 +36050,10 @@ async function runInitCommandInternal(name, options, jsonContext) {
       `Existing ${proxyResult.path} left in place \u2014 add the admin session-cookie redirect to it so logged-out visitors never render the admin routes.`
     );
   }
-  const drizzleConfigPath = path92.join(cwd, "drizzle.config.ts");
+  const drizzleConfigPath = path93.join(cwd, "drizzle.config.ts");
   if (!dbFiles.includes("drizzle.config.ts") && fs79.existsSync(drizzleConfigPath)) {
     if (forceMode) {
-      const { readNamespacedTemplate } = await import("./read-namespaced-template-KUENIIDC.js");
+      const { readNamespacedTemplate } = await import("./read-namespaced-template-WYIGUH7S.js");
       fs79.writeFileSync(
         drizzleConfigPath,
         readNamespacedTemplate("drizzle.config.ts", namespace),
@@ -35789,7 +36066,7 @@ async function runInitCommandInternal(name, options, jsonContext) {
         initialValue: true
       });
       if (!p61.isCancel(overwrite) && overwrite) {
-        const { readNamespacedTemplate } = await import("./read-namespaced-template-KUENIIDC.js");
+        const { readNamespacedTemplate } = await import("./read-namespaced-template-WYIGUH7S.js");
         fs79.writeFileSync(
           drizzleConfigPath,
           readNamespacedTemplate("drizzle.config.ts", namespace),
@@ -36089,8 +36366,7 @@ Run manually: ${pc18.cyan(pmExecCommand(pm, `betterstart seed`))}`,
   } else if (options.yes) {
     deployProvider = "none";
   } else {
-    const initialDeployProvider = railwaySessionPromise ? "railway" : readLinkedProjectId(cwd) ? "vercel" : "none";
-    deployProvider = await promptDeployProvider(initialDeployProvider);
+    deployProvider = await promptDeployProvider();
   }
   let deployedUrl;
   if (deployProvider === "vercel") {
@@ -36207,7 +36483,7 @@ async function runInitCommand(name, options) {
 
 // adapters/next/commands/list-integrations.ts
 import * as p62 from "@clack/prompts";
-import path93 from "path";
+import path94 from "path";
 
 // adapters/next/integration-runtime/list-available-integrations.ts
 function listAvailableIntegrations() {
@@ -36216,7 +36492,7 @@ function listAvailableIntegrations() {
 
 // adapters/next/commands/list-integrations.ts
 async function runListIntegrationsCommand(options) {
-  const cwd = options.cwd ? path93.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path94.resolve(options.cwd) : process.cwd();
   if (options.json) {
     let installed2;
     try {
@@ -36252,7 +36528,7 @@ async function runListIntegrationsCommand(options) {
 
 // adapters/next/commands/list-presets.ts
 import * as p63 from "@clack/prompts";
-import path94 from "path";
+import path95 from "path";
 
 // adapters/next/preset-runtime/list-available-presets.ts
 function listAvailablePresets() {
@@ -36261,7 +36537,7 @@ function listAvailablePresets() {
 
 // adapters/next/commands/list-presets.ts
 async function runListPresetsCommand(options) {
-  const cwd = options.cwd ? path94.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path95.resolve(options.cwd) : process.cwd();
   if (options.json) {
     let installed2;
     try {
@@ -36295,7 +36571,7 @@ async function runListPresetsCommand(options) {
 
 // adapters/next/commands/update-component/get-static-asset-component-entries.ts
 import fs80 from "fs";
-import path95 from "path";
+import path96 from "path";
 function getStaticAssetComponentEntries(assetDirectory) {
   const assetDir = resolveCliAssetPath("shared-assets", "react-admin", assetDirectory);
   if (!fs80.existsSync(assetDir)) return [];
@@ -36312,12 +36588,12 @@ function getStaticAssetComponentEntries(assetDirectory) {
       continue;
     }
     const indexFile = ["index.tsx", "index.ts"].find(
-      (file) => fs80.existsSync(path95.join(assetDir, entry.name, file))
+      (file) => fs80.existsSync(path96.join(assetDir, entry.name, file))
     );
     if (indexFile) {
       components.push({
         name: entry.name,
-        file: path95.join(entry.name, indexFile)
+        file: path96.join(entry.name, indexFile)
       });
     }
   }
@@ -36885,6 +37161,10 @@ var TEMPLATE_REGISTRY = {
     content: ({ cwd, config }) => adminDataTemplate(detectProjectName(cwd), config.frameworkConfig.next.namespace)
   },
   cn: { relPath: "utils/shared/cn.ts", content: () => readTemplate("utils/shared/cn.ts") },
+  "shared-is-record": {
+    relPath: "utils/shared/is-record.ts",
+    content: () => readTemplate("utils/shared/is-record.ts")
+  },
   "auth-can-access-admin": {
     relPath: "utils/auth/can-access-admin.ts",
     content: () => readTemplate("utils/auth/can-access-admin.ts")
@@ -36933,6 +37213,10 @@ var TEMPLATE_REGISTRY = {
     relPath: "utils/date/date-range-start-time.ts",
     content: () => readTemplate("utils/date/date-range-start-time.ts")
   },
+  "date-format-action-date": {
+    relPath: "utils/date/format-action-date.ts",
+    content: () => readTemplate("utils/date/format-action-date.ts")
+  },
   "date-format-date-range-input-date": {
     relPath: "utils/date/format-date-range-input-date.ts",
     content: () => readTemplate("utils/date/format-date-range-input-date.ts")
@@ -37669,6 +37953,10 @@ var TEMPLATE_REGISTRY = {
     relPath: "utils/editor/transform-selected-markdown-lines.ts",
     content: () => readTemplate("utils/editor/transform-selected-markdown-lines.ts")
   },
+  "editor-set-task-item-checked": {
+    relPath: "utils/editor/set-task-item-checked.ts",
+    content: () => readTemplate("utils/editor/set-task-item-checked.ts")
+  },
   "editor-update-nodes-attr": {
     relPath: "utils/editor/update-nodes-attr.ts",
     content: () => readTemplate("utils/editor/update-nodes-attr.ts")
@@ -37689,6 +37977,10 @@ var TEMPLATE_REGISTRY = {
     relPath: "utils/editor/table-input.ts",
     content: () => readTemplate("utils/editor/table-input.ts")
   },
+  "email-email-theme": {
+    relPath: "utils/email/email-theme.ts",
+    content: () => readTemplate("utils/email/email-theme.ts")
+  },
   "email-escape-html": {
     relPath: "utils/email/escape-html.ts",
     content: () => readTemplate("utils/email/escape-html.ts")
@@ -37721,6 +38013,10 @@ var TEMPLATE_REGISTRY = {
     relPath: "utils/email/render-thank-you-email.ts",
     content: () => readTemplate("utils/email/render-thank-you-email.ts")
   },
+  "use-field-error-visible": {
+    relPath: "hooks/use-field-error-visible.ts",
+    content: () => readTemplate("hooks/use-field-error-visible.ts")
+  },
   "form-clone-default-value": {
     relPath: "utils/form/clone-default-value.ts",
     content: () => readTemplate("utils/form/clone-default-value.ts")
@@ -37949,6 +38245,20 @@ var TEMPLATE_REGISTRY = {
     relPath: "utils/dev-mode/code-block-height.ts",
     content: () => readTemplate("utils/dev-mode/code-block-height.ts")
   },
+  "dev-mode-json-schemas-utils": {
+    relPath: "utils/dev-mode/dev-mode-json-schemas.ts",
+    content: () => readTemplate("utils/dev-mode/dev-mode-json-schemas.ts")
+  },
+  "dev-mode-parse-lifecycle-hooks-utils": {
+    relPath: "utils/dev-mode/parse-dev-mode-lifecycle-hooks.ts",
+    content: () => readTemplate("utils/dev-mode/parse-dev-mode-lifecycle-hooks.ts"),
+    dependencies: ["dev-mode-json-schemas-utils"]
+  },
+  "dev-mode-parse-snippets-utils": {
+    relPath: "utils/dev-mode/parse-dev-mode-snippets.ts",
+    content: () => readTemplate("utils/dev-mode/parse-dev-mode-snippets.ts"),
+    dependencies: ["dev-mode-json-schemas-utils"]
+  },
   "lifecycle-hooks": {
     relPath: "lib/lifecycle-hooks/index.ts",
     content: () => readTemplate("lib/lifecycle-hooks/index.ts"),
@@ -39076,16 +39386,16 @@ async function listInstallableChoices(cwd) {
 }
 
 // adapters/next/commands/menu-choices/list-schema-choices.ts
-import path96 from "path";
+import path97 from "path";
 async function listSchemaChoices(cwd) {
   const config = await resolveConfigOrExit(cwd);
   const paths = resolveProjectPaths(config);
-  return listSchemaNames(path96.join(cwd, ...paths.schemasDir.split("/")));
+  return listSchemaNames(path97.join(cwd, ...paths.schemasDir.split("/")));
 }
 
 // adapters/next/commands/remove-schema/run-remove-schema-command.ts
 import * as clack2 from "@clack/prompts";
-import path97 from "path";
+import path98 from "path";
 
 // core-engine/snapshots/store/delete-snapshot.ts
 import fs81 from "fs";
@@ -39125,7 +39435,7 @@ function resolveSchemaOwnerForRemoval(cwd, schemaName) {
 // adapters/next/commands/remove-schema/run-remove-schema-command.ts
 async function runRemoveSchemaCommand(schemaName, options) {
   const owner = resolveSchemaOwnerForRemoval(
-    options.cwd ? path97.resolve(options.cwd) : process.cwd(),
+    options.cwd ? path98.resolve(options.cwd) : process.cwd(),
     schemaName
   );
   if (owner === "core") {
@@ -39138,7 +39448,7 @@ async function runRemoveSchemaCommand(schemaName, options) {
     clack2.log.error(`"${schemaName}" is owned by ${owner}. Remove the owning preset instead.`);
     process.exit(1);
   }
-  const cwd = options.cwd ? path97.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path98.resolve(options.cwd) : process.cwd();
   const config = await resolveConfigOrExit(cwd);
   const paths = resolveProjectPaths(config);
   const manifest = loadManifest(cwd, schemaName);
@@ -39174,7 +39484,7 @@ async function runRemoveSchemaCommand(schemaName, options) {
   }
   const loaded = (() => {
     try {
-      return loadSchema(path97.join(cwd, ...paths.schemasDir.split("/")), schemaName);
+      return loadSchema(path98.join(cwd, ...paths.schemasDir.split("/")), schemaName);
     } catch {
       return null;
     }
@@ -39219,7 +39529,7 @@ Schema JSON preserved.`
 
 // adapters/next/commands/remove.ts
 import * as p64 from "@clack/prompts";
-import path101 from "path";
+import path102 from "path";
 
 // adapters/next/init/scaffolders/dependencies/build-remove-args.ts
 function buildRemoveArgs(pm, deps, dev) {
@@ -39263,11 +39573,11 @@ async function removeDependenciesAsync({
 }
 
 // adapters/next/integration-runtime/find-blocking-integration-dependencies.ts
-import path99 from "path";
+import path100 from "path";
 
 // adapters/next/integration-runtime/schema-manifest-contains-mailchimp-imports.ts
 import fs83 from "fs";
-import path98 from "path";
+import path99 from "path";
 function schemaManifestContainsMailchimpImports(cwd, config, schemaName) {
   const manifest = loadManifest(cwd, schemaName);
   if (!manifest) {
@@ -39284,7 +39594,7 @@ function schemaManifestContainsMailchimpImports(cwd, config, schemaName) {
     ...manifest.skipped
   ]);
   return liveManifestPaths.some((filePath) => {
-    const fullPath = path98.join(cwd, ...filePath.split("/"));
+    const fullPath = path99.join(cwd, ...filePath.split("/"));
     if (!fs83.existsSync(fullPath) || !fs83.statSync(fullPath).isFile()) {
       return false;
     }
@@ -39297,7 +39607,7 @@ function schemaManifestContainsMailchimpImports(cwd, config, schemaName) {
 function findBlockingIntegrationDependencies(cwd, config, integrationId) {
   const blockers = [];
   const paths = resolveProjectPaths(config);
-  const schemasDir = path99.join(cwd, ...paths.schemasDir.split("/"));
+  const schemasDir = path100.join(cwd, ...paths.schemasDir.split("/"));
   const ownership = loadSchemaOwnershipIndex(cwd);
   for (const schemaName of listSchemaNames(schemasDir)) {
     if (ownership.schemas[schemaName] !== "user") {
@@ -39488,7 +39798,7 @@ function findBlockingSchemaDependencies(cwd, config, ownedSchemas) {
 
 // adapters/next/preset-runtime/remove-preset-schemas.ts
 import fs85 from "fs";
-import path100 from "path";
+import path101 from "path";
 
 // preset-engine/ownership/remove-schema-owner.ts
 function removeSchemaOwner(cwd, schemaName) {
@@ -39529,8 +39839,8 @@ function removePresetSchemas(cwd, config, manifest) {
       }
       deleteSnapshot(cwd, schemaName);
     }
-    const schemaPath = path100.posix.join(paths.schemasDir, `${schemaName}.json`);
-    const formsSchemaPath = path100.posix.join(paths.schemasDir, "forms", `${schemaName}.json`);
+    const schemaPath = path101.posix.join(paths.schemasDir, `${schemaName}.json`);
+    const formsSchemaPath = path101.posix.join(paths.schemasDir, "forms", `${schemaName}.json`);
     if (removePath(cwd, schemaPath)) {
       deletedPaths.push(schemaPath);
     }
@@ -39662,7 +39972,7 @@ async function runRemoveCommand(items, options) {
     );
     process.exit(1);
   }
-  const cwd = options.cwd ? path101.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path102.resolve(options.cwd) : process.cwd();
   const config = await resolveConfigOrExit(cwd);
   const pm = detectPackageManager(cwd);
   if (!options.force) {
@@ -39715,9 +40025,9 @@ async function runRemoveCommand(items, options) {
 // adapters/next/commands/seed/run-seed-command.ts
 import * as clack3 from "@clack/prompts";
 import fs86 from "fs";
-import path102 from "path";
+import path103 from "path";
 async function runSeedCommand(options) {
-  const cwd = options.cwd ? path102.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path103.resolve(options.cwd) : process.cwd();
   clack3.intro("BetterStart Seed");
   let config;
   try {
@@ -39793,15 +40103,15 @@ async function runSeedCommand(options) {
     }
     name = nameInput;
   }
-  const scriptsDir = path102.join(cwd, adminDir, "scripts");
-  const seedPath = path102.join(scriptsDir, "seed.ts");
+  const scriptsDir = path103.join(cwd, adminDir, "scripts");
+  const seedPath = path103.join(scriptsDir, "seed.ts");
   if (!fs86.existsSync(scriptsDir)) {
     fs86.mkdirSync(scriptsDir, { recursive: true });
   }
   const namespace = resolveAdminNamespace(config.frameworkConfig.next.namespace);
   fs86.writeFileSync(seedPath, buildSeedScript(`${namespace.apiPath}/auth`), "utf-8");
   const { execFile: execFile2 } = await import("child_process");
-  const tsxBin = path102.join(cwd, "node_modules", ".bin", "tsx");
+  const tsxBin = path103.join(cwd, "node_modules", ".bin", "tsx");
   const runSeed2 = (overwrite) => new Promise((resolve, reject) => {
     execFile2(
       tsxBin,
@@ -39867,7 +40177,7 @@ async function runSeedCommand(options) {
     clack3.log.error(errMsg);
     clack3.log.info("You can run the seed script manually:");
     clack3.log.info(
-      `  SEED_EMAIL="${email}" SEED_PASSWORD="..." npx tsx ${path102.relative(cwd, seedPath)}`
+      `  SEED_EMAIL="${email}" SEED_PASSWORD="..." npx tsx ${path103.relative(cwd, seedPath)}`
     );
     clack3.outro("");
     process.exit(1);
@@ -39884,12 +40194,12 @@ async function runSeedCommand(options) {
 
 // adapters/next/commands/uninstall/run-uninstall-command.ts
 import * as p65 from "@clack/prompts";
-import path104 from "path";
+import path105 from "path";
 import pc19 from "picocolors";
 
 // adapters/next/commands/uninstall/build-uninstall-plan.ts
 import fs91 from "fs";
-import path103 from "path";
+import path104 from "path";
 
 // adapters/next/commands/uninstall-cleaners/clean-css.ts
 import fs87 from "fs";
@@ -40008,13 +40318,13 @@ function isCLICreatedOxcConfig(configPath) {
 function buildUninstallPlan(cwd, namespaceValue) {
   const steps = [];
   const namespace = resolveAdminNamespace(namespaceValue);
-  const hasSrc = fs91.existsSync(path103.join(cwd, "src"));
+  const hasSrc = fs91.existsSync(path104.join(cwd, "src"));
   const appBase = hasSrc ? "src/app" : "app";
   const dirs = [];
-  const adminDir = path103.join(cwd, namespace.segment);
-  const legacyAdminDir = path103.join(cwd, "admin");
-  const adminRouteGroup = path103.join(cwd, appBase, namespace.routeGroup);
-  const legacyAdminRouteGroup = path103.join(cwd, appBase, "(admin)");
+  const adminDir = path104.join(cwd, namespace.segment);
+  const legacyAdminDir = path104.join(cwd, "admin");
+  const adminRouteGroup = path104.join(cwd, appBase, namespace.routeGroup);
+  const legacyAdminRouteGroup = path104.join(cwd, appBase, "(admin)");
   if (fs91.existsSync(adminDir)) dirs.push(`${namespace.segment}/`);
   if (namespace.segment !== "admin" && fs91.existsSync(legacyAdminDir)) dirs.push("admin/");
   if (fs91.existsSync(adminRouteGroup)) dirs.push(`${appBase}/${namespace.routeGroup}/`);
@@ -40042,9 +40352,9 @@ function buildUninstallPlan(cwd, namespaceValue) {
   const configFiles = [];
   const configPaths = [];
   const candidates = [
-    [CONFIG_FILE_NAME, path103.join(cwd, CONFIG_FILE_NAME)],
-    ["drizzle.config.ts", path103.join(cwd, "drizzle.config.ts")],
-    ["ADMIN.md", path103.join(cwd, "ADMIN.md")]
+    [CONFIG_FILE_NAME, path104.join(cwd, CONFIG_FILE_NAME)],
+    ["drizzle.config.ts", path104.join(cwd, "drizzle.config.ts")],
+    ["ADMIN.md", path104.join(cwd, "ADMIN.md")]
   ];
   for (const [label, fullPath] of candidates) {
     if (fs91.existsSync(fullPath)) {
@@ -40053,7 +40363,7 @@ function buildUninstallPlan(cwd, namespaceValue) {
     }
   }
   for (const fileName of [".oxfmtrc.json", ".oxlintrc.json"]) {
-    const configPath = path103.join(cwd, fileName);
+    const configPath = path104.join(cwd, fileName);
     if (isCLICreatedOxcConfig(configPath)) {
       configFiles.push(`${fileName} (CLI-created)`);
       configPaths.push(configPath);
@@ -40072,7 +40382,7 @@ function buildUninstallPlan(cwd, namespaceValue) {
       }
     });
   }
-  const tsconfigPath = path103.join(cwd, "tsconfig.json");
+  const tsconfigPath = path104.join(cwd, "tsconfig.json");
   if (fs91.existsSync(tsconfigPath)) {
     const content = fs91.readFileSync(tsconfigPath, "utf-8");
     const aliasMatches = [
@@ -40099,7 +40409,7 @@ function buildUninstallPlan(cwd, namespaceValue) {
       (l) => new RegExp(`^@source\\s+"[^"]*(?:admin|${namespace.segment})[^"]*";\\s*$`).test(l)
     );
     if (sourceLines.length > 0) {
-      const relCss = path103.relative(cwd, cssFile);
+      const relCss = path104.relative(cwd, cssFile);
       steps.push({
         label: `CSS @source lines (${relCss})`,
         items: [`@source lines in ${relCss}`],
@@ -40111,7 +40421,7 @@ function buildUninstallPlan(cwd, namespaceValue) {
       });
     }
   }
-  const envPath = path103.join(cwd, ".env.local");
+  const envPath = path104.join(cwd, ".env.local");
   if (fs91.existsSync(envPath)) {
     const envContent = fs91.readFileSync(envPath, "utf-8");
     const bsVars = envContent.split("\n").filter((l) => l.trim().match(/^BETTERSTART_\w+=/)).map((l) => l.split("=")[0]);
@@ -40132,7 +40442,7 @@ function buildUninstallPlan(cwd, namespaceValue) {
 
 // adapters/next/commands/uninstall/run-uninstall-command.ts
 async function runUninstallCommand(options) {
-  const cwd = options.cwd ? path104.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path105.resolve(options.cwd) : process.cwd();
   p65.intro(pc19.bgRed(pc19.white(" BetterStart Uninstall ")));
   let namespace = DEFAULT_ADMIN_NAMESPACE;
   try {
@@ -40177,7 +40487,7 @@ async function runUninstallCommand(options) {
 // adapters/next/commands/update-component/run-update-command.ts
 import * as clack8 from "@clack/prompts";
 import fs97 from "fs";
-import path110 from "path";
+import path111 from "path";
 
 // adapters/next/integration-runtime/sync-installed-integration-manifests.ts
 function syncInstalledIntegrationManifests(cwd, config) {
@@ -40208,7 +40518,7 @@ function applyNamespaceToTemplateEntry(entry, config, cwd) {
 
 // adapters/next/commands/update-component/copy-namespaced-directory.ts
 import fs93 from "fs";
-import path105 from "path";
+import path106 from "path";
 import fsExtra from "fs-extra";
 
 // adapters/next/commands/update-component/write-namespaced-file.ts
@@ -40226,38 +40536,38 @@ function copyNamespacedDirectory(srcDir, destDir, namespace) {
   const entries = fs93.readdirSync(srcDir, { withFileTypes: true });
   for (const entry of entries) {
     const namespacedName = applyAdminNamespaceToPath(entry.name, namespace);
-    const srcPath = path105.join(srcDir, entry.name);
-    const destPath = path105.join(destDir, namespacedName);
+    const srcPath = path106.join(srcDir, entry.name);
+    const destPath = path106.join(destDir, namespacedName);
     if (entry.isDirectory()) {
       fsExtra.ensureDirSync(destPath);
       copyNamespacedDirectory(srcPath, destPath, namespace);
       continue;
     }
-    fsExtra.ensureDirSync(path105.dirname(destPath));
+    fsExtra.ensureDirSync(path106.dirname(destPath));
     writeNamespacedFile(srcPath, destPath, namespace);
   }
 }
 
 // adapters/next/commands/update-component/find-static-asset-file.ts
 import fs94 from "fs";
-import path106 from "path";
+import path107 from "path";
 function findStaticAssetFile(assetDir, componentName) {
   if (!fs94.existsSync(assetDir)) return void 0;
   const isNestedComponentName = /[\\/]/.test(componentName);
-  const nestedComponentName = componentName.split(/[\\/]/).filter(Boolean).join(path106.sep);
-  if (isNestedComponentName && nestedComponentName && !path106.isAbsolute(componentName) && !nestedComponentName.split(path106.sep).includes("..")) {
+  const nestedComponentName = componentName.split(/[\\/]/).filter(Boolean).join(path107.sep);
+  if (isNestedComponentName && nestedComponentName && !path107.isAbsolute(componentName) && !nestedComponentName.split(path107.sep).includes("..")) {
     for (const extension of [".tsx", ".ts"]) {
       const relPath = `${nestedComponentName}${extension}`;
-      const filePath = path106.join(assetDir, relPath);
+      const filePath = path107.join(assetDir, relPath);
       if (fs94.existsSync(filePath) && fs94.statSync(filePath).isFile()) {
         return relPath;
       }
     }
   }
-  if (!isNestedComponentName && !componentName.includes("..") && !path106.isAbsolute(componentName)) {
+  if (!isNestedComponentName && !componentName.includes("..") && !path107.isAbsolute(componentName)) {
     for (const extension of [".tsx", ".ts"]) {
-      const relPath = path106.join(componentName, `index${extension}`);
-      const filePath = path106.join(assetDir, relPath);
+      const relPath = path107.join(componentName, `index${extension}`);
+      const filePath = path107.join(assetDir, relPath);
       if (fs94.existsSync(filePath) && fs94.statSync(filePath).isFile()) {
         return relPath;
       }
@@ -40306,7 +40616,7 @@ function normalizeShadcnPresetOnly(value) {
 import * as clack6 from "@clack/prompts";
 import { execFileSync as execFileSync4 } from "child_process";
 import fs96 from "fs";
-import path109 from "path";
+import path110 from "path";
 
 // adapters/next/commands/update-component/create-admin-shadcn-components-json.ts
 function createAdminShadcnComponentsJson(config) {
@@ -40337,7 +40647,7 @@ function createAdminShadcnComponentsJson(config) {
 }
 
 // adapters/next/commands/update-component/get-host-project-files-to-restore.ts
-import path107 from "path";
+import path108 from "path";
 function getHostProjectFilesToRestore(cwd) {
   const hostRelativePaths = [
     "app/layout.tsx",
@@ -40351,16 +40661,16 @@ function getHostProjectFilesToRestore(cwd) {
     "app/globals.css",
     "src/app/globals.css"
   ];
-  return hostRelativePaths.map((relativePath) => path107.join(cwd, relativePath));
+  return hostRelativePaths.map((relativePath) => path108.join(cwd, relativePath));
 }
 
 // adapters/next/commands/update-component/resolve-local-shadcn-bin.ts
 import * as clack5 from "@clack/prompts";
 import fs95 from "fs";
-import path108 from "path";
+import path109 from "path";
 function resolveLocalShadcnBin(cwd) {
   const binName = process.platform === "win32" ? "shadcn.cmd" : "shadcn";
-  const shadcnBin = path108.join(cwd, "node_modules", ".bin", binName);
+  const shadcnBin = path109.join(cwd, "node_modules", ".bin", binName);
   if (!fs95.existsSync(shadcnBin)) {
     clack5.cancel(
       `shadcn is not installed in this project. Run 'betterstart update-deps' and try again.`
@@ -40378,13 +40688,13 @@ function runShadcnPresetUpdate({
   only
 }) {
   const namespace = resolveAdminNamespace(config.frameworkConfig.next.namespace);
-  const adminGlobalsPath = path109.join(cwd, config.paths.admin, namespace.globalsFile);
-  const componentsJsonPath = path109.join(cwd, "components.json");
+  const adminGlobalsPath = path110.join(cwd, config.paths.admin, namespace.globalsFile);
+  const componentsJsonPath = path110.join(cwd, "components.json");
   const shadcnBackupPath = `${componentsJsonPath}.bak`;
   const restoreAfterApplyPaths = [
     componentsJsonPath,
     shadcnBackupPath,
-    path109.join(cwd, config.paths.admin, "lib", "utils.ts"),
+    path110.join(cwd, config.paths.admin, "lib", "utils.ts"),
     ...getHostProjectFilesToRestore(cwd)
   ];
   if (!preset) {
@@ -40393,7 +40703,7 @@ function runShadcnPresetUpdate({
   }
   if (!fs96.existsSync(adminGlobalsPath)) {
     clack6.cancel(
-      `Admin globals file not found at ${path109.relative(cwd, adminGlobalsPath)}. Run 'betterstart update admin-globals' first.`
+      `Admin globals file not found at ${path110.relative(cwd, adminGlobalsPath)}. Run 'betterstart update admin-globals' first.`
     );
     process.exit(1);
   }
@@ -40403,7 +40713,7 @@ function runShadcnPresetUpdate({
     snapshot: captureFile(filePath)
   }));
   clack6.intro("BetterStart Shadcn Preset");
-  clack6.log.info(`Applying preset to ${path109.join(config.paths.admin, "components/ui")}`);
+  clack6.log.info(`Applying preset to ${path110.join(config.paths.admin, "components/ui")}`);
   let failed = false;
   try {
     fs96.writeFileSync(
@@ -40459,7 +40769,7 @@ function validateShadcnPresetOptions(components, options) {
 
 // adapters/next/commands/update-component/run-update-command.ts
 async function runUpdateCommand(components, options) {
-  const cwd = options.cwd ? path110.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path111.resolve(options.cwd) : process.cwd();
   const normalizedOnly = normalizeShadcnPresetOnly(options.only);
   validateShadcnPresetOptions(components, options);
   if (options.json && !options.list) {
@@ -40520,7 +40830,7 @@ async function runUpdateCommand(components, options) {
     return;
   }
   const config = await resolveConfigOrExit(cwd);
-  const admin = path110.resolve(cwd, config.paths.admin);
+  const admin = path111.resolve(cwd, config.paths.admin);
   if (!fs97.existsSync(admin)) {
     clack8.cancel(
       `Admin directory not found at ${config.paths.admin}. Run 'betterstart init' first.`
@@ -40575,7 +40885,7 @@ async function runUpdateCommand(components, options) {
     }
     const { relPath, content } = applyNamespaceToTemplateEntry(entry, config, cwd);
     const baseDir = entry.base === "cwd" ? cwd : admin;
-    const destPath = path110.join(baseDir, relPath);
+    const destPath = path111.join(baseDir, relPath);
     if (entry.preserveExisting && fs97.existsSync(destPath)) {
       clack8.log.info(`Preserved ${relPath}`);
       updatedTemplateNames.add(name);
@@ -40585,7 +40895,7 @@ async function runUpdateCommand(components, options) {
     pendingWrites.push({
       displayPath: relPath,
       write: () => {
-        fsExtra2.ensureDirSync(path110.dirname(destPath));
+        fsExtra2.ensureDirSync(path111.dirname(destPath));
         fs97.writeFileSync(destPath, content, "utf-8");
         clack8.log.success(`Updated ${relPath}`);
       }
@@ -40617,20 +40927,20 @@ async function runUpdateCommand(components, options) {
     }
     const namespace = config.frameworkConfig.next.namespace;
     const namespacedAssetFile = applyAdminNamespaceToPath(assetFile, namespace);
-    const destPath = path110.join(admin, "components", assetDirectory, namespacedAssetFile);
+    const destPath = path111.join(admin, "components", assetDirectory, namespacedAssetFile);
     pendingWrites.push({
       displayPath: `components/${assetDirectory}/${namespacedAssetFile}`,
       write: () => {
-        fsExtra2.ensureDirSync(path110.dirname(destPath));
-        writeNamespacedFile(path110.join(assetDir, assetFile), destPath, namespace);
+        fsExtra2.ensureDirSync(path111.dirname(destPath));
+        writeNamespacedFile(path111.join(assetDir, assetFile), destPath, namespace);
         clack8.log.success(`Updated components/${assetDirectory}/${namespacedAssetFile}`);
       }
     });
     if (assetDirectory === "custom") {
-      const assetSubdir = path110.join(assetDir, name);
+      const assetSubdir = path111.join(assetDir, name);
       if (fs97.existsSync(assetSubdir) && fs97.statSync(assetSubdir).isDirectory()) {
         const namespacedName = applyAdminNamespaceToPath(name, namespace);
-        const destSubdir = path110.join(admin, "components", assetDirectory, namespacedName);
+        const destSubdir = path111.join(admin, "components", assetDirectory, namespacedName);
         pendingWrites.push({
           displayPath: `components/${assetDirectory}/${namespacedName}/ (template files)`,
           write: () => {
@@ -40665,19 +40975,19 @@ async function runUpdateCommand(components, options) {
       "content-editor"
     );
     const namespace = config.frameworkConfig.next.namespace;
-    const destBaseDir = path110.join(admin, "components", "custom", "content-editor");
+    const destBaseDir = path111.join(admin, "components", "custom", "content-editor");
     if (!fs97.existsSync(srcBaseDir)) {
       return false;
     }
     const dirsToCopy = [];
     for (const directory of TIPTAP_CONTENT_EDITOR_DIRECTORIES) {
-      const srcDir = path110.join(srcBaseDir, directory);
+      const srcDir = path111.join(srcBaseDir, directory);
       if (!fs97.existsSync(srcDir)) {
         continue;
       }
       dirsToCopy.push({
         srcDir,
-        destDir: path110.join(destBaseDir, applyAdminNamespaceToPath(directory, namespace))
+        destDir: path111.join(destBaseDir, applyAdminNamespaceToPath(directory, namespace))
       });
     }
     if (dirsToCopy.length === 0) {
@@ -40691,7 +41001,7 @@ async function runUpdateCommand(components, options) {
           copyNamespacedDirectory(srcDir, destDir, namespace);
         }
         clack8.log.success("Updated components/custom/content-editor/tiptap-*/ (template files)");
-        removePath(admin, path110.join(admin, "components", "custom", "tiptap"));
+        removePath(admin, path111.join(admin, "components", "custom", "tiptap"));
       }
     });
     updatedStaticNames.add(key);
@@ -40770,6 +41080,7 @@ async function runUpdateCommand(components, options) {
       entry.write();
     }
   }
+  scaffoldPublicAssets(cwd);
   syncInstalledPresetManifests(cwd, config);
   syncInstalledIntegrationManifests(cwd, config);
   const projectPackageJson = readProjectPackageJson(cwd);
@@ -40788,7 +41099,7 @@ async function runUpdateCommand(components, options) {
 
 // adapters/next/commands/update-deps.ts
 import * as clack9 from "@clack/prompts";
-import path111 from "path";
+import path112 from "path";
 
 // adapters/next/integration-runtime/get-installed-integrations.ts
 function getInstalledIntegrations(config) {
@@ -40802,7 +41113,7 @@ function getInstalledPresets(config) {
 
 // adapters/next/commands/update-deps.ts
 async function runUpdateDepsCommand(options) {
-  const cwd = options.cwd ? path111.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path112.resolve(options.cwd) : process.cwd();
   clack9.intro("BetterStart Update Dependencies");
   const pm = detectPackageManager(cwd);
   clack9.log.info(`Package manager: ${pm}`);
@@ -40838,16 +41149,16 @@ async function runUpdateDepsCommand(options) {
 // adapters/next/commands/update-styles.ts
 import * as clack10 from "@clack/prompts";
 import fs98 from "fs";
-import path112 from "path";
+import path113 from "path";
 async function runUpdateStylesCommand(options) {
-  const cwd = options.cwd ? path112.resolve(options.cwd) : process.cwd();
+  const cwd = options.cwd ? path113.resolve(options.cwd) : process.cwd();
   clack10.intro("BetterStart Update Styles");
   const config = await resolveConfigOrExit(cwd);
   const adminDir = config.paths.admin;
   const namespace = resolveAdminNamespace(config.frameworkConfig.next.namespace);
-  const targetPath = path112.join(cwd, adminDir, namespace.globalsFile);
+  const targetPath = path113.join(cwd, adminDir, namespace.globalsFile);
   if (!fs98.existsSync(targetPath)) {
-    clack10.cancel(`${namespace.globalsFile} not found at ${path112.relative(cwd, targetPath)}`);
+    clack10.cancel(`${namespace.globalsFile} not found at ${path113.relative(cwd, targetPath)}`);
     process.exit(1);
   }
   fs98.writeFileSync(
@@ -40855,7 +41166,7 @@ async function runUpdateStylesCommand(options) {
     applyAdminNamespaceToContent(readTemplate("admin-globals.css"), namespace.segment),
     "utf-8"
   );
-  clack10.log.success(`Updated ${path112.relative(cwd, targetPath)}`);
+  clack10.log.success(`Updated ${path113.relative(cwd, targetPath)}`);
   clack10.outro("Styles updated");
 }