@skmtc/core 0.0.983 → 0.16.1

package/script/types/GeneratorType.d.ts

@@ -1,127 +1,65 @@
-import type { OperationConfig } from '../dsl/operation/types.js';
+import type { OasOperationConfig } from '../dsl/operation/oas/types.js';
+import type { WebhookConfig } from '../dsl/webhook/types.js';
+import type { GqlOperationConfig } from '../dsl/operation/gql/types.js';
 import type { ModelConfig } from '../dsl/model/types.js';
 /**
- * Union type representing all possible generator configurations.
+ * Discriminated union of every generator configuration the dispatcher
+ * recognizes. The `type` field discriminates the variant — `'oasOperation'`
+ * for HTTP-flavored operation generators, `'gqlOperation'` for GraphQL
+ * operation generators, `'model'` for protocol-neutral model generators.
  *
- * Generator configurations define how different types of generators should
- * process OpenAPI documents. This includes both operation generators (which
- * process API endpoints) and model generators (which process data schemas).
+ * Operation variants are routed only to the matching document protocol; a
+ * `'oasOperation'` config is silently skipped on a GraphQL document and
+ * vice versa. Model generators run against either protocol's registry.
  *
  * @template EnrichmentType - Optional type for custom enrichment data
  *
- * @example
+ * @example OAS operation generator
  * ```typescript
- * import { GeneratorConfig } from '@skmtc/core';
+ * import { toOasOperationEntry } from '@skmtc/core';
  *
- * // Operation generator configuration
- * const apiClientConfig: GeneratorConfig = {
- *   type: 'operation',
- *   generatorId: 'api-client',
- *   settings: {
- *     exportPath: './src/api/client.ts',
- *     enrichment: customEnrichments
- *   },
- *   toGenerator: (args) => new ApiClientGenerator(args)
- * };
- *
- * // Model generator configuration
- * const typescriptModels: GeneratorConfig = {
- *   type: 'model',
- *   generatorId: 'typescript-models',
- *   settings: {
- *     exportPath: './src/types/models.ts'
- *   },
- *   toGenerator: (args) => new TypeScriptModelGenerator(args)
- * };
- * ```
- */
-export type GeneratorConfig<EnrichmentType = undefined> = OperationConfig<EnrichmentType> | ModelConfig<EnrichmentType>;
-/**
- * Type-safe mapping of generator configurations.
- *
- * This type preserves the structure and types of generator configurations
- * within a map, ensuring that each generator maintains its specific
- * configuration type and enrichment data.
- *
- * @template G - The generator configuration type
- * @template EnrichmentType - The enrichment type for the generators
- *
- * @example
- * ```typescript
- * type MyGenerators = {
- *   'api-client': OperationConfig<ApiEnrichment>;
- *   'typescript-models': ModelConfig<ModelEnrichment>;
- *   'validation': ModelConfig<ValidationEnrichment>;
- * };
- *
- * type MyGeneratorsMap = GeneratorsMap<MyGenerators, undefined>;
- * // Preserves the exact structure and types of MyGenerators
+ * const apiClientEntry = toOasOperationEntry({
+ *   id: 'api-client',
+ *   transform: ({ context, operation }) => {},
+ *   isSupported: ({ operation }) => operation.method === 'get'
+ * });
+ * // apiClientEntry.type === 'oasOperation'
  * ```
- */
-export type GeneratorsMap<G extends GeneratorConfig<EnrichmentType>, EnrichmentType> = {
-    [K in keyof G]: G[K];
-};
-/**
- * Container type for a complete generators map with optional enrichment.
- *
- * This type represents a complete mapping of generators that can process
- * an OpenAPI document. It's used as the main configuration structure
- * passed to the SKMTC processing pipeline.
- *
- * @template EnrichmentType - Optional type for custom enrichment data across all generators
  *
- * @example Basic generators map
+ * @example GraphQL operation generator
  * ```typescript
- * import { GeneratorsMapContainer } from '@skmtc/core';
+ * import { toGqlOperationEntry } from '@skmtc/core';
  *
- * const generators: GeneratorsMapContainer = {
- *   'api-client': {
- *     type: 'operation',
- *     generatorId: 'api-client',
- *     settings: { exportPath: './src/api.ts' },
- *     toGenerator: (args) => new ApiClientGenerator(args)
- *   },
- *   'typescript-models': {
- *     type: 'model',
- *     generatorId: 'typescript-models',
- *     settings: { exportPath: './src/models.ts' },
- *     toGenerator: (args) => new TypeScriptModels(args)
- *   }
- * };
- *
- * // Use with toArtifacts
- * const result = await toArtifacts({
- *   documentObject: openApiDoc,
- *   settings: clientSettings,
- *   toGeneratorConfigMap: () => generators,
- *   traceId: 'generation',
- *   spanId: 'main',
- *   startAt: Date.now()
+ * const gqlEntry = toGqlOperationEntry({
+ *   id: 'gql-client',
+ *   transform: ({ context, operation }) => {}
  * });
+ * // gqlEntry.type === 'gqlOperation'
  * ```
  *
- * @example With enrichments
+ * @example Model generator
  * ```typescript
- * type MyEnrichments = {
- *   customValidation: boolean;
- *   generateComments: boolean;
- * };
+ * import { toModelEntry } from '@skmtc/core';
  *
- * const enrichedGenerators: GeneratorsMapContainer<MyEnrichments> = {
- *   'enhanced-models': {
- *     type: 'model',
- *     generatorId: 'enhanced-models',
- *     settings: {
- *       exportPath: './src/enhanced.ts',
- *       enrichment: {
- *         customValidation: true,
- *         generateComments: true
- *       }
- *     },
- *     toGenerator: (args) => new EnhancedModelGenerator(args)
- *   }
- * };
+ * const modelEntry = toModelEntry({
+ *   id: 'typescript-models',
+ *   transform: ({ context, refName }) => {}
+ * });
+ * // modelEntry.type === 'model'
  * ```
  */
-export type GeneratorsMapContainer<EnrichmentType = undefined> = GeneratorsMap<GeneratorConfig<EnrichmentType>, EnrichmentType>;
+export type GeneratorConfig<EnrichmentType = undefined> = OasOperationConfig<EnrichmentType> | WebhookConfig<EnrichmentType> | GqlOperationConfig<EnrichmentType> | ModelConfig<EnrichmentType>;
+/**
+ * A name → generator-config map. Keys are arbitrary generator
+ * identifiers (the same string a caller might pass to `--skip` etc.);
+ * each value is a `GeneratorConfig` variant.
+ *
+ * The runtime treats this as a plain `Record<string, GeneratorConfig>`
+ * — it iterates with `Object.values` and `Object.keys` — so the type
+ * mirrors that shape. There is no per-key type narrowing: callers who
+ * want type-level distinctions between specific entries can keep the
+ * literal map well-typed at its definition site and only widen here at
+ * the boundary.
+ */
+export type GeneratorsMapContainer<EnrichmentType = undefined> = Record<string, GeneratorConfig<EnrichmentType>>;
 //# sourceMappingURL=GeneratorType.d.ts.map

package/script/types/GeneratorType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GeneratorType.d.ts","sourceRoot":"","sources":["../../src/types/GeneratorType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,MAAM,eAAe,CAAC,cAAc,GAAG,SAAS,IAClD,eAAe,CAAC,cAAc,CAAC,GAC/B,WAAW,CAAC,cAAc,CAAC,CAAA;AAE/B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,eAAe,CAAC,cAAc,CAAC,EAAE,cAAc,IAAI;KACpF,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACrB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,MAAM,MAAM,sBAAsB,CAAC,cAAc,GAAG,SAAS,IAAI,aAAa,CAC5E,eAAe,CAAC,cAAc,CAAC,EAC/B,cAAc,CACf,CAAA"}
+{"version":3,"file":"GeneratorType.d.ts","sourceRoot":"","sources":["../../src/types/GeneratorType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAA;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAC5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAA;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,MAAM,eAAe,CAAC,cAAc,GAAG,SAAS,IAClD,kBAAkB,CAAC,cAAc,CAAC,GAClC,aAAa,CAAC,cAAc,CAAC,GAC7B,kBAAkB,CAAC,cAAc,CAAC,GAClC,WAAW,CAAC,cAAc,CAAC,CAAA;AAE/B;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,sBAAsB,CAAC,cAAc,GAAG,SAAS,IAAI,MAAM,CACrE,MAAM,EACN,eAAe,CAAC,cAAc,CAAC,CAChC,CAAA"}

package/script/types/JsonPointer.d.ts

@@ -0,0 +1,92 @@
+/**
+ * @fileoverview RFC 6901 JSON Pointer branded type and helpers.
+ *
+ * Used by gen-maps (the attribution / sidecar system) to identify
+ * the precise location of a schema element within the OpenAPI
+ * document. Threaded through parse via `StackTrail.toJsonPointer()`
+ * and attached to every parsed OAS schema as `.location`.
+ *
+ * @module JsonPointer
+ */
+import type { Brand } from './Brand.js';
+/**
+ * Branded type for an RFC 6901 JSON Pointer string.
+ *
+ * Always starts with `#/` (URI fragment form) or `/` (raw form);
+ * helpers in this module produce the URI fragment form so the
+ * resulting strings round-trip through the `oas:` URI scheme used
+ * in sidecar `S` tables.
+ *
+ * Empty pointer (`#/`) refers to the document root.
+ */
+export type JsonPointer = Brand<string, 'JsonPointer'>;
+/**
+ * Escape a single segment per RFC 6901 §4.
+ *
+ * `~` → `~0` (must be replaced first to avoid double-escaping)
+ * `/` → `~1`
+ */
+export declare const escapeSegment: (segment: string) => string;
+/**
+ * Unescape a single segment per RFC 6901 §4.
+ *
+ * `~1` → `/` (must be replaced first)
+ * `~0` → `~`
+ */
+export declare const unescapeSegment: (segment: string) => string;
+/**
+ * Build a JSON Pointer from an array of unescaped segments.
+ * Returns the URI fragment form: `#/<seg1>/<seg2>/...`.
+ *
+ * Empty array yields `#/` (document root).
+ *
+ * @example
+ * ```ts
+ * toJsonPointer(['components', 'schemas', 'User'])
+ * // → '#/components/schemas/User'
+ *
+ * toJsonPointer(['paths', '/users/{id}', 'get'])
+ * // → '#/paths/~1users~1{id}/get'
+ * ```
+ */
+export declare const toJsonPointer: (segments: readonly string[]) => JsonPointer;
+/**
+ * Parse a JSON Pointer (URI fragment form `#/...` or raw `/...`)
+ * into an array of unescaped segments.
+ *
+ * Returns `undefined` if the pointer is malformed (doesn't start
+ * with `#/` or `/`, or is empty).
+ *
+ * @example
+ * ```ts
+ * fromJsonPointer('#/components/schemas/User')
+ * // → ['components', 'schemas', 'User']
+ *
+ * fromJsonPointer('#/paths/~1users~1{id}/get')
+ * // → ['paths', '/users/{id}', 'get']
+ *
+ * fromJsonPointer('#/')
+ * // → []
+ * ```
+ */
+export declare const fromJsonPointer: (pointer: string) => string[] | undefined;
+/**
+ * Append one or more segments to an existing JSON Pointer.
+ *
+ * @example
+ * ```ts
+ * const base = toJsonPointer(['components', 'schemas', 'User'])
+ * append(base, 'properties', 'email')
+ * // → '#/components/schemas/User/properties/email'
+ * ```
+ */
+export declare const append: (pointer: JsonPointer, ...segments: string[]) => JsonPointer;
+/**
+ * Type guard for the URI-fragment form.
+ *
+ * Loose check — verifies prefix and that there are no obviously
+ * malformed sequences. Doesn't verify that all `~` instances are
+ * followed by `0` or `1` (a stricter validator could).
+ */
+export declare const isJsonPointer: (value: unknown) => value is JsonPointer;
+//# sourceMappingURL=JsonPointer.d.ts.map

package/script/types/JsonPointer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonPointer.d.ts","sourceRoot":"","sources":["../../src/types/JsonPointer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAEvC;;;;;;;;;GASG;AACH,MAAM,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;AAEtD;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,KAAG,MACK,CAAA;AAErD;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAI,SAAS,MAAM,KAAG,MACG,CAAA;AAErD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,GAAI,UAAU,SAAS,MAAM,EAAE,KAAG,WAG3D,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,eAAe,GAAI,SAAS,MAAM,KAAG,MAAM,EAAE,GAAG,SAa5D,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,GAAI,SAAS,WAAW,EAAE,GAAG,UAAU,MAAM,EAAE,KAAG,WAOpE,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,WAGvD,CAAA"}

package/script/types/JsonPointer.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * @fileoverview RFC 6901 JSON Pointer branded type and helpers.
+ *
+ * Used by gen-maps (the attribution / sidecar system) to identify
+ * the precise location of a schema element within the OpenAPI
+ * document. Threaded through parse via `StackTrail.toJsonPointer()`
+ * and attached to every parsed OAS schema as `.location`.
+ *
+ * @module JsonPointer
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJsonPointer = exports.append = exports.fromJsonPointer = exports.toJsonPointer = exports.unescapeSegment = exports.escapeSegment = void 0;
+/**
+ * Escape a single segment per RFC 6901 §4.
+ *
+ * `~` → `~0` (must be replaced first to avoid double-escaping)
+ * `/` → `~1`
+ */
+const escapeSegment = (segment) => segment.replaceAll('~', '~0').replaceAll('/', '~1');
+exports.escapeSegment = escapeSegment;
+/**
+ * Unescape a single segment per RFC 6901 §4.
+ *
+ * `~1` → `/` (must be replaced first)
+ * `~0` → `~`
+ */
+const unescapeSegment = (segment) => segment.replaceAll('~1', '/').replaceAll('~0', '~');
+exports.unescapeSegment = unescapeSegment;
+/**
+ * Build a JSON Pointer from an array of unescaped segments.
+ * Returns the URI fragment form: `#/<seg1>/<seg2>/...`.
+ *
+ * Empty array yields `#/` (document root).
+ *
+ * @example
+ * ```ts
+ * toJsonPointer(['components', 'schemas', 'User'])
+ * // → '#/components/schemas/User'
+ *
+ * toJsonPointer(['paths', '/users/{id}', 'get'])
+ * // → '#/paths/~1users~1{id}/get'
+ * ```
+ */
+const toJsonPointer = (segments) => {
+    if (segments.length === 0)
+        return '#/';
+    return `#/${segments.map(exports.escapeSegment).join('/')}`;
+};
+exports.toJsonPointer = toJsonPointer;
+/**
+ * Parse a JSON Pointer (URI fragment form `#/...` or raw `/...`)
+ * into an array of unescaped segments.
+ *
+ * Returns `undefined` if the pointer is malformed (doesn't start
+ * with `#/` or `/`, or is empty).
+ *
+ * @example
+ * ```ts
+ * fromJsonPointer('#/components/schemas/User')
+ * // → ['components', 'schemas', 'User']
+ *
+ * fromJsonPointer('#/paths/~1users~1{id}/get')
+ * // → ['paths', '/users/{id}', 'get']
+ *
+ * fromJsonPointer('#/')
+ * // → []
+ * ```
+ */
+const fromJsonPointer = (pointer) => {
+    let body;
+    if (pointer.startsWith('#/')) {
+        body = pointer.slice(2);
+    }
+    else if (pointer.startsWith('/')) {
+        body = pointer.slice(1);
+    }
+    else if (pointer === '#' || pointer === '') {
+        return [];
+    }
+    else {
+        return undefined;
+    }
+    if (body === '')
+        return [];
+    return body.split('/').map(exports.unescapeSegment);
+};
+exports.fromJsonPointer = fromJsonPointer;
+/**
+ * Append one or more segments to an existing JSON Pointer.
+ *
+ * @example
+ * ```ts
+ * const base = toJsonPointer(['components', 'schemas', 'User'])
+ * append(base, 'properties', 'email')
+ * // → '#/components/schemas/User/properties/email'
+ * ```
+ */
+const append = (pointer, ...segments) => {
+    if (segments.length === 0)
+        return pointer;
+    const escaped = segments.map(exports.escapeSegment).join('/');
+    if (pointer === '#/') {
+        return `#/${escaped}`;
+    }
+    return `${pointer}/${escaped}`;
+};
+exports.append = append;
+/**
+ * Type guard for the URI-fragment form.
+ *
+ * Loose check — verifies prefix and that there are no obviously
+ * malformed sequences. Doesn't verify that all `~` instances are
+ * followed by `0` or `1` (a stricter validator could).
+ */
+const isJsonPointer = (value) => {
+    if (typeof value !== 'string')
+        return false;
+    return value === '#/' || value.startsWith('#/');
+};
+exports.isJsonPointer = isJsonPointer;

package/script/types/Manifest.d.ts

@@ -70,8 +70,10 @@
  *
  * @module Manifest
  */
+import "../_dnt.polyfills.js";
 import { type ResultsItem } from './Results.js';
 import { type Preview, type Mapping } from './Preview.js';
+import type { ParseIssue } from '../context/ParseIssue.js';
 import * as v from 'valibot';
 export type ManifestEntry = {
     lines: number;
@@ -90,9 +92,16 @@ export type ManifestContent = {
     spanId: string;
     region?: string;
     files: Record<string, ManifestEntry>;
-    previews: Record<string, Record<string, Preview>>;
-    mappings?: Record<string, Record<string, Mapping>>;
+    previews: Record<string, Preview>;
+    mappings?: Record<string, Mapping>;
     results: ResultsItem;
+    /**
+     * Issues recorded during the parse phase — both protocol-agnostic
+     * (OAS and GQL share the same union). Defaults to `[]` for clean
+     * parses. Lives in the manifest so post-run diagnostics can re-read
+     * it from `.settings/manifest.json` without re-running.
+     */
+    parseIssues: ParseIssue[];
     startAt: number;
     endAt: number;
 };

package/script/types/Manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Manifest.d.ts","sourceRoot":"","sources":["../../src/types/Manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AAEH,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,cAAc,CAAA;AAC5D,OAAO,EAAW,KAAK,OAAO,EAAE,KAAK,OAAO,EAAW,MAAM,cAAc,CAAA;AAC3E,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,MAAM,CAAA;IAClB,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,aAAa,CAAC,aAAa,CAIvD,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,eAAO,MAAM,WAAW,EAAE,CAAC,CAAC,aAAa,CAAC,WAAW,CAGnD,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IACpC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IAClD,OAAO,EAAE,WAAW,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,aAAa,CAAC,eAAe,CAW3D,CAAA"}
+{"version":3,"file":"Manifest.d.ts","sourceRoot":"","sources":["../../src/types/Manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH,OAAO,sBAAsB,CAAC;AAG9B,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,cAAc,CAAA;AAC5D,OAAO,EAAW,KAAK,OAAO,EAAE,KAAK,OAAO,EAAW,MAAM,cAAc,CAAA;AAC3E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAG1D,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AA8C5B,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,MAAM,CAAA;IAClB,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,aAAa,CAAC,aAAa,CAIvD,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,eAAO,MAAM,WAAW,EAAE,CAAC,CAAC,aAAa,CAAC,WAAW,CAGnD,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IACpC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAClC,OAAO,EAAE,WAAW,CAAA;IACpB;;;;;OAKG;IACH,WAAW,EAAE,UAAU,EAAE,CAAA;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,aAAa,CAAC,eAAe,CAY3D,CAAA"}

package/script/types/Manifest.js

@@ -1,4 +1,39 @@
 "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.manifestContent = exports.previewItem = exports.manifestEntry = void 0;
 /**
  * @fileoverview Generation Manifest System for SKMTC Core
  *
@@ -71,44 +106,55 @@
  *
  * @module Manifest
  */
-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.manifestContent = exports.previewItem = exports.manifestEntry = void 0;
+require("../_dnt.polyfills.js");
 const Results_js_1 = require("./Results.js");
 const Preview_js_1 = require("./Preview.js");
+const generateTypes_js_1 = require("../context/generateTypes.js");
+const ParseIssue_js_1 = require("../context/ParseIssue.js");
 const v = __importStar(require("valibot"));
+/**
+ * Valibot schema for the unified {@link ParseIssue} discriminated union.
+ *
+ * The TS type and this schema stay in sync via the
+ * `v.GenericSchema<ParseIssue>` annotation — adding a variant on one
+ * side without the other fails to type-check.
+ */
+const parseIssue = v.variant('protocol', [
+    v.variant('level', [
+        v.object({
+            protocol: v.literal('oas'),
+            level: v.literal('error'),
+            type: generateTypes_js_1.oasIssueType,
+            location: v.string(),
+            message: v.string(),
+            cause: v.optional(v.unknown())
+        }),
+        v.object({
+            protocol: v.literal('oas'),
+            level: v.literal('warning'),
+            type: generateTypes_js_1.oasIssueType,
+            location: v.string(),
+            message: v.string()
+        })
+    ]),
+    v.variant('level', [
+        v.object({
+            protocol: v.literal('gql'),
+            level: v.literal('error'),
+            type: ParseIssue_js_1.gqlIssueType,
+            location: v.string(),
+            message: v.string(),
+            cause: v.optional(v.unknown())
+        }),
+        v.object({
+            protocol: v.literal('gql'),
+            level: v.literal('warning'),
+            type: ParseIssue_js_1.gqlIssueType,
+            location: v.string(),
+            message: v.string()
+        })
+    ])
+]);
 exports.manifestEntry = v.object({
     lines: v.number(),
     characters: v.number(),
@@ -124,9 +170,10 @@ exports.manifestContent = v.object({
     spanId: v.string(),
     region: v.optional(v.string()),
     files: v.record(v.string(), exports.manifestEntry),
-    previews: v.record(v.string(), v.record(v.string(), Preview_js_1.preview)),
-    mappings: v.optional(v.record(v.string(), v.record(v.string(), Preview_js_1.mapping))),
+    previews: v.record(v.string(), Preview_js_1.preview),
+    mappings: v.optional(v.record(v.string(), Preview_js_1.mapping)),
     results: Results_js_1.resultsItem,
+    parseIssues: v.array(parseIssue),
     startAt: v.number(),
     endAt: v.number()
 });

package/script/types/Method.d.ts

@@ -1,3 +1,4 @@
+import "../_dnt.polyfills.js";
 import * as v from 'valibot';
 /**
  * Array of all valid HTTP methods supported by OpenAPI v3.

package/script/types/Method.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Method.d.ts","sourceRoot":"","sources":["../../src/types/Method.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,gFASf,CAAA;AAEV;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,UAA+D,CAAA;AAE/F,eAAO,MAAM,MAAM,EAAE,CAAC,CAAC,WAAW,CAChC;IACE,CAAC,CAAC,aAAa,CAAC,KAAK,EAAE,SAAS,CAAC;IACjC,CAAC,CAAC,aAAa,CAAC,MAAM,EAAE,SAAS,CAAC;IAClC,CAAC,CAAC,aAAa,CAAC,KAAK,EAAE,SAAS,CAAC;IACjC,CAAC,CAAC,aAAa,CAAC,OAAO,EAAE,SAAS,CAAC;IACnC,CAAC,CAAC,aAAa,CAAC,QAAQ,EAAE,SAAS,CAAC;IACpC,CAAC,CAAC,aAAa,CAAC,MAAM,EAAE,SAAS,CAAC;IAClC,CAAC,CAAC,aAAa,CAAC,SAAS,EAAE,SAAS,CAAC;IACrC,CAAC,CAAC,aAAa,CAAC,OAAO,EAAE,SAAS,CAAC;CACpC,EACD,SAAS,CAUT,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAA;AAE/F,eAAO,MAAM,OAAO,EAAE,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,EAAE,SAAS,CAAmB,CAAA;AAE/E,eAAO,MAAM,QAAQ,GAAI,KAAK,OAAO,KAAG,GAAG,IAAI,MAE9C,CAAA"}
+{"version":3,"file":"Method.d.ts","sourceRoot":"","sources":["../../src/types/Method.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,gFASf,CAAA;AAEV;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,UAA+D,CAAA;AAE/F,eAAO,MAAM,MAAM,EAAE,CAAC,CAAC,WAAW,CAChC;IACE,CAAC,CAAC,aAAa,CAAC,KAAK,EAAE,SAAS,CAAC;IACjC,CAAC,CAAC,aAAa,CAAC,MAAM,EAAE,SAAS,CAAC;IAClC,CAAC,CAAC,aAAa,CAAC,KAAK,EAAE,SAAS,CAAC;IACjC,CAAC,CAAC,aAAa,CAAC,OAAO,EAAE,SAAS,CAAC;IACnC,CAAC,CAAC,aAAa,CAAC,QAAQ,EAAE,SAAS,CAAC;IACpC,CAAC,CAAC,aAAa,CAAC,MAAM,EAAE,SAAS,CAAC;IAClC,CAAC,CAAC,aAAa,CAAC,SAAS,EAAE,SAAS,CAAC;IACrC,CAAC,CAAC,aAAa,CAAC,OAAO,EAAE,SAAS,CAAC;CACpC,EACD,SAAS,CAUT,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAA;AAE/F,eAAO,MAAM,OAAO,EAAE,CAAC,CAAC,WAAW,CAAC,OAAO,MAAM,EAAE,SAAS,CAAmB,CAAA;AAE/E,eAAO,MAAM,QAAQ,GAAI,KAAK,OAAO,KAAG,GAAG,IAAI,MAE9C,CAAA"}

package/script/types/Method.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isMethod = exports.methods = exports.method = exports.methodValuesNoTrace = exports.methodValues = void 0;
+require("../_dnt.polyfills.js");
 const v = __importStar(require("valibot"));
 /**
  * Array of all valid HTTP methods supported by OpenAPI v3.

package/script/types/ModuleExport.d.ts

@@ -1,3 +1,4 @@
+import "../_dnt.polyfills.js";
 import * as v from 'valibot';
 /**
  * Valibot schema for validating module export configuration objects.

package/script/types/ModuleExport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ModuleExport.d.ts","sourceRoot":"","sources":["../../src/types/ModuleExport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,aAAa,CAAC,YAAY,CAGrD,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,0EAA0E;IAC1E,UAAU,EAAE,MAAM,CAAA;IAClB,kDAAkD;IAClD,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA"}
+{"version":3,"file":"ModuleExport.d.ts","sourceRoot":"","sources":["../../src/types/ModuleExport.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,aAAa,CAAC,YAAY,CAGrD,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,0EAA0E;IAC1E,UAAU,EAAE,MAAM,CAAA;IAClB,kDAAkD;IAClD,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA"}

package/script/types/ModuleExport.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.moduleExport = void 0;
+require("../_dnt.polyfills.js");
 const v = __importStar(require("valibot"));
 /**
  * Valibot schema for validating module export configuration objects.

package/script/types/OasBase.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview `OasBase` base class for parsed nodes.
+ *
+ * Shared base for OAS and GQL classes that carry a source-document
+ * position, stored as a `StackTrail`. The trail is **total**: a parsed
+ * node snapshots the visitor position; a programmatically-constructed
+ * (synthetic) node gets `StackTrail.empty()`. Callers convert to a JSON
+ * Pointer on demand via `stackTrail.toJsonPointer()`, gating on
+ * `stackTrail.isEmpty()` for synthetic nodes — there is no `undefined`.
+ *
+ * @module OasBase
+ */
+import type { ParseContextType } from '../context/parseTypes.js';
+import { StackTrail } from '../context/StackTrail.js';
+/**
+ * Base class for parsed nodes that carry a source-document position.
+ *
+ * Each schema / operation class extends this so the parse-position
+ * field is declared in one place. Subclass constructors call
+ * `super(context)`; `OasBase` reads `context.currentStackTrail` and
+ * snapshots it, or records `StackTrail.empty()` when there is none.
+ * Pure parse-time metadata — has no spec semantics.
+ *
+ * Adds **only** the `stackTrail` slot. Schema classes remain a
+ * discriminated union with literal `type` / `oasType` fields
+ * preserved on each subclass.
+ */
+export declare class OasBase {
+    /**
+     * StackTrail snapshot captured at construction time. Cloned so that
+     * subsequent factory traversal doesn't mutate this node's recorded
+     * position. `StackTrail.empty()` when the node was constructed
+     * programmatically (no parse context / no active stack-trail scope) —
+     * a synthetic node with no source position. No parsed node is ever
+     * at the empty trail, so `isEmpty()` cleanly means "synthetic".
+     */
+    stackTrail: StackTrail;
+    constructor(context?: ParseContextType);
+}
+//# sourceMappingURL=OasBase.d.ts.map