@skmtc/core 0.0.984 → 0.16.1

package/esm/dsl/model/ModelDriver.d.ts

@@ -1,4 +1,4 @@
-import type { ModelInsertable } from './types.js';
+import type { ModelProjection } from './types.js';
 import type { GenerateContextType } from '../../context/generateTypes.js';
 import type { ContentSettings } from '../ContentSettings.js';
 import type { GeneratedDefinition } from '../GeneratedValue.js';
@@ -6,83 +6,48 @@ import type { GeneratedValue } from '../GeneratedValue.js';
 import type { RefName } from '../../types/RefName.js';
 type CreateModelArgs<V extends GeneratedValue, EnrichmentType> = {
     context: GenerateContextType;
-    insertable: ModelInsertable<V, EnrichmentType>;
+    projection: ModelProjection<V, EnrichmentType>;
     refName: RefName;
     destinationPath?: string;
     rootRef?: RefName;
     noExport?: boolean;
+    /**
+     * Target variant of the projection. The Driver resolves the
+     * peer's enrichment for this variant, asserts the variant exists
+     * (or is the default `'main'` which is always permitted), and
+     * threads it into the projection's `ContentSettings`.
+     */
+    variant: string;
 };
 /**
- * Driver class responsible for managing model generation lifecycle.
+ * Driver for the model insertion lifecycle.
  *
- * @template V - The generated value type
- * @template T - The generation type
- * @template EnrichmentType - Optional enrichment type
+ * Resolves the projection's identifier and export path, looks up an
+ * existing `Definition` in the target file, instantiates the projection
+ * (constructing its value) when no cache hit exists, registers the new
+ * definition, and stitches an import into `destinationPath` if it differs
+ * from the projection's `exportPath`.
  */
 export declare class ModelDriver<V extends GeneratedValue, EnrichmentType> {
-    /** The generation context */
     context: GenerateContextType;
-    /** The insertable model configuration */
-    insertable: ModelInsertable<V, EnrichmentType>;
-    /** Reference name for the model */
+    projection: ModelProjection<V, EnrichmentType>;
     refName: RefName;
-    /** Content settings for the model */
     settings: ContentSettings<EnrichmentType>;
-    /** Optional destination path for the generated file */
     destinationPath?: string;
-    /** The generated definition */
     definition: GeneratedDefinition<V>;
-    /** Optional root reference name */
     rootRef?: RefName;
-    /** Whether to skip export declaration */
     noExport?: boolean;
-    /**
-     * Creates a new ModelDriver instance.
-     *
-     * @param args - Constructor arguments
-     * @param args.context - Generation context
-     * @param args.insertable - Model insertable configuration
-     * @param args.refName - Reference name for the model
-     * @param args.destinationPath - Optional destination path
-     * @param args.rootRef - Optional root reference name
-     * @param args.noExport - Whether to skip export declaration
-     */
-    constructor({ context, insertable, refName, destinationPath, rootRef, noExport }: CreateModelArgs<V, EnrichmentType>);
-    /**
-     * Applies generation configuration to create the model definition.
-     *
-     * This method handles the core generation logic, including identifier resolution,
-     * export path management, and import registration for cross-file dependencies.
-     *
-     * @param args - Apply configuration arguments
-     * @param args.destinationPath - Optional destination path for imports
-     * @returns Generated definition for the model
-     */
+    variant: string;
+    constructor({ context, projection, refName, destinationPath, rootRef, noExport, variant }: CreateModelArgs<V, EnrichmentType>);
     private apply;
     /**
-     * Retrieves or creates a definition for the model.
-     *
-     * This method first checks for cached definitions to avoid duplicate generation,
-     * then creates a new definition if none exists. It handles the complete model
-     * transformation process including schema resolution and value generation.
-     *
-     * @param args - Definition retrieval arguments
-     * @param args.identifier - The identifier for the definition
-     * @param args.exportPath - The export path for the definition
-     * @returns Model definition instance
+     * Ensure the file at `path` exists, creating it on first write through
+     * the projection's language — the static read off the projection class
+     * at the use site, never persisted (works pre-construction on the
+     * cache-hit path). Returns the normalized path.
      */
+    private ensureFile;
     private getDefinition;
-    /**
-     * Type guard to verify a definition matches the expected generated value type.
-     *
-     * This method performs type narrowing to ensure a cached definition is compatible
-     * with the current generation requirements, including export path validation.
-     *
-     * @template V - The expected generated value type
-     * @param definition - The definition to verify (may be undefined)
-     * @param exportPath - Expected export path for validation
-     * @returns True if definition matches expected type and constraints
-     */
     private affirmDefinition;
 }
 export {};

package/esm/dsl/model/ModelDriver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ModelDriver.d.ts","sourceRoot":"","sources":["../../../src/dsl/model/ModelDriver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AACjD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAA;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAI5D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AAGrD,KAAK,eAAe,CAAC,CAAC,SAAS,cAAc,EAAE,cAAc,IAAI;IAC/D,OAAO,EAAE,mBAAmB,CAAA;IAC5B,UAAU,EAAE,eAAe,CAAC,CAAC,EAAE,cAAc,CAAC,CAAA;IAC9C,OAAO,EAAE,OAAO,CAAA;IAChB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAWD;;;;;;GAMG;AACH,qBAAa,WAAW,CAAC,CAAC,SAAS,cAAc,EAAE,cAAc;IAC/D,6BAA6B;IAC7B,OAAO,EAAE,mBAAmB,CAAA;IAC5B,yCAAyC;IACzC,UAAU,EAAE,eAAe,CAAC,CAAC,EAAE,cAAc,CAAC,CAAA;IAC9C,mCAAmC;IACnC,OAAO,EAAE,OAAO,CAAA;IAChB,qCAAqC;IACrC,QAAQ,EAAE,eAAe,CAAC,cAAc,CAAC,CAAA;IACzC,uDAAuD;IACvD,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,+BAA+B;IAC/B,UAAU,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAA;IAClC,mCAAmC;IACnC,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,yCAAyC;IACzC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAElB;;;;;;;;;;OAUG;gBACS,EACV,OAAO,EACP,UAAU,EACV,OAAO,EACP,eAAe,EACf,OAAO,EACP,QAAQ,EACT,EAAE,eAAe,CAAC,CAAC,EAAE,cAAc,CAAC;IAgBrC;;;;;;;;;OASG;IACH,OAAO,CAAC,KAAK;IAeb;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,aAAa;IA2CrB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,gBAAgB;CAqBzB"}
+{"version":3,"file":"ModelDriver.d.ts","sourceRoot":"","sources":["../../../src/dsl/model/ModelDriver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AACjD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAA;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAI5D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AAMrD,KAAK,eAAe,CAAC,CAAC,SAAS,cAAc,EAAE,cAAc,IAAI;IAC/D,OAAO,EAAE,mBAAmB,CAAA;IAC5B,UAAU,EAAE,eAAe,CAAC,CAAC,EAAE,cAAc,CAAC,CAAA;IAC9C,OAAO,EAAE,OAAO,CAAA;IAChB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB;;;;;OAKG;IACH,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAWD;;;;;;;;GAQG;AACH,qBAAa,WAAW,CAAC,CAAC,SAAS,cAAc,EAAE,cAAc;IAC/D,OAAO,EAAE,mBAAmB,CAAA;IAC5B,UAAU,EAAE,eAAe,CAAC,CAAC,EAAE,cAAc,CAAC,CAAA;IAC9C,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,eAAe,CAAC,cAAc,CAAC,CAAA;IACzC,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,UAAU,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAA;IAClC,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;gBAEH,EACV,OAAO,EACP,UAAU,EACV,OAAO,EACP,eAAe,EACf,OAAO,EACP,QAAQ,EACR,OAAO,EACR,EAAE,eAAe,CAAC,CAAC,EAAE,cAAc,CAAC;IAwBrC,OAAO,CAAC,KAAK;IAoBb;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IAYlB,OAAO,CAAC,aAAa;IAkCrB,OAAO,CAAC,gBAAgB;CAsBzB"}

package/esm/dsl/model/ModelDriver.js

@@ -1,126 +1,119 @@
-import { normalize } from '../../deps/jsr.io/@std/path/1.1.3/normalize.js';
-import { Definition } from '../Definition.js';
+import { normalize } from '../../deps/jsr.io/@std/path/1.1.4/normalize.js';
 import { toModelGeneratorKey } from '../GeneratorKeys.js';
+import { DEFAULT_VARIANT } from '../../types/Variant.js';
+import get from 'lodash-es/get.js';
 /**
- * Driver class responsible for managing model generation lifecycle.
+ * Driver for the model insertion lifecycle.
  *
- * @template V - The generated value type
- * @template T - The generation type
- * @template EnrichmentType - Optional enrichment type
+ * Resolves the projection's identifier and export path, looks up an
+ * existing `Definition` in the target file, instantiates the projection
+ * (constructing its value) when no cache hit exists, registers the new
+ * definition, and stitches an import into `destinationPath` if it differs
+ * from the projection's `exportPath`.
  */
 export class ModelDriver {
-    /**
-     * Creates a new ModelDriver instance.
-     *
-     * @param args - Constructor arguments
-     * @param args.context - Generation context
-     * @param args.insertable - Model insertable configuration
-     * @param args.refName - Reference name for the model
-     * @param args.destinationPath - Optional destination path
-     * @param args.rootRef - Optional root reference name
-     * @param args.noExport - Whether to skip export declaration
-     */
-    constructor({ context, insertable, refName, destinationPath, rootRef, noExport }) {
-        /** The generation context */
+    constructor({ context, projection, refName, destinationPath, rootRef, noExport, variant }) {
         Object.defineProperty(this, "context", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        /** The insertable model configuration */
-        Object.defineProperty(this, "insertable", {
+        Object.defineProperty(this, "projection", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        /** Reference name for the model */
         Object.defineProperty(this, "refName", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        /** Content settings for the model */
         Object.defineProperty(this, "settings", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        /** Optional destination path for the generated file */
         Object.defineProperty(this, "destinationPath", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        /** The generated definition */
         Object.defineProperty(this, "definition", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        /** Optional root reference name */
         Object.defineProperty(this, "rootRef", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        /** Whether to skip export declaration */
         Object.defineProperty(this, "noExport", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "variant", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.context = context;
-        this.insertable = insertable;
+        this.projection = projection;
         this.refName = refName;
         this.destinationPath = destinationPath;
         this.rootRef = rootRef;
         this.noExport = noExport;
-        this.context.modelDepth[`${insertable.id}:${refName}`] = 0;
-        this.settings = this.context.toModelContentSettings({ refName, insertable });
+        this.variant = variant;
+        this.context.modelDepth[`${projection.id}:${refName}`] = 0;
+        assertPeerVariantExists({
+            context,
+            generatorId: projection.id,
+            refName,
+            variant
+        });
+        this.settings = this.context.toModelContentSettings({ refName, projection, variant });
         this.definition = this.apply({ destinationPath });
-        this.context.modelDepth[`${insertable.id}:${refName}`] = 0;
+        this.context.modelDepth[`${projection.id}:${refName}`] = 0;
     }
-    /**
-     * Applies generation configuration to create the model definition.
-     *
-     * This method handles the core generation logic, including identifier resolution,
-     * export path management, and import registration for cross-file dependencies.
-     *
-     * @param args - Apply configuration arguments
-     * @param args.destinationPath - Optional destination path for imports
-     * @returns Generated definition for the model
-     */
     apply({ destinationPath } = {}) {
         const { identifier, exportPath } = this.settings;
         const definition = this.getDefinition({ identifier, exportPath });
         if (destinationPath && normalize(exportPath) !== normalize(destinationPath)) {
+            // Cross-file import of the peer's identifier from its export path.
+            // The language builds the import object (`toImport`) and creates the
+            // destination file on first write (caller-side); the engine stores
+            // via the pure-data `context.register`.
+            this.ensureFile(destinationPath);
             this.context.register({
-                imports: { [exportPath]: [identifier.name] },
+                imports: [this.projection.lang.toImport({ identifier, module: exportPath })],
                 destinationPath
             });
         }
         return definition;
     }
     /**
-     * Retrieves or creates a definition for the model.
-     *
-     * This method first checks for cached definitions to avoid duplicate generation,
-     * then creates a new definition if none exists. It handles the complete model
-     * transformation process including schema resolution and value generation.
-     *
-     * @param args - Definition retrieval arguments
-     * @param args.identifier - The identifier for the definition
-     * @param args.exportPath - The export path for the definition
-     * @returns Model definition instance
+     * Ensure the file at `path` exists, creating it on first write through
+     * the projection's language — the static read off the projection class
+     * at the use site, never persisted (works pre-construction on the
+     * cache-hit path). Returns the normalized path.
      */
+    ensureFile(path) {
+        const normalizedPath = normalize(path);
+        if (!this.context.getFile(normalizedPath)) {
+            this.context.addFile(this.projection.lang.createFile({ path: normalizedPath, settings: this.context.settings }));
+        }
+        return normalizedPath;
+    }
     getDefinition({ identifier, exportPath }) {
         const cachedDefinition = this.context.findDefinition({
             name: identifier.name,
@@ -129,55 +122,71 @@ export class ModelDriver {
         if (this.affirmDefinition(cachedDefinition, exportPath)) {
             return cachedDefinition;
         }
-        // const [previous, current] = this.context.stackTrail.slice(-2).stackTrail
-        // if (
-        //   previous === this.insertable.id &&
-        //   current === this.refName &&
-        //   this.refName === this.rootRef
-        // ) {
-        //   this.context.modelDepth++
-        // }
-        const value = new this.insertable({
+        const value = new this.projection({
             refName: this.refName,
             context: this.context,
             settings: this.settings,
             destinationPath: this.settings.exportPath,
             rootRef: this.rootRef
         });
-        const definition = new Definition({
+        const definition = this.projection.lang.toDefinition({
             context: this.context,
-            value,
             identifier,
+            value,
             noExport: this.noExport
         });
+        this.ensureFile(exportPath);
         this.context.register({
             definitions: [definition],
             destinationPath: exportPath
         });
         return definition;
     }
-    /**
-     * Type guard to verify a definition matches the expected generated value type.
-     *
-     * This method performs type narrowing to ensure a cached definition is compatible
-     * with the current generation requirements, including export path validation.
-     *
-     * @template V - The expected generated value type
-     * @param definition - The definition to verify (may be undefined)
-     * @param exportPath - Expected export path for validation
-     * @returns True if definition matches expected type and constraints
-     */
     affirmDefinition(definition, exportPath) {
         if (!definition) {
             return false;
         }
         const currentKey = toModelGeneratorKey({
-            generatorId: this.insertable.id,
-            refName: this.refName
+            generatorId: this.projection.id,
+            refName: this.refName,
+            variant: this.settings.variant
         });
         if (currentKey !== definition.generatorKey) {
             throw new Error(`Registered definition mismatch: '${definition.identifier.name}' in file '${exportPath}'. Cached key '${definition.generatorKey}' does not match new key '${currentKey}'`);
         }
-        return definition.value instanceof this.insertable;
+        return definition.value instanceof this.projection;
     }
 }
+/**
+ * Guard the peer-variant-mismatch invariant for model insertions.
+ *
+ * `'main'` is the universally-safe variant — it's guaranteed to be
+ * present on every peer (the engine fills it when no enrichments are
+ * configured, and the missing-`'main'` check throws when other
+ * variants exist without it). So calls with `variant === 'main'`
+ * always succeed regardless of the peer's enrichment shape.
+ *
+ * For any other variant, the peer's enrichment block at
+ * `[generatorId][refName]` must explicitly declare that variant
+ * key. The Driver throws here — loud at the call site — rather than
+ * letting silently-wrong output reach the consumer.
+ */
+const assertPeerVariantExists = ({ context, generatorId, refName, variant }) => {
+    if (variant === DEFAULT_VARIANT) {
+        return;
+    }
+    const modelEnrichments = get(context.settings, ['enrichments', generatorId, refName]);
+    if (modelEnrichments === null || modelEnrichments === undefined) {
+        throw new Error(`[${generatorId}] Cannot insert variant '${variant}' for '${refName}' — ` +
+            `peer has no enrichments configured. Only '${DEFAULT_VARIANT}' is permitted.`);
+    }
+    if (typeof modelEnrichments !== 'object' || Array.isArray(modelEnrichments)) {
+        throw new Error(`[${generatorId}] Cannot insert variant '${variant}' for '${refName}' — ` +
+            `peer enrichment is not a variant record.`);
+    }
+    if (!(variant in modelEnrichments)) {
+        const available = Object.keys(modelEnrichments).join(', ');
+        throw new Error(`[${generatorId}] Cannot insert variant '${variant}' for '${refName}'. ` +
+            `Available variants: ${available}.`);
+    }
+};

package/esm/dsl/model/toModelEntry.d.ts

@@ -1,15 +1,16 @@
 import type { RefName } from '../../types/RefName.js';
 import type { EnrichmentRequest } from '../../types/EnrichmentRequest.js';
-import type { TransformModelArgs, ToModelPreviewModuleArgs, ToModelMappingArgs } from './types.js';
+import type { TransformModelArgs, ToModelPreviewModuleArgs, ToModelMappingArgs, ToModelEnrichmentsArgs } from './types.js';
 import type * as v from 'valibot';
 import type { MappingModule, PreviewModule } from '../../types/Preview.js';
-type ToModelEntryArgs<EnrichmentType = undefined, Acc = void> = {
+type ToModelEntryArgs<EnrichmentType = undefined> = {
     id: string;
-    transform: ({ context, refName, acc }: TransformModelArgs<Acc>) => Acc;
-    toEnrichmentSchema?: () => v.GenericSchema<EnrichmentType>;
-    toPreviewModule?: ({ context, refName }: ToModelPreviewModuleArgs) => PreviewModule;
-    toMappingModule?: ({ context, refName }: ToModelMappingArgs) => MappingModule;
+    transform: ({ context, refName, variant }: TransformModelArgs) => void;
+    toEnrichmentSchema: () => v.GenericSchema<EnrichmentType>;
+    toPreviewModule?: ({ context, refName, variant }: ToModelPreviewModuleArgs) => PreviewModule;
+    toMappingModule?: ({ context, refName, variant }: ToModelMappingArgs) => MappingModule;
     toEnrichmentRequest?: <RequestedEnrichment extends EnrichmentType>(refName: RefName) => EnrichmentRequest<RequestedEnrichment> | undefined;
+    toEnrichmentDefaults?: ({ refName, context, variant }: ToModelEnrichmentsArgs) => EnrichmentType | undefined;
 };
 /**
  * Creates a model transformation entry for the SKMTC pipeline.
@@ -22,7 +23,6 @@ type ToModelEntryArgs<EnrichmentType = undefined, Acc = void> = {
  * mapping generation, enrichment handling, and schema validation.
  *
  * @template EnrichmentType - Type of enrichments that can be applied to models
- * @template Acc - Accumulator type for the transformation process
  * @param args - Configuration for the model entry
  * @param args.id - Unique identifier for this model entry
  * @param args.transform - Function to transform schemas into artifacts
@@ -38,10 +38,8 @@ type ToModelEntryArgs<EnrichmentType = undefined, Acc = void> = {
  *
  * const typeScriptModelEntry = toModelEntry({
  *   id: 'typescript-models',
- *   transform: ({ context, refName, acc }) => {
- *     const schema = context.getSchemaByRefName(refName);
- *     const tsInterface = generateTypeScriptInterface(schema);
- *     return { ...acc, [refName]: tsInterface };
+ *   transform: ({ context, refName }) => {
+ *     context.insertModel(TsModel, refName);
  *   },
  *   toPreviewModule: ({ context, refName }) => ({
  *     group: 'forms',
@@ -55,13 +53,8 @@ type ToModelEntryArgs<EnrichmentType = undefined, Acc = void> = {
  * ```typescript
  * const validationModelEntry = toModelEntry({
  *   id: 'validation-schemas',
- *   transform: ({ context, refName, acc }) => {
- *     const enrichments = context.getEnrichments(refName);
- *     const schema = context.getSchemaByRefName(refName);
- *     const validationSchema = generateValidationSchema(schema, {
- *       strict: enrichments?.strict ?? false
- *     });
- *     return { ...acc, [refName]: validationSchema };
+ *   transform: ({ context, refName }) => {
+ *     context.insertModel(ValidationModel, refName);
  *   },
  *   toEnrichmentSchema: () => v.object({
  *     strict: v.optional(v.boolean()),
@@ -74,14 +67,15 @@ type ToModelEntryArgs<EnrichmentType = undefined, Acc = void> = {
  * });
  * ```
  */
-export declare const toModelEntry: <EnrichmentType = undefined, Acc = void>({ id, transform, toPreviewModule, toMappingModule, toEnrichmentSchema, toEnrichmentRequest }: ToModelEntryArgs<EnrichmentType, Acc>) => {
+export declare const toModelEntry: <EnrichmentType = undefined>({ id, transform, toPreviewModule, toMappingModule, toEnrichmentSchema, toEnrichmentRequest, toEnrichmentDefaults }: ToModelEntryArgs<EnrichmentType>) => {
     id: string;
     type: "model";
-    transform: ({ context, refName, acc }: TransformModelArgs<Acc>) => Acc;
-    toPreviewModule?: ({ context, refName }: ToModelPreviewModuleArgs) => PreviewModule;
-    toMappingModule?: ({ context, refName }: ToModelMappingArgs) => MappingModule;
-    toEnrichmentSchema?: () => v.GenericSchema<EnrichmentType>;
+    transform: ({ context, refName, variant }: TransformModelArgs) => void;
+    toPreviewModule?: ({ context, refName, variant }: ToModelPreviewModuleArgs) => PreviewModule;
+    toMappingModule?: ({ context, refName, variant }: ToModelMappingArgs) => MappingModule;
+    toEnrichmentSchema: () => v.GenericSchema<EnrichmentType>;
     toEnrichmentRequest?: <RequestedEnrichment extends EnrichmentType>(refName: RefName) => EnrichmentRequest<RequestedEnrichment> | undefined;
+    toEnrichmentDefaults?: ({ refName, context, variant }: ToModelEnrichmentsArgs) => EnrichmentType | undefined;
 };
 export {};
 //# sourceMappingURL=toModelEntry.d.ts.map

package/esm/dsl/model/toModelEntry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toModelEntry.d.ts","sourceRoot":"","sources":["../../../src/dsl/model/toModelEntry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAA;AACzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAClG,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AACjC,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAE1E,KAAK,gBAAgB,CAAC,cAAc,GAAG,SAAS,EAAE,GAAG,GAAG,IAAI,IAAI;IAC9D,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,kBAAkB,CAAC,GAAG,CAAC,KAAK,GAAG,CAAA;IACtE,kBAAkB,CAAC,EAAE,MAAM,CAAC,CAAC,aAAa,CAAC,cAAc,CAAC,CAAA;IAC1D,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,wBAAwB,KAAK,aAAa,CAAA;IACnF,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,kBAAkB,KAAK,aAAa,CAAA;IAC7E,mBAAmB,CAAC,EAAE,CAAC,mBAAmB,SAAS,cAAc,EAC/D,OAAO,EAAE,OAAO,KACb,iBAAiB,CAAC,mBAAmB,CAAC,GAAG,SAAS,CAAA;CACxD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,eAAO,MAAM,YAAY,GAAI,cAAc,GAAG,SAAS,EAAE,GAAG,GAAG,IAAI,EAAE,8FAOlE,gBAAgB,CAAC,cAAc,EAAE,GAAG,CAAC,KAAG;IACzC,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,OAAO,CAAA;IACb,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,EAAE,kBAAkB,CAAC,GAAG,CAAC,KAAK,GAAG,CAAA;IACtE,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,wBAAwB,KAAK,aAAa,CAAA;IACnF,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,kBAAkB,KAAK,aAAa,CAAA;IAC7E,kBAAkB,CAAC,EAAE,MAAM,CAAC,CAAC,aAAa,CAAC,cAAc,CAAC,CAAA;IAC1D,mBAAmB,CAAC,EAAE,CAAC,mBAAmB,SAAS,cAAc,EAC/D,OAAO,EAAE,OAAO,KACb,iBAAiB,CAAC,mBAAmB,CAAC,GAAG,SAAS,CAAA;CAWxD,CAAA"}
+{"version":3,"file":"toModelEntry.d.ts","sourceRoot":"","sources":["../../../src/dsl/model/toModelEntry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAA;AACzE,OAAO,KAAK,EACV,kBAAkB,EAClB,wBAAwB,EACxB,kBAAkB,EAClB,sBAAsB,EACvB,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AACjC,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAE1E,KAAK,gBAAgB,CAAC,cAAc,GAAG,SAAS,IAAI;IAClD,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,kBAAkB,KAAK,IAAI,CAAA;IACtE,kBAAkB,EAAE,MAAM,CAAC,CAAC,aAAa,CAAC,cAAc,CAAC,CAAA;IACzD,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,wBAAwB,KAAK,aAAa,CAAA;IAC5F,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,kBAAkB,KAAK,aAAa,CAAA;IACtF,mBAAmB,CAAC,EAAE,CAAC,mBAAmB,SAAS,cAAc,EAC/D,OAAO,EAAE,OAAO,KACb,iBAAiB,CAAC,mBAAmB,CAAC,GAAG,SAAS,CAAA;IACvD,oBAAoB,CAAC,EAAE,CAAC,EACtB,OAAO,EACP,OAAO,EACP,OAAO,EACR,EAAE,sBAAsB,KAAK,cAAc,GAAG,SAAS,CAAA;CACzD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,eAAO,MAAM,YAAY,GAAI,cAAc,GAAG,SAAS,EAAE,oHAQtD,gBAAgB,CAAC,cAAc,CAAC,KAAG;IACpC,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,OAAO,CAAA;IACb,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,kBAAkB,KAAK,IAAI,CAAA;IACtE,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,wBAAwB,KAAK,aAAa,CAAA;IAC5F,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,kBAAkB,KAAK,aAAa,CAAA;IACtF,kBAAkB,EAAE,MAAM,CAAC,CAAC,aAAa,CAAC,cAAc,CAAC,CAAA;IACzD,mBAAmB,CAAC,EAAE,CAAC,mBAAmB,SAAS,cAAc,EAC/D,OAAO,EAAE,OAAO,KACb,iBAAiB,CAAC,mBAAmB,CAAC,GAAG,SAAS,CAAA;IACvD,oBAAoB,CAAC,EAAE,CAAC,EACtB,OAAO,EACP,OAAO,EACP,OAAO,EACR,EAAE,sBAAsB,KAAK,cAAc,GAAG,SAAS,CAAA;CAYzD,CAAA"}

package/esm/dsl/model/toModelEntry.js

@@ -9,7 +9,6 @@
  * mapping generation, enrichment handling, and schema validation.
  *
  * @template EnrichmentType - Type of enrichments that can be applied to models
- * @template Acc - Accumulator type for the transformation process
  * @param args - Configuration for the model entry
  * @param args.id - Unique identifier for this model entry
  * @param args.transform - Function to transform schemas into artifacts
@@ -25,10 +24,8 @@
  *
  * const typeScriptModelEntry = toModelEntry({
  *   id: 'typescript-models',
- *   transform: ({ context, refName, acc }) => {
- *     const schema = context.getSchemaByRefName(refName);
- *     const tsInterface = generateTypeScriptInterface(schema);
- *     return { ...acc, [refName]: tsInterface };
+ *   transform: ({ context, refName }) => {
+ *     context.insertModel(TsModel, refName);
  *   },
  *   toPreviewModule: ({ context, refName }) => ({
  *     group: 'forms',
@@ -42,13 +39,8 @@
  * ```typescript
  * const validationModelEntry = toModelEntry({
  *   id: 'validation-schemas',
- *   transform: ({ context, refName, acc }) => {
- *     const enrichments = context.getEnrichments(refName);
- *     const schema = context.getSchemaByRefName(refName);
- *     const validationSchema = generateValidationSchema(schema, {
- *       strict: enrichments?.strict ?? false
- *     });
- *     return { ...acc, [refName]: validationSchema };
+ *   transform: ({ context, refName }) => {
+ *     context.insertModel(ValidationModel, refName);
  *   },
  *   toEnrichmentSchema: () => v.object({
  *     strict: v.optional(v.boolean()),
@@ -61,7 +53,7 @@
  * });
  * ```
  */
-export const toModelEntry = ({ id, transform, toPreviewModule, toMappingModule, toEnrichmentSchema, toEnrichmentRequest }) => {
+export const toModelEntry = ({ id, transform, toPreviewModule, toMappingModule, toEnrichmentSchema, toEnrichmentRequest, toEnrichmentDefaults }) => {
     return {
         id,
         type: 'model',
@@ -69,6 +61,7 @@ export const toModelEntry = ({ id, transform, toPreviewModule, toMappingModule,
         toPreviewModule,
         toMappingModule,
         toEnrichmentSchema,
-        toEnrichmentRequest
+        toEnrichmentRequest,
+        toEnrichmentDefaults
     };
 };