@scalar/workspace-store 0.62.0 → 0.64.0

package/dist/helpers/get-resolved-ref.js

@@ -1,7 +1,64 @@
 import { isObject } from '@scalar/helpers/object/is-object';
+/**
+ * Keys the store writes on an externalized stub for its own bookkeeping.
+ *
+ * They describe the stub — whether it is shared across documents, whether its chunk has loaded — not the
+ * node it points at.
+ */
+const STUB_BOOKKEEPING_KEYS = new Set(['$global', '$status']);
+const isReferenceNode = (value) => typeof value === 'object' && value !== null && '$ref' in value;
+/**
+ * Whether a reference is pure indirection: a `$ref` and the store's own bookkeeping, nothing more.
+ *
+ * A reference that carries anything else is a schema in its own right — an `$id` opens a schema
+ * resource, `$defs` and `$dynamicAnchor` bind a generic's type parameter, and `description` annotates
+ * the target — so it stays its own hop and the caller resolves it as it descends, the way it always
+ * has. Collapsing such a node into the one it points at merges two schema resources into one, and the
+ * `$dynamicRef` in the inner one then has no outer scope left to bind against.
+ */
+const isPassThroughReference = (node) => {
+    for (const key of Object.keys(node)) {
+        if (key !== '$ref' && key !== '$ref-value' && !STUB_BOOKKEEPING_KEYS.has(key)) {
+            return false;
+        }
+    }
+    return true;
+};
+/**
+ * Follow `$ref-value` onward for as long as it lands on another reference that is pure indirection.
+ *
+ * A reference can point at a second reference. `resolve()` on a static or SSR workspace leaves exactly
+ * that behind: the component stays in the document as a `{ $ref: '#/x-ext/<hash>', $global: true }` stub
+ * and the content lives under `x-ext`, so `#/components/schemas/User` reaches the schema in two hops.
+ * Stopping at the first hop hands consumers the stub, a node with no `type` and no `properties`, which
+ * renders as an empty, non-expandable schema.
+ *
+ * Stops at a reference that has not been resolved yet and hands that node back, which is what a single
+ * hop onto an unresolved reference produces today. `seen` terminates a reference cycle on the node it
+ * comes back around to rather than looping.
+ *
+ * @param value - The value the first hop produced.
+ * @param seen - References already crossed, including the node the chain started at.
+ */
+const followPassThroughReferences = (value, seen) => {
+    let current = value;
+    while (isReferenceNode(current) && isPassThroughReference(current) && !seen.has(current)) {
+        const next = current['$ref-value'];
+        if (next === undefined) {
+            return current;
+        }
+        seen.add(current);
+        current = next;
+    }
+    return current;
+};
 const defaultTransform = (node) => {
     // Unresolved references have no value; callers must account for that state.
-    return node['$ref-value'];
+    const value = node['$ref-value'];
+    if (value === undefined) {
+        return undefined;
+    }
+    return followPassThroughReferences(value, new Set([node]));
 };
 /**
  * Transform for getResolvedRef that merges sibling properties of a $ref wrapper
@@ -10,15 +67,16 @@ const defaultTransform = (node) => {
  */
 export const mergeSiblingReferences = (node) => {
     const { '$ref-value': value, ...rest } = node;
+    const target = value === undefined ? undefined : followPassThroughReferences(value, new Set([node]));
     // A reference can land on something that is not a record: a pointer that aims at a string
     // (`$ref: '#/info/title'`), one that was never resolved, or one whose target is an array. Spreading
     // any of those copies it index by index, so a reference to a title becomes `{ 0: 'G', 1: 'a', … }`
     // and every consumer downstream treats those digits as real properties. There is nothing to merge
     // siblings onto in that case, so only the siblings survive.
-    if (!isObject(value)) {
+    if (!isObject(target)) {
         return rest;
     }
-    return { ...value, ...rest };
+    return { ...target, ...rest };
 };
 export function getResolvedRef(node, transform = defaultTransform) {
     if (typeof node === 'object' && node !== null && '$ref' in node) {

package/dist/helpers/operation-examples.d.ts

@@ -0,0 +1,6 @@
+import type { ExampleObject, OperationObject } from '../schemas/v3.2/strict/openapi-document.js';
+/** The request body and parameter examples needed by a single request, never its responses. */
+export declare const getOperationExamples: (operation: OperationObject, key: string, contentType?: string) => (ExampleObject | undefined)[];
+/** Overlay fetched values for request consumers without persisting them as document edits. */
+export declare const resolveOperationExamples: (operation: OperationObject, key: string, contentType: string | undefined, resolve: (example: ExampleObject | undefined) => ExampleObject | undefined) => OperationObject;
+//# sourceMappingURL=operation-examples.d.ts.map

package/dist/helpers/operation-examples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operation-examples.d.ts","sourceRoot":"","sources":["../../src/helpers/operation-examples.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAmB,eAAe,EAAE,MAAM,wCAAwC,CAAA;AAE7G,+FAA+F;AAC/F,eAAO,MAAM,oBAAoB,GAC/B,WAAW,eAAe,EAC1B,KAAK,MAAM,EACX,cAAc,MAAM,KACnB,CAAC,aAAa,GAAG,SAAS,CAAC,EAS7B,CAAA;AAED,8FAA8F;AAC9F,eAAO,MAAM,wBAAwB,GACnC,WAAW,eAAe,EAC1B,KAAK,MAAM,EACX,aAAa,MAAM,GAAG,SAAS,EAC/B,SAAS,CAAC,OAAO,EAAE,aAAa,GAAG,SAAS,KAAK,aAAa,GAAG,SAAS,KACzE,eA6BF,CAAA"}

package/dist/helpers/operation-examples.js

@@ -0,0 +1,45 @@
+import { getResolvedRef } from '../helpers/get-resolved-ref.js';
+import { getExample } from '../request-example/builder/helpers/get-example.js';
+/** The request body and parameter examples needed by a single request, never its responses. */
+export const getOperationExamples = (operation, key, contentType) => {
+    const body = getResolvedRef(operation.requestBody);
+    return [
+        body ? getExample(body, key, contentType) : undefined,
+        ...(operation.parameters ?? []).map((parameter) => {
+            const resolved = getResolvedRef(parameter);
+            return resolved ? getExample(resolved, key, undefined) : undefined;
+        }),
+    ];
+};
+/** Overlay fetched values for request consumers without persisting them as document edits. */
+export const resolveOperationExamples = (operation, key, contentType, resolve) => {
+    const mapMedia = (media) => {
+        const selected = key || Object.keys(media.examples ?? {})[0];
+        const example = selected ? getResolvedRef(media.examples?.[selected]) : undefined;
+        const resolved = resolve(example);
+        return selected && resolved && resolved !== example
+            ? { ...media, examples: { ...media.examples, [selected]: resolved } }
+            : media;
+    };
+    const body = getResolvedRef(operation.requestBody);
+    const type = contentType ?? Object.keys(body?.content ?? {})[0];
+    return {
+        ...operation,
+        ...(body && type && body.content[type]
+            ? {
+                requestBody: { ...body, content: { ...body.content, [type]: mapMedia(body.content[type]) } },
+            }
+            : {}),
+        parameters: operation.parameters?.map((parameter) => {
+            const resolved = getResolvedRef(parameter);
+            if (!resolved)
+                return parameter;
+            const content = 'content' in resolved ? resolved.content : undefined;
+            const mediaType = Object.keys(content ?? {})[0];
+            if (mediaType && content?.[mediaType]) {
+                return { ...resolved, content: { ...content, [mediaType]: mapMedia(content[mediaType]) } };
+            }
+            return { ...resolved, ...mapMedia(resolved) };
+        }),
+    };
+};

package/dist/helpers/unpack-proxy.d.ts

@@ -13,6 +13,16 @@
  * @param depth - Optional, limits recursion depth. `null` means unlimited depth (default is 1).
  * @returns - A plain object or array with all proxies removed up to the specified depth.
  */
+/**
+ * Strips the known proxies (Vue reactivity, overrides, detect-changes, magic) from a value without
+ * touching its properties, returning the raw object underneath.
+ *
+ * Use this when the raw object is wanted as an identity — a cache key or a cycle guard — rather than as
+ * data. `unpackProxyObject` walks the value's own properties and writes each one back, which costs a
+ * read and a write per property and mutates the object it unpacks; callers that only compare identities
+ * pay for neither.
+ */
+export declare const unpackProxyShallow: <T>(input: T) => T;
 export declare const unpackProxyObject: <T>(input: T, { depth }?: {
     depth?: number | null;
 }) => T;

package/dist/helpers/unpack-proxy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unpack-proxy.d.ts","sourceRoot":"","sources":["../../src/helpers/unpack-proxy.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,EAAE,OAAO,CAAC,EAAE,YAAe;IAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAO,KAAG,CAsE9F,CAAA"}
+{"version":3,"file":"unpack-proxy.d.ts","sourceRoot":"","sources":["../../src/helpers/unpack-proxy.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,CAMhD,CAAA;AAED,eAAO,MAAM,iBAAiB,GAAI,CAAC,EAAE,OAAO,CAAC,EAAE,YAAe;IAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAO,KAAG,CAsE9F,CAAA"}

package/dist/helpers/unpack-proxy.js

@@ -17,6 +17,21 @@ import { unpackOverridesProxy } from '../helpers/overrides-proxy.js';
  * @param depth - Optional, limits recursion depth. `null` means unlimited depth (default is 1).
  * @returns - A plain object or array with all proxies removed up to the specified depth.
  */
+/**
+ * Strips the known proxies (Vue reactivity, overrides, detect-changes, magic) from a value without
+ * touching its properties, returning the raw object underneath.
+ *
+ * Use this when the raw object is wanted as an identity — a cache key or a cycle guard — rather than as
+ * data. `unpackProxyObject` walks the value's own properties and writes each one back, which costs a
+ * read and a write per property and mutates the object it unpacks; callers that only compare identities
+ * pay for neither.
+ */
+export const unpackProxyShallow = (input) => {
+    if (typeof input !== 'object' || input === null) {
+        return input;
+    }
+    return unpackDetectChangesProxy(toRaw(getRaw(unpackOverridesProxy(input))));
+};
 export const unpackProxyObject = (input, { depth = 0 } = {}) => {
     // Internal DFS helper to recursively strip all known proxies (Vue, overrides, detect-changes, magic proxies)
     const dfs = (value, currentDepth = 0) => {

package/dist/helpers/use-external-examples.d.ts

@@ -0,0 +1,15 @@
+import { type ComponentPublicInstance, type ComputedRef, type InjectionKey, type Ref } from 'vue';
+import { type ExternalExampleResolver } from '../helpers/external-examples.js';
+import type { ExampleObject } from '../schemas/v3.2/strict/openapi-document.js';
+/** Supply the current document's resolver so consumers share downloads and invalidation. */
+export declare const EXTERNAL_EXAMPLES: InjectionKey<() => ExternalExampleResolver>;
+/** Observe current visibility, rather than mounting, to avoid fetching every operation on a long page. */
+export declare const useExampleVisibility: (target: Ref<Element | ComponentPublicInstance | null>) => Ref<boolean>;
+/** Resolve only the selected examples and expose immutable views of their downloaded values. */
+export declare const useExternalExamples: (examples: () => (ExampleObject | undefined)[], enabled?: () => boolean, resolver?: () => ExternalExampleResolver) => {
+    pending: ComputedRef<boolean>;
+    failed: ComputedRef<boolean>;
+    resolve: (example: ExampleObject | undefined) => ExampleObject | undefined;
+    retry: () => Promise<void>;
+};
+//# sourceMappingURL=use-external-examples.d.ts.map

package/dist/helpers/use-external-examples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-external-examples.d.ts","sourceRoot":"","sources":["../../src/helpers/use-external-examples.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,GAAG,EAOT,MAAM,KAAK,CAAA;AAEZ,OAAO,EAAE,KAAK,uBAAuB,EAAiC,MAAM,6BAA6B,CAAA;AACzG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAA;AAE3E,4FAA4F;AAC5F,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,MAAM,uBAAuB,CAA+B,CAAA;AAEzG,0GAA0G;AAC1G,eAAO,MAAM,oBAAoB,GAAI,QAAQ,GAAG,CAAC,OAAO,GAAG,uBAAuB,GAAG,IAAI,CAAC,KAAG,GAAG,CAAC,OAAO,CAuBvG,CAAA;AAED,gGAAgG;AAChG,eAAO,MAAM,mBAAmB,GAC9B,UAAU,MAAM,CAAC,aAAa,GAAG,SAAS,CAAC,EAAE,EAC7C,UAAS,MAAM,OAAoB,EACnC,WAAW,MAAM,uBAAuB,KACvC;IACD,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IAC7B,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IAC5B,OAAO,EAAE,CAAC,OAAO,EAAE,aAAa,GAAG,SAAS,KAAK,aAAa,GAAG,SAAS,CAAA;IAC1E,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAgC3B,CAAA"}

package/dist/helpers/use-external-examples.js

@@ -0,0 +1,55 @@
+import { computed, inject, onScopeDispose, ref, watch, watchEffect, } from 'vue';
+import { createExternalExampleResolver } from '../helpers/external-examples.js';
+/** Supply the current document's resolver so consumers share downloads and invalidation. */
+export const EXTERNAL_EXAMPLES = Symbol('external-examples');
+/** Observe current visibility, rather than mounting, to avoid fetching every operation on a long page. */
+export const useExampleVisibility = (target) => {
+    const visible = ref(false);
+    let observer;
+    watch(target, (element) => {
+        observer?.disconnect();
+        visible.value = false;
+        const node = element && ('$el' in element ? element.$el : element);
+        if (typeof Element === 'undefined' || !(node instanceof Element))
+            return;
+        if (typeof IntersectionObserver === 'undefined') {
+            visible.value = true;
+            return;
+        }
+        observer = new IntersectionObserver(([entry]) => {
+            visible.value = entry?.isIntersecting ?? false;
+        });
+        observer.observe(node);
+    }, { flush: 'post' });
+    onScopeDispose(() => observer?.disconnect());
+    return visible;
+};
+/** Resolve only the selected examples and expose immutable views of their downloaded values. */
+export const useExternalExamples = (examples, enabled = () => true, resolver) => {
+    const fallback = createExternalExampleResolver();
+    const getResolver = resolver ?? inject(EXTERNAL_EXAMPLES, () => fallback);
+    const states = computed(() => examples()
+        .filter((example) => example !== undefined && example.value === undefined && !!example.externalValue)
+        .map((example) => getResolver()(example)));
+    watchEffect(() => {
+        if (!enabled())
+            return;
+        for (const state of states.value) {
+            if (state.status === 'idle')
+                void state.load();
+        }
+    });
+    return {
+        pending: computed(() => states.value.some((state) => state.status !== 'loaded')),
+        failed: computed(() => states.value.some((state) => state.status === 'error')),
+        resolve: (example) => {
+            if (!example || example.value !== undefined || !example.externalValue)
+                return example;
+            const state = getResolver()(example);
+            return state.status === 'loaded' ? { ...example, value: state.value } : example;
+        },
+        retry: async () => {
+            await Promise.all(states.value.map((state) => state.load()));
+        },
+    };
+};

package/dist/mutators/operation/parameters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parameters.d.ts","sourceRoot":"","sources":["../../../src/mutators/operation/parameters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAIrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAmClD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,wBAAwB,GACnC,UAAU,iBAAiB,GAAG,IAAI,EAClC,4CAA4C,eAAe,CAAC,4BAA4B,CAAC,SAuD1F,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,8BAA8B,GACzC,UAAU,iBAAiB,GAAG,IAAI,EAClC,uCAAuC,eAAe,CAAC,mCAAmC,CAAC,SA8C5F,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,GACnC,UAAU,iBAAiB,GAAG,IAAI,EAClC,6BAA6B,eAAe,CAAC,4BAA4B,CAAC,SAkC3E,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,4BAA4B,GACvC,UAAU,iBAAiB,GAAG,IAAI,EAClC,gBAAgB,eAAe,CAAC,iCAAiC,CAAC,SAanE,CAAA"}
+{"version":3,"file":"parameters.d.ts","sourceRoot":"","sources":["../../../src/mutators/operation/parameters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAIrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAmClD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,wBAAwB,GACnC,UAAU,iBAAiB,GAAG,IAAI,EAClC,4CAA4C,eAAe,CAAC,4BAA4B,CAAC,SAuE1F,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,8BAA8B,GACzC,UAAU,iBAAiB,GAAG,IAAI,EAClC,uCAAuC,eAAe,CAAC,mCAAmC,CAAC,SA8C5F,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,GACnC,UAAU,iBAAiB,GAAG,IAAI,EAClC,6BAA6B,eAAe,CAAC,4BAA4B,CAAC,SAkC3E,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,4BAA4B,GACvC,UAAU,iBAAiB,GAAG,IAAI,EAClC,gBAAgB,eAAe,CAAC,iCAAiC,CAAC,SAanE,CAAA"}

package/dist/mutators/operation/parameters.js

@@ -2,6 +2,7 @@ import { getPathItemOperation } from '../../helpers/for-each-path-item-operation
 import { getResolvedRef } from '../../helpers/get-resolved-ref.js';
 import { unpackProxyObject } from '../../helpers/unpack-proxy.js';
 import { isOpenApiDocument } from '../../schemas/type-guards.js';
+import { isContentTypeParameterObject } from '../../schemas/v3.2/strict/type-guards.js';
 const getPathItemsForParameterMutation = (pathItemRef) => {
     if (!pathItemRef || typeof pathItemRef !== 'object') {
         return [];
@@ -40,23 +41,41 @@ const getPathItemsForParameterMutation = (pathItemRef) => {
 export const upsertOperationParameter = (document, { meta, type, payload, originalParameter }) => {
     // We are editing an existing parameter
     if (originalParameter) {
-        // To support content-type parameters in the API client, we just assume an
-        // examples property can be set.
         const param = originalParameter;
+        const target = isContentTypeParameterObject(param) ? Object.values(param.content ?? {})[0] : param;
+        if (!target) {
+            return;
+        }
+        if (target !== param) {
+            // Keep authored examples and migrate edits saved by older clients. Those edits
+            // already take precedence when reading, so they must also win during migration.
+            target.examples = {
+                ...(target.example !== undefined ? { default: { value: target.example } } : {}),
+                ...target.examples,
+                ...('example' in param && param.example !== undefined ? { default: { value: param.example } } : {}),
+                ...('examples' in param ? param.examples : {}),
+            };
+            // A media type cannot carry both the singular example and the examples map.
+            delete target.example;
+            if ('examples' in param) {
+                delete param.examples;
+            }
+            if ('example' in param) {
+                delete param.example;
+            }
+        }
         // Only update the name when the payload carries a non-empty value — an
         // empty name in the payload means the key input blurred before rendering
         // its initial value and should not overwrite the existing parameter name.
         if (payload.name || !param.name) {
             param.name = payload.name;
         }
-        if (!param.examples) {
-            param.examples = {};
-        }
-        // Create the example if it doesn't exist
-        if (!param.examples[meta.exampleKey]) {
-            param.examples[meta.exampleKey] = {};
+        target.examples ??= {};
+        target.examples[meta.exampleKey] ??= {};
+        const example = getResolvedRef(target.examples[meta.exampleKey]);
+        if (!example) {
+            return;
         }
-        const example = getResolvedRef(param.examples[meta.exampleKey]);
         // Update the example value and disabled state
         example.value = payload.value;
         example['x-disabled'] = payload.isDisabled;

package/dist/plugins/bundler/index.d.ts

@@ -20,9 +20,12 @@ export declare const loadingStatus: () => LifecyclePlugin;
  *
  * This is useful for inlining external content (like examples or schemas) into the OpenAPI document during bundling.
  *
- * @param node - The node being processed, which may contain an 'externalValue' property.
+ * In lazy mode, preserve the absolute URL for on-demand client resolution without fetching a payload.
+ * The default eager mode remains available to existing bundler consumers.
  */
-export declare const externalValueResolver: () => LifecyclePlugin;
+export declare const externalValueResolver: (options?: {
+    lazy?: boolean;
+}) => LifecyclePlugin;
 /**
  * Lifecycle plugin to resolve $ref on any object, including non-standard locations like the info object.
  *

package/dist/plugins/bundler/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/bundler/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EAAE,KAAK,eAAe,EAAwB,MAAM,2BAA2B,CAAA;AAStF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,QAAO,eAahC,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,QAAO,eAmCxC,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,QAAO,eAwCjC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,mBAAmB,QAAO,eAuBtC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,oBAAoB,QAAO,eAuBvC,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,QAAO,eAyBhC,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,QAAO,eAkFrC,CAAA;AAKD;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,QAAO,eAaxC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/bundler/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EAAE,KAAK,eAAe,EAAwB,MAAM,2BAA2B,CAAA;AAStF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,QAAO,eAahC,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,GAAI,UAAU;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,KAAG,eA2CpE,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,QAAO,eAwCjC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,mBAAmB,QAAO,eAuBtC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,oBAAoB,QAAO,eAuBvC,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,QAAO,eAyBhC,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,QAAO,eAkFrC,CAAA;AAKD;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,QAAO,eAaxC,CAAA"}

package/dist/plugins/bundler/index.js

@@ -39,21 +39,30 @@ export const loadingStatus = () => {
  *
  * This is useful for inlining external content (like examples or schemas) into the OpenAPI document during bundling.
  *
- * @param node - The node being processed, which may contain an 'externalValue' property.
+ * In lazy mode, preserve the absolute URL for on-demand client resolution without fetching a payload.
+ * The default eager mode remains available to existing bundler consumers.
  */
-export const externalValueResolver = () => {
+export const externalValueResolver = (options) => {
     return {
         type: 'lifecycle',
         onAfterNodeProcess: async (node, context) => {
             const externalValue = node['externalValue'];
             const cache = context.resolutionCache;
             // Only process if 'externalValue' is a string
-            if (typeof externalValue !== 'string') {
+            if (typeof externalValue !== 'string' || node['value'] !== undefined) {
                 return;
             }
             // `externalValue` may be relative (for example `/examples/pet.json`). Resolve it against the
             // origin of the document it lives in so it becomes an absolute URL a loader can fetch.
             const resolvedValue = resolveReferencePath(context.origin, externalValue);
+            if (options?.lazy) {
+                const path = context.path.at(-2) === 'examples' ? context.path : (context.referencedFromPath ?? context.path);
+                if (path.at(-2) !== 'examples' || isSchemaPath(path))
+                    return;
+                // Preserve the referenced document origin before bundling loses that context.
+                node['externalValue'] = resolvedValue;
+                return;
+            }
             const loader = context.loaders.find((it) => it.validate(resolvedValue));
             // We can not process the external value
             if (!loader) {

package/dist/request-example/builder/header/is-param-disabled.d.ts

@@ -3,11 +3,11 @@ import type { ExampleObject, ParameterObject } from '@scalar/workspace-store/sch
  * Determines if a parameter is disabled
  *
  * First we explicitly check if its been disabled via the `x-disabled` extension.
- * Then we check if its an optional parameter and not a path parameter.
+ * Populated examples are enabled unless explicitly disabled. Empty optional parameters stay disabled.
  *
  * @param param - The parameter to check.
  * @param example - The example to check.
- * @param defaultDisabled - When true (default), optional parameters are treated as disabled unless explicitly enabled. When false, only parameters explicitly marked `x-disabled: true` are disabled.
+ * @param defaultDisabled - When true (default), empty optional parameters are treated as disabled unless explicitly enabled. When false, only parameters explicitly marked `x-disabled: true` are disabled.
  * @returns true if the parameter is disabled, false otherwise.
  */
 export declare const isParamDisabled: (param: ParameterObject, example: ExampleObject | undefined, defaultDisabled?: boolean) => boolean;

package/dist/request-example/builder/header/is-param-disabled.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"is-param-disabled.d.ts","sourceRoot":"","sources":["../../../../src/request-example/builder/header/is-param-disabled.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,8DAA8D,CAAA;AAElH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,eAAe,EACtB,SAAS,aAAa,GAAG,SAAS,EAClC,kBAAiB,OAAc,YAgBhC,CAAA"}
+{"version":3,"file":"is-param-disabled.d.ts","sourceRoot":"","sources":["../../../../src/request-example/builder/header/is-param-disabled.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,8DAA8D,CAAA;AAElH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,eAAe,EACtB,SAAS,aAAa,GAAG,SAAS,EAClC,kBAAiB,OAAc,KAC9B,OAgBF,CAAA"}

package/dist/request-example/builder/header/is-param-disabled.js

@@ -2,11 +2,11 @@
  * Determines if a parameter is disabled
  *
  * First we explicitly check if its been disabled via the `x-disabled` extension.
- * Then we check if its an optional parameter and not a path parameter.
+ * Populated examples are enabled unless explicitly disabled. Empty optional parameters stay disabled.
  *
  * @param param - The parameter to check.
  * @param example - The example to check.
- * @param defaultDisabled - When true (default), optional parameters are treated as disabled unless explicitly enabled. When false, only parameters explicitly marked `x-disabled: true` are disabled.
+ * @param defaultDisabled - When true (default), empty optional parameters are treated as disabled unless explicitly enabled. When false, only parameters explicitly marked `x-disabled: true` are disabled.
  * @returns true if the parameter is disabled, false otherwise.
  */
 export const isParamDisabled = (param, example, defaultDisabled = true) => {
@@ -15,8 +15,9 @@ export const isParamDisabled = (param, example, defaultDisabled = true) => {
     if (typeof xDisabled === 'boolean') {
         return xDisabled;
     }
-    // If the parameter is not disabled by default, return false
-    if (!defaultDisabled) {
+    // Keep the editor, generated snippets, and outgoing requests aligned for pre-populated values.
+    const hasValue = example?.value !== undefined && example.value !== '' && example.value !== null;
+    if (!defaultDisabled || hasValue) {
         return false;
     }
     // Otherwise, disable optional parameters (except path parameters which are always required)

package/dist/request-example/builder/helpers/get-example-from-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-example-from-schema.d.ts","sourceRoot":"","sources":["../../../../src/request-example/builder/helpers/get-example-from-schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,YAAY,EAAqD,MAAM,uBAAuB,CAAA;AAG5G,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAA;AA+wB1E,KAAK,2BAA2B,GAAG;IACjC,+CAA+C;IAC/C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4CAA4C;IAC5C,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,uDAAuD;IACvD,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;IACvB,iEAAiE;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACnC,qDAAqD;IACrD,8BAA8B,CAAC,EAAE,OAAO,CAAA;IACxC;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,0DAA0D;IAC1D,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC9C,CAAA;AA+ND;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,YAAY,EACpB,UAAU,2BAA2B,EACrC,iEAOG,OAAO,CAAC;IACT,KAAK,EAAE,MAAM,CAAA;IACb,YAAY,EAAE,YAAY,CAAA;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;IACrB,6EAA6E;IAC7E,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,qGAAqG;IACrG,YAAY,EAAE,YAAY,CAAA;CAC3B,CAAM,KACN,OAmNF,CAAA"}
+{"version":3,"file":"get-example-from-schema.d.ts","sourceRoot":"","sources":["../../../../src/request-example/builder/helpers/get-example-from-schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,YAAY,EAAqD,MAAM,uBAAuB,CAAA;AAG5G,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAA;AA+wB1E,KAAK,2BAA2B,GAAG;IACjC,+CAA+C;IAC/C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4CAA4C;IAC5C,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,uDAAuD;IACvD,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAA;IACvB,iEAAiE;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACnC,qDAAqD;IACrD,8BAA8B,CAAC,EAAE,OAAO,CAAA;IACxC;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,0DAA0D;IAC1D,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC9C,CAAA;AAuPD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,YAAY,EACpB,UAAU,2BAA2B,EACrC,iEAOG,OAAO,CAAC;IACT,KAAK,EAAE,MAAM,CAAA;IACb,YAAY,EAAE,YAAY,CAAA;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;IACrB,6EAA6E;IAC7E,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,qGAAqG;IACrG,YAAY,EAAE,YAAY,CAAA;CAC3B,CAAM,KACN,OAmNF,CAAA"}

package/dist/request-example/builder/helpers/get-example-from-schema.js

@@ -646,6 +646,26 @@ const createOptionsCacheKey = (options) => JSON.stringify({
         ? Object.entries(options.compositionSelection).sort(([a], [b]) => a.localeCompare(b))
         : undefined,
 });
+/** Sentinel for "nothing memoized yet", since `undefined` is itself a valid options value. */
+const NO_OPTIONS = Symbol('NO_OPTIONS');
+/** The options object `lastOptionsKey` was built from. */
+let lastOptions = NO_OPTIONS;
+let lastOptionsKey = '';
+/**
+ * The options half of the result-cache key, built once per top-level call instead of once per node.
+ *
+ * `createOptionsCacheKey` serializes the whole options object, and every schema the walk enters needs
+ * the same string. The walk is synchronous and passes the same `options` object down, so rebuilding at
+ * level 0, or whenever the identity changes, is enough: a caller that mutates its options object in
+ * place still gets a fresh key on its next top-level call, exactly as before.
+ */
+const getOptionsCacheKey = (options, level) => {
+    if (level === 0 || options !== lastOptions) {
+        lastOptionsKey = createOptionsCacheKey(options);
+        lastOptions = options;
+    }
+    return lastOptionsKey;
+};
 /** Stand-in for a truncated schema whose shape cannot be read off the document. */
 const MAX_DEPTH_EXCEEDED = '[Max Depth Exceeded]';
 /** How long a chain of composition wrappers may be unwrapped before the stack becomes the concern. */
@@ -867,7 +887,7 @@ export const getExampleFromSchema = (schema, options, { level = 0, parentSchema,
     }
     seen.add(targetValue);
     /** Make the cache key unique per options and schema path */
-    const cacheKey = createOptionsCacheKey(options) + (schemaPath.length > 0 ? `:path:${schemaPath.join('.')}` : '');
+    const cacheKey = getOptionsCacheKey(options, level) + (schemaPath.length > 0 ? `:path:${schemaPath.join('.')}` : '');
     // Check cache first for performance - avoid recomputing the same schema (skipped under a dynamic scope)
     if (!skipCache) {
         const cached = resultCache.get(targetValue)?.get(cacheKey);

package/dist/request-example/builder/helpers/get-example.d.ts

@@ -4,6 +4,8 @@ import type { ExampleObject, MediaTypeObject, ParameterObject, RequestBodyObject
  * Or the [deprecated] `example` field.
  * If no exampleKey is provided it will fallback to the first example in the examples object then the [deprecated]
  * `example` field.
+ * When the parameter carries both its own `examples`/`example` and a `content` object, the parameter-level value
+ * takes priority to preserve edits saved by older clients before they are migrated into the media type.
  * Used both for send-request and generating code snippets.
  */
 export declare const getExample: (param: ParameterObject | RequestBodyObject | MediaTypeObject, exampleName: string | undefined, contentType: string | undefined) => ExampleObject | undefined;

package/dist/request-example/builder/helpers/get-example.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-example.d.ts","sourceRoot":"","sources":["../../../../src/request-example/builder/helpers/get-example.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,eAAe,EACf,eAAe,EACf,iBAAiB,EAClB,MAAM,8DAA8D,CAAA;AAgCrE;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GACrB,OAAO,eAAe,GAAG,iBAAiB,GAAG,eAAe,EAC5D,aAAa,MAAM,GAAG,SAAS,EAC/B,aAAa,MAAM,GAAG,SAAS,KAC9B,aAAa,GAAG,SA6ClB,CAAA"}
+{"version":3,"file":"get-example.d.ts","sourceRoot":"","sources":["../../../../src/request-example/builder/helpers/get-example.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,eAAe,EACf,eAAe,EACf,iBAAiB,EAClB,MAAM,8DAA8D,CAAA;AAgCrE;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,GACrB,OAAO,eAAe,GAAG,iBAAiB,GAAG,eAAe,EAC5D,aAAa,MAAM,GAAG,SAAS,EAC/B,aAAa,MAAM,GAAG,SAAS,KAC9B,aAAa,GAAG,SA6ClB,CAAA"}

package/dist/request-example/builder/helpers/get-example.js

@@ -23,20 +23,22 @@ const getExampleFromExamples = (examples, exampleField, exampleName) => {
  * Or the [deprecated] `example` field.
  * If no exampleKey is provided it will fallback to the first example in the examples object then the [deprecated]
  * `example` field.
+ * When the parameter carries both its own `examples`/`example` and a `content` object, the parameter-level value
+ * takes priority to preserve edits saved by older clients before they are migrated into the media type.
  * Used both for send-request and generating code snippets.
  */
 export const getExample = (param, exampleName, contentType) => {
-    // Content based parameters
-    if ('content' in param) {
-        const content = param.content?.[contentType ?? Object.keys(param.content)[0] ?? ''];
-        const result = getExampleFromExamples(content?.examples, content?.example, exampleName);
+    // Schema-based parameters and content-based parameter edits saved by older clients.
+    if ('examples' in param || 'example' in param) {
+        const result = getExampleFromExamples(param.examples, param.example, exampleName);
         if (result !== undefined) {
             return result;
         }
     }
-    // Schema based parameters
-    if ('examples' in param || 'example' in param) {
-        const result = getExampleFromExamples(param.examples, param.example, exampleName);
+    // Content based parameters
+    if ('content' in param) {
+        const content = param.content?.[contentType ?? Object.keys(param.content)[0] ?? ''];
+        const result = getExampleFromExamples(content?.examples, content?.example, exampleName);
         if (result !== undefined) {
             return result;
         }

package/dist/request-example/context/headers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"headers.d.ts","sourceRoot":"","sources":["../../../src/request-example/context/headers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAA;AAEnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8DAA8D,CAAA;AAanG;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,GAAI,YAAY,MAAM,KAAG,MACQ,CAAA;AAE3E;;GAEG;AACH,eAAO,MAAM,qCAAqC,GAAI,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CACK,CAAA;AAkDlH;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,GACvC,WAAW,eAAe,EAC1B,aAAa,MAAM,EACnB,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAC9B,MAAM,CAAC,MAAM,EAAE,MAAM,CAIpB,CAAA;AAEJ;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,GAAI,0FAU/B;IACD,MAAM,EAAE,UAAU,CAAA;IAClB,SAAS,EAAE,eAAe,CAAA;IAC1B,WAAW,EAAE,MAAM,CAAA;IACnB,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,OAAO,CAAC,EAAE;QACR,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,OAAO,CAAA;KACpB,CAAA;CACF,KAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAuCxB,CAAA"}
+{"version":3,"file":"headers.d.ts","sourceRoot":"","sources":["../../../src/request-example/context/headers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAA;AAEnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8DAA8D,CAAA;AAcnG;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,GAAI,YAAY,MAAM,KAAG,MACQ,CAAA;AAE3E;;GAEG;AACH,eAAO,MAAM,qCAAqC,GAAI,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CACK,CAAA;AAgDlH;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,GACvC,WAAW,eAAe,EAC1B,aAAa,MAAM,EACnB,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAC9B,MAAM,CAAC,MAAM,EAAE,MAAM,CAIpB,CAAA;AAEJ;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,GAAI,0FAU/B;IACD,MAAM,EAAE,UAAU,CAAA;IAClB,SAAS,EAAE,eAAe,CAAA;IAC1B,WAAW,EAAE,MAAM,CAAA;IACnB,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,OAAO,CAAC,EAAE;QACR,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,OAAO,CAAA;KACpB,CAAA;CACF,KAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAuCxB,CAAA"}

package/dist/request-example/context/headers.js

@@ -1,6 +1,7 @@
 import { canMethodHaveBody } from '@scalar/helpers/http/can-method-have-body';
 import { getResolvedRef } from '@scalar/workspace-store/helpers/get-resolved-ref';
 import { isParamDisabled } from '../../request-example/builder/header/is-param-disabled.js';
+import { getExample } from '../../request-example/builder/helpers/get-example.js';
 /** Default Accept header value to accept all response types. */
 const DEFAULT_ACCEPT = '*/*';
 const CONVENTIONAL_DEFAULT_HEADER_NAMES = {
@@ -21,8 +22,7 @@ export const restoreConventionalHeaderName = (headerName) => CONVENTIONAL_DEFAUL
 export const restoreConventionalDefaultHeaderNames = (headers) => Object.fromEntries(Object.entries(headers).map(([name, value]) => [restoreConventionalHeaderName(name), value]));
 /**
  * Lowercase names of **enabled** operation parameters with `in: header` for the given example.
- * Uses the same rules as the request builder (`isParamDisabled`): optional parameters are treated
- * as disabled unless `examples[exampleName]['x-disabled']` is explicitly `false`.
+ * Uses the same example selection and enablement rules as the request builder, including schema defaults.
  */
 const getEnabledOperationHeaderParameterNames = (operation, exampleName) => {
     const names = new Set();
@@ -31,8 +31,7 @@ const getEnabledOperationHeaderParameterNames = (operation, exampleName) => {
         if (!param || param.in !== 'header') {
             continue;
         }
-        const rawExample = 'examples' in param && param.examples?.[exampleName] ? param.examples[exampleName] : undefined;
-        const example = rawExample ? getResolvedRef(rawExample) : undefined;
+        const example = getExample(param, exampleName, undefined);
         if (!isParamDisabled(param, example)) {
             names.add(param.name.toLowerCase());
         }

package/dist/resolve.d.ts

@@ -1,7 +1,15 @@
 import type { MaybeRefSchemaObject, SchemaObject } from './schemas/v3.2/strict/schema.js';
-type ResolvedSchema<T> = T extends undefined ? undefined : SchemaObject & {
+/**
+ * A resolved schema is a read-only view.
+ *
+ * What comes back is either the document's own node or a shallow merge over it, so the nested values
+ * are the document's either way and a write reaches the document without going through the store. The
+ * `Readonly` says so to the compiler at the one level where a write is cheap to make by accident; a
+ * caller with a change to make copies what it needs, or goes through a store mutation.
+ */
+type ResolvedSchema<T> = T extends undefined ? undefined : Readonly<SchemaObject & {
     $ref?: string;
-};
+}>;
 export declare const resolve: {
     schema: <T extends MaybeRefSchemaObject | undefined>(schema: T) => ResolvedSchema<T>;
 };

package/dist/resolve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../src/resolve.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAEtF,KAAK,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAAG,SAAS,GAAG,YAAY,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAE3F,eAAO,MAAM,OAAO;aACT,CAAC,SAAS,oBAAoB,GAAG,SAAS,UAAU,CAAC,KAAG,cAAc,CAAC,CAAC,CAAC;CAWnF,CAAA"}
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../src/resolve.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAEtF;;;;;;;GAOG;AACH,KAAK,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC,YAAY,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AAWrG,eAAO,MAAM,OAAO;aACT,CAAC,SAAS,oBAAoB,GAAG,SAAS,UAAU,CAAC,KAAG,cAAc,CAAC,CAAC,CAAC;CAQnF,CAAA"}

package/dist/resolve.js

@@ -3,12 +3,20 @@ import { getResolvedRef, mergeSiblingReferences } from './helpers/get-resolved-r
 import { compose } from './schemas/compose.js';
 import { coerceValue } from './schemas/typebox-coerce.js';
 import { SchemaObjectSchema } from './schemas/v3.2/strict/openapi-document.js';
+/**
+ * The coercion target: a schema object that may still carry the `$ref` it was resolved from.
+ *
+ * `Type.Composite` merges every property of `SchemaObjectSchema` to build this, so it belongs at module
+ * scope. `resolve.schema` runs once per property of every schema a render walks, and rebuilding the
+ * composite per call dominated that walk.
+ */
+const resolvedSchemaSchema = compose(SchemaObjectSchema, Type.Object({ $ref: Type.Optional(Type.String()) }));
 export const resolve = {
     schema: (schema) => {
         if (schema === undefined) {
             return undefined;
         }
         const resoled = getResolvedRef(schema, mergeSiblingReferences);
-        return coerceValue(compose(SchemaObjectSchema, Type.Object({ $ref: Type.Optional(Type.String()) })), resoled);
+        return coerceValue(resolvedSchemaSchema, resoled);
     },
 };