@scalar/blocks 0.4.3 → 0.5.0

package/dist/schema/helpers/merge-all-of-schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-all-of-schemas.js","names":[],"sources":["../../../src/schema/helpers/merge-all-of-schemas.ts"],"sourcesContent":["import { isObjectEqual } from '@scalar/helpers/object/is-object-equal'\nimport { objectKeys } from '@scalar/helpers/object/object-keys'\nimport { getResolvedRef } from '@scalar/workspace-store/helpers/get-resolved-ref'\nimport { resolve } from '@scalar/workspace-store/resolve'\nimport type { SchemaObject } from '@scalar/workspace-store/schemas/v3.2/strict/openapi-document'\nimport { isArraySchema } from '@scalar/workspace-store/schemas/v3.2/strict/type-guards'\n\n/**\n * Schema keywords whose value should reflect the *last* occurrence when merging\n * `allOf` members. Most keywords keep the first occurrence, but for human-facing\n * annotations a later subschema is expected to override an earlier one — matching\n * OpenAPI/JSON Schema tooling like Swagger UI.\n */\nconst LAST_WINS_KEYS = new Set<string>(['description', 'title'])\n\nconst ENUM_ANNOTATIONS = ['x-enum-varnames', 'x-enumNames', 'x-enum-descriptions', 'x-enumDescriptions'] as const\n\n/** Keep positional annotations attached to their values when intersecting enum constraints. */\nconst mergeEnums = (\n  existing: SchemaObject,\n  incoming: SchemaObject,\n  override: boolean = false,\n): Partial<SchemaObject> => {\n  const values =\n    existing.enum === undefined\n      ? incoming.enum?.slice()\n      : incoming.enum === undefined\n        ? existing.enum.slice()\n        : existing.enum.filter((value) => incoming.enum?.some((candidate) => isObjectEqual(value, candidate)))\n\n  if (values === undefined) {\n    return {}\n  }\n\n  const merged: Partial<SchemaObject> = { enum: values }\n  for (const key of ENUM_ANNOTATIONS) {\n    const source = incoming[key] !== undefined && (override || existing[key] === undefined) ? incoming : existing\n    const annotation = source[key]\n    const sourceValues = source.enum\n    if (Array.isArray(annotation)) {\n      merged[key] =\n        sourceValues === undefined\n          ? annotation\n          : values.map(\n              (value) => annotation[sourceValues.findIndex((candidate) => isObjectEqual(value, candidate))] ?? '',\n            )\n    } else if (annotation !== undefined && (key === 'x-enum-descriptions' || key === 'x-enumDescriptions')) {\n      merged[key] = annotation\n    }\n  }\n  return merged\n}\n\n/**\n * Merges multiple OpenAPI schema objects into a single schema object.\n * Handles nested allOf compositions and merges properties recursively.\n *\n * @param schemas - Array of OpenAPI schema objects to merge\n * @param rootSchema - Optional root schema to merge with the result\n * @param seenRefs - `$ref` strings already being merged higher in the call stack\n * @returns Merged schema object\n */\nexport const mergeAllOfSchemas = (\n  schemas: SchemaObject | undefined,\n  rootSchema?: SchemaObject,\n  seenRefs: Set<string> = new Set(),\n): SchemaObject => {\n  // Handle max depth, empty or invalid input\n  if (!schemas?.allOf?.length || !Array.isArray(schemas.allOf)) {\n    return rootSchema || ({} as SchemaObject)\n  }\n\n  // Initialize result object once\n  const result = {} as SchemaObject\n\n  // Extract base schema properties (everything except allOf)\n  const { allOf: _, ...baseSchema } = schemas\n\n  // Process allOf schemas first\n  for (const _schema of schemas.allOf) {\n    if (!_schema || typeof _schema !== 'object') {\n      continue\n    }\n\n    // Resolve ref if present\n    const schema = resolve.schema(_schema)\n\n    // Handle nested allOf recursively\n    if (schema.allOf) {\n      const nestedMerged = mergeAllOfSchemas(schema, undefined, seenRefs)\n      mergeSchemaIntoResult(result, nestedMerged, false, seenRefs)\n      continue\n    }\n\n    mergeSchemaIntoResult(result, schema, false, seenRefs)\n  }\n\n  // Apply base schema properties with precedence over allOf properties\n  if (Object.keys(baseSchema).length > 0) {\n    mergeSchemaIntoResult(result, baseSchema, true, seenRefs)\n  }\n\n  // Process root schema last if provided\n  if (rootSchema && typeof rootSchema === 'object') {\n    if (rootSchema.allOf) {\n      const nestedMerged = mergeAllOfSchemas(rootSchema, undefined, seenRefs)\n      mergeSchemaIntoResult(result, nestedMerged, true, seenRefs)\n    } else {\n      mergeSchemaIntoResult(result, rootSchema, true, seenRefs)\n    }\n  }\n\n  // Drop a `discriminator` inherited from an `allOf` member: a merged subtype is\n  // one concrete branch, not a choice-point, and keeping the base's mapping makes\n  // it look like the base again, recursing the selector inference (issue #9674).\n  // A discriminator the schema declares itself is kept.\n  const declaresOwnDiscriminator =\n    'discriminator' in baseSchema ||\n    Boolean(rootSchema && typeof rootSchema === 'object' && 'discriminator' in rootSchema)\n\n  if ('discriminator' in result && !declaresOwnDiscriminator) {\n    delete (result as Record<string, unknown>).discriminator\n  }\n\n  return result\n}\n\n/**\n * Efficiently merges a source schema into a target result object.\n * Handles all schema merging logic in a single optimized function.\n *\n * @param result - The target schema object to merge into\n * @param schema - The source schema object to merge from\n * @param override - Whether to override existing properties (default: false)\n */\nconst mergeSchemaIntoResult = (\n  result: SchemaObject,\n  schema: SchemaObject,\n  override: boolean = false,\n  seenRefs: Set<string> = new Set(),\n): void => {\n  // Early return if schema is empty\n  const schemaKeys = objectKeys(schema)\n  if (schemaKeys.length === 0) {\n    return\n  }\n\n  const mergedEnums = mergeEnums(result, schema, override)\n\n  // Loop through all schema properties and handle them appropriately\n  for (const key of schemaKeys) {\n    const propertyName: string = key\n    const value = getResolvedRef(schema[key]) as any\n\n    if (value === undefined) {\n      continue\n    }\n\n    // Required\n    if (propertyName === 'required') {\n      // Merge required fields with deduplication\n      if (Array.isArray(value) && value.length > 0) {\n        // @ts-expect-error\n        if (result.required?.length) {\n          // @ts-expect-error\n          result.required = [...new Set([...result.required, ...value])]\n        } else {\n          // @ts-expect-error\n          result.required = value.slice()\n        }\n      }\n    }\n    // Properties\n    else if (propertyName === 'properties') {\n      // Merge properties recursively\n      if (value && typeof value === 'object') {\n        // @ts-expect-error\n        if (!result.properties) {\n          // @ts-expect-error\n          result.properties = {}\n        }\n\n        // @ts-expect-error\n        mergePropertiesIntoResult(result.properties, value, seenRefs)\n      }\n    }\n    // Items\n    else if (propertyName === 'items') {\n      // Handle items (for both arrays and objects with items)\n      const items = resolve.schema(value)\n      if (items) {\n        if (isArraySchema(schema)) {\n          // @ts-expect-error\n          if (!result.items) {\n            // @ts-expect-error\n            result.items = {}\n          }\n\n          // Handle allOf within array items\n          if (items.allOf) {\n            const mergedItems = mergeAllOfSchemas(items, undefined, seenRefs)\n            // @ts-expect-error\n            Object.assign(result.items, mergedItems)\n          } else {\n            // @ts-expect-error\n            mergeItemsIntoResult(getResolvedRef(result.items), items, seenRefs)\n          }\n        }\n        // For non-array types with items.allOf, merge into properties\n        else if (items.allOf) {\n          const mergedItems = mergeAllOfSchemas(items, undefined, seenRefs)\n          if ('properties' in mergedItems) {\n            if (!('properties' in result)) {\n              // @ts-expect-error\n              result.properties = {}\n            }\n\n            'properties' in result && mergePropertiesIntoResult(result.properties, mergedItems.properties, seenRefs)\n          }\n        }\n        // For non-array types without allOf, still set items if not already set\n        else if (!('items' in result)) {\n          // @ts-expect-error\n          result.items = items\n        }\n      }\n    }\n    // Enum values and their annotations are applied together after the other keywords.\n    else if (key === 'enum') {\n      continue\n    }\n    // OneOf/AnyOf\n    else if (key === 'oneOf' || key === 'anyOf') {\n      // Preserve the composition itself so its variants keep rendering as a\n      // selector. Flattening the option properties into the parent would drop\n      // the variant structure entirely and silently lose branches that have no\n      // top-level `properties` (for example branches that are themselves an\n      // `allOf`). The sibling `allOf` members stay on `result` as base\n      // properties, which the Schema component renders above the selector.\n      if (Array.isArray(value) && value.length > 0 && (override || result[key] === undefined)) {\n        result[key] = value\n      }\n    }\n    // Skip allOf as it's handled at a higher level\n    else if (key === 'allOf') {\n      continue\n    }\n    // For all other properties, preserve the first occurrence or override if specified.\n    // Annotation keywords (see LAST_WINS_KEYS) always take the latest value so a later\n    // allOf member can override an earlier one.\n    else {\n      if (override || LAST_WINS_KEYS.has(propertyName) || result[key] === undefined) {\n        result[key] = value\n      }\n    }\n  }\n  Object.assign(result, mergedEnums)\n}\n\n/**\n * Efficiently merges properties into a result object without creating new objects.\n */\nconst mergePropertiesIntoResult = (\n  result: Extract<SchemaObject, { type: 'object' }>['properties'],\n  properties: Extract<SchemaObject, { type: 'object' }>['properties'],\n  seenRefs: Set<string> = new Set(),\n): void => {\n  const propertyKeys = Object.keys(properties ?? {})\n  if (!properties || !result || propertyKeys.length === 0) {\n    return\n  }\n\n  for (const key of propertyKeys) {\n    const schema = resolve.schema(properties[key])\n    if (!schema) {\n      delete result[key]\n      continue\n    }\n\n    if (typeof schema !== 'object') {\n      result[key] = schema\n      continue\n    }\n\n    if (!result[key]) {\n      // Break self-referential cycles reached through `allOf`. When a brand-new\n      // property's `$ref` is already being merged higher in the call stack,\n      // keep the raw reference instead of recursing into its `allOf` forever.\n      // This mirrors the guard in the \"merge existing property\" branch below and\n      // covers schemas that point back at themselves through an `allOf` member\n      // (e.g. a node whose `self` property $refs the node, which is an allOf).\n      const rawProperty = properties[key]\n      const newSchemaRef = (rawProperty as { $ref?: string })?.$ref\n      if (rawProperty && typeof newSchemaRef === 'string' && seenRefs.has(newSchemaRef)) {\n        result[key] = rawProperty\n        continue\n      }\n      const nextNewSeenRefs = typeof newSchemaRef === 'string' ? new Set(seenRefs).add(newSchemaRef) : seenRefs\n\n      // Handle new property with allOf\n      if (schema.allOf) {\n        result[key] = mergeAllOfSchemas(schema, undefined, nextNewSeenRefs)\n      } else if (isArraySchema(schema) && resolve.schema(schema.items)?.allOf) {\n        result[key] = {\n          ...schema,\n          items: mergeAllOfSchemas(resolve.schema(schema.items), undefined, seenRefs),\n        }\n      } else if (properties[key]) {\n        result[key] = properties[key]\n      }\n      continue\n    }\n\n    // Merge existing property\n    const existing = resolve.schema(result[key])\n\n    // Break self-referential cycles: when this property's `$ref` is already\n    // being merged higher in the call stack, keep the partially merged existing\n    // schema instead of recursing into it again. This mirrors the guard in\n    // `mergeItems` and covers schemas that point back at themselves through a\n    // plain object property (e.g. a tree node whose `parent` $refs the node).\n    const schemaRef = schema.$ref\n    if (typeof schemaRef === 'string' && seenRefs.has(schemaRef)) {\n      result[key] = existing\n      continue\n    }\n    const nextSeenRefs = typeof schemaRef === 'string' ? new Set(seenRefs).add(schemaRef) : seenRefs\n\n    if (schema.allOf) {\n      result[key] = mergeAllOfSchemas({ allOf: [existing, schema] } as SchemaObject, undefined, nextSeenRefs)\n    } else if (isArraySchema(schema) && isArraySchema(existing) && schema.items) {\n      const existingItems = resolve.schema(existing.items)\n      result[key] = {\n        ...existing,\n        type: 'array',\n        items: existingItems\n          ? mergeItems(existingItems, resolve.schema(schema.items), nextSeenRefs)\n          : resolve.schema(schema.items),\n      }\n    } else {\n      // Create merged object with properties handled separately\n      if ('properties' in existing && 'properties' in schema) {\n        const merged = { ...existing, ...schema }\n        merged.properties = { ...existing.properties }\n        mergePropertiesIntoResult(merged.properties, schema.properties, nextSeenRefs)\n        result[key] = merged\n      }\n      // Simple merge without property recursion\n      else {\n        result[key] = {\n          ...schema,\n          ...existing,\n          ...mergeEnums(existing, schema),\n        }\n      }\n    }\n  }\n}\n\n/**\n * Efficiently merges array items into a result object.\n */\nconst mergeItemsIntoResult = (result: SchemaObject, items: SchemaObject, seenRefs: Set<string> = new Set()): void => {\n  // Handle allOf in items\n  if (items.allOf || result.allOf) {\n    // Build array without spreads for better performance\n    const allOfSchemas: SchemaObject[] = []\n\n    if (result.allOf) {\n      for (const schema of result.allOf) {\n        allOfSchemas.push(resolve.schema(schema))\n      }\n    } else {\n      allOfSchemas.push(result)\n    }\n\n    if (items.allOf) {\n      for (const schema of items.allOf) {\n        allOfSchemas.push(resolve.schema(schema))\n      }\n    } else {\n      allOfSchemas.push(items)\n    }\n\n    const merged = mergeAllOfSchemas({ allOf: allOfSchemas } as SchemaObject, undefined, seenRefs)\n    Object.assign(result, merged)\n    return\n  }\n\n  // Regular merge\n  Object.assign(result, items)\n\n  // Merge properties if both have them\n  if ('properties' in result && 'properties' in items) {\n    mergePropertiesIntoResult(result.properties, items.properties, seenRefs)\n  }\n}\n\n/**\n * Helper function for merging items that returns a new object.\n */\nconst mergeItems = (\n  existing: SchemaObject,\n  incoming: SchemaObject,\n  seenRefs: Set<string> = new Set(),\n): SchemaObject => {\n  const incomingRef = (incoming as { $ref?: string }).$ref\n\n  if (typeof incomingRef === 'string') {\n    if (seenRefs.has(incomingRef)) {\n      return existing\n    }\n    return mergeItemsInner(existing, incoming, new Set(seenRefs).add(incomingRef))\n  }\n\n  return mergeItemsInner(existing, incoming, seenRefs)\n}\n\nconst mergeItemsInner = (\n  existing: SchemaObject,\n  incoming: SchemaObject,\n  seenRefs: Set<string> = new Set(),\n): SchemaObject => {\n  // Handle allOf in either schema\n  if (existing.allOf || incoming.allOf) {\n    // Build array without spreads for better performance\n    const allOfSchemas: SchemaObject[] = []\n\n    if (existing.allOf) {\n      for (const schema of existing.allOf) {\n        allOfSchemas.push(resolve.schema(schema))\n      }\n    } else {\n      allOfSchemas.push(existing)\n    }\n\n    if (incoming.allOf) {\n      for (const schema of incoming.allOf) {\n        allOfSchemas.push(resolve.schema(schema))\n      }\n    } else {\n      allOfSchemas.push(incoming)\n    }\n\n    return mergeAllOfSchemas({ allOf: allOfSchemas } as SchemaObject, undefined, seenRefs)\n  }\n\n  // Construct the merged object after narrowing both schemas so their property types survive.\n  if ('properties' in existing && 'properties' in incoming) {\n    const merged = { ...existing, ...incoming, properties: { ...existing.properties } }\n    mergePropertiesIntoResult(merged.properties, incoming.properties, seenRefs)\n    return merged\n  }\n\n  return { ...existing, ...incoming }\n}\n"],"mappings":"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"}

package/dist/schema/helpers/normalize-object-composition.d.ts

@@ -0,0 +1,9 @@
+import type { SchemaObject } from '@scalar/workspace-store/schemas/v3.2/strict/openapi-document';
+/** Display schemas may carry the nullable annotation produced by composition optimization. */
+type DisplaySchema = SchemaObject & {
+    nullable?: boolean;
+};
+/** Preserve a named property's object boundary when all of its composition members form one object. */
+export declare const normalizeObjectComposition: (value: DisplaySchema | undefined, name: string | undefined) => DisplaySchema | undefined;
+export {};
+//# sourceMappingURL=normalize-object-composition.d.ts.map

package/dist/schema/helpers/normalize-object-composition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-object-composition.d.ts","sourceRoot":"","sources":["../../../src/schema/helpers/normalize-object-composition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAA;AAKhG,8FAA8F;AAC9F,KAAK,aAAa,GAAG,YAAY,GAAG;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAA;AAE1D,uGAAuG;AACvG,eAAO,MAAM,0BAA0B,GACrC,OAAO,aAAa,GAAG,SAAS,EAChC,MAAM,MAAM,GAAG,SAAS,KACvB,aAAa,GAAG,SAmClB,CAAA"}

package/dist/schema/helpers/normalize-object-composition.js

@@ -0,0 +1,29 @@
+import { isTypeObject as e } from "./is-type-object.js";
+import { partitionAllOfCompositions as t } from "./partition-all-of-compositions.js";
+//#region src/schema/helpers/normalize-object-composition.ts
+var n = (n, r) => {
+	if (!r || !n?.allOf || n.oneOf || n.anyOf || n.not) return n;
+	let { segments: i } = t(n), a = i[0];
+	if (i.length !== 1 || a?.kind !== "object" || !e(a.schema)) return n;
+	let o = { ...a.schema };
+	"$ref" in o && delete o.$ref;
+	let s = {
+		title: n.title,
+		description: n.description,
+		deprecated: n.deprecated,
+		readOnly: n.readOnly,
+		writeOnly: n.writeOnly,
+		example: n.example,
+		examples: n.examples,
+		nullable: n.nullable
+	};
+	return {
+		...o,
+		...s,
+		..."$ref" in n && typeof n.$ref == "string" ? { $ref: n.$ref } : {}
+	};
+};
+//#endregion
+export { n as normalizeObjectComposition };
+
+//# sourceMappingURL=normalize-object-composition.js.map

package/dist/schema/helpers/normalize-object-composition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-object-composition.js","names":[],"sources":["../../../src/schema/helpers/normalize-object-composition.ts"],"sourcesContent":["import type { SchemaObject } from '@scalar/workspace-store/schemas/v3.2/strict/openapi-document'\n\nimport { isTypeObject } from './is-type-object'\nimport { partitionAllOfCompositions } from './partition-all-of-compositions'\n\n/** Display schemas may carry the nullable annotation produced by composition optimization. */\ntype DisplaySchema = SchemaObject & { nullable?: boolean }\n\n/** Preserve a named property's object boundary when all of its composition members form one object. */\nexport const normalizeObjectComposition = (\n  value: DisplaySchema | undefined,\n  name: string | undefined,\n): DisplaySchema | undefined => {\n  // Choice groups and unnamed composition containers keep their existing rendering.\n  if (!name || !value?.allOf || value.oneOf || value.anyOf || value.not) {\n    return value\n  }\n\n  const { segments } = partitionAllOfCompositions(value)\n  const segment = segments[0]\n  if (segments.length !== 1 || segment?.kind !== 'object' || !isTypeObject(segment.schema)) {\n    return value\n  }\n\n  // A member reference identifies only part of this object, not the combined property.\n  // Keep the property's own reference, if it has one.\n  const objectSchema = { ...segment.schema }\n  if ('$ref' in objectSchema) {\n    delete objectSchema.$ref\n  }\n  // Member annotations describe only one part of the combined property. Keep the\n  // property's annotations authoritative without changing merged validation rules.\n  const annotations = {\n    title: value.title,\n    description: value.description,\n    deprecated: value.deprecated,\n    readOnly: value.readOnly,\n    writeOnly: value.writeOnly,\n    example: value.example,\n    examples: value.examples,\n    nullable: value.nullable,\n  }\n  return {\n    ...objectSchema,\n    ...annotations,\n    ...('$ref' in value && typeof value.$ref === 'string' ? { $ref: value.$ref } : {}),\n  }\n}\n"],"mappings":";;;AASA,IAAa,KACX,GACA,MAC8B;CAE9B,IAAI,CAAC,KAAQ,CAAC,GAAO,SAAS,EAAM,SAAS,EAAM,SAAS,EAAM,KAChE,OAAO;CAGT,IAAM,EAAE,gBAAa,EAA2B,CAAK,GAC/C,IAAU,EAAS;CACzB,IAAI,EAAS,WAAW,KAAK,GAAS,SAAS,YAAY,CAAC,EAAa,EAAQ,MAAM,GACrF,OAAO;CAKT,IAAM,IAAe,EAAE,GAAG,EAAQ,OAAO;CACzC,AAAI,UAAU,KACZ,OAAO,EAAa;CAItB,IAAM,IAAc;EAClB,OAAO,EAAM;EACb,aAAa,EAAM;EACnB,YAAY,EAAM;EAClB,UAAU,EAAM;EAChB,WAAW,EAAM;EACjB,SAAS,EAAM;EACf,UAAU,EAAM;EAChB,UAAU,EAAM;CAClB;CACA,OAAO;EACL,GAAG;EACH,GAAG;EACH,GAAI,UAAU,KAAS,OAAO,EAAM,QAAS,WAAW,EAAE,MAAM,EAAM,KAAK,IAAI,CAAC;CAClF;AACF"}

package/dist/schema/helpers/optimize-value-for-display.d.ts

@@ -0,0 +1,13 @@
+import type { SchemaObject } from '@scalar/workspace-store/schemas/v3.2/strict/openapi-document';
+/** Display normalization tracks null branches without changing the stored OpenAPI schema. */
+type DisplaySchema = SchemaObject & {
+    nullable?: boolean;
+};
+/**
+ * Normalize compositions for display without changing the source schema. Null branches
+ * become nullable state, single branches are flattened, and shared properties and
+ * required fields are merged into variants so the renderer keeps their full context.
+ */
+export declare function optimizeValueForDisplay(value: DisplaySchema | undefined): DisplaySchema | undefined;
+export {};
+//# sourceMappingURL=optimize-value-for-display.d.ts.map

package/dist/schema/helpers/optimize-value-for-display.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimize-value-for-display.d.ts","sourceRoot":"","sources":["../../../src/schema/helpers/optimize-value-for-display.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAA;AAIhG,6FAA6F;AAC7F,KAAK,aAAa,GAAG,YAAY,GAAG;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAA;AAmD1D;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,aAAa,GAAG,SAAS,GAAG,aAAa,GAAG,SAAS,CAmHnG"}

package/dist/schema/helpers/optimize-value-for-display.js

@@ -0,0 +1,64 @@
+import { compositions as e } from "./schema-composition.js";
+import { resolve as t } from "@scalar/workspace-store/resolve";
+//#region src/schema/helpers/optimize-value-for-display.ts
+function n(...e) {
+	let t = {}, n = {}, r = /* @__PURE__ */ new Set(), i = !1, a = !1;
+	for (let o of e) if (o) for (let [e, s] of Object.entries(o)) {
+		if (e === "properties" && s && typeof s == "object") {
+			Object.assign(n, s), i = !0;
+			continue;
+		}
+		if (e === "required" && Array.isArray(s)) {
+			for (let e of s) r.add(e);
+			a = !0;
+			continue;
+		}
+		t[e] = s;
+	}
+	return i && (t.properties = n), a && (t.required = [...r]), t;
+}
+function r(r) {
+	if (!r || typeof r != "object") return r;
+	let i = e.find((e) => e in r && e !== "not");
+	if (!i) return { ...r };
+	let a = r[i];
+	if (!Array.isArray(a)) return { ...r };
+	let { [i]: o, nullable: s, ...c } = r, l = Object.keys(c).length > 0, { filteredSchemas: u, hasNullSchema: d } = a.reduce((e, n) => {
+		let r = t.schema(n);
+		return "type" in r && r.type === "null" ? e.hasNullSchema = !0 : e.filteredSchemas.push(r), e;
+	}, {
+		filteredSchemas: [],
+		hasNullSchema: !1
+	}), f = d || s === !0;
+	if (u.length === 1) {
+		let e = n(u[0], c);
+		return f && (e.nullable = !0), e;
+	}
+	if ((i === "oneOf" || i === "anyOf") && (l || u.some((e) => e.allOf))) {
+		let { discriminator: e, ...a } = c, o = u.map((e) => {
+			let r = t.schema(e);
+			if (r.allOf?.length === 1) {
+				let { allOf: e, ...i } = r, o = t.schema(e[0]);
+				if ("properties" in i || "required" in i || "$ref" in i) {
+					let { $ref: e, title: t, name: r, ...s } = o;
+					return n(a, i, s);
+				}
+				return n(a, i, o);
+			}
+			return n(a, r);
+		}), s = { [i]: o };
+		return typeof r.description == "string" && (s.description = r.description), f && (s.nullable = !0), s;
+	}
+	if (u.length !== a.length) {
+		let e = {
+			...r,
+			[i]: u
+		};
+		return f && (e.nullable = !0), e;
+	}
+	return { ...r };
+}
+//#endregion
+export { r as optimizeValueForDisplay };
+
+//# sourceMappingURL=optimize-value-for-display.js.map

package/dist/schema/helpers/optimize-value-for-display.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimize-value-for-display.js","names":[],"sources":["../../../src/schema/helpers/optimize-value-for-display.ts"],"sourcesContent":["import { resolve } from '@scalar/workspace-store/resolve'\nimport type { SchemaObject } from '@scalar/workspace-store/schemas/v3.2/strict/openapi-document'\n\nimport { compositions } from './schema-composition'\n\n/** Display normalization tracks null branches without changing the stored OpenAPI schema. */\ntype DisplaySchema = SchemaObject & { nullable?: boolean }\n\n/**\n * Shallow-merges schema-like objects, but unions `properties` and `required`\n * instead of letting a later object's `properties`/`required` completely\n * overwrite an earlier one's. Without this, a variant schema (e.g. a `oneOf`\n * branch) that declares its own `properties`/`required` would wipe out the\n * shared base fields factored out at the root (or via a sibling `allOf`)\n * instead of being combined with them (#9657).\n */\nfunction mergeSchemaProperties(...objects: (Record<string, unknown> | undefined)[]): Record<string, unknown> {\n  const merged: Record<string, unknown> = {}\n  const properties: Record<string, unknown> = {}\n  const required = new Set<string>()\n  let hasProperties = false\n  let hasRequired = false\n\n  for (const object of objects) {\n    if (!object) {\n      continue\n    }\n\n    for (const [key, val] of Object.entries(object)) {\n      if (key === 'properties' && val && typeof val === 'object') {\n        Object.assign(properties, val)\n        hasProperties = true\n        continue\n      }\n\n      if (key === 'required' && Array.isArray(val)) {\n        for (const name of val) {\n          required.add(name)\n        }\n        hasRequired = true\n        continue\n      }\n\n      merged[key] = val\n    }\n  }\n\n  if (hasProperties) {\n    merged.properties = properties\n  }\n  if (hasRequired) {\n    merged.required = [...required]\n  }\n\n  return merged\n}\n\n/**\n * Normalize compositions for display without changing the source schema. Null branches\n * become nullable state, single branches are flattened, and shared properties and\n * required fields are merged into variants so the renderer keeps their full context.\n */\nexport function optimizeValueForDisplay(value: DisplaySchema | undefined): DisplaySchema | undefined {\n  if (!value || typeof value !== 'object') {\n    return value\n  }\n\n  // Find the composition keyword early to avoid unnecessary work\n  const composition = compositions.find((keyword) => keyword in value && keyword !== 'not')\n\n  // If there's no relevant composition keyword, return a shallow copy\n  if (!composition) {\n    return { ...value }\n  }\n\n  const schemas = value[composition]\n  if (!Array.isArray(schemas)) {\n    return { ...value }\n  }\n\n  // Extract root properties efficiently (excluding composition and nullable)\n  const { [composition]: _, nullable: originalNullable, ...rootProperties } = value\n  const hasRootProperties = Object.keys(rootProperties).length > 0\n\n  // Check for null schemas and filter them out in one pass\n  const { filteredSchemas, hasNullSchema } = schemas.reduce<{\n    filteredSchemas: SchemaObject[]\n    hasNullSchema: boolean\n  }>(\n    (acc, _schema) => {\n      const schema = resolve.schema(_schema)\n\n      if ('type' in schema && schema.type === 'null') {\n        acc.hasNullSchema = true\n      } else {\n        acc.filteredSchemas.push(schema)\n      }\n      return acc\n    },\n    { filteredSchemas: [], hasNullSchema: false },\n  )\n\n  // Determine if nullable should be set\n  const shouldBeNullable = hasNullSchema || originalNullable === true\n\n  // If only one schema remains after filtering, merge with root properties.\n  // `properties`/`required` are unioned so sibling properties declared next to\n  // the composition (e.g. `properties` alongside a single-`$ref` `allOf`) are\n  // kept instead of being overwritten by the member schema's own `properties`.\n  // Root-level annotations (title, description, …) win over the member's: they\n  // describe the combined schema, not the base it extends.\n  if (filteredSchemas.length === 1) {\n    const mergedSchema = mergeSchemaProperties(filteredSchemas[0], rootProperties) as DisplaySchema\n    if (shouldBeNullable) {\n      mergedSchema.nullable = true\n    }\n    return mergedSchema\n  }\n\n  // Check if root properties should be merged into schemas\n  const shouldMergeRootProperties =\n    (composition === 'oneOf' || composition === 'anyOf') &&\n    (hasRootProperties || filteredSchemas.some((schema) => schema.allOf))\n\n  if (shouldMergeRootProperties) {\n    // The discriminator belongs to the union, not to its variants. Copied into a variant, it\n    // makes the variant look like a bare `discriminator.mapping` base, which then infers a\n    // second selector inside the variant.\n    const { discriminator: _discriminator, ...variantRootProperties } = rootProperties\n\n    const mergedSchemas = filteredSchemas.map((_schema) => {\n      const schema = resolve.schema(_schema)\n\n      // Flatten single-item allOf and merge with root properties. If the\n      // variant has its own properties/required/$ref, the allOf member's own\n      // identity (`$ref`, `title`, `name`) is dropped before merging so it\n      // cannot overwrite the variant's, which would otherwise mislabel the\n      // flattened schema as the base it extends instead of the variant itself\n      // (#9964). `getModelNameFromSchema` labels a variant by title → name →\n      // $ref, so any of those leaking from the base is enough to mislabel it.\n      // A variant that is a bare wrapper around the allOf member has no\n      // identity of its own to protect, so the base's identity is kept as a\n      // fallback label.\n      if (schema.allOf?.length === 1) {\n        const { allOf, ...otherProps } = schema\n        const allOfMember = resolve.schema(allOf[0])!\n        const variantHasOwnIdentity = 'properties' in otherProps || 'required' in otherProps || '$ref' in otherProps\n        if (variantHasOwnIdentity) {\n          const { $ref: _ref, title: _title, name: _name, ...allOfMemberWithoutIdentity } = allOfMember\n          return mergeSchemaProperties(variantRootProperties, otherProps, allOfMemberWithoutIdentity)\n        }\n        return mergeSchemaProperties(variantRootProperties, otherProps, allOfMember)\n      }\n      return mergeSchemaProperties(variantRootProperties, schema)\n    })\n\n    // @ts-expect-error - We avoid using coerceValue here as it may be dangerous, so we type cast\n    const result = { [composition]: mergedSchemas } as DisplaySchema\n    if (typeof value.description === 'string') {\n      result.description = value.description\n    }\n    if (shouldBeNullable) {\n      result.nullable = true\n    }\n    return result\n  }\n\n  // Return with filtered schemas if any nulls were removed\n  if (filteredSchemas.length !== schemas.length) {\n    const result: DisplaySchema = { ...value, [composition]: filteredSchemas }\n    if (shouldBeNullable) {\n      result.nullable = true\n    }\n    return result\n  }\n\n  return { ...value }\n}\n"],"mappings":";;;AAgBA,SAAS,EAAsB,GAAG,GAA2E;CAC3G,IAAM,IAAkC,CAAC,GACnC,IAAsC,CAAC,GACvC,oBAAW,IAAI,IAAY,GAC7B,IAAgB,IAChB,IAAc;CAElB,KAAK,IAAM,KAAU,GACd,OAIL,KAAK,IAAM,CAAC,GAAK,MAAQ,OAAO,QAAQ,CAAM,GAAG;EAC/C,IAAI,MAAQ,gBAAgB,KAAO,OAAO,KAAQ,UAAU;GAE1D,AADA,OAAO,OAAO,GAAY,CAAG,GAC7B,IAAgB;GAChB;EACF;EAEA,IAAI,MAAQ,cAAc,MAAM,QAAQ,CAAG,GAAG;GAC5C,KAAK,IAAM,KAAQ,GACjB,EAAS,IAAI,CAAI;GAEnB,IAAc;GACd;EACF;EAEA,EAAO,KAAO;CAChB;CAUF,OAPI,MACF,EAAO,aAAa,IAElB,MACF,EAAO,WAAW,CAAC,GAAG,CAAQ,IAGzB;AACT;AAOA,SAAgB,EAAwB,GAA6D;CACnG,IAAI,CAAC,KAAS,OAAO,KAAU,UAC7B,OAAO;CAIT,IAAM,IAAc,EAAa,MAAM,MAAY,KAAW,KAAS,MAAY,KAAK;CAGxF,IAAI,CAAC,GACH,OAAO,EAAE,GAAG,EAAM;CAGpB,IAAM,IAAU,EAAM;CACtB,IAAI,CAAC,MAAM,QAAQ,CAAO,GACxB,OAAO,EAAE,GAAG,EAAM;CAIpB,IAAM,GAAG,IAAc,GAAG,UAAU,GAAkB,GAAG,MAAmB,GACtE,IAAoB,OAAO,KAAK,CAAc,CAAC,CAAC,SAAS,GAGzD,EAAE,oBAAiB,qBAAkB,EAAQ,QAIhD,GAAK,MAAY;EAChB,IAAM,IAAS,EAAQ,OAAO,CAAO;EAOrC,OALI,UAAU,KAAU,EAAO,SAAS,SACtC,EAAI,gBAAgB,KAEpB,EAAI,gBAAgB,KAAK,CAAM,GAE1B;CACT,GACA;EAAE,iBAAiB,CAAC;EAAG,eAAe;CAAM,CAC9C,GAGM,IAAmB,KAAiB,MAAqB;CAQ/D,IAAI,EAAgB,WAAW,GAAG;EAChC,IAAM,IAAe,EAAsB,EAAgB,IAAI,CAAc;EAI7E,OAHI,MACF,EAAa,WAAW,KAEnB;CACT;CAOA,KAHG,MAAgB,WAAW,MAAgB,aAC3C,KAAqB,EAAgB,MAAM,MAAW,EAAO,KAAK,IAEtC;EAI7B,IAAM,EAAE,eAAe,GAAgB,GAAG,MAA0B,GAE9D,IAAgB,EAAgB,KAAK,MAAY;GACrD,IAAM,IAAS,EAAQ,OAAO,CAAO;GAYrC,IAAI,EAAO,OAAO,WAAW,GAAG;IAC9B,IAAM,EAAE,UAAO,GAAG,MAAe,GAC3B,IAAc,EAAQ,OAAO,EAAM,EAAE;IAE3C,IAD8B,gBAAgB,KAAc,cAAc,KAAc,UAAU,GACvE;KACzB,IAAM,EAAE,MAAM,GAAM,OAAO,GAAQ,MAAM,GAAO,GAAG,MAA+B;KAClF,OAAO,EAAsB,GAAuB,GAAY,CAA0B;IAC5F;IACA,OAAO,EAAsB,GAAuB,GAAY,CAAW;GAC7E;GACA,OAAO,EAAsB,GAAuB,CAAM;EAC5D,CAAC,GAGK,IAAS,GAAG,IAAc,EAAc;EAO9C,OANI,OAAO,EAAM,eAAgB,aAC/B,EAAO,cAAc,EAAM,cAEzB,MACF,EAAO,WAAW,KAEb;CACT;CAGA,IAAI,EAAgB,WAAW,EAAQ,QAAQ;EAC7C,IAAM,IAAwB;GAAE,GAAG;IAAQ,IAAc;EAAgB;EAIzE,OAHI,MACF,EAAO,WAAW,KAEb;CACT;CAEA,OAAO,EAAE,GAAG,EAAM;AACpB"}

package/dist/schema/helpers/partition-all-of-compositions.d.ts

@@ -0,0 +1,32 @@
+import type { SchemaObject } from '@scalar/workspace-store/schemas/v3.2/strict/openapi-document';
+import type { CompositionKeyword } from './schema-composition';
+type ChoiceKeyword = Extract<CompositionKeyword, 'oneOf' | 'anyOf'>;
+/** An ordered piece of an `allOf`: either a merged object or a choice picker. */
+type AllOfSegment = {
+    kind: 'object';
+    schema: SchemaObject;
+} | {
+    kind: 'choice';
+    composition: ChoiceKeyword;
+    /** A minimal schema carrying only this group's composition, for SchemaComposition */
+    value: SchemaObject;
+    /** Ordinal among choice members, matching the request-example composition key */
+    choiceIndex: number;
+};
+/**
+ * Splits an `allOf` schema into an ordered list of segments so the renderer can
+ * show each `oneOf`/`anyOf` group as its own picker **in the position it was
+ * declared**, with the surrounding plain fields around it.
+ *
+ * `mergeAllOfSchemas` alone keeps only the FIRST `oneOf`/`anyOf` (dropping the
+ * 2nd+ groups of an object with several independent mutually-exclusive
+ * selections) and, being a merge, also loses the ordering between fields and
+ * choices. Walking the members in order fixes both: runs of consecutive object
+ * members are merged into one object segment, and each choice member becomes its
+ * own picker segment in place.
+ */
+export declare const partitionAllOfCompositions: (schema: SchemaObject | undefined) => {
+    segments: AllOfSegment[];
+};
+export {};
+//# sourceMappingURL=partition-all-of-compositions.d.ts.map

package/dist/schema/helpers/partition-all-of-compositions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition-all-of-compositions.d.ts","sourceRoot":"","sources":["../../../src/schema/helpers/partition-all-of-compositions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAA;AAGhG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAE9D,KAAK,aAAa,GAAG,OAAO,CAAC,kBAAkB,EAAE,OAAO,GAAG,OAAO,CAAC,CAAA;AAEnE,iFAAiF;AACjF,KAAK,YAAY,GACb;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAE,GACxC;IACE,IAAI,EAAE,QAAQ,CAAA;IACd,WAAW,EAAE,aAAa,CAAA;IAC1B,qFAAqF;IACrF,KAAK,EAAE,YAAY,CAAA;IACnB,iFAAiF;IACjF,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAmFL;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,0BAA0B,GAAI,QAAQ,YAAY,GAAG,SAAS,KAAG;IAAE,QAAQ,EAAE,YAAY,EAAE,CAAA;CAmFvG,CAAA"}

package/dist/schema/helpers/partition-all-of-compositions.js

@@ -0,0 +1,67 @@
+import { mergeAllOfSchemas as e } from "./merge-all-of-schemas.js";
+import { resolve as t } from "@scalar/workspace-store/resolve";
+//#region src/schema/helpers/partition-all-of-compositions.ts
+var n = ["oneOf", "anyOf"], r = (e, i, a) => {
+	let { allOf: o, oneOf: s, anyOf: c, not: l, if: u, then: d, else: f, ...p } = e;
+	Object.keys(p).length > 0 && i.push({
+		kind: "object",
+		schema: p
+	});
+	for (let e of n) {
+		let t = e === "oneOf" ? s : c, n = Array.isArray(t) && t.some((e) => {
+			let t = e && typeof e == "object" && "$ref" in e ? e.$ref : void 0;
+			return typeof t == "string" && a.has(t);
+		});
+		Array.isArray(t) && t.length > 0 && i.push({
+			kind: "choice",
+			composition: e,
+			value: { [e]: t },
+			inheritedSelection: n
+		});
+	}
+	if (Array.isArray(o)) {
+		for (let e of o) if (e && typeof e == "object") {
+			let n = t.schema(e), o = n.$ref;
+			if (typeof o == "string") {
+				if (a.has(o)) continue;
+				r(n, i, new Set(a).add(o));
+			} else r(n, i, a);
+		}
+	}
+}, i = (n) => {
+	if (!n) return { segments: [] };
+	let { allOf: i, oneOf: a, anyOf: o, not: s, if: c, then: l, else: u, ...d } = n;
+	if (!Array.isArray(i)) return { segments: [{
+		kind: "object",
+		schema: n
+	}] };
+	let f = [];
+	Object.keys(d).length > 0 && f.push({
+		kind: "object",
+		schema: d
+	});
+	let p = "$ref" in n ? n.$ref : void 0, m = new Set(typeof p == "string" ? [p] : []);
+	for (let e of i) if (e && typeof e == "object") {
+		let n = t.schema(e), i = n.$ref;
+		r(n, f, typeof i == "string" ? new Set(m).add(i) : m);
+	}
+	let h = [], g = [], _ = 0, v = () => {
+		if (g.length === 0) return;
+		let t = g.length === 1 ? g[0] : e({ allOf: g });
+		h.push({
+			kind: "object",
+			schema: t
+		}), g = [];
+	};
+	for (let e of f) e.kind === "object" ? g.push(e.schema) : e.inheritedSelection ? _++ : (v(), h.push({
+		kind: "choice",
+		composition: e.composition,
+		value: e.value,
+		choiceIndex: _++
+	}));
+	return v(), { segments: h };
+};
+//#endregion
+export { i as partitionAllOfCompositions };
+
+//# sourceMappingURL=partition-all-of-compositions.js.map

package/dist/schema/helpers/partition-all-of-compositions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition-all-of-compositions.js","names":[],"sources":["../../../src/schema/helpers/partition-all-of-compositions.ts"],"sourcesContent":["import { resolve } from '@scalar/workspace-store/resolve'\nimport type { SchemaObject } from '@scalar/workspace-store/schemas/v3.2/strict/openapi-document'\n\nimport { mergeAllOfSchemas } from './merge-all-of-schemas'\nimport type { CompositionKeyword } from './schema-composition'\n\ntype ChoiceKeyword = Extract<CompositionKeyword, 'oneOf' | 'anyOf'>\n\n/** An ordered piece of an `allOf`: either a merged object or a choice picker. */\ntype AllOfSegment =\n  | { kind: 'object'; schema: SchemaObject }\n  | {\n      kind: 'choice'\n      composition: ChoiceKeyword\n      /** A minimal schema carrying only this group's composition, for SchemaComposition */\n      value: SchemaObject\n      /** Ordinal among choice members, matching the request-example composition key */\n      choiceIndex: number\n    }\n\nconst CHOICE_KEYWORDS: ChoiceKeyword[] = ['oneOf', 'anyOf']\n\ntype Member =\n  | { kind: 'object'; schema: SchemaObject }\n  | { kind: 'choice'; composition: ChoiceKeyword; value: SchemaObject; inheritedSelection: boolean }\n\n/**\n * Flattens a member's own (non-composition) properties and every `oneOf`/`anyOf`\n * group it declares — recursing into nested `allOf` — into a flat, ordered list,\n * preserving source order so choice groups stay where they were authored.\n *\n * Pure-constraint keywords (`not`, `if/then/else`) are dropped: they carry no\n * visual variant and Scalar would otherwise render `not` as a bogus picker. The\n * rule still lives in the schema (validation) and in field descriptions.\n */\nconst collectMembers = (schema: SchemaObject, out: Member[], seenRefs: Set<string>): void => {\n  const {\n    allOf,\n    oneOf,\n    anyOf,\n    not: _not,\n    if: _if,\n    then: _then,\n    else: _else,\n    ...rest\n  }: SchemaObject & {\n    allOf?: unknown[]\n    oneOf?: unknown[]\n    anyOf?: unknown[]\n    not?: unknown\n    if?: unknown\n    then?: unknown\n    else?: unknown\n  } = schema\n\n  if (Object.keys(rest).length > 0) {\n    out.push({ kind: 'object', schema: rest })\n  }\n\n  for (const keyword of CHOICE_KEYWORDS) {\n    const value = keyword === 'oneOf' ? oneOf : anyOf\n    // A variant inherits its base fields through allOf, but the base's choice\n    // containing that variant has already been selected. Rendering it again\n    // would re-enter the variant and expose fields from the other branches.\n    const selectsAncestor =\n      Array.isArray(value) &&\n      value.some((branch) => {\n        const ref = branch && typeof branch === 'object' && '$ref' in branch ? branch.$ref : undefined\n        return typeof ref === 'string' && seenRefs.has(ref)\n      })\n    if (Array.isArray(value) && value.length > 0) {\n      out.push({\n        kind: 'choice',\n        composition: keyword,\n        value: { [keyword]: value } as unknown as SchemaObject,\n        inheritedSelection: selectsAncestor,\n      })\n    }\n  }\n\n  if (Array.isArray(allOf)) {\n    for (const rawMember of allOf) {\n      if (rawMember && typeof rawMember === 'object') {\n        const resolved: SchemaObject & { $ref?: string } = resolve.schema(rawMember)\n        // Break `$ref` cycles reached through `allOf` (e.g. a member that\n        // references an ancestor). Without this guard a recursive `allOf`\n        // schema would recurse forever. `mergeAllOfSchemas` guards the same way.\n        const ref = resolved.$ref\n        if (typeof ref === 'string') {\n          if (seenRefs.has(ref)) {\n            continue\n          }\n          collectMembers(resolved, out, new Set(seenRefs).add(ref))\n        } else {\n          collectMembers(resolved, out, seenRefs)\n        }\n      }\n    }\n  }\n}\n\n/**\n * Splits an `allOf` schema into an ordered list of segments so the renderer can\n * show each `oneOf`/`anyOf` group as its own picker **in the position it was\n * declared**, with the surrounding plain fields around it.\n *\n * `mergeAllOfSchemas` alone keeps only the FIRST `oneOf`/`anyOf` (dropping the\n * 2nd+ groups of an object with several independent mutually-exclusive\n * selections) and, being a merge, also loses the ordering between fields and\n * choices. Walking the members in order fixes both: runs of consecutive object\n * members are merged into one object segment, and each choice member becomes its\n * own picker segment in place.\n */\nexport const partitionAllOfCompositions = (schema: SchemaObject | undefined): { segments: AllOfSegment[] } => {\n  if (!schema) {\n    return { segments: [] }\n  }\n\n  // The schema's own (non-composition) keys, minus its top-level `oneOf`/`anyOf`\n  // — those are rendered as their own composition by the caller, not here.\n  const {\n    allOf,\n    oneOf: _oneOf,\n    anyOf: _anyOf,\n    not: _not,\n    if: _if,\n    then: _then,\n    else: _else,\n    ...rest\n  }: SchemaObject & {\n    allOf?: unknown[]\n    oneOf?: unknown[]\n    anyOf?: unknown[]\n    not?: unknown\n    if?: unknown\n    then?: unknown\n    else?: unknown\n  } = schema\n\n  if (!Array.isArray(allOf)) {\n    return { segments: [{ kind: 'object', schema: schema }] }\n  }\n\n  const members: Member[] = []\n  if (Object.keys(rest).length > 0) {\n    members.push({ kind: 'object', schema: rest })\n  }\n  const schemaRef = '$ref' in schema ? schema.$ref : undefined\n  const seenRefs = new Set<string>(typeof schemaRef === 'string' ? [schemaRef] : [])\n  for (const rawMember of allOf) {\n    if (rawMember && typeof rawMember === 'object') {\n      const resolved: SchemaObject & { $ref?: string } = resolve.schema(rawMember)\n      const ref = resolved.$ref\n      collectMembers(resolved, members, typeof ref === 'string' ? new Set(seenRefs).add(ref) : seenRefs)\n    }\n  }\n\n  // Coalesce consecutive object members into a single merged object segment,\n  // keeping choice members as their own segments between them.\n  const segments: AllOfSegment[] = []\n  let objectRun: SchemaObject[] = []\n  let choiceIndex = 0\n\n  const flushObjectRun = () => {\n    if (objectRun.length === 0) {\n      return\n    }\n    const merged = objectRun.length === 1 ? objectRun[0]! : mergeAllOfSchemas({ allOf: objectRun } as SchemaObject)\n    segments.push({ kind: 'object', schema: merged })\n    objectRun = []\n  }\n\n  for (const member of members) {\n    if (member.kind === 'object') {\n      objectRun.push(member.schema)\n    } else if (member.inheritedSelection) {\n      // Hidden inherited choices still occupy an ordinal in the request example.\n      choiceIndex++\n    } else {\n      flushObjectRun()\n      // `choiceIndex` is the ordinal used to build the composition-selection key\n      // that syncs each picker with the request example. It MUST stay aligned\n      // with the ordinal computed while walking `allOf` in\n      // `get-example-from-schema.ts` (`@scalar/workspace-store`), or a picker and\n      // its generated example fall out of sync.\n      segments.push({\n        kind: 'choice',\n        composition: member.composition,\n        value: member.value,\n        choiceIndex: choiceIndex++,\n      })\n    }\n  }\n  flushObjectRun()\n\n  return { segments }\n}\n"],"mappings":";;;AAoBA,IAAM,IAAmC,CAAC,SAAS,OAAO,GAepD,KAAkB,GAAsB,GAAe,MAAgC;CAC3F,IAAM,EACJ,UACA,UACA,UACA,KAAK,GACL,IAAI,GACJ,MAAM,GACN,MAAM,GACN,GAAG,MASD;CAEJ,AAAI,OAAO,KAAK,CAAI,CAAC,CAAC,SAAS,KAC7B,EAAI,KAAK;EAAE,MAAM;EAAU,QAAQ;CAAK,CAAC;CAG3C,KAAK,IAAM,KAAW,GAAiB;EACrC,IAAM,IAAQ,MAAY,UAAU,IAAQ,GAItC,IACJ,MAAM,QAAQ,CAAK,KACnB,EAAM,MAAM,MAAW;GACrB,IAAM,IAAM,KAAU,OAAO,KAAW,YAAY,UAAU,IAAS,EAAO,OAAO,KAAA;GACrF,OAAO,OAAO,KAAQ,YAAY,EAAS,IAAI,CAAG;EACpD,CAAC;EACH,AAAI,MAAM,QAAQ,CAAK,KAAK,EAAM,SAAS,KACzC,EAAI,KAAK;GACP,MAAM;GACN,aAAa;GACb,OAAO,GAAG,IAAU,EAAM;GAC1B,oBAAoB;EACtB,CAAC;CAEL;CAEA,IAAI,MAAM,QAAQ,CAAK;OAChB,IAAM,KAAa,GACtB,IAAI,KAAa,OAAO,KAAc,UAAU;GAC9C,IAAM,IAA6C,EAAQ,OAAO,CAAS,GAIrE,IAAM,EAAS;GACrB,IAAI,OAAO,KAAQ,UAAU;IAC3B,IAAI,EAAS,IAAI,CAAG,GAClB;IAEF,EAAe,GAAU,GAAK,IAAI,IAAI,CAAQ,CAAC,CAAC,IAAI,CAAG,CAAC;GAC1D,OACE,EAAe,GAAU,GAAK,CAAQ;EAE1C;;AAGN,GAca,KAA8B,MAAmE;CAC5G,IAAI,CAAC,GACH,OAAO,EAAE,UAAU,CAAC,EAAE;CAKxB,IAAM,EACJ,UACA,OAAO,GACP,OAAO,GACP,KAAK,GACL,IAAI,GACJ,MAAM,GACN,MAAM,GACN,GAAG,MASD;CAEJ,IAAI,CAAC,MAAM,QAAQ,CAAK,GACtB,OAAO,EAAE,UAAU,CAAC;EAAE,MAAM;EAAkB;CAAO,CAAC,EAAE;CAG1D,IAAM,IAAoB,CAAC;CAC3B,AAAI,OAAO,KAAK,CAAI,CAAC,CAAC,SAAS,KAC7B,EAAQ,KAAK;EAAE,MAAM;EAAU,QAAQ;CAAK,CAAC;CAE/C,IAAM,IAAY,UAAU,IAAS,EAAO,OAAO,KAAA,GAC7C,IAAW,IAAI,IAAY,OAAO,KAAc,WAAW,CAAC,CAAS,IAAI,CAAC,CAAC;CACjF,KAAK,IAAM,KAAa,GACtB,IAAI,KAAa,OAAO,KAAc,UAAU;EAC9C,IAAM,IAA6C,EAAQ,OAAO,CAAS,GACrE,IAAM,EAAS;EACrB,EAAe,GAAU,GAAS,OAAO,KAAQ,WAAW,IAAI,IAAI,CAAQ,CAAC,CAAC,IAAI,CAAG,IAAI,CAAQ;CACnG;CAKF,IAAM,IAA2B,CAAC,GAC9B,IAA4B,CAAC,GAC7B,IAAc,GAEZ,UAAuB;EAC3B,IAAI,EAAU,WAAW,GACvB;EAEF,IAAM,IAAS,EAAU,WAAW,IAAI,EAAU,KAAM,EAAkB,EAAE,OAAO,EAAU,CAAiB;EAE9G,AADA,EAAS,KAAK;GAAE,MAAM;GAAU,QAAQ;EAAO,CAAC,GAChD,IAAY,CAAC;CACf;CAEA,KAAK,IAAM,KAAU,GACnB,AAAI,EAAO,SAAS,WAClB,EAAU,KAAK,EAAO,MAAM,IACnB,EAAO,qBAEhB,OAEA,EAAe,GAMf,EAAS,KAAK;EACZ,MAAM;EACN,aAAa,EAAO;EACpB,OAAO,EAAO;EACd,aAAa;CACf,CAAC;CAKL,OAFA,EAAe,GAER,EAAE,YAAS;AACpB"}

package/dist/schema/helpers/schema-composition.d.ts

@@ -0,0 +1,4 @@
+/** Composition */
+export type CompositionKeyword = 'oneOf' | 'anyOf' | 'allOf' | 'not';
+export declare const compositions: CompositionKeyword[];
+//# sourceMappingURL=schema-composition.d.ts.map

package/dist/schema/helpers/schema-composition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-composition.d.ts","sourceRoot":"","sources":["../../../src/schema/helpers/schema-composition.ts"],"names":[],"mappings":"AAAA,kBAAkB;AAClB,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,KAAK,CAAA;AAEpE,eAAO,MAAM,YAAY,EAAE,kBAAkB,EAAuC,CAAA"}

package/dist/schema/helpers/schema-composition.js

@@ -0,0 +1,11 @@
+//#region src/schema/helpers/schema-composition.ts
+var e = [
+	"oneOf",
+	"anyOf",
+	"allOf",
+	"not"
+];
+//#endregion
+export { e as compositions };
+
+//# sourceMappingURL=schema-composition.js.map

package/dist/schema/helpers/schema-composition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-composition.js","names":[],"sources":["../../../src/schema/helpers/schema-composition.ts"],"sourcesContent":["/** Composition */\nexport type CompositionKeyword = 'oneOf' | 'anyOf' | 'allOf' | 'not'\n\nexport const compositions: CompositionKeyword[] = ['oneOf', 'anyOf', 'allOf', 'not']\n"],"mappings":";AAGA,IAAa,IAAqC;CAAC;CAAS;CAAS;CAAS;AAAK"}

package/dist/schema/helpers/schema-cycle.d.ts

@@ -0,0 +1,31 @@
+import type { InjectionKey } from 'vue';
+/**
+ * The set of schema "cycle keys" for every ancestor on the current render path.
+ *
+ * Each `Schema` component injects this set, adds its own key, and re-provides
+ * it to its descendants. When a node's key is already present in the ancestor
+ * set we've hit a cycle (a self-referential schema) and must stop force
+ * expanding to avoid rendering forever.
+ *
+ * See {@link getCycleKey} for how a node's key is derived.
+ */
+export declare const SCHEMA_ANCESTORS_SYMBOL: InjectionKey<ReadonlySet<unknown>>;
+/**
+ * Derive a stable identity for a schema node from its *raw* (unresolved) value.
+ *
+ * Cycle detection needs a key that is identical every time the same schema is
+ * reached along a path, and that survives the shallow copies/merges performed
+ * while rendering (which break object identity of the resolved schema).
+ *
+ * - For `$ref` nodes we use the ref string. Two branches that reference the
+ *   same component share the string, so a schema that (transitively) references
+ *   itself is detected as a cycle, while sibling references are not.
+ * - For inline schemas there is no ref, so we fall back to the raw object
+ *   reference. A self-referential inline schema reuses the same object, so
+ *   object identity catches the cycle.
+ *
+ * Returns `undefined` for primitives/booleans (e.g. `additionalProperties: true`)
+ * which can never form a cycle.
+ */
+export declare const getCycleKey: (raw: unknown) => unknown;
+//# sourceMappingURL=schema-cycle.d.ts.map

package/dist/schema/helpers/schema-cycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-cycle.d.ts","sourceRoot":"","sources":["../../../src/schema/helpers/schema-cycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,KAAK,CAAA;AAEvC;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,EAAE,YAAY,CAAC,WAAW,CAAC,OAAO,CAAC,CAA8B,CAAA;AAErG;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,WAAW,GAAI,KAAK,OAAO,KAAG,OAS1C,CAAA"}

package/dist/schema/helpers/schema-cycle.js

@@ -0,0 +1,8 @@
+//#region src/schema/helpers/schema-cycle.ts
+var e = Symbol("schema-ancestors"), t = (e) => {
+	if (e && typeof e == "object") return "$ref" in e && typeof e.$ref == "string" ? e.$ref : e;
+};
+//#endregion
+export { e as SCHEMA_ANCESTORS_SYMBOL, t as getCycleKey };
+
+//# sourceMappingURL=schema-cycle.js.map

package/dist/schema/helpers/schema-cycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-cycle.js","names":[],"sources":["../../../src/schema/helpers/schema-cycle.ts"],"sourcesContent":["import type { InjectionKey } from 'vue'\n\n/**\n * The set of schema \"cycle keys\" for every ancestor on the current render path.\n *\n * Each `Schema` component injects this set, adds its own key, and re-provides\n * it to its descendants. When a node's key is already present in the ancestor\n * set we've hit a cycle (a self-referential schema) and must stop force\n * expanding to avoid rendering forever.\n *\n * See {@link getCycleKey} for how a node's key is derived.\n */\nexport const SCHEMA_ANCESTORS_SYMBOL: InjectionKey<ReadonlySet<unknown>> = Symbol('schema-ancestors')\n\n/**\n * Derive a stable identity for a schema node from its *raw* (unresolved) value.\n *\n * Cycle detection needs a key that is identical every time the same schema is\n * reached along a path, and that survives the shallow copies/merges performed\n * while rendering (which break object identity of the resolved schema).\n *\n * - For `$ref` nodes we use the ref string. Two branches that reference the\n *   same component share the string, so a schema that (transitively) references\n *   itself is detected as a cycle, while sibling references are not.\n * - For inline schemas there is no ref, so we fall back to the raw object\n *   reference. A self-referential inline schema reuses the same object, so\n *   object identity catches the cycle.\n *\n * Returns `undefined` for primitives/booleans (e.g. `additionalProperties: true`)\n * which can never form a cycle.\n */\nexport const getCycleKey = (raw: unknown): unknown => {\n  if (raw && typeof raw === 'object') {\n    if ('$ref' in raw && typeof raw.$ref === 'string') {\n      return (raw as { $ref: string }).$ref\n    }\n    return raw\n  }\n\n  return undefined\n}\n"],"mappings":";AAYA,IAAa,IAA8D,OAAO,kBAAkB,GAmBvF,KAAe,MAA0B;CACpD,IAAI,KAAO,OAAO,KAAQ,UAIxB,OAHI,UAAU,KAAO,OAAO,EAAI,QAAS,WAC/B,EAAyB,OAE5B;AAIX"}

package/dist/schema/helpers/schema-expansion.d.ts

@@ -0,0 +1,89 @@
+import { type InjectionKey, type Ref } from 'vue';
+/**
+ * What a node does when nobody has expressed an opinion about it: its own
+ * `defaultOpen`, or whatever expand-all / collapse-all last set.
+ */
+type ExpansionBaseline = 'default' | 'expanded' | 'collapsed';
+/** What the store cannot work out about a node on its own. */
+type ExpansionContext = {
+    /**
+     * Whether this node sits on a `$ref` cycle. Bulk expansion and the baseline
+     * skip cyclic nodes; without that, `expandAll()` on a self-referential schema
+     * never terminates, because the cycle guard only suppresses auto-expansion.
+     */
+    cyclic?: boolean;
+    /** What the node would do with no store at all (its `defaultOpen`). */
+    defaultOpen?: boolean;
+    /**
+     * The public anchor path this node covers, when it differs from its key. A
+     * key carrying a structural marker (`~headers`) must still open for a deep
+     * link written against the anchor path (`…headers.X-Rate`).
+     */
+    anchorPath?: string;
+};
+/** Shared expansion controls for a host and its schema trees. */
+export type SchemaExpansionStore = {
+    /** Resolve whether a node is open. See the resolution order below. */
+    isExpanded: (key: string, ctx?: ExpansionContext) => boolean;
+    /** Record an explicit user decision about one node. */
+    setExpanded: (key: string, value: boolean) => void;
+    /** Flip one node, resolving its current state first. */
+    toggle: (key: string, ctx?: ExpansionContext) => void;
+    /** Expand everything, or everything beneath `root`. */
+    expandAll: (root?: string) => void;
+    /** Collapse everything, or everything beneath `root`. */
+    collapseAll: (root?: string) => void;
+    /** Make a deep link's expansion permanent by opening every ancestor of `path`. */
+    commitPath: (path: string) => void;
+    /** The standing baseline, exposed so a print hook can flip it and put it back. */
+    baseline: Ref<ExpansionBaseline>;
+    /**
+     * The budget for closed panels kept in the DOM as `hidden="until-found"`. It
+     * lives on the store, so it is shared by every schema tree under one reference.
+     * Kept panels stay searchable with find-in-page but grow the DOM, so a closing
+     * row asks `acquire()` first and simply unmounts past the cap. Deliberately
+     * not reactive: it only matters at the moment a panel closes.
+     */
+    untilFound: {
+        acquire: () => boolean;
+        release: () => void;
+    };
+    /**
+     * Run a bulk transition with slot retention paused. A collapse-all or the
+     * afterprint restore closes many rows in one flush; letting each one
+     * `acquire()` would drain the budget in a single gesture and pin hundreds of
+     * hidden subtrees. Releases still run, so reopened rows hand slots back.
+     */
+    pauseRetentionFor: (mutate: () => void) => void;
+};
+/**
+ * Build the node key for a breadcrumb: the dot-joined anchor path, so store keys
+ * and public anchors are the same string. Callers append `~`-marked structural
+ * segments (`~headers`, `~anonymous-…`) for nodes the anchor cannot name.
+ */
+export declare const toNodeKey: (breadcrumb: readonly string[] | undefined) => string;
+/**
+ * A per-reference store of which schema properties are open. Sparse by
+ * construction: only what somebody touched, typically under twenty keys, where
+ * a dense map over a large document would be tens of thousands. The maps are
+ * `shallowReactive` because a Map inside a `shallowRef` does not track `.set()`
+ * (clicks would do nothing) and replacing the Map wholesale would invalidate
+ * every mounted row on every toggle.
+ */
+export declare const createSchemaExpansionStore: (scrollTargetId?: Ref<string>) => SchemaExpansionStore;
+/**
+ * Marks that an enclosing Schema already owns the tree root. Nesting depth
+ * cannot identify the outermost tree, because a nested Schema may mount at depth
+ * 0 (an `allOf` member, or a caller that omits `depth`), and the root-only
+ * features (sticky ancestor strip, keyboard navigation) must not install twice.
+ */
+export declare const SCHEMA_TREE_ROOT_SYMBOL: InjectionKey<boolean>;
+/**
+ * Create the expansion store for one `<ApiReference>` and wire up deep links.
+ * The scroll target is read only after mount: it comes from a URL fragment the
+ * server never sees, so committing it during SSR would make every ancestor
+ * panel on a deep-linked path a hydration mismatch.
+ */
+export declare const useSchemaExpansion: (scrollTargetId?: Ref<string>) => SchemaExpansionStore;
+export {};
+//# sourceMappingURL=schema-expansion.d.ts.map

package/dist/schema/helpers/schema-expansion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-expansion.d.ts","sourceRoot":"","sources":["../../../src/schema/helpers/schema-expansion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,GAAG,EAOT,MAAM,KAAK,CAAA;AAIZ;;;GAGG;AACH,KAAK,iBAAiB,GAAG,SAAS,GAAG,UAAU,GAAG,WAAW,CAAA;AAE7D,8DAA8D;AAC9D,KAAK,gBAAgB,GAAG;IACtB;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,uEAAuE;IACvE,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,iEAAiE;AACjE,MAAM,MAAM,oBAAoB,GAAG;IACjC,sEAAsE;IACtE,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,gBAAgB,KAAK,OAAO,CAAA;IAC5D,uDAAuD;IACvD,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;IAClD,wDAAwD;IACxD,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,gBAAgB,KAAK,IAAI,CAAA;IACrD,uDAAuD;IACvD,SAAS,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;IAClC,yDAAyD;IACzD,WAAW,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;IACpC,kFAAkF;IAClF,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAClC,kFAAkF;IAClF,QAAQ,EAAE,GAAG,CAAC,iBAAiB,CAAC,CAAA;IAChC;;;;;;OAMG;IACH,UAAU,EAAE;QACV,OAAO,EAAE,MAAM,OAAO,CAAA;QACtB,OAAO,EAAE,MAAM,IAAI,CAAA;KACpB,CAAA;IACD;;;;;OAKG;IACH,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;CAChD,CAAA;AAUD;;;;GAIG;AACH,eAAO,MAAM,SAAS,GAAI,YAAY,SAAS,MAAM,EAAE,GAAG,SAAS,KAAG,MAAqC,CAAA;AAQ3G;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,GAAI,iBAAgB,GAAG,CAAC,MAAM,CAAkB,KAAG,oBA2KzF,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,EAAE,YAAY,CAAC,OAAO,CAA8B,CAAA;AAExF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,iBAAgB,GAAG,CAAC,MAAM,CAAkB,KAAG,oBA2CjF,CAAA"}

package/dist/schema/helpers/schema-expansion.js

@@ -0,0 +1,93 @@
+import { isOnSchemaTargetPath as e } from "./is-on-schema-target-path.js";
+import { nextTick as t, onBeforeUnmount as n, onMounted as r, shallowReactive as i, shallowRef as a, watch as o } from "vue";
+//#region src/schema/helpers/schema-expansion.ts
+var s = (e, t) => t === "" || e === t || e.startsWith(`${t}.`), c = (e) => e?.join(".") ?? "", l = 300, u = (n = a("")) => {
+	let r = i(/* @__PURE__ */ new Map()), o = i(/* @__PURE__ */ new Map()), c = a("default"), u = (e) => {
+		if (o.size === 0) return;
+		let t = e;
+		for (;;) {
+			let e = o.get(t);
+			if (e !== void 0) return e;
+			let n = t.lastIndexOf(".");
+			if (n === -1) return o.get("");
+			t = t.slice(0, n);
+		}
+	}, d = (e) => {
+		for (let t of [...r.keys()]) s(t, e) && r.delete(t);
+	}, f = !1, p = (e) => {
+		f = !0, e(), t(() => {
+			f = !1;
+		});
+	}, m = (e, t) => {
+		if (d(e), e === "") {
+			o.clear(), c.value = t ? "expanded" : "collapsed";
+			return;
+		}
+		for (let t of [...o.keys()]) s(t, e) && o.delete(t);
+		o.set(e, t);
+	}, h = (t, i = {}) => {
+		let a = r.get(t);
+		if (a !== void 0) return a;
+		if (!i.cyclic) {
+			let e = u(t);
+			if (e !== void 0) return e;
+			if (c.value === "expanded") return !0;
+			if (c.value === "collapsed") return !1;
+		}
+		return e(i.anchorPath ?? t, n.value) ? !0 : i.defaultOpen ?? !1;
+	}, g = (e, t) => {
+		r.set(e, t);
+	};
+	return {
+		isExpanded: h,
+		setExpanded: g,
+		toggle: (e, t) => g(e, !h(e, t)),
+		expandAll: (e = "") => m(e, !0),
+		collapseAll: (e = "") => p(() => m(e, !1)),
+		commitPath: (e) => {
+			if (!e) return;
+			let t = e.split(".");
+			for (let e = 1; e <= t.length; e++) {
+				let n = t.slice(0, e).join(".");
+				r.set(n, !0);
+				let i = n.lastIndexOf(".");
+				i !== -1 && r.set(`${n.slice(0, i)}.~${n.slice(i + 1)}`, !0);
+			}
+		},
+		baseline: c,
+		pauseRetentionFor: p,
+		untilFound: (() => {
+			let e = 0;
+			return {
+				acquire: () => f || e >= l ? !1 : (e += 1, !0),
+				release: () => {
+					e = Math.max(0, e - 1);
+				}
+			};
+		})()
+	};
+}, d = Symbol("schema-tree-root"), f = (e = a("")) => {
+	let t = u(e);
+	return r(() => {
+		o(e, (e) => {
+			e && t.commitPath(e);
+		}, { immediate: !0 });
+		let r = null, i = () => {
+			r = t.baseline.value, t.baseline.value = "expanded";
+		}, a = () => {
+			if (r !== null) {
+				let e = r;
+				t.pauseRetentionFor(() => {
+					t.baseline.value = e;
+				}), r = null;
+			}
+		};
+		window.addEventListener("beforeprint", i), window.addEventListener("afterprint", a), n(() => {
+			window.removeEventListener("beforeprint", i), window.removeEventListener("afterprint", a);
+		});
+	}), t;
+};
+//#endregion
+export { d as SCHEMA_TREE_ROOT_SYMBOL, u as createSchemaExpansionStore, c as toNodeKey, f as useSchemaExpansion };
+
+//# sourceMappingURL=schema-expansion.js.map