@skmtc/core 0.16.3 → 0.26.0

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

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

package/script/enrichments/toEnrichmentDescriptor.d.ts

@@ -1,15 +1,8 @@
-import * as v from 'valibot';
+import type * as v from 'valibot';
 /**
- * Widget kind for one enrichment field — the rendered control in the
- * enrichment-editor UI. Mirrors the `EnrichmentFieldKind` enum in the
- * skmtc-hub TypeSpec contract.
+ * Properties shared by every enrichment-field variant.
  */
-export type EnrichmentFieldKind = 'text' | 'textarea' | 'toggle' | 'select' | 'module' | 'accessorPath' | 'array' | 'object';
-/**
- * One node of a serialised enrichment-schema descriptor — the
- * form-renderable projection of a generator's enrichment schema.
- */
-export type EnrichmentField = {
+export type EnrichmentFieldBase = {
     /** Key written into the enrichment values object. */
     key: string;
     /** Human label, derived from the key when no metadata is supplied. */
@@ -17,22 +10,58 @@ export type EnrichmentField = {
     description?: string;
     /** Whether the schema marks this field optional. */
     optional: boolean;
-    kind: EnrichmentFieldKind;
-    /** Choices for a `select` field. */
-    options?: string[];
+};
+/**
+ * The variant-specific part of one enrichment field — the widget `type`
+ * discriminant plus exactly the payload that widget carries. Mirrors the
+ * `EnrichmentField` union in the skmtc-hub TypeSpec contract.
+ *
+ * There are deliberately NO standalone `module` / `schemaPath` widget
+ * types: a component reference is only meaningful WITH the path that gives
+ * it a type, so the pair is declared as one `moduleSelect` field. A
+ * generator that uses the raw `moduleExport` / `schemaPath` schemas
+ * standalone degrades to the generic object/array widgets.
+ */
+export type EnrichmentFieldShape = {
+    type: 'text';
+} | {
+    type: 'textarea';
+} | {
+    type: 'toggle';
+} | {
+    type: 'select';
+    /** The selectable choices. */
+    options: string[];
+} | {
+    type: 'moduleSelect';
     /**
-     * For `kind: 'array'` — a one-element list describing the item shape.
-     * If the item is an object, the synthesised field carries the nested
-     * `fields`; if it is a primitive, the synthesised field carries the
-     * appropriate primitive kind. The single-element convention matches
-     * the contract's `EnrichmentField[]` shape.
+     * The TS source of the contract a chosen module must satisfy for this
+     * field (a single `export type XModule<F> = …` the editor's matcher
+     * checks candidates against). Always present: the module type is
+     * explicit in the declaration (`lensInputModuleType` for the common
+     * lens/input case), never an editor-side default.
      */
-    item?: EnrichmentField[];
-    /** For `kind: 'object'` — the nested object's fields. */
-    fields?: EnrichmentField[];
+    moduleType: string;
+} | {
+    type: 'array';
+    /** Shape of each item. */
+    item: EnrichmentField;
+} | {
+    type: 'object';
+    /** The nested object's fields. */
+    fields: EnrichmentField[];
 };
-/** What a generator targets — operations or models. */
-export type TargetKind = 'operation' | 'model';
+/**
+ * One node of a serialised enrichment-schema descriptor — the
+ * form-renderable projection of a generator's enrichment schema,
+ * discriminated on `type`. Recursive: `array` fields carry a single
+ * `item` shape, `object` fields carry nested `fields`.
+ */
+export type EnrichmentField = EnrichmentFieldBase & EnrichmentFieldShape;
+/** The widget-type discriminant values of {@link EnrichmentField}. */
+export type EnrichmentFieldType = EnrichmentField['type'];
+/** Which subject type a generator enriches — operations, webhooks, or models. */
+export type SubjectType = 'operation' | 'model' | 'webhook';
 /**
  * A generator's enrichment schema, projected for the CMS. The same
  * descriptor is what an agent would drive — the form UI is one
@@ -40,7 +69,14 @@ export type TargetKind = 'operation' | 'model';
  */
 export type EnrichmentDescriptor = {
     generator: string;
-    appliesTo: TargetKind;
+    subjectType: SubjectType;
+    /**
+     * Whether this generator's entry declares variant support
+     * (`supportsVariant: () => true`). The CMS reads it to decide whether to
+     * offer the per-subject variant axis (add / rename / delete variants) above
+     * the subject scope; `false` when the entry omits it.
+     */
+    supportsVariant: boolean;
     fields: EnrichmentField[];
 };
 /**
@@ -54,6 +90,14 @@ export type EnrichmentSource = {
     readonly id: string;
     readonly type: 'oasOperation' | 'gqlOperation' | 'model' | 'webhook';
     readonly toEnrichmentSchema?: () => v.GenericSchema;
+    /**
+     * Whether the entry supports the variant axis. Required: every entry built by
+     * `toOasOperationEntry` / `toGqlOperationEntry` / `toModelEntry` has it,
+     * because the factory inserts a `() => false` default when the author omits
+     * it — so by the time an entry reaches the descriptor the function always
+     * exists.
+     */
+    readonly supportsVariant: () => boolean;
 };
 /**
  * Walk a Valibot object schema and return the projected list of
@@ -71,7 +115,7 @@ export type EnrichmentSource = {
  * umbrella yields `[]`.
  *
  * Generally callers should prefer {@link toEnrichmentDescriptor}, which
- * takes a generator entry and fills in `generator` / `appliesTo`
+ * takes a generator entry and fills in `generator` / `subjectType`
  * automatically. This lower-level entry point is useful in tests and
  * when only the field shape is needed.
  */
@@ -80,8 +124,9 @@ export declare const toEnrichmentFields: (schema: v.GenericSchema | undefined) =
  * Project a generator entry's enrichment schema into a serialisable
  * `EnrichmentDescriptor` the CMS can render as a form. The entry's
  * `id` becomes `descriptor.generator`; its `type` discriminator maps
- * to `appliesTo` (`'oasOperation' | 'gqlOperation'` → `'operation'`;
- * `'model'` → `'model'`). If the entry has no `toEnrichmentSchema`, or
+ * to `subjectType` (`'oasOperation' | 'gqlOperation'` → `'operation'`;
+ * `'webhook'` → `'webhook'`; `'model'` → `'model'`). If the entry has no
+ * `toEnrichmentSchema`, or
  * declares the empty umbrella, the descriptor has an empty `fields`
  * array — the UI hides the section, matching the engine's "no
  * enrichments" behaviour.

package/script/enrichments/toEnrichmentDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toEnrichmentDescriptor.d.ts","sourceRoot":"","sources":["../../src/enrichments/toEnrichmentDescriptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAI5B;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAC3B,MAAM,GACN,UAAU,GACV,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,cAAc,GACd,OAAO,GACP,QAAQ,CAAA;AAEZ;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,qDAAqD;IACrD,GAAG,EAAE,MAAM,CAAA;IACX,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,oDAAoD;IACpD,QAAQ,EAAE,OAAO,CAAA;IACjB,IAAI,EAAE,mBAAmB,CAAA;IACzB,oCAAoC;IACpC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,eAAe,EAAE,CAAA;IACxB,yDAAyD;IACzD,MAAM,CAAC,EAAE,eAAe,EAAE,CAAA;CAC3B,CAAA;AAED,uDAAuD;AACvD,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,OAAO,CAAA;AAE9C;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,UAAU,CAAA;IACrB,MAAM,EAAE,eAAe,EAAE,CAAA;CAC1B,CAAA;AAED;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG,cAAc,GAAG,OAAO,GAAG,SAAS,CAAA;IACpE,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC,CAAC,aAAa,CAAA;CACpD,CAAA;AAwHD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAQ,CAAC,CAAC,aAAa,GAAG,SAAS,KAAG,eAAe,EAKvF,CAAA;AAwBD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,sBAAsB,GAAI,OAAO,gBAAgB,KAAG,oBAI/D,CAAA"}
+{"version":3,"file":"toEnrichmentDescriptor.d.ts","sourceRoot":"","sources":["../../src/enrichments/toEnrichmentDescriptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AAGjC;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,qDAAqD;IACrD,GAAG,EAAE,MAAM,CAAA;IACX,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,oDAAoD;IACpD,QAAQ,EAAE,OAAO,CAAA;CAClB,CAAA;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,oBAAoB,GAC5B;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GACpB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IACA,IAAI,EAAE,QAAQ,CAAA;IACd,8BAA8B;IAC9B,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB,GACC;IACA,IAAI,EAAE,cAAc,CAAA;IACpB;;;;;;OAMG;IACH,UAAU,EAAE,MAAM,CAAA;CACnB,GACC;IACA,IAAI,EAAE,OAAO,CAAA;IACb,0BAA0B;IAC1B,IAAI,EAAE,eAAe,CAAA;CACtB,GACC;IACA,IAAI,EAAE,QAAQ,CAAA;IACd,kCAAkC;IAClC,MAAM,EAAE,eAAe,EAAE,CAAA;CAC1B,CAAA;AAEH;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,mBAAmB,GAAG,oBAAoB,CAAA;AAExE,sEAAsE;AACtE,MAAM,MAAM,mBAAmB,GAAG,eAAe,CAAC,MAAM,CAAC,CAAA;AAEzD,iFAAiF;AACjF,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,OAAO,GAAG,SAAS,CAAA;AAE3D;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,WAAW,CAAA;IACxB;;;;;OAKG;IACH,eAAe,EAAE,OAAO,CAAA;IACxB,MAAM,EAAE,eAAe,EAAE,CAAA;CAC1B,CAAA;AAED;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG,cAAc,GAAG,OAAO,GAAG,SAAS,CAAA;IACpE,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC,CAAC,aAAa,CAAA;IACnD;;;;;;OAMG;IACH,QAAQ,CAAC,eAAe,EAAE,MAAM,OAAO,CAAA;CACxC,CAAA;AAqJD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAQ,CAAC,CAAC,aAAa,GAAG,SAAS,KAAG,eAAe,EAKvF,CAAA;AAsBD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,sBAAsB,GAAI,OAAO,gBAAgB,KAAG,oBAK/D,CAAA"}

package/script/enrichments/toEnrichmentDescriptor.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toEnrichmentDescriptor = exports.toEnrichmentFields = void 0;
-const ModuleExport_js_1 = require("../types/ModuleExport.js");
-const AccessorPath_js_1 = require("../types/AccessorPath.js");
+const ModuleSelect_js_1 = require("../types/ModuleSelect.js");
 const isValibotSchema = (input) => typeof input === 'object' &&
     input !== null &&
     'type' in input &&
@@ -16,6 +15,30 @@ const unwrap = (schema) => {
     }
     return { inner: schema, optional: false };
 };
+/**
+ * A `v.pipe(base, …actions)` schema spreads `base` and adds a `pipe` array
+ * whose first element IS the original base schema. The `moduleSelect`
+ * registry lookup must therefore also check the pipe's base, or piping a
+ * moduleSelect through metadata (`v.title(…)`) would silently demote it to
+ * a generic object widget.
+ */
+const baseOf = (schema) => Array.isArray(schema.pipe) && isValibotSchema(schema.pipe[0]) ? schema.pipe[0] : schema;
+/** The `v.title(…)` metadata riding a piped schema, if any — the field label. */
+const titleOf = (schema) => {
+    if (!Array.isArray(schema.pipe))
+        return undefined;
+    for (const action of schema.pipe) {
+        if (typeof action === 'object' &&
+            action !== null &&
+            'type' in action &&
+            action.type === 'title' &&
+            'title' in action &&
+            typeof action.title === 'string') {
+            return action.title;
+        }
+    }
+    return undefined;
+};
 /**
  * Whether an object member should be omitted from the descriptor. A member
  * that unwraps to `v.undefined()` carries no payload — it is the canonical
@@ -33,48 +56,51 @@ const toLabel = (key) => {
     const spaced = key.replace(/([a-z0-9])([A-Z])/g, '$1 $2').replace(/[_-]+/g, ' ');
     return spaced.charAt(0).toUpperCase() + spaced.slice(1);
 };
-const kindFor = (schema) => {
-    if (isValibotSchema(ModuleExport_js_1.moduleExport) && schema === ModuleExport_js_1.moduleExport) {
-        return { kind: 'module' };
-    }
-    if (isValibotSchema(AccessorPath_js_1.accessorPath) && schema === AccessorPath_js_1.accessorPath) {
-        return { kind: 'accessorPath' };
+const typeFor = (schema) => {
+    const moduleType = (0, ModuleSelect_js_1.moduleTypeOf)(schema) ?? (0, ModuleSelect_js_1.moduleTypeOf)(baseOf(schema));
+    if (moduleType !== undefined) {
+        return { type: 'moduleSelect', moduleType };
     }
     switch (schema.type) {
         case 'string':
-            return { kind: 'text' };
+            return { type: 'text' };
         case 'boolean':
-            return { kind: 'toggle' };
+            return { type: 'toggle' };
         case 'number':
-            return { kind: 'text' };
+            return { type: 'text' };
         case 'picklist': {
             const opts = isOptionsArray(schema.options) ? schema.options.map(o => String(o)) : [];
-            return { kind: 'select', options: opts };
+            return { type: 'select', options: opts };
         }
         case 'object': {
             const entries = isEntriesRecord(schema.entries) ? schema.entries : {};
             return {
-                kind: 'object',
+                type: 'object',
                 fields: walkEntries(entries)
             };
         }
         case 'array': {
             if (isValibotSchema(schema.item)) {
-                return { kind: 'array', item: [walkFromShape('', schema.item)] };
+                return { type: 'array', item: walkFromShape('', schema.item) };
             }
-            return { kind: 'array', item: [] };
+            // An unrecognisable item schema degrades to a text item — consistent
+            // with the walker's default posture for unknown leaves.
+            return { type: 'array', item: { key: '', label: '', optional: false, type: 'text' } };
         }
         default:
-            return { kind: 'text' };
+            return { type: 'text' };
     }
 };
 const walkFromShape = (key, rawSchema) => {
     const { inner, optional } = unwrap(rawSchema);
-    return { key, label: toLabel(key), optional, ...kindFor(inner) };
+    // A `v.title(…)` label wins over the key-derived one; the title may ride
+    // the schema itself or sit inside an optional wrapper.
+    const label = titleOf(inner) ?? titleOf(rawSchema) ?? toLabel(key);
+    return { key, label, optional, ...typeFor(inner) };
 };
 const walkField = (key, rawSchema) => {
     if (!isValibotSchema(rawSchema)) {
-        return { key, label: toLabel(key), optional: false, kind: 'text' };
+        return { key, label: toLabel(key), optional: false, type: 'text' };
     }
     return walkFromShape(key, rawSchema);
 };
@@ -82,7 +108,7 @@ const walkField = (key, rawSchema) => {
  * Walk an object schema's `entries` into descriptor fields, omitting members
  * that carry no payload (see {@link isOmittedMember}). The single iteration
  * point shared by the top-level walk ({@link toEnrichmentFields}) and the
- * nested-object case in {@link kindFor}.
+ * nested-object case in {@link typeFor}.
  */
 const walkEntries = (entries) => Object.keys(entries)
     .filter(key => !isOmittedMember(entries[key]))
@@ -103,7 +129,7 @@ const walkEntries = (entries) => Object.keys(entries)
  * umbrella yields `[]`.
  *
  * Generally callers should prefer {@link toEnrichmentDescriptor}, which
- * takes a generator entry and fills in `generator` / `appliesTo`
+ * takes a generator entry and fills in `generator` / `subjectType`
  * automatically. This lower-level entry point is useful in tests and
  * when only the field shape is needed.
  */
@@ -116,21 +142,19 @@ const toEnrichmentFields = (schema) => {
     return walkEntries(inner.entries);
 };
 exports.toEnrichmentFields = toEnrichmentFields;
-const toAppliesTo = (entryType) => {
+const toSubjectType = (entryType) => {
     switch (entryType) {
         case 'model':
             return 'model';
         case 'oasOperation':
         case 'gqlOperation':
             return 'operation';
-        // STOPGAP: a webhook is operation-shaped (method + responses), so its
-        // enrichment editor reuses the 'operation' context for now. A dedicated
-        // 'webhook' TargetKind would be more truthful but ripples into the
-        // skmtc-hub TypeSpec contract that TargetKind/appliesTo mirror — deferred
-        // to a coordinated change. (Was an uncovered gap: WebhookConfig joined the
-        // GeneratorConfig union without a toAppliesTo arm.)
+        // A webhook resembles an operation (a path-item keyed by HTTP method) but
+        // is a DISTINCT subject: it is addressed by webhook name, not request path,
+        // and has no request URL. It is its own SubjectType so the editor and the
+        // hub treat it truthfully rather than conflating it with an operation.
         case 'webhook':
-            return 'operation';
+            return 'webhook';
         default: {
             const _exhaustive = entryType;
             throw new Error(`Unhandled generator entry type: ${String(_exhaustive)}`);
@@ -141,8 +165,9 @@ const toAppliesTo = (entryType) => {
  * Project a generator entry's enrichment schema into a serialisable
  * `EnrichmentDescriptor` the CMS can render as a form. The entry's
  * `id` becomes `descriptor.generator`; its `type` discriminator maps
- * to `appliesTo` (`'oasOperation' | 'gqlOperation'` → `'operation'`;
- * `'model'` → `'model'`). If the entry has no `toEnrichmentSchema`, or
+ * to `subjectType` (`'oasOperation' | 'gqlOperation'` → `'operation'`;
+ * `'webhook'` → `'webhook'`; `'model'` → `'model'`). If the entry has no
+ * `toEnrichmentSchema`, or
  * declares the empty umbrella, the descriptor has an empty `fields`
  * array — the UI hides the section, matching the engine's "no
  * enrichments" behaviour.
@@ -156,7 +181,8 @@ const toAppliesTo = (entryType) => {
  */
 const toEnrichmentDescriptor = (entry) => ({
     generator: entry.id,
-    appliesTo: toAppliesTo(entry.type),
+    subjectType: toSubjectType(entry.type),
+    supportsVariant: entry.supportsVariant(),
     fields: (0, exports.toEnrichmentFields)(entry.toEnrichmentSchema?.())
 });
 exports.toEnrichmentDescriptor = toEnrichmentDescriptor;

package/script/enrichments/validateConfig.d.ts

@@ -0,0 +1,60 @@
+import { type GeneratorEnrichments } from '../types/Enrichments.js';
+import type { EnrichmentSource } from './toEnrichmentDescriptor.js';
+/**
+ * Which of the three enrichment scopes a validation issue belongs to.
+ * Mirrors the `{ subject, generator, stack }` umbrella members.
+ */
+export type EnrichmentValidationScope = 'subject' | 'generator' | 'stack';
+/**
+ * One enrichment value that fails its generator's Valibot enrichment
+ * schema — the authoritative validation verdict. Produced by
+ * {@link validateConfig}; the routing fields locate the offending leaf in
+ * `client.json#settings.enrichments`:
+ *
+ *  - **operation subject** — `subject` = path, `method` = HTTP method
+ *  - **model subject** — `subject` = refName (no `method`)
+ *  - **gql operation subject** — `subject` = field name, `method` = root type
+ *  - **generator** run-constant — `scope: 'generator'` (no subject routing)
+ *  - **stack** run-constant — `scope: 'stack'` (no subject routing)
+ *
+ * `field` is the dotted path to the offending key *within* the leaf
+ * (absent when the whole leaf is the wrong shape).
+ */
+export type EnrichmentValidationIssue = {
+    generator: string;
+    scope: EnrichmentValidationScope;
+    subject?: string;
+    method?: string;
+    variant?: string;
+    field?: string;
+    message: string;
+};
+/**
+ * The single enrichment-validation authority. Validates every enrichment
+ * value in `enrichments` against its owning generator's Valibot enrichment
+ * schema (`toEnrichmentSchema`) — composed across the supplied generator
+ * `sources` — and returns the flat list of value errors. This is the same
+ * Valibot that the engine parses at generate time; `validateConfig` exposes
+ * it as a standalone, **documentless** check (no OpenAPI/SDL needed — only
+ * the values and the schemas), usable wherever a verdict is needed:
+ * pre-persist, CLI push, schema-drift migration, and the Publish gate.
+ *
+ * Scope of this check (value validity only):
+ *  - **catches** wrong-typed / missing-required / failed-refinement values
+ *    against the current schema, and a generator configured but absent from
+ *    the stack (`scope: 'generator'`, "not present in the stack").
+ *  - **does not** flag unknown *fields* — Valibot's `v.object` strips
+ *    unknown keys rather than erroring. Field-level referential drift ("this
+ *    key is no longer in the schema") is the descriptor referential check's
+ *    job, not this one.
+ *  - **does not** resolve subjects against a document — subject *existence*
+ *    (does this path/refName exist) needs the schema document and is the
+ *    caller's concern.
+ *
+ * `sources` mirrors {@link toEnrichmentDescriptor}'s input: pass
+ * `Object.values(toGeneratorConfigMap())`. The walk is decoupled from
+ * `GeneratorConfig` via {@link EnrichmentSource} so tests can pass plain
+ * entry-like objects.
+ */
+export declare const validateConfig: (enrichments: GeneratorEnrichments | undefined, sources: readonly EnrichmentSource[]) => EnrichmentValidationIssue[];
+//# sourceMappingURL=validateConfig.d.ts.map

package/script/enrichments/validateConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateConfig.d.ts","sourceRoot":"","sources":["../../src/enrichments/validateConfig.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,oBAAoB,EAC1B,MAAM,yBAAyB,CAAA;AAChC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAEnE;;;GAGG;AACH,MAAM,MAAM,yBAAyB,GAAG,SAAS,GAAG,WAAW,GAAG,OAAO,CAAA;AAEzE;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,yBAAyB,CAAA;IAChC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAkID;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,cAAc,GACzB,aAAa,oBAAoB,GAAG,SAAS,EAC7C,SAAS,SAAS,gBAAgB,EAAE,KACnC,yBAAyB,EA6C3B,CAAA"}

package/script/enrichments/validateConfig.js

@@ -0,0 +1,213 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfig = void 0;
+const v = __importStar(require("valibot"));
+const Enrichments_js_1 = require("../types/Enrichments.js");
+const isRecord = (input) => typeof input === 'object' && input !== null && !Array.isArray(input);
+const firstKey = (path) => path && path.length > 0 && path[0].key !== undefined ? String(path[0].key) : undefined;
+const fieldPath = (path) => path && path.length > 1
+    ? path
+        .slice(1)
+        .map(segment => String(segment.key))
+        .join('.')
+    : undefined;
+/**
+ * Collect every `{ subject, method?, variant, values }` leaf from a
+ * generator's enrichment slot, walking the routing depth its **type**
+ * dictates — model (`refName → variant`), oas operation
+ * (`path → method → variant`), gql operation
+ * (`rootKind → fieldName → variant`). Because the type is read from the
+ * generator entry, operation-vs-model is known authoritatively — there is
+ * no `'main' in value` shape-guessing. Reserved keys (`_generator`) are
+ * skipped; malformed nodes are skipped (they surface elsewhere, never here
+ * as a value error).
+ */
+const collectSubjectLeaves = (type, slot) => {
+    const leaves = [];
+    for (const [subjectKey, subjectValue] of Object.entries(slot)) {
+        if ((0, Enrichments_js_1.isReservedEnrichmentKey)(subjectKey))
+            continue;
+        if (!isRecord(subjectValue))
+            continue;
+        switch (type) {
+            case 'model': {
+                // refName → { variant: values }
+                for (const [variant, values] of Object.entries(subjectValue)) {
+                    leaves.push({ subject: subjectKey, variant, values });
+                }
+                break;
+            }
+            case 'oasOperation': {
+                // path → { method: { variant: values } }
+                for (const [method, variants] of Object.entries(subjectValue)) {
+                    if (!isRecord(variants))
+                        continue;
+                    for (const [variant, values] of Object.entries(variants)) {
+                        leaves.push({ subject: subjectKey, method, variant, values });
+                    }
+                }
+                break;
+            }
+            case 'webhook': {
+                // name → { method: { variant: values } }
+                for (const [method, variants] of Object.entries(subjectValue)) {
+                    if (!isRecord(variants))
+                        continue;
+                    for (const [variant, values] of Object.entries(variants)) {
+                        leaves.push({ subject: subjectKey, method, variant, values });
+                    }
+                }
+                break;
+            }
+            case 'gqlOperation': {
+                // rootKind → { fieldName: { variant: values } }
+                for (const [fieldName, variants] of Object.entries(subjectValue)) {
+                    if (!isRecord(variants))
+                        continue;
+                    for (const [variant, values] of Object.entries(variants)) {
+                        leaves.push({ subject: fieldName, method: subjectKey, variant, values });
+                    }
+                }
+                break;
+            }
+            default: {
+                const _exhaustive = type;
+                throw new Error(`Unhandled generator type: ${String(_exhaustive)}`);
+            }
+        }
+    }
+    return leaves;
+};
+/**
+ * Validate one scope's value against the generator's composite umbrella
+ * schema, reporting only issues that belong to that scope. The other two
+ * scopes are passed `undefined` and any issues they raise are filtered out,
+ * so each scope is validated in isolation without duplicating run-constant
+ * errors across every subject. Mirrors generate-time
+ * `v.parse(toEnrichmentSchema(), { subject, generator, stack })`, swapping
+ * `parse` for `safeParse` to collect rather than throw.
+ */
+const parseScope = (schema, scope, value, tag) => {
+    const raw = {
+        subject: undefined,
+        generator: undefined,
+        stack: undefined
+    };
+    raw[scope] = value;
+    const result = v.safeParse(schema, raw);
+    if (result.success)
+        return [];
+    return result.issues
+        .filter(issue => firstKey(issue.path) === scope)
+        .map(issue => {
+        const field = fieldPath(issue.path);
+        return {
+            ...tag,
+            scope,
+            ...(field !== undefined ? { field } : {}),
+            message: issue.message
+        };
+    });
+};
+/**
+ * The single enrichment-validation authority. Validates every enrichment
+ * value in `enrichments` against its owning generator's Valibot enrichment
+ * schema (`toEnrichmentSchema`) — composed across the supplied generator
+ * `sources` — and returns the flat list of value errors. This is the same
+ * Valibot that the engine parses at generate time; `validateConfig` exposes
+ * it as a standalone, **documentless** check (no OpenAPI/SDL needed — only
+ * the values and the schemas), usable wherever a verdict is needed:
+ * pre-persist, CLI push, schema-drift migration, and the Publish gate.
+ *
+ * Scope of this check (value validity only):
+ *  - **catches** wrong-typed / missing-required / failed-refinement values
+ *    against the current schema, and a generator configured but absent from
+ *    the stack (`scope: 'generator'`, "not present in the stack").
+ *  - **does not** flag unknown *fields* — Valibot's `v.object` strips
+ *    unknown keys rather than erroring. Field-level referential drift ("this
+ *    key is no longer in the schema") is the descriptor referential check's
+ *    job, not this one.
+ *  - **does not** resolve subjects against a document — subject *existence*
+ *    (does this path/refName exist) needs the schema document and is the
+ *    caller's concern.
+ *
+ * `sources` mirrors {@link toEnrichmentDescriptor}'s input: pass
+ * `Object.values(toGeneratorConfigMap())`. The walk is decoupled from
+ * `GeneratorConfig` via {@link EnrichmentSource} so tests can pass plain
+ * entry-like objects.
+ */
+const validateConfig = (enrichments, sources) => {
+    if (!isRecord(enrichments))
+        return [];
+    const sourceById = new Map(sources.map(source => [source.id, source]));
+    const stack = enrichments[Enrichments_js_1.STACK_ENRICHMENT_KEY];
+    const issues = [];
+    for (const [generatorId, slot] of Object.entries(enrichments)) {
+        if (generatorId === Enrichments_js_1.STACK_ENRICHMENT_KEY)
+            continue;
+        // Other `_`-prefixed top-level keys are reserved/unknown — the
+        // `generatorEnrichments` schema flags those structurally, not here.
+        if ((0, Enrichments_js_1.isReservedEnrichmentKey)(generatorId))
+            continue;
+        const source = sourceById.get(generatorId);
+        if (!source) {
+            issues.push({
+                generator: generatorId,
+                scope: 'generator',
+                message: `Generator '${generatorId}' has enrichments configured but is not present in the stack.`
+            });
+            continue;
+        }
+        const schema = source.toEnrichmentSchema?.();
+        if (!schema || !isRecord(slot))
+            continue;
+        // Run-constant scopes — validated once per generator (each generator's
+        // umbrella declares its own `generator` / `stack` member shape).
+        issues.push(...parseScope(schema, 'generator', slot[Enrichments_js_1.GENERATOR_ENRICHMENT_KEY], { generator: generatorId }));
+        issues.push(...parseScope(schema, 'stack', stack, { generator: generatorId }));
+        // Subject scope — one parse per (subject, variant) leaf.
+        for (const leaf of collectSubjectLeaves(source.type, slot)) {
+            issues.push(...parseScope(schema, 'subject', leaf.values, {
+                generator: generatorId,
+                subject: leaf.subject,
+                ...(leaf.method !== undefined ? { method: leaf.method } : {}),
+                variant: leaf.variant
+            }));
+        }
+    }
+    return issues;
+};
+exports.validateConfig = validateConfig;

package/script/helpers/isImported.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isImported = void 0;
-const normalize_js_1 = require("../deps/jsr.io/@std/path/1.1.4/normalize.js");
+const normalize_js_1 = require("../deps/jsr.io/@std/path/1.1.6/normalize.js");
 /**
  * Determines whether two file paths represent different locations (import required).
  *

package/script/helpers/toResolvedArtifactPath.js

@@ -63,7 +63,7 @@ exports.toResolvedArtifactPath = void 0;
  * @module toResolvedArtifactPath
  */
 require("../_dnt.polyfills.js");
-const join_js_1 = require("../deps/jsr.io/@std/path/1.1.4/join.js");
+const join_js_1 = require("../deps/jsr.io/@std/path/1.1.6/join.js");
 /**
  * Resolves artifact destination paths relative to a base directory.
  *