@skmtc/core 0.0.984 → 0.16.2

package/esm/parse/v3-1/tag/toTagsV3.d.ts

@@ -0,0 +1,17 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasTag } from '../../../oas/tag/Tag.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToTagsV3Args = {
+    tags: OpenAPIV3.TagObject[] | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toTagsV3: ({ tags, stackTrail, context }: ToTagsV3Args) => OasTag[] | undefined;
+export type ToTagV3Args = {
+    tag: OpenAPIV3.TagObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toTagV3: ({ tag, stackTrail, context }: ToTagV3Args) => OasTag;
+//# sourceMappingURL=toTagsV3.d.ts.map

package/esm/parse/v3-1/tag/toTagsV3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toTagsV3.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-1/tag/toTagsV3.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAIhD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,SAAS,CAAC,SAAS,EAAE,GAAG,SAAS,CAAA;IACvC,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,+BAA+B,YAAY,KAAG,MAAM,EAAE,GAAG,SAMjF,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,GAAG,EAAE,SAAS,CAAC,SAAS,CAAA;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,OAAO,GAAI,8BAA8B,WAAW,KAAG,MAuBnE,CAAA"}

package/esm/parse/v3-1/tag/toTagsV3.js

@@ -0,0 +1,27 @@
+import { OasTag } from '../../../oas/tag/Tag.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+import { toExternalDocs } from '../externalDocs/toExternalDocs.js';
+export const toTagsV3 = ({ tags, stackTrail, context }) => {
+    if (!tags) {
+        return undefined;
+    }
+    return tags.map(tag => toTagV3({ tag, stackTrail, context }));
+};
+export const toTagV3 = ({ tag, stackTrail, context }) => {
+    const { name, description, externalDocs, ...skipped } = tag;
+    const parsedExternalDocs = stackTrail.trace('externalDocs', st => toExternalDocs({ externalDocs, stackTrail: st, context }));
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: tag,
+        context,
+        stackTrail,
+        parentType: 'tag'
+    });
+    const fields = {
+        name,
+        description,
+        externalDocs: parsedExternalDocs,
+        extensionFields
+    };
+    return new OasTag(fields);
+};

package/esm/parse/v3-1/union/toUnion.d.ts

@@ -0,0 +1,13 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasUnion } from '../../../oas/union/Union.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToUnionArgs = {
+    value: OpenAPIV3.SchemaObject;
+    members: (OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject)[];
+    parentType: 'anyOf' | 'oneOf';
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toUnion: ({ value, members, parentType, stackTrail, context }: ToUnionArgs) => OasUnion;
+//# sourceMappingURL=toUnion.d.ts.map

package/esm/parse/v3-1/union/toUnion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toUnion.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-1/union/toUnion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAA;AAStD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAChE,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,SAAS,CAAC,YAAY,CAAA;IAC7B,OAAO,EAAE,CAAC,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,YAAY,CAAC,EAAE,CAAA;IAC/D,UAAU,EAAE,OAAO,GAAG,OAAO,CAAA;IAC7B,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,OAAO,GAAI,qDAMrB,WAAW,KAAG,QA0EhB,CAAA"}

package/esm/parse/v3-1/union/toUnion.js

@@ -0,0 +1,66 @@
+import { OasUnion } from '../../../oas/union/Union.js';
+import { toDiscriminatorV3 } from '../discriminator/toDiscriminatorV3.js';
+import { toSchemaV3 } from '../schema/toSchemasV3.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+import { parseNullable } from '../_helpers/parseNullable.js';
+import { parseExample } from '../_helpers/parseExample.js';
+import { parseDefault } from '../_helpers/parseDefault.js';
+export const toUnion = ({ value, members, parentType, stackTrail, context }) => {
+    const { nullable, value: valueWithoutNullable } = parseNullable({
+        value,
+        context,
+        stackTrail
+    });
+    const { discriminator, title, description, example: unparsedExample, default: unparsedDefaultValue, ...skipped } = valueWithoutNullable;
+    const example = parseExample({
+        value: unparsedExample,
+        context,
+        parent: value,
+        nullable,
+        check: isPresent,
+        toMessage: item => `Removed invalid example. Expected a non-null value, got: ${item}`,
+        stackTrail
+    });
+    const defaultValue = parseDefault({
+        value: unparsedDefaultValue,
+        context,
+        parent: value,
+        nullable,
+        check: isPresent,
+        toMessage: item => `Removed invalid default. Expected a non-null value, got: ${item}`,
+        stackTrail
+    });
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: value,
+        context,
+        stackTrail,
+        parentType: `schema:${parentType}`
+    });
+    const discriminatorParsed = stackTrail.trace('discriminator', st => toDiscriminatorV3({ discriminator, stackTrail: st, context }));
+    const membersParsed = members.reduce((acc, item, index) => {
+        if (item === undefined || item === null) {
+            return acc;
+        }
+        return [
+            ...acc,
+            stackTrail.trace(`${index}`, st => toSchemaV3({ schema: item, stackTrail: st, context }))
+        ];
+    }, []);
+    return context.withStackTrail(stackTrail, () => new OasUnion({
+        title,
+        description,
+        nullable,
+        default: defaultValue,
+        discriminator: discriminatorParsed,
+        members: membersParsed,
+        example,
+        extensionFields
+    }, context));
+};
+// A union (anyOf/oneOf) value may match any of its members, so the most we
+// can validate without resolving members is that a present default/example
+// is not a bare `null` on a non-nullable schema.
+const isPresent = (value) => {
+    return value !== null && value !== undefined;
+};

package/esm/parse/v3-1/unknown/toUnknown.d.ts

@@ -0,0 +1,11 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasUnknown } from '../../../oas/unknown/Unknown.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToUnknownArgs = {
+    value: OpenAPIV3.SchemaObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toUnknown: ({ value, stackTrail, context }: ToUnknownArgs) => OasUnknown;
+//# sourceMappingURL=toUnknown.d.ts.map

package/esm/parse/v3-1/unknown/toUnknown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toUnknown.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-1/unknown/toUnknown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAE5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,SAAS,CAAC,YAAY,CAAA;IAC7B,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,gCAAgC,aAAa,KAAG,UAuBzE,CAAA"}

package/esm/parse/v3-1/unknown/toUnknown.js

@@ -0,0 +1,19 @@
+import { OasUnknown } from '../../../oas/unknown/Unknown.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+export const toUnknown = ({ value, stackTrail, context }) => {
+    const { type: _type, title, description, example, nullable, ...skipped } = value;
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: value,
+        context,
+        stackTrail,
+        parentType: 'schema:unknown'
+    });
+    return context.withStackTrail(stackTrail, () => new OasUnknown({
+        title,
+        description,
+        nullable,
+        extensionFields,
+        example
+    }, context));
+};

package/esm/parse/v3-1/webhook/toWebhooksV3.d.ts

@@ -0,0 +1,49 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { Method } from '../../../types/Method.js';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasWebhook } from '../../../oas/webhook/Webhook.js';
+import type { OasPathItem } from '../../../oas/pathItem/PathItem.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+/**
+ * The 3.1 `webhooks` object: a map of webhook NAME → PathItem, identical
+ * in shape to `paths` but keyed by name rather than URL path. Inline
+ * PathItems only — a webhook PathItem `$ref` is a 3.1 edge case not yet
+ * handled (see the arc note §5 Refs).
+ */
+export type WebhooksObject = Record<string, OpenAPIV3.PathItemObject>;
+type WebhookInfo = {
+    method: Method;
+    name: string;
+    pathItem: OasPathItem | undefined;
+};
+export type ToWebhookV3Args = {
+    operation: OpenAPIV3.OperationObject;
+    webhookInfo: WebhookInfo;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+/**
+ * Parses a single webhook Operation Object into an {@link OasWebhook}.
+ *
+ * Mirrors `toOperationV3` and reuses the same leaf field parsers
+ * (`toParameterListV3` / `toRequestBodyV3` / `toResponsesV3` / …) — the
+ * inner Operation Object is structurally identical. Only the orchestration
+ * is duplicated (the dialect-shaped glue), and the output is an
+ * `OasWebhook` carrying a `name`, not an `OasOperation` carrying a `path`.
+ */
+export declare const toWebhookV3: ({ operation, webhookInfo, stackTrail, context }: ToWebhookV3Args) => OasWebhook;
+export type ToWebhooksV3Args = {
+    webhooks: WebhooksObject | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+/**
+ * Flattens the 3.1 `webhooks` map into `OasWebhook[]`, mirroring
+ * `toOperationsV3`'s `paths` → `OasOperation[]` flattening. Returns `[]`
+ * when no `webhooks` object is present (the common 3.0 / no-webhook case).
+ * The stack trail nests `webhooks` → `<name>` → `<method>` so
+ * `OasDocument.removeItem` can locate a webhook by name.
+ */
+export declare const toWebhooksV3: ({ webhooks, stackTrail, context }: ToWebhooksV3Args) => OasWebhook[];
+export {};
+//# sourceMappingURL=toWebhooksV3.d.ts.map

package/esm/parse/v3-1/webhook/toWebhooksV3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toWebhooksV3.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-1/webhook/toWebhooksV3.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAA;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AAItE,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAE5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAA;AAOpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,cAAc,CAAC,CAAA;AAErE,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,WAAW,GAAG,SAAS,CAAA;CAClC,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,EAAE,SAAS,CAAC,eAAe,CAAA;IACpC,WAAW,EAAE,WAAW,CAAA;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAOD;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,GAAI,iDAKzB,eAAe,KAAG,UAmEpB,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,EAAE,cAAc,GAAG,SAAS,CAAA;IACpC,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,GAAI,mCAI1B,gBAAgB,KAAG,UAAU,EA+E/B,CAAA"}

package/esm/parse/v3-1/webhook/toWebhooksV3.js

@@ -0,0 +1,130 @@
+import { toRequestBodyV3 } from '../requestBody/toRequestBodiesV3.js';
+import { toResponsesV3 } from '../response/toResponseV3.js';
+import { toParameterListV3 } from '../parameter/toParameterV3.js';
+import { OasWebhook } from '../../../oas/webhook/Webhook.js';
+import { toPathItemV3 } from '../pathItem/toPathItemV3.js';
+import { methodValues } from '../../../types/Method.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+import { toSecurityRequirementsV3 } from '../securityRequirement/toSecurityRequirement.js';
+import { isEmpty } from '../../../helpers/isEmpty.js';
+import { toExternalDocs } from '../externalDocs/toExternalDocs.js';
+import { toOptionalServersV3 } from '../server/toServerV3.js';
+/**
+ * Parses a single webhook Operation Object into an {@link OasWebhook}.
+ *
+ * Mirrors `toOperationV3` and reuses the same leaf field parsers
+ * (`toParameterListV3` / `toRequestBodyV3` / `toResponsesV3` / …) — the
+ * inner Operation Object is structurally identical. Only the orchestration
+ * is duplicated (the dialect-shaped glue), and the output is an
+ * `OasWebhook` carrying a `name`, not an `OasOperation` carrying a `path`.
+ */
+export const toWebhookV3 = ({ operation, webhookInfo, stackTrail, context }) => {
+    const { method, name, pathItem } = webhookInfo;
+    const { operationId, tags, summary, description, parameters, requestBody, responses, deprecated, security, externalDocs, servers, ...skipped } = operation;
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: operation,
+        context,
+        stackTrail,
+        parentType: 'operation'
+    });
+    const parsedParameters = stackTrail.trace('parameters', st => toParameterListV3({ parameters, stackTrail: st, context }));
+    const parsedRequestBody = stackTrail.trace('requestBody', st => toRequestBodyV3({ requestBody, stackTrail: st, context }));
+    const parsedResponses = stackTrail.trace('responses', st => toResponsesV3({ responses, stackTrail: st, context }));
+    const parsedSecurity = stackTrail.trace('security', st => toSecurityRequirementsV3({ security, stackTrail: st, context }));
+    const parsedExternalDocs = stackTrail.trace('externalDocs', st => toExternalDocs({ externalDocs, stackTrail: st, context }));
+    const parsedServers = stackTrail.trace('servers', st => toOptionalServersV3({ servers, stackTrail: st, context }));
+    return context.withStackTrail(stackTrail, () => new OasWebhook({
+        pathItem,
+        name,
+        method,
+        operationId,
+        summary,
+        tags,
+        description,
+        parameters: parsedParameters,
+        requestBody: parsedRequestBody,
+        responses: parsedResponses,
+        deprecated,
+        security: parsedSecurity,
+        externalDocs: parsedExternalDocs,
+        servers: parsedServers,
+        extensionFields
+    }, context));
+};
+/**
+ * Flattens the 3.1 `webhooks` map into `OasWebhook[]`, mirroring
+ * `toOperationsV3`'s `paths` → `OasOperation[]` flattening. Returns `[]`
+ * when no `webhooks` object is present (the common 3.0 / no-webhook case).
+ * The stack trail nests `webhooks` → `<name>` → `<method>` so
+ * `OasDocument.removeItem` can locate a webhook by name.
+ */
+export const toWebhooksV3 = ({ webhooks, stackTrail, context }) => {
+    if (!webhooks) {
+        return [];
+    }
+    return Object.entries(webhooks).flatMap(([name, pathItem]) => {
+        return stackTrail.trace(name, nameStack => {
+            if (!pathItem) {
+                return [];
+            }
+            const cleaned = Object.entries(pathItem).reduce(({ rest, methodObject }, [key, operation]) => {
+                const isMethod = methodValues.includes(key);
+                if (isMethod) {
+                    const { [key]: _deleted, ...remaining } = rest;
+                    return {
+                        rest: remaining,
+                        methodObject: {
+                            ...methodObject,
+                            [key]: operation
+                        }
+                    };
+                }
+                return { rest, methodObject };
+            }, {
+                rest: pathItem,
+                methodObject: {}
+            });
+            const pathItemObject = !isEmpty(cleaned.rest)
+                ? toPathItemV3({ pathItem: cleaned.rest, stackTrail: nameStack, context })
+                : undefined;
+            return Object.entries(cleaned.methodObject)
+                .map(([method, operation]) => {
+                // Use `nameStack` (the trail with the webhook name already
+                // pushed) so downstream traces record webhooks:<name>:<method>:…
+                // — the trail `OasDocument.removeItem` matches a webhook on.
+                return nameStack.trace(method, st => {
+                    if (!operation) {
+                        return;
+                    }
+                    try {
+                        return toWebhookV3({
+                            operation,
+                            webhookInfo: {
+                                method: method,
+                                name,
+                                pathItem: pathItemObject
+                            },
+                            stackTrail: st,
+                            context
+                        });
+                    }
+                    catch (error) {
+                        const normalized = error instanceof Error ? error : new Error(String(error));
+                        context.logIssue({
+                            key: method,
+                            parent: operation,
+                            level: 'error',
+                            message: normalized.message,
+                            cause: normalized,
+                            stackTrail: st,
+                            type: 'INVALID_OPERATION'
+                        });
+                        return undefined;
+                    }
+                });
+            })
+                .filter((item) => Boolean(item));
+        });
+    });
+};

package/esm/run/toArtifacts.d.ts

@@ -1,9 +1,11 @@
 import type { ClientSettings } from '../types/Settings.js';
-import type { PrettierConfigType } from '../types/PrettierConfig.js';
 import type { ManifestContent } from '../types/Manifest.js';
 import type { GeneratorsMapContainer } from '../types/GeneratorType.js';
-import type { OpenAPIV3 } from 'openapi-types';
 import type { StackTrail } from '../context/StackTrail.js';
+import type { SkmtcDocumentInput } from '../types/SkmtcDocument.js';
+import type { AttributionState } from '../types/AttributionState.js';
+import type { Sidecar } from '../anchors/sidecar.js';
+import type { GenerationMapEntry } from '../anchors/generationMap.js';
 /**
  * Arguments for the {@link toArtifacts} transformation function.
  *
@@ -28,12 +30,15 @@ type TransformArgs = {
     traceId: string;
     /** Unique identifier for this transformation span */
     spanId: string;
-    /** The OpenAPI v3 document to process */
-    documentObject: OpenAPIV3.Document;
+    /**
+     * Source document. Discriminated union: an OpenAPI v3 document
+     * (`{ type: 'oas', value }`) or a GraphQL SDL string / `GraphQLSchema`
+     * (`{ type: 'gql', value }`). Protocol-specific parsing runs inside
+     * the pipeline.
+     */
+    document: SkmtcDocumentInput;
     /** Client settings for customizing generation behavior */
     settings: ClientSettings | undefined;
-    /** Optional Prettier configuration for code formatting */
-    prettier?: PrettierConfigType;
     /** Optional path for writing log files */
     logsPath?: string;
     /** Stack trail for distributed tracing */
@@ -44,6 +49,12 @@ type TransformArgs = {
     startAt: number;
     /** Whether to suppress console output during generation */
     silent: boolean;
+    /**
+     * Optional attribution (gen-maps) state. When set with a
+     * `postPass` block, the pipeline emits sidecars + a generation-map index
+     * alongside the standard artifacts. See {@link AttributionState}.
+     */
+    attribution?: AttributionState;
 };
 /**
  * Transforms an OpenAPI v3 document into generated code artifacts and metadata.
@@ -96,24 +107,6 @@ type TransformArgs = {
  * console.log(`Generation took ${result.manifest.endAt - result.manifest.startAt}ms`);
  * ```
  *
- * @example With Prettier formatting
- * ```typescript
- * const result = await toArtifacts({
- *   traceId: 'formatted-generation',
- *   spanId: 'api-client',
- *   documentObject: openApiDoc,
- *   settings: clientSettings,
- *   prettier: {
- *     semi: true,
- *     singleQuote: true,
- *     trailingComma: 'es5'
- *   },
- *   toGeneratorConfigMap: () => generatorMap,
- *   startAt: Date.now(),
- *   silent: true
- * });
- * ```
- *
  * @example Error handling
  * ```typescript
  * try {
@@ -131,9 +124,11 @@ type TransformArgs = {
  * }
  * ```
  */
-export declare const toArtifacts: ({ traceId, spanId, documentObject, settings, prettier, toGeneratorConfigMap, logsPath, startAt, silent, stackTrail }: TransformArgs) => {
+export declare const toArtifacts: ({ traceId, spanId, document, settings, toGeneratorConfigMap, logsPath, startAt, silent, stackTrail, attribution }: TransformArgs) => {
     artifacts: Record<string, string>;
     manifest: ManifestContent;
+    sidecars?: Record<string, Sidecar>;
+    generationMap?: GenerationMapEntry[];
 };
 export {};
 //# sourceMappingURL=toArtifacts.d.ts.map

package/esm/run/toArtifacts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toArtifacts.d.ts","sourceRoot":"","sources":["../../src/run/toArtifacts.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAEpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAA;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAE1D;;;;;;;;;;;;;;;;;;GAkBG;AACH,KAAK,aAAa,GAAG;IACnB,qDAAqD;IACrD,OAAO,EAAE,MAAM,CAAA;IACf,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAA;IACd,yCAAyC;IACzC,cAAc,EAAE,SAAS,CAAC,QAAQ,CAAA;IAClC,0DAA0D;IAC1D,QAAQ,EAAE,cAAc,GAAG,SAAS,CAAA;IACpC,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,kBAAkB,CAAA;IAC7B,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,0CAA0C;IAC1C,UAAU,EAAE,UAAU,CAAA;IACtB,4DAA4D;IAC5D,oBAAoB,EAAE,CAAC,cAAc,GAAG,SAAS,OAAO,sBAAsB,CAAC,cAAc,CAAC,CAAA;IAC9F,4CAA4C;IAC5C,OAAO,EAAE,MAAM,CAAA;IACf,2DAA2D;IAC3D,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqFG;AACH,eAAO,MAAM,WAAW,GAAI,sHAWzB,aAAa,KAAG;IAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,QAAQ,EAAE,eAAe,CAAA;CA0BhF,CAAA"}
+{"version":3,"file":"toArtifacts.d.ts","sourceRoot":"","sources":["../../src/run/toArtifacts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAA;AACvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAA;AACpE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AACpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAA;AAErE;;;;;;;;;;;;;;;;;;GAkBG;AACH,KAAK,aAAa,GAAG;IACnB,qDAAqD;IACrD,OAAO,EAAE,MAAM,CAAA;IACf,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAA;IACd;;;;;OAKG;IACH,QAAQ,EAAE,kBAAkB,CAAA;IAC5B,0DAA0D;IAC1D,QAAQ,EAAE,cAAc,GAAG,SAAS,CAAA;IACpC,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,0CAA0C;IAC1C,UAAU,EAAE,UAAU,CAAA;IACtB,4DAA4D;IAC5D,oBAAoB,EAAE,CAAC,cAAc,GAAG,SAAS,OAAO,sBAAsB,CAAC,cAAc,CAAC,CAAA;IAC9F,4CAA4C;IAC5C,OAAO,EAAE,MAAM,CAAA;IACf,2DAA2D;IAC3D,MAAM,EAAE,OAAO,CAAA;IACf;;;;OAIG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAA;CAC/B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,eAAO,MAAM,WAAW,GAAI,mHAWzB,aAAa,KAAG;IACjB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACjC,QAAQ,EAAE,eAAe,CAAA;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAClC,aAAa,CAAC,EAAE,kBAAkB,EAAE,CAAA;CAqCrC,CAAA"}

package/esm/run/toArtifacts.js

@@ -1,4 +1,3 @@
-import * as dntShim from "../_dnt.shims.js";
 import { CoreContext } from '../context/CoreContext.js';
 /**
  * Transforms an OpenAPI v3 document into generated code artifacts and metadata.
@@ -51,24 +50,6 @@ import { CoreContext } from '../context/CoreContext.js';
  * console.log(`Generation took ${result.manifest.endAt - result.manifest.startAt}ms`);
  * ```
  *
- * @example With Prettier formatting
- * ```typescript
- * const result = await toArtifacts({
- *   traceId: 'formatted-generation',
- *   spanId: 'api-client',
- *   documentObject: openApiDoc,
- *   settings: clientSettings,
- *   prettier: {
- *     semi: true,
- *     singleQuote: true,
- *     trailingComma: 'es5'
- *   },
- *   toGeneratorConfigMap: () => generatorMap,
- *   startAt: Date.now(),
- *   silent: true
- * });
- * ```
- *
  * @example Error handling
  * ```typescript
  * try {
@@ -86,15 +67,15 @@ import { CoreContext } from '../context/CoreContext.js';
  * }
  * ```
  */
-export const toArtifacts = ({ traceId, spanId, documentObject, settings, prettier, toGeneratorConfigMap, logsPath, startAt, silent, stackTrail }) => {
+export const toArtifacts = ({ traceId, spanId, document, settings, toGeneratorConfigMap, logsPath, startAt, silent, stackTrail, attribution }) => {
     const context = new CoreContext({ spanId, logsPath, silent });
-    const { artifacts, files, previews, results, mappings } = context.toArtifacts({
+    const { artifacts, files, previews, results, mappings, parseIssues, sidecars, generationMap } = context.toArtifacts({
         settings,
         toGeneratorConfigMap,
-        prettier,
-        documentObject,
+        document,
         stackTrail,
-        silent
+        silent,
+        attribution
     });
     const manifest = {
         files,
@@ -103,10 +84,11 @@ export const toArtifacts = ({ traceId, spanId, documentObject, settings, prettie
         traceId,
         spanId,
         results,
-        deploymentId: dntShim.Deno.env.get('DENO_DEPLOYMENT_ID') ?? Date.now().toString(),
-        region: dntShim.Deno.env.get('DENO_REGION'),
+        parseIssues,
+        deploymentId: Date.now().toString(),
+        region: undefined,
         startAt,
         endAt: Date.now()
     };
-    return { artifacts, manifest };
+    return { artifacts, manifest, sidecars, generationMap };
 };

package/esm/run/toEnrichmentDefaults.d.ts

@@ -0,0 +1,51 @@
+import type { ClientSettings } from '../types/Settings.js';
+import type { GeneratorsMapContainer } from '../types/GeneratorType.js';
+import type { StackTrail } from '../context/StackTrail.js';
+import type { SkmtcDocumentInput } from '../types/SkmtcDocument.js';
+import type { EnrichmentDefaults } from '../types/EnrichmentDefaults.js';
+import type { ParseIssue } from '../context/ParseIssue.js';
+/**
+ * Arguments for {@link toEnrichmentDefaults}. The seed-values counterpart of
+ * `SupportedSubjectsArgs` — same parse-then-capability shape, no attribution.
+ */
+type EnrichmentDefaultsArgs = {
+    /** Unique identifier for the trace */
+    traceId: string;
+    /** Unique identifier for this span */
+    spanId: string;
+    /**
+     * Source document. OAS variant carries the OpenAPI v3 JSON; GQL variant
+     * carries the SDL string. Protocol-specific parsing runs inside the pipeline.
+     */
+    document: SkmtcDocumentInput;
+    /** Client settings (only `include` / `skip` affect which generators run). */
+    settings: ClientSettings | undefined;
+    /** Stack trail for distributed tracing */
+    stackTrail: StackTrail;
+    /** Function that returns the generator configuration map */
+    toGeneratorConfigMap: <EnrichmentType = undefined>() => GeneratorsMapContainer<EnrichmentType>;
+    /** Whether to suppress console output */
+    silent: boolean;
+    /** Optional path for writing log files */
+    logsPath?: string;
+};
+/**
+ * Compute the seed enrichment values each configured generator derives from a
+ * document — the "Generate fields from schema" payload the CMS persists and the
+ * user then edits.
+ *
+ * Runs Parse + a values pass: every generator that advertises
+ * `toEnrichmentDefaults` is called over the subjects it supports, with no
+ * transform and no render. The result mirrors the
+ * `client.json#settings.enrichments` subtree (subject scope only) so a host can
+ * fold it straight into settings.
+ *
+ * Like {@link toSupportedSubjects} it fails open: a bad schema surfaces as a
+ * `parseIssue`, not a throw, and the defaults map is returned empty.
+ */
+export declare const toEnrichmentDefaults: ({ spanId, document, settings, toGeneratorConfigMap, stackTrail, silent, logsPath }: EnrichmentDefaultsArgs) => {
+    enrichmentDefaults: EnrichmentDefaults;
+    parseIssues: ParseIssue[];
+};
+export {};
+//# sourceMappingURL=toEnrichmentDefaults.d.ts.map

package/esm/run/toEnrichmentDefaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toEnrichmentDefaults.d.ts","sourceRoot":"","sources":["../../src/run/toEnrichmentDefaults.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAA;AACvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AACxE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAE1D;;;GAGG;AACH,KAAK,sBAAsB,GAAG;IAC5B,sCAAsC;IACtC,OAAO,EAAE,MAAM,CAAA;IACf,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAA;IACd;;;OAGG;IACH,QAAQ,EAAE,kBAAkB,CAAA;IAC5B,6EAA6E;IAC7E,QAAQ,EAAE,cAAc,GAAG,SAAS,CAAA;IACpC,0CAA0C;IAC1C,UAAU,EAAE,UAAU,CAAA;IACtB,4DAA4D;IAC5D,oBAAoB,EAAE,CAAC,cAAc,GAAG,SAAS,OAAO,sBAAsB,CAAC,cAAc,CAAC,CAAA;IAC9F,yCAAyC;IACzC,MAAM,EAAE,OAAO,CAAA;IACf,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,GAAI,oFAQlC,sBAAsB,KAAG;IAC1B,kBAAkB,EAAE,kBAAkB,CAAA;IACtC,WAAW,EAAE,UAAU,EAAE,CAAA;CAU1B,CAAA"}

package/esm/run/toEnrichmentDefaults.js

@@ -0,0 +1,24 @@
+import { CoreContext } from '../context/CoreContext.js';
+/**
+ * Compute the seed enrichment values each configured generator derives from a
+ * document — the "Generate fields from schema" payload the CMS persists and the
+ * user then edits.
+ *
+ * Runs Parse + a values pass: every generator that advertises
+ * `toEnrichmentDefaults` is called over the subjects it supports, with no
+ * transform and no render. The result mirrors the
+ * `client.json#settings.enrichments` subtree (subject scope only) so a host can
+ * fold it straight into settings.
+ *
+ * Like {@link toSupportedSubjects} it fails open: a bad schema surfaces as a
+ * `parseIssue`, not a throw, and the defaults map is returned empty.
+ */
+export const toEnrichmentDefaults = ({ spanId, document, settings, toGeneratorConfigMap, stackTrail, silent, logsPath }) => {
+    const context = new CoreContext({ spanId, logsPath, silent });
+    return context.toEnrichmentDefaults({
+        document,
+        settings,
+        toGeneratorConfigMap,
+        stackTrail
+    });
+};

package/esm/run/toSupportedSubjects.d.ts

@@ -0,0 +1,48 @@
+import type { ClientSettings } from '../types/Settings.js';
+import type { GeneratorsMapContainer } from '../types/GeneratorType.js';
+import type { StackTrail } from '../context/StackTrail.js';
+import type { SkmtcDocumentInput } from '../types/SkmtcDocument.js';
+import type { SupportedSubjects } from '../types/SupportedSubjects.js';
+import type { ParseIssue } from '../context/ParseIssue.js';
+/**
+ * Arguments for {@link toSupportedSubjects}. The capability-only counterpart of
+ * `TransformArgs` — no attribution, since nothing is rendered.
+ */
+type SupportedSubjectsArgs = {
+    /** Unique identifier for the trace */
+    traceId: string;
+    /** Unique identifier for this span */
+    spanId: string;
+    /**
+     * Source document. OAS variant carries the OpenAPI v3 JSON; GQL variant
+     * carries the SDL string. Protocol-specific parsing runs inside the pipeline.
+     */
+    document: SkmtcDocumentInput;
+    /** Client settings (only `include` / `skip` affect which generators run). */
+    settings: ClientSettings | undefined;
+    /** Stack trail for distributed tracing */
+    stackTrail: StackTrail;
+    /** Function that returns the generator configuration map */
+    toGeneratorConfigMap: <EnrichmentType = undefined>() => GeneratorsMapContainer<EnrichmentType>;
+    /** Whether to suppress console output */
+    silent: boolean;
+    /** Optional path for writing log files */
+    logsPath?: string;
+};
+/**
+ * Report the subjects each configured generator supports for a document.
+ *
+ * Runs only Parse + a capability pass — every generator's `isSupported` is
+ * evaluated over the document's operations / models, with no transform and no
+ * render. Use this to drive a UI that needs to know, ahead of a run, which
+ * operations / models each generator would process.
+ *
+ * Like {@link toArtifacts} it fails open: a bad schema surfaces as a
+ * `parseIssue`, not a throw, and the supported map is returned empty.
+ */
+export declare const toSupportedSubjects: ({ spanId, document, settings, toGeneratorConfigMap, stackTrail, silent, logsPath }: SupportedSubjectsArgs) => {
+    subjects: SupportedSubjects;
+    parseIssues: ParseIssue[];
+};
+export {};
+//# sourceMappingURL=toSupportedSubjects.d.ts.map

package/esm/run/toSupportedSubjects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toSupportedSubjects.d.ts","sourceRoot":"","sources":["../../src/run/toSupportedSubjects.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAA;AACvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AACnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAA;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAE1D;;;GAGG;AACH,KAAK,qBAAqB,GAAG;IAC3B,sCAAsC;IACtC,OAAO,EAAE,MAAM,CAAA;IACf,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAA;IACd;;;OAGG;IACH,QAAQ,EAAE,kBAAkB,CAAA;IAC5B,6EAA6E;IAC7E,QAAQ,EAAE,cAAc,GAAG,SAAS,CAAA;IACpC,0CAA0C;IAC1C,UAAU,EAAE,UAAU,CAAA;IACtB,4DAA4D;IAC5D,oBAAoB,EAAE,CAAC,cAAc,GAAG,SAAS,OAAO,sBAAsB,CAAC,cAAc,CAAC,CAAA;IAC9F,yCAAyC;IACzC,MAAM,EAAE,OAAO,CAAA;IACf,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,GAAI,oFAQjC,qBAAqB,KAAG;IAAE,QAAQ,EAAE,iBAAiB,CAAC;IAAC,WAAW,EAAE,UAAU,EAAE,CAAA;CASlF,CAAA"}