@skmtc/core 0.18.1 → 0.26.0

package/esm/dsl/CodeFileBase.js

@@ -1,60 +1,42 @@
 import { FileBase } from './FileBase.js';
+/**
+ * The neutral name/type filter every language's `findDefinitions` shares. The
+ * language passes its definition list and a `typeOf` extractor — the one
+ * lang-specific bit, which narrows to the language's Identifier subclass to
+ * read the typed `type` (returned here as the opaque `string`).
+ *
+ * - no `name` and no `type` → returns `all` (the whole list; the former
+ *   `listDefinitions`).
+ * - otherwise → the matching subset, or `undefined` when nothing matches.
+ */
+export const matchDefinitions = (all, query, typeOf) => {
+    const name = query?.name;
+    const type = query?.type;
+    if (name === undefined && type === undefined) {
+        return all;
+    }
+    const matches = all.filter(definition => {
+        const nameMatches = name === undefined || definition.identifier.name === name;
+        const typeMatches = type === undefined || typeOf(definition.identifier) === type;
+        return nameMatches && typeMatches;
+    });
+    return matches.length > 0 ? matches : undefined;
+};
 /**
  * The base every language's *code* file extends — a {@link FileBase} that
- * also carries imports. (`JsonFile`, which has no imports, extends
- * {@link FileBase} directly.)
+ * coordinates definitions, imports, and re-exports. (`JsonFile`, with none of
+ * these, extends {@link FileBase} directly.)
  *
- * The import collection and its merge are **language-neutral**: imports are
- * held keyed by {@link ImportBase.mergeKey} and collapsed via
- * {@link ImportBase.merge}, with no language-specific logic. The spike
- * proved this same `Map` + merge serves TypeScript (per-module grouping,
- * type-tags) and Go (whole-package imports, discarded symbol lists)
- * identically — only the *arrangement* of the rendered import section
- * differs, which is why `toString()` stays abstract and lives on the
- * language subclass (`TsFile`, `GoFile`).
+ * Language-blind: the declaration type {@link findDefinitions} filters on is
+ * the opaque-boundary `string` here; a lang's concrete file narrows its own
+ * `findDefinitions` override to its `XxEntityType`.
+ *
+ * Pure contract — no fields, no merge logic. Storage AND the duplication/merge
+ * policy are language-specific and live in the concrete lang subclass; the
+ * engine speaks only these four neutral operations — three writers driven by
+ * `register`, plus {@link findDefinitions}, the read seam the cross-generator
+ * cache and file inspection use. The cache resolves a single primary by name
+ * via `findDefinitions({ name })?.[0]`.
  */
 export class CodeFileBase extends FileBase {
-    constructor() {
-        super(...arguments);
-        /** Registered imports, keyed by {@link ImportBase.mergeKey}. */
-        Object.defineProperty(this, "imports", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-        /** Registered re-exports, keyed by {@link ReExportBase.mergeKey}. */
-        Object.defineProperty(this, "reExports", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-    }
-    /**
-     * Merge imports in, collapsing any that share a `mergeKey()` with an
-     * existing entry via {@link ImportBase.merge}. Neutral — the engine's
-     * `register` calls this on the abstract base for every language's file.
-     */
-    addImports(incoming) {
-        for (const importEntry of incoming) {
-            const key = importEntry.mergeKey();
-            const existing = this.imports.get(key);
-            this.imports.set(key, existing ? existing.merge(importEntry) : importEntry);
-        }
-    }
-    /**
-     * Merge re-exports in, collapsing any that share a `mergeKey()` with an
-     * existing entry via {@link ReExportBase.merge}. Neutral — the engine's
-     * `register` calls this on the abstract base; a language without
-     * re-exports never receives any (its concise register vocabulary has no
-     * `reExports` field).
-     */
-    addReExports(incoming) {
-        for (const reExportEntry of incoming) {
-            const key = reExportEntry.mergeKey();
-            const existing = this.reExports.get(key);
-            this.reExports.set(key, existing ? existing.merge(reExportEntry) : reExportEntry);
-        }
-    }
 }

package/esm/dsl/FileBase.d.ts

@@ -1,41 +1,37 @@
-import type { DefinitionBase } from './Definition.js';
+import type { Stringable } from './Stringable.js';
 /**
  * The language-neutral coordination surface shared by the engine and
  * every `@skmtc/lang-*` package's concrete file subclass.
  *
- * The engine (`GenerateContext` and the cross-generator cache) only ever
- * reads this surface — the file's `path` and its `definitions` map. It
- * never reads a file's language-specific output state (imports,
- * re-exports) or its rendered string, which is what keeps the engine
- * language-blind. A language package subclasses `FileBase`, adds its own
- * output state, and implements `toString()` to render itself.
+ * `FileBase` carries only what is common to *every* file — code or not:
+ * its `path`, an optional free-form `custom` content slot, and the
+ * `toString()` contract. It holds NO definitions, imports, or dedup
+ * policy — those are code-file concerns that live on {@link CodeFileBase}
+ * and the language subclass, which is what keeps the engine
+ * language-blind.
  *
- * `JsonFile` extends this too — a JSON file is a `FileBase` whose
- * `definitions` map stays empty and whose `toString()` serialises its
- * content. (See notes/lang: "JSON is a degenerate language".)
+ * `JsonFile` extends this directly — a JSON file has a `path`, serialises
+ * its content in `toString()`, and never touches definitions. (See
+ * notes/lang: "JSON is a degenerate language".)
  *
- * Lives in its own leaf module (only a type-only `DefinitionBase` import)
- * so that `File` and `JsonFile` — which both `extends FileBase` — can
- * import it without forming a value-level import cycle through `File.ts`.
+ * Lives in its own leaf module (only a type-only `Stringable` import) so
+ * that the file subclasses can import it without forming a value-level
+ * import cycle.
  */
 export declare abstract class FileBase {
     /** The file path for this generated file */
     path: string;
-    /** Map of definition names to their Definition objects */
-    definitions: Map<string, DefinitionBase>;
+    /**
+     * Optional free-form content. On a code file this is the leading banner
+     * (e.g. a codegen header); on an ad-hoc non-code file (Markdown, plain
+     * text) it can carry the body. Inert until a concrete subclass renders
+     * it in `toString()`. Set through the neutral `register` vocabulary's
+     * `custom` field (last write wins).
+     */
+    custom: Stringable | undefined;
     constructor({ path }: {
         path: string;
     });
-    /**
-     * Add a definition, deduplicating by identifier name (first write wins).
-     *
-     * Neutral: the engine's `register` calls this on the abstract base, so it
-     * works for every language's file. Per-language duplication rules (e.g.
-     * TypeScript declaration merging — a class and its `declare namespace`
-     * sharing a name) belong in the language's file subclass, which overrides
-     * this method.
-     */
-    addDefinition(definition: DefinitionBase): void;
     /** Renders the file's complete contents. Implemented by the subclass. */
     abstract toString(): string;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"FileBase.d.ts","sourceRoot":"","sources":["../../src/dsl/FileBase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAErD;;;;;;;;;;;;;;;;;;GAkBG;AACH,8BAAsB,QAAQ;IAC5B,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAA;IAEZ,0DAA0D;IAC1D,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;gBAE5B,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE;IAKtC;;;;;;;;OAQG;IACH,aAAa,CAAC,UAAU,EAAE,cAAc,GAAG,IAAI;IAM/C,yEAAyE;IACzE,QAAQ,CAAC,QAAQ,IAAI,MAAM;CAC5B"}
+{"version":3,"file":"FileBase.d.ts","sourceRoot":"","sources":["../../src/dsl/FileBase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,8BAAsB,QAAQ;IAC5B,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAA;IAEZ;;;;;;OAMG;IACH,MAAM,EAAE,UAAU,GAAG,SAAS,CAAA;gBAElB,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE;IAItC,yEAAyE;IACzE,QAAQ,CAAC,QAAQ,IAAI,MAAM;CAC5B"}

package/esm/dsl/FileBase.js

@@ -2,20 +2,20 @@
  * The language-neutral coordination surface shared by the engine and
  * every `@skmtc/lang-*` package's concrete file subclass.
  *
- * The engine (`GenerateContext` and the cross-generator cache) only ever
- * reads this surface — the file's `path` and its `definitions` map. It
- * never reads a file's language-specific output state (imports,
- * re-exports) or its rendered string, which is what keeps the engine
- * language-blind. A language package subclasses `FileBase`, adds its own
- * output state, and implements `toString()` to render itself.
+ * `FileBase` carries only what is common to *every* file — code or not:
+ * its `path`, an optional free-form `custom` content slot, and the
+ * `toString()` contract. It holds NO definitions, imports, or dedup
+ * policy — those are code-file concerns that live on {@link CodeFileBase}
+ * and the language subclass, which is what keeps the engine
+ * language-blind.
  *
- * `JsonFile` extends this too — a JSON file is a `FileBase` whose
- * `definitions` map stays empty and whose `toString()` serialises its
- * content. (See notes/lang: "JSON is a degenerate language".)
+ * `JsonFile` extends this directly — a JSON file has a `path`, serialises
+ * its content in `toString()`, and never touches definitions. (See
+ * notes/lang: "JSON is a degenerate language".)
  *
- * Lives in its own leaf module (only a type-only `DefinitionBase` import)
- * so that `File` and `JsonFile` — which both `extends FileBase` — can
- * import it without forming a value-level import cycle through `File.ts`.
+ * Lives in its own leaf module (only a type-only `Stringable` import) so
+ * that the file subclasses can import it without forming a value-level
+ * import cycle.
  */
 export class FileBase {
     constructor({ path }) {
@@ -26,28 +26,19 @@ export class FileBase {
             writable: true,
             value: void 0
         });
-        /** Map of definition names to their Definition objects */
-        Object.defineProperty(this, "definitions", {
+        /**
+         * Optional free-form content. On a code file this is the leading banner
+         * (e.g. a codegen header); on an ad-hoc non-code file (Markdown, plain
+         * text) it can carry the body. Inert until a concrete subclass renders
+         * it in `toString()`. Set through the neutral `register` vocabulary's
+         * `custom` field (last write wins).
+         */
+        Object.defineProperty(this, "custom", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
         this.path = path;
-        this.definitions = new Map();
-    }
-    /**
-     * Add a definition, deduplicating by identifier name (first write wins).
-     *
-     * Neutral: the engine's `register` calls this on the abstract base, so it
-     * works for every language's file. Per-language duplication rules (e.g.
-     * TypeScript declaration merging — a class and its `declare namespace`
-     * sharing a name) belong in the language's file subclass, which overrides
-     * this method.
-     */
-    addDefinition(definition) {
-        if (!this.definitions.has(definition.identifier.name)) {
-            this.definitions.set(definition.identifier.name, definition);
-        }
     }
 }

package/esm/dsl/GeneratorKeys.d.ts

@@ -129,7 +129,7 @@ export type OasOperationGeneratorKey = Brand<NakedOasOperationGeneratorKey, 'Oas
  * Branded type for GraphQL operation generator keys.
  *
  * Sibling to {@link OasOperationGeneratorKey} for the GraphQL protocol. The key
- * encodes the generator ID, the root kind (`query` / `mutation` /
+ * encodes the generator ID, the root type (`query` / `mutation` /
  * `subscription`), and the root field name.
  */
 export type GqlOperationGeneratorKey = Brand<NakedGqlOperationGeneratorKey, 'GqlOperationGeneratorKey'>;
@@ -210,15 +210,15 @@ type ToOasOperationGeneratorKeyArgs = {
     path: string;
     /** HTTP method */
     method: Method;
-    /** Operation variant name (use `'main'` for variants-unaware generators) */
-    variant: string;
+    /** Operation variant name — omitted means `'main'` */
+    variant?: string;
 } | {
     /** Unique identifier for the generator */
     generatorId: string;
     /** OpenAPI operation object containing path and method */
     operation: OasOperation;
-    /** Operation variant name (use `'main'` for variants-unaware generators) */
-    variant: string;
+    /** Operation variant name — omitted means `'main'` */
+    variant?: string;
 };
 /**
  * Creates an OAS operation generator key from generator ID and operation details.
@@ -271,15 +271,15 @@ type ToWebhookGeneratorKeyArgs = {
     name: string;
     /** HTTP method */
     method: Method;
-    /** Webhook variant name (use `'main'` for variants-unaware generators) */
-    variant: string;
+    /** Webhook variant name — omitted means `'main'` */
+    variant?: string;
 } | {
     /** Unique identifier for the generator */
     generatorId: string;
     /** OpenAPI webhook object containing name and method */
     webhook: OasWebhook;
-    /** Webhook variant name (use `'main'` for variants-unaware generators) */
-    variant: string;
+    /** Webhook variant name — omitted means `'main'` */
+    variant?: string;
 };
 /**
  * Creates a webhook generator key from generator ID and webhook details.
@@ -293,25 +293,25 @@ export declare const toWebhookGeneratorKey: ({ generatorId, variant, ...rest }:
  * Arguments for {@link toGqlOperationGeneratorKey}.
  *
  * Can specify operation details directly or provide a {@link GqlOperation}
- * object from which the root kind and field name will be extracted. The
+ * object from which the root type and field name will be extracted. The
  * `variant` segment is always required (see {@link Variant}).
  */
 type ToGqlOperationGeneratorKeyArgs = {
     /** Unique identifier for the generator */
     generatorId: string;
-    /** GraphQL root kind */
+    /** GraphQL root type */
     rootKind: GqlRootKind;
     /** Root field name */
     fieldName: string;
-    /** Operation variant name (use `'main'` for variants-unaware generators) */
-    variant: string;
+    /** Operation variant name — omitted means `'main'` */
+    variant?: string;
 } | {
     /** Unique identifier for the generator */
     generatorId: string;
     /** GraphQL operation object */
     operation: GqlOperation;
-    /** Operation variant name (use `'main'` for variants-unaware generators) */
-    variant: string;
+    /** Operation variant name — omitted means `'main'` */
+    variant?: string;
 };
 /**
  * Creates a GraphQL operation generator key.
@@ -331,8 +331,8 @@ type ToModelGeneratorKeyArgs = {
     generatorId: string;
     /** Reference name of the schema model */
     refName: RefName;
-    /** Model variant name (use `'main'` for variants-unaware generators) */
-    variant: string;
+    /** Model variant name — omitted means `'main'` */
+    variant?: string;
 };
 /**
  * Creates a model generator key from generator ID, schema reference name,
@@ -455,7 +455,7 @@ export declare const isWebhookGeneratorKey: (arg: unknown) => arg is WebhookGene
  *
  * 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 declare const isGqlOperationGeneratorKey: (arg: unknown) => arg is GqlOperationGeneratorKey;
 /**
@@ -572,7 +572,7 @@ export type GeneratorKeyObject = {
     type: 'gqlOperation';
     /** Generator identifier */
     generatorId: string;
-    /** GraphQL root kind */
+    /** GraphQL root type */
     rootKind: GqlRootKind;
     /** Root field name */
     fieldName: string;

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

@@ -1 +1 @@
-{"version":3,"file":"GeneratorKeys.d.ts","sourceRoot":"","sources":["../../src/dsl/GeneratorKeys.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"GeneratorKeys.d.ts","sourceRoot":"","sources":["../../src/dsl/GeneratorKeys.ts"],"names":[],"mappings":"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"}

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"}