@ghentcdh/crouton-api 0.0.1-alpha.78 → 0.0.1-alpha.80

package/dist/index.cjs

@@ -670,7 +670,7 @@ var LayoutControlSchema = import_zod8.z.union([
   import_zod8.z.object({
     id: import_zod8.z.string(),
     colspan: import_zod8.z.number().int().min(1).max(12).optional(),
-    rowspan: import_zod8.z.number().int().min(1).optional(),
+    rowspan: import_zod8.z.number().int().min(1).max(6).optional(),
     width: import_zod8.z.string().optional(),
     label: import_zod8.z.string().optional(),
     hideLabel: import_zod8.z.boolean().optional(),
@@ -690,7 +690,7 @@ var LayoutNodeSchema = import_zod8.z.lazy(() => import_zod8.z.object({
   title: import_zod8.z.string().optional(),
   titleKey: import_zod8.z.string().optional(),
   colspan: import_zod8.z.number().int().min(1).max(12).optional(),
-  rowspan: import_zod8.z.number().int().min(1).optional(),
+  rowspan: import_zod8.z.number().int().min(1).max(6).optional(),
   label: import_zod8.z.string().optional(),
   controls: import_zod8.z.array(LayoutControlSchema).optional(),
   items: import_zod8.z.array(LayoutNodeSchema).optional()
@@ -702,152 +702,526 @@ var LayoutSchema = import_zod8.z.object({
 });
 
 // ../crouton-core/src/lib/resource/ResourceJson.schema.ts
-var import_zod30 = require("zod");
+var import_zod31 = require("zod");
 
 // ../crouton-core/src/lib/resource/CalculatedColumn.schema.ts
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 
 // ../crouton-core/src/lib/resource/FieldInput.schema.ts
-var import_zod19 = require("zod");
+var import_zod20 = 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");
+
+// ../crouton-core/src/lib/resource/field-input/option-meta.ts
+var opt = /* @__PURE__ */ __name((schema, meta) => schema.meta(meta), "opt");
+
+// ../crouton-core/src/lib/resource/field-input/base.options.ts
 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());
+  label: opt(import_zod9.z.string().optional(), {
+    description: "Override the field label",
+    examples: [
+      "My label"
+    ]
+  }),
+  hideLabel: opt(import_zod9.z.boolean().optional(), {
+    description: "Hide the field label"
+  }),
+  placeholder: opt(import_zod9.z.string().optional(), {
+    description: "Placeholder text shown inside the input when empty",
+    examples: [
+      "Search..."
+    ]
+  }),
+  readonly: opt(import_zod9.z.boolean().optional(), {
+    description: "Render the field in read-only mode"
+  }),
+  colspan: opt(import_zod9.z.number().optional(), {
+    description: "Grid column span (1\u201312)",
+    examples: [
+      6,
+      12
+    ]
+  }),
+  width: opt(import_zod9.z.string().optional(), {
+    description: "Named width (xs, sm, md, lg, xl, full) or any CSS value",
+    examples: [
+      "md",
+      "240px"
+    ]
+  }),
+  styles: opt(import_zod9.z.record(import_zod9.z.string(), import_zod9.z.unknown()).optional(), {
+    description: "Inline CSS style object applied to the field wrapper",
+    examples: [
+      {
+        color: "red"
+      }
+    ]
+  }),
+  customRender: opt(import_zod9.z.string().optional(), {
+    description: "Name of a globally registered Vue component to render instead of the default input",
+    examples: [
+      "MyCustomInput"
+    ]
+  })
+}).catchall(import_zod9.z.unknown()).meta({
+  title: "Base options",
+  description: "Accepted by every field input type"
+});
 
 // ../crouton-core/src/lib/resource/field-input/types/array.options.ts
 var ArrayOptionsSchema = BaseOptionsSchema.extend({
-  layout: import_zod10.z.enum([
+  layout: opt(import_zod10.z.enum([
     "row",
     "column"
-  ]).optional(),
-  elementLabelProp: import_zod10.z.string().optional(),
-  hideActions: import_zod10.z.boolean().optional()
+  ]).optional(), {
+    description: "Direction in which array items are stacked",
+    examples: [
+      "row",
+      "column"
+    ]
+  }),
+  elementLabelProp: opt(import_zod10.z.string().optional(), {
+    description: "Property of each array item used as its label in the UI",
+    examples: [
+      "name",
+      "title"
+    ]
+  }),
+  hideActions: opt(import_zod10.z.boolean().optional(), {
+    description: "Hide the add/remove action buttons"
+  })
+}).meta({
+  title: "Array options",
+  description: "Options for the detail/array layout control"
 });
 
 // ../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()
+  labelKey: opt(import_zod11.z.string().optional(), {
+    description: "Object key used as the display label in the dropdown",
+    examples: [
+      "label",
+      "name"
+    ]
+  }),
+  valueKey: opt(import_zod11.z.string().optional(), {
+    description: "Object key used as the stored value",
+    examples: [
+      "value",
+      "id"
+    ]
+  }),
+  freeText: opt(import_zod11.z.boolean().optional(), {
+    description: "Allow the user to type a value not in the options list"
+  }),
+  enableCreate: opt(import_zod11.z.boolean().optional(), {
+    description: 'Show a "create" action when no matching option is found'
+  }),
+  storeValue: opt(import_zod11.z.boolean().optional(), {
+    description: "Store option[valueKey] instead of the whole option object"
+  })
+}).meta({
+  title: "Common autocomplete options",
+  description: "Shared options available on all autocomplete variants"
 });
 var AutocompleteInlineOptionsSchema = AutocompleteBaseSchema.extend({
-  options: import_zod11.z.array(import_zod11.z.unknown()),
-  values: import_zod11.z.array(import_zod11.z.unknown()).optional()
+  options: opt(import_zod11.z.array(import_zod11.z.unknown()), {
+    description: "Inline array of option items",
+    examples: [
+      [
+        {
+          label: "Active",
+          value: "active"
+        }
+      ]
+    ]
+  }),
+  values: opt(import_zod11.z.array(import_zod11.z.unknown()).optional(), {
+    description: "Alias for options (deprecated \u2014 prefer options)",
+    deprecated: true
+  })
+}).meta({
+  title: "Inline autocomplete",
+  description: "Options provided as an inline array"
 });
 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()
+  uri: opt(import_zod11.z.string(), {
+    description: "Remote endpoint URL that returns option items",
+    examples: [
+      "/api/authors"
+    ]
+  }),
+  dataField: opt(import_zod11.z.string().optional(), {
+    description: "Field in the API response containing the data array",
+    examples: [
+      "data",
+      "results"
+    ]
+  }),
+  skipAuth: opt(import_zod11.z.boolean().optional(), {
+    description: "Send the request without authentication headers"
+  })
+}).meta({
+  title: "Remote autocomplete",
+  description: "Options fetched from a remote endpoint"
 });
 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()
+  resource: opt(import_zod11.z.string(), {
+    description: "Relative path to a resource.json used to populate the options",
+    examples: [
+      "./author.resource.json"
+    ]
+  }),
+  skipAuth: opt(import_zod11.z.boolean().optional(), {
+    description: "Send the request without authentication headers"
+  }),
+  dataField: opt(import_zod11.z.string().optional(), {
+    description: "Field in the API response containing the data array",
+    examples: [
+      "data",
+      "results"
+    ]
+  })
+}).meta({
+  title: "Resource autocomplete",
+  description: "Options populated from a crouton resource"
 });
 var AutocompleteOptionsSchema = import_zod11.z.union([
   AutocompleteInlineOptionsSchema,
   AutocompleteRemoteOptionsSchema,
   AutocompleteResourceOptionsSchema,
   AutocompleteBaseSchema
-]).describe("Autocomplete options: inline array, remote URI, or resource reference");
+]).meta({
+  title: "Autocomplete options",
+  description: "Autocomplete options: inline array, remote URI, or resource reference"
+});
 
 // ../crouton-core/src/lib/resource/field-input/types/boolean.options.ts
-var BooleanOptionsSchema = BaseOptionsSchema.extend({});
+var BooleanOptionsSchema = BaseOptionsSchema.extend({}).meta({
+  title: "Boolean options",
+  description: "Checkbox input. All common options apply; no type-specific options."
+});
 
 // ../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());
+  customRender: opt(import_zod12.z.string().optional(), {
+    description: "Name of the globally registered Vue component to render (overrides the base option)",
+    examples: [
+      "MyWidget"
+    ]
+  })
+}).catchall(import_zod12.z.unknown()).meta({
+  title: "Custom options",
+  description: "Options for app-registered custom renderer components"
+});
 
 // ../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"')
+  fromLabel: opt(import_zod13.z.string().optional(), {
+    description: "Label above the start date input",
+    default: "From",
+    examples: [
+      "From",
+      "Start date"
+    ]
+  }),
+  toLabel: opt(import_zod13.z.string().optional(), {
+    description: "Label above the end date input",
+    default: "To",
+    examples: [
+      "To",
+      "End date"
+    ]
+  }),
+  fromField: opt(import_zod13.z.string().optional(), {
+    description: "JSON object key for the start date",
+    default: "from",
+    examples: [
+      "from",
+      "startDate"
+    ]
+  }),
+  toField: opt(import_zod13.z.string().optional(), {
+    description: "JSON object key for the end date",
+    default: "to",
+    examples: [
+      "to",
+      "endDate"
+    ]
+  })
+}).meta({
+  title: "Date-range options",
+  description: "Options for the from/to date range picker"
 });
 
 // ../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)
+  withTime: opt(import_zod14.z.boolean().optional(), {
+    description: "Force time input on/off, overrides format detection"
+  }),
+  min: opt(import_zod14.z.string().optional(), {
+    description: "Earliest selectable date (ISO 8601 or yyyy-MM-dd)",
+    examples: [
+      "2020-01-01"
+    ]
+  }),
+  max: opt(import_zod14.z.string().optional(), {
+    description: "Latest selectable date (ISO 8601 or yyyy-MM-dd)",
+    examples: [
+      "2099-12-31"
+    ]
+  }),
+  locale: opt(import_zod14.z.string().optional().default("en-GB"), {
+    description: "BCP-47 locale for month heading and weekday labels",
+    examples: [
+      "en-GB",
+      "nl-BE"
+    ],
+    default: "en-GB"
+  }),
+  firstDayOfWeek: opt(import_zod14.z.number().optional().default(1), {
+    description: "First day of the week: 0 = Sunday, 1 = Monday",
+    examples: [
+      0,
+      1
+    ],
+    default: 1
+  })
+}).meta({
+  title: "Date options",
+  description: "Options for the date picker (and dateTime alias)"
 });
 
 // ../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"')
+  minHeight: opt(import_zod15.z.string().optional(), {
+    description: "Minimum editor height",
+    examples: [
+      "200px",
+      "400px"
+    ]
+  })
+}).meta({
+  title: "Markdown options",
+  description: "Options for the Markdown rich-text editor"
 });
 
 // ../crouton-core/src/lib/resource/field-input/types/number.options.ts
-var NumberOptionsSchema = BaseOptionsSchema.extend({});
+var NumberOptionsSchema = BaseOptionsSchema.extend({}).meta({
+  title: "Number options",
+  description: "Numeric input (also used for Integer alias). All common options apply; no type-specific options."
+});
 
 // ../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([
+  colspan: opt(import_zod16.z.number().optional().default(12), {
+    description: "Grid column span (1\u201312); defaults to 12 for relation controls",
+    default: 12,
+    examples: [
+      12,
+      6
+    ]
+  }),
+  sort: opt(import_zod16.z.string().optional(), {
+    description: "Field to sort related records by",
+    examples: [
+      "name",
+      "createdAt"
+    ]
+  }),
+  sortDir: opt(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());
+  ]).optional(), {
+    description: "Sort direction",
+    default: "asc",
+    examples: [
+      "asc",
+      "desc"
+    ]
+  }),
+  direction: opt(import_zod16.z.string().optional(), {
+    description: "CSS flex direction for the button layout",
+    examples: [
+      "row",
+      "column"
+    ]
+  }),
+  displayKey: opt(import_zod16.z.string().optional(), {
+    description: "Key used as the display label for related records",
+    examples: [
+      "name",
+      "title"
+    ]
+  }),
+  resource: opt(import_zod16.z.string().optional(), {
+    description: "Path to the related resource.json",
+    examples: [
+      "./author.resource.json"
+    ]
+  })
+}).catchall(import_zod16.z.unknown()).meta({
+  title: "Relation options",
+  description: "Options for the sub-resource relation control"
+});
 
 // ../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")
+  options: opt(import_zod17.z.array(import_zod17.z.unknown()).optional(), {
+    description: "Inline array of option items",
+    examples: [
+      [
+        {
+          label: "Active",
+          value: "active"
+        }
+      ]
+    ]
+  }),
+  values: opt(import_zod17.z.array(import_zod17.z.unknown()).optional(), {
+    description: "Alias for options (deprecated \u2014 prefer options)",
+    deprecated: true
+  }),
+  resource: opt(import_zod17.z.string().optional(), {
+    description: "Relative path to a resource.json used to populate the options",
+    examples: [
+      "./status.resource.json"
+    ]
+  }),
+  labelKey: opt(import_zod17.z.string().optional(), {
+    description: "Object key used as the display label",
+    examples: [
+      "label",
+      "name"
+    ]
+  }),
+  valueKey: opt(import_zod17.z.string().optional(), {
+    description: "Object key used as the stored value",
+    examples: [
+      "value",
+      "id"
+    ]
+  }),
+  uri: opt(import_zod17.z.string().optional(), {
+    description: "Remote endpoint URL for fetching options",
+    examples: [
+      "/api/statuses"
+    ]
+  }),
+  dataField: opt(import_zod17.z.string().optional(), {
+    description: "Field in the API response containing the data array",
+    examples: [
+      "data",
+      "results"
+    ]
+  }),
+  clearable: opt(import_zod17.z.boolean().optional(), {
+    description: "Show a clear button to remove the selected value"
+  }),
+  storeValue: opt(import_zod17.z.boolean().optional(), {
+    description: "Store option[valueKey] instead of the whole option object"
+  })
+}).meta({
+  title: "Select options",
+  description: "Options for the select dropdown and multi-select (mutliSelect alias)"
 });
 
 // ../crouton-core/src/lib/resource/field-input/types/string.options.ts
-var StringOptionsSchema = BaseOptionsSchema.extend({});
+var import_zod18 = require("zod");
+var NormalizedUniqueSchema = import_zod18.z.object({
+  enabled: import_zod18.z.boolean(),
+  scope: import_zod18.z.array(import_zod18.z.string()).optional(),
+  caseInsensitive: import_zod18.z.boolean().optional(),
+  message: import_zod18.z.string().optional()
+});
+var StringOptionsSchema = BaseOptionsSchema.extend({
+  /** Async uniqueness validation: present when the column declares `unique`. */
+  unique: NormalizedUniqueSchema.optional().meta({
+    description: "Async uniqueness validation: present when the column declares `unique`."
+  })
+}).meta({
+  title: "String options",
+  description: "Plain text input. All common options apply; no type-specific options."
+});
 
 // ../crouton-core/src/lib/resource/field-input/types/textarea.options.ts
-var TextareaOptionsSchema = BaseOptionsSchema.extend({});
+var TextareaOptionsSchema = BaseOptionsSchema.extend({}).meta({
+  title: "Textarea options",
+  description: "Multi-line text input. All common options apply; no type-specific options."
+});
 
 // ../crouton-core/src/lib/resource/field-input/types/toggle.options.ts
-var import_zod18 = require("zod");
+var import_zod19 = 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")
+  options: opt(import_zod19.z.array(import_zod19.z.unknown()).optional(), {
+    description: "Array of option items rendered as toggle buttons",
+    examples: [
+      [
+        {
+          label: "Yes",
+          value: true
+        },
+        {
+          label: "No",
+          value: false
+        }
+      ]
+    ]
+  }),
+  values: opt(import_zod19.z.array(import_zod19.z.unknown()).optional(), {
+    description: "Alias for options (deprecated \u2014 prefer options)",
+    deprecated: true
+  }),
+  labelKey: opt(import_zod19.z.string().optional(), {
+    description: "Object key used as the button label",
+    examples: [
+      "label"
+    ]
+  }),
+  valueKey: opt(import_zod19.z.string().optional(), {
+    description: "Object key used as the stored value",
+    examples: [
+      "value"
+    ]
+  }),
+  storeValue: opt(import_zod19.z.boolean().optional(), {
+    description: "Store option[valueKey] instead of the whole option object"
+  }),
+  clearable: opt(import_zod19.z.boolean().optional().default(true), {
+    description: "Clicking the active button again clears the value",
+    default: true
+  }),
+  color: opt(import_zod19.z.string().optional().default("primary"), {
+    description: "Color token applied to the active button",
+    examples: [
+      "primary",
+      "secondary"
+    ],
+    default: "primary"
+  }),
+  size: opt(import_zod19.z.string().optional().default("sm"), {
+    description: "Size token for the buttons",
+    examples: [
+      "sm",
+      "md",
+      "lg"
+    ],
+    default: "sm"
+  })
+}).meta({
+  title: "Toggle options",
+  description: "Options for the toggle button-group control"
 });
 
 // ../crouton-core/src/lib/resource/field-input/registry.ts
@@ -967,42 +1341,42 @@ var fieldInputRegistry = /* @__PURE__ */ new Map([
 ]);
 
 // ../crouton-core/src/lib/resource/FieldInput.schema.ts
-var RelationType = import_zod19.z.enum([
+var RelationType = import_zod20.z.enum([
   "oneToOne",
   "manyToOne",
   "oneToMany",
   "manyToMany"
 ]);
-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 DetailControlSchema = import_zod20.z.object({
+  property: import_zod20.z.string(),
+  type: import_zod20.z.string().optional(),
+  options: import_zod20.z.record(import_zod20.z.string(), import_zod20.z.unknown()).optional(),
+  hideLabel: import_zod20.z.boolean().optional(),
+  width: import_zod20.z.string().optional()
 });
-var DetailConfigSchema = import_zod19.z.object({
-  layout: import_zod19.z.enum([
+var DetailConfigSchema = import_zod20.z.object({
+  layout: import_zod20.z.enum([
     "collapse",
     "row"
   ]),
-  titleKey: import_zod19.z.string().optional(),
-  controls: import_zod19.z.array(DetailControlSchema)
+  titleKey: import_zod20.z.string().optional(),
+  controls: import_zod20.z.array(DetailControlSchema)
 });
-var FieldInputSchema = import_zod19.z.object({
-  $schema: import_zod19.z.string().optional(),
-  type: import_zod19.z.string().optional(),
-  customRender: import_zod19.z.string().optional(),
+var FieldInputSchema = import_zod20.z.object({
+  $schema: import_zod20.z.string().optional(),
+  type: import_zod20.z.string().optional(),
+  customRender: import_zod20.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_zod19.z.string().optional(),
+  format: import_zod20.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_zod19.z.string().optional(),
+  resource: import_zod20.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).
@@ -1011,11 +1385,11 @@ var FieldInputSchema = import_zod19.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_zod19.z.string().optional(),
+  foreignKey: import_zod20.z.string().optional(),
   /** Override the Prisma relation field name when it differs from the column id. */
-  relation: import_zod19.z.string().optional(),
+  relation: import_zod20.z.string().optional(),
   /** Override the display order in form views. Lower values come first. */
-  position: import_zod19.z.number().optional(),
+  position: import_zod20.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
@@ -1028,10 +1402,10 @@ var FieldInputSchema = import_zod19.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_zod19.z.unknown().optional(),
-  options: import_zod19.z.union([
+  defaultValue: import_zod20.z.unknown().optional(),
+  options: import_zod20.z.union([
     RelationOptionsSchema,
-    import_zod19.z.unknown()
+    import_zod20.z.unknown()
   ]).optional(),
   /** Nested array detail layout (renders via `detailFixed`). */
   detail: DetailConfigSchema.optional()
@@ -1082,16 +1456,16 @@ var normalizeLabel = /* @__PURE__ */ __name((obj) => {
 }, "normalizeLabel");
 
 // ../crouton-core/src/lib/resource/CalculatedColumn.schema.ts
-var CalculatedColumnSchema = import_zod20.z.object({
+var CalculatedColumnSchema = import_zod21.z.object({
   /** Column identifier used in the response payload and UI schema. */
-  id: import_zod20.z.string(),
+  id: import_zod21.z.string(),
   /** SQL alias — must match `id`. */
-  alias: import_zod20.z.string(),
+  alias: import_zod21.z.string(),
   /** Human-readable label shown in the table header. */
-  label: import_zod20.z.string().optional(),
-  sqlExpression: import_zod20.z.string(),
+  label: import_zod21.z.string().optional(),
+  sqlExpression: import_zod21.z.string(),
   /** JSON schema / cast type for the computed value. Defaults to `"number"`. `"string"` skips CAST. */
-  type: import_zod20.z.enum([
+  type: import_zod21.z.enum([
     "number",
     "boolean",
     "string"
@@ -1102,9 +1476,9 @@ var CalculatedColumnSchema = import_zod20.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_zod20.z.number().optional(),
-  hiddenInTable: import_zod20.z.boolean().optional(),
-  hiddenInView: import_zod20.z.boolean().optional(),
+  position: import_zod21.z.number().optional(),
+  hiddenInTable: import_zod21.z.boolean().optional(),
+  hiddenInView: import_zod21.z.boolean().optional(),
   /**
    * Field input options for rendering in form / view schemas.
    * Supports `colspan`, `format`, and any other options passed to the Control renderer.
@@ -1114,11 +1488,11 @@ var CalculatedColumnSchema = import_zod20.z.object({
 }).transform(normalizeLabel);
 
 // ../crouton-core/src/lib/resource/Column.ts
-var import_zod22 = require("zod");
+var import_zod23 = require("zod");
 
 // ../crouton-core/src/lib/resource/ColumnType.schema.ts
-var import_zod21 = require("zod");
-var ColumnTypeShorthandSchema = import_zod21.z.enum([
+var import_zod22 = require("zod");
+var ColumnTypeShorthandSchema = import_zod22.z.enum([
   "string",
   "number",
   "integer",
@@ -1128,36 +1502,36 @@ var ColumnTypeShorthandSchema = import_zod21.z.enum([
   "object",
   "array"
 ]);
-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)
+var JsonSchemaFragmentSchema = import_zod22.z.lazy(() => import_zod22.z.object({
+  type: import_zod22.z.union([
+    import_zod22.z.string(),
+    import_zod22.z.array(import_zod22.z.string()),
+    import_zod22.z.lazy(() => JsonSchemaFragmentSchema)
   ]).optional(),
-  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()
+  format: import_zod22.z.string().optional(),
+  enum: import_zod22.z.array(import_zod22.z.unknown()).optional(),
+  const: import_zod22.z.unknown().optional(),
+  nullable: import_zod22.z.boolean().optional(),
+  properties: import_zod22.z.record(import_zod22.z.string(), JsonSchemaFragmentSchema).optional(),
+  required: import_zod22.z.union([
+    import_zod22.z.array(import_zod22.z.string()),
+    import_zod22.z.boolean()
   ]).optional(),
   items: JsonSchemaFragmentSchema.optional(),
-  additionalProperties: import_zod21.z.union([
-    import_zod21.z.boolean(),
+  additionalProperties: import_zod22.z.union([
+    import_zod22.z.boolean(),
     JsonSchemaFragmentSchema
   ]).optional(),
-  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([
+  title: import_zod22.z.string().optional(),
+  description: import_zod22.z.string().optional(),
+  default: import_zod22.z.unknown().optional(),
+  minimum: import_zod22.z.number().optional(),
+  maximum: import_zod22.z.number().optional(),
+  minLength: import_zod22.z.number().optional(),
+  maxLength: import_zod22.z.number().optional(),
+  pattern: import_zod22.z.string().optional()
+}).catchall(import_zod22.z.unknown()));
+var ColumnTypeSchema = import_zod22.z.union([
   ColumnTypeShorthandSchema,
   JsonSchemaFragmentSchema
 ]);
@@ -1261,40 +1635,73 @@ 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_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 UniqueConfigSchema = import_zod23.z.object({
+  /** Other column ids the uniqueness is scoped by (composite unique). */
+  scope: import_zod23.z.array(import_zod23.z.string()).optional(),
+  /** Compare case-insensitively (maps to Prisma `mode: 'insensitive'`). */
+  caseInsensitive: import_zod23.z.boolean().optional(),
+  /** Message shown on the field when the value is already taken. */
+  message: import_zod23.z.string().optional()
+});
+var UniqueSchema = import_zod23.z.union([
+  import_zod23.z.boolean(),
+  UniqueConfigSchema
+]);
+var normalizeUnique = /* @__PURE__ */ __name((unique) => {
+  if (!unique) return void 0;
+  if (unique === true) return {
+    enabled: true
+  };
+  return {
+    enabled: true,
+    ...unique
+  };
+}, "normalizeUnique");
+var WhenConditionSchema = import_zod23.z.object({
+  field: import_zod23.z.string(),
+  eq: import_zod23.z.unknown().optional(),
+  neq: import_zod23.z.unknown().optional(),
+  exists: import_zod23.z.boolean().optional(),
+  notExists: import_zod23.z.boolean().optional()
 });
-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),
+var JsonColumnSchema = import_zod23.z.object({
+  id: import_zod23.z.string(),
+  column: import_zod23.z.string().optional(),
+  label: import_zod23.z.string().optional(),
+  hiddenInTable: import_zod23.z.boolean().default(false),
+  hiddenInForm: import_zod23.z.boolean().default(false),
+  hiddenInView: import_zod23.z.boolean().default(false),
+  sortable: import_zod23.z.boolean().default(false),
+  defaultSort: import_zod23.z.boolean().default(false),
+  searchable: import_zod23.z.boolean().default(false),
+  filterable: import_zod23.z.boolean().default(false),
+  createable: import_zod23.z.boolean().default(true),
+  updateable: import_zod23.z.boolean().default(true),
+  hideLabel: import_zod23.z.boolean().default(false),
   showWhen: WhenConditionSchema.optional(),
   hideWhen: WhenConditionSchema.optional(),
   disabledWhen: WhenConditionSchema.optional(),
-  displayKey: import_zod22.z.string().optional(),
-  sortId: import_zod22.z.string().optional(),
+  displayKey: import_zod23.z.string().optional(),
+  sortId: import_zod23.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_zod22.z.string().optional(),
-  idField: import_zod22.z.boolean().default(false),
-  showInLookup: import_zod22.z.boolean().default(false),
+  enum: import_zod23.z.string().optional(),
+  idField: import_zod23.z.boolean().default(false),
+  showInLookup: import_zod23.z.boolean().default(false),
+  /**
+  * Enforce that this column's value is unique across the resource. `true` is
+  * simple single-column uniqueness; the object form allows a composite
+  * `scope`, case-insensitive comparison, and a custom `message`.
+  *
+  * Requires a matching DB unique constraint (`@unique` in Prisma) to be
+  * actually enforceable - the flag alone does not create one. The form uses it
+  * to validate as-you-type against a lightweight check endpoint; the API maps
+  * a Prisma unique violation back to this field on write.
+  */
+  unique: UniqueSchema.optional(),
   /**
   * Data type of the column, as a shorthand name (`"string"`, `"integer"`, …)
   * or a full JSON Schema fragment:
@@ -1325,12 +1732,12 @@ var JsonColumnSchema = import_zod22.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_zod22.z.boolean().optional(),
+  required: import_zod23.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_zod22.z.string().default("string"),
+  columnType: import_zod23.z.string().default("string"),
   fieldInput: FieldInputSchema.optional(),
   /**
   * Optional per-context override for the read-only VIEW ui. Same shape as
@@ -1354,27 +1761,27 @@ var JsonColumnSchema = import_zod22.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_zod22.z.string().optional(),
+  extend: import_zod23.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_zod22.z.record(import_zod22.z.string(), import_zod22.z.record(import_zod22.z.string(), import_zod22.z.unknown())).optional()
+  columns: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.record(import_zod23.z.string(), import_zod23.z.unknown())).optional()
 });
 
 // ../crouton-core/src/lib/resource/ParentRef.schema.ts
-var import_zod23 = require("zod");
-var ParentRefSchema = import_zod23.z.object({
+var import_zod24 = require("zod");
+var ParentRefSchema = import_zod24.z.object({
   /** Route segment of the parent, e.g. `"group"`. */
-  route: import_zod23.z.string(),
+  route: import_zod24.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_zod23.z.string().default("parentId"),
+  param: import_zod24.z.string().default("parentId"),
   /** Type of the parent id, used to coerce the path param. Defaults to `'string'`. */
-  idType: import_zod23.z.enum([
+  idType: import_zod24.z.enum([
     "string",
     "number"
   ]).optional()
@@ -1382,37 +1789,37 @@ var ParentRefSchema = import_zod23.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_zod24 = require("zod");
-var ResourceKindSchema = import_zod24.z.enum([
+var import_zod25 = require("zod");
+var ResourceKindSchema = import_zod25.z.enum([
   "prisma",
   "custom"
 ]).default("prisma");
 
 // ../crouton-core/src/lib/resource/Sidebar.schema.ts
-var import_zod25 = __toESM(require("zod"), 1);
-var SidebarGroupSchema = import_zod25.default.object({
+var import_zod26 = __toESM(require("zod"), 1);
+var SidebarGroupSchema = import_zod26.default.object({
   /** Human-readable heading shown in the sidebar. Defaults to a title-cased version of the slug. */
-  label: import_zod25.default.string().optional(),
+  label: import_zod26.default.string().optional(),
   /** Controls the order of this group among top-level sidebar items. */
-  position: import_zod25.default.number().optional()
+  position: import_zod26.default.number().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(),
+var SidebarSchema = import_zod26.default.object({
+  hide: import_zod26.default.boolean().default(false),
+  position: import_zod26.default.number().optional(),
+  label: import_zod26.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_zod25.default.string().optional()
+  group: import_zod26.default.string().optional()
 });
 
 // ../crouton-core/src/lib/resource/TableAction.schema.ts
-var import_zod26 = require("zod");
-var ActionConditionSchema = import_zod26.z.object({
+var import_zod27 = require("zod");
+var ActionConditionSchema = import_zod27.z.object({
   /** Row field to evaluate. */
-  field: import_zod26.z.string(),
+  field: import_zod27.z.string(),
   /**
   * Comparison operator. Defaults to `"eq"`.
   * - `eq` / `neq`         — strict equality
@@ -1420,7 +1827,7 @@ var ActionConditionSchema = import_zod26.z.object({
   * - `exists`             — field is not null / undefined / empty string
   * - `notExists`          — field is null / undefined / empty string
   */
-  op: import_zod26.z.enum([
+  op: import_zod27.z.enum([
     "eq",
     "neq",
     "gt",
@@ -1431,38 +1838,38 @@ var ActionConditionSchema = import_zod26.z.object({
     "notExists"
   ]).default("eq"),
   /** Comparison value. Not required for `exists` / `notExists`. */
-  value: import_zod26.z.unknown().optional()
+  value: import_zod27.z.unknown().optional()
 });
-var ActionSchema = import_zod26.z.object({
-  type: import_zod26.z.string(),
+var ActionSchema = import_zod27.z.object({
+  type: import_zod27.z.string(),
   /** Unique identifier for the action. */
-  id: import_zod26.z.string(),
+  id: import_zod27.z.string(),
   /** Human-readable button label. */
-  label: import_zod26.z.string(),
+  label: import_zod27.z.string(),
   /** MDI icon name, e.g. `"mdi:open-in-new"`. */
-  icon: import_zod26.z.string().optional(),
+  icon: import_zod27.z.string().optional(),
   /** Tooltip text. Falls back to `label` when omitted. */
-  tooltip: import_zod26.z.string().optional(),
+  tooltip: import_zod27.z.string().optional(),
   condition: ActionConditionSchema.optional()
 });
 var JsonProcedureActionSchema = ActionSchema.extend({
-  type: import_zod26.z.literal("procedure").default("procedure"),
+  type: import_zod27.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_zod26.z.string(),
+  procedure: import_zod27.z.string(),
   /** HTTP method for the frontend. Defaults to `"post"`. */
-  method: import_zod26.z.string().optional().default("post"),
+  method: import_zod27.z.string().optional().default("post"),
   /** Static query / body params passed to the endpoint. */
-  data: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.unknown()).optional()
+  data: import_zod27.z.record(import_zod27.z.string(), import_zod27.z.unknown()).optional()
 });
 var JsonLinkActionSchema = ActionSchema.extend({
   /** Optional condition evaluated per row. Button is hidden when the condition is false. */
-  type: import_zod26.z.literal("link").default("link"),
+  type: import_zod27.z.literal("link").default("link"),
   /** URL to open. May contain `{env.VAR}` placeholders. */
-  href: import_zod26.z.string(),
-  blank: import_zod26.z.boolean().optional().default(true)
+  href: import_zod27.z.string(),
+  blank: import_zod27.z.boolean().optional().default(true)
 });
 var transformAction = /* @__PURE__ */ __name((action) => {
   const label = action.label;
@@ -1471,7 +1878,7 @@ var transformAction = /* @__PURE__ */ __name((action) => {
     ...action
   };
 }, "transformAction");
-var JsonActionSchema = import_zod26.z.union([
+var JsonActionSchema = import_zod27.z.union([
   JsonProcedureActionSchema,
   JsonLinkActionSchema
 ]).transform(transformAction);
@@ -1513,14 +1920,14 @@ var registerResourceExtensions = /* @__PURE__ */ __name((map = {}) => Object.ent
 var getResourceExtensions = /* @__PURE__ */ __name(() => registry, "getResourceExtensions");
 
 // ../crouton-core/src/lib/resource/include.schema.ts
-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(),
+var import_zod28 = require("zod");
+var JsonIncludeEntrySchema = import_zod28.z.lazy(() => import_zod28.z.union([
+  import_zod28.z.string(),
+  import_zod28.z.object({
+    relation: import_zod28.z.string(),
+    include: import_zod28.z.array(JsonIncludeEntrySchema).optional(),
     /** Prisma-format orderBy clause applied to the included records. */
-    orderBy: import_zod27.z.record(import_zod27.z.string(), import_zod27.z.unknown()).optional()
+    orderBy: import_zod28.z.record(import_zod28.z.string(), import_zod28.z.unknown()).optional()
   })
 ]));
 
@@ -1529,36 +1936,36 @@ var BASELINE_RESOURCE_VERSION = 1;
 var CURRENT_RESOURCE_VERSION = 1;
 
 // ../crouton-core/src/lib/data-source/Operations.schema.ts
-var import_zod29 = require("zod");
+var import_zod30 = require("zod");
 
 // ../crouton-core/src/lib/data-source/Security.schema.ts
-var import_zod28 = require("zod");
-var SecuritySchema = import_zod28.z.union([
-  import_zod28.z.object({
-    public: import_zod28.z.literal(true)
+var import_zod29 = require("zod");
+var SecuritySchema = import_zod29.z.union([
+  import_zod29.z.object({
+    public: import_zod29.z.literal(true)
   }),
-  import_zod28.z.object({
-    guard: import_zod28.z.union([
-      import_zod28.z.string(),
-      import_zod28.z.array(import_zod28.z.string()).min(1)
+  import_zod29.z.object({
+    guard: import_zod29.z.union([
+      import_zod29.z.string(),
+      import_zod29.z.array(import_zod29.z.string()).min(1)
     ])
   })
 ]);
 
 // ../crouton-core/src/lib/data-source/Operations.schema.ts
-var ExternalOpEntry = import_zod29.z.object({
-  uri: import_zod29.z.string(),
-  method: import_zod29.z.string().optional(),
+var ExternalOpEntry = import_zod30.z.object({
+  uri: import_zod30.z.string(),
+  method: import_zod30.z.string().optional(),
   security: SecuritySchema.optional()
 });
-var OpEntry = import_zod29.z.union([
-  import_zod29.z.boolean(),
+var OpEntry = import_zod30.z.union([
+  import_zod30.z.boolean(),
   ExternalOpEntry,
-  import_zod29.z.object({
+  import_zod30.z.object({
     security: SecuritySchema.optional()
   })
 ]);
-var JsonOperationsSchema = import_zod29.z.object({
+var JsonOperationsSchema = import_zod30.z.object({
   findAll: OpEntry.default(true),
   findOne: OpEntry.default(true),
   create: OpEntry.default(true),
@@ -1610,16 +2017,16 @@ var buildSubResourceOperations = /* @__PURE__ */ __name((ops, baseUri, idField =
 }, "buildSubResourceOperations");
 
 // ../crouton-core/src/lib/resource/ResourceJson.schema.ts
-var JsonColumnsMapSchema = import_zod30.z.record(import_zod30.z.string(), JsonColumnSchema.omit({
+var JsonColumnsMapSchema = import_zod31.z.record(import_zod31.z.string(), JsonColumnSchema.omit({
   id: true
-}).catchall(import_zod30.z.unknown()));
+}).catchall(import_zod31.z.unknown()));
 var ColumnsSchema = JsonColumnsMapSchema;
-var JsonDisplaySchema = import_zod30.z.object({
-  mode: import_zod30.z.enum([
+var JsonDisplaySchema = import_zod31.z.object({
+  mode: import_zod31.z.enum([
     "page",
     "modal"
   ]).default("modal"),
-  customComponent: import_zod30.z.string().nullable().optional().default(null)
+  customComponent: import_zod31.z.string().nullable().optional().default(null)
 });
 var normalizeColumns = /* @__PURE__ */ __name((columns) => {
   if (!columns) return void 0;
@@ -1632,47 +2039,47 @@ var normalizeColumns = /* @__PURE__ */ __name((columns) => {
     label: col.label ?? labelFromId(col.id)
   }));
 }, "normalizeColumns");
-var ResourceJsonShape = import_zod30.z.object({
+var ResourceJsonShape = import_zod31.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_zod30.z.string().optional(),
+  $schema: import_zod31.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_zod30.z.number().int().positive().optional(),
+  schemaVersion: import_zod31.z.number().int().positive().optional(),
   /** When `true`, the resource lives in the repo but is NOT loaded/served (work in progress). */
-  draft: import_zod30.z.boolean().optional().default(false),
+  draft: import_zod31.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_zod30.z.string(),
-  route: import_zod30.z.string().optional(),
-  id: import_zod30.z.string().optional(),
+  name: import_zod31.z.string(),
+  route: import_zod31.z.string().optional(),
+  id: import_zod31.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_zod30.z.string().optional(),
-  tag: import_zod30.z.string().optional().default("Crouton"),
-  title: import_zod30.z.string().optional(),
-  table: import_zod30.z.string().optional(),
+  model: import_zod31.z.string().optional(),
+  tag: import_zod31.z.string().optional().default("Crouton"),
+  title: import_zod31.z.string().optional(),
+  table: import_zod31.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_zod30.z.enum([
+  idType: import_zod31.z.enum([
     "string",
     "number"
   ]).optional(),
-  database: import_zod30.z.string().optional(),
+  database: import_zod31.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.
@@ -1684,12 +2091,12 @@ var ResourceJsonShape = import_zod30.z.object({
   security: SecuritySchema.optional(),
   operations: JsonOperationsSchema.optional(),
   columns: ColumnsSchema.optional().default(ColumnsSchema.parse({})),
-  calculatedColumns: import_zod30.z.array(CalculatedColumnSchema).default([]),
-  actions: import_zod30.z.array(JsonActionSchema).default([]),
+  calculatedColumns: import_zod31.z.array(CalculatedColumnSchema).default([]),
+  actions: import_zod31.z.array(JsonActionSchema).default([]),
   /** Global table-level actions (no record id). Shown as toolbar buttons. */
-  tableActions: import_zod30.z.array(JsonActionSchema).default([]),
+  tableActions: import_zod31.z.array(JsonActionSchema).default([]),
   /** Modal width when opening a form for this resource. */
-  modalSize: import_zod30.z.enum([
+  modalSize: import_zod31.z.enum([
     "xs",
     "sm",
     "lg",
@@ -1702,7 +2109,7 @@ var ResourceJsonShape = import_zod30.z.object({
   * `{ "relation": "text_author", "include": ["author"] }` →
   *   `include: { text_author: { include: { author: true } } }`
   */
-  include: import_zod30.z.array(JsonIncludeEntrySchema).default([]),
+  include: import_zod31.z.array(JsonIncludeEntrySchema).default([]),
   /** Explicit layout for generated views (`form`, `view`, `table`). When absent, source-order grid is used. */
   layout: LayoutSchema.optional()
 });
@@ -1771,7 +2178,7 @@ var buildResourceJsonSchema = /* @__PURE__ */ __name(() => {
     schema.optional()
   ]));
   const shape = ext.size ? ResourceJsonShape.extend(extShape) : ResourceJsonShape;
-  return import_zod30.z.preprocess((raw) => {
+  return import_zod31.z.preprocess((raw) => {
     if (raw && typeof raw === "object" && !Array.isArray(raw)) {
       const obj = raw;
       if (obj["kind"] === void 0 && obj["model"] !== void 0) {
@@ -2165,6 +2572,9 @@ var buildFormControl = /* @__PURE__ */ __name((col) => {
     const type = fieldInput?.type ?? defaultControlFormat(col);
     control.control(type, options).width("full");
   }
+  if (col.unique) control.opt({
+    unique: normalizeUnique(col.unique)
+  });
   if (fieldInput?.customRender) control.setCustomRender(fieldInput?.customRender);
   if (col.hideLabel) control.hideLabel();
   if (col.label) control.label(col.label);
@@ -2258,7 +2668,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_zod32 = require("zod");
+var import_zod33 = require("zod");
 
 // ../crouton-core/src/lib/view/column-type-schema.source.ts
 var optionValues = /* @__PURE__ */ __name((col) => {
@@ -2294,20 +2704,20 @@ var columnTypeSchemaSource = /* @__PURE__ */ __name((schemaCols) => {
 }, "columnTypeSchemaSource");
 
 // ../crouton-core/src/lib/view/json-schema.opts.ts
-var import_zod31 = require("zod");
+var import_zod32 = require("zod");
 var isInstanceOf = /* @__PURE__ */ __name((zodSchema, className) => {
-  if (!(zodSchema instanceof import_zod31.z.ZodCustom)) return false;
+  if (!(zodSchema instanceof import_zod32.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_zod31.z.ZodDate) {
+  if (zodSchema instanceof import_zod32.z.ZodDate) {
     jsonSchema.type = "string";
     jsonSchema.format = "date-time";
   }
-  if (zodSchema instanceof import_zod31.z.ZodBigInt) {
+  if (zodSchema instanceof import_zod32.z.ZodBigInt) {
     jsonSchema.type = "integer";
   }
   if (isInstanceOf(zodSchema, "Decimal") || isInstanceOf(zodSchema, "Decimal2")) {
@@ -2372,8 +2782,10 @@ var applyControlOverrides = /* @__PURE__ */ __name((base, ctrl) => {
   if (ctrl.width !== void 0) base.width(ctrl.width);
   if (ctrl.label !== void 0) base.label(ctrl.label);
   if (ctrl.hideLabel) base.hideLabel();
-  if (ctrl.type !== void 0 || ctrl.options !== void 0) {
-    base.control(ctrl.type ?? "text", ctrl.options);
+  if (ctrl.type !== void 0) {
+    base.control(ctrl.type, ctrl.options);
+  } else if (ctrl.options !== void 0) {
+    base.opt(ctrl.options);
   }
   return base;
 }, "applyControlOverrides");
@@ -2387,10 +2799,6 @@ var buildNodeInto = /* @__PURE__ */ __name((node, colMap, warn, seenIds) => {
         warn(`layout: unknown or hidden column id "${id}" \u2014 skipping`);
         continue;
       }
-      if (typeof ctrl !== "string") {
-        if (ctrl.colspan !== void 0 && ctrl.rowspan !== void 0) {
-        }
-      }
       seenIds.add(id);
       const control = buildFormControl(col);
       container.addControl(applyControlOverrides(control, ctrl));
@@ -2420,7 +2828,7 @@ var buildFormUiSchemaFromLayout = /* @__PURE__ */ __name((node, cols, warn = con
   }
   return root.build();
 }, "buildFormUiSchemaFromLayout");
-var flattenLayoutControlIds = /* @__PURE__ */ __name((node) => {
+var flattenLayoutControlIds = /* @__PURE__ */ __name((node, warn = console.warn) => {
   const ids = [];
   const visit = /* @__PURE__ */ __name((n) => {
     for (const ctrl of n.controls ?? []) {
@@ -2428,6 +2836,7 @@ var flattenLayoutControlIds = /* @__PURE__ */ __name((node) => {
       if (typeof ctrl !== "string") {
         const c = ctrl;
         if (c.colspan !== void 0 || c.rowspan !== void 0) {
+          warn(`layout: colspan/rowspan on table control "${id}" \u2014 ignored, table is flat`);
         }
       }
       ids.push(id);
@@ -2440,7 +2849,7 @@ var flattenLayoutControlIds = /* @__PURE__ */ __name((node) => {
 
 // ../crouton-core/src/lib/view/layout-table-order.ts
 var orderTableColumnsFromLayout = /* @__PURE__ */ __name((view, node, warn = console.warn) => {
-  const orderedIds = flattenLayoutControlIds(node);
+  const orderedIds = flattenLayoutControlIds(node, warn);
   if (!orderedIds.length) return view;
   const elements = view.ui_schema?.elements ?? [];
   const columns = view.columns ?? [];
@@ -2451,7 +2860,7 @@ var orderTableColumnsFromLayout = /* @__PURE__ */ __name((view, node, warn = con
       el
     ];
   }));
-  const columnById = new Map(columns.map((c) => [
+  const columnById2 = new Map(columns.map((c) => [
     c.id,
     c
   ]));
@@ -2469,14 +2878,14 @@ var orderTableColumnsFromLayout = /* @__PURE__ */ __name((view, node, warn = con
     seen.add(id);
     const el = elementById.get(id);
     if (el) reorderedElements.push(el);
-    const col = columnById.get(id);
+    const col = columnById2.get(id);
     if (col) reorderedColumns.push(col);
   }
   for (const el of elements) {
     const id = el.scope?.replace("#/properties/", "");
     if (id && !seen.has(id)) {
       reorderedElements.push(el);
-      const col = columnById.get(id);
+      const col = columnById2.get(id);
       if (col) reorderedColumns.push(col);
     }
   }
@@ -2550,7 +2959,7 @@ var zodSchemaSource = /* @__PURE__ */ __name((schema) => (schemaCols) => {
   ]));
   const picked = schema.pick(mask);
   try {
-    return (0, import_zod32.toJSONSchema)(picked, {
+    return (0, import_zod33.toJSONSchema)(picked, {
       target: "draft-07",
       ...jsonSchemaOpts
     });
@@ -2764,81 +3173,81 @@ var buildViewsFromColumns = /* @__PURE__ */ __name((columns) => {
 }, "buildViewsFromColumns");
 
 // ../crouton-core/src/lib/view/view.schema.ts
-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(),
+var import_zod34 = require("zod");
+var ViewColumnConfigSchema = import_zod34.z.object({
+  id: import_zod34.z.string(),
+  label: import_zod34.z.string().optional(),
+  sortable: import_zod34.z.boolean().optional(),
+  searchable: import_zod34.z.boolean().optional(),
   fieldInput: FieldInputSchema.optional()
 });
-var ViewConfigSchema = import_zod33.z.object({
+var ViewConfigSchema = import_zod34.z.object({
   // TODO why we have both?
-  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(),
+  json_schema: import_zod34.z.record(import_zod34.z.string(), import_zod34.z.unknown()).optional(),
+  ui_schema: import_zod34.z.record(import_zod34.z.string(), import_zod34.z.unknown()).optional(),
   // TODO why we have both?
-  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()
+  ui: import_zod34.z.record(import_zod34.z.string(), import_zod34.z.unknown()).optional(),
+  data: import_zod34.z.record(import_zod34.z.string(), import_zod34.z.unknown()).optional(),
+  columns: import_zod34.z.array(ViewColumnConfigSchema),
+  defaultSort: import_zod34.z.string().optional()
 });
 var viewDefList = [
   "table",
   "view",
   "form"
 ];
-var ViewDefEnum = import_zod33.z.enum(viewDefList);
+var ViewDefEnum = import_zod34.z.enum(viewDefList);
 
 // ../crouton-core/src/lib/compile/enum-registry.ts
-var import_zod34 = require("zod");
-var EnumEntrySchema = import_zod34.z.object({
-  value: import_zod34.z.unknown(),
-  label: import_zod34.z.string()
+var import_zod35 = require("zod");
+var EnumEntrySchema = import_zod35.z.object({
+  value: import_zod35.z.unknown(),
+  label: import_zod35.z.string()
 });
-var EnumRegistrySchema = import_zod34.z.record(import_zod34.z.string(), import_zod34.z.array(EnumEntrySchema)).default({});
+var EnumRegistrySchema = import_zod35.z.record(import_zod35.z.string(), import_zod35.z.array(EnumEntrySchema)).default({});
 
 // ../crouton-core/src/lib/compile/relation-type.ts
-var import_zod35 = require("zod");
+var import_zod36 = require("zod");
 
 // ../crouton-core/src/lib/compile/compiled-resource.schema.ts
-var import_zod42 = require("zod");
+var import_zod43 = require("zod");
 
 // ../crouton-core/src/lib/compile/compiled-sub-resource.schema.ts
-var import_zod38 = require("zod");
+var import_zod39 = require("zod");
 
 // ../crouton-core/src/lib/data-source/DataSourceSchema.ts
-var import_zod36 = __toESM(require("zod"), 1);
-var DataSourceShape = import_zod36.default.object({
+var import_zod37 = __toESM(require("zod"), 1);
+var DataSourceShape = import_zod37.default.object({
   /** Datasource name (folder + `name` in data-source.json). */
-  name: import_zod36.default.string(),
+  name: import_zod37.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_zod36.default.string().optional(),
+  urlEnv: import_zod37.default.string().optional(),
   /** Import path for this datasource's generated Zod types (for resource `schema.ts`). */
-  generatedTypesImport: import_zod36.default.string().optional(),
+  generatedTypesImport: import_zod37.default.string().optional(),
   /** Datasource type tag. Default `postgres`. */
-  type: import_zod36.default.string().default("postgres"),
+  type: import_zod37.default.string().default("postgres"),
   /** Mark this as the default datasource. Default `false`. */
-  default: import_zod36.default.boolean().default(false),
+  default: import_zod37.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_zod36.default.enum([
+  adapter: import_zod37.default.enum([
     "prisma",
     "custom"
   ]).default("prisma"),
   /** Prisma schema path, relative to project root. Default `prisma/<name>/schema.prisma`. */
-  prismaSchema: import_zod36.default.string().optional(),
+  prismaSchema: import_zod37.default.string().optional(),
   /** Prisma config path, relative to project root. Default `prisma/<name>/prisma.config.ts`. */
-  prismaConfig: import_zod36.default.string().optional(),
+  prismaConfig: import_zod37.default.string().optional(),
   /** zod-prisma-types output dir, relative to project root. Default `generated/<name>/src`. */
-  zodOutput: import_zod36.default.string().optional(),
+  zodOutput: import_zod37.default.string().optional(),
   /** Prisma client output dir, relative to project root. Default `generated/<name>/client`. */
-  clientOutput: import_zod36.default.string().optional()
+  clientOutput: import_zod37.default.string().optional()
 });
 var transformDataSource = /* @__PURE__ */ __name((data) => {
   const name = data.name ?? "name";
@@ -2854,88 +3263,88 @@ var transformDataSource = /* @__PURE__ */ __name((data) => {
 var DataSourceSchema = DataSourceShape.transform(transformDataSource);
 
 // ../crouton-core/src/lib/compile/value-label-column.ts
-var import_zod37 = require("zod");
-var ValueSchema = import_zod37.z.object({
-  value: import_zod37.z.unknown(),
-  label: import_zod37.z.string()
+var import_zod38 = require("zod");
+var ValueSchema = import_zod38.z.object({
+  value: import_zod38.z.unknown(),
+  label: import_zod38.z.string()
 });
-var ValueLabelColumnSchema = import_zod37.z.object({
-  field: import_zod37.z.string(),
-  values: import_zod37.z.array(ValueSchema).default([]),
-  enumName: import_zod37.z.string().optional()
+var ValueLabelColumnSchema = import_zod38.z.object({
+  field: import_zod38.z.string(),
+  values: import_zod38.z.array(ValueSchema).default([]),
+  enumName: import_zod38.z.string().optional()
 });
 
 // ../crouton-core/src/lib/compile/compiled-sub-resource.schema.ts
-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([
+var CompiledSubResourceConfigSchema = import_zod39.z.object({
+  column: import_zod39.z.string(),
+  relation: import_zod39.z.string(),
+  childRoute: import_zod39.z.string(),
+  childKind: import_zod39.z.enum([
     "prisma",
     "custom"
   ]).default("prisma"),
-  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([
+  childDir: import_zod39.z.string().optional(),
+  childModel: import_zod39.z.string(),
+  foreignKey: import_zod39.z.string(),
+  name: import_zod39.z.string().optional(),
+  title: import_zod39.z.string().optional(),
+  idField: import_zod39.z.string().optional(),
+  idType: import_zod39.z.enum([
     "string",
     "number"
   ]).optional(),
-  views: import_zod38.z.record(import_zod38.z.string(), ViewConfigSchema).optional(),
+  views: import_zod39.z.record(import_zod39.z.string(), ViewConfigSchema).optional(),
   operations: JsonOperationsSchema,
-  actions: import_zod38.z.array(JsonActionSchema).optional(),
-  modalSize: import_zod38.z.enum([
+  actions: import_zod39.z.array(JsonActionSchema).optional(),
+  modalSize: import_zod39.z.enum([
     "xs",
     "sm",
     "lg",
     "xl"
   ]).optional(),
   display: JsonDisplaySchema.optional(),
-  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([
+  include: import_zod39.z.array(JsonIncludeEntrySchema).optional(),
+  calculatedColumns: import_zod39.z.array(CalculatedColumnSchema).optional(),
+  includeInFindOne: import_zod39.z.boolean().optional(),
+  hiddenInTable: import_zod39.z.boolean().optional(),
+  findOneOrderBy: import_zod39.z.record(import_zod39.z.string(), import_zod39.z.unknown()).optional(),
+  valueLabelColumns: import_zod39.z.array(ValueLabelColumnSchema).optional(),
+  relationType: import_zod39.z.enum([
     "oneToMany",
     "manyToOne"
   ]).optional()
 });
 
 // ../crouton-core/src/lib/compile/definition.schema.ts
-var import_zod40 = require("zod");
+var import_zod41 = require("zod");
 
 // ../crouton-core/src/lib/compile/schema-input.ts
-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 import_zod40 = require("zod");
+var JsonSchemaInputSchema = import_zod40.z.object({
+  type: import_zod40.z.literal("object"),
+  properties: import_zod40.z.record(import_zod40.z.string(), import_zod40.z.unknown()),
+  required: import_zod40.z.array(import_zod40.z.string()).optional(),
+  additionalProperties: import_zod40.z.boolean().optional()
 });
-var SchemaInputSchema = import_zod39.z.union([
-  import_zod39.z.custom((val) => val instanceof import_zod39.ZodObject),
+var SchemaInputSchema = import_zod40.z.union([
+  import_zod40.z.custom((val) => val instanceof import_zod40.ZodObject),
   JsonSchemaInputSchema
 ]);
 
 // ../crouton-core/src/lib/compile/definition.schema.ts
-var ExternalOperationDefSchema = import_zod40.z.object({
-  uri: import_zod40.z.string(),
-  method: import_zod40.z.string().optional()
+var ExternalOperationDefSchema = import_zod41.z.object({
+  uri: import_zod41.z.string(),
+  method: import_zod41.z.string().optional()
 });
-var OperationDefSchema = import_zod40.z.union([
-  import_zod40.z.literal(true),
+var OperationDefSchema = import_zod41.z.union([
+  import_zod41.z.literal(true),
   ExternalOperationDefSchema,
-  import_zod40.z.object({
+  import_zod41.z.object({
     schema: SchemaInputSchema.optional(),
     security: SecuritySchema.optional()
   })
 ]);
-var ResourceDefinitionSchema = import_zod40.z.object({
+var ResourceDefinitionSchema = import_zod41.z.object({
   findAll: OperationDefSchema.optional(),
   findOne: OperationDefSchema.optional(),
   create: OperationDefSchema.optional(),
@@ -2943,93 +3352,348 @@ var ResourceDefinitionSchema = import_zod40.z.object({
   patch: OperationDefSchema.optional(),
   delete: OperationDefSchema.optional()
 });
-var DefinitionCallbackSchema = import_zod40.z.function({
+var DefinitionCallbackSchema = import_zod41.z.function({
   input: [],
   output: ResourceDefinitionSchema
 });
-var DefinitionSchema = import_zod40.z.union([
+var DefinitionSchema = import_zod41.z.union([
   ResourceDefinitionSchema,
   DefinitionCallbackSchema
 ]);
 
 // ../crouton-core/src/lib/compile/lookup.schema.ts
-var import_zod41 = require("zod");
-var LookupSchema = import_zod41.z.object({
-  key: import_zod41.z.string(),
-  label: import_zod41.z.string().optional()
+var import_zod42 = require("zod");
+var LookupSchema = import_zod42.z.object({
+  key: import_zod42.z.string(),
+  label: import_zod42.z.string().optional()
 });
 
 // ../crouton-core/src/lib/compile/compiled-resource.schema.ts
 var CompiledResourceSchema = ResourceJsonShape.extend({
-  route: import_zod42.z.string(),
-  valueLabelColumns: import_zod42.z.array(ValueLabelColumnSchema).default([]),
-  subResources: import_zod42.z.lazy(() => import_zod42.z.array(CompiledSubResourceConfigSchema)).default([]),
+  route: import_zod43.z.string(),
+  valueLabelColumns: import_zod43.z.array(ValueLabelColumnSchema).default([]),
+  subResources: import_zod43.z.lazy(() => import_zod43.z.array(CompiledSubResourceConfigSchema)).default([]),
   lookup: LookupSchema.optional(),
-  views: import_zod42.z.record(import_zod42.z.string(), ViewConfigSchema),
+  views: import_zod43.z.record(import_zod43.z.string(), ViewConfigSchema),
   definition: DefinitionSchema,
-  idField: import_zod42.z.string(),
-  idType: import_zod42.z.enum([
+  idField: import_zod43.z.string(),
+  idType: import_zod43.z.enum([
     "string",
     "number"
   ]).default("string")
 });
 
+// ../crouton-core/src/lib/compile/crud-config.ts
+var resolveDefinition = /* @__PURE__ */ __name((config) => {
+  const def2 = config.definition;
+  return typeof def2 === "function" ? def2() : def2;
+}, "resolveDefinition");
+var isOperationEnabled = /* @__PURE__ */ __name((def2, op) => def2[op] != null, "isOperationEnabled");
+var schemaFor = /* @__PURE__ */ __name((def2, op) => {
+  const entry = def2[op];
+  if (!entry || entry === true) return void 0;
+  return entry.schema;
+}, "schemaFor");
+var isOperationExternal = /* @__PURE__ */ __name((def2, op) => {
+  const entry = def2[op];
+  return typeof entry === "object" && entry !== null && "uri" in entry;
+}, "isOperationExternal");
+var externalRouteFor = /* @__PURE__ */ __name((def2, op) => {
+  const entry = def2[op];
+  if (typeof entry === "object" && entry !== null && "uri" in entry) {
+    return entry.uri;
+  }
+  return void 0;
+}, "externalRouteFor");
+
 // ../crouton-core/src/lib/compile/to-json-schema.ts
-var import_zod43 = require("zod");
+var import_zod44 = require("zod");
+var isZodSchema = /* @__PURE__ */ __name((schema) => schema instanceof import_zod44.ZodObject, "isZodSchema");
+var dropNullableFromRequired2 = /* @__PURE__ */ __name((jsonSchema) => {
+  const { properties, required } = jsonSchema;
+  if (!properties || !Array.isArray(required)) return;
+  jsonSchema.required = required.filter((key) => !isNullableProperty(properties[key]));
+}, "dropNullableFromRequired");
+var toJsonSchema = /* @__PURE__ */ __name((schema) => {
+  if (isZodSchema(schema)) {
+    let jsonSchema;
+    try {
+      jsonSchema = (0, import_zod44.toJSONSchema)(schema, {
+        target: "openApi3",
+        ...jsonSchemaOpts
+      });
+    } catch {
+      return {
+        type: "object"
+      };
+    }
+    dropNullableFromRequired2(jsonSchema);
+    return jsonSchema;
+  }
+  return schema;
+}, "toJsonSchema");
+
+// ../crouton-core/src/lib/compile/payload-builders.ts
+var pickExtensions = /* @__PURE__ */ __name((config) => Object.fromEntries([
+  ...getResourceExtensions().keys()
+].filter((k) => config[k] !== void 0).map((k) => [
+  k,
+  config[k]
+])), "pickExtensions");
+var resolveEnvPlaceholders = /* @__PURE__ */ __name((value) => value.replace(/\{env\.([^}]+)\}/g, (match, varName) => (
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  (typeof globalThis.process !== "undefined" ? globalThis.process?.env?.[varName] : void 0) ?? match
+)), "resolveEnvPlaceholders");
+var RESOURCE_OPS = [
+  "findAll",
+  "findOne",
+  "create",
+  "update",
+  "patch",
+  "delete"
+];
+var OP_SUFFIX = {
+  findAll: "",
+  findOne: "/{id}",
+  create: "",
+  update: "/{id}",
+  patch: "/{id}",
+  delete: "/{id}"
+};
+var OP_METHOD = {
+  findAll: "get",
+  findOne: "get",
+  create: "post",
+  update: "put",
+  patch: "patch",
+  delete: "delete"
+};
+var buildResourceOperations = /* @__PURE__ */ __name((definition, baseUri) => Object.fromEntries(RESOURCE_OPS.filter((op) => isOperationEnabled(definition, op)).map((op) => {
+  const extRoute = externalRouteFor(definition, op);
+  const uri = extRoute ? resolveEnvPlaceholders(extRoute) : `${baseUri}${OP_SUFFIX[op]}`;
+  const entry = definition[op];
+  const method = (extRoute && typeof entry === "object" && entry !== null && "method" in entry ? entry.method : void 0) ?? OP_METHOD[op];
+  return [
+    op,
+    {
+      uri,
+      method
+    }
+  ];
+})), "buildResourceOperations");
+var _resolveActions = /* @__PURE__ */ __name((baseUrl, actions) => {
+  if (!actions?.length) return [];
+  return actions.map((a) => a.type === "link" ? {
+    ...a,
+    href: resolveEnvPlaceholders(a.href)
+  } : {
+    ...a,
+    uri: baseUrl.map((b) => b === "{actionId}" ? a.id : b).join("/"),
+    method: a.method ?? "post"
+  });
+}, "_resolveActions");
+var resolveActions = /* @__PURE__ */ __name((baseUrl, actions) => _resolveActions([
+  baseUrl,
+  "procedure",
+  "{actionId}",
+  "{id}"
+], actions), "resolveActions");
+var resolveTableActions = /* @__PURE__ */ __name((baseUrl, actions) => _resolveActions([
+  baseUrl,
+  "table-action",
+  "{actionId}"
+], actions), "resolveTableActions");
+var buildDefinitionPayload = /* @__PURE__ */ __name((config) => {
+  const { route, name, tag, idType = "string" } = config;
+  const definition = resolveDefinition(config);
+  const listSchema = schemaFor(definition, "findAll");
+  const oneSchema = schemaFor(definition, "findOne") ?? listSchema;
+  const createSchema = schemaFor(definition, "create");
+  const updateSchema = schemaFor(definition, "update");
+  const patchSchema = schemaFor(definition, "patch");
+  const operations = [
+    "findAll",
+    "findOne",
+    "create",
+    "update",
+    "patch",
+    "delete"
+  ].filter((op) => isOperationEnabled(definition, op));
+  return {
+    name,
+    route,
+    idType,
+    tag,
+    operations,
+    display: config.display,
+    schemas: {
+      ...listSchema && {
+        findAll: toJsonSchema(listSchema)
+      },
+      ...oneSchema && {
+        findOne: toJsonSchema(oneSchema)
+      },
+      ...createSchema && {
+        create: toJsonSchema(createSchema)
+      },
+      ...updateSchema && {
+        update: toJsonSchema(updateSchema)
+      },
+      ...patchSchema && {
+        patch: toJsonSchema(patchSchema)
+      }
+    },
+    ...pickExtensions(config)
+  };
+}, "buildDefinitionPayload");
+var buildResourceJsonPayload = /* @__PURE__ */ __name((config, baseUrl) => {
+  const { route } = config;
+  const definition = resolveDefinition(config);
+  const uri = `${baseUrl}/${route}`;
+  const operations = Object.fromEntries(RESOURCE_OPS.map((op) => [
+    op,
+    isOperationEnabled(definition, op)
+  ]));
+  if (!isOperationExternal(definition, "findAll")) {
+    operations["lookup"] = `${uri}?q={text}`;
+  }
+  const form = config.views?.["form"];
+  const schema = form?.json_schema ? {
+    data: form.json_schema,
+    ui: form.ui_schema
+  } : null;
+  return {
+    id: config.id ?? route,
+    uri,
+    operations,
+    schema,
+    ...pickExtensions(config)
+  };
+}, "buildResourceJsonPayload");
+var buildViewsPayload = /* @__PURE__ */ __name((config, baseUrl) => {
+  if (!config.views || !Object.keys(config.views).length) return void 0;
+  const definition = resolveDefinition(config);
+  const baseUri = config.parent ? `${baseUrl}/${config.parent.route}/{${config.parent.param}}/${config.route}` : `${baseUrl}/${config.route}`;
+  const operations = buildResourceOperations(definition, baseUri);
+  if (isOperationEnabled(definition, "findAll") && !isOperationExternal(definition, "findAll")) {
+    operations["lookup"] = `${baseUri}?q={text}`;
+  }
+  const schemas = Object.fromEntries(Object.entries(config.views).map(([key, v]) => [
+    key,
+    {
+      data: v.json_schema,
+      ui: v.ui_schema,
+      ...v.defaultSort !== void 0 && {
+        defaultSort: v.defaultSort
+      }
+    }
+  ]));
+  return {
+    id: config.id ?? config.route,
+    name: config.name,
+    route: config.route,
+    uri: baseUri,
+    title: config.title ?? config.tag,
+    idField: config.lookup?.key ?? "id",
+    idType: config.idType ?? "string",
+    ...config.modalSize && {
+      modalSize: config.modalSize
+    },
+    operations,
+    display: config.display,
+    schemas,
+    actions: resolveActions(baseUri, config.actions),
+    tableActions: resolveTableActions(baseUri, config.tableActions),
+    ...pickExtensions(config)
+  };
+}, "buildViewsPayload");
+var buildSubResourceViewsPayload = /* @__PURE__ */ __name((config, sub, baseUrl) => {
+  if (!sub.views) return void 0;
+  const { route } = config;
+  const childUri = `${baseUrl}/${route}/{parent.id}/${sub.childRoute}`;
+  return {
+    id: `${route}/${sub.childRoute}`,
+    name: sub.name ?? sub.childRoute,
+    route: sub.childRoute,
+    uri: childUri,
+    title: sub.title ?? sub.childRoute,
+    idField: sub.idField ?? "id",
+    idType: sub.idType ?? "string",
+    ...sub.modalSize && {
+      modalSize: sub.modalSize
+    },
+    ...sub.display && {
+      display: sub.display
+    },
+    // ponytail: cast because JsonOperationsSchema uses boolean|{security?} but buildSubResourceOperations wants boolean
+    operations: buildSubResourceOperations(sub.operations, childUri, sub.idField ?? "id"),
+    schemas: Object.fromEntries(Object.entries(sub.views).map(([key, v]) => [
+      key,
+      {
+        data: v.json_schema,
+        ui: v.ui_schema,
+        ...v.defaultSort !== void 0 && {
+          defaultSort: v.defaultSort
+        }
+      }
+    ])),
+    actions: resolveActions(`${baseUrl}/${sub.childRoute}`, sub.actions)
+  };
+}, "buildSubResourceViewsPayload");
 
 // ../crouton-core/src/lib/config/CroutonConfig.schema.ts
-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),
+var import_zod45 = require("zod");
+var RulesetSchema = import_zod45.z.object({
+  hideIdInTable: import_zod45.z.boolean().default(true),
+  hideIdInForm: import_zod45.z.boolean().default(true),
+  hideIdInView: import_zod45.z.boolean().default(true),
+  hideTimestamps: import_zod45.z.boolean().default(true),
+  hideForeignKeys: import_zod45.z.boolean().default(true),
+  includeRelations: import_zod45.z.boolean().default(true),
+  hideRelationsInTable: import_zod45.z.boolean().default(true),
+  showRelationsInForm: import_zod45.z.boolean().default(true),
+  enumValueLabel: import_zod45.z.boolean().default(true),
+  sharedEnums: import_zod45.z.boolean().default(true),
   defaultOperations: JsonOperationsSchema.default(JsonOperationsSchema.parse({}))
 });
-var I18nConfigSchema = import_zod44.z.object({
+var I18nConfigSchema = import_zod45.z.object({
   /** Default / fallback language. */
-  defaultLanguage: import_zod44.z.string().default("en"),
+  defaultLanguage: import_zod45.z.string().default("en"),
   /** All supported language codes. */
-  languages: import_zod44.z.array(import_zod44.z.string()).min(1),
+  languages: import_zod45.z.array(import_zod45.z.string()).min(1),
   /** Directory containing `<lang>.json` bundles, relative to project root. */
-  translationsDir: import_zod44.z.string().default("translations")
+  translationsDir: import_zod45.z.string().default("translations")
 });
-var CroutonConfigSchema = import_zod44.z.object({
+var CroutonConfigSchema = import_zod45.z.object({
   /**
   * Application title served to the frontend via `GET /_app/layout`.
   * Displayed in the admin sidebar header.
   */
-  title: import_zod44.z.string(),
+  title: import_zod45.z.string(),
   /** Where resource directories live, relative to the project root. */
-  resourcesDir: import_zod44.z.string(),
+  resourcesDir: import_zod45.z.string(),
   /** Where datasource folders live (each with a `data-source.json`). */
-  dataSourcesDir: import_zod44.z.string(),
+  dataSourcesDir: import_zod45.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_zod44.z.string().default("{Model}WithRelationsSchema"),
+  schemaExportName: import_zod45.z.string().default("{Model}WithRelationsSchema"),
   /** Path to the shared enum registry, relative to project root. Default `crouton.enums.json`. */
-  enumsFile: import_zod44.z.string().default("crouton.enums.json"),
+  enumsFile: import_zod45.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_zod44.z.record(import_zod44.z.string(), SidebarGroupSchema).default({}),
+  sidebarGroups: import_zod45.z.record(import_zod45.z.string(), SidebarGroupSchema).default({}),
   /**
   * Whether form fields are saved automatically as the user edits them.
   * @default true
   */
-  autoSave: import_zod44.z.boolean().default(true),
+  autoSave: import_zod45.z.boolean().default(true),
   /** Optional i18n / translation configuration. */
   i18n: I18nConfigSchema.optional()
 });
@@ -3042,29 +3706,29 @@ var CONFIG_FILES = [
 ];
 
 // ../crouton-core/src/lib/i18n/Translations.schema.ts
-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(),
+var import_zod46 = require("zod");
+var NestedStringRecord = import_zod46.z.lazy(() => import_zod46.z.record(import_zod46.z.string(), import_zod46.z.union([
+  import_zod46.z.string(),
   NestedStringRecord
 ])));
-var TranslationBundleSchema = import_zod45.z.object({
-  app: import_zod45.z.object({
-    title: import_zod45.z.string().optional()
+var TranslationBundleSchema = import_zod46.z.object({
+  app: import_zod46.z.object({
+    title: import_zod46.z.string().optional()
   }).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()
+  sidebarGroups: import_zod46.z.record(import_zod46.z.string(), import_zod46.z.string()).optional(),
+  resources: import_zod46.z.record(import_zod46.z.string(), import_zod46.z.object({
+    title: import_zod46.z.string().optional(),
+    sidebar: import_zod46.z.string().optional(),
+    columns: import_zod46.z.record(import_zod46.z.string(), import_zod46.z.string()).optional(),
+    actions: import_zod46.z.record(import_zod46.z.string(), import_zod46.z.string()).optional(),
+    subResources: import_zod46.z.record(import_zod46.z.string(), import_zod46.z.object({
+      title: import_zod46.z.string().optional(),
+      columns: import_zod46.z.record(import_zod46.z.string(), import_zod46.z.string()).optional()
     }).optional()).optional()
   }).optional()).optional(),
-  enums: import_zod45.z.record(import_zod45.z.string(), import_zod45.z.record(import_zod45.z.string(), import_zod45.z.string())).optional(),
+  enums: import_zod46.z.record(import_zod46.z.string(), import_zod46.z.record(import_zod46.z.string(), import_zod46.z.string())).optional(),
   ui: NestedStringRecord.optional(),
-  validation: import_zod45.z.record(import_zod45.z.string(), import_zod45.z.string()).optional()
+  validation: import_zod46.z.record(import_zod46.z.string(), import_zod46.z.string()).optional()
 }).passthrough();
 
 // ../crouton-core/src/lib/i18n/translation-keys.ts
@@ -3144,25 +3808,25 @@ var resolveLanguage = /* @__PURE__ */ __name((acceptLanguage, supported, default
 }, "resolveLanguage");
 
 // src/lib/crouton-api.module.ts
-var import_common27 = require("@nestjs/common");
+var import_common28 = require("@nestjs/common");
 var import_core2 = require("@nestjs/core");
 
 // src/lib/crud/app-layout/app-layout.types.ts
-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 import_zod47 = require("zod");
+var SidebarLeafSchema = import_zod47.z.object({
+  kind: import_zod47.z.literal("item").default("item"),
+  id: import_zod47.z.string(),
+  label: import_zod47.z.string(),
+  position: import_zod47.z.number().optional()
 });
-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 SidebarGroupSchema2 = import_zod47.z.object({
+  kind: import_zod47.z.literal("group").default("group"),
+  id: import_zod47.z.string(),
+  label: import_zod47.z.string(),
+  position: import_zod47.z.number().optional(),
+  children: import_zod47.z.array(SidebarLeafSchema).default([])
 });
-var SidebarNodeSchema = import_zod46.z.discriminatedUnion("kind", [
+var SidebarNodeSchema = import_zod47.z.discriminatedUnion("kind", [
   SidebarLeafSchema,
   SidebarGroupSchema2
 ]);
@@ -3837,9 +4501,12 @@ var loadConfig = /* @__PURE__ */ __name(async () => {
     config = mod.default ?? mod;
   }
   const parsed = CroutonConfigSchema.parse(config);
+  const configDir = (0, import_node_path3.dirname)(path);
+  const enumsFile = (0, import_node_path3.isAbsolute)(parsed.enumsFile) ? parsed.enumsFile : (0, import_node_path3.resolve)(configDir, parsed.enumsFile);
   return {
     ...parsed,
-    configDir: (0, import_node_path3.dirname)(path)
+    configDir,
+    enumsFile
   };
 }, "loadConfig");
 
@@ -3994,54 +4661,54 @@ CroutonValidationExceptionFilter = _ts_decorate3([
 ], CroutonValidationExceptionFilter);
 
 // src/lib/crud/crud-controller.factory.ts
-var import_common23 = require("@nestjs/common");
-var import_swagger11 = require("@nestjs/swagger");
+var import_common24 = require("@nestjs/common");
+var import_swagger12 = require("@nestjs/swagger");
 
 // src/lib/crud/crud-repository.factory.ts
 var import_common10 = require("@nestjs/common");
 
 // src/lib/crud/action/action.types.ts
-var import_zod47 = require("zod");
-var ActionMetadataSchema2 = import_zod47.z.object({
+var import_zod48 = require("zod");
+var ActionMetadataSchema2 = import_zod48.z.object({
   /** URL segment used in the endpoint. */
-  id: import_zod47.z.string(),
+  id: import_zod48.z.string(),
   /** Human-readable label shown as a button. */
-  label: import_zod47.z.string().optional(),
+  label: import_zod48.z.string().optional(),
   /** MDI icon name, e.g. `"mdi:open-in-new"`. */
-  icon: import_zod47.z.string().optional(),
+  icon: import_zod48.z.string().optional(),
   /** Tooltip text. Falls back to `label` when omitted. */
-  tooltip: import_zod47.z.string().optional(),
+  tooltip: import_zod48.z.string().optional(),
   /** Per-row condition — button is hidden when false. */
-  condition: import_zod47.z.custom().optional()
+  condition: import_zod48.z.custom().optional()
 });
 var ResourceLinkActionSchema2 = ActionMetadataSchema2.extend({
-  type: import_zod47.z.literal("link"),
+  type: import_zod48.z.literal("link"),
   /** URL to open. May contain `{id}` or `{env.VAR}` placeholders. */
-  href: import_zod47.z.string()
+  href: import_zod48.z.string()
 });
 var ResourceRowProcedureActionSchema2 = ActionMetadataSchema2.extend({
-  type: import_zod47.z.literal("procedure").optional(),
+  type: import_zod48.z.literal("procedure").optional(),
   /** HTTP method for the endpoint. Defaults to `"post"`. */
-  method: import_zod47.z.string().optional(),
+  method: import_zod48.z.string().optional(),
   /** Static data payload merged into the request body by the frontend. */
-  data: import_zod47.z.record(import_zod47.z.string(), import_zod47.z.unknown()).optional(),
+  data: import_zod48.z.record(import_zod48.z.string(), import_zod48.z.unknown()).optional(),
   /** Procedure called with `(prisma, recordId)`. */
-  procedure: import_zod47.z.custom((v) => typeof v === "function")
+  procedure: import_zod48.z.custom((v) => typeof v === "function")
 });
 var ResourceTableProcedureActionSchema2 = ActionMetadataSchema2.extend({
-  type: import_zod47.z.literal("procedure").optional(),
+  type: import_zod48.z.literal("procedure").optional(),
   /** HTTP method for the endpoint. Defaults to `"post"`. */
-  method: import_zod47.z.string().optional(),
+  method: import_zod48.z.string().optional(),
   /** Static data payload merged into the request body by the frontend. */
-  data: import_zod47.z.record(import_zod47.z.string(), import_zod47.z.unknown()).optional(),
+  data: import_zod48.z.record(import_zod48.z.string(), import_zod48.z.unknown()).optional(),
   /** Procedure called with `(prisma)` — no record id. */
-  procedure: import_zod47.z.custom((v) => typeof v === "function")
+  procedure: import_zod48.z.custom((v) => typeof v === "function")
 });
-var ResourceRowActionSchema2 = import_zod47.z.union([
+var ResourceRowActionSchema2 = import_zod48.z.union([
   ResourceRowProcedureActionSchema2,
   ResourceLinkActionSchema2
 ]);
-var ResourceTableActionSchema2 = import_zod47.z.union([
+var ResourceTableActionSchema2 = import_zod48.z.union([
   ResourceTableProcedureActionSchema2,
   ResourceLinkActionSchema2
 ]);
@@ -4053,9 +4720,8 @@ var import_node_fs4 = require("fs");
 var import_node_module = require("module");
 var import_node_path5 = require("path");
 var import_node_url = require("url");
-var import_meta = {};
 var _require = (0, import_node_module.createRequire)(importMetaUrl ?? __filename);
-var IS_ESM = typeof import_meta !== "undefined" && typeof importMetaUrl === "string";
+var IS_ESM = typeof __filename === "undefined";
 var findModule = /* @__PURE__ */ __name((dir, name) => {
   for (const ext of [
     ".ts",
@@ -4148,7 +4814,7 @@ var securityForSub = /* @__PURE__ */ __name((config, sub, op, moduleDefault) =>
 }, "securityForSub");
 
 // src/lib/crud/custom-repository/custom-repository.types.ts
-var import_zod48 = require("zod");
+var import_zod49 = require("zod");
 var CUSTOM_OPS = [
   "findAll",
   "findOne",
@@ -4165,7 +4831,7 @@ var PARENT_METHOD = {
   patch: "patchByParent",
   delete: "deleteByParent"
 };
-var CustomRepositorySchema = import_zod48.z.custom((value) => typeof value === "object" && value !== null);
+var CustomRepositorySchema = import_zod49.z.custom((value) => typeof value === "object" && value !== null);
 
 // src/lib/crud/resource/resource-load-errors.registry.ts
 var ResourceLoadErrorsRegistry = class ResourceLoadErrorsRegistry2 {
@@ -4235,6 +4901,7 @@ var import_common9 = require("@nestjs/common");
 
 // src/lib/crud/constants.ts
 var PRISMA_NOT_FOUND_CODE = "P2025";
+var PRISMA_UNIQUE_CONSTRAINT_CODE = "P2002";
 var DEFAULT_ID_TYPE = "string";
 var DEFAULT_ID_FIELD = "id";
 
@@ -4747,8 +5414,13 @@ var ReadRepository = class {
         ...mergedInclude
       };
     } else {
-      if (countClause) query._count = countClause;
-      if (mergedInclude) query.include = mergedInclude;
+      const includeClause = {
+        ...mergedInclude ?? {},
+        ...countClause ? {
+          _count: countClause
+        } : {}
+      };
+      if (Object.keys(includeClause).length) query.include = includeClause;
     }
     const rows = await this.prismaModel.findMany(query);
     const mapped = countableSubResources.length ? rows.map((row) => {
@@ -4966,10 +5638,133 @@ var ReadRepository = class {
     });
     return withCalc;
   }
-};
+};
+
+// src/lib/crud/write.repository.ts
+var import_common7 = require("@nestjs/common");
+
+// src/lib/crud/unique-validation.ts
+var columnsOf = /* @__PURE__ */ __name((config) => config.columns ?? [], "columnsOf");
+var columnDbName = /* @__PURE__ */ __name((col) => col.column ?? col.id, "columnDbName");
+var columnById = /* @__PURE__ */ __name((config, id) => columnsOf(config).find((c) => c.id === id), "columnById");
+var dbNameForId = /* @__PURE__ */ __name((config, id) => {
+  const col = columnById(config, id);
+  return col ? columnDbName(col) : id;
+}, "dbNameForId");
+var uniqueColumns = /* @__PURE__ */ __name((config) => columnsOf(config).map((column) => ({
+  column,
+  unique: normalizeUnique(column.unique)
+})).filter((e) => e.unique != null), "uniqueColumns");
+var findUniqueColumn = /* @__PURE__ */ __name((config, fieldId) => uniqueColumns(config).find((e) => e.column.id === fieldId), "findUniqueColumn");
+var extractTargets = /* @__PURE__ */ __name((meta) => {
+  const target = meta?.target;
+  if (Array.isArray(target)) return target.map(String);
+  if (typeof target === "string") return [
+    target
+  ];
+  return [];
+}, "extractTargets");
+var columnForTarget = /* @__PURE__ */ __name((config, target) => columnsOf(config).find((c) => columnDbName(c) === target || c.id === target), "columnForTarget");
+var sameSet = /* @__PURE__ */ __name((a, b) => a.length === b.length && (/* @__PURE__ */ new Set([
+  ...a,
+  ...b
+])).size === a.length, "sameSet");
+var mapPrismaUniqueError = /* @__PURE__ */ __name((e, config) => {
+  if (e?.code !== PRISMA_UNIQUE_CONSTRAINT_CODE) return void 0;
+  const targets = extractTargets(e.meta);
+  if (targets.length > 1) {
+    for (const { column, unique } of uniqueColumns(config)) {
+      const names = [
+        columnDbName(column),
+        ...(unique.scope ?? []).map((id) => dbNameForId(config, id))
+      ];
+      if (sameSet(names, targets)) {
+        const label = column.label ?? column.id;
+        return new CroutonValidationError([
+          {
+            field: column.id,
+            message: unique.message ?? `${label} already exists`,
+            code: "unique"
+          }
+        ]);
+      }
+    }
+  }
+  const resolved = targets.length ? targets : [
+    "value"
+  ];
+  const errors = resolved.map((target) => {
+    const col = columnForTarget(config, target);
+    const unique = normalizeUnique(col?.unique);
+    const label = col?.label ?? col?.id ?? target;
+    return {
+      field: col?.id ?? target,
+      message: unique?.message ?? `${label} already exists`,
+      code: "unique"
+    };
+  });
+  return new CroutonValidationError(errors);
+}, "mapPrismaUniqueError");
+var dmmfUniqueInfo = /* @__PURE__ */ __name((client, modelName) => {
+  try {
+    const dmmf = client?._baseDmmf;
+    if (!dmmf) return null;
+    const model = dmmf.modelMap?.[modelName];
+    if (!model) return null;
+    const singleColumns = /* @__PURE__ */ new Set();
+    for (const field of model.fields ?? []) {
+      if (field.isUnique || field.isId) singleColumns.add(field.dbName ?? field.name);
+    }
+    const compositeFieldSets = (model.uniqueFields ?? []).filter((f) => f.length > 1).map((f) => new Set(f));
+    return {
+      singleColumns,
+      compositeFieldSets
+    };
+  } catch {
+    return null;
+  }
+}, "dmmfUniqueInfo");
+var warnMissingUniqueConstraints = /* @__PURE__ */ __name((configs, dataSourceRegistry) => {
+  if (process.env["NODE_ENV"] === "production") return;
+  for (const config of configs) {
+    const cols = uniqueColumns(config);
+    if (!cols.length || !config.model) continue;
+    let client;
+    try {
+      const adapter = dataSourceRegistry.resolveAdapter(config.database);
+      if (adapter.kind !== "prisma") continue;
+      client = adapter.client;
+    } catch {
+      continue;
+    }
+    const info = dmmfUniqueInfo(client, config.model);
+    if (!info) continue;
+    for (const { column, unique } of cols) {
+      const dbName = columnDbName(column);
+      if (!unique.scope?.length) {
+        if (!info.singleColumns.has(dbName)) {
+          console.warn(`[crouton] WARNING: column "${column.id}" on resource "${config.name}" declares unique: true but Prisma model "${config.model}" has no @unique on "${dbName}". Add @unique to the Prisma schema to enforce the race-condition guarantee.`);
+        }
+      } else {
+        const expectedSet = /* @__PURE__ */ new Set([
+          dbName,
+          ...unique.scope.map((id) => dbNameForId(config, id))
+        ]);
+        const hasComposite = info.compositeFieldSets.some((s) => s.size === expectedSet.size && [
+          ...expectedSet
+        ].every((f) => s.has(f)));
+        if (!hasComposite) {
+          console.warn(`[crouton] WARNING: column "${column.id}" on resource "${config.name}" declares composite unique (scope: ${JSON.stringify(unique.scope)}) but Prisma model "${config.model}" has no matching @@unique constraint. Add @@unique([${[
+            dbName,
+            ...expectedSet
+          ].join(", ")}]) to the Prisma schema.`);
+        }
+      }
+    }
+  }
+}, "warnMissingUniqueConstraints");
 
 // src/lib/crud/write.repository.ts
-var import_common7 = require("@nestjs/common");
 var includeRelationNames = /* @__PURE__ */ __name((include) => new Set((include ?? []).map((e) => typeof e === "string" ? e : e.relation)), "includeRelationNames");
 var PRISMA_RELATION_WRITE_KEYS = /* @__PURE__ */ new Set([
   "connect",
@@ -5040,9 +5835,13 @@ var WriteRepository = class {
   * normalized, and run through `beforeWrite` by the factory wrapper.
   */
   async create(data, _request) {
-    return this.prismaModel.create({
-      data
-    });
+    try {
+      return await this.prismaModel.create({
+        data
+      });
+    } catch (e) {
+      throw mapPrismaUniqueError(e, this.config) ?? e;
+    }
   }
   /**
   * Update a record. The data has already been stripped, normalized, and hooked
@@ -5059,6 +5858,8 @@ var WriteRepository = class {
       });
     } catch (e) {
       if (e?.code === PRISMA_NOT_FOUND_CODE) throw this.notFound(id);
+      const uniqueError = mapPrismaUniqueError(e, this.config);
+      if (uniqueError) throw uniqueError;
       throw e;
     }
   }
@@ -5076,6 +5877,8 @@ var WriteRepository = class {
       });
     } catch (e) {
       if (e?.code === PRISMA_NOT_FOUND_CODE) throw this.notFound(id);
+      const uniqueError = mapPrismaUniqueError(e, this.config);
+      if (uniqueError) throw uniqueError;
       throw e;
     }
   }
@@ -5089,6 +5892,8 @@ var WriteRepository = class {
       });
     } catch (e) {
       if (e?.code === PRISMA_NOT_FOUND_CODE) throw this.notFound(id);
+      const uniqueError = mapPrismaUniqueError(e, this.config);
+      if (uniqueError) throw uniqueError;
       throw e;
     }
   }
@@ -5358,23 +6163,23 @@ var PrismaDataSourceAdapter = class {
 };
 
 // src/lib/crud/hooks/hooks.types.ts
-var import_zod49 = require("zod");
-var WriteOpSchema = import_zod49.z.enum([
+var import_zod50 = require("zod");
+var WriteOpSchema = import_zod50.z.enum([
   "create",
   "update",
   "patch",
   "delete"
 ]);
-var ReadOpSchema = import_zod49.z.enum([
+var ReadOpSchema = import_zod50.z.enum([
   "findAll",
   "findOne"
 ]);
-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()
+var ResourceHooksSchema = import_zod50.z.object({
+  beforeWrite: import_zod50.z.custom().optional(),
+  afterWrite: import_zod50.z.custom().optional(),
+  afterRead: import_zod50.z.custom().optional(),
+  beforeFindAll: import_zod50.z.custom().optional(),
+  afterFindAll: import_zod50.z.custom().optional()
 });
 
 // src/lib/crud/hooks/hooks.loader.ts
@@ -5624,21 +6429,21 @@ var validateCustomRepository = /* @__PURE__ */ __name((config, repository, adapt
 }, "validateCustomRepository");
 
 // src/lib/crud/schema.utils.ts
-var import_zod50 = require("zod");
-function isZodSchema(schema) {
-  return schema instanceof import_zod50.ZodObject;
+var import_zod51 = require("zod");
+function isZodSchema2(schema) {
+  return schema instanceof import_zod51.ZodObject;
 }
-__name(isZodSchema, "isZodSchema");
-var dropNullableFromRequired2 = /* @__PURE__ */ __name((jsonSchema) => {
+__name(isZodSchema2, "isZodSchema");
+var dropNullableFromRequired3 = /* @__PURE__ */ __name((jsonSchema) => {
   const { properties, required } = jsonSchema;
   if (!properties || !Array.isArray(required)) return;
   jsonSchema.required = required.filter((key) => !isNullableProperty(properties[key]));
 }, "dropNullableFromRequired");
 function toJsonSchema2(schema) {
-  if (isZodSchema(schema)) {
+  if (isZodSchema2(schema)) {
     let jsonSchema;
     try {
-      jsonSchema = (0, import_zod50.toJSONSchema)(schema, {
+      jsonSchema = (0, import_zod51.toJSONSchema)(schema, {
         target: "openApi3",
         ...jsonSchemaOpts
       });
@@ -5647,7 +6452,7 @@ function toJsonSchema2(schema) {
         type: "object"
       };
     }
-    dropNullableFromRequired2(jsonSchema);
+    dropNullableFromRequired3(jsonSchema);
     return jsonSchema;
   }
   return schema;
@@ -5664,7 +6469,7 @@ var unwrap2 = /* @__PURE__ */ __name((schema) => {
 }, "unwrap");
 var typeOf = /* @__PURE__ */ __name((schema) => schema?._zod?.def?.type, "typeOf");
 function toSelectFields(schema) {
-  if (!isZodSchema(schema)) {
+  if (!isZodSchema2(schema)) {
     return Object.keys(schema.properties).reduce((acc, key) => {
       acc[key] = true;
       return acc;
@@ -6767,26 +7572,26 @@ var import_common20 = require("@nestjs/common");
 var import_swagger8 = require("@nestjs/swagger");
 
 // src/lib/crud/resource/PatchResourceJson.schema.ts
-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()
+var import_zod52 = require("zod");
+var FieldVariantPatchSchema = import_zod52.z.object({
+  type: import_zod52.z.string().nullable().optional(),
+  format: import_zod52.z.string().nullable().optional(),
+  resource: import_zod52.z.string().nullable().optional(),
+  position: import_zod52.z.number().nullable().optional(),
+  options: import_zod52.z.record(import_zod52.z.string(), import_zod52.z.unknown().nullable()).optional()
 }).partial();
-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(),
+var PatchColumnSchema = import_zod52.z.object({
+  label: import_zod52.z.string().optional(),
+  column: import_zod52.z.string().optional(),
+  hiddenInTable: import_zod52.z.boolean().optional(),
+  hiddenInForm: import_zod52.z.boolean().optional(),
+  hiddenInView: import_zod52.z.boolean().optional(),
   fieldInput: FieldVariantPatchSchema.optional(),
   fieldView: FieldVariantPatchSchema.optional(),
   fieldTable: FieldVariantPatchSchema.optional()
 }).partial();
-var PatchResourceJsonSchema = import_zod51.z.object({
-  columns: import_zod51.z.record(import_zod51.z.string(), PatchColumnSchema)
+var PatchResourceJsonSchema = import_zod52.z.object({
+  columns: import_zod52.z.record(import_zod52.z.string(), PatchColumnSchema)
 });
 
 // src/lib/crud/resource/WriteResourceJson.ts
@@ -6853,207 +7658,10 @@ var writeRawResourceJson = /* @__PURE__ */ __name((jsonPath, raw) => {
 }, "writeRawResourceJson");
 
 // src/lib/crud/operations/payload-builders.ts
-var pickExtensions = /* @__PURE__ */ __name((config) => Object.fromEntries([
-  ...getResourceExtensions().keys()
-].filter((k) => config[k] !== void 0).map((k) => [
-  k,
-  config[k]
-])), "pickExtensions");
-var resolveEnvPlaceholders = /* @__PURE__ */ __name((value) => value.replace(/\{env\.([^}]+)\}/g, (match, varName) => process.env[varName] ?? match), "resolveEnvPlaceholders");
-var RESOURCE_OPS = [
-  "findAll",
-  "findOne",
-  "create",
-  "update",
-  "patch",
-  "delete"
-];
-var OP_METHOD = {
-  findAll: "get",
-  findOne: "get",
-  create: "post",
-  update: "put",
-  patch: "patch",
-  delete: "delete"
-};
-var OP_SUFFIX = {
-  findAll: "",
-  findOne: "/{id}",
-  create: "",
-  update: "/{id}",
-  patch: "/{id}",
-  delete: "/{id}"
-};
-var buildResourceOperations = /* @__PURE__ */ __name((definition, baseUri) => Object.fromEntries(RESOURCE_OPS.filter((op) => isOperationEnabled2(definition, op)).map((op) => {
-  const extUri = externalRouteFor2(definition, op);
-  const uri = extUri ? resolveEnvPlaceholders(extUri) : `${baseUri}${OP_SUFFIX[op]}`;
-  const entry = definition[op];
-  const method = (extUri && typeof entry === "object" && entry !== null && "method" in entry ? entry.method : void 0) ?? OP_METHOD[op];
-  return [
-    op,
-    {
-      uri,
-      method
-    }
-  ];
-})), "buildResourceOperations");
-var buildDefinitionPayload2 = /* @__PURE__ */ __name((config) => {
-  const { route, name, tag, idType = "string" } = config;
-  const definition = resolveDefinition2(config);
-  const listSchema = schemaFor2(definition, "findAll");
-  const oneSchema = schemaFor2(definition, "findOne") ?? listSchema;
-  const createSchema = schemaFor2(definition, "create");
-  const updateSchema = schemaFor2(definition, "update");
-  const patchSchema = schemaFor2(definition, "patch");
-  const operations = [
-    "findAll",
-    "findOne",
-    "create",
-    "update",
-    "patch",
-    "delete"
-  ].filter((op) => isOperationEnabled2(definition, op));
-  return {
-    name,
-    route,
-    idType,
-    tag,
-    operations,
-    display: config.display,
-    schemas: {
-      ...listSchema && {
-        findAll: toJsonSchema2(listSchema)
-      },
-      ...oneSchema && {
-        findOne: toJsonSchema2(oneSchema)
-      },
-      ...createSchema && {
-        create: toJsonSchema2(createSchema)
-      },
-      ...updateSchema && {
-        update: toJsonSchema2(updateSchema)
-      },
-      ...patchSchema && {
-        patch: toJsonSchema2(patchSchema)
-      }
-    },
-    ...pickExtensions(config)
-  };
-}, "buildDefinitionPayload");
-var buildResourceJsonPayload2 = /* @__PURE__ */ __name((config, baseUrl) => {
-  const { name, route } = config;
-  const definition = resolveDefinition2(config);
-  const uri = `${baseUrl}/${route}`;
-  const operations = Object.fromEntries(RESOURCE_OPS.map((op) => [
-    op,
-    isOperationEnabled2(definition, op)
-  ]));
-  if (!isOperationExternal2(definition, "findAll")) {
-    operations.lookup = `${uri}?q={text}`;
-  }
-  const form = config.views?.["form"];
-  const schema = form?.json_schema ? {
-    data: form.json_schema,
-    ui: form.ui_schema
-  } : null;
-  return {
-    id: config.id ?? route,
-    uri,
-    operations,
-    schema,
-    ...pickExtensions(config)
-  };
-}, "buildResourceJsonPayload");
-var _resolveActions = /* @__PURE__ */ __name((baseUrl, actions) => {
-  if (!actions?.length) return [];
-  const resolved = actions.map((a) => a.type === "link" ? {
-    ...a,
-    href: resolveEnvPlaceholders(a.href)
-  } : {
-    ...a,
-    uri: baseUrl.map((b) => b === "{actionId}" ? a.id : b).join("/"),
-    method: a.method ?? "post"
-  });
-  return resolved;
-}, "_resolveActions");
-var resolveActions = /* @__PURE__ */ __name((baseUrl, actions) => {
-  return _resolveActions([
-    baseUrl,
-    "procedure",
-    "{actionId}",
-    "{id}"
-  ], actions);
-}, "resolveActions");
-var buildViewsPayload2 = /* @__PURE__ */ __name((config, baseUrl) => {
-  if (!config.views || !Object.keys(config.views).length) return void 0;
-  const definition = resolveDefinition2(config);
-  const baseUri = config.parent ? `${baseUrl}/${config.parent.route}/{${config.parent.param}}/${config.route}` : `${baseUrl}/${config.route}`;
-  const operations = buildResourceOperations(definition, baseUri);
-  if (isOperationEnabled2(definition, "findAll") && !isOperationExternal2(definition, "findAll")) {
-    operations["lookup"] = `${baseUri}?q={text}`;
-  }
-  const schemas = Object.fromEntries(Object.entries(config.views).map(([key, v]) => [
-    key,
-    {
-      data: v.json_schema,
-      ui: v.ui_schema,
-      ...v.defaultSort !== void 0 && {
-        defaultSort: v.defaultSort
-      }
-    }
-  ]));
-  const baseAction = `${baseUri}${config.route}`;
-  return {
-    id: config.id ?? config.route,
-    name: config.name,
-    route: config.route,
-    uri: baseUri,
-    title: config.title ?? config.tag,
-    idField: config.lookup?.key ?? "id",
-    idType: config.idType ?? "string",
-    ...config.modalSize && {
-      modalSize: config.modalSize
-    },
-    operations,
-    display: config.display,
-    schemas,
-    actions: resolveActions(baseAction, config.actions),
-    tableActions: resolveActions(baseAction, config.tableActions),
-    ...pickExtensions(config)
-  };
-}, "buildViewsPayload");
-var buildSubResourceViewsPayload = /* @__PURE__ */ __name((config, sub, baseUrl) => {
-  if (!sub.views) return void 0;
-  const { route } = config;
-  const childUri = `${baseUrl}/${route}/{parent.id}/${sub.childRoute}`;
-  return {
-    id: `${route}/${sub.childRoute}`,
-    name: sub.name ?? sub.childRoute,
-    route: sub.childRoute,
-    uri: childUri,
-    title: sub.title ?? sub.childRoute,
-    idField: sub.idField ?? "id",
-    idType: sub.idType ?? "string",
-    ...sub.modalSize && {
-      modalSize: sub.modalSize
-    },
-    ...sub.display && {
-      display: sub.display
-    },
-    operations: buildSubResourceOperations(sub.operations, childUri, sub.idField ?? "id"),
-    schemas: Object.fromEntries(Object.entries(sub.views).map(([key, v]) => [
-      key,
-      {
-        data: v.json_schema,
-        ui: v.ui_schema,
-        ...v.defaultSort !== void 0 && {
-          defaultSort: v.defaultSort
-        }
-      }
-    ])),
-    actions: resolveActions(`${baseUrl}/${sub.childRoute}`, sub.actions)
-  };
-}, "buildSubResourceViewsPayload");
+var buildDefinitionPayload2 = /* @__PURE__ */ __name((config) => buildDefinitionPayload(config), "buildDefinitionPayload");
+var buildResourceJsonPayload2 = /* @__PURE__ */ __name((config, baseUrl) => buildResourceJsonPayload(config, baseUrl), "buildResourceJsonPayload");
+var buildViewsPayload2 = /* @__PURE__ */ __name((config, baseUrl) => buildViewsPayload(config, baseUrl), "buildViewsPayload");
+var buildSubResourceViewsPayload2 = /* @__PURE__ */ __name((config, sub, baseUrl) => buildSubResourceViewsPayload(config, sub, baseUrl), "buildSubResourceViewsPayload");
 var buildEditableColumnsPayload = /* @__PURE__ */ __name((config) => {
   const columns = config.columns ?? [];
   return {
@@ -7293,7 +7901,7 @@ var childSchemas = /* @__PURE__ */ __name((sub) => (ctx) => {
   if (!sub.views) return null;
   const { config, baseUrl } = ctx;
   const { route } = config;
-  const schemasPayload = buildSubResourceViewsPayload(config, sub, baseUrl);
+  const schemasPayload = buildSubResourceViewsPayload2(config, sub, baseUrl);
   return {
     route: `${sub.childRoute}/schemas`,
     methodName: `getSchemas_${sub.childRoute}`,
@@ -7305,7 +7913,7 @@ var childSchemas = /* @__PURE__ */ __name((sub) => (ctx) => {
         if (localizedParent) {
           const localizedSub = (localizedParent.subResources ?? []).find((s) => s.childRoute === sub.childRoute);
           if (localizedSub) {
-            return buildSubResourceViewsPayload(localizedParent, localizedSub, baseUrl) ?? schemasPayload;
+            return buildSubResourceViewsPayload2(localizedParent, localizedSub, baseUrl) ?? schemasPayload;
           }
         }
       }
@@ -7338,9 +7946,103 @@ var registerSchemas = /* @__PURE__ */ __name((ctx, sub) => {
   }
 }, "registerSchemas");
 
-// src/lib/crud/operations/register-update.ts
+// src/lib/crud/operations/register-unique-check.ts
 var import_common22 = require("@nestjs/common");
 var import_swagger10 = require("@nestjs/swagger");
+var import_zod53 = require("zod");
+var UniqueQuerySchema = import_zod53.z.object({
+  /** The column id to check (must be a declared-unique column). */
+  field: import_zod53.z.string(),
+  /** The candidate value. */
+  value: import_zod53.z.string(),
+  /** On edit, the id of the record being edited, so it does not match itself. */
+  excludeId: import_zod53.z.string().optional(),
+  /** JSON object of `{ scopeFieldId: value }` for composite (scoped) uniqueness. */
+  scope: import_zod53.z.string().optional()
+});
+var registerUniqueCheck = /* @__PURE__ */ __name((ctx) => {
+  const { cls, config } = ctx;
+  if (!isOperationEnabled2(ctx.definition, "findAll")) return;
+  if (!config.model) return;
+  if (uniqueColumns(config).length === 0) return;
+  const methodName = "uniqueCheck";
+  const idField = config.idField ?? "id";
+  const idType = config.idType ?? "string";
+  const modelName = config.model;
+  const handler = /* @__PURE__ */ __name(async function(query) {
+    const { field, value, excludeId } = query;
+    const entry = findUniqueColumn(config, field);
+    if (!entry) {
+      throw new CroutonValidationError([
+        {
+          field,
+          message: `"${field}" is not a unique field`,
+          code: "unknown_field"
+        }
+      ]);
+    }
+    const dbName = columnDbName(entry.column);
+    const where = {
+      [dbName]: entry.unique.caseInsensitive ? {
+        equals: value,
+        mode: "insensitive"
+      } : value
+    };
+    if (excludeId !== void 0 && excludeId !== "") {
+      where.NOT = {
+        [idField]: idType === "number" ? Number(excludeId) : String(excludeId)
+      };
+    }
+    if (entry.unique.scope?.length && query.scope) {
+      let parsed;
+      try {
+        parsed = JSON.parse(query.scope);
+      } catch {
+        parsed = {};
+      }
+      for (const scopeId of entry.unique.scope) {
+        where[dbNameForId(config, scopeId)] = parsed[scopeId] ?? null;
+      }
+    }
+    const model = this.repo.prisma?.[modelName];
+    if (!model) return {
+      unique: true
+    };
+    const row = await model.findFirst({
+      where,
+      select: {
+        [idField]: true
+      }
+    });
+    return {
+      unique: !row
+    };
+  }, "handler");
+  def(cls, methodName, handler);
+  const d = desc(cls, methodName);
+  (0, import_common22.Get)("unique")(cls.prototype, methodName, d);
+  (0, import_common22.Query)(new ZodValidationPipe(UniqueQuerySchema))(cls.prototype, methodName, 0);
+  (0, import_swagger10.ApiOperation)({
+    summary: `Check whether a ${config.name} field value is unique`
+  })(cls.prototype, methodName, d);
+  (0, import_swagger10.ApiResponse)({
+    status: 200,
+    description: "Uniqueness result",
+    schema: {
+      type: "object",
+      properties: {
+        unique: {
+          type: "boolean"
+        }
+      }
+    }
+  })(cls.prototype, methodName, d);
+  ctx.secure(methodName, "findAll");
+}, "registerUniqueCheck");
+
+// src/lib/crud/operations/register-update.ts
+var import_common23 = require("@nestjs/common");
+var import_swagger11 = require("@nestjs/swagger");
 var defaultUpdate = /* @__PURE__ */ __name((ctx) => {
   if (!isOperationEnabled2(ctx.definition, "update")) return null;
   if (isOperationExternal2(ctx.definition, "update")) return null;
@@ -7354,9 +8056,9 @@ var defaultUpdate = /* @__PURE__ */ __name((ctx) => {
       return this.repo.update(id, body, req);
     }, "updateFn"),
     decorators: /* @__PURE__ */ __name(() => {
-      (0, import_common22.Param)("id")(cls.prototype, methodName, 0);
+      (0, import_common23.Param)("id")(cls.prototype, methodName, 0);
       bodyDecorator(updateSchema)(cls.prototype, methodName, 1);
-      (0, import_common22.Req)()(cls.prototype, methodName, 2);
+      (0, import_common23.Req)()(cls.prototype, methodName, 2);
     }, "decorators")
   };
 }, "defaultUpdate");
@@ -7368,10 +8070,10 @@ var childUpdate = /* @__PURE__ */ __name((sub) => (ctx) => {
     return this.repo.updateChild(sub, childId, body, req);
   }, "updateFn");
   const decorators = /* @__PURE__ */ __name(() => {
-    (0, import_common22.Param)("id")(cls.prototype, methodName, 0);
-    (0, import_common22.Param)("childId")(cls.prototype, methodName, 1);
-    (0, import_common22.Body)()(cls.prototype, methodName, 2);
-    (0, import_common22.Req)()(cls.prototype, methodName, 3);
+    (0, import_common23.Param)("id")(cls.prototype, methodName, 0);
+    (0, import_common23.Param)("childId")(cls.prototype, methodName, 1);
+    (0, import_common23.Body)()(cls.prototype, methodName, 2);
+    (0, import_common23.Req)()(cls.prototype, methodName, 3);
   }, "decorators");
   return {
     route: `:id/${sub.childRoute}/:childId`,
@@ -7389,15 +8091,15 @@ var registerUpdate = /* @__PURE__ */ __name((ctx, sub) => {
   const { cls } = ctx;
   def(cls, methodName, properties.updateFn);
   const d = desc(cls, methodName);
-  (0, import_common22.Put)(route)(cls.prototype, methodName, d);
-  (0, import_swagger10.ApiOperation)({
+  (0, import_common23.Put)(route)(cls.prototype, methodName, d);
+  (0, import_swagger11.ApiOperation)({
     summary: `Replace a ${name}`
   })(cls.prototype, methodName, d);
-  (0, import_swagger10.ApiResponse)({
+  (0, import_swagger11.ApiResponse)({
     status: 200,
     description: `${name} replaced`
   })(cls.prototype, methodName, d);
-  (0, import_swagger10.ApiNotFoundResponse)({
+  (0, import_swagger11.ApiNotFoundResponse)({
     description: "Not found"
   })(cls.prototype, methodName, d);
   properties.decorators();
@@ -7414,6 +8116,7 @@ var registerEndpoints = /* @__PURE__ */ __name((ctx) => {
   registerResourceJsonEndpoint(ctx);
   registerResourceColumnsEndpoint(ctx);
   registerDefinitionEndpoint(ctx);
+  registerUniqueCheck(ctx);
   registerEndpoint(ctx);
   registerActionRoutes(ctx);
   registerTableActionRoutes(ctx);
@@ -7442,11 +8145,11 @@ function createCrudController(config, baseUrl, moduleDefaultSecurity, securityEn
   const createSchema = schemaFor2(definition, "create");
   const updateSchema = schemaFor2(definition, "update");
   const explicitPatchSchema = schemaFor2(definition, "patch");
-  const patchSchema = explicitPatchSchema ?? (updateSchema && isZodSchema(updateSchema) ? updateSchema.partial() : void 0) ?? updateSchema;
+  const patchSchema = explicitPatchSchema ?? (updateSchema && isZodSchema2(updateSchema) ? updateSchema.partial() : void 0) ?? updateSchema;
   const bodyDecorator = /* @__PURE__ */ __name((schema, options) => {
-    if (!schema) return (0, import_common23.Body)();
-    if (isZodSchema(schema)) return (0, import_common23.Body)(new ZodValidationPipe(schema, options));
-    return (0, import_common23.Body)();
+    if (!schema) return (0, import_common24.Body)();
+    if (isZodSchema2(schema)) return (0, import_common24.Body)(new ZodValidationPipe(schema, options));
+    return (0, import_common24.Body)();
   }, "bodyDecorator");
   const resolveClient = /* @__PURE__ */ __name((registry2, resource) => {
     try {
@@ -7476,7 +8179,7 @@ function createCrudController(config, baseUrl, moduleDefaultSecurity, securityEn
   const secure = /* @__PURE__ */ __name((methodName, op, sub) => {
     const sec = sub ? securityForSub(config, sub, op, moduleDefaultSecurity) : securityFor(config, definition, op, moduleDefaultSecurity);
     if (sec) {
-      (0, import_common23.SetMetadata)(CROUTON_SECURITY, sec)(CrudControllerBase.prototype, methodName, Object.getOwnPropertyDescriptor(CrudControllerBase.prototype, methodName));
+      (0, import_common24.SetMetadata)(CROUTON_SECURITY, sec)(CrudControllerBase.prototype, methodName, Object.getOwnPropertyDescriptor(CrudControllerBase.prototype, methodName));
     }
   }, "secure");
   const ctx = {
@@ -7500,11 +8203,11 @@ function createCrudController(config, baseUrl, moduleDefaultSecurity, securityEn
   };
   registerEndpoints(ctx);
   const controllerPath = resourceControllerPath(route, config.parent);
-  (0, import_common23.Controller)(prefix ? `${prefix}/${controllerPath}` : controllerPath)(CrudControllerBase);
+  (0, import_common24.Controller)(prefix ? `${prefix}/${controllerPath}` : controllerPath)(CrudControllerBase);
   if (securityEnabled) {
-    (0, import_common23.UseGuards)(CroutonSecurityGuard)(CrudControllerBase);
+    (0, import_common24.UseGuards)(CroutonSecurityGuard)(CrudControllerBase);
   }
-  (0, import_swagger11.ApiTags)(tag)(CrudControllerBase);
+  (0, import_swagger12.ApiTags)(tag)(CrudControllerBase);
   Object.defineProperty(CrudControllerBase, "name", {
     value: `${name.charAt(0).toUpperCase() + name.slice(1)}Controller`
   });
@@ -7517,8 +8220,8 @@ function createCrudController(config, baseUrl, moduleDefaultSecurity, securityEn
 __name(createCrudController, "createCrudController");
 
 // src/lib/crud/dev-tools/dev-resources.controller.ts
-var import_common24 = require("@nestjs/common");
-var import_swagger12 = require("@nestjs/swagger");
+var import_common25 = require("@nestjs/common");
+var import_swagger13 = require("@nestjs/swagger");
 
 // ../crouton-codegen/src/naming.ts
 var clientAccessor = /* @__PURE__ */ __name((prismaModelName) => {
@@ -8236,12 +8939,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_zod52 = require("zod");
+var import_zod54 = require("zod");
 var import_promises5 = require("fs/promises");
 var import_node_path12 = require("path");
 var ScallfoldDatasourceSchema = DataSourceShape.extend({
   /** Folder name under `dataSourcesDir`. */
-  folder: import_zod52.z.string().default("default")
+  folder: import_zod54.z.string().default("default")
 }).transform(transformDataSource);
 
 // ../crouton-codegen/src/datasource-scaffold.ts
@@ -8619,7 +9322,7 @@ var DevResourcesController = class {
   }
   assertDev() {
     if (!IS_DEV) {
-      throw new import_common24.ForbiddenException("The database sync tools are only available when CROUTON_SCHEMA_EDITOR is enabled.");
+      throw new import_common25.ForbiddenException("The database sync tools are only available when CROUTON_SCHEMA_EDITOR is enabled.");
     }
   }
   /** Loads project config + resolves the datasource + Prisma schema path. Throws 404/400 with a clear message on misconfiguration. */
@@ -8628,14 +9331,14 @@ var DevResourcesController = class {
     try {
       loaded = await loadConfig2(process.cwd());
     } catch (e) {
-      throw new import_common24.NotFoundException(e.message ?? "No crouton.json config found.");
+      throw new import_common25.NotFoundException(e.message ?? "No crouton.json config found.");
     }
     const datasources = await loadDatasources(loaded);
     let ds;
     try {
       ds = resolveDatasource(datasources, datasourceName);
     } catch (e) {
-      throw new import_common24.BadRequestException(e.message);
+      throw new import_common25.BadRequestException(e.message);
     }
     const schemaPath = resolveFromRoot(loaded.root, ds.prismaSchema);
     return {
@@ -8650,7 +9353,7 @@ var DevResourcesController = class {
         schemaPath
       });
     } catch (e) {
-      throw new import_common24.BadRequestException(`Failed to read Prisma schema at ${schemaPath}: ${e.message}`);
+      throw new import_common25.BadRequestException(`Failed to read Prisma schema at ${schemaPath}: ${e.message}`);
     }
   }
   buildApplyContext(loaded, ds) {
@@ -8720,7 +9423,7 @@ var DevResourcesController = class {
       zodOutputDir: zodDir
     });
     if (!result.ok) {
-      throw new import_common24.BadRequestException(`prisma db pull failed:
+      throw new import_common25.BadRequestException(`prisma db pull failed:
 ${result.dbPull.output}`);
     }
     return {
@@ -8737,13 +9440,13 @@ ${result.dbPull.output}`);
   async sync(body) {
     this.assertDev();
     if (!body?.model) {
-      throw new import_common24.BadRequestException('"model" is required.');
+      throw new import_common25.BadRequestException('"model" is required.');
     }
     const { loaded, ds, schemaPath } = await this.loadProject(body.datasource);
     const models = await this.introspectModels(schemaPath);
     const model = models.find((m) => m.prismaName === body.model || m.clientAccessor === body.model);
     if (!model) {
-      throw new import_common24.NotFoundException(`Model "${body.model}" not found in ${schemaPath}.`);
+      throw new import_common25.NotFoundException(`Model "${body.model}" not found in ${schemaPath}.`);
     }
     const resolveRelationResource = await makeRelationResolver(loaded);
     const diff2 = await buildResourceDiff(model, {
@@ -8865,14 +9568,14 @@ ${result.dbPull.output}`);
     const resourcesDir = resolveFromRoot(loaded.root, loaded.config.resourcesDir);
     const jsonPath = resolveResourcePath(resourcesDir, name);
     const raw = readRawResourceJson(jsonPath);
-    if (!raw) throw new import_common24.NotFoundException(`Resource "${name}" not found.`);
-    if (jsonPath.endsWith(".ts")) throw new import_common24.ForbiddenException("TypeScript resources cannot be edited.");
+    if (!raw) throw new import_common25.NotFoundException(`Resource "${name}" not found.`);
+    if (jsonPath.endsWith(".ts")) throw new import_common25.ForbiddenException("TypeScript resources cannot be edited.");
     const patched = applyResourceFlagPatch(raw, {
       draft: false
     });
     const result = validateResourceJson(patched);
     if (!result.success) {
-      throw new import_common24.BadRequestException(`Validation failed: ${result.error.message}`);
+      throw new import_common25.BadRequestException(`Validation failed: ${result.error.message}`);
     }
     writeRawResourceJson(jsonPath, patched);
     return {
@@ -8885,8 +9588,8 @@ ${result.dbPull.output}`);
     const resourcesDir = resolveFromRoot(loaded.root, loaded.config.resourcesDir);
     const jsonPath = resolveResourcePath(resourcesDir, name);
     const raw = readRawResourceJson(jsonPath);
-    if (!raw) throw new import_common24.NotFoundException(`Resource "${name}" not found.`);
-    if (jsonPath.endsWith(".ts")) throw new import_common24.ForbiddenException("TypeScript resources cannot be edited.");
+    if (!raw) throw new import_common25.NotFoundException(`Resource "${name}" not found.`);
+    if (jsonPath.endsWith(".ts")) throw new import_common25.ForbiddenException("TypeScript resources cannot be edited.");
     const patched = applyResourceFlagPatch(raw, {
       sidebar: {
         hide: true
@@ -8894,7 +9597,7 @@ ${result.dbPull.output}`);
     });
     const result = validateResourceJson(patched);
     if (!result.success) {
-      throw new import_common24.BadRequestException(`Validation failed: ${result.error.message}`);
+      throw new import_common25.BadRequestException(`Validation failed: ${result.error.message}`);
     }
     writeRawResourceJson(jsonPath, patched);
     return {
@@ -8907,8 +9610,8 @@ ${result.dbPull.output}`);
     const resourcesDir = resolveFromRoot(loaded.root, loaded.config.resourcesDir);
     const jsonPath = resolveResourcePath(resourcesDir, name);
     const raw = readRawResourceJson(jsonPath);
-    if (!raw) throw new import_common24.NotFoundException(`Resource "${name}" not found.`);
-    if (jsonPath.endsWith(".ts")) throw new import_common24.ForbiddenException("TypeScript resources cannot be edited.");
+    if (!raw) throw new import_common25.NotFoundException(`Resource "${name}" not found.`);
+    if (jsonPath.endsWith(".ts")) throw new import_common25.ForbiddenException("TypeScript resources cannot be edited.");
     const sidebarPatch = {
       hide: false
     };
@@ -8921,7 +9624,7 @@ ${result.dbPull.output}`);
     });
     const result = validateResourceJson(patched);
     if (!result.success) {
-      throw new import_common24.BadRequestException(`Validation failed: ${result.error.message}`);
+      throw new import_common25.BadRequestException(`Validation failed: ${result.error.message}`);
     }
     writeRawResourceJson(jsonPath, patched);
     return {
@@ -8934,12 +9637,12 @@ ${result.dbPull.output}`);
     const resourcesDir = resolveFromRoot(loaded.root, loaded.config.resourcesDir);
     const jsonPath = resolveResourcePath(resourcesDir, name);
     const raw = readRawResourceJson(jsonPath);
-    if (!raw) throw new import_common24.NotFoundException(`Resource "${name}" not found.`);
-    if (jsonPath.endsWith(".ts")) throw new import_common24.ForbiddenException("TypeScript resources cannot be edited.");
+    if (!raw) throw new import_common25.NotFoundException(`Resource "${name}" not found.`);
+    if (jsonPath.endsWith(".ts")) throw new import_common25.ForbiddenException("TypeScript resources cannot be edited.");
     const patched = applyResourceFlagPatch(raw, body);
     const result = validateResourceJson(patched);
     if (!result.success) {
-      throw new import_common24.BadRequestException(`Validation failed: ${result.error.message}`);
+      throw new import_common25.BadRequestException(`Validation failed: ${result.error.message}`);
     }
     writeRawResourceJson(jsonPath, patched);
     return {
@@ -8948,11 +9651,11 @@ ${result.dbPull.output}`);
   }
 };
 _ts_decorate8([
-  (0, import_common24.Get)("models"),
-  (0, import_swagger12.ApiOperation)({
+  (0, import_common25.Get)("models"),
+  (0, import_swagger13.ApiOperation)({
     summary: "Dev-only: list DB models from the Prisma schema, flagging which already have a resource.json and whether the running backend can actually use them yet"
   }),
-  (0, import_swagger12.ApiResponse)({
+  (0, import_swagger13.ApiResponse)({
     status: 200,
     description: "DB models and their resource/client status"
   }),
@@ -8961,11 +9664,11 @@ _ts_decorate8([
   _ts_metadata8("design:returntype", Promise)
 ], DevResourcesController.prototype, "listModels", null);
 _ts_decorate8([
-  (0, import_common24.Post)("restart"),
-  (0, import_swagger12.ApiOperation)({
+  (0, import_common25.Post)("restart"),
+  (0, import_swagger13.ApiOperation)({
     summary: "Dev-only: exit this process so a dev watcher/process manager (nodemon, `nest start --watch`, pm2, a Docker restart policy, ...) restarts it with a fresh Prisma client. Does nothing useful if this process isn't supervised by one of those."
   }),
-  (0, import_swagger12.ApiResponse)({
+  (0, import_swagger13.ApiResponse)({
     status: 200,
     description: "Restart scheduled \u2014 the connection will drop shortly after"
   }),
@@ -8974,15 +9677,15 @@ _ts_decorate8([
   _ts_metadata8("design:returntype", Object)
 ], DevResourcesController.prototype, "restart", null);
 _ts_decorate8([
-  (0, import_common24.Post)("pull"),
-  (0, import_swagger12.ApiOperation)({
+  (0, import_common25.Post)("pull"),
+  (0, import_swagger13.ApiOperation)({
     summary: "Dev-only: run `prisma db pull` + case-format + `prisma generate` for a datasource, refreshing schema.prisma and the generated Prisma client/Zod types from the live database"
   }),
-  (0, import_swagger12.ApiResponse)({
+  (0, import_swagger13.ApiResponse)({
     status: 200,
     description: "Result of each step, or requiresConfirmation if schema.prisma has uncommitted changes"
   }),
-  _ts_param2(0, (0, import_common24.Body)()),
+  _ts_param2(0, (0, import_common25.Body)()),
   _ts_metadata8("design:type", Function),
   _ts_metadata8("design:paramtypes", [
     Object
@@ -8990,15 +9693,15 @@ _ts_decorate8([
   _ts_metadata8("design:returntype", Promise)
 ], DevResourcesController.prototype, "pull", null);
 _ts_decorate8([
-  (0, import_common24.Post)("sync"),
-  (0, import_swagger12.ApiOperation)({
+  (0, import_common25.Post)("sync"),
+  (0, import_swagger13.ApiOperation)({
     summary: "Dev-only: generate or update a single resource.json from its DB model, using recommended defaults (non-interactive)"
   }),
-  (0, import_swagger12.ApiResponse)({
+  (0, import_swagger13.ApiResponse)({
     status: 200,
     description: "Files written for this resource"
   }),
-  _ts_param2(0, (0, import_common24.Body)()),
+  _ts_param2(0, (0, import_common25.Body)()),
   _ts_metadata8("design:type", Function),
   _ts_metadata8("design:paramtypes", [
     Object
@@ -9006,15 +9709,15 @@ _ts_decorate8([
   _ts_metadata8("design:returntype", Promise)
 ], DevResourcesController.prototype, "sync", null);
 _ts_decorate8([
-  (0, import_common24.Post)("plan"),
-  (0, import_swagger12.ApiOperation)({
+  (0, import_common25.Post)("plan"),
+  (0, import_swagger13.ApiOperation)({
     summary: "Dev-only: dry-run introspect + diff across all (or selected) DB models using recommended defaults \u2014 computes what would change, writes nothing"
   }),
-  (0, import_swagger12.ApiResponse)({
+  (0, import_swagger13.ApiResponse)({
     status: 200,
     description: "Proposed per-resource changes"
   }),
-  _ts_param2(0, (0, import_common24.Body)()),
+  _ts_param2(0, (0, import_common25.Body)()),
   _ts_metadata8("design:type", Function),
   _ts_metadata8("design:paramtypes", [
     Object
@@ -9022,15 +9725,15 @@ _ts_decorate8([
   _ts_metadata8("design:returntype", Promise)
 ], DevResourcesController.prototype, "plan", null);
 _ts_decorate8([
-  (0, import_common24.Post)("apply"),
-  (0, import_swagger12.ApiOperation)({
+  (0, import_common25.Post)("apply"),
+  (0, import_swagger13.ApiOperation)({
     summary: "Dev-only: commit resource.json/schema.ts changes to disk for the given resources (or all, if omitted), using recommended defaults"
   }),
-  (0, import_swagger12.ApiResponse)({
+  (0, import_swagger13.ApiResponse)({
     status: 200,
     description: "Per-resource commit results"
   }),
-  _ts_param2(0, (0, import_common24.Body)()),
+  _ts_param2(0, (0, import_common25.Body)()),
   _ts_metadata8("design:type", Function),
   _ts_metadata8("design:paramtypes", [
     Object
@@ -9038,11 +9741,11 @@ _ts_decorate8([
   _ts_metadata8("design:returntype", Promise)
 ], DevResourcesController.prototype, "apply", null);
 _ts_decorate8([
-  (0, import_common24.Get)("visibility"),
-  (0, import_swagger12.ApiOperation)({
+  (0, import_common25.Get)("visibility"),
+  (0, import_swagger13.ApiOperation)({
     summary: "Dev-only: list all resources with their menu visibility state (in-menu, hidden, draft, error)"
   }),
-  (0, import_swagger12.ApiResponse)({
+  (0, import_swagger13.ApiResponse)({
     status: 200,
     description: "Resource visibility list"
   }),
@@ -9051,15 +9754,15 @@ _ts_decorate8([
   _ts_metadata8("design:returntype", Promise)
 ], DevResourcesController.prototype, "visibility", null);
 _ts_decorate8([
-  (0, import_common24.Post)(":name/publish"),
-  (0, import_swagger12.ApiOperation)({
+  (0, import_common25.Post)(":name/publish"),
+  (0, import_swagger13.ApiOperation)({
     summary: "Dev-only: publish a draft resource (removes `draft: true` from resource.json)"
   }),
-  (0, import_swagger12.ApiResponse)({
+  (0, import_swagger13.ApiResponse)({
     status: 200,
     description: "Resource published"
   }),
-  _ts_param2(0, (0, import_common24.Param)("name")),
+  _ts_param2(0, (0, import_common25.Param)("name")),
   _ts_metadata8("design:type", Function),
   _ts_metadata8("design:paramtypes", [
     String
@@ -9067,15 +9770,15 @@ _ts_decorate8([
   _ts_metadata8("design:returntype", Promise)
 ], DevResourcesController.prototype, "publish", null);
 _ts_decorate8([
-  (0, import_common24.Post)(":name/remove-from-menu"),
-  (0, import_swagger12.ApiOperation)({
+  (0, import_common25.Post)(":name/remove-from-menu"),
+  (0, import_swagger13.ApiOperation)({
     summary: "Dev-only: hide a resource from the sidebar menu (sets `sidebar.hide: true` in resource.json)"
   }),
-  (0, import_swagger12.ApiResponse)({
+  (0, import_swagger13.ApiResponse)({
     status: 200,
     description: "Resource removed from menu"
   }),
-  _ts_param2(0, (0, import_common24.Param)("name")),
+  _ts_param2(0, (0, import_common25.Param)("name")),
   _ts_metadata8("design:type", Function),
   _ts_metadata8("design:paramtypes", [
     String
@@ -9083,16 +9786,16 @@ _ts_decorate8([
   _ts_metadata8("design:returntype", Promise)
 ], DevResourcesController.prototype, "removeFromMenu", null);
 _ts_decorate8([
-  (0, import_common24.Post)(":name/add-to-menu"),
-  (0, import_swagger12.ApiOperation)({
+  (0, import_common25.Post)(":name/add-to-menu"),
+  (0, import_swagger13.ApiOperation)({
     summary: "Dev-only: publish + un-hide a resource and optionally set sidebar group/position/label"
   }),
-  (0, import_swagger12.ApiResponse)({
+  (0, import_swagger13.ApiResponse)({
     status: 200,
     description: "Resource added to menu"
   }),
-  _ts_param2(0, (0, import_common24.Param)("name")),
-  _ts_param2(1, (0, import_common24.Body)()),
+  _ts_param2(0, (0, import_common25.Param)("name")),
+  _ts_param2(1, (0, import_common25.Body)()),
   _ts_metadata8("design:type", Function),
   _ts_metadata8("design:paramtypes", [
     String,
@@ -9101,16 +9804,16 @@ _ts_decorate8([
   _ts_metadata8("design:returntype", Promise)
 ], DevResourcesController.prototype, "addToMenu", null);
 _ts_decorate8([
-  (0, import_common24.Patch)(":name/flags"),
-  (0, import_swagger12.ApiOperation)({
+  (0, import_common25.Patch)(":name/flags"),
+  (0, import_swagger13.ApiOperation)({
     summary: "Dev-only: set arbitrary resource flags (draft, sidebar.hide, group, position, label)"
   }),
-  (0, import_swagger12.ApiResponse)({
+  (0, import_swagger13.ApiResponse)({
     status: 200,
     description: "Flags updated"
   }),
-  _ts_param2(0, (0, import_common24.Param)("name")),
-  _ts_param2(1, (0, import_common24.Body)()),
+  _ts_param2(0, (0, import_common25.Param)("name")),
+  _ts_param2(1, (0, import_common25.Body)()),
   _ts_metadata8("design:type", Function),
   _ts_metadata8("design:paramtypes", [
     String,
@@ -9119,8 +9822,8 @@ _ts_decorate8([
   _ts_metadata8("design:returntype", Promise)
 ], DevResourcesController.prototype, "updateFlags", null);
 DevResourcesController = _ts_decorate8([
-  (0, import_common24.Controller)("_app/resources"),
-  (0, import_swagger12.ApiTags)("Dev tools"),
+  (0, import_common25.Controller)("_app/resources"),
+  (0, import_swagger13.ApiTags)("Dev tools"),
   _ts_metadata8("design:type", Function),
   _ts_metadata8("design:paramtypes", [
     typeof DataSourceRegistry === "undefined" ? Object : DataSourceRegistry,
@@ -9129,12 +9832,12 @@ DevResourcesController = _ts_decorate8([
 ], DevResourcesController);
 
 // src/lib/crud/enum-registry/enum-registry.types.ts
-var import_zod53 = require("zod");
-var EnumEntrySchema2 = import_zod53.z.object({
-  value: import_zod53.z.unknown(),
-  label: import_zod53.z.string()
+var import_zod55 = require("zod");
+var EnumEntrySchema2 = import_zod55.z.object({
+  value: import_zod55.z.unknown(),
+  label: import_zod55.z.string()
 });
-var EnumRegistrySchema2 = import_zod53.z.record(import_zod53.z.string(), import_zod53.z.array(EnumEntrySchema2)).default({});
+var EnumRegistrySchema2 = import_zod55.z.record(import_zod55.z.string(), import_zod55.z.array(EnumEntrySchema2)).default({});
 
 // src/lib/crud/enum-registry/enum-registry.loader.ts
 var import_node_fs8 = require("fs");
@@ -9182,7 +9885,7 @@ var injectEnumValues2 = /* @__PURE__ */ __name((columns, enums) => {
 }, "injectEnumValues");
 
 // src/lib/crud/interceptors/no-cache.interceptor.ts
-var import_common25 = require("@nestjs/common");
+var import_common26 = require("@nestjs/common");
 function _ts_decorate9(decorators, target, key, desc2) {
   var c = arguments.length, r = c < 3 ? target : desc2 === null ? desc2 = Object.getOwnPropertyDescriptor(target, key) : desc2, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
@@ -9210,7 +9913,7 @@ var NoCacheInterceptor = class {
   }
 };
 NoCacheInterceptor = _ts_decorate9([
-  (0, import_common25.Injectable)()
+  (0, import_common26.Injectable)()
 ], NoCacheInterceptor);
 
 // src/lib/crud/builder/schema.helpers.ts
@@ -9269,9 +9972,9 @@ var buildResourceDefinitions2 = /* @__PURE__ */ __name((schema, operations, enri
 }, "buildResourceDefinitions");
 
 // src/lib/crud/adapter/relation-type.ts
-var import_zod54 = require("zod");
+var import_zod56 = require("zod");
 var unwrapZodType = /* @__PURE__ */ __name((type) => {
-  if (type instanceof import_zod54.ZodOptional || type instanceof import_zod54.ZodNullable) {
+  if (type instanceof import_zod56.ZodOptional || type instanceof import_zod56.ZodNullable) {
     return unwrapZodType(type.unwrap());
   }
   return type;
@@ -9281,7 +9984,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_zod54.ZodArray ? "oneToMany" : "manyToOne";
+  return inner instanceof import_zod56.ZodArray ? "oneToMany" : "manyToOne";
 }, "deriveRelationType");
 var deriveRelationTypeFromColumns = /* @__PURE__ */ __name((col, cols) => {
   const base = col.column ?? col.id;
@@ -9535,7 +10238,7 @@ var fromJson = /* @__PURE__ */ __name((json, schema, hooks, dirPath, baseUrl, ac
   const subResources = isCustom ? [] : buildSubResources(columns, json.route, json.model ?? "", dirPath, enums, baseUrl);
   const enrichedColumns = resolveColumnFieldVariants2(enrichResourceRefColumns(enrichActionColumns2(columns, json.route, subResources, baseUrl), dirPath, baseUrl) ?? columns);
   const calculatedColumns = json.calculatedColumns ?? [];
-  let views = buildViews(schema, enrichedColumns);
+  let views = buildViews(schema, enrichedColumns, json.layout);
   if (views && calculatedColumns.length) {
     views = {
       ...views,
@@ -9717,6 +10420,20 @@ var validateResourceConfig = /* @__PURE__ */ __name((config, opts) => {
       warnings.push('repository.ts is present on a prisma resource and will be ignored \u2014 set kind: "custom" if you want to use it for data access.');
     }
   }
+  const columns = config.columns ?? [];
+  const columnIds = new Set(columns.map((c) => c.id));
+  for (const col of columns) {
+    const unique = normalizeUnique(col.unique);
+    if (!unique) continue;
+    if (col.idField) {
+      warnings.push(`Column "${col.id}" is the id field; "unique" is redundant there.`);
+    }
+    for (const scopeId of unique.scope ?? []) {
+      if (!columnIds.has(scopeId)) {
+        errors.push(`Column "${col.id}" has unique.scope referencing unknown column "${scopeId}".`);
+      }
+    }
+  }
   return {
     errors,
     warnings
@@ -10176,8 +10893,8 @@ var buildStatus = /* @__PURE__ */ __name(async (registry2, loadedConfigs, enumRe
 }, "buildStatus");
 
 // src/lib/crud/status/status.controller.ts
-var import_common26 = require("@nestjs/common");
-var import_swagger13 = require("@nestjs/swagger");
+var import_common27 = require("@nestjs/common");
+var import_swagger14 = require("@nestjs/swagger");
 function _ts_decorate10(decorators, target, key, desc2) {
   var c = arguments.length, r = c < 3 ? target : desc2 === null ? desc2 = Object.getOwnPropertyDescriptor(target, key) : desc2, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
@@ -10215,11 +10932,11 @@ var createStatusController = /* @__PURE__ */ __name((enumRegistry, translationRe
     }
   };
   _ts_decorate10([
-    (0, import_common26.Get)("status.json"),
-    (0, import_swagger13.ApiOperation)({
+    (0, import_common27.Get)("status.json"),
+    (0, import_swagger14.ApiOperation)({
       summary: "Crouton system status (db, resources, version)"
     }),
-    (0, import_swagger13.ApiResponse)({
+    (0, import_swagger14.ApiResponse)({
       status: 200,
       description: "System status"
     }),
@@ -10228,8 +10945,8 @@ var createStatusController = /* @__PURE__ */ __name((enumRegistry, translationRe
     _ts_metadata9("design:returntype", Promise)
   ], StatusController.prototype, "getStatus", null);
   StatusController = _ts_decorate10([
-    (0, import_common26.Controller)(prefix ? `${prefix}/crouton` : "crouton"),
-    (0, import_swagger13.ApiTags)("Status"),
+    (0, import_common27.Controller)(prefix ? `${prefix}/crouton` : "crouton"),
+    (0, import_swagger14.ApiTags)("Status"),
     _ts_metadata9("design:type", Function),
     _ts_metadata9("design:paramtypes", [
       typeof DataSourceRegistry === "undefined" ? Object : DataSourceRegistry,
@@ -10344,6 +11061,7 @@ var CroutonApiModule = class _CroutonApiModule {
       }
       validConfigs.push(c);
     }
+    warnMissingUniqueConstraints(validConfigs, dataSourceRegistry);
     const configRegistry = new ResourceConfigRegistry(loader, validConfigs);
     let translationRegistry;
     if (config.i18n) {
@@ -10421,7 +11139,7 @@ var CroutonApiModule = class _CroutonApiModule {
   }
 };
 CroutonApiModule = _ts_decorate11([
-  (0, import_common27.Module)({
+  (0, import_common28.Module)({
     controllers: [],
     providers: [],
     exports: []