@ghentcdh/crouton-core 0.0.1-alpha.39 → 0.0.1-alpha.41

package/dist/index.cjs

@@ -36,6 +36,8 @@ __export(index_exports, {
   CONFIG_FILES: () => CONFIG_FILES,
   CURRENT_RESOURCE_VERSION: () => CURRENT_RESOURCE_VERSION,
   CalculatedColumnSchema: () => CalculatedColumnSchema,
+  ColumnTypeSchema: () => ColumnTypeSchema,
+  ColumnTypeShorthandSchema: () => ColumnTypeShorthandSchema,
   ContainerBuilder: () => ContainerBuilder,
   ControlBuilder: () => ControlBuilder,
   ControlType: () => ControlType,
@@ -47,12 +49,14 @@ __export(index_exports, {
   ElementBuilder: () => ElementBuilder,
   FieldInputSchema: () => FieldInputSchema,
   FieldVariantSchema: () => FieldVariantSchema,
+  I18nConfigSchema: () => I18nConfigSchema,
   JsonActionSchema: () => JsonActionSchema,
   JsonColumnSchema: () => JsonColumnSchema,
   JsonIncludeEntrySchema: () => JsonIncludeEntrySchema,
   JsonLinkActionSchema: () => JsonLinkActionSchema,
   JsonOperationsSchema: () => JsonOperationsSchema,
   JsonProcedureActionSchema: () => JsonProcedureActionSchema,
+  JsonSchemaFragmentSchema: () => JsonSchemaFragmentSchema,
   LayoutBuilder: () => LayoutBuilder,
   LayoutType: () => LayoutType,
   MIGRATIONS: () => MIGRATIONS,
@@ -64,6 +68,7 @@ __export(index_exports, {
   OperatorNoValue: () => OperatorNoValue,
   OperatorOptions: () => OperatorOptions,
   OperatorsByType: () => OperatorsByType,
+  ParentRefSchema: () => ParentRefSchema,
   PositiveRequestNumber: () => PositiveRequestNumber,
   RelationFieldInputOptionsSchema: () => RelationFieldInputOptionsSchema,
   RelationType: () => RelationType,
@@ -71,6 +76,7 @@ __export(index_exports, {
   RequestSchemaWithOffset: () => RequestSchemaWithOffset,
   ResourceJsonSchema: () => ResourceJsonSchema,
   ResourceJsonShape: () => ResourceJsonShape,
+  ResourceKindSchema: () => ResourceKindSchema,
   ResponseRequestSchema: () => ResponseRequestSchema,
   ResponseSchema: () => ResponseSchema,
   RulesetSchema: () => RulesetSchema,
@@ -81,9 +87,11 @@ __export(index_exports, {
   StringOrArray: () => StringOrArray,
   TableBuilder: () => TableBuilder,
   TextCellBuilder: () => TextCellBuilder,
+  TranslationBundleSchema: () => TranslationBundleSchema,
   ViewColumnConfigSchema: () => ViewColumnConfigSchema,
   ViewConfigSchema: () => ViewConfigSchema,
   WhenConditionSchema: () => WhenConditionSchema,
+  actionKey: () => actionKey,
   applySchemaTransforms: () => applySchemaTransforms,
   buildConditionSchema: () => buildConditionSchema,
   buildFilter: () => buildFilter,
@@ -93,13 +101,22 @@ __export(index_exports, {
   buildSortKey: () => buildSortKey,
   buildTableUiSchema: () => buildTableUiSchema,
   buildViews: () => buildViews,
+  buildViewsFromColumnTypes: () => buildViewsFromColumnTypes,
   buildViewsFromColumns: () => buildViewsFromColumns,
+  buildViewsWithSource: () => buildViewsWithSource,
   colPosition: () => colPosition,
   columnForContext: () => columnForContext,
+  columnKey: () => columnKey,
+  columnToJsonSchemaProperty: () => columnToJsonSchemaProperty,
+  columnTypeName: () => columnTypeName,
+  columnTypeSchemaSource: () => columnTypeSchemaSource,
+  columnTypeToJsonSchema: () => columnTypeToJsonSchema,
   createSchema: () => createSchema,
+  createTranslator: () => createTranslator,
   deriveSortId: () => deriveSortId,
   dropNullableFromRequired: () => dropNullableFromRequired,
   enforceRequiredStringMinLength: () => enforceRequiredStringMinLength,
+  enumKey: () => enumKey,
   extractFilters: () => extractFilters,
   filterToString: () => filterToString,
   findColumnDef: () => findColumnDef,
@@ -107,29 +124,46 @@ __export(index_exports, {
   fromValueLabel: () => fromValueLabel,
   injectCalculatedColumns: () => injectCalculatedColumns,
   injectCalculatedColumnsToView: () => injectCalculatedColumnsToView,
+  isArrayColumn: () => isArrayColumn,
+  isArrayColumnType: () => isArrayColumnType,
   isAutocomplete: () => isAutocomplete,
   isBoolean: () => isBoolean,
+  isCustomKind: () => isCustomKind,
   isDateRange: () => isDateRange,
+  isObjectCell: () => isObjectCell,
+  isObjectColumn: () => isObjectColumn,
+  isObjectColumnType: () => isObjectColumnType,
   isRecordCell: () => isRecordCell,
   isRelation: () => isRelation,
   jsonSchemaOpts: () => jsonSchemaOpts,
   labelFromId: () => labelFromId,
   mergeFieldVariant: () => mergeFieldVariant,
   normalizeLabel: () => normalizeLabel,
+  offsetOf: () => offsetOf,
   patchFilterProperties: () => patchFilterProperties,
   pickSharedCellOptions: () => pickSharedCellOptions,
   resolveDefaultSort: () => resolveDefaultSort,
   resolveFormField: () => resolveFormField,
+  resolveLanguage: () => resolveLanguage,
   resolveTableField: () => resolveTableField,
   resolveViewField: () => resolveViewField,
+  resourceControllerPath: () => resourceControllerPath,
+  resourceSidebarKey: () => resourceSidebarKey,
+  resourceTitleKey: () => resourceTitleKey,
   resourceVersionOf: () => resourceVersionOf,
   runResourceMigrations: () => runResourceMigrations,
+  sidebarGroupKey: () => sidebarGroupKey,
   sortByPosition: () => sortByPosition,
   stringToFilter: () => stringToFilter,
+  subResourceColumnKey: () => subResourceColumnKey,
+  subResourceTitleKey: () => subResourceTitleKey,
   toValueLabel: () => toValueLabel,
   toViewColumn: () => toViewColumn,
   transformDataSource: () => transformDataSource,
-  uiFromJsonSchema: () => uiFromJsonSchema
+  uiFromJsonSchema: () => uiFromJsonSchema,
+  uiKey: () => uiKey,
+  validationKey: () => validationKey,
+  zodSchemaSource: () => zodSchemaSource
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -162,6 +196,7 @@ var RequestSchemaWithOffset = RequestSchema.transform((schema) => {
     offset: (page - 1) * pageSize
   };
 });
+var offsetOf = (params) => params.offset ?? (params.page - 1) * params.pageSize;
 
 // src/lib/filter.ts
 var Operator = [
@@ -344,8 +379,12 @@ var enforceRequiredStringMinLength = (schema) => {
 };
 var findProperty = (column, schema) => {
   if (!column.scope) return { id: null, property: null };
-  const id = column.scope?.substring("#/properties/".length);
-  const property = schema?.properties?.[id] ?? {};
+  const id = column.scope.substring("#/properties/".length);
+  const segments = id.split("/properties/");
+  let property = schema?.properties?.[segments[0]] ?? {};
+  for (const segment of segments.slice(1)) {
+    property = property?.properties?.[segment] ?? {};
+  }
   return { id, property };
 };
 
@@ -428,6 +467,7 @@ var ControlType = {
   textArea: "textarea",
   markdown: "markdown",
   array: "array",
+  object: "object",
   custom: "custom",
   select: "select",
   mutliSelect: "mutliSelect",
@@ -511,6 +551,16 @@ var ControlBuilder = class _ControlBuilder extends ElementBuilder {
       ...options ?? {}
     });
   }
+  /**
+   * Render a datepicker. Defaults to a day-only picker; pass
+   * `{ format: 'dateTime' }` (or `{ withTime: true }`) to include a time.
+   */
+  date(options) {
+    return this.opt({
+      format: ControlType.date,
+      ...options ?? {}
+    });
+  }
   textArea(options) {
     return this.opt({
       format: ControlType.textArea,
@@ -785,7 +835,7 @@ var JsonOperationsSchema = import_zod8.z.object({
 });
 
 // src/lib/resource/ResourceJson.schema.ts
-var import_zod15 = require("zod");
+var import_zod18 = require("zod");
 
 // src/lib/resource/CalculatedColumn.schema.ts
 var import_zod10 = require("zod");
@@ -936,61 +986,190 @@ var CalculatedColumnSchema = import_zod10.z.object({
 }).transform(normalizeLabel);
 
 // src/lib/resource/Column.ts
+var import_zod12 = require("zod");
+
+// src/lib/resource/ColumnType.schema.ts
 var import_zod11 = require("zod");
-var WhenConditionSchema = import_zod11.z.object({
-  field: import_zod11.z.string(),
+var ColumnTypeShorthandSchema = import_zod11.z.enum([
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "date",
+  "date-time",
+  "object",
+  "array"
+]);
+var JsonSchemaFragmentSchema = import_zod11.z.lazy(
+  () => import_zod11.z.object({
+    type: import_zod11.z.union([import_zod11.z.string(), import_zod11.z.array(import_zod11.z.string())]).optional(),
+    format: import_zod11.z.string().optional(),
+    enum: import_zod11.z.array(import_zod11.z.unknown()).optional(),
+    const: import_zod11.z.unknown().optional(),
+    nullable: import_zod11.z.boolean().optional(),
+    properties: import_zod11.z.record(import_zod11.z.string(), JsonSchemaFragmentSchema).optional(),
+    required: import_zod11.z.array(import_zod11.z.string()).optional(),
+    items: JsonSchemaFragmentSchema.optional(),
+    additionalProperties: import_zod11.z.union([import_zod11.z.boolean(), JsonSchemaFragmentSchema]).optional(),
+    title: import_zod11.z.string().optional(),
+    description: import_zod11.z.string().optional(),
+    default: import_zod11.z.unknown().optional(),
+    minimum: import_zod11.z.number().optional(),
+    maximum: import_zod11.z.number().optional(),
+    minLength: import_zod11.z.number().optional(),
+    maxLength: import_zod11.z.number().optional(),
+    pattern: import_zod11.z.string().optional()
+  }).catchall(import_zod11.z.unknown())
+);
+var ColumnTypeSchema = import_zod11.z.union([
+  ColumnTypeShorthandSchema,
+  JsonSchemaFragmentSchema
+]);
+var SHORTHAND_FRAGMENTS = {
+  string: { type: "string" },
+  number: { type: "number" },
+  integer: { type: "integer" },
+  boolean: { type: "boolean" },
+  date: { type: "string", format: "date" },
+  "date-time": { type: "string", format: "date-time" },
+  object: { type: "object" },
+  array: { type: "array" }
+};
+var isShorthand = (type) => typeof type === "string";
+var NESTED_SHORTHANDS = {
+  date: SHORTHAND_FRAGMENTS.date,
+  "date-time": SHORTHAND_FRAGMENTS["date-time"]
+};
+var normalizeFragment = (fragment) => {
+  const out = { ...fragment };
+  if (typeof out.type === "string") {
+    const expanded = NESTED_SHORTHANDS[out.type];
+    if (expanded) {
+      out.type = expanded.type;
+      if (out.format === void 0) out.format = expanded.format;
+    }
+  }
+  if (out.properties) {
+    out.properties = Object.fromEntries(
+      Object.entries(out.properties).map(([key, value]) => [
+        key,
+        normalizeFragment(value)
+      ])
+    );
+  }
+  if (out.items) out.items = normalizeFragment(out.items);
+  if (out.additionalProperties && typeof out.additionalProperties === "object") {
+    out.additionalProperties = normalizeFragment(out.additionalProperties);
+  }
+  return out;
+};
+var columnTypeToJsonSchema = (type) => {
+  if (type === void 0) return { type: "string" };
+  if (isShorthand(type)) return { ...SHORTHAND_FRAGMENTS[type] };
+  return normalizeFragment(type);
+};
+var columnTypeName = (type) => {
+  const fragment = columnTypeToJsonSchema(type);
+  const raw = fragment.type;
+  if (Array.isArray(raw)) return raw.find((t) => t !== "null") ?? "string";
+  if (typeof raw === "string") return raw;
+  if (fragment.properties) return "object";
+  if (fragment.items) return "array";
+  return "string";
+};
+var isObjectColumnType = (type) => columnTypeName(type) === "object";
+var isArrayColumnType = (type) => columnTypeName(type) === "array";
+
+// src/lib/resource/Column.ts
+var WhenConditionSchema = import_zod12.z.object({
+  field: import_zod12.z.string(),
   // required
-  eq: import_zod11.z.unknown().optional(),
-  neq: import_zod11.z.unknown().optional(),
-  exists: import_zod11.z.boolean().optional(),
-  notExists: import_zod11.z.boolean().optional()
+  eq: import_zod12.z.unknown().optional(),
+  neq: import_zod12.z.unknown().optional(),
+  exists: import_zod12.z.boolean().optional(),
+  notExists: import_zod12.z.boolean().optional()
 });
-var JsonColumnSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
+var JsonColumnSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
   // required in array form; implied by the map key in map form
-  column: import_zod11.z.string().optional(),
+  column: import_zod12.z.string().optional(),
   // default: same as `id`
-  label: import_zod11.z.string().optional(),
+  label: import_zod12.z.string().optional(),
   // default: title-cased version of `id`
-  hiddenInTable: import_zod11.z.boolean().default(false),
+  hiddenInTable: import_zod12.z.boolean().default(false),
   // default: false
-  hiddenInForm: import_zod11.z.boolean().default(false),
+  hiddenInForm: import_zod12.z.boolean().default(false),
   // default: false
-  hiddenInView: import_zod11.z.boolean().default(false),
+  hiddenInView: import_zod12.z.boolean().default(false),
   // default: false
-  sortable: import_zod11.z.boolean().default(false),
+  sortable: import_zod12.z.boolean().default(false),
   // default: false
-  defaultSort: import_zod11.z.boolean().default(false),
+  defaultSort: import_zod12.z.boolean().default(false),
   // default: false
-  searchable: import_zod11.z.boolean().default(false),
+  searchable: import_zod12.z.boolean().default(false),
   // default: false
-  filterable: import_zod11.z.boolean().default(false),
+  filterable: import_zod12.z.boolean().default(false),
   // default: false
-  createable: import_zod11.z.boolean().default(true),
+  createable: import_zod12.z.boolean().default(true),
   // default: true (only `false` excludes it)
-  updateable: import_zod11.z.boolean().default(true),
+  updateable: import_zod12.z.boolean().default(true),
   // default: true (only `false` excludes it)
-  hideLabel: import_zod11.z.boolean().default(false),
+  hideLabel: import_zod12.z.boolean().default(false),
   // default: false
   showWhen: WhenConditionSchema.optional(),
   hideWhen: WhenConditionSchema.optional(),
   disabledWhen: WhenConditionSchema.optional(),
-  displayKey: import_zod11.z.string().optional(),
+  displayKey: import_zod12.z.string().optional(),
   // e.g. "author.name" for nested display
-  sortId: import_zod11.z.string().optional(),
+  sortId: import_zod12.z.string().optional(),
   // overrides the sort
   /**
    * Name of a shared enum in the project enum registry (`crouton.enums.json`).
    * At load time the loader injects that enum's `{ value, label }[]` into
    * `fieldInput.options.values`, so columns don't duplicate the option list.
    */
-  enum: import_zod11.z.string().optional(),
+  enum: import_zod12.z.string().optional(),
   // name of a shared enum in crouton.enums.json
-  idField: import_zod11.z.boolean().default(false),
+  idField: import_zod12.z.boolean().default(false),
   // default: false — exactly one column should set this
-  showInLookup: import_zod11.z.boolean().default(false),
+  showInLookup: import_zod12.z.boolean().default(false),
   // default: false
-  columnType: import_zod11.z.string().default("string"),
+  /**
+   * Data type of the column, as a shorthand name (`"string"`, `"integer"`, …)
+   * or a full JSON Schema fragment:
+   *
+   * ```json
+   * "type": {
+   *   "type": "object",
+   *   "properties": { "id": { "type": "string" }, "name": { "type": "string" } }
+   * }
+   * ```
+   *
+   * Required on every column of a `kind: "custom"` resource, where it is the
+   * only source of the resource's json_schema. Optional on a `prisma`
+   * resource, whose schema is derived from the Zod model.
+   */
+  type: ColumnTypeSchema.optional(),
+  /**
+   * Whether the form requires a value.
+   *
+   * A prisma resource derives `required` from its Zod model, so this is an
+   * override in either direction: `true` adds the column to the form schema's
+   * `required` array, `false` removes it, and omitting it leaves the model's
+   * answer alone. A `kind: "custom"` resource has no model, so this is the only
+   * way to mark one of its fields required.
+   *
+   * Applies to the **form** view only — a required filter input would make the
+   * filter panel unsubmittable, and the table and view schemas are read-only.
+   * Ignored on the id column and on columns that are neither createable nor
+   * updateable, since the form cannot supply a value for those.
+   */
+  required: import_zod12.z.boolean().optional(),
+  /**
+   * @deprecated Use `type` instead. Retained because it is still consumed by
+   * the boolean predicate and the schema-less sub-resource view builder.
+   */
+  columnType: import_zod12.z.string().default("string"),
   // default: 'string'
   fieldInput: FieldInputSchema.optional(),
   /**
@@ -1015,46 +1194,66 @@ var JsonColumnSchema = import_zod11.z.object({
    * Visibility (`hiddenInTable/Form/View`) on this column is inherited by all sub-columns as a
    * default; the referenced resource's own column visibility further restricts it.
    */
-  extend: import_zod11.z.string().optional(),
+  extend: import_zod12.z.string().optional(),
   // path to another resource.json expanded as virtual sub-columns
   /**
    * Per-sub-column overrides when using `extend`.
    * Key: the virtual column id (`"{extendId}_{refColId}"`) or just the referenced column id.
    * Value: any `JsonColumn` fields to merge over the generated virtual column.
    */
-  columns: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.record(import_zod11.z.string(), import_zod11.z.unknown())).optional()
+  columns: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.record(import_zod12.z.string(), import_zod12.z.unknown())).optional()
   // per-sub-column overrides, only used with `extend`
 });
 
+// src/lib/resource/ParentRef.schema.ts
+var import_zod13 = require("zod");
+var ParentRefSchema = import_zod13.z.object({
+  /** Route segment of the parent, e.g. `"group"`. */
+  route: import_zod13.z.string(),
+  /**
+   * Name of the path parameter carrying the parent id, e.g. `"groupId"`.
+   * Avoid `"id"` — that is the child's own id in `/:id` routes.
+   */
+  param: import_zod13.z.string().default("parentId"),
+  /** Type of the parent id, used to coerce the path param. Defaults to `'string'`. */
+  idType: import_zod13.z.enum(["string", "number"]).optional()
+});
+var resourceControllerPath = (route, parent) => parent ? `${parent.route}/:${parent.param}/${route}` : route;
+
+// src/lib/resource/ResourceKind.ts
+var import_zod14 = require("zod");
+var ResourceKindSchema = import_zod14.z.enum(["prisma", "custom"]).default("prisma");
+var isCustomKind = (kind) => kind === "custom";
+
 // src/lib/resource/Sidebar.schema.ts
-var import_zod12 = __toESM(require("zod"), 1);
-var SidebarGroupSchema = import_zod12.default.object({
+var import_zod15 = __toESM(require("zod"), 1);
+var SidebarGroupSchema = import_zod15.default.object({
   /** Human-readable heading shown in the sidebar. Defaults to a title-cased version of the slug. */
-  label: import_zod12.default.string().optional(),
+  label: import_zod15.default.string().optional(),
   /** Controls the order of this group among top-level sidebar items. */
-  position: import_zod12.default.number().optional()
+  position: import_zod15.default.number().optional()
 });
-var SidebarSchema = import_zod12.default.object({
-  hide: import_zod12.default.boolean().default(false),
+var SidebarSchema = import_zod15.default.object({
+  hide: import_zod15.default.boolean().default(false),
   // default: false
-  position: import_zod12.default.number().optional(),
+  position: import_zod15.default.number().optional(),
   // default: sorted alphabetically after positioned entries
-  label: import_zod12.default.string().optional(),
+  label: import_zod15.default.string().optional(),
   // default: resource `title`
   /**
    * Slug of the group this resource belongs to.
    * Must match a key in `sidebarGroups` in `crouton.json`.
    * Resources with the same `group` are nested under a shared collapsible section.
    */
-  group: import_zod12.default.string().optional()
+  group: import_zod15.default.string().optional()
   // must match a key in `sidebarGroups` (crouton.json)
 });
 
 // src/lib/resource/TableAction.schema.ts
-var import_zod13 = require("zod");
-var ActionConditionSchema = import_zod13.z.object({
+var import_zod16 = require("zod");
+var ActionConditionSchema = import_zod16.z.object({
   /** Row field to evaluate. */
-  field: import_zod13.z.string(),
+  field: import_zod16.z.string(),
   //
   /**
    * Comparison operator. Defaults to `"eq"`.
@@ -1063,49 +1262,49 @@ var ActionConditionSchema = import_zod13.z.object({
    * - `exists`             — field is not null / undefined / empty string
    * - `notExists`          — field is null / undefined / empty string
    */
-  op: import_zod13.z.enum(["eq", "neq", "gt", "gte", "lt", "lte", "exists", "notExists"]).default("eq"),
+  op: import_zod16.z.enum(["eq", "neq", "gt", "gte", "lt", "lte", "exists", "notExists"]).default("eq"),
   // default: 'eq'
   /** Comparison value. Not required for `exists` / `notExists`. */
-  value: import_zod13.z.unknown().optional()
+  value: import_zod16.z.unknown().optional()
   // not required for exists/notExists
 });
-var ActionSchema = import_zod13.z.object({
-  type: import_zod13.z.string(),
+var ActionSchema = import_zod16.z.object({
+  type: import_zod16.z.string(),
   /** Unique identifier for the action. */
-  id: import_zod13.z.string(),
+  id: import_zod16.z.string(),
   // required
   /** Human-readable button label. */
-  label: import_zod13.z.string(),
+  label: import_zod16.z.string(),
   /** MDI icon name, e.g. `"mdi:open-in-new"`. */
-  icon: import_zod13.z.string().optional(),
+  icon: import_zod16.z.string().optional(),
   /** Tooltip text. Falls back to `label` when omitted. */
-  tooltip: import_zod13.z.string().optional(),
+  tooltip: import_zod16.z.string().optional(),
   // default: falls back to `label`
   condition: ActionConditionSchema.optional()
 });
 var JsonProcedureActionSchema = ActionSchema.extend({
-  type: import_zod13.z.literal("procedure").default("procedure"),
+  type: import_zod16.z.literal("procedure").default("procedure"),
   // default: 'procedure'
   /**
    * Filename (without extension) inside the resource's `actions/` directory
    * that exports the table-action procedure, e.g. `"syncZotero"`.
    */
-  procedure: import_zod13.z.string(),
+  procedure: import_zod16.z.string(),
   // required
   /** HTTP method for the frontend. Defaults to `"post"`. */
-  method: import_zod13.z.string().optional().default("post"),
+  method: import_zod16.z.string().optional().default("post"),
   // default: 'post'
   /** Static query / body params passed to the endpoint. */
-  data: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.unknown()).optional()
+  data: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.unknown()).optional()
 });
 var JsonLinkActionSchema = ActionSchema.extend({
   /** Optional condition evaluated per row. Button is hidden when the condition is false. */
-  type: import_zod13.z.literal("link").default("link"),
+  type: import_zod16.z.literal("link").default("link"),
   // required
   /** URL to open. May contain `{env.VAR}` placeholders. */
-  href: import_zod13.z.string(),
+  href: import_zod16.z.string(),
   // required,
-  blank: import_zod13.z.boolean().optional().default(true)
+  blank: import_zod16.z.boolean().optional().default(true)
 });
 var transformAction = (action) => {
   const label = action.label;
@@ -1114,21 +1313,21 @@ var transformAction = (action) => {
     ...action
   };
 };
-var JsonActionSchema = import_zod13.z.union([JsonProcedureActionSchema, JsonLinkActionSchema]).transform(transformAction);
+var JsonActionSchema = import_zod16.z.union([JsonProcedureActionSchema, JsonLinkActionSchema]).transform(transformAction);
 
 // src/lib/resource/include.schema.ts
-var import_zod14 = require("zod");
-var JsonIncludeEntrySchema = import_zod14.z.lazy(
-  () => import_zod14.z.union([
-    import_zod14.z.string(),
+var import_zod17 = require("zod");
+var JsonIncludeEntrySchema = import_zod17.z.lazy(
+  () => import_zod17.z.union([
+    import_zod17.z.string(),
     // plain relation name → `{ [name]: true }`
-    import_zod14.z.object({
-      relation: import_zod14.z.string(),
+    import_zod17.z.object({
+      relation: import_zod17.z.string(),
       // required
-      include: import_zod14.z.array(JsonIncludeEntrySchema).optional(),
+      include: import_zod17.z.array(JsonIncludeEntrySchema).optional(),
       // nested includes;
       /** Prisma-format orderBy clause applied to the included records. */
-      orderBy: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.unknown()).optional()
+      orderBy: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.unknown()).optional()
     })
   ])
 );
@@ -1138,15 +1337,15 @@ var BASELINE_RESOURCE_VERSION = 1;
 var CURRENT_RESOURCE_VERSION = 1;
 
 // src/lib/resource/ResourceJson.schema.ts
-var JsonColumnsMapSchema = import_zod15.z.record(
-  import_zod15.z.string(),
-  JsonColumnSchema.omit({ id: true }).catchall(import_zod15.z.unknown())
+var JsonColumnsMapSchema = import_zod18.z.record(
+  import_zod18.z.string(),
+  JsonColumnSchema.omit({ id: true }).catchall(import_zod18.z.unknown())
 );
 var ColumnsSchema = JsonColumnsMapSchema;
-var JsonDisplaySchema = import_zod15.z.object({
-  mode: import_zod15.z.enum(["page", "modal"]).default("modal"),
+var JsonDisplaySchema = import_zod18.z.object({
+  mode: import_zod18.z.enum(["page", "modal"]).default("modal"),
   // default: 'modal'
-  customComponent: import_zod15.z.string().nullable().optional().default(null)
+  customComponent: import_zod18.z.string().nullable().optional().default(null)
   // default: null
 });
 var normalizeColumns = (columns) => {
@@ -1157,34 +1356,54 @@ var normalizeColumns = (columns) => {
     label: col.label ?? labelFromId(col.id)
   }));
 };
-var ResourceJsonShape = import_zod15.z.object({
+var ResourceJsonShape = import_zod18.z.object({
   /**
    * URL of the generated JSON Schema, for editor autocomplete/validation. Declared so the
    * key is *allowed* (not stripped, and not flagged by the very schema it points at).
    * Ignored at runtime.
    */
-  $schema: import_zod15.z.string().optional(),
+  $schema: import_zod18.z.string().optional(),
   /**
    * resource.json shape version. Missing ⇒ baseline (see `./version`). Auto-migrated
    * toward `CURRENT_RESOURCE_VERSION` on load in the dev environment.
    */
-  schemaVersion: import_zod15.z.number().int().positive().optional(),
+  schemaVersion: import_zod18.z.number().int().positive().optional(),
   /** When `true`, the resource lives in the repo but is NOT loaded/served (work in progress). */
-  draft: import_zod15.z.boolean().optional().default(false),
-  name: import_zod15.z.string(),
+  draft: import_zod18.z.boolean().optional().default(false),
+  /**
+   * Where the data comes from. `prisma` (the default) is backed by a Prisma
+   * model plus a `schema.ts`; `custom` is configuration only and the developer
+   * supplies a `repository.ts`. See `./ResourceKind`.
+   */
+  kind: ResourceKindSchema,
+  name: import_zod18.z.string(),
   // required — unique id, used as the frontend form id
-  route: import_zod15.z.string(),
+  route: import_zod18.z.string(),
   // required — URL segment for generated endpoints
-  model: import_zod15.z.string(),
-  // required — Prisma model name
-  tag: import_zod15.z.string(),
+  /**
+   * Prisma model name. Required when `kind` is `prisma` (enforced by the
+   * refinement on `ResourceJsonSchema`), and must be absent when `kind` is
+   * `custom` — there is no Prisma delegate to address.
+   */
+  model: import_zod18.z.string().optional(),
+  tag: import_zod18.z.string(),
   // required — OpenAPI tag
-  title: import_zod15.z.string().optional(),
+  title: import_zod18.z.string().optional(),
   // no computed default — used as UI display title
-  table: import_zod15.z.string().optional(),
+  table: import_zod18.z.string().optional(),
   // default: same as `model`
-  database: import_zod15.z.string().optional(),
+  /**
+   * Type of the resource's primary key, used to coerce `:id` route params.
+   * Written by codegen from the Prisma model; defaults to `'string'`.
+   */
+  idType: import_zod18.z.enum(["string", "number"]).optional(),
+  database: import_zod18.z.string().optional(),
   // default: project's default data source
+  /**
+   * Mount this resource under a parent route instead of at the top level —
+   * see `./ParentRef.schema`. Only valid on a `kind: "custom"` resource.
+   */
+  parent: ParentRefSchema.optional(),
   sidebar: SidebarSchema.default(SidebarSchema.parse({})),
   // default: shown, alphabetically ordered, ungrouped
   display: JsonDisplaySchema.default(JsonDisplaySchema.parse({})),
@@ -1193,12 +1412,12 @@ var ResourceJsonShape = import_zod15.z.object({
   // required key — but every sub-field defaults to enabled
   columns: ColumnsSchema.default(ColumnsSchema.parse({})),
   //  id-keyed map; omit for a columnless resource
-  calculatedColumns: import_zod15.z.array(CalculatedColumnSchema).default([]),
-  actions: import_zod15.z.array(JsonActionSchema).default([]),
+  calculatedColumns: import_zod18.z.array(CalculatedColumnSchema).default([]),
+  actions: import_zod18.z.array(JsonActionSchema).default([]),
   /** Global table-level actions (no record id). Shown as toolbar buttons. */
-  tableActions: import_zod15.z.array(JsonActionSchema).default([]),
+  tableActions: import_zod18.z.array(JsonActionSchema).default([]),
   /** Modal width when opening a form for this resource. */
-  modalSize: import_zod15.z.enum(["xs", "sm", "lg", "xl"]).default("sm"),
+  modalSize: import_zod18.z.enum(["xs", "sm", "lg", "xl"]).default("sm"),
   // default: 'sm' for create/edit modal
   /**
    * Relations to include when querying this resource.
@@ -1207,9 +1426,60 @@ var ResourceJsonShape = import_zod15.z.object({
    * `{ "relation": "text_author", "include": ["author"] }` →
    *   `include: { text_author: { include: { author: true } } }`
    */
-  include: import_zod15.z.array(JsonIncludeEntrySchema).default([])
+  include: import_zod18.z.array(JsonIncludeEntrySchema).default([])
 });
-var ResourceJsonSchema = ResourceJsonShape.transform((obj) => {
+var refineByKind = (obj, ctx) => {
+  if (obj.kind === "custom") {
+    if (obj.model !== void 0) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["model"],
+        message: 'A custom resource has no Prisma model. Remove "model" \u2014 data access comes from repository.ts.'
+      });
+    }
+    if (obj.calculatedColumns?.length) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["calculatedColumns"],
+        message: "calculatedColumns run raw SQL against a database table and are not supported on a custom resource. Compute the value in repository.ts instead."
+      });
+    }
+    for (const [id, col] of Object.entries(obj.columns ?? {})) {
+      if (col.fieldInput?.format === "relation" || col.fieldInput?.type === "autocomplete") {
+        continue;
+      }
+      if (col.type === void 0) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["columns", id, "type"],
+          message: `Column "${id}" needs a "type": a custom resource has no schema.ts, so its json_schema is built from the column types.`
+        });
+      }
+    }
+    if (obj.parent && obj.parent.param === "id") {
+      ctx.addIssue({
+        code: "custom",
+        path: ["parent", "param"],
+        message: `parent.param cannot be "id" \u2014 that is the child's own id in /:id routes. Use something like "groupId".`
+      });
+    }
+  } else if (obj.parent !== void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["parent"],
+      message: '"parent" is only supported on a custom resource. A prisma resource is nested by declaring a relation column on its parent.'
+    });
+  } else if (obj.model === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["model"],
+      message: '"model" is required for a prisma-backed resource. Set "kind": "custom" for a resource with no Prisma model.'
+    });
+  }
+};
+var ResourceJsonSchema = ResourceJsonShape.superRefine(
+  refineByKind
+).transform((obj) => {
   const title = obj.title ?? labelFromId(obj.name);
   const schemaVersion = obj.schemaVersion ?? BASELINE_RESOURCE_VERSION;
   return {
@@ -1277,52 +1547,62 @@ var resolveViewField = (c) => mergeFieldVariant(c.fieldInput, c.fieldView);
 var resolveTableField = (c) => mergeFieldVariant(resolveViewField(c), c.fieldTable);
 
 // src/lib/config/CroutonConfig.schema.ts
-var import_zod16 = require("zod");
-var RulesetSchema = import_zod16.z.object({
-  hideIdInTable: import_zod16.z.boolean().default(true),
-  hideIdInForm: import_zod16.z.boolean().default(true),
-  hideIdInView: import_zod16.z.boolean().default(true),
-  hideTimestamps: import_zod16.z.boolean().default(true),
-  hideForeignKeys: import_zod16.z.boolean().default(true),
-  includeRelations: import_zod16.z.boolean().default(false),
-  hideRelationsInTable: import_zod16.z.boolean().default(true),
-  showRelationsInForm: import_zod16.z.boolean().default(true),
-  enumValueLabel: import_zod16.z.boolean().default(true),
-  sharedEnums: import_zod16.z.boolean().default(true),
+var import_zod19 = require("zod");
+var RulesetSchema = import_zod19.z.object({
+  hideIdInTable: import_zod19.z.boolean().default(true),
+  hideIdInForm: import_zod19.z.boolean().default(true),
+  hideIdInView: import_zod19.z.boolean().default(true),
+  hideTimestamps: import_zod19.z.boolean().default(true),
+  hideForeignKeys: import_zod19.z.boolean().default(true),
+  includeRelations: import_zod19.z.boolean().default(true),
+  hideRelationsInTable: import_zod19.z.boolean().default(true),
+  showRelationsInForm: import_zod19.z.boolean().default(true),
+  enumValueLabel: import_zod19.z.boolean().default(true),
+  sharedEnums: import_zod19.z.boolean().default(true),
   defaultOperations: JsonOperationsSchema.default(
     JsonOperationsSchema.parse({})
   )
 });
-var CroutonConfigSchema = import_zod16.z.object({
+var I18nConfigSchema = import_zod19.z.object({
+  /** Default / fallback language. */
+  defaultLanguage: import_zod19.z.string().default("en"),
+  /** All supported language codes. */
+  languages: import_zod19.z.array(import_zod19.z.string()).min(1),
+  /** Directory containing `<lang>.json` bundles, relative to project root. */
+  translationsDir: import_zod19.z.string().default("translations")
+});
+var CroutonConfigSchema = import_zod19.z.object({
   /**
    * Application title served to the frontend via `GET /_app/layout`.
    * Displayed in the admin sidebar header.
    */
-  title: import_zod16.z.string(),
+  title: import_zod19.z.string(),
   /** Where resource directories live, relative to the project root. */
-  resourcesDir: import_zod16.z.string(),
+  resourcesDir: import_zod19.z.string(),
   /** Where datasource folders live (each with a `data-source.json`). */
-  dataSourcesDir: import_zod16.z.string(),
+  dataSourcesDir: import_zod19.z.string(),
   /**
    * Template for a model's Zod export name. `{Model}` → Prisma model name.
    * Defaults to `{Model}WithRelationsSchema` (the relations-aware schema
    * emitted by zod-prisma-types when `createRelationValuesTypes` is on).
    */
-  schemaExportName: import_zod16.z.string().default("{Model}WithRelationsSchema"),
+  schemaExportName: import_zod19.z.string().default("{Model}WithRelationsSchema"),
   /** Path to the shared enum registry, relative to project root. Default `crouton.enums.json`. */
-  enumsFile: import_zod16.z.string().default("crouton.enums.json"),
+  enumsFile: import_zod19.z.string().default("crouton.enums.json"),
   /** Optional overrides of the default visibility ruleset. */
   rules: RulesetSchema.default(RulesetSchema.parse({})),
   /**
    * Sidebar group definitions, keyed by group slug (e.g. `"metadata"`).
    * Resources reference a group via `sidebar.group` in their `resource.json`.
    */
-  sidebarGroups: import_zod16.z.record(import_zod16.z.string(), SidebarGroupSchema).default({}),
+  sidebarGroups: import_zod19.z.record(import_zod19.z.string(), SidebarGroupSchema).default({}),
   /**
    * Whether form fields are saved automatically as the user edits them.
    * @default true
    */
-  autoSave: import_zod16.z.boolean().default(true)
+  autoSave: import_zod19.z.boolean().default(true),
+  /** Optional i18n / translation configuration. */
+  i18n: I18nConfigSchema.optional()
 });
 
 // src/lib/config/readConfig.ts
@@ -1334,6 +1614,9 @@ var isRelation = (col) => col.fieldInput?.format === "relation";
 var isAutocomplete = (col) => col.fieldInput?.type === "autocomplete";
 var isRecordCell = (col) => isRelation(col) || isAutocomplete(col);
 var isDateRange = (col) => col.fieldInput?.format === "date-range";
+var isObjectColumn = (col) => isObjectColumnType(col.type);
+var isArrayColumn = (col) => isArrayColumnType(col.type);
+var isObjectCell = (col) => isObjectColumn(col) && !!col.displayKey;
 
 // src/lib/view/column.utils.ts
 var colPosition = (col, i) => col.fieldInput?.position ?? i;
@@ -1449,7 +1732,7 @@ var buildTableUiSchema = (cols) => {
     const id = el.scope?.replace("#/properties/", "");
     const col = id ? colMap[id] : void 0;
     if (!col) return el;
-    const fieldInputOptions = isRecordCell(col) || isDateRange(col) ? col.fieldInput?.options ?? {} : pickSharedCellOptions(col);
+    const fieldInputOptions = isRecordCell(col) || isDateRange(col) || isObjectCell(col) ? col.fieldInput?.options ?? {} : pickSharedCellOptions(col);
     const dataPathOption = col.column ? { dataPath: col.column } : {};
     const derivedSortId = isRecordCell(col) || isDateRange(col) ? null : deriveSortId(col);
     const sortOptions = derivedSortId ? { sortId: derivedSortId } : { sortable: false };
@@ -1465,7 +1748,9 @@ var buildTableUiSchema = (cols) => {
         ...isDateRange(col) && { format: "date-range" },
         label: col.label
       },
-      ...isRecordCell(col) && { type: "RecordCell" },
+      // An object column with a displayKey renders the same way as a relation:
+      // one nested key out of an object value.
+      ...(isRecordCell(col) || isObjectCell(col)) && { type: "RecordCell" },
       ...isDateRange(col) && { type: "Control" }
     };
   });
@@ -1533,6 +1818,11 @@ var buildDetailLayout = (detail) => {
   if (detail.titleKey) inner.titleKey(detail.titleKey);
   return inner;
 };
+var defaultControlFormat = (col) => {
+  if (isObjectColumn(col)) return "object";
+  if (isArrayColumn(col)) return "array";
+  return "text";
+};
 var buildFormControl = (col) => {
   const control = ControlBuilder.properties(col.id);
   const fieldInput = col.fieldInput;
@@ -1552,6 +1842,11 @@ var buildFormControl = (col) => {
     control.detailFixed(detailLayout, {
       layout: fieldInput.detail.layout === "collapse" ? "row" : void 0
     });
+  } else if (fieldInput?.format !== "date-range" && (fieldInput?.type === "date" || fieldInput?.format === "dateTime")) {
+    const options = { ...fieldInput.options };
+    if (!options.colspan) options.colspan = 12;
+    const format = fieldInput.format === "dateTime" ? "dateTime" : "date";
+    control.control(format, options).width("full");
   } else if (fieldInput?.format === "date-range") {
     const options = { ...fieldInput.options };
     if (!options.colspan) options.colspan = 12;
@@ -1559,10 +1854,11 @@ var buildFormControl = (col) => {
   } else {
     const options = fieldInput?.options ?? {};
     if (!options.colspan) options.colspan = 12;
-    const type = fieldInput?.type ?? "text";
+    const type = fieldInput?.type ?? defaultControlFormat(col);
     control.control(type, options).width("full");
   }
-  if (fieldInput?.customRender) control.setCustomRender(fieldInput?.customRender);
+  if (fieldInput?.customRender)
+    control.setCustomRender(fieldInput?.customRender);
   if (col.hideLabel) control.hideLabel();
   if (col.label) control.label(col.label);
   applyColumnRule(control, col);
@@ -1637,19 +1933,63 @@ var injectCalculatedColumns = (tableView, calculated) => injectCalculatedColumns
 var injectCalculatedColumnsToView = (viewConfig, calculated) => injectCalculatedColumnsIntoView(viewConfig, calculated, "view");
 
 // src/lib/view/view.builder.ts
-var import_zod18 = require("zod");
+var import_zod21 = require("zod");
+
+// src/lib/view/column-type-schema.source.ts
+var optionValues = (col) => {
+  const values = col.fieldInput?.options?.["values"];
+  if (!Array.isArray(values)) return void 0;
+  const unwrapped = values.map(
+    (v) => v && typeof v === "object" && "value" in v ? v.value : v
+  );
+  return unwrapped.length ? unwrapped : void 0;
+};
+var columnToJsonSchemaProperty = (col) => {
+  const property = col.type === void 0 && isAutocomplete(col) ? {} : { ...columnTypeToJsonSchema(col.type) };
+  if (property.title === void 0) property.title = col.label ?? col.id;
+  if (col.fieldInput?.defaultValue !== void 0 && property.default === void 0) {
+    property.default = col.fieldInput.defaultValue;
+  }
+  if (property.enum === void 0) {
+    const values = optionValues(col);
+    if (values) property.enum = values;
+  }
+  return property;
+};
+var columnTypeSchemaSource = (schemaCols) => {
+  if (!schemaCols.length) return void 0;
+  const properties = {};
+  for (const col of schemaCols) {
+    properties[col.id] = columnToJsonSchemaProperty(col);
+  }
+  return { type: "object", properties };
+};
 
 // src/lib/view/json-schema.opts.ts
-var import_zod17 = require("zod");
-var dateOverride = ({ zodSchema, jsonSchema }) => {
-  if (zodSchema instanceof import_zod17.z.ZodDate) {
+var import_zod20 = require("zod");
+var isInstanceOf = (zodSchema, className) => {
+  if (!(zodSchema instanceof import_zod20.z.ZodCustom)) return false;
+  const result = zodSchema.safeParse(null);
+  return !result.success && result.error.issues[0]?.expected === className;
+};
+var jsonSchemaOverride = ({ zodSchema, jsonSchema }) => {
+  if (zodSchema instanceof import_zod20.z.ZodDate) {
     jsonSchema.type = "string";
     jsonSchema.format = "date-time";
   }
+  if (zodSchema instanceof import_zod20.z.ZodBigInt) {
+    jsonSchema.type = "integer";
+  }
+  if (isInstanceOf(zodSchema, "Decimal")) {
+    jsonSchema.type = "number";
+  }
+  if (isInstanceOf(zodSchema, "Buffer")) {
+    jsonSchema.type = "string";
+  }
 };
 var jsonSchemaOpts = {
   unrepresentable: "any",
-  override: dateOverride
+  override: jsonSchemaOverride
 };
 
 // src/lib/view/view.builder.ts
@@ -1706,20 +2046,51 @@ var injectFieldDefaults = (jsonSchema, columns) => {
     if (prop) prop.default = col.fieldInput.defaultValue;
   }
 };
-var buildView = (schema, columns, visible, buildUiSchema, sort = false, schemaVisible) => {
-  if (!schema || !columns?.length) return void 0;
-  const visibleCols = sort ? sortByPosition(columns.filter(visible)) : columns.filter(visible);
-  if (!visibleCols.length) return void 0;
-  const schemaCols = (schemaVisible ? columns.filter((c) => visible(c) || schemaVisible(c)) : visibleCols).filter((c) => !isRelation(c));
+var zodSchemaSource = (schema) => (schemaCols) => {
   const schemaKeys = new Set(Object.keys(schema.shape));
   const schemaIds = schemaCols.map((c) => c.id).filter((id) => schemaKeys.has(id));
   if (!schemaIds.length) return void 0;
   const mask = Object.fromEntries(schemaIds.map((id) => [id, true]));
   const picked = schema.pick(mask);
-  const jsonSchema = (0, import_zod18.toJSONSchema)(picked, {
+  return (0, import_zod21.toJSONSchema)(picked, {
     target: "draft-07",
     ...jsonSchemaOpts
   });
+};
+var NON_NULL_TYPES = ["object", "array", "string", "number", "boolean"];
+var SHAPE_KEYS = ["type", "enum", "const", "anyOf", "oneOf", "allOf", "$ref"];
+var applyRequiredColumns = (jsonSchema, columns) => {
+  if (!columns?.length) return;
+  const properties = jsonSchema["properties"];
+  if (!properties) return;
+  const required = new Set(
+    Array.isArray(jsonSchema["required"]) ? jsonSchema["required"] : []
+  );
+  for (const col of columns) {
+    if (col.required === void 0) continue;
+    if (!(col.id in properties)) continue;
+    if (!col.required) {
+      required.delete(col.id);
+      continue;
+    }
+    if (col.idField) continue;
+    if (col.createable === false && col.updateable === false) continue;
+    required.add(col.id);
+    const property = properties[col.id];
+    if (property && typeof property === "object" && !SHAPE_KEYS.some((key) => key in property)) {
+      property["type"] = [...NON_NULL_TYPES];
+    }
+  }
+  if (required.size) jsonSchema["required"] = [...required];
+  else delete jsonSchema["required"];
+};
+var buildView = (source, columns, visible, buildUiSchema, sort = false, schemaVisible) => {
+  if (!source || !columns?.length) return void 0;
+  const visibleCols = sort ? sortByPosition(columns.filter(visible)) : columns.filter(visible);
+  if (!visibleCols.length) return void 0;
+  const schemaCols = (schemaVisible ? columns.filter((c) => visible(c) || schemaVisible(c)) : visibleCols).filter((c) => !isRelation(c));
+  const jsonSchema = source(schemaCols);
+  if (!jsonSchema) return void 0;
   applySchemaTransforms(jsonSchema);
   injectFieldDefaults(jsonSchema, visibleCols);
   if (schemaVisible) {
@@ -1742,10 +2113,10 @@ var emptyTableView = () => ({
   ui_schema: buildTableUiSchema([]),
   columns: []
 });
-var buildViews = (schema, columns) => {
+var buildViewsWithSource = (source, columns) => {
   const views = {};
   const table = buildView(
-    schema,
+    source,
     columns?.map((c) => columnForContext(c, "table")),
     (c) => !c.hiddenInTable,
     buildTableUiSchema,
@@ -1761,16 +2132,19 @@ var buildViews = (schema, columns) => {
     views.table = emptyTableView();
   }
   const form = buildView(
-    schema,
+    source,
     columns,
     (c) => !c.hiddenInForm,
     buildFormUiSchema,
     true,
     (c) => !c.idField && (c.createable === true || c.updateable === true)
   );
-  if (form) views.form = form;
+  if (form) {
+    applyRequiredColumns(form.json_schema, columns);
+    views.form = form;
+  }
   const filter = buildView(
-    schema,
+    source,
     columns,
     (c) => !!c.filterable,
     buildFormUiSchema,
@@ -1784,7 +2158,7 @@ var buildViews = (schema, columns) => {
     views.filter = filter;
   }
   const view = buildView(
-    schema,
+    source,
     columns?.map((c) => columnForContext(c, "view")),
     (c) => !c.hiddenInView,
     buildFormUiSchema,
@@ -1793,6 +2167,8 @@ var buildViews = (schema, columns) => {
   if (view) views.view = view;
   return Object.keys(views).length ? views : void 0;
 };
+var buildViews = (schema, columns) => buildViewsWithSource(schema ? zodSchemaSource(schema) : void 0, columns);
+var buildViewsFromColumnTypes = (columns) => buildViewsWithSource(columnTypeSchemaSource, columns);
 var buildViewsFromColumns = (columns) => {
   if (!columns?.length) return void 0;
   const buildJsonSchema = (cols) => {
@@ -1821,6 +2197,8 @@ var buildViewsFromColumns = (columns) => {
           type: "string",
           title: c.label ?? c.id
         };
+      } else if (c.type !== void 0) {
+        properties[c.id] = columnToJsonSchemaProperty(c);
       } else {
         const opts = c.fieldInput?.options;
         const isObject = opts?.emitObject === true || c.fieldInput?.type === "autocomplete";
@@ -1878,7 +2256,10 @@ var buildViewsFromColumns = (columns) => {
   }
   const formCols = sortByPosition(columns.filter((c) => !c.hiddenInForm));
   const form = makeView(formCols, buildFormUiSchema);
-  if (form) views.form = form;
+  if (form) {
+    applyRequiredColumns(form.json_schema, formCols);
+    views.form = form;
+  }
   const viewCols = sortByPosition(
     columns.filter((c) => !c.hiddenInView).map((c) => columnForContext(c, "view"))
   );
@@ -1888,20 +2269,131 @@ var buildViewsFromColumns = (columns) => {
 };
 
 // src/lib/view/view.schema.ts
-var import_zod19 = require("zod");
-var ViewColumnConfigSchema = import_zod19.z.object({
-  id: import_zod19.z.string(),
-  label: import_zod19.z.string().optional(),
-  sortable: import_zod19.z.boolean().optional(),
-  searchable: import_zod19.z.boolean().optional(),
+var import_zod22 = require("zod");
+var ViewColumnConfigSchema = import_zod22.z.object({
+  id: import_zod22.z.string(),
+  label: import_zod22.z.string().optional(),
+  sortable: import_zod22.z.boolean().optional(),
+  searchable: import_zod22.z.boolean().optional(),
   fieldInput: FieldInputSchema.optional()
 });
-var ViewConfigSchema = import_zod19.z.object({
-  json_schema: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.unknown()),
-  ui_schema: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.unknown()),
-  columns: import_zod19.z.array(ViewColumnConfigSchema),
-  defaultSort: import_zod19.z.string().optional()
+var ViewConfigSchema = import_zod22.z.object({
+  json_schema: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.unknown()),
+  ui_schema: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.unknown()),
+  columns: import_zod22.z.array(ViewColumnConfigSchema),
+  defaultSort: import_zod22.z.string().optional()
 });
+
+// src/lib/i18n/Translations.schema.ts
+var import_zod23 = require("zod");
+var NestedStringRecord = import_zod23.z.lazy(
+  () => import_zod23.z.record(import_zod23.z.string(), import_zod23.z.union([import_zod23.z.string(), NestedStringRecord]))
+);
+var TranslationBundleSchema = import_zod23.z.object({
+  app: import_zod23.z.object({
+    title: import_zod23.z.string().optional()
+  }).optional(),
+  sidebarGroups: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.string()).optional(),
+  resources: import_zod23.z.record(
+    import_zod23.z.string(),
+    import_zod23.z.object({
+      title: import_zod23.z.string().optional(),
+      sidebar: import_zod23.z.string().optional(),
+      columns: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.string()).optional(),
+      actions: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.string()).optional(),
+      subResources: import_zod23.z.record(
+        import_zod23.z.string(),
+        import_zod23.z.object({
+          title: import_zod23.z.string().optional(),
+          columns: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.string()).optional()
+        }).optional()
+      ).optional()
+    }).optional()
+  ).optional(),
+  enums: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.record(import_zod23.z.string(), import_zod23.z.string())).optional(),
+  ui: NestedStringRecord.optional(),
+  validation: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.string()).optional()
+}).passthrough();
+
+// src/lib/i18n/translation-keys.ts
+var resourceTitleKey = (resource) => `resources.${resource}.title`;
+var resourceSidebarKey = (resource) => `resources.${resource}.sidebar`;
+var columnKey = (resource, column) => `resources.${resource}.columns.${column}`;
+var actionKey = (resource, action) => `resources.${resource}.actions.${action}`;
+var subResourceTitleKey = (resource, sub) => `resources.${resource}.subResources.${sub}.title`;
+var subResourceColumnKey = (resource, sub, column) => `resources.${resource}.subResources.${sub}.columns.${column}`;
+var enumKey = (enumName, value) => `enums.${enumName}.${value}`;
+var sidebarGroupKey = (group) => `sidebarGroups.${group}`;
+var uiKey = (path) => `ui.${path}`;
+var validationKey = (code) => `validation.${code}`;
+
+// src/lib/i18n/translator.ts
+var getNestedValue = (obj, path) => {
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[key];
+  }
+  if (typeof current === "string" && current !== "") return current;
+  return void 0;
+};
+var createTranslator = (bundles, language, defaultLanguage = "en") => {
+  const langBundle = bundles[language];
+  const defaultBundle = language !== defaultLanguage ? bundles[defaultLanguage] : void 0;
+  return (path, fallback) => {
+    if (langBundle) {
+      const value = getNestedValue(
+        langBundle,
+        path
+      );
+      if (value !== void 0) return value;
+    }
+    if (defaultBundle) {
+      const value = getNestedValue(
+        defaultBundle,
+        path
+      );
+      if (value !== void 0) return value;
+    }
+    return fallback ?? path;
+  };
+};
+
+// src/lib/i18n/negotiate.ts
+var parseAcceptLanguage = (header) => {
+  const entries = [];
+  for (const part of header.split(",")) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    const [tag, ...params] = trimmed.split(";");
+    let q = 1;
+    for (const param of params) {
+      const match = param.trim().match(/^q\s*=\s*([0-9.]+)$/);
+      if (match) {
+        q = parseFloat(match[1]);
+        if (isNaN(q)) q = 0;
+      }
+    }
+    entries.push({ tag: tag.trim().toLowerCase(), q });
+  }
+  return entries.sort((a, b) => b.q - a.q);
+};
+var resolveLanguage = (acceptLanguage, supported, defaultLanguage) => {
+  if (!acceptLanguage) return defaultLanguage;
+  const supportedLower = supported.map((s) => s.toLowerCase());
+  const entries = parseAcceptLanguage(acceptLanguage);
+  for (const { tag, q } of entries) {
+    if (q <= 0) continue;
+    if (tag === "*") return defaultLanguage;
+    const exactIdx = supportedLower.indexOf(tag);
+    if (exactIdx !== -1) return supported[exactIdx];
+    const base = tag.split("-")[0];
+    const baseIdx = supportedLower.indexOf(base);
+    if (baseIdx !== -1) return supported[baseIdx];
+  }
+  return defaultLanguage;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BASELINE_RESOURCE_VERSION,
@@ -1910,6 +2402,8 @@ var ViewConfigSchema = import_zod19.z.object({
   CONFIG_FILES,
   CURRENT_RESOURCE_VERSION,
   CalculatedColumnSchema,
+  ColumnTypeSchema,
+  ColumnTypeShorthandSchema,
   ContainerBuilder,
   ControlBuilder,
   ControlType,
@@ -1921,12 +2415,14 @@ var ViewConfigSchema = import_zod19.z.object({
   ElementBuilder,
   FieldInputSchema,
   FieldVariantSchema,
+  I18nConfigSchema,
   JsonActionSchema,
   JsonColumnSchema,
   JsonIncludeEntrySchema,
   JsonLinkActionSchema,
   JsonOperationsSchema,
   JsonProcedureActionSchema,
+  JsonSchemaFragmentSchema,
   LayoutBuilder,
   LayoutType,
   MIGRATIONS,
@@ -1938,6 +2434,7 @@ var ViewConfigSchema = import_zod19.z.object({
   OperatorNoValue,
   OperatorOptions,
   OperatorsByType,
+  ParentRefSchema,
   PositiveRequestNumber,
   RelationFieldInputOptionsSchema,
   RelationType,
@@ -1945,6 +2442,7 @@ var ViewConfigSchema = import_zod19.z.object({
   RequestSchemaWithOffset,
   ResourceJsonSchema,
   ResourceJsonShape,
+  ResourceKindSchema,
   ResponseRequestSchema,
   ResponseSchema,
   RulesetSchema,
@@ -1955,9 +2453,11 @@ var ViewConfigSchema = import_zod19.z.object({
   StringOrArray,
   TableBuilder,
   TextCellBuilder,
+  TranslationBundleSchema,
   ViewColumnConfigSchema,
   ViewConfigSchema,
   WhenConditionSchema,
+  actionKey,
   applySchemaTransforms,
   buildConditionSchema,
   buildFilter,
@@ -1967,13 +2467,22 @@ var ViewConfigSchema = import_zod19.z.object({
   buildSortKey,
   buildTableUiSchema,
   buildViews,
+  buildViewsFromColumnTypes,
   buildViewsFromColumns,
+  buildViewsWithSource,
   colPosition,
   columnForContext,
+  columnKey,
+  columnToJsonSchemaProperty,
+  columnTypeName,
+  columnTypeSchemaSource,
+  columnTypeToJsonSchema,
   createSchema,
+  createTranslator,
   deriveSortId,
   dropNullableFromRequired,
   enforceRequiredStringMinLength,
+  enumKey,
   extractFilters,
   filterToString,
   findColumnDef,
@@ -1981,28 +2490,45 @@ var ViewConfigSchema = import_zod19.z.object({
   fromValueLabel,
   injectCalculatedColumns,
   injectCalculatedColumnsToView,
+  isArrayColumn,
+  isArrayColumnType,
   isAutocomplete,
   isBoolean,
+  isCustomKind,
   isDateRange,
+  isObjectCell,
+  isObjectColumn,
+  isObjectColumnType,
   isRecordCell,
   isRelation,
   jsonSchemaOpts,
   labelFromId,
   mergeFieldVariant,
   normalizeLabel,
+  offsetOf,
   patchFilterProperties,
   pickSharedCellOptions,
   resolveDefaultSort,
   resolveFormField,
+  resolveLanguage,
   resolveTableField,
   resolveViewField,
+  resourceControllerPath,
+  resourceSidebarKey,
+  resourceTitleKey,
   resourceVersionOf,
   runResourceMigrations,
+  sidebarGroupKey,
   sortByPosition,
   stringToFilter,
+  subResourceColumnKey,
+  subResourceTitleKey,
   toValueLabel,
   toViewColumn,
   transformDataSource,
-  uiFromJsonSchema
+  uiFromJsonSchema,
+  uiKey,
+  validationKey,
+  zodSchemaSource
 });
 //# sourceMappingURL=index.cjs.map