@skmtc/core 0.18.1 → 0.27.0

package/esm/dsl/GeneratorKeys.js

@@ -65,6 +65,7 @@
  */
 import "../_dnt.polyfills.js";
 import { isMethod } from '../types/Method.js';
+import { DEFAULT_VARIANT } from '../types/Variant.js';
 const GQL_ROOT_KINDS = ['query', 'mutation', 'subscription'];
 const isGqlRootKind = (value) => GQL_ROOT_KINDS.includes(value);
 /**
@@ -102,7 +103,7 @@ const isGqlRootKind = (value) => GQL_ROOT_KINDS.includes(value);
  * // Result: 'rest-client|/posts|post' (branded)
  * ```
  */
-export const toOasOperationGeneratorKey = ({ generatorId, variant, ...rest }) => {
+export const toOasOperationGeneratorKey = ({ generatorId, variant = DEFAULT_VARIANT, ...rest }) => {
     const { path, method } = 'operation' in rest ? rest.operation : rest;
     const nakedKey = `${generatorId}|${path}|${method}|${variant}`;
     return nakedKey;
@@ -114,7 +115,7 @@ export const toOasOperationGeneratorKey = ({ generatorId, variant, ...rest }) =>
  * Format: `generatorId|webhook|name|method|variant`. The literal `webhook`
  * segment keeps webhook keys from colliding with operation keys.
  */
-export const toWebhookGeneratorKey = ({ generatorId, variant, ...rest }) => {
+export const toWebhookGeneratorKey = ({ generatorId, variant = DEFAULT_VARIANT, ...rest }) => {
     const { name, method } = 'webhook' in rest ? rest.webhook : rest;
     const nakedKey = `${generatorId}|webhook|${name}|${method}|${variant}`;
     return nakedKey;
@@ -125,7 +126,7 @@ export const toWebhookGeneratorKey = ({ generatorId, variant, ...rest }) => {
  * Sibling to {@link toOasOperationGeneratorKey} for the GraphQL protocol. Format:
  * `generatorId|rootKind|fieldName|variant`.
  */
-export const toGqlOperationGeneratorKey = ({ generatorId, variant, ...rest }) => {
+export const toGqlOperationGeneratorKey = ({ generatorId, variant = DEFAULT_VARIANT, ...rest }) => {
     const { rootKind, fieldName } = 'operation' in rest
         ? { rootKind: rest.operation.rootKind, fieldName: rest.operation.fieldName }
         : rest;
@@ -160,7 +161,7 @@ export const toGqlOperationGeneratorKey = ({ generatorId, variant, ...rest }) =>
  * // Result: 'zod-schemas|CreateUserRequest|coercive' (branded)
  * ```
  */
-export const toModelGeneratorKey = ({ generatorId, refName, variant }) => {
+export const toModelGeneratorKey = ({ generatorId, refName, variant = DEFAULT_VARIANT }) => {
     const nakedKey = `${generatorId}|${refName}|${variant}`;
     return nakedKey;
 };
@@ -305,7 +306,7 @@ export const isWebhookGeneratorKey = (arg) => {
  *
  * Validates that the argument is a string with the format
  * `generatorId|rootKind|fieldName`, with `rootKind` constrained to a
- * GraphQL root operation kind (`query` / `mutation` / `subscription`).
+ * GraphQL root operation type (`query` / `mutation` / `subscription`).
  */
 export const isGqlOperationGeneratorKey = (arg) => {
     if (typeof arg !== 'string') {

package/esm/dsl/IdentifierBase.d.ts

@@ -17,19 +17,19 @@ export type IdentifierBaseArgs = {
  * `(name, exportPath)` cross-generator cache key, and `DefinitionBase`. The
  * engine reads ONLY `.name` (the cache-key source); `typeName` and
  * `exported` are language-neutral facts it threads but never interprets.
- * Crucially it carries NO `kind` — the per-language declaration vocabulary
+ * Crucially it carries NO `type` — the per-language declaration vocabulary
  * lives, typed, on the language subclasses.
  *
  * It completes the neutral `*Base` family
  * (`CodeFileBase` / `DefinitionBase` / `ImportBase`): the concrete,
- * kind-carrying subclasses (`TsIdentifier`, `KtIdentifier`) live in the
+ * type-carrying subclasses (`TsIdentifier`, `KtIdentifier`) live in the
  * `@skmtc/lang-*` packages and **extend** this base. Construction goes
  * through a language package's factories (`createVariable` / `createType`
  * for TypeScript; `createDataClass` / `createEnumClass` / … for Kotlin) or
  * the engine's assembly seam `lang.toIdentifier({ name, ...identifierType })`.
- * The engine holds the result as `IdentifierBase`; the language's `kind` is
- * read only by the language renderers, which narrow via an `instanceof`
- * guard (`isTsIdentifier` / `isKtIdentifier`).
+ * The engine holds the result as `IdentifierBase`; the language's `type` is
+ * read only by the language renderers, which narrow back to the concrete
+ * subclass via `instanceof` (e.g. `value instanceof TsIdentifier`).
  */
 export declare class IdentifierBase {
     /** The identifier name — the only field the engine reads. */
@@ -51,5 +51,19 @@ export declare class IdentifierBase {
      * identifier is interpolated into generated code.
      */
     toString(): string;
+    /**
+     * The key under which a file stores and dedups this identifier's
+     * definition: two definitions whose identifiers share a `declarationKey`
+     * occupy the same declaration slot, so the later one collapses into the
+     * first (the cross-generator cache then resolves a name to its
+     * first-registered definition).
+     *
+     * The neutral default is the bare {@link name} — one definition per name,
+     * which is what most languages want. A language whose declaration space is
+     * richer overrides this: TypeScript folds in the declaration `type` so a
+     * `class Foo` and a `declare namespace Foo` — distinct declarations the
+     * compiler legitimately merges — get distinct keys instead of colliding.
+     */
+    declarationKey(): string;
 }
 //# sourceMappingURL=IdentifierBase.d.ts.map

package/esm/dsl/IdentifierBase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IdentifierBase.d.ts","sourceRoot":"","sources":["../../src/dsl/IdentifierBase.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,wEAAwE;IACxE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,cAAc;IACzB,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAA;IAEZ,yEAAyE;IACzE,QAAQ,CAAC,EAAE,MAAM,CAAA;IAEjB;;;;;;;OAOG;IACH,QAAQ,EAAE,OAAO,CAAA;gBAEL,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,kBAAkB;IAM5D;;;OAGG;IACH,QAAQ,IAAI,MAAM;CAGnB"}
+{"version":3,"file":"IdentifierBase.d.ts","sourceRoot":"","sources":["../../src/dsl/IdentifierBase.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,wEAAwE;IACxE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,cAAc;IACzB,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAA;IAEZ,yEAAyE;IACzE,QAAQ,CAAC,EAAE,MAAM,CAAA;IAEjB;;;;;;;OAOG;IACH,QAAQ,EAAE,OAAO,CAAA;gBAEL,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,kBAAkB;IAM5D;;;OAGG;IACH,QAAQ,IAAI,MAAM;IAIlB;;;;;;;;;;;;OAYG;IACH,cAAc,IAAI,MAAM;CAGzB"}

package/esm/dsl/IdentifierBase.js

@@ -6,19 +6,19 @@
  * `(name, exportPath)` cross-generator cache key, and `DefinitionBase`. The
  * engine reads ONLY `.name` (the cache-key source); `typeName` and
  * `exported` are language-neutral facts it threads but never interprets.
- * Crucially it carries NO `kind` — the per-language declaration vocabulary
+ * Crucially it carries NO `type` — the per-language declaration vocabulary
  * lives, typed, on the language subclasses.
  *
  * It completes the neutral `*Base` family
  * (`CodeFileBase` / `DefinitionBase` / `ImportBase`): the concrete,
- * kind-carrying subclasses (`TsIdentifier`, `KtIdentifier`) live in the
+ * type-carrying subclasses (`TsIdentifier`, `KtIdentifier`) live in the
  * `@skmtc/lang-*` packages and **extend** this base. Construction goes
  * through a language package's factories (`createVariable` / `createType`
  * for TypeScript; `createDataClass` / `createEnumClass` / … for Kotlin) or
  * the engine's assembly seam `lang.toIdentifier({ name, ...identifierType })`.
- * The engine holds the result as `IdentifierBase`; the language's `kind` is
- * read only by the language renderers, which narrow via an `instanceof`
- * guard (`isTsIdentifier` / `isKtIdentifier`).
+ * The engine holds the result as `IdentifierBase`; the language's `type` is
+ * read only by the language renderers, which narrow back to the concrete
+ * subclass via `instanceof` (e.g. `value instanceof TsIdentifier`).
  */
 export class IdentifierBase {
     constructor({ name, typeName, exported }) {
@@ -61,4 +61,20 @@ export class IdentifierBase {
     toString() {
         return this.name;
     }
+    /**
+     * The key under which a file stores and dedups this identifier's
+     * definition: two definitions whose identifiers share a `declarationKey`
+     * occupy the same declaration slot, so the later one collapses into the
+     * first (the cross-generator cache then resolves a name to its
+     * first-registered definition).
+     *
+     * The neutral default is the bare {@link name} — one definition per name,
+     * which is what most languages want. A language whose declaration space is
+     * richer overrides this: TypeScript folds in the declaration `type` so a
+     * `class Foo` and a `declare namespace Foo` — distinct declarations the
+     * compiler legitimately merges — get distinct keys instead of colliding.
+     */
+    declarationKey() {
+        return this.name;
+    }
 }

package/esm/dsl/IdentifierType.d.ts

@@ -1,28 +1,22 @@
-import type { Lang, LangKind } from './Lang.js';
 /**
  * The non-`name` parts of an identifier — everything a projection's
  * `toIdentifierType` derives from the schema (context-aware), bundled so
  * the engine can assemble the full identifier with
  * `lang.toIdentifier({ name, ...identifierType })`.
  *
- * Generic over the projection's {@link Lang}: the `kind` is drawn from that
- * language's declaration vocabulary, recovered via {@link LangKind} from the
- * typed `kind` on the {@link import('@/dsl/IdentifierBase.ts').IdentifierBase}
- * subclass the lang produces (`KtEntityKind` for `KtLang`, `TsEntityKind` for
- * the TypeScript `Lang`, …). A bare `Lang` falls back to the loose
- * `kind: string` — the opaque-kind boundary the engine never interprets.
- *
- * This is what lets a language's projection-base veneer parameterize core's
- * config (`ModelProjectionBaseConfig<E, KtLang>`) instead of recasting
- * `toIdentifierType`'s return: the tightening rides the `L` type argument.
+ * The `type` is the opaque-boundary `string` — the engine never interprets
+ * it. Each language's declaration-type vocabulary is a fixed fact of its lang
+ * package; a lang veneer tightens `toIdentifierType`'s return to its own
+ * `XxIdentifierType` (`type` narrowed to `XxEntityType`), which is assignable
+ * back to this shape. Core never models or recovers that vocabulary.
  *
  * Pairs with `toIdentifierName(args) -> string` (the pure, cache-key
  * source): the engine assembles
  * `lang.toIdentifier({ name: P.toIdentifierName(args), ...P.toIdentifierType(coordinate, context) })`.
  */
-export type IdentifierType<L extends Lang = Lang> = {
-    /** Per-language declaration kind — `LangKind<L>`, opaque to the engine. */
-    kind: LangKind<L>;
+export type IdentifierType = {
+    /** Per-language declaration type — the opaque-boundary `string`. */
+    type: string;
     /** Optional type annotation, opaque to the engine (lang-interpreted). */
     typeName?: string;
     /** Whether the identifier is exported. Defaults to `true`. */

package/esm/dsl/IdentifierType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IdentifierType.d.ts","sourceRoot":"","sources":["../../src/dsl/IdentifierType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAE/C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,IAAI;IAClD,2EAA2E;IAC3E,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAA;IACjB,yEAAyE;IACzE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA"}
+{"version":3,"file":"IdentifierType.d.ts","sourceRoot":"","sources":["../../src/dsl/IdentifierType.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAA;IACZ,yEAAyE;IACzE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA"}

package/esm/dsl/Lang.d.ts

@@ -10,13 +10,9 @@ import type { SnippetBase, SnippetBaseArgs } from './SnippetBase.js';
  * Arguments for {@link Lang.toDefinition} — everything the language needs
  * to wrap a generated `value` in its own `Definition` subclass.
  *
- * `identifier` stays the neutral {@link IdentifierBase}: the engine holds
- * identifiers as the base and passes that to the factory (which narrows via
- * its own `instanceof` guard). Keeping it neutral is also what lets a typed
- * `Lang` (e.g. `KtLang`) satisfy the bare `Lang` constraint — `identifier`
- * is a contravariant parameter, so a narrower type here would break the
- * subtype relation. The typed identifier surfaces only on `toIdentifier`'s
- * RETURN (a covariant position).
+ * `identifier` is the neutral {@link IdentifierBase}: the engine holds
+ * identifiers as the base and passes that to the factory, which narrows to
+ * its own concrete subclass via `instanceof`.
  */
 export type LangToDefinitionArgs<V extends GeneratedValue = GeneratedValue> = {
     context: GenerateContextType;
@@ -40,12 +36,12 @@ export type LangToImportArgs = {
  * seam. `name` comes from the projection's pure `toIdentifierName`; the
  * remaining fields come from the context-aware `toIdentifierType`
  * (spread in). The language builds its concrete `IdentifierBase` subclass
- * (`TsIdentifier` / `KtIdentifier`), reading the opaque `kind` into its
- * typed `EntityKind` slot.
+ * (`TsIdentifier` / `KtIdentifier`), reading the opaque `type` into its
+ * typed `EntityType` slot.
  */
 export type LangToIdentifierArgs = {
     name: string;
-    kind: string;
+    type: string;
     typeName?: string;
     exported?: boolean;
 };
@@ -72,7 +68,7 @@ export type LangToIdentifierArgs = {
  * vocabulary is intra-lang-package (each language's register function
  * converts its own form), so the neutral interface never names one.
  */
-export type Lang<IdentifierT extends IdentifierBase = IdentifierBase> = {
+export type Lang = {
     /** Construct the language's file for `path`. */
     createFile: (args: {
         path: string;
@@ -84,28 +80,14 @@ export type Lang<IdentifierT extends IdentifierBase = IdentifierBase> = {
     toImport: (args: LangToImportArgs) => ImportBase;
     /**
      * Assemble this language's `IdentifierBase` subclass from name +
-     * kind/type/exported. `kind` arrives as the opaque-boundary `string` (the
-     * engine never narrows it); the language reads it into its typed
-     * `EntityKind` slot. The returned `IdentifierT` is the language's concrete
-     * subclass — its typed `kind` is the ONLY place `IdentifierT` appears (a
-     * covariant return position), which is what lets {@link IdentifierType}
-     * recover the vocabulary to tighten the projection config while a typed
-     * `Lang` still satisfies the bare `Lang` constraint.
+     * type/typeName/exported. `type` arrives as the opaque-boundary `string` — the
+     * engine never narrows it; the language reads it into its own typed
+     * `EntityType` slot. The engine holds the result as the neutral
+     * `IdentifierBase`; the declaration-type vocabulary is a fixed fact of each
+     * language package, never modelled or recovered here.
      */
-    toIdentifier: (args: LangToIdentifierArgs) => IdentifierT;
+    toIdentifier: (args: LangToIdentifierArgs) => IdentifierBase;
 };
-/**
- * The language's declaration-kind vocabulary, recovered from the typed
- * `kind` on the {@link IdentifierBase} subclass a `Lang` produces.
- *
- * `KtIdentifier` carries `kind: KtEntityKind`, `TsIdentifier` carries
- * `kind: TsEntityKind`, … The neutral `IdentifierBase` has no `kind`, so a
- * bare `Lang` falls back to the loose `string` — the opaque-kind boundary
- * the engine speaks.
- */
-export type LangKind<L extends Lang> = ReturnType<L['toIdentifier']> extends {
-    kind: infer Kind extends string;
-} ? Kind : string;
 /**
  * The constructor contract a language's snippet base class must satisfy to
  * be used as the `base` of a projection-base factory
@@ -124,13 +106,11 @@ export type LangKind<L extends Lang> = ReturnType<L['toIdentifier']> extends {
  * generic over the base's *instance* type cannot type-safely extend it
  * (TS2415/TS2545 — see the scratch in `notes/lang/14`), and the price would
  * be that language-specific instance members are type-erased on projection
- * classes. Only the STATIC `lang` is parameterized — over the neutral `Lang`
- * by default, narrowed to a language's typed `Lang` (e.g. `KtLang`) when a
- * veneer threads `L` through. Narrowing a covariant static intersection does
- * not reawaken TS2415; the `extends config.base` in the factories stays well
- * typed because the instance side is unchanged.
+ * classes. The static `lang` is the neutral {@link Lang} — the engine reads
+ * it language-blind; each lang package's concrete declaration-type vocabulary
+ * is a fixed fact of that package, never recovered through this type.
  */
-export type LangSnippetConstructor<L extends Lang = Lang> = (new (args: SnippetBaseArgs) => SnippetBase) & {
-    lang: L;
+export type LangSnippetConstructor = (new (args: SnippetBaseArgs) => SnippetBase) & {
+    lang: Lang;
 };
 //# sourceMappingURL=Lang.d.ts.map

package/esm/dsl/Lang.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Lang.d.ts","sourceRoot":"","sources":["../../src/dsl/Lang.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AACrD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAA;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAEpE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,IAAI;IAC5E,OAAO,EAAE,mBAAmB,CAAA;IAC5B,UAAU,EAAE,cAAc,CAAA;IAC1B,KAAK,EAAE,CAAC,CAAA;IACR,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,EAAE,cAAc,CAAA;IAC1B,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,IAAI,CAAC,WAAW,SAAS,cAAc,GAAG,cAAc,IAAI;IACtE,gDAAgD;IAChD,UAAU,EAAE,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,cAAc,GAAG,SAAS,CAAA;KAAE,KAAK,QAAQ,CAAA;IACtF,yEAAyE;IACzE,YAAY,EAAE,CAAC,CAAC,SAAS,cAAc,EAAE,IAAI,EAAE,oBAAoB,CAAC,CAAC,CAAC,KAAK,cAAc,CAAC,CAAC,CAAC,CAAA;IAC5F,mEAAmE;IACnE,QAAQ,EAAE,CAAC,IAAI,EAAE,gBAAgB,KAAK,UAAU,CAAA;IAChD;;;;;;;;;OASG;IACH,YAAY,EAAE,CAAC,IAAI,EAAE,oBAAoB,KAAK,WAAW,CAAA;CAC1D,CAAA;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,IAAI,IAAI,UAAU,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,SAAS;IAC3E,IAAI,EAAE,MAAM,IAAI,SAAS,MAAM,CAAA;CAChC,GACG,IAAI,GACJ,MAAM,CAAA;AAEV;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,sBAAsB,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,IAAI,CAAC,KAC3D,IAAI,EAAE,eAAe,KAClB,WAAW,CAAC,GAAG;IAAE,IAAI,EAAE,CAAC,CAAA;CAAE,CAAA"}
+{"version":3,"file":"Lang.d.ts","sourceRoot":"","sources":["../../src/dsl/Lang.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AACrD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAA;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAEpE;;;;;;;GAOG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,IAAI;IAC5E,OAAO,EAAE,mBAAmB,CAAA;IAC5B,UAAU,EAAE,cAAc,CAAA;IAC1B,KAAK,EAAE,CAAC,CAAA;IACR,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,EAAE,cAAc,CAAA;IAC1B,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,IAAI,GAAG;IACjB,gDAAgD;IAChD,UAAU,EAAE,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,cAAc,GAAG,SAAS,CAAA;KAAE,KAAK,QAAQ,CAAA;IACtF,yEAAyE;IACzE,YAAY,EAAE,CAAC,CAAC,SAAS,cAAc,EAAE,IAAI,EAAE,oBAAoB,CAAC,CAAC,CAAC,KAAK,cAAc,CAAC,CAAC,CAAC,CAAA;IAC5F,mEAAmE;IACnE,QAAQ,EAAE,CAAC,IAAI,EAAE,gBAAgB,KAAK,UAAU,CAAA;IAChD;;;;;;;OAOG;IACH,YAAY,EAAE,CAAC,IAAI,EAAE,oBAAoB,KAAK,cAAc,CAAA;CAC7D,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,KAAK,IAAI,EAAE,eAAe,KAAK,WAAW,CAAC,GAAG;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,CAAA"}

package/esm/dsl/MarkdownFile.d.ts

@@ -0,0 +1,55 @@
+import { FileBase } from './FileBase.js';
+import type { Stringable } from './Stringable.js';
+/**
+ * Constructor arguments for {@link MarkdownFile}.
+ */
+type MarkdownFileArgs = {
+    /** The file path for the generated Markdown file */
+    path: string;
+    /** The Markdown content to write to the file */
+    content: Stringable;
+};
+/**
+ * Represents a Markdown file in the SKMTC DSL system.
+ *
+ * The Markdown counterpart of {@link import('@/dsl/JsonFile.ts').JsonFile}: a
+ * degenerate, non-code file that extends {@link FileBase} directly — it holds
+ * no definitions, imports or re-exports, because Markdown has no grammar to
+ * coordinate. Its `content` is any {@link Stringable} (a string or a composed
+ * snippet tree) and `toString()` renders it verbatim. Written through
+ * `GenerateContext.registerMarkdown`.
+ *
+ * @example
+ * ```typescript
+ * import { MarkdownFile } from '@skmtc/core';
+ *
+ * const doc = new MarkdownFile({
+ *   path: '@/docs/GetPet.generated.md',
+ *   content: '# Get pet'
+ * });
+ *
+ * console.log(doc.toString()); // '# Get pet'
+ * ```
+ */
+export declare class MarkdownFile extends FileBase {
+    /** The file type, always 'markdown' for Markdown files */
+    fileType: 'markdown';
+    /** The Markdown content to write to the file */
+    content: Stringable;
+    /**
+     * Creates a new MarkdownFile instance.
+     *
+     * @param args - Markdown file configuration
+     * @param args.path - The output path for this Markdown file
+     * @param args.content - The Markdown content to write
+     */
+    constructor({ path, content }: MarkdownFileArgs);
+    /**
+     * Renders the Markdown content to a string.
+     *
+     * @returns The Markdown content as a string
+     */
+    toString(): string;
+}
+export {};
+//# sourceMappingURL=MarkdownFile.d.ts.map

package/esm/dsl/MarkdownFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownFile.d.ts","sourceRoot":"","sources":["../../src/dsl/MarkdownFile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD;;GAEG;AACH,KAAK,gBAAgB,GAAG;IACtB,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAA;IACZ,gDAAgD;IAChD,OAAO,EAAE,UAAU,CAAA;CACpB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,YAAa,SAAQ,QAAQ;IACxC,0DAA0D;IAC1D,QAAQ,EAAE,UAAU,CAAa;IAEjC,gDAAgD;IAChD,OAAO,EAAE,UAAU,CAAA;IAEnB;;;;;;OAMG;gBACS,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,gBAAgB;IAK/C;;;;OAIG;IACM,QAAQ,IAAI,MAAM;CAG5B"}

package/esm/dsl/MarkdownFile.js

@@ -0,0 +1,58 @@
+import { FileBase } from './FileBase.js';
+/**
+ * Represents a Markdown file in the SKMTC DSL system.
+ *
+ * The Markdown counterpart of {@link import('@/dsl/JsonFile.ts').JsonFile}: a
+ * degenerate, non-code file that extends {@link FileBase} directly — it holds
+ * no definitions, imports or re-exports, because Markdown has no grammar to
+ * coordinate. Its `content` is any {@link Stringable} (a string or a composed
+ * snippet tree) and `toString()` renders it verbatim. Written through
+ * `GenerateContext.registerMarkdown`.
+ *
+ * @example
+ * ```typescript
+ * import { MarkdownFile } from '@skmtc/core';
+ *
+ * const doc = new MarkdownFile({
+ *   path: '@/docs/GetPet.generated.md',
+ *   content: '# Get pet'
+ * });
+ *
+ * console.log(doc.toString()); // '# Get pet'
+ * ```
+ */
+export class MarkdownFile extends FileBase {
+    /**
+     * Creates a new MarkdownFile instance.
+     *
+     * @param args - Markdown file configuration
+     * @param args.path - The output path for this Markdown file
+     * @param args.content - The Markdown content to write
+     */
+    constructor({ path, content }) {
+        super({ path });
+        /** The file type, always 'markdown' for Markdown files */
+        Object.defineProperty(this, "fileType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'markdown'
+        });
+        /** The Markdown content to write to the file */
+        Object.defineProperty(this, "content", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.content = content;
+    }
+    /**
+     * Renders the Markdown content to a string.
+     *
+     * @returns The Markdown content as a string
+     */
+    toString() {
+        return this.content.toString();
+    }
+}

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

@@ -16,8 +16,10 @@ type CreateModelArgs<V extends GeneratedValue, EnrichmentType> = {
      * 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`.
+     * Optional — omitting it means `'main'`, so variants-unaware
+     * callers keep working unchanged.
      */
-    variant: string;
+    variant?: string;
 };
 /**
  * Driver for the model insertion lifecycle.

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;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;IA0BrC,OAAO,CAAC,KAAK;IAoBb;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IAYlB,OAAO,CAAC,aAAa;IAkCrB,OAAO,CAAC,gBAAgB;CAsBzB"}
+{"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;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,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,OAAyB,EAC1B,EAAE,eAAe,CAAC,CAAC,EAAE,cAAc,CAAC;IA0BrC,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,4 +1,4 @@
-import { normalize } from '../../deps/jsr.io/@std/path/1.1.4/normalize.js';
+import { normalize } from '../../deps/jsr.io/@std/path/1.1.6/normalize.js';
 import { toModelGeneratorKey } from '../GeneratorKeys.js';
 import { DEFAULT_VARIANT } from '../../types/Variant.js';
 import get from 'lodash-es/get.js';
@@ -12,7 +12,7 @@ import get from 'lodash-es/get.js';
  * from the projection's `exportPath`.
  */
 export class ModelDriver {
-    constructor({ context, projection, refName, destinationPath, rootRef, noExport, variant }) {
+    constructor({ context, projection, refName, destinationPath, rootRef, noExport, variant = DEFAULT_VARIANT }) {
         Object.defineProperty(this, "context", {
             enumerable: true,
             configurable: true,
@@ -81,7 +81,7 @@ export class ModelDriver {
             refName,
             variant
         });
-        assertPeerSupported({ context, projection, refName });
+        assertPeerSupported({ context, projection, refName, variant });
         this.settings = this.context.toModelContentSettings({ refName, projection, variant });
         this.definition = this.apply({ destinationPath });
         this.context.modelDepth[`${projection.id}:${refName}`] = 0;
@@ -210,11 +210,9 @@ const assertPeerVariantExists = ({ context, generatorId, refName, variant }) =>
  * model: `toModelProjectionBase` defaults it to `() => true`, and a
  * hand-rolled projection may omit it.
  */
-const assertPeerSupported = ({ context, projection, refName }) => {
-    if (typeof projection.isSupported !== 'function') {
-        return;
-    }
-    if (!projection.isSupported({ refName, context })) {
+const assertPeerSupported = ({ context, projection, refName, variant }) => {
+    const isSupported = projection.isSupported ?? (() => true);
+    if (!isSupported({ refName, context, variant })) {
         throw new Error(`[${projection.id}] Cannot insert '${refName}' — peer generator ` +
             `does not support this model (isSupported returned false).`);
     }

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

@@ -1,15 +1,30 @@
 import type { RefName } from '../../types/RefName.js';
 import type { EnrichmentRequest } from '../../types/EnrichmentRequest.js';
-import type { TransformModelArgs, ToModelPreviewModuleArgs, ToModelMappingArgs, ToModelEnrichmentsArgs, IsSupportedModelArgs, IsSupportedModelConfigArgs } from './types.js';
-import * as v from 'valibot';
-import type { MappingModule, PreviewModule } from '../../types/Preview.js';
+import type { TransformModelArgs, ToModelPreviewModuleArgs, ToModelEnrichmentsArgs, IsSupportedModelArgs } from './types.js';
+import type { PreviewModule } from '../../types/Preview.js';
+import type * as v from 'valibot';
 type ToModelEntryArgs<EnrichmentType = undefined> = {
     id: string;
     transform: ({ context, refName, variant }: TransformModelArgs) => void;
     toEnrichmentSchema: () => v.GenericSchema<EnrichmentType>;
-    isSupported?: ({ context, refName }: IsSupportedModelConfigArgs<EnrichmentType>) => boolean;
+    isSupported?: (args: IsSupportedModelArgs) => boolean;
+    /**
+     * Optional: whether this generator entry supports variants. Defaults to a
+     * function returning `false` when omitted.
+     */
+    supportsVariant?: () => boolean;
     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;
+};
+export type ModelEntry<EnrichmentType = undefined> = {
+    id: string;
+    type: 'model';
+    transform: ({ context, refName, variant }: TransformModelArgs) => void;
+    isSupported: (args: IsSupportedModelArgs) => boolean;
+    supportsVariant: () => boolean;
+    toPreviewModule?: ({ context, refName, variant }: ToModelPreviewModuleArgs) => PreviewModule;
+    toEnrichmentSchema: () => v.GenericSchema<EnrichmentType>;
     toEnrichmentRequest?: <RequestedEnrichment extends EnrichmentType>(refName: RefName) => EnrichmentRequest<RequestedEnrichment> | undefined;
     toEnrichmentDefaults?: ({ refName, context, variant }: ToModelEnrichmentsArgs) => EnrichmentType | undefined;
 };
@@ -32,7 +47,6 @@ type ToModelEntryArgs<EnrichmentType = undefined> = {
  *   Resolve the schema inside the predicate when needed
  *   (`context.resolveSchemaRefOnce(refName, id)`). Defaults to supporting every model.
  * @param args.toPreviewModule - Optional function to generate preview modules
- * @param args.toMappingModule - Optional function to generate mapping modules
  * @param args.toEnrichmentSchema - Optional function to provide enrichment validation
  * @param args.toEnrichmentRequest - Optional function to request enrichments
  * @returns Model entry object for use in the generation pipeline
@@ -72,16 +86,6 @@ type ToModelEntryArgs<EnrichmentType = undefined> = {
  * });
  * ```
  */
-export declare const toModelEntry: <EnrichmentType = undefined>({ id, transform, isSupported, toPreviewModule, toMappingModule, toEnrichmentSchema, toEnrichmentRequest, toEnrichmentDefaults }: ToModelEntryArgs<EnrichmentType>) => {
-    id: string;
-    type: "model";
-    transform: ({ context, refName, variant }: TransformModelArgs) => void;
-    isSupported: ({ context, refName }: IsSupportedModelArgs) => boolean;
-    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 declare const toModelEntry: <EnrichmentType = undefined>({ id, transform, isSupported, supportsVariant, toPreviewModule, toEnrichmentSchema, toEnrichmentRequest, toEnrichmentDefaults }: ToModelEntryArgs<EnrichmentType>) => ModelEntry<EnrichmentType>;
 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,EACV,kBAAkB,EAClB,wBAAwB,EACxB,kBAAkB,EAClB,sBAAsB,EACtB,oBAAoB,EACpB,0BAA0B,EAC3B,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAK1E,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,WAAW,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,0BAA0B,CAAC,cAAc,CAAC,KAAK,OAAO,CAAA;IAC3F,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,eAAO,MAAM,YAAY,GAAI,cAAc,GAAG,SAAS,EAAE,iIAStD,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,WAAW,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,oBAAoB,KAAK,OAAO,CAAA;IACpE,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;CAmCzD,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,EAExB,sBAAsB,EACtB,oBAAoB,EACrB,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AAEjC,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,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,oBAAoB,KAAK,OAAO,CAAA;IACrD;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,OAAO,CAAA;IAC/B,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,wBAAwB,KAAK,aAAa,CAAA;IAC5F,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,MAAM,MAAM,UAAU,CAAC,cAAc,GAAG,SAAS,IAAI;IACnD,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,WAAW,EAAE,CAAC,IAAI,EAAE,oBAAoB,KAAK,OAAO,CAAA;IACpD,eAAe,EAAE,MAAM,OAAO,CAAA;IAC9B,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,wBAAwB,KAAK,aAAa,CAAA;IAC5F,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;CACzD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,eAAO,MAAM,YAAY,GAAI,cAAc,GAAG,SAAS,EAAE,iIAStD,gBAAgB,CAAC,cAAc,CAAC,KAAG,UAAU,CAAC,cAAc,CAY9D,CAAA"}

package/esm/dsl/model/toModelEntry.js

@@ -1,6 +1,3 @@
-import * as v from 'valibot';
-import { GENERATOR_ENRICHMENT_KEY, STACK_ENRICHMENT_KEY } from '../../types/Enrichments.js';
-import get from 'lodash-es/get.js';
 /**
  * Creates a model transformation entry for the SKMTC pipeline.
  *
@@ -20,7 +17,6 @@ import get from 'lodash-es/get.js';
  *   Resolve the schema inside the predicate when needed
  *   (`context.resolveSchemaRefOnce(refName, id)`). Defaults to supporting every model.
  * @param args.toPreviewModule - Optional function to generate preview modules
- * @param args.toMappingModule - Optional function to generate mapping modules
  * @param args.toEnrichmentSchema - Optional function to provide enrichment validation
  * @param args.toEnrichmentRequest - Optional function to request enrichments
  * @returns Model entry object for use in the generation pipeline
@@ -60,34 +56,14 @@ import get from 'lodash-es/get.js';
  * });
  * ```
  */
-export const toModelEntry = ({ id, transform, isSupported, toPreviewModule, toMappingModule, toEnrichmentSchema, toEnrichmentRequest, toEnrichmentDefaults }) => {
+export const toModelEntry = ({ id, transform, isSupported, supportsVariant, toPreviewModule, toEnrichmentSchema, toEnrichmentRequest, toEnrichmentDefaults }) => {
     return {
         id,
         type: 'model',
         transform,
-        isSupported: ({ context, refName, variant }) => {
-            if (!isSupported) {
-                return true;
-            }
-            // Assemble the three-scope umbrella — mirrors
-            // `ModelProjectionBase.toEnrichments` so the shim and the
-            // projection-base resolve to the same value. Subject is per-item
-            // (`[id][refName][variant]`); generator and stack are run-constants.
-            // The required composite schema parses cast-free.
-            const raw = {
-                subject: get(context.settings, ['enrichments', id, refName, variant]),
-                generator: get(context.settings, ['enrichments', id, GENERATOR_ENRICHMENT_KEY]),
-                stack: get(context.settings, ['enrichments', STACK_ENRICHMENT_KEY])
-            };
-            return isSupported({
-                context,
-                refName,
-                enrichments: v.parse(toEnrichmentSchema(), raw),
-                variant
-            });
-        },
+        isSupported: isSupported ?? (() => true),
+        supportsVariant: supportsVariant ?? (() => false),
         toPreviewModule,
-        toMappingModule,
         toEnrichmentSchema,
         toEnrichmentRequest,
         toEnrichmentDefaults