@skmtc/core 0.28.5 → 0.28.6

package/script/dsl/operation/oas/toOasOperationProjectionBase.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toOasOperationProjectionBase = void 0;
 const GeneratorKeys_js_1 = require("../../GeneratorKeys.js");
+const ProjectionOptions_js_1 = require("../../../types/ProjectionOptions.js");
+const InsertOptions_js_1 = require("../../../types/InsertOptions.js");
 const Variant_js_1 = require("../../../types/Variant.js");
 const parseEnrichmentUmbrella_js_1 = require("../../../enrichments/parseEnrichmentUmbrella.js");
 /**
@@ -27,13 +29,31 @@ const parseEnrichmentUmbrella_js_1 = require("../../../enrichments/parseEnrichme
 const toOasOperationProjectionBase = (base, config) => {
     var _a;
     return _a = class extends base {
+            /**
+             * How this projection's key is computed — read by the Driver so it can
+             * check a cache hit without knowing whether it holds a subject's
+             * projection or a container.
+             *
+             * A method rather than a field, and reading `id` through `this`, for the
+             * same reason the container reads its group that way: a subclass
+             * overriding the generator id must change the key its values are stored
+             * under, not just what callers are told.
+             */
+            static toGeneratorKey({ operation, settings }) {
+                return (0, GeneratorKeys_js_1.toOasOperationGeneratorKey)({
+                    generatorId: this.id,
+                    operation,
+                    variant: settings.variant ?? Variant_js_1.DEFAULT_VARIANT
+                });
+            }
             constructor(args) {
                 super({
                     context: args.context,
-                    generatorKey: (0, GeneratorKeys_js_1.toOasOperationGeneratorKey)({
-                        generatorId: config.id,
+                    // `new.target` is the most-derived class, so a subclass override of
+                    // `id` reaches the key the value actually carries.
+                    generatorKey: new.target.toGeneratorKey({
                         operation: args.operation,
-                        variant: args.settings.variant ?? Variant_js_1.DEFAULT_VARIANT
+                        settings: args.settings
                     })
                 });
                 Object.defineProperty(this, "settings", {
@@ -48,39 +68,45 @@ const toOasOperationProjectionBase = (base, config) => {
                     writable: true,
                     value: void 0
                 });
+                /** The caller's options. */
+                Object.defineProperty(this, "options", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: void 0
+                });
                 this.operation = args.operation;
                 this.settings = args.settings;
+                this.options = (0, ProjectionOptions_js_1.readProjectionOptions)(args);
             }
             /**
              * Insert a related operation. The inserted operation is exported to this
              * projection's own `exportPath` unless `noExport` is set.
              *
-             * Pass `{ variant }` to target a specific variant on the peer (e.g.
-             * to thread `this.settings.variant` into a within-package sibling
-             * Projection that's also variants-aware). Omitting it defaults to
-             * the peer's `'main'` variant — the safe choice for variants-unaware
-             * peers and the standard pattern for cross-package composition.
+             * Pass `{ variant }` to target a specific variant on the peer; omitting
+             * it defaults to the peer's `'main'` variant. `{ options }` is required
+             * when the peer declares options and refused when it does not.
              */
-            insertOperation(projection, operation, options = {}) {
+            insertOperation(projection, operation, ...rest) {
                 return this.context.insertOperation({
                     projection,
                     operation,
                     destinationPath: this.settings.exportPath,
-                    noExport: options.noExport,
-                    variant: options.variant
+                    ...(0, InsertOptions_js_1.toPeerInsertOptions)(rest)
                 });
             }
             /**
              * Insert a related model into this projection's export file.
              *
              * Pass `{ variant }` to target a specific variant on the peer model
-             * projection. Omitting it defaults to the peer's `'main'` variant.
+             * projection; omitting it defaults to the peer's `'main'` variant.
+             * `{ options }` is required when the peer declares options and refused
+             * when it does not.
              */
-            insertModel(projection, refName, options = {}) {
+            insertModel(projection, refName, ...rest) {
                 return this.context.insertModel(projection, refName, {
-                    destinationPath: this.settings.exportPath,
-                    noExport: options.noExport,
-                    variant: options.variant
+                    ...(0, InsertOptions_js_1.toPeerInsertOptions)(rest),
+                    destinationPath: this.settings.exportPath
                 });
             }
             /**
@@ -88,18 +114,15 @@ const toOasOperationProjectionBase = (base, config) => {
              * request/response schemas where the schema may be either a `$ref` or a
              * concrete object.
              *
-             * `{ variant }` flows through the `$ref` branch only; for inline
-             * schemas, bake the variant into `fallbackName`.
+             * `{ variant }` and `{ options }` flow through the `$ref` branch only;
+             * for inline schemas, bake what distinguishes them into `fallbackName`.
              */
-            insertNormalizedModel(projection, { schema, fallbackName }, options = {}) {
+            insertNormalizedModel(projection, { schema, fallbackName }, ...rest) {
                 return this.context.insertNormalizedModel(projection, {
                     schema,
                     fallbackName,
                     destinationPath: this.settings.exportPath
-                }, {
-                    noExport: options.noExport,
-                    variant: options.variant
-                });
+                }, ...rest);
             }
         },
         Object.defineProperty(_a, "id", {
@@ -132,6 +155,12 @@ const toOasOperationProjectionBase = (base, config) => {
             writable: true,
             value: config.toExportPath.bind(config)
         }),
+        Object.defineProperty(_a, "toContainer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config.toContainer?.bind(config)
+        }),
         Object.defineProperty(_a, "isSupported", {
             enumerable: true,
             configurable: true,

package/script/dsl/operation/oas/types.d.ts

@@ -4,17 +4,20 @@ import type { ContentSettings } from '../../ContentSettings.js';
 import type { GenerateContextType } from '../../../context/generateTypes.js';
 import type { IdentifierType } from '../../IdentifierType.js';
 import type { GeneratedValue } from '../../GeneratedValue.js';
+import type { DefinitionContainer } from '../../DefinitionContainer.js';
+import type { GeneratorKey } from '../../GeneratorKeys.js';
+import type { ProjectionOptionsArg } from '../../../types/ProjectionOptions.js';
 /**
  * External constructor signature for an OAS operation projection class.
  *
  * The pipeline calls `new SomeProjection(args)` with this shape; the
  * runtime base class injects `generatorKey` before calling `super()`.
  */
-export type OasOperationProjectionConstructorArgs<EnrichmentType = undefined> = {
+export type OasOperationProjectionConstructorArgs<EnrichmentType = undefined, ProjectionOptions = undefined> = {
     context: GenerateContextType;
     settings: ContentSettings<EnrichmentType>;
     operation: OasOperation;
-};
+} & ProjectionOptionsArg<ProjectionOptions>;
 export type TransformOasOperationArgs = {
     context: GenerateContextType;
     operation: OasOperation;
@@ -54,20 +57,66 @@ export type ToOasOperationMappingArgs = {
     variant: string;
 };
 /**
- * Arguments for an OAS operation projection's `toIdentifierName` — the
- * pure, cache-key-source half of the old `toIdentifier`.
+ * Arguments for an OAS operation projection's `toIdentifierName`. Fold `options` into the name when the output
+ * depends on them: definitions are cached by name and export path.
  */
-export type ToOasOperationIdentifierNameArgs<EnrichmentType = undefined> = {
+export type ToOasOperationIdentifierNameArgs<EnrichmentType = undefined, ProjectionOptions = undefined> = {
     operation: OasOperation;
     enrichments: EnrichmentType;
     /** Operation variant the identifier should disambiguate (see {@link Variant}) */
     variant: string;
+} & ProjectionOptionsArg<ProjectionOptions>;
+/**
+ * Arguments for a projection's `toGeneratorKey` static. `settings` carries
+ * the identifier, enrichments and variant the key may be built from.
+ */
+export type ToGeneratorKeyArgs<EnrichmentType = undefined> = {
+    operation: OasOperation;
+    settings: ContentSettings<EnrichmentType>;
 };
-export type ToOasOperationExportPathArgs<EnrichmentType = undefined> = {
+/**
+ * Arguments for a container projection's `toGroupName` static — the same
+ * `(operation, enrichments, variant)` its identity siblings receive.
+ */
+export type ToOasOperationGroupNameArgs<EnrichmentType = undefined> = {
+    operation: OasOperation;
+    enrichments: EnrichmentType;
+    /** Variant the group belongs to (see {@link Variant}) */
+    variant: string;
+};
+/**
+ * Arguments for a member projection's `toContainer` static — the same
+ * `(operation, enrichments, variant)` its identity siblings receive, and run
+ * on the same cache-check path, so it must be pure and cheap.
+ */
+export type ToOasOperationContainerArgs<EnrichmentType = undefined, ProjectionOptions = undefined> = {
+    operation: OasOperation;
+    enrichments: EnrichmentType;
+    /** Variant the placement should disambiguate (see {@link Variant}) */
+    variant: string;
+} & ProjectionOptionsArg<ProjectionOptions>;
+export type ToOasOperationExportPathArgs<EnrichmentType = undefined, ProjectionOptions = undefined> = {
     operation: OasOperation;
     enrichments: EnrichmentType;
     /** Operation variant the export path should disambiguate (see {@link Variant}) */
     variant: string;
+} & ProjectionOptionsArg<ProjectionOptions>;
+/**
+ * Static structural type of a container projection class — a projection
+ * whose VALUE holds definitions.
+ *
+ * Nothing is declared: the constraint is the value's own type, so a
+ * projection whose value has no member store is not assignable here. That is
+ * the same contract a file satisfies
+ * ({@link import('@/dsl/DefinitionContainer.ts').DefinitionContainer}), which
+ * is what makes both of them places. A container takes no caller options:
+ * its identity is its group's, shared by every member.
+ */
+export type OasOperationContainerProjection<EnrichmentType = any> = OasOperationProjection<GeneratedValue & DefinitionContainer, EnrichmentType> & {
+    /** The group its members share — what its key is made of. */
+    toGroupName: (args: ToOasOperationGroupNameArgs<EnrichmentType>) => string;
+    /** Required here: a container is keyed on its group, never its subject. */
+    toGeneratorKey: (args: ToGeneratorKeyArgs<EnrichmentType>) => GeneratorKey;
 };
 /**
  * Static structural type of an OAS operation projection class.
@@ -75,12 +124,13 @@ export type ToOasOperationExportPathArgs<EnrichmentType = undefined> = {
  * Captures both the instance side (`new(...) => V`) and the static side
  * (`id`, `toIdentifierName`, `toIdentifierType`, `toExportPath`,
  * `toEnrichments`). Passed as a type parameter to
- * `context.insertOperation(...)`.
+ * `context.insertOperation(...)`. `ProjectionOptions` is the caller options
+ * the class declares; the Drivers infer it from the constructor and statics.
  */
-export type OasOperationProjection<V extends GeneratedValue, EnrichmentType = undefined> = {
+export type OasOperationProjection<V extends GeneratedValue, EnrichmentType = undefined, ProjectionOptions = undefined> = {
     prototype: V;
 } & {
-    new ({ context, settings, operation }: OasOperationProjectionConstructorArgs<EnrichmentType>): V;
+    new ({ context, settings, operation, options }: OasOperationProjectionConstructorArgs<EnrichmentType, ProjectionOptions>): V;
     id: string;
     type: 'oasOperation';
     /**
@@ -91,7 +141,7 @@ export type OasOperationProjection<V extends GeneratedValue, EnrichmentType = un
      */
     lang: Lang;
     /** Pure: the cache-key name. */
-    toIdentifierName: (args: ToOasOperationIdentifierNameArgs<EnrichmentType>) => string;
+    toIdentifierName: (args: ToOasOperationIdentifierNameArgs<EnrichmentType, ProjectionOptions>) => string;
     /**
      * Context-aware, overridable: the non-`name` parts of the identifier,
      * derived from the operation/schema. The engine assembles
@@ -99,7 +149,26 @@ export type OasOperationProjection<V extends GeneratedValue, EnrichmentType = un
      * ...toIdentifierType(operation, context) })`.
      */
     toIdentifierType: (operation: OasOperation, context: GenerateContextType) => IdentifierType;
-    toExportPath: (args: ToOasOperationExportPathArgs<EnrichmentType>) => string;
+    toExportPath: (args: ToOasOperationExportPathArgs<EnrichmentType, ProjectionOptions>) => string;
+    /**
+     * How this projection's key is computed. A subject's projection keys on
+     * its subject; a container keys on the group its members share. The Driver
+     * reads it rather than branching on which kind it holds.
+     *
+     * Optional, like {@link isSupported}: a hand-rolled projection may omit it
+     * and is keyed on its subject, which is what every projection did before
+     * containers existed.
+     */
+    toGeneratorKey?: (args: ToGeneratorKeyArgs<EnrichmentType>) => GeneratorKey;
+    /**
+     * The declaration this projection's definition is inserted into, rather
+     * than the file. Absent for a top-level definition — the common case.
+     *
+     * A member's file is its container's, so `toExportPath` is not consulted
+     * when this is present. A container takes no caller options: the member's
+     * options may select the container class, never parameterise it.
+     */
+    toContainer?: (args: ToOasOperationContainerArgs<EnrichmentType, ProjectionOptions>) => OasOperationContainerProjection;
     toEnrichments: ({ operation, context }: ToOasOperationEnrichmentsArgs) => EnrichmentType;
     /**
      * Family-level capability predicate, surfaced as a static by
@@ -111,4 +180,3 @@ export type OasOperationProjection<V extends GeneratedValue, EnrichmentType = un
      */
     isSupported?: (args: IsSupportedOasOperationArgs) => boolean;
 } & Function;
-//# sourceMappingURL=types.d.ts.map

package/script/dsl/webhook/WebhookDriver.d.ts

@@ -3,22 +3,14 @@ import type { OasWebhook } from '../../oas/webhook/Webhook.js';
 import type { ContentSettings } from '../ContentSettings.js';
 import type { GeneratedDefinition } from '../GeneratedValue.js';
 import type { GeneratedValue } from '../GeneratedValue.js';
-import type { GenerateContextType } from '../../context/generateTypes.js';
-type CreateWebhookArgs<V extends GeneratedValue, EnrichmentType = undefined> = {
+import type { GenerateContextType, InsertWebhookArgs } from '../../context/generateTypes.js';
+/**
+ * The `insertWebhook` 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 CreateWebhookArgs<V extends GeneratedValue, EnrichmentType = undefined, ProjectionOptions = undefined> = InsertWebhookArgs<V, EnrichmentType, ProjectionOptions> & {
     context: GenerateContextType;
-    projection: WebhookProjection<V, EnrichmentType>;
-    webhook: OasWebhook;
-    destinationPath?: string;
-    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;
 };
 /**
  * Driver for the webhook insertion lifecycle.
@@ -29,16 +21,18 @@ type CreateWebhookArgs<V extends GeneratedValue, EnrichmentType = undefined> = {
  * exists, registers the new definition, and stitches an import into
  * `destinationPath` if it differs from the projection's `exportPath`.
  */
-export declare class WebhookDriver<V extends GeneratedValue, EnrichmentType = undefined> {
+export declare class WebhookDriver<V extends GeneratedValue, EnrichmentType = undefined, ProjectionOptions = undefined> {
     context: GenerateContextType;
-    projection: WebhookProjection<V, EnrichmentType>;
+    projection: WebhookProjection<V, EnrichmentType, ProjectionOptions>;
     webhook: OasWebhook;
     settings: ContentSettings<EnrichmentType>;
     destinationPath?: string;
     definition: GeneratedDefinition<V>;
-    noExport?: boolean;
+    noExport: boolean;
     variant: string;
-    constructor({ context, projection, webhook, destinationPath, noExport, variant }: CreateWebhookArgs<V, EnrichmentType>);
+    /** The caller's options, as passed to `insertWebhook`. */
+    options: ProjectionOptions;
+    constructor(args: CreateWebhookArgs<V, EnrichmentType, ProjectionOptions>);
     private apply;
     /**
      * Ensure the file at `path` exists, creating it on first write through the
@@ -49,4 +43,3 @@ export declare class WebhookDriver<V extends GeneratedValue, EnrichmentType = un
     private affirmDefinition;
 }
 export {};
-//# sourceMappingURL=WebhookDriver.d.ts.map

package/script/dsl/webhook/WebhookDriver.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.WebhookDriver = 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 webhook insertion lifecycle.
  *
@@ -14,7 +19,7 @@ const Variant_js_1 = require("../../types/Variant.js");
  * `destinationPath` if it differs from the projection's `exportPath`.
  */
 class WebhookDriver {
-    constructor({ context, projection, webhook, destinationPath, noExport, variant = Variant_js_1.DEFAULT_VARIANT }) {
+    constructor(args) {
         Object.defineProperty(this, "context", {
             enumerable: true,
             configurable: true,
@@ -63,12 +68,21 @@ class WebhookDriver {
             writable: true,
             value: void 0
         });
+        /** The caller's options, as passed to `insertWebhook`. */
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const { context, projection, webhook, destinationPath, noExport = false, variant = Variant_js_1.DEFAULT_VARIANT } = args;
         this.context = context;
         this.projection = projection;
         this.webhook = webhook;
         this.destinationPath = destinationPath;
         this.noExport = noExport;
         this.variant = variant;
+        this.options = (0, ProjectionOptions_js_1.readProjectionOptions)(args);
         assertPeerVariantExists({
             context,
             generatorId: projection.id,
@@ -79,7 +93,8 @@ class WebhookDriver {
         this.settings = this.context.toWebhookContentSettings({
             webhook,
             projection,
-            variant
+            variant,
+            options: this.options
         });
         this.definition = this.apply({ destinationPath });
     }
@@ -118,7 +133,8 @@ class WebhookDriver {
         const value = new this.projection({
             context: this.context,
             webhook: this.webhook,
-            settings: this.settings
+            settings: this.settings,
+            options: this.options
         });
         const definition = this.projection.lang.toDefinition({
             context: this.context,
@@ -145,7 +161,16 @@ class WebhookDriver {
         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.WebhookDriver = WebhookDriver;

package/script/dsl/webhook/toWebhookEntry.d.ts

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

package/script/dsl/webhook/toWebhookProjectionBase.d.ts

@@ -1,5 +1,7 @@
 import type { GenerateContextType } from '../../context/generateTypes.js';
-import type { InsertOperationOptions, InsertModelOptions, InsertNormalizedModelArgs, InsertNormalizedModelReturn } from '../../context/generateTypes.js';
+import type { InsertNormalizedModelArgs, InsertNormalizedModelOptions, InsertNormalizedModelReturn } from '../../context/generateTypes.js';
+import { type ProjectionOptionsRest } from '../../types/ProjectionOptions.js';
+import { type PeerInsertOptions } from '../../types/InsertOptions.js';
 import type { OasWebhook } from '../../oas/webhook/Webhook.js';
 import type { OasOperation } from '../../oas/operation/Operation.js';
 import type { ContentSettings } from '../ContentSettings.js';
@@ -24,17 +26,17 @@ import type * as v from 'valibot';
  * (`WebhookProjectionBaseConfig<E, KtIdentifierType>`) so `toIdentifierType`'s
  * return tightens to that language's `type` vocabulary — no recast.
  */
-export type WebhookProjectionBaseConfig<EnrichmentType = undefined, IdType extends IdentifierType = IdentifierType> = {
+export type WebhookProjectionBaseConfig<EnrichmentType = undefined, IdType extends IdentifierType = IdentifierType, ProjectionOptions = undefined> = {
     id: string;
     /** Pure: the cache-key name (the cache-check path runs this). */
-    toIdentifierName: (args: ToWebhookIdentifierNameArgs<EnrichmentType>) => string;
+    toIdentifierName: (args: ToWebhookIdentifierNameArgs<EnrichmentType, ProjectionOptions>) => string;
     /**
      * Context-aware, overridable: the non-`name` parts of the identifier,
      * derived from the webhook. Runs only on cache-miss. Returns this
      * language's `XxIdentifierType` (`IdType`; the loose `type: string` by default).
      */
     toIdentifierType: (webhook: OasWebhook, context: GenerateContextType) => IdType;
-    toExportPath: (args: ToWebhookExportPathArgs<EnrichmentType>) => string;
+    toExportPath: (args: ToWebhookExportPathArgs<EnrichmentType, ProjectionOptions>) => string;
     /**
      * Required composite schema for the `{ subject, generator, stack }`
      * enrichment umbrella. Required (not optional) is load-bearing: it is what
@@ -78,27 +80,31 @@ type ToEnrichmentsArgs = {
  * Defines NO `register` / `registerInto` — those live in the language
  * package's projection-base veneer over this factory.
  */
-export declare const toWebhookProjectionBase: <EnrichmentType = undefined, IdType extends IdentifierType = IdentifierType>(base: LangSnippetConstructor, config: WebhookProjectionBaseConfig<EnrichmentType, IdType>) => {
-    new (args: WebhookProjectionConstructorArgs<EnrichmentType>): {
+export declare const toWebhookProjectionBase: <EnrichmentType = undefined, IdType extends IdentifierType = IdentifierType, ProjectionOptions = undefined>(base: LangSnippetConstructor, config: WebhookProjectionBaseConfig<EnrichmentType, IdType, ProjectionOptions>) => {
+    new (args: WebhookProjectionConstructorArgs<EnrichmentType, ProjectionOptions>): {
         settings: ContentSettings<EnrichmentType>;
         webhook: OasWebhook;
+        /** The caller's options. */
+        options: ProjectionOptions;
         /**
          * Insert a related operation (the operation-reference protocol — e.g. a
          * webhook handler that references a list endpoint). Exported to this
-         * projection's own `exportPath` unless `noExport` is set.
+         * projection's own `exportPath` unless `noExport` is set. `{ options }`
+         * is required when the peer declares options and refused when it does not.
          */
-        insertOperation<V extends GeneratedValue, PeerEnrichmentType = undefined>(projection: OasOperationProjection<V, PeerEnrichmentType>, operation: OasOperation, options?: Pick<InsertOperationOptions, "noExport" | "variant">): Inserted<V, PeerEnrichmentType>;
+        insertOperation<V extends GeneratedValue, PeerEnrichmentType = undefined, PeerProjectionOptions = undefined>(projection: OasOperationProjection<V, PeerEnrichmentType, PeerProjectionOptions>, operation: OasOperation, ...rest: ProjectionOptionsRest<PeerInsertOptions<PeerProjectionOptions>, PeerProjectionOptions>): Inserted<V, PeerEnrichmentType>;
         /**
          * Insert a related model into this projection's export file (e.g. the
-         * webhook's payload type).
+         * webhook's payload type). `{ options }` is required when the peer
+         * declares options and refused when it does not.
          */
-        insertModel<V extends GeneratedValue, PeerEnrichmentType_1 = undefined>(projection: ModelProjection<V, PeerEnrichmentType_1>, refName: RefName, options?: Pick<InsertModelOptions, "noExport" | "variant">): Inserted<V, PeerEnrichmentType_1>;
+        insertModel<V extends GeneratedValue, PeerEnrichmentType_1 = undefined, PeerProjectionOptions_1 = undefined>(projection: ModelProjection<V, PeerEnrichmentType_1, PeerProjectionOptions_1>, refName: RefName, ...rest: ProjectionOptionsRest<PeerInsertOptions<PeerProjectionOptions_1>, PeerProjectionOptions_1>): Inserted<V, PeerEnrichmentType_1>;
         /**
          * Insert a related model with reference normalization. Useful for inline
          * payload schemas where the schema may be either a `$ref` or a concrete
          * object.
          */
-        insertNormalizedModel<V extends GeneratedValue, Schema extends OasSchema | OasRef<"schema"> | OasVoid, PeerEnrichmentType_2 = undefined>(projection: NormalizedModelProjection<V, PeerEnrichmentType_2>, { 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_2 = undefined, PeerProjectionOptions_2 = undefined>(projection: NormalizedModelProjection<V, PeerEnrichmentType_2, PeerProjectionOptions_2>, { schema, fallbackName }: Omit<InsertNormalizedModelArgs<Schema>, "destinationPath">, ...rest: ProjectionOptionsRest<InsertNormalizedModelOptions<PeerProjectionOptions_2>, PeerProjectionOptions_2>): InsertNormalizedModelReturn<V, Schema>;
         context: GenerateContextType;
         skipped: boolean;
         generatorKey: import("../GeneratorKeys.js").GeneratorKey | undefined;
@@ -106,9 +112,9 @@ export declare const toWebhookProjectionBase: <EnrichmentType = undefined, IdTyp
     };
     id: string;
     type: "webhook";
-    toIdentifierName: (args: ToWebhookIdentifierNameArgs<EnrichmentType>) => string;
+    toIdentifierName: (args: ToWebhookIdentifierNameArgs<EnrichmentType, ProjectionOptions>) => string;
     toIdentifierType: (webhook: OasWebhook, context: GenerateContextType) => IdType;
-    toExportPath: (args: ToWebhookExportPathArgs<EnrichmentType>) => string;
+    toExportPath: (args: ToWebhookExportPathArgs<EnrichmentType, ProjectionOptions>) => string;
     isSupported: (args: {
         webhook: OasWebhook;
         context: GenerateContextType;
@@ -123,4 +129,3 @@ export declare const toWebhookProjectionBase: <EnrichmentType = undefined, IdTyp
     lang: import("../Lang.js").Lang;
 };
 export {};
-//# sourceMappingURL=toWebhookProjectionBase.d.ts.map

package/script/dsl/webhook/toWebhookProjectionBase.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toWebhookProjectionBase = void 0;
 const GeneratorKeys_js_1 = require("../GeneratorKeys.js");
+const ProjectionOptions_js_1 = require("../../types/ProjectionOptions.js");
+const InsertOptions_js_1 = require("../../types/InsertOptions.js");
 const Variant_js_1 = require("../../types/Variant.js");
 const parseEnrichmentUmbrella_js_1 = require("../../enrichments/parseEnrichmentUmbrella.js");
 /**
@@ -41,32 +43,40 @@ const toWebhookProjectionBase = (base, config) => {
                     writable: true,
                     value: void 0
                 });
+                /** The caller's options. */
+                Object.defineProperty(this, "options", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: void 0
+                });
                 this.webhook = args.webhook;
                 this.settings = args.settings;
+                this.options = (0, ProjectionOptions_js_1.readProjectionOptions)(args);
             }
             /**
              * Insert a related operation (the operation-reference protocol — e.g. a
              * webhook handler that references a list endpoint). Exported to this
-             * projection's own `exportPath` unless `noExport` is set.
+             * projection's own `exportPath` unless `noExport` is set. `{ options }`
+             * is required when the peer declares options and refused when it does not.
              */
-            insertOperation(projection, operation, options = {}) {
+            insertOperation(projection, operation, ...rest) {
                 return this.context.insertOperation({
                     projection,
                     operation,
                     destinationPath: this.settings.exportPath,
-                    noExport: options.noExport,
-                    variant: options.variant
+                    ...(0, InsertOptions_js_1.toPeerInsertOptions)(rest)
                 });
             }
             /**
              * Insert a related model into this projection's export file (e.g. the
-             * webhook's payload type).
+             * webhook's payload type). `{ options }` is required when the peer
+             * declares options and refused when it does not.
              */
-            insertModel(projection, refName, options = {}) {
+            insertModel(projection, refName, ...rest) {
                 return this.context.insertModel(projection, refName, {
-                    destinationPath: this.settings.exportPath,
-                    noExport: options.noExport,
-                    variant: options.variant
+                    ...(0, InsertOptions_js_1.toPeerInsertOptions)(rest),
+                    destinationPath: this.settings.exportPath
                 });
             }
             /**
@@ -74,15 +84,12 @@ const toWebhookProjectionBase = (base, config) => {
              * payload schemas where the schema may be either a `$ref` or a concrete
              * object.
              */
-            insertNormalizedModel(projection, { schema, fallbackName }, options = {}) {
+            insertNormalizedModel(projection, { schema, fallbackName }, ...rest) {
                 return this.context.insertNormalizedModel(projection, {
                     schema,
                     fallbackName,
                     destinationPath: this.settings.exportPath
-                }, {
-                    noExport: options.noExport,
-                    variant: options.variant
-                });
+                }, ...rest);
             }
         },
         Object.defineProperty(_a, "id", {