@skmtc/core 0.28.5 → 0.28.7

package/script/dsl/DefinitionContainer.d.ts

@@ -0,0 +1,40 @@
+import type { DefinitionBase } from './Definition.js';
+import type { FindDefinitionsQuery } from './CodeFileBase.js';
+/**
+ * A place definitions can be inserted into.
+ *
+ * Files were the only such place until languages with member-holding
+ * declarations arrived: a Kotlin `interface` body, a C# `class` body, a Java
+ * `enum` body all hold named declarations the same way a file does. This is
+ * the pair of operations the engine needs from either, and
+ * {@link import('./CodeFileBase.ts').CodeFileBase} already satisfies it — a
+ * declaration's VALUE satisfying it too is what makes the declaration an
+ * insertion target.
+ *
+ * What that buys is the property files already have: order independence.
+ * Every producer looks a member up before creating it, so members may arrive
+ * in any order, and the container is found or created by whoever needs it
+ * first — no accumulating `add` method, and no second vocabulary for
+ * generators that group their output.
+ */
+export type DefinitionContainer = {
+    /**
+     * Add a member, applying the language's duplication rule. Called by the
+     * engine's `register` when a `into` target is named.
+     */
+    addDefinition(definition: DefinitionBase): void;
+    /**
+     * The read seam the cross-generator cache uses, identical to a file's:
+     * matching members, or `undefined` when nothing matches.
+     */
+    findDefinitions(query?: FindDefinitionsQuery): DefinitionBase[] | undefined;
+};
+/**
+ * Whether a definition's value can hold members.
+ *
+ * Structural rather than nominal on purpose: `instanceof` fails across module
+ * instances — two copies of a language package in one bundle is a real
+ * situation — and the failure is silent, so a value that plainly implements
+ * the contract must be accepted however it was constructed.
+ */
+export declare const isDefinitionContainer: (value: unknown) => value is DefinitionContainer;

package/script/dsl/DefinitionContainer.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDefinitionContainer = void 0;
+/**
+ * Whether a definition's value can hold members.
+ *
+ * Structural rather than nominal on purpose: `instanceof` fails across module
+ * instances — two copies of a language package in one bundle is a real
+ * situation — and the failure is silent, so a value that plainly implements
+ * the contract must be accepted however it was constructed.
+ */
+const isDefinitionContainer = (value) => {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.addDefinition === 'function' && typeof candidate.findDefinitions === 'function');
+};
+exports.isDefinitionContainer = isDefinitionContainer;

package/script/dsl/FileBase.d.ts

@@ -35,4 +35,3 @@ export declare abstract class FileBase {
     /** Renders the file's complete contents. Implemented by the subclass. */
     abstract toString(): string;
 }
-//# sourceMappingURL=FileBase.d.ts.map

package/script/dsl/GeneratedValue.d.ts

@@ -17,4 +17,3 @@ export type GeneratedValue = Stringable & {
  * @template V - The generated value type extending GeneratedValue
  */
 export type GeneratedDefinition<V extends GeneratedValue> = DefinitionBase<V>;
-//# sourceMappingURL=GeneratedValue.d.ts.map

package/script/dsl/GeneratedValueList.d.ts

@@ -164,4 +164,3 @@ export declare class GeneratedValueList {
      */
     toString(): string;
 }
-//# sourceMappingURL=GeneratedValueList.d.ts.map

package/script/dsl/GeneratorKeys.d.ts

@@ -117,6 +117,24 @@ export type NakedModelGeneratorKey = `${string}|${string}|${string}`;
  * trailing `variant` segment carries the variant axis (see {@link Variant}).
  */
 export type NakedWebhookGeneratorKey = `${string}|webhook|${string}|${Method}|${string}`;
+/**
+ * Raw string format for container generator keys:
+ * `generatorId|container|group|name|variant`.
+ *
+ * A container is a place, not a subject — many subjects insert members into
+ * one — so its key cannot name a subject the way an operation's does. It
+ * names the GROUP those subjects share instead: the tag they carry, the
+ * module they belong to, whatever the generator collects them by. Every
+ * member of the group computes the same one, and the `generatorId` segment
+ * is what the integrity check compares, so a second generator claiming that
+ * declaration fails rather than silently inheriting it.
+ *
+ * `name` distinguishes containers within one group — a tag may produce a
+ * service interface and a controller class. The literal `container` segment
+ * in position 2 keeps the key disjoint from the 5-segment webhook key, whose
+ * own discriminator is `webhook`.
+ */
+export type NakedContainerGeneratorKey = `${string}|container|${string}|${string}|${string}`;
 /**
  * Branded type for OAS operation generator keys.
  *
@@ -150,6 +168,11 @@ export type ModelGeneratorKey = Brand<NakedModelGeneratorKey, 'ModelGeneratorKey
  * key space.
  */
 export type WebhookGeneratorKey = Brand<NakedWebhookGeneratorKey, 'WebhookGeneratorKey'>;
+/**
+ * Branded type for container generator keys — the key a definition that
+ * holds members carries. See {@link NakedContainerGeneratorKey}.
+ */
+export type ContainerGeneratorKey = Brand<NakedContainerGeneratorKey, 'ContainerGeneratorKey'>;
 /**
  * Branded type for generator-only keys.
  *
@@ -194,7 +217,7 @@ export type GeneratorOnlyKey = Brand<string, 'GeneratorOnlyKey'>;
  * });
  * ```
  */
-export type GeneratorKey = OasOperationGeneratorKey | WebhookGeneratorKey | GqlOperationGeneratorKey | ModelGeneratorKey | GeneratorOnlyKey;
+export type GeneratorKey = OasOperationGeneratorKey | WebhookGeneratorKey | GqlOperationGeneratorKey | ModelGeneratorKey | ContainerGeneratorKey | GeneratorOnlyKey;
 /**
  * Arguments for {@link toOasOperationGeneratorKey}.
  *
@@ -289,6 +312,30 @@ type ToWebhookGeneratorKeyArgs = {
  * segment keeps webhook keys from colliding with operation keys.
  */
 export declare const toWebhookGeneratorKey: ({ generatorId, variant, ...rest }: ToWebhookGeneratorKeyArgs) => WebhookGeneratorKey;
+/**
+ * Arguments for {@link toContainerGeneratorKey}.
+ */
+export type ToContainerGeneratorKeyArgs = {
+    /** The generator that owns the container. */
+    generatorId: string;
+    /** The group its members share — a tag, a module, a service. */
+    group: string;
+    /** The container's identifier name, distinguishing it within the group. */
+    name: string;
+    /** Variant the container belongs to (see {@link Variant}). */
+    variant?: string;
+};
+/**
+ * Build the key for a definition that holds members.
+ *
+ * Every member of a group computes the same key for the container it inserts
+ * into, because the group is a function of the subject the same way an
+ * identifier name is. Deriving it from the group rather than from where the
+ * container happens to land keeps the key stable when a generator changes
+ * its file or naming policy, and keeps it saying what the definition IS
+ * rather than where it sits.
+ */
+export declare const toContainerGeneratorKey: ({ generatorId, group, name, variant }: ToContainerGeneratorKeyArgs) => ContainerGeneratorKey;
 /**
  * Arguments for {@link toGqlOperationGeneratorKey}.
  *
@@ -450,6 +497,15 @@ export declare const isOasOperationGeneratorKey: (arg: unknown) => arg is OasOpe
  * it disjoint from the 4-segment operation key.
  */
 export declare const isWebhookGeneratorKey: (arg: unknown) => arg is WebhookGeneratorKey;
+/**
+ * Type guard to check if a value is a valid {@link ContainerGeneratorKey}.
+ *
+ * Validates `generatorId|container|group|name|variant`: five
+ * pipe-delimited segments with a literal `container` discriminator in
+ * position 2. That literal is what keeps it disjoint from the webhook key,
+ * which is also five segments but carries `webhook` in the same position.
+ */
+export declare const isContainerGeneratorKey: (arg: unknown) => arg is ContainerGeneratorKey;
 /**
  * Type guard to check if a value is a valid {@link GqlOperationGeneratorKey}.
  *
@@ -567,6 +623,17 @@ export type GeneratorKeyObject = {
     method: Method;
     /** Webhook variant name */
     variant: string;
+} | {
+    /** Discriminator for container generator keys */
+    type: 'container';
+    /** Generator identifier */
+    generatorId: string;
+    /** The group the container's members share */
+    group: string;
+    /** The container's identifier name */
+    name: string;
+    /** Container variant name */
+    variant: string;
 } | {
     /** Discriminator for GraphQL operation generator keys */
     type: 'gqlOperation';
@@ -639,4 +706,3 @@ export type GeneratorKeyObject = {
  */
 export declare const fromGeneratorKey: (generatorKey: GeneratorKey) => GeneratorKeyObject;
 export {};
-//# sourceMappingURL=GeneratorKeys.d.ts.map

package/script/dsl/GeneratorKeys.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fromGeneratorKey = exports.toGeneratorId = exports.isGeneratorOnlyKey = exports.isModelGeneratorKey = exports.isGqlOperationGeneratorKey = exports.isWebhookGeneratorKey = exports.isOasOperationGeneratorKey = exports.isGeneratorKey = exports.toGeneratorOnlyKey = exports.toModelGeneratorKey = exports.toGqlOperationGeneratorKey = exports.toWebhookGeneratorKey = exports.toOasOperationGeneratorKey = void 0;
+exports.fromGeneratorKey = exports.toGeneratorId = exports.isGeneratorOnlyKey = exports.isModelGeneratorKey = exports.isGqlOperationGeneratorKey = exports.isContainerGeneratorKey = exports.isWebhookGeneratorKey = exports.isOasOperationGeneratorKey = exports.isGeneratorKey = exports.toGeneratorOnlyKey = exports.toModelGeneratorKey = exports.toGqlOperationGeneratorKey = exports.toContainerGeneratorKey = exports.toWebhookGeneratorKey = exports.toOasOperationGeneratorKey = void 0;
 /**
  * @fileoverview Generator Key System for SKMTC Core
  *
@@ -125,6 +125,37 @@ const toWebhookGeneratorKey = ({ generatorId, variant = Variant_js_1.DEFAULT_VAR
     return nakedKey;
 };
 exports.toWebhookGeneratorKey = toWebhookGeneratorKey;
+/**
+ * Build the key for a definition that holds members.
+ *
+ * Every member of a group computes the same key for the container it inserts
+ * into, because the group is a function of the subject the same way an
+ * identifier name is. Deriving it from the group rather than from where the
+ * container happens to land keeps the key stable when a generator changes
+ * its file or naming policy, and keeps it saying what the definition IS
+ * rather than where it sits.
+ */
+const toContainerGeneratorKey = ({ generatorId, group, name, variant = Variant_js_1.DEFAULT_VARIANT }) => {
+    const nakedKey = `${generatorId}|container|${escapeKeySegment(group)}|${escapeKeySegment(name)}|${variant}`;
+    return nakedKey;
+};
+exports.toContainerGeneratorKey = toContainerGeneratorKey;
+/**
+ * A group is whatever the generator groups by, and an OpenAPI tag is free
+ * text — `Users | Admin` is not unusual. An unescaped `|` would add a
+ * segment, so the key would still compare equal to itself and group
+ * correctly, while `isContainerGeneratorKey` rejected it on arity and
+ * `fromGeneratorKey` fell through to `generator-only` with the whole key
+ * as the generator id. Attribution would then record that, with nothing
+ * reporting a problem.
+ *
+ * `%` is escaped first so the mapping round-trips: without it a group
+ * holding the literal text `%7C` would come back out of
+ * {@link fromGeneratorKey} as `|`.
+ */
+const escapeKeySegment = (segment) => segment.replaceAll('%', '%25').replaceAll('|', '%7C');
+/** Reverses {@link escapeKeySegment}: `%` last, so `%257C` returns `%7C`. */
+const unescapeKeySegment = (segment) => segment.replaceAll('%7C', '|').replaceAll('%25', '%');
 /**
  * Creates a GraphQL operation generator key.
  *
@@ -312,6 +343,29 @@ const isWebhookGeneratorKey = (arg) => {
     return true;
 };
 exports.isWebhookGeneratorKey = isWebhookGeneratorKey;
+/**
+ * Type guard to check if a value is a valid {@link ContainerGeneratorKey}.
+ *
+ * Validates `generatorId|container|group|name|variant`: five
+ * pipe-delimited segments with a literal `container` discriminator in
+ * position 2. That literal is what keeps it disjoint from the webhook key,
+ * which is also five segments but carries `webhook` in the same position.
+ */
+const isContainerGeneratorKey = (arg) => {
+    if (typeof arg !== 'string') {
+        return false;
+    }
+    const keyTokens = arg.split('|');
+    if (keyTokens.length !== 5) {
+        return false;
+    }
+    const [generatorId, discriminator, group, name, variant] = keyTokens;
+    if (discriminator !== 'container') {
+        return false;
+    }
+    return [generatorId, group, name, variant].every(token => typeof token === 'string' && token.length > 0);
+};
+exports.isContainerGeneratorKey = isContainerGeneratorKey;
 /**
  * Type guard to check if a value is a valid {@link GqlOperationGeneratorKey}.
  *
@@ -455,6 +509,9 @@ const toGeneratorId = (generatorKey) => {
     if ((0, exports.isWebhookGeneratorKey)(generatorKey)) {
         return generatorKey.split('|')[0];
     }
+    if ((0, exports.isContainerGeneratorKey)(generatorKey)) {
+        return generatorKey.split('|')[0];
+    }
     if ((0, exports.isGqlOperationGeneratorKey)(generatorKey)) {
         return generatorKey.split('|')[0];
     }
@@ -517,6 +574,16 @@ const fromGeneratorKey = (generatorKey) => {
         const [generatorId, _webhook, name, method, variant] = generatorKey.split('|');
         return { type: 'webhook', generatorId, name, method: method, variant };
     }
+    if ((0, exports.isContainerGeneratorKey)(generatorKey)) {
+        const [generatorId, _container, group, name, variant] = generatorKey.split('|');
+        return {
+            type: 'container',
+            generatorId,
+            group: unescapeKeySegment(group),
+            name: unescapeKeySegment(name),
+            variant
+        };
+    }
     if ((0, exports.isGqlOperationGeneratorKey)(generatorKey)) {
         const [generatorId, rootKind, fieldName, variant] = generatorKey.split('|');
         return {

package/script/dsl/IdentifierBase.d.ts

@@ -66,4 +66,3 @@ export declare class IdentifierBase {
      */
     declarationKey(): string;
 }
-//# sourceMappingURL=IdentifierBase.d.ts.map

package/script/dsl/IdentifierType.d.ts

@@ -22,4 +22,3 @@ export type IdentifierType = {
     /** Whether the identifier is exported. Defaults to `true`. */
     exported?: boolean;
 };
-//# sourceMappingURL=IdentifierType.d.ts.map

package/script/dsl/ImportBase.d.ts

@@ -37,4 +37,3 @@ export declare abstract class ImportBase {
     /** Render the standalone import. The `File` may re-arrange via `mergeKey`. */
     abstract toString(): string;
 }
-//# sourceMappingURL=ImportBase.d.ts.map

package/script/dsl/Inserted.d.ts

@@ -152,4 +152,3 @@ export declare class Inserted<V extends GeneratedValue, EnrichmentType> {
     toValue(): V;
 }
 export {};
-//# sourceMappingURL=Inserted.d.ts.map

package/script/dsl/JsonFile.d.ts

@@ -91,4 +91,3 @@ export declare class JsonFile extends FileBase {
     toString(): string;
 }
 export {};
-//# sourceMappingURL=JsonFile.d.ts.map

package/script/dsl/Lang.d.ts

@@ -113,4 +113,3 @@ export type Lang = {
 export type LangSnippetConstructor = (new (args: SnippetBaseArgs) => SnippetBase) & {
     lang: Lang;
 };
-//# sourceMappingURL=Lang.d.ts.map

package/script/dsl/MarkdownFile.d.ts

@@ -52,4 +52,3 @@ export declare class MarkdownFile extends FileBase {
     toString(): string;
 }
 export {};
-//# sourceMappingURL=MarkdownFile.d.ts.map

package/script/dsl/ReExportBase.d.ts

@@ -39,4 +39,3 @@ export declare abstract class ReExportBase {
     /** Render the standalone re-export. The `File` may re-arrange via `mergeKey`. */
     abstract toString(): string;
 }
-//# sourceMappingURL=ReExportBase.d.ts.map

package/script/dsl/SnippetBase.d.ts

@@ -83,4 +83,3 @@ export declare class SnippetBase {
     stackTrail: StackTrail;
     constructor({ context, generatorKey, stackTrail }: SnippetBaseArgs);
 }
-//# sourceMappingURL=SnippetBase.d.ts.map

package/script/dsl/Stringable.d.ts

@@ -11,4 +11,3 @@ export type Stringable = {
     /** Converts the object to its string representation */
     toString: () => string;
 };
-//# sourceMappingURL=Stringable.d.ts.map

package/script/dsl/constants.d.ts

@@ -27,4 +27,3 @@
  * ```
  */
 export declare const EMPTY = "__EMPTY__";
-//# sourceMappingURL=constants.d.ts.map

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

@@ -1,26 +1,20 @@
 import type { ModelProjection } from './types.js';
-import type { GenerateContextType } from '../../context/generateTypes.js';
+import type { GenerateContextType, InsertModelOptions } from '../../context/generateTypes.js';
 import type { ContentSettings } from '../ContentSettings.js';
 import type { GeneratedDefinition } from '../GeneratedValue.js';
 import type { GeneratedValue } from '../GeneratedValue.js';
 import type { RefName } from '../../types/RefName.js';
-type CreateModelArgs<V extends GeneratedValue, EnrichmentType> = {
+/**
+ * The `insertModel` call plus the context. The Driver defaults `variant`
+ * to `'main'` and `noExport` to `false`, and reads the caller's options
+ * once for the identity statics and the constructor.
+ */
+type CreateModelArgs<V extends GeneratedValue, EnrichmentType, ProjectionOptions> = {
     context: GenerateContextType;
-    projection: ModelProjection<V, EnrichmentType>;
+    projection: ModelProjection<V, EnrichmentType, ProjectionOptions>;
     refName: RefName;
-    destinationPath?: string;
     rootRef?: RefName;
-    noExport?: boolean;
-    /**
-     * Target variant of the projection. The Driver resolves the
-     * peer's enrichment for this variant, asserts the variant exists
-     * (or is the default `'main'` which is always permitted), and
-     * threads it into the projection's `ContentSettings`.
-     * Optional — omitting it means `'main'`, so variants-unaware
-     * callers keep working unchanged.
-     */
-    variant?: string;
-};
+} & InsertModelOptions<ProjectionOptions>;
 /**
  * Driver for the model insertion lifecycle.
  *
@@ -30,17 +24,19 @@ type CreateModelArgs<V extends GeneratedValue, EnrichmentType> = {
  * definition, and stitches an import into `destinationPath` if it differs
  * from the projection's `exportPath`.
  */
-export declare class ModelDriver<V extends GeneratedValue, EnrichmentType> {
+export declare class ModelDriver<V extends GeneratedValue, EnrichmentType, ProjectionOptions = undefined> {
     context: GenerateContextType;
-    projection: ModelProjection<V, EnrichmentType>;
+    projection: ModelProjection<V, EnrichmentType, ProjectionOptions>;
     refName: RefName;
     settings: ContentSettings<EnrichmentType>;
     destinationPath?: string;
     definition: GeneratedDefinition<V>;
     rootRef?: RefName;
-    noExport?: boolean;
+    noExport: boolean;
     variant: string;
-    constructor({ context, projection, refName, destinationPath, rootRef, noExport, variant }: CreateModelArgs<V, EnrichmentType>);
+    /** The caller's options, as passed to `insertModel`. */
+    options: ProjectionOptions;
+    constructor(args: CreateModelArgs<V, EnrichmentType, ProjectionOptions>);
     private apply;
     /**
      * Ensure the file at `path` exists, creating it on first write through
@@ -53,4 +49,3 @@ export declare class ModelDriver<V extends GeneratedValue, EnrichmentType> {
     private affirmDefinition;
 }
 export {};
-//# sourceMappingURL=ModelDriver.d.ts.map

package/script/dsl/model/ModelDriver.js

@@ -1,9 +1,14 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModelDriver = void 0;
 const normalize_js_1 = require("../../deps/jsr.io/@std/path/1.1.6/normalize.js");
 const GeneratorKeys_js_1 = require("../GeneratorKeys.js");
 const Variant_js_1 = require("../../types/Variant.js");
+const ProjectionOptions_js_1 = require("../../types/ProjectionOptions.js");
+const isEqual_js_1 = __importDefault(require("lodash-es/isEqual.js"));
 /**
  * Driver for the model insertion lifecycle.
  *
@@ -14,7 +19,7 @@ const Variant_js_1 = require("../../types/Variant.js");
  * from the projection's `exportPath`.
  */
 class ModelDriver {
-    constructor({ context, projection, refName, destinationPath, rootRef, noExport, variant = Variant_js_1.DEFAULT_VARIANT }) {
+    constructor(args) {
         Object.defineProperty(this, "context", {
             enumerable: true,
             configurable: true,
@@ -69,6 +74,14 @@ class ModelDriver {
             writable: true,
             value: void 0
         });
+        /** The caller's options, as passed to `insertModel`. */
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const { context, projection, refName, destinationPath, rootRef, noExport = false, variant = Variant_js_1.DEFAULT_VARIANT } = args;
         this.context = context;
         this.projection = projection;
         this.refName = refName;
@@ -76,6 +89,7 @@ class ModelDriver {
         this.rootRef = rootRef;
         this.noExport = noExport;
         this.variant = variant;
+        this.options = (0, ProjectionOptions_js_1.readProjectionOptions)(args);
         this.context.modelDepth[`${projection.id}:${refName}`] = 0;
         assertPeerVariantExists({
             context,
@@ -84,7 +98,12 @@ class ModelDriver {
             variant
         });
         assertPeerSupported({ context, projection, refName, variant });
-        this.settings = this.context.toModelContentSettings({ refName, projection, variant });
+        this.settings = this.context.toModelContentSettings({
+            refName,
+            projection,
+            variant,
+            options: this.options
+        });
         this.definition = this.apply({ destinationPath });
         this.context.modelDepth[`${projection.id}:${refName}`] = 0;
     }
@@ -130,7 +149,8 @@ class ModelDriver {
             context: this.context,
             settings: this.settings,
             destinationPath: this.settings.exportPath,
-            rootRef: this.rootRef
+            rootRef: this.rootRef,
+            options: this.options
         });
         const definition = this.projection.lang.toDefinition({
             context: this.context,
@@ -157,7 +177,16 @@ class ModelDriver {
         if (currentKey !== definition.generatorKey) {
             throw new Error(`Registered definition mismatch: '${definition.identifier.name}' in file '${exportPath}'. Cached key '${definition.generatorKey}' does not match new key '${currentKey}'`);
         }
-        return definition.value instanceof this.projection;
+        if (!(definition.value instanceof this.projection)) {
+            return false;
+        }
+        // Options are identity, like the variant, but cannot ride the key: a hit
+        // is checked against the options its value was built with.
+        const cachedOptions = (0, ProjectionOptions_js_1.toValueOptions)(definition.value);
+        if (!(0, isEqual_js_1.default)(cachedOptions, this.options)) {
+            throw new Error(`Registered definition mismatch: '${definition.identifier.name}' in file '${exportPath}'. Cached options ${JSON.stringify(cachedOptions)} do not match new options ${JSON.stringify(this.options)}. Fold options into toIdentifierName.`);
+        }
+        return true;
     }
 }
 exports.ModelDriver = ModelDriver;

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

@@ -88,4 +88,3 @@ export type ModelEntry<EnrichmentType = undefined> = {
  */
 export declare const toModelEntry: <EnrichmentType = undefined>({ id, transform, isSupported, supportsVariant, toPreviewModule, toEnrichmentSchema, toEnrichmentRequest, toEnrichmentDefaults }: ToModelEntryArgs<EnrichmentType>) => ModelEntry<EnrichmentType>;
 export {};
-//# sourceMappingURL=toModelEntry.d.ts.map

package/script/dsl/model/toModelProjectionBase.d.ts

@@ -1,5 +1,6 @@
-import type { GenerateContextType } from '../../context/generateTypes.js';
-import type { InsertModelOptions, InsertNormalizedModelArgs, InsertNormalizedModelReturn } from '../../context/generateTypes.js';
+import type { GenerateContextType, InsertNormalizedModelArgs, InsertNormalizedModelOptions, InsertNormalizedModelReturn } from '../../context/generateTypes.js';
+import { type ProjectionOptionsArg, type ProjectionOptionsRest } from '../../types/ProjectionOptions.js';
+import { type PeerInsertOptions } from '../../types/InsertOptions.js';
 import type { RefName } from '../../types/RefName.js';
 import type { ContentSettings } from '../ContentSettings.js';
 import type { LangSnippetConstructor } from '../Lang.js';
@@ -15,13 +16,13 @@ import type * as v from 'valibot';
  * Arguments accepted by classes generated via {@link toModelProjectionBase}.
  *
  * The factory injects `generatorKey` before delegating to the language
- * snippet base, so user code only supplies these three fields.
+ * snippet base, so user code only supplies these fields.
  */
-export type ModelProjectionArgs<EnrichmentType = undefined> = {
+export type ModelProjectionArgs<EnrichmentType = undefined, ProjectionOptions = undefined> = {
     context: GenerateContextType;
     settings: ContentSettings<EnrichmentType>;
     refName: RefName;
-};
+} & ProjectionOptionsArg<ProjectionOptions>;
 type ToEnrichmentsArgs = {
     refName: RefName;
     context: GenerateContextType;
@@ -36,11 +37,14 @@ type ToEnrichmentsArgs = {
  * (`ModelProjectionBaseConfig<E, KtIdentifierType>`) so `toIdentifierType`'s
  * return tightens to that language's `type` vocabulary — no recast. The
  * default keeps the loose `type: string` boundary.
+ *
+ * Generic over `ProjectionOptions`: the caller options this projection
+ * accepts, received by the identity statics and stored as `this.options`.
  */
-export type ModelProjectionBaseConfig<EnrichmentType = undefined, IdType extends IdentifierType = IdentifierType> = {
+export type ModelProjectionBaseConfig<EnrichmentType = undefined, IdType extends IdentifierType = IdentifierType, ProjectionOptions = undefined> = {
     id: string;
     /** Pure: the cache-key name (the cache-check path runs this). */
-    toIdentifierName: (args: ToModelIdentifierNameArgs<EnrichmentType>) => string;
+    toIdentifierName: (args: ToModelIdentifierNameArgs<EnrichmentType, ProjectionOptions>) => string;
     /**
      * Context-aware, overridable: the non-`name` parts of the identifier
      * (`type` / `typeName` / `exported`), derived from the schema. Runs only
@@ -49,7 +53,7 @@ export type ModelProjectionBaseConfig<EnrichmentType = undefined, IdType extends
      * `string` by default). The tightening rides the type argument.
      */
     toIdentifierType: (refName: RefName, context: GenerateContextType) => IdType;
-    toExportPath: (args: ToModelExportPathArgs<EnrichmentType>) => string;
+    toExportPath: (args: ToModelExportPathArgs<EnrichmentType, ProjectionOptions>) => string;
     /**
      * Required composite schema for the `{ subject, generator, stack }`
      * enrichment umbrella. Required (not optional) is load-bearing: it is what
@@ -96,21 +100,24 @@ export type ModelProjectionBaseConfig<EnrichmentType = undefined, IdType extends
  * The projection machinery previously hosted on `ModelProjectionBase` lives
  * here now, because the base class is no longer statically known.
  */
-export declare const toModelProjectionBase: <EnrichmentType = undefined, IdType extends IdentifierType = IdentifierType>(base: LangSnippetConstructor, config: ModelProjectionBaseConfig<EnrichmentType, IdType>) => {
-    new (args: ModelProjectionArgs<EnrichmentType>): {
+export declare const toModelProjectionBase: <EnrichmentType = undefined, IdType extends IdentifierType = IdentifierType, ProjectionOptions = undefined>(base: LangSnippetConstructor, config: ModelProjectionBaseConfig<EnrichmentType, IdType, ProjectionOptions>) => {
+    new (args: ModelProjectionArgs<EnrichmentType, ProjectionOptions>): {
         settings: ContentSettings<EnrichmentType>;
         refName: RefName;
+        /** The caller's options. */
+        options: ProjectionOptions;
         /**
          * Insert a related model and return its `Inserted` reference. The
          * inserted model is exported to this projection's own `exportPath`
-         * unless `noExport` is set.
+         * unless `noExport` is set. `{ options }` is required when the peer
+         * declares options and refused when it does not.
          */
-        insertModel<V extends GeneratedValue, PeerEnrichmentType = undefined>(projection: ModelProjection<V, PeerEnrichmentType>, refName: RefName, options?: Pick<InsertModelOptions, "noExport" | "variant">): Inserted<V, PeerEnrichmentType>;
+        insertModel<V extends GeneratedValue, PeerEnrichmentType = undefined, PeerProjectionOptions = undefined>(projection: ModelProjection<V, PeerEnrichmentType, PeerProjectionOptions>, refName: RefName, ...rest: ProjectionOptionsRest<PeerInsertOptions<PeerProjectionOptions>, PeerProjectionOptions>): Inserted<V, PeerEnrichmentType>;
         /**
          * Insert a related model with reference normalization. If `schema` is a
          * `$ref`, the referenced name is used; otherwise `fallbackName` applies.
          */
-        insertNormalizedModel<V extends GeneratedValue, Schema extends OasSchema | OasRef<"schema"> | OasVoid, PeerEnrichmentType_1 = undefined>(projection: NormalizedModelProjection<V, PeerEnrichmentType_1>, { schema, fallbackName }: Omit<InsertNormalizedModelArgs<Schema>, "destinationPath">, options?: Pick<InsertModelOptions, "noExport" | "variant">): InsertNormalizedModelReturn<V, Schema>;
+        insertNormalizedModel<V extends GeneratedValue, Schema extends OasSchema | OasRef<"schema"> | OasVoid, PeerEnrichmentType_1 = undefined, PeerProjectionOptions_1 = undefined>(projection: NormalizedModelProjection<V, PeerEnrichmentType_1, PeerProjectionOptions_1>, { schema, fallbackName }: Omit<InsertNormalizedModelArgs<Schema>, "destinationPath">, ...rest: ProjectionOptionsRest<InsertNormalizedModelOptions<PeerProjectionOptions_1>, PeerProjectionOptions_1>): InsertNormalizedModelReturn<V, Schema>;
         context: GenerateContextType;
         skipped: boolean;
         generatorKey: import("../GeneratorKeys.js").GeneratorKey | undefined;
@@ -118,9 +125,9 @@ export declare const toModelProjectionBase: <EnrichmentType = undefined, IdType
     };
     id: string;
     type: "model";
-    toIdentifierName: (args: ToModelIdentifierNameArgs<EnrichmentType>) => string;
+    toIdentifierName: (args: ToModelIdentifierNameArgs<EnrichmentType, ProjectionOptions>) => string;
     toIdentifierType: (refName: RefName, context: GenerateContextType) => IdType;
-    toExportPath: (args: ToModelExportPathArgs<EnrichmentType>) => string;
+    toExportPath: (args: ToModelExportPathArgs<EnrichmentType, ProjectionOptions>) => string;
     toEnrichments: ({ refName, context, variant }: ToEnrichmentsArgs) => EnrichmentType;
     /**
      * Derive the seed enrichment values for a model from its schema (the CMS
@@ -135,4 +142,3 @@ export declare const toModelProjectionBase: <EnrichmentType = undefined, IdType
     lang: import("../Lang.js").Lang;
 };
 export {};
-//# sourceMappingURL=toModelProjectionBase.d.ts.map