@ghentcdh/crouton-api 0.0.1-alpha.51 → 0.0.1-alpha.53

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,7 +1257,7 @@ var init_TableAction_schema = __esm({
         ...action
       };
     }, "transformAction");
-    JsonActionSchema = import_zod17.z.union([
+    JsonActionSchema = import_zod15.z.union([
       JsonProcedureActionSchema,
       JsonLinkActionSchema
     ]).transform(transformAction);
@@ -1431,19 +1308,19 @@ var init_extensions = __esm({
 });
 
 // ../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()
       })
     ]));
   }
@@ -1460,6 +1337,105 @@ 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, buildResourceJsonSchema, ResourceJsonSchema;
 var init_ResourceJson_schema = __esm({
@@ -1571,12 +1547,7 @@ var init_ResourceJson_schema = __esm({
       * `{ "relation": "text_author", "include": ["author"] }` →
       *   `include: { text_author: { include: { author: true } } }`
       */
-      include: import_zod19.z.array(JsonIncludeEntrySchema).default([]),
-      /**
-      * Normalized extension blocks lifted from registered top-level keys.
-      * Authors never write this key directly — the transform fills it.
-      */
-      extensions: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.unknown()).optional()
+      include: import_zod19.z.array(JsonIncludeEntrySchema).default([])
     });
     refineByKind = /* @__PURE__ */ __name((obj, ctx) => {
       if (obj.kind === "custom") {
@@ -1673,24 +1644,14 @@ var init_ResourceJson_schema = __esm({
           patch: false,
           delete: false
         }) : JsonOperationsSchema.parse({});
-        const raw = obj;
-        const extensions = {};
-        for (const name of ext.keys()) {
-          if (raw[name] !== void 0) {
-            extensions[name] = raw[name];
-            delete raw[name];
-          }
-        }
         return {
           title,
           ...obj,
+          id: obj.id ?? obj.name,
           route: obj.route ?? obj.id ?? obj.name ?? "",
           schemaVersion,
           columns: normalizeColumns(obj.columns),
-          operations: obj.operations ?? defaultOps,
-          ...Object.keys(extensions).length && {
-            extensions
-          }
+          operations: obj.operations ?? defaultOps
         };
       }));
     }, "buildResourceJsonSchema");
@@ -1812,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({
@@ -2376,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")) {
@@ -2410,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();
@@ -2483,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
         });
@@ -2571,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));
@@ -2694,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();
   }
 });
@@ -2908,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();
@@ -2974,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()
     });
   }
 });
@@ -3148,7 +3484,7 @@ __export(index_exports, {
   buildViews: () => buildViews,
   decorateRow: () => decorateRow,
   decorateRows: () => decorateRows,
-  isOperationEnabled: () => isOperationEnabled,
+  isOperationEnabled: () => isOperationEnabled2,
   isRowProcedureAction: () => isRowProcedureAction,
   isTableProcedureAction: () => isTableProcedureAction,
   loadDataSourcesFromDir: () => loadDataSourcesFromDir,
@@ -3156,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();
@@ -3179,21 +3516,21 @@ 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
 ]);
@@ -3422,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 [
@@ -3435,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 {
@@ -3448,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 {
@@ -3539,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);
@@ -3606,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();
@@ -3644,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 —
@@ -4039,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");
@@ -4117,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;
@@ -4143,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",
@@ -4160,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();
@@ -4243,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");
@@ -4255,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") {
@@ -4340,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;
@@ -4496,13 +4845,17 @@ 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) {
     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");
@@ -5144,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) => {
@@ -5159,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
       });
@@ -5177,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;
@@ -5276,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]
@@ -5567,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);
@@ -6018,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 {
@@ -6037,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) {
@@ -6081,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;
@@ -6097,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) {
@@ -6275,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) {
@@ -6292,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) {
@@ -6332,7 +6685,7 @@ var registerFindAll = /* @__PURE__ */ __name((ctx, sub) => {
     ...listSchema && {
       schema: {
         type: "array",
-        items: toJsonSchema(listSchema)
+        items: toJsonSchema2(listSchema)
       }
     }
   })(cls.prototype, methodName, d);
@@ -6345,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 {
@@ -6362,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) {
@@ -6398,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)({
@@ -6413,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 {
@@ -6431,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) {
@@ -6482,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
@@ -6572,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",
@@ -6597,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",
@@ -6621,47 +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)
       } : {}
     },
-    ...config.extensions && {
-      extensions: config.extensions
-    }
+    ...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"];
@@ -6670,13 +7027,11 @@ var buildResourceJsonPayload = /* @__PURE__ */ __name((config, baseUrl) => {
     ui: form.ui_schema
   } : null;
   return {
-    id: name,
+    id: config.id ?? route,
     uri,
     operations,
     schema,
-    ...config.extensions && {
-      extensions: config.extensions
-    }
+    ...pickExtensions(config)
   };
 }, "buildResourceJsonPayload");
 var _resolveActions = /* @__PURE__ */ __name((baseUrl, actions) => {
@@ -6699,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]) => [
@@ -6719,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,
@@ -6734,9 +7089,7 @@ var buildViewsPayload = /* @__PURE__ */ __name((config, baseUrl) => {
     schemas,
     actions: resolveActions(baseAction, config.actions),
     tableActions: resolveActions(baseAction, config.tableActions),
-    ...config.extensions && {
-      extensions: config.extensions
-    }
+    ...pickExtensions(config)
   };
 }, "buildViewsPayload");
 var buildSubResourceViewsPayload = /* @__PURE__ */ __name((config, sub, baseUrl) => {
@@ -6798,13 +7151,13 @@ var import_node_path9 = require("path");
 var registerDefinitionEndpoint = /* @__PURE__ */ __name((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) payload = buildDefinitionPayload(fresh);
+      if (fresh) payload = buildDefinitionPayload2(fresh);
     }
     if (!schemaEnricher) return payload;
     return {
@@ -6829,13 +7182,13 @@ var registerDefinitionEndpoint = /* @__PURE__ */ __name((ctx) => {
 var registerResourceJsonEndpoint = /* @__PURE__ */ __name((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) payload = buildResourceJsonPayload(fresh, baseUrl);
+      if (fresh) payload = buildResourceJsonPayload2(fresh, baseUrl);
     }
     if (!schemaEnricher) return payload;
     return {
@@ -6983,7 +7336,7 @@ init_dev_mode();
 var defaultSchemas = /* @__PURE__ */ __name((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",
@@ -6993,7 +7346,7 @@ var defaultSchemas = /* @__PURE__ */ __name((ctx) => {
       let payload = viewsPayload;
       if (IS_DEV || language) {
         const fresh = await this.configRegistry.getByRoute(route, language);
-        if (fresh) payload = buildViewsPayload(fresh, baseUrl) ?? viewsPayload;
+        if (fresh) payload = buildViewsPayload2(fresh, baseUrl) ?? viewsPayload;
       }
       if (!payload || !schemaEnricher) return payload;
       return {
@@ -7048,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 {
@@ -7066,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) {
@@ -7141,15 +7494,15 @@ var registerEndpoint = /* @__PURE__ */ __name((ctx, sub) => {
 // src/lib/crud/crud-controller.factory.ts
 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) => {
@@ -7954,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
@@ -8849,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();
@@ -8876,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;
@@ -8951,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);
@@ -8986,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;
@@ -8998,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;
@@ -9008,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;
@@ -9029,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) => {
@@ -9093,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;
@@ -9145,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 ?? [];
@@ -9226,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)
     };
@@ -9235,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) {
@@ -9257,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,
@@ -9307,12 +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)
     },
-    ...json.extensions && {
-      extensions: json.extensions
-    }
+    ...pickExtensions2(json)
   };
 }, "fromJson");
 var buildLookup = /* @__PURE__ */ __name((columns) => {
@@ -9395,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");
@@ -9457,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);
@@ -9470,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",
@@ -9480,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;
@@ -9542,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(() => {
@@ -9564,15 +10011,10 @@ var getCroutonVersion = /* @__PURE__ */ __name(() => {
 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 (registry2) => {
-  const entries = registry2.entries();
   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
@@ -9588,20 +10030,27 @@ var checkDatabases = /* @__PURE__ */ __name(async (registry2) => {
   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) => ({
@@ -9628,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(() => {
@@ -9905,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,
@@ -9917,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,
@@ -9977,6 +10429,9 @@ var CroutonApiModule = class _CroutonApiModule {
     return {
       module: _CroutonApiModule,
       controllers,
+      exports: [
+        ResourceConfigRegistry
+      ],
       providers: [
         {
           provide: import_core2.APP_FILTER,
@@ -10034,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:
@@ -10063,6 +10548,7 @@ init_hooks();
   loadResourceHooks,
   loadSubResourceHooks,
   parseFilterString,
+  parseSchema,
   postWrite,
   prepareWrite,
   resolveDefinition,