@ghentcdh/crouton-api 0.0.1-alpha.39 → 0.0.1-alpha.40

package/dist/index.cjs

@@ -34,14 +34,25 @@ __export(index_exports, {
   CroutonApiModule: () => CroutonApiModule,
   DataSourceRegistry: () => DataSourceRegistry,
   FileSystemResourceConfigLoader: () => FileSystemResourceConfigLoader,
+  ReadOpSchema: () => ReadOpSchema,
   ResourceConfigLoader: () => ResourceConfigLoader2,
   ResourceConfigRegistry: () => ResourceConfigRegistry,
+  ResourceHooksSchema: () => ResourceHooksSchema,
+  WriteOpSchema: () => WriteOpSchema,
+  buildFilterWhere: () => buildFilterWhere,
   buildViews: () => buildViews,
+  decorateRow: () => decorateRow,
+  decorateRows: () => decorateRows,
   isOperationEnabled: () => isOperationEnabled,
   isRowProcedureAction: () => isRowProcedureAction,
   isTableProcedureAction: () => isTableProcedureAction,
   loadDataSourcesFromDir: () => loadDataSourcesFromDir,
   loadResourceConfigsFromDir: () => loadResourceConfigsFromDir,
+  loadResourceHooks: () => loadResourceHooks,
+  loadSubResourceHooks: () => loadSubResourceHooks,
+  parseFilterString: () => parseFilterString,
+  postWrite: () => postWrite,
+  prepareWrite: () => prepareWrite,
   resolveDefinition: () => resolveDefinition,
   schemaFor: () => schemaFor,
   upsertOnFor: () => upsertOnFor
@@ -86,6 +97,7 @@ var RequestSchemaWithOffset = RequestSchema.transform((schema) => {
     offset: (page - 1) * pageSize
   };
 });
+var offsetOf = /* @__PURE__ */ __name((params) => params.offset ?? (params.page - 1) * params.pageSize, "offsetOf");
 
 // ../crouton-core/src/lib/filter.ts
 var Operator = [
@@ -240,6 +252,7 @@ var ControlType = {
   textArea: "textarea",
   markdown: "markdown",
   array: "array",
+  object: "object",
   custom: "custom",
   select: "select",
   mutliSelect: "mutliSelect",
@@ -329,6 +342,16 @@ var ControlBuilder = class _ControlBuilder extends ElementBuilder {
       ...options ?? {}
     });
   }
+  /**
+  * Render a datepicker. Defaults to a day-only picker; pass
+  * `{ format: 'dateTime' }` (or `{ withTime: true }`) to include a time.
+  */
+  date(options) {
+    return this.opt({
+      format: ControlType.date,
+      ...options ?? {}
+    });
+  }
   textArea(options) {
     return this.opt({
       format: ControlType.textArea,
@@ -617,7 +640,7 @@ var JsonOperationsSchema = import_zod8.z.object({
 });
 
 // ../crouton-core/src/lib/resource/ResourceJson.schema.ts
-var import_zod15 = require("zod");
+var import_zod18 = require("zod");
 
 // ../crouton-core/src/lib/resource/CalculatedColumn.schema.ts
 var import_zod10 = require("zod");
@@ -771,42 +794,197 @@ var CalculatedColumnSchema = import_zod10.z.object({
 }).transform(normalizeLabel);
 
 // ../crouton-core/src/lib/resource/Column.ts
+var import_zod12 = require("zod");
+
+// ../crouton-core/src/lib/resource/ColumnType.schema.ts
 var import_zod11 = require("zod");
-var WhenConditionSchema = import_zod11.z.object({
-  field: import_zod11.z.string(),
-  eq: import_zod11.z.unknown().optional(),
-  neq: import_zod11.z.unknown().optional(),
-  exists: import_zod11.z.boolean().optional(),
-  notExists: import_zod11.z.boolean().optional()
+var ColumnTypeShorthandSchema = import_zod11.z.enum([
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "date",
+  "date-time",
+  "object",
+  "array"
+]);
+var JsonSchemaFragmentSchema = import_zod11.z.lazy(() => import_zod11.z.object({
+  type: import_zod11.z.union([
+    import_zod11.z.string(),
+    import_zod11.z.array(import_zod11.z.string())
+  ]).optional(),
+  format: import_zod11.z.string().optional(),
+  enum: import_zod11.z.array(import_zod11.z.unknown()).optional(),
+  const: import_zod11.z.unknown().optional(),
+  nullable: import_zod11.z.boolean().optional(),
+  properties: import_zod11.z.record(import_zod11.z.string(), JsonSchemaFragmentSchema).optional(),
+  required: import_zod11.z.array(import_zod11.z.string()).optional(),
+  items: JsonSchemaFragmentSchema.optional(),
+  additionalProperties: import_zod11.z.union([
+    import_zod11.z.boolean(),
+    JsonSchemaFragmentSchema
+  ]).optional(),
+  title: import_zod11.z.string().optional(),
+  description: import_zod11.z.string().optional(),
+  default: import_zod11.z.unknown().optional(),
+  minimum: import_zod11.z.number().optional(),
+  maximum: import_zod11.z.number().optional(),
+  minLength: import_zod11.z.number().optional(),
+  maxLength: import_zod11.z.number().optional(),
+  pattern: import_zod11.z.string().optional()
+}).catchall(import_zod11.z.unknown()));
+var ColumnTypeSchema = import_zod11.z.union([
+  ColumnTypeShorthandSchema,
+  JsonSchemaFragmentSchema
+]);
+var SHORTHAND_FRAGMENTS = {
+  string: {
+    type: "string"
+  },
+  number: {
+    type: "number"
+  },
+  integer: {
+    type: "integer"
+  },
+  boolean: {
+    type: "boolean"
+  },
+  date: {
+    type: "string",
+    format: "date"
+  },
+  "date-time": {
+    type: "string",
+    format: "date-time"
+  },
+  object: {
+    type: "object"
+  },
+  array: {
+    type: "array"
+  }
+};
+var isShorthand = /* @__PURE__ */ __name((type) => typeof type === "string", "isShorthand");
+var NESTED_SHORTHANDS = {
+  date: SHORTHAND_FRAGMENTS.date,
+  "date-time": SHORTHAND_FRAGMENTS["date-time"]
+};
+var normalizeFragment = /* @__PURE__ */ __name((fragment) => {
+  const out = {
+    ...fragment
+  };
+  if (typeof out.type === "string") {
+    const expanded = NESTED_SHORTHANDS[out.type];
+    if (expanded) {
+      out.type = expanded.type;
+      if (out.format === void 0) out.format = expanded.format;
+    }
+  }
+  if (out.properties) {
+    out.properties = Object.fromEntries(Object.entries(out.properties).map(([key, value]) => [
+      key,
+      normalizeFragment(value)
+    ]));
+  }
+  if (out.items) out.items = normalizeFragment(out.items);
+  if (out.additionalProperties && typeof out.additionalProperties === "object") {
+    out.additionalProperties = normalizeFragment(out.additionalProperties);
+  }
+  return out;
+}, "normalizeFragment");
+var columnTypeToJsonSchema = /* @__PURE__ */ __name((type) => {
+  if (type === void 0) return {
+    type: "string"
+  };
+  if (isShorthand(type)) return {
+    ...SHORTHAND_FRAGMENTS[type]
+  };
+  return normalizeFragment(type);
+}, "columnTypeToJsonSchema");
+var columnTypeName = /* @__PURE__ */ __name((type) => {
+  const fragment = columnTypeToJsonSchema(type);
+  const raw = fragment.type;
+  if (Array.isArray(raw)) return raw.find((t) => t !== "null") ?? "string";
+  if (typeof raw === "string") return raw;
+  if (fragment.properties) return "object";
+  if (fragment.items) return "array";
+  return "string";
+}, "columnTypeName");
+var isObjectColumnType = /* @__PURE__ */ __name((type) => columnTypeName(type) === "object", "isObjectColumnType");
+var isArrayColumnType = /* @__PURE__ */ __name((type) => columnTypeName(type) === "array", "isArrayColumnType");
+
+// ../crouton-core/src/lib/resource/Column.ts
+var WhenConditionSchema = import_zod12.z.object({
+  field: import_zod12.z.string(),
+  eq: import_zod12.z.unknown().optional(),
+  neq: import_zod12.z.unknown().optional(),
+  exists: import_zod12.z.boolean().optional(),
+  notExists: import_zod12.z.boolean().optional()
 });
-var JsonColumnSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  column: import_zod11.z.string().optional(),
-  label: import_zod11.z.string().optional(),
-  hiddenInTable: import_zod11.z.boolean().default(false),
-  hiddenInForm: import_zod11.z.boolean().default(false),
-  hiddenInView: import_zod11.z.boolean().default(false),
-  sortable: import_zod11.z.boolean().default(false),
-  defaultSort: import_zod11.z.boolean().default(false),
-  searchable: import_zod11.z.boolean().default(false),
-  filterable: import_zod11.z.boolean().default(false),
-  createable: import_zod11.z.boolean().default(true),
-  updateable: import_zod11.z.boolean().default(true),
-  hideLabel: import_zod11.z.boolean().default(false),
+var JsonColumnSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  column: import_zod12.z.string().optional(),
+  label: import_zod12.z.string().optional(),
+  hiddenInTable: import_zod12.z.boolean().default(false),
+  hiddenInForm: import_zod12.z.boolean().default(false),
+  hiddenInView: import_zod12.z.boolean().default(false),
+  sortable: import_zod12.z.boolean().default(false),
+  defaultSort: import_zod12.z.boolean().default(false),
+  searchable: import_zod12.z.boolean().default(false),
+  filterable: import_zod12.z.boolean().default(false),
+  createable: import_zod12.z.boolean().default(true),
+  updateable: import_zod12.z.boolean().default(true),
+  hideLabel: import_zod12.z.boolean().default(false),
   showWhen: WhenConditionSchema.optional(),
   hideWhen: WhenConditionSchema.optional(),
   disabledWhen: WhenConditionSchema.optional(),
-  displayKey: import_zod11.z.string().optional(),
-  sortId: import_zod11.z.string().optional(),
+  displayKey: import_zod12.z.string().optional(),
+  sortId: import_zod12.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_zod11.z.string().optional(),
-  idField: import_zod11.z.boolean().default(false),
-  showInLookup: import_zod11.z.boolean().default(false),
-  columnType: import_zod11.z.string().default("string"),
+  enum: import_zod12.z.string().optional(),
+  idField: import_zod12.z.boolean().default(false),
+  showInLookup: import_zod12.z.boolean().default(false),
+  /**
+  * Data type of the column, as a shorthand name (`"string"`, `"integer"`, …)
+  * or a full JSON Schema fragment:
+  *
+  * ```json
+  * "type": {
+  *   "type": "object",
+  *   "properties": { "id": { "type": "string" }, "name": { "type": "string" } }
+  * }
+  * ```
+  *
+  * Required on every column of a `kind: "custom"` resource, where it is the
+  * only source of the resource's json_schema. Optional on a `prisma`
+  * resource, whose schema is derived from the Zod model.
+  */
+  type: ColumnTypeSchema.optional(),
+  /**
+  * Whether the form requires a value.
+  *
+  * A prisma resource derives `required` from its Zod model, so this is an
+  * override in either direction: `true` adds the column to the form schema's
+  * `required` array, `false` removes it, and omitting it leaves the model's
+  * answer alone. A `kind: "custom"` resource has no model, so this is the only
+  * way to mark one of its fields required.
+  *
+  * Applies to the **form** view only — a required filter input would make the
+  * filter panel unsubmittable, and the table and view schemas are read-only.
+  * Ignored on the id column and on columns that are neither createable nor
+  * updateable, since the form cannot supply a value for those.
+  */
+  required: import_zod12.z.boolean().optional(),
+  /**
+  * @deprecated Use `type` instead. Retained because it is still consumed by
+  * the boolean predicate and the schema-less sub-resource view builder.
+  */
+  columnType: import_zod12.z.string().default("string"),
   fieldInput: FieldInputSchema.optional(),
   /**
   * Optional per-context override for the read-only VIEW ui. Same shape as
@@ -830,40 +1008,65 @@ var JsonColumnSchema = import_zod11.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_zod11.z.string().optional(),
+  extend: import_zod12.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_zod11.z.record(import_zod11.z.string(), import_zod11.z.record(import_zod11.z.string(), import_zod11.z.unknown())).optional()
+  columns: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.record(import_zod12.z.string(), import_zod12.z.unknown())).optional()
+});
+
+// ../crouton-core/src/lib/resource/ParentRef.schema.ts
+var import_zod13 = require("zod");
+var ParentRefSchema = import_zod13.z.object({
+  /** Route segment of the parent, e.g. `"group"`. */
+  route: import_zod13.z.string(),
+  /**
+  * Name of the path parameter carrying the parent id, e.g. `"groupId"`.
+  * Avoid `"id"` — that is the child's own id in `/:id` routes.
+  */
+  param: import_zod13.z.string().default("parentId"),
+  /** Type of the parent id, used to coerce the path param. Defaults to `'string'`. */
+  idType: import_zod13.z.enum([
+    "string",
+    "number"
+  ]).optional()
 });
+var resourceControllerPath = /* @__PURE__ */ __name((route, parent) => parent ? `${parent.route}/:${parent.param}/${route}` : route, "resourceControllerPath");
+
+// ../crouton-core/src/lib/resource/ResourceKind.ts
+var import_zod14 = require("zod");
+var ResourceKindSchema = import_zod14.z.enum([
+  "prisma",
+  "custom"
+]).default("prisma");
 
 // ../crouton-core/src/lib/resource/Sidebar.schema.ts
-var import_zod12 = __toESM(require("zod"), 1);
-var SidebarGroupSchema = import_zod12.default.object({
+var import_zod15 = __toESM(require("zod"), 1);
+var SidebarGroupSchema = import_zod15.default.object({
   /** Human-readable heading shown in the sidebar. Defaults to a title-cased version of the slug. */
-  label: import_zod12.default.string().optional(),
+  label: import_zod15.default.string().optional(),
   /** Controls the order of this group among top-level sidebar items. */
-  position: import_zod12.default.number().optional()
+  position: import_zod15.default.number().optional()
 });
-var SidebarSchema = import_zod12.default.object({
-  hide: import_zod12.default.boolean().default(false),
-  position: import_zod12.default.number().optional(),
-  label: import_zod12.default.string().optional(),
+var SidebarSchema = import_zod15.default.object({
+  hide: import_zod15.default.boolean().default(false),
+  position: import_zod15.default.number().optional(),
+  label: import_zod15.default.string().optional(),
   /**
   * 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_zod12.default.string().optional()
+  group: import_zod15.default.string().optional()
 });
 
 // ../crouton-core/src/lib/resource/TableAction.schema.ts
-var import_zod13 = require("zod");
-var ActionConditionSchema = import_zod13.z.object({
+var import_zod16 = require("zod");
+var ActionConditionSchema = import_zod16.z.object({
   /** Row field to evaluate. */
-  field: import_zod13.z.string(),
+  field: import_zod16.z.string(),
   /**
   * Comparison operator. Defaults to `"eq"`.
   * - `eq` / `neq`         — strict equality
@@ -871,7 +1074,7 @@ var ActionConditionSchema = import_zod13.z.object({
   * - `exists`             — field is not null / undefined / empty string
   * - `notExists`          — field is null / undefined / empty string
   */
-  op: import_zod13.z.enum([
+  op: import_zod16.z.enum([
     "eq",
     "neq",
     "gt",
@@ -882,38 +1085,38 @@ var ActionConditionSchema = import_zod13.z.object({
     "notExists"
   ]).default("eq"),
   /** Comparison value. Not required for `exists` / `notExists`. */
-  value: import_zod13.z.unknown().optional()
+  value: import_zod16.z.unknown().optional()
 });
-var ActionSchema = import_zod13.z.object({
-  type: import_zod13.z.string(),
+var ActionSchema = import_zod16.z.object({
+  type: import_zod16.z.string(),
   /** Unique identifier for the action. */
-  id: import_zod13.z.string(),
+  id: import_zod16.z.string(),
   /** Human-readable button label. */
-  label: import_zod13.z.string(),
+  label: import_zod16.z.string(),
   /** MDI icon name, e.g. `"mdi:open-in-new"`. */
-  icon: import_zod13.z.string().optional(),
+  icon: import_zod16.z.string().optional(),
   /** Tooltip text. Falls back to `label` when omitted. */
-  tooltip: import_zod13.z.string().optional(),
+  tooltip: import_zod16.z.string().optional(),
   condition: ActionConditionSchema.optional()
 });
 var JsonProcedureActionSchema = ActionSchema.extend({
-  type: import_zod13.z.literal("procedure").default("procedure"),
+  type: import_zod16.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_zod13.z.string(),
+  procedure: import_zod16.z.string(),
   /** HTTP method for the frontend. Defaults to `"post"`. */
-  method: import_zod13.z.string().optional().default("post"),
+  method: import_zod16.z.string().optional().default("post"),
   /** Static query / body params passed to the endpoint. */
-  data: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.unknown()).optional()
+  data: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.unknown()).optional()
 });
 var JsonLinkActionSchema = ActionSchema.extend({
   /** Optional condition evaluated per row. Button is hidden when the condition is false. */
-  type: import_zod13.z.literal("link").default("link"),
+  type: import_zod16.z.literal("link").default("link"),
   /** URL to open. May contain `{env.VAR}` placeholders. */
-  href: import_zod13.z.string(),
-  blank: import_zod13.z.boolean().optional().default(true)
+  href: import_zod16.z.string(),
+  blank: import_zod16.z.boolean().optional().default(true)
 });
 var transformAction = /* @__PURE__ */ __name((action) => {
   const label = action.label;
@@ -922,20 +1125,20 @@ var transformAction = /* @__PURE__ */ __name((action) => {
     ...action
   };
 }, "transformAction");
-var JsonActionSchema = import_zod13.z.union([
+var JsonActionSchema = import_zod16.z.union([
   JsonProcedureActionSchema,
   JsonLinkActionSchema
 ]).transform(transformAction);
 
 // ../crouton-core/src/lib/resource/include.schema.ts
-var import_zod14 = require("zod");
-var JsonIncludeEntrySchema = import_zod14.z.lazy(() => import_zod14.z.union([
-  import_zod14.z.string(),
-  import_zod14.z.object({
-    relation: import_zod14.z.string(),
-    include: import_zod14.z.array(JsonIncludeEntrySchema).optional(),
+var import_zod17 = require("zod");
+var JsonIncludeEntrySchema = import_zod17.z.lazy(() => import_zod17.z.union([
+  import_zod17.z.string(),
+  import_zod17.z.object({
+    relation: import_zod17.z.string(),
+    include: import_zod17.z.array(JsonIncludeEntrySchema).optional(),
     /** Prisma-format orderBy clause applied to the included records. */
-    orderBy: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.unknown()).optional()
+    orderBy: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.unknown()).optional()
   })
 ]));
 
@@ -944,16 +1147,16 @@ var BASELINE_RESOURCE_VERSION = 1;
 var CURRENT_RESOURCE_VERSION = 1;
 
 // ../crouton-core/src/lib/resource/ResourceJson.schema.ts
-var JsonColumnsMapSchema = import_zod15.z.record(import_zod15.z.string(), JsonColumnSchema.omit({
+var JsonColumnsMapSchema = import_zod18.z.record(import_zod18.z.string(), JsonColumnSchema.omit({
   id: true
-}).catchall(import_zod15.z.unknown()));
+}).catchall(import_zod18.z.unknown()));
 var ColumnsSchema = JsonColumnsMapSchema;
-var JsonDisplaySchema = import_zod15.z.object({
-  mode: import_zod15.z.enum([
+var JsonDisplaySchema = import_zod18.z.object({
+  mode: import_zod18.z.enum([
     "page",
     "modal"
   ]).default("modal"),
-  customComponent: import_zod15.z.string().nullable().optional().default(null)
+  customComponent: import_zod18.z.string().nullable().optional().default(null)
 });
 var normalizeColumns = /* @__PURE__ */ __name((columns) => {
   if (!columns) return void 0;
@@ -966,37 +1169,61 @@ var normalizeColumns = /* @__PURE__ */ __name((columns) => {
     label: col.label ?? labelFromId(col.id)
   }));
 }, "normalizeColumns");
-var ResourceJsonShape = import_zod15.z.object({
+var ResourceJsonShape = import_zod18.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_zod15.z.string().optional(),
+  $schema: import_zod18.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_zod15.z.number().int().positive().optional(),
+  schemaVersion: import_zod18.z.number().int().positive().optional(),
   /** When `true`, the resource lives in the repo but is NOT loaded/served (work in progress). */
-  draft: import_zod15.z.boolean().optional().default(false),
-  name: import_zod15.z.string(),
-  route: import_zod15.z.string(),
-  model: import_zod15.z.string(),
-  tag: import_zod15.z.string(),
-  title: import_zod15.z.string().optional(),
-  table: import_zod15.z.string().optional(),
-  database: import_zod15.z.string().optional(),
+  draft: import_zod18.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_zod18.z.string(),
+  route: import_zod18.z.string(),
+  /**
+  * 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_zod18.z.string().optional(),
+  tag: import_zod18.z.string(),
+  title: import_zod18.z.string().optional(),
+  table: import_zod18.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_zod18.z.enum([
+    "string",
+    "number"
+  ]).optional(),
+  database: import_zod18.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.
+  */
+  parent: ParentRefSchema.optional(),
   sidebar: SidebarSchema.default(SidebarSchema.parse({})),
   display: JsonDisplaySchema.default(JsonDisplaySchema.parse({})),
   operations: JsonOperationsSchema,
   columns: ColumnsSchema.default(ColumnsSchema.parse({})),
-  calculatedColumns: import_zod15.z.array(CalculatedColumnSchema).default([]),
-  actions: import_zod15.z.array(JsonActionSchema).default([]),
+  calculatedColumns: import_zod18.z.array(CalculatedColumnSchema).default([]),
+  actions: import_zod18.z.array(JsonActionSchema).default([]),
   /** Global table-level actions (no record id). Shown as toolbar buttons. */
-  tableActions: import_zod15.z.array(JsonActionSchema).default([]),
+  tableActions: import_zod18.z.array(JsonActionSchema).default([]),
   /** Modal width when opening a form for this resource. */
-  modalSize: import_zod15.z.enum([
+  modalSize: import_zod18.z.enum([
     "xs",
     "sm",
     "lg",
@@ -1009,9 +1236,73 @@ var ResourceJsonShape = import_zod15.z.object({
   * `{ "relation": "text_author", "include": ["author"] }` →
   *   `include: { text_author: { include: { author: true } } }`
   */
-  include: import_zod15.z.array(JsonIncludeEntrySchema).default([])
+  include: import_zod18.z.array(JsonIncludeEntrySchema).default([])
 });
-var ResourceJsonSchema = ResourceJsonShape.transform((obj) => {
+var refineByKind = /* @__PURE__ */ __name((obj, ctx) => {
+  if (obj.kind === "custom") {
+    if (obj.model !== void 0) {
+      ctx.addIssue({
+        code: "custom",
+        path: [
+          "model"
+        ],
+        message: 'A custom resource has no Prisma model. Remove "model" \u2014 data access comes from repository.ts.'
+      });
+    }
+    if (obj.calculatedColumns?.length) {
+      ctx.addIssue({
+        code: "custom",
+        path: [
+          "calculatedColumns"
+        ],
+        message: "calculatedColumns run raw SQL against a database table and are not supported on a custom resource. Compute the value in repository.ts instead."
+      });
+    }
+    for (const [id, col] of Object.entries(obj.columns ?? {})) {
+      if (col.fieldInput?.format === "relation" || col.fieldInput?.type === "autocomplete") {
+        continue;
+      }
+      if (col.type === void 0) {
+        ctx.addIssue({
+          code: "custom",
+          path: [
+            "columns",
+            id,
+            "type"
+          ],
+          message: `Column "${id}" needs a "type": a custom resource has no schema.ts, so its json_schema is built from the column types.`
+        });
+      }
+    }
+    if (obj.parent && obj.parent.param === "id") {
+      ctx.addIssue({
+        code: "custom",
+        path: [
+          "parent",
+          "param"
+        ],
+        message: `parent.param cannot be "id" \u2014 that is the child's own id in /:id routes. Use something like "groupId".`
+      });
+    }
+  } else if (obj.parent !== void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: [
+        "parent"
+      ],
+      message: '"parent" is only supported on a custom resource. A prisma resource is nested by declaring a relation column on its parent.'
+    });
+  } else if (obj.model === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: [
+        "model"
+      ],
+      message: '"model" is required for a prisma-backed resource. Set "kind": "custom" for a resource with no Prisma model.'
+    });
+  }
+}, "refineByKind");
+var ResourceJsonSchema = ResourceJsonShape.superRefine(refineByKind).transform((obj) => {
   const title = obj.title ?? labelFromId(obj.name);
   const schemaVersion = obj.schemaVersion ?? BASELINE_RESOURCE_VERSION;
   return {
@@ -1090,50 +1381,50 @@ var resolveViewField = /* @__PURE__ */ __name((c) => mergeFieldVariant(c.fieldIn
 var resolveTableField = /* @__PURE__ */ __name((c) => mergeFieldVariant(resolveViewField(c), c.fieldTable), "resolveTableField");
 
 // ../crouton-core/src/lib/config/CroutonConfig.schema.ts
-var import_zod16 = require("zod");
-var RulesetSchema = import_zod16.z.object({
-  hideIdInTable: import_zod16.z.boolean().default(true),
-  hideIdInForm: import_zod16.z.boolean().default(true),
-  hideIdInView: import_zod16.z.boolean().default(true),
-  hideTimestamps: import_zod16.z.boolean().default(true),
-  hideForeignKeys: import_zod16.z.boolean().default(true),
-  includeRelations: import_zod16.z.boolean().default(false),
-  hideRelationsInTable: import_zod16.z.boolean().default(true),
-  showRelationsInForm: import_zod16.z.boolean().default(true),
-  enumValueLabel: import_zod16.z.boolean().default(true),
-  sharedEnums: import_zod16.z.boolean().default(true),
+var import_zod19 = require("zod");
+var RulesetSchema = import_zod19.z.object({
+  hideIdInTable: import_zod19.z.boolean().default(true),
+  hideIdInForm: import_zod19.z.boolean().default(true),
+  hideIdInView: import_zod19.z.boolean().default(true),
+  hideTimestamps: import_zod19.z.boolean().default(true),
+  hideForeignKeys: import_zod19.z.boolean().default(true),
+  includeRelations: import_zod19.z.boolean().default(true),
+  hideRelationsInTable: import_zod19.z.boolean().default(true),
+  showRelationsInForm: import_zod19.z.boolean().default(true),
+  enumValueLabel: import_zod19.z.boolean().default(true),
+  sharedEnums: import_zod19.z.boolean().default(true),
   defaultOperations: JsonOperationsSchema.default(JsonOperationsSchema.parse({}))
 });
-var CroutonConfigSchema = import_zod16.z.object({
+var CroutonConfigSchema = import_zod19.z.object({
   /**
   * Application title served to the frontend via `GET /_app/layout`.
   * Displayed in the admin sidebar header.
   */
-  title: import_zod16.z.string(),
+  title: import_zod19.z.string(),
   /** Where resource directories live, relative to the project root. */
-  resourcesDir: import_zod16.z.string(),
+  resourcesDir: import_zod19.z.string(),
   /** Where datasource folders live (each with a `data-source.json`). */
-  dataSourcesDir: import_zod16.z.string(),
+  dataSourcesDir: import_zod19.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_zod16.z.string().default("{Model}WithRelationsSchema"),
+  schemaExportName: import_zod19.z.string().default("{Model}WithRelationsSchema"),
   /** Path to the shared enum registry, relative to project root. Default `crouton.enums.json`. */
-  enumsFile: import_zod16.z.string().default("crouton.enums.json"),
+  enumsFile: import_zod19.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_zod16.z.record(import_zod16.z.string(), SidebarGroupSchema).default({}),
+  sidebarGroups: import_zod19.z.record(import_zod19.z.string(), SidebarGroupSchema).default({}),
   /**
   * Whether form fields are saved automatically as the user edits them.
   * @default true
   */
-  autoSave: import_zod16.z.boolean().default(true)
+  autoSave: import_zod19.z.boolean().default(true)
 });
 
 // ../crouton-core/src/lib/config/readConfig.ts
@@ -1149,6 +1440,9 @@ var isRelation = /* @__PURE__ */ __name((col) => col.fieldInput?.format === "rel
 var isAutocomplete = /* @__PURE__ */ __name((col) => col.fieldInput?.type === "autocomplete", "isAutocomplete");
 var isRecordCell = /* @__PURE__ */ __name((col) => isRelation(col) || isAutocomplete(col), "isRecordCell");
 var isDateRange = /* @__PURE__ */ __name((col) => col.fieldInput?.format === "date-range", "isDateRange");
+var isObjectColumn = /* @__PURE__ */ __name((col) => isObjectColumnType(col.type), "isObjectColumn");
+var isArrayColumn = /* @__PURE__ */ __name((col) => isArrayColumnType(col.type), "isArrayColumn");
+var isObjectCell = /* @__PURE__ */ __name((col) => isObjectColumn(col) && !!col.displayKey, "isObjectCell");
 
 // ../crouton-core/src/lib/view/column.utils.ts
 var colPosition = /* @__PURE__ */ __name((col, i) => col.fieldInput?.position ?? i, "colPosition");
@@ -1290,7 +1584,7 @@ var buildTableUiSchema = /* @__PURE__ */ __name((cols) => {
     const id = el.scope?.replace("#/properties/", "");
     const col = id ? colMap[id] : void 0;
     if (!col) return el;
-    const fieldInputOptions = isRecordCell(col) || isDateRange(col) ? col.fieldInput?.options ?? {} : pickSharedCellOptions(col);
+    const fieldInputOptions = isRecordCell(col) || isDateRange(col) || isObjectCell(col) ? col.fieldInput?.options ?? {} : pickSharedCellOptions(col);
     const dataPathOption = col.column ? {
       dataPath: col.column
     } : {};
@@ -1316,7 +1610,9 @@ var buildTableUiSchema = /* @__PURE__ */ __name((cols) => {
         },
         label: col.label
       },
-      ...isRecordCell(col) && {
+      // An object column with a displayKey renders the same way as a relation:
+      // one nested key out of an object value.
+      ...(isRecordCell(col) || isObjectCell(col)) && {
         type: "RecordCell"
       },
       ...isDateRange(col) && {
@@ -1374,6 +1670,11 @@ var buildDetailLayout = /* @__PURE__ */ __name((detail) => {
   if (detail.titleKey) inner.titleKey(detail.titleKey);
   return inner;
 }, "buildDetailLayout");
+var defaultControlFormat = /* @__PURE__ */ __name((col) => {
+  if (isObjectColumn(col)) return "object";
+  if (isArrayColumn(col)) return "array";
+  return "text";
+}, "defaultControlFormat");
 var buildFormControl = /* @__PURE__ */ __name((col) => {
   const control = ControlBuilder.properties(col.id);
   const fieldInput = col.fieldInput;
@@ -1397,6 +1698,13 @@ var buildFormControl = /* @__PURE__ */ __name((col) => {
     control.detailFixed(detailLayout, {
       layout: fieldInput.detail.layout === "collapse" ? "row" : void 0
     });
+  } else if (fieldInput?.format !== "date-range" && (fieldInput?.type === "date" || fieldInput?.format === "dateTime")) {
+    const options = {
+      ...fieldInput.options
+    };
+    if (!options.colspan) options.colspan = 12;
+    const format = fieldInput.format === "dateTime" ? "dateTime" : "date";
+    control.control(format, options).width("full");
   } else if (fieldInput?.format === "date-range") {
     const options = {
       ...fieldInput.options
@@ -1406,7 +1714,7 @@ var buildFormControl = /* @__PURE__ */ __name((col) => {
   } else {
     const options = fieldInput?.options ?? {};
     if (!options.colspan) options.colspan = 12;
-    const type = fieldInput?.type ?? "text";
+    const type = fieldInput?.type ?? defaultControlFormat(col);
     control.control(type, options).width("full");
   }
   if (fieldInput?.customRender) control.setCustomRender(fieldInput?.customRender);
@@ -1502,19 +1810,66 @@ 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_zod18 = require("zod");
+var import_zod21 = require("zod");
+
+// ../crouton-core/src/lib/view/column-type-schema.source.ts
+var optionValues = /* @__PURE__ */ __name((col) => {
+  const values = col.fieldInput?.options?.["values"];
+  if (!Array.isArray(values)) return void 0;
+  const unwrapped = values.map((v) => v && typeof v === "object" && "value" in v ? v.value : v);
+  return unwrapped.length ? unwrapped : void 0;
+}, "optionValues");
+var columnToJsonSchemaProperty = /* @__PURE__ */ __name((col) => {
+  const property = col.type === void 0 && isAutocomplete(col) ? {} : {
+    ...columnTypeToJsonSchema(col.type)
+  };
+  if (property.title === void 0) property.title = col.label ?? col.id;
+  if (col.fieldInput?.defaultValue !== void 0 && property.default === void 0) {
+    property.default = col.fieldInput.defaultValue;
+  }
+  if (property.enum === void 0) {
+    const values = optionValues(col);
+    if (values) property.enum = values;
+  }
+  return property;
+}, "columnToJsonSchemaProperty");
+var columnTypeSchemaSource = /* @__PURE__ */ __name((schemaCols) => {
+  if (!schemaCols.length) return void 0;
+  const properties = {};
+  for (const col of schemaCols) {
+    properties[col.id] = columnToJsonSchemaProperty(col);
+  }
+  return {
+    type: "object",
+    properties
+  };
+}, "columnTypeSchemaSource");
 
 // ../crouton-core/src/lib/view/json-schema.opts.ts
-var import_zod17 = require("zod");
-var dateOverride = /* @__PURE__ */ __name(({ zodSchema, jsonSchema }) => {
-  if (zodSchema instanceof import_zod17.z.ZodDate) {
+var import_zod20 = require("zod");
+var isInstanceOf = /* @__PURE__ */ __name((zodSchema, className) => {
+  if (!(zodSchema instanceof import_zod20.z.ZodCustom)) return false;
+  const result = zodSchema.safeParse(null);
+  return !result.success && result.error.issues[0]?.expected === className;
+}, "isInstanceOf");
+var jsonSchemaOverride = /* @__PURE__ */ __name(({ zodSchema, jsonSchema }) => {
+  if (zodSchema instanceof import_zod20.z.ZodDate) {
     jsonSchema.type = "string";
     jsonSchema.format = "date-time";
   }
-}, "dateOverride");
+  if (zodSchema instanceof import_zod20.z.ZodBigInt) {
+    jsonSchema.type = "integer";
+  }
+  if (isInstanceOf(zodSchema, "Decimal")) {
+    jsonSchema.type = "number";
+  }
+  if (isInstanceOf(zodSchema, "Buffer")) {
+    jsonSchema.type = "string";
+  }
+}, "jsonSchemaOverride");
 var jsonSchemaOpts = {
   unrepresentable: "any",
-  override: dateOverride
+  override: jsonSchemaOverride
 };
 
 // ../crouton-core/src/lib/view/view.builder.ts
@@ -1567,11 +1922,7 @@ var injectFieldDefaults = /* @__PURE__ */ __name((jsonSchema, columns) => {
     if (prop) prop.default = col.fieldInput.defaultValue;
   }
 }, "injectFieldDefaults");
-var buildView = /* @__PURE__ */ __name((schema, columns, visible, buildUiSchema, sort = false, schemaVisible) => {
-  if (!schema || !columns?.length) return void 0;
-  const visibleCols = sort ? sortByPosition(columns.filter(visible)) : columns.filter(visible);
-  if (!visibleCols.length) return void 0;
-  const schemaCols = (schemaVisible ? columns.filter((c) => visible(c) || schemaVisible(c)) : visibleCols).filter((c) => !isRelation(c));
+var zodSchemaSource = /* @__PURE__ */ __name((schema) => (schemaCols) => {
   const schemaKeys = new Set(Object.keys(schema.shape));
   const schemaIds = schemaCols.map((c) => c.id).filter((id) => schemaKeys.has(id));
   if (!schemaIds.length) return void 0;
@@ -1580,10 +1931,61 @@ var buildView = /* @__PURE__ */ __name((schema, columns, visible, buildUiSchema,
     true
   ]));
   const picked = schema.pick(mask);
-  const jsonSchema = (0, import_zod18.toJSONSchema)(picked, {
+  return (0, import_zod21.toJSONSchema)(picked, {
     target: "draft-07",
     ...jsonSchemaOpts
   });
+}, "zodSchemaSource");
+var NON_NULL_TYPES = [
+  "object",
+  "array",
+  "string",
+  "number",
+  "boolean"
+];
+var SHAPE_KEYS = [
+  "type",
+  "enum",
+  "const",
+  "anyOf",
+  "oneOf",
+  "allOf",
+  "$ref"
+];
+var applyRequiredColumns = /* @__PURE__ */ __name((jsonSchema, columns) => {
+  if (!columns?.length) return;
+  const properties = jsonSchema["properties"];
+  if (!properties) return;
+  const required = new Set(Array.isArray(jsonSchema["required"]) ? jsonSchema["required"] : []);
+  for (const col of columns) {
+    if (col.required === void 0) continue;
+    if (!(col.id in properties)) continue;
+    if (!col.required) {
+      required.delete(col.id);
+      continue;
+    }
+    if (col.idField) continue;
+    if (col.createable === false && col.updateable === false) continue;
+    required.add(col.id);
+    const property = properties[col.id];
+    if (property && typeof property === "object" && !SHAPE_KEYS.some((key) => key in property)) {
+      property["type"] = [
+        ...NON_NULL_TYPES
+      ];
+    }
+  }
+  if (required.size) jsonSchema["required"] = [
+    ...required
+  ];
+  else delete jsonSchema["required"];
+}, "applyRequiredColumns");
+var buildView = /* @__PURE__ */ __name((source, columns, visible, buildUiSchema, sort = false, schemaVisible) => {
+  if (!source || !columns?.length) return void 0;
+  const visibleCols = sort ? sortByPosition(columns.filter(visible)) : columns.filter(visible);
+  if (!visibleCols.length) return void 0;
+  const schemaCols = (schemaVisible ? columns.filter((c) => visible(c) || schemaVisible(c)) : visibleCols).filter((c) => !isRelation(c));
+  const jsonSchema = source(schemaCols);
+  if (!jsonSchema) return void 0;
   applySchemaTransforms(jsonSchema);
   injectFieldDefaults(jsonSchema, visibleCols);
   if (schemaVisible) {
@@ -1608,26 +2010,31 @@ var emptyTableView = /* @__PURE__ */ __name(() => ({
   ui_schema: buildTableUiSchema([]),
   columns: []
 }), "emptyTableView");
-var buildViews = /* @__PURE__ */ __name((schema, columns) => {
+var buildViewsWithSource = /* @__PURE__ */ __name((source, columns) => {
   const views = {};
-  const table = buildView(schema, columns?.map((c) => columnForContext(c, "table")), (c) => !c.hiddenInTable, buildTableUiSchema, true);
+  const table = buildView(source, columns?.map((c) => columnForContext(c, "table")), (c) => !c.hiddenInTable, buildTableUiSchema, true);
   if (table) {
     table.defaultSort = resolveDefaultSort(table.columns, columns);
     views.table = table;
   } else if (columns?.length) {
     views.table = emptyTableView();
   }
-  const form = buildView(schema, columns, (c) => !c.hiddenInForm, buildFormUiSchema, true, (c) => !c.idField && (c.createable === true || c.updateable === true));
-  if (form) views.form = form;
-  const filter = buildView(schema, columns, (c) => !!c.filterable, buildFormUiSchema, true);
+  const form = buildView(source, columns, (c) => !c.hiddenInForm, buildFormUiSchema, true, (c) => !c.idField && (c.createable === true || c.updateable === true));
+  if (form) {
+    applyRequiredColumns(form.json_schema, columns);
+    views.form = form;
+  }
+  const filter = buildView(source, columns, (c) => !!c.filterable, buildFormUiSchema, true);
   if (filter) {
     patchFilterProperties(filter.json_schema, columns?.filter((c) => !!c.filterable));
     views.filter = filter;
   }
-  const view = buildView(schema, columns?.map((c) => columnForContext(c, "view")), (c) => !c.hiddenInView, buildFormUiSchema, true);
+  const view = buildView(source, columns?.map((c) => columnForContext(c, "view")), (c) => !c.hiddenInView, buildFormUiSchema, true);
   if (view) views.view = view;
   return Object.keys(views).length ? views : void 0;
-}, "buildViews");
+}, "buildViewsWithSource");
+var buildViews = /* @__PURE__ */ __name((schema, columns) => buildViewsWithSource(schema ? zodSchemaSource(schema) : void 0, columns), "buildViews");
+var buildViewsFromColumnTypes = /* @__PURE__ */ __name((columns) => buildViewsWithSource(columnTypeSchemaSource, columns), "buildViewsFromColumnTypes");
 var buildViewsFromColumns = /* @__PURE__ */ __name((columns) => {
   if (!columns?.length) return void 0;
   const buildJsonSchema = /* @__PURE__ */ __name((cols) => {
@@ -1656,6 +2063,8 @@ var buildViewsFromColumns = /* @__PURE__ */ __name((columns) => {
           type: "string",
           title: c.label ?? c.id
         };
+      } else if (c.type !== void 0) {
+        properties[c.id] = columnToJsonSchemaProperty(c);
       } else {
         const opts = c.fieldInput?.options;
         const isObject = opts?.emitObject === true || c.fieldInput?.type === "autocomplete";
@@ -1718,7 +2127,10 @@ var buildViewsFromColumns = /* @__PURE__ */ __name((columns) => {
   }
   const formCols = sortByPosition(columns.filter((c) => !c.hiddenInForm));
   const form = makeView(formCols, buildFormUiSchema);
-  if (form) views.form = form;
+  if (form) {
+    applyRequiredColumns(form.json_schema, formCols);
+    views.form = form;
+  }
   const viewCols = sortByPosition(columns.filter((c) => !c.hiddenInView).map((c) => columnForContext(c, "view")));
   const viewView = makeView(viewCols, buildFormUiSchema);
   if (viewView) views.view = viewView;
@@ -1726,41 +2138,41 @@ var buildViewsFromColumns = /* @__PURE__ */ __name((columns) => {
 }, "buildViewsFromColumns");
 
 // ../crouton-core/src/lib/view/view.schema.ts
-var import_zod19 = require("zod");
-var ViewColumnConfigSchema = import_zod19.z.object({
-  id: import_zod19.z.string(),
-  label: import_zod19.z.string().optional(),
-  sortable: import_zod19.z.boolean().optional(),
-  searchable: import_zod19.z.boolean().optional(),
+var import_zod22 = require("zod");
+var ViewColumnConfigSchema = import_zod22.z.object({
+  id: import_zod22.z.string(),
+  label: import_zod22.z.string().optional(),
+  sortable: import_zod22.z.boolean().optional(),
+  searchable: import_zod22.z.boolean().optional(),
   fieldInput: FieldInputSchema.optional()
 });
-var ViewConfigSchema = import_zod19.z.object({
-  json_schema: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.unknown()),
-  ui_schema: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.unknown()),
-  columns: import_zod19.z.array(ViewColumnConfigSchema),
-  defaultSort: import_zod19.z.string().optional()
+var ViewConfigSchema = import_zod22.z.object({
+  json_schema: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.unknown()),
+  ui_schema: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.unknown()),
+  columns: import_zod22.z.array(ViewColumnConfigSchema),
+  defaultSort: import_zod22.z.string().optional()
 });
 
 // src/lib/crouton-api.module.ts
-var import_common19 = require("@nestjs/common");
+var import_common21 = require("@nestjs/common");
 var import_core = require("@nestjs/core");
 
 // src/lib/crud/app-layout/app-layout.types.ts
-var import_zod20 = require("zod");
-var SidebarLeafSchema = import_zod20.z.object({
-  kind: import_zod20.z.literal("item").default("item"),
-  id: import_zod20.z.string(),
-  label: import_zod20.z.string(),
-  position: import_zod20.z.number().optional()
+var import_zod23 = require("zod");
+var SidebarLeafSchema = import_zod23.z.object({
+  kind: import_zod23.z.literal("item").default("item"),
+  id: import_zod23.z.string(),
+  label: import_zod23.z.string(),
+  position: import_zod23.z.number().optional()
 });
-var SidebarGroupSchema2 = import_zod20.z.object({
-  kind: import_zod20.z.literal("group").default("group"),
-  id: import_zod20.z.string(),
-  label: import_zod20.z.string(),
-  position: import_zod20.z.number().optional(),
-  children: import_zod20.z.array(SidebarLeafSchema).default([])
+var SidebarGroupSchema2 = import_zod23.z.object({
+  kind: import_zod23.z.literal("group").default("group"),
+  id: import_zod23.z.string(),
+  label: import_zod23.z.string(),
+  position: import_zod23.z.number().optional(),
+  children: import_zod23.z.array(SidebarLeafSchema).default([])
 });
-var SidebarNodeSchema = import_zod20.z.discriminatedUnion("kind", [
+var SidebarNodeSchema = import_zod23.z.discriminatedUnion("kind", [
   SidebarLeafSchema,
   SidebarGroupSchema2
 ]);
@@ -1773,7 +2185,10 @@ var byPosition = /* @__PURE__ */ __name((a, b) => {
   return a.label.localeCompare(b.label);
 }, "byPosition");
 var buildLayoutPayload = /* @__PURE__ */ __name((configs, sidebarGroups = {}, title, autoSave = true, isDev = false) => {
-  const visible = configs.filter((c) => c.sidebar?.hide !== true && c.views?.["table"]);
+  const visible = configs.filter((c) => c.sidebar?.hide !== true && c.views?.["table"] && // A resource nested under a parent has no standalone route, so a sidebar
+  // entry for it would resolve to `<name>/schemas` and 404. It is reached
+  // from its parent's detail view instead.
+  !c.parent);
   const topLevel = [];
   const groupMap = new Map(Object.entries(sidebarGroups).map(([slug, cfg]) => [
     slug,
@@ -2026,51 +2441,51 @@ CroutonValidationExceptionFilter = _ts_decorate3([
 ], CroutonValidationExceptionFilter);
 
 // src/lib/crud/crud-controller.factory.ts
-var import_common16 = require("@nestjs/common");
+var import_common18 = require("@nestjs/common");
 var import_swagger11 = require("@nestjs/swagger");
 
 // src/lib/crud/action/action.types.ts
-var import_zod21 = require("zod");
-var ActionMetadataSchema = import_zod21.z.object({
+var import_zod24 = require("zod");
+var ActionMetadataSchema = import_zod24.z.object({
   /** URL segment used in the endpoint. */
-  id: import_zod21.z.string(),
+  id: import_zod24.z.string(),
   /** Human-readable label shown as a button. */
-  label: import_zod21.z.string().optional(),
+  label: import_zod24.z.string().optional(),
   /** MDI icon name, e.g. `"mdi:open-in-new"`. */
-  icon: import_zod21.z.string().optional(),
+  icon: import_zod24.z.string().optional(),
   /** Tooltip text. Falls back to `label` when omitted. */
-  tooltip: import_zod21.z.string().optional(),
+  tooltip: import_zod24.z.string().optional(),
   /** Per-row condition — button is hidden when false. */
-  condition: import_zod21.z.custom().optional()
+  condition: import_zod24.z.custom().optional()
 });
 var ResourceLinkActionSchema = ActionMetadataSchema.extend({
-  type: import_zod21.z.literal("link"),
+  type: import_zod24.z.literal("link"),
   /** URL to open. May contain `{id}` or `{env.VAR}` placeholders. */
-  href: import_zod21.z.string()
+  href: import_zod24.z.string()
 });
 var ResourceRowProcedureActionSchema = ActionMetadataSchema.extend({
-  type: import_zod21.z.literal("procedure").optional(),
+  type: import_zod24.z.literal("procedure").optional(),
   /** HTTP method for the endpoint. Defaults to `"post"`. */
-  method: import_zod21.z.string().optional(),
+  method: import_zod24.z.string().optional(),
   /** Static data payload merged into the request body by the frontend. */
-  data: import_zod21.z.record(import_zod21.z.string(), import_zod21.z.unknown()).optional(),
+  data: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.unknown()).optional(),
   /** Procedure called with `(prisma, recordId)`. */
-  procedure: import_zod21.z.custom((v) => typeof v === "function")
+  procedure: import_zod24.z.custom((v) => typeof v === "function")
 });
 var ResourceTableProcedureActionSchema = ActionMetadataSchema.extend({
-  type: import_zod21.z.literal("procedure").optional(),
+  type: import_zod24.z.literal("procedure").optional(),
   /** HTTP method for the endpoint. Defaults to `"post"`. */
-  method: import_zod21.z.string().optional(),
+  method: import_zod24.z.string().optional(),
   /** Static data payload merged into the request body by the frontend. */
-  data: import_zod21.z.record(import_zod21.z.string(), import_zod21.z.unknown()).optional(),
+  data: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.unknown()).optional(),
   /** Procedure called with `(prisma)` — no record id. */
-  procedure: import_zod21.z.custom((v) => typeof v === "function")
+  procedure: import_zod24.z.custom((v) => typeof v === "function")
 });
-var ResourceRowActionSchema = import_zod21.z.union([
+var ResourceRowActionSchema = import_zod24.z.union([
   ResourceRowProcedureActionSchema,
   ResourceLinkActionSchema
 ]);
-var ResourceTableActionSchema = import_zod21.z.union([
+var ResourceTableActionSchema = import_zod24.z.union([
   ResourceTableProcedureActionSchema,
   ResourceLinkActionSchema
 ]);
@@ -2093,7 +2508,7 @@ var findModule = /* @__PURE__ */ __name((dir, name) => {
   return void 0;
 }, "findModule");
 var IS_VITE = typeof globalThis.__vite_ssr_import__ === "function";
-var importDefault = /* @__PURE__ */ __name(async (filePath) => {
+var importDefault = /* @__PURE__ */ __name(async (filePath, onError) => {
   try {
     if (IS_VITE) {
       const importPath = IS_DEV ? `${filePath}?t=${Date.now()}` : filePath;
@@ -2103,7 +2518,9 @@ var importDefault = /* @__PURE__ */ __name(async (filePath) => {
       const mod = _require(filePath);
       return mod.default;
     }
-  } catch {
+  } catch (error) {
+    if (onError) onError(error, filePath);
+    else console.error(`[crouton] Failed to import ${filePath}:`, error);
     return void 0;
   }
 }, "importDefault");
@@ -2149,9 +2566,422 @@ var schemaFor = /* @__PURE__ */ __name((def2, op) => {
 }, "schemaFor");
 var upsertOnFor = /* @__PURE__ */ __name((def2) => def2.upsert?.upsertOn, "upsertOnFor");
 
-// src/lib/crud/read.repository.ts
+// src/lib/crud/custom-repository/custom-repository.types.ts
+var import_zod25 = require("zod");
+var CUSTOM_OPS = [
+  "findAll",
+  "findOne",
+  "create",
+  "update",
+  "patch",
+  "delete"
+];
+var PARENT_METHOD = {
+  findAll: "findAllByParent",
+  findOne: "findOneByParent",
+  create: "createByParent",
+  update: "updateByParent",
+  patch: "patchByParent",
+  delete: "deleteByParent"
+};
+var CustomRepositorySchema = import_zod25.z.custom((value) => typeof value === "object" && value !== null);
+
+// src/lib/crud/resource/resource-load-errors.registry.ts
+var ResourceLoadErrorsRegistry = class ResourceLoadErrorsRegistry2 {
+  static {
+    __name(this, "ResourceLoadErrorsRegistry");
+  }
+  errors = [];
+  record(e) {
+    this.errors.push(e);
+  }
+  getAll() {
+    return [
+      ...this.errors
+    ];
+  }
+  clear() {
+    this.errors = [];
+  }
+};
+var resourceLoadErrorsRegistry = new ResourceLoadErrorsRegistry();
+
+// src/lib/crud/custom-repository/custom-repository.loader.ts
+var REPOSITORY_MODULE = "repository";
+var loadCustomRepository = /* @__PURE__ */ __name(async (basePath, resourceName) => {
+  const file = findModule(basePath, REPOSITORY_MODULE);
+  if (!file) return void 0;
+  let failure;
+  const repository = await importDefault(file, (error) => {
+    failure = error;
+  });
+  if (failure !== void 0) {
+    resourceLoadErrorsRegistry.record({
+      name: resourceName,
+      path: file,
+      error: `Failed to import ${REPOSITORY_MODULE}: ${failure instanceof Error ? failure.message : String(failure)}`
+    });
+    return void 0;
+  }
+  if (repository && typeof repository !== "object") {
+    resourceLoadErrorsRegistry.record({
+      name: resourceName,
+      path: file,
+      error: `${REPOSITORY_MODULE} must default-export an object of operation functions.`
+    });
+    return void 0;
+  }
+  return repository;
+}, "loadCustomRepository");
+var loadSubResourceRepositories = /* @__PURE__ */ __name(async (subResources, parentName) => {
+  for (const sub of subResources) {
+    if (sub.childKind !== "custom") continue;
+    if (!sub.childDir) {
+      resourceLoadErrorsRegistry.record({
+        name: parentName,
+        path: sub.childRoute,
+        error: `Sub-resource "${sub.childRoute}" is a custom resource but its directory could not be resolved, so its repository.ts cannot be loaded. Check the relation column's "resource" path.`
+      });
+      continue;
+    }
+    const repository = await loadCustomRepository(sub.childDir, `${parentName}.${sub.childRoute}`);
+    if (repository) sub.repository = repository;
+  }
+}, "loadSubResourceRepositories");
+
+// src/lib/crud/custom-repository/custom-repository.adapter.ts
 var import_common4 = require("@nestjs/common");
 
+// src/lib/crud/constants.ts
+var PRISMA_NOT_FOUND_CODE = "P2025";
+var DEFAULT_ID_TYPE = "string";
+var DEFAULT_ID_FIELD = "id";
+
+// src/lib/crud/hooks/hooks.types.ts
+var import_zod26 = require("zod");
+var WriteOpSchema = import_zod26.z.enum([
+  "create",
+  "update",
+  "patch",
+  "upsert",
+  "delete"
+]);
+var ReadOpSchema = import_zod26.z.enum([
+  "findAll",
+  "findOne"
+]);
+var ResourceHooksSchema = import_zod26.z.object({
+  beforeWrite: import_zod26.z.custom().optional(),
+  afterWrite: import_zod26.z.custom().optional(),
+  afterRead: import_zod26.z.custom().optional()
+});
+
+// src/lib/crud/hooks/hooks.loader.ts
+var import_node_path4 = require("path");
+var loadResourceHooks = /* @__PURE__ */ __name(async (basePath) => {
+  const file = findModule(basePath, "hooks");
+  return file ? importDefault(file) : void 0;
+}, "loadResourceHooks");
+var loadSubResourceHooks = /* @__PURE__ */ __name(async (subResources, basePath) => {
+  for (const sub of subResources) {
+    const file = (sub.name ? findModule((0, import_node_path4.join)(basePath, "hooks"), sub.name) : void 0) ?? (sub.childDir ? findModule(sub.childDir, "hooks") : void 0);
+    if (!file) continue;
+    const hooks = await importDefault(file);
+    if (hooks) sub.hooks = hooks;
+  }
+}, "loadSubResourceHooks");
+
+// src/lib/crud/resource/valueLabel.apply.ts
+var applyValueLabelColumns = /* @__PURE__ */ __name((row, cols) => {
+  if (!row || !cols?.length) return row;
+  const out = {
+    ...row
+  };
+  for (const { field, values } of cols) {
+    if (field in out) out[field] = toValueLabel(out[field], values);
+  }
+  return out;
+}, "applyValueLabelColumns");
+var normalizeValueLabels = /* @__PURE__ */ __name((data, cols) => {
+  if (!data || typeof data !== "object" || Array.isArray(data) || !cols?.length) return data;
+  const out = {
+    ...data
+  };
+  for (const { field } of cols) {
+    if (field in out) out[field] = fromValueLabel(out[field]);
+  }
+  return out;
+}, "normalizeValueLabels");
+
+// src/lib/crud/hooks/hooks.apply.ts
+var decorateRows = /* @__PURE__ */ __name(async (rows, op, target, prisma, request, parent) => {
+  const hook = target.hooks?.afterRead;
+  const hooked = hook ? await Promise.all(rows.map((row) => hook(row, {
+    prisma,
+    op,
+    request,
+    ...parent && {
+      parent
+    }
+  }))) : rows;
+  const cols = target.valueLabelColumns;
+  return cols?.length ? hooked.map((r) => applyValueLabelColumns(r, cols)) : hooked;
+}, "decorateRows");
+var decorateRow = /* @__PURE__ */ __name(async (row, op, target, prisma, request, parent) => {
+  const hook = target.hooks?.afterRead;
+  return hook ? hook(row, {
+    prisma,
+    op,
+    request,
+    ...parent && {
+      parent
+    }
+  }) : row;
+}, "decorateRow");
+var prepareWrite = /* @__PURE__ */ __name(async (data, op, target, prisma, id, request, parent) => {
+  const normalized = normalizeValueLabels(data, target.valueLabelColumns);
+  const hook = target.hooks?.beforeWrite;
+  return hook ? hook(normalized, {
+    prisma,
+    op,
+    id,
+    request,
+    ...parent && {
+      parent
+    }
+  }) : normalized;
+}, "prepareWrite");
+var postWrite = /* @__PURE__ */ __name(async (result, op, target, prisma, id, request, parent) => {
+  const hook = target.hooks?.afterWrite;
+  return hook ? hook(result, {
+    prisma,
+    op,
+    id,
+    request,
+    ...parent && {
+      parent
+    }
+  }) : result;
+}, "postWrite");
+
+// src/lib/crud/custom-repository/custom-repository.adapter.ts
+var unsupported = /* @__PURE__ */ __name((config, op) => {
+  const method = config.parent ? PARENT_METHOD[op] : op;
+  throw new import_common4.NotImplementedException(`Resource "${config.name}" enables "${op}" but its repository.ts does not implement "${method}".`);
+}, "unsupported");
+var createCustomRepository = /* @__PURE__ */ __name((prisma, config, dataSources, repository) => {
+  const repo = repository ?? {};
+  const idField = config.idField ?? DEFAULT_ID_FIELD;
+  const toId = /* @__PURE__ */ __name((id) => (config.idType ?? DEFAULT_ID_TYPE) === "number" ? +id : String(id), "toId");
+  const parentRef = config.parent;
+  const parentIdFrom = /* @__PURE__ */ __name((request) => {
+    const raw = request?.params?.[parentRef.param];
+    if (raw === void 0 || raw === null || raw === "") {
+      throw new import_common4.BadRequestException(`Resource "${config.name}" is nested under "${parentRef.route}" but no "${parentRef.param}" was supplied.`);
+    }
+    return (parentRef.idType ?? "string") === "number" ? +raw : String(raw);
+  }, "parentIdFrom");
+  const parentCtx = /* @__PURE__ */ __name((request, parentId2) => ({
+    parent: {
+      route: parentRef.route,
+      param: parentRef.param,
+      id: parentId2
+    }
+  }), "parentCtx");
+  const parentHookCtx = /* @__PURE__ */ __name((request) => {
+    if (!parentRef) return void 0;
+    const raw = request?.params?.[parentRef.param];
+    if (raw === void 0 || raw === null || raw === "") return void 0;
+    return {
+      route: parentRef.route,
+      param: parentRef.param,
+      id: (parentRef.idType ?? "string") === "number" ? +raw : String(raw)
+    };
+  }, "parentHookCtx");
+  const ctx = /* @__PURE__ */ __name((op, params, id, request) => ({
+    prisma,
+    dataSources,
+    config,
+    op,
+    offset: params ? offsetOf(params) : 0,
+    ...id !== void 0 && {
+      id
+    },
+    ...request !== void 0 && {
+      request
+    }
+  }), "ctx");
+  const findAllWithCount = /* @__PURE__ */ __name(async (params, request) => {
+    let result;
+    if (parentRef) {
+      if (!repo.findAllByParent) unsupported(config, "findAll");
+      const parentId2 = parentIdFrom(request);
+      result = await repo.findAllByParent(parentId2, params, {
+        ...ctx("findAll", params, void 0, request),
+        ...parentCtx(request, parentId2)
+      });
+    } else {
+      if (!repo.findAll) unsupported(config, "findAll");
+      result = await repo.findAll(params, ctx("findAll", params, void 0, request));
+    }
+    const data = await decorateRows(result?.data ?? [], "findAll", config, prisma, request, parentHookCtx(request));
+    return {
+      data,
+      count: result?.count ?? data.length
+    };
+  }, "findAllWithCount");
+  const findOne = /* @__PURE__ */ __name(async (id, request) => {
+    let row;
+    if (parentRef) {
+      if (!repo.findOneByParent) unsupported(config, "findOne");
+      const parentId2 = parentIdFrom(request);
+      row = await repo.findOneByParent(parentId2, toId(id), {
+        ...ctx("findOne", void 0, id, request),
+        ...parentCtx(request, parentId2)
+      });
+    } else {
+      if (!repo.findOne) unsupported(config, "findOne");
+      row = await repo.findOne(toId(id), ctx("findOne", void 0, id, request));
+    }
+    if (row === null || row === void 0) {
+      throw new import_common4.NotFoundException(`${config.name} with id ${id} not found`);
+    }
+    return decorateRow(row, "findOne", config, prisma, request, parentHookCtx(request));
+  }, "findOne");
+  const write = /* @__PURE__ */ __name(async (op, data, id, request) => {
+    const coercedId = id !== void 0 ? toId(id) : void 0;
+    const prepared = /* @__PURE__ */ __name(() => prepareWrite(data, op, config, prisma, coercedId, request, parentHookCtx(request)), "prepared");
+    let result;
+    if (parentRef) {
+      const fn = op === "create" ? repo.createByParent : op === "update" ? repo.updateByParent : repo.patchByParent ?? repo.updateByParent;
+      if (!fn) unsupported(config, op);
+      const parentId2 = parentIdFrom(request);
+      const nestedCtx = {
+        ...ctx(op, void 0, coercedId, request),
+        ...parentCtx(request, parentId2)
+      };
+      const body = await prepared();
+      result = op === "create" ? await fn(parentId2, body, nestedCtx) : await fn(parentId2, coercedId, body, nestedCtx);
+    } else {
+      const fn = op === "create" ? repo.create : op === "update" ? repo.update : repo.patch ?? repo.update;
+      if (!fn) unsupported(config, op);
+      const body = await prepared();
+      result = op === "create" ? await fn(body, ctx("create", void 0, void 0, request)) : await fn(coercedId, body, ctx(op, void 0, coercedId, request));
+    }
+    return postWrite(result, op, config, prisma, coercedId, request, parentHookCtx(request));
+  }, "write");
+  const notAChildRepository = /* @__PURE__ */ __name(async () => {
+    throw new import_common4.NotImplementedException(`Resource "${config.name}" is a custom resource; nested sub-resource routes are not supported. Expose the child collection as its own resource instead.`);
+  }, "notAChildRepository");
+  return {
+    prisma,
+    // Preferred by register-findall: one round trip returns rows and count.
+    findAllWithCount,
+    findAll: /* @__PURE__ */ __name(async (params, request) => (await findAllWithCount(params, request)).data, "findAll"),
+    count: /* @__PURE__ */ __name(async (filter) => (await findAllWithCount({
+      page: 1,
+      pageSize: 1,
+      sort: idField,
+      sortDir: "asc",
+      filter: filter ?? []
+    })).count, "count"),
+    findOne,
+    create: /* @__PURE__ */ __name((data, request) => write("create", data, void 0, request), "create"),
+    update: /* @__PURE__ */ __name((id, data, request) => write("update", data, id, request), "update"),
+    patch: /* @__PURE__ */ __name((id, data, request) => write("patch", data, id, request), "patch"),
+    delete: /* @__PURE__ */ __name(async (id, request) => {
+      const coercedId = toId(id);
+      let result;
+      if (parentRef) {
+        if (!repo.deleteByParent) unsupported(config, "delete");
+        const parentId2 = parentIdFrom(request);
+        result = await repo.deleteByParent(parentId2, coercedId, {
+          ...ctx("delete", void 0, coercedId, request),
+          ...parentCtx(request, parentId2)
+        });
+      } else {
+        if (!repo.delete) unsupported(config, "delete");
+        result = await repo.delete(coercedId, ctx("delete", void 0, coercedId, request));
+      }
+      return postWrite(result, "delete", config, prisma, coercedId, request, parentHookCtx(request));
+    }, "delete"),
+    upsert: /* @__PURE__ */ __name(async () => {
+      throw new import_common4.NotImplementedException(`Resource "${config.name}" is a custom resource; upsert is not part of the repository contract.`);
+    }, "upsert"),
+    upsertMany: /* @__PURE__ */ __name(async () => {
+      throw new import_common4.NotImplementedException(`Resource "${config.name}" is a custom resource; upsert is not part of the repository contract.`);
+    }, "upsertMany"),
+    findAllByParent: notAChildRepository,
+    findOneChild: notAChildRepository,
+    createChild: notAChildRepository,
+    updateChild: notAChildRepository,
+    deleteChild: notAChildRepository
+  };
+}, "createCustomRepository");
+
+// src/lib/crud/custom-repository/custom-repository.validate.ts
+var validateCustomRepository = /* @__PURE__ */ __name((config, repository) => {
+  const definition = resolveDefinition(config);
+  const enabled = CUSTOM_OPS.filter((op) => isOperationEnabled(definition, op));
+  const nested = !!config.parent;
+  const methodFor = /* @__PURE__ */ __name((op) => nested ? PARENT_METHOD[op] : op, "methodFor");
+  if (!repository) {
+    return `No repository.ts found. A custom resource implements its own data access; create ${config.name}/repository.ts with a default export implementing: ${enabled.map(methodFor).join(", ") || "no operations"}.`;
+  }
+  const implemented = /* @__PURE__ */ __name((name) => typeof repository[name] === "function", "implemented");
+  const missing = enabled.filter((op) => op === "patch" ? !implemented(methodFor("patch")) && !implemented(methodFor("update")) : !implemented(methodFor(op)));
+  if (missing.length) {
+    const names = missing.map(methodFor);
+    return `repository.ts does not implement ${names.join(", ")}` + (nested ? ` (this resource is nested under "${config.parent.route}", so it implements the parent-aware operations). ` : ". ") + `Either implement them or disable the operation in resource.json ("operations": { "${missing[0]}": false }).`;
+  }
+  return void 0;
+}, "validateCustomRepository");
+
+// src/lib/crud/read.repository.ts
+var import_common6 = require("@nestjs/common");
+
+// src/lib/crud/custom-repository/child-delegate.ts
+var import_common5 = require("@nestjs/common");
+var childRepositoryFn = /* @__PURE__ */ __name((sub, op, parentName) => {
+  const repo = sub.repository;
+  const method = PARENT_METHOD[op];
+  if (!repo) {
+    throw new import_common5.NotImplementedException(`Sub-resource "${sub.childRoute}" of "${parentName}" is a custom resource but no repository.ts was loaded for it.`);
+  }
+  const fn = repo[method] ?? (op === "patch" ? repo[PARENT_METHOD.update] : void 0);
+  if (typeof fn !== "function") {
+    throw new import_common5.NotImplementedException(`Sub-resource "${sub.childRoute}" of "${parentName}" does not implement "${method}" in its repository.ts.`);
+  }
+  return fn.bind(repo);
+}, "childRepositoryFn");
+var childCtx = /* @__PURE__ */ __name(({ parentConfig, prisma, op, parentId: parentId2, params, id, request }) => ({
+  prisma,
+  dataSources: {
+    resolve: /* @__PURE__ */ __name(() => prisma, "resolve"),
+    entries: /* @__PURE__ */ __name(() => [], "entries")
+  },
+  config: parentConfig,
+  op,
+  offset: params ? offsetOf(params) : 0,
+  ...id !== void 0 && {
+    id
+  },
+  ...request !== void 0 && {
+    request
+  },
+  // Served under the parent's `:id`, so that is the param name here — unlike a
+  // top-level nested resource, which names its own param.
+  parent: {
+    route: parentConfig.route,
+    param: "id",
+    id: parentId2
+  }
+}), "childCtx");
+var parentIdFromRequest = /* @__PURE__ */ __name((request, fallback) => {
+  const raw = request?.params?.id;
+  return raw === void 0 || raw === null || raw === "" ? fallback : raw;
+}, "parentIdFromRequest");
+
 // src/lib/crud/sql.helpers.ts
 var castExpression = /* @__PURE__ */ __name((col) => {
   if (col.type === "string") return `(${col.sqlExpression})`;
@@ -2168,17 +2998,17 @@ var coerceColumnValue = /* @__PURE__ */ __name((col) => {
   if (col.type === "string") return (v) => v === void 0 || v === null ? null : String(v);
   return (v) => Number(v ?? 0);
 }, "coerceColumnValue");
-var buildCalculatedColumnSql = /* @__PURE__ */ __name((col, tableName, ids) => {
+var buildCalculatedColumnSql = /* @__PURE__ */ __name((col, tableName, ids, idField) => {
   const alias = col.alias ?? col.id;
   const placeholders = ids.map((_, i) => `$${i + 1}`).join(", ");
-  return `SELECT main.id, ${castExpression(col)} AS "${alias}" FROM "${tableName}" main WHERE main.id IN (${placeholders})`;
+  return `SELECT main."${idField}" AS id, ${castExpression(col)} AS "${alias}" FROM "${tableName}" main WHERE main."${idField}" IN (${placeholders})`;
 }, "buildCalculatedColumnSql");
-var mergeCalculatedColumnsForRows = /* @__PURE__ */ __name(async (rows, calcCols, tableName, prisma) => {
+var mergeCalculatedColumnsForRows = /* @__PURE__ */ __name(async (rows, calcCols, tableName, prisma, idField = "id") => {
   if (!calcCols.length || !rows.length) return rows;
-  const ids = rows.map((r) => r.id);
+  const ids = rows.map((r) => r[idField]);
   const results = await Promise.all(calcCols.map(async (col) => {
     const alias = col.alias ?? col.id;
-    const sql = buildCalculatedColumnSql(col, tableName, ids);
+    const sql = buildCalculatedColumnSql(col, tableName, ids, idField);
     const defaultValue = defaultValueForType(col);
     const coerce = coerceColumnValue(col);
     try {
@@ -2203,7 +3033,7 @@ var mergeCalculatedColumnsForRows = /* @__PURE__ */ __name(async (rows, calcCols
   return rows.map((row) => {
     const extra = {};
     for (const { id, defaultValue, map } of results) {
-      extra[id] = map[String(row.id)] ?? defaultValue;
+      extra[id] = map[String(row[idField])] ?? defaultValue;
     }
     return {
       ...row,
@@ -2263,7 +3093,7 @@ var buildChildSortClause = /* @__PURE__ */ __name((sort, sortDir) => {
   }, {});
 }, "buildChildSortClause");
 var buildFindOneIncludes = /* @__PURE__ */ __name((subResources, configInclude) => {
-  const autoSubs = subResources.filter((s) => s.includeInFindOne);
+  const autoSubs = subResources.filter((s) => s.includeInFindOne && s.childKind !== "custom");
   const flatIncludes = autoSubs.length ? Object.fromEntries(autoSubs.map((s) => s.findOneOrderBy ? [
     s.relation,
     {
@@ -2408,16 +3238,6 @@ var orderableChildSort = /* @__PURE__ */ __name((sort, childModel, _sub) => {
   if (sort.includes(".")) return sort;
   return scalarFields.has(sort) ? sort : void 0;
 }, "orderableChildSort");
-var applyValueLabelColumns = /* @__PURE__ */ __name((row, cols) => {
-  if (!row || !cols?.length) return row;
-  const out = {
-    ...row
-  };
-  for (const { field, values } of cols) {
-    if (field in out) out[field] = toValueLabel(out[field], values);
-  }
-  return out;
-}, "applyValueLabelColumns");
 var ReadRepository = class {
   static {
     __name(this, "ReadRepository");
@@ -2434,6 +3254,15 @@ var ReadRepository = class {
     this.listSelect = listSelect;
     this.oneSelect = oneSelect;
   }
+  /**
+  * Physical table name for raw SQL (calculated columns).
+  *
+  * `table` overrides `model` for a `@@map`-ed Prisma model. Empty for a custom
+  * resource, which cannot have calculated columns.
+  */
+  get tableName() {
+    return this.config.table ?? this.config.model ?? "";
+  }
   toId(id) {
     return (this.config.idType ?? "string") === "number" ? +id : String(id);
   }
@@ -2451,43 +3280,55 @@ var ReadRepository = class {
     if (this.listSelect && !(sort in this.listSelect)) return void 0;
     return buildSort(sort, sortDir);
   }
-  async decorate(rows, op) {
-    const hook = this.config.hooks?.afterRead;
-    const hooked = hook ? await Promise.all(rows.map((row) => hook(row, {
-      prisma: this.prisma,
-      op
-    }))) : rows;
-    const cols = this.config.valueLabelColumns;
-    return cols?.length ? hooked.map((r) => applyValueLabelColumns(r, cols)) : hooked;
-  }
-  async decorateOne(row, op) {
-    const hook = this.config.hooks?.afterRead;
-    return hook ? hook(row, {
-      prisma: this.prisma,
-      op
-    }) : row;
+  /**
+  * The parent a *child* read is scoped to, for the hook context.
+  *
+  * A sub-resource is served by the parent's controller, so its parent id arrives
+  * as the parent's own `:id` — hence `param: 'id'`. `undefined` when no parent id
+  * was supplied, so a hook is never handed a fabricated one.
+  */
+  parentHookContext(parentId2) {
+    if (parentId2 === void 0 || parentId2 === null || parentId2 === "") {
+      return void 0;
+    }
+    return {
+      route: this.config.route,
+      param: "id",
+      id: this.toId(parentId2)
+    };
+  }
+  async decorate(rows, op, request) {
+    return decorateRows(rows, op, this.config, this.prisma, request);
+  }
+  async decorateOne(row, op, request) {
+    return decorateRow(row, op, this.config, this.prisma, request);
   }
   /**
   * Fetch a paginated, sorted, and filtered list of records.
   * Sub-resource counts are merged onto each row; calculated columns are resolved via raw SQL.
   */
-  async findAll(params) {
+  async findAll(params, request) {
     const subResources = this.config.subResources ?? [];
     const projection = this.projection("findAll");
     const query = {
       where: this.buildWhere(params.filter),
       take: params.pageSize,
-      skip: params.offset ?? (params.page - 1) * params.pageSize,
+      skip: offsetOf(params),
       orderBy: this.safeSort(sanitizeValueLabelSort(params.sort, this.config.valueLabelColumns), params.sortDir)
     };
-    const countableSubResources = subResources.filter((s) => s.relationType !== "manyToOne");
-    const manyToOneIncludes = subResources.filter((s) => s.relationType === "manyToOne").map((s) => s.relation);
+    const prismaSubResources = subResources.filter((s) => s.childKind !== "custom");
+    const oneToManySubResources = prismaSubResources.filter((s) => s.relationType !== "manyToOne");
+    const countableSubResources = oneToManySubResources.filter((s) => !s.hiddenInTable);
+    const manyToOneIncludes = prismaSubResources.filter((s) => s.relationType === "manyToOne").map((s) => s.relation);
     const flatIncludes = manyToOneIncludes.length ? Object.fromEntries(manyToOneIncludes.map((r) => [
       r,
       true
     ])) : void 0;
     const configInclude = buildIncludeClause(this.config.include);
-    const countableRelations = new Set(countableSubResources.map((s) => s.relation));
+    const countableRelations = /* @__PURE__ */ new Set([
+      ...oneToManySubResources.map((s) => s.relation),
+      ...subResources.filter((s) => s.childKind === "custom").map((s) => s.relation)
+    ]);
     const filteredConfigInclude = configInclude ? Object.fromEntries(Object.entries(configInclude).filter(([key]) => !countableRelations.has(key))) : void 0;
     const safeConfigInclude = filteredConfigInclude && Object.keys(filteredConfigInclude).length ? filteredConfigInclude : void 0;
     const mergedInclude = flatIncludes || safeConfigInclude ? {
@@ -2525,8 +3366,8 @@ var ReadRepository = class {
         ...counts
       };
     }) : rows;
-    const withCalc = await mergeCalculatedColumnsForRows(mapped, this.config.calculatedColumns ?? [], this.config.model, this.prisma);
-    return this.decorate(withCalc, "findAll");
+    const withCalc = await mergeCalculatedColumnsForRows(mapped, this.config.calculatedColumns ?? [], this.tableName, this.prisma, this.config.idField ?? "id");
+    return this.decorate(withCalc, "findAll", request);
   }
   /** Count records matching the given filter strings. */
   count(filter) {
@@ -2540,7 +3381,7 @@ var ReadRepository = class {
   * `config.include` entries are loaded with full nesting via `buildIncludeClause`.
   * @throws {NotFoundException} When no record exists for the given id.
   */
-  async findOne(id) {
+  async findOne(id, request) {
     const projection = this.projection("findOne");
     const idField = this.config.idField ?? "id";
     const query = {
@@ -2561,36 +3402,59 @@ var ReadRepository = class {
       }
     }
     const record = await this.prismaModel.findUnique(query);
-    if (!record) throw new import_common4.NotFoundException(`${this.config.name} with id ${id} not found`);
+    if (!record) throw new import_common6.NotFoundException(`${this.config.name} with id ${id} not found`);
     const [withCalc] = await mergeCalculatedColumnsForRows([
       record
-    ], this.config.calculatedColumns ?? [], this.config.model, this.prisma);
+    ], this.config.calculatedColumns ?? [], this.tableName, this.prisma, this.config.idField ?? "id");
     let enriched = withCalc ?? record;
     for (const sub of this.config.subResources ?? []) {
       if (!sub.calculatedColumns?.length) continue;
       const nested = enriched[sub.relation];
       if (!Array.isArray(nested) || !nested.length) continue;
-      const enrichedNested = await mergeCalculatedColumnsForRows(nested, sub.calculatedColumns, sub.childModel, this.prisma);
+      const enrichedNested = await mergeCalculatedColumnsForRows(nested, sub.calculatedColumns, sub.childModel, this.prisma, sub.idField ?? "id");
       enriched = {
         ...enriched,
         [sub.relation]: enrichedNested
       };
     }
-    return this.decorateOne(enriched, "findOne");
+    return this.decorateOne(enriched, "findOne", request);
   }
   /**
   * Fetch a paginated list of child records belonging to the given parent.
   * @param childRoute - Matches the `childRoute` key on a `SubResourceConfig`.
   * @throws {Error} When no matching sub-resource config or Prisma model is found.
   */
-  async findAllByParent(parentId, childRoute, params) {
+  async findAllByParent(parentId2, childRoute, params, request) {
     const sub = (this.config.subResources ?? []).find((s) => s.childRoute === childRoute);
     if (!sub) throw new Error(`No sub-resource "${childRoute}" on "${this.config.name}"`);
+    if (sub.childKind === "custom") {
+      const findAll = childRepositoryFn(sub, "findAll", this.config.name);
+      const result = await findAll(this.toId(parentId2), params, childCtx({
+        parentConfig: this.config,
+        prisma: this.prisma,
+        op: "findAll",
+        parentId: this.toId(parentId2),
+        params,
+        request
+      }));
+      const rows = result?.data ?? [];
+      const decorated2 = sub.hooks?.afterRead ? await Promise.all(rows.map((row) => sub.hooks.afterRead(row, {
+        prisma: this.prisma,
+        op: "findAll",
+        request,
+        parent: this.parentHookContext(parentId2)
+      }))) : rows;
+      const labeled2 = sub.valueLabelColumns?.length ? decorated2.map((r) => applyValueLabelColumns(r, sub.valueLabelColumns)) : decorated2;
+      return {
+        data: labeled2,
+        count: result?.count ?? labeled2.length
+      };
+    }
     const childModel = this.prisma[sub.childModel];
     if (!childModel) throw new Error(`Prisma model "${sub.childModel}" not found`);
     const where = {
       ...this.buildWhere(params.filter),
-      [sub.foreignKey]: this.toId(parentId)
+      [sub.foreignKey]: this.toId(parentId2)
     };
     const includeClause = buildIncludeClause(sub.include);
     const childSort = orderableChildSort(sanitizeValueLabelSort(params.sort, sub.valueLabelColumns), childModel, sub);
@@ -2598,7 +3462,7 @@ var ReadRepository = class {
       childModel.findMany({
         where,
         take: params.pageSize,
-        skip: params.offset ?? (params.page - 1) * params.pageSize,
+        skip: offsetOf(params),
         orderBy: childSort ? buildChildSortClause(childSort, params.sortDir) : void 0,
         ...includeClause && {
           include: includeClause
@@ -2608,10 +3472,12 @@ var ReadRepository = class {
         where
       })
     ]);
-    const withCalc = sub.calculatedColumns?.length ? await mergeCalculatedColumnsForRows(data, sub.calculatedColumns, sub.childModel, this.prisma) : data;
+    const withCalc = sub.calculatedColumns?.length ? await mergeCalculatedColumnsForRows(data, sub.calculatedColumns, sub.childModel, this.prisma, sub.idField ?? "id") : data;
     const decorated = sub.hooks?.afterRead ? await Promise.all(withCalc.map((row) => sub.hooks.afterRead(row, {
       prisma: this.prisma,
-      op: "findAll"
+      op: "findAll",
+      request,
+      parent: this.parentHookContext(parentId2)
     }))) : withCalc;
     const labeled = sub.valueLabelColumns?.length ? decorated.map((r) => applyValueLabelColumns(r, sub.valueLabelColumns)) : decorated;
     return {
@@ -2623,7 +3489,30 @@ var ReadRepository = class {
   * Fetch a single child record. When `parentId` is supplied the query also filters by the foreign key.
   * @throws {NotFoundException} When no matching record is found.
   */
-  async findOneChild(sub, childId, parentId) {
+  async findOneChild(sub, childId, parentId2, request) {
+    if (sub.childKind === "custom") {
+      if (parentId2 === void 0) {
+        throw new import_common6.BadRequestException(`Sub-resource "${sub.childRoute}" of "${this.config.name}" requires a parent id.`);
+      }
+      const findOne = childRepositoryFn(sub, "findOne", this.config.name);
+      const row = await findOne(this.toId(parentId2), (sub.idType ?? "string") === "number" ? +childId : String(childId), childCtx({
+        parentConfig: this.config,
+        prisma: this.prisma,
+        op: "findOne",
+        parentId: this.toId(parentId2),
+        id: childId,
+        request
+      }));
+      if (row === null || row === void 0) {
+        throw new import_common6.NotFoundException(`${sub.childRoute} with id ${childId} not found`);
+      }
+      return sub.hooks?.afterRead ? sub.hooks.afterRead(row, {
+        prisma: this.prisma,
+        op: "findOne",
+        request,
+        parent: this.parentHookContext(parentId2)
+      }) : row;
+    }
     const childModel = this.prisma[sub.childModel];
     if (!childModel) throw new Error(`Prisma model "${sub.childModel}" not found`);
     const id = (sub.idType ?? "string") === "number" ? +childId : String(childId);
@@ -2631,7 +3520,7 @@ var ReadRepository = class {
     const where = {
       [idField]: id
     };
-    if (parentId !== void 0) where[sub.foreignKey] = this.toId(parentId);
+    if (parentId2 !== void 0) where[sub.foreignKey] = this.toId(parentId2);
     const includeClause = buildIncludeClause(sub.include);
     const record = await childModel.findFirst({
       where,
@@ -2639,24 +3528,26 @@ var ReadRepository = class {
         include: includeClause
       }
     });
-    if (!record) throw new import_common4.NotFoundException(`${sub.childRoute} with id ${childId} not found`);
+    if (!record) throw new import_common6.NotFoundException(`${sub.childRoute} with id ${childId} not found`);
     const [withCalc] = sub.calculatedColumns?.length ? await mergeCalculatedColumnsForRows([
       record
-    ], sub.calculatedColumns, sub.childModel, this.prisma) : [
+    ], sub.calculatedColumns, sub.childModel, this.prisma, sub.idField ?? "id") : [
       record
     ];
     if (sub.hooks?.afterRead) return sub.hooks.afterRead(withCalc, {
       prisma: this.prisma,
-      op: "findOne"
+      op: "findOne",
+      request,
+      parent: this.parentHookContext(parentId2)
     });
     return withCalc;
   }
 };
 
 // src/lib/crud/schema.utils.ts
-var import_zod22 = require("zod");
+var import_zod27 = require("zod");
 function isZodSchema(schema) {
-  return schema instanceof import_zod22.ZodObject;
+  return schema instanceof import_zod27.ZodObject;
 }
 __name(isZodSchema, "isZodSchema");
 var isNullableProperty2 = /* @__PURE__ */ __name((property) => {
@@ -2670,7 +3561,7 @@ var dropNullableFromRequired2 = /* @__PURE__ */ __name((jsonSchema) => {
 }, "dropNullableFromRequired");
 function toJsonSchema(schema) {
   if (isZodSchema(schema)) {
-    const jsonSchema = (0, import_zod22.toJSONSchema)(schema, {
+    const jsonSchema = (0, import_zod27.toJSONSchema)(schema, {
       target: "openApi3",
       ...jsonSchemaOpts
     });
@@ -2723,24 +3614,25 @@ function toSelectFields(schema) {
 __name(toSelectFields, "toSelectFields");
 
 // src/lib/crud/write.repository.ts
-var import_common5 = require("@nestjs/common");
-
-// src/lib/crud/constants.ts
-var PRISMA_NOT_FOUND_CODE = "P2025";
-var DEFAULT_ID_FIELD = "id";
-
-// src/lib/crud/write.repository.ts
-var normalizeValueLabels = /* @__PURE__ */ __name((data, cols) => {
-  if (!data || typeof data !== "object" || Array.isArray(data) || !cols?.length) return data;
-  const out = {
-    ...data
-  };
-  for (const { field } of cols) {
-    if (field in out) out[field] = fromValueLabel(out[field]);
-  }
-  return out;
-}, "normalizeValueLabels");
+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",
+  "connectOrCreate",
+  "create",
+  "createMany",
+  "set",
+  "disconnect",
+  "update",
+  "updateMany",
+  "upsert",
+  "delete",
+  "deleteMany"
+]);
+var isPrismaRelationWrite = /* @__PURE__ */ __name((value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  return Object.keys(value).some((k) => PRISMA_RELATION_WRITE_KEYS.has(k));
+}, "isPrismaRelationWrite");
 var WriteRepository = class {
   static {
     __name(this, "WriteRepository");
@@ -2757,7 +3649,7 @@ var WriteRepository = class {
     return (this.config.idType ?? "string") === "number" ? +id : String(id);
   }
   notFound(id) {
-    return new import_common5.NotFoundException(`${this.config.name} with id ${id} not found`);
+    return new import_common7.NotFoundException(`${this.config.name} with id ${id} not found`);
   }
   stripSubResourceKeys(data) {
     if (!data || typeof data !== "object" || Array.isArray(data)) return data;
@@ -2771,26 +3663,29 @@ var WriteRepository = class {
     if (!nonCreateable.size) return data;
     return Object.fromEntries(Object.entries(data).filter(([k]) => !nonCreateable.has(k)));
   }
-  async prepare(data, op, id) {
-    const normalized = normalizeValueLabels(data, this.config.valueLabelColumns);
-    const hook = this.config.hooks?.beforeWrite;
-    return hook ? hook(normalized, {
-      prisma: this.prisma,
-      op,
-      id
-    }) : normalized;
+  /**
+  * The parent a *child* write is scoped to, for the hook context.
+  *
+  * A sub-resource is served by the parent's controller, so its parent id arrives
+  * as the parent's own `:id` — hence `param: 'id'`. A resource that declares
+  * `parent` names its own param and goes through the custom adapter instead.
+  */
+  parentHookContext(parentId1) {
+    return {
+      route: this.config.route,
+      param: "id",
+      id: this.toId(parentId1)
+    };
   }
-  async postWrite(result, op, id) {
-    const hook = this.config.hooks?.afterWrite;
-    return hook ? hook(result, {
-      prisma: this.prisma,
-      op,
-      id
-    }) : result;
+  async prepare(data, op, id, request) {
+    return prepareWrite(data, op, this.config, this.prisma, id, request);
+  }
+  async postWrite(result, op, id, request) {
+    return postWrite(result, op, this.config, this.prisma, id, request);
   }
   upsertWhere(data) {
     const keys = upsertOnFor(resolveDefinition(this.config));
-    if (!keys) throw new import_common5.BadRequestException(`${this.config.name} has no upsertOn configured`);
+    if (!keys) throw new import_common7.BadRequestException(`${this.config.name} has no upsertOn configured`);
     if (typeof keys === "string") return {
       [keys]: data[keys]
     };
@@ -2802,61 +3697,62 @@ var WriteRepository = class {
       ]))
     };
   }
-  async create(data) {
+  async create(data, request) {
     const result = await this.prismaModel.create({
-      data: await this.prepare(this.stripSubResourceKeys(data), "create")
+      data: await this.prepare(this.stripSubResourceKeys(data), "create", void 0, request)
     });
-    return this.postWrite(result, "create");
+    return this.postWrite(result, "create", void 0, request);
   }
-  async update(id, data) {
+  async update(id, data, request) {
     const idField = this.config.idField ?? "id";
     try {
       const result = await this.prismaModel.update({
         where: {
           [idField]: this.toId(id)
         },
-        data: await this.prepare(this.stripSubResourceKeys(data), "update", this.toId(id))
+        data: await this.prepare(this.stripSubResourceKeys(data), "update", this.toId(id), request)
       });
-      return this.postWrite(result, "update", this.toId(id));
+      return this.postWrite(result, "update", this.toId(id), request);
     } catch (e) {
       if (e?.code === PRISMA_NOT_FOUND_CODE) throw this.notFound(id);
       throw e;
     }
   }
-  async patch(id, data) {
+  async patch(id, data, request) {
     const idField = this.config.idField ?? "id";
     try {
       const result = await this.prismaModel.update({
         where: {
           [idField]: this.toId(id)
         },
-        data: await this.prepare(this.stripSubResourceKeys(data), "patch", this.toId(id))
+        data: await this.prepare(this.stripSubResourceKeys(data), "patch", this.toId(id), request)
       });
-      return this.postWrite(result, "patch", this.toId(id));
+      return this.postWrite(result, "patch", this.toId(id), request);
     } catch (e) {
       if (e?.code === PRISMA_NOT_FOUND_CODE) throw this.notFound(id);
       throw e;
     }
   }
-  async upsert(data) {
+  async upsert(data, request) {
     const where = this.upsertWhere(data);
     const existing = await this.prismaModel.findFirst({
       where
     });
     const op = existing ? "update" : "create";
-    const prepared = await this.prepare(this.stripSubResourceKeys(data), op, existing ? existing[this.config.idField ?? DEFAULT_ID_FIELD] : void 0);
+    const existingId = existing ? existing[this.config.idField ?? DEFAULT_ID_FIELD] : void 0;
+    const prepared = await this.prepare(this.stripSubResourceKeys(data), op, existingId, request);
     const result = await this.prismaModel.upsert({
       where,
       create: prepared,
       update: prepared
     });
-    return this.postWrite(result, op, existing ? existing[this.config.idField ?? DEFAULT_ID_FIELD] : void 0);
+    return this.postWrite(result, op, existingId, request);
   }
   /** Upsert multiple rows in parallel. */
-  upsertMany(rows) {
-    return Promise.all(rows.map((r) => this.upsert(r)));
+  upsertMany(rows, request) {
+    return Promise.all(rows.map((r) => this.upsert(r, request)));
   }
-  async delete(id) {
+  async delete(id, request) {
     const idField = this.config.idField ?? "id";
     try {
       const result = await this.prismaModel.delete({
@@ -2864,40 +3760,96 @@ var WriteRepository = class {
           [idField]: this.toId(id)
         }
       });
-      return this.postWrite(result, "delete", this.toId(id));
+      return this.postWrite(result, "delete", this.toId(id), request);
     } catch (e) {
       if (e?.code === PRISMA_NOT_FOUND_CODE) throw this.notFound(id);
       throw e;
     }
   }
   /**
+  * Write to a **custom** sub-resource by delegating to the child's own
+  * repository.
+  *
+  * The child has no Prisma model, so `prisma[childModel]` is not an option.
+  * Value-label normalisation and the child's `beforeWrite`/`afterWrite` hooks
+  * still apply, so a custom child behaves like a Prisma one from the caller's
+  * point of view.
+  */
+  async delegateChildWrite(sub, op, parentId1, childId, data, request) {
+    if (parentId1 === void 0) {
+      throw new import_common7.BadRequestException(`Sub-resource "${sub.childRoute}" of "${this.config.name}" requires a parent id.`);
+    }
+    const fn = childRepositoryFn(sub, op, this.config.name);
+    const id = childId === void 0 ? void 0 : (sub.idType ?? "string") === "number" ? +childId : String(childId);
+    const ctx = childCtx({
+      parentConfig: this.config,
+      prisma: this.prisma,
+      op,
+      parentId: this.toId(parentId1),
+      id,
+      request
+    });
+    let payload;
+    if (op !== "delete") {
+      const stripped = op === "create" ? this.stripNonCreateableChildFields(data, sub) : data;
+      const normalized = normalizeValueLabels(stripped, sub.valueLabelColumns);
+      payload = sub.hooks?.beforeWrite ? await sub.hooks.beforeWrite(normalized, {
+        prisma: this.prisma,
+        op: op === "patch" ? "patch" : op,
+        ...id !== void 0 && {
+          id
+        },
+        request,
+        parent: ctx.parent
+      }) : normalized;
+    }
+    const result = op === "create" ? await fn(this.toId(parentId1), payload, ctx) : op === "delete" ? await fn(this.toId(parentId1), id, ctx) : await fn(this.toId(parentId1), id, payload, ctx);
+    return sub.hooks?.afterWrite ? sub.hooks.afterWrite(result, {
+      prisma: this.prisma,
+      op: op === "patch" ? "patch" : op,
+      ...id !== void 0 && {
+        id
+      },
+      request
+    }) : result;
+  }
+  /**
   * Create a child record and attach it to the parent via the configured foreign key.
   * Fields marked `createable: false` in the form view are stripped before writing.
   */
-  async createChild(parentId, sub, data) {
+  async createChild(parentId1, sub, data, request) {
+    if (sub.childKind === "custom") {
+      return this.delegateChildWrite(sub, "create", parentId1, void 0, data, request);
+    }
     const childModel = this.prisma[sub.childModel];
     if (!childModel) throw new Error(`Prisma model "${sub.childModel}" not found`);
     const stripped = this.stripNonCreateableChildFields(data, sub);
     const normalized = normalizeValueLabels(stripped, sub.valueLabelColumns);
     const payload = {
       ...normalized,
-      [sub.foreignKey]: this.toId(parentId)
+      [sub.foreignKey]: this.toId(parentId1)
     };
     const prepared = sub.hooks?.beforeWrite ? await sub.hooks.beforeWrite(payload, {
       prisma: this.prisma,
-      op: "create"
+      op: "create",
+      request,
+      parent: this.parentHookContext(parentId1)
     }) : payload;
     const includeKeys = includeRelationNames(sub.include);
+    const preparedEntries = prepared;
     const prismaData = {
-      ...Object.fromEntries(Object.entries(prepared).filter(([k]) => !includeKeys.has(k))),
-      [sub.foreignKey]: this.toId(parentId)
+      ...Object.fromEntries(Object.entries(preparedEntries).filter(([k, v]) => !includeKeys.has(k) || isPrismaRelationWrite(v))),
+      ...sub.foreignKey in preparedEntries ? {
+        [sub.foreignKey]: this.toId(parentId1)
+      } : {}
     };
     const result = await childModel.create({
       data: prismaData
     });
     return sub.hooks?.afterWrite ? sub.hooks.afterWrite(result, {
       prisma: this.prisma,
-      op: "create"
+      op: "create",
+      request
     }) : result;
   }
   /**
@@ -2905,7 +3857,10 @@ var WriteRepository = class {
   * receive non-scalar fields.
   * @throws {NotFoundException} When the child record does not exist (Prisma P2025).
   */
-  async updateChild(sub, childId, data) {
+  async updateChild(sub, childId, data, request) {
+    if (sub.childKind === "custom") {
+      return this.delegateChildWrite(sub, "update", parentIdFromRequest(request), childId, data, request);
+    }
     const childModel = this.prisma[sub.childModel];
     if (!childModel) throw new Error(`Prisma model "${sub.childModel}" not found`);
     const id = (sub.idType ?? "string") === "number" ? +childId : String(childId);
@@ -2913,10 +3868,12 @@ var WriteRepository = class {
     const afterHook = sub.hooks?.beforeWrite ? await sub.hooks.beforeWrite(normalized, {
       prisma: this.prisma,
       op: "update",
-      id
+      id,
+      request,
+      parent: this.parentHookContext(parentId)
     }) : normalized;
     const includeKeys = includeRelationNames(sub.include);
-    const prepared = Object.fromEntries(Object.entries(afterHook).filter(([k]) => !includeKeys.has(k)));
+    const prepared = Object.fromEntries(Object.entries(afterHook).filter(([k, v]) => !includeKeys.has(k) || isPrismaRelationWrite(v)));
     try {
       const result = await childModel.update({
         where: {
@@ -2927,10 +3884,11 @@ var WriteRepository = class {
       return sub.hooks?.afterWrite ? sub.hooks.afterWrite(result, {
         prisma: this.prisma,
         op: "update",
-        id
+        id,
+        request
       }) : result;
     } catch (e) {
-      if (e?.code === PRISMA_NOT_FOUND_CODE) throw new import_common5.NotFoundException(`${sub.childRoute} with id ${childId} not found`);
+      if (e?.code === PRISMA_NOT_FOUND_CODE) throw new import_common7.NotFoundException(`${sub.childRoute} with id ${childId} not found`);
       throw e;
     }
   }
@@ -2939,7 +3897,10 @@ var WriteRepository = class {
   * clause to prevent cross-parent deletions.
   * @throws {NotFoundException} When no matching record is found.
   */
-  async deleteChild(sub, childId, parentId) {
+  async deleteChild(sub, childId, parentId1, request) {
+    if (sub.childKind === "custom") {
+      return this.delegateChildWrite(sub, "delete", parentIdFromRequest(request, parentId1), childId, void 0, request);
+    }
     const childModel = this.prisma[sub.childModel];
     if (!childModel) throw new Error(`Prisma model "${sub.childModel}" not found`);
     const id = (sub.idType ?? "string") === "number" ? +childId : String(childId);
@@ -2947,26 +3908,36 @@ var WriteRepository = class {
     const where = {
       [idField]: id
     };
-    if (parentId !== void 0) where[sub.foreignKey] = this.toId(parentId);
+    if (parentId1 !== void 0) where[sub.foreignKey] = this.toId(parentId1);
     try {
       const result = await childModel.deleteMany({
         where
       });
-      if (result.count === 0) throw new import_common5.NotFoundException(`${sub.childRoute} with id ${childId} not found`);
+      if (result.count === 0) throw new import_common7.NotFoundException(`${sub.childRoute} with id ${childId} not found`);
       return sub.hooks?.afterWrite ? sub.hooks.afterWrite(result, {
         prisma: this.prisma,
         op: "delete",
-        id
+        id,
+        request
       }) : result;
     } catch (e) {
-      if (e?.code === PRISMA_NOT_FOUND_CODE) throw new import_common5.NotFoundException(`${sub.childRoute} with id ${childId} not found`);
+      if (e?.code === PRISMA_NOT_FOUND_CODE) throw new import_common7.NotFoundException(`${sub.childRoute} with id ${childId} not found`);
       throw e;
     }
   }
 };
 
 // src/lib/crud/crud-repository.factory.ts
-function createCrudRepository(prisma, config) {
+function createCrudRepository(prisma, config, dataSources) {
+  if (config.kind === "custom") {
+    return createCustomRepository(prisma, config, dataSources ?? {
+      resolve: /* @__PURE__ */ __name(() => prisma, "resolve"),
+      entries: /* @__PURE__ */ __name(() => [], "entries")
+    }, config.repository);
+  }
+  if (!config.model) {
+    throw new Error(`Resource "${config.name}" has no "model". A prisma-backed resource must name its Prisma model; set "kind": "custom" for a resource with no model.`);
+  }
   const model = prisma[config.model];
   if (!model) {
     throw new Error(`Model "${config.model}" not found on the provided PrismaClient. Check the resource config for "${config.name}".`);
@@ -2999,7 +3970,7 @@ function createCrudRepository(prisma, config) {
 __name(createCrudRepository, "createCrudRepository");
 
 // src/lib/crud/data-source/data-source.registry.ts
-var import_common6 = require("@nestjs/common");
+var import_common8 = require("@nestjs/common");
 function _ts_decorate4(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") r = Reflect.decorate(decorators, target, key, desc2);
@@ -3070,36 +4041,16 @@ var DataSourceRegistry = class {
   }
 };
 DataSourceRegistry = _ts_decorate4([
-  (0, import_common6.Injectable)(),
+  (0, import_common8.Injectable)(),
   _ts_metadata3("design:type", Function),
   _ts_metadata3("design:paramtypes", [
     Array
   ])
 ], DataSourceRegistry);
 
-// src/lib/crud/resource/resource-load-errors.registry.ts
-var ResourceLoadErrorsRegistry = class ResourceLoadErrorsRegistry2 {
-  static {
-    __name(this, "ResourceLoadErrorsRegistry");
-  }
-  errors = [];
-  record(e) {
-    this.errors.push(e);
-  }
-  getAll() {
-    return [
-      ...this.errors
-    ];
-  }
-  clear() {
-    this.errors = [];
-  }
-};
-var resourceLoadErrorsRegistry = new ResourceLoadErrorsRegistry();
-
 // src/lib/crud/data-source/data-source.loader.ts
 var import_node_fs2 = require("fs");
-var import_node_path4 = require("path");
+var import_node_path5 = require("path");
 var loadDataSourcesFromDir = /* @__PURE__ */ __name(async (dirPath) => {
   if (!(0, import_node_fs2.existsSync)(dirPath)) return [];
   const entries = (0, import_node_fs2.readdirSync)(dirPath, {
@@ -3108,8 +4059,8 @@ var loadDataSourcesFromDir = /* @__PURE__ */ __name(async (dirPath) => {
   const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
   const results = [];
   for (const dir of dirs) {
-    const basePath = (0, import_node_path4.join)(dirPath, dir);
-    const jsonFile = (0, import_node_path4.join)(basePath, "data-source.json");
+    const basePath = (0, import_node_path5.join)(dirPath, dir);
+    const jsonFile = (0, import_node_path5.join)(basePath, "data-source.json");
     if (!(0, import_node_fs2.existsSync)(jsonFile)) continue;
     let _config;
     try {
@@ -3149,14 +4100,14 @@ var findModule2 = /* @__PURE__ */ __name((dir, name) => {
     ".ts",
     ".js"
   ]) {
-    const p = (0, import_node_path4.join)(dir, `${name}${ext}`);
+    const p = (0, import_node_path5.join)(dir, `${name}${ext}`);
     if ((0, import_node_fs2.existsSync)(p)) return p;
   }
   return void 0;
 }, "findModule");
 
 // src/lib/crud/operations/register-actions.ts
-var import_common7 = require("@nestjs/common");
+var import_common9 = require("@nestjs/common");
 var import_swagger2 = require("@nestjs/swagger");
 
 // src/lib/crud/operations/decorator.utils.ts
@@ -3180,8 +4131,8 @@ var registerActionRoutes = /* @__PURE__ */ __name((ctx) => {
       return action.procedure(this.repo.prisma, recordId);
     });
     const d = desc(cls, methodName);
-    (0, import_common7.Post)(`procedure/${action.id}/:recordId`)(cls.prototype, methodName, d);
-    (0, import_common7.Param)("recordId")(cls.prototype, methodName, 0);
+    (0, import_common9.Post)(`procedure/${action.id}/:recordId`)(cls.prototype, methodName, d);
+    (0, import_common9.Param)("recordId")(cls.prototype, methodName, 0);
     (0, import_swagger2.ApiOperation)({
       summary: `Execute action "${action.label}" on a ${name}`
     })(cls.prototype, methodName, d);
@@ -3205,7 +4156,7 @@ var registerTableActionRoutes = /* @__PURE__ */ __name((ctx) => {
       return action.procedure(this.repo.prisma);
     });
     const d = desc(cls, methodName);
-    (0, import_common7.Post)(`table-action/${action.id}`)(cls.prototype, methodName, d);
+    (0, import_common9.Post)(`table-action/${action.id}`)(cls.prototype, methodName, d);
     (0, import_swagger2.ApiOperation)({
       summary: `Execute table action "${action.label ?? action.id}" on ${name}`
     })(cls.prototype, methodName, d);
@@ -3217,7 +4168,7 @@ var registerTableActionRoutes = /* @__PURE__ */ __name((ctx) => {
 }, "registerTableActionRoutes");
 
 // src/lib/crud/operations/register-create.ts
-var import_common8 = require("@nestjs/common");
+var import_common10 = require("@nestjs/common");
 var import_swagger3 = require("@nestjs/swagger");
 var defaultCreate = /* @__PURE__ */ __name((ctx) => {
   if (!isOperationEnabled(ctx.definition, "create")) return null;
@@ -3227,13 +4178,14 @@ var defaultCreate = /* @__PURE__ */ __name((ctx) => {
     route: "",
     methodName,
     name: config.name,
-    createFn: /* @__PURE__ */ __name(function(body) {
-      return this.repo.create(body);
+    createFn: /* @__PURE__ */ __name(function(body, req) {
+      return this.repo.create(body, req);
     }, "createFn"),
     decorators: /* @__PURE__ */ __name(() => {
       bodyDecorator(createSchema, {
         coerceNullableUndefinedToNull: true
       })(cls.prototype, methodName, 0);
+      (0, import_common10.Req)()(cls.prototype, methodName, 1);
     }, "decorators")
   };
 }, "defaultCreate");
@@ -3241,12 +4193,13 @@ var childCreate = /* @__PURE__ */ __name((sub) => (ctx) => {
   if (!isOperationEnabled(sub.operations, "create")) return null;
   const { cls } = ctx;
   const methodName = `createChild_${sub.childRoute}`;
-  const createFn = /* @__PURE__ */ __name(async function(id, body) {
-    return this.repo.createChild(id, sub, body);
+  const createFn = /* @__PURE__ */ __name(async function(id, body, req) {
+    return this.repo.createChild(id, sub, body, req);
   }, "createFn");
   const decorators = /* @__PURE__ */ __name(() => {
-    (0, import_common8.Param)("id")(cls.prototype, methodName, 0);
-    (0, import_common8.Body)()(cls.prototype, methodName, 1);
+    (0, import_common10.Param)("id")(cls.prototype, methodName, 0);
+    (0, import_common10.Body)()(cls.prototype, methodName, 1);
+    (0, import_common10.Req)()(cls.prototype, methodName, 2);
   }, "decorators");
   return {
     route: `:id/${sub.childRoute}`,
@@ -3264,7 +4217,7 @@ var registerCreate = /* @__PURE__ */ __name((ctx, sub) => {
   const { cls } = ctx;
   def(cls, methodName, properties.createFn);
   const d = desc(cls, methodName);
-  (0, import_common8.Post)(route)(cls.prototype, methodName, d);
+  (0, import_common10.Post)(route)(cls.prototype, methodName, d);
   (0, import_swagger3.ApiOperation)({
     summary: `Create a ${name}`
   })(cls.prototype, methodName, d);
@@ -3276,7 +4229,7 @@ var registerCreate = /* @__PURE__ */ __name((ctx, sub) => {
 }, "registerCreate");
 
 // src/lib/crud/operations/register-delete.ts
-var import_common9 = require("@nestjs/common");
+var import_common11 = require("@nestjs/common");
 var import_swagger4 = require("@nestjs/swagger");
 var defaultDelete = /* @__PURE__ */ __name((ctx) => {
   if (!isOperationEnabled(ctx.definition, "delete")) return null;
@@ -3289,8 +4242,8 @@ var defaultDelete = /* @__PURE__ */ __name((ctx) => {
     name,
     decorators: /* @__PURE__ */ __name(() => {
     }, "decorators"),
-    deleteFn: /* @__PURE__ */ __name(function(id) {
-      return this.repo.delete(id);
+    deleteFn: /* @__PURE__ */ __name(function(id, req) {
+      return this.repo.delete(id, req);
     }, "deleteFn")
   };
 }, "defaultDelete");
@@ -3298,11 +4251,13 @@ var deleteChild = /* @__PURE__ */ __name((sub) => (ctx) => {
   if (!isOperationEnabled(sub.operations, "delete")) return null;
   const { cls } = ctx;
   const methodName = `deleteChild_${sub.childRoute}`;
-  const deleteFn = /* @__PURE__ */ __name(async function(childId, parentId) {
-    return this.repo.deleteChild(sub, childId, parentId);
+  const deleteFn = /* @__PURE__ */ __name(async function(childId, parentId2, req) {
+    return this.repo.deleteChild(sub, childId, parentId2, req);
   }, "deleteFn");
   const decorators = /* @__PURE__ */ __name(() => {
-    (0, import_common9.Param)("childId")(cls.prototype, methodName, 0);
+    (0, import_common11.Param)("childId")(cls.prototype, methodName, 0);
+    (0, import_common11.Param)("id")(cls.prototype, methodName, 1);
+    (0, import_common11.Req)()(cls.prototype, methodName, 2);
   }, "decorators");
   return {
     route: `:id/${sub.childRoute}/:childId`,
@@ -3320,8 +4275,8 @@ var registerDelete = /* @__PURE__ */ __name((ctx, sub) => {
   const { methodName, route, name } = properties;
   def(cls, methodName, properties.deleteFn);
   const d = desc(cls, methodName);
-  (0, import_common9.Delete)(route)(cls.prototype, methodName, d);
-  (0, import_common9.Param)("id")(cls.prototype, methodName, 0);
+  (0, import_common11.Delete)(route)(cls.prototype, methodName, d);
+  (0, import_common11.Param)("id")(cls.prototype, methodName, 0);
   (0, import_swagger4.ApiOperation)({
     summary: `Delete ${name} record`
   })(cls.prototype, methodName, d);
@@ -3330,10 +4285,11 @@ var registerDelete = /* @__PURE__ */ __name((ctx, sub) => {
     status: 200
   })(cls.prototype, methodName, d);
   properties.decorators();
+  if (!sub) (0, import_common11.Req)()(cls.prototype, methodName, 1);
 }, "registerDelete");
 
 // src/lib/crud/operations/register-findall.ts
-var import_common10 = require("@nestjs/common");
+var import_common12 = require("@nestjs/common");
 var import_swagger5 = require("@nestjs/swagger");
 
 // src/lib/crud/request.dto.ts
@@ -3416,7 +4372,7 @@ var ZodValidationPipe = class {
 };
 
 // src/lib/crud/operations/register-findall.ts
-var _findAll = /* @__PURE__ */ __name(async (repo, params, q, lookupLabel) => {
+var _findAll = /* @__PURE__ */ __name(async (repo, params, q, lookupLabel, request) => {
   const effectiveParams = {
     ...params
   };
@@ -3426,10 +4382,13 @@ var _findAll = /* @__PURE__ */ __name(async (repo, params, q, lookupLabel) => {
       `${lookupLabel}:${q}`
     ];
   }
-  const [data, count] = await Promise.all([
-    repo.findAll(effectiveParams),
+  const { data, count } = repo.findAllWithCount ? await repo.findAllWithCount(effectiveParams, request) : await Promise.all([
+    repo.findAll(effectiveParams, request),
     repo.count(effectiveParams.filter)
-  ]);
+  ]).then(([data2, count2]) => ({
+    data: data2,
+    count: count2
+  }));
   const totalPages = Math.max(1, Math.ceil(count / params.pageSize));
   return {
     data,
@@ -3444,8 +4403,8 @@ var _findAll = /* @__PURE__ */ __name(async (repo, params, q, lookupLabel) => {
     }
   };
 }, "_findAll");
-var findAllByParent = /* @__PURE__ */ __name(async (repo, id, childRoute, params) => {
-  const { data, count } = await repo.findAllByParent(id, childRoute, params);
+var findAllByParent = /* @__PURE__ */ __name(async (repo, id, childRoute, params, request) => {
+  const { data, count } = await repo.findAllByParent(id, childRoute, params, request);
   const totalPages = Math.max(1, Math.ceil(count / params.pageSize));
   return {
     data,
@@ -3464,8 +4423,8 @@ var defaultFindAll = /* @__PURE__ */ __name((ctx) => {
   if (!isOperationEnabled(ctx.definition, "findAll")) return;
   const { config } = ctx;
   const lookupLabel = config.lookup?.label;
-  const findAll = /* @__PURE__ */ __name(async function(params, q) {
-    return _findAll(this.repo, params, q, lookupLabel);
+  const findAll = /* @__PURE__ */ __name(async function(params, q, req) {
+    return _findAll(this.repo, params, q, lookupLabel, req);
   }, "findAll");
   return {
     route: "",
@@ -3481,11 +4440,12 @@ var childFindAll = /* @__PURE__ */ __name((sub) => (ctx) => {
   if (!isOperationEnabled(sub.operations, "findAll")) return;
   const { cls } = ctx;
   const methodName = `findAllBy_${sub.childRoute}`;
-  const findAll = /* @__PURE__ */ __name(async function(params, q, id) {
-    return findAllByParent(this.repo, id, sub.childRoute, params);
+  const findAll = /* @__PURE__ */ __name(async function(params, q, id, req) {
+    return findAllByParent(this.repo, id, sub.childRoute, params, req);
   }, "findAll");
   const decorators = /* @__PURE__ */ __name(() => {
-    (0, import_common10.Param)("id")(cls.prototype, methodName, 2);
+    (0, import_common12.Param)("id")(cls.prototype, methodName, 2);
+    (0, import_common12.Req)()(cls.prototype, methodName, 3);
   }, "decorators");
   return {
     name: sub.childRoute,
@@ -3504,9 +4464,10 @@ var registerFindAll = /* @__PURE__ */ __name((ctx, sub) => {
   const { cls } = ctx;
   def(cls, methodName, properties.findAll);
   const d = desc(cls, methodName);
-  (0, import_common10.Get)(route)(cls.prototype, methodName, d);
-  (0, import_common10.Query)(new ZodValidationPipe(RequestDtoNoOffset.zodSchema))(cls.prototype, methodName, 0);
-  (0, import_common10.Query)("q")(cls.prototype, methodName, 1);
+  (0, import_common12.Get)(route)(cls.prototype, methodName, d);
+  (0, import_common12.Query)(new ZodValidationPipe(RequestDtoNoOffset.zodSchema))(cls.prototype, methodName, 0);
+  (0, import_common12.Query)("q")(cls.prototype, methodName, 1);
+  if (!sub) (0, import_common12.Req)()(cls.prototype, methodName, 2);
   (0, import_swagger5.ApiOperation)({
     summary: `List all ${name}s`
   })(cls.prototype, methodName, d);
@@ -3524,7 +4485,7 @@ var registerFindAll = /* @__PURE__ */ __name((ctx, sub) => {
 }, "registerFindAll");
 
 // src/lib/crud/operations/register-findone.ts
-var import_common11 = require("@nestjs/common");
+var import_common13 = require("@nestjs/common");
 var import_swagger6 = require("@nestjs/swagger");
 var defaultFindOne = /* @__PURE__ */ __name((ctx) => {
   if (!isOperationEnabled(ctx.definition, "findOne")) return null;
@@ -3534,11 +4495,12 @@ var defaultFindOne = /* @__PURE__ */ __name((ctx) => {
     route: ":id",
     methodName,
     name: config.name,
-    findOneFn: /* @__PURE__ */ __name(function(id) {
-      return this.repo.findOne(id);
+    findOneFn: /* @__PURE__ */ __name(function(id, req) {
+      return this.repo.findOne(id, req);
     }, "findOneFn"),
     decorators: /* @__PURE__ */ __name(() => {
-      (0, import_common11.Param)("id")(cls.prototype, methodName, 0);
+      (0, import_common13.Param)("id")(cls.prototype, methodName, 0);
+      (0, import_common13.Req)()(cls.prototype, methodName, 1);
     }, "decorators")
   };
 }, "defaultFindOne");
@@ -3546,12 +4508,13 @@ var childFindOne = /* @__PURE__ */ __name((sub) => (ctx) => {
   if (!isOperationEnabled(sub.operations, "findOne")) return null;
   const { cls } = ctx;
   const methodName = `findOneChild_${sub.childRoute}`;
-  const findOneFn = /* @__PURE__ */ __name(async function(parentId, childId) {
-    return this.repo.findOneChild(sub, childId, parentId);
+  const findOneFn = /* @__PURE__ */ __name(async function(parentId2, childId, req) {
+    return this.repo.findOneChild(sub, childId, parentId2, req);
   }, "findOneFn");
   const decorators = /* @__PURE__ */ __name(() => {
-    (0, import_common11.Param)("id")(cls.prototype, methodName, 0);
-    (0, import_common11.Param)("childId")(cls.prototype, methodName, 1);
+    (0, import_common13.Param)("id")(cls.prototype, methodName, 0);
+    (0, import_common13.Param)("childId")(cls.prototype, methodName, 1);
+    (0, import_common13.Req)()(cls.prototype, methodName, 2);
   }, "decorators");
   return {
     route: `:id/${sub.childRoute}/:childId`,
@@ -3569,7 +4532,7 @@ var registerFindOne = /* @__PURE__ */ __name((ctx, sub) => {
   const { cls } = ctx;
   def(cls, methodName, properties.findOneFn);
   const d = desc(cls, methodName);
-  (0, import_common11.Get)(route)(cls.prototype, methodName, d);
+  (0, import_common13.Get)(route)(cls.prototype, methodName, d);
   (0, import_swagger6.ApiOperation)({
     summary: `Get one ${name} by id`
   })(cls.prototype, methodName, d);
@@ -3588,7 +4551,7 @@ var registerFindOne = /* @__PURE__ */ __name((ctx, sub) => {
 }, "registerFindOne");
 
 // src/lib/crud/operations/register-patch.ts
-var import_common12 = require("@nestjs/common");
+var import_common14 = require("@nestjs/common");
 var import_swagger7 = require("@nestjs/swagger");
 var defaultPatch = /* @__PURE__ */ __name((ctx) => {
   if (!isOperationEnabled(ctx.definition, "patch")) return null;
@@ -3598,12 +4561,13 @@ var defaultPatch = /* @__PURE__ */ __name((ctx) => {
     route: ":id",
     methodName,
     name: config.name,
-    patchFn: /* @__PURE__ */ __name(function(id, body) {
-      return this.repo.patch(id, body);
+    patchFn: /* @__PURE__ */ __name(function(id, body, req) {
+      return this.repo.patch(id, body, req);
     }, "patchFn"),
     decorators: /* @__PURE__ */ __name(() => {
-      (0, import_common12.Param)("id")(cls.prototype, methodName, 0);
+      (0, import_common14.Param)("id")(cls.prototype, methodName, 0);
       bodyDecorator(patchSchema)(cls.prototype, methodName, 1);
+      (0, import_common14.Req)()(cls.prototype, methodName, 2);
     }, "decorators")
   };
 }, "defaultPatch");
@@ -3611,13 +4575,14 @@ var childPatch = /* @__PURE__ */ __name((sub) => (ctx) => {
   if (!isOperationEnabled(sub.operations, "patch")) return null;
   const { cls } = ctx;
   const methodName = `patchChild_${sub.childRoute}`;
-  const patchFn = /* @__PURE__ */ __name(async function(_id, childId, body) {
-    return this.repo.updateChild(sub, childId, body);
+  const patchFn = /* @__PURE__ */ __name(async function(_id, childId, body, req) {
+    return this.repo.updateChild(sub, childId, body, req);
   }, "patchFn");
   const decorators = /* @__PURE__ */ __name(() => {
-    (0, import_common12.Param)("id")(cls.prototype, methodName, 0);
-    (0, import_common12.Param)("childId")(cls.prototype, methodName, 1);
-    (0, import_common12.Body)()(cls.prototype, methodName, 2);
+    (0, import_common14.Param)("id")(cls.prototype, methodName, 0);
+    (0, import_common14.Param)("childId")(cls.prototype, methodName, 1);
+    (0, import_common14.Body)()(cls.prototype, methodName, 2);
+    (0, import_common14.Req)()(cls.prototype, methodName, 3);
   }, "decorators");
   return {
     route: `:id/${sub.childRoute}/:childId`,
@@ -3635,7 +4600,7 @@ var registerPatch = /* @__PURE__ */ __name((ctx, sub) => {
   const { cls } = ctx;
   def(cls, methodName, properties.patchFn);
   const d = desc(cls, methodName);
-  (0, import_common12.Patch)(route)(cls.prototype, methodName, d);
+  (0, import_common14.Patch)(route)(cls.prototype, methodName, d);
   (0, import_swagger7.ApiOperation)({
     summary: `Update a ${name}`
   })(cls.prototype, methodName, d);
@@ -3650,30 +4615,30 @@ var registerPatch = /* @__PURE__ */ __name((ctx, sub) => {
 }, "registerPatch");
 
 // src/lib/crud/operations/register-schema-endpoints.ts
-var import_common13 = require("@nestjs/common");
+var import_common15 = require("@nestjs/common");
 var import_swagger8 = require("@nestjs/swagger");
 
 // src/lib/crud/resource/PatchResourceJson.schema.ts
-var import_zod23 = require("zod");
-var FieldVariantPatchSchema = import_zod23.z.object({
-  type: import_zod23.z.string().nullable().optional(),
-  format: import_zod23.z.string().nullable().optional(),
-  resource: import_zod23.z.string().nullable().optional(),
-  position: import_zod23.z.number().nullable().optional(),
-  options: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.unknown().nullable()).optional()
+var import_zod28 = require("zod");
+var FieldVariantPatchSchema = import_zod28.z.object({
+  type: import_zod28.z.string().nullable().optional(),
+  format: import_zod28.z.string().nullable().optional(),
+  resource: import_zod28.z.string().nullable().optional(),
+  position: import_zod28.z.number().nullable().optional(),
+  options: import_zod28.z.record(import_zod28.z.string(), import_zod28.z.unknown().nullable()).optional()
 }).partial();
-var PatchColumnSchema = import_zod23.z.object({
-  label: import_zod23.z.string().optional(),
-  column: import_zod23.z.string().optional(),
-  hiddenInTable: import_zod23.z.boolean().optional(),
-  hiddenInForm: import_zod23.z.boolean().optional(),
-  hiddenInView: import_zod23.z.boolean().optional(),
+var PatchColumnSchema = import_zod28.z.object({
+  label: import_zod28.z.string().optional(),
+  column: import_zod28.z.string().optional(),
+  hiddenInTable: import_zod28.z.boolean().optional(),
+  hiddenInForm: import_zod28.z.boolean().optional(),
+  hiddenInView: import_zod28.z.boolean().optional(),
   fieldInput: FieldVariantPatchSchema.optional(),
   fieldView: FieldVariantPatchSchema.optional(),
   fieldTable: FieldVariantPatchSchema.optional()
 }).partial();
-var PatchResourceJsonSchema = import_zod23.z.object({
-  columns: import_zod23.z.record(import_zod23.z.string(), PatchColumnSchema)
+var PatchResourceJsonSchema = import_zod28.z.object({
+  columns: import_zod28.z.record(import_zod28.z.string(), PatchColumnSchema)
 });
 
 // src/lib/crud/resource/WriteResourceJson.ts
@@ -3906,7 +4871,7 @@ var resolveActions = /* @__PURE__ */ __name((baseUrl, actions) => {
 var buildViewsPayload = /* @__PURE__ */ __name((config, baseUrl) => {
   if (!config.views || !Object.keys(config.views).length) return void 0;
   const definition = resolveDefinition(config);
-  const baseUri = `${baseUrl}/${config.route}`;
+  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")) {
     operations["lookup"] = `${baseUri}?q={text}`;
@@ -3926,7 +4891,7 @@ var buildViewsPayload = /* @__PURE__ */ __name((config, baseUrl) => {
     id: config.name,
     name: config.name,
     route: config.route,
-    uri: `${baseUrl}/${config.route}`,
+    uri: baseUri,
     title: config.title ?? config.tag,
     idField: config.lookup?.key ?? "id",
     idType: config.idType ?? "string",
@@ -3995,7 +4960,7 @@ var buildEditableColumnsPayload = /* @__PURE__ */ __name((config) => {
 }, "buildEditableColumnsPayload");
 
 // src/lib/crud/operations/register-schema-endpoints.ts
-var import_node_path5 = require("path");
+var import_node_path6 = require("path");
 var registerDefinitionEndpoint = /* @__PURE__ */ __name((ctx) => {
   const { cls, config } = ctx;
   const { route, name } = config;
@@ -4008,7 +4973,7 @@ var registerDefinitionEndpoint = /* @__PURE__ */ __name((ctx) => {
     return definitionPayload;
   });
   const d = desc(cls, "getDefinition");
-  (0, import_common13.Get)("definition")(cls.prototype, "getDefinition", d);
+  (0, import_common15.Get)("definition")(cls.prototype, "getDefinition", d);
   (0, import_swagger8.ApiOperation)({
     summary: `Get the resource definition for ${name}`
   })(cls.prototype, "getDefinition", d);
@@ -4029,7 +4994,7 @@ var registerResourceJsonEndpoint = /* @__PURE__ */ __name((ctx) => {
     return resourceJsonPayload;
   });
   const d = desc(cls, "getResourceJson");
-  (0, import_common13.Get)("resource.json")(cls.prototype, "getResourceJson", d);
+  (0, import_common15.Get)("resource.json")(cls.prototype, "getResourceJson", d);
   (0, import_swagger8.ApiOperation)({
     summary: `Get resource descriptor for ${name}`
   })(cls.prototype, "getResourceJson", d);
@@ -4043,13 +5008,13 @@ var registerResourceColumnsEndpoint = /* @__PURE__ */ __name((ctx) => {
   const { route, name } = config;
   def(cls, "getResourceColumns", async function() {
     if (!IS_DEV) {
-      throw new import_common13.ForbiddenException("The resource schema editor is only available when the backend is running in local dev mode.");
+      throw new import_common15.ForbiddenException("The resource schema editor is only available when the backend is running in local dev mode.");
     }
     const fresh = await this.configRegistry.getByRoute(route);
     return buildEditableColumnsPayload(fresh ?? config);
   });
   const d = desc(cls, "getResourceColumns");
-  (0, import_common13.Get)("resource-columns")(cls.prototype, "getResourceColumns", d);
+  (0, import_common15.Get)("resource-columns")(cls.prototype, "getResourceColumns", d);
   (0, import_swagger8.ApiOperation)({
     summary: `Dev-only: get the editable column list for ${name}`
   })(cls.prototype, "getResourceColumns", d);
@@ -4063,30 +5028,30 @@ var registerResourceJsonPatchEndpoint = /* @__PURE__ */ __name((ctx) => {
   const { route, name } = config;
   def(cls, "patchResourceJson", async function(body) {
     if (!IS_DEV) {
-      throw new import_common13.ForbiddenException("Editing resource.json is only available when the backend is running in local dev mode.");
+      throw new import_common15.ForbiddenException("Editing resource.json is only available when the backend is running in local dev mode.");
     }
     await this.configRegistry.getByRoute(route);
     const dir = this.configRegistry.getResourceDir(route);
     if (!dir) {
-      throw new import_common13.NotFoundException(`No resource.json on disk for "${name}" (route "${route}").`);
+      throw new import_common15.NotFoundException(`No resource.json on disk for "${name}" (route "${route}").`);
     }
-    const jsonPath = (0, import_node_path5.join)(dir, "resource.json");
+    const jsonPath = (0, import_node_path6.join)(dir, "resource.json");
     const raw = readRawResourceJson(jsonPath);
     if (!raw) {
-      throw new import_common13.NotFoundException(`resource.json not found at ${jsonPath}`);
+      throw new import_common15.NotFoundException(`resource.json not found at ${jsonPath}`);
     }
     const merged = applyColumnPatch(raw, body);
     const validated = validateResourceJson(merged);
     if (!validated.success) {
-      throw new import_common13.BadRequestException(validated.error.issues);
+      throw new import_common15.BadRequestException(validated.error.issues);
     }
     writeRawResourceJson(jsonPath, merged);
     const fresh = await this.configRegistry.getByRoute(route);
     return buildEditableColumnsPayload(fresh ?? config);
   });
   const d = desc(cls, "patchResourceJson");
-  (0, import_common13.Patch)("resource.json")(cls.prototype, "patchResourceJson", d);
-  (0, import_common13.Body)(new ZodValidationPipe(PatchResourceJsonSchema))(cls.prototype, "patchResourceJson", 0);
+  (0, import_common15.Patch)("resource.json")(cls.prototype, "patchResourceJson", d);
+  (0, import_common15.Body)(new ZodValidationPipe(PatchResourceJsonSchema))(cls.prototype, "patchResourceJson", 0);
   (0, import_swagger8.ApiOperation)({
     summary: `Dev-only: patch column layout in resource.json for ${name}`
   })(cls.prototype, "patchResourceJson", d);
@@ -4100,22 +5065,22 @@ var registerResourceJsonRawGetEndpoint = /* @__PURE__ */ __name((ctx) => {
   const { route, name } = config;
   def(cls, "getResourceJsonRaw", async function() {
     if (!IS_DEV) {
-      throw new import_common13.ForbiddenException("The resource JSON editor is only available when the backend is running in local dev mode.");
+      throw new import_common15.ForbiddenException("The resource JSON editor is only available when the backend is running in local dev mode.");
     }
     await this.configRegistry.getByRoute(route);
     const dir = this.configRegistry.getResourceDir(route);
     if (!dir) {
-      throw new import_common13.NotFoundException(`No resource.json on disk for "${name}" (route "${route}").`);
+      throw new import_common15.NotFoundException(`No resource.json on disk for "${name}" (route "${route}").`);
     }
-    const jsonPath = (0, import_node_path5.join)(dir, "resource.json");
+    const jsonPath = (0, import_node_path6.join)(dir, "resource.json");
     const raw = readRawResourceJson(jsonPath);
     if (!raw) {
-      throw new import_common13.NotFoundException(`resource.json not found at ${jsonPath}`);
+      throw new import_common15.NotFoundException(`resource.json not found at ${jsonPath}`);
     }
     return raw;
   });
   const d = desc(cls, "getResourceJsonRaw");
-  (0, import_common13.Get)("resource-json-raw")(cls.prototype, "getResourceJsonRaw", d);
+  (0, import_common15.Get)("resource-json-raw")(cls.prototype, "getResourceJsonRaw", d);
   (0, import_swagger8.ApiOperation)({
     summary: `Dev-only: get the raw resource.json for ${name}`
   })(cls.prototype, "getResourceJsonRaw", d);
@@ -4129,24 +5094,24 @@ var registerResourceJsonRawPutEndpoint = /* @__PURE__ */ __name((ctx) => {
   const { route, name } = config;
   def(cls, "putResourceJsonRaw", async function(body) {
     if (!IS_DEV) {
-      throw new import_common13.ForbiddenException("Editing resource.json is only available when the backend is running in local dev mode.");
+      throw new import_common15.ForbiddenException("Editing resource.json is only available when the backend is running in local dev mode.");
     }
     await this.configRegistry.getByRoute(route);
     const dir = this.configRegistry.getResourceDir(route);
     if (!dir) {
-      throw new import_common13.NotFoundException(`No resource.json on disk for "${name}" (route "${route}").`);
+      throw new import_common15.NotFoundException(`No resource.json on disk for "${name}" (route "${route}").`);
     }
     const validated = validateResourceJson(body);
     if (!validated.success) {
-      throw new import_common13.BadRequestException(validated.error.issues);
+      throw new import_common15.BadRequestException(validated.error.issues);
     }
-    const jsonPath = (0, import_node_path5.join)(dir, "resource.json");
+    const jsonPath = (0, import_node_path6.join)(dir, "resource.json");
     writeRawResourceJson(jsonPath, body);
     return body;
   });
   const d = desc(cls, "putResourceJsonRaw");
-  (0, import_common13.Put)("resource-json-raw")(cls.prototype, "putResourceJsonRaw", d);
-  (0, import_common13.Body)()(cls.prototype, "putResourceJsonRaw", 0);
+  (0, import_common15.Put)("resource-json-raw")(cls.prototype, "putResourceJsonRaw", d);
+  (0, import_common15.Body)()(cls.prototype, "putResourceJsonRaw", 0);
   (0, import_swagger8.ApiOperation)({
     summary: `Dev-only: replace the full resource.json for ${name}`
   })(cls.prototype, "putResourceJsonRaw", d);
@@ -4157,7 +5122,7 @@ var registerResourceJsonRawPutEndpoint = /* @__PURE__ */ __name((ctx) => {
 }, "registerResourceJsonRawPutEndpoint");
 
 // src/lib/crud/operations/register-schemas.ts
-var import_common14 = require("@nestjs/common");
+var import_common16 = require("@nestjs/common");
 var import_swagger9 = require("@nestjs/swagger");
 var defaultSchemas = /* @__PURE__ */ __name((ctx) => {
   const { config, baseUrl } = ctx;
@@ -4201,7 +5166,7 @@ var registerSchemas = /* @__PURE__ */ __name((ctx, sub) => {
   const { cls } = ctx;
   def(cls, methodName, properties.schemasFn);
   const d = desc(cls, methodName);
-  (0, import_common14.Get)(route)(cls.prototype, methodName, d);
+  (0, import_common16.Get)(route)(cls.prototype, methodName, d);
   (0, import_swagger9.ApiOperation)({
     summary: `Get view schemas for ${name}`
   })(cls.prototype, methodName, d);
@@ -4213,7 +5178,7 @@ var registerSchemas = /* @__PURE__ */ __name((ctx, sub) => {
 }, "registerSchemas");
 
 // src/lib/crud/operations/register-update.ts
-var import_common15 = require("@nestjs/common");
+var import_common17 = require("@nestjs/common");
 var import_swagger10 = require("@nestjs/swagger");
 var defaultUpdate = /* @__PURE__ */ __name((ctx) => {
   if (!isOperationEnabled(ctx.definition, "update")) return null;
@@ -4223,12 +5188,13 @@ var defaultUpdate = /* @__PURE__ */ __name((ctx) => {
     route: ":id",
     methodName,
     name: config.name,
-    updateFn: /* @__PURE__ */ __name(function(id, body) {
-      return this.repo.update(id, body);
+    updateFn: /* @__PURE__ */ __name(function(id, body, req) {
+      return this.repo.update(id, body, req);
     }, "updateFn"),
     decorators: /* @__PURE__ */ __name(() => {
-      (0, import_common15.Param)("id")(cls.prototype, methodName, 0);
+      (0, import_common17.Param)("id")(cls.prototype, methodName, 0);
       bodyDecorator(updateSchema)(cls.prototype, methodName, 1);
+      (0, import_common17.Req)()(cls.prototype, methodName, 2);
     }, "decorators")
   };
 }, "defaultUpdate");
@@ -4236,13 +5202,14 @@ var childUpdate = /* @__PURE__ */ __name((sub) => (ctx) => {
   if (!isOperationEnabled(sub.operations, "update")) return null;
   const { cls } = ctx;
   const methodName = `updateChild_${sub.childRoute}`;
-  const updateFn = /* @__PURE__ */ __name(async function(_id, childId, body) {
-    return this.repo.updateChild(sub, childId, body);
+  const updateFn = /* @__PURE__ */ __name(async function(_id, childId, body, req) {
+    return this.repo.updateChild(sub, childId, body, req);
   }, "updateFn");
   const decorators = /* @__PURE__ */ __name(() => {
-    (0, import_common15.Param)("id")(cls.prototype, methodName, 0);
-    (0, import_common15.Param)("childId")(cls.prototype, methodName, 1);
-    (0, import_common15.Body)()(cls.prototype, methodName, 2);
+    (0, import_common17.Param)("id")(cls.prototype, methodName, 0);
+    (0, import_common17.Param)("childId")(cls.prototype, methodName, 1);
+    (0, import_common17.Body)()(cls.prototype, methodName, 2);
+    (0, import_common17.Req)()(cls.prototype, methodName, 3);
   }, "decorators");
   return {
     route: `:id/${sub.childRoute}/:childId`,
@@ -4260,7 +5227,7 @@ var registerUpdate = /* @__PURE__ */ __name((ctx, sub) => {
   const { cls } = ctx;
   def(cls, methodName, properties.updateFn);
   const d = desc(cls, methodName);
-  (0, import_common15.Put)(route)(cls.prototype, methodName, d);
+  (0, import_common17.Put)(route)(cls.prototype, methodName, d);
   (0, import_swagger10.ApiOperation)({
     summary: `Replace a ${name}`
   })(cls.prototype, methodName, d);
@@ -4318,10 +5285,18 @@ function createCrudController(config, baseUrl) {
     throw new Error(`Resource "${name}" declares 'upsert' but no upsertOn`);
   }
   const bodyDecorator = /* @__PURE__ */ __name((schema, options) => {
-    if (!schema) return (0, import_common16.Body)();
-    if (isZodSchema(schema)) return (0, import_common16.Body)(new ZodValidationPipe(schema, options));
-    return (0, import_common16.Body)();
+    if (!schema) return (0, import_common18.Body)();
+    if (isZodSchema(schema)) return (0, import_common18.Body)(new ZodValidationPipe(schema, options));
+    return (0, import_common18.Body)();
   }, "bodyDecorator");
+  const resolveClient = /* @__PURE__ */ __name((registry, resource) => {
+    try {
+      return registry.resolve(resource.database);
+    } catch (e) {
+      if (resource.kind === "custom") return void 0;
+      throw e;
+    }
+  }, "resolveClient");
   let CrudControllerBase = class CrudControllerBase {
     static {
       __name(this, "CrudControllerBase");
@@ -4329,8 +5304,8 @@ function createCrudController(config, baseUrl) {
     repo;
     configRegistry;
     constructor(registry, configRegistry) {
-      const prisma = registry.resolve(config.database);
-      this.repo = createCrudRepository(prisma, config);
+      const prisma = resolveClient(registry, config);
+      this.repo = createCrudRepository(prisma, config, registry);
       this.configRegistry = configRegistry;
     }
   };
@@ -4352,7 +5327,7 @@ function createCrudController(config, baseUrl) {
     baseUrl
   };
   registerEndpoints(ctx);
-  (0, import_common16.Controller)(route)(CrudControllerBase);
+  (0, import_common18.Controller)(resourceControllerPath(route, config.parent))(CrudControllerBase);
   (0, import_swagger11.ApiTags)(tag)(CrudControllerBase);
   Object.defineProperty(CrudControllerBase, "name", {
     value: `${name.charAt(0).toUpperCase() + name.slice(1)}Controller`
@@ -4366,7 +5341,7 @@ function createCrudController(config, baseUrl) {
 __name(createCrudController, "createCrudController");
 
 // src/lib/crud/dev-tools/dev-resources.controller.ts
-var import_common17 = require("@nestjs/common");
+var import_common19 = require("@nestjs/common");
 var import_swagger12 = require("@nestjs/swagger");
 
 // ../crouton-codegen/src/naming.ts
@@ -4595,9 +5570,14 @@ var classify = /* @__PURE__ */ __name((model, ctx = {}) => {
       };
     } else if (field.kind === "relation") {
       const target = ctx.resolveRelationResource?.(field.relationModel ?? "");
+      const isCollectionSide = field.relationType === "oneToMany" || field.relationType === "manyToMany";
       if (ruleset.showRelationsInForm && target) {
         col = {
           hiddenInTable: ruleset.hideRelationsInTable,
+          ...isCollectionSide ? {
+            hiddenInForm: true,
+            hiddenInView: true
+          } : {},
           fieldInput: {
             format: "relation",
             resource: target,
@@ -4793,7 +5773,8 @@ var diff = /* @__PURE__ */ __name(({ draft, existing, hasSchemaFile = false }) =
   }
   return {
     name: draft.name,
-    model: draft.config.model,
+    // Codegen only ever drafts prisma-backed resources, so `model` is set.
+    model: draft.config.model ?? draft.name,
     isNew,
     decisions,
     draft,
@@ -4825,7 +5806,7 @@ var resolve2 = /* @__PURE__ */ __name(async (diff2, resolver = recommendedResolv
 // ../crouton-codegen/src/serialize.ts
 var RESOURCE_SCHEMA_URL = `https://ghentcdh.github.io/crouton/schema/v${CURRENT_RESOURCE_VERSION}/resource.schema.json`;
 var withResourceHeader = /* @__PURE__ */ __name((config, opts = {}) => {
-  const { $schema: _schema, schemaVersion: _version, draft: existingDraft, ...rest } = config;
+  const { $schema: _schema, schemaVersion: _version, draft: existingDraft, kind: existingKind, ...rest } = config;
   const draft = opts.draft !== void 0 ? opts.draft : existingDraft;
   return {
     $schema: RESOURCE_SCHEMA_URL,
@@ -4833,6 +5814,9 @@ var withResourceHeader = /* @__PURE__ */ __name((config, opts = {}) => {
     ...draft !== void 0 ? {
       draft
     } : {},
+    ...existingKind !== void 0 ? {
+      kind: existingKind
+    } : {},
     ...rest
   };
 }, "withResourceHeader");
@@ -4933,7 +5917,7 @@ var apply = /* @__PURE__ */ __name((resolved, ctx) => {
 
 // ../crouton-codegen/src/commit.ts
 var import_promises3 = require("fs/promises");
-var import_node_path6 = require("path");
+var import_node_path7 = require("path");
 var commit = /* @__PURE__ */ __name(async (plan, opts = {}) => {
   const written = [];
   const skipped = [];
@@ -4943,7 +5927,7 @@ var commit = /* @__PURE__ */ __name(async (plan, opts = {}) => {
       continue;
     }
     if (!opts.dryRun) {
-      await (0, import_promises3.mkdir)((0, import_node_path6.dirname)(file.path), {
+      await (0, import_promises3.mkdir)((0, import_node_path7.dirname)(file.path), {
         recursive: true
       });
       await (0, import_promises3.writeFile)(file.path, file.contents, "utf-8");
@@ -4958,15 +5942,15 @@ var commit = /* @__PURE__ */ __name(async (plan, opts = {}) => {
 
 // ../crouton-codegen/src/config.ts
 var import_promises4 = require("fs/promises");
-var import_node_path7 = require("path");
+var import_node_path8 = require("path");
 var findConfigPath2 = /* @__PURE__ */ __name(async (cwd) => {
-  let dir = (0, import_node_path7.resolve)(cwd);
+  let dir = (0, import_node_path8.resolve)(cwd);
   while (true) {
     for (const name of CONFIG_FILES) {
-      const candidate = (0, import_node_path7.join)(dir, name);
+      const candidate = (0, import_node_path8.join)(dir, name);
       if (await fileExists2(candidate)) return candidate;
     }
-    const parent = (0, import_node_path7.dirname)(dir);
+    const parent = (0, import_node_path8.dirname)(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -4987,7 +5971,7 @@ var loadConfig2 = /* @__PURE__ */ __name(async (cwd) => {
   return {
     config,
     path,
-    root: (0, import_node_path7.dirname)(path)
+    root: (0, import_node_path8.dirname)(path)
   };
 }, "loadConfig");
 var validateConfig = /* @__PURE__ */ __name((config, path = "<config>") => {
@@ -5004,7 +5988,7 @@ var loadDatasources = /* @__PURE__ */ __name(async (loaded) => {
   const datasources = [];
   for (const e of entries) {
     if (!e.isDirectory()) continue;
-    const jsonPath = (0, import_node_path7.join)(base, e.name, "data-source.json");
+    const jsonPath = (0, import_node_path8.join)(base, e.name, "data-source.json");
     if (!await fileExists2(jsonPath)) continue;
     const ds_json = JSON.parse(await (0, import_promises4.readFile)(jsonPath, "utf-8"));
     const name = ds_json.name ?? e.name;
@@ -5050,34 +6034,42 @@ var makeSchemaExportName = /* @__PURE__ */ __name((config) => {
   const template = config.schemaExportName ?? "{Model}WithRelationsSchema";
   return (prismaName) => template.replace("{Model}", prismaName);
 }, "makeSchemaExportName");
-var resolveFromRoot = /* @__PURE__ */ __name((root, p) => (0, import_node_path7.isAbsolute)(p) ? p : (0, import_node_path7.join)(root, p), "resolveFromRoot");
+var resolveFromRoot = /* @__PURE__ */ __name((root, p) => (0, import_node_path8.isAbsolute)(p) ? p : (0, import_node_path8.join)(root, p), "resolveFromRoot");
 
 // ../crouton-codegen/src/scaffold.ts
-var import_zod24 = require("zod");
+var import_zod29 = require("zod");
 var import_promises5 = require("fs/promises");
-var import_node_path8 = require("path");
+var import_node_path9 = require("path");
 var ScallfoldDatasourceSchema = DataSourceShape.extend({
   /** Folder name under `dataSourcesDir`. */
-  folder: import_zod24.z.string().default("default")
+  folder: import_zod29.z.string().default("default")
 }).transform(transformDataSource);
 
 // ../crouton-codegen/src/datasource-scaffold.ts
-var import_node_path9 = require("path");
+var import_node_path10 = require("path");
 
 // ../crouton-codegen/src/project.ts
 var import_promises6 = require("fs/promises");
-var import_node_path10 = require("path");
-var resourceDir = /* @__PURE__ */ __name((loaded, name) => (0, import_node_path10.join)(resolveFromRoot(loaded.root, loaded.config.resourcesDir), name), "resourceDir");
+var import_node_path11 = require("path");
+var resourceDir = /* @__PURE__ */ __name((loaded, name) => (0, import_node_path11.join)(resolveFromRoot(loaded.root, loaded.config.resourcesDir), name), "resourceDir");
 var readExistingResource = /* @__PURE__ */ __name(async (loaded, name) => {
   const dir = resourceDir(loaded, name);
-  const jsonPath = (0, import_node_path10.join)(dir, "resource.json");
+  const jsonPath = (0, import_node_path11.join)(dir, "resource.json");
   const config = await fileExists2(jsonPath) ? JSON.parse(await (0, import_promises6.readFile)(jsonPath, "utf-8")) : null;
-  const hasSchemaFile = await fileExists2((0, import_node_path10.join)(dir, "schema.ts")) || await fileExists2((0, import_node_path10.join)(dir, "schema.js"));
+  const hasSchemaFile = await fileExists2((0, import_node_path11.join)(dir, "schema.ts")) || await fileExists2((0, import_node_path11.join)(dir, "schema.js"));
   return {
     config,
     hasSchemaFile
   };
 }, "readExistingResource");
+var isCustomResourceFile = /* @__PURE__ */ __name(async (jsonPath) => {
+  try {
+    const parsed = JSON.parse(await (0, import_promises6.readFile)(jsonPath, "utf-8"));
+    return parsed?.kind === "custom";
+  } catch {
+    return false;
+  }
+}, "isCustomResourceFile");
 var listResourceNames = /* @__PURE__ */ __name(async (loaded) => {
   const base = resolveFromRoot(loaded.root, loaded.config.resourcesDir);
   if (!await fileExists2(base)) return [];
@@ -5086,9 +6078,11 @@ var listResourceNames = /* @__PURE__ */ __name(async (loaded) => {
   });
   const names = [];
   for (const e of entries) {
-    if (e.isDirectory() && await fileExists2((0, import_node_path10.join)(base, e.name, "resource.json"))) {
-      names.push(e.name);
-    }
+    if (!e.isDirectory()) continue;
+    const jsonPath = (0, import_node_path11.join)(base, e.name, "resource.json");
+    if (!await fileExists2(jsonPath)) continue;
+    if (await isCustomResourceFile(jsonPath)) continue;
+    names.push(e.name);
   }
   return names;
 }, "listResourceNames");
@@ -5126,7 +6120,7 @@ var buildResourceDiffs = /* @__PURE__ */ __name(async (models, deps) => {
 var import_node_child_process = require("child_process");
 var import_node_fs4 = require("fs");
 var import_promises7 = require("fs/promises");
-var import_node_path11 = require("path");
+var import_node_path12 = require("path");
 var run = /* @__PURE__ */ __name((cmd, args, cwd) => new Promise((resolve7) => {
   const child = (0, import_node_child_process.spawn)(cmd, args, {
     cwd,
@@ -5213,7 +6207,7 @@ var fixZodImports = /* @__PURE__ */ __name(async (zodOutputDir) => {
       return;
     }
     for (const entry of entries) {
-      const full = (0, import_node_path11.join)(dir, entry.name);
+      const full = (0, import_node_path12.join)(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(full);
       } else if (entry.name.endsWith(".ts")) {
@@ -5262,8 +6256,8 @@ var pullAndGenerate = /* @__PURE__ */ __name(async (input) => {
   };
 }, "pullAndGenerate");
 var normalizeSchema = /* @__PURE__ */ __name(async (schemaPath, configDir) => {
-  const dir = configDir ?? (0, import_node_path11.dirname)(schemaPath);
-  const configPath = (0, import_node_path11.join)(dir, "normalize-schema.json");
+  const dir = configDir ?? (0, import_node_path12.dirname)(schemaPath);
+  const configPath = (0, import_node_path12.join)(dir, "normalize-schema.json");
   if (!(0, import_node_fs4.existsSync)(configPath)) return {
     renamed: 0
   };
@@ -5293,7 +6287,7 @@ var normalizeSchema = /* @__PURE__ */ __name(async (schemaPath, configDir) => {
 }, "normalizeSchema");
 
 // src/lib/crud/resource/ResourceFlags.ts
-var import_node_path12 = require("path");
+var import_node_path13 = require("path");
 var applyResourceFlagPatch = /* @__PURE__ */ __name((raw, patch) => {
   const result = {
     ...raw
@@ -5334,8 +6328,8 @@ var applyResourceFlagPatch = /* @__PURE__ */ __name((raw, patch) => {
   return result;
 }, "applyResourceFlagPatch");
 var resolveResourcePath = /* @__PURE__ */ __name((resourcesDir, name) => {
-  const resolved = (0, import_node_path12.resolve)(resourcesDir, name, "resource.json");
-  if (!resolved.startsWith((0, import_node_path12.resolve)(resourcesDir) + "/")) {
+  const resolved = (0, import_node_path13.resolve)(resourcesDir, name, "resource.json");
+  if (!resolved.startsWith((0, import_node_path13.resolve)(resourcesDir) + "/")) {
     throw new Error(`Invalid resource name: "${name}"`);
   }
   return resolved;
@@ -5394,7 +6388,7 @@ var DevResourcesController = class {
   }
   assertDev() {
     if (!IS_DEV) {
-      throw new import_common17.ForbiddenException("The database sync tools are only available when CROUTON_SCHEMA_EDITOR is enabled.");
+      throw new import_common19.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. */
@@ -5403,14 +6397,14 @@ var DevResourcesController = class {
     try {
       loaded = await loadConfig2(process.cwd());
     } catch (e) {
-      throw new import_common17.NotFoundException(e.message ?? "No crouton.json config found.");
+      throw new import_common19.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_common17.BadRequestException(e.message);
+      throw new import_common19.BadRequestException(e.message);
     }
     const schemaPath = resolveFromRoot(loaded.root, ds.prismaSchema);
     return {
@@ -5425,7 +6419,7 @@ var DevResourcesController = class {
         schemaPath
       });
     } catch (e) {
-      throw new import_common17.BadRequestException(`Failed to read Prisma schema at ${schemaPath}: ${e.message}`);
+      throw new import_common19.BadRequestException(`Failed to read Prisma schema at ${schemaPath}: ${e.message}`);
     }
   }
   buildApplyContext(loaded, ds) {
@@ -5495,7 +6489,7 @@ var DevResourcesController = class {
       zodOutputDir: zodDir
     });
     if (!result.ok) {
-      throw new import_common17.BadRequestException(`prisma db pull failed:
+      throw new import_common19.BadRequestException(`prisma db pull failed:
 ${result.dbPull.output}`);
     }
     return {
@@ -5512,13 +6506,13 @@ ${result.dbPull.output}`);
   async sync(body) {
     this.assertDev();
     if (!body?.model) {
-      throw new import_common17.BadRequestException('"model" is required.');
+      throw new import_common19.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_common17.NotFoundException(`Model "${body.model}" not found in ${schemaPath}.`);
+      throw new import_common19.NotFoundException(`Model "${body.model}" not found in ${schemaPath}.`);
     }
     const resolveRelationResource = await makeRelationResolver(loaded);
     const diff2 = await buildResourceDiff(model, {
@@ -5640,14 +6634,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_common17.NotFoundException(`Resource "${name}" not found.`);
-    if (jsonPath.endsWith(".ts")) throw new import_common17.ForbiddenException("TypeScript resources cannot be edited.");
+    if (!raw) throw new import_common19.NotFoundException(`Resource "${name}" not found.`);
+    if (jsonPath.endsWith(".ts")) throw new import_common19.ForbiddenException("TypeScript resources cannot be edited.");
     const patched = applyResourceFlagPatch(raw, {
       draft: false
     });
     const result = validateResourceJson(patched);
     if (!result.success) {
-      throw new import_common17.BadRequestException(`Validation failed: ${result.error.message}`);
+      throw new import_common19.BadRequestException(`Validation failed: ${result.error.message}`);
     }
     writeRawResourceJson(jsonPath, patched);
     return {
@@ -5660,8 +6654,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_common17.NotFoundException(`Resource "${name}" not found.`);
-    if (jsonPath.endsWith(".ts")) throw new import_common17.ForbiddenException("TypeScript resources cannot be edited.");
+    if (!raw) throw new import_common19.NotFoundException(`Resource "${name}" not found.`);
+    if (jsonPath.endsWith(".ts")) throw new import_common19.ForbiddenException("TypeScript resources cannot be edited.");
     const patched = applyResourceFlagPatch(raw, {
       sidebar: {
         hide: true
@@ -5669,7 +6663,7 @@ ${result.dbPull.output}`);
     });
     const result = validateResourceJson(patched);
     if (!result.success) {
-      throw new import_common17.BadRequestException(`Validation failed: ${result.error.message}`);
+      throw new import_common19.BadRequestException(`Validation failed: ${result.error.message}`);
     }
     writeRawResourceJson(jsonPath, patched);
     return {
@@ -5682,8 +6676,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_common17.NotFoundException(`Resource "${name}" not found.`);
-    if (jsonPath.endsWith(".ts")) throw new import_common17.ForbiddenException("TypeScript resources cannot be edited.");
+    if (!raw) throw new import_common19.NotFoundException(`Resource "${name}" not found.`);
+    if (jsonPath.endsWith(".ts")) throw new import_common19.ForbiddenException("TypeScript resources cannot be edited.");
     const sidebarPatch = {
       hide: false
     };
@@ -5696,7 +6690,7 @@ ${result.dbPull.output}`);
     });
     const result = validateResourceJson(patched);
     if (!result.success) {
-      throw new import_common17.BadRequestException(`Validation failed: ${result.error.message}`);
+      throw new import_common19.BadRequestException(`Validation failed: ${result.error.message}`);
     }
     writeRawResourceJson(jsonPath, patched);
     return {
@@ -5709,12 +6703,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_common17.NotFoundException(`Resource "${name}" not found.`);
-    if (jsonPath.endsWith(".ts")) throw new import_common17.ForbiddenException("TypeScript resources cannot be edited.");
+    if (!raw) throw new import_common19.NotFoundException(`Resource "${name}" not found.`);
+    if (jsonPath.endsWith(".ts")) throw new import_common19.ForbiddenException("TypeScript resources cannot be edited.");
     const patched = applyResourceFlagPatch(raw, body);
     const result = validateResourceJson(patched);
     if (!result.success) {
-      throw new import_common17.BadRequestException(`Validation failed: ${result.error.message}`);
+      throw new import_common19.BadRequestException(`Validation failed: ${result.error.message}`);
     }
     writeRawResourceJson(jsonPath, patched);
     return {
@@ -5723,7 +6717,7 @@ ${result.dbPull.output}`);
   }
 };
 _ts_decorate5([
-  (0, import_common17.Get)("models"),
+  (0, import_common19.Get)("models"),
   (0, import_swagger12.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"
   }),
@@ -5736,7 +6730,7 @@ _ts_decorate5([
   _ts_metadata4("design:returntype", Promise)
 ], DevResourcesController.prototype, "listModels", null);
 _ts_decorate5([
-  (0, import_common17.Post)("restart"),
+  (0, import_common19.Post)("restart"),
   (0, import_swagger12.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."
   }),
@@ -5749,7 +6743,7 @@ _ts_decorate5([
   _ts_metadata4("design:returntype", Object)
 ], DevResourcesController.prototype, "restart", null);
 _ts_decorate5([
-  (0, import_common17.Post)("pull"),
+  (0, import_common19.Post)("pull"),
   (0, import_swagger12.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"
   }),
@@ -5757,7 +6751,7 @@ _ts_decorate5([
     status: 200,
     description: "Result of each step, or requiresConfirmation if schema.prisma has uncommitted changes"
   }),
-  _ts_param(0, (0, import_common17.Body)()),
+  _ts_param(0, (0, import_common19.Body)()),
   _ts_metadata4("design:type", Function),
   _ts_metadata4("design:paramtypes", [
     Object
@@ -5765,7 +6759,7 @@ _ts_decorate5([
   _ts_metadata4("design:returntype", Promise)
 ], DevResourcesController.prototype, "pull", null);
 _ts_decorate5([
-  (0, import_common17.Post)("sync"),
+  (0, import_common19.Post)("sync"),
   (0, import_swagger12.ApiOperation)({
     summary: "Dev-only: generate or update a single resource.json from its DB model, using recommended defaults (non-interactive)"
   }),
@@ -5773,7 +6767,7 @@ _ts_decorate5([
     status: 200,
     description: "Files written for this resource"
   }),
-  _ts_param(0, (0, import_common17.Body)()),
+  _ts_param(0, (0, import_common19.Body)()),
   _ts_metadata4("design:type", Function),
   _ts_metadata4("design:paramtypes", [
     Object
@@ -5781,7 +6775,7 @@ _ts_decorate5([
   _ts_metadata4("design:returntype", Promise)
 ], DevResourcesController.prototype, "sync", null);
 _ts_decorate5([
-  (0, import_common17.Post)("plan"),
+  (0, import_common19.Post)("plan"),
   (0, import_swagger12.ApiOperation)({
     summary: "Dev-only: dry-run introspect + diff across all (or selected) DB models using recommended defaults \u2014 computes what would change, writes nothing"
   }),
@@ -5789,7 +6783,7 @@ _ts_decorate5([
     status: 200,
     description: "Proposed per-resource changes"
   }),
-  _ts_param(0, (0, import_common17.Body)()),
+  _ts_param(0, (0, import_common19.Body)()),
   _ts_metadata4("design:type", Function),
   _ts_metadata4("design:paramtypes", [
     Object
@@ -5797,7 +6791,7 @@ _ts_decorate5([
   _ts_metadata4("design:returntype", Promise)
 ], DevResourcesController.prototype, "plan", null);
 _ts_decorate5([
-  (0, import_common17.Post)("apply"),
+  (0, import_common19.Post)("apply"),
   (0, import_swagger12.ApiOperation)({
     summary: "Dev-only: commit resource.json/schema.ts changes to disk for the given resources (or all, if omitted), using recommended defaults"
   }),
@@ -5805,7 +6799,7 @@ _ts_decorate5([
     status: 200,
     description: "Per-resource commit results"
   }),
-  _ts_param(0, (0, import_common17.Body)()),
+  _ts_param(0, (0, import_common19.Body)()),
   _ts_metadata4("design:type", Function),
   _ts_metadata4("design:paramtypes", [
     Object
@@ -5813,7 +6807,7 @@ _ts_decorate5([
   _ts_metadata4("design:returntype", Promise)
 ], DevResourcesController.prototype, "apply", null);
 _ts_decorate5([
-  (0, import_common17.Get)("visibility"),
+  (0, import_common19.Get)("visibility"),
   (0, import_swagger12.ApiOperation)({
     summary: "Dev-only: list all resources with their menu visibility state (in-menu, hidden, draft, error)"
   }),
@@ -5826,7 +6820,7 @@ _ts_decorate5([
   _ts_metadata4("design:returntype", Promise)
 ], DevResourcesController.prototype, "visibility", null);
 _ts_decorate5([
-  (0, import_common17.Post)(":name/publish"),
+  (0, import_common19.Post)(":name/publish"),
   (0, import_swagger12.ApiOperation)({
     summary: "Dev-only: publish a draft resource (removes `draft: true` from resource.json)"
   }),
@@ -5834,7 +6828,7 @@ _ts_decorate5([
     status: 200,
     description: "Resource published"
   }),
-  _ts_param(0, (0, import_common17.Param)("name")),
+  _ts_param(0, (0, import_common19.Param)("name")),
   _ts_metadata4("design:type", Function),
   _ts_metadata4("design:paramtypes", [
     String
@@ -5842,7 +6836,7 @@ _ts_decorate5([
   _ts_metadata4("design:returntype", Promise)
 ], DevResourcesController.prototype, "publish", null);
 _ts_decorate5([
-  (0, import_common17.Post)(":name/remove-from-menu"),
+  (0, import_common19.Post)(":name/remove-from-menu"),
   (0, import_swagger12.ApiOperation)({
     summary: "Dev-only: hide a resource from the sidebar menu (sets `sidebar.hide: true` in resource.json)"
   }),
@@ -5850,7 +6844,7 @@ _ts_decorate5([
     status: 200,
     description: "Resource removed from menu"
   }),
-  _ts_param(0, (0, import_common17.Param)("name")),
+  _ts_param(0, (0, import_common19.Param)("name")),
   _ts_metadata4("design:type", Function),
   _ts_metadata4("design:paramtypes", [
     String
@@ -5858,7 +6852,7 @@ _ts_decorate5([
   _ts_metadata4("design:returntype", Promise)
 ], DevResourcesController.prototype, "removeFromMenu", null);
 _ts_decorate5([
-  (0, import_common17.Post)(":name/add-to-menu"),
+  (0, import_common19.Post)(":name/add-to-menu"),
   (0, import_swagger12.ApiOperation)({
     summary: "Dev-only: publish + un-hide a resource and optionally set sidebar group/position/label"
   }),
@@ -5866,8 +6860,8 @@ _ts_decorate5([
     status: 200,
     description: "Resource added to menu"
   }),
-  _ts_param(0, (0, import_common17.Param)("name")),
-  _ts_param(1, (0, import_common17.Body)()),
+  _ts_param(0, (0, import_common19.Param)("name")),
+  _ts_param(1, (0, import_common19.Body)()),
   _ts_metadata4("design:type", Function),
   _ts_metadata4("design:paramtypes", [
     String,
@@ -5876,7 +6870,7 @@ _ts_decorate5([
   _ts_metadata4("design:returntype", Promise)
 ], DevResourcesController.prototype, "addToMenu", null);
 _ts_decorate5([
-  (0, import_common17.Patch)(":name/flags"),
+  (0, import_common19.Patch)(":name/flags"),
   (0, import_swagger12.ApiOperation)({
     summary: "Dev-only: set arbitrary resource flags (draft, sidebar.hide, group, position, label)"
   }),
@@ -5884,8 +6878,8 @@ _ts_decorate5([
     status: 200,
     description: "Flags updated"
   }),
-  _ts_param(0, (0, import_common17.Param)("name")),
-  _ts_param(1, (0, import_common17.Body)()),
+  _ts_param(0, (0, import_common19.Param)("name")),
+  _ts_param(1, (0, import_common19.Body)()),
   _ts_metadata4("design:type", Function),
   _ts_metadata4("design:paramtypes", [
     String,
@@ -5894,7 +6888,7 @@ _ts_decorate5([
   _ts_metadata4("design:returntype", Promise)
 ], DevResourcesController.prototype, "updateFlags", null);
 DevResourcesController = _ts_decorate5([
-  (0, import_common17.Controller)("_app/resources"),
+  (0, import_common19.Controller)("_app/resources"),
   (0, import_swagger12.ApiTags)("Dev tools"),
   _ts_metadata4("design:type", Function),
   _ts_metadata4("design:paramtypes", [
@@ -5904,28 +6898,28 @@ DevResourcesController = _ts_decorate5([
 ], DevResourcesController);
 
 // src/lib/crud/enum-registry/enum-registry.types.ts
-var import_zod25 = require("zod");
-var EnumEntrySchema = import_zod25.z.object({
-  value: import_zod25.z.unknown(),
-  label: import_zod25.z.string()
+var import_zod30 = require("zod");
+var EnumEntrySchema = import_zod30.z.object({
+  value: import_zod30.z.unknown(),
+  label: import_zod30.z.string()
 });
-var EnumRegistrySchema = import_zod25.z.record(import_zod25.z.string(), import_zod25.z.array(EnumEntrySchema)).default({});
+var EnumRegistrySchema = import_zod30.z.record(import_zod30.z.string(), import_zod30.z.array(EnumEntrySchema)).default({});
 
 // src/lib/crud/enum-registry/enum-registry.loader.ts
 var import_node_fs5 = require("fs");
-var import_node_path13 = require("path");
+var import_node_path14 = require("path");
 var ENUMS_FILE = "crouton.enums.json";
 var loadEnumRegistry = /* @__PURE__ */ __name((startDir, enumsFile) => {
   let file = enumsFile;
   if (!file) {
     let dir = startDir;
     while (true) {
-      const candidate = (0, import_node_path13.join)(dir, ENUMS_FILE);
+      const candidate = (0, import_node_path14.join)(dir, ENUMS_FILE);
       if ((0, import_node_fs5.existsSync)(candidate)) {
         file = candidate;
         break;
       }
-      const parent = (0, import_node_path13.dirname)(dir);
+      const parent = (0, import_node_path14.dirname)(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -5991,9 +6985,9 @@ var upsertOp = /* @__PURE__ */ __name((entry, schema) => {
 }, "upsertOp");
 
 // src/lib/crud/adapter/relation-type.ts
-var import_zod26 = require("zod");
+var import_zod31 = require("zod");
 var unwrapZodType = /* @__PURE__ */ __name((type) => {
-  if (type instanceof import_zod26.ZodOptional || type instanceof import_zod26.ZodNullable) {
+  if (type instanceof import_zod31.ZodOptional || type instanceof import_zod31.ZodNullable) {
     return unwrapZodType(type.unwrap());
   }
   return type;
@@ -6003,7 +6997,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_zod26.ZodArray ? "oneToMany" : "manyToOne";
+  return inner instanceof import_zod31.ZodArray ? "oneToMany" : "manyToOne";
 }, "deriveRelationType");
 var deriveRelationTypeFromColumns = /* @__PURE__ */ __name((col, cols) => {
   const base = col.column ?? col.id;
@@ -6035,7 +7029,7 @@ var enrichRelationTypes = /* @__PURE__ */ __name((columns, schema) => {
 
 // src/lib/crud/resource/ReadResourceJson.ts
 var import_node_fs6 = require("fs");
-var import_node_path14 = require("path");
+var import_node_path15 = require("path");
 var readResourceJson = /* @__PURE__ */ __name((jsonPath) => {
   if (!(0, import_node_fs6.existsSync)(jsonPath)) return void 0;
   let fileContent;
@@ -6058,30 +7052,62 @@ var readResourceJson = /* @__PURE__ */ __name((jsonPath) => {
     success: true,
     data: {
       json: resource.data,
-      dir: (0, import_node_path14.dirname)(jsonPath)
+      dir: (0, import_node_path15.dirname)(jsonPath)
     }
   };
 }, "readResourceJson");
 
 // src/lib/crud/adapter/resource-resolver.ts
 var import_node_fs7 = require("fs");
-var import_node_path15 = require("path");
-var unwrap2 = /* @__PURE__ */ __name((result) => {
-  if (result?.success) return result.data;
-  return void 0;
-}, "unwrap");
-var resolveChildResource = /* @__PURE__ */ __name((resourcePath, parentDir) => {
-  const directPath = (0, import_node_path15.resolve)(parentDir, resourcePath);
+var import_node_path16 = require("path");
+var resolveChildResourceDetailed = /* @__PURE__ */ __name((resourcePath, parentDir) => {
+  const attempted = [];
   try {
-    if (resourcePath.endsWith(".json") && (0, import_node_fs7.existsSync)(directPath)) {
-      return unwrap2(readResourceJson(directPath));
+    if (resourcePath.endsWith(".json")) {
+      const directPath = (0, import_node_path16.resolve)(parentDir, resourcePath);
+      attempted.push(directPath);
+      if ((0, import_node_fs7.existsSync)(directPath)) {
+        const result2 = readResourceJson(directPath);
+        if (result2?.success) return {
+          ok: true,
+          value: result2.data
+        };
+        return {
+          ok: false,
+          reason: "invalid",
+          error: result2?.error ?? `Could not read ${directPath}`
+        };
+      }
     }
     const childName = resourcePath.replace(/^\.\//, "").replace(/\.resource$/, "");
-    const childJsonPath = (0, import_node_path15.resolve)((0, import_node_path15.dirname)(parentDir), childName, "resource.json");
-    return unwrap2(readResourceJson(childJsonPath));
-  } catch {
-    return void 0;
+    const childJsonPath = (0, import_node_path16.resolve)((0, import_node_path16.dirname)(parentDir), childName, "resource.json");
+    attempted.push(childJsonPath);
+    const result = readResourceJson(childJsonPath);
+    if (result?.success) return {
+      ok: true,
+      value: result.data
+    };
+    if (result) return {
+      ok: false,
+      reason: "invalid",
+      error: result.error
+    };
+    return {
+      ok: false,
+      reason: "missing",
+      attempted
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      reason: "invalid",
+      error: err.message
+    };
   }
+}, "resolveChildResourceDetailed");
+var resolveChildResource = /* @__PURE__ */ __name((resourcePath, parentDir) => {
+  const resolution = resolveChildResourceDetailed(resourcePath, parentDir);
+  return resolution.ok ? resolution.value : void 0;
 }, "resolveChildResource");
 
 // src/lib/crud/adapter/column-enrichment.ts
@@ -6261,18 +7287,44 @@ var resolveColumnFieldVariants = /* @__PURE__ */ __name((cols) => cols?.map((col
 }), "resolveColumnFieldVariants");
 
 // src/lib/crud/adapter/sub-resource.builder.ts
+var REMOTE_RESOURCE = /^https?:\/\//i;
 var buildSubResources = /* @__PURE__ */ __name((columns, parentRoute, parentModel, parentDir, enums = {}, baseUrl) => {
   if (!columns || !parentDir) return [];
-  return columns.filter((c) => c.fieldInput?.format === "relation" && c.fieldInput?.resource).map((c) => {
-    const childResolved = resolveChildResource(c.fieldInput.resource, parentDir);
-    const childJson = childResolved?.json;
-    const childDir = childResolved?.dir;
-    const childRoute = childJson?.route ?? c.fieldInput.resource.replace(/^\.\.?\//, "").replace(/\/resource\.json$/, "").replace(/\.resource$/, "");
+  return columns.filter((c) => c.fieldInput?.format === "relation" && c.fieldInput?.resource).flatMap((c) => {
+    const resourcePath = c.fieldInput.resource;
+    if (REMOTE_RESOURCE.test(resourcePath)) return [];
+    const resolution = resolveChildResourceDetailed(resourcePath, parentDir);
+    if (!resolution.ok) {
+      resourceLoadErrorsRegistry.record({
+        name: parentRoute,
+        path: resourcePath,
+        error: resolution.reason === "missing" ? `Relation column "${c.id}" points at "${resourcePath}", but no resource.json was found there (looked in: ${resolution.attempted.join(", ")}). Sub-resource routes for it were not registered.` : `Relation column "${c.id}" points at "${resourcePath}", which could not be read: ${resolution.error} Sub-resource routes for it were not registered.`
+      });
+      return [];
+    }
+    const childJson = resolution.value.json;
+    const childDir = resolution.value.dir;
+    if (childJson.parent) {
+      resourceLoadErrorsRegistry.record({
+        name: parentRoute,
+        path: resourcePath,
+        error: `Relation column "${c.id}" declares "${childJson.name}" as a sub-resource, but that resource also declares "parent": { "route": "${childJson.parent.route}" }. The two ways of nesting are mutually exclusive \u2014 remove the "parent" block to embed it in this resource, or remove this relation column to keep its own nested controller. Sub-resource routes for it were not registered.`
+      });
+      return [];
+    }
+    const childRoute = childJson.route ?? resourcePath.replace(/^\.\.?\//, "").replace(/\/resource\.json$/, "").replace(/\.resource$/, "");
     const rawChildColumns = childJson?.columns;
     const expandedChildColumns = rawChildColumns ? expandExtendColumns(rawChildColumns, childDir) : void 0;
     const childColumns = applyRelationFormatDefault(expandedChildColumns) ?? expandedChildColumns;
     injectEnumValues(childColumns, enums);
     const enrichedChildColumns = enrichNestedRelationColumns(childColumns, childDir, baseUrl);
+    const autoIncludes = (enrichedChildColumns ?? []).filter((col) => col.fieldInput?.format === "relation" && (col.fieldInput.relationType ?? deriveRelationTypeFromColumns(col, enrichedChildColumns)) === "manyToOne").map((col) => col.fieldInput?.relation ?? col.id);
+    const explicitIncludes = childJson?.include ?? [];
+    const explicitNames = new Set(explicitIncludes.map((e) => typeof e === "string" ? e : e.relation));
+    const mergedIncludes = [
+      ...explicitIncludes,
+      ...autoIncludes.filter((name) => !explicitNames.has(name))
+    ];
     const childLookupKey = childColumns?.find((col) => col.idField)?.id ?? "id";
     const childCalculatedColumns = childJson?.calculatedColumns ?? [];
     let childViews = childJson ? buildViewsFromColumns(enrichedChildColumns) : void 0;
@@ -6289,16 +7341,27 @@ var buildSubResources = /* @__PURE__ */ __name((columns, parentRoute, parentMode
       }
     }
     const childOps = childJson?.operations ?? {};
+    const childKind = childJson?.kind === "custom" ? "custom" : "prisma";
     return {
       column: c.id,
       relation: c.fieldInput?.relation ?? c.id,
       childRoute,
-      childModel: c.id,
+      childKind,
+      ...childDir && {
+        childDir
+      },
+      // A custom child has no Prisma model. Leave it empty rather than
+      // falling back to the column id, which would produce a bogus
+      // `prisma[<column>]` lookup at query time.
+      childModel: childKind === "custom" ? "" : c.id,
       foreignKey: c.fieldInput?.foreignKey ?? `${parentModel}Id`,
       name: childJson?.name ?? childRoute,
       title: childJson?.title ?? childJson?.tag ?? childRoute,
       idField: childLookupKey,
       idType: childJson?.idType ?? "string",
+      ...c.hiddenInTable && {
+        hiddenInTable: true
+      },
       ...childViews && {
         views: childViews
       },
@@ -6317,8 +7380,8 @@ var buildSubResources = /* @__PURE__ */ __name((columns, parentRoute, parentMode
       ...childJson?.modalSize && {
         modalSize: childJson.modalSize
       },
-      ...childJson?.include?.length && {
-        include: childJson.include
+      ...mergedIncludes.length && {
+        include: mergedIncludes
       },
       ...childJson?.calculatedColumns?.length && {
         calculatedColumns: childJson.calculatedColumns
@@ -6342,17 +7405,18 @@ var buildSubResources = /* @__PURE__ */ __name((columns, parentRoute, parentMode
 }, "buildSubResources");
 
 // src/lib/crud/adapter/json-adapter.ts
-var fromJson = /* @__PURE__ */ __name((json, schema, hooks, dirPath, baseUrl, actions, tableActions, enums = {}) => {
+var fromJson = /* @__PURE__ */ __name((json, schema, hooks, dirPath, baseUrl, actions, tableActions, enums = {}, repository) => {
+  const isCustom = json.kind === "custom";
   const rawColumns = expandExtendColumns(json.columns, dirPath);
   const columns = enrichRelationTypes(applyRelationFormatDefault(rawColumns) ?? rawColumns, schema);
   injectEnumValues(columns, enums);
-  const subResources = buildSubResources(columns, json.route, json.model, dirPath, enums, baseUrl);
+  const subResources = isCustom ? [] : buildSubResources(columns, json.route, json.model ?? "", dirPath, enums, baseUrl);
   const enrichedColumns = resolveColumnFieldVariants(enrichResourceRefColumns(enrichActionColumns(columns, json.route, subResources, baseUrl), dirPath, baseUrl) ?? columns);
   const calculatedColumns = json.calculatedColumns ?? [];
   const picked = pickByColumns(schema, enrichedColumns);
   const createSchema = pickByColumns(schema, enrichedColumns, (c) => !c.idField && c.createable !== false);
   const updateSchema = pickByColumns(schema, enrichedColumns, (c) => !c.idField && c.updateable !== false);
-  let views = buildViews(schema, enrichedColumns);
+  let views = isCustom ? buildViewsFromColumnTypes(enrichedColumns) : buildViews(schema, enrichedColumns);
   if (views && calculatedColumns.length) {
     views = {
       ...views,
@@ -6410,6 +7474,9 @@ var fromJson = /* @__PURE__ */ __name((json, schema, hooks, dirPath, baseUrl, ac
     ...hooks && {
       hooks
     },
+    ...repository && {
+      repository
+    },
     definition,
     ...views && {
       views
@@ -6453,40 +7520,6 @@ var buildLookup = /* @__PURE__ */ __name((columns) => {
   };
 }, "buildLookup");
 
-// src/lib/crud/hooks/hooks.types.ts
-var import_zod27 = require("zod");
-var WriteOpSchema = import_zod27.z.enum([
-  "create",
-  "update",
-  "patch",
-  "upsert",
-  "delete"
-]);
-var ReadOpSchema = import_zod27.z.enum([
-  "findAll",
-  "findOne"
-]);
-var ResourceHooksSchema = import_zod27.z.object({
-  beforeWrite: import_zod27.z.custom().optional(),
-  afterWrite: import_zod27.z.custom().optional(),
-  afterRead: import_zod27.z.custom().optional()
-});
-
-// src/lib/crud/hooks/hooks.loader.ts
-var import_node_path16 = require("path");
-var loadResourceHooks = /* @__PURE__ */ __name(async (basePath) => {
-  const file = findModule(basePath, "hooks");
-  return file ? importDefault(file) : void 0;
-}, "loadResourceHooks");
-var loadSubResourceHooks = /* @__PURE__ */ __name(async (subResources, basePath) => {
-  for (const sub of subResources) {
-    const file = sub.name ? findModule((0, import_node_path16.join)(basePath, "hooks"), sub.name) : void 0;
-    if (!file) continue;
-    const hooks = await importDefault(file);
-    if (hooks) sub.hooks = hooks;
-  }
-}, "loadSubResourceHooks");
-
 // src/lib/crud/resource/MigrateResourceJson.ts
 var import_node_fs8 = require("fs");
 var migrateResourceJsonFile = /* @__PURE__ */ __name((jsonPath, opts) => {
@@ -6609,10 +7642,12 @@ var loadResourceConfigsFromDir = /* @__PURE__ */ __name(async (dirPath, baseUrl,
         });
         continue;
       }
+      const repository = json.kind === "custom" ? await loadCustomRepository(basePath, json.name) : void 0;
       const actions = await loadActions(json.actions ?? [], basePath, "row");
       const tableActions = await loadActions(json.tableActions ?? [], basePath, "table");
-      const config = fromJson(json, schema, hooks, basePath, baseUrl, actions, tableActions, enums);
+      const config = fromJson(json, schema, hooks, basePath, baseUrl, actions, tableActions, enums, repository);
       await loadSubResourceHooks(config.subResources ?? [], basePath);
+      await loadSubResourceRepositories(config.subResources ?? [], config.name);
       onResourceDir?.(config.route, basePath);
       configs.push(config);
       continue;
@@ -6736,6 +7771,13 @@ var getResourceStatus = /* @__PURE__ */ __name((loadedConfigs) => {
     path: c.route,
     valid: true,
     version: c.schemaVersion ?? CURRENT_RESOURCE_VERSION,
+    kind: c.kind ?? "prisma",
+    // Which operations the user's repository.ts actually implements. A resource
+    // only reaches this list after validateCustomRepository passed, so this is
+    // informational rather than a warning.
+    ...c.kind === "custom" && c.repository ? {
+      customOperations: CUSTOM_OPS.filter((op) => typeof c.repository?.[op] === "function")
+    } : {},
     ...c.sidebar?.hide ? {
       hidden: true
     } : {}
@@ -6893,7 +7935,7 @@ var buildStatus = /* @__PURE__ */ __name(async (registry, loadedConfigs, enumReg
 }, "buildStatus");
 
 // src/lib/crud/status/status.controller.ts
-var import_common18 = require("@nestjs/common");
+var import_common20 = require("@nestjs/common");
 var import_swagger13 = require("@nestjs/swagger");
 function _ts_decorate6(decorators, target, key, desc2) {
   var c = arguments.length, r = c < 3 ? target : desc2 === null ? desc2 = Object.getOwnPropertyDescriptor(target, key) : desc2, d;
@@ -6923,7 +7965,7 @@ var createStatusController = /* @__PURE__ */ __name((enumRegistry) => {
     }
   };
   _ts_decorate6([
-    (0, import_common18.Get)("status.json"),
+    (0, import_common20.Get)("status.json"),
     (0, import_swagger13.ApiOperation)({
       summary: "Crouton system status (db, resources, version)"
     }),
@@ -6936,7 +7978,7 @@ var createStatusController = /* @__PURE__ */ __name((enumRegistry) => {
     _ts_metadata5("design:returntype", Promise)
   ], StatusController.prototype, "getStatus", null);
   StatusController = _ts_decorate6([
-    (0, import_common18.Controller)("crouton"),
+    (0, import_common20.Controller)("crouton"),
     (0, import_swagger13.ApiTags)("Status"),
     _ts_metadata5("design:type", Function),
     _ts_metadata5("design:paramtypes", [
@@ -6978,9 +8020,34 @@ var CroutonApiModule = class _CroutonApiModule {
     const enumRegistry = loadEnumRegistry(startDir, config.enumsFile);
     const validConfigs = [];
     for (const c of configs) {
+      if (c.kind === "custom") {
+        if (c.database) {
+          try {
+            dataSourceRegistry.resolve(c.database);
+          } catch (e) {
+            resourceLoadErrorsRegistry.record({
+              name: c.name,
+              path: c.route,
+              error: e.message ?? String(e)
+            });
+            continue;
+          }
+        }
+        const problem = validateCustomRepository(c, c.repository);
+        if (problem) {
+          resourceLoadErrorsRegistry.record({
+            name: c.name,
+            path: c.route,
+            error: problem
+          });
+          continue;
+        }
+        validConfigs.push(c);
+        continue;
+      }
       try {
         const prisma = dataSourceRegistry.resolve(c.database);
-        if (!prisma[c.model]) {
+        if (!c.model || !prisma[c.model]) {
           resourceLoadErrorsRegistry.record({
             name: c.name,
             path: c.route,
@@ -7043,7 +8110,7 @@ var CroutonApiModule = class _CroutonApiModule {
   }
 };
 CroutonApiModule = _ts_decorate7([
-  (0, import_common19.Module)({
+  (0, import_common21.Module)({
     controllers: [],
     providers: [],
     exports: []
@@ -7054,14 +8121,25 @@ CroutonApiModule = _ts_decorate7([
   CroutonApiModule,
   DataSourceRegistry,
   FileSystemResourceConfigLoader,
+  ReadOpSchema,
   ResourceConfigLoader,
   ResourceConfigRegistry,
+  ResourceHooksSchema,
+  WriteOpSchema,
+  buildFilterWhere,
   buildViews,
+  decorateRow,
+  decorateRows,
   isOperationEnabled,
   isRowProcedureAction,
   isTableProcedureAction,
   loadDataSourcesFromDir,
   loadResourceConfigsFromDir,
+  loadResourceHooks,
+  loadSubResourceHooks,
+  parseFilterString,
+  postWrite,
+  prepareWrite,
   resolveDefinition,
   schemaFor,
   upsertOnFor