@ghentcdh/crouton-api 0.0.1-alpha.50 → 0.0.1-alpha.52

package/dist/index.cjs

@@ -672,228 +672,105 @@ var init_table_utils = __esm({
   }
 });
 
-// ../crouton-core/src/lib/data-source/DataSourceSchema.ts
-var import_zod7, DataSourceShape, transformDataSource, DataSourceSchema;
-var init_DataSourceSchema = __esm({
-  "../crouton-core/src/lib/data-source/DataSourceSchema.ts"() {
+// ../crouton-core/src/lib/compile/action.types.ts
+var import_zod7, ActionMetadataSchema, ResourceLinkActionSchema, ResourceRowProcedureActionSchema, ResourceTableProcedureActionSchema, ResourceRowActionSchema, ResourceTableActionSchema;
+var init_action_types = __esm({
+  "../crouton-core/src/lib/compile/action.types.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod7 = __toESM(require("zod"), 1);
-    DataSourceShape = import_zod7.default.object({
-      /** Datasource name (folder + `name` in data-source.json). */
-      name: import_zod7.default.string(),
-      /**
-      * Env var holding the connection URL. Required for Prisma adapters; optional
-      * for custom adapters whose connection config may differ (secrets file, SDK
-      * key, etc.).
-      */
-      urlEnv: import_zod7.default.string().optional(),
-      /** Import path for this datasource's generated Zod types (for resource `schema.ts`). */
-      generatedTypesImport: import_zod7.default.string().optional(),
-      /** Datasource type tag. Default `postgres`. */
-      type: import_zod7.default.string().default("postgres"),
-      /** Mark this as the default datasource. Default `false`. */
-      default: import_zod7.default.boolean().default(false),
-      /**
-      * Adapter kind. `"prisma"` (default) expects `index.ts` to default-export a
-      * `PrismaClient`; `"custom"` expects it to default-export a `DataSourceAdapter`.
-      */
-      adapter: import_zod7.default.enum([
-        "prisma",
-        "custom"
-      ]).default("prisma"),
-      /** Prisma schema path, relative to project root. Default `prisma/<name>/schema.prisma`. */
-      prismaSchema: import_zod7.default.string().optional(),
-      /** Prisma config path, relative to project root. Default `prisma/<name>/prisma.config.ts`. */
-      prismaConfig: import_zod7.default.string().optional(),
-      /** zod-prisma-types output dir, relative to project root. Default `generated/<name>/src`. */
-      zodOutput: import_zod7.default.string().optional(),
-      /** Prisma client output dir, relative to project root. Default `generated/<name>/client`. */
-      clientOutput: import_zod7.default.string().optional()
+    import_zod7 = require("zod");
+    ActionMetadataSchema = import_zod7.z.object({
+      id: import_zod7.z.string(),
+      label: import_zod7.z.string().optional(),
+      icon: import_zod7.z.string().optional(),
+      tooltip: import_zod7.z.string().optional(),
+      condition: import_zod7.z.custom().optional()
     });
-    transformDataSource = /* @__PURE__ */ __name((data) => {
-      const name = data.name ?? "name";
-      return {
-        ...data,
-        generatedTypesImport: data.generatedTypesImport ?? `@your-scope/generated/${name}`,
-        prismaSchema: data.prismaSchema ?? `prisma/${name}/schema.prisma`,
-        prismaConfig: data.prismaConfig ?? `prisma/${name}/prisma.config.ts`,
-        zodOutput: data.zodOutput ?? `generated/${name}/src`,
-        clientOutput: data.clientOutput ?? `generated/${name}/client`
-      };
-    }, "transformDataSource");
-    DataSourceSchema = DataSourceShape.transform(transformDataSource);
-  }
-});
-
-// ../crouton-core/src/lib/data-source/Security.schema.ts
-var import_zod8, SecuritySchema;
-var init_Security_schema = __esm({
-  "../crouton-core/src/lib/data-source/Security.schema.ts"() {
-    "use strict";
-    init_cjs_shims();
-    import_zod8 = require("zod");
-    SecuritySchema = import_zod8.z.union([
-      import_zod8.z.object({
-        public: import_zod8.z.literal(true)
-      }),
-      import_zod8.z.object({
-        guard: import_zod8.z.union([
-          import_zod8.z.string(),
-          import_zod8.z.array(import_zod8.z.string()).min(1)
-        ])
-      })
-    ]);
-  }
-});
-
-// ../crouton-core/src/lib/data-source/Operations.schema.ts
-var import_zod9, OpEntry, BoolOrUpsertSchema, JsonOperationsSchema, buildSubResourceOperations;
-var init_Operations_schema = __esm({
-  "../crouton-core/src/lib/data-source/Operations.schema.ts"() {
-    "use strict";
-    init_cjs_shims();
-    import_zod9 = require("zod");
-    init_Security_schema();
-    OpEntry = import_zod9.z.union([
-      import_zod9.z.boolean(),
-      import_zod9.z.object({
-        security: SecuritySchema.optional()
-      })
+    ResourceLinkActionSchema = ActionMetadataSchema.extend({
+      type: import_zod7.z.literal("link"),
+      href: import_zod7.z.string()
+    });
+    ResourceRowProcedureActionSchema = ActionMetadataSchema.extend({
+      type: import_zod7.z.literal("procedure").optional(),
+      method: import_zod7.z.string().optional(),
+      data: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown()).optional(),
+      procedure: import_zod7.z.custom((v) => typeof v === "function")
+    });
+    ResourceTableProcedureActionSchema = ActionMetadataSchema.extend({
+      type: import_zod7.z.literal("procedure").optional(),
+      method: import_zod7.z.string().optional(),
+      data: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown()).optional(),
+      procedure: import_zod7.z.custom((v) => typeof v === "function")
+    });
+    ResourceRowActionSchema = import_zod7.z.union([
+      ResourceRowProcedureActionSchema,
+      ResourceLinkActionSchema
     ]);
-    BoolOrUpsertSchema = import_zod9.z.union([
-      import_zod9.z.boolean(),
-      import_zod9.z.object({
-        upsertOn: import_zod9.z.union([
-          import_zod9.z.string(),
-          import_zod9.z.array(import_zod9.z.string())
-        ]),
-        security: SecuritySchema.optional()
-      })
+    ResourceTableActionSchema = import_zod7.z.union([
+      ResourceTableProcedureActionSchema,
+      ResourceLinkActionSchema
     ]);
-    JsonOperationsSchema = import_zod9.z.object({
-      findAll: OpEntry.default(true),
-      findOne: OpEntry.default(true),
-      create: OpEntry.default(true),
-      update: OpEntry.default(true),
-      patch: OpEntry.default(true),
-      upsert: BoolOrUpsertSchema.default(false),
-      delete: OpEntry.default(true)
-    });
-    buildSubResourceOperations = /* @__PURE__ */ __name((ops, baseUri, idField = "id") => {
-      if (!ops) return {};
-      const idPlaceholder = `{${idField}}`;
-      return {
-        ...ops.findAll && {
-          findAll: {
-            uri: baseUri,
-            method: "get"
-          }
-        },
-        ...ops.findOne && {
-          findOne: {
-            uri: `${baseUri}/${idPlaceholder}`,
-            method: "get"
-          }
-        },
-        ...ops.create && {
-          create: {
-            uri: baseUri,
-            method: "post"
-          }
-        },
-        ...ops.update && {
-          update: {
-            uri: `${baseUri}/${idPlaceholder}`,
-            method: "put"
-          }
-        },
-        ...ops.patch && {
-          patch: {
-            uri: `${baseUri}/${idPlaceholder}`,
-            method: "patch"
-          }
-        },
-        ...ops.delete && {
-          delete: {
-            uri: `${baseUri}/${idPlaceholder}`,
-            method: "delete"
-          }
-        }
-      };
-    }, "buildSubResourceOperations");
-  }
-});
-
-// ../crouton-core/src/lib/data-source/index.ts
-var init_data_source = __esm({
-  "../crouton-core/src/lib/data-source/index.ts"() {
-    "use strict";
-    init_cjs_shims();
-    init_DataSourceSchema();
-    init_Operations_schema();
-    init_Security_schema();
   }
 });
 
 // ../crouton-core/src/lib/resource/FieldInput.schema.ts
-var import_zod10, RelationType, DetailControlSchema, DetailConfigSchema, RelationFieldInputOptionsSchema, FieldInputSchema, FieldVariantSchema, stripNull, mergeFieldVariant;
+var import_zod8, RelationType, DetailControlSchema, DetailConfigSchema, RelationFieldInputOptionsSchema, FieldInputSchema, FieldVariantSchema, stripNull, mergeFieldVariant;
 var init_FieldInput_schema = __esm({
   "../crouton-core/src/lib/resource/FieldInput.schema.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod10 = require("zod");
-    RelationType = import_zod10.z.enum([
+    import_zod8 = require("zod");
+    RelationType = import_zod8.z.enum([
       "oneToOne",
       "manyToOne",
       "oneToMany",
       "manyToMany"
     ]);
-    DetailControlSchema = import_zod10.z.object({
-      property: import_zod10.z.string(),
-      type: import_zod10.z.string().optional(),
-      options: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.unknown()).optional(),
-      hideLabel: import_zod10.z.boolean().optional(),
-      width: import_zod10.z.string().optional()
+    DetailControlSchema = import_zod8.z.object({
+      property: import_zod8.z.string(),
+      type: import_zod8.z.string().optional(),
+      options: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown()).optional(),
+      hideLabel: import_zod8.z.boolean().optional(),
+      width: import_zod8.z.string().optional()
     });
-    DetailConfigSchema = import_zod10.z.object({
-      layout: import_zod10.z.enum([
+    DetailConfigSchema = import_zod8.z.object({
+      layout: import_zod8.z.enum([
         "collapse",
         "row"
       ]),
-      titleKey: import_zod10.z.string().optional(),
-      controls: import_zod10.z.array(DetailControlSchema)
+      titleKey: import_zod8.z.string().optional(),
+      controls: import_zod8.z.array(DetailControlSchema)
     });
-    RelationFieldInputOptionsSchema = import_zod10.z.object({
-      colspan: import_zod10.z.number().optional().default(12),
+    RelationFieldInputOptionsSchema = import_zod8.z.object({
+      colspan: import_zod8.z.number().optional().default(12),
       /** Field to sort related records by, e.g. `"title"` or `"author.name"`. */
-      sort: import_zod10.z.string().optional(),
+      sort: import_zod8.z.string().optional(),
       /** Sort direction. Defaults to `"asc"` when omitted. */
-      sortDir: import_zod10.z.enum([
+      sortDir: import_zod8.z.enum([
         "asc",
         "desc"
       ]).optional(),
       /** CSS flex direction for the relation control button layout. */
-      direction: import_zod10.z.string().optional(),
+      direction: import_zod8.z.string().optional(),
       /** Key used as the display label in the relation control. */
-      displayKey: import_zod10.z.string().optional(),
+      displayKey: import_zod8.z.string().optional(),
       /** Path to the related resource (resolved to a URI at load time). */
-      resource: import_zod10.z.string().optional()
-    }).catchall(import_zod10.z.unknown());
-    FieldInputSchema = import_zod10.z.object({
-      type: import_zod10.z.string().optional(),
-      customRender: import_zod10.z.string().optional(),
+      resource: import_zod8.z.string().optional()
+    }).catchall(import_zod8.z.unknown());
+    FieldInputSchema = import_zod8.z.object({
+      type: import_zod8.z.string().optional(),
+      customRender: import_zod8.z.string().optional(),
       /**
       * Render format hint for the frontend (e.g. `"relation"` for sub-resource
       * relations). When `format` is `"relation"`, `resource` must also be set.
       */
-      format: import_zod10.z.string().optional(),
+      format: import_zod8.z.string().optional(),
       /**
       * Relative path to the child resource definition, e.g. `"./author.resource"`.
       * Only used when `format` is `"relation"`. Resolved at load time to inject
       * sub-resource URIs into `options`.
       */
-      resource: import_zod10.z.string().optional(),
+      resource: import_zod8.z.string().optional(),
       /**
       * Cardinality of the relation. Used by the frontend to determine the correct
       * renderer and behaviour (e.g. single-select vs multi-select).
@@ -902,11 +779,11 @@ var init_FieldInput_schema = __esm({
       */
       relationType: RelationType.optional(),
       /** FK field on the child model pointing back to the parent, e.g. `"workId"`. Defaults to `${parentModel}Id`. */
-      foreignKey: import_zod10.z.string().optional(),
+      foreignKey: import_zod8.z.string().optional(),
       /** Override the Prisma relation field name when it differs from the column id. */
-      relation: import_zod10.z.string().optional(),
+      relation: import_zod8.z.string().optional(),
       /** Override the display order in form views. Lower values come first. */
-      position: import_zod10.z.number().optional(),
+      position: import_zod8.z.number().optional(),
       /**
       * Value to pre-fill this field with on the create form. Injected into the
       * generated form view's JSON Schema as `properties[id].default`, which
@@ -914,10 +791,10 @@ var init_FieldInput_schema = __esm({
       * opening a blank record. Not applicable to `format: "relation"` fields —
       * relation columns are excluded from the picked data schema entirely.
       */
-      defaultValue: import_zod10.z.unknown().optional(),
-      options: import_zod10.z.union([
+      defaultValue: import_zod8.z.unknown().optional(),
+      options: import_zod8.z.union([
         RelationFieldInputOptionsSchema,
-        import_zod10.z.unknown()
+        import_zod8.z.unknown()
       ]).optional(),
       /** Nested array detail layout (renders via `detailFixed`). */
       detail: DetailConfigSchema.optional()
@@ -967,24 +844,24 @@ var init_label_helper = __esm({
 });
 
 // ../crouton-core/src/lib/resource/CalculatedColumn.schema.ts
-var import_zod11, CalculatedColumnSchema;
+var import_zod9, CalculatedColumnSchema;
 var init_CalculatedColumn_schema = __esm({
   "../crouton-core/src/lib/resource/CalculatedColumn.schema.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod11 = require("zod");
+    import_zod9 = require("zod");
     init_FieldInput_schema();
     init_label_helper();
-    CalculatedColumnSchema = import_zod11.z.object({
+    CalculatedColumnSchema = import_zod9.z.object({
       /** Column identifier used in the response payload and UI schema. */
-      id: import_zod11.z.string(),
+      id: import_zod9.z.string(),
       /** SQL alias — must match `id`. */
-      alias: import_zod11.z.string(),
+      alias: import_zod9.z.string(),
       /** Human-readable label shown in the table header. */
-      label: import_zod11.z.string().optional(),
-      sqlExpression: import_zod11.z.string(),
+      label: import_zod9.z.string().optional(),
+      sqlExpression: import_zod9.z.string(),
       /** JSON schema / cast type for the computed value. Defaults to `"number"`. `"string"` skips CAST. */
-      type: import_zod11.z.enum([
+      type: import_zod9.z.enum([
         "number",
         "boolean",
         "string"
@@ -995,9 +872,9 @@ var init_CalculatedColumn_schema = __esm({
        * `position: N` places this column before the element currently at index N.
        * Can also be set via `fieldInput.position` (takes precedence).
        */
-      position: import_zod11.z.number().optional(),
-      hiddenInTable: import_zod11.z.boolean().optional(),
-      hiddenInView: import_zod11.z.boolean().optional(),
+      position: import_zod9.z.number().optional(),
+      hiddenInTable: import_zod9.z.boolean().optional(),
+      hiddenInView: import_zod9.z.boolean().optional(),
       /**
        * Field input options for rendering in form / view schemas.
        * Supports `colspan`, `format`, and any other options passed to the Control renderer.
@@ -1009,13 +886,13 @@ var init_CalculatedColumn_schema = __esm({
 });
 
 // ../crouton-core/src/lib/resource/ColumnType.schema.ts
-var import_zod12, ColumnTypeShorthandSchema, JsonSchemaFragmentSchema, ColumnTypeSchema, SHORTHAND_FRAGMENTS, isShorthand, NESTED_SHORTHANDS, normalizeFragment, columnTypeToJsonSchema, columnTypeName, isObjectColumnType, isArrayColumnType;
+var import_zod10, ColumnTypeShorthandSchema, JsonSchemaFragmentSchema, ColumnTypeSchema, SHORTHAND_FRAGMENTS, isShorthand, NESTED_SHORTHANDS, normalizeFragment, columnTypeToJsonSchema, columnTypeName, isObjectColumnType, isArrayColumnType;
 var init_ColumnType_schema = __esm({
   "../crouton-core/src/lib/resource/ColumnType.schema.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod12 = require("zod");
-    ColumnTypeShorthandSchema = import_zod12.z.enum([
+    import_zod10 = require("zod");
+    ColumnTypeShorthandSchema = import_zod10.z.enum([
       "string",
       "number",
       "integer",
@@ -1025,32 +902,32 @@ var init_ColumnType_schema = __esm({
       "object",
       "array"
     ]);
-    JsonSchemaFragmentSchema = import_zod12.z.lazy(() => import_zod12.z.object({
-      type: import_zod12.z.union([
-        import_zod12.z.string(),
-        import_zod12.z.array(import_zod12.z.string())
+    JsonSchemaFragmentSchema = import_zod10.z.lazy(() => import_zod10.z.object({
+      type: import_zod10.z.union([
+        import_zod10.z.string(),
+        import_zod10.z.array(import_zod10.z.string())
       ]).optional(),
-      format: import_zod12.z.string().optional(),
-      enum: import_zod12.z.array(import_zod12.z.unknown()).optional(),
-      const: import_zod12.z.unknown().optional(),
-      nullable: import_zod12.z.boolean().optional(),
-      properties: import_zod12.z.record(import_zod12.z.string(), JsonSchemaFragmentSchema).optional(),
-      required: import_zod12.z.array(import_zod12.z.string()).optional(),
+      format: import_zod10.z.string().optional(),
+      enum: import_zod10.z.array(import_zod10.z.unknown()).optional(),
+      const: import_zod10.z.unknown().optional(),
+      nullable: import_zod10.z.boolean().optional(),
+      properties: import_zod10.z.record(import_zod10.z.string(), JsonSchemaFragmentSchema).optional(),
+      required: import_zod10.z.array(import_zod10.z.string()).optional(),
       items: JsonSchemaFragmentSchema.optional(),
-      additionalProperties: import_zod12.z.union([
-        import_zod12.z.boolean(),
+      additionalProperties: import_zod10.z.union([
+        import_zod10.z.boolean(),
         JsonSchemaFragmentSchema
       ]).optional(),
-      title: import_zod12.z.string().optional(),
-      description: import_zod12.z.string().optional(),
-      default: import_zod12.z.unknown().optional(),
-      minimum: import_zod12.z.number().optional(),
-      maximum: import_zod12.z.number().optional(),
-      minLength: import_zod12.z.number().optional(),
-      maxLength: import_zod12.z.number().optional(),
-      pattern: import_zod12.z.string().optional()
-    }).catchall(import_zod12.z.unknown()));
-    ColumnTypeSchema = import_zod12.z.union([
+      title: import_zod10.z.string().optional(),
+      description: import_zod10.z.string().optional(),
+      default: import_zod10.z.unknown().optional(),
+      minimum: import_zod10.z.number().optional(),
+      maximum: import_zod10.z.number().optional(),
+      minLength: import_zod10.z.number().optional(),
+      maxLength: import_zod10.z.number().optional(),
+      pattern: import_zod10.z.string().optional()
+    }).catchall(import_zod10.z.unknown()));
+    ColumnTypeSchema = import_zod10.z.union([
       ColumnTypeShorthandSchema,
       JsonSchemaFragmentSchema
     ]);
@@ -1134,48 +1011,48 @@ var init_ColumnType_schema = __esm({
 });
 
 // ../crouton-core/src/lib/resource/Column.ts
-var import_zod13, WhenConditionSchema, JsonColumnSchema;
+var import_zod11, WhenConditionSchema, JsonColumnSchema;
 var init_Column = __esm({
   "../crouton-core/src/lib/resource/Column.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod13 = require("zod");
+    import_zod11 = require("zod");
     init_ColumnType_schema();
     init_FieldInput_schema();
-    WhenConditionSchema = import_zod13.z.object({
-      field: import_zod13.z.string(),
-      eq: import_zod13.z.unknown().optional(),
-      neq: import_zod13.z.unknown().optional(),
-      exists: import_zod13.z.boolean().optional(),
-      notExists: import_zod13.z.boolean().optional()
+    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()
     });
-    JsonColumnSchema = import_zod13.z.object({
-      id: import_zod13.z.string(),
-      column: import_zod13.z.string().optional(),
-      label: import_zod13.z.string().optional(),
-      hiddenInTable: import_zod13.z.boolean().default(false),
-      hiddenInForm: import_zod13.z.boolean().default(false),
-      hiddenInView: import_zod13.z.boolean().default(false),
-      sortable: import_zod13.z.boolean().default(false),
-      defaultSort: import_zod13.z.boolean().default(false),
-      searchable: import_zod13.z.boolean().default(false),
-      filterable: import_zod13.z.boolean().default(false),
-      createable: import_zod13.z.boolean().default(true),
-      updateable: import_zod13.z.boolean().default(true),
-      hideLabel: import_zod13.z.boolean().default(false),
+    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),
       showWhen: WhenConditionSchema.optional(),
       hideWhen: WhenConditionSchema.optional(),
       disabledWhen: WhenConditionSchema.optional(),
-      displayKey: import_zod13.z.string().optional(),
-      sortId: import_zod13.z.string().optional(),
+      displayKey: import_zod11.z.string().optional(),
+      sortId: import_zod11.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_zod13.z.string().optional(),
-      idField: import_zod13.z.boolean().default(false),
-      showInLookup: import_zod13.z.boolean().default(false),
+      enum: import_zod11.z.string().optional(),
+      idField: import_zod11.z.boolean().default(false),
+      showInLookup: import_zod11.z.boolean().default(false),
       /**
       * Data type of the column, as a shorthand name (`"string"`, `"integer"`, …)
       * or a full JSON Schema fragment:
@@ -1206,12 +1083,12 @@ var init_Column = __esm({
       * 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_zod13.z.boolean().optional(),
+      required: import_zod11.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_zod13.z.string().default("string"),
+      columnType: import_zod11.z.string().default("string"),
       fieldInput: FieldInputSchema.optional(),
       /**
       * Optional per-context override for the read-only VIEW ui. Same shape as
@@ -1235,34 +1112,34 @@ var init_Column = __esm({
       * 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_zod13.z.string().optional(),
+      extend: import_zod11.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_zod13.z.record(import_zod13.z.string(), import_zod13.z.record(import_zod13.z.string(), import_zod13.z.unknown())).optional()
+      columns: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.record(import_zod11.z.string(), import_zod11.z.unknown())).optional()
     });
   }
 });
 
 // ../crouton-core/src/lib/resource/ParentRef.schema.ts
-var import_zod14, ParentRefSchema, resourceControllerPath;
+var import_zod12, ParentRefSchema, resourceControllerPath;
 var init_ParentRef_schema = __esm({
   "../crouton-core/src/lib/resource/ParentRef.schema.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod14 = require("zod");
-    ParentRefSchema = import_zod14.z.object({
+    import_zod12 = require("zod");
+    ParentRefSchema = import_zod12.z.object({
       /** Route segment of the parent, e.g. `"group"`. */
-      route: import_zod14.z.string(),
+      route: import_zod12.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_zod14.z.string().default("parentId"),
+      param: import_zod12.z.string().default("parentId"),
       /** Type of the parent id, used to coerce the path param. Defaults to `'string'`. */
-      idType: import_zod14.z.enum([
+      idType: import_zod12.z.enum([
         "string",
         "number"
       ]).optional()
@@ -1272,13 +1149,13 @@ var init_ParentRef_schema = __esm({
 });
 
 // ../crouton-core/src/lib/resource/ResourceKind.ts
-var import_zod15, ResourceKindSchema;
+var import_zod13, ResourceKindSchema;
 var init_ResourceKind = __esm({
   "../crouton-core/src/lib/resource/ResourceKind.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod15 = require("zod");
-    ResourceKindSchema = import_zod15.z.enum([
+    import_zod13 = require("zod");
+    ResourceKindSchema = import_zod13.z.enum([
       "prisma",
       "custom"
     ]).default("prisma");
@@ -1286,42 +1163,42 @@ var init_ResourceKind = __esm({
 });
 
 // ../crouton-core/src/lib/resource/Sidebar.schema.ts
-var import_zod16, SidebarGroupSchema, SidebarSchema;
+var import_zod14, SidebarGroupSchema, SidebarSchema;
 var init_Sidebar_schema = __esm({
   "../crouton-core/src/lib/resource/Sidebar.schema.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod16 = __toESM(require("zod"), 1);
-    SidebarGroupSchema = import_zod16.default.object({
+    import_zod14 = __toESM(require("zod"), 1);
+    SidebarGroupSchema = import_zod14.default.object({
       /** Human-readable heading shown in the sidebar. Defaults to a title-cased version of the slug. */
-      label: import_zod16.default.string().optional(),
+      label: import_zod14.default.string().optional(),
       /** Controls the order of this group among top-level sidebar items. */
-      position: import_zod16.default.number().optional()
+      position: import_zod14.default.number().optional()
     });
-    SidebarSchema = import_zod16.default.object({
-      hide: import_zod16.default.boolean().default(false),
-      position: import_zod16.default.number().optional(),
-      label: import_zod16.default.string().optional(),
+    SidebarSchema = import_zod14.default.object({
+      hide: import_zod14.default.boolean().default(false),
+      position: import_zod14.default.number().optional(),
+      label: import_zod14.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_zod16.default.string().optional()
+      group: import_zod14.default.string().optional()
     });
   }
 });
 
 // ../crouton-core/src/lib/resource/TableAction.schema.ts
-var import_zod17, ActionConditionSchema, ActionSchema, JsonProcedureActionSchema, JsonLinkActionSchema, transformAction, JsonActionSchema;
+var import_zod15, ActionConditionSchema, ActionSchema, JsonProcedureActionSchema, JsonLinkActionSchema, transformAction, JsonActionSchema;
 var init_TableAction_schema = __esm({
   "../crouton-core/src/lib/resource/TableAction.schema.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod17 = require("zod");
-    ActionConditionSchema = import_zod17.z.object({
+    import_zod15 = require("zod");
+    ActionConditionSchema = import_zod15.z.object({
       /** Row field to evaluate. */
-      field: import_zod17.z.string(),
+      field: import_zod15.z.string(),
       /**
       * Comparison operator. Defaults to `"eq"`.
       * - `eq` / `neq`         — strict equality
@@ -1329,7 +1206,7 @@ var init_TableAction_schema = __esm({
       * - `exists`             — field is not null / undefined / empty string
       * - `notExists`          — field is null / undefined / empty string
       */
-      op: import_zod17.z.enum([
+      op: import_zod15.z.enum([
         "eq",
         "neq",
         "gt",
@@ -1340,38 +1217,38 @@ var init_TableAction_schema = __esm({
         "notExists"
       ]).default("eq"),
       /** Comparison value. Not required for `exists` / `notExists`. */
-      value: import_zod17.z.unknown().optional()
+      value: import_zod15.z.unknown().optional()
     });
-    ActionSchema = import_zod17.z.object({
-      type: import_zod17.z.string(),
+    ActionSchema = import_zod15.z.object({
+      type: import_zod15.z.string(),
       /** Unique identifier for the action. */
-      id: import_zod17.z.string(),
+      id: import_zod15.z.string(),
       /** Human-readable button label. */
-      label: import_zod17.z.string(),
+      label: import_zod15.z.string(),
       /** MDI icon name, e.g. `"mdi:open-in-new"`. */
-      icon: import_zod17.z.string().optional(),
+      icon: import_zod15.z.string().optional(),
       /** Tooltip text. Falls back to `label` when omitted. */
-      tooltip: import_zod17.z.string().optional(),
+      tooltip: import_zod15.z.string().optional(),
       condition: ActionConditionSchema.optional()
     });
     JsonProcedureActionSchema = ActionSchema.extend({
-      type: import_zod17.z.literal("procedure").default("procedure"),
+      type: import_zod15.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_zod17.z.string(),
+      procedure: import_zod15.z.string(),
       /** HTTP method for the frontend. Defaults to `"post"`. */
-      method: import_zod17.z.string().optional().default("post"),
+      method: import_zod15.z.string().optional().default("post"),
       /** Static query / body params passed to the endpoint. */
-      data: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.unknown()).optional()
+      data: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.unknown()).optional()
     });
     JsonLinkActionSchema = ActionSchema.extend({
       /** Optional condition evaluated per row. Button is hidden when the condition is false. */
-      type: import_zod17.z.literal("link").default("link"),
+      type: import_zod15.z.literal("link").default("link"),
       /** URL to open. May contain `{env.VAR}` placeholders. */
-      href: import_zod17.z.string(),
-      blank: import_zod17.z.boolean().optional().default(true)
+      href: import_zod15.z.string(),
+      blank: import_zod15.z.boolean().optional().default(true)
     });
     transformAction = /* @__PURE__ */ __name((action) => {
       const label = action.label;
@@ -1380,27 +1257,70 @@ var init_TableAction_schema = __esm({
         ...action
       };
     }, "transformAction");
-    JsonActionSchema = import_zod17.z.union([
+    JsonActionSchema = import_zod15.z.union([
       JsonProcedureActionSchema,
       JsonLinkActionSchema
     ]).transform(transformAction);
   }
 });
 
+// ../crouton-core/src/lib/resource/extensions.ts
+var CORE_RESOURCE_KEYS, registry, registerResourceExtension, registerResourceExtensions, getResourceExtensions;
+var init_extensions = __esm({
+  "../crouton-core/src/lib/resource/extensions.ts"() {
+    "use strict";
+    init_cjs_shims();
+    CORE_RESOURCE_KEYS = /* @__PURE__ */ new Set([
+      "$schema",
+      "schemaVersion",
+      "draft",
+      "kind",
+      "id",
+      "name",
+      "route",
+      "model",
+      "tag",
+      "title",
+      "table",
+      "idType",
+      "database",
+      "parent",
+      "sidebar",
+      "display",
+      "security",
+      "operations",
+      "columns",
+      "calculatedColumns",
+      "actions",
+      "tableActions",
+      "modalSize",
+      "include",
+      "extensions"
+    ]);
+    registry = /* @__PURE__ */ new Map();
+    registerResourceExtension = /* @__PURE__ */ __name((name, schema) => {
+      if (CORE_RESOURCE_KEYS.has(name)) throw new Error(`Extension "${name}" shadows a core resource key.`);
+      registry.set(name, schema);
+    }, "registerResourceExtension");
+    registerResourceExtensions = /* @__PURE__ */ __name((map = {}) => Object.entries(map).forEach(([k, s]) => registerResourceExtension(k, s)), "registerResourceExtensions");
+    getResourceExtensions = /* @__PURE__ */ __name(() => registry, "getResourceExtensions");
+  }
+});
+
 // ../crouton-core/src/lib/resource/include.schema.ts
-var import_zod18, JsonIncludeEntrySchema;
+var import_zod16, JsonIncludeEntrySchema;
 var init_include_schema = __esm({
   "../crouton-core/src/lib/resource/include.schema.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod18 = require("zod");
-    JsonIncludeEntrySchema = import_zod18.z.lazy(() => import_zod18.z.union([
-      import_zod18.z.string(),
-      import_zod18.z.object({
-        relation: import_zod18.z.string(),
-        include: import_zod18.z.array(JsonIncludeEntrySchema).optional(),
+    import_zod16 = require("zod");
+    JsonIncludeEntrySchema = import_zod16.z.lazy(() => import_zod16.z.union([
+      import_zod16.z.string(),
+      import_zod16.z.object({
+        relation: import_zod16.z.string(),
+        include: import_zod16.z.array(JsonIncludeEntrySchema).optional(),
         /** Prisma-format orderBy clause applied to the included records. */
-        orderBy: import_zod18.z.record(import_zod18.z.string(), import_zod18.z.unknown()).optional()
+        orderBy: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.unknown()).optional()
       })
     ]));
   }
@@ -1417,8 +1337,107 @@ var init_version = __esm({
   }
 });
 
+// ../crouton-core/src/lib/data-source/Security.schema.ts
+var import_zod17, SecuritySchema;
+var init_Security_schema = __esm({
+  "../crouton-core/src/lib/data-source/Security.schema.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_zod17 = require("zod");
+    SecuritySchema = import_zod17.z.union([
+      import_zod17.z.object({
+        public: import_zod17.z.literal(true)
+      }),
+      import_zod17.z.object({
+        guard: import_zod17.z.union([
+          import_zod17.z.string(),
+          import_zod17.z.array(import_zod17.z.string()).min(1)
+        ])
+      })
+    ]);
+  }
+});
+
+// ../crouton-core/src/lib/data-source/Operations.schema.ts
+var import_zod18, OpEntry, BoolOrUpsertSchema, JsonOperationsSchema, buildSubResourceOperations;
+var init_Operations_schema = __esm({
+  "../crouton-core/src/lib/data-source/Operations.schema.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_zod18 = require("zod");
+    init_Security_schema();
+    OpEntry = import_zod18.z.union([
+      import_zod18.z.boolean(),
+      import_zod18.z.object({
+        security: SecuritySchema.optional()
+      })
+    ]);
+    BoolOrUpsertSchema = import_zod18.z.union([
+      import_zod18.z.boolean(),
+      import_zod18.z.object({
+        upsertOn: import_zod18.z.union([
+          import_zod18.z.string(),
+          import_zod18.z.array(import_zod18.z.string())
+        ]),
+        security: SecuritySchema.optional()
+      })
+    ]);
+    JsonOperationsSchema = import_zod18.z.object({
+      findAll: OpEntry.default(true),
+      findOne: OpEntry.default(true),
+      create: OpEntry.default(true),
+      update: OpEntry.default(true),
+      patch: OpEntry.default(true),
+      upsert: BoolOrUpsertSchema.default(false),
+      delete: OpEntry.default(true)
+    });
+    buildSubResourceOperations = /* @__PURE__ */ __name((ops, baseUri, idField = "id") => {
+      if (!ops) return {};
+      const idPlaceholder = `{${idField}}`;
+      return {
+        ...ops.findAll && {
+          findAll: {
+            uri: baseUri,
+            method: "get"
+          }
+        },
+        ...ops.findOne && {
+          findOne: {
+            uri: `${baseUri}/${idPlaceholder}`,
+            method: "get"
+          }
+        },
+        ...ops.create && {
+          create: {
+            uri: baseUri,
+            method: "post"
+          }
+        },
+        ...ops.update && {
+          update: {
+            uri: `${baseUri}/${idPlaceholder}`,
+            method: "put"
+          }
+        },
+        ...ops.patch && {
+          patch: {
+            uri: `${baseUri}/${idPlaceholder}`,
+            method: "patch"
+          }
+        },
+        ...ops.delete && {
+          delete: {
+            uri: `${baseUri}/${idPlaceholder}`,
+            method: "delete"
+          }
+        }
+      };
+    }, "buildSubResourceOperations");
+  }
+});
+
 // ../crouton-core/src/lib/resource/ResourceJson.schema.ts
-var import_zod19, JsonColumnsMapSchema, ColumnsSchema, JsonDisplaySchema, normalizeColumns, ResourceJsonShape, refineByKind, ResourceJsonSchema;
+var import_zod19, JsonColumnsMapSchema, ColumnsSchema, JsonDisplaySchema, normalizeColumns, ResourceJsonShape, refineByKind, buildResourceJsonSchema, ResourceJsonSchema;
 var init_ResourceJson_schema = __esm({
   "../crouton-core/src/lib/resource/ResourceJson.schema.ts"() {
     "use strict";
@@ -1430,6 +1449,7 @@ var init_ResourceJson_schema = __esm({
     init_ResourceKind();
     init_Sidebar_schema();
     init_TableAction_schema();
+    init_extensions();
     init_include_schema();
     init_version();
     init_Operations_schema();
@@ -1478,14 +1498,15 @@ var init_ResourceJson_schema = __esm({
       */
       kind: ResourceKindSchema,
       name: import_zod19.z.string(),
-      route: import_zod19.z.string(),
+      route: import_zod19.z.string().optional(),
+      id: import_zod19.z.string().optional(),
       /**
       * Prisma model name. Required when `kind` is `prisma` (enforced by the
       * refinement on `ResourceJsonSchema`), and must be absent when `kind` is
       * `custom` — there is no Prisma delegate to address.
       */
       model: import_zod19.z.string().optional(),
-      tag: import_zod19.z.string(),
+      tag: import_zod19.z.string().optional().default("Crouton"),
       title: import_zod19.z.string().optional(),
       table: import_zod19.z.string().optional(),
       /**
@@ -1506,8 +1527,8 @@ var init_ResourceJson_schema = __esm({
       display: JsonDisplaySchema.default(JsonDisplaySchema.parse({})),
       /** Global security block — applies to every operation unless overridden per-operation. */
       security: SecuritySchema.optional(),
-      operations: JsonOperationsSchema,
-      columns: ColumnsSchema.default(ColumnsSchema.parse({})),
+      operations: JsonOperationsSchema.optional(),
+      columns: ColumnsSchema.optional().default(ColumnsSchema.parse({})),
       calculatedColumns: import_zod19.z.array(CalculatedColumnSchema).default([]),
       actions: import_zod19.z.array(JsonActionSchema).default([]),
       /** Global table-level actions (no record id). Shown as toolbar buttons. */
@@ -1592,16 +1613,49 @@ var init_ResourceJson_schema = __esm({
         });
       }
     }, "refineByKind");
-    ResourceJsonSchema = ResourceJsonShape.superRefine(refineByKind).transform((obj) => {
-      const title = obj.title ?? labelFromId(obj.name);
-      const schemaVersion = obj.schemaVersion ?? BASELINE_RESOURCE_VERSION;
-      return {
-        title,
-        ...obj,
-        schemaVersion,
-        columns: normalizeColumns(obj.columns)
-      };
-    });
+    buildResourceJsonSchema = /* @__PURE__ */ __name(() => {
+      const ext = getResourceExtensions();
+      const extShape = Object.fromEntries([
+        ...ext
+      ].map(([name, schema]) => [
+        name,
+        schema.optional()
+      ]));
+      const shape = ext.size ? ResourceJsonShape.extend(extShape) : ResourceJsonShape;
+      return import_zod19.z.preprocess((raw) => {
+        if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+          const obj = raw;
+          if (obj["kind"] === void 0) {
+            return {
+              ...obj,
+              kind: obj["model"] !== void 0 ? "prisma" : "custom"
+            };
+          }
+        }
+        return raw;
+      }, shape.superRefine(refineByKind).transform((obj) => {
+        const title = obj.title ?? labelFromId(obj.name);
+        const schemaVersion = obj.schemaVersion ?? BASELINE_RESOURCE_VERSION;
+        const defaultOps = obj.kind === "custom" ? JsonOperationsSchema.parse({
+          findAll: false,
+          findOne: false,
+          create: false,
+          update: false,
+          patch: false,
+          delete: false
+        }) : JsonOperationsSchema.parse({});
+        return {
+          title,
+          ...obj,
+          id: obj.id ?? obj.name,
+          route: obj.route ?? obj.id ?? obj.name ?? "",
+          schemaVersion,
+          columns: normalizeColumns(obj.columns),
+          operations: obj.operations ?? defaultOps
+        };
+      }));
+    }, "buildResourceJsonSchema");
+    ResourceJsonSchema = buildResourceJsonSchema();
   }
 });
 
@@ -1703,6 +1757,7 @@ var init_resource = __esm({
     "use strict";
     init_cjs_shims();
     init_ResourceJson_schema();
+    init_extensions();
     init_version();
     init_migrations();
     init_Sidebar_schema();
@@ -1718,96 +1773,6 @@ var init_resource = __esm({
   }
 });
 
-// ../crouton-core/src/lib/config/CroutonConfig.schema.ts
-var import_zod20, RulesetSchema, I18nConfigSchema, CroutonConfigSchema;
-var init_CroutonConfig_schema = __esm({
-  "../crouton-core/src/lib/config/CroutonConfig.schema.ts"() {
-    "use strict";
-    init_cjs_shims();
-    import_zod20 = require("zod");
-    init_Operations_schema();
-    init_resource();
-    RulesetSchema = import_zod20.z.object({
-      hideIdInTable: import_zod20.z.boolean().default(true),
-      hideIdInForm: import_zod20.z.boolean().default(true),
-      hideIdInView: import_zod20.z.boolean().default(true),
-      hideTimestamps: import_zod20.z.boolean().default(true),
-      hideForeignKeys: import_zod20.z.boolean().default(true),
-      includeRelations: import_zod20.z.boolean().default(true),
-      hideRelationsInTable: import_zod20.z.boolean().default(true),
-      showRelationsInForm: import_zod20.z.boolean().default(true),
-      enumValueLabel: import_zod20.z.boolean().default(true),
-      sharedEnums: import_zod20.z.boolean().default(true),
-      defaultOperations: JsonOperationsSchema.default(JsonOperationsSchema.parse({}))
-    });
-    I18nConfigSchema = import_zod20.z.object({
-      /** Default / fallback language. */
-      defaultLanguage: import_zod20.z.string().default("en"),
-      /** All supported language codes. */
-      languages: import_zod20.z.array(import_zod20.z.string()).min(1),
-      /** Directory containing `<lang>.json` bundles, relative to project root. */
-      translationsDir: import_zod20.z.string().default("translations")
-    });
-    CroutonConfigSchema = import_zod20.z.object({
-      /**
-      * Application title served to the frontend via `GET /_app/layout`.
-      * Displayed in the admin sidebar header.
-      */
-      title: import_zod20.z.string(),
-      /** Where resource directories live, relative to the project root. */
-      resourcesDir: import_zod20.z.string(),
-      /** Where datasource folders live (each with a `data-source.json`). */
-      dataSourcesDir: import_zod20.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_zod20.z.string().default("{Model}WithRelationsSchema"),
-      /** Path to the shared enum registry, relative to project root. Default `crouton.enums.json`. */
-      enumsFile: import_zod20.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_zod20.z.record(import_zod20.z.string(), SidebarGroupSchema).default({}),
-      /**
-      * Whether form fields are saved automatically as the user edits them.
-      * @default true
-      */
-      autoSave: import_zod20.z.boolean().default(true),
-      /** Optional i18n / translation configuration. */
-      i18n: I18nConfigSchema.optional()
-    });
-  }
-});
-
-// ../crouton-core/src/lib/config/readConfig.ts
-var CONFIG_FILES;
-var init_readConfig = __esm({
-  "../crouton-core/src/lib/config/readConfig.ts"() {
-    "use strict";
-    init_cjs_shims();
-    CONFIG_FILES = [
-      "crouton.json",
-      "crouton.mjs",
-      "crouton.js"
-    ];
-  }
-});
-
-// ../crouton-core/src/lib/config/index.ts
-var init_config = __esm({
-  "../crouton-core/src/lib/config/index.ts"() {
-    "use strict";
-    init_cjs_shims();
-    init_CroutonConfig_schema();
-    init_readConfig();
-  }
-});
-
 // ../crouton-core/src/lib/view/column-predicates.ts
 var isBoolean, isRelation, isAutocomplete, isRecordCell, isDateRange, isObjectColumn, isArrayColumn, isObjectCell;
 var init_column_predicates = __esm({
@@ -2282,23 +2247,23 @@ var init_column_type_schema_source = __esm({
 });
 
 // ../crouton-core/src/lib/view/json-schema.opts.ts
-var import_zod21, isInstanceOf, jsonSchemaOverride, jsonSchemaOpts;
+var import_zod20, isInstanceOf, jsonSchemaOverride, jsonSchemaOpts;
 var init_json_schema_opts = __esm({
   "../crouton-core/src/lib/view/json-schema.opts.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod21 = require("zod");
+    import_zod20 = require("zod");
     isInstanceOf = /* @__PURE__ */ __name((zodSchema, className) => {
-      if (!(zodSchema instanceof import_zod21.z.ZodCustom)) return false;
+      if (!(zodSchema instanceof import_zod20.z.ZodCustom)) return false;
       const result = zodSchema.safeParse(null);
       return !result.success && result.error.issues[0]?.expected === className;
     }, "isInstanceOf");
     jsonSchemaOverride = /* @__PURE__ */ __name(({ zodSchema, jsonSchema }) => {
-      if (zodSchema instanceof import_zod21.z.ZodDate) {
+      if (zodSchema instanceof import_zod20.z.ZodDate) {
         jsonSchema.type = "string";
         jsonSchema.format = "date-time";
       }
-      if (zodSchema instanceof import_zod21.z.ZodBigInt) {
+      if (zodSchema instanceof import_zod20.z.ZodBigInt) {
         jsonSchema.type = "integer";
       }
       if (isInstanceOf(zodSchema, "Decimal")) {
@@ -2316,12 +2281,12 @@ var init_json_schema_opts = __esm({
 });
 
 // ../crouton-core/src/lib/view/view.builder.ts
-var import_zod22, patchFilterProperties, injectFieldDefaults, zodSchemaSource, NON_NULL_TYPES, SHAPE_KEYS, applyRequiredColumns, buildView, emptyTableView, buildViewsWithSource, buildViews, buildViewsFromColumnTypes, buildViewsFromColumns;
+var import_zod21, patchFilterProperties, injectFieldDefaults, zodSchemaSource, NON_NULL_TYPES, SHAPE_KEYS, applyRequiredColumns, buildView, emptyTableView, buildViewsWithSource, buildViews, buildViewsFromColumnTypes, buildViewsFromColumns;
 var init_view_builder = __esm({
   "../crouton-core/src/lib/view/view.builder.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod22 = require("zod");
+    import_zod21 = require("zod");
     init_column_predicates();
     init_column_type_schema_source();
     init_column_utils();
@@ -2389,7 +2354,7 @@ var init_view_builder = __esm({
       ]));
       const picked = schema.pick(mask);
       try {
-        return (0, import_zod22.toJSONSchema)(picked, {
+        return (0, import_zod21.toJSONSchema)(picked, {
           target: "draft-07",
           ...jsonSchemaOpts
         });
@@ -2477,7 +2442,7 @@ var init_view_builder = __esm({
       if (table) {
         table.defaultSort = resolveDefaultSort(table.columns, columns);
         views.table = table;
-      } else if (columns?.length) {
+      } else if (columns !== void 0) {
         views.table = emptyTableView();
       }
       const form = buildView(source, columns, (c) => !c.hiddenInForm, buildFormUiSchema, true, (c) => !c.idField && (c.createable === true || c.updateable === true));
@@ -2600,88 +2565,552 @@ var init_view_builder = __esm({
   }
 });
 
-// ../crouton-core/src/lib/view/view.schema.ts
-var import_zod23, ViewColumnConfigSchema, ViewConfigSchema, viewDefList, ViewDefEnum;
-var init_view_schema = __esm({
-  "../crouton-core/src/lib/view/view.schema.ts"() {
+// ../crouton-core/src/lib/view/view.schema.ts
+var import_zod22, ViewColumnConfigSchema, ViewConfigSchema, viewDefList, ViewDefEnum;
+var init_view_schema = __esm({
+  "../crouton-core/src/lib/view/view.schema.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_zod22 = require("zod");
+    init_FieldInput_schema();
+    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()
+    });
+    ViewConfigSchema = import_zod22.z.object({
+      // TODO why we have both?
+      json_schema: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.unknown()).optional(),
+      ui_schema: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.unknown()).optional(),
+      // TODO why we have both?
+      ui: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.unknown()).optional(),
+      data: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.unknown()).optional(),
+      columns: import_zod22.z.array(ViewColumnConfigSchema),
+      defaultSort: import_zod22.z.string().optional()
+    });
+    viewDefList = [
+      "table",
+      "view",
+      "form"
+    ];
+    ViewDefEnum = import_zod22.z.enum(viewDefList);
+  }
+});
+
+// ../crouton-core/src/lib/view/index.ts
+var init_view = __esm({
+  "../crouton-core/src/lib/view/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_column_predicates();
+    init_column_utils();
+    init_sort_helpers();
+    init_schema_transforms();
+    init_table_schema_builder();
+    init_form_schema_builder();
+    init_calculated_columns_builder();
+    init_view_builder();
+    init_column_type_schema_source();
+    init_view_schema();
+    init_json_schema_opts();
+  }
+});
+
+// ../crouton-core/src/lib/compile/column-enrichment.ts
+var init_column_enrichment = __esm({
+  "../crouton-core/src/lib/compile/column-enrichment.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// ../crouton-core/src/lib/compile/column-transforms.ts
+var init_column_transforms = __esm({
+  "../crouton-core/src/lib/compile/column-transforms.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_resource();
+  }
+});
+
+// ../crouton-core/src/lib/compile/enum-registry.ts
+var import_zod23, EnumEntrySchema, EnumRegistrySchema;
+var init_enum_registry = __esm({
+  "../crouton-core/src/lib/compile/enum-registry.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_zod23 = require("zod");
+    EnumEntrySchema = import_zod23.z.object({
+      value: import_zod23.z.unknown(),
+      label: import_zod23.z.string()
+    });
+    EnumRegistrySchema = import_zod23.z.record(import_zod23.z.string(), import_zod23.z.array(EnumEntrySchema)).default({});
+  }
+});
+
+// ../crouton-core/src/lib/compile/relation-type.ts
+var import_zod24;
+var init_relation_type = __esm({
+  "../crouton-core/src/lib/compile/relation-type.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_zod24 = require("zod");
+  }
+});
+
+// ../crouton-core/src/lib/compile/schema.helpers.ts
+var init_schema_helpers = __esm({
+  "../crouton-core/src/lib/compile/schema.helpers.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_view();
+  }
+});
+
+// ../crouton-core/src/lib/compile/compile-resource.ts
+var init_compile_resource = __esm({
+  "../crouton-core/src/lib/compile/compile-resource.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_resource();
+    init_view();
+    init_column_enrichment();
+    init_column_transforms();
+    init_enum_registry();
+    init_relation_type();
+    init_schema_helpers();
+  }
+});
+
+// ../crouton-core/src/lib/data-source/DataSourceSchema.ts
+var import_zod25, DataSourceShape, transformDataSource, DataSourceSchema;
+var init_DataSourceSchema = __esm({
+  "../crouton-core/src/lib/data-source/DataSourceSchema.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_zod25 = __toESM(require("zod"), 1);
+    DataSourceShape = import_zod25.default.object({
+      /** Datasource name (folder + `name` in data-source.json). */
+      name: import_zod25.default.string(),
+      /**
+      * Env var holding the connection URL. Required for Prisma adapters; optional
+      * for custom adapters whose connection config may differ (secrets file, SDK
+      * key, etc.).
+      */
+      urlEnv: import_zod25.default.string().optional(),
+      /** Import path for this datasource's generated Zod types (for resource `schema.ts`). */
+      generatedTypesImport: import_zod25.default.string().optional(),
+      /** Datasource type tag. Default `postgres`. */
+      type: import_zod25.default.string().default("postgres"),
+      /** Mark this as the default datasource. Default `false`. */
+      default: import_zod25.default.boolean().default(false),
+      /**
+      * Adapter kind. `"prisma"` (default) expects `index.ts` to default-export a
+      * `PrismaClient`; `"custom"` expects it to default-export a `DataSourceAdapter`.
+      */
+      adapter: import_zod25.default.enum([
+        "prisma",
+        "custom"
+      ]).default("prisma"),
+      /** Prisma schema path, relative to project root. Default `prisma/<name>/schema.prisma`. */
+      prismaSchema: import_zod25.default.string().optional(),
+      /** Prisma config path, relative to project root. Default `prisma/<name>/prisma.config.ts`. */
+      prismaConfig: import_zod25.default.string().optional(),
+      /** zod-prisma-types output dir, relative to project root. Default `generated/<name>/src`. */
+      zodOutput: import_zod25.default.string().optional(),
+      /** Prisma client output dir, relative to project root. Default `generated/<name>/client`. */
+      clientOutput: import_zod25.default.string().optional()
+    });
+    transformDataSource = /* @__PURE__ */ __name((data) => {
+      const name = data.name ?? "name";
+      return {
+        ...data,
+        generatedTypesImport: data.generatedTypesImport ?? `@your-scope/generated/${name}`,
+        prismaSchema: data.prismaSchema ?? `prisma/${name}/schema.prisma`,
+        prismaConfig: data.prismaConfig ?? `prisma/${name}/prisma.config.ts`,
+        zodOutput: data.zodOutput ?? `generated/${name}/src`,
+        clientOutput: data.clientOutput ?? `generated/${name}/client`
+      };
+    }, "transformDataSource");
+    DataSourceSchema = DataSourceShape.transform(transformDataSource);
+  }
+});
+
+// ../crouton-core/src/lib/data-source/index.ts
+var init_data_source = __esm({
+  "../crouton-core/src/lib/data-source/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_DataSourceSchema();
+    init_Operations_schema();
+    init_Security_schema();
+  }
+});
+
+// ../crouton-core/src/lib/compile/value-label-column.ts
+var import_zod26, ValueSchema, ValueLabelColumnSchema;
+var init_value_label_column = __esm({
+  "../crouton-core/src/lib/compile/value-label-column.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod23 = require("zod");
-    init_FieldInput_schema();
-    ViewColumnConfigSchema = import_zod23.z.object({
-      id: import_zod23.z.string(),
-      label: import_zod23.z.string().optional(),
-      sortable: import_zod23.z.boolean().optional(),
-      searchable: import_zod23.z.boolean().optional(),
-      fieldInput: FieldInputSchema.optional()
+    import_zod26 = require("zod");
+    ValueSchema = import_zod26.z.object({
+      value: import_zod26.z.unknown(),
+      label: import_zod26.z.string()
     });
-    ViewConfigSchema = import_zod23.z.object({
-      // TODO why we have both?
-      json_schema: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.unknown()).optional(),
-      ui_schema: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.unknown()).optional(),
-      // TODO why we have both?
-      ui: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.unknown()).optional(),
-      data: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.unknown()).optional(),
-      columns: import_zod23.z.array(ViewColumnConfigSchema),
-      defaultSort: import_zod23.z.string().optional()
+    ValueLabelColumnSchema = import_zod26.z.object({
+      field: import_zod26.z.string(),
+      values: import_zod26.z.array(ValueSchema).default([]),
+      enumName: import_zod26.z.string().optional()
     });
-    viewDefList = [
-      "table",
-      "view",
-      "form"
-    ];
-    ViewDefEnum = import_zod23.z.enum(viewDefList);
   }
 });
 
-// ../crouton-core/src/lib/view/index.ts
-var init_view = __esm({
-  "../crouton-core/src/lib/view/index.ts"() {
+// ../crouton-core/src/lib/compile/compiled-sub-resource.schema.ts
+var import_zod27, CompiledSubResourceConfigSchema;
+var init_compiled_sub_resource_schema = __esm({
+  "../crouton-core/src/lib/compile/compiled-sub-resource.schema.ts"() {
     "use strict";
     init_cjs_shims();
-    init_column_predicates();
-    init_column_utils();
-    init_sort_helpers();
-    init_schema_transforms();
-    init_table_schema_builder();
-    init_form_schema_builder();
-    init_calculated_columns_builder();
-    init_view_builder();
-    init_column_type_schema_source();
-    init_view_schema();
+    import_zod27 = require("zod");
+    init_data_source();
+    init_resource();
+    init_view();
+    init_value_label_column();
+    CompiledSubResourceConfigSchema = import_zod27.z.object({
+      column: import_zod27.z.string(),
+      relation: import_zod27.z.string(),
+      childRoute: import_zod27.z.string(),
+      childKind: import_zod27.z.enum([
+        "prisma",
+        "custom"
+      ]).default("prisma"),
+      childDir: import_zod27.z.string().optional(),
+      childModel: import_zod27.z.string(),
+      foreignKey: import_zod27.z.string(),
+      name: import_zod27.z.string().optional(),
+      title: import_zod27.z.string().optional(),
+      idField: import_zod27.z.string().optional(),
+      idType: import_zod27.z.enum([
+        "string",
+        "number"
+      ]).optional(),
+      views: import_zod27.z.record(import_zod27.z.string(), ViewConfigSchema).optional(),
+      operations: JsonOperationsSchema,
+      actions: import_zod27.z.array(JsonActionSchema).optional(),
+      modalSize: import_zod27.z.enum([
+        "xs",
+        "sm",
+        "lg",
+        "xl"
+      ]).optional(),
+      include: import_zod27.z.array(JsonIncludeEntrySchema).optional(),
+      calculatedColumns: import_zod27.z.array(CalculatedColumnSchema).optional(),
+      includeInFindOne: import_zod27.z.boolean().optional(),
+      hiddenInTable: import_zod27.z.boolean().optional(),
+      findOneOrderBy: import_zod27.z.record(import_zod27.z.string(), import_zod27.z.unknown()).optional(),
+      valueLabelColumns: import_zod27.z.array(ValueLabelColumnSchema).optional(),
+      relationType: import_zod27.z.enum([
+        "oneToMany",
+        "manyToOne"
+      ]).optional()
+    });
+  }
+});
+
+// ../crouton-core/src/lib/compile/schema-input.ts
+var import_zod28, JsonSchemaInputSchema, SchemaInputSchema;
+var init_schema_input = __esm({
+  "../crouton-core/src/lib/compile/schema-input.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_zod28 = require("zod");
+    JsonSchemaInputSchema = import_zod28.z.object({
+      type: import_zod28.z.literal("object"),
+      properties: import_zod28.z.record(import_zod28.z.string(), import_zod28.z.unknown()),
+      required: import_zod28.z.array(import_zod28.z.string()).optional(),
+      additionalProperties: import_zod28.z.boolean().optional()
+    });
+    SchemaInputSchema = import_zod28.z.union([
+      import_zod28.z.custom((val) => val instanceof import_zod28.ZodObject),
+      JsonSchemaInputSchema
+    ]);
+  }
+});
+
+// ../crouton-core/src/lib/compile/definition.schema.ts
+var import_zod29, OperationDefSchema, UpsertOperationDefSchema, ResourceDefinitionSchema, DefinitionCallbackSchema, DefinitionSchema;
+var init_definition_schema = __esm({
+  "../crouton-core/src/lib/compile/definition.schema.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_zod29 = require("zod");
+    init_schema_input();
+    init_Security_schema();
+    OperationDefSchema = import_zod29.z.union([
+      import_zod29.z.literal(true),
+      import_zod29.z.object({
+        schema: SchemaInputSchema.optional(),
+        security: SecuritySchema.optional()
+      })
+    ]);
+    UpsertOperationDefSchema = import_zod29.z.object({
+      schema: SchemaInputSchema.optional(),
+      upsertOn: import_zod29.z.union([
+        import_zod29.z.string(),
+        import_zod29.z.array(import_zod29.z.string())
+      ]),
+      security: SecuritySchema.optional()
+    });
+    ResourceDefinitionSchema = import_zod29.z.object({
+      findAll: OperationDefSchema.optional(),
+      findOne: OperationDefSchema.optional(),
+      create: OperationDefSchema.optional(),
+      update: OperationDefSchema.optional(),
+      patch: OperationDefSchema.optional(),
+      upsert: UpsertOperationDefSchema.optional(),
+      delete: OperationDefSchema.optional()
+    });
+    DefinitionCallbackSchema = import_zod29.z.function({
+      input: [],
+      output: ResourceDefinitionSchema
+    });
+    DefinitionSchema = import_zod29.z.union([
+      ResourceDefinitionSchema,
+      DefinitionCallbackSchema
+    ]);
+  }
+});
+
+// ../crouton-core/src/lib/compile/lookup.schema.ts
+var import_zod30, LookupSchema;
+var init_lookup_schema = __esm({
+  "../crouton-core/src/lib/compile/lookup.schema.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_zod30 = require("zod");
+    LookupSchema = import_zod30.z.object({
+      key: import_zod30.z.string(),
+      label: import_zod30.z.string().optional()
+    });
+  }
+});
+
+// ../crouton-core/src/lib/compile/compiled-resource.schema.ts
+var import_zod31, CompiledResourceSchema;
+var init_compiled_resource_schema = __esm({
+  "../crouton-core/src/lib/compile/compiled-resource.schema.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_zod31 = require("zod");
+    init_resource();
+    init_view();
+    init_compiled_sub_resource_schema();
+    init_definition_schema();
+    init_lookup_schema();
+    init_value_label_column();
+    CompiledResourceSchema = ResourceJsonShape.extend({
+      route: import_zod31.z.string(),
+      valueLabelColumns: import_zod31.z.array(ValueLabelColumnSchema).default([]),
+      subResources: import_zod31.z.lazy(() => import_zod31.z.array(CompiledSubResourceConfigSchema)).default([]),
+      lookup: LookupSchema.optional(),
+      views: import_zod31.z.record(import_zod31.z.string(), ViewConfigSchema),
+      definition: DefinitionSchema,
+      idField: import_zod31.z.string(),
+      idType: import_zod31.z.enum([
+        "string",
+        "number"
+      ]).default("string")
+    });
+  }
+});
+
+// ../crouton-core/src/lib/compile/crud-config.ts
+var init_crud_config = __esm({
+  "../crouton-core/src/lib/compile/crud-config.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
+// ../crouton-core/src/lib/compile/to-json-schema.ts
+var import_zod32;
+var init_to_json_schema = __esm({
+  "../crouton-core/src/lib/compile/to-json-schema.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_zod32 = require("zod");
     init_json_schema_opts();
   }
 });
 
+// ../crouton-core/src/lib/compile/payload-builders.ts
+var init_payload_builders = __esm({
+  "../crouton-core/src/lib/compile/payload-builders.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_data_source();
+    init_resource();
+    init_crud_config();
+    init_to_json_schema();
+  }
+});
+
+// ../crouton-core/src/lib/compile/parse-schema.ts
+var init_parse_schema = __esm({
+  "../crouton-core/src/lib/compile/parse-schema.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_resource();
+    init_compile_resource();
+    init_payload_builders();
+  }
+});
+
+// ../crouton-core/src/lib/compile/index.ts
+var init_compile = __esm({
+  "../crouton-core/src/lib/compile/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_action_types();
+    init_compile_resource();
+    init_compiled_resource_schema();
+    init_compiled_sub_resource_schema();
+    init_crud_config();
+    init_definition_schema();
+    init_enum_registry();
+    init_lookup_schema();
+    init_parse_schema();
+    init_payload_builders();
+    init_relation_type();
+    init_schema_helpers();
+    init_schema_input();
+    init_to_json_schema();
+    init_value_label_column();
+  }
+});
+
+// ../crouton-core/src/lib/config/CroutonConfig.schema.ts
+var import_zod33, RulesetSchema, I18nConfigSchema, CroutonConfigSchema;
+var init_CroutonConfig_schema = __esm({
+  "../crouton-core/src/lib/config/CroutonConfig.schema.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_zod33 = require("zod");
+    init_Operations_schema();
+    init_resource();
+    RulesetSchema = import_zod33.z.object({
+      hideIdInTable: import_zod33.z.boolean().default(true),
+      hideIdInForm: import_zod33.z.boolean().default(true),
+      hideIdInView: import_zod33.z.boolean().default(true),
+      hideTimestamps: import_zod33.z.boolean().default(true),
+      hideForeignKeys: import_zod33.z.boolean().default(true),
+      includeRelations: import_zod33.z.boolean().default(true),
+      hideRelationsInTable: import_zod33.z.boolean().default(true),
+      showRelationsInForm: import_zod33.z.boolean().default(true),
+      enumValueLabel: import_zod33.z.boolean().default(true),
+      sharedEnums: import_zod33.z.boolean().default(true),
+      defaultOperations: JsonOperationsSchema.default(JsonOperationsSchema.parse({}))
+    });
+    I18nConfigSchema = import_zod33.z.object({
+      /** Default / fallback language. */
+      defaultLanguage: import_zod33.z.string().default("en"),
+      /** All supported language codes. */
+      languages: import_zod33.z.array(import_zod33.z.string()).min(1),
+      /** Directory containing `<lang>.json` bundles, relative to project root. */
+      translationsDir: import_zod33.z.string().default("translations")
+    });
+    CroutonConfigSchema = import_zod33.z.object({
+      /**
+      * Application title served to the frontend via `GET /_app/layout`.
+      * Displayed in the admin sidebar header.
+      */
+      title: import_zod33.z.string(),
+      /** Where resource directories live, relative to the project root. */
+      resourcesDir: import_zod33.z.string(),
+      /** Where datasource folders live (each with a `data-source.json`). */
+      dataSourcesDir: import_zod33.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_zod33.z.string().default("{Model}WithRelationsSchema"),
+      /** Path to the shared enum registry, relative to project root. Default `crouton.enums.json`. */
+      enumsFile: import_zod33.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_zod33.z.record(import_zod33.z.string(), SidebarGroupSchema).default({}),
+      /**
+      * Whether form fields are saved automatically as the user edits them.
+      * @default true
+      */
+      autoSave: import_zod33.z.boolean().default(true),
+      /** Optional i18n / translation configuration. */
+      i18n: I18nConfigSchema.optional()
+    });
+  }
+});
+
+// ../crouton-core/src/lib/config/readConfig.ts
+var CONFIG_FILES;
+var init_readConfig = __esm({
+  "../crouton-core/src/lib/config/readConfig.ts"() {
+    "use strict";
+    init_cjs_shims();
+    CONFIG_FILES = [
+      "crouton.json",
+      "crouton.mjs",
+      "crouton.js"
+    ];
+  }
+});
+
+// ../crouton-core/src/lib/config/index.ts
+var init_config = __esm({
+  "../crouton-core/src/lib/config/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_CroutonConfig_schema();
+    init_readConfig();
+  }
+});
+
 // ../crouton-core/src/lib/i18n/Translations.schema.ts
-var import_zod24, NestedStringRecord, TranslationBundleSchema;
+var import_zod34, NestedStringRecord, TranslationBundleSchema;
 var init_Translations_schema = __esm({
   "../crouton-core/src/lib/i18n/Translations.schema.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod24 = require("zod");
-    NestedStringRecord = import_zod24.z.lazy(() => import_zod24.z.record(import_zod24.z.string(), import_zod24.z.union([
-      import_zod24.z.string(),
+    import_zod34 = require("zod");
+    NestedStringRecord = import_zod34.z.lazy(() => import_zod34.z.record(import_zod34.z.string(), import_zod34.z.union([
+      import_zod34.z.string(),
       NestedStringRecord
     ])));
-    TranslationBundleSchema = import_zod24.z.object({
-      app: import_zod24.z.object({
-        title: import_zod24.z.string().optional()
+    TranslationBundleSchema = import_zod34.z.object({
+      app: import_zod34.z.object({
+        title: import_zod34.z.string().optional()
       }).optional(),
-      sidebarGroups: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.string()).optional(),
-      resources: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.object({
-        title: import_zod24.z.string().optional(),
-        sidebar: import_zod24.z.string().optional(),
-        columns: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.string()).optional(),
-        actions: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.string()).optional(),
-        subResources: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.object({
-          title: import_zod24.z.string().optional(),
-          columns: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.string()).optional()
+      sidebarGroups: import_zod34.z.record(import_zod34.z.string(), import_zod34.z.string()).optional(),
+      resources: import_zod34.z.record(import_zod34.z.string(), import_zod34.z.object({
+        title: import_zod34.z.string().optional(),
+        sidebar: import_zod34.z.string().optional(),
+        columns: import_zod34.z.record(import_zod34.z.string(), import_zod34.z.string()).optional(),
+        actions: import_zod34.z.record(import_zod34.z.string(), import_zod34.z.string()).optional(),
+        subResources: import_zod34.z.record(import_zod34.z.string(), import_zod34.z.object({
+          title: import_zod34.z.string().optional(),
+          columns: import_zod34.z.record(import_zod34.z.string(), import_zod34.z.string()).optional()
         }).optional()).optional()
       }).optional()).optional(),
-      enums: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.record(import_zod24.z.string(), import_zod24.z.string())).optional(),
+      enums: import_zod34.z.record(import_zod34.z.string(), import_zod34.z.record(import_zod34.z.string(), import_zod34.z.string())).optional(),
       ui: NestedStringRecord.optional(),
-      validation: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.string()).optional()
+      validation: import_zod34.z.record(import_zod34.z.string(), import_zod34.z.string()).optional()
     }).passthrough();
   }
 });
@@ -2814,6 +3243,7 @@ var init_src = __esm({
     init_base_builder();
     init_table_builder();
     init_table_utils();
+    init_compile();
     init_data_source();
     init_resource();
     init_config();
@@ -2880,27 +3310,27 @@ var init_module_loader = __esm({
 });
 
 // src/lib/crud/hooks/hooks.types.ts
-var import_zod28, WriteOpSchema, ReadOpSchema, ResourceHooksSchema;
+var import_zod38, WriteOpSchema, ReadOpSchema, ResourceHooksSchema;
 var init_hooks_types = __esm({
   "src/lib/crud/hooks/hooks.types.ts"() {
     "use strict";
     init_cjs_shims();
-    import_zod28 = require("zod");
-    WriteOpSchema = import_zod28.z.enum([
+    import_zod38 = require("zod");
+    WriteOpSchema = import_zod38.z.enum([
       "create",
       "update",
       "patch",
       "upsert",
       "delete"
     ]);
-    ReadOpSchema = import_zod28.z.enum([
+    ReadOpSchema = import_zod38.z.enum([
       "findAll",
       "findOne"
     ]);
-    ResourceHooksSchema = import_zod28.z.object({
-      beforeWrite: import_zod28.z.custom().optional(),
-      afterWrite: import_zod28.z.custom().optional(),
-      afterRead: import_zod28.z.custom().optional()
+    ResourceHooksSchema = import_zod38.z.object({
+      beforeWrite: import_zod38.z.custom().optional(),
+      afterWrite: import_zod38.z.custom().optional(),
+      afterRead: import_zod38.z.custom().optional()
     });
   }
 });
@@ -3054,7 +3484,7 @@ __export(index_exports, {
   buildViews: () => buildViews,
   decorateRow: () => decorateRow,
   decorateRows: () => decorateRows,
-  isOperationEnabled: () => isOperationEnabled,
+  isOperationEnabled: () => isOperationEnabled2,
   isRowProcedureAction: () => isRowProcedureAction,
   isTableProcedureAction: () => isTableProcedureAction,
   loadDataSourcesFromDir: () => loadDataSourcesFromDir,
@@ -3062,13 +3492,14 @@ __export(index_exports, {
   loadResourceHooks: () => loadResourceHooks,
   loadSubResourceHooks: () => loadSubResourceHooks,
   parseFilterString: () => parseFilterString,
+  parseSchema: () => parseSchema,
   postWrite: () => postWrite,
   prepareWrite: () => prepareWrite,
-  resolveDefinition: () => resolveDefinition,
-  schemaFor: () => schemaFor,
+  resolveDefinition: () => resolveDefinition2,
+  schemaFor: () => schemaFor2,
   securityFor: () => securityFor,
   securityForSub: () => securityForSub,
-  upsertOnFor: () => upsertOnFor
+  upsertOnFor: () => upsertOnFor2
 });
 module.exports = __toCommonJS(index_exports);
 init_cjs_shims();
@@ -3078,27 +3509,28 @@ init_src();
 init_cjs_shims();
 var import_common24 = require("@nestjs/common");
 var import_core2 = require("@nestjs/core");
+init_src();
 
 // src/lib/crud/app-layout/index.ts
 init_cjs_shims();
 
 // src/lib/crud/app-layout/app-layout.types.ts
 init_cjs_shims();
-var import_zod25 = require("zod");
-var SidebarLeafSchema = import_zod25.z.object({
-  kind: import_zod25.z.literal("item").default("item"),
-  id: import_zod25.z.string(),
-  label: import_zod25.z.string(),
-  position: import_zod25.z.number().optional()
+var import_zod35 = require("zod");
+var SidebarLeafSchema = import_zod35.z.object({
+  kind: import_zod35.z.literal("item").default("item"),
+  id: import_zod35.z.string(),
+  label: import_zod35.z.string(),
+  position: import_zod35.z.number().optional()
 });
-var SidebarGroupSchema2 = import_zod25.z.object({
-  kind: import_zod25.z.literal("group").default("group"),
-  id: import_zod25.z.string(),
-  label: import_zod25.z.string(),
-  position: import_zod25.z.number().optional(),
-  children: import_zod25.z.array(SidebarLeafSchema).default([])
+var SidebarGroupSchema2 = import_zod35.z.object({
+  kind: import_zod35.z.literal("group").default("group"),
+  id: import_zod35.z.string(),
+  label: import_zod35.z.string(),
+  position: import_zod35.z.number().optional(),
+  children: import_zod35.z.array(SidebarLeafSchema).default([])
 });
-var SidebarNodeSchema = import_zod25.z.discriminatedUnion("kind", [
+var SidebarNodeSchema = import_zod35.z.discriminatedUnion("kind", [
   SidebarLeafSchema,
   SidebarGroupSchema2
 ]);
@@ -3205,7 +3637,7 @@ var readResourceJson = /* @__PURE__ */ __name((jsonPath) => {
       error: `Invalid JSON in ${jsonPath}: ${err.message}`
     };
   }
-  const resource = ResourceJsonSchema.safeParse(fileContent);
+  const resource = buildResourceJsonSchema().safeParse(fileContent);
   if (resource.error) {
     return {
       success: false,
@@ -3327,7 +3759,7 @@ var expandExtendColumns = /* @__PURE__ */ __name((columns, dirPath) => {
   }
   return result;
 }, "expandExtendColumns");
-var buildValueLabelColumns = /* @__PURE__ */ __name((columns) => (columns ?? []).flatMap((c) => {
+var buildValueLabelColumns2 = /* @__PURE__ */ __name((columns) => (columns ?? []).flatMap((c) => {
   const opts = c.fieldInput?.options;
   if (!opts?.emitObject || !Array.isArray(opts.values)) return [];
   return [
@@ -3340,7 +3772,7 @@ var buildValueLabelColumns = /* @__PURE__ */ __name((columns) => (columns ?? [])
     }
   ];
 }), "buildValueLabelColumns");
-var applyRelationFormatDefault = /* @__PURE__ */ __name((cols) => cols?.map((col) => {
+var applyRelationFormatDefault2 = /* @__PURE__ */ __name((cols) => cols?.map((col) => {
   const fi = col.fieldInput;
   if (fi && fi.resource && !fi.format && !fi.type) {
     return {
@@ -3353,7 +3785,7 @@ var applyRelationFormatDefault = /* @__PURE__ */ __name((cols) => cols?.map((col
   }
   return col;
 }), "applyRelationFormatDefault");
-var resolveColumnFieldVariants = /* @__PURE__ */ __name((cols) => cols?.map((col) => {
+var resolveColumnFieldVariants2 = /* @__PURE__ */ __name((cols) => cols?.map((col) => {
   const fieldView = resolveViewField(col);
   const fieldTable = resolveTableField(col);
   return {
@@ -3444,7 +3876,7 @@ var localizeResource = /* @__PURE__ */ __name((config, t) => {
       columnLabels.set(col.id, translated);
     }
     translateEnumOptions(columns, t);
-    localized.valueLabelColumns = buildValueLabelColumns(columns);
+    localized.valueLabelColumns = buildValueLabelColumns2(columns);
   }
   if (localized.views) {
     localized.views = patchViewTitles(localized.views, columnLabels);
@@ -3511,7 +3943,7 @@ var ResourceConfigRegistry = class {
   configs;
   translationRegistry;
   /**
-  * Per-language memo: `Map<language, Map<route, Resource>>`.
+  * Per-language memo: `Map<language, Map<route, R>>`.
   * Cleared whenever the underlying configs reload (dev mode).
   */
   localizedCache = /* @__PURE__ */ new Map();
@@ -3519,8 +3951,8 @@ var ResourceConfigRegistry = class {
     this.loader = loader;
     this.configs = initialConfigs;
   }
-  setTranslationRegistry(registry) {
-    this.translationRegistry = registry;
+  setTranslationRegistry(registry2) {
+    this.translationRegistry = registry2;
   }
   async getAll(language) {
     if (IS_DEV) {
@@ -3549,6 +3981,10 @@ var ResourceConfigRegistry = class {
     }
     return config;
   }
+  async findById(id, language) {
+    const all = await this.getAll(language);
+    return all.find((c) => c.id === id);
+  }
   /**
   * On-disk directory containing `route`'s `resource.json`, if known.
   * Only meaningful after a load has populated the loader's internal map —
@@ -3614,7 +4050,7 @@ function _ts_metadata2(metadataKey, metadataValue) {
   }
 }
 __name(_ts_metadata2, "_ts_metadata");
-var createAppLayoutController = /* @__PURE__ */ __name((configs, sidebarGroups = {}, title, autoSave = true, translationRegistry, i18nConfig) => {
+var createAppLayoutController = /* @__PURE__ */ __name((configs, sidebarGroups = {}, title, autoSave = true, translationRegistry, i18nConfig, prefix) => {
   const layoutPayload = buildLayoutPayload(configs, sidebarGroups, title, autoSave, IS_DEV);
   let AppLayoutController = class AppLayoutController {
     static {
@@ -3692,7 +4128,7 @@ var createAppLayoutController = /* @__PURE__ */ __name((configs, sidebarGroups =
     _ts_metadata2("design:returntype", void 0)
   ], AppLayoutController.prototype, "getTranslations", null);
   AppLayoutController = _ts_decorate2([
-    (0, import_common2.Controller)("_app"),
+    (0, import_common2.Controller)(prefix ? `${prefix}/_app` : "_app"),
     (0, import_swagger.ApiTags)("App"),
     _ts_metadata2("design:type", Function),
     _ts_metadata2("design:paramtypes", [
@@ -3704,9 +4140,9 @@ var createAppLayoutController = /* @__PURE__ */ __name((configs, sidebarGroups =
   ], AppLayoutController);
   return AppLayoutController;
 }, "createAppLayoutController");
-var translateSidebarGroups = /* @__PURE__ */ __name((groups, language, registry) => {
-  if (!registry?.active) return groups;
-  const t = registry.translatorFor(language);
+var translateSidebarGroups = /* @__PURE__ */ __name((groups, language, registry2) => {
+  if (!registry2?.active) return groups;
+  const t = registry2.translatorFor(language);
   const translated = {};
   for (const [slug, cfg] of Object.entries(groups)) {
     const label = t(sidebarGroupKey(slug), cfg.label);
@@ -3717,9 +4153,9 @@ var translateSidebarGroups = /* @__PURE__ */ __name((groups, language, registry)
   }
   return translated;
 }, "translateSidebarGroups");
-var translateTitle = /* @__PURE__ */ __name((title, language, registry) => {
-  if (!title || !registry?.active) return title;
-  const t = registry.translatorFor(language);
+var translateTitle = /* @__PURE__ */ __name((title, language, registry2) => {
+  if (!title || !registry2?.active) return title;
+  const t = registry2.translatorFor(language);
   return t("app.title", title);
 }, "translateTitle");
 
@@ -3944,49 +4380,49 @@ init_cjs_shims();
 
 // src/lib/crud/action/action.types.ts
 init_cjs_shims();
-var import_zod26 = require("zod");
-var ActionMetadataSchema = import_zod26.z.object({
+var import_zod36 = require("zod");
+var ActionMetadataSchema2 = import_zod36.z.object({
   /** URL segment used in the endpoint. */
-  id: import_zod26.z.string(),
+  id: import_zod36.z.string(),
   /** Human-readable label shown as a button. */
-  label: import_zod26.z.string().optional(),
+  label: import_zod36.z.string().optional(),
   /** MDI icon name, e.g. `"mdi:open-in-new"`. */
-  icon: import_zod26.z.string().optional(),
+  icon: import_zod36.z.string().optional(),
   /** Tooltip text. Falls back to `label` when omitted. */
-  tooltip: import_zod26.z.string().optional(),
+  tooltip: import_zod36.z.string().optional(),
   /** Per-row condition — button is hidden when false. */
-  condition: import_zod26.z.custom().optional()
+  condition: import_zod36.z.custom().optional()
 });
-var ResourceLinkActionSchema = ActionMetadataSchema.extend({
-  type: import_zod26.z.literal("link"),
+var ResourceLinkActionSchema2 = ActionMetadataSchema2.extend({
+  type: import_zod36.z.literal("link"),
   /** URL to open. May contain `{id}` or `{env.VAR}` placeholders. */
-  href: import_zod26.z.string()
+  href: import_zod36.z.string()
 });
-var ResourceRowProcedureActionSchema = ActionMetadataSchema.extend({
-  type: import_zod26.z.literal("procedure").optional(),
+var ResourceRowProcedureActionSchema2 = ActionMetadataSchema2.extend({
+  type: import_zod36.z.literal("procedure").optional(),
   /** HTTP method for the endpoint. Defaults to `"post"`. */
-  method: import_zod26.z.string().optional(),
+  method: import_zod36.z.string().optional(),
   /** Static data payload merged into the request body by the frontend. */
-  data: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.unknown()).optional(),
+  data: import_zod36.z.record(import_zod36.z.string(), import_zod36.z.unknown()).optional(),
   /** Procedure called with `(prisma, recordId)`. */
-  procedure: import_zod26.z.custom((v) => typeof v === "function")
+  procedure: import_zod36.z.custom((v) => typeof v === "function")
 });
-var ResourceTableProcedureActionSchema = ActionMetadataSchema.extend({
-  type: import_zod26.z.literal("procedure").optional(),
+var ResourceTableProcedureActionSchema2 = ActionMetadataSchema2.extend({
+  type: import_zod36.z.literal("procedure").optional(),
   /** HTTP method for the endpoint. Defaults to `"post"`. */
-  method: import_zod26.z.string().optional(),
+  method: import_zod36.z.string().optional(),
   /** Static data payload merged into the request body by the frontend. */
-  data: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.unknown()).optional(),
+  data: import_zod36.z.record(import_zod36.z.string(), import_zod36.z.unknown()).optional(),
   /** Procedure called with `(prisma)` — no record id. */
-  procedure: import_zod26.z.custom((v) => typeof v === "function")
+  procedure: import_zod36.z.custom((v) => typeof v === "function")
 });
-var ResourceRowActionSchema = import_zod26.z.union([
-  ResourceRowProcedureActionSchema,
-  ResourceLinkActionSchema
+var ResourceRowActionSchema2 = import_zod36.z.union([
+  ResourceRowProcedureActionSchema2,
+  ResourceLinkActionSchema2
 ]);
-var ResourceTableActionSchema = import_zod26.z.union([
-  ResourceTableProcedureActionSchema,
-  ResourceLinkActionSchema
+var ResourceTableActionSchema2 = import_zod36.z.union([
+  ResourceTableProcedureActionSchema2,
+  ResourceLinkActionSchema2
 ]);
 var isRowProcedureAction = /* @__PURE__ */ __name((action) => action.type !== "link", "isRowProcedureAction");
 var isTableProcedureAction = /* @__PURE__ */ __name((action) => action.type !== "link", "isTableProcedureAction");
@@ -4022,17 +4458,17 @@ var loadActions = /* @__PURE__ */ __name(async (jsonActions, basePath, scope) =>
 }, "loadActions");
 
 // src/lib/crud/crud.config.ts
-var resolveDefinition = /* @__PURE__ */ __name((config) => {
+var resolveDefinition2 = /* @__PURE__ */ __name((config) => {
   const def2 = config.definition;
   return typeof def2 === "function" ? def2() : def2;
 }, "resolveDefinition");
-var isOperationEnabled = /* @__PURE__ */ __name((def2, op) => def2[op] != null, "isOperationEnabled");
-var schemaFor = /* @__PURE__ */ __name((def2, op) => {
+var isOperationEnabled2 = /* @__PURE__ */ __name((def2, op) => def2[op] != null, "isOperationEnabled");
+var schemaFor2 = /* @__PURE__ */ __name((def2, op) => {
   const entry = def2[op];
   if (!entry || entry === true) return void 0;
   return entry.schema;
 }, "schemaFor");
-var upsertOnFor = /* @__PURE__ */ __name((def2) => def2.upsert?.upsertOn, "upsertOnFor");
+var upsertOnFor2 = /* @__PURE__ */ __name((def2) => def2.upsert?.upsertOn, "upsertOnFor");
 var opSecurity = /* @__PURE__ */ __name((entry) => {
   if (!entry || entry === true) return void 0;
   return entry.security;
@@ -4048,7 +4484,7 @@ init_cjs_shims();
 
 // src/lib/crud/custom-repository/custom-repository.types.ts
 init_cjs_shims();
-var import_zod27 = require("zod");
+var import_zod37 = require("zod");
 var CUSTOM_OPS = [
   "findAll",
   "findOne",
@@ -4065,7 +4501,7 @@ var PARENT_METHOD = {
   patch: "patchByParent",
   delete: "deleteByParent"
 };
-var CustomRepositorySchema = import_zod27.z.custom((value) => typeof value === "object" && value !== null);
+var CustomRepositorySchema = import_zod37.z.custom((value) => typeof value === "object" && value !== null);
 
 // src/lib/crud/custom-repository/custom-repository.loader.ts
 init_cjs_shims();
@@ -4148,6 +4584,7 @@ var DEFAULT_ID_FIELD = "id";
 
 // src/lib/crud/data-source/prisma.adapter.ts
 init_cjs_shims();
+var DB_CHECK_TIMEOUT_MS = 3e3;
 var PrismaDataSourceAdapter = class {
   static {
     __name(this, "PrismaDataSourceAdapter");
@@ -4160,6 +4597,13 @@ var PrismaDataSourceAdapter = class {
   supports(model) {
     return typeof this.client?.[model] !== "undefined";
   }
+  async healthCheck() {
+    const c = this.client;
+    await Promise.race([
+      c.$queryRaw`SELECT 1`,
+      new Promise((_, reject) => setTimeout(() => reject(new Error("Database health check timed out")), DB_CHECK_TIMEOUT_MS))
+    ]);
+  }
   async disconnect() {
     const c = this.client;
     if (typeof c?.$disconnect === "function") {
@@ -4203,8 +4647,8 @@ var LanguageInterceptor = class {
     __name(this, "LanguageInterceptor");
   }
   registry;
-  constructor(registry) {
-    this.registry = registry;
+  constructor(registry2) {
+    this.registry = registry2;
   }
   intercept(context, next) {
     const http = context.switchToHttp();
@@ -4245,7 +4689,7 @@ var unsupported = /* @__PURE__ */ __name((config, op) => {
 }, "unsupported");
 var createCustomRepository = /* @__PURE__ */ __name((prisma, config, dataSources, repository, configRegistry) => {
   const adapter = new PrismaDataSourceAdapter(prisma);
-  const repo = repository ?? {};
+  const repo = repository ?? (prisma && typeof prisma === "object" ? prisma : {});
   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;
@@ -4401,13 +4845,18 @@ var createCustomRepository = /* @__PURE__ */ __name((prisma, config, dataSources
 
 // src/lib/crud/custom-repository/custom-repository.validate.ts
 init_cjs_shims();
-var validateCustomRepository = /* @__PURE__ */ __name((config, repository) => {
-  const definition = resolveDefinition(config);
-  const enabled = CUSTOM_OPS.filter((op) => isOperationEnabled(definition, op));
+var validateCustomRepository = /* @__PURE__ */ __name((config, repository, adapterClient) => {
+  const definition = resolveDefinition2(config);
+  const enabled = CUSTOM_OPS.filter((op) => isOperationEnabled2(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"}.`;
+    if (enabled.length === 0) return void 0;
+    if (adapterClient && typeof adapterClient === "object") {
+      const missing2 = enabled.filter((op) => typeof adapterClient[methodFor(op)] !== "function");
+      if (missing2.length === 0) return void 0;
+    }
+    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(", ")}.`;
   }
   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)));
@@ -5048,10 +5497,10 @@ var ReadRepository = class {
 
 // src/lib/crud/schema.utils.ts
 init_cjs_shims();
-var import_zod29 = require("zod");
+var import_zod39 = require("zod");
 init_src();
 function isZodSchema(schema) {
-  return schema instanceof import_zod29.ZodObject;
+  return schema instanceof import_zod39.ZodObject;
 }
 __name(isZodSchema, "isZodSchema");
 var isNullableProperty2 = /* @__PURE__ */ __name((property) => {
@@ -5063,11 +5512,11 @@ var dropNullableFromRequired2 = /* @__PURE__ */ __name((jsonSchema) => {
   if (!properties || !Array.isArray(required)) return;
   jsonSchema.required = required.filter((key) => !isNullableProperty2(properties[key]));
 }, "dropNullableFromRequired");
-function toJsonSchema(schema) {
+function toJsonSchema2(schema) {
   if (isZodSchema(schema)) {
     let jsonSchema;
     try {
-      jsonSchema = (0, import_zod29.toJSONSchema)(schema, {
+      jsonSchema = (0, import_zod39.toJSONSchema)(schema, {
         target: "openApi3",
         ...jsonSchemaOpts
       });
@@ -5081,7 +5530,7 @@ function toJsonSchema(schema) {
   }
   return schema;
 }
-__name(toJsonSchema, "toJsonSchema");
+__name(toJsonSchema2, "toJsonSchema");
 var unwrap = /* @__PURE__ */ __name((schema) => {
   let s = schema;
   let t = s?._zod?.def?.type;
@@ -5180,7 +5629,7 @@ var WriteRepository = class {
     return new import_common8.NotFoundException(`${this.config.name} with id ${id} not found`);
   }
   upsertWhere(data) {
-    const keys = upsertOnFor(resolveDefinition(this.config));
+    const keys = upsertOnFor2(resolveDefinition2(this.config));
     if (!keys) throw new import_common8.BadRequestException(`${this.config.name} has no upsertOn configured`);
     if (typeof keys === "string") return {
       [keys]: data[keys]
@@ -5471,9 +5920,9 @@ function createCrudRepository(prisma, config, dataSources, configRegistry) {
   if (!model) {
     throw new Error(`Model "${config.model}" not found on the provided PrismaClient. Check the resource config for "${config.name}".`);
   }
-  const definition = resolveDefinition(config);
-  const listSchema = schemaFor(definition, "findAll");
-  const oneSchema = schemaFor(definition, "findOne");
+  const definition = resolveDefinition2(config);
+  const listSchema = schemaFor2(definition, "findAll");
+  const oneSchema = schemaFor2(definition, "findOne");
   const listSelect = listSchema ? toSelectFields(listSchema) : void 0;
   const oneSelect = oneSchema ? toSelectFields(oneSchema) : listSelect;
   const adapter = new PrismaDataSourceAdapter(prisma);
@@ -5819,9 +6268,9 @@ var CroutonSecurityGuard = class {
   reflector;
   registry;
   moduleRef;
-  constructor(reflector, registry, moduleRef) {
+  constructor(reflector, registry2, moduleRef) {
     this.reflector = reflector;
-    this.registry = registry;
+    this.registry = registry2;
     this.moduleRef = moduleRef;
   }
   async canActivate(context) {
@@ -5922,7 +6371,7 @@ init_cjs_shims();
 var import_common13 = require("@nestjs/common");
 var import_swagger3 = require("@nestjs/swagger");
 var defaultCreate = /* @__PURE__ */ __name((ctx) => {
-  if (!isOperationEnabled(ctx.definition, "create")) return null;
+  if (!isOperationEnabled2(ctx.definition, "create")) return null;
   const { cls, config, createSchema, bodyDecorator } = ctx;
   const methodName = "create";
   return {
@@ -5941,7 +6390,7 @@ var defaultCreate = /* @__PURE__ */ __name((ctx) => {
   };
 }, "defaultCreate");
 var childCreate = /* @__PURE__ */ __name((sub) => (ctx) => {
-  if (!isOperationEnabled(sub.operations, "create")) return null;
+  if (!isOperationEnabled2(sub.operations, "create")) return null;
   const { cls } = ctx;
   const methodName = `createChild_${sub.childRoute}`;
   const createFn = /* @__PURE__ */ __name(async function(id, body, req) {
@@ -5985,7 +6434,7 @@ init_cjs_shims();
 var import_common14 = require("@nestjs/common");
 var import_swagger4 = require("@nestjs/swagger");
 var defaultDelete = /* @__PURE__ */ __name((ctx) => {
-  if (!isOperationEnabled(ctx.definition, "delete")) return null;
+  if (!isOperationEnabled2(ctx.definition, "delete")) return null;
   const { config } = ctx;
   const methodName = "delete";
   const { name } = config;
@@ -6001,7 +6450,7 @@ var defaultDelete = /* @__PURE__ */ __name((ctx) => {
   };
 }, "defaultDelete");
 var deleteChild = /* @__PURE__ */ __name((sub) => (ctx) => {
-  if (!isOperationEnabled(sub.operations, "delete")) return null;
+  if (!isOperationEnabled2(sub.operations, "delete")) return null;
   const { cls } = ctx;
   const methodName = `deleteChild_${sub.childRoute}`;
   const deleteFn = /* @__PURE__ */ __name(async function(childId, parentId, req) {
@@ -6049,14 +6498,14 @@ var import_swagger5 = require("@nestjs/swagger");
 
 // src/lib/crud/request.dto.ts
 init_cjs_shims();
-var import_zod_nestjs = require("@anatine/zod-nestjs");
+var import_nestjs_zod = require("nestjs-zod");
 init_src();
-var RequestDtoNoOffset = class extends (0, import_zod_nestjs.createZodDto)(RequestSchema) {
+var RequestDtoNoOffset = class extends (0, import_nestjs_zod.createZodDto)(RequestSchema) {
   static {
     __name(this, "RequestDtoNoOffset");
   }
 };
-var RequestDto = class extends (0, import_zod_nestjs.createZodDto)(RequestSchemaWithOffset) {
+var RequestDto = class extends (0, import_nestjs_zod.createZodDto)(RequestSchemaWithOffset) {
   static {
     __name(this, "RequestDto");
   }
@@ -6179,7 +6628,7 @@ var findAllByParent = /* @__PURE__ */ __name(async (repo, id, childRoute, params
   };
 }, "findAllByParent");
 var defaultFindAll = /* @__PURE__ */ __name((ctx) => {
-  if (!isOperationEnabled(ctx.definition, "findAll")) return;
+  if (!isOperationEnabled2(ctx.definition, "findAll")) return;
   const { config } = ctx;
   const lookupLabel = config.lookup?.label;
   const findAll = /* @__PURE__ */ __name(async function(params, q, req) {
@@ -6196,7 +6645,7 @@ var defaultFindAll = /* @__PURE__ */ __name((ctx) => {
   };
 }, "defaultFindAll");
 var childFindAll = /* @__PURE__ */ __name((sub) => (ctx) => {
-  if (!isOperationEnabled(sub.operations, "findAll")) return;
+  if (!isOperationEnabled2(sub.operations, "findAll")) return;
   const { cls } = ctx;
   const methodName = `findAllBy_${sub.childRoute}`;
   const findAll = /* @__PURE__ */ __name(async function(params, q, id, req) {
@@ -6224,7 +6673,7 @@ var registerFindAll = /* @__PURE__ */ __name((ctx, sub) => {
   def(cls, methodName, properties.findAll);
   const d = desc(cls, methodName);
   (0, import_common15.Get)(route)(cls.prototype, methodName, d);
-  (0, import_common15.Query)(new ZodValidationPipe(RequestDtoNoOffset.zodSchema))(cls.prototype, methodName, 0);
+  (0, import_common15.Query)(new ZodValidationPipe(RequestDtoNoOffset.schema))(cls.prototype, methodName, 0);
   (0, import_common15.Query)("q")(cls.prototype, methodName, 1);
   if (!sub) (0, import_common15.Req)()(cls.prototype, methodName, 2);
   (0, import_swagger5.ApiOperation)({
@@ -6236,7 +6685,7 @@ var registerFindAll = /* @__PURE__ */ __name((ctx, sub) => {
     ...listSchema && {
       schema: {
         type: "array",
-        items: toJsonSchema(listSchema)
+        items: toJsonSchema2(listSchema)
       }
     }
   })(cls.prototype, methodName, d);
@@ -6249,7 +6698,7 @@ init_cjs_shims();
 var import_common16 = require("@nestjs/common");
 var import_swagger6 = require("@nestjs/swagger");
 var defaultFindOne = /* @__PURE__ */ __name((ctx) => {
-  if (!isOperationEnabled(ctx.definition, "findOne")) return null;
+  if (!isOperationEnabled2(ctx.definition, "findOne")) return null;
   const { cls, config } = ctx;
   const methodName = "findOne";
   return {
@@ -6266,7 +6715,7 @@ var defaultFindOne = /* @__PURE__ */ __name((ctx) => {
   };
 }, "defaultFindOne");
 var childFindOne = /* @__PURE__ */ __name((sub) => (ctx) => {
-  if (!isOperationEnabled(sub.operations, "findOne")) return null;
+  if (!isOperationEnabled2(sub.operations, "findOne")) return null;
   const { cls } = ctx;
   const methodName = `findOneChild_${sub.childRoute}`;
   const findOneFn = /* @__PURE__ */ __name(async function(parentId, childId, req) {
@@ -6302,7 +6751,7 @@ var registerFindOne = /* @__PURE__ */ __name((ctx, sub) => {
     status: 200,
     description: `The ${name}`,
     ...ctx.oneSchema && {
-      schema: toJsonSchema(ctx.oneSchema)
+      schema: toJsonSchema2(ctx.oneSchema)
     }
   })(cls.prototype, methodName, d);
   (0, import_swagger6.ApiNotFoundResponse)({
@@ -6317,7 +6766,7 @@ init_cjs_shims();
 var import_common17 = require("@nestjs/common");
 var import_swagger7 = require("@nestjs/swagger");
 var defaultPatch = /* @__PURE__ */ __name((ctx) => {
-  if (!isOperationEnabled(ctx.definition, "patch")) return null;
+  if (!isOperationEnabled2(ctx.definition, "patch")) return null;
   const { cls, config, patchSchema, bodyDecorator } = ctx;
   const methodName = "patch";
   return {
@@ -6335,7 +6784,7 @@ var defaultPatch = /* @__PURE__ */ __name((ctx) => {
   };
 }, "defaultPatch");
 var childPatch = /* @__PURE__ */ __name((sub) => (ctx) => {
-  if (!isOperationEnabled(sub.operations, "patch")) return null;
+  if (!isOperationEnabled2(sub.operations, "patch")) return null;
   const { cls } = ctx;
   const methodName = `patchChild_${sub.childRoute}`;
   const patchFn = /* @__PURE__ */ __name(async function(_id, childId, body, req) {
@@ -6386,26 +6835,26 @@ init_dev_mode();
 
 // src/lib/crud/resource/PatchResourceJson.schema.ts
 init_cjs_shims();
-var import_zod30 = require("zod");
-var FieldVariantPatchSchema = import_zod30.z.object({
-  type: import_zod30.z.string().nullable().optional(),
-  format: import_zod30.z.string().nullable().optional(),
-  resource: import_zod30.z.string().nullable().optional(),
-  position: import_zod30.z.number().nullable().optional(),
-  options: import_zod30.z.record(import_zod30.z.string(), import_zod30.z.unknown().nullable()).optional()
+var import_zod40 = require("zod");
+var FieldVariantPatchSchema = import_zod40.z.object({
+  type: import_zod40.z.string().nullable().optional(),
+  format: import_zod40.z.string().nullable().optional(),
+  resource: import_zod40.z.string().nullable().optional(),
+  position: import_zod40.z.number().nullable().optional(),
+  options: import_zod40.z.record(import_zod40.z.string(), import_zod40.z.unknown().nullable()).optional()
 }).partial();
-var PatchColumnSchema = import_zod30.z.object({
-  label: import_zod30.z.string().optional(),
-  column: import_zod30.z.string().optional(),
-  hiddenInTable: import_zod30.z.boolean().optional(),
-  hiddenInForm: import_zod30.z.boolean().optional(),
-  hiddenInView: import_zod30.z.boolean().optional(),
+var PatchColumnSchema = import_zod40.z.object({
+  label: import_zod40.z.string().optional(),
+  column: import_zod40.z.string().optional(),
+  hiddenInTable: import_zod40.z.boolean().optional(),
+  hiddenInForm: import_zod40.z.boolean().optional(),
+  hiddenInView: import_zod40.z.boolean().optional(),
   fieldInput: FieldVariantPatchSchema.optional(),
   fieldView: FieldVariantPatchSchema.optional(),
   fieldTable: FieldVariantPatchSchema.optional()
 }).partial();
-var PatchResourceJsonSchema = import_zod30.z.object({
-  columns: import_zod30.z.record(import_zod30.z.string(), PatchColumnSchema)
+var PatchResourceJsonSchema = import_zod40.z.object({
+  columns: import_zod40.z.record(import_zod40.z.string(), PatchColumnSchema)
 });
 
 // src/lib/crud/resource/WriteResourceJson.ts
@@ -6468,7 +6917,7 @@ var applyColumnPatch = /* @__PURE__ */ __name((raw, patch) => {
 }, "applyColumnPatch");
 var serializeResourceJson = /* @__PURE__ */ __name((config) => `${JSON.stringify(config, null, 2)}
 `, "serializeResourceJson");
-var validateResourceJson = /* @__PURE__ */ __name((raw) => ResourceJsonSchema.safeParse(raw), "validateResourceJson");
+var validateResourceJson = /* @__PURE__ */ __name((raw) => buildResourceJsonSchema().safeParse(raw), "validateResourceJson");
 var writeRawResourceJson = /* @__PURE__ */ __name((jsonPath, raw) => {
   (0, import_node_fs6.writeFileSync)(jsonPath, serializeResourceJson(raw), "utf-8");
 }, "writeRawResourceJson");
@@ -6476,6 +6925,12 @@ var writeRawResourceJson = /* @__PURE__ */ __name((jsonPath, raw) => {
 // src/lib/crud/operations/payload-builders.ts
 init_cjs_shims();
 init_src();
+var pickExtensions = /* @__PURE__ */ __name((config) => Object.fromEntries([
+  ...getResourceExtensions().keys()
+].filter((k) => config[k] !== void 0).map((k) => [
+  k,
+  config[k]
+])), "pickExtensions");
 var resolveEnvPlaceholders = /* @__PURE__ */ __name((value) => value.replace(/\{env\.([^}]+)\}/g, (match, varName) => process.env[varName] ?? match), "resolveEnvPlaceholders");
 var RESOURCE_OPS = [
   "findAll",
@@ -6501,22 +6956,22 @@ var OP_SUFFIX = {
   patch: "/{id}",
   delete: "/{id}"
 };
-var buildResourceOperations = /* @__PURE__ */ __name((definition, baseUri) => Object.fromEntries(RESOURCE_OPS.filter((op) => isOperationEnabled(definition, op)).map((op) => [
+var buildResourceOperations = /* @__PURE__ */ __name((definition, baseUri) => Object.fromEntries(RESOURCE_OPS.filter((op) => isOperationEnabled2(definition, op)).map((op) => [
   op,
   {
     uri: `${baseUri}${OP_SUFFIX[op]}`,
     method: OP_METHOD[op]
   }
 ])), "buildResourceOperations");
-var buildDefinitionPayload = /* @__PURE__ */ __name((config) => {
+var buildDefinitionPayload2 = /* @__PURE__ */ __name((config) => {
   const { route, name, tag, idType = "string" } = config;
-  const definition = resolveDefinition(config);
-  const listSchema = schemaFor(definition, "findAll");
-  const oneSchema = schemaFor(definition, "findOne") ?? listSchema;
-  const createSchema = schemaFor(definition, "create");
-  const updateSchema = schemaFor(definition, "update");
-  const patchSchema = schemaFor(definition, "patch");
-  const upsertSchema = schemaFor(definition, "upsert") ?? createSchema;
+  const definition = resolveDefinition2(config);
+  const listSchema = schemaFor2(definition, "findAll");
+  const oneSchema = schemaFor2(definition, "findOne") ?? listSchema;
+  const createSchema = schemaFor2(definition, "create");
+  const updateSchema = schemaFor2(definition, "update");
+  const patchSchema = schemaFor2(definition, "patch");
+  const upsertSchema = schemaFor2(definition, "upsert") ?? createSchema;
   const operations = [
     "findAll",
     "findOne",
@@ -6525,44 +6980,45 @@ var buildDefinitionPayload = /* @__PURE__ */ __name((config) => {
     "patch",
     "upsert",
     "delete"
-  ].filter((op) => isOperationEnabled(definition, op));
+  ].filter((op) => isOperationEnabled2(definition, op));
   return {
     name,
     route,
     idType,
     tag,
     operations,
-    upsertOn: upsertOnFor(definition),
+    upsertOn: upsertOnFor2(definition),
     display: config.display,
     schemas: {
       ...listSchema && {
-        findAll: toJsonSchema(listSchema)
+        findAll: toJsonSchema2(listSchema)
       },
       ...oneSchema && {
-        findOne: toJsonSchema(oneSchema)
+        findOne: toJsonSchema2(oneSchema)
       },
       ...createSchema && {
-        create: toJsonSchema(createSchema)
+        create: toJsonSchema2(createSchema)
       },
       ...updateSchema && {
-        update: toJsonSchema(updateSchema)
+        update: toJsonSchema2(updateSchema)
       },
       ...patchSchema && {
-        patch: toJsonSchema(patchSchema)
+        patch: toJsonSchema2(patchSchema)
       },
-      ...isOperationEnabled(definition, "upsert") && upsertSchema ? {
-        upsert: toJsonSchema(upsertSchema)
+      ...isOperationEnabled2(definition, "upsert") && upsertSchema ? {
+        upsert: toJsonSchema2(upsertSchema)
       } : {}
-    }
+    },
+    ...pickExtensions(config)
   };
 }, "buildDefinitionPayload");
-var buildResourceJsonPayload = /* @__PURE__ */ __name((config, baseUrl) => {
+var buildResourceJsonPayload2 = /* @__PURE__ */ __name((config, baseUrl) => {
   const { name, route } = config;
-  const definition = resolveDefinition(config);
+  const definition = resolveDefinition2(config);
   const uri = `${baseUrl}/${route}`;
   const operations = Object.fromEntries(RESOURCE_OPS.map((op) => [
     op,
-    isOperationEnabled(definition, op)
+    isOperationEnabled2(definition, op)
   ]));
   operations.lookup = `${uri}?q={text}`;
   const form = config.views?.["form"];
@@ -6571,10 +7027,11 @@ var buildResourceJsonPayload = /* @__PURE__ */ __name((config, baseUrl) => {
     ui: form.ui_schema
   } : null;
   return {
-    id: name,
+    id: config.id ?? route,
     uri,
     operations,
-    schema
+    schema,
+    ...pickExtensions(config)
   };
 }, "buildResourceJsonPayload");
 var _resolveActions = /* @__PURE__ */ __name((baseUrl, actions) => {
@@ -6597,12 +7054,12 @@ var resolveActions = /* @__PURE__ */ __name((baseUrl, actions) => {
     "{id}"
   ], actions);
 }, "resolveActions");
-var buildViewsPayload = /* @__PURE__ */ __name((config, baseUrl) => {
+var buildViewsPayload2 = /* @__PURE__ */ __name((config, baseUrl) => {
   if (!config.views || !Object.keys(config.views).length) return void 0;
-  const definition = resolveDefinition(config);
+  const definition = resolveDefinition2(config);
   const baseUri = config.parent ? `${baseUrl}/${config.parent.route}/{${config.parent.param}}/${config.route}` : `${baseUrl}/${config.route}`;
   const operations = buildResourceOperations(definition, baseUri);
-  if (isOperationEnabled(definition, "findAll")) {
+  if (isOperationEnabled2(definition, "findAll")) {
     operations["lookup"] = `${baseUri}?q={text}`;
   }
   const schemas = Object.fromEntries(Object.entries(config.views).map(([key, v]) => [
@@ -6617,7 +7074,7 @@ var buildViewsPayload = /* @__PURE__ */ __name((config, baseUrl) => {
   ]));
   const baseAction = `${baseUri}${config.route}`;
   return {
-    id: config.name,
+    id: config.id ?? config.route,
     name: config.name,
     route: config.route,
     uri: baseUri,
@@ -6631,7 +7088,8 @@ var buildViewsPayload = /* @__PURE__ */ __name((config, baseUrl) => {
     display: config.display,
     schemas,
     actions: resolveActions(baseAction, config.actions),
-    tableActions: resolveActions(baseAction, config.tableActions)
+    tableActions: resolveActions(baseAction, config.tableActions),
+    ...pickExtensions(config)
   };
 }, "buildViewsPayload");
 var buildSubResourceViewsPayload = /* @__PURE__ */ __name((config, sub, baseUrl) => {
@@ -6691,16 +7149,21 @@ var buildEditableColumnsPayload = /* @__PURE__ */ __name((config) => {
 // src/lib/crud/operations/register-schema-endpoints.ts
 var import_node_path9 = require("path");
 var registerDefinitionEndpoint = /* @__PURE__ */ __name((ctx) => {
-  const { cls, config } = ctx;
+  const { cls, config, schemaEnricher } = ctx;
   const { route, name } = config;
-  const definitionPayload = buildDefinitionPayload(config);
+  const definitionPayload = buildDefinitionPayload2(config);
   def(cls, "getDefinition", async function() {
     const language = getRequestLanguage();
+    let payload = definitionPayload;
     if (IS_DEV || language) {
       const fresh = await this.configRegistry.getByRoute(route, language);
-      if (fresh) return buildDefinitionPayload(fresh);
+      if (fresh) payload = buildDefinitionPayload2(fresh);
     }
-    return definitionPayload;
+    if (!schemaEnricher) return payload;
+    return {
+      ...payload,
+      ...schemaEnricher(payload)
+    };
   });
   const d = desc(cls, "getDefinition");
   (0, import_common18.Get)("definition")(cls.prototype, "getDefinition", d);
@@ -6717,16 +7180,21 @@ var registerDefinitionEndpoint = /* @__PURE__ */ __name((ctx) => {
   }
 }, "registerDefinitionEndpoint");
 var registerResourceJsonEndpoint = /* @__PURE__ */ __name((ctx) => {
-  const { cls, config, baseUrl } = ctx;
+  const { cls, config, baseUrl, schemaEnricher } = ctx;
   const { route, name } = config;
-  const resourceJsonPayload = buildResourceJsonPayload(config, baseUrl);
+  const resourceJsonPayload = buildResourceJsonPayload2(config, baseUrl);
   def(cls, "getResourceJson", async function() {
     const language = getRequestLanguage();
+    let payload = resourceJsonPayload;
     if (IS_DEV || language) {
       const fresh = await this.configRegistry.getByRoute(route, language);
-      if (fresh) return buildResourceJsonPayload(fresh, baseUrl);
+      if (fresh) payload = buildResourceJsonPayload2(fresh, baseUrl);
     }
-    return resourceJsonPayload;
+    if (!schemaEnricher) return payload;
+    return {
+      ...payload,
+      ...schemaEnricher(payload)
+    };
   });
   const d = desc(cls, "getResourceJson");
   (0, import_common18.Get)("resource.json")(cls.prototype, "getResourceJson", d);
@@ -6866,20 +7334,25 @@ var import_common19 = require("@nestjs/common");
 var import_swagger9 = require("@nestjs/swagger");
 init_dev_mode();
 var defaultSchemas = /* @__PURE__ */ __name((ctx) => {
-  const { config, baseUrl } = ctx;
+  const { config, baseUrl, schemaEnricher } = ctx;
   const { route, name } = config;
-  const viewsPayload = buildViewsPayload(config, baseUrl);
+  const viewsPayload = buildViewsPayload2(config, baseUrl);
   return {
     route: "schemas",
     methodName: "getSchemas",
     name,
     schemasFn: /* @__PURE__ */ __name(async function() {
       const language = getRequestLanguage();
+      let payload = viewsPayload;
       if (IS_DEV || language) {
         const fresh = await this.configRegistry.getByRoute(route, language);
-        if (fresh) return buildViewsPayload(fresh, baseUrl) ?? viewsPayload;
+        if (fresh) payload = buildViewsPayload2(fresh, baseUrl) ?? viewsPayload;
       }
-      return viewsPayload;
+      if (!payload || !schemaEnricher) return payload;
+      return {
+        ...payload,
+        ...schemaEnricher(payload)
+      };
     }, "schemasFn"),
     decorators: /* @__PURE__ */ __name(() => {
     }, "decorators")
@@ -6928,7 +7401,7 @@ init_cjs_shims();
 var import_common20 = require("@nestjs/common");
 var import_swagger10 = require("@nestjs/swagger");
 var defaultUpdate = /* @__PURE__ */ __name((ctx) => {
-  if (!isOperationEnabled(ctx.definition, "update")) return null;
+  if (!isOperationEnabled2(ctx.definition, "update")) return null;
   const { cls, config, updateSchema, bodyDecorator } = ctx;
   const methodName = "update";
   return {
@@ -6946,7 +7419,7 @@ var defaultUpdate = /* @__PURE__ */ __name((ctx) => {
   };
 }, "defaultUpdate");
 var childUpdate = /* @__PURE__ */ __name((sub) => (ctx) => {
-  if (!isOperationEnabled(sub.operations, "update")) return null;
+  if (!isOperationEnabled2(sub.operations, "update")) return null;
   const { cls } = ctx;
   const methodName = `updateChild_${sub.childRoute}`;
   const updateFn = /* @__PURE__ */ __name(async function(_id, childId, body, req) {
@@ -7019,17 +7492,17 @@ var registerEndpoint = /* @__PURE__ */ __name((ctx, sub) => {
 }, "registerEndpoint");
 
 // src/lib/crud/crud-controller.factory.ts
-function createCrudController(config, baseUrl, moduleDefaultSecurity, securityEnabled = false) {
+function createCrudController(config, baseUrl, moduleDefaultSecurity, securityEnabled = false, prefix, schemaEnricher) {
   const { route, name, tag, idType = "string" } = config;
-  const definition = resolveDefinition(config);
-  const listSchema = schemaFor(definition, "findAll");
-  const oneSchema = schemaFor(definition, "findOne") ?? listSchema;
-  const createSchema = schemaFor(definition, "create");
-  const updateSchema = schemaFor(definition, "update");
-  const explicitPatchSchema = schemaFor(definition, "patch");
+  const definition = resolveDefinition2(config);
+  const listSchema = schemaFor2(definition, "findAll");
+  const oneSchema = schemaFor2(definition, "findOne") ?? listSchema;
+  const createSchema = schemaFor2(definition, "create");
+  const updateSchema = schemaFor2(definition, "update");
+  const explicitPatchSchema = schemaFor2(definition, "patch");
   const patchSchema = explicitPatchSchema ?? (updateSchema && isZodSchema(updateSchema) ? updateSchema.partial() : void 0) ?? updateSchema;
-  const upsertSchema = schemaFor(definition, "upsert") ?? createSchema;
-  if (isOperationEnabled(definition, "upsert") && !upsertOnFor(definition)) {
+  const upsertSchema = schemaFor2(definition, "upsert") ?? createSchema;
+  if (isOperationEnabled2(definition, "upsert") && !upsertOnFor2(definition)) {
     throw new Error(`Resource "${name}" declares 'upsert' but no upsertOn`);
   }
   const bodyDecorator = /* @__PURE__ */ __name((schema, options) => {
@@ -7037,9 +7510,9 @@ function createCrudController(config, baseUrl, moduleDefaultSecurity, securityEn
     if (isZodSchema(schema)) return (0, import_common21.Body)(new ZodValidationPipe(schema, options));
     return (0, import_common21.Body)();
   }, "bodyDecorator");
-  const resolveClient = /* @__PURE__ */ __name((registry, resource) => {
+  const resolveClient = /* @__PURE__ */ __name((registry2, resource) => {
     try {
-      return registry.resolve(resource.database);
+      return registry2.resolve(resource.database);
     } catch (e) {
       if (resource.kind === "custom") return void 0;
       throw e;
@@ -7051,9 +7524,9 @@ function createCrudController(config, baseUrl, moduleDefaultSecurity, securityEn
     }
     repo;
     configRegistry;
-    constructor(registry, configRegistry) {
-      const prisma = resolveClient(registry, config);
-      this.repo = createCrudRepository(prisma, config, registry, configRegistry);
+    constructor(registry2, configRegistry) {
+      const prisma = resolveClient(registry2, config);
+      this.repo = createCrudRepository(prisma, config, registry2, configRegistry);
       this.configRegistry = configRegistry;
     }
   };
@@ -7080,10 +7553,12 @@ function createCrudController(config, baseUrl, moduleDefaultSecurity, securityEn
     bodyDecorator,
     baseUrl,
     moduleDefaultSecurity,
-    secure
+    secure,
+    schemaEnricher
   };
   registerEndpoints(ctx);
-  (0, import_common21.Controller)(resourceControllerPath(route, config.parent))(CrudControllerBase);
+  const controllerPath = resourceControllerPath(route, config.parent);
+  (0, import_common21.Controller)(prefix ? `${prefix}/${controllerPath}` : controllerPath)(CrudControllerBase);
   if (securityEnabled) {
     (0, import_common21.UseGuards)(CroutonSecurityGuard)(CrudControllerBase);
   }
@@ -7832,13 +8307,13 @@ var resolveFromRoot = /* @__PURE__ */ __name((root, p) => (0, import_node_path11
 
 // ../crouton-codegen/src/scaffold.ts
 init_cjs_shims();
-var import_zod31 = require("zod");
+var import_zod41 = require("zod");
 init_src();
 var import_promises5 = require("fs/promises");
 var import_node_path12 = require("path");
 var ScallfoldDatasourceSchema = DataSourceShape.extend({
   /** Folder name under `dataSourcesDir`. */
-  folder: import_zod31.z.string().default("default")
+  folder: import_zod41.z.string().default("default")
 }).transform(transformDataSource);
 
 // ../crouton-codegen/src/datasource-scaffold.ts
@@ -8727,12 +9202,12 @@ init_cjs_shims();
 
 // src/lib/crud/enum-registry/enum-registry.types.ts
 init_cjs_shims();
-var import_zod32 = require("zod");
-var EnumEntrySchema = import_zod32.z.object({
-  value: import_zod32.z.unknown(),
-  label: import_zod32.z.string()
+var import_zod42 = require("zod");
+var EnumEntrySchema2 = import_zod42.z.object({
+  value: import_zod42.z.unknown(),
+  label: import_zod42.z.string()
 });
-var EnumRegistrySchema = import_zod32.z.record(import_zod32.z.string(), import_zod32.z.array(EnumEntrySchema)).default({});
+var EnumRegistrySchema2 = import_zod42.z.record(import_zod42.z.string(), import_zod42.z.array(EnumEntrySchema2)).default({});
 
 // src/lib/crud/enum-registry/enum-registry.loader.ts
 init_cjs_shims();
@@ -8754,17 +9229,17 @@ var loadEnumRegistry = /* @__PURE__ */ __name((startDir, enumsFile) => {
       dir = parent;
     }
   }
-  if (!file || !(0, import_node_fs8.existsSync)(file)) return EnumRegistrySchema.parse(void 0);
+  if (!file || !(0, import_node_fs8.existsSync)(file)) return EnumRegistrySchema2.parse(void 0);
   try {
-    return EnumRegistrySchema.parse(JSON.parse((0, import_node_fs8.readFileSync)(file, "utf-8")));
+    return EnumRegistrySchema2.parse(JSON.parse((0, import_node_fs8.readFileSync)(file, "utf-8")));
   } catch {
-    return EnumRegistrySchema.parse(void 0);
+    return EnumRegistrySchema2.parse(void 0);
   }
 }, "loadEnumRegistry");
 
 // src/lib/crud/enum-registry/enum-registry.injector.ts
 init_cjs_shims();
-var injectEnumValues = /* @__PURE__ */ __name((columns, enums) => {
+var injectEnumValues2 = /* @__PURE__ */ __name((columns, enums) => {
   if (!columns) return;
   for (const col of columns) {
     if (!col.enum) continue;
@@ -8829,7 +9304,7 @@ var upsertOp = /* @__PURE__ */ __name((entry, schema) => {
   }
   return void 0;
 }, "upsertOp");
-var buildResourceDefinitions = /* @__PURE__ */ __name((schema, operations, enrichedColumns) => {
+var buildResourceDefinitions2 = /* @__PURE__ */ __name((schema, operations, enrichedColumns) => {
   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);
@@ -8864,9 +9339,9 @@ init_cjs_shims();
 
 // src/lib/crud/adapter/relation-type.ts
 init_cjs_shims();
-var import_zod33 = require("zod");
+var import_zod43 = require("zod");
 var unwrapZodType = /* @__PURE__ */ __name((type) => {
-  if (type instanceof import_zod33.ZodOptional || type instanceof import_zod33.ZodNullable) {
+  if (type instanceof import_zod43.ZodOptional || type instanceof import_zod43.ZodNullable) {
     return unwrapZodType(type.unwrap());
   }
   return type;
@@ -8876,7 +9351,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_zod33.ZodArray ? "oneToMany" : "manyToOne";
+  return inner instanceof import_zod43.ZodArray ? "oneToMany" : "manyToOne";
 }, "deriveRelationType");
 var deriveRelationTypeFromColumns = /* @__PURE__ */ __name((col, cols) => {
   const base = col.column ?? col.id;
@@ -8886,7 +9361,7 @@ var deriveRelationTypeFromColumns = /* @__PURE__ */ __name((col, cols) => {
   ]);
   return cols.some((c) => fkNames.has(c.id)) ? "manyToOne" : "oneToMany";
 }, "deriveRelationTypeFromColumns");
-var enrichRelationTypes = /* @__PURE__ */ __name((columns, schema) => {
+var enrichRelationTypes2 = /* @__PURE__ */ __name((columns, schema) => {
   if (!schema) return columns;
   return columns.map((col) => {
     const fi = col.fieldInput;
@@ -8907,7 +9382,7 @@ var enrichRelationTypes = /* @__PURE__ */ __name((columns, schema) => {
 }, "enrichRelationTypes");
 
 // src/lib/crud/adapter/column-enrichment.ts
-var enrichActionColumns = /* @__PURE__ */ __name((columns, parentRoute, subResources, baseUrl) => {
+var enrichActionColumns2 = /* @__PURE__ */ __name((columns, parentRoute, subResources, baseUrl) => {
   if (!columns) return columns;
   const base = baseUrl ?? "";
   return columns.map((col) => {
@@ -8971,7 +9446,7 @@ var enrichNestedRelationColumns = /* @__PURE__ */ __name((cols, dir, baseUrl) =>
     };
   });
 }, "enrichNestedRelationColumns");
-var enrichIncludeWithSort = /* @__PURE__ */ __name((include, columns) => {
+var enrichIncludeWithSort2 = /* @__PURE__ */ __name((include, columns) => {
   if (!include?.length) return include;
   return include.map((entry) => {
     const relationName = typeof entry === "string" ? entry : entry.relation;
@@ -9023,8 +9498,8 @@ var buildSubResources = /* @__PURE__ */ __name((columns, parentRoute, parentMode
     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 childColumns = applyRelationFormatDefault2(expandedChildColumns) ?? expandedChildColumns;
+    injectEnumValues2(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 ?? [];
@@ -9104,8 +9579,8 @@ var buildSubResources = /* @__PURE__ */ __name((columns, parentRoute, parentMode
           return {};
         })()
       },
-      ...buildValueLabelColumns(childColumns).length && {
-        valueLabelColumns: buildValueLabelColumns(childColumns)
+      ...buildValueLabelColumns2(childColumns).length && {
+        valueLabelColumns: buildValueLabelColumns2(childColumns)
       },
       relationType: c.fieldInput?.relationType ?? deriveRelationTypeFromColumns(c, columns)
     };
@@ -9113,13 +9588,19 @@ var buildSubResources = /* @__PURE__ */ __name((columns, parentRoute, parentMode
 }, "buildSubResources");
 
 // src/lib/crud/adapter/json-adapter.ts
+var pickExtensions2 = /* @__PURE__ */ __name((obj) => Object.fromEntries([
+  ...getResourceExtensions().keys()
+].filter((k) => obj[k] !== void 0).map((k) => [
+  k,
+  obj[k]
+])), "pickExtensions");
 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 columns = enrichRelationTypes2(applyRelationFormatDefault2(rawColumns) ?? rawColumns, schema);
+  injectEnumValues2(columns, enums);
   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 enrichedColumns = resolveColumnFieldVariants2(enrichResourceRefColumns(enrichActionColumns2(columns, json.route, subResources, baseUrl), dirPath, baseUrl) ?? columns);
   const calculatedColumns = json.calculatedColumns ?? [];
   let views = isCustom ? buildViewsFromColumnTypes(enrichedColumns) : buildViews(schema, enrichedColumns);
   if (views && calculatedColumns.length) {
@@ -9135,8 +9616,8 @@ var fromJson = /* @__PURE__ */ __name((json, schema, hooks, dirPath, baseUrl, ac
     }
   }
   const lookup = buildLookup(enrichedColumns);
-  const enrichedInclude = enrichIncludeWithSort(json.include, enrichedColumns);
-  const definition = buildResourceDefinitions(schema, json.operations, enrichedColumns);
+  const enrichedInclude = enrichIncludeWithSort2(json.include, enrichedColumns);
+  const definition = buildResourceDefinitions2(schema, json.operations, enrichedColumns);
   return {
     ...json,
     name: json.name,
@@ -9185,9 +9666,10 @@ var fromJson = /* @__PURE__ */ __name((json, schema, hooks, dirPath, baseUrl, ac
     ...json.modalSize && {
       modalSize: json.modalSize
     },
-    ...buildValueLabelColumns(enrichedColumns).length && {
-      valueLabelColumns: buildValueLabelColumns(enrichedColumns)
-    }
+    ...buildValueLabelColumns2(enrichedColumns).length && {
+      valueLabelColumns: buildValueLabelColumns2(enrichedColumns)
+    },
+    ...pickExtensions2(json)
   };
 }, "fromJson");
 var buildLookup = /* @__PURE__ */ __name((columns) => {
@@ -9270,6 +9752,45 @@ var migrateResourceJsonFile = /* @__PURE__ */ __name((jsonPath, opts) => {
   }
 }, "migrateResourceJsonFile");
 
+// src/lib/crud/resource/resource-config.validator.ts
+init_cjs_shims();
+var ALL_OPS = [
+  "findAll",
+  "findOne",
+  "create",
+  "update",
+  "patch",
+  "upsert",
+  "delete"
+];
+var validateResourceConfig = /* @__PURE__ */ __name((config, opts) => {
+  const errors = [];
+  const warnings = [];
+  const definition = resolveDefinition2(config);
+  const enabledOps = ALL_OPS.filter((op) => isOperationEnabled2(definition, op));
+  if (enabledOps.length === 0) {
+    warnings.push("All operations are disabled \u2014 this resource serves nothing.");
+  }
+  if (config.kind === "custom") {
+    if (config.database) {
+      warnings.push('"database" is set alongside kind: "custom" \u2014 it selects the client injected as ctx.prisma, but data access still comes from repository.ts.');
+    }
+    if (isOperationEnabled2(definition, "upsert")) {
+      warnings.push('"upsert" is enabled but custom resources do not register a PUT handler \u2014 disable it in operations or implement it yourself.');
+    }
+    const repoError = validateCustomRepository(config, config.repository);
+    if (repoError) errors.push(repoError);
+  } else {
+    if (opts?.repositoryFileExistsOnDisk) {
+      warnings.push('repository.ts is present on a prisma resource and will be ignored \u2014 set kind: "custom" if you want to use it for data access.');
+    }
+  }
+  return {
+    errors,
+    warnings
+  };
+}, "validateResourceConfig");
+
 // src/lib/crud/loader/index.ts
 var import_node_fs10 = require("fs");
 var import_node_path18 = require("path");
@@ -9332,10 +9853,35 @@ var loadResourceConfigsFromDir = /* @__PURE__ */ __name(async (dirPath, baseUrl,
         });
         continue;
       }
+      const errorsBeforeRepo = resourceLoadErrorsRegistry.getAll().length;
       const repository = json.kind === "custom" ? await loadCustomRepository(basePath, json.name) : void 0;
+      const repositoryImportFailed = resourceLoadErrorsRegistry.getAll().length > errorsBeforeRepo;
       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, repository);
+      if (repositoryImportFailed) continue;
+      const repositoryFileExistsOnDisk = json.kind !== "custom" && !!findModule(basePath, "repository");
+      const { errors, warnings } = validateResourceConfig(config, {
+        repositoryFileExistsOnDisk
+      });
+      if (errors.length > 0) {
+        for (const error of errors) {
+          resourceLoadErrorsRegistry.record({
+            name: dir,
+            path: jsonFile,
+            error
+          });
+        }
+        continue;
+      }
+      for (const warning of warnings) {
+        resourceLoadReportRegistry.record({
+          state: "warning",
+          name: config.name,
+          path: jsonFile,
+          warning
+        });
+      }
       await loadSubResourceHooks(config.subResources ?? [], basePath);
       await loadSubResourceRepositories(config.subResources ?? [], config.name);
       onResourceDir?.(config.route, basePath);
@@ -9345,7 +9891,14 @@ var loadResourceConfigsFromDir = /* @__PURE__ */ __name(async (dirPath, baseUrl,
     const tsFile = findModule(basePath, "resource");
     if (tsFile) {
       const config = await importDefault(tsFile);
-      if (!config) continue;
+      if (!config) {
+        resourceLoadErrorsRegistry.record({
+          name: dir,
+          path: tsFile,
+          error: "resource.ts has no default export \u2014 add `export default { name, route, ... }`."
+        });
+        continue;
+      }
       if (config.draft) {
         resourceLoadReportRegistry.record({
           state: "draft",
@@ -9355,10 +9908,30 @@ var loadResourceConfigsFromDir = /* @__PURE__ */ __name(async (dirPath, baseUrl,
         });
         continue;
       }
-      configs.push(hooks ? {
+      const merged = hooks ? {
         ...config,
         hooks
-      } : config);
+      } : config;
+      const { errors, warnings } = validateResourceConfig(merged);
+      if (errors.length > 0) {
+        for (const error of errors) {
+          resourceLoadErrorsRegistry.record({
+            name: dir,
+            path: tsFile,
+            error
+          });
+        }
+        continue;
+      }
+      for (const warning of warnings) {
+        resourceLoadReportRegistry.record({
+          state: "warning",
+          name: merged.name,
+          path: tsFile,
+          warning
+        });
+      }
+      configs.push(merged);
     }
   }
   return configs;
@@ -9417,7 +9990,6 @@ init_src();
 var import_node_fs11 = require("fs");
 var import_node_path19 = require("path");
 var import_node_url = require("url");
-var DB_CHECK_TIMEOUT_MS = 3e3;
 var CONNECTION_STRING_PATTERN = /(?:postgresql|postgres|mysql|mongodb|sqlserver|sqlite):\/\/[^\s"')]+/gi;
 var stripConnectionStrings = /* @__PURE__ */ __name((message) => message.replace(CONNECTION_STRING_PATTERN, "[REDACTED]"), "stripConnectionStrings");
 var getCroutonVersion = /* @__PURE__ */ __name(() => {
@@ -9438,16 +10010,11 @@ var getCroutonVersion = /* @__PURE__ */ __name(() => {
 }, "getCroutonVersion");
 var getVersion = /* @__PURE__ */ __name(() => process.env["APP_VERSION"] ?? "unknown", "getVersion");
 var getEnvironment = /* @__PURE__ */ __name(() => process.env["ENVIRONMENT"] ?? process.env["NODE_ENV"] ?? "unknown", "getEnvironment");
-var checkDatabases = /* @__PURE__ */ __name(async (registry) => {
-  const entries = registry.entries();
+var checkDatabases = /* @__PURE__ */ __name(async (registry2) => {
   const results = [];
-  for (const { name, client } of entries) {
-    const prismaClient = client;
+  for (const { name, adapter } of registry2.entries()) {
     try {
-      await Promise.race([
-        prismaClient.$queryRaw`SELECT 1`,
-        new Promise((_resolve, reject) => setTimeout(() => reject(new Error("Database health check timed out")), DB_CHECK_TIMEOUT_MS))
-      ]);
+      await adapter.healthCheck?.();
       results.push({
         name,
         connected: true
@@ -9463,20 +10030,27 @@ var checkDatabases = /* @__PURE__ */ __name(async (registry) => {
   return results;
 }, "checkDatabases");
 var getResourceStatus = /* @__PURE__ */ __name((loadedConfigs) => {
+  const warningsByName = /* @__PURE__ */ new Map();
+  for (const w of resourceLoadReportRegistry.getByState("warning")) {
+    const existing = warningsByName.get(w.name) ?? [];
+    existing.push(w.warning);
+    warningsByName.set(w.name, existing);
+  }
   const valid = loadedConfigs.map((c) => ({
     name: c.name,
     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.
+    // Which operations the user's repository.ts actually implements.
     ...c.kind === "custom" && c.repository ? {
       customOperations: CUSTOM_OPS.filter((op) => typeof c.repository?.[op] === "function")
     } : {},
     ...c.sidebar?.hide ? {
       hidden: true
+    } : {},
+    ...warningsByName.has(c.name) ? {
+      warnings: warningsByName.get(c.name)
     } : {}
   }));
   const failed = resourceLoadErrorsRegistry.getAll().map((e) => ({
@@ -9503,10 +10077,12 @@ var getResourceStatus = /* @__PURE__ */ __name((loadedConfigs) => {
 var buildSummary = /* @__PURE__ */ __name((databases, resources) => {
   const databaseErrors = databases.filter((d) => !d.connected).length;
   const resourceErrors = resources.filter((r) => !r.valid).length;
+  const warningCount = resources.reduce((acc, r) => acc + (r.warnings?.length ?? 0), 0);
   return {
     ok: databaseErrors === 0 && resourceErrors === 0,
     databaseErrors,
-    resourceErrors
+    resourceErrors,
+    warningCount
   };
 }, "buildSummary");
 var getSystemEnums = /* @__PURE__ */ __name(() => {
@@ -9655,8 +10231,8 @@ var getI18nStatus = /* @__PURE__ */ __name((translationRegistry) => {
     bundles
   };
 }, "getI18nStatus");
-var buildStatus = /* @__PURE__ */ __name(async (registry, loadedConfigs, enumRegistry, translationRegistry) => {
-  const databases = await checkDatabases(registry);
+var buildStatus = /* @__PURE__ */ __name(async (registry2, loadedConfigs, enumRegistry, translationRegistry) => {
+  const databases = await checkDatabases(registry2);
   const resources = getResourceStatus(loadedConfigs);
   const summary = buildSummary(databases, resources);
   return {
@@ -9697,7 +10273,7 @@ function _ts_metadata9(metadataKey, metadataValue) {
   }
 }
 __name(_ts_metadata9, "_ts_metadata");
-var createStatusController = /* @__PURE__ */ __name((enumRegistry, translationRegistry) => {
+var createStatusController = /* @__PURE__ */ __name((enumRegistry, translationRegistry, prefix) => {
   let StatusController = class StatusController {
     static {
       __name(this, "StatusController");
@@ -9727,7 +10303,7 @@ var createStatusController = /* @__PURE__ */ __name((enumRegistry, translationRe
     _ts_metadata9("design:returntype", Promise)
   ], StatusController.prototype, "getStatus", null);
   StatusController = _ts_decorate9([
-    (0, import_common23.Controller)("crouton"),
+    (0, import_common23.Controller)(prefix ? `${prefix}/crouton` : "crouton"),
     (0, import_swagger13.ApiTags)("Status"),
     _ts_metadata9("design:type", Function),
     _ts_metadata9("design:paramtypes", [
@@ -9771,7 +10347,7 @@ var CroutonApiModule = class _CroutonApiModule {
     }
   }
   static forResources(configs, dataSources, loader, appConfig, config) {
-    const { baseUrl, security } = appConfig;
+    const { baseUrl, prefix, security } = appConfig;
     const dataSourceRegistry = new DataSourceRegistry(dataSources);
     const guardRegistry = new SecurityGuardRegistry(security?.guards ?? {});
     const moduleDefaultSecurity = security?.default;
@@ -9780,9 +10356,10 @@ var CroutonApiModule = class _CroutonApiModule {
     const validConfigs = [];
     for (const c of configs) {
       if (c.kind === "custom") {
+        let adapterClient;
         if (c.database) {
           try {
-            dataSourceRegistry.resolveAdapter(c.database);
+            adapterClient = dataSourceRegistry.resolveAdapter(c.database).client;
           } catch (e) {
             resourceLoadErrorsRegistry.record({
               name: c.name,
@@ -9792,7 +10369,7 @@ var CroutonApiModule = class _CroutonApiModule {
             continue;
           }
         }
-        const problem = validateCustomRepository(c, c.repository);
+        const problem = validateCustomRepository(c, c.repository, adapterClient);
         if (problem) {
           resourceLoadErrorsRegistry.record({
             name: c.name,
@@ -9840,18 +10417,21 @@ var CroutonApiModule = class _CroutonApiModule {
       configRegistry.setTranslationRegistry(translationRegistry);
     }
     const controllers = [
-      ...validConfigs.map((c) => createCrudController(c, baseUrl, moduleDefaultSecurity, !!security)),
-      createAppLayoutController(configs, config.sidebarGroups, config.title, config.autoSave ?? true, translationRegistry, config.i18n),
+      ...validConfigs.map((c) => createCrudController(c, baseUrl, moduleDefaultSecurity, !!security, prefix, appConfig.schemaEnricher)),
+      createAppLayoutController(configs, config.sidebarGroups, config.title, config.autoSave ?? true, translationRegistry, config.i18n, prefix),
       // Only registered (and thus only visible in Swagger/routing) when the
       // visual resource builder is enabled — see dev-resources.controller.ts.
       ...IS_DEV ? [
         DevResourcesController
       ] : [],
-      createStatusController(enumRegistry, translationRegistry)
+      createStatusController(enumRegistry, translationRegistry, prefix)
     ];
     return {
       module: _CroutonApiModule,
       controllers,
+      exports: [
+        ResourceConfigRegistry
+      ],
       providers: [
         {
           provide: import_core2.APP_FILTER,
@@ -9889,6 +10469,7 @@ var CroutonApiModule = class _CroutonApiModule {
     };
   }
   static async forResourceDir(dirPath, dataSourcesPath, appConfig) {
+    if (appConfig.extensions) registerResourceExtensions(appConfig.extensions);
     const config = await loadConfig();
     const loader = new FileSystemResourceConfigLoader(dirPath, appConfig.baseUrl, config.enumsFile);
     const configs = await loadResourceConfigsFromDir(dirPath, appConfig.baseUrl, config.enumsFile);
@@ -9908,6 +10489,36 @@ CroutonApiModule = _ts_decorate10([
   })
 ], CroutonApiModule);
 
+// src/lib/crud/parse-schema.ts
+init_cjs_shims();
+init_src();
+var parseSchema = /* @__PURE__ */ __name((input, appConfig, view = "schemas") => {
+  if (appConfig.extensions) registerResourceExtensions(appConfig.extensions);
+  const normalized = input !== null && typeof input === "object" && "json" in input ? input : {
+    json: input
+  };
+  const parseResult = buildResourceJsonSchema().safeParse(normalized.json);
+  if (!parseResult.success) {
+    throw new Error(`Resource cannot be parsed: ${parseResult.error.message}`);
+  }
+  const resource = fromJson(parseResult.data, normalized.schema, normalized.hooks, normalized.dirPath, appConfig.baseUrl, normalized.actions, normalized.tableActions, normalized.enums ?? {}, void 0);
+  let payload;
+  if (view === "schemas") {
+    payload = buildViewsPayload2(resource, appConfig.baseUrl);
+  } else if (view === "definition") {
+    payload = buildDefinitionPayload2(resource);
+  } else {
+    payload = buildResourceJsonPayload2(resource, appConfig.baseUrl);
+  }
+  if (payload && appConfig.schemaEnricher) {
+    payload = {
+      ...payload,
+      ...appConfig.schemaEnricher(payload)
+    };
+  }
+  return payload;
+}, "parseSchema");
+
 // src/index.ts
 init_hooks();
 // Annotate the CommonJS export names for ESM import in node:
@@ -9937,6 +10548,7 @@ init_hooks();
   loadResourceHooks,
   loadSubResourceHooks,
   parseFilterString,
+  parseSchema,
   postWrite,
   prepareWrite,
   resolveDefinition,