@kubb/ast 5.0.0-beta.31 → 5.0.0-beta.33

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+import { $t as ScalarSchemaType, At as FunctionParameterNode, Bt as DateSchemaNode, C as PrinterFactoryOptions, Ct as HttpStatusCode, D as DistributiveOmit, Dt as ParameterNode, Et as ParameterLocation, Ft as FileNode, Gt as IntersectionSchemaNode, Ht as EnumSchemaNode, It as ImportNode, Jt as NumberSchemaNode, Kt as Ipv4SchemaNode, Lt as SourceNode, Mt as ParameterGroupNode, Nt as ParamsTypeNode, O as UserFileNode, Ot as FunctionNodeType, Pt as ExportNode, Qt as ScalarSchemaNode, Rt as ArraySchemaNode, S as Printer, Sn as VisitorDepth, St as ResponseNode, Tt as StatusCode, Ut as EnumValueNode, Vt as DatetimeSchemaNode, Wt as FormatStringSchemaNode, Xt as PrimitiveSchemaType, Yt as ObjectSchemaNode, Zt as RefSchemaNode, _ as VisitorContext, _n as TypeDeclarationNode, _t as HttpMethod, an as TimeSchemaNode, bn as NodeKind, bt as OperationNodeBase, cn as PropertyNode, ct as DedupePlan, d as AsyncVisitor, dn as CodeNode, dt as Node, en as SchemaNode, et as InferSchemaNode, f as CollectOptions, fn as ConstNode, ft as InputMeta, g as Visitor, gn as TextNode, gt as GenericOperationNode, h as TransformOptions, hn as JsxNode, ht as OutputNode, in as StringSchemaNode, it as SchemaDialect, jt as FunctionParametersNode, kt as FunctionParamNode, ln as ArrowFunctionNode, m as ParentOf, mn as JSDocNode, mt as InputStreamNode, nn as SchemaType, nt as DispatchRule, on as UnionSchemaNode, ot as BuildDedupePlanOptions, p as CollectVisitor, pn as FunctionNode, pt as InputNode, qt as Ipv6SchemaNode, rn as SpecialSchemaType, sn as UrlSchemaNode, st as DedupeCanonical, t as OperationParamsResolver, tn as SchemaNodeByType, tt as ParserOptions, un as BreakNode, v as WalkOptions, vn as TypeNode, vt as HttpOperationNode, w as PrinterPartial, wt as MediaType, xn as ScalarPrimitive, xt as OperationProtocol, yn as BaseNode, yt as OperationNode, zt as ComplexSchemaType } from "./types-CE8VJ5_y.js";
+export type { ArraySchemaNode, ArrowFunctionNode, AsyncVisitor, BaseNode, BreakNode, BuildDedupePlanOptions, CodeNode, CollectOptions, CollectVisitor, ComplexSchemaType, ConstNode, DateSchemaNode, DatetimeSchemaNode, DedupeCanonical, DedupePlan, DispatchRule, DistributiveOmit, EnumSchemaNode, EnumValueNode, ExportNode, FileNode, FormatStringSchemaNode, FunctionNode, FunctionNodeType, FunctionParamNode, FunctionParameterNode, FunctionParametersNode, GenericOperationNode, HttpMethod, HttpOperationNode, HttpStatusCode, ImportNode, InferSchemaNode, InputMeta, InputNode, InputStreamNode, IntersectionSchemaNode, Ipv4SchemaNode, Ipv6SchemaNode, JSDocNode, JsxNode, MediaType, Node, NodeKind, NumberSchemaNode, ObjectSchemaNode, OperationNode, OperationNodeBase, OperationParamsResolver, OperationProtocol, OutputNode, ParameterGroupNode, ParameterLocation, ParameterNode, ParamsTypeNode, ParentOf, ParserOptions, PrimitiveSchemaType, Printer, PrinterFactoryOptions, PrinterPartial, PropertyNode, RefSchemaNode, ResponseNode, ScalarPrimitive, ScalarSchemaNode, ScalarSchemaType, SchemaDialect, SchemaNode, SchemaNodeByType, SchemaType, SourceNode, SpecialSchemaType, StatusCode, StringSchemaNode, TextNode, TimeSchemaNode, TransformOptions, TypeDeclarationNode, TypeNode, UnionSchemaNode, UrlSchemaNode, UserFileNode, Visitor, VisitorContext, VisitorDepth, WalkOptions };

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/ast",
-  "version": "5.0.0-beta.31",
+  "version": "5.0.0-beta.33",
   "description": "Spec-agnostic AST layer for Kubb. Defines the node tree, visitor pattern, factory functions, and type guards used across all code generation plugins.",
   "keywords": [
     "ast",
@@ -32,6 +32,10 @@
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     },
+    "./types": {
+      "import": "./dist/types.js",
+      "require": "./dist/types.cjs"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {

package/src/constants.ts

@@ -1,5 +1,3 @@
-import type { NodeKind } from './nodes/base.ts'
-import type { MediaType } from './nodes/http.ts'
 import type { HttpMethod } from './nodes/operation.ts'
 import type { SchemaType } from './nodes/schema.ts'
 
@@ -16,26 +14,6 @@ export const visitorDepths = {
   deep: 'deep',
 } as const satisfies Record<VisitorDepth, VisitorDepth>
 
-export const nodeKinds = {
-  input: 'Input',
-  output: 'Output',
-  operation: 'Operation',
-  schema: 'Schema',
-  property: 'Property',
-  parameter: 'Parameter',
-  response: 'Response',
-  functionParameter: 'FunctionParameter',
-  parameterGroup: 'ParameterGroup',
-  functionParameters: 'FunctionParameters',
-  type: 'Type',
-  file: 'File',
-  import: 'Import',
-  export: 'Export',
-  source: 'Source',
-  text: 'Text',
-  break: 'Break',
-} as const satisfies Record<string, NodeKind>
-
 /**
  * Schema type discriminators used by all AST schema nodes.
  *
@@ -198,31 +176,3 @@ export const httpMethods = {
  * ```
  */
 export const WALK_CONCURRENCY = 30
-
-/**
- * Common MIME types used in request/response content negotiation.
- *
- * Covers JSON, XML, form data, PDFs, images, audio, and video formats.
- * Use these as keys when serializing request/response bodies.
- */
-export const mediaTypes = {
-  applicationJson: 'application/json',
-  applicationXml: 'application/xml',
-  applicationFormUrlEncoded: 'application/x-www-form-urlencoded',
-  applicationOctetStream: 'application/octet-stream',
-  applicationPdf: 'application/pdf',
-  applicationZip: 'application/zip',
-  applicationGraphql: 'application/graphql',
-  multipartFormData: 'multipart/form-data',
-  textPlain: 'text/plain',
-  textHtml: 'text/html',
-  textCsv: 'text/csv',
-  textXml: 'text/xml',
-  imagePng: 'image/png',
-  imageJpeg: 'image/jpeg',
-  imageGif: 'image/gif',
-  imageWebp: 'image/webp',
-  imageSvgXml: 'image/svg+xml',
-  audioMpeg: 'audio/mpeg',
-  videoMp4: 'video/mp4',
-} as const satisfies Record<string, MediaType>

package/src/dedupe.ts

@@ -101,12 +101,11 @@ export function applyDedupe(node: OperationNode, canonicalBySignature: ReadonlyM
 export function applyDedupe(node: Node, canonicalBySignature: ReadonlyMap<string, DedupeCanonical>, skipRootMatch = false): Node {
   if (canonicalBySignature.size === 0) return node
 
-  const signatures = new Map<SchemaNode, string>()
   const root = node
 
   return transform(node, {
     schema(schemaNode) {
-      const signature = signatureOf(schemaNode, signatures)
+      const signature = signatureOf(schemaNode)
       if (skipRootMatch && schemaNode === root) return undefined
 
       const canonical = canonicalBySignature.get(signature)
@@ -145,7 +144,6 @@ function cleanDefinition(node: SchemaNode, name: string): SchemaNode {
 export function buildDedupePlan(roots: ReadonlyArray<Node>, options: BuildDedupePlanOptions): DedupePlan {
   const { isCandidate, nameFor, refFor, minOccurrences = 2 } = options
 
-  const signatures = new Map<SchemaNode, string>()
   const topLevelNodes = new Set<SchemaNode>()
 
   type Group = {
@@ -156,7 +154,7 @@ export function buildDedupePlan(roots: ReadonlyArray<Node>, options: BuildDedupe
   const groups = new Map<string, Group>()
 
   function record(schemaNode: SchemaNode): void {
-    const signature = signatureOf(schemaNode, signatures)
+    const signature = signatureOf(schemaNode)
     if (!isCandidate(schemaNode)) return
 
     const isTopLevel = topLevelNodes.has(schemaNode) && !!schemaNode.name

package/src/guards.ts

@@ -1,19 +1,4 @@
-import type {
-  FunctionParameterNode,
-  FunctionParametersNode,
-  HttpOperationNode,
-  InputNode,
-  Node,
-  NodeKind,
-  OperationNode,
-  OutputNode,
-  ParameterGroupNode,
-  ParameterNode,
-  PropertyNode,
-  ResponseNode,
-  SchemaNode,
-  SchemaNodeByType,
-} from './nodes/index.ts'
+import type { HttpOperationNode, InputNode, Node, NodeKind, OperationNode, OutputNode, SchemaNode, SchemaNodeByType } from './nodes/index.ts'
 
 /**
  * Narrows a `SchemaNode` to the variant that matches `type`.
@@ -93,33 +78,3 @@ export function isHttpOperationNode(node: OperationNode): node is HttpOperationN
  * ```
  */
 export const isSchemaNode = isKind<SchemaNode>('Schema')
-
-/**
- * Returns `true` when the input is a `PropertyNode`.
- */
-export const isPropertyNode = isKind<PropertyNode>('Property')
-
-/**
- * Returns `true` when the input is a `ParameterNode`.
- */
-export const isParameterNode = isKind<ParameterNode>('Parameter')
-
-/**
- * Returns `true` when the input is a `ResponseNode`.
- */
-export const isResponseNode = isKind<ResponseNode>('Response')
-
-/**
- * Returns `true` when the input is a `FunctionParameterNode`.
- */
-export const isFunctionParameterNode = isKind<FunctionParameterNode>('FunctionParameter')
-
-/**
- * Returns `true` when the input is a `ParameterGroupNode`.
- */
-export const isParameterGroupNode = isKind<ParameterGroupNode>('ParameterGroup')
-
-/**
- * Returns `true` when the input is a `FunctionParametersNode`.
- */
-export const isFunctionParametersNode = isKind<FunctionParametersNode>('FunctionParameters')

package/src/index.ts

@@ -1,4 +1,4 @@
-export { httpMethods, isScalarPrimitive, mediaTypes, nodeKinds, schemaTypes } from './constants.ts'
+export { httpMethods, schemaTypes } from './constants.ts'
 export { applyDedupe, buildDedupePlan } from './dedupe.ts'
 export { defineSchemaDialect } from './dialect.ts'
 export { dispatch } from './dispatch.ts'
@@ -6,7 +6,6 @@ export {
   createArrowFunction,
   createBreak,
   createConst,
-  createContent,
   createExport,
   createFile,
   createFunction,
@@ -22,7 +21,6 @@ export {
   createParameterGroup,
   createParamsType,
   createProperty,
-  createRequestBody,
   createResponse,
   createSchema,
   createSource,
@@ -31,16 +29,15 @@ export {
   syncOptionality,
   update,
 } from './factory.ts'
-export { isHttpOperationNode, isInputNode, isOperationNode, isOutputNode, isSchemaNode, narrowSchema } from './guards.ts'
+export { isHttpOperationNode, isOperationNode, isSchemaNode, narrowSchema } from './guards.ts'
 export { createPrinterFactory, definePrinter } from './printer.ts'
 export { extractRefName } from './refs.ts'
 export { childName, collectImports, enumPropName, findDiscriminator } from './resolvers.ts'
-export { isSchemaEqual, schemaSignature } from './signature.ts'
-export { mergeAdjacentObjects, mergeAdjacentObjectsLazy, setDiscriminatorEnum, setEnumName, simplifyUnion } from './transformers.ts'
+export { schemaSignature } from './signature.ts'
+export { mergeAdjacentObjectsLazy, setDiscriminatorEnum, setEnumName, simplifyUnion } from './transformers.ts'
 export type * from './types.ts'
 export {
   caseParams,
-  collectReferencedSchemaNames,
   collectUsedSchemaNames,
   containsCircularRef,
   createDiscriminantNode,
@@ -48,7 +45,6 @@ export {
   extractStringsFromNodes,
   findCircularSchemas,
   isStringType,
-  resolveRefName,
   syncSchemaRef,
 } from './utils.ts'
-export { collect, collectLazy, transform, walk } from './visitor.ts'
+export { collect, transform, walk } from './visitor.ts'

package/src/infer.ts

@@ -130,12 +130,3 @@ export type InferSchemaNode<
     ? TEntry[1]
     : InferSchemaNode<TSchema, TDateType, TRest>
   : SchemaNode
-
-/**
- * Backward-compatible alias for `InferSchemaNode`.
- */
-export type InferSchema<
-  TSchema extends object,
-  TDateType extends ParserOptions['dateType'] = 'string',
-  TEntries extends ReadonlyArray<[object, SchemaNode]> = SchemaNodeMap<TDateType>,
-> = InferSchemaNode<TSchema, TDateType, TEntries>

package/src/refs.ts

@@ -1,11 +1,3 @@
-import type { InputNode } from './nodes/root.ts'
-import type { SchemaNode } from './nodes/schema.ts'
-
-/**
- * Lookup map from schema name to `SchemaNode`.
- */
-export type RefMap = Map<string, SchemaNode>
-
 /**
  * Returns the last path segment of a reference string.
  *
@@ -19,51 +11,3 @@ export type RefMap = Map<string, SchemaNode>
 export function extractRefName(ref: string): string {
   return ref.split('/').at(-1) ?? ref
 }
-
-/**
- * Builds a `RefMap` from `input.schemas` using each schema's `name`.
- *
- * Unnamed schemas are skipped.
- *
- * @example
- * ```ts
- * const refMap = buildRefMap(input)
- * const pet = refMap.get('Pet')
- * ```
- */
-export function buildRefMap(input: InputNode): RefMap {
-  const map: RefMap = new Map()
-
-  for (const schema of input.schemas) {
-    if (schema.name) {
-      map.set(schema.name, schema)
-    }
-  }
-  return map
-}
-
-/**
- * Resolves a schema by name from a `RefMap`.
- *
- * Returns `null` when the ref is not found.
- *
- * @example
- * ```ts
- * const petSchema = resolveRef(refMap, 'Pet')
- * ```
- */
-export function resolveRef(refMap: RefMap, ref: string): SchemaNode | null {
-  return refMap.get(ref) ?? null
-}
-
-/**
- * Converts a `RefMap` into a plain object.
- *
- * @example
- * ```ts
- * const refsObject = refMapToObject(refMap)
- * ```
- */
-export function refMapToObject(refMap: RefMap): Record<string, SchemaNode> {
-  return Object.fromEntries(refMap)
-}

package/src/signature.ts

@@ -16,90 +16,187 @@ function refTargetName(node: Extract<SchemaNode, { type: 'ref' }>): string {
   return node.name ?? ''
 }
 
+type ScalarField = { kind: 'scalar'; key: string; prefix: string }
+type BoolField = { kind: 'bool'; key: string; prefix: string }
+type ChildField = { kind: 'child'; key: string; prefix: string }
+type ChildrenField = { kind: 'children'; key: string; prefix: string }
+type ObjectPropsField = { kind: 'objectProps' }
+type AdditionalPropsField = { kind: 'additionalProps' }
+type PatternPropsField = { kind: 'patternProps' }
+type EnumValuesField = { kind: 'enumValues' }
+type RefTargetField = { kind: 'refTarget' }
+
+type ShapeField =
+  | ScalarField
+  | BoolField
+  | ChildField
+  | ChildrenField
+  | ObjectPropsField
+  | AdditionalPropsField
+  | PatternPropsField
+  | EnumValuesField
+  | RefTargetField
+
+const arrayTupleFields: ReadonlyArray<ShapeField> = [
+  { kind: 'children', key: 'items', prefix: 'i' },
+  { kind: 'child', key: 'rest', prefix: 'r' },
+  { kind: 'scalar', key: 'min', prefix: 'mn' },
+  { kind: 'scalar', key: 'max', prefix: 'mx' },
+  { kind: 'bool', key: 'unique', prefix: 'u' },
+]
+
+const numericFields: ReadonlyArray<ShapeField> = [
+  { kind: 'scalar', key: 'min', prefix: 'mn' },
+  { kind: 'scalar', key: 'max', prefix: 'mx' },
+  { kind: 'scalar', key: 'exclusiveMinimum', prefix: 'emn' },
+  { kind: 'scalar', key: 'exclusiveMaximum', prefix: 'emx' },
+  { kind: 'scalar', key: 'multipleOf', prefix: 'mo' },
+]
+
+const rangeFields: ReadonlyArray<ShapeField> = [
+  { kind: 'scalar', key: 'min', prefix: 'mn' },
+  { kind: 'scalar', key: 'max', prefix: 'mx' },
+]
+
 /**
- * Builds the local, shape-only descriptor for a node: its kind, flags, constraints, and its
- * children's signatures. {@link signatureOf} hashes this string; children contribute their
- * fixed-length signature rather than their own full descriptor, which keeps the result bounded.
+ * Maps each schema node `type` to the ordered list of shape-contributing fields.
+ * Node types absent from this map (scalar types like boolean, null, any, etc.) fall
+ * back to `${type}|${flags}` with no additional fields.
  */
-function describeShape(node: SchemaNode, signatures: Map<SchemaNode, string>): string {
-  const flags = flagsDescriptor(node)
+const SHAPE_KEYS: Partial<Record<SchemaNode['type'], ReadonlyArray<ShapeField>>> = {
+  object: [
+    { kind: 'objectProps' },
+    { kind: 'additionalProps' },
+    { kind: 'patternProps' },
+    { kind: 'scalar', key: 'minProperties', prefix: 'mn' },
+    { kind: 'scalar', key: 'maxProperties', prefix: 'mx' },
+  ],
+  array: arrayTupleFields,
+  tuple: arrayTupleFields,
+  union: [
+    { kind: 'scalar', key: 'strategy', prefix: 's' },
+    { kind: 'scalar', key: 'discriminatorPropertyName', prefix: 'd' },
+    { kind: 'children', key: 'members', prefix: 'm' },
+  ],
+  intersection: [{ kind: 'children', key: 'members', prefix: 'm' }],
+  enum: [{ kind: 'enumValues' }],
+  ref: [{ kind: 'refTarget' }],
+  string: [
+    { kind: 'scalar', key: 'min', prefix: 'mn' },
+    { kind: 'scalar', key: 'max', prefix: 'mx' },
+    { kind: 'scalar', key: 'pattern', prefix: 'pt' },
+  ],
+  number: numericFields,
+  integer: numericFields,
+  bigint: numericFields,
+  url: [
+    { kind: 'scalar', key: 'path', prefix: 'path' },
+    { kind: 'scalar', key: 'min', prefix: 'mn' },
+    { kind: 'scalar', key: 'max', prefix: 'mx' },
+  ],
+  uuid: rangeFields,
+  email: rangeFields,
+  datetime: [
+    { kind: 'bool', key: 'offset', prefix: 'o' },
+    { kind: 'bool', key: 'local', prefix: 'l' },
+  ],
+  date: [{ kind: 'scalar', key: 'representation', prefix: 'rep' }],
+  time: [{ kind: 'scalar', key: 'representation', prefix: 'rep' }],
+}
 
-  switch (node.type) {
-    case 'object': {
-      const props = (node.properties ?? []).map((prop) => `${prop.name}${prop.required ? '!' : '?'}${signatureOf(prop.schema, signatures)}`).join(',')
-      let additional = ''
-      if (typeof node.additionalProperties === 'boolean') {
-        additional = `ab:${node.additionalProperties}`
-      } else if (node.additionalProperties) {
-        additional = `as:${signatureOf(node.additionalProperties, signatures)}`
-      }
-      const pattern = node.patternProperties
-        ? Object.keys(node.patternProperties)
-            .sort()
-            .map((key) => `${key}=${signatureOf(node.patternProperties![key]!, signatures)}`)
-            .join(',')
-        : ''
-      return `object|${flags}|p[${props}]|${additional}|pp[${pattern}]|mn:${node.minProperties ?? ''}|mx:${node.maxProperties ?? ''}`
+function serializeShapeField(field: ShapeField, node: SchemaNode, record: Record<string, unknown>): string {
+  switch (field.kind) {
+    case 'scalar':
+      return `${field.prefix}:${record[field.key] ?? ''}`
+    case 'bool':
+      return `${field.prefix}:${record[field.key] ? 1 : 0}`
+    case 'child': {
+      const child = record[field.key] as SchemaNode | undefined
+      return `${field.prefix}:${child ? signatureOf(child) : ''}`
     }
-    case 'array':
-    case 'tuple': {
-      const items = (node.items ?? []).map((item) => signatureOf(item, signatures)).join(',')
-      const rest = node.rest ? signatureOf(node.rest, signatures) : ''
-      return `${node.type}|${flags}|i[${items}]|r:${rest}|mn:${node.min ?? ''}|mx:${node.max ?? ''}|u:${node.unique ? 1 : 0}`
+    case 'children': {
+      const children = (record[field.key] as Array<SchemaNode> | undefined) ?? []
+      return `${field.prefix}[${children.map((c) => signatureOf(c)).join(',')}]`
     }
-    case 'union': {
-      const members = (node.members ?? []).map((member) => signatureOf(member, signatures)).join(',')
-      return `union|${flags}|s:${node.strategy ?? ''}|d:${node.discriminatorPropertyName ?? ''}|m[${members}]`
+    case 'objectProps': {
+      const obj = node as Extract<SchemaNode, { type: 'object' }>
+      const props = (obj.properties ?? []).map((prop) => `${prop.name}${prop.required ? '!' : '?'}${signatureOf(prop.schema)}`).join(',')
+      return `p[${props}]`
     }
-    case 'intersection': {
-      const members = (node.members ?? []).map((member) => signatureOf(member, signatures)).join(',')
-      return `intersection|${flags}|m[${members}]`
+    case 'additionalProps': {
+      const obj = node as Extract<SchemaNode, { type: 'object' }>
+      if (typeof obj.additionalProperties === 'boolean') return `ab:${obj.additionalProperties}`
+      if (obj.additionalProperties) return `as:${signatureOf(obj.additionalProperties)}`
+      return ''
     }
-    case 'enum': {
+    case 'patternProps': {
+      const obj = node as Extract<SchemaNode, { type: 'object' }>
+      const pattern = obj.patternProperties
+        ? Object.keys(obj.patternProperties)
+            .sort()
+            .map((key) => `${key}=${signatureOf(obj.patternProperties![key]!)}`)
+            .join(',')
+        : ''
+      return `pp[${pattern}]`
+    }
+    case 'enumValues': {
+      const en = node as Extract<SchemaNode, { type: 'enum' }>
       let values = ''
-      if (node.namedEnumValues?.length) {
-        values = node.namedEnumValues.map((entry) => `${entry.name}=${entry.primitive}:${String(entry.value)}`).join(',')
-      } else if (node.enumValues?.length) {
-        values = node.enumValues.map((value) => `${value === null ? 'null' : typeof value}:${String(value)}`).join(',')
+      if (en.namedEnumValues?.length) {
+        values = en.namedEnumValues.map((entry) => `${entry.name}=${entry.primitive}:${String(entry.value)}`).join(',')
+      } else if (en.enumValues?.length) {
+        values = en.enumValues.map((value) => `${value === null ? 'null' : typeof value}:${String(value)}`).join(',')
       }
-      return `enum|${flags}|v[${values}]`
+      return `v[${values}]`
+    }
+    case 'refTarget': {
+      return `->${refTargetName(node as Extract<SchemaNode, { type: 'ref' }>)}`
     }
-    case 'ref':
-      return `ref|${flags}|->${refTargetName(node)}`
-    case 'string':
-      return `string|${flags}|mn:${node.min ?? ''}|mx:${node.max ?? ''}|pt:${node.pattern ?? ''}`
-    case 'number':
-    case 'integer':
-    case 'bigint':
-      return `${node.type}|${flags}|mn:${node.min ?? ''}|mx:${node.max ?? ''}|emn:${node.exclusiveMinimum ?? ''}|emx:${node.exclusiveMaximum ?? ''}|mo:${node.multipleOf ?? ''}`
-    case 'url':
-      return `url|${flags}|path:${node.path ?? ''}|mn:${node.min ?? ''}|mx:${node.max ?? ''}`
-    case 'uuid':
-    case 'email':
-      return `${node.type}|${flags}|mn:${node.min ?? ''}|mx:${node.max ?? ''}`
-    case 'datetime':
-      return `datetime|${flags}|o:${node.offset ? 1 : 0}|l:${node.local ? 1 : 0}`
-    case 'date':
-    case 'time':
-      return `${node.type}|${flags}|rep:${node.representation}`
-    default:
-      return `${node.type}|${flags}`
   }
 }
 
+/**
+ * Builds the local, shape-only descriptor for a node: its kind, flags, constraints, and its
+ * children's signatures. {@link signatureOf} hashes this string; children contribute their
+ * fixed-length signature rather than their own full descriptor, which keeps the result bounded.
+ */
+function describeShape(node: SchemaNode): string {
+  const flags = flagsDescriptor(node)
+  const fields = SHAPE_KEYS[node.type]
+  if (!fields) return `${node.type}|${flags}`
+
+  const record = node as unknown as Record<string, unknown>
+  const parts: Array<string> = [`${node.type}|${flags}`]
+  for (const field of fields) {
+    parts.push(serializeShapeField(field, node, record))
+  }
+  return parts.join('|')
+}
+
+/**
+ * Persistent hash-consing cache: `SchemaNode` → signature digest, keyed by node identity.
+ *
+ * A `WeakMap` so entries are released once the node is garbage-collected, and so a node hashed
+ * during dedupe planning is not re-hashed when the same tree is rewritten during streaming
+ * (where `schemaSignature` and `applyDedupe` would otherwise each walk it from scratch). Reuse
+ * across calls is sound because a signature depends only on a node's content, and schema nodes
+ * are immutable once created — transforms allocate new objects rather than mutating in place.
+ */
+const signatureCache = new WeakMap<SchemaNode, string>()
+
 /**
  * Hash-consing: each node's signature is a fixed-length digest of its local shape plus its
  * children's digests (a Merkle hash). Children contribute their 64-char hash instead of their
  * full nested descriptor, so a signature stays bounded regardless of subtree depth, and the
  * digest is identical across calls because it depends only on content — never on traversal
  * order. This keeps the keys built during planning consistent with the ones recomputed later
- * during streaming. `signatures` memoizes node → digest within a single computation.
+ * during streaming. {@link signatureCache} memoizes node → digest across every computation.
  */
-export function signatureOf(node: SchemaNode, signatures: Map<SchemaNode, string>): string {
-  const cached = signatures.get(node)
+export function signatureOf(node: SchemaNode): string {
+  const cached = signatureCache.get(node)
   if (cached !== undefined) return cached
-  const signature = createHash('sha256').update(describeShape(node, signatures)).digest('hex')
-  signatures.set(node, signature)
+  const signature = createHash('sha256').update(describeShape(node)).digest('hex')
+  signatureCache.set(node, signature)
   return signature
 }
 
@@ -119,7 +216,7 @@ export function signatureOf(node: SchemaNode, signatures: Map<SchemaNode, string
  * ```
  */
 export function schemaSignature(node: SchemaNode): string {
-  return signatureOf(node, new Map())
+  return signatureOf(node)
 }
 
 /**

package/src/types.ts

@@ -3,7 +3,7 @@ export type { BuildDedupePlanOptions, DedupeCanonical, DedupePlan } from './dedu
 export type { SchemaDialect } from './dialect.ts'
 export type { DispatchRule } from './dispatch.ts'
 export type { DistributiveOmit } from './factory.ts'
-export type { InferSchema, InferSchemaNode, ParserOptions } from './infer.ts'
+export type { InferSchemaNode, ParserOptions } from './infer.ts'
 export type {
   ArraySchemaNode,
   ArrowFunctionNode,
@@ -70,7 +70,6 @@ export type {
   UnionSchemaNode,
   UrlSchemaNode,
 } from './nodes/index.ts'
-export type { RefMap } from './refs.ts'
 export type { AsyncVisitor, CollectOptions, CollectVisitor, ParentOf, TransformOptions, Visitor, VisitorContext, WalkOptions } from './visitor.ts'
 export type { Printer, PrinterFactoryOptions, PrinterPartial } from './printer.ts'
 export type { ScalarPrimitive } from './constants.ts'

package/src/visitor.ts

@@ -401,10 +401,14 @@ export async function walk(node: Node, options: WalkOptions): Promise<void> {
 async function _walk(node: Node, visitor: AsyncVisitor, recurse: boolean, limit: LimitFn, parent: Node | undefined): Promise<void> {
   await limit(() => applyVisitor(node, visitor, parent))
 
-  const children = getChildren(node, recurse)
-  for (const child of children) {
-    await _walk(child, visitor, recurse, limit, node)
-  }
+  // Visit siblings concurrently and let the shared `limit` cap how many callbacks
+  // run at once. Awaiting each child sequentially here would serialize the whole
+  // traversal and make `concurrency` inert — every visitor callback would run one
+  // at a time regardless of the limit.
+  const children = Array.from(getChildren(node, recurse))
+  if (children.length === 0) return
+
+  await Promise.all(children.map((child) => _walk(child, visitor, recurse, limit, node)))
 }
 
 /**