@skmtc/core 0.18.1 → 0.27.0

package/script/deps/jsr.io/@std/path/{1.1.4 → 1.1.6}/posix/from_file_url.js

@@ -1,5 +1,5 @@
 "use strict";
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
 // This module is browser compatible.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fromFileUrl = fromFileUrl;

package/{esm/deps/jsr.io/@std/path/1.1.4 → script/deps/jsr.io/@std/path/1.1.6}/posix/join.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/posix/join.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CASpE"}
+{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.6/posix/join.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CASpE"}

package/script/deps/jsr.io/@std/path/{1.1.4 → 1.1.6}/posix/join.js

@@ -1,5 +1,5 @@
 "use strict";
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
 // This module is browser compatible.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.join = join;

package/{esm/deps/jsr.io/@std/path/1.1.4 → script/deps/jsr.io/@std/path/1.1.6}/posix/normalize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/posix/normalize.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,MAAM,CAmBpD"}
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.6/posix/normalize.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,MAAM,CAmBpD"}

package/script/deps/jsr.io/@std/path/{1.1.4 → 1.1.6}/posix/normalize.js

@@ -1,5 +1,5 @@
 "use strict";
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
 // This module is browser compatible.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalize = normalize;

package/script/deps/jsr.io/@std/path/{1.1.4 → 1.1.6}/windows/_util.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"_util.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/windows/_util.ts"],"names":[],"mappings":"AAcA,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAKzD"}
+{"version":3,"file":"_util.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.6/windows/_util.ts"],"names":[],"mappings":"AAcA,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAKzD"}

package/script/deps/jsr.io/@std/path/{1.1.4 → 1.1.6}/windows/_util.js

@@ -1,5 +1,5 @@
 "use strict";
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
 // Copyright the Browserify authors. MIT License.
 // Ported from https://github.com/browserify/path-browserify/
 // This module is browser compatible.

package/script/deps/jsr.io/@std/path/1.1.6/windows/extname.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Return the extension of the `path` with leading period.
+ *
+ * @example Usage
+ * ```ts
+ * import { extname } from "@std/path/windows/extname";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(extname("file.ts"), ".ts");
+ * assertEquals(extname(new URL("file:///C:/foo/bar/baz.ext")), ".ext");
+ * ```
+ *
+ * @param path The path to get the extension from.
+ * @returns The extension of the `path`.
+ * @throws {TypeError} If `path` is a `URL` instance whose protocol is not `file:`.
+ */
+export declare function extname(path: string | URL): string;
+//# sourceMappingURL=extname.d.ts.map

package/script/deps/jsr.io/@std/path/1.1.6/windows/extname.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extname.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.6/windows/extname.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,MAAM,CAkElD"}

package/script/deps/jsr.io/@std/path/1.1.6/windows/extname.js

@@ -0,0 +1,86 @@
+"use strict";
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extname = extname;
+const constants_js_1 = require("../_common/constants.js");
+const assert_path_js_1 = require("../_common/assert_path.js");
+const _util_js_1 = require("./_util.js");
+const from_file_url_js_1 = require("./from_file_url.js");
+/**
+ * Return the extension of the `path` with leading period.
+ *
+ * @example Usage
+ * ```ts
+ * import { extname } from "@std/path/windows/extname";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(extname("file.ts"), ".ts");
+ * assertEquals(extname(new URL("file:///C:/foo/bar/baz.ext")), ".ext");
+ * ```
+ *
+ * @param path The path to get the extension from.
+ * @returns The extension of the `path`.
+ * @throws {TypeError} If `path` is a `URL` instance whose protocol is not `file:`.
+ */
+function extname(path) {
+    if (path instanceof URL) {
+        path = (0, from_file_url_js_1.fromFileUrl)(path);
+    }
+    (0, assert_path_js_1.assertPath)(path);
+    let start = 0;
+    let startDot = -1;
+    let startPart = 0;
+    let end = -1;
+    let matchedSlash = true;
+    // Track the state of characters (if any) we see before our first dot and
+    // after any path separator we find
+    let preDotState = 0;
+    // Check for a drive letter prefix so as not to mistake the following
+    // path separator as an extra separator at the end of the path that can be
+    // disregarded
+    if (path.length >= 2 &&
+        path.charCodeAt(1) === constants_js_1.CHAR_COLON &&
+        (0, _util_js_1.isWindowsDeviceRoot)(path.charCodeAt(0))) {
+        start = startPart = 2;
+    }
+    for (let i = path.length - 1; i >= start; --i) {
+        const code = path.charCodeAt(i);
+        if ((0, _util_js_1.isPathSeparator)(code)) {
+            // If we reached a path separator that was not part of a set of path
+            // separators at the end of the string, stop now
+            if (!matchedSlash) {
+                startPart = i + 1;
+                break;
+            }
+            continue;
+        }
+        if (end === -1) {
+            // We saw the first non-path separator, mark this as the end of our
+            // extension
+            matchedSlash = false;
+            end = i + 1;
+        }
+        if (code === constants_js_1.CHAR_DOT) {
+            // If this is our first dot, mark it as the start of our extension
+            if (startDot === -1)
+                startDot = i;
+            else if (preDotState !== 1)
+                preDotState = 1;
+        }
+        else if (startDot !== -1) {
+            // We saw a non-dot and non-path separator before our dot, so we should
+            // have a good chance at having a non-empty extension
+            preDotState = -1;
+        }
+    }
+    if (startDot === -1 ||
+        end === -1 ||
+        // We saw a non-dot character immediately before the dot
+        preDotState === 0 ||
+        // The (right-most) trimmed path component is exactly '..'
+        (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)) {
+        return "";
+    }
+    return path.slice(startDot, end);
+}

package/{esm/deps/jsr.io/@std/path/1.1.4 → script/deps/jsr.io/@std/path/1.1.6}/windows/from_file_url.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"from_file_url.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/windows/from_file_url.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,GAAG,MAAM,CAYrD"}
+{"version":3,"file":"from_file_url.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.6/windows/from_file_url.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,GAAG,MAAM,CAYrD"}

package/script/deps/jsr.io/@std/path/{1.1.4 → 1.1.6}/windows/from_file_url.js

@@ -1,5 +1,5 @@
 "use strict";
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
 // This module is browser compatible.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fromFileUrl = fromFileUrl;

package/{esm/deps/jsr.io/@std/path/1.1.4 → script/deps/jsr.io/@std/path/1.1.6}/windows/join.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/windows/join.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAqDpE"}
+{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.6/windows/join.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAqDpE"}

package/script/deps/jsr.io/@std/path/{1.1.4 → 1.1.6}/windows/join.js

@@ -1,5 +1,5 @@
 "use strict";
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
 // This module is browser compatible.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.join = join;

package/{esm/deps/jsr.io/@std/path/1.1.4 → script/deps/jsr.io/@std/path/1.1.6}/windows/normalize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/windows/normalize.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,MAAM,CA6GpD"}
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.6/windows/normalize.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,MAAM,CA6GpD"}

package/script/deps/jsr.io/@std/path/{1.1.4 → 1.1.6}/windows/normalize.js

@@ -1,5 +1,5 @@
 "use strict";
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
 // This module is browser compatible.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalize = normalize;

package/script/dsl/CodeFileBase.d.ts

@@ -1,38 +1,71 @@
 import { FileBase } from './FileBase.js';
+import type { DefinitionBase } from './Definition.js';
+import type { IdentifierBase } from './IdentifierBase.js';
 import type { ImportBase } from './ImportBase.js';
 import type { ReExportBase } from './ReExportBase.js';
+/**
+ * Query for {@link CodeFileBase.findDefinitions}. `name` filters by identifier
+ * name; `type` filters by the declaration type as the opaque-boundary
+ * `string`. A lang's concrete file narrows the override to its own
+ * `XxEntityType` (`'class'` / `'interface'` / … for TypeScript). Omit both to
+ * return every definition.
+ */
+export type FindDefinitionsQuery = {
+    type?: string;
+    name?: string;
+};
+/**
+ * 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 declare const matchDefinitions: (all: DefinitionBase[], query: FindDefinitionsQuery | undefined, typeOf: (identifier: IdentifierBase) => string | undefined) => DefinitionBase[] | 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 declare abstract class CodeFileBase extends FileBase {
-    /** Registered imports, keyed by {@link ImportBase.mergeKey}. */
-    imports: Map<string, ImportBase>;
-    /** Registered re-exports, keyed by {@link ReExportBase.mergeKey}. */
-    reExports: Map<string, ReExportBase>;
     /**
-     * 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.
+     * Add a definition, applying the language's duplication rule (e.g.
+     * TypeScript declaration merging). Called by the engine's `register`.
+     */
+    abstract addDefinition(definition: DefinitionBase): void;
+    /**
+     * Merge imports in, applying the language's collapse rule (typically
+     * keyed by {@link ImportBase.mergeKey} and combined via
+     * {@link ImportBase.merge}). Called by the engine's `register`.
+     */
+    abstract addImports(imports: ImportBase[]): void;
+    /**
+     * Merge re-exports in, applying the language's collapse rule. Called by the
+     * engine's `register`; a language without re-exports never receives any.
      */
-    addImports(incoming: ImportBase[]): void;
+    abstract addReExports(reExports: ReExportBase[]): void;
     /**
-     * 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).
+     * Query the file's definitions. With no `name`/`type` → every definition (an
+     * array; the neutral "list all" used to inspect a file, e.g. assert the
+     * peer-dedup invariant). With `name` and/or `type` → the matching subset, or
+     * `undefined` when nothing matches. `type` is the declaration type as the
+     * opaque `string`; a lang's concrete file may narrow it. Implement with
+     * {@link matchDefinitions}.
      */
-    addReExports(incoming: ReExportBase[]): void;
+    abstract findDefinitions(query?: FindDefinitionsQuery): DefinitionBase[] | undefined;
 }
 //# sourceMappingURL=CodeFileBase.d.ts.map

package/script/dsl/CodeFileBase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CodeFileBase.d.ts","sourceRoot":"","sources":["../../src/dsl/CodeFileBase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD;;;;;;;;;;;;;GAaG;AACH,8BAAsB,YAAa,SAAQ,QAAQ;IACjD,gEAAgE;IAChE,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAY;IAE5C,qEAAqE;IACrE,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAY;IAEhD;;;;OAIG;IACH,UAAU,CAAC,QAAQ,EAAE,UAAU,EAAE,GAAG,IAAI;IASxC;;;;;;OAMG;IACH,YAAY,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;CAQ7C"}
+{"version":3,"file":"CodeFileBase.d.ts","sourceRoot":"","sources":["../../src/dsl/CodeFileBase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD;;;;;;GAMG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,GAC3B,KAAK,cAAc,EAAE,EACrB,OAAO,oBAAoB,GAAG,SAAS,EACvC,QAAQ,CAAC,UAAU,EAAE,cAAc,KAAK,MAAM,GAAG,SAAS,KACzD,cAAc,EAAE,GAAG,SAerB,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,8BAAsB,YAAa,SAAQ,QAAQ;IACjD;;;OAGG;IACH,QAAQ,CAAC,aAAa,CAAC,UAAU,EAAE,cAAc,GAAG,IAAI;IAExD;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,IAAI;IAEhD;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,SAAS,EAAE,YAAY,EAAE,GAAG,IAAI;IAEtD;;;;;;;OAOG;IACH,QAAQ,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,oBAAoB,GAAG,cAAc,EAAE,GAAG,SAAS;CACrF"}

package/script/dsl/CodeFileBase.js

@@ -1,64 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CodeFileBase = void 0;
+exports.CodeFileBase = exports.matchDefinitions = void 0;
 const FileBase_js_1 = require("./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.
+ */
+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;
+};
+exports.matchDefinitions = matchDefinitions;
 /**
  * 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]`.
  */
 class CodeFileBase extends FileBase_js_1.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);
-        }
-    }
 }
 exports.CodeFileBase = CodeFileBase;

package/script/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/script/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/script/dsl/FileBase.js

@@ -5,20 +5,20 @@ exports.FileBase = void 0;
  * 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.
  */
 class FileBase {
     constructor({ path }) {
@@ -29,29 +29,20 @@ 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);
-        }
     }
 }
 exports.FileBase = FileBase;