@skmtc/core 0.0.984 → 0.16.2

package/esm/dsl/ImportBase.js

@@ -0,0 +1,24 @@
+/**
+ * The language-neutral contract for a registered import.
+ *
+ * A `@skmtc/lang-*` package provides a concrete subclass (`TsImport`,
+ * `GoImport`, …) that owns the language's import shape and rendering. The
+ * engine and {@link import('@/dsl/CodeFileBase.ts').CodeFileBase} only ever
+ * see this neutral surface:
+ *
+ * - `mergeKey()` — identity for dedup AND the handle a `File` uses to
+ *   arrange its import section (typically the module / package path). Two
+ *   imports with the same key collapse via {@link merge}.
+ * - `merge(other)` — combine a same-key import into this one (e.g. union
+ *   their symbols). The subclass narrows `other` to its own type.
+ * - `toString()` — render the standalone import. A language `File` MAY
+ *   re-arrange instead (e.g. Go groups every package into one
+ *   `import ( … )` block keyed by `mergeKey()`), so `toString()` is the
+ *   per-import render, not the whole section.
+ *
+ * The split is deliberate: the *merge* of imports is language-neutral (it
+ * lives on `CodeFileBase`); the *arrangement* of the import section is
+ * language-specific (it lives in the concrete `File.toString()`).
+ */
+export class ImportBase {
+}

package/esm/dsl/Inserted.d.ts

@@ -1,6 +1,6 @@
 import type { GeneratedDefinition, GeneratedValue } from './GeneratedValue.js';
 import type { ContentSettings } from './ContentSettings.js';
-import type { Identifier } from './Identifier.js';
+import type { IdentifierBase } from './IdentifierBase.js';
 /**
  * Constructor arguments for {@link Inserted}.
  *
@@ -39,7 +39,7 @@ type ConstructorArgs<V extends GeneratedValue, EnrichmentType> = {
  * ```typescript
  * import { Inserted } from '@skmtc/core';
  *
- * class MyGenerator extends ModelBase {
+ * class MyGenerator extends ModelProjectionBase {
  *   generate(): Definition {
  *     // Insert a related model with forced generation
  *     const userModel = this.insertModel(
@@ -53,7 +53,7 @@ type ConstructorArgs<V extends GeneratedValue, EnrichmentType> = {
  *     const identifier = userModel.toName(); // 'User'
  *
  *     return new Definition({
- *       identifier: Identifier.createType(this.refName),
+ *       identifier: createType(this.refName),
  *       value: {
  *         generatorKey: this.generatorKey,
  *         content: `export interface Order { user: ${userTypeName}; }`
@@ -97,11 +97,11 @@ export declare class Inserted<V extends GeneratedValue, EnrichmentType> {
     /**
      * Gets the full identifier of the inserted artifact.
      *
-     * This method returns the complete Identifier object, which includes both
-     * the name and type information. Useful when you need access to entity type
-     * or type annotations.
+     * This method returns the complete `IdentifierBase` object, which carries
+     * the name and (language-neutrally) the type annotation. Useful when you
+     * need access to the type annotation or export flag.
      *
-     * @returns The complete Identifier object
+     * @returns The complete `IdentifierBase` object
      *
      * @example
      * ```typescript
@@ -109,11 +109,11 @@ export declare class Inserted<V extends GeneratedValue, EnrichmentType> {
      * const identifier = model.toIdentifier();
      *
      * console.log(identifier.name);        // 'User'
-     * console.log(identifier.entityType);  // EntityType instance
-     * console.log(identifier.typeName);    // Optional type annotation
+     * console.log(identifier.typeName);    // optional type annotation
+     * console.log(identifier.exported);    // export flag
      * ```
      */
-    toIdentifier(): Identifier;
+    toIdentifier(): IdentifierBase;
     /**
      * Gets the export path where the artifact was generated.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"Inserted.d.ts","sourceRoot":"","sources":["../../src/dsl/Inserted.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAC9E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD;;;;;GAKG;AACH,KAAK,eAAe,CAAC,CAAC,SAAS,cAAc,EAAE,cAAc,IAAI;IAC/D,4DAA4D;IAC5D,QAAQ,EAAE,eAAe,CAAC,cAAc,CAAC,CAAA;IACzC,8CAA8C;IAC9C,UAAU,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAA;CACnC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,cAAc,EAAE,cAAc;IAC5D,4DAA4D;IAC5D,QAAQ,EAAE,eAAe,CAAC,cAAc,CAAC,CAAA;IAEzC,8CAA8C;IAC9C,UAAU,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAA;IAElC;;;;;;OAMG;gBACS,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE,eAAe,CAAC,CAAC,EAAE,cAAc,CAAC;IAKxE;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,IAAI,MAAM;IAIhB;;;;;;;;;;;;;;;;;;OAkBG;IACH,YAAY,IAAI,UAAU;IAI1B;;;;;;;;;;;;;;;;;OAiBG;IACH,YAAY,IAAI,MAAM;IAItB;;;;;;;;;;;;;;;OAeG;IACH,OAAO,IAAI,CAAC;CAGb"}
+{"version":3,"file":"Inserted.d.ts","sourceRoot":"","sources":["../../src/dsl/Inserted.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAC9E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEzD;;;;;GAKG;AACH,KAAK,eAAe,CAAC,CAAC,SAAS,cAAc,EAAE,cAAc,IAAI;IAC/D,4DAA4D;IAC5D,QAAQ,EAAE,eAAe,CAAC,cAAc,CAAC,CAAA;IACzC,8CAA8C;IAC9C,UAAU,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAA;CACnC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,cAAc,EAAE,cAAc;IAC5D,4DAA4D;IAC5D,QAAQ,EAAE,eAAe,CAAC,cAAc,CAAC,CAAA;IAEzC,8CAA8C;IAC9C,UAAU,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAA;IAElC;;;;;;OAMG;gBACS,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE,eAAe,CAAC,CAAC,EAAE,cAAc,CAAC;IAKxE;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,IAAI,MAAM;IAIhB;;;;;;;;;;;;;;;;;;OAkBG;IACH,YAAY,IAAI,cAAc;IAI9B;;;;;;;;;;;;;;;;;OAiBG;IACH,YAAY,IAAI,MAAM;IAItB;;;;;;;;;;;;;;;OAeG;IACH,OAAO,IAAI,CAAC;CAGb"}

package/esm/dsl/Inserted.js

@@ -24,7 +24,7 @@
  * ```typescript
  * import { Inserted } from '@skmtc/core';
  *
- * class MyGenerator extends ModelBase {
+ * class MyGenerator extends ModelProjectionBase {
  *   generate(): Definition {
  *     // Insert a related model with forced generation
  *     const userModel = this.insertModel(
@@ -38,7 +38,7 @@
  *     const identifier = userModel.toName(); // 'User'
  *
  *     return new Definition({
- *       identifier: Identifier.createType(this.refName),
+ *       identifier: createType(this.refName),
  *       value: {
  *         generatorKey: this.generatorKey,
  *         content: `export interface Order { user: ${userTypeName}; }`
@@ -97,11 +97,11 @@ export class Inserted {
     /**
      * Gets the full identifier of the inserted artifact.
      *
-     * This method returns the complete Identifier object, which includes both
-     * the name and type information. Useful when you need access to entity type
-     * or type annotations.
+     * This method returns the complete `IdentifierBase` object, which carries
+     * the name and (language-neutrally) the type annotation. Useful when you
+     * need access to the type annotation or export flag.
      *
-     * @returns The complete Identifier object
+     * @returns The complete `IdentifierBase` object
      *
      * @example
      * ```typescript
@@ -109,8 +109,8 @@ export class Inserted {
      * const identifier = model.toIdentifier();
      *
      * console.log(identifier.name);        // 'User'
-     * console.log(identifier.entityType);  // EntityType instance
-     * console.log(identifier.typeName);    // Optional type annotation
+     * console.log(identifier.typeName);    // optional type annotation
+     * console.log(identifier.exported);    // export flag
      * ```
      */
     toIdentifier() {

package/esm/dsl/JsonFile.d.ts

@@ -1,3 +1,4 @@
+import { FileBase } from './FileBase.js';
 /**
  * Constructor arguments for {@link JsonFile}.
  */
@@ -39,11 +40,9 @@ type JsonFileArgs = {
  * });
  *
  */
-export declare class JsonFile {
+export declare class JsonFile extends FileBase {
     /** The file type, always 'json' for JSON files */
     fileType: 'json';
-    /** The file path for this generated JSON file */
-    path: string;
     /** The JSON content to write to the file */
     content: Record<string, unknown>;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"JsonFile.d.ts","sourceRoot":"","sources":["../../src/dsl/JsonFile.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,KAAK,YAAY,GAAG;IAClB,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAA;IACZ,4CAA4C;IAC5C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACjC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,QAAQ;IACnB,kDAAkD;IAClD,QAAQ,EAAE,MAAM,CAAS;IAEzB,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAA;IAEZ,4CAA4C;IAC5C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAEhC;;;;;;;;;;;;;;;;;;OAkBG;gBACS,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,YAAY;IAK3C;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,QAAQ,IAAI,MAAM;CAGnB"}
+{"version":3,"file":"JsonFile.d.ts","sourceRoot":"","sources":["../../src/dsl/JsonFile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAExC;;GAEG;AACH,KAAK,YAAY,GAAG;IAClB,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAA;IACZ,4CAA4C;IAC5C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACjC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,QAAS,SAAQ,QAAQ;IACpC,kDAAkD;IAClD,QAAQ,EAAE,MAAM,CAAS;IAEzB,4CAA4C;IAC5C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAEhC;;;;;;;;;;;;;;;;;;OAkBG;gBACS,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,YAAY;IAK3C;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACM,QAAQ,IAAI,MAAM;CAG5B"}

package/esm/dsl/JsonFile.js

@@ -1,3 +1,4 @@
+import { FileBase } from './FileBase.js';
 /**
  * Represents a JSON file in the SKMTC DSL system.
  *
@@ -30,7 +31,7 @@
  * });
  *
  */
-export class JsonFile {
+export class JsonFile extends FileBase {
     /**
      * Creates a new JsonFile instance.
      *
@@ -51,6 +52,7 @@ export class JsonFile {
      * ```
      */
     constructor({ path, content }) {
+        super({ path });
         /** The file type, always 'json' for JSON files */
         Object.defineProperty(this, "fileType", {
             enumerable: true,
@@ -58,13 +60,6 @@ export class JsonFile {
             writable: true,
             value: 'json'
         });
-        /** The file path for this generated JSON file */
-        Object.defineProperty(this, "path", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         /** The JSON content to write to the file */
         Object.defineProperty(this, "content", {
             enumerable: true,
@@ -72,7 +67,6 @@ export class JsonFile {
             writable: true,
             value: void 0
         });
-        this.path = path;
         this.content = content;
     }
     /**

package/esm/dsl/Lang.d.ts

@@ -0,0 +1,136 @@
+import type { DefinitionBase } from './Definition.js';
+import type { FileBase } from './FileBase.js';
+import type { ImportBase } from './ImportBase.js';
+import type { IdentifierBase } from './IdentifierBase.js';
+import type { GeneratedValue } from './GeneratedValue.js';
+import type { ClientSettings } from '../types/Settings.js';
+import type { GenerateContextType } from '../context/generateTypes.js';
+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).
+ */
+export type LangToDefinitionArgs<V extends GeneratedValue = GeneratedValue> = {
+    context: GenerateContextType;
+    identifier: IdentifierBase;
+    value: V;
+    noExport?: boolean;
+    description?: string;
+};
+/**
+ * Arguments for {@link Lang.toImport} — the import of one
+ * {@link IdentifierBase} from a module, the cross-file import a Driver
+ * registers when a generator references a peer's Definition. Neutral for the
+ * same contravariance reason as {@link LangToDefinitionArgs}.
+ */
+export type LangToImportArgs = {
+    identifier: IdentifierBase;
+    module: string;
+};
+/**
+ * Arguments for {@link Lang.toIdentifier} — the engine's identifier-assembly
+ * 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.
+ */
+export type LangToIdentifierArgs = {
+    name: string;
+    kind: string;
+    typeName?: string;
+    exported?: boolean;
+};
+/**
+ * The language-specific surface the engine reaches through.
+ *
+ * A `Lang` is the object a `@skmtc/lang-*` package exposes, carried as the
+ * static `lang` on the package's snippet base ({@link LangSnippetConstructor}).
+ * Its only consumers are the Drivers — peers the engine can't name
+ * concretely — which read it off the projection class (`projection.lang`)
+ * ephemerally at each use site. The engine never names a concrete `File` /
+ * `Definition` / `Import` — it only ever calls these neutral factories:
+ *
+ * - `createFile` — construct this language's file for a path.
+ * - `toDefinition` — wrap a generated value in this language's `Definition`.
+ * - `toImport` — build the import of a single peer `IdentifierBase` from a
+ *   module (the Driver's cross-file import).
+ * - `toIdentifier` — assemble this language's `IdentifierBase` subclass from
+ *   a `name` (the pure `toIdentifierName`) and the spread `IdentifierType`
+ *   (the context-aware `toIdentifierType`). The engine's identifier-assembly
+ *   seam — it holds the result as the neutral `IdentifierBase`.
+ *
+ * There is deliberately no concise-import conversion here: the concise
+ * 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> = {
+    /** Construct the language's file for `path`. */
+    createFile: (args: {
+        path: string;
+        settings: ClientSettings | undefined;
+    }) => FileBase;
+    /** Wrap a generated `value` in this language's `Definition` subclass. */
+    toDefinition: <V extends GeneratedValue>(args: LangToDefinitionArgs<V>) => DefinitionBase<V>;
+    /** Build the import of one peer `IdentifierBase` from a module. */
+    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.
+     */
+    toIdentifier: (args: LangToIdentifierArgs) => IdentifierT;
+};
+/**
+ * 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
+ * (`toModelProjectionBase(TsSnippet, …)`). It is where language
+ * enters the DSL class hierarchy; `SnippetBase` itself stays language-blind.
+ *
+ * `lang` is **static-only**: its reader is the Drivers, which need the
+ * peer's language *before* constructing the value (cache-hit path) and read
+ * it ephemerally at each use site (`projection.lang`). Statics inherit
+ * through class expressions, so every projection class built on the base
+ * exposes it with no re-declaration. There is no instance slot — the
+ * register paths delegate to the language package's register function,
+ * which names its own classes directly.
+ *
+ * The INSTANCE type stays the concrete {@link SnippetBase}: a core factory
+ * 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.
+ */
+export type LangSnippetConstructor<L extends Lang = Lang> = (new (args: SnippetBaseArgs) => SnippetBase) & {
+    lang: L;
+};
+//# sourceMappingURL=Lang.d.ts.map

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

@@ -0,0 +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"}

package/esm/dsl/Lang.js

@@ -0,0 +1 @@
+export {};

package/esm/dsl/ReExportBase.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The language-neutral contract for a registered re-export.
+ *
+ * A `@skmtc/lang-*` package whose language supports re-exports provides a
+ * concrete subclass (`TsReExport`, …) that owns the language's re-export
+ * shape and rendering; a language without them simply never constructs
+ * one (its concise register vocabulary has no `reExports` field, so the
+ * absence is compile-time). The engine and
+ * {@link import('@/dsl/CodeFileBase.ts').CodeFileBase} only ever see this
+ * neutral surface — the same split as
+ * {@link import('@/dsl/ImportBase.ts').ImportBase}:
+ *
+ * - `mergeKey()` — identity for dedup AND the handle a `File` uses to
+ *   arrange its re-export section (typically the source module path). Two
+ *   re-exports with the same key collapse via {@link merge}.
+ * - `merge(other)` — combine a same-key re-export into this one (e.g.
+ *   union their symbols). The subclass narrows `other` to its own type.
+ * - `toString()` — render the standalone re-export. A language `File` MAY
+ *   re-arrange instead, so `toString()` is the per-entry render, not the
+ *   whole section.
+ *
+ * The *merge* of re-exports is language-neutral (it lives on
+ * `CodeFileBase`); the *arrangement* of the re-export section is
+ * language-specific (it lives in the concrete `File.toString()`).
+ */
+export declare abstract class ReExportBase {
+    /**
+     * Identity for dedup and arrangement — typically the source module
+     * path. Re-exports sharing a `mergeKey()` are merged via {@link merge}.
+     */
+    abstract mergeKey(): string;
+    /**
+     * Combine another re-export that shares this `mergeKey()` into a single
+     * entry. The concrete subclass narrows `other` to its own type (and
+     * throws if handed a foreign re-export — which only happens if two
+     * languages wrote to one file, a misconfiguration).
+     */
+    abstract merge(other: ReExportBase): ReExportBase;
+    /** Render the standalone re-export. The `File` may re-arrange via `mergeKey`. */
+    abstract toString(): string;
+}
+//# sourceMappingURL=ReExportBase.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ReExportBase.d.ts","sourceRoot":"","sources":["../../src/dsl/ReExportBase.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,8BAAsB,YAAY;IAChC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,IAAI,MAAM;IAE3B;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY;IAEjD,iFAAiF;IACjF,QAAQ,CAAC,QAAQ,IAAI,MAAM;CAC5B"}

package/esm/dsl/ReExportBase.js

@@ -0,0 +1,27 @@
+/**
+ * The language-neutral contract for a registered re-export.
+ *
+ * A `@skmtc/lang-*` package whose language supports re-exports provides a
+ * concrete subclass (`TsReExport`, …) that owns the language's re-export
+ * shape and rendering; a language without them simply never constructs
+ * one (its concise register vocabulary has no `reExports` field, so the
+ * absence is compile-time). The engine and
+ * {@link import('@/dsl/CodeFileBase.ts').CodeFileBase} only ever see this
+ * neutral surface — the same split as
+ * {@link import('@/dsl/ImportBase.ts').ImportBase}:
+ *
+ * - `mergeKey()` — identity for dedup AND the handle a `File` uses to
+ *   arrange its re-export section (typically the source module path). Two
+ *   re-exports with the same key collapse via {@link merge}.
+ * - `merge(other)` — combine a same-key re-export into this one (e.g.
+ *   union their symbols). The subclass narrows `other` to its own type.
+ * - `toString()` — render the standalone re-export. A language `File` MAY
+ *   re-arrange instead, so `toString()` is the per-entry render, not the
+ *   whole section.
+ *
+ * The *merge* of re-exports is language-neutral (it lives on
+ * `CodeFileBase`); the *arrangement* of the re-export section is
+ * language-specific (it lives in the concrete `File.toString()`).
+ */
+export class ReExportBase {
+}

package/esm/dsl/SnippetBase.d.ts

@@ -0,0 +1,86 @@
+import type { GenerateContextType } from '../context/generateTypes.js';
+import type { GeneratorKey } from './GeneratorKeys.js';
+import { StackTrail } from '../context/StackTrail.js';
+/**
+ * Constructor arguments for {@link SnippetBase}.
+ *
+ * Exported so language packages can type their snippet base constructors
+ * against it (see `LangSnippetConstructor` in `dsl/Lang.ts`).
+ */
+export type SnippetBaseArgs = {
+    /** The generation context providing OAS objects and utilities */
+    context: GenerateContextType;
+    /** Optional generator key — attribution (gen-maps) input only */
+    generatorKey?: GeneratorKey;
+    /**
+     * Position of the originating schema fragment, when the snippet has a
+     * single originating node — attribution (gen-maps) input only. Callers
+     * that hold a schema pass `stackTrail: schema?.stackTrail.clone() ??
+     * StackTrail.empty()` — the clone stays at the call site, where the
+     * live, mutable trail is in hand. Omit for snippets with no single
+     * originating node (structural / boilerplate / accumulators) — they
+     * carry the empty trail and the resolver falls back to the key-derived
+     * pointer.
+     */
+    stackTrail?: StackTrail;
+};
+/**
+ * Abstract root of every stringifiable element in the SKMTC DSL.
+ *
+ * Two specializations live below this class:
+ *
+ * - **Projections** — named, exportable artifacts built by the
+ *   projection-base factories (`toModelProjectionBase` and the OAS/GQL
+ *   siblings) on a language package's snippet base; the pipeline wraps
+ *   them in a `Definition` and registers them in a file.
+ * - **Snippets** are anonymous, embedded values whose `toString()` is spliced
+ *   into the body of a Projection (or another Snippet). `Definition` and
+ *   `CustomValue` extend `SnippetBase` directly without going through a
+ *   Projection base.
+ *
+ * `SnippetBase` is **language-blind**: it has no `register`, no language,
+ * and nothing on it can throw for lack of identity. Register ergonomics
+ * live on each language package's snippet base (e.g. `TsSnippet`'s
+ * `register`, which delegates to that package's register function) — a raw
+ * `SnippetBase` subclass that tries to register is a compile-time error.
+ * `generatorKey` and `stackTrail` are *optional* attribution inputs only.
+ *
+ * ## Attribution (gen-maps)
+ *
+ * Every instance self-wraps its `toString` at construction (an
+ * own-property wrapper — shared function, non-enumerable). The wrapper is
+ * gated by the **capture interval**: the span while
+ * {@link import('@/context/generateTypes.ts').GenerateContextType.captureSink}
+ * is set, which `RenderContext` opens around the one capturing render and
+ * closes in `finally`. Inside the interval each `toString` invocation is
+ * observed into the transient
+ * {@link import('@/anchors/CaptureSink.ts').CaptureSink} occurrence tree;
+ * outside it the wrapper is a pure pass-through. Subclass authors write
+ * nothing different. Snippets constructed *during* the capture render are
+ * captured too — they self-wrap at birth.
+ *
+ * One documented convention: declare `toString` as a prototype method,
+ * never as an instance field (an arrow-function field would overwrite the
+ * wrapper).
+ */
+export declare class SnippetBase {
+    /** The generation context providing access to OAS objects and utilities */
+    context: GenerateContextType;
+    /** Whether this generator has been skipped */
+    skipped: boolean;
+    /** Optional generator key — attribution input only */
+    generatorKey: GeneratorKey | undefined;
+    /**
+     * Position of the schema fragment this snippet was built from, as a
+     * `StackTrail`. Callers pass a stable snapshot (a **clone** taken at the
+     * call site — `StackTrail` is mutable, so an un-cloned reference would
+     * alias a trail that later append/remove calls could mutate). The empty
+     * trail (`StackTrail.empty()`) means "no single originating node", in
+     * which case the resolver uses the generator-key-derived pointer.
+     * Converted to a JSON Pointer string only at the resolver — never
+     * carried as a string here.
+     */
+    stackTrail: StackTrail;
+    constructor({ context, generatorKey, stackTrail }: SnippetBaseArgs);
+}
+//# sourceMappingURL=SnippetBase.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SnippetBase.d.ts","sourceRoot":"","sources":["../../src/dsl/SnippetBase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAA;AACtE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,iEAAiE;IACjE,OAAO,EAAE,mBAAmB,CAAA;IAC5B,iEAAiE;IACjE,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B;;;;;;;;;OASG;IACH,UAAU,CAAC,EAAE,UAAU,CAAA;CACxB,CAAA;AAwBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,qBAAa,WAAW;IACtB,2EAA2E;IAC3E,OAAO,EAAE,mBAAmB,CAAA;IAE5B,8CAA8C;IAC9C,OAAO,EAAE,OAAO,CAAQ;IAExB,sDAAsD;IACtD,YAAY,EAAE,YAAY,GAAG,SAAS,CAAA;IAEtC;;;;;;;;;OASG;IACH,UAAU,EAAE,UAAU,CAAA;gBAEV,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,EAAE,eAAe;CAcnE"}

package/esm/dsl/SnippetBase.js

@@ -0,0 +1,113 @@
+import { StackTrail } from '../context/StackTrail.js';
+/**
+ * The own-property `toString` wrapper every {@link SnippetBase} instance
+ * installs at construction — ONE shared function, no per-instance closure.
+ *
+ * Own properties shadow every prototype, so this intercepts the leaf
+ * subclass's `toString` no matter where in the hierarchy it is declared —
+ * the same mechanism that defeats base-prototype wrapping, used in our
+ * favor. The real implementation is resolved through the prototype chain
+ * from the leaf (a read made ON the prototype object isn't shadowed by the
+ * instance's own property).
+ *
+ * Outside the capture interval (`context.captureSink` unset) this is a
+ * pure pass-through — one property read and one branch. Bare test mocks
+ * (`{} as GenerateContextType`) read `undefined` and take the pass-through
+ * path.
+ */
+const capturingToString = function () {
+    const impl = Object.getPrototypeOf(this).toString;
+    const sink = this.context.captureSink; // undefined outside the capture interval
+    return sink ? sink.observe(this, impl) : impl.call(this);
+};
+/**
+ * Abstract root of every stringifiable element in the SKMTC DSL.
+ *
+ * Two specializations live below this class:
+ *
+ * - **Projections** — named, exportable artifacts built by the
+ *   projection-base factories (`toModelProjectionBase` and the OAS/GQL
+ *   siblings) on a language package's snippet base; the pipeline wraps
+ *   them in a `Definition` and registers them in a file.
+ * - **Snippets** are anonymous, embedded values whose `toString()` is spliced
+ *   into the body of a Projection (or another Snippet). `Definition` and
+ *   `CustomValue` extend `SnippetBase` directly without going through a
+ *   Projection base.
+ *
+ * `SnippetBase` is **language-blind**: it has no `register`, no language,
+ * and nothing on it can throw for lack of identity. Register ergonomics
+ * live on each language package's snippet base (e.g. `TsSnippet`'s
+ * `register`, which delegates to that package's register function) — a raw
+ * `SnippetBase` subclass that tries to register is a compile-time error.
+ * `generatorKey` and `stackTrail` are *optional* attribution inputs only.
+ *
+ * ## Attribution (gen-maps)
+ *
+ * Every instance self-wraps its `toString` at construction (an
+ * own-property wrapper — shared function, non-enumerable). The wrapper is
+ * gated by the **capture interval**: the span while
+ * {@link import('@/context/generateTypes.ts').GenerateContextType.captureSink}
+ * is set, which `RenderContext` opens around the one capturing render and
+ * closes in `finally`. Inside the interval each `toString` invocation is
+ * observed into the transient
+ * {@link import('@/anchors/CaptureSink.ts').CaptureSink} occurrence tree;
+ * outside it the wrapper is a pure pass-through. Subclass authors write
+ * nothing different. Snippets constructed *during* the capture render are
+ * captured too — they self-wrap at birth.
+ *
+ * One documented convention: declare `toString` as a prototype method,
+ * never as an instance field (an arrow-function field would overwrite the
+ * wrapper).
+ */
+export class SnippetBase {
+    constructor({ context, generatorKey, stackTrail }) {
+        /** The generation context providing access to OAS objects and utilities */
+        Object.defineProperty(this, "context", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Whether this generator has been skipped */
+        Object.defineProperty(this, "skipped", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        /** Optional generator key — attribution input only */
+        Object.defineProperty(this, "generatorKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Position of the schema fragment this snippet was built from, as a
+         * `StackTrail`. Callers pass a stable snapshot (a **clone** taken at the
+         * call site — `StackTrail` is mutable, so an un-cloned reference would
+         * alias a trail that later append/remove calls could mutate). The empty
+         * trail (`StackTrail.empty()`) means "no single originating node", in
+         * which case the resolver uses the generator-key-derived pointer.
+         * Converted to a JSON Pointer string only at the resolver — never
+         * carried as a string here.
+         */
+        Object.defineProperty(this, "stackTrail", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.context = context;
+        this.generatorKey = generatorKey;
+        this.stackTrail = stackTrail ?? StackTrail.empty();
+        // Self-wrap for attribution capture: an own-property `toString`
+        // (shared function value, non-enumerable) that observes into the
+        // context's capture sink while the capture interval is open and
+        // passes through otherwise.
+        Object.defineProperty(this, 'toString', {
+            value: capturingToString,
+            configurable: true
+        });
+    }
+}

package/esm/dsl/Stringable.d.ts

@@ -6,6 +6,7 @@
  * This interface matches JavaScript's built-in `toString()` contract and is used
  * extensively by the {@link List} class and other string-building utilities.
  */
+import "../_dnt.polyfills.js";
 export type Stringable = {
     /** Converts the object to its string representation */
     toString: () => string;

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

@@ -1 +1 @@
-{"version":3,"file":"Stringable.d.ts","sourceRoot":"","sources":["../../src/dsl/Stringable.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,uDAAuD;IACvD,QAAQ,EAAE,MAAM,MAAM,CAAA;CACvB,CAAA"}
+{"version":3,"file":"Stringable.d.ts","sourceRoot":"","sources":["../../src/dsl/Stringable.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,sBAAsB,CAAC;AAE9B,MAAM,MAAM,UAAU,GAAG;IACvB,uDAAuD;IACvD,QAAQ,EAAE,MAAM,MAAM,CAAA;CACvB,CAAA"}

package/esm/dsl/Stringable.js

@@ -1 +1,9 @@
-export {};
+/**
+ * Represents any object that can be converted to a string representation.
+ *
+ * The `Stringable` interface is a fundamental type used throughout the SKMTC DSL
+ * system to ensure that objects can be converted to strings for code generation.
+ * This interface matches JavaScript's built-in `toString()` contract and is used
+ * extensively by the {@link List} class and other string-building utilities.
+ */
+import "../_dnt.polyfills.js";