@skmtc/core 0.0.983 → 0.16.1

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

@@ -0,0 +1,151 @@
+import type { OasOperation } from '../../../oas/operation/Operation.js';
+import type { Lang } from '../../Lang.js';
+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 { EnrichmentRequest } from '../../../types/EnrichmentRequest.js';
+import type * as v from 'valibot';
+import type { MappingModule, PreviewModule } from '../../../types/Preview.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> = {
+    context: GenerateContextType;
+    settings: ContentSettings<EnrichmentType>;
+    operation: OasOperation;
+};
+export type TransformOasOperationArgs = {
+    context: GenerateContextType;
+    operation: OasOperation;
+    /**
+     * The operation variant the engine is dispatching for this call. The
+     * engine fans out one `transform` call per variant declared in the
+     * consumer's `enrichments[id][path][method]` block (or just `'main'`
+     * when no enrichments are configured). See {@link Variant}.
+     */
+    variant: string;
+};
+export type WithTransformOasOperation = {
+    transformOperation: (operation: OasOperation) => void;
+};
+export type IsSupportedOasOperationConfigArgs<EnrichmentType = undefined> = {
+    context: GenerateContextType;
+    operation: OasOperation;
+    enrichments: EnrichmentType;
+    /** Operation variant being probed (see {@link Variant}) */
+    variant: string;
+};
+export type IsSupportedOasOperationArgs = {
+    context: GenerateContextType;
+    operation: OasOperation;
+    /** Operation variant being probed (see {@link Variant}) */
+    variant: string;
+};
+export type ToOasOperationEnrichmentsArgs = {
+    operation: OasOperation;
+    context: GenerateContextType;
+    /** Operation variant whose enrichment should be resolved (see {@link Variant}) */
+    variant: string;
+};
+export type ToOasOperationPreviewModuleArgs = {
+    context: GenerateContextType;
+    operation: OasOperation;
+    /** Operation variant the preview module describes (see {@link Variant}) */
+    variant: string;
+};
+export type ToOasOperationMappingArgs = {
+    context: GenerateContextType;
+    operation: OasOperation;
+    /** Operation variant the mapping module describes (see {@link Variant}) */
+    variant: string;
+};
+/**
+ * Arguments for an OAS operation projection's `toIdentifierName` — the
+ * pure, cache-key-source half of the old `toIdentifier`.
+ */
+export type ToOasOperationIdentifierNameArgs<EnrichmentType = undefined> = {
+    operation: OasOperation;
+    enrichments: EnrichmentType;
+    /** Operation variant the identifier should disambiguate (see {@link Variant}) */
+    variant: string;
+};
+export type ToOasOperationExportPathArgs<EnrichmentType = undefined> = {
+    operation: OasOperation;
+    enrichments: EnrichmentType;
+    /** Operation variant the export path should disambiguate (see {@link Variant}) */
+    variant: string;
+};
+/**
+ * Static structural type of an OAS operation projection class.
+ *
+ * Captures both the instance side (`new(...) => V`) and the static side
+ * (`id`, `toIdentifierName`, `toIdentifierType`, `toExportPath`,
+ * `toEnrichments`). Passed as a type parameter to
+ * `context.insertOperation(...)`.
+ */
+export type OasOperationProjection<V extends GeneratedValue, EnrichmentType = undefined> = {
+    prototype: V;
+} & {
+    new ({ context, settings, operation }: OasOperationProjectionConstructorArgs<EnrichmentType>): V;
+    id: string;
+    type: 'oasOperation';
+    /**
+     * The projection's language — the static inherited from the language
+     * snippet base the projection class is built on
+     * (`toOasOperationProjectionBase(TsSnippet, …)`). Drivers read
+     * it ephemerally at each use site, pre-construction (cache-hit path).
+     */
+    lang: Lang;
+    /** Pure: the cache-key name. */
+    toIdentifierName: (args: ToOasOperationIdentifierNameArgs<EnrichmentType>) => string;
+    /**
+     * Context-aware, overridable: the non-`name` parts of the identifier,
+     * derived from the operation/schema. The engine assembles
+     * `lang.toIdentifier({ name: toIdentifierName(args),
+     * ...toIdentifierType(operation, context) })`.
+     */
+    toIdentifierType: (operation: OasOperation, context: GenerateContextType) => IdentifierType;
+    toExportPath: (args: ToOasOperationExportPathArgs<EnrichmentType>) => string;
+    toEnrichments: ({ operation, context }: ToOasOperationEnrichmentsArgs) => EnrichmentType;
+    /**
+     * Family-level capability predicate, surfaced as a static by
+     * `toOasOperationProjectionBase` (default `() => true`). The Driver
+     * probes it on every `insertOperation` so a peer is never handed an
+     * operation it has declared unsupported. Optional: a hand-rolled
+     * projection may omit it, in which case it is treated as supporting
+     * every operation.
+     */
+    isSupported?: (args: {
+        operation: OasOperation;
+        context: GenerateContextType;
+    }) => boolean;
+} & Function;
+/**
+ * Pipeline-side configuration for an OAS operation projection (built by
+ * `toOasOperationEntry`).
+ */
+export type OasOperationConfig<EnrichmentType = undefined> = {
+    id: string;
+    type: 'oasOperation';
+    transform: ({ context, operation, variant }: TransformOasOperationArgs) => void;
+    toEnrichmentSchema: () => v.GenericSchema<EnrichmentType>;
+    isSupported: ({ context, operation }: IsSupportedOasOperationArgs) => boolean;
+    /**
+     * Optional: compute the DEFAULT enrichment values for an operation from its
+     * schema — the seed the CMS persists and the user then edits. The pipeline
+     * counterpart of the projection base's static of the same name: a generator
+     * wires this on the entry (typically forwarding `MyProjection.toEnrichmentDefaults`)
+     * so the seeding pass can reach it from the generator-config map without the
+     * projection class. Returns the `{ subject, generator, stack }` umbrella, or
+     * `undefined` when the generator advertises no defaults.
+     */
+    toEnrichmentDefaults?: ({ operation, context, variant }: ToOasOperationEnrichmentsArgs) => EnrichmentType | undefined;
+    toPreviewModule?: ({ context, operation }: ToOasOperationPreviewModuleArgs) => PreviewModule;
+    toMappingModule?: ({ context, operation }: ToOasOperationMappingArgs) => MappingModule;
+    toEnrichmentRequest?: <RequestedEnrichment extends EnrichmentType>(operation: OasOperation) => EnrichmentRequest<RequestedEnrichment> | undefined;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/dsl/operation/oas/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAA;AACvE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC/D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAA;AAC5E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAA;AAC5E,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AACjC,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAE7E;;;;;GAKG;AACH,MAAM,MAAM,qCAAqC,CAAC,cAAc,GAAG,SAAS,IAAI;IAC9E,OAAO,EAAE,mBAAmB,CAAA;IAC5B,QAAQ,EAAE,eAAe,CAAC,cAAc,CAAC,CAAA;IACzC,SAAS,EAAE,YAAY,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG;IACtC,OAAO,EAAE,mBAAmB,CAAA;IAC5B,SAAS,EAAE,YAAY,CAAA;IACvB;;;;;OAKG;IACH,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG;IACtC,kBAAkB,EAAE,CAAC,SAAS,EAAE,YAAY,KAAK,IAAI,CAAA;CACtD,CAAA;AAED,MAAM,MAAM,iCAAiC,CAAC,cAAc,GAAG,SAAS,IAAI;IAC1E,OAAO,EAAE,mBAAmB,CAAA;IAC5B,SAAS,EAAE,YAAY,CAAA;IACvB,WAAW,EAAE,cAAc,CAAA;IAC3B,2DAA2D;IAC3D,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,OAAO,EAAE,mBAAmB,CAAA;IAC5B,SAAS,EAAE,YAAY,CAAA;IACvB,2DAA2D;IAC3D,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,6BAA6B,GAAG;IAC1C,SAAS,EAAE,YAAY,CAAA;IACvB,OAAO,EAAE,mBAAmB,CAAA;IAC5B,kFAAkF;IAClF,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,+BAA+B,GAAG;IAC5C,OAAO,EAAE,mBAAmB,CAAA;IAC5B,SAAS,EAAE,YAAY,CAAA;IACvB,2EAA2E;IAC3E,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG;IACtC,OAAO,EAAE,mBAAmB,CAAA;IAC5B,SAAS,EAAE,YAAY,CAAA;IACvB,2EAA2E;IAC3E,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,gCAAgC,CAAC,cAAc,GAAG,SAAS,IAAI;IACzE,SAAS,EAAE,YAAY,CAAA;IACvB,WAAW,EAAE,cAAc,CAAA;IAC3B,iFAAiF;IACjF,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,4BAA4B,CAAC,cAAc,GAAG,SAAS,IAAI;IACrE,SAAS,EAAE,YAAY,CAAA;IACvB,WAAW,EAAE,cAAc,CAAA;IAC3B,kFAAkF;IAClF,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,sBAAsB,CAAC,CAAC,SAAS,cAAc,EAAE,cAAc,GAAG,SAAS,IAAI;IACzF,SAAS,EAAE,CAAC,CAAA;CACb,GAAG;IACF,KAAK,EACH,OAAO,EACP,QAAQ,EACR,SAAS,EACV,EAAE,qCAAqC,CAAC,cAAc,CAAC,GAAG,CAAC,CAAA;IAC5D,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,cAAc,CAAA;IACpB;;;;;OAKG;IACH,IAAI,EAAE,IAAI,CAAA;IACV,gCAAgC;IAChC,gBAAgB,EAAE,CAAC,IAAI,EAAE,gCAAgC,CAAC,cAAc,CAAC,KAAK,MAAM,CAAA;IACpF;;;;;OAKG;IACH,gBAAgB,EAAE,CAAC,SAAS,EAAE,YAAY,EAAE,OAAO,EAAE,mBAAmB,KAAK,cAAc,CAAA;IAC3F,YAAY,EAAE,CAAC,IAAI,EAAE,4BAA4B,CAAC,cAAc,CAAC,KAAK,MAAM,CAAA;IAC5E,aAAa,EAAE,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,6BAA6B,KAAK,cAAc,CAAA;IACxF;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,SAAS,EAAE,YAAY,CAAC;QAAC,OAAO,EAAE,mBAAmB,CAAA;KAAE,KAAK,OAAO,CAAA;CAE3F,GAAG,QAAQ,CAAA;AAEZ;;;GAGG;AACH,MAAM,MAAM,kBAAkB,CAAC,cAAc,GAAG,SAAS,IAAI;IAC3D,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,cAAc,CAAA;IACpB,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,yBAAyB,KAAK,IAAI,CAAA;IAC/E,kBAAkB,EAAE,MAAM,CAAC,CAAC,aAAa,CAAC,cAAc,CAAC,CAAA;IACzD,WAAW,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,2BAA2B,KAAK,OAAO,CAAA;IAC7E;;;;;;;;OAQG;IACH,oBAAoB,CAAC,EAAE,CAAC,EACtB,SAAS,EACT,OAAO,EACP,OAAO,EACR,EAAE,6BAA6B,KAAK,cAAc,GAAG,SAAS,CAAA;IAC/D,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,+BAA+B,KAAK,aAAa,CAAA;IAC5F,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,yBAAyB,KAAK,aAAa,CAAA;IACtF,mBAAmB,CAAC,EAAE,CAAC,mBAAmB,SAAS,cAAc,EAC/D,SAAS,EAAE,YAAY,KACpB,iBAAiB,CAAC,mBAAmB,CAAC,GAAG,SAAS,CAAA;CACxD,CAAA"}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,50 @@
+import type { WebhookProjection } from './types.js';
+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> = {
+    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`.
+     */
+    variant: string;
+};
+/**
+ * Driver for the webhook insertion lifecycle.
+ *
+ * Sibling of `OasOperationDriver`. Resolves the projection's identifier and
+ * export path, looks up an existing `Definition` in the target file,
+ * instantiates the projection (constructing its value) when no cache hit
+ * 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> {
+    context: GenerateContextType;
+    projection: WebhookProjection<V, EnrichmentType>;
+    webhook: OasWebhook;
+    settings: ContentSettings<EnrichmentType>;
+    destinationPath?: string;
+    definition: GeneratedDefinition<V>;
+    noExport?: boolean;
+    variant: string;
+    constructor({ context, projection, webhook, destinationPath, noExport, variant }: CreateWebhookArgs<V, EnrichmentType>);
+    private apply;
+    /**
+     * Ensure the file at `path` exists, creating it on first write through the
+     * projection's language. Returns the normalized path.
+     */
+    private ensureFile;
+    private getDefinition;
+    private affirmDefinition;
+}
+export {};
+//# sourceMappingURL=WebhookDriver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WebhookDriver.d.ts","sourceRoot":"","sources":["../../../src/dsl/webhook/WebhookDriver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAA;AAC9D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAI5D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAA;AAKzE,KAAK,iBAAiB,CAAC,CAAC,SAAS,cAAc,EAAE,cAAc,GAAG,SAAS,IAAI;IAC7E,OAAO,EAAE,mBAAmB,CAAA;IAC5B,UAAU,EAAE,iBAAiB,CAAC,CAAC,EAAE,cAAc,CAAC,CAAA;IAChD,OAAO,EAAE,UAAU,CAAA;IACnB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB;;;;;OAKG;IACH,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAWD;;;;;;;;GAQG;AACH,qBAAa,aAAa,CAAC,CAAC,SAAS,cAAc,EAAE,cAAc,GAAG,SAAS;IAC7E,OAAO,EAAE,mBAAmB,CAAA;IAC5B,UAAU,EAAE,iBAAiB,CAAC,CAAC,EAAE,cAAc,CAAC,CAAA;IAChD,OAAO,EAAE,UAAU,CAAA;IACnB,QAAQ,EAAE,eAAe,CAAC,cAAc,CAAC,CAAA;IACzC,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,UAAU,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAA;IAClC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;gBAEH,EACV,OAAO,EACP,UAAU,EACV,OAAO,EACP,eAAe,EACf,QAAQ,EACR,OAAO,EACR,EAAE,iBAAiB,CAAC,CAAC,EAAE,cAAc,CAAC;IA0BvC,OAAO,CAAC,KAAK;IAiBb;;;OAGG;IACH,OAAO,CAAC,UAAU;IAYlB,OAAO,CAAC,aAAa;IAgCrB,OAAO,CAAC,gBAAgB;CAsBzB"}

package/script/dsl/webhook/WebhookDriver.js

@@ -0,0 +1,197 @@
+"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.4/normalize.js");
+const GeneratorKeys_js_1 = require("../GeneratorKeys.js");
+const Variant_js_1 = require("../../types/Variant.js");
+const get_js_1 = __importDefault(require("lodash-es/get.js"));
+/**
+ * Driver for the webhook insertion lifecycle.
+ *
+ * Sibling of `OasOperationDriver`. Resolves the projection's identifier and
+ * export path, looks up an existing `Definition` in the target file,
+ * instantiates the projection (constructing its value) when no cache hit
+ * exists, registers the new definition, and stitches an import into
+ * `destinationPath` if it differs from the projection's `exportPath`.
+ */
+class WebhookDriver {
+    constructor({ context, projection, webhook, destinationPath, noExport, variant }) {
+        Object.defineProperty(this, "context", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "projection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "webhook", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "settings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "destinationPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "definition", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "noExport", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "variant", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.context = context;
+        this.projection = projection;
+        this.webhook = webhook;
+        this.destinationPath = destinationPath;
+        this.noExport = noExport;
+        this.variant = variant;
+        assertPeerVariantExists({
+            context,
+            generatorId: projection.id,
+            webhook,
+            variant
+        });
+        assertPeerSupported({ context, projection, webhook });
+        this.settings = this.context.toWebhookContentSettings({
+            webhook,
+            projection,
+            variant
+        });
+        this.definition = this.apply({ destinationPath });
+    }
+    apply({ destinationPath } = {}) {
+        const { identifier, exportPath } = this.settings;
+        const definition = this.getDefinition({ identifier, exportPath });
+        if (destinationPath && (0, normalize_js_1.normalize)(exportPath) !== (0, normalize_js_1.normalize)(destinationPath)) {
+            // Cross-file import of the peer's identifier from its export path.
+            this.ensureFile(destinationPath);
+            this.context.register({
+                imports: [this.projection.lang.toImport({ identifier, module: exportPath })],
+                destinationPath
+            });
+        }
+        return definition;
+    }
+    /**
+     * Ensure the file at `path` exists, creating it on first write through the
+     * projection's language. Returns the normalized path.
+     */
+    ensureFile(path) {
+        const normalizedPath = (0, normalize_js_1.normalize)(path);
+        if (!this.context.getFile(normalizedPath)) {
+            this.context.addFile(this.projection.lang.createFile({ path: normalizedPath, settings: this.context.settings }));
+        }
+        return normalizedPath;
+    }
+    getDefinition({ identifier, exportPath }) {
+        const cachedDefinition = this.context.findDefinition({
+            name: identifier.name,
+            exportPath
+        });
+        if (this.affirmDefinition(cachedDefinition, exportPath)) {
+            return cachedDefinition;
+        }
+        const value = new this.projection({
+            context: this.context,
+            webhook: this.webhook,
+            settings: this.settings
+        });
+        const definition = this.projection.lang.toDefinition({
+            context: this.context,
+            identifier,
+            value,
+            noExport: this.noExport
+        });
+        this.ensureFile(exportPath);
+        this.context.register({
+            definitions: [definition],
+            destinationPath: exportPath
+        });
+        return definition;
+    }
+    affirmDefinition(definition, exportPath) {
+        if (!definition) {
+            return false;
+        }
+        const currentKey = (0, GeneratorKeys_js_1.toWebhookGeneratorKey)({
+            generatorId: this.projection.id,
+            webhook: this.webhook,
+            variant: this.settings.variant
+        });
+        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;
+    }
+}
+exports.WebhookDriver = WebhookDriver;
+/**
+ * Guard the peer-variant-mismatch invariant (sibling of the operation
+ * Driver's). `'main'` is universally safe; any other variant must be
+ * declared in the peer's enrichment block at `[generatorId][name][method]`.
+ */
+const assertPeerVariantExists = ({ context, generatorId, webhook, variant }) => {
+    if (variant === Variant_js_1.DEFAULT_VARIANT) {
+        return;
+    }
+    const webhookEnrichments = (0, get_js_1.default)(context.settings, ['enrichments', generatorId, webhook.name, webhook.method]);
+    const webhookLabel = `webhook '${webhook.name}' (${webhook.method.toUpperCase()})`;
+    if (webhookEnrichments === null || webhookEnrichments === undefined) {
+        throw new Error(`[${generatorId}] Cannot insert variant '${variant}' for ${webhookLabel} — ` +
+            `peer has no enrichments configured. Only '${Variant_js_1.DEFAULT_VARIANT}' is permitted.`);
+    }
+    if (typeof webhookEnrichments !== 'object' || Array.isArray(webhookEnrichments)) {
+        throw new Error(`[${generatorId}] Cannot insert variant '${variant}' for ${webhookLabel} — ` +
+            `peer enrichment is not a variant record.`);
+    }
+    if (!(variant in webhookEnrichments)) {
+        const available = Object.keys(webhookEnrichments).join(', ');
+        throw new Error(`[${generatorId}] Cannot insert variant '${variant}' for ${webhookLabel}. ` +
+            `Available variants: ${available}.`);
+    }
+};
+/**
+ * Guard the peer-capability invariant (sibling of the operation Driver's).
+ * A peer that declares a webhook unsupported throws here; the throw unwinds
+ * into `GenerateContext`'s per-item `try/catch`, recording the calling
+ * generator's item as `error` while the run continues. A peer with no static
+ * `isSupported` supports every webhook.
+ */
+const assertPeerSupported = ({ context, projection, webhook }) => {
+    if (typeof projection.isSupported !== 'function') {
+        return;
+    }
+    if (!projection.isSupported({ webhook, context })) {
+        const webhookLabel = `webhook '${webhook.name}' (${webhook.method.toUpperCase()})`;
+        throw new Error(`[${projection.id}] Cannot insert ${webhookLabel} — peer generator ` +
+            `does not support this webhook (isSupported returned false).`);
+    }
+};

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

@@ -0,0 +1,58 @@
+import * as v from 'valibot';
+import type { OasWebhook } from '../../oas/webhook/Webhook.js';
+import type { EnrichmentRequest } from '../../types/EnrichmentRequest.js';
+import type { IsSupportedWebhookArgs, ToWebhookPreviewModuleArgs, ToWebhookMappingArgs, ToWebhookEnrichmentsArgs, TransformWebhookArgs, IsSupportedWebhookConfigArgs } from './types.js';
+import type { MappingModule, PreviewModule } from '../../types/Preview.js';
+/**
+ * Configuration arguments for creating webhook generator entries.
+ *
+ * Mirrors {@link ToOasOperationConfigArgs} for the 3.1 webhook subject —
+ * the field that varies is `webhook` (an {@link OasWebhook}) in place of
+ * `operation`.
+ *
+ * @template EnrichmentType - Type of enrichment data this webhook can provide
+ */
+export type ToWebhookConfigArgs<EnrichmentType = undefined> = {
+    id: string;
+    transform: ({ context, webhook, variant }: TransformWebhookArgs) => void;
+    toEnrichmentSchema: () => v.GenericSchema<EnrichmentType>;
+    isSupported?: ({ context, webhook }: IsSupportedWebhookConfigArgs<EnrichmentType>) => boolean;
+    toPreviewModule?: ({ context, webhook }: ToWebhookPreviewModuleArgs) => PreviewModule;
+    toMappingModule?: ({ context, webhook }: ToWebhookMappingArgs) => MappingModule;
+    toEnrichmentRequest?: <RequestedEnrichment extends EnrichmentType>(webhook: OasWebhook) => EnrichmentRequest<RequestedEnrichment> | undefined;
+    toEnrichmentDefaults?: ({ webhook, context, variant }: ToWebhookEnrichmentsArgs) => EnrichmentType | undefined;
+};
+/**
+ * Creates a configured webhook generator entry.
+ *
+ * Sibling of {@link toOasOperationEntry} for the OpenAPI 3.1 webhook
+ * subject. Webhooks have inverted semantics (handler/receiver, not client
+ * call), so they are a distinct subject — never routed through an operation
+ * generator. The enrichment routing is `[id][name][method][variant]`,
+ * mirroring the operation `[id][path][method][variant]` with the webhook
+ * name in the `path` slot.
+ *
+ * @example Basic webhook entry
+ * ```typescript
+ * import { toWebhookEntry } from '@skmtc/core';
+ *
+ * const webhookEntry = toWebhookEntry({
+ *   id: 'webhook-handlers',
+ *   transform: ({ context, webhook }) => {
+ *     context.insertWebhook({ projection: MyHandler, webhook });
+ *   }
+ * });
+ * ```
+ */
+export declare const toWebhookEntry: <EnrichmentType = undefined>({ id, transform, toEnrichmentSchema, isSupported, toPreviewModule, toMappingModule, toEnrichmentRequest, toEnrichmentDefaults }: ToWebhookConfigArgs<EnrichmentType>) => {
+    id: string;
+    type: "webhook";
+    transform: ({ context, webhook, variant }: TransformWebhookArgs) => void;
+    toEnrichmentSchema: () => v.GenericSchema<EnrichmentType>;
+    isSupported: ({ context, webhook }: IsSupportedWebhookArgs) => boolean;
+    toPreviewModule?: ({ context, webhook }: ToWebhookPreviewModuleArgs) => PreviewModule;
+    toMappingModule?: ({ context, webhook }: ToWebhookMappingArgs) => MappingModule;
+    toEnrichmentRequest?: <RequestedEnrichment extends EnrichmentType>(webhook: OasWebhook) => EnrichmentRequest<RequestedEnrichment> | undefined;
+    toEnrichmentDefaults?: ({ webhook, context, variant }: ToWebhookEnrichmentsArgs) => EnrichmentType | undefined;
+};
+//# sourceMappingURL=toWebhookEntry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toWebhookEntry.d.ts","sourceRoot":"","sources":["../../../src/dsl/webhook/toWebhookEntry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAA;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAA;AACzE,OAAO,KAAK,EACV,sBAAsB,EACtB,0BAA0B,EAC1B,oBAAoB,EACpB,wBAAwB,EACxB,oBAAoB,EACpB,4BAA4B,EAC7B,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAK1E;;;;;;;;GAQG;AACH,MAAM,MAAM,mBAAmB,CAAC,cAAc,GAAG,SAAS,IAAI;IAC5D,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,oBAAoB,KAAK,IAAI,CAAA;IACxE,kBAAkB,EAAE,MAAM,CAAC,CAAC,aAAa,CAAC,cAAc,CAAC,CAAA;IACzD,WAAW,CAAC,EAAE,CAAC,EACb,OAAO,EACP,OAAO,EACR,EAAE,4BAA4B,CAAC,cAAc,CAAC,KAAK,OAAO,CAAA;IAC3D,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,0BAA0B,KAAK,aAAa,CAAA;IACrF,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,oBAAoB,KAAK,aAAa,CAAA;IAC/E,mBAAmB,CAAC,EAAE,CAAC,mBAAmB,SAAS,cAAc,EAC/D,OAAO,EAAE,UAAU,KAChB,iBAAiB,CAAC,mBAAmB,CAAC,GAAG,SAAS,CAAA;IACvD,oBAAoB,CAAC,EAAE,CAAC,EACtB,OAAO,EACP,OAAO,EACP,OAAO,EACR,EAAE,wBAAwB,KAAK,cAAc,GAAG,SAAS,CAAA;CAC3D,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,cAAc,GAAI,cAAc,GAAG,SAAS,EAAE,iIASxD,mBAAmB,CAAC,cAAc,CAAC,KAAG;IACvC,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,SAAS,CAAA;IACf,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,oBAAoB,KAAK,IAAI,CAAA;IACxE,kBAAkB,EAAE,MAAM,CAAC,CAAC,aAAa,CAAC,cAAc,CAAC,CAAA;IACzD,WAAW,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,sBAAsB,KAAK,OAAO,CAAA;IACtE,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,0BAA0B,KAAK,aAAa,CAAA;IACrF,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,oBAAoB,KAAK,aAAa,CAAA;IAC/E,mBAAmB,CAAC,EAAE,CAAC,mBAAmB,SAAS,cAAc,EAC/D,OAAO,EAAE,UAAU,KAChB,iBAAiB,CAAC,mBAAmB,CAAC,GAAG,SAAS,CAAA;IACvD,oBAAoB,CAAC,EAAE,CAAC,EACtB,OAAO,EACP,OAAO,EACP,OAAO,EACR,EAAE,wBAAwB,KAAK,cAAc,GAAG,SAAS,CAAA;CAyC3D,CAAA"}

package/script/dsl/webhook/toWebhookEntry.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toWebhookEntry = void 0;
+const v = __importStar(require("valibot"));
+const Enrichments_js_1 = require("../../types/Enrichments.js");
+const get_js_1 = __importDefault(require("lodash-es/get.js"));
+/**
+ * Creates a configured webhook generator entry.
+ *
+ * Sibling of {@link toOasOperationEntry} for the OpenAPI 3.1 webhook
+ * subject. Webhooks have inverted semantics (handler/receiver, not client
+ * call), so they are a distinct subject — never routed through an operation
+ * generator. The enrichment routing is `[id][name][method][variant]`,
+ * mirroring the operation `[id][path][method][variant]` with the webhook
+ * name in the `path` slot.
+ *
+ * @example Basic webhook entry
+ * ```typescript
+ * import { toWebhookEntry } from '@skmtc/core';
+ *
+ * const webhookEntry = toWebhookEntry({
+ *   id: 'webhook-handlers',
+ *   transform: ({ context, webhook }) => {
+ *     context.insertWebhook({ projection: MyHandler, webhook });
+ *   }
+ * });
+ * ```
+ */
+const toWebhookEntry = ({ id, transform, toEnrichmentSchema, isSupported, toPreviewModule, toMappingModule, toEnrichmentRequest, toEnrichmentDefaults }) => {
+    return {
+        id,
+        type: 'webhook',
+        transform,
+        toEnrichmentSchema,
+        isSupported: ({ context, webhook, variant }) => {
+            if (!isSupported) {
+                return true;
+            }
+            // Assemble the three-scope umbrella — mirrors
+            // `WebhookProjectionBase.toEnrichments` so the shim and the
+            // projection-base resolve to the same value. Subject is per-item
+            // (`[id][name][method][variant]`); generator and stack are
+            // run-constants. The required composite schema parses cast-free.
+            const raw = {
+                subject: (0, get_js_1.default)(context.settings, [
+                    'enrichments',
+                    id,
+                    webhook.name,
+                    webhook.method,
+                    variant
+                ]),
+                generator: (0, get_js_1.default)(context.settings, ['enrichments', id, Enrichments_js_1.GENERATOR_ENRICHMENT_KEY]),
+                stack: (0, get_js_1.default)(context.settings, ['enrichments', Enrichments_js_1.STACK_ENRICHMENT_KEY])
+            };
+            return isSupported({
+                context,
+                webhook,
+                enrichments: v.parse(toEnrichmentSchema(), raw),
+                variant
+            });
+        },
+        toPreviewModule,
+        toMappingModule,
+        toEnrichmentRequest,
+        toEnrichmentDefaults
+    };
+};
+exports.toWebhookEntry = toWebhookEntry;