@ghentcdh/crouton-api 0.0.1-alpha.75 → 0.0.1-alpha.77

package/dist/index.cjs

@@ -70,7 +70,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// ../../node_modules/.pnpm/tsup@8.5.1_@microsoft+api-extractor@7.58.8_@types+node@26.4.0__@swc+core@1.16.1_@swc+he_9a17c50ee76d0369ad0c28a18d209a0d/node_modules/tsup/assets/cjs_shims.js
+// ../../node_modules/.pnpm/tsup@8.5.1_@swc+core@1.16.13_@swc+helpers@0.5.23__jiti@2.7.0_postcss@8.5.28_tsx@4.23.15_typescript@6.0.3_yaml@2.9.0/node_modules/tsup/assets/cjs_shims.js
 var getImportMetaUrl = /* @__PURE__ */ __name(() => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href, "getImportMetaUrl");
 var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
@@ -702,64 +702,307 @@ var LayoutSchema = import_zod8.z.object({
 });
 
 // ../crouton-core/src/lib/resource/ResourceJson.schema.ts
-var import_zod20 = require("zod");
+var import_zod30 = require("zod");
 
 // ../crouton-core/src/lib/resource/CalculatedColumn.schema.ts
-var import_zod10 = require("zod");
+var import_zod20 = require("zod");
 
 // ../crouton-core/src/lib/resource/FieldInput.schema.ts
+var import_zod19 = require("zod");
+
+// ../crouton-core/src/lib/resource/field-input/types/array.options.ts
+var import_zod10 = require("zod");
+
+// ../crouton-core/src/lib/resource/field-input/base.options.ts
 var import_zod9 = require("zod");
-var RelationType = import_zod9.z.enum([
+var BaseOptionsSchema = import_zod9.z.object({
+  label: import_zod9.z.string().optional().describe("Override the field label"),
+  hideLabel: import_zod9.z.boolean().optional().describe("Hide the label"),
+  placeholder: import_zod9.z.string().optional(),
+  readonly: import_zod9.z.boolean().optional(),
+  colspan: import_zod9.z.number().optional(),
+  width: import_zod9.z.string().optional(),
+  styles: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.unknown()).optional(),
+  customRender: import_zod9.z.string().optional()
+}).catchall(import_zod9.z.unknown());
+
+// ../crouton-core/src/lib/resource/field-input/types/array.options.ts
+var ArrayOptionsSchema = BaseOptionsSchema.extend({
+  layout: import_zod10.z.enum([
+    "row",
+    "column"
+  ]).optional(),
+  elementLabelProp: import_zod10.z.string().optional(),
+  hideActions: import_zod10.z.boolean().optional()
+});
+
+// ../crouton-core/src/lib/resource/field-input/types/autocomplete.options.ts
+var import_zod11 = require("zod");
+var AutocompleteBaseSchema = BaseOptionsSchema.extend({
+  labelKey: import_zod11.z.string().optional(),
+  valueKey: import_zod11.z.string().optional(),
+  freeText: import_zod11.z.boolean().optional(),
+  enableCreate: import_zod11.z.boolean().optional(),
+  storeValue: import_zod11.z.boolean().optional()
+});
+var AutocompleteInlineOptionsSchema = AutocompleteBaseSchema.extend({
+  options: import_zod11.z.array(import_zod11.z.unknown()),
+  values: import_zod11.z.array(import_zod11.z.unknown()).optional()
+});
+var AutocompleteRemoteOptionsSchema = AutocompleteBaseSchema.extend({
+  uri: import_zod11.z.string().describe("Remote endpoint URL"),
+  dataField: import_zod11.z.string().optional().describe("Field in response containing the data array"),
+  skipAuth: import_zod11.z.boolean().optional()
+});
+var AutocompleteResourceOptionsSchema = AutocompleteBaseSchema.extend({
+  resource: import_zod11.z.string().describe("Relative path to a resource.json"),
+  skipAuth: import_zod11.z.boolean().optional(),
+  dataField: import_zod11.z.string().optional()
+});
+var AutocompleteOptionsSchema = import_zod11.z.union([
+  AutocompleteInlineOptionsSchema,
+  AutocompleteRemoteOptionsSchema,
+  AutocompleteResourceOptionsSchema,
+  AutocompleteBaseSchema
+]).describe("Autocomplete options: inline array, remote URI, or resource reference");
+
+// ../crouton-core/src/lib/resource/field-input/types/boolean.options.ts
+var BooleanOptionsSchema = BaseOptionsSchema.extend({});
+
+// ../crouton-core/src/lib/resource/field-input/types/custom.options.ts
+var import_zod12 = require("zod");
+var CustomOptionsSchema = BaseOptionsSchema.extend({
+  customRender: import_zod12.z.string().optional()
+}).catchall(import_zod12.z.unknown());
+
+// ../crouton-core/src/lib/resource/field-input/types/date-range.options.ts
+var import_zod13 = require("zod");
+var DateRangeOptionsSchema = BaseOptionsSchema.extend({
+  fromLabel: import_zod13.z.string().optional().describe('Label above the start date input. Defaults to "From"'),
+  toLabel: import_zod13.z.string().optional().describe('Label above the end date input. Defaults to "To"'),
+  fromField: import_zod13.z.string().optional().describe('JSON object key for the start date. Defaults to "from"'),
+  toField: import_zod13.z.string().optional().describe('JSON object key for the end date. Defaults to "to"')
+});
+
+// ../crouton-core/src/lib/resource/field-input/types/date.options.ts
+var import_zod14 = require("zod");
+var DateOptionsSchema = BaseOptionsSchema.extend({
+  withTime: import_zod14.z.boolean().optional().describe("Force time input on/off, overrides format"),
+  min: import_zod14.z.string().optional().describe("Earliest selectable date, ISO or yyyy-MM-dd"),
+  max: import_zod14.z.string().optional().describe("Latest selectable date, ISO or yyyy-MM-dd"),
+  locale: import_zod14.z.string().optional().describe("BCP-47 locale for month heading and weekday labels").default("en-GB"),
+  firstDayOfWeek: import_zod14.z.number().optional().describe("0 = Sunday, 1 = Monday").default(1)
+});
+
+// ../crouton-core/src/lib/resource/field-input/types/markdown.options.ts
+var import_zod15 = require("zod");
+var MarkdownOptionsSchema = BaseOptionsSchema.extend({
+  minHeight: import_zod15.z.string().optional().describe('Minimum editor height, e.g. "200px"')
+});
+
+// ../crouton-core/src/lib/resource/field-input/types/number.options.ts
+var NumberOptionsSchema = BaseOptionsSchema.extend({});
+
+// ../crouton-core/src/lib/resource/field-input/types/relation.options.ts
+var import_zod16 = require("zod");
+var RelationOptionsSchema = BaseOptionsSchema.extend({
+  colspan: import_zod16.z.number().optional().default(12),
+  sort: import_zod16.z.string().optional().describe("Field to sort related records by"),
+  sortDir: import_zod16.z.enum([
+    "asc",
+    "desc"
+  ]).optional().describe("Sort direction, defaults to asc"),
+  direction: import_zod16.z.string().optional().describe("CSS flex direction for the button layout"),
+  displayKey: import_zod16.z.string().optional().describe("Key used as display label"),
+  resource: import_zod16.z.string().optional().describe("Path to the related resource")
+}).catchall(import_zod16.z.unknown());
+
+// ../crouton-core/src/lib/resource/field-input/types/select.options.ts
+var import_zod17 = require("zod");
+var SelectOptionsSchema = BaseOptionsSchema.extend({
+  options: import_zod17.z.array(import_zod17.z.unknown()).optional(),
+  values: import_zod17.z.array(import_zod17.z.unknown()).optional(),
+  resource: import_zod17.z.string().optional(),
+  labelKey: import_zod17.z.string().optional(),
+  valueKey: import_zod17.z.string().optional(),
+  uri: import_zod17.z.string().optional().describe("Remote endpoint URL for fetching options"),
+  dataField: import_zod17.z.string().optional().describe("Field in response containing the data array"),
+  clearable: import_zod17.z.boolean().optional().describe("Allow clearing the selected value"),
+  storeValue: import_zod17.z.boolean().optional().describe("Store option[valueKey] instead of the whole object")
+});
+
+// ../crouton-core/src/lib/resource/field-input/types/string.options.ts
+var StringOptionsSchema = BaseOptionsSchema.extend({});
+
+// ../crouton-core/src/lib/resource/field-input/types/textarea.options.ts
+var TextareaOptionsSchema = BaseOptionsSchema.extend({});
+
+// ../crouton-core/src/lib/resource/field-input/types/toggle.options.ts
+var import_zod18 = require("zod");
+var ToggleOptionsSchema = BaseOptionsSchema.extend({
+  options: import_zod18.z.array(import_zod18.z.unknown()).optional(),
+  values: import_zod18.z.array(import_zod18.z.unknown()).optional(),
+  labelKey: import_zod18.z.string().optional(),
+  valueKey: import_zod18.z.string().optional(),
+  storeValue: import_zod18.z.boolean().optional().describe("Store option[valueKey] instead of the whole object"),
+  clearable: import_zod18.z.boolean().optional().describe("Clicking active button clears the value").default(true),
+  color: import_zod18.z.string().optional().describe("Btn color for the active button").default("primary"),
+  size: import_zod18.z.string().optional().describe("Btn size").default("sm")
+});
+
+// ../crouton-core/src/lib/resource/field-input/registry.ts
+var fieldInputRegistry = /* @__PURE__ */ new Map([
+  [
+    "string",
+    {
+      options: StringOptionsSchema,
+      schemaFile: "string"
+    }
+  ],
+  [
+    "number",
+    {
+      options: NumberOptionsSchema,
+      schemaFile: "number"
+    }
+  ],
+  [
+    "Integer",
+    {
+      options: NumberOptionsSchema,
+      schemaFile: "number"
+    }
+  ],
+  [
+    "textarea",
+    {
+      options: TextareaOptionsSchema,
+      schemaFile: "textarea"
+    }
+  ],
+  [
+    "markdown",
+    {
+      options: MarkdownOptionsSchema,
+      schemaFile: "markdown"
+    }
+  ],
+  [
+    "boolean",
+    {
+      options: BooleanOptionsSchema,
+      schemaFile: "boolean"
+    }
+  ],
+  [
+    "toggle",
+    {
+      options: ToggleOptionsSchema,
+      schemaFile: "toggle"
+    }
+  ],
+  [
+    "select",
+    {
+      options: SelectOptionsSchema,
+      schemaFile: "select"
+    }
+  ],
+  [
+    "mutliSelect",
+    {
+      options: SelectOptionsSchema,
+      schemaFile: "select"
+    }
+  ],
+  [
+    "autocomplete",
+    {
+      options: AutocompleteOptionsSchema,
+      schemaFile: "autocomplete"
+    }
+  ],
+  [
+    "date",
+    {
+      options: DateOptionsSchema,
+      schemaFile: "date"
+    }
+  ],
+  [
+    "dateTime",
+    {
+      options: DateOptionsSchema,
+      schemaFile: "date"
+    }
+  ],
+  [
+    "date-range",
+    {
+      options: DateRangeOptionsSchema,
+      schemaFile: "date-range"
+    }
+  ],
+  [
+    "relation",
+    {
+      options: RelationOptionsSchema,
+      schemaFile: "relation"
+    }
+  ],
+  [
+    "array",
+    {
+      options: ArrayOptionsSchema,
+      schemaFile: "array"
+    }
+  ],
+  [
+    "custom",
+    {
+      options: CustomOptionsSchema,
+      schemaFile: "custom"
+    }
+  ]
+]);
+
+// ../crouton-core/src/lib/resource/FieldInput.schema.ts
+var RelationType = import_zod19.z.enum([
   "oneToOne",
   "manyToOne",
   "oneToMany",
   "manyToMany"
 ]);
-var DetailControlSchema = import_zod9.z.object({
-  property: import_zod9.z.string(),
-  type: import_zod9.z.string().optional(),
-  options: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.unknown()).optional(),
-  hideLabel: import_zod9.z.boolean().optional(),
-  width: import_zod9.z.string().optional()
+var DetailControlSchema = import_zod19.z.object({
+  property: import_zod19.z.string(),
+  type: import_zod19.z.string().optional(),
+  options: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.unknown()).optional(),
+  hideLabel: import_zod19.z.boolean().optional(),
+  width: import_zod19.z.string().optional()
 });
-var DetailConfigSchema = import_zod9.z.object({
-  layout: import_zod9.z.enum([
+var DetailConfigSchema = import_zod19.z.object({
+  layout: import_zod19.z.enum([
     "collapse",
     "row"
   ]),
-  titleKey: import_zod9.z.string().optional(),
-  controls: import_zod9.z.array(DetailControlSchema)
+  titleKey: import_zod19.z.string().optional(),
+  controls: import_zod19.z.array(DetailControlSchema)
 });
-var RelationFieldInputOptionsSchema = import_zod9.z.object({
-  colspan: import_zod9.z.number().optional().default(12),
-  /** Field to sort related records by, e.g. `"title"` or `"author.name"`. */
-  sort: import_zod9.z.string().optional(),
-  /** Sort direction. Defaults to `"asc"` when omitted. */
-  sortDir: import_zod9.z.enum([
-    "asc",
-    "desc"
-  ]).optional(),
-  /** CSS flex direction for the relation control button layout. */
-  direction: import_zod9.z.string().optional(),
-  /** Key used as the display label in the relation control. */
-  displayKey: import_zod9.z.string().optional(),
-  /** Path to the related resource (resolved to a URI at load time). */
-  resource: import_zod9.z.string().optional()
-}).catchall(import_zod9.z.unknown());
-var FieldInputSchema = import_zod9.z.object({
-  type: import_zod9.z.string().optional(),
-  customRender: import_zod9.z.string().optional(),
+var FieldInputSchema = import_zod19.z.object({
+  $schema: import_zod19.z.string().optional(),
+  type: import_zod19.z.string().optional(),
+  customRender: import_zod19.z.string().optional(),
   /**
   * Render format hint for the frontend (e.g. `"relation"` for sub-resource
   * relations). When `format` is `"relation"`, `resource` must also be set.
   */
-  format: import_zod9.z.string().optional(),
+  format: import_zod19.z.string().optional(),
   /**
   * Relative path to the child resource definition, e.g. `"./author.resource"`.
   * Only used when `format` is `"relation"`. Resolved at load time to inject
   * sub-resource URIs into `options`.
   */
-  resource: import_zod9.z.string().optional(),
+  resource: import_zod19.z.string().optional(),
   /**
   * Cardinality of the relation. Used by the frontend to determine the correct
   * renderer and behaviour (e.g. single-select vs multi-select).
@@ -768,11 +1011,11 @@ var FieldInputSchema = import_zod9.z.object({
   */
   relationType: RelationType.optional(),
   /** FK field on the child model pointing back to the parent, e.g. `"workId"`. Defaults to `${parentModel}Id`. */
-  foreignKey: import_zod9.z.string().optional(),
+  foreignKey: import_zod19.z.string().optional(),
   /** Override the Prisma relation field name when it differs from the column id. */
-  relation: import_zod9.z.string().optional(),
+  relation: import_zod19.z.string().optional(),
   /** Override the display order in form views. Lower values come first. */
-  position: import_zod9.z.number().optional(),
+  position: import_zod19.z.number().optional(),
   /**
   * Value to pre-fill this field with on the create form. Injected into the
   * generated form view's JSON Schema as `properties[id].default`, which
@@ -785,14 +1028,24 @@ var FieldInputSchema = import_zod9.z.object({
   * - `"$today"` — current date ISO string (date only, e.g. `"2025-03-14"`)
   * - `"$user"` — current user object (requires `defaults: { '$user': ... }` on `CroutonPlugin` config, or `useCrouton().setDefault('$user', ...)`)
   */
-  defaultValue: import_zod9.z.unknown().optional(),
-  options: import_zod9.z.union([
-    RelationFieldInputOptionsSchema,
-    import_zod9.z.unknown()
+  defaultValue: import_zod19.z.unknown().optional(),
+  options: import_zod19.z.union([
+    RelationOptionsSchema,
+    import_zod19.z.unknown()
   ]).optional(),
   /** Nested array detail layout (renders via `detailFixed`). */
   detail: DetailConfigSchema.optional()
 });
+var parseFieldInputOptions = /* @__PURE__ */ __name((fi) => {
+  if (!fi.type || fi.options == null) return fi;
+  const def2 = fieldInputRegistry.get(fi.type);
+  if (!def2) return fi;
+  const result = def2.options.safeParse(fi.options);
+  return result.success ? {
+    ...fi,
+    options: result.data
+  } : fi;
+}, "parseFieldInputOptions");
 var FieldVariantSchema = FieldInputSchema;
 var stripNull = /* @__PURE__ */ __name((obj) => {
   const out = {};
@@ -829,16 +1082,16 @@ var normalizeLabel = /* @__PURE__ */ __name((obj) => {
 }, "normalizeLabel");
 
 // ../crouton-core/src/lib/resource/CalculatedColumn.schema.ts
-var CalculatedColumnSchema = import_zod10.z.object({
+var CalculatedColumnSchema = import_zod20.z.object({
   /** Column identifier used in the response payload and UI schema. */
-  id: import_zod10.z.string(),
+  id: import_zod20.z.string(),
   /** SQL alias — must match `id`. */
-  alias: import_zod10.z.string(),
+  alias: import_zod20.z.string(),
   /** Human-readable label shown in the table header. */
-  label: import_zod10.z.string().optional(),
-  sqlExpression: import_zod10.z.string(),
+  label: import_zod20.z.string().optional(),
+  sqlExpression: import_zod20.z.string(),
   /** JSON schema / cast type for the computed value. Defaults to `"number"`. `"string"` skips CAST. */
-  type: import_zod10.z.enum([
+  type: import_zod20.z.enum([
     "number",
     "boolean",
     "string"
@@ -849,9 +1102,9 @@ var CalculatedColumnSchema = import_zod10.z.object({
    * `position: N` places this column before the element currently at index N.
    * Can also be set via `fieldInput.position` (takes precedence).
    */
-  position: import_zod10.z.number().optional(),
-  hiddenInTable: import_zod10.z.boolean().optional(),
-  hiddenInView: import_zod10.z.boolean().optional(),
+  position: import_zod20.z.number().optional(),
+  hiddenInTable: import_zod20.z.boolean().optional(),
+  hiddenInView: import_zod20.z.boolean().optional(),
   /**
    * Field input options for rendering in form / view schemas.
    * Supports `colspan`, `format`, and any other options passed to the Control renderer.
@@ -861,11 +1114,11 @@ var CalculatedColumnSchema = import_zod10.z.object({
 }).transform(normalizeLabel);
 
 // ../crouton-core/src/lib/resource/Column.ts
-var import_zod12 = require("zod");
+var import_zod22 = require("zod");
 
 // ../crouton-core/src/lib/resource/ColumnType.schema.ts
-var import_zod11 = require("zod");
-var ColumnTypeShorthandSchema = import_zod11.z.enum([
+var import_zod21 = require("zod");
+var ColumnTypeShorthandSchema = import_zod21.z.enum([
   "string",
   "number",
   "integer",
@@ -875,36 +1128,36 @@ var ColumnTypeShorthandSchema = import_zod11.z.enum([
   "object",
   "array"
 ]);
-var JsonSchemaFragmentSchema = import_zod11.z.lazy(() => import_zod11.z.object({
-  type: import_zod11.z.union([
-    import_zod11.z.string(),
-    import_zod11.z.array(import_zod11.z.string()),
-    import_zod11.z.lazy(() => JsonSchemaFragmentSchema)
+var JsonSchemaFragmentSchema = import_zod21.z.lazy(() => import_zod21.z.object({
+  type: import_zod21.z.union([
+    import_zod21.z.string(),
+    import_zod21.z.array(import_zod21.z.string()),
+    import_zod21.z.lazy(() => JsonSchemaFragmentSchema)
   ]).optional(),
-  format: import_zod11.z.string().optional(),
-  enum: import_zod11.z.array(import_zod11.z.unknown()).optional(),
-  const: import_zod11.z.unknown().optional(),
-  nullable: import_zod11.z.boolean().optional(),
-  properties: import_zod11.z.record(import_zod11.z.string(), JsonSchemaFragmentSchema).optional(),
-  required: import_zod11.z.union([
-    import_zod11.z.array(import_zod11.z.string()),
-    import_zod11.z.boolean()
+  format: import_zod21.z.string().optional(),
+  enum: import_zod21.z.array(import_zod21.z.unknown()).optional(),
+  const: import_zod21.z.unknown().optional(),
+  nullable: import_zod21.z.boolean().optional(),
+  properties: import_zod21.z.record(import_zod21.z.string(), JsonSchemaFragmentSchema).optional(),
+  required: import_zod21.z.union([
+    import_zod21.z.array(import_zod21.z.string()),
+    import_zod21.z.boolean()
   ]).optional(),
   items: JsonSchemaFragmentSchema.optional(),
-  additionalProperties: import_zod11.z.union([
-    import_zod11.z.boolean(),
+  additionalProperties: import_zod21.z.union([
+    import_zod21.z.boolean(),
     JsonSchemaFragmentSchema
   ]).optional(),
-  title: import_zod11.z.string().optional(),
-  description: import_zod11.z.string().optional(),
-  default: import_zod11.z.unknown().optional(),
-  minimum: import_zod11.z.number().optional(),
-  maximum: import_zod11.z.number().optional(),
-  minLength: import_zod11.z.number().optional(),
-  maxLength: import_zod11.z.number().optional(),
-  pattern: import_zod11.z.string().optional()
-}).catchall(import_zod11.z.unknown()));
-var ColumnTypeSchema = import_zod11.z.union([
+  title: import_zod21.z.string().optional(),
+  description: import_zod21.z.string().optional(),
+  default: import_zod21.z.unknown().optional(),
+  minimum: import_zod21.z.number().optional(),
+  maximum: import_zod21.z.number().optional(),
+  minLength: import_zod21.z.number().optional(),
+  maxLength: import_zod21.z.number().optional(),
+  pattern: import_zod21.z.string().optional()
+}).catchall(import_zod21.z.unknown()));
+var ColumnTypeSchema = import_zod21.z.union([
   ColumnTypeShorthandSchema,
   JsonSchemaFragmentSchema
 ]);
@@ -1008,40 +1261,40 @@ var isObjectColumnType = /* @__PURE__ */ __name((type) => columnTypeName(type) =
 var isArrayColumnType = /* @__PURE__ */ __name((type) => columnTypeName(type) === "array", "isArrayColumnType");
 
 // ../crouton-core/src/lib/resource/Column.ts
-var WhenConditionSchema = import_zod12.z.object({
-  field: import_zod12.z.string(),
-  eq: import_zod12.z.unknown().optional(),
-  neq: import_zod12.z.unknown().optional(),
-  exists: import_zod12.z.boolean().optional(),
-  notExists: import_zod12.z.boolean().optional()
+var WhenConditionSchema = import_zod22.z.object({
+  field: import_zod22.z.string(),
+  eq: import_zod22.z.unknown().optional(),
+  neq: import_zod22.z.unknown().optional(),
+  exists: import_zod22.z.boolean().optional(),
+  notExists: import_zod22.z.boolean().optional()
 });
-var JsonColumnSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  column: import_zod12.z.string().optional(),
-  label: import_zod12.z.string().optional(),
-  hiddenInTable: import_zod12.z.boolean().default(false),
-  hiddenInForm: import_zod12.z.boolean().default(false),
-  hiddenInView: import_zod12.z.boolean().default(false),
-  sortable: import_zod12.z.boolean().default(false),
-  defaultSort: import_zod12.z.boolean().default(false),
-  searchable: import_zod12.z.boolean().default(false),
-  filterable: import_zod12.z.boolean().default(false),
-  createable: import_zod12.z.boolean().default(true),
-  updateable: import_zod12.z.boolean().default(true),
-  hideLabel: import_zod12.z.boolean().default(false),
+var JsonColumnSchema = import_zod22.z.object({
+  id: import_zod22.z.string(),
+  column: import_zod22.z.string().optional(),
+  label: import_zod22.z.string().optional(),
+  hiddenInTable: import_zod22.z.boolean().default(false),
+  hiddenInForm: import_zod22.z.boolean().default(false),
+  hiddenInView: import_zod22.z.boolean().default(false),
+  sortable: import_zod22.z.boolean().default(false),
+  defaultSort: import_zod22.z.boolean().default(false),
+  searchable: import_zod22.z.boolean().default(false),
+  filterable: import_zod22.z.boolean().default(false),
+  createable: import_zod22.z.boolean().default(true),
+  updateable: import_zod22.z.boolean().default(true),
+  hideLabel: import_zod22.z.boolean().default(false),
   showWhen: WhenConditionSchema.optional(),
   hideWhen: WhenConditionSchema.optional(),
   disabledWhen: WhenConditionSchema.optional(),
-  displayKey: import_zod12.z.string().optional(),
-  sortId: import_zod12.z.string().optional(),
+  displayKey: import_zod22.z.string().optional(),
+  sortId: import_zod22.z.string().optional(),
   /**
   * Name of a shared enum in the project enum registry (`crouton.enums.json`).
   * At load time the loader injects that enum's `{ value, label }[]` into
   * `fieldInput.options.values`, so columns don't duplicate the option list.
   */
-  enum: import_zod12.z.string().optional(),
-  idField: import_zod12.z.boolean().default(false),
-  showInLookup: import_zod12.z.boolean().default(false),
+  enum: import_zod22.z.string().optional(),
+  idField: import_zod22.z.boolean().default(false),
+  showInLookup: import_zod22.z.boolean().default(false),
   /**
   * Data type of the column, as a shorthand name (`"string"`, `"integer"`, …)
   * or a full JSON Schema fragment:
@@ -1072,12 +1325,12 @@ var JsonColumnSchema = import_zod12.z.object({
   * Ignored on the id column and on columns that are neither createable nor
   * updateable, since the form cannot supply a value for those.
   */
-  required: import_zod12.z.boolean().optional(),
+  required: import_zod22.z.boolean().optional(),
   /**
   * @deprecated Use `type` instead. Retained because it is still consumed by
   * the boolean predicate and the schema-less sub-resource view builder.
   */
-  columnType: import_zod12.z.string().default("string"),
+  columnType: import_zod22.z.string().default("string"),
   fieldInput: FieldInputSchema.optional(),
   /**
   * Optional per-context override for the read-only VIEW ui. Same shape as
@@ -1101,27 +1354,27 @@ var JsonColumnSchema = import_zod12.z.object({
   * Visibility (`hiddenInTable/Form/View`) on this column is inherited by all sub-columns as a
   * default; the referenced resource's own column visibility further restricts it.
   */
-  extend: import_zod12.z.string().optional(),
+  extend: import_zod22.z.string().optional(),
   /**
   * Per-sub-column overrides when using `extend`.
   * Key: the virtual column id (`"{extendId}_{refColId}"`) or just the referenced column id.
   * Value: any `JsonColumn` fields to merge over the generated virtual column.
   */
-  columns: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.record(import_zod12.z.string(), import_zod12.z.unknown())).optional()
+  columns: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.record(import_zod22.z.string(), import_zod22.z.unknown())).optional()
 });
 
 // ../crouton-core/src/lib/resource/ParentRef.schema.ts
-var import_zod13 = require("zod");
-var ParentRefSchema = import_zod13.z.object({
+var import_zod23 = require("zod");
+var ParentRefSchema = import_zod23.z.object({
   /** Route segment of the parent, e.g. `"group"`. */
-  route: import_zod13.z.string(),
+  route: import_zod23.z.string(),
   /**
   * Name of the path parameter carrying the parent id, e.g. `"groupId"`.
   * Avoid `"id"` — that is the child's own id in `/:id` routes.
   */
-  param: import_zod13.z.string().default("parentId"),
+  param: import_zod23.z.string().default("parentId"),
   /** Type of the parent id, used to coerce the path param. Defaults to `'string'`. */
-  idType: import_zod13.z.enum([
+  idType: import_zod23.z.enum([
     "string",
     "number"
   ]).optional()
@@ -1129,37 +1382,37 @@ var ParentRefSchema = import_zod13.z.object({
 var resourceControllerPath = /* @__PURE__ */ __name((route, parent) => parent ? `${parent.route}/:${parent.param}/${route}` : route, "resourceControllerPath");
 
 // ../crouton-core/src/lib/resource/ResourceKind.ts
-var import_zod14 = require("zod");
-var ResourceKindSchema = import_zod14.z.enum([
+var import_zod24 = require("zod");
+var ResourceKindSchema = import_zod24.z.enum([
   "prisma",
   "custom"
 ]).default("prisma");
 
 // ../crouton-core/src/lib/resource/Sidebar.schema.ts
-var import_zod15 = __toESM(require("zod"), 1);
-var SidebarGroupSchema = import_zod15.default.object({
+var import_zod25 = __toESM(require("zod"), 1);
+var SidebarGroupSchema = import_zod25.default.object({
   /** Human-readable heading shown in the sidebar. Defaults to a title-cased version of the slug. */
-  label: import_zod15.default.string().optional(),
+  label: import_zod25.default.string().optional(),
   /** Controls the order of this group among top-level sidebar items. */
-  position: import_zod15.default.number().optional()
+  position: import_zod25.default.number().optional()
 });
-var SidebarSchema = import_zod15.default.object({
-  hide: import_zod15.default.boolean().default(false),
-  position: import_zod15.default.number().optional(),
-  label: import_zod15.default.string().optional(),
+var SidebarSchema = import_zod25.default.object({
+  hide: import_zod25.default.boolean().default(false),
+  position: import_zod25.default.number().optional(),
+  label: import_zod25.default.string().optional(),
   /**
   * Slug of the group this resource belongs to.
   * Must match a key in `sidebarGroups` in `crouton.json`.
   * Resources with the same `group` are nested under a shared collapsible section.
   */
-  group: import_zod15.default.string().optional()
+  group: import_zod25.default.string().optional()
 });
 
 // ../crouton-core/src/lib/resource/TableAction.schema.ts
-var import_zod16 = require("zod");
-var ActionConditionSchema = import_zod16.z.object({
+var import_zod26 = require("zod");
+var ActionConditionSchema = import_zod26.z.object({
   /** Row field to evaluate. */
-  field: import_zod16.z.string(),
+  field: import_zod26.z.string(),
   /**
   * Comparison operator. Defaults to `"eq"`.
   * - `eq` / `neq`         — strict equality
@@ -1167,7 +1420,7 @@ var ActionConditionSchema = import_zod16.z.object({
   * - `exists`             — field is not null / undefined / empty string
   * - `notExists`          — field is null / undefined / empty string
   */
-  op: import_zod16.z.enum([
+  op: import_zod26.z.enum([
     "eq",
     "neq",
     "gt",
@@ -1178,38 +1431,38 @@ var ActionConditionSchema = import_zod16.z.object({
     "notExists"
   ]).default("eq"),
   /** Comparison value. Not required for `exists` / `notExists`. */
-  value: import_zod16.z.unknown().optional()
+  value: import_zod26.z.unknown().optional()
 });
-var ActionSchema = import_zod16.z.object({
-  type: import_zod16.z.string(),
+var ActionSchema = import_zod26.z.object({
+  type: import_zod26.z.string(),
   /** Unique identifier for the action. */
-  id: import_zod16.z.string(),
+  id: import_zod26.z.string(),
   /** Human-readable button label. */
-  label: import_zod16.z.string(),
+  label: import_zod26.z.string(),
   /** MDI icon name, e.g. `"mdi:open-in-new"`. */
-  icon: import_zod16.z.string().optional(),
+  icon: import_zod26.z.string().optional(),
   /** Tooltip text. Falls back to `label` when omitted. */
-  tooltip: import_zod16.z.string().optional(),
+  tooltip: import_zod26.z.string().optional(),
   condition: ActionConditionSchema.optional()
 });
 var JsonProcedureActionSchema = ActionSchema.extend({
-  type: import_zod16.z.literal("procedure").default("procedure"),
+  type: import_zod26.z.literal("procedure").default("procedure"),
   /**
   * Filename (without extension) inside the resource's `actions/` directory
   * that exports the table-action procedure, e.g. `"syncZotero"`.
   */
-  procedure: import_zod16.z.string(),
+  procedure: import_zod26.z.string(),
   /** HTTP method for the frontend. Defaults to `"post"`. */
-  method: import_zod16.z.string().optional().default("post"),
+  method: import_zod26.z.string().optional().default("post"),
   /** Static query / body params passed to the endpoint. */
-  data: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.unknown()).optional()
+  data: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.unknown()).optional()
 });
 var JsonLinkActionSchema = ActionSchema.extend({
   /** Optional condition evaluated per row. Button is hidden when the condition is false. */
-  type: import_zod16.z.literal("link").default("link"),
+  type: import_zod26.z.literal("link").default("link"),
   /** URL to open. May contain `{env.VAR}` placeholders. */
-  href: import_zod16.z.string(),
-  blank: import_zod16.z.boolean().optional().default(true)
+  href: import_zod26.z.string(),
+  blank: import_zod26.z.boolean().optional().default(true)
 });
 var transformAction = /* @__PURE__ */ __name((action) => {
   const label = action.label;
@@ -1218,7 +1471,7 @@ var transformAction = /* @__PURE__ */ __name((action) => {
     ...action
   };
 }, "transformAction");
-var JsonActionSchema = import_zod16.z.union([
+var JsonActionSchema = import_zod26.z.union([
   JsonProcedureActionSchema,
   JsonLinkActionSchema
 ]).transform(transformAction);
@@ -1260,14 +1513,14 @@ var registerResourceExtensions = /* @__PURE__ */ __name((map = {}) => Object.ent
 var getResourceExtensions = /* @__PURE__ */ __name(() => registry, "getResourceExtensions");
 
 // ../crouton-core/src/lib/resource/include.schema.ts
-var import_zod17 = require("zod");
-var JsonIncludeEntrySchema = import_zod17.z.lazy(() => import_zod17.z.union([
-  import_zod17.z.string(),
-  import_zod17.z.object({
-    relation: import_zod17.z.string(),
-    include: import_zod17.z.array(JsonIncludeEntrySchema).optional(),
+var import_zod27 = require("zod");
+var JsonIncludeEntrySchema = import_zod27.z.lazy(() => import_zod27.z.union([
+  import_zod27.z.string(),
+  import_zod27.z.object({
+    relation: import_zod27.z.string(),
+    include: import_zod27.z.array(JsonIncludeEntrySchema).optional(),
     /** Prisma-format orderBy clause applied to the included records. */
-    orderBy: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.unknown()).optional()
+    orderBy: import_zod27.z.record(import_zod27.z.string(), import_zod27.z.unknown()).optional()
   })
 ]));
 
@@ -1276,36 +1529,36 @@ var BASELINE_RESOURCE_VERSION = 1;
 var CURRENT_RESOURCE_VERSION = 1;
 
 // ../crouton-core/src/lib/data-source/Operations.schema.ts
-var import_zod19 = require("zod");
+var import_zod29 = require("zod");
 
 // ../crouton-core/src/lib/data-source/Security.schema.ts
-var import_zod18 = require("zod");
-var SecuritySchema = import_zod18.z.union([
-  import_zod18.z.object({
-    public: import_zod18.z.literal(true)
+var import_zod28 = require("zod");
+var SecuritySchema = import_zod28.z.union([
+  import_zod28.z.object({
+    public: import_zod28.z.literal(true)
   }),
-  import_zod18.z.object({
-    guard: import_zod18.z.union([
-      import_zod18.z.string(),
-      import_zod18.z.array(import_zod18.z.string()).min(1)
+  import_zod28.z.object({
+    guard: import_zod28.z.union([
+      import_zod28.z.string(),
+      import_zod28.z.array(import_zod28.z.string()).min(1)
     ])
   })
 ]);
 
 // ../crouton-core/src/lib/data-source/Operations.schema.ts
-var ExternalOpEntry = import_zod19.z.object({
-  uri: import_zod19.z.string(),
-  method: import_zod19.z.string().optional(),
+var ExternalOpEntry = import_zod29.z.object({
+  uri: import_zod29.z.string(),
+  method: import_zod29.z.string().optional(),
   security: SecuritySchema.optional()
 });
-var OpEntry = import_zod19.z.union([
-  import_zod19.z.boolean(),
+var OpEntry = import_zod29.z.union([
+  import_zod29.z.boolean(),
   ExternalOpEntry,
-  import_zod19.z.object({
+  import_zod29.z.object({
     security: SecuritySchema.optional()
   })
 ]);
-var JsonOperationsSchema = import_zod19.z.object({
+var JsonOperationsSchema = import_zod29.z.object({
   findAll: OpEntry.default(true),
   findOne: OpEntry.default(true),
   create: OpEntry.default(true),
@@ -1357,16 +1610,16 @@ var buildSubResourceOperations = /* @__PURE__ */ __name((ops, baseUri, idField =
 }, "buildSubResourceOperations");
 
 // ../crouton-core/src/lib/resource/ResourceJson.schema.ts
-var JsonColumnsMapSchema = import_zod20.z.record(import_zod20.z.string(), JsonColumnSchema.omit({
+var JsonColumnsMapSchema = import_zod30.z.record(import_zod30.z.string(), JsonColumnSchema.omit({
   id: true
-}).catchall(import_zod20.z.unknown()));
+}).catchall(import_zod30.z.unknown()));
 var ColumnsSchema = JsonColumnsMapSchema;
-var JsonDisplaySchema = import_zod20.z.object({
-  mode: import_zod20.z.enum([
+var JsonDisplaySchema = import_zod30.z.object({
+  mode: import_zod30.z.enum([
     "page",
     "modal"
   ]).default("modal"),
-  customComponent: import_zod20.z.string().nullable().optional().default(null)
+  customComponent: import_zod30.z.string().nullable().optional().default(null)
 });
 var normalizeColumns = /* @__PURE__ */ __name((columns) => {
   if (!columns) return void 0;
@@ -1379,47 +1632,47 @@ var normalizeColumns = /* @__PURE__ */ __name((columns) => {
     label: col.label ?? labelFromId(col.id)
   }));
 }, "normalizeColumns");
-var ResourceJsonShape = import_zod20.z.object({
+var ResourceJsonShape = import_zod30.z.object({
   /**
   * URL of the generated JSON Schema, for editor autocomplete/validation. Declared so the
   * key is *allowed* (not stripped, and not flagged by the very schema it points at).
   * Ignored at runtime.
   */
-  $schema: import_zod20.z.string().optional(),
+  $schema: import_zod30.z.string().optional(),
   /**
   * resource.json shape version. Missing ⇒ baseline (see `./version`). Auto-migrated
   * toward `CURRENT_RESOURCE_VERSION` on load in the dev environment.
   */
-  schemaVersion: import_zod20.z.number().int().positive().optional(),
+  schemaVersion: import_zod30.z.number().int().positive().optional(),
   /** When `true`, the resource lives in the repo but is NOT loaded/served (work in progress). */
-  draft: import_zod20.z.boolean().optional().default(false),
+  draft: import_zod30.z.boolean().optional().default(false),
   /**
   * Where the data comes from. `prisma` (the default) is backed by a Prisma
   * model plus a `schema.ts`; `custom` is configuration only and the developer
   * supplies a `repository.ts`. See `./ResourceKind`.
   */
   kind: ResourceKindSchema,
-  name: import_zod20.z.string(),
-  route: import_zod20.z.string().optional(),
-  id: import_zod20.z.string().optional(),
+  name: import_zod30.z.string(),
+  route: import_zod30.z.string().optional(),
+  id: import_zod30.z.string().optional(),
   /**
   * Prisma model name. Required when `kind` is `prisma` (enforced by the
   * refinement on `ResourceJsonSchema`), and must be absent when `kind` is
   * `custom` — there is no Prisma delegate to address.
   */
-  model: import_zod20.z.string().optional(),
-  tag: import_zod20.z.string().optional().default("Crouton"),
-  title: import_zod20.z.string().optional(),
-  table: import_zod20.z.string().optional(),
+  model: import_zod30.z.string().optional(),
+  tag: import_zod30.z.string().optional().default("Crouton"),
+  title: import_zod30.z.string().optional(),
+  table: import_zod30.z.string().optional(),
   /**
   * Type of the resource's primary key, used to coerce `:id` route params.
   * Written by codegen from the Prisma model; defaults to `'string'`.
   */
-  idType: import_zod20.z.enum([
+  idType: import_zod30.z.enum([
     "string",
     "number"
   ]).optional(),
-  database: import_zod20.z.string().optional(),
+  database: import_zod30.z.string().optional(),
   /**
   * Mount this resource under a parent route instead of at the top level —
   * see `./ParentRef.schema`. Only valid on a `kind: "custom"` resource.
@@ -1431,12 +1684,12 @@ var ResourceJsonShape = import_zod20.z.object({
   security: SecuritySchema.optional(),
   operations: JsonOperationsSchema.optional(),
   columns: ColumnsSchema.optional().default(ColumnsSchema.parse({})),
-  calculatedColumns: import_zod20.z.array(CalculatedColumnSchema).default([]),
-  actions: import_zod20.z.array(JsonActionSchema).default([]),
+  calculatedColumns: import_zod30.z.array(CalculatedColumnSchema).default([]),
+  actions: import_zod30.z.array(JsonActionSchema).default([]),
   /** Global table-level actions (no record id). Shown as toolbar buttons. */
-  tableActions: import_zod20.z.array(JsonActionSchema).default([]),
+  tableActions: import_zod30.z.array(JsonActionSchema).default([]),
   /** Modal width when opening a form for this resource. */
-  modalSize: import_zod20.z.enum([
+  modalSize: import_zod30.z.enum([
     "xs",
     "sm",
     "lg",
@@ -1449,7 +1702,7 @@ var ResourceJsonShape = import_zod20.z.object({
   * `{ "relation": "text_author", "include": ["author"] }` →
   *   `include: { text_author: { include: { author: true } } }`
   */
-  include: import_zod20.z.array(JsonIncludeEntrySchema).default([]),
+  include: import_zod30.z.array(JsonIncludeEntrySchema).default([]),
   /** Explicit layout for generated views (`form`, `view`, `table`). When absent, source-order grid is used. */
   layout: LayoutSchema.optional()
 });
@@ -1518,7 +1771,7 @@ var buildResourceJsonSchema = /* @__PURE__ */ __name(() => {
     schema.optional()
   ]));
   const shape = ext.size ? ResourceJsonShape.extend(extShape) : ResourceJsonShape;
-  return import_zod20.z.preprocess((raw) => {
+  return import_zod30.z.preprocess((raw) => {
     if (raw && typeof raw === "object" && !Array.isArray(raw)) {
       const obj = raw;
       if (obj["kind"] === void 0 && obj["model"] !== void 0) {
@@ -1546,7 +1799,15 @@ var buildResourceJsonSchema = /* @__PURE__ */ __name(() => {
       id: obj.id ?? obj.name,
       route: obj.route ?? obj.id ?? obj.name ?? "",
       schemaVersion,
-      columns: normalizeColumns(obj.columns),
+      columns: normalizeColumns(obj.columns)?.map((col) => {
+        const out = {
+          ...col
+        };
+        if (out.fieldInput) out.fieldInput = parseFieldInputOptions(out.fieldInput);
+        if (out.fieldView) out.fieldView = parseFieldInputOptions(out.fieldView);
+        if (out.fieldTable) out.fieldTable = parseFieldInputOptions(out.fieldTable);
+        return out;
+      }),
       operations: obj.operations ?? defaultOps
     };
   }));
@@ -1997,7 +2258,7 @@ var injectCalculatedColumns = /* @__PURE__ */ __name((tableView, calculated) =>
 var injectCalculatedColumnsToView = /* @__PURE__ */ __name((viewConfig, calculated) => injectCalculatedColumnsIntoView(viewConfig, calculated, "view"), "injectCalculatedColumnsToView");
 
 // ../crouton-core/src/lib/view/view.builder.ts
-var import_zod22 = require("zod");
+var import_zod32 = require("zod");
 
 // ../crouton-core/src/lib/view/column-type-schema.source.ts
 var optionValues = /* @__PURE__ */ __name((col) => {
@@ -2033,20 +2294,20 @@ var columnTypeSchemaSource = /* @__PURE__ */ __name((schemaCols) => {
 }, "columnTypeSchemaSource");
 
 // ../crouton-core/src/lib/view/json-schema.opts.ts
-var import_zod21 = require("zod");
+var import_zod31 = require("zod");
 var isInstanceOf = /* @__PURE__ */ __name((zodSchema, className) => {
-  if (!(zodSchema instanceof import_zod21.z.ZodCustom)) return false;
+  if (!(zodSchema instanceof import_zod31.z.ZodCustom)) return false;
   const result = zodSchema.safeParse(null);
   if (result.success) return false;
   const issue = result.error.issues[0];
   return issue?.expected === className || (issue?.message?.includes(className) ?? false);
 }, "isInstanceOf");
 var jsonSchemaOverride = /* @__PURE__ */ __name(({ zodSchema, jsonSchema }) => {
-  if (zodSchema instanceof import_zod21.z.ZodDate) {
+  if (zodSchema instanceof import_zod31.z.ZodDate) {
     jsonSchema.type = "string";
     jsonSchema.format = "date-time";
   }
-  if (zodSchema instanceof import_zod21.z.ZodBigInt) {
+  if (zodSchema instanceof import_zod31.z.ZodBigInt) {
     jsonSchema.type = "integer";
   }
   if (isInstanceOf(zodSchema, "Decimal") || isInstanceOf(zodSchema, "Decimal2")) {
@@ -2289,7 +2550,7 @@ var zodSchemaSource = /* @__PURE__ */ __name((schema) => (schemaCols) => {
   ]));
   const picked = schema.pick(mask);
   try {
-    return (0, import_zod22.toJSONSchema)(picked, {
+    return (0, import_zod32.toJSONSchema)(picked, {
       target: "draft-07",
       ...jsonSchemaOpts
     });
@@ -2383,7 +2644,7 @@ var buildViewsWithSource = /* @__PURE__ */ __name((source, columns, layout) => {
     views.table = emptyTableView();
   }
   const formUiBuilder = layout?.form ? (cols) => buildFormUiSchemaFromLayout(layout.form, cols) : buildFormUiSchema;
-  const form = buildView(source, columns, (c) => !c.hiddenInForm, formUiBuilder, true, (c) => !c.idField && (c.createable === true || c.updateable === true));
+  const form = buildView(source, columns, (c) => !c.hiddenInForm, formUiBuilder, true, (c) => !c.idField && !c.hiddenInForm && (c.createable === true || c.updateable === true));
   if (form) {
     applyRequiredColumns(form.json_schema, columns);
     views.form = form;
@@ -2503,81 +2764,81 @@ var buildViewsFromColumns = /* @__PURE__ */ __name((columns) => {
 }, "buildViewsFromColumns");
 
 // ../crouton-core/src/lib/view/view.schema.ts
-var import_zod23 = require("zod");
-var ViewColumnConfigSchema = import_zod23.z.object({
-  id: import_zod23.z.string(),
-  label: import_zod23.z.string().optional(),
-  sortable: import_zod23.z.boolean().optional(),
-  searchable: import_zod23.z.boolean().optional(),
+var import_zod33 = require("zod");
+var ViewColumnConfigSchema = import_zod33.z.object({
+  id: import_zod33.z.string(),
+  label: import_zod33.z.string().optional(),
+  sortable: import_zod33.z.boolean().optional(),
+  searchable: import_zod33.z.boolean().optional(),
   fieldInput: FieldInputSchema.optional()
 });
-var ViewConfigSchema = import_zod23.z.object({
+var ViewConfigSchema = import_zod33.z.object({
   // TODO why we have both?
-  json_schema: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.unknown()).optional(),
-  ui_schema: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.unknown()).optional(),
+  json_schema: import_zod33.z.record(import_zod33.z.string(), import_zod33.z.unknown()).optional(),
+  ui_schema: import_zod33.z.record(import_zod33.z.string(), import_zod33.z.unknown()).optional(),
   // TODO why we have both?
-  ui: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.unknown()).optional(),
-  data: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.unknown()).optional(),
-  columns: import_zod23.z.array(ViewColumnConfigSchema),
-  defaultSort: import_zod23.z.string().optional()
+  ui: import_zod33.z.record(import_zod33.z.string(), import_zod33.z.unknown()).optional(),
+  data: import_zod33.z.record(import_zod33.z.string(), import_zod33.z.unknown()).optional(),
+  columns: import_zod33.z.array(ViewColumnConfigSchema),
+  defaultSort: import_zod33.z.string().optional()
 });
 var viewDefList = [
   "table",
   "view",
   "form"
 ];
-var ViewDefEnum = import_zod23.z.enum(viewDefList);
+var ViewDefEnum = import_zod33.z.enum(viewDefList);
 
 // ../crouton-core/src/lib/compile/enum-registry.ts
-var import_zod24 = require("zod");
-var EnumEntrySchema = import_zod24.z.object({
-  value: import_zod24.z.unknown(),
-  label: import_zod24.z.string()
+var import_zod34 = require("zod");
+var EnumEntrySchema = import_zod34.z.object({
+  value: import_zod34.z.unknown(),
+  label: import_zod34.z.string()
 });
-var EnumRegistrySchema = import_zod24.z.record(import_zod24.z.string(), import_zod24.z.array(EnumEntrySchema)).default({});
+var EnumRegistrySchema = import_zod34.z.record(import_zod34.z.string(), import_zod34.z.array(EnumEntrySchema)).default({});
 
 // ../crouton-core/src/lib/compile/relation-type.ts
-var import_zod25 = require("zod");
+var import_zod35 = require("zod");
 
 // ../crouton-core/src/lib/compile/compiled-resource.schema.ts
-var import_zod32 = require("zod");
+var import_zod42 = require("zod");
 
 // ../crouton-core/src/lib/compile/compiled-sub-resource.schema.ts
-var import_zod28 = require("zod");
+var import_zod38 = require("zod");
 
 // ../crouton-core/src/lib/data-source/DataSourceSchema.ts
-var import_zod26 = __toESM(require("zod"), 1);
-var DataSourceShape = import_zod26.default.object({
+var import_zod36 = __toESM(require("zod"), 1);
+var DataSourceShape = import_zod36.default.object({
   /** Datasource name (folder + `name` in data-source.json). */
-  name: import_zod26.default.string(),
+  name: import_zod36.default.string(),
   /**
   * Env var holding the connection URL. Required for Prisma adapters; optional
   * for custom adapters whose connection config may differ (secrets file, SDK
   * key, etc.).
   */
-  urlEnv: import_zod26.default.string().optional(),
+  urlEnv: import_zod36.default.string().optional(),
   /** Import path for this datasource's generated Zod types (for resource `schema.ts`). */
-  generatedTypesImport: import_zod26.default.string().optional(),
+  generatedTypesImport: import_zod36.default.string().optional(),
   /** Datasource type tag. Default `postgres`. */
-  type: import_zod26.default.string().default("postgres"),
+  type: import_zod36.default.string().default("postgres"),
   /** Mark this as the default datasource. Default `false`. */
-  default: import_zod26.default.boolean().default(false),
+  default: import_zod36.default.boolean().default(false),
   /**
   * Adapter kind. `"prisma"` (default) expects `index.ts` to default-export a
   * `PrismaClient`; `"custom"` expects it to default-export a `DataSourceAdapter`.
   */
-  adapter: import_zod26.default.enum([
+  adapter: import_zod36.default.enum([
     "prisma",
     "custom"
   ]).default("prisma"),
   /** Prisma schema path, relative to project root. Default `prisma/<name>/schema.prisma`. */
-  prismaSchema: import_zod26.default.string().optional(),
+  prismaSchema: import_zod36.default.string().optional(),
   /** Prisma config path, relative to project root. Default `prisma/<name>/prisma.config.ts`. */
-  prismaConfig: import_zod26.default.string().optional(),
+  prismaConfig: import_zod36.default.string().optional(),
   /** zod-prisma-types output dir, relative to project root. Default `generated/<name>/src`. */
-  zodOutput: import_zod26.default.string().optional(),
+  zodOutput: import_zod36.default.string().optional(),
   /** Prisma client output dir, relative to project root. Default `generated/<name>/client`. */
-  clientOutput: import_zod26.default.string().optional()
+  clientOutput: import_zod36.default.string().optional()
 });
 var transformDataSource = /* @__PURE__ */ __name((data) => {
   const name = data.name ?? "name";
@@ -2593,88 +2854,88 @@ var transformDataSource = /* @__PURE__ */ __name((data) => {
 var DataSourceSchema = DataSourceShape.transform(transformDataSource);
 
 // ../crouton-core/src/lib/compile/value-label-column.ts
-var import_zod27 = require("zod");
-var ValueSchema = import_zod27.z.object({
-  value: import_zod27.z.unknown(),
-  label: import_zod27.z.string()
+var import_zod37 = require("zod");
+var ValueSchema = import_zod37.z.object({
+  value: import_zod37.z.unknown(),
+  label: import_zod37.z.string()
 });
-var ValueLabelColumnSchema = import_zod27.z.object({
-  field: import_zod27.z.string(),
-  values: import_zod27.z.array(ValueSchema).default([]),
-  enumName: import_zod27.z.string().optional()
+var ValueLabelColumnSchema = import_zod37.z.object({
+  field: import_zod37.z.string(),
+  values: import_zod37.z.array(ValueSchema).default([]),
+  enumName: import_zod37.z.string().optional()
 });
 
 // ../crouton-core/src/lib/compile/compiled-sub-resource.schema.ts
-var CompiledSubResourceConfigSchema = import_zod28.z.object({
-  column: import_zod28.z.string(),
-  relation: import_zod28.z.string(),
-  childRoute: import_zod28.z.string(),
-  childKind: import_zod28.z.enum([
+var CompiledSubResourceConfigSchema = import_zod38.z.object({
+  column: import_zod38.z.string(),
+  relation: import_zod38.z.string(),
+  childRoute: import_zod38.z.string(),
+  childKind: import_zod38.z.enum([
     "prisma",
     "custom"
   ]).default("prisma"),
-  childDir: import_zod28.z.string().optional(),
-  childModel: import_zod28.z.string(),
-  foreignKey: import_zod28.z.string(),
-  name: import_zod28.z.string().optional(),
-  title: import_zod28.z.string().optional(),
-  idField: import_zod28.z.string().optional(),
-  idType: import_zod28.z.enum([
+  childDir: import_zod38.z.string().optional(),
+  childModel: import_zod38.z.string(),
+  foreignKey: import_zod38.z.string(),
+  name: import_zod38.z.string().optional(),
+  title: import_zod38.z.string().optional(),
+  idField: import_zod38.z.string().optional(),
+  idType: import_zod38.z.enum([
     "string",
     "number"
   ]).optional(),
-  views: import_zod28.z.record(import_zod28.z.string(), ViewConfigSchema).optional(),
+  views: import_zod38.z.record(import_zod38.z.string(), ViewConfigSchema).optional(),
   operations: JsonOperationsSchema,
-  actions: import_zod28.z.array(JsonActionSchema).optional(),
-  modalSize: import_zod28.z.enum([
+  actions: import_zod38.z.array(JsonActionSchema).optional(),
+  modalSize: import_zod38.z.enum([
     "xs",
     "sm",
     "lg",
     "xl"
   ]).optional(),
   display: JsonDisplaySchema.optional(),
-  include: import_zod28.z.array(JsonIncludeEntrySchema).optional(),
-  calculatedColumns: import_zod28.z.array(CalculatedColumnSchema).optional(),
-  includeInFindOne: import_zod28.z.boolean().optional(),
-  hiddenInTable: import_zod28.z.boolean().optional(),
-  findOneOrderBy: import_zod28.z.record(import_zod28.z.string(), import_zod28.z.unknown()).optional(),
-  valueLabelColumns: import_zod28.z.array(ValueLabelColumnSchema).optional(),
-  relationType: import_zod28.z.enum([
+  include: import_zod38.z.array(JsonIncludeEntrySchema).optional(),
+  calculatedColumns: import_zod38.z.array(CalculatedColumnSchema).optional(),
+  includeInFindOne: import_zod38.z.boolean().optional(),
+  hiddenInTable: import_zod38.z.boolean().optional(),
+  findOneOrderBy: import_zod38.z.record(import_zod38.z.string(), import_zod38.z.unknown()).optional(),
+  valueLabelColumns: import_zod38.z.array(ValueLabelColumnSchema).optional(),
+  relationType: import_zod38.z.enum([
     "oneToMany",
     "manyToOne"
   ]).optional()
 });
 
 // ../crouton-core/src/lib/compile/definition.schema.ts
-var import_zod30 = require("zod");
+var import_zod40 = require("zod");
 
 // ../crouton-core/src/lib/compile/schema-input.ts
-var import_zod29 = require("zod");
-var JsonSchemaInputSchema = import_zod29.z.object({
-  type: import_zod29.z.literal("object"),
-  properties: import_zod29.z.record(import_zod29.z.string(), import_zod29.z.unknown()),
-  required: import_zod29.z.array(import_zod29.z.string()).optional(),
-  additionalProperties: import_zod29.z.boolean().optional()
+var import_zod39 = require("zod");
+var JsonSchemaInputSchema = import_zod39.z.object({
+  type: import_zod39.z.literal("object"),
+  properties: import_zod39.z.record(import_zod39.z.string(), import_zod39.z.unknown()),
+  required: import_zod39.z.array(import_zod39.z.string()).optional(),
+  additionalProperties: import_zod39.z.boolean().optional()
 });
-var SchemaInputSchema = import_zod29.z.union([
-  import_zod29.z.custom((val) => val instanceof import_zod29.ZodObject),
+var SchemaInputSchema = import_zod39.z.union([
+  import_zod39.z.custom((val) => val instanceof import_zod39.ZodObject),
   JsonSchemaInputSchema
 ]);
 
 // ../crouton-core/src/lib/compile/definition.schema.ts
-var ExternalOperationDefSchema = import_zod30.z.object({
-  uri: import_zod30.z.string(),
-  method: import_zod30.z.string().optional()
+var ExternalOperationDefSchema = import_zod40.z.object({
+  uri: import_zod40.z.string(),
+  method: import_zod40.z.string().optional()
 });
-var OperationDefSchema = import_zod30.z.union([
-  import_zod30.z.literal(true),
+var OperationDefSchema = import_zod40.z.union([
+  import_zod40.z.literal(true),
   ExternalOperationDefSchema,
-  import_zod30.z.object({
+  import_zod40.z.object({
     schema: SchemaInputSchema.optional(),
     security: SecuritySchema.optional()
   })
 ]);
-var ResourceDefinitionSchema = import_zod30.z.object({
+var ResourceDefinitionSchema = import_zod40.z.object({
   findAll: OperationDefSchema.optional(),
   findOne: OperationDefSchema.optional(),
   create: OperationDefSchema.optional(),
@@ -2682,93 +2943,93 @@ var ResourceDefinitionSchema = import_zod30.z.object({
   patch: OperationDefSchema.optional(),
   delete: OperationDefSchema.optional()
 });
-var DefinitionCallbackSchema = import_zod30.z.function({
+var DefinitionCallbackSchema = import_zod40.z.function({
   input: [],
   output: ResourceDefinitionSchema
 });
-var DefinitionSchema = import_zod30.z.union([
+var DefinitionSchema = import_zod40.z.union([
   ResourceDefinitionSchema,
   DefinitionCallbackSchema
 ]);
 
 // ../crouton-core/src/lib/compile/lookup.schema.ts
-var import_zod31 = require("zod");
-var LookupSchema = import_zod31.z.object({
-  key: import_zod31.z.string(),
-  label: import_zod31.z.string().optional()
+var import_zod41 = require("zod");
+var LookupSchema = import_zod41.z.object({
+  key: import_zod41.z.string(),
+  label: import_zod41.z.string().optional()
 });
 
 // ../crouton-core/src/lib/compile/compiled-resource.schema.ts
 var CompiledResourceSchema = ResourceJsonShape.extend({
-  route: import_zod32.z.string(),
-  valueLabelColumns: import_zod32.z.array(ValueLabelColumnSchema).default([]),
-  subResources: import_zod32.z.lazy(() => import_zod32.z.array(CompiledSubResourceConfigSchema)).default([]),
+  route: import_zod42.z.string(),
+  valueLabelColumns: import_zod42.z.array(ValueLabelColumnSchema).default([]),
+  subResources: import_zod42.z.lazy(() => import_zod42.z.array(CompiledSubResourceConfigSchema)).default([]),
   lookup: LookupSchema.optional(),
-  views: import_zod32.z.record(import_zod32.z.string(), ViewConfigSchema),
+  views: import_zod42.z.record(import_zod42.z.string(), ViewConfigSchema),
   definition: DefinitionSchema,
-  idField: import_zod32.z.string(),
-  idType: import_zod32.z.enum([
+  idField: import_zod42.z.string(),
+  idType: import_zod42.z.enum([
     "string",
     "number"
   ]).default("string")
 });
 
 // ../crouton-core/src/lib/compile/to-json-schema.ts
-var import_zod33 = require("zod");
+var import_zod43 = require("zod");
 
 // ../crouton-core/src/lib/config/CroutonConfig.schema.ts
-var import_zod34 = require("zod");
-var RulesetSchema = import_zod34.z.object({
-  hideIdInTable: import_zod34.z.boolean().default(true),
-  hideIdInForm: import_zod34.z.boolean().default(true),
-  hideIdInView: import_zod34.z.boolean().default(true),
-  hideTimestamps: import_zod34.z.boolean().default(true),
-  hideForeignKeys: import_zod34.z.boolean().default(true),
-  includeRelations: import_zod34.z.boolean().default(true),
-  hideRelationsInTable: import_zod34.z.boolean().default(true),
-  showRelationsInForm: import_zod34.z.boolean().default(true),
-  enumValueLabel: import_zod34.z.boolean().default(true),
-  sharedEnums: import_zod34.z.boolean().default(true),
+var import_zod44 = require("zod");
+var RulesetSchema = import_zod44.z.object({
+  hideIdInTable: import_zod44.z.boolean().default(true),
+  hideIdInForm: import_zod44.z.boolean().default(true),
+  hideIdInView: import_zod44.z.boolean().default(true),
+  hideTimestamps: import_zod44.z.boolean().default(true),
+  hideForeignKeys: import_zod44.z.boolean().default(true),
+  includeRelations: import_zod44.z.boolean().default(true),
+  hideRelationsInTable: import_zod44.z.boolean().default(true),
+  showRelationsInForm: import_zod44.z.boolean().default(true),
+  enumValueLabel: import_zod44.z.boolean().default(true),
+  sharedEnums: import_zod44.z.boolean().default(true),
   defaultOperations: JsonOperationsSchema.default(JsonOperationsSchema.parse({}))
 });
-var I18nConfigSchema = import_zod34.z.object({
+var I18nConfigSchema = import_zod44.z.object({
   /** Default / fallback language. */
-  defaultLanguage: import_zod34.z.string().default("en"),
+  defaultLanguage: import_zod44.z.string().default("en"),
   /** All supported language codes. */
-  languages: import_zod34.z.array(import_zod34.z.string()).min(1),
+  languages: import_zod44.z.array(import_zod44.z.string()).min(1),
   /** Directory containing `<lang>.json` bundles, relative to project root. */
-  translationsDir: import_zod34.z.string().default("translations")
+  translationsDir: import_zod44.z.string().default("translations")
 });
-var CroutonConfigSchema = import_zod34.z.object({
+var CroutonConfigSchema = import_zod44.z.object({
   /**
   * Application title served to the frontend via `GET /_app/layout`.
   * Displayed in the admin sidebar header.
   */
-  title: import_zod34.z.string(),
+  title: import_zod44.z.string(),
   /** Where resource directories live, relative to the project root. */
-  resourcesDir: import_zod34.z.string(),
+  resourcesDir: import_zod44.z.string(),
   /** Where datasource folders live (each with a `data-source.json`). */
-  dataSourcesDir: import_zod34.z.string(),
+  dataSourcesDir: import_zod44.z.string(),
   /**
   * Template for a model's Zod export name. `{Model}` → Prisma model name.
   * Defaults to `{Model}WithRelationsSchema` (the relations-aware schema
   * emitted by zod-prisma-types when `createRelationValuesTypes` is on).
   */
-  schemaExportName: import_zod34.z.string().default("{Model}WithRelationsSchema"),
+  schemaExportName: import_zod44.z.string().default("{Model}WithRelationsSchema"),
   /** Path to the shared enum registry, relative to project root. Default `crouton.enums.json`. */
-  enumsFile: import_zod34.z.string().default("crouton.enums.json"),
+  enumsFile: import_zod44.z.string().default("crouton.enums.json"),
   /** Optional overrides of the default visibility ruleset. */
   rules: RulesetSchema.default(RulesetSchema.parse({})),
   /**
   * Sidebar group definitions, keyed by group slug (e.g. `"metadata"`).
   * Resources reference a group via `sidebar.group` in their `resource.json`.
   */
-  sidebarGroups: import_zod34.z.record(import_zod34.z.string(), SidebarGroupSchema).default({}),
+  sidebarGroups: import_zod44.z.record(import_zod44.z.string(), SidebarGroupSchema).default({}),
   /**
   * Whether form fields are saved automatically as the user edits them.
   * @default true
   */
-  autoSave: import_zod34.z.boolean().default(true),
+  autoSave: import_zod44.z.boolean().default(true),
   /** Optional i18n / translation configuration. */
   i18n: I18nConfigSchema.optional()
 });
@@ -2781,29 +3042,29 @@ var CONFIG_FILES = [
 ];
 
 // ../crouton-core/src/lib/i18n/Translations.schema.ts
-var import_zod35 = require("zod");
-var NestedStringRecord = import_zod35.z.lazy(() => import_zod35.z.record(import_zod35.z.string(), import_zod35.z.union([
-  import_zod35.z.string(),
+var import_zod45 = require("zod");
+var NestedStringRecord = import_zod45.z.lazy(() => import_zod45.z.record(import_zod45.z.string(), import_zod45.z.union([
+  import_zod45.z.string(),
   NestedStringRecord
 ])));
-var TranslationBundleSchema = import_zod35.z.object({
-  app: import_zod35.z.object({
-    title: import_zod35.z.string().optional()
+var TranslationBundleSchema = import_zod45.z.object({
+  app: import_zod45.z.object({
+    title: import_zod45.z.string().optional()
   }).optional(),
-  sidebarGroups: import_zod35.z.record(import_zod35.z.string(), import_zod35.z.string()).optional(),
-  resources: import_zod35.z.record(import_zod35.z.string(), import_zod35.z.object({
-    title: import_zod35.z.string().optional(),
-    sidebar: import_zod35.z.string().optional(),
-    columns: import_zod35.z.record(import_zod35.z.string(), import_zod35.z.string()).optional(),
-    actions: import_zod35.z.record(import_zod35.z.string(), import_zod35.z.string()).optional(),
-    subResources: import_zod35.z.record(import_zod35.z.string(), import_zod35.z.object({
-      title: import_zod35.z.string().optional(),
-      columns: import_zod35.z.record(import_zod35.z.string(), import_zod35.z.string()).optional()
+  sidebarGroups: import_zod45.z.record(import_zod45.z.string(), import_zod45.z.string()).optional(),
+  resources: import_zod45.z.record(import_zod45.z.string(), import_zod45.z.object({
+    title: import_zod45.z.string().optional(),
+    sidebar: import_zod45.z.string().optional(),
+    columns: import_zod45.z.record(import_zod45.z.string(), import_zod45.z.string()).optional(),
+    actions: import_zod45.z.record(import_zod45.z.string(), import_zod45.z.string()).optional(),
+    subResources: import_zod45.z.record(import_zod45.z.string(), import_zod45.z.object({
+      title: import_zod45.z.string().optional(),
+      columns: import_zod45.z.record(import_zod45.z.string(), import_zod45.z.string()).optional()
     }).optional()).optional()
   }).optional()).optional(),
-  enums: import_zod35.z.record(import_zod35.z.string(), import_zod35.z.record(import_zod35.z.string(), import_zod35.z.string())).optional(),
+  enums: import_zod45.z.record(import_zod45.z.string(), import_zod45.z.record(import_zod45.z.string(), import_zod45.z.string())).optional(),
   ui: NestedStringRecord.optional(),
-  validation: import_zod35.z.record(import_zod35.z.string(), import_zod35.z.string()).optional()
+  validation: import_zod45.z.record(import_zod45.z.string(), import_zod45.z.string()).optional()
 }).passthrough();
 
 // ../crouton-core/src/lib/i18n/translation-keys.ts
@@ -2887,21 +3148,21 @@ var import_common27 = require("@nestjs/common");
 var import_core2 = require("@nestjs/core");
 
 // src/lib/crud/app-layout/app-layout.types.ts
-var import_zod36 = require("zod");
-var SidebarLeafSchema = import_zod36.z.object({
-  kind: import_zod36.z.literal("item").default("item"),
-  id: import_zod36.z.string(),
-  label: import_zod36.z.string(),
-  position: import_zod36.z.number().optional()
+var import_zod46 = require("zod");
+var SidebarLeafSchema = import_zod46.z.object({
+  kind: import_zod46.z.literal("item").default("item"),
+  id: import_zod46.z.string(),
+  label: import_zod46.z.string(),
+  position: import_zod46.z.number().optional()
 });
-var SidebarGroupSchema2 = import_zod36.z.object({
-  kind: import_zod36.z.literal("group").default("group"),
-  id: import_zod36.z.string(),
-  label: import_zod36.z.string(),
-  position: import_zod36.z.number().optional(),
-  children: import_zod36.z.array(SidebarLeafSchema).default([])
+var SidebarGroupSchema2 = import_zod46.z.object({
+  kind: import_zod46.z.literal("group").default("group"),
+  id: import_zod46.z.string(),
+  label: import_zod46.z.string(),
+  position: import_zod46.z.number().optional(),
+  children: import_zod46.z.array(SidebarLeafSchema).default([])
 });
-var SidebarNodeSchema = import_zod36.z.discriminatedUnion("kind", [
+var SidebarNodeSchema = import_zod46.z.discriminatedUnion("kind", [
   SidebarLeafSchema,
   SidebarGroupSchema2
 ]);
@@ -3740,47 +4001,47 @@ var import_swagger11 = require("@nestjs/swagger");
 var import_common10 = require("@nestjs/common");
 
 // src/lib/crud/action/action.types.ts
-var import_zod37 = require("zod");
-var ActionMetadataSchema2 = import_zod37.z.object({
+var import_zod47 = require("zod");
+var ActionMetadataSchema2 = import_zod47.z.object({
   /** URL segment used in the endpoint. */
-  id: import_zod37.z.string(),
+  id: import_zod47.z.string(),
   /** Human-readable label shown as a button. */
-  label: import_zod37.z.string().optional(),
+  label: import_zod47.z.string().optional(),
   /** MDI icon name, e.g. `"mdi:open-in-new"`. */
-  icon: import_zod37.z.string().optional(),
+  icon: import_zod47.z.string().optional(),
   /** Tooltip text. Falls back to `label` when omitted. */
-  tooltip: import_zod37.z.string().optional(),
+  tooltip: import_zod47.z.string().optional(),
   /** Per-row condition — button is hidden when false. */
-  condition: import_zod37.z.custom().optional()
+  condition: import_zod47.z.custom().optional()
 });
 var ResourceLinkActionSchema2 = ActionMetadataSchema2.extend({
-  type: import_zod37.z.literal("link"),
+  type: import_zod47.z.literal("link"),
   /** URL to open. May contain `{id}` or `{env.VAR}` placeholders. */
-  href: import_zod37.z.string()
+  href: import_zod47.z.string()
 });
 var ResourceRowProcedureActionSchema2 = ActionMetadataSchema2.extend({
-  type: import_zod37.z.literal("procedure").optional(),
+  type: import_zod47.z.literal("procedure").optional(),
   /** HTTP method for the endpoint. Defaults to `"post"`. */
-  method: import_zod37.z.string().optional(),
+  method: import_zod47.z.string().optional(),
   /** Static data payload merged into the request body by the frontend. */
-  data: import_zod37.z.record(import_zod37.z.string(), import_zod37.z.unknown()).optional(),
+  data: import_zod47.z.record(import_zod47.z.string(), import_zod47.z.unknown()).optional(),
   /** Procedure called with `(prisma, recordId)`. */
-  procedure: import_zod37.z.custom((v) => typeof v === "function")
+  procedure: import_zod47.z.custom((v) => typeof v === "function")
 });
 var ResourceTableProcedureActionSchema2 = ActionMetadataSchema2.extend({
-  type: import_zod37.z.literal("procedure").optional(),
+  type: import_zod47.z.literal("procedure").optional(),
   /** HTTP method for the endpoint. Defaults to `"post"`. */
-  method: import_zod37.z.string().optional(),
+  method: import_zod47.z.string().optional(),
   /** Static data payload merged into the request body by the frontend. */
-  data: import_zod37.z.record(import_zod37.z.string(), import_zod37.z.unknown()).optional(),
+  data: import_zod47.z.record(import_zod47.z.string(), import_zod47.z.unknown()).optional(),
   /** Procedure called with `(prisma)` — no record id. */
-  procedure: import_zod37.z.custom((v) => typeof v === "function")
+  procedure: import_zod47.z.custom((v) => typeof v === "function")
 });
-var ResourceRowActionSchema2 = import_zod37.z.union([
+var ResourceRowActionSchema2 = import_zod47.z.union([
   ResourceRowProcedureActionSchema2,
   ResourceLinkActionSchema2
 ]);
-var ResourceTableActionSchema2 = import_zod37.z.union([
+var ResourceTableActionSchema2 = import_zod47.z.union([
   ResourceTableProcedureActionSchema2,
   ResourceLinkActionSchema2
 ]);
@@ -3887,7 +4148,7 @@ var securityForSub = /* @__PURE__ */ __name((config, sub, op, moduleDefault) =>
 }, "securityForSub");
 
 // src/lib/crud/custom-repository/custom-repository.types.ts
-var import_zod38 = require("zod");
+var import_zod48 = require("zod");
 var CUSTOM_OPS = [
   "findAll",
   "findOne",
@@ -3904,7 +4165,7 @@ var PARENT_METHOD = {
   patch: "patchByParent",
   delete: "deleteByParent"
 };
-var CustomRepositorySchema = import_zod38.z.custom((value) => typeof value === "object" && value !== null);
+var CustomRepositorySchema = import_zod48.z.custom((value) => typeof value === "object" && value !== null);
 
 // src/lib/crud/resource/resource-load-errors.registry.ts
 var ResourceLoadErrorsRegistry = class ResourceLoadErrorsRegistry2 {
@@ -5097,23 +5358,23 @@ var PrismaDataSourceAdapter = class {
 };
 
 // src/lib/crud/hooks/hooks.types.ts
-var import_zod39 = require("zod");
-var WriteOpSchema = import_zod39.z.enum([
+var import_zod49 = require("zod");
+var WriteOpSchema = import_zod49.z.enum([
   "create",
   "update",
   "patch",
   "delete"
 ]);
-var ReadOpSchema = import_zod39.z.enum([
+var ReadOpSchema = import_zod49.z.enum([
   "findAll",
   "findOne"
 ]);
-var ResourceHooksSchema = import_zod39.z.object({
-  beforeWrite: import_zod39.z.custom().optional(),
-  afterWrite: import_zod39.z.custom().optional(),
-  afterRead: import_zod39.z.custom().optional(),
-  beforeFindAll: import_zod39.z.custom().optional(),
-  afterFindAll: import_zod39.z.custom().optional()
+var ResourceHooksSchema = import_zod49.z.object({
+  beforeWrite: import_zod49.z.custom().optional(),
+  afterWrite: import_zod49.z.custom().optional(),
+  afterRead: import_zod49.z.custom().optional(),
+  beforeFindAll: import_zod49.z.custom().optional(),
+  afterFindAll: import_zod49.z.custom().optional()
 });
 
 // src/lib/crud/hooks/hooks.loader.ts
@@ -5363,9 +5624,9 @@ var validateCustomRepository = /* @__PURE__ */ __name((config, repository, adapt
 }, "validateCustomRepository");
 
 // src/lib/crud/schema.utils.ts
-var import_zod40 = require("zod");
+var import_zod50 = require("zod");
 function isZodSchema(schema) {
-  return schema instanceof import_zod40.ZodObject;
+  return schema instanceof import_zod50.ZodObject;
 }
 __name(isZodSchema, "isZodSchema");
 var dropNullableFromRequired2 = /* @__PURE__ */ __name((jsonSchema) => {
@@ -5377,7 +5638,7 @@ function toJsonSchema2(schema) {
   if (isZodSchema(schema)) {
     let jsonSchema;
     try {
-      jsonSchema = (0, import_zod40.toJSONSchema)(schema, {
+      jsonSchema = (0, import_zod50.toJSONSchema)(schema, {
         target: "openApi3",
         ...jsonSchemaOpts
       });
@@ -6506,26 +6767,26 @@ var import_common20 = require("@nestjs/common");
 var import_swagger8 = require("@nestjs/swagger");
 
 // src/lib/crud/resource/PatchResourceJson.schema.ts
-var import_zod41 = require("zod");
-var FieldVariantPatchSchema = import_zod41.z.object({
-  type: import_zod41.z.string().nullable().optional(),
-  format: import_zod41.z.string().nullable().optional(),
-  resource: import_zod41.z.string().nullable().optional(),
-  position: import_zod41.z.number().nullable().optional(),
-  options: import_zod41.z.record(import_zod41.z.string(), import_zod41.z.unknown().nullable()).optional()
+var import_zod51 = require("zod");
+var FieldVariantPatchSchema = import_zod51.z.object({
+  type: import_zod51.z.string().nullable().optional(),
+  format: import_zod51.z.string().nullable().optional(),
+  resource: import_zod51.z.string().nullable().optional(),
+  position: import_zod51.z.number().nullable().optional(),
+  options: import_zod51.z.record(import_zod51.z.string(), import_zod51.z.unknown().nullable()).optional()
 }).partial();
-var PatchColumnSchema = import_zod41.z.object({
-  label: import_zod41.z.string().optional(),
-  column: import_zod41.z.string().optional(),
-  hiddenInTable: import_zod41.z.boolean().optional(),
-  hiddenInForm: import_zod41.z.boolean().optional(),
-  hiddenInView: import_zod41.z.boolean().optional(),
+var PatchColumnSchema = import_zod51.z.object({
+  label: import_zod51.z.string().optional(),
+  column: import_zod51.z.string().optional(),
+  hiddenInTable: import_zod51.z.boolean().optional(),
+  hiddenInForm: import_zod51.z.boolean().optional(),
+  hiddenInView: import_zod51.z.boolean().optional(),
   fieldInput: FieldVariantPatchSchema.optional(),
   fieldView: FieldVariantPatchSchema.optional(),
   fieldTable: FieldVariantPatchSchema.optional()
 }).partial();
-var PatchResourceJsonSchema = import_zod41.z.object({
-  columns: import_zod41.z.record(import_zod41.z.string(), PatchColumnSchema)
+var PatchResourceJsonSchema = import_zod51.z.object({
+  columns: import_zod51.z.record(import_zod51.z.string(), PatchColumnSchema)
 });
 
 // src/lib/crud/resource/WriteResourceJson.ts
@@ -7720,9 +7981,32 @@ var resolve4 = /* @__PURE__ */ __name(async (diff2, resolver = recommendedResolv
 
 // ../crouton-codegen/src/serialize.ts
 var RESOURCE_SCHEMA_URL = `https://ghentcdh.github.io/crouton/schema/v${CURRENT_RESOURCE_VERSION}/resource.schema.json`;
+var FIELD_INPUT_SCHEMA_BASE = `https://ghentcdh.github.io/crouton/schema/v${CURRENT_RESOURCE_VERSION}`;
+var stampFieldInputSchema = /* @__PURE__ */ __name((fi) => {
+  const type = fi.type;
+  if (!type) return fi;
+  const def2 = fieldInputRegistry.get(type);
+  if (!def2) return fi;
+  const { $schema: _old, ...rest } = fi;
+  return {
+    $schema: `${FIELD_INPUT_SCHEMA_BASE}/${def2.schemaFile}.field-input.schema.json`,
+    ...rest
+  };
+}, "stampFieldInputSchema");
 var withResourceHeader = /* @__PURE__ */ __name((config, opts = {}) => {
   const { $schema: _schema, schemaVersion: _version, draft: existingDraft, kind: existingKind, ...rest } = config;
   const draft = opts.draft !== void 0 ? opts.draft : existingDraft;
+  if (Array.isArray(rest.columns)) {
+    rest.columns = rest.columns.map((col) => {
+      const out = {
+        ...col
+      };
+      if (out["fieldInput"] && typeof out["fieldInput"] === "object") out["fieldInput"] = stampFieldInputSchema(out["fieldInput"]);
+      if (out["fieldView"] && typeof out["fieldView"] === "object") out["fieldView"] = stampFieldInputSchema(out["fieldView"]);
+      if (out["fieldTable"] && typeof out["fieldTable"] === "object") out["fieldTable"] = stampFieldInputSchema(out["fieldTable"]);
+      return out;
+    });
+  }
   return {
     $schema: RESOURCE_SCHEMA_URL,
     schemaVersion: CURRENT_RESOURCE_VERSION,
@@ -7952,12 +8236,12 @@ var makeSchemaExportName = /* @__PURE__ */ __name((config) => {
 var resolveFromRoot = /* @__PURE__ */ __name((root, p) => (0, import_node_path11.isAbsolute)(p) ? p : (0, import_node_path11.join)(root, p), "resolveFromRoot");
 
 // ../crouton-codegen/src/scaffold.ts
-var import_zod42 = require("zod");
+var import_zod52 = require("zod");
 var import_promises5 = require("fs/promises");
 var import_node_path12 = require("path");
 var ScallfoldDatasourceSchema = DataSourceShape.extend({
   /** Folder name under `dataSourcesDir`. */
-  folder: import_zod42.z.string().default("default")
+  folder: import_zod52.z.string().default("default")
 }).transform(transformDataSource);
 
 // ../crouton-codegen/src/datasource-scaffold.ts
@@ -8170,7 +8454,7 @@ ${stderr}`.trim()
 }, "prismaGenerate");
 var pullAndGenerate = /* @__PURE__ */ __name(async (input) => {
   const { root, prismaConfigPath, schemaPath } = input;
-  loadDotenv(root);
+  loadDotenv((0, import_node_path15.dirname)(schemaPath));
   const backupPath = await backupSchema(schemaPath);
   const dbPull = await prismaDbPull(root, prismaConfigPath);
   if (!dbPull.ok) return {
@@ -8845,12 +9129,12 @@ DevResourcesController = _ts_decorate8([
 ], DevResourcesController);
 
 // src/lib/crud/enum-registry/enum-registry.types.ts
-var import_zod43 = require("zod");
-var EnumEntrySchema2 = import_zod43.z.object({
-  value: import_zod43.z.unknown(),
-  label: import_zod43.z.string()
+var import_zod53 = require("zod");
+var EnumEntrySchema2 = import_zod53.z.object({
+  value: import_zod53.z.unknown(),
+  label: import_zod53.z.string()
 });
-var EnumRegistrySchema2 = import_zod43.z.record(import_zod43.z.string(), import_zod43.z.array(EnumEntrySchema2)).default({});
+var EnumRegistrySchema2 = import_zod53.z.record(import_zod53.z.string(), import_zod53.z.array(EnumEntrySchema2)).default({});
 
 // src/lib/crud/enum-registry/enum-registry.loader.ts
 var import_node_fs8 = require("fs");
@@ -8985,9 +9269,9 @@ var buildResourceDefinitions2 = /* @__PURE__ */ __name((schema, operations, enri
 }, "buildResourceDefinitions");
 
 // src/lib/crud/adapter/relation-type.ts
-var import_zod44 = require("zod");
+var import_zod54 = require("zod");
 var unwrapZodType = /* @__PURE__ */ __name((type) => {
-  if (type instanceof import_zod44.ZodOptional || type instanceof import_zod44.ZodNullable) {
+  if (type instanceof import_zod54.ZodOptional || type instanceof import_zod54.ZodNullable) {
     return unwrapZodType(type.unwrap());
   }
   return type;
@@ -8997,7 +9281,7 @@ var deriveRelationType = /* @__PURE__ */ __name((schema, columnId) => {
   const field = schema.shape[columnId];
   if (!field) return void 0;
   const inner = unwrapZodType(field);
-  return inner instanceof import_zod44.ZodArray ? "oneToMany" : "manyToOne";
+  return inner instanceof import_zod54.ZodArray ? "oneToMany" : "manyToOne";
 }, "deriveRelationType");
 var deriveRelationTypeFromColumns = /* @__PURE__ */ __name((col, cols) => {
   const base = col.column ?? col.id;