@skmtc/core 0.0.983 → 0.16.1

package/esm/context/ParseIssue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParseIssue.d.ts","sourceRoot":"","sources":["../../src/context/ParseIssue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,MAAM,YAAY,GACpB,mBAAmB,GACnB,mBAAmB,GACnB,mBAAmB,GACnB,yBAAyB,GACzB,iBAAiB,GACjB,yBAAyB,GACzB,wBAAwB,CAAA;AAE5B;;;;;GAKG;AACH,eAAO,MAAM,YAAY,kYAQvB,CAAA;AAKF,MAAM,MAAM,UAAU,GAClB;IACE,QAAQ,EAAE,KAAK,CAAA;IACf,KAAK,EAAE,OAAO,CAAA;IACd,IAAI,EAAE,YAAY,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,GACD;IACE,QAAQ,EAAE,KAAK,CAAA;IACf,KAAK,EAAE,SAAS,CAAA;IAChB,IAAI,EAAE,YAAY,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAChB,GACD;IACE,QAAQ,EAAE,KAAK,CAAA;IACf,KAAK,EAAE,OAAO,CAAA;IACd,IAAI,EAAE,YAAY,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,GACD;IACE,QAAQ,EAAE,KAAK,CAAA;IACf,KAAK,EAAE,SAAS,CAAA;IAChB,IAAI,EAAE,YAAY,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA"}

package/esm/context/ParseIssue.js

@@ -0,0 +1,33 @@
+/**
+ * Unified discriminated union for parse-time issues across both OAS and
+ * GraphQL parsing. Each variant stands on its own — no shared base —
+ * so TypeScript narrows cleanly on `protocol` and `level`.
+ *
+ * `cause?: unknown` is only present on the error variants. Warnings are
+ * synthesized by the parser with all the information needed for the
+ * `message`; errors usually wrap a thrown `Error`, which we keep in
+ * `cause` for debugging without forcing renderers to know about it.
+ *
+ * `location` is the schema-level address of the issue: for OAS it's the
+ * stringified stack trail (e.g. `components.schemas.User.properties.email`);
+ * for GraphQL it's the schema-level address used by the GQL parser
+ * (e.g. `Query.getUser.return`).
+ */
+import * as v from 'valibot';
+/**
+ * Valibot schema for {@link GqlIssueType}. Annotation deliberately
+ * omitted so the precise literal-union output type flows through to
+ * consumers; drift between this list and {@link GqlIssueType} is
+ * caught by the compile-time assertion below.
+ */
+export const gqlIssueType = v.union([
+    v.literal('NESTED_LIST_LOSSY'),
+    v.literal('UNKNOWN_TYPE_KIND'),
+    v.literal('DROPPED_DIRECTIVE'),
+    v.literal('SKIPPED_FIELD_ARGUMENTS'),
+    v.literal('SKIPPED_FEATURE'),
+    v.literal('INVALID_TYPE_DEFINITION'),
+    v.literal('INVALID_DEPENDENCY_REF')
+]);
+const _gqlIssueTypeDriftCheck = gqlIssueType;
+void _gqlIssueTypeDriftCheck;

package/esm/context/RenderContext.d.ts

@@ -1,47 +1,71 @@
-import type { PrettierConfigType } from '../types/PrettierConfig.js';
 import type { FilesRenderResult, RenderResult } from './generateTypes.js';
-import type { Definition } from '../dsl/Definition.js';
+import type { DefinitionBase } from '../dsl/Definition.js';
 import type { PickArgs } from './generateTypes.js';
 import type { ResultType } from '../types/Results.js';
 import type * as log from '../deps/jsr.io/@std/log/0.224.14/mod.js';
 import type { Logger } from '../types/Logger.js';
-import { File } from '../dsl/File.js';
+import type { FileBase } from '../dsl/FileBase.js';
 import type { Preview, Mapping } from '../types/Preview.js';
-import type { JsonFile } from '../dsl/JsonFile.js';
 import type { StackTrail } from './StackTrail.js';
+import { type CaptureChannel } from '../anchors/CaptureSink.js';
+import type { GenerationMapEntry } from '../anchors/generationMap.js';
+import type { AttributionState } from '../types/AttributionState.js';
+import type { Sidecar } from '../anchors/sidecar.js';
+/**
+ * Result of the render phase: artifacts + file metadata + previews +
+ * mappings, plus the attribution sidecars / generation-map when the run
+ * configured `attribution.postPass`.
+ */
+type RenderPhaseResult = Omit<RenderResult, 'results'> & {
+    sidecars?: Record<string, Sidecar>;
+    generationMap?: GenerationMapEntry[];
+};
 /**
  * Constructor arguments for {@link RenderContext}.
  */
 type ConstructorArgs = {
     /** Map of generated files to render */
-    files: Map<string, File | JsonFile>;
+    files: Map<string, FileBase>;
     /** Preview data for generated content */
-    previews: Record<string, Record<string, Preview>>;
+    previews: Record<string, Preview>;
     /** Mapping data for file relationships */
-    mappings: Record<string, Record<string, Mapping>>;
-    /** Optional formatter configuration (using Prettier format for compatibility) */
-    prettierConfig?: PrettierConfigType;
+    mappings: Record<string, Mapping>;
     /** Base path for resolving file paths */
     basePath: string | undefined;
     /** Logger instance for debug information */
     logger: log.Logger;
     /** Function to capture result status */
     captureCurrentResult: (result: ResultType, stackTrail: StackTrail) => void;
+    /**
+     * Attribution (gen-maps) emission config. When `postPass` is set, the
+     * single render pass also captures the producer occurrence tree and
+     * emits sidecars + a generation map. Capture is skipped entirely when
+     * absent — plain render, the capture interval never opens.
+     */
+    attribution?: AttributionState;
+    /**
+     * Shared attribution capture channel — the same object the run's
+     * `GenerateContext` holds, so snippets see the sink this context
+     * publishes during the capturing render. Wired by `CoreContext`.
+     */
+    captureChannel?: CaptureChannel;
 };
 export declare class RenderContext {
     #private;
     /** Map of generated files to render */
-    files: Map<string, File | JsonFile>;
+    files: Map<string, FileBase>;
     /** Preview data for generated content */
-    previews: Record<string, Record<string, Preview>>;
+    previews: Record<string, Preview>;
     /** Mapping data for file relationships */
-    mappings: Record<string, Record<string, Mapping>>;
+    mappings: Record<string, Mapping>;
     /** Base path for resolving file paths */
     basePath: string | undefined;
     /** Logger instance for debug information */
     logger: Logger;
     /** Function to capture result status */
     captureCurrentResult: (result: ResultType, stackTrail: StackTrail) => void;
+    /** Attribution (gen-maps) emission config; see {@link ConstructorArgs}. */
+    attribution: AttributionState | undefined;
     /**
      * Creates a new RenderContext instance with the specified configuration.
      *
@@ -50,13 +74,12 @@ export declare class RenderContext {
      *
      * @param args - Constructor arguments containing all required configuration
      */
-    constructor({ files, previews, mappings, prettierConfig, basePath, logger, captureCurrentResult }: ConstructorArgs);
+    constructor({ files, previews, mappings, basePath, logger, captureCurrentResult, attribution, captureChannel }: ConstructorArgs);
     /**
-     * Renders all files in the context to their final formatted form.
+     * Renders all files in the context to their final form.
      *
-     * This is the main rendering method that orchestrates the collation and
-     * formatting of all generated files. It processes files through Biome
-     * formatting (if configured), resolves paths, and produces the final
+     * This is the main rendering method that orchestrates the collation of
+     * all generated files. It resolves paths and produces the final
      * artifacts ready for writing to the filesystem.
      *
      * @returns Promise resolving to render result containing artifacts, file metadata, previews, and mappings
@@ -67,7 +90,6 @@ export declare class RenderContext {
      *   files: generatedFiles,
      *   previews: previewData,
      *   mappings: mappingData,
-     *   prettierConfig: { semi: false, singleQuote: true },
      *   basePath: './src/generated',
      *   stackTrail: traceStack,
      *   logger: logger,
@@ -82,16 +104,16 @@ export declare class RenderContext {
      * });
      * ```
      */
-    render(stackTrail: StackTrail): Omit<RenderResult, 'results'>;
+    render(stackTrail: StackTrail): RenderPhaseResult;
     /**
      * Collates all files in the context into a unified render result.
      *
      * This method processes each file in the context through the rendering pipeline,
-     * applying Biome formatting and path resolution. It coordinates the parallel
-     * processing of all files and aggregates the results into a single output structure.
+     * applying path resolution. It coordinates the parallel processing of all files
+     * and aggregates the results into a single output structure.
      *
      * The collation process includes:
-     * - File content rendering with optional Biome formatting
+     * - File content rendering
      * - Path resolution using base path configuration
      * - Metadata calculation (line count, character count)
      * - Result aggregation into artifacts and file metadata maps
@@ -132,7 +154,7 @@ export declare class RenderContext {
      * const alsoSameFile = renderContext.getFile('/absolute/path/src/models/User.ts');
      * ```
      */
-    getFile(filePath: string): File | JsonFile;
+    getFile(filePath: string): FileBase;
     /**
      * Picks a specific definition from a file in the context.
      *
@@ -164,7 +186,7 @@ export declare class RenderContext {
      * });
      * ```
      */
-    pick({ name, exportPath }: PickArgs): Definition | undefined;
+    pick({ name, exportPath }: PickArgs): DefinitionBase | undefined;
 }
 export {};
 //# sourceMappingURL=RenderContext.d.ts.map

package/esm/context/RenderContext.d.ts.map

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

package/esm/context/RenderContext.js

@@ -9,11 +9,14 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _RenderContext_prettierConfig;
+var _RenderContext_captureChannel, _RenderContext_sink, _RenderContext_captures;
 import invariant from 'tiny-invariant';
-import { normalize } from '../deps/jsr.io/@std/path/1.1.3/normalize.js';
+import { normalize } from '../deps/jsr.io/@std/path/1.1.4/normalize.js';
 import { toResolvedArtifactPath } from '../helpers/toResolvedArtifactPath.js';
-import { File } from '../dsl/File.js';
+import { CodeFileBase } from '../dsl/CodeFileBase.js';
+import { CaptureSink } from '../anchors/CaptureSink.js';
+import { postPass } from '../anchors/postPass.js';
+import { entriesForSidecar } from '../anchors/generationMap.js';
 export class RenderContext {
     /**
      * Creates a new RenderContext instance with the specified configuration.
@@ -23,7 +26,7 @@ export class RenderContext {
      *
      * @param args - Constructor arguments containing all required configuration
      */
-    constructor({ files, previews, mappings, prettierConfig, basePath, logger, captureCurrentResult }) {
+    constructor({ files, previews, mappings, basePath, logger, captureCurrentResult, attribution, captureChannel }) {
         /** Map of generated files to render */
         Object.defineProperty(this, "files", {
             enumerable: true,
@@ -45,8 +48,6 @@ export class RenderContext {
             writable: true,
             value: void 0
         });
-        /** Optional formatter configuration (using Prettier format for compatibility) */
-        _RenderContext_prettierConfig.set(this, void 0);
         /** Base path for resolving file paths */
         Object.defineProperty(this, "basePath", {
             enumerable: true,
@@ -68,20 +69,55 @@ export class RenderContext {
             writable: true,
             value: void 0
         });
+        /** Attribution (gen-maps) emission config; see {@link ConstructorArgs}. */
+        Object.defineProperty(this, "attribution", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Shared attribution capture channel — the same object the
+         * `GenerateContext` exposes to snippets as `captureSink`. `render` opens
+         * the capture interval by setting `channel.sink` and closes it in
+         * `finally`. Optional: a capturing render without a channel records no
+         * occurrences (snippets read their own context's channel).
+         */
+        _RenderContext_captureChannel.set(this, void 0);
+        /**
+         * Active capture sink for the in-progress render pass, or `undefined`
+         * when rendering without attribution. `collate` checks this to decide
+         * whether to capture; set + cleared by `render`.
+         */
+        _RenderContext_sink.set(this, void 0);
+        /**
+         * Per-file render output retained during a capturing render, consumed
+         * by `render` to build sidecars. Reset each capturing render.
+         */
+        _RenderContext_captures.set(this, []
+        /**
+         * Creates a new RenderContext instance with the specified configuration.
+         *
+         * Initializes the rendering context with files to render, preview data,
+         * formatting configuration, and logging/tracing infrastructure.
+         *
+         * @param args - Constructor arguments containing all required configuration
+         */
+        );
         this.files = files;
         this.previews = previews;
         this.mappings = mappings;
-        __classPrivateFieldSet(this, _RenderContext_prettierConfig, prettierConfig, "f");
         this.basePath = basePath;
         this.logger = logger;
         this.captureCurrentResult = captureCurrentResult;
+        this.attribution = attribution;
+        __classPrivateFieldSet(this, _RenderContext_captureChannel, captureChannel, "f");
     }
     /**
-     * Renders all files in the context to their final formatted form.
+     * Renders all files in the context to their final form.
      *
-     * This is the main rendering method that orchestrates the collation and
-     * formatting of all generated files. It processes files through Biome
-     * formatting (if configured), resolves paths, and produces the final
+     * This is the main rendering method that orchestrates the collation of
+     * all generated files. It resolves paths and produces the final
      * artifacts ready for writing to the filesystem.
      *
      * @returns Promise resolving to render result containing artifacts, file metadata, previews, and mappings
@@ -92,7 +128,6 @@ export class RenderContext {
      *   files: generatedFiles,
      *   previews: previewData,
      *   mappings: mappingData,
-     *   prettierConfig: { semi: false, singleQuote: true },
      *   basePath: './src/generated',
      *   stackTrail: traceStack,
      *   logger: logger,
@@ -108,24 +143,76 @@ export class RenderContext {
      * ```
      */
     render(stackTrail) {
-        const result = this.collate(stackTrail);
-        const rendered = {
+        const postPassConfig = this.attribution?.postPass;
+        // No emission configured → plain render, no capture: the capture
+        // interval never opens, so every snippet's `toString` wrapper takes
+        // the pass-through path.
+        if (!postPassConfig) {
+            const result = this.collate(stackTrail);
+            return {
+                artifacts: result.artifacts,
+                files: result.files,
+                previews: this.previews,
+                mappings: this.mappings
+            };
+        }
+        // Capturing render: open the capture interval by publishing a sink on
+        // the shared channel for the single `collate` walk, and close it in
+        // `finally`. Snippets' self-installed `toString` wrappers observe into
+        // the sink; `collate` routes each File's render through it.
+        const sink = new CaptureSink();
+        __classPrivateFieldSet(this, _RenderContext_sink, sink, "f");
+        __classPrivateFieldSet(this, _RenderContext_captures, [], "f");
+        if (__classPrivateFieldGet(this, _RenderContext_captureChannel, "f")) {
+            __classPrivateFieldGet(this, _RenderContext_captureChannel, "f").sink = sink;
+        }
+        let result;
+        try {
+            result = this.collate(stackTrail);
+        }
+        finally {
+            if (__classPrivateFieldGet(this, _RenderContext_captureChannel, "f")) {
+                __classPrivateFieldGet(this, _RenderContext_captureChannel, "f").sink = undefined;
+            }
+            __classPrivateFieldSet(this, _RenderContext_sink, undefined, "f");
+        }
+        // Build one sidecar per captured File from the spans the sink
+        // resolved (no re-render, no `toString`). Keyed by destination path,
+        // matching the file map. Accumulate the flat generation map.
+        const { parser, schemaSrc, generatorMeta } = postPassConfig;
+        const sidecars = {};
+        const generationMap = [];
+        for (const capture of __classPrivateFieldGet(this, _RenderContext_captures, "f")) {
+            const sidecar = postPass({
+                filePath: capture.filePath,
+                source: capture.source,
+                spans: capture.spans,
+                schemaSrc,
+                parser,
+                generatorMeta
+            });
+            sidecars[capture.destinationPath] = sidecar;
+            generationMap.push(...entriesForSidecar(sidecar));
+        }
+        __classPrivateFieldSet(this, _RenderContext_captures, [], "f");
+        return {
             artifacts: result.artifacts,
             files: result.files,
             previews: this.previews,
-            mappings: this.mappings
+            mappings: this.mappings,
+            sidecars,
+            generationMap
         };
-        return rendered;
     }
     /**
      * Collates all files in the context into a unified render result.
      *
      * This method processes each file in the context through the rendering pipeline,
-     * applying Biome formatting and path resolution. It coordinates the parallel
-     * processing of all files and aggregates the results into a single output structure.
+     * applying path resolution. It coordinates the parallel processing of all files
+     * and aggregates the results into a single output structure.
      *
      * The collation process includes:
-     * - File content rendering with optional Biome formatting
+     * - File content rendering
      * - Path resolution using base path configuration
      * - Metadata calculation (line count, character count)
      * - Result aggregation into artifacts and file metadata maps
@@ -149,11 +236,29 @@ export class RenderContext {
         const fileObjects = fileEntries
             .map(([destinationPath, file]) => {
             return stackTrail.trace(destinationPath, st => {
+                // When capturing, route a File's render through the sink so the
+                // occurrence tree + spans are recorded for this one render.
+                // JsonFile (and the non-capturing path) render plainly — the
+                // installed wrapper is inert while the sink is not in a
+                // `captureFile` call.
+                let content;
+                if (__classPrivateFieldGet(this, _RenderContext_sink, "f") && file instanceof CodeFileBase) {
+                    const captured = __classPrivateFieldGet(this, _RenderContext_sink, "f").captureFile(() => file.toString());
+                    content = captured.text;
+                    __classPrivateFieldGet(this, _RenderContext_captures, "f").push({
+                        destinationPath,
+                        filePath: file.path,
+                        source: captured.text,
+                        spans: captured.spans
+                    });
+                }
+                else {
+                    content = file.toString();
+                }
                 const renderedFile = renderFile({
-                    content: file.toString(),
+                    content,
                     destinationPath,
-                    basePath: this.basePath,
-                    prettierConfig: __classPrivateFieldGet(this, _RenderContext_prettierConfig, "f")
+                    basePath: this.basePath
                 });
                 this.captureCurrentResult('success', st);
                 return renderedFile;
@@ -196,9 +301,9 @@ export class RenderContext {
      * ```
      */
     getFile(filePath) {
-        const normalisedPath = normalize(filePath);
-        const currentFile = this.files.get(normalisedPath);
-        invariant(currentFile, `File not found during render phase: ${normalisedPath}`);
+        const normalizedPath = normalize(filePath);
+        const currentFile = this.files.get(normalizedPath);
+        invariant(currentFile, `File not found during render phase: ${normalizedPath}`);
         return currentFile;
     }
     /**
@@ -234,35 +339,33 @@ export class RenderContext {
      */
     pick({ name, exportPath }) {
         const file = this.getFile(exportPath);
-        invariant(file instanceof File, `File at "${exportPath}" is not a "File" type`);
+        invariant(file instanceof CodeFileBase, `File at "${exportPath}" is not a code file`);
         return file.definitions.get(name);
     }
 }
-_RenderContext_prettierConfig = new WeakMap();
+_RenderContext_captureChannel = new WeakMap(), _RenderContext_sink = new WeakMap(), _RenderContext_captures = new WeakMap();
 /**
- * Renders a single file with formatting and metadata calculation.
+ * Renders a single file with metadata calculation.
  *
  * This function processes a single file through the rendering pipeline,
- * applying Biome formatting if configured and calculating file metadata
- * such as line count and character count. It resolves the final path using
- * the base path configuration.
+ * calculating file metadata such as line count and character count. It
+ * resolves the final path using the base path configuration.
  *
  * @param args - File rendering arguments
- * @returns Promise resolving to a FileObject with content and metadata
+ * @returns A FileObject with content and metadata
  *
  * @example
  * ```typescript
- * const fileObject = await renderFile({
+ * const fileObject = renderFile({
  *   content: 'const x = 1;',
  *   destinationPath: 'utils.ts',
- *   basePath: './src',
- *   prettierConfig: { semi: false }
+ *   basePath: './src'
  * });
  *
  * console.log(fileObject.path); // './src/utils.ts'
- * console.log(fileObject.content); // 'const x = 1' (formatted)
+ * console.log(fileObject.content); // 'const x = 1;'
  * console.log(fileObject.lines); // 1
- * console.log(fileObject.characters); // 11
+ * console.log(fileObject.characters); // 12
  * ```
  */
 const renderFile = ({ content, destinationPath, basePath }) => {

package/esm/context/StackTrail.d.ts

@@ -1,6 +1,17 @@
+import "../_dnt.polyfills.js";
+import { type JsonPointer } from '../types/JsonPointer.js';
 export declare class StackTrail {
     #private;
     constructor(stack?: string[]);
+    /**
+     * The canonical empty trail — used for nodes that were synthesized
+     * programmatically rather than parsed from a source document (they
+     * have no position). Distinct from any parsed position: no parsed
+     * `OasBase` node ever sits at the empty trail.
+     */
+    static empty(): StackTrail;
+    /** True when the trail holds no frames (a synthetic / positionless node). */
+    isEmpty(): boolean;
     /**
      * Creates a shallow copy of the stack trail.
      *
@@ -77,6 +88,63 @@ export declare class StackTrail {
      * console.log(ref); // undefined
      * ```
      */
+    /**
+     * Converts the trail to an RFC 6901 JSON Pointer (URI fragment form).
+     *
+     * Unlike {@link toStackRef}, this works for *any* visitor path — not
+     * just components-rooted references. Used by the gen-maps system to
+     * attach a `location` field to every parsed OAS schema, recording
+     * exactly where in the document the schema lives.
+     *
+     * Special characters in stack frames (`/`, `~`) are escaped per
+     * RFC 6901.
+     *
+     * @returns A JSON Pointer string starting with `#/`
+     *
+     * @example Components-rooted
+     * ```typescript
+     * const trail = new StackTrail(['components', 'schemas', 'User'])
+     * trail.toJsonPointer() // '#/components/schemas/User'
+     * ```
+     *
+     * @example Path-rooted (escapes slashes in path segments)
+     * ```typescript
+     * const trail = new StackTrail(['paths', '/users/{id}', 'get'])
+     * trail.toJsonPointer() // '#/paths/~1users~1{id}/get'
+     * ```
+     */
+    toJsonPointer(): JsonPointer;
+    /**
+     * The **document-relative** JSON Pointer for a parsed node, with the
+     * run's operational prefix stripped — the resolvable form used as a
+     * schema pointer in gen-maps.
+     *
+     * A parsed node's trail is seeded with operational frames before any
+     * document traversal: the worker pushes `[traceId, spanId]` and
+     * `CoreContext.toArtifacts` wraps each phase in `.trace('parse', …)` /
+     * `.trace('generate', …)` etc. The document path
+     * (`components/schemas/Pet/properties/name`) is appended on top. Unlike
+     * {@link toJsonPointer} — which serializes the *whole* trail and so does
+     * NOT resolve against the input document — this drops everything up to
+     * and including the phase frame, leaving only the document-relative path.
+     *
+     * Protocol-agnostic: the remaining frames are the input document's own
+     * keys (`components`, `paths`, … for OAS), never an `oas:`/`gql:` scheme.
+     *
+     * Falls back to the full trail when no phase frame is present (a trail
+     * seeded empty — e.g. in tests — is already document-relative). Returns
+     * `#/` (document root) for the empty trail.
+     *
+     * @example
+     * ```typescript
+     * new StackTrail(['trace-1', 'span-1', 'parse', 'components', 'schemas', 'Pet'])
+     *   .toSchemaPointer() // '#/components/schemas/Pet'
+     *
+     * new StackTrail(['components', 'schemas', 'User']) // already doc-relative
+     *   .toSchemaPointer() // '#/components/schemas/User'
+     * ```
+     */
+    toSchemaPointer(): JsonPointer;
     toStackRef(): string | undefined;
     /**
      * Removes frame(s) from the end of the trail.

package/esm/context/StackTrail.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StackTrail.d.ts","sourceRoot":"","sources":["../../src/context/StackTrail.ts"],"names":[],"mappings":"AAEA,qBAAa,UAAU;;gBAIT,KAAK,GAAE,MAAM,EAAO;IAIhC;;;;;;;;;;;;;;OAcG;IACH,KAAK,IAAI,UAAU;IAInB;;;;;;;;;;;OAWG;IACH,IAAI,UAAU,IAAI,MAAM,EAAE,CAEzB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,UAAU;IAgB5C,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,UAAU,KAAK,CAAC,GAAG,CAAC;IAgB7C,UAAU,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,UAAU,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAgBhF;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,UAAU,IAAI,MAAM,GAAG,SAAS;IAkBhC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,UAAU;IAoB5C;;;;;;;;;;;;;;OAcG;IACH,MAAM,IAAI,MAAM;IAIhB;;;;;;;;;;;;;;;;;OAiBG;IACH,QAAQ,IAAI,MAAM;CAOnB"}
+{"version":3,"file":"StackTrail.d.ts","sourceRoot":"","sources":["../../src/context/StackTrail.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B,OAAO,EAAiB,KAAK,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAEzE,qBAAa,UAAU;;gBAIT,KAAK,GAAE,MAAM,EAAO;IAIhC;;;;;OAKG;IACH,MAAM,CAAC,KAAK,IAAI,UAAU;IAI1B,6EAA6E;IAC7E,OAAO,IAAI,OAAO;IAIlB;;;;;;;;;;;;;;OAcG;IACH,KAAK,IAAI,UAAU;IAInB;;;;;;;;;;;OAWG;IACH,IAAI,UAAU,IAAI,MAAM,EAAE,CAEzB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,UAAU;IAgB5C,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,UAAU,KAAK,CAAC,GAAG,CAAC;IAgB7C,UAAU,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,UAAU,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAgBhF;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,aAAa,IAAI,WAAW;IAI5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,eAAe,IAAI,WAAW;IAa9B,UAAU,IAAI,MAAM,GAAG,SAAS;IAkBhC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,UAAU;IAoB5C;;;;;;;;;;;;;;OAcG;IACH,MAAM,IAAI,MAAM;IAIhB;;;;;;;;;;;;;;;;;OAiBG;IACH,QAAQ,IAAI,MAAM;CAOnB"}