@omnifyjp/omnify 3.12.5 → 3.13.1

package/ts-dist/input-resolver.js

@@ -0,0 +1,246 @@
+/**
+ * Input resolver for omnify-ts.
+ *
+ * Accepts a `schemas.json` source spec and returns a local file path the
+ * caller can read directly. Three source types are supported:
+ *
+ *   - **Local** (path/relative path) — read directly from disk.
+ *   - **HTTP/HTTPS** (URL) — fetch, cache under `.omnify/cache/`, and pin
+ *     the SHA-256 hash in `.omnify/input.lock.json` for reproducible builds.
+ *   - **NPM** (package specifier like `@org/pkg/schemas.json`) — resolve via
+ *     Node module resolution from the consumer project's node_modules.
+ *
+ * Lockfile semantics (HTTP only):
+ *   - Default mode: re-fetch when the cache is stale, auto-update the
+ *     lockfile, and warn the user when the upstream hash changes so they
+ *     can review and commit the lockfile change.
+ *   - `--frozen-lockfile` mode: fail loudly if the lockfile is missing,
+ *     points at a different URL, or its hash differs from upstream. Use
+ *     this in CI to guarantee build reproducibility.
+ *
+ * Local and NPM specs do not need an omnify lockfile because:
+ *   - Local files are read every run; there is no fetch step that could
+ *     introduce drift.
+ *   - NPM packages are already version-pinned by `package-lock.json` /
+ *     `pnpm-lock.yaml` / `yarn.lock`.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { createRequire } from 'node:module';
+import { dirname, isAbsolute, join, relative, resolve as resolvePath, } from 'node:path';
+const defaultFetcher = (url) => fetch(url);
+// ============================================================================
+// Input kind detection
+// ============================================================================
+/**
+ * Decide which kind of source a spec string is. Heuristic — explicit
+ * prefixes win, ambiguous bare names default to local. Unscoped npm
+ * packages are intentionally NOT supported because they collide with
+ * relative path semantics; users should publish under a scope.
+ */
+export function sniffInputKind(spec) {
+    if (/^https?:\/\//i.test(spec))
+        return 'http';
+    if (spec.startsWith('@'))
+        return 'npm';
+    return 'local';
+}
+function lockfilePath(configDir) {
+    return join(configDir, '.omnify', 'input.lock.json');
+}
+function cachePath(configDir) {
+    return join(configDir, '.omnify', 'cache', 'schemas.json');
+}
+function readLockfile(path) {
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const raw = readFileSync(path, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== 1) {
+            throw new Error(`unsupported lockfile version ${parsed.version} at ${path}; expected 1`);
+        }
+        return parsed;
+    }
+    catch (err) {
+        throw new Error(`failed to read input lockfile ${path}: ${err.message}`);
+    }
+}
+function writeLockfile(path, entry) {
+    mkdirSync(dirname(path), { recursive: true });
+    // Trailing newline so the file is git-friendly.
+    writeFileSync(path, JSON.stringify(entry, null, 2) + '\n', 'utf-8');
+}
+// ============================================================================
+// Hashing
+// ============================================================================
+function sha256(data) {
+    return createHash('sha256').update(data, 'utf-8').digest('hex');
+}
+function sha256File(path) {
+    return sha256(readFileSync(path, 'utf-8'));
+}
+function shortHash(h) {
+    return h.slice(0, 12);
+}
+// ============================================================================
+// Per-kind resolvers
+// ============================================================================
+function resolveLocal(spec, configDir) {
+    const localPath = isAbsolute(spec) ? spec : resolvePath(configDir, spec);
+    if (!existsSync(localPath)) {
+        throw new Error(`omnify-ts: local schemas.json not found at ${localPath}\n` +
+            `(spec: ${spec}, resolved from: ${configDir})\n` +
+            `Run "omnify generate" in the backend project to create it, or fix the path.`);
+    }
+    return {
+        localPath,
+        kind: 'local',
+        sha256: sha256File(localPath),
+    };
+}
+function resolveNpm(spec, configDir) {
+    // Use Node module resolution rooted at the consumer project's
+    // package.json. createRequire wants a file path; the file doesn't have
+    // to exist as long as the directory does.
+    const require = createRequire(join(configDir, 'noop.js'));
+    let localPath;
+    try {
+        localPath = require.resolve(spec);
+    }
+    catch (err) {
+        const pkgName = extractPackageName(spec);
+        throw new Error(`omnify-ts: npm schemas.json not resolvable: ${spec}\n` +
+            `Did you run "npm install --save-dev ${pkgName}" in ${configDir}?\n` +
+            `Original error: ${err.message}`);
+    }
+    return {
+        localPath,
+        kind: 'npm',
+        sha256: sha256File(localPath),
+    };
+}
+/**
+ * Extract the package name from an npm spec like
+ * `@org/pkg/path/to/file.json` → `@org/pkg`. Used for friendly error
+ * messages.
+ */
+function extractPackageName(spec) {
+    if (spec.startsWith('@')) {
+        // Scoped: @org/pkg[/...]
+        const parts = spec.split('/');
+        return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : spec;
+    }
+    // Bare (we don't really support these but extract first segment anyway)
+    return spec.split('/')[0];
+}
+async function resolveHttp(spec, opts, fetcher) {
+    const lockPath = lockfilePath(opts.configDir);
+    const cachedFile = cachePath(opts.configDir);
+    const existingLock = readLockfile(lockPath);
+    const lockMatchesSpec = existingLock?.input === spec;
+    // Fast path: cache exists, lockfile matches spec, hash on disk matches
+    // lockfile, and we are not forced to update. No network call.
+    if (!opts.forceUpdate &&
+        existingLock &&
+        lockMatchesSpec &&
+        existsSync(cachedFile)) {
+        const cachedHash = sha256File(cachedFile);
+        if (cachedHash === existingLock.sha256) {
+            return {
+                localPath: cachedFile,
+                kind: 'http',
+                sha256: cachedHash,
+            };
+        }
+        // Cache exists but is corrupted/edited. Fall through to re-fetch unless
+        // we are in frozen mode, in which case the lockfile mismatch is fatal.
+        if (opts.frozen) {
+            throw new Error(`omnify-ts: --frozen-lockfile: cached schemas.json at ${cachedFile} ` +
+                `has been modified (hash ${shortHash(cachedHash)} vs lockfile ` +
+                `${shortHash(existingLock.sha256)}). Refusing to silently re-fetch ` +
+                `in CI mode. Delete the cache and re-run without --frozen-lockfile ` +
+                `to refresh the lockfile.`);
+        }
+    }
+    // We need to fetch. In frozen mode, fail unless we already have a
+    // matching lockfile entry; the cache may have been wiped by CI but the
+    // lockfile is the source of truth so we still know what hash to expect.
+    if (opts.frozen && !lockMatchesSpec) {
+        if (!existingLock) {
+            throw new Error(`omnify-ts: --frozen-lockfile requires ${lockPath} to exist.\n` +
+                `Run "omnify-ts" once without --frozen-lockfile to generate the ` +
+                `lockfile, then commit it.`);
+        }
+        throw new Error(`omnify-ts: --frozen-lockfile: lockfile at ${lockPath} pins input ` +
+            `"${existingLock.input}" but config has "${spec}". ` +
+            `Run without --frozen-lockfile to refresh.`);
+    }
+    console.log(`[omnify-ts] Fetching ${spec}`);
+    const response = await fetcher(spec);
+    if (!response.ok) {
+        throw new Error(`omnify-ts: HTTP ${response.status} ${response.statusText} fetching ${spec}`);
+    }
+    const body = await response.text();
+    const remoteHash = sha256(body);
+    // In frozen mode, the bytes we just downloaded MUST match the lockfile.
+    // Anything else means upstream changed since the lockfile was generated
+    // and the developer hasn't acknowledged the new schemas yet.
+    if (opts.frozen) {
+        // existingLock + lockMatchesSpec are guaranteed by the check above.
+        if (existingLock.sha256 !== remoteHash) {
+            throw new Error(`omnify-ts: --frozen-lockfile: upstream schemas.json hash ` +
+                `${shortHash(remoteHash)} does not match lockfile ` +
+                `${shortHash(existingLock.sha256)}.\n` +
+                `Upstream changed since the lockfile was generated. ` +
+                `Run "omnify-ts --update" locally, review the diff, and commit ` +
+                `${relative(opts.configDir, lockPath)}.`);
+        }
+    }
+    else if (existingLock && lockMatchesSpec && existingLock.sha256 !== remoteHash) {
+        // Auto-update mode: warn so the developer notices the change at review
+        // time and commits the new lockfile + regenerated types together.
+        console.warn(`[omnify-ts] WARNING: upstream schemas.json changed ` +
+            `(${shortHash(existingLock.sha256)} → ${shortHash(remoteHash)}). ` +
+            `Lockfile updated; review and commit the diff.`);
+    }
+    // Persist cache + lockfile.
+    mkdirSync(dirname(cachedFile), { recursive: true });
+    writeFileSync(cachedFile, body, 'utf-8');
+    writeLockfile(lockPath, {
+        version: 1,
+        input: spec,
+        source: 'http',
+        sha256: remoteHash,
+        fetchedAt: new Date().toISOString(),
+        cachedAt: relative(opts.configDir, cachedFile),
+    });
+    return {
+        localPath: cachedFile,
+        kind: 'http',
+        sha256: remoteHash,
+    };
+}
+// ============================================================================
+// Public entry point
+// ============================================================================
+/**
+ * Resolve an input spec to a concrete local file path. Dispatches by kind:
+ * local files are read directly, npm packages are resolved through Node
+ * module resolution, and HTTP URLs are fetched, cached, and pinned in the
+ * lockfile.
+ *
+ * The `fetcher` parameter is exposed only for tests; production callers
+ * should leave it at the default (`globalThis.fetch`).
+ */
+export async function resolveInput(spec, opts, fetcher = defaultFetcher) {
+    const kind = sniffInputKind(spec);
+    switch (kind) {
+        case 'local':
+            return resolveLocal(spec, opts.configDir);
+        case 'npm':
+            return resolveNpm(spec, opts.configDir);
+        case 'http':
+            return resolveHttp(spec, opts, fetcher);
+    }
+}

package/ts-dist/metadata-generator.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @omnify/ts — Form Field Metadata Generator (issue omnify-jp/omnify-go#54)
+ *
+ * Emits a `<modelName>Metadata` constant alongside the existing generated
+ * `base/<Model>.ts`. The constant is a flat description of every field's
+ * type, validation rules, translatable flag, enum binding, label, and
+ * placeholder dictionaries.
+ *
+ * Downstream tools (forms, stories, smoke tests, validation, headless form
+ * runners) read from this single source of truth instead of each project
+ * rolling its own per-model lookup tables.
+ *
+ * The metadata is a *new* artifact emitted in addition to the existing
+ * interface, zod schemas, and i18n object — none of those are modified.
+ */
+import type { GeneratorOptions, PropertyDefinition, SchemaDefinition, SchemaDisplayNames } from './types.js';
+/** Coarse field-type taxonomy that downstream form runners switch on. */
+export type MetadataFieldType = 'string' | 'text' | 'number' | 'boolean' | 'date' | 'datetime' | 'time' | 'json' | 'enum' | 'uuid' | 'file' | 'compound';
+/** Per-field entry in the metadata constant. */
+export interface MetadataField {
+    /** Coarse field type (see taxonomy above). */
+    type: MetadataFieldType;
+    /** Whether the field is required by the create schema. */
+    required: boolean;
+    /** Whether the YAML declared the field nullable. */
+    nullable: boolean;
+    /** Whether the YAML declared the field translatable. */
+    translatable: boolean;
+    /** Validation rules that apply to this field type. Empty object if none. */
+    validation: Record<string, unknown>;
+    /** Enum name (only for `type: 'enum'`). */
+    enum?: string;
+    /** Enum value list (only for `type: 'enum'`); always emitted with `as const`. */
+    enumValues?: readonly string[];
+    /** Relation info (only for `type: 'uuid'`/'number' association FK). */
+    relation?: {
+        model: string;
+        table?: string;
+        onDelete?: string;
+    };
+    /** Compound type identifier (only for `type: 'compound'`). */
+    compoundType?: string;
+    /** Localized label dictionary (locale → string). */
+    label: Record<string, string>;
+    /** Localized placeholder dictionary (locale → string). Optional. */
+    placeholder?: Record<string, string>;
+}
+/** Aggregations exported alongside the per-field entries for ergonomics. */
+export interface MetadataAggregations {
+    translatableFields: string[];
+    requiredFields: string[];
+    enumFields: string[];
+    relationFields: string[];
+}
+/** Resolved metadata for a single schema. */
+export interface SchemaMetadata {
+    modelName: string;
+    table?: string;
+    fields: Record<string, MetadataField>;
+    aggregations: MetadataAggregations;
+}
+/**
+ * Map a YAML property to the coarse metadata type taxonomy. Used by both
+ * #54 (metadata generator) and #55 (payload builder) so the two stay in
+ * lockstep.
+ */
+export declare function classifyFieldType(prop: PropertyDefinition, allSchemas: Record<string, SchemaDefinition>, customSimpleTypes: Record<string, {
+    mapsTo: string;
+}>): MetadataFieldType;
+/**
+ * Build the metadata IR for a single schema. Pure function — formatter
+ * does the string work.
+ */
+export declare function buildSchemaMetadata(schema: SchemaDefinition, allSchemas: Record<string, SchemaDefinition>, options: GeneratorOptions, displayNames: SchemaDisplayNames): SchemaMetadata;
+/** Render the SchemaMetadata IR to a TypeScript const literal block. */
+export declare function formatMetadataConst(meta: SchemaMetadata): string;

package/ts-dist/metadata-generator.js

@@ -0,0 +1,329 @@
+/**
+ * @omnify/ts — Form Field Metadata Generator (issue omnify-jp/omnify-go#54)
+ *
+ * Emits a `<modelName>Metadata` constant alongside the existing generated
+ * `base/<Model>.ts`. The constant is a flat description of every field's
+ * type, validation rules, translatable flag, enum binding, label, and
+ * placeholder dictionaries.
+ *
+ * Downstream tools (forms, stories, smoke tests, validation, headless form
+ * runners) read from this single source of truth instead of each project
+ * rolling its own per-model lookup tables.
+ *
+ * The metadata is a *new* artifact emitted in addition to the existing
+ * interface, zod schemas, and i18n object — none of those are modified.
+ */
+import { toSnakeCase } from './interface-generator.js';
+// ---------------------------------------------------------------------------
+// Type classification — single source of truth so #55 (payload builder)
+// can reuse the same field-type decisions.
+// ---------------------------------------------------------------------------
+const TEXT_TYPES = new Set(['Text', 'MediumText', 'LongText']);
+const STRING_TYPES = new Set([
+    'String', 'Email', 'Password', 'Phone', 'Slug', 'Url', 'Uuid',
+]);
+const NUMBER_TYPES = new Set([
+    'TinyInt', 'Int', 'BigInt', 'Float', 'Decimal',
+]);
+/**
+ * Map a YAML property to the coarse metadata type taxonomy. Used by both
+ * #54 (metadata generator) and #55 (payload builder) so the two stay in
+ * lockstep.
+ */
+export function classifyFieldType(prop, allSchemas, customSimpleTypes) {
+    // File / image
+    if (prop.type === 'File')
+        return 'file';
+    // Owning-side association → FK column. Resolve target id type.
+    if (prop.type === 'Association' &&
+        (prop.relation === 'ManyToOne' || prop.relation === 'OneToOne') &&
+        !prop.mappedBy) {
+        const targetSchema = prop.target ? allSchemas[prop.target] : undefined;
+        const idType = (() => {
+            const id = targetSchema?.options?.id;
+            return typeof id === 'string' ? id : 'BigInt';
+        })();
+        if (idType === 'Uuid' || idType === 'Ulid' || idType === 'String') {
+            return 'uuid';
+        }
+        return 'number';
+    }
+    // Inverse-side association doesn't carry a column → not represented in
+    // the form metadata.
+    if (prop.type === 'Association')
+        return 'json';
+    // Enum
+    if (prop.type === 'Enum' || prop.type === 'EnumRef' || prop.type === 'Select') {
+        return 'enum';
+    }
+    // Compound type (japan.address etc.) — caller provides the simple-types
+    // table; if the property type isn't there, fall through to base map.
+    if (customSimpleTypes[prop.type]) {
+        const mapsTo = customSimpleTypes[prop.type].mapsTo;
+        if (TEXT_TYPES.has(mapsTo))
+            return 'text';
+        if (NUMBER_TYPES.has(mapsTo))
+            return 'number';
+        return 'string';
+    }
+    if (TEXT_TYPES.has(prop.type))
+        return 'text';
+    if (NUMBER_TYPES.has(prop.type))
+        return 'number';
+    if (STRING_TYPES.has(prop.type))
+        return 'string';
+    if (prop.type === 'Boolean')
+        return 'boolean';
+    if (prop.type === 'Date')
+        return 'date';
+    if (prop.type === 'DateTime' || prop.type === 'Timestamp')
+        return 'datetime';
+    if (prop.type === 'Time')
+        return 'time';
+    if (prop.type === 'Json')
+        return 'json';
+    // Lookup is a FK to an enum-like lookup table; treat as enum reference.
+    if (prop.type === 'Lookup')
+        return 'enum';
+    return 'string';
+}
+// ---------------------------------------------------------------------------
+// Build the SchemaMetadata IR from a SchemaDefinition.
+// ---------------------------------------------------------------------------
+function pickValidation(prop) {
+    const out = {};
+    // Source of truth: prop.rules (the validation rules block) takes
+    // precedence over the legacy top-level length / min / max fields.
+    const rules = prop.rules ?? {};
+    if (rules.maxLength != null)
+        out.maxLength = rules.maxLength;
+    else if (prop.maxLength != null)
+        out.maxLength = prop.maxLength;
+    else if (prop.length != null)
+        out.maxLength = prop.length;
+    if (rules.minLength != null)
+        out.minLength = rules.minLength;
+    else if (prop.minLength != null)
+        out.minLength = prop.minLength;
+    if (rules.max != null)
+        out.max = rules.max;
+    else if (prop.max != null)
+        out.max = prop.max;
+    if (rules.min != null)
+        out.min = rules.min;
+    else if (prop.min != null)
+        out.min = prop.min;
+    if (prop.pattern != null)
+        out.pattern = prop.pattern;
+    return out;
+}
+function isFieldRequired(prop) {
+    if (prop.rules?.required === false)
+        return false;
+    if (prop.rules?.required === true)
+        return true;
+    return !(prop.nullable ?? false);
+}
+function resolveEnumValues(prop, pluginEnums, allSchemas) {
+    if (typeof prop.enum === 'string') {
+        // First check plugin enums (e.g. Prefecture from compound types).
+        const fromPlugin = pluginEnums[prop.enum];
+        if (fromPlugin)
+            return fromPlugin;
+        // Fall back to schema-defined enums (kind: 'enum' schemas with values).
+        const schemaEnum = allSchemas[prop.enum];
+        if (schemaEnum?.values && schemaEnum.values.length > 0) {
+            return schemaEnum.values.map((v) => v.value);
+        }
+        return undefined;
+    }
+    if (Array.isArray(prop.enum)) {
+        return prop.enum.map((v) => typeof v === 'string' ? v : v.value);
+    }
+    return undefined;
+}
+/**
+ * Build the metadata IR for a single schema. Pure function — formatter
+ * does the string work.
+ */
+export function buildSchemaMetadata(schema, allSchemas, options, displayNames) {
+    const fields = {};
+    const translatableFields = [];
+    const requiredFields = [];
+    const enumFields = [];
+    const relationFields = [];
+    if (schema.properties) {
+        const propNames = schema.propertyOrder ?? Object.keys(schema.properties);
+        for (const propName of propNames) {
+            const prop = schema.properties[propName];
+            if (!prop)
+                continue;
+            // Skip inverse associations — they don't carry a column.
+            const isInverseAssoc = prop.type === 'Association' &&
+                (Boolean(prop.mappedBy) ||
+                    prop.relation === 'OneToMany' ||
+                    prop.relation === 'ManyToMany' ||
+                    prop.relation === 'MorphMany' ||
+                    prop.relation === 'MorphToMany' ||
+                    prop.relation === 'MorphedByMany' ||
+                    prop.relation === 'MorphTo');
+            if (isInverseAssoc)
+                continue;
+            // Owning ManyToOne / OneToOne → FK column key has `_id` suffix.
+            const isOwningAssoc = prop.type === 'Association' &&
+                (prop.relation === 'ManyToOne' || prop.relation === 'OneToOne') &&
+                !prop.mappedBy;
+            const fieldKey = isOwningAssoc
+                ? `${toSnakeCase(propName)}_id`
+                : toSnakeCase(propName);
+            const fieldType = classifyFieldType(prop, allSchemas, options.customTypes.simple);
+            const required = isFieldRequired(prop);
+            const nullable = prop.nullable ?? false;
+            const translatable = prop.translatable === true;
+            const meta = {
+                type: fieldType,
+                required,
+                nullable,
+                translatable,
+                validation: pickValidation(prop),
+                label: displayNames.propertyDisplayNames[fieldKey] ?? {},
+            };
+            const placeholder = displayNames.propertyPlaceholders[fieldKey];
+            if (placeholder)
+                meta.placeholder = placeholder;
+            if (fieldType === 'enum') {
+                if (typeof prop.enum === 'string') {
+                    meta.enum = prop.enum;
+                }
+                const values = resolveEnumValues(prop, options.customTypes.enums, allSchemas);
+                if (values)
+                    meta.enumValues = values;
+                enumFields.push(fieldKey);
+            }
+            if (isOwningAssoc) {
+                const targetName = prop.target ?? '';
+                const targetSchema = targetName ? allSchemas[targetName] : undefined;
+                const targetTable = targetSchema?.tableName ?? toSnakeCase(targetName) + 's';
+                meta.relation = {
+                    model: targetName,
+                    table: targetTable,
+                    onDelete: prop.onDelete,
+                };
+                relationFields.push(fieldKey);
+            }
+            if (translatable)
+                translatableFields.push(fieldKey);
+            if (required)
+                requiredFields.push(fieldKey);
+            fields[fieldKey] = meta;
+        }
+    }
+    return {
+        modelName: schema.name,
+        table: schema.tableName,
+        fields,
+        aggregations: {
+            translatableFields,
+            requiredFields,
+            enumFields,
+            relationFields,
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Formatter — turns the IR into a TypeScript const literal.
+// ---------------------------------------------------------------------------
+function jsLiteral(value, indent = 0) {
+    if (value === null)
+        return 'null';
+    if (value === undefined)
+        return 'undefined';
+    if (typeof value === 'string')
+        return JSON.stringify(value);
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return '[]';
+        const inner = value.map((v) => jsLiteral(v, indent + 2)).join(', ');
+        return `[${inner}]`;
+    }
+    if (typeof value === 'object') {
+        const entries = Object.entries(value);
+        if (entries.length === 0)
+            return '{}';
+        const pad = ' '.repeat(indent + 2);
+        const closingPad = ' '.repeat(indent);
+        const inner = entries
+            .map(([k, v]) => `${pad}${formatKey(k)}: ${jsLiteral(v, indent + 2)}`)
+            .join(',\n');
+        return `{\n${inner},\n${closingPad}}`;
+    }
+    return JSON.stringify(value);
+}
+function formatKey(key) {
+    // Use bare identifier when possible (preserves nice JS look); fall back
+    // to quoted string for keys with hyphens, dots, or starting with a digit.
+    if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key))
+        return key;
+    return JSON.stringify(key);
+}
+/** Render the SchemaMetadata IR to a TypeScript const literal block. */
+export function formatMetadataConst(meta) {
+    const lowerName = meta.modelName.charAt(0).toLowerCase() + meta.modelName.slice(1);
+    const constName = `${lowerName}Metadata`;
+    const parts = [];
+    parts.push(`// ============================================================================\n`);
+    parts.push(`// Form Field Metadata (issue #54)\n`);
+    parts.push(`// ============================================================================\n\n`);
+    parts.push(`/**\n`);
+    parts.push(` * Form field metadata for ${meta.modelName}.\n`);
+    parts.push(` *\n`);
+    parts.push(` * Single source of truth for downstream tools (form runners, stories,\n`);
+    parts.push(` * smoke tests, headless validation). Includes per-field type taxonomy,\n`);
+    parts.push(` * validation rules, translatable / required / nullable flags, enum value\n`);
+    parts.push(` * lists, relation pointers, and i18n labels — all flat, all in one const.\n`);
+    parts.push(` */\n`);
+    parts.push(`export const ${constName} = {\n`);
+    parts.push(`  modelName: ${JSON.stringify(meta.modelName)},\n`);
+    if (meta.table) {
+        parts.push(`  table: ${JSON.stringify(meta.table)},\n`);
+    }
+    parts.push(`\n`);
+    parts.push(`  fields: {\n`);
+    for (const [fieldName, field] of Object.entries(meta.fields)) {
+        parts.push(`    ${formatKey(fieldName)}: {\n`);
+        parts.push(`      type: ${JSON.stringify(field.type)},\n`);
+        parts.push(`      required: ${field.required},\n`);
+        parts.push(`      nullable: ${field.nullable},\n`);
+        parts.push(`      translatable: ${field.translatable},\n`);
+        parts.push(`      validation: ${jsLiteral(field.validation, 6)},\n`);
+        if (field.enum) {
+            parts.push(`      enum: ${JSON.stringify(field.enum)},\n`);
+        }
+        if (field.enumValues) {
+            parts.push(`      enumValues: ${jsLiteral([...field.enumValues], 6)} as const,\n`);
+        }
+        if (field.relation) {
+            parts.push(`      relation: ${jsLiteral(field.relation, 6)},\n`);
+        }
+        if (field.compoundType) {
+            parts.push(`      compoundType: ${JSON.stringify(field.compoundType)},\n`);
+        }
+        parts.push(`      label: ${jsLiteral(field.label, 6)},\n`);
+        if (field.placeholder) {
+            parts.push(`      placeholder: ${jsLiteral(field.placeholder, 6)},\n`);
+        }
+        parts.push(`    },\n`);
+    }
+    parts.push(`  },\n\n`);
+    // Aggregations — emit as `as const` arrays so the literal types narrow.
+    parts.push(`  translatableFields: ${jsLiteral(meta.aggregations.translatableFields, 2)} as const,\n`);
+    parts.push(`  requiredFields: ${jsLiteral(meta.aggregations.requiredFields, 2)} as const,\n`);
+    parts.push(`  enumFields: ${jsLiteral(meta.aggregations.enumFields, 2)} as const,\n`);
+    parts.push(`  relationFields: ${jsLiteral(meta.aggregations.relationFields, 2)} as const,\n`);
+    parts.push(`} as const;\n\n`);
+    // Field-name type alias for ergonomic keying in downstream consumers.
+    parts.push(`export type ${meta.modelName}FieldName = keyof typeof ${constName}.fields;\n\n`);
+    return parts.join('');
+}