attaform 0.20.2 → 0.21.1

package/dist/shared/attaform.Be8NZG9M.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"attaform.Be8NZG9M.mjs","sources":["../../src/runtime/core/abstract-schema-factory.ts","../../src/runtime/core/merge-deep.ts","../../src/runtime/core/walk-path-segments.ts","../../src/runtime/core/walk-derive-default.ts","../../src/runtime/core/field-meta-store.ts","../../src/runtime/core/walk-slim-primitives.ts","../../src/runtime/core/walk-field-meta.ts"],"sourcesContent":["/**\n * `createAbstractSchema` — the schema-agnostic factory that hosts every\n * `AbstractSchema` method whose implementation is identical-modulo-\n * introspector between the v3 and v4 adapters.\n *\n * Each adapter wires through two small contracts:\n *\n *   - `SchemaIntrospector<Schema>` — pure, side-effect-free accessors\n *     that read schema shape. The factory branches on `kindOf`, walks\n *     discriminated-union literals via `getLiteralValues` /\n *     `getDiscriminatedOptions`, detects coerce / preprocess nodes,\n *     and consults the three async / container-refine flags.\n *\n *   - `AbstractSchemaServices<Schema, Form, GetValueFormType>` — the\n *     adapter-specific delegates the factory calls for everything that\n *     genuinely diverges per Zod version: fingerprinting, path-walking\n *     (the path walker itself has v3 / v4 quirks), default-value\n *     derivation, the strict-mode `getDefaultValues` flow,\n *     wrapper-peeling that's tied to the per-version wrapper set,\n *     field-meta resolution, and the per-version `safeParse`\n *     boundary.\n *\n * The two-interface split keeps the introspector reusable by any other\n * walker (fingerprint, slim-primitives, default-values) without dragging\n * in the side-effectful services. Services consume the introspector as\n * they wish; the factory consumes both.\n *\n * Behavior-neutral by design: the goal is one set of definitions for\n * the 13 structurally-parallel methods, with no observable change at\n * either adapter's `AbstractSchema` surface. Per-adapter caches keep\n * the same lifetime (one per `useForm()` call); `getSchemasAtPath`\n * preserves each adapter's prior sub-schema shape via the\n * `makeSubSchema` service (v3 recurses; v4 builds the 5-method stub).\n */\nimport type {\n  AbstractSchema,\n  DefaultValuesResponse,\n  FormKey,\n  GetDefaultValuesConfig,\n  ResolvedFieldMeta,\n  SlimPrimitiveKind,\n  UnionDiscriminatorContext,\n  ValidationError,\n  ValidationResponse,\n  ValidateOptions,\n} from '../types/types-api'\nimport type { SchemaFactoryOptions } from './get-computed-schema'\nimport { AttaformErrorCode } from './error-codes'\nimport { canonicalizePath, type Path, type PathKey } from './paths'\n\nconst PATH_SEPARATOR = '.'\n\n/**\n * Stable shape-discriminant the factory branches on. Adapters return\n * the union of v3 + v4 kinds plus `'unknown'` for anything they don't\n * recognise — the factory only inspects a small subset\n * (`'tuple'` / `'array'` for `arrayShapeAtPath`,\n * `'literal'` for the discriminated-union walk), so adapters can return\n * extra version-specific kinds (`'effects'` / `'pipeline'` / `'branded'`\n * / `'native-enum'` on v3) without confusing the factory.\n */\nexport type SharedZodKind =\n  | 'string'\n  | 'number'\n  | 'boolean'\n  | 'bigint'\n  | 'date'\n  | 'null'\n  | 'undefined'\n  | 'literal'\n  | 'enum'\n  | 'native-enum'\n  | 'object'\n  | 'array'\n  | 'tuple'\n  | 'set'\n  | 'record'\n  | 'map'\n  | 'union'\n  | 'discriminated-union'\n  | 'intersection'\n  | 'optional'\n  | 'nullable'\n  | 'default'\n  | 'catch'\n  | 'readonly'\n  | 'branded'\n  | 'effects'\n  | 'pipeline'\n  | 'lazy'\n  | 'pipe'\n  | 'transform'\n  | 'preprocess'\n  | 'any'\n  | 'unknown'\n  | 'never'\n  | 'nan'\n  | 'void'\n  | 'file'\n  | 'function'\n  | 'symbol'\n  | 'promise'\n  | 'custom'\n  | 'template-literal'\n\n/**\n * Pure schema-shape accessors. The factory consults these to branch on\n * structural facts about a schema node. Every member is side-effect-\n * free and idempotent.\n *\n * `kindOf` returns the discriminant; the structural accessors\n * (`getObjectShape`, `getTupleItems`, `getDiscriminatedOptions`,\n * `getLiteralValues`) read a single field of the node's def shape.\n * The three boolean predicates summarise tree-walking detections each\n * adapter already exposes; both adapters memoise them at the\n * AbstractSchema level so calling per construction is cheap.\n */\nexport interface SchemaIntrospector<Schema> {\n  /** Discriminant on schema shape. Adapters may return extra kinds. */\n  kindOf(schema: Schema): SharedZodKind | string\n  /**\n   * Returns the property-to-sub-schema map of a `ZodObject`. Empty\n   * record for non-objects.\n   */\n  getObjectShape(schema: Schema): Record<string, Schema>\n  /** Returns the position-typed items of a `ZodTuple`. Empty for non-tuples. */\n  getTupleItems(schema: Schema): readonly Schema[]\n  /**\n   * Returns the option objects of a `ZodDiscriminatedUnion` — each one\n   * is itself a `ZodObject` whose `getObjectShape` includes the\n   * discriminator key as a `ZodLiteral`.\n   */\n  getDiscriminatedOptions(schema: Schema): readonly Schema[]\n  /** Returns the discriminator key of a `ZodDiscriminatedUnion`. */\n  getDiscriminator(schema: Schema): string | undefined\n  /**\n   * Returns the literal values a `ZodLiteral` admits. Multi-value\n   * literals (`z.literal(['a', 'b'])`) return both; single-value return\n   * the one. Empty for non-literals.\n   */\n  getLiteralValues(schema: Schema): readonly unknown[]\n  /**\n   * True iff the node is a preprocess-style schema-side normalizer:\n   * `z.preprocess(fn, inner)` in either version. v3's `ZodEffects`\n   * with `effect.type === 'preprocess'` and v4's `ZodPipe<ZodTransform,\n   * inner>` both collapse here. Coerce primitives go through\n   * `isCoercePrimitive` instead — they're not pipes in v4 and not\n   * effects in v3, but both adapters detect them off the same flag.\n   */\n  isPreprocessNode(schema: Schema): boolean\n  /**\n   * True iff the schema is a `z.coerce.X()` primitive. Both adapter\n   * versions store the coerce intent as a flag on the wrapped\n   * primitive's def (not as a wrapper), so detection is uniform.\n   */\n  isCoercePrimitive(schema: Schema): boolean\n  /**\n   * True iff the schema tree contains a refine whose predicate can run\n   * asynchronously. v3 is conservative (every `.refine` flagged because\n   * the inner sync wrapper hides the user fn); v4 is exact (inspects\n   * `def.checks[].def.fn.constructor.name`). Either way the runtime\n   * uses this to decide whether a construction-time async pass is\n   * needed.\n   */\n  containsAsyncRefine(schema: Schema): boolean\n  /**\n   * True iff the schema tree contains a `.transform(asyncFn)` /\n   * `z.preprocess(asyncFn, …)`. Statically detectable in both adapters\n   * via the user fn's `constructor.name === 'AsyncFunction'`. Disjoint\n   * from `containsAsyncRefine` — refines and transforms live in\n   * different slots.\n   */\n  containsAsyncTransform(schema: Schema): boolean\n  /**\n   * True iff any refine fires at a container node (object / array /\n   * tuple / union / discriminated-union / intersection / record / set)\n   * or the root. False means every refine is leaf-local, so per-keystroke\n   * subtree validation catches the same verdicts as a whole-form pass.\n   */\n  hasContainerOrRootRefine(schema: Schema): boolean\n\n  // ---------------------------------------------------------------------\n  // Walker accessors — consumed by the shared `core/walk-*` walkers (D2 /\n  // D3 / D5) so the path-walking / slim-primitive / default-derivation\n  // shapes don't fork per adapter. v3 / v4 each expose the full surface;\n  // members not applicable to one adapter return `undefined` (kept on the\n  // contract so the walkers don't branch on adapter identity).\n  // ---------------------------------------------------------------------\n\n  /** Element schema of a `z.array(...)`. Undefined for non-arrays / malformed defs. */\n  getArrayElement(schema: Schema): Schema | undefined\n  /** Element schema of a `z.set(...)`. Undefined for non-sets / malformed defs. */\n  getSetValueType(schema: Schema): Schema | undefined\n  /** Key schema of a `z.record(K, V)`. Undefined for non-records / single-arg records. */\n  getRecordKeyType(schema: Schema): Schema | undefined\n  /** Value schema of a `z.record(...)`. Undefined for non-records / malformed defs. */\n  getRecordValueType(schema: Schema): Schema | undefined\n  /** Option array of a `z.union(...)`. Empty for non-unions. */\n  getUnionOptions(schema: Schema): readonly Schema[]\n  /** Left side of a `z.intersection(L, R)`. Undefined for non-intersections. */\n  getIntersectionLeft(schema: Schema): Schema | undefined\n  /** Right side of a `z.intersection(L, R)`. Undefined for non-intersections. */\n  getIntersectionRight(schema: Schema): Schema | undefined\n  /** Values of a `z.enum(...)`. Empty for non-enums. */\n  getEnumValues(schema: Schema): readonly (string | number)[]\n  /**\n   * Raw reverse-mapped values object of a `z.nativeEnum(E)`. v3 returns\n   * the TS enum object directly; v4 always returns `undefined` because\n   * v4 folds nativeEnum into the regular `enum` kind.\n   */\n  getNativeEnumValues(schema: Schema): Record<string, unknown> | undefined\n\n  /**\n   * Inner schema of any wrapper exposing `def.innerType` — Optional /\n   * Nullable / Default / Readonly / Catch in both v3 and v4. Branded\n   * (v3-only) uses `def.type` instead — see `unwrapBranded`. Returns\n   * `undefined` when no inner is available.\n   */\n  unwrapInner(schema: Schema): Schema | undefined\n  /**\n   * v3-only: `ZodBranded`'s inner schema (`_def.type`). Returns\n   * `undefined` on v4 (no branded wrapper) and on non-branded schemas.\n   */\n  unwrapBranded(schema: Schema): Schema | undefined\n  /**\n   * v3-only: structural source of a `ZodEffects` (refine / transform /\n   * preprocess) — `_def.schema`. Returns `undefined` on v4 (no\n   * ZodEffects wrapper; effects live as pipe sides / leaf checks).\n   */\n  unwrapEffectsSource(schema: Schema): Schema | undefined\n  /** Input side of v4's `z.pipe(IN, OUT)` (also v3's `z.pipeline(...)`). */\n  unwrapPipeIn(schema: Schema): Schema | undefined\n  /** Output side of a pipe — undefined on v3's `ZodEffects`. */\n  unwrapPipeOut(schema: Schema): Schema | undefined\n  /**\n   * Inner schema of a `z.lazy(() => inner)`. Each call invokes the\n   * getter fresh; if the getter throws (recursive cycle resolved before\n   * its target is constructed) returns `undefined`.\n   */\n  unwrapLazy(schema: Schema): Schema | undefined\n  /**\n   * Getter function reference of a `z.lazy()` wrapper — used by walkers\n   * that track cycle identity by the getter rather than its result\n   * (each call returns a distinct schema instance).\n   */\n  getLazyGetter(schema: Schema): (() => unknown) | undefined\n\n  /**\n   * Resolve a `z.default(...)` wrapper to its declared default value.\n   * v3 stores the default as a thunk (`() => value`); v4 stores it as\n   * a getter that returns the value directly. Both adapters return the\n   * resolved value here.\n   */\n  getDefaultValue(schema: Schema): unknown\n  /**\n   * Resolve a `z.catch(inner, val)` wrapper to its fallback value.\n   * The catch slot stores a `(ctx) => value` function; both adapters\n   * invoke it with a placeholder context and surface `undefined` if\n   * the consumer's function throws.\n   */\n  getCatchDefault(schema: Schema): unknown\n  /**\n   * True iff the schema carries a callable `z.catch(...)` fallback.\n   * Lets callers distinguish \"no catch wrapper\" from \"catch wrapper\n   * whose value happens to be `undefined`.\"\n   */\n  hasCatchValue(schema: Schema): boolean\n}\n\n/**\n * Adapter-specific delegates the factory calls for operations that\n * genuinely differ per Zod version (path walking, default-value\n * derivation, wrapper-peeling, error normalization, sub-schema\n * construction). Each service is a thin wrapper around per-adapter\n * helpers; the factory composes them.\n *\n * `safeParseSync` / `safeParseAsync` abstract the per-version\n * `safeParse` / `safeParseAsync` calls so the factory can stay\n * version-agnostic. Both return a uniform success-discriminant shape;\n * `safeParseSync` is allowed to throw when the schema is async-only\n * (the factory catches and falls back to the async path).\n *\n * `makeSubSchema` is the per-adapter sub-schema constructor for\n * `getSchemasAtPath`. v3 recurses through the full adapter factory\n * (sub-schemas expose the entire `AbstractSchema` surface). v4 builds\n * a 5-method stub (fingerprint / needsAsyncValidation /\n * getDefaultValues / getSchemasAtPath / validateAtPath) because none\n * of its consumers reach for the wider surface and the stub keeps\n * sub-walker allocation cheap. The factory preserves each adapter's\n * prior behavior by routing through this service rather than hard-\n * coding one strategy.\n */\nexport interface AbstractSchemaServices<Schema, Form, GetValueFormType> {\n  /**\n   * Resolves the deterministic structural fingerprint of the schema.\n   * Async so adapters can dynamic-import the fingerprint walker, keeping\n   * it off the eager path (only opt-in async features consume it).\n   */\n  fingerprint(schema: Schema): Promise<string>\n  /**\n   * Returns every sub-schema reachable at the given path. Multiple\n   * results indicate a union / discriminated-union split; empty\n   * indicates the path doesn't resolve. Adapters cap descent through\n   * `z.lazy(...)` via `maxRecursionDepth`.\n   */\n  getNestedSchemasAtPath(schema: Schema, path: Path, maxRecursionDepth: number): Schema[]\n  /**\n   * \"Slim-mode\" path walk — the variant `getSlimPrimitiveTypesAtPath`\n   * and `getSchemasAtPath` consume. v3 strips refinements / defaults /\n   * optional / nullable / effects off the root before walking, so the\n   * yielded candidates reflect the slim shape (matches what the slim-\n   * primitive gate sees and what consumers expect when introspecting\n   * sub-schemas). v4 walks the original schema and aliases this to\n   * `getNestedSchemasAtPath` — its path walker already inlines the\n   * wrapper peeling.\n   */\n  getNestedSchemasInSlimMode(schema: Schema, path: Path, maxRecursionDepth: number): Schema[]\n  /** Returns the slim-primitive accept-set of a single sub-schema. */\n  slimPrimitivesOf(schema: Schema, maxRecursionDepth: number): Set<SlimPrimitiveKind>\n  /**\n   * Returns the schema's prescribed default at the given root. The\n   * runtime calls this in `getDefaultAtPath` (`useDefault=true` — honor\n   * `.default(x)`) and `getEmptyValueAtPath` (`useDefault=false` —\n   * yield the inner-schema's falsy concrete). v3 and v4 each implement\n   * their own walker; the factory only consumes the result.\n   */\n  deriveDefault(\n    schema: Schema,\n    useDefault: boolean,\n    maxRecursionDepth: number,\n    formKey: FormKey\n  ): unknown\n  /**\n   * Adapter-owned construction-time default-values flow. v3 runs a\n   * validate-then-fix loop against a slim schema with strict-mode\n   * refine seeding; v4 runs a strict-pass-or-lax-success against the\n   * derived data. Both honour `config.strict ?? true` and\n   * `config.constraints`.\n   */\n  runStrictGetDefaults(\n    schema: Schema,\n    config: GetDefaultValuesConfig<Form>,\n    formKey: FormKey,\n    maxRecursionDepth: number\n  ): DefaultValuesResponse<Form>\n  /**\n   * Peels `.optional()` / `.nullable()` only when the inner is\n   * structurally fillable (object / array / tuple / record /\n   * union / intersection or a chain of peelable wrappers that resolve\n   * to one of those). Used by `getDefaultAtPath` so partial writes\n   * through optional sub-schemas fill from the inner shape's defaults.\n   * `.default(x)` is preserved at every layer.\n   */\n  unwrapStructuralWrappers(schema: Schema): Schema\n  /**\n   * Peels every transparent wrapper (optional / nullable / default /\n   * readonly / catch / pipe / lazy / branded / effects) and descends\n   * intersection sides looking for a single discriminated union.\n   * Returns the matching DU or `undefined` when no DU is found or\n   * when ambiguity bails (two different DUs both reachable).\n   */\n  unwrapToDiscriminatedUnion(schema: Schema): Schema | undefined\n  /**\n   * Peels every transparent wrapper off a schema — for `arrayShapeAtPath`\n   * the goal is the structural kind regardless of default-value\n   * semantics, so `.default(x)` / `.catch(x)` are peeled here whereas\n   * `unwrapStructuralWrappers` preserves them.\n   */\n  peelAllWrappers(schema: Schema): Schema\n  /**\n   * Returns `true` iff the leaf schema is \"required\" at the\n   * union-aware sense documented on `AbstractSchema.isRequiredAtPath`:\n   * `.optional()` / `.nullable()` / `.default()` / `.catch()` at any\n   * wrapper layer make the leaf permissive; union requires every\n   * branch; intersection requires either side.\n   */\n  isLeafRequired(schema: Schema): boolean\n  /** Returns the resolved field-meta payload for the schema at `path`. */\n  resolveFieldMetaAtPath(schema: Schema, path: Path, maxRecursionDepth: number): ResolvedFieldMeta\n  /**\n   * Normalise schema-library issues into the runtime's\n   * `ValidationError[]` shape. v3 and v4 have slightly different\n   * `ZodIssue` payloads; each adapter knows how to map its own.\n   */\n  issuesToValidationErrors(issues: readonly unknown[], formKey: FormKey): ValidationError[]\n  /**\n   * Run a sync `safeParse` against the schema. Returns a tagged result\n   * the factory aggregates into a `ValidationResponse`. MAY throw when\n   * the schema contains async-only refines / transforms (the factory\n   * catches and falls back to the async path).\n   */\n  safeParseSync(\n    schema: Schema,\n    data: unknown\n  ): { success: true; data: unknown } | { success: false; issues: readonly unknown[] }\n  /** Async sister of `safeParseSync`. MUST NOT throw (catch user-fn rejections). */\n  safeParseAsync(\n    schema: Schema,\n    data: unknown\n  ): Promise<{ success: true; data: unknown } | { success: false; issues: readonly unknown[] }>\n  /**\n   * Per-adapter sub-schema constructor for `getSchemasAtPath`. v3\n   * recurses through the full factory (sub-schemas carry the entire\n   * `AbstractSchema` surface). v4 returns a 5-method stub. The factory\n   * delegates here to preserve each adapter's prior shape; consumers\n   * across the runtime only reach for `needsAsyncValidation()` on\n   * sub-schemas, so both shapes are observationally interchangeable.\n   */\n  makeSubSchema(\n    schema: Schema,\n    formKey: FormKey,\n    maxRecursionDepth: number\n  ): AbstractSchema<unknown, GetValueFormType>\n}\n\n/**\n * Build a runtime `AbstractSchema` for `rootSchema` by composing the\n * shared uniform-method implementations with the per-adapter introspector\n * + services. Each adapter calls this once per `useForm({ schema })` —\n * the returned object plus its three caches (`leafCache`,\n * `preprocessOrCoerceCache`, `discriminatorCache`) plus the two memoised\n * lazy flags live for the form's lifetime.\n */\nexport function createAbstractSchema<Schema, Form, GetValueFormType>(\n  rootSchema: Schema,\n  intro: SchemaIntrospector<Schema>,\n  services: AbstractSchemaServices<Schema, Form, GetValueFormType>,\n  formKey: FormKey,\n  options: SchemaFactoryOptions\n): AbstractSchema<Form, GetValueFormType> {\n  const maxRecursionDepth = options.maxRecursionDepth\n\n  // Per-adapter caches. Lifetime = one `createAbstractSchema` call (one\n  // per `useForm()`). These memoise the schema walks that the proxy\n  // traps + reactive computeds hit on every read so the schema doesn't\n  // get re-walked per keystroke / per field-state get.\n  const leafCache = new Map<PathKey, boolean>()\n  const preprocessOrCoerceCache = new Map<PathKey, boolean>()\n  const discriminatorCache = new Map<PathKey, UnionDiscriminatorContext | undefined>()\n  // Memoised one-shot tree walks. `needsAsyncValidation` is queried at\n  // construction by the store (drives the construction-time async seed);\n  // `hasContainerOrRootRefine` is queried per keystroke (drives the\n  // subtree-vs-whole-form scope cut).\n  let asyncValidationFlag: boolean | null = null\n  let containerRefineFlag: boolean | null = null\n\n  function computeDiscriminator(path: Path): UnionDiscriminatorContext | undefined {\n    const candidates =\n      path.length === 0\n        ? [rootSchema]\n        : services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth)\n    // `unwrapToDiscriminatedUnion` peels every transparent wrapper\n    // (Optional / Nullable / Default / Readonly / Catch / Effects /\n    // Pipeline / Branded) and descends Intersection sides looking for a\n    // single discriminated union. Ambiguous resolutions (two distinct\n    // DUs both reachable across candidates) bail — the runtime then\n    // falls back to a plain write.\n    let matchedUnion: Schema | undefined\n    for (const candidate of candidates) {\n      const du = services.unwrapToDiscriminatedUnion(candidate)\n      if (du === undefined) continue\n      if (matchedUnion !== undefined && matchedUnion !== du) return undefined\n      matchedUnion = du\n    }\n    if (matchedUnion === undefined) return undefined\n    const discKey = intro.getDiscriminator(matchedUnion)\n    if (discKey === undefined) return undefined\n    const unionOptions = intro.getDiscriminatedOptions(matchedUnion)\n    const literalSet = new Set<unknown>()\n    for (const opt of unionOptions) {\n      const shape = intro.getObjectShape(opt)\n      const litSchema = shape[discKey]\n      if (litSchema === undefined) continue\n      if (intro.kindOf(litSchema) !== 'literal') continue\n      // Multi-value literals (`z.literal(['a','b'])`) register every\n      // member as a selectable variant.\n      for (const v of intro.getLiteralValues(litSchema)) literalSet.add(v)\n    }\n    return {\n      discriminatorKey: discKey,\n      getVariantDefault(value: unknown): unknown {\n        for (const opt of unionOptions) {\n          const shape = intro.getObjectShape(opt)\n          const litSchema = shape[discKey]\n          if (litSchema === undefined) continue\n          if (intro.kindOf(litSchema) !== 'literal') continue\n          const literalValues = intro.getLiteralValues(litSchema)\n          if (literalValues.includes(value)) {\n            return services.deriveDefault(opt, true, maxRecursionDepth, formKey)\n          }\n        }\n        return undefined\n      },\n      isVariantSelected(value: unknown): boolean {\n        return literalSet.has(value)\n      },\n    }\n  }\n\n  const abstractSchema: AbstractSchema<Form, GetValueFormType> = {\n    fingerprint: () => services.fingerprint(rootSchema),\n\n    needsAsyncValidation(): boolean {\n      asyncValidationFlag ??=\n        intro.containsAsyncRefine(rootSchema) || intro.containsAsyncTransform(rootSchema)\n      return asyncValidationFlag\n    },\n\n    hasContainerOrRootRefine(): boolean {\n      containerRefineFlag ??= intro.hasContainerOrRootRefine(rootSchema)\n      return containerRefineFlag\n    },\n\n    getDefaultValues(config: GetDefaultValuesConfig<Form>): DefaultValuesResponse<Form> {\n      return services.runStrictGetDefaults(rootSchema, config, formKey, maxRecursionDepth)\n    },\n\n    getDefaultAtPath(path) {\n      // Empty path → root default. Reuses the same generator used at\n      // form construction so refines / wrappers behave consistently.\n      if (path.length === 0) {\n        return services.deriveDefault(rootSchema, true, maxRecursionDepth, formKey)\n      }\n      const [first] = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth)\n      if (first === undefined) return undefined\n      // STRUCTURAL default: peel `.optional()` / `.nullable()` so partial\n      // object writes through optional sub-schemas (`{ profile:\n      // z.object({...}).optional() }`) get the inner shape's defaults\n      // filled in. `.default(x)` is preserved so deriveDefault returns\n      // the explicit default. First candidate matches\n      // `validateAtPath`'s first-success semantic.\n      const peeled = services.unwrapStructuralWrappers(first)\n      return services.deriveDefault(peeled, true, maxRecursionDepth, formKey)\n    },\n\n    getEmptyValueAtPath(path) {\n      // `clear`'s underlying value lookup. Same path-resolution flow as\n      // `getDefaultAtPath` but with `useDefault=false` so `.default(x)`\n      // / `.catch(x)` wrappers are skipped — the walker yields the\n      // inner-schema's empty concrete instead. Structural wrappers\n      // (`.optional()` / `.nullable()`) are NOT peeled: clearing an\n      // `.optional()` slot is legitimately `undefined`, clearing a\n      // `.nullable()` slot is `null`.\n      if (path.length === 0) {\n        return services.deriveDefault(rootSchema, false, maxRecursionDepth, formKey)\n      }\n      const [first] = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth)\n      if (first === undefined) return undefined\n      return services.deriveDefault(first, false, maxRecursionDepth, formKey)\n    },\n\n    arrayShapeAtPath(path) {\n      if (path.length === 0) return undefined\n      const [first] = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth)\n      if (first === undefined) return undefined\n      const peeled = services.peelAllWrappers(first)\n      const kind = intro.kindOf(peeled)\n      if (kind === 'tuple') return intro.getTupleItems(peeled).length\n      if (kind === 'array') return null\n      return undefined\n    },\n\n    isFixedObjectAtPath(path) {\n      // Root form is a fixed object — a closed top-level key set.\n      if (path.length === 0) return true\n      const resolved = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth)\n      // A path the schema doesn't declare is not a fixed object; the\n      // proxy falls back to live keys there.\n      if (resolved.length === 0) return false\n      // The walker returns the NODE itself at a terminal path (it only\n      // splits a union / DU into variants while descending THROUGH one),\n      // so a record / array / set / union / DU surfaces here as its own\n      // single non-object kind. Multiple candidates appear only when the\n      // path descended through a union and landed on a key present in\n      // several variants; that key is a fixed object iff it's an object\n      // in every variant. Peel wrappers first so `z.object().optional()`\n      // still reads as an object.\n      return resolved.every((s) => intro.kindOf(services.peelAllWrappers(s)) === 'object')\n    },\n\n    getSchemasAtPath(path) {\n      // Slim-mode walk: v3 strips refinements / defaults / wrappers off\n      // the root so the yielded sub-schemas reflect the slim shape (the\n      // shape the slim-primitive gate consults). v4 aliases the slim\n      // and unstripped walks to the same call. The factory uses one\n      // hook for both `getSlimPrimitiveTypesAtPath` and\n      // `getSchemasAtPath` — same v3 strip semantic, same v4 alias.\n      const resolved = services.getNestedSchemasInSlimMode(rootSchema, path, maxRecursionDepth)\n      // Empty list is a valid result for paths the schema doesn't\n      // declare — callers (getValue / register / custom introspection)\n      // treat `[]` as \"no sub-schema here\". No warning needed.\n      if (resolved.length === 0) return []\n      return resolved.map((sub) => services.makeSubSchema(sub, formKey, maxRecursionDepth))\n    },\n\n    getSlimPrimitiveTypesAtPath(path): Set<SlimPrimitiveKind> {\n      // Empty path is the root form: always an object.\n      if (path.length === 0) return new Set<SlimPrimitiveKind>(['object'])\n      const resolved = services.getNestedSchemasInSlimMode(rootSchema, path, maxRecursionDepth)\n      // Path doesn't resolve in the schema → no kinds accepted. The\n      // gate's membership check rejects every kind against an empty\n      // set, blocking writes to typo / unknown paths.\n      if (resolved.length === 0) return new Set<SlimPrimitiveKind>()\n      const out = new Set<SlimPrimitiveKind>()\n      for (const candidate of resolved) {\n        for (const k of services.slimPrimitivesOf(candidate, maxRecursionDepth)) {\n          out.add(k)\n        }\n      }\n      return out\n    },\n\n    isLeafAtPath(path): boolean {\n      const cacheKey = canonicalizePath(path).key\n      const cached = leafCache.get(cacheKey)\n      if (cached !== undefined) return cached\n      const prim = this.getSlimPrimitiveTypesAtPath(path)\n      // Empty set → path doesn't exist in schema → descend permissively\n      // (treat as container so schema-named reserved keys at depth 2+\n      // don't shadow). Any container kind in the set → descend.\n      // Otherwise every kind is a primitive → leaf.\n      const isLeaf =\n        prim.size > 0 &&\n        !prim.has('object') &&\n        !prim.has('array') &&\n        !prim.has('map') &&\n        !prim.has('set')\n      leafCache.set(cacheKey, isLeaf)\n      return isLeaf\n    },\n\n    isPreprocessOrCoerceLeaf(path): boolean {\n      // Walks prefixes of `path` looking for either shape adapters\n      // use for schema-side input normalizers (`z.preprocess(...)` or\n      // `z.coerce.X()`). Returns true at such a node OR anywhere\n      // underneath it; the slim-primitive gate uses this to accept\n      // raw consumer writes verbatim throughout that subtree.\n      const cacheKey = canonicalizePath(path).key\n      const cached = preprocessOrCoerceCache.get(cacheKey)\n      if (cached !== undefined) return cached\n      let hit = false\n      for (let i = 0; i <= path.length && !hit; i++) {\n        const prefix = path.slice(0, i)\n        const candidates: Schema[] =\n          prefix.length === 0\n            ? [rootSchema]\n            : services.getNestedSchemasAtPath(rootSchema, prefix, maxRecursionDepth)\n        for (const candidate of candidates) {\n          if (intro.isCoercePrimitive(candidate) || intro.isPreprocessNode(candidate)) {\n            hit = true\n            break\n          }\n        }\n      }\n      preprocessOrCoerceCache.set(cacheKey, hit)\n      return hit\n    },\n\n    isRequiredAtPath(path): boolean {\n      // Root form is structurally required (it's the parsed object).\n      // The required-empty check tracks primitive leaves only, so this\n      // branch is academic for the call sites that matter.\n      if (path.length === 0) return true\n      const resolved = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth)\n      if (resolved.length === 0) return false\n      // Every candidate must be required for the path overall to be\n      // required — matches the union \"any-branch-permissive\" rule\n      // when the path traverses a union.\n      return resolved.every((candidate) => services.isLeafRequired(candidate))\n    },\n\n    getFieldMetaAtPath(path): ResolvedFieldMeta {\n      return services.resolveFieldMetaAtPath(rootSchema, path, maxRecursionDepth)\n    },\n\n    getUnionDiscriminatorAtPath(path): UnionDiscriminatorContext | undefined {\n      const cacheKey = canonicalizePath(path).key\n      if (discriminatorCache.has(cacheKey)) {\n        return discriminatorCache.get(cacheKey)\n      }\n      const result = computeDiscriminator(path)\n      discriminatorCache.set(cacheKey, result)\n      return result\n    },\n\n    validateAtPath(\n      data: unknown,\n      path: Path | undefined,\n      validateOptions?: ValidateOptions\n    ): ReturnType<AbstractSchema<Form, GetValueFormType>['validateAtPath']> {\n      // Sync attempt: when `options.sync === true`, try the sync parse.\n      // It throws on async refines / pipes / transforms; we catch and\n      // fall through to the async path. Without the flag the adapter\n      // goes straight to async — the historical contract every non-\n      // reshape callsite expects.\n      const trySync = validateOptions?.sync === true\n      if (trySync) {\n        try {\n          return runSync()\n        } catch {\n          // Async-only schema. Fall through to the async path.\n        }\n      }\n      return runAsync()\n\n      function runSync(): ValidationResponse<GetValueFormType> {\n        if (path === undefined) {\n          const result = services.safeParseSync(rootSchema, data)\n          return result.success\n            ? {\n                data: result.data as GetValueFormType,\n                errors: undefined,\n                success: true,\n                formKey,\n              }\n            : {\n                data: undefined,\n                errors: services.issuesToValidationErrors(result.issues, formKey),\n                success: false,\n                formKey,\n              }\n        }\n        const resolved = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth)\n        if (resolved.length === 0) return pathNotFound(path)\n        const aggregated: ValidationError[] = []\n        for (const candidate of resolved) {\n          const result = services.safeParseSync(candidate, data)\n          if (result.success) {\n            return {\n              data: result.data as GetValueFormType,\n              errors: undefined,\n              success: true,\n              formKey,\n            }\n          }\n          aggregated.push(...services.issuesToValidationErrors(result.issues, formKey))\n        }\n        return { data: undefined, errors: aggregated, success: false, formKey }\n      }\n\n      async function runAsync(): Promise<ValidationResponse<GetValueFormType>> {\n        if (path === undefined) {\n          let result: Awaited<ReturnType<typeof services.safeParseAsync>>\n          try {\n            result = await services.safeParseAsync(rootSchema, data)\n          } catch (err) {\n            return validatorThrewResponse(err, [])\n          }\n          return result.success\n            ? {\n                data: result.data as GetValueFormType,\n                errors: undefined,\n                success: true,\n                formKey,\n              }\n            : {\n                data: undefined,\n                errors: services.issuesToValidationErrors(result.issues, formKey),\n                success: false,\n                formKey,\n              }\n        }\n        const resolved = services.getNestedSchemasAtPath(rootSchema, path, maxRecursionDepth)\n        if (resolved.length === 0) return pathNotFound(path)\n        // Sequential await — parallelising would run every branch's\n        // async side effects on a value only one branch should see.\n        const aggregated: ValidationError[] = []\n        for (const candidate of resolved) {\n          let result: Awaited<ReturnType<typeof services.safeParseAsync>>\n          try {\n            result = await services.safeParseAsync(candidate, data)\n          } catch (err) {\n            return validatorThrewResponse(err, path)\n          }\n          if (result.success) {\n            return {\n              data: result.data as GetValueFormType,\n              errors: undefined,\n              success: true,\n              formKey,\n            }\n          }\n          aggregated.push(...services.issuesToValidationErrors(result.issues, formKey))\n        }\n        return { data: undefined, errors: aggregated, success: false, formKey }\n      }\n\n      // User code inside `z.preprocess` / `.refine` / `.transform` can\n      // throw (sync) or reject (async). Zod does NOT wrap these into\n      // issues; they propagate out of `safeParse` / `safeParseAsync`.\n      // Without this catch the throw bubbles through `validateAtPath`\n      // into the runtime's submit / change-mode pipelines as either a\n      // `submitError` (handleSubmit) or an unhandled rejection\n      // (scheduleFieldValidation), and the consumer would never see a\n      // path-scoped error message. Surface as a `ValidationError` at\n      // the field path so the form's normal error pipeline handles it.\n      function validatorThrewResponse(\n        err: unknown,\n        errPath: Path\n      ): ValidationResponse<GetValueFormType> {\n        const message =\n          err instanceof Error ? err.message : typeof err === 'string' ? err : 'Validator threw'\n        return {\n          data: undefined,\n          errors: [\n            {\n              message,\n              path: [...errPath],\n              formKey,\n              code: AttaformErrorCode.ValidatorThrew,\n            },\n          ],\n          success: false,\n          formKey,\n        }\n      }\n\n      function pathNotFound(p: Path): ValidationResponse<GetValueFormType> {\n        return {\n          data: undefined,\n          errors: [\n            {\n              message: `Path '${p.join(PATH_SEPARATOR)}' did not resolve to any schema`,\n              path: [...p],\n              formKey,\n              code: AttaformErrorCode.PathNotFound,\n            },\n          ],\n          success: false,\n          formKey,\n        }\n      }\n    },\n  }\n\n  return abstractSchema\n}\n","/**\n * Plain-record deep merge for default-value derivation.\n *\n * Leaf semantics (anything not a plain `{}` record is a leaf):\n *   - `undefined` override → no-op (base wins).\n *   - `null` override → replaces base (a deliberate \"clear this field\"\n *     signal that mustn't be merged into).\n *   - Primitives / arrays / Date / Map / class instances → replace\n *     wholesale (e.g. an array override doesn't concat).\n *\n * Recursion only when BOTH sides are plain records. The override-key\n * walk uses `Object.keys` (own enumerable) so a key with an explicit\n * `undefined` value lands here too — the consumer's choice to name the\n * path overrides the base's value, mirroring how an explicit `null`\n * would.\n *\n * Hosted in core so the v3 and v4 default-value walkers single-source\n * the intersection / constraint-merge step. Previously identical\n * `mergeDeep` / `mergeDeepV3` bodies lived per-adapter.\n */\nimport { isPlainRecord } from './path-walker'\nimport { safeAssign, safeOwnRead } from './safe-assign'\n\nexport function mergeDeep(base: unknown, override: unknown): unknown {\n  if (override === undefined) return base\n  if (!isPlainRecord(override)) return override\n  if (!isPlainRecord(base)) return override\n\n  // Object spread carries `base`'s own properties through the\n  // spec's `CreateDataProperty` step, which bypasses the\n  // `__proto__` setter — so a `base` carrying a literal\n  // `__proto__` own property (e.g. from JSON-parsed adapter\n  // defaults that round-tripped through storage) survives the\n  // spread without reassigning the result's prototype. The\n  // per-key reads route through `safeOwnRead` so a\n  // `key === '__proto__'` doesn't resolve via the inherited\n  // accessor on the regular target. The per-key `safeAssign` lands\n  // an `override`'s `__proto__` entry as an own data property via\n  // `Object.defineProperty`; every other key takes the plain\n  // bracket-assign branch. Legitimate consumer-schema fields named\n  // `prototype` / `constructor` / `__proto__` flow through default-\n  // value derivation alongside every other key, and\n  // `Object.prototype` stays untouched.\n  const result: Record<string, unknown> = { ...base }\n  for (const key of Object.keys(override)) {\n    const oVal = safeOwnRead(override, key)\n    const bVal = safeOwnRead(base, key)\n    if (isPlainRecord(oVal) && isPlainRecord(bVal)) {\n      safeAssign(result, key, mergeDeep(bVal, oVal))\n    } else {\n      safeAssign(result, key, oVal)\n    }\n  }\n  return result\n}\n","/**\n * Shared path walker — descends a dotted segment array through a Zod\n * schema tree and returns the sub-schemas reachable at that path.\n *\n * One body, two adapters: v3 and v4 each invoke `walkPathSegments`\n * with their `SchemaIntrospector` instance. Wrapper / container kinds\n * (Optional / Nullable / Default / Readonly / Catch / Pipe / Pipeline /\n * Effects / Branded / Lazy / Intersection / Union / DiscriminatedUnion /\n * Object / Array / Set / Record / Tuple) all dispatch through the\n * introspector accessors, so the walker stays agnostic to per-version\n * `def.*` shape.\n *\n * Semantics (preserved verbatim from the prior per-adapter\n * implementations — characterised by `test/adapters/zod-v3/path-walker.test.ts`\n * and `test/adapters/zod-v4/path-walker.test.ts`):\n *\n *  - Unions return multiple candidates (caller tries each).\n *  - Discriminated unions filter options to those whose shape owns the\n *    next segment (`Object.hasOwn`, NOT `in`, so `Object.prototype` keys\n *    don't leak); fall back to every option when no shape matches\n *    (the segment is the discriminator key itself).\n *  - Object shape access uses `Object.hasOwn` for the same reason: a\n *    bare `shape[head]` would resolve `'toString'` / `'valueOf'` etc.\n *    to the inherited Function and treat it as a schema.\n *  - Transparent wrappers (optional / nullable / default / readonly /\n *    catch / pipe / pipeline / effects / branded) descend without\n *    consuming a segment.\n *  - `lazy` bumps the lazy counter; past the cap the walker returns\n *    `[]` so writes at recursive paths deeper than `maxRecursionDepth`\n *    fall back to a permissive type gate.\n *  - Intersection unions both sides' resolutions — callers try each\n *    candidate, matching parse-time semantics where a value must\n *    satisfy both.\n *  - Leaf kinds (string / number / boolean / literal / enum / etc.)\n *    return `[]` when path remains, so a caller that asked for\n *    `firstName.middle` against a string schema gets an empty\n *    resolution rather than a wrong schema.\n *  - Unsupported kinds (`map` / `symbol` / `function` / `promise`) are\n *    rejected at adapter construction by `assertSupportedKinds`; the\n *    walker's exhaustiveness on those kinds returns `[]` defensively\n *    so a downstream caller that instantiates a sub-schema directly\n *    isn't crashed.\n */\nimport type { SchemaIntrospector } from './abstract-schema-factory'\n\nexport function walkPathSegments<Schema>(\n  schema: Schema,\n  segments: readonly string[],\n  intro: SchemaIntrospector<Schema>,\n  maxDepth: number,\n  lazyDepth: number\n): Schema[] {\n  if (segments.length === 0) return [schema]\n  const [head, ...rest] = segments\n  if (head === undefined) return [schema]\n  const kind = intro.kindOf(schema)\n  switch (kind) {\n    case 'object': {\n      const shape = intro.getObjectShape(schema)\n      if (!Object.hasOwn(shape, head)) return []\n      const next = shape[head]\n      return next === undefined ? [] : walkPathSegments(next, rest, intro, maxDepth, lazyDepth)\n    }\n    case 'array': {\n      const inner = intro.getArrayElement(schema)\n      return inner === undefined ? [] : walkPathSegments(inner, rest, intro, maxDepth, lazyDepth)\n    }\n    case 'set': {\n      // Sets aren't position-indexed; the head segment is a synthetic\n      // indexer (`[...path, 0]`) used to query the element type. Descend\n      // into the value schema and consume the segment.\n      const inner = intro.getSetValueType(schema)\n      return inner === undefined ? [] : walkPathSegments(inner, rest, intro, maxDepth, lazyDepth)\n    }\n    case 'record': {\n      const inner = intro.getRecordValueType(schema)\n      return inner === undefined ? [] : walkPathSegments(inner, rest, intro, maxDepth, lazyDepth)\n    }\n    case 'tuple': {\n      const index = Number(head)\n      if (!Number.isInteger(index)) return []\n      const items = intro.getTupleItems(schema)\n      const item = items[index]\n      return item === undefined ? [] : walkPathSegments(item, rest, intro, maxDepth, lazyDepth)\n    }\n    case 'union':\n      return intro\n        .getUnionOptions(schema)\n        .flatMap((opt) => walkPathSegments(opt, segments, intro, maxDepth, lazyDepth))\n    case 'discriminated-union': {\n      const options = intro.getDiscriminatedOptions(schema)\n      const matching = options.filter((opt) => Object.hasOwn(intro.getObjectShape(opt), head))\n      const candidates = matching.length > 0 ? matching : options\n      return candidates.flatMap((opt) =>\n        walkPathSegments(opt, segments, intro, maxDepth, lazyDepth)\n      )\n    }\n    case 'optional':\n    case 'nullable':\n    case 'default':\n    case 'readonly':\n    case 'catch': {\n      // `catch` peels like a wrapper — descend into the inner schema.\n      // The catch fallback only matters at parse time, not path lookup.\n      const inner = intro.unwrapInner(schema)\n      return inner === undefined\n        ? []\n        : walkPathSegments(inner, segments, intro, maxDepth, lazyDepth)\n    }\n    case 'pipe': {\n      // v4: `z.pipe(IN, OUT)` / `z.preprocess(fn, inner)` desugars to\n      // pipe-with-transform-on-`in`. Both sides are sub-schemas; the\n      // walker peeks at either, preferring `in`.\n      const inner = intro.unwrapPipeIn(schema) ?? intro.unwrapPipeOut(schema)\n      return inner === undefined\n        ? []\n        : walkPathSegments(inner, segments, intro, maxDepth, lazyDepth)\n    }\n    case 'pipeline': {\n      // v3: `z.pipeline(...)` — peel to the input side.\n      const inner = intro.unwrapPipeIn(schema)\n      return inner === undefined\n        ? []\n        : walkPathSegments(inner, segments, intro, maxDepth, lazyDepth)\n    }\n    case 'effects': {\n      // v3: `ZodEffects` (refine / transform / preprocess) — peel to\n      // the structural source schema. Path resolution lands on the\n      // inner shape regardless of effect type.\n      const inner = intro.unwrapEffectsSource(schema)\n      return inner === undefined\n        ? []\n        : walkPathSegments(inner, segments, intro, maxDepth, lazyDepth)\n    }\n    case 'branded': {\n      // v3: `ZodBranded` — peel to the inner schema. Brands are\n      // compile-time tags with no runtime structural impact.\n      const inner = intro.unwrapBranded(schema)\n      return inner === undefined\n        ? []\n        : walkPathSegments(inner, segments, intro, maxDepth, lazyDepth)\n    }\n    case 'lazy': {\n      // Bump the lazy counter. Past the cap, return [] so callers fall\n      // back to permissive behaviour at recursive paths beyond the cap.\n      if (lazyDepth >= maxDepth) return []\n      const inner = intro.unwrapLazy(schema)\n      return inner === undefined\n        ? []\n        : walkPathSegments(inner, segments, intro, maxDepth, lazyDepth + 1)\n    }\n    case 'intersection': {\n      const left = intro.getIntersectionLeft(schema)\n      const right = intro.getIntersectionRight(schema)\n      const leftResults =\n        left === undefined ? [] : walkPathSegments(left, segments, intro, maxDepth, lazyDepth)\n      const rightResults =\n        right === undefined ? [] : walkPathSegments(right, segments, intro, maxDepth, lazyDepth)\n      return [...leftResults, ...rightResults]\n    }\n    // Leaves — can't descend further. The unsupported kinds (`map` /\n    // `symbol` / `function` / `promise`) are rejected at adapter\n    // construction by `assertSupportedKinds`; falling through to `[]`\n    // keeps the walker defensive in case construction is skipped\n    // (e.g. a downstream test instantiates a sub-schema directly).\n    default:\n      return []\n  }\n}\n","/**\n * Shared default-value walker — derives the initial seed value the\n * runtime places at every leaf of a Zod schema tree.\n *\n * Both v3 and v4 adapters dispatch through this body via their\n * `SchemaIntrospector` instance plus a small `DeriveDefaultContext`\n * carrying per-adapter knobs (`unsupportedKindFallback`, `formKey`).\n * The per-version kind sets — v3's `branded` / `effects` / `pipeline`\n * / `native-enum`, v4's `pipe` / `file` — collapse to distinct cases\n * on the SharedZodKind switch.\n *\n * Semantics (preserved verbatim from the prior per-adapter\n * implementations — characterised by the `default-values`,\n * `get-default-at-path`, and `default-values-parity` test suites in\n * `test/adapters/zod-v{3,4}/`):\n *\n *  - When `useDefault=true`, the walker FIRST peels transparent\n *    wrappers (Optional / Nullable / Readonly / Catch-without-value /\n *    Branded / Effects / Pipeline) looking for an embedded\n *    `ZodDefault` — and returns its value if found. This mirrors v3's\n *    prior `unwrapDefault` chain-peel and CLOSES a v3↔v4 parity gap:\n *    on v4, `z.string().default('x').optional()` previously returned\n *    `undefined` because the outer-kind switch hit `case 'optional'`\n *    first; under the unified walker it returns `'x'`. ZodCatch\n *    precedence is preserved: catch wraps default → catch wins (the\n *    chain-peel returns the catch value at the outer Catch layer).\n *\n *  - Schema-side input normalizers (`z.coerce.X()`,\n *    `z.preprocess(fn, _)`) declare a write boundary the runtime\n *    cannot honestly synthesise a default for. Both early-return\n *    `undefined` so the consumer's `defaultValues` or a later\n *    `setValue` owns what lands in storage.\n *\n *  - Containers recurse into children; leaves return their kind's\n *    canonical empty value (`'' / 0 / 0n / false / new Date(0) /\n *    null / undefined / NaN / first enum or literal value /\n *    [] / new Set() / {}`).\n *\n *  - Unions / DUs use the first option as the seed.\n *\n *  - Intersections merge both sides via the shared `mergeDeep`.\n *\n *  - Lazy bumps a counter; past `maxDepth` returns `undefined` (the\n *    recursive node falls back to consumer-supplied defaultValues).\n *\n *  - Catch with `useDefault=true` returns the catch fallback; with\n *    `useDefault=false` recurses the inner so the leaf's empty value\n *    wins.\n *\n *  - `void` / `any` / `unknown` / `never` / opaque kinds return\n *    `undefined`.\n */\nimport type { SchemaIntrospector } from './abstract-schema-factory'\nimport { mergeDeep } from './merge-deep'\nimport { safeAssign } from './safe-assign'\n\nexport interface DeriveDefaultContext<Schema> {\n  /**\n   * Fallback for a kind the walker doesn't have a case for. Returning\n   * `undefined` is the safe default; v3 wires a `console.warn` here\n   * for visibility into custom-adapter consumers, v4 returns\n   * `undefined` silently (its kind set is exhaustive against\n   * `SchemaIntrospector.kindOf`).\n   */\n  unsupportedKindFallback(schema: Schema, kind: string): unknown\n  /**\n   * How `case 'catch'` resolves when `useDefault=false`. The two\n   * adapters chose differently and pinned the choice with tests:\n   *\n   *   - v3 wires `'preserveCatch'`: a `.catch(v)` wrapper always\n   *     surfaces its fallback `v`, regardless of `useDefault`. Rationale:\n   *     the catch is an emphatic consumer statement that should\n   *     resurface across submit failures, hydration, and history.\n   *   - v4 wires `'recurseInner'`: `useDefault=false` means \"show the\n   *     leaf empty\", and `.catch()` is a default-like wrapper that gets\n   *     skipped. The walker recurses into the inner so the leaf's\n   *     bare empty value (`'' / 0 / false / ...`) wins.\n   *\n   * On `useDefault=true` the chain-peel at the top of the walker\n   * already finds and returns the catch fallback at either adapter,\n   * so this knob only takes effect on `useDefault=false`.\n   */\n  catchOnUseDefaultFalse: 'preserveCatch' | 'recurseInner'\n}\n\n/**\n * Sentinel for the chain-peel-default helper. Distinct from\n * `undefined`, which IS a legal returned default value (e.g.\n * `z.string().default(undefined)`).\n */\nexport const NO_EMBEDDED_DEFAULT = Symbol('atta:no-embedded-default')\n\n/**\n * Peel transparent wrappers looking for an embedded `ZodDefault` (or\n * a `ZodCatch` with a fallback value, which takes precedence over a\n * nested default at the same depth). Returns the resolved value or\n * the sentinel `NO_EMBEDDED_DEFAULT` if none found.\n *\n * Mirrors v3's prior `unwrapDefault` loop and now applies on v4 too.\n * v4's kind set means `branded` / `effects` / `pipeline` peels\n * silently no-op (the introspector stubs return undefined).\n *\n * Bounded loop (32 iterations) matches the prior cap and acts as a\n * runaway guard for pathological wrapper stacks / self-referential\n * lazy loops resolved before their inner is constructed.\n *\n * Exported so the v3 strict-mode fix-up loop in `zod-v3/index.ts`\n * (the `runStrictGetDefaultsV3` validate-then-fix path) can reuse\n * it for the issue-driven default-resolution step.\n */\nexport function peelEmbeddedDefault<Schema>(\n  schema: Schema,\n  intro: SchemaIntrospector<Schema>\n): unknown {\n  let current: Schema | undefined = schema\n  for (let i = 0; i < 32; i++) {\n    if (current === undefined) return NO_EMBEDDED_DEFAULT\n    const k = intro.kindOf(current)\n    if (k === 'default') return intro.getDefaultValue(current)\n    if (k === 'catch') {\n      if (intro.hasCatchValue(current)) return intro.getCatchDefault(current)\n      current = intro.unwrapInner(current)\n      continue\n    }\n    if (k === 'optional' || k === 'nullable' || k === 'readonly') {\n      current = intro.unwrapInner(current)\n      continue\n    }\n    if (k === 'branded') {\n      current = intro.unwrapBranded(current)\n      continue\n    }\n    if (k === 'effects') {\n      current = intro.unwrapEffectsSource(current)\n      continue\n    }\n    if (k === 'pipeline') {\n      current = intro.unwrapPipeIn(current)\n      continue\n    }\n    return NO_EMBEDDED_DEFAULT\n  }\n  return NO_EMBEDDED_DEFAULT\n}\n\n/**\n * Walk transparent wrappers looking for a `ZodDefault` in the chain.\n * Used by the preprocess branch to decide whether the inner has a\n * consumer-declared default the adapter should honor (recurse the\n * inner) or whether the slot is fully consumer-owned (`undefined`).\n *\n * Distinct from `peelEmbeddedDefault` in that the result is a\n * boolean — the caller decides what to do with it, not the value\n * itself.\n */\nfunction hasDeclaredDefaultInChain<Schema>(\n  schema: Schema,\n  intro: SchemaIntrospector<Schema>\n): boolean {\n  let current: Schema | undefined = schema\n  for (let i = 0; i < 32; i++) {\n    if (current === undefined) return false\n    const k = intro.kindOf(current)\n    if (k === 'default') return true\n    if (k === 'optional' || k === 'nullable' || k === 'readonly' || k === 'catch') {\n      current = intro.unwrapInner(current)\n      continue\n    }\n    return false\n  }\n  return false\n}\n\nexport function deriveDefaultWalk<Schema>(\n  schema: Schema,\n  useDefault: boolean,\n  intro: SchemaIntrospector<Schema>,\n  maxDepth: number,\n  ctx: DeriveDefaultContext<Schema>,\n  lazyDepth = 0\n): unknown {\n  // Pre-check the wrapper chain for an embedded ZodDefault / ZodCatch\n  // fallback. Returning it here is what makes\n  // `z.string().default('x').optional()` resolve to 'x' rather than\n  // undefined. Closes the v3↔v4 parity gap (v4 previously stopped at\n  // the outer Optional and returned undefined).\n  if (useDefault) {\n    const peeled = peelEmbeddedDefault(schema, intro)\n    if (peeled !== NO_EMBEDDED_DEFAULT) return peeled\n  }\n\n  // `z.coerce.X()` flags the wrapped primitive's def with `coerce:\n  // true`; the consumer's pre-conversion input shape is unknown so\n  // synthesising the primitive's slim concrete (`''` / `0` / etc.)\n  // would claim a value the consumer never supplied. Leave the slot\n  // `undefined` so `defaultValues` or a later `setValue` owns what\n  // lands in storage. A consumer-declared `.default(x)` on the coerce\n  // primitive was already honored by the chain-peel above.\n  if (intro.isCoercePrimitive(schema)) return undefined\n\n  const kind = intro.kindOf(schema)\n  switch (kind) {\n    case 'object': {\n      const shape = intro.getObjectShape(schema)\n      // Default container carries `Object.prototype`. The default\n      // flows directly into `form.values`; matching the rest of the\n      // value-write pipeline keeps the initial tree consistent with\n      // what `setAtPath` and `mergeDeep` produce. Schema field names\n      // can legitimately include `__proto__` (an architecture firm\n      // tracking prototypes; a Zod schema with `z.object({ __proto__: … })`);\n      // `safeAssign` lands such a key as an own data property.\n      const out: Record<string, unknown> = {}\n      for (const [key, subSchema] of Object.entries(shape)) {\n        safeAssign(\n          out,\n          key,\n          deriveDefaultWalk(subSchema, useDefault, intro, maxDepth, ctx, lazyDepth)\n        )\n      }\n      return out\n    }\n    case 'array':\n      return []\n    case 'set':\n      return new Set()\n    case 'record':\n      return {}\n    case 'tuple': {\n      const items = intro.getTupleItems(schema)\n      return items.map((item) =>\n        deriveDefaultWalk(item, useDefault, intro, maxDepth, ctx, lazyDepth)\n      )\n    }\n    case 'union': {\n      const options = intro.getUnionOptions(schema)\n      const first = options[0]\n      return first === undefined\n        ? undefined\n        : deriveDefaultWalk(first, useDefault, intro, maxDepth, ctx, lazyDepth)\n    }\n    case 'discriminated-union': {\n      const options = intro.getDiscriminatedOptions(schema)\n      const first = options[0]\n      return first === undefined\n        ? undefined\n        : deriveDefaultWalk(first, useDefault, intro, maxDepth, ctx, lazyDepth)\n    }\n    case 'optional':\n      return undefined\n    case 'nullable':\n      return null\n    case 'default': {\n      // `useDefault=false` path: the chain-peel above is suppressed,\n      // so a direct ZodDefault still lands here — recurse the inner\n      // to produce the leaf's bare empty value (the explicit default\n      // is the consumer's \"starting state\" intent, not the leaf's\n      // type-honest blank).\n      if (useDefault) return intro.getDefaultValue(schema)\n      const inner = intro.unwrapInner(schema)\n      return inner === undefined\n        ? undefined\n        : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth)\n    }\n    case 'readonly':\n    case 'branded': {\n      // Readonly: v3 + v4 transparent wrapper.\n      // Branded: v3-only — `_def.type` carrier.\n      const inner = kind === 'branded' ? intro.unwrapBranded(schema) : intro.unwrapInner(schema)\n      return inner === undefined\n        ? undefined\n        : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth)\n    }\n    case 'effects': {\n      // v3-only. `ZodEffects` wraps refine / transform / preprocess.\n      // For `preprocess`: the input side is the user-supplied fn, so\n      // the slot has no canonical empty value the adapter can honestly\n      // synthesise. If the inner declares a default, recurse (the\n      // chain-peel finds it for useDefault=true; under useDefault=false\n      // we recurse to the leaf's empty). Otherwise return undefined so\n      // `defaultValues` or a later setValue owns the slot.\n      // For `refinement` / `transform`: recurse the structural source.\n      const inner = intro.unwrapEffectsSource(schema)\n      if (intro.isPreprocessNode(schema)) {\n        if (inner !== undefined && hasDeclaredDefaultInChain(inner, intro)) {\n          return deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth)\n        }\n        return undefined\n      }\n      return inner === undefined\n        ? undefined\n        : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth)\n    }\n    case 'pipeline': {\n      // v3-only. The pre-transform default is the input schema's\n      // natural default.\n      const inner = intro.unwrapPipeIn(schema)\n      return inner === undefined\n        ? undefined\n        : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth)\n    }\n    case 'pipe': {\n      // v4-only. Two sub-cases mirroring v3's preprocess branch:\n      //\n      //   - `z.preprocess(fn, inner)` — `in` is a ZodTransform. The\n      //     input shape is unknown until the consumer writes. If the\n      //     inner carries a declared default, recurse; otherwise\n      //     return undefined.\n      //   - `.transform(fn)` (transform on output) / generic / codec\n      //     pipes — the input side IS the source schema; peel to it.\n      const inn = intro.unwrapPipeIn(schema)\n      if (inn !== undefined && intro.kindOf(inn) === 'transform') {\n        const out = intro.unwrapPipeOut(schema)\n        if (out !== undefined && hasDeclaredDefaultInChain(out, intro)) {\n          return deriveDefaultWalk(out, useDefault, intro, maxDepth, ctx, lazyDepth)\n        }\n        return undefined\n      }\n      const out = intro.unwrapPipeOut(schema)\n      const real =\n        inn !== undefined && intro.kindOf(inn) !== 'transform'\n          ? inn\n          : out !== undefined && intro.kindOf(out) !== 'transform'\n            ? out\n            : (inn ?? out)\n      return real === undefined\n        ? undefined\n        : deriveDefaultWalk(real, useDefault, intro, maxDepth, ctx, lazyDepth)\n    }\n    case 'string':\n      return ''\n    case 'number':\n      return 0\n    case 'bigint':\n      // z.bigint() strictly rejects numbers; the default must be a\n      // bigint literal. Using `0` here would fail the schema's own\n      // validation during default-values derivation.\n      return 0n\n    case 'boolean':\n      return false\n    case 'date':\n      return new Date(0)\n    case 'null':\n      return null\n    case 'undefined':\n      return undefined\n    case 'enum': {\n      const values = intro.getEnumValues(schema)\n      return values[0]\n    }\n    case 'native-enum': {\n      // v3-only. Numeric enums get reverse-mapped\n      // (`enum E { A }` → `{ A: 0, '0': 'A' }`); the valid runtime\n      // members are the keys whose VALUE'S key isn't itself a number.\n      // String enums have no reverse mapping, so every key is valid.\n      // Pick the first valid value.\n      const values = intro.getNativeEnumValues(schema)\n      if (values === undefined) return undefined\n      const validKeys = Object.keys(values).filter(\n        (k) => typeof values[values[k] as string] !== 'number'\n      )\n      if (validKeys.length === 0) return undefined\n      const first = validKeys[0]\n      return first === undefined ? undefined : values[first]\n    }\n    case 'literal': {\n      const values = intro.getLiteralValues(schema)\n      return values[0]\n    }\n    case 'nan':\n      return NaN\n    case 'lazy': {\n      // Bump the lazy counter ONLY here — structural recursion doesn't\n      // accumulate. Past the cap, return undefined so a recursive node\n      // ends in a non-fatal blank; `defaultValues` (consumer-supplied)\n      // is the authority for what the seed should be at the recursive\n      // boundary anyway.\n      if (lazyDepth >= maxDepth) return undefined\n      let inner: Schema | undefined\n      try {\n        inner = intro.unwrapLazy(schema)\n      } catch {\n        return undefined\n      }\n      return inner === undefined\n        ? undefined\n        : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth + 1)\n    }\n    case 'intersection': {\n      const left = intro.getIntersectionLeft(schema)\n      const right = intro.getIntersectionRight(schema)\n      const l =\n        left === undefined\n          ? undefined\n          : deriveDefaultWalk(left, useDefault, intro, maxDepth, ctx, lazyDepth)\n      const r =\n        right === undefined\n          ? undefined\n          : deriveDefaultWalk(right, useDefault, intro, maxDepth, ctx, lazyDepth)\n      // `mergeDeep` prefers `right` where both sides carry a plain-\n      // record value at a key, and returns `right` wholesale when\n      // either side is a leaf. Matches parse-time semantics: an\n      // intersection of `{ a }` and `{ b }` must satisfy both, so the\n      // merged shape carries both keys' defaults.\n      return mergeDeep(l, r)\n    }\n    case 'catch': {\n      // `useDefault=true` was already caught by `peelEmbeddedDefault`\n      // at the top of the walker; reaching this branch implies\n      // `useDefault=false`. The two adapters chose different\n      // semantics here and pinned the choice with tests (see the\n      // `catchOnUseDefaultFalse` docblock on `DeriveDefaultContext`).\n      if (useDefault) return intro.getCatchDefault(schema)\n      if (ctx.catchOnUseDefaultFalse === 'preserveCatch' && intro.hasCatchValue(schema)) {\n        return intro.getCatchDefault(schema)\n      }\n      const inner = intro.unwrapInner(schema)\n      return inner === undefined\n        ? undefined\n        : deriveDefaultWalk(inner, useDefault, intro, maxDepth, ctx, lazyDepth)\n    }\n    case 'file':\n      // `z.file()` has no canonical \"empty file\" — the user picks one\n      // through the directive's change handler. `null` is the storage\n      // blank value the directive canonicalises to on register / clear;\n      // emitting `null` here keeps `getEmptyValueAtPath` aligned with\n      // what `form.clear(path)` writes.\n      return null\n    case 'any':\n    case 'unknown':\n    case 'void':\n    case 'never':\n    case 'promise':\n    case 'custom':\n    case 'template-literal':\n    case 'transform':\n    case 'map':\n    case 'symbol':\n    case 'function':\n      // `promise` / `custom` / `template-literal` / `map` / `symbol` /\n      // `function` are rejected by `assertSupportedKinds` at adapter\n      // construction, so these branches are unreachable through the\n      // public surface. `transform` is the input side of a\n      // `z.preprocess(fn, inner)` and has no own default — callers\n      // walk to `inner` via the surrounding pipe / effects. Kept for\n      // exhaustive switch safety.\n      return undefined\n    default:\n      return ctx.unsupportedKindFallback(schema, kind)\n  }\n}\n","/**\n * Shared field-metadata storage. Both Zod adapters (v3 and v4) and the\n * unified `attaform/zod` entry read from the same `WeakMap`s so a\n * payload written via any entry's `withMeta` / `fieldMeta.add` is\n * visible to whichever adapter actually runs at lookup time.\n *\n * No `zod` runtime import — pure JavaScript primitives. The previous\n * v4 adapter built `fieldMeta` via `z.registry<FieldMetaPayload>()`,\n * which left a `z.registry` namespace reference reachable from\n * `attaform/zod`'s module graph; bundlers analysing a `zod@^3` consumer\n * resolved that against zod 3's exports map (no `registry` export) and\n * emitted an `IMPORT_IS_UNDEFINED` warning. Lifting storage here drops\n * that reference entirely so the unified entry behaves cleanly on any\n * Zod major.\n *\n * The native v4 chain `schema.register(fieldMeta, payload)` still\n * works against this shim — Zod 4's `.register()` only calls\n * `registry.add(this, payload)` and returns the schema; structural\n * matching is enough.\n *\n * Two parallel maps:\n * - `store` — last-write-wins single payload per schema reference.\n *   Backs `fieldMeta.get(schema)` and the adapter's\n *   `getFieldMetaAtPath` single-payload fallback.\n * - `lists` — every registration in order, per schema reference.\n *   Backs the v4 adapter's path-walker disambiguation when the same\n *   schema instance is bound at multiple form paths.\n */\n\nimport type { FieldMetaPayload } from './field-meta'\n\n/**\n * Minimal registry shape the shared store satisfies — `.add` / `.get`\n * / `.has` / `.remove`. Cast to `z.$ZodRegistry<FieldMetaPayload>` at\n * the v4 adapter's re-export so the native `schema.register(fieldMeta,\n * payload)` chain type-checks; the v3 adapter exports it as its own\n * registry-shaped surface.\n */\nexport type FieldMetaStore = {\n  add(schema: object, payload: FieldMetaPayload): FieldMetaStore\n  get(schema: object): FieldMetaPayload | undefined\n  has(schema: object): boolean\n  remove(schema: object): FieldMetaStore\n}\n\nconst store = new WeakMap<object, FieldMetaPayload>()\nconst lists = new WeakMap<object, FieldMetaPayload[]>()\n\nconst registry: FieldMetaStore = {\n  add(schema, payload) {\n    store.set(schema, payload)\n    const list = lists.get(schema) ?? []\n    list.push(payload)\n    lists.set(schema, list)\n    return registry\n  },\n  get(schema) {\n    return store.get(schema)\n  },\n  has(schema) {\n    return store.has(schema)\n  },\n  remove(schema) {\n    store.delete(schema)\n    lists.delete(schema)\n    return registry\n  },\n}\n\n/**\n * The shared registry every Attaform-aware Zod schema can register\n * field metadata against, regardless of Zod major. One module-scoped\n * instance — every adapter entry re-exports this same object so\n * writes from one entry are visible at lookup through any other.\n */\nexport const fieldMetaStore: FieldMetaStore = registry\n\n/**\n * Last-write-wins payload lookup for a schema reference. Returns\n * `undefined` if nothing has been registered.\n */\nexport function getFieldMetaForSchema(schema: object): FieldMetaPayload | undefined {\n  return store.get(schema)\n}\n\n/**\n * Read every payload registered against `schema` in registration\n * order. Empty list when nothing has been registered. Used by the v4\n * adapter's path-resolver to disambiguate per occurrence when one\n * schema instance is bound at multiple form paths.\n */\nexport function getFieldMetaListForSchema(schema: object): readonly FieldMetaPayload[] {\n  return lists.get(schema) ?? []\n}\n","/**\n * Shared slim-primitive walker — returns the set of\n * `SlimPrimitiveKind`s a schema accepts at write time. Wrappers\n * (Optional / Nullable / Default / Readonly / Catch / Pipe /\n * Pipeline / Effects / Branded / Lazy) are peeled; refinement-level\n * constraints (`.email()`, `.min(N)`, enum membership, literal\n * equality, regex) are ignored.\n *\n * Both v3 and v4 adapters dispatch through this body via their\n * `SchemaIntrospector` instance. Their per-version kind sets — v3's\n * `branded` / `effects` / `pipeline` / `native-enum`, v4's `pipe` /\n * `file` — collapse to distinct cases on the SharedZodKind switch;\n * each adapter's `kindOf` returns only the kinds it knows.\n *\n * Semantics (preserved verbatim from the prior per-adapter\n * implementations — characterised by `test/adapters/zod-v{3,4}/\n * slim-primitives.test.ts`):\n *\n *  - Leaves (string / number / boolean / bigint / date / null /\n *    undefined / void / nan) map to their kind singleton.\n *  - Enum walks values, categorising each by typeof (string / number\n *    members register their respective kinds). Empty enum falls back\n *    to string.\n *  - Literal walks values through the shared `slimKindOf` to map each\n *    value to a kind. Multi-value literals (`z.literal(['a', 1])`)\n *    register both.\n *  - Object / record → object; array / tuple → array; set → set;\n *    file → file + null (the directive's \"no file selected\"\n *    sentinel — v4 only).\n *  - Optional adds 'undefined' to the inner set; nullable adds 'null'.\n *  - Default / readonly / catch / branded peel transparently.\n *  - Pipe (v4) consults both `in` and `out`: if `in` is a transform,\n *    use `out` (the structural side of a preprocess); else prefer\n *    `in` (the source schema). Pipeline (v3) takes the `in` side.\n *  - Effects (v3) peels to the structural source.\n *  - Lazy bumps the depth counter; past the cap returns `permissive`\n *    so recursive paths beyond the cap aren't false-rejected.\n *  - Union / discriminated-union: union the option sets.\n *  - Intersection: intersect both sides (must satisfy both at parse\n *    time).\n *  - Native-enum (v3) walks values, categorising by typeof.\n *  - Never returns empty; any / unknown / unrecognised return\n *    permissive.\n */\nimport type { SchemaIntrospector } from './abstract-schema-factory'\nimport { slimKindOf } from './slim-primitive-gate'\nimport type { SlimPrimitiveKind } from '../types/types-api'\n\n// The slim-primitive permissive set — kinds the gate accepts when the\n// walker can't characterise a schema. Identical between v3 and v4 by\n// design; hosted in core for single-source-of-truth.\nexport const PERMISSIVE_SLIM_KINDS: ReadonlySet<SlimPrimitiveKind> =\n  /* @__PURE__ */ new Set<SlimPrimitiveKind>([\n    'string',\n    'number',\n    'boolean',\n    'bigint',\n    'date',\n    'null',\n    'undefined',\n    'object',\n    'array',\n    'symbol',\n    'function',\n    'map',\n    'set',\n    'file',\n  ])\n\n// Module-level frozen singletons for the leaf branches. Returning a\n// shared instance instead of `new Set([…])` per call cuts a hot\n// allocation when slim-primitives is reached through wrappers and\n// collapses the inline literal Set constructions into shared\n// references for a small bundle-size win. The walker returns\n// `ReadonlySet`; callers that need to mutate (optional / nullable /\n// union branches, and the public boundary) clone first.\nconst KIND_STRING: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['string'])\nconst KIND_NUMBER: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['number'])\nconst KIND_BOOLEAN: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['boolean'])\nconst KIND_BIGINT: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['bigint'])\nconst KIND_DATE: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['date'])\nconst KIND_NULL: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['null'])\nconst KIND_UNDEFINED: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['undefined'])\nconst KIND_OBJECT: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['object'])\nconst KIND_ARRAY: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['array'])\nconst KIND_SET: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['set'])\nconst KIND_FILE: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set(['file', 'null'])\nconst EMPTY_KINDS: ReadonlySet<SlimPrimitiveKind> = /* @__PURE__ */ new Set()\n\nexport function slimPrimitivesWalk<Schema>(\n  schema: Schema,\n  intro: SchemaIntrospector<Schema>,\n  maxDepth: number,\n  lazyDepth = 0\n): ReadonlySet<SlimPrimitiveKind> {\n  const kind = intro.kindOf(schema)\n  switch (kind) {\n    case 'string':\n      return KIND_STRING\n    case 'number':\n    case 'nan':\n      return KIND_NUMBER\n    case 'boolean':\n      return KIND_BOOLEAN\n    case 'bigint':\n      return KIND_BIGINT\n    case 'date':\n      return KIND_DATE\n    case 'file':\n      // `z.file()` accepts `File` instances at write time. `null` is\n      // also accepted at the slim-primitive level so the directive's\n      // canonical blank value (the \"no file selected\" sentinel) lands\n      // even on required-file schemas — the blank-path channel + the\n      // derived \"No value supplied\" error already gates submission, so\n      // permitting `null` storage here doesn't loosen schema enforcement.\n      return KIND_FILE\n    case 'null':\n      return KIND_NULL\n    case 'undefined':\n    case 'void':\n      return KIND_UNDEFINED\n    case 'enum': {\n      const values = intro.getEnumValues(schema)\n      const out = new Set<SlimPrimitiveKind>()\n      for (const v of values) {\n        if (typeof v === 'string') out.add('string')\n        else if (typeof v === 'number') out.add('number')\n      }\n      return out.size === 0 ? KIND_STRING : out\n    }\n    case 'native-enum': {\n      // v3 only — `z.nativeEnum(E)` exposes the reverse-mapped TS enum\n      // object on `_def.values`. Categorise each member by typeof.\n      // Numeric enums also include reverse-mapped string keys whose\n      // value is a number; both string and number kinds get registered.\n      const values = intro.getNativeEnumValues(schema)\n      if (values === undefined) return KIND_STRING\n      const out = new Set<SlimPrimitiveKind>()\n      for (const v of Object.values(values)) {\n        if (typeof v === 'string') out.add('string')\n        else if (typeof v === 'number') out.add('number')\n      }\n      return out.size === 0 ? KIND_STRING : out\n    }\n    case 'literal': {\n      const values = intro.getLiteralValues(schema)\n      const out = new Set<SlimPrimitiveKind>()\n      for (const v of values) out.add(slimKindOf(v))\n      return out.size === 0 ? PERMISSIVE_SLIM_KINDS : out\n    }\n    case 'object':\n    case 'record':\n      return KIND_OBJECT\n    case 'array':\n    case 'tuple':\n      return KIND_ARRAY\n    case 'set':\n      return KIND_SET\n    case 'optional': {\n      const inner = intro.unwrapInner(schema)\n      const innerSet =\n        inner === undefined ? EMPTY_KINDS : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth)\n      const out = new Set<SlimPrimitiveKind>(innerSet)\n      out.add('undefined')\n      return out\n    }\n    case 'nullable': {\n      const inner = intro.unwrapInner(schema)\n      const innerSet =\n        inner === undefined ? EMPTY_KINDS : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth)\n      const out = new Set<SlimPrimitiveKind>(innerSet)\n      out.add('null')\n      return out\n    }\n    case 'default':\n    case 'readonly':\n    case 'catch': {\n      const inner = intro.unwrapInner(schema)\n      return inner === undefined\n        ? PERMISSIVE_SLIM_KINDS\n        : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth)\n    }\n    case 'branded': {\n      // v3-only. Brand wrappers carry their inner on `_def.type`.\n      const inner = intro.unwrapBranded(schema)\n      return inner === undefined\n        ? PERMISSIVE_SLIM_KINDS\n        : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth)\n    }\n    case 'effects': {\n      // v3-only. ZodEffects wraps refines / transforms / preprocess;\n      // for slim-primitive purposes the structural source is the\n      // pre-transform shape (consumers write to that shape).\n      const inner = intro.unwrapEffectsSource(schema)\n      return inner === undefined\n        ? PERMISSIVE_SLIM_KINDS\n        : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth)\n    }\n    case 'pipeline': {\n      // v3-only. Take the input side.\n      const inner = intro.unwrapPipeIn(schema)\n      return inner === undefined\n        ? PERMISSIVE_SLIM_KINDS\n        : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth)\n    }\n    case 'pipe': {\n      // v4-only. `z.preprocess(fn, inner)` and `z.coerce.X()`\n      // (pipe-with-transform-on-input) and `inner.transform(fn)`\n      // (transform-on-output) all serialise as ZodPipe, but the\n      // \"storage shape\" lives on opposite sides. For preprocess /\n      // coerce, the input side IS the transform (shapeless,\n      // PERMISSIVE) and the inner schema sits on the output. For\n      // `.transform`, the input side is the source schema. Pick the\n      // non-transform side so `isLeafAtPath` and the directive coerce\n      // target both resolve against a real shape.\n      const pipeIn = intro.unwrapPipeIn(schema)\n      const pipeOut = intro.unwrapPipeOut(schema)\n      const inner =\n        pipeIn !== undefined && intro.kindOf(pipeIn) === 'transform' ? pipeOut : (pipeIn ?? pipeOut)\n      return inner === undefined\n        ? PERMISSIVE_SLIM_KINDS\n        : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth)\n    }\n    case 'lazy': {\n      // Bump on lazy crossing only; past the cap, fall back to\n      // permissive so recursive paths beyond the cap aren't gated.\n      if (lazyDepth >= maxDepth) return PERMISSIVE_SLIM_KINDS\n      const inner = intro.unwrapLazy(schema)\n      return inner === undefined\n        ? PERMISSIVE_SLIM_KINDS\n        : slimPrimitivesWalk(inner, intro, maxDepth, lazyDepth + 1)\n    }\n    case 'union':\n    case 'discriminated-union': {\n      // Both adapters store DU options on `def.options` too, so\n      // `getUnionOptions` works for either kind.\n      const options = intro.getUnionOptions(schema)\n      const out = new Set<SlimPrimitiveKind>()\n      for (const opt of options) {\n        for (const k of slimPrimitivesWalk(opt, intro, maxDepth, lazyDepth)) out.add(k)\n      }\n      return out.size === 0 ? PERMISSIVE_SLIM_KINDS : out\n    }\n    case 'intersection': {\n      const left = intro.getIntersectionLeft(schema)\n      const right = intro.getIntersectionRight(schema)\n      const leftSet =\n        left === undefined\n          ? PERMISSIVE_SLIM_KINDS\n          : slimPrimitivesWalk(left, intro, maxDepth, lazyDepth)\n      const rightSet =\n        right === undefined\n          ? PERMISSIVE_SLIM_KINDS\n          : slimPrimitivesWalk(right, intro, maxDepth, lazyDepth)\n      const out = new Set<SlimPrimitiveKind>()\n      for (const k of leftSet) if (rightSet.has(k)) out.add(k)\n      return out\n    }\n    case 'never':\n      return EMPTY_KINDS\n    case 'any':\n    case 'unknown':\n      return PERMISSIVE_SLIM_KINDS\n    // Opaque / unsupported kinds: be permissive so legitimate writes\n    // aren't false-rejected. The unsupported kinds (`map` / `symbol` /\n    // `function` / `promise`) are rejected at adapter construction by\n    // `assertSupportedKinds`; this fallthrough keeps the walker\n    // defensive in case construction is skipped.\n    default:\n      return PERMISSIVE_SLIM_KINDS\n  }\n}\n","import type { SchemaIntrospector } from './abstract-schema-factory'\nimport type { FieldMetaPayload } from './field-meta'\nimport { canonicalizePath, type Path, type PathKey } from './paths'\n\n/**\n * Version-specific primitives the field-meta walk consumes. Both\n * adapters already expose all three:\n *\n *   - `intro` — the adapter's `SchemaIntrospector` (kind discriminant +\n *     structural accessors + wrapper unwraps). The walk dispatches on\n *     `intro.kindOf`, which differs per version (v3 returns\n *     `effects` / `pipeline` / `branded`; v4 returns `pipe` / `transform`),\n *     so the switch below handles both vocabularies.\n *   - `peelAllWrappers` — the catch-peeling structural peel\n *     (`peelAllV3Wrappers` on v3, `peelAllWrappers` on v4). Used to reach\n *     a registration that sits on the inner before wrapping, e.g.\n *     `withMeta(z.string(), {...}).optional()`.\n *   - `getFieldMetaList` — reads the adapter's per-instance registration\n *     list. The registry is adapter-local (keyed by schema instance), so\n *     it can't be a shared import.\n *\n * All required: the walk has no sensible default for any of them.\n */\nexport interface FieldMetaWalkServices<Schema> {\n  intro: SchemaIntrospector<Schema>\n  peelAllWrappers: (schema: Schema) => Schema\n  getFieldMetaList: (schema: Schema) => readonly FieldMetaPayload[]\n}\n\n// Per-rootSchema cache of path -> payload maps, shared across adapters.\n// Build is a single tree-walk; lookups are O(1) thereafter. Keyed on the\n// root schema instance (a given instance belongs to exactly one Zod\n// version, so v3 and v4 roots never collide) so entries GC with the form.\nconst pathMetaCache = new WeakMap<object, Map<PathKey, FieldMetaPayload>>()\n\n/**\n * Build the path -> field-meta-payload map for `rootSchema` by walking\n * the schema tree once. Both adapters' `resolveFieldMetaAtPath` delegate\n * here so the path-keyed disambiguation of shared schemas registered at\n * multiple paths lives in one place.\n *\n * After the walk, \"surplus\" registrations get absorbed into the schema's\n * last-visited path — covers chains like\n * `withMeta(s, {label}).register(fieldMeta, {desc})` where one path\n * consumes list[0] and list[1] would otherwise go unread.\n */\nexport function getFieldMetaPathMap<Schema extends object>(\n  rootSchema: Schema,\n  services: FieldMetaWalkServices<Schema>\n): Map<PathKey, FieldMetaPayload> {\n  const cached = pathMetaCache.get(rootSchema)\n  if (cached !== undefined) return cached\n  const map = new Map<PathKey, FieldMetaPayload>()\n  const counters = new Map<Schema, number>()\n  const lastPathPerSchema = new Map<Schema, PathKey>()\n  const inProgress = new WeakSet<object>()\n  walkForMeta(rootSchema, [], map, counters, lastPathPerSchema, inProgress, services)\n  for (const [schema, lastPath] of lastPathPerSchema) {\n    const list = services.getFieldMetaList(schema)\n    const consumed = counters.get(schema) ?? 0\n    if (list.length <= consumed) continue\n    const surplus = list\n      .slice(consumed)\n      .reduce<FieldMetaPayload>((acc, p) => ({ ...acc, ...p }), {})\n    const existing = map.get(lastPath) ?? {}\n    map.set(lastPath, { ...existing, ...surplus })\n  }\n  pathMetaCache.set(rootSchema, map)\n  return map\n}\n\n/**\n * Pull a payload off `schema`'s registration list, counter-indexed so a\n * schema registered at multiple paths pairs each visit with the next\n * payload in declaration order. Clamp to the last entry — schemas reused\n * MORE times than they're registered (e.g. an array element registered\n * once, visited per-index) all share the single registration.\n */\nfunction consumePayload<Schema>(\n  schema: Schema,\n  counters: Map<Schema, number>,\n  getFieldMetaList: (schema: Schema) => readonly FieldMetaPayload[]\n): FieldMetaPayload | undefined {\n  const list = getFieldMetaList(schema)\n  if (list.length === 0) return undefined\n  const idx = counters.get(schema) ?? 0\n  const payload = list[Math.min(idx, list.length - 1)]\n  counters.set(schema, idx + 1)\n  return payload\n}\n\n/**\n * Walk the schema tree from `schema`, emitting a payload for each path\n * that has registered metadata. Visits the schema first (terminal-position\n * registration), then the peeled inner if different (inner-then-wrap\n * registration). At each point the FIRST list-payload found wins for that\n * path. `inProgress` bounds recursive `z.lazy(...)` cycles.\n */\nfunction walkForMeta<Schema extends object>(\n  schema: Schema,\n  path: Path,\n  map: Map<PathKey, FieldMetaPayload>,\n  counters: Map<Schema, number>,\n  lastPathPerSchema: Map<Schema, PathKey>,\n  inProgress: WeakSet<object>,\n  services: FieldMetaWalkServices<Schema>\n): void {\n  if (inProgress.has(schema)) return\n  inProgress.add(schema)\n  try {\n    const { intro, peelAllWrappers, getFieldMetaList } = services\n    const pathKey = canonicalizePath(path).key\n    if (!map.has(pathKey)) {\n      const payload = consumePayload(schema, counters, getFieldMetaList)\n      if (payload !== undefined) {\n        map.set(pathKey, payload)\n        lastPathPerSchema.set(schema, pathKey)\n      }\n    }\n    const peeled = peelAllWrappers(schema)\n    if (peeled !== schema && !map.has(pathKey)) {\n      const payload = consumePayload(peeled, counters, getFieldMetaList)\n      if (payload !== undefined) {\n        map.set(pathKey, payload)\n        lastPathPerSchema.set(peeled, pathKey)\n      }\n    }\n    // Descend by kind. The switch handles both adapters' kind\n    // vocabularies; unhandled and leaf kinds fall through to `default`\n    // and stop (their own metadata was captured above).\n    const kind = intro.kindOf(schema)\n    switch (kind) {\n      case 'object': {\n        for (const [key, child] of Object.entries(intro.getObjectShape(schema))) {\n          walkForMeta(child, [...path, key], map, counters, lastPathPerSchema, inProgress, services)\n        }\n        return\n      }\n      case 'array': {\n        const inner = intro.getArrayElement(schema)\n        if (inner !== undefined)\n          walkForMeta(inner, [...path, 0], map, counters, lastPathPerSchema, inProgress, services)\n        return\n      }\n      case 'tuple': {\n        const items = intro.getTupleItems(schema)\n        for (let i = 0; i < items.length; i++) {\n          const item = items[i]\n          if (item !== undefined)\n            walkForMeta(item, [...path, i], map, counters, lastPathPerSchema, inProgress, services)\n        }\n        return\n      }\n      case 'set': {\n        const inner = intro.getSetValueType(schema)\n        if (inner !== undefined)\n          walkForMeta(inner, [...path, 0], map, counters, lastPathPerSchema, inProgress, services)\n        return\n      }\n      case 'record': {\n        const inner = intro.getRecordValueType(schema)\n        if (inner !== undefined)\n          walkForMeta(inner, [...path, '*'], map, counters, lastPathPerSchema, inProgress, services)\n        return\n      }\n      case 'union': {\n        for (const opt of intro.getUnionOptions(schema)) {\n          walkForMeta(opt, path, map, counters, lastPathPerSchema, inProgress, services)\n        }\n        return\n      }\n      case 'discriminated-union': {\n        for (const opt of intro.getDiscriminatedOptions(schema)) {\n          walkForMeta(opt, path, map, counters, lastPathPerSchema, inProgress, services)\n        }\n        return\n      }\n      case 'optional':\n      case 'nullable':\n      case 'default':\n      case 'readonly':\n      case 'catch': {\n        const inner = intro.unwrapInner(schema)\n        if (inner !== undefined)\n          walkForMeta(inner, path, map, counters, lastPathPerSchema, inProgress, services)\n        return\n      }\n      case 'pipe':\n      case 'pipeline': {\n        const inner = intro.unwrapPipeIn(schema)\n        if (inner !== undefined)\n          walkForMeta(inner, path, map, counters, lastPathPerSchema, inProgress, services)\n        return\n      }\n      case 'effects': {\n        const inner = intro.unwrapEffectsSource(schema)\n        if (inner !== undefined)\n          walkForMeta(inner, path, map, counters, lastPathPerSchema, inProgress, services)\n        return\n      }\n      case 'branded': {\n        const inner = intro.unwrapBranded(schema)\n        if (inner !== undefined)\n          walkForMeta(inner, path, map, counters, lastPathPerSchema, inProgress, services)\n        return\n      }\n      case 'lazy': {\n        // A throwing lazy getter (a recursive cycle resolved before its\n        // target is constructed) must not crash form setup. v3's\n        // unwrapLazy already swallows it; the try guards v4's, which\n        // rethrows. Either way the inProgress check bounds a true cycle.\n        try {\n          const inner = intro.unwrapLazy(schema)\n          if (inner !== undefined)\n            walkForMeta(inner, path, map, counters, lastPathPerSchema, inProgress, services)\n        } catch {\n          // Treat an unresolvable lazy as a leaf.\n        }\n        return\n      }\n      case 'intersection': {\n        const left = intro.getIntersectionLeft(schema)\n        const right = intro.getIntersectionRight(schema)\n        if (left !== undefined)\n          walkForMeta(left, path, map, counters, lastPathPerSchema, inProgress, services)\n        if (right !== undefined)\n          walkForMeta(right, path, map, counters, lastPathPerSchema, inProgress, services)\n        return\n      }\n      default:\n        return\n    }\n  } finally {\n    inProgress.delete(schema)\n  }\n}\n"],"names":["out"],"mappings":";;;AAkDA,MAAM,cAAA,GAAiB,GAAA;AAqXhB,SAAS,oBAAA,CACd,UAAA,EACA,KAAA,EACA,QAAA,EACA,SACA,OAAA,EACwC;AACxC,EAAA,MAAM,oBAAoB,OAAA,CAAQ,iBAAA;AAMlC,EAAA,MAAM,SAAA,uBAAgB,GAAA,EAAsB;AAC5C,EAAA,MAAM,uBAAA,uBAA8B,GAAA,EAAsB;AAC1D,EAAA,MAAM,kBAAA,uBAAyB,GAAA,EAAoD;AAKnF,EAAA,IAAI,mBAAA,GAAsC,IAAA;AAC1C,EAAA,IAAI,mBAAA,GAAsC,IAAA;AAE1C,EAAA,SAAS,qBAAqB,IAAA,EAAmD;AAC/E,IAAA,MAAM,UAAA,GACJ,IAAA,CAAK,MAAA,KAAW,CAAA,GACZ,CAAC,UAAU,CAAA,GACX,QAAA,CAAS,sBAAA,CAAuB,UAAA,EAAY,IAAA,EAAM,iBAAiB,CAAA;AAOzE,IAAA,IAAI,YAAA;AACJ,IAAA,KAAA,MAAW,aAAa,UAAA,EAAY;AAClC,MAAA,MAAM,EAAA,GAAK,QAAA,CAAS,0BAAA,CAA2B,SAAS,CAAA;AACxD,MAAA,IAAI,OAAO,MAAA,EAAW;AACtB,MAAA,IAAI,YAAA,KAAiB,MAAA,IAAa,YAAA,KAAiB,EAAA,EAAI,OAAO,MAAA;AAC9D,MAAA,YAAA,GAAe,EAAA;AAAA,IACjB;AACA,IAAA,IAAI,YAAA,KAAiB,QAAW,OAAO,MAAA;AACvC,IAAA,MAAM,OAAA,GAAU,KAAA,CAAM,gBAAA,CAAiB,YAAY,CAAA;AACnD,IAAA,IAAI,OAAA,KAAY,QAAW,OAAO,MAAA;AAClC,IAAA,MAAM,YAAA,GAAe,KAAA,CAAM,uBAAA,CAAwB,YAAY,CAAA;AAC/D,IAAA,MAAM,UAAA,uBAAiB,GAAA,EAAa;AACpC,IAAA,KAAA,MAAW,OAAO,YAAA,EAAc;AAC9B,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,cAAA,CAAe,GAAG,CAAA;AACtC,MAAA,MAAM,SAAA,GAAY,MAAM,OAAO,CAAA;AAC/B,MAAA,IAAI,cAAc,MAAA,EAAW;AAC7B,MAAA,IAAI,KAAA,CAAM,MAAA,CAAO,SAAS,CAAA,KAAM,SAAA,EAAW;AAG3C,MAAA,KAAA,MAAW,KAAK,KAAA,CAAM,gBAAA,CAAiB,SAAS,CAAA,EAAG,UAAA,CAAW,IAAI,CAAC,CAAA;AAAA,IACrE;AACA,IAAA,OAAO;AAAA,MACL,gBAAA,EAAkB,OAAA;AAAA,MAClB,kBAAkB,KAAA,EAAyB;AACzC,QAAA,KAAA,MAAW,OAAO,YAAA,EAAc;AAC9B,UAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,cAAA,CAAe,GAAG,CAAA;AACtC,UAAA,MAAM,SAAA,GAAY,MAAM,OAAO,CAAA;AAC/B,UAAA,IAAI,cAAc,MAAA,EAAW;AAC7B,UAAA,IAAI,KAAA,CAAM,MAAA,CAAO,SAAS,CAAA,KAAM,SAAA,EAAW;AAC3C,UAAA,MAAM,aAAA,GAAgB,KAAA,CAAM,gBAAA,CAAiB,SAAS,CAAA;AACtD,UAAA,IAAI,aAAA,CAAc,QAAA,CAAS,KAAK,CAAA,EAAG;AACjC,YAAA,OAAO,QAAA,CAAS,aAAA,CAAc,GAAA,EAAK,IAAA,EAAM,mBAAmB,OAAO,CAAA;AAAA,UACrE;AAAA,QACF;AACA,QAAA,OAAO,MAAA;AAAA,MACT,CAAA;AAAA,MACA,kBAAkB,KAAA,EAAyB;AACzC,QAAA,OAAO,UAAA,CAAW,IAAI,KAAK,CAAA;AAAA,MAC7B;AAAA,KACF;AAAA,EACF;AAEA,EAAA,MAAM,cAAA,GAAyD;AAAA,IAC7D,WAAA,EAAa,MAAM,QAAA,CAAS,WAAA,CAAY,UAAU,CAAA;AAAA,IAElD,oBAAA,GAAgC;AAC9B,MAAA,mBAAA,KAAA,mBAAA,GACE,MAAM,mBAAA,CAAoB,UAAU,CAAA,IAAK,KAAA,CAAM,uBAAuB,UAAU,CAAA,CAAA;AAClF,MAAA,OAAO,mBAAA;AAAA,IACT,CAAA;AAAA,IAEA,wBAAA,GAAoC;AAClC,MAAA,mBAAA,KAAA,mBAAA,GAAwB,KAAA,CAAM,yBAAyB,UAAU,CAAA,CAAA;AACjE,MAAA,OAAO,mBAAA;AAAA,IACT,CAAA;AAAA,IAEA,iBAAiB,MAAA,EAAmE;AAClF,MAAA,OAAO,QAAA,CAAS,oBAAA,CAAqB,UAAA,EAAY,MAAA,EAAQ,SAAS,iBAAiB,CAAA;AAAA,IACrF,CAAA;AAAA,IAEA,iBAAiB,IAAA,EAAM;AAGrB,MAAA,IAAI,IAAA,CAAK,WAAW,CAAA,EAAG;AACrB,QAAA,OAAO,QAAA,CAAS,aAAA,CAAc,UAAA,EAAY,IAAA,EAAM,mBAAmB,OAAO,CAAA;AAAA,MAC5E;AACA,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,SAAS,sBAAA,CAAuB,UAAA,EAAY,MAAM,iBAAiB,CAAA;AACnF,MAAA,IAAI,KAAA,KAAU,QAAW,OAAO,MAAA;AAOhC,MAAA,MAAM,MAAA,GAAS,QAAA,CAAS,wBAAA,CAAyB,KAAK,CAAA;AACtD,MAAA,OAAO,QAAA,CAAS,aAAA,CAAc,MAAA,EAAQ,IAAA,EAAM,mBAAmB,OAAO,CAAA;AAAA,IACxE,CAAA;AAAA,IAEA,oBAAoB,IAAA,EAAM;AAQxB,MAAA,IAAI,IAAA,CAAK,WAAW,CAAA,EAAG;AACrB,QAAA,OAAO,QAAA,CAAS,aAAA,CAAc,UAAA,EAAY,KAAA,EAAO,mBAAmB,OAAO,CAAA;AAAA,MAC7E;AACA,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,SAAS,sBAAA,CAAuB,UAAA,EAAY,MAAM,iBAAiB,CAAA;AACnF,MAAA,IAAI,KAAA,KAAU,QAAW,OAAO,MAAA;AAChC,MAAA,OAAO,QAAA,CAAS,aAAA,CAAc,KAAA,EAAO,KAAA,EAAO,mBAAmB,OAAO,CAAA;AAAA,IACxE,CAAA;AAAA,IAEA,iBAAiB,IAAA,EAAM;AACrB,MAAA,IAAI,IAAA,CAAK,MAAA,KAAW,CAAA,EAAG,OAAO,MAAA;AAC9B,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,SAAS,sBAAA,CAAuB,UAAA,EAAY,MAAM,iBAAiB,CAAA;AACnF,MAAA,IAAI,KAAA,KAAU,QAAW,OAAO,MAAA;AAChC,MAAA,MAAM,MAAA,GAAS,QAAA,CAAS,eAAA,CAAgB,KAAK,CAAA;AAC7C,MAAA,MAAM,IAAA,GAAO,KAAA,CAAM,MAAA,CAAO,MAAM,CAAA;AAChC,MAAA,IAAI,SAAS,OAAA,EAAS,OAAO,KAAA,CAAM,aAAA,CAAc,MAAM,CAAA,CAAE,MAAA;AACzD,MAAA,IAAI,IAAA,KAAS,SAAS,OAAO,IAAA;AAC7B,MAAA,OAAO,MAAA;AAAA,IACT,CAAA;AAAA,IAEA,oBAAoB,IAAA,EAAM;AAExB,MAAA,IAAI,IAAA,CAAK,MAAA,KAAW,CAAA,EAAG,OAAO,IAAA;AAC9B,MAAA,MAAM,QAAA,GAAW,QAAA,CAAS,sBAAA,CAAuB,UAAA,EAAY,MAAM,iBAAiB,CAAA;AAGpF,MAAA,IAAI,QAAA,CAAS,MAAA,KAAW,CAAA,EAAG,OAAO,KAAA;AASlC,MAAA,OAAO,QAAA,CAAS,KAAA,CAAM,CAAC,CAAA,KAAM,KAAA,CAAM,MAAA,CAAO,QAAA,CAAS,eAAA,CAAgB,CAAC,CAAC,CAAA,KAAM,QAAQ,CAAA;AAAA,IACrF,CAAA;AAAA,IAEA,iBAAiB,IAAA,EAAM;AAOrB,MAAA,MAAM,QAAA,GAAW,QAAA,CAAS,0BAAA,CAA2B,UAAA,EAAY,MAAM,iBAAiB,CAAA;AAIxF,MAAA,IAAI,QAAA,CAAS,MAAA,KAAW,CAAA,EAAG,OAAO,EAAC;AACnC,MAAA,OAAO,QAAA,CAAS,IAAI,CAAC,GAAA,KAAQ,SAAS,aAAA,CAAc,GAAA,EAAK,OAAA,EAAS,iBAAiB,CAAC,CAAA;AAAA,IACtF,CAAA;AAAA,IAEA,4BAA4B,IAAA,EAA8B;AAExD,MAAA,IAAI,IAAA,CAAK,WAAW,CAAA,EAAG,2BAAW,GAAA,CAAuB,CAAC,QAAQ,CAAC,CAAA;AACnE,MAAA,MAAM,QAAA,GAAW,QAAA,CAAS,0BAAA,CAA2B,UAAA,EAAY,MAAM,iBAAiB,CAAA;AAIxF,MAAA,IAAI,QAAA,CAAS,MAAA,KAAW,CAAA,EAAG,2BAAW,GAAA,EAAuB;AAC7D,MAAA,MAAM,GAAA,uBAAU,GAAA,EAAuB;AACvC,MAAA,KAAA,MAAW,aAAa,QAAA,EAAU;AAChC,QAAA,KAAA,MAAW,CAAA,IAAK,QAAA,CAAS,gBAAA,CAAiB,SAAA,EAAW,iBAAiB,CAAA,EAAG;AACvE,UAAA,GAAA,CAAI,IAAI,CAAC,CAAA;AAAA,QACX;AAAA,MACF;AACA,MAAA,OAAO,GAAA;AAAA,IACT,CAAA;AAAA,IAEA,aAAa,IAAA,EAAe;AAC1B,MAAA,MAAM,QAAA,GAAW,gBAAA,CAAiB,IAAI,CAAA,CAAE,GAAA;AACxC,MAAA,MAAM,MAAA,GAAS,SAAA,CAAU,GAAA,CAAI,QAAQ,CAAA;AACrC,MAAA,IAAI,MAAA,KAAW,QAAW,OAAO,MAAA;AACjC,MAAA,MAAM,IAAA,GAAO,IAAA,CAAK,2BAAA,CAA4B,IAAI,CAAA;AAKlD,MAAA,MAAM,MAAA,GACJ,KAAK,IAAA,GAAO,CAAA,IACZ,CAAC,IAAA,CAAK,GAAA,CAAI,QAAQ,CAAA,IAClB,CAAC,IAAA,CAAK,IAAI,OAAO,CAAA,IACjB,CAAC,IAAA,CAAK,GAAA,CAAI,KAAK,CAAA,IACf,CAAC,IAAA,CAAK,GAAA,CAAI,KAAK,CAAA;AACjB,MAAA,SAAA,CAAU,GAAA,CAAI,UAAU,MAAM,CAAA;AAC9B,MAAA,OAAO,MAAA;AAAA,IACT,CAAA;AAAA,IAEA,yBAAyB,IAAA,EAAe;AAMtC,MAAA,MAAM,QAAA,GAAW,gBAAA,CAAiB,IAAI,CAAA,CAAE,GAAA;AACxC,MAAA,MAAM,MAAA,GAAS,uBAAA,CAAwB,GAAA,CAAI,QAAQ,CAAA;AACnD,MAAA,IAAI,MAAA,KAAW,QAAW,OAAO,MAAA;AACjC,MAAA,IAAI,GAAA,GAAM,KAAA;AACV,MAAA,KAAA,IAAS,IAAI,CAAA,EAAG,CAAA,IAAK,KAAK,MAAA,IAAU,CAAC,KAAK,CAAA,EAAA,EAAK;AAC7C,QAAA,MAAM,MAAA,GAAS,IAAA,CAAK,KAAA,CAAM,CAAA,EAAG,CAAC,CAAA;AAC9B,QAAA,MAAM,UAAA,GACJ,MAAA,CAAO,MAAA,KAAW,CAAA,GACd,CAAC,UAAU,CAAA,GACX,QAAA,CAAS,sBAAA,CAAuB,UAAA,EAAY,MAAA,EAAQ,iBAAiB,CAAA;AAC3E,QAAA,KAAA,MAAW,aAAa,UAAA,EAAY;AAClC,UAAA,IAAI,MAAM,iBAAA,CAAkB,SAAS,KAAK,KAAA,CAAM,gBAAA,CAAiB,SAAS,CAAA,EAAG;AAC3E,YAAA,GAAA,GAAM,IAAA;AACN,YAAA;AAAA,UACF;AAAA,QACF;AAAA,MACF;AACA,MAAA,uBAAA,CAAwB,GAAA,CAAI,UAAU,GAAG,CAAA;AACzC,MAAA,OAAO,GAAA;AAAA,IACT,CAAA;AAAA,IAEA,iBAAiB,IAAA,EAAe;AAI9B,MAAA,IAAI,IAAA,CAAK,MAAA,KAAW,CAAA,EAAG,OAAO,IAAA;AAC9B,MAAA,MAAM,QAAA,GAAW,QAAA,CAAS,sBAAA,CAAuB,UAAA,EAAY,MAAM,iBAAiB,CAAA;AACpF,MAAA,IAAI,QAAA,CAAS,MAAA,KAAW,CAAA,EAAG,OAAO,KAAA;AAIlC,MAAA,OAAO,SAAS,KAAA,CAAM,CAAC,cAAc,QAAA,CAAS,cAAA,CAAe,SAAS,CAAC,CAAA;AAAA,IACzE,CAAA;AAAA,IAEA,mBAAmB,IAAA,EAAyB;AAC1C,MAAA,OAAO,QAAA,CAAS,sBAAA,CAAuB,UAAA,EAAY,IAAA,EAAM,iBAAiB,CAAA;AAAA,IAC5E,CAAA;AAAA,IAEA,4BAA4B,IAAA,EAA6C;AACvE,MAAA,MAAM,QAAA,GAAW,gBAAA,CAAiB,IAAI,CAAA,CAAE,GAAA;AACxC,MAAA,IAAI,kBAAA,CAAmB,GAAA,CAAI,QAAQ,CAAA,EAAG;AACpC,QAAA,OAAO,kBAAA,CAAmB,IAAI,QAAQ,CAAA;AAAA,MACxC;AACA,MAAA,MAAM,MAAA,GAAS,qBAAqB,IAAI,CAAA;AACxC,MAAA,kBAAA,CAAmB,GAAA,CAAI,UAAU,MAAM,CAAA;AACvC,MAAA,OAAO,MAAA;AAAA,IACT,CAAA;AAAA,IAEA,cAAA,CACE,IAAA,EACA,IAAA,EACA,eAAA,EACsE;AAMtE,MAAA,MAAM,OAAA,GAAU,iBAAiB,IAAA,KAAS,IAAA;AAC1C,MAAA,IAAI,OAAA,EAAS;AACX,QAAA,IAAI;AACF,UAAA,OAAO,OAAA,EAAQ;AAAA,QACjB,CAAA,CAAA,MAAQ;AAAA,QAER;AAAA,MACF;AACA,MAAA,OAAO,QAAA,EAAS;AAEhB,MAAA,SAAS,OAAA,GAAgD;AACvD,QAAA,IAAI,SAAS,MAAA,EAAW;AACtB,UAAA,MAAM,MAAA,GAAS,QAAA,CAAS,aAAA,CAAc,UAAA,EAAY,IAAI,CAAA;AACtD,UAAA,OAAO,OAAO,OAAA,GACV;AAAA,YACE,MAAM,MAAA,CAAO,IAAA;AAAA,YACb,MAAA,EAAQ,MAAA;AAAA,YACR,OAAA,EAAS,IAAA;AAAA,YACT;AAAA,WACF,GACA;AAAA,YACE,IAAA,EAAM,MAAA;AAAA,YACN,MAAA,EAAQ,QAAA,CAAS,wBAAA,CAAyB,MAAA,CAAO,QAAQ,OAAO,CAAA;AAAA,YAChE,OAAA,EAAS,KAAA;AAAA,YACT;AAAA,WACF;AAAA,QACN;AACA,QAAA,MAAM,QAAA,GAAW,QAAA,CAAS,sBAAA,CAAuB,UAAA,EAAY,MAAM,iBAAiB,CAAA;AACpF,QAAA,IAAI,QAAA,CAAS,MAAA,KAAW,CAAA,EAAG,OAAO,aAAa,IAAI,CAAA;AACnD,QAAA,MAAM,aAAgC,EAAC;AACvC,QAAA,KAAA,MAAW,aAAa,QAAA,EAAU;AAChC,UAAA,MAAM,MAAA,GAAS,QAAA,CAAS,aAAA,CAAc,SAAA,EAAW,IAAI,CAAA;AACrD,UAAA,IAAI,OAAO,OAAA,EAAS;AAClB,YAAA,OAAO;AAAA,cACL,MAAM,MAAA,CAAO,IAAA;AAAA,cACb,MAAA,EAAQ,MAAA;AAAA,cACR,OAAA,EAAS,IAAA;AAAA,cACT;AAAA,aACF;AAAA,UACF;AACA,UAAA,UAAA,CAAW,KAAK,GAAG,QAAA,CAAS,yBAAyB,MAAA,CAAO,MAAA,EAAQ,OAAO,CAAC,CAAA;AAAA,QAC9E;AACA,QAAA,OAAO,EAAE,IAAA,EAAM,MAAA,EAAW,QAAQ,UAAA,EAAY,OAAA,EAAS,OAAO,OAAA,EAAQ;AAAA,MACxE;AAEA,MAAA,eAAe,QAAA,GAA0D;AACvE,QAAA,IAAI,SAAS,MAAA,EAAW;AACtB,UAAA,IAAI,MAAA;AACJ,UAAA,IAAI;AACF,YAAA,MAAA,GAAS,MAAM,QAAA,CAAS,cAAA,CAAe,UAAA,EAAY,IAAI,CAAA;AAAA,UACzD,SAAS,GAAA,EAAK;AACZ,YAAA,OAAO,sBAAA,CAAuB,GAAA,EAAK,EAAE,CAAA;AAAA,UACvC;AACA,UAAA,OAAO,OAAO,OAAA,GACV;AAAA,YACE,MAAM,MAAA,CAAO,IAAA;AAAA,YACb,MAAA,EAAQ,MAAA;AAAA,YACR,OAAA,EAAS,IAAA;AAAA,YACT;AAAA,WACF,GACA;AAAA,YACE,IAAA,EAAM,MAAA;AAAA,YACN,MAAA,EAAQ,QAAA,CAAS,wBAAA,CAAyB,MAAA,CAAO,QAAQ,OAAO,CAAA;AAAA,YAChE,OAAA,EAAS,KAAA;AAAA,YACT;AAAA,WACF;AAAA,QACN;AACA,QAAA,MAAM,QAAA,GAAW,QAAA,CAAS,sBAAA,CAAuB,UAAA,EAAY,MAAM,iBAAiB,CAAA;AACpF,QAAA,IAAI,QAAA,CAAS,MAAA,KAAW,CAAA,EAAG,OAAO,aAAa,IAAI,CAAA;AAGnD,QAAA,MAAM,aAAgC,EAAC;AACvC,QAAA,KAAA,MAAW,aAAa,QAAA,EAAU;AAChC,UAAA,IAAI,MAAA;AACJ,UAAA,IAAI;AACF,YAAA,MAAA,GAAS,MAAM,QAAA,CAAS,cAAA,CAAe,SAAA,EAAW,IAAI,CAAA;AAAA,UACxD,SAAS,GAAA,EAAK;AACZ,YAAA,OAAO,sBAAA,CAAuB,KAAK,IAAI,CAAA;AAAA,UACzC;AACA,UAAA,IAAI,OAAO,OAAA,EAAS;AAClB,YAAA,OAAO;AAAA,cACL,MAAM,MAAA,CAAO,IAAA;AAAA,cACb,MAAA,EAAQ,MAAA;AAAA,cACR,OAAA,EAAS,IAAA;AAAA,cACT;AAAA,aACF;AAAA,UACF;AACA,UAAA,UAAA,CAAW,KAAK,GAAG,QAAA,CAAS,yBAAyB,MAAA,CAAO,MAAA,EAAQ,OAAO,CAAC,CAAA;AAAA,QAC9E;AACA,QAAA,OAAO,EAAE,IAAA,EAAM,MAAA,EAAW,QAAQ,UAAA,EAAY,OAAA,EAAS,OAAO,OAAA,EAAQ;AAAA,MACxE;AAWA,MAAA,SAAS,sBAAA,CACP,KACA,OAAA,EACsC;AACtC,QAAA,MAAM,OAAA,GACJ,eAAe,KAAA,GAAQ,GAAA,CAAI,UAAU,OAAO,GAAA,KAAQ,WAAW,GAAA,GAAM,iBAAA;AACvE,QAAA,OAAO;AAAA,UACL,IAAA,EAAM,MAAA;AAAA,UACN,MAAA,EAAQ;AAAA,YACN;AAAA,cACE,OAAA;AAAA,cACA,IAAA,EAAM,CAAC,GAAG,OAAO,CAAA;AAAA,cACjB,OAAA;AAAA,cACA,MAAM,iBAAA,CAAkB;AAAA;AAC1B,WACF;AAAA,UACA,OAAA,EAAS,KAAA;AAAA,UACT;AAAA,SACF;AAAA,MACF;AAEA,MAAA,SAAS,aAAa,CAAA,EAA+C;AACnE,QAAA,OAAO;AAAA,UACL,IAAA,EAAM,MAAA;AAAA,UACN,MAAA,EAAQ;AAAA,YACN;AAAA,cACE,OAAA,EAAS,CAAA,MAAA,EAAS,CAAA,CAAE,IAAA,CAAK,cAAc,CAAC,CAAA,+BAAA,CAAA;AAAA,cACxC,IAAA,EAAM,CAAC,GAAG,CAAC,CAAA;AAAA,cACX,OAAA;AAAA,cACA,MAAM,iBAAA,CAAkB;AAAA;AAC1B,WACF;AAAA,UACA,OAAA,EAAS,KAAA;AAAA,UACT;AAAA,SACF;AAAA,MACF;AAAA,IACF;AAAA,GACF;AAEA,EAAA,OAAO,cAAA;AACT;;AC7yBO,SAAS,SAAA,CAAU,MAAe,QAAA,EAA4B;AACnE,EAAA,IAAI,QAAA,KAAa,QAAW,OAAO,IAAA;AACnC,EAAA,IAAI,CAAC,aAAA,CAAc,QAAQ,CAAA,EAAG,OAAO,QAAA;AACrC,EAAA,IAAI,CAAC,aAAA,CAAc,IAAI,CAAA,EAAG,OAAO,QAAA;AAiBjC,EAAA,MAAM,MAAA,GAAkC,EAAE,GAAG,IAAA,EAAK;AAClD,EAAA,KAAA,MAAW,GAAA,IAAO,MAAA,CAAO,IAAA,CAAK,QAAQ,CAAA,EAAG;AACvC,IAAA,MAAM,IAAA,GAAO,WAAA,CAAY,QAAA,EAAU,GAAG,CAAA;AACtC,IAAA,MAAM,IAAA,GAAO,WAAA,CAAY,IAAA,EAAM,GAAG,CAAA;AAClC,IAAA,IAAI,aAAA,CAAc,IAAI,CAAA,IAAK,aAAA,CAAc,IAAI,CAAA,EAAG;AAC9C,MAAA,UAAA,CAAW,MAAA,EAAQ,GAAA,EAAK,SAAA,CAAU,IAAA,EAAM,IAAI,CAAC,CAAA;AAAA,IAC/C,CAAA,MAAO;AACL,MAAA,UAAA,CAAW,MAAA,EAAQ,KAAK,IAAI,CAAA;AAAA,IAC9B;AAAA,EACF;AACA,EAAA,OAAO,MAAA;AACT;;ACTO,SAAS,gBAAA,CACd,MAAA,EACA,QAAA,EACA,KAAA,EACA,UACA,SAAA,EACU;AACV,EAAA,IAAI,QAAA,CAAS,MAAA,KAAW,CAAA,EAAG,OAAO,CAAC,MAAM,CAAA;AACzC,EAAA,MAAM,CAAC,IAAA,EAAM,GAAG,IAAI,CAAA,GAAI,QAAA;AACxB,EAAA,IAAI,IAAA,KAAS,MAAA,EAAW,OAAO,CAAC,MAAM,CAAA;AACtC,EAAA,MAAM,IAAA,GAAO,KAAA,CAAM,MAAA,CAAO,MAAM,CAAA;AAChC,EAAA,QAAQ,IAAA;AAAM,IACZ,KAAK,QAAA,EAAU;AACb,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,cAAA,CAAe,MAAM,CAAA;AACzC,MAAA,IAAI,CAAC,MAAA,CAAO,MAAA,CAAO,OAAO,IAAI,CAAA,SAAU,EAAC;AACzC,MAAA,MAAM,IAAA,GAAO,MAAM,IAAI,CAAA;AACvB,MAAA,OAAO,IAAA,KAAS,SAAY,EAAC,GAAI,iBAAiB,IAAA,EAAM,IAAA,EAAM,KAAA,EAAO,QAAA,EAAU,SAAS,CAAA;AAAA,IAC1F;AAAA,IACA,KAAK,OAAA,EAAS;AACZ,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,eAAA,CAAgB,MAAM,CAAA;AAC1C,MAAA,OAAO,KAAA,KAAU,SAAY,EAAC,GAAI,iBAAiB,KAAA,EAAO,IAAA,EAAM,KAAA,EAAO,QAAA,EAAU,SAAS,CAAA;AAAA,IAC5F;AAAA,IACA,KAAK,KAAA,EAAO;AAIV,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,eAAA,CAAgB,MAAM,CAAA;AAC1C,MAAA,OAAO,KAAA,KAAU,SAAY,EAAC,GAAI,iBAAiB,KAAA,EAAO,IAAA,EAAM,KAAA,EAAO,QAAA,EAAU,SAAS,CAAA;AAAA,IAC5F;AAAA,IACA,KAAK,QAAA,EAAU;AACb,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,kBAAA,CAAmB,MAAM,CAAA;AAC7C,MAAA,OAAO,KAAA,KAAU,SAAY,EAAC,GAAI,iBAAiB,KAAA,EAAO,IAAA,EAAM,KAAA,EAAO,QAAA,EAAU,SAAS,CAAA;AAAA,IAC5F;AAAA,IACA,KAAK,OAAA,EAAS;AACZ,MAAA,MAAM,KAAA,GAAQ,OAAO,IAAI,CAAA;AACzB,MAAA,IAAI,CAAC,MAAA,CAAO,SAAA,CAAU,KAAK,CAAA,SAAU,EAAC;AACtC,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,aAAA,CAAc,MAAM,CAAA;AACxC,MAAA,MAAM,IAAA,GAAO,MAAM,KAAK,CAAA;AACxB,MAAA,OAAO,IAAA,KAAS,SAAY,EAAC,GAAI,iBAAiB,IAAA,EAAM,IAAA,EAAM,KAAA,EAAO,QAAA,EAAU,SAAS,CAAA;AAAA,IAC1F;AAAA,IACA,KAAK,OAAA;AACH,MAAA,OAAO,KAAA,CACJ,eAAA,CAAgB,MAAM,CAAA,CACtB,OAAA,CAAQ,CAAC,GAAA,KAAQ,gBAAA,CAAiB,GAAA,EAAK,QAAA,EAAU,KAAA,EAAO,QAAA,EAAU,SAAS,CAAC,CAAA;AAAA,IACjF,KAAK,qBAAA,EAAuB;AAC1B,MAAA,MAAM,OAAA,GAAU,KAAA,CAAM,uBAAA,CAAwB,MAAM,CAAA;AACpD,MAAA,MAAM,QAAA,GAAW,OAAA,CAAQ,MAAA,CAAO,CAAC,GAAA,KAAQ,MAAA,CAAO,MAAA,CAAO,KAAA,CAAM,cAAA,CAAe,GAAG,CAAA,EAAG,IAAI,CAAC,CAAA;AACvF,MAAA,MAAM,UAAA,GAAa,QAAA,CAAS,MAAA,GAAS,CAAA,GAAI,QAAA,GAAW,OAAA;AACpD,MAAA,OAAO,UAAA,CAAW,OAAA;AAAA,QAAQ,CAAC,GAAA,KACzB,gBAAA,CAAiB,KAAK,QAAA,EAAU,KAAA,EAAO,UAAU,SAAS;AAAA,OAC5D;AAAA,IACF;AAAA,IACA,KAAK,UAAA;AAAA,IACL,KAAK,UAAA;AAAA,IACL,KAAK,SAAA;AAAA,IACL,KAAK,UAAA;AAAA,IACL,KAAK,OAAA,EAAS;AAGZ,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,WAAA,CAAY,MAAM,CAAA;AACtC,MAAA,OAAO,KAAA,KAAU,SACb,EAAC,GACD,iBAAiB,KAAA,EAAO,QAAA,EAAU,KAAA,EAAO,QAAA,EAAU,SAAS,CAAA;AAAA,IAClE;AAAA,IACA,KAAK,MAAA,EAAQ;AAIX,MAAA,MAAM,QAAQ,KAAA,CAAM,YAAA,CAAa,MAAM,CAAA,IAAK,KAAA,CAAM,cAAc,MAAM,CAAA;AACtE,MAAA,OAAO,KAAA,KAAU,SACb,EAAC,GACD,iBAAiB,KAAA,EAAO,QAAA,EAAU,KAAA,EAAO,QAAA,EAAU,SAAS,CAAA;AAAA,IAClE;AAAA,IACA,KAAK,UAAA,EAAY;AAEf,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,YAAA,CAAa,MAAM,CAAA;AACvC,MAAA,OAAO,KAAA,KAAU,SACb,EAAC,GACD,iBAAiB,KAAA,EAAO,QAAA,EAAU,KAAA,EAAO,QAAA,EAAU,SAAS,CAAA;AAAA,IAClE;AAAA,IACA,KAAK,SAAA,EAAW;AAId,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,mBAAA,CAAoB,MAAM,CAAA;AAC9C,MAAA,OAAO,KAAA,KAAU,SACb,EAAC,GACD,iBAAiB,KAAA,EAAO,QAAA,EAAU,KAAA,EAAO,QAAA,EAAU,SAAS,CAAA;AAAA,IAClE;AAAA,IACA,KAAK,SAAA,EAAW;AAGd,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,aAAA,CAAc,MAAM,CAAA;AACxC,MAAA,OAAO,KAAA,KAAU,SACb,EAAC,GACD,iBAAiB,KAAA,EAAO,QAAA,EAAU,KAAA,EAAO,QAAA,EAAU,SAAS,CAAA;AAAA,IAClE;AAAA,IACA,KAAK,MAAA,EAAQ;AAGX,MAAA,IAAI,SAAA,IAAa,QAAA,EAAU,OAAO,EAAC;AACnC,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,UAAA,CAAW,MAAM,CAAA;AACrC,MAAA,OAAO,KAAA,KAAU,MAAA,GACb,EAAC,GACD,gBAAA,CAAiB,OAAO,QAAA,EAAU,KAAA,EAAO,QAAA,EAAU,SAAA,GAAY,CAAC,CAAA;AAAA,IACtE;AAAA,IACA,KAAK,cAAA,EAAgB;AACnB,MAAA,MAAM,IAAA,GAAO,KAAA,CAAM,mBAAA,CAAoB,MAAM,CAAA;AAC7C,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,oBAAA,CAAqB,MAAM,CAAA;AAC/C,MAAA,MAAM,WAAA,GACJ,IAAA,KAAS,MAAA,GAAY,EAAC,GAAI,iBAAiB,IAAA,EAAM,QAAA,EAAU,KAAA,EAAO,QAAA,EAAU,SAAS,CAAA;AACvF,MAAA,MAAM,YAAA,GACJ,KAAA,KAAU,MAAA,GAAY,EAAC,GAAI,iBAAiB,KAAA,EAAO,QAAA,EAAU,KAAA,EAAO,QAAA,EAAU,SAAS,CAAA;AACzF,MAAA,OAAO,CAAC,GAAG,WAAA,EAAa,GAAG,YAAY,CAAA;AAAA,IACzC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMA;AACE,MAAA,OAAO,EAAC;AAAA;AAEd;;AC9EO,MAAM,mBAAA,GAAsB,OAAO,0BAA0B;AAoB7D,SAAS,mBAAA,CACd,QACA,KAAA,EACS;AACT,EAAA,IAAI,OAAA,GAA8B,MAAA;AAClC,EAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,EAAA,EAAI,CAAA,EAAA,EAAK;AAC3B,IAAA,IAAI,OAAA,KAAY,QAAW,OAAO,mBAAA;AAClC,IAAA,MAAM,CAAA,GAAI,KAAA,CAAM,MAAA,CAAO,OAAO,CAAA;AAC9B,IAAA,IAAI,CAAA,KAAM,SAAA,EAAW,OAAO,KAAA,CAAM,gBAAgB,OAAO,CAAA;AACzD,IAAA,IAAI,MAAM,OAAA,EAAS;AACjB,MAAA,IAAI,MAAM,aAAA,CAAc,OAAO,GAAG,OAAO,KAAA,CAAM,gBAAgB,OAAO,CAAA;AACtE,MAAA,OAAA,GAAU,KAAA,CAAM,YAAY,OAAO,CAAA;AACnC,MAAA;AAAA,IACF;AACA,IAAA,IAAI,CAAA,KAAM,UAAA,IAAc,CAAA,KAAM,UAAA,IAAc,MAAM,UAAA,EAAY;AAC5D,MAAA,OAAA,GAAU,KAAA,CAAM,YAAY,OAAO,CAAA;AACnC,MAAA;AAAA,IACF;AACA,IAAA,IAAI,MAAM,SAAA,EAAW;AACnB,MAAA,OAAA,GAAU,KAAA,CAAM,cAAc,OAAO,CAAA;AACrC,MAAA;AAAA,IACF;AACA,IAAA,IAAI,MAAM,SAAA,EAAW;AACnB,MAAA,OAAA,GAAU,KAAA,CAAM,oBAAoB,OAAO,CAAA;AAC3C,MAAA;AAAA,IACF;AACA,IAAA,IAAI,MAAM,UAAA,EAAY;AACpB,MAAA,OAAA,GAAU,KAAA,CAAM,aAAa,OAAO,CAAA;AACpC,MAAA;AAAA,IACF;AACA,IAAA,OAAO,mBAAA;AAAA,EACT;AACA,EAAA,OAAO,mBAAA;AACT;AAYA,SAAS,yBAAA,CACP,QACA,KAAA,EACS;AACT,EAAA,IAAI,OAAA,GAA8B,MAAA;AAClC,EAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,EAAA,EAAI,CAAA,EAAA,EAAK;AAC3B,IAAA,IAAI,OAAA,KAAY,QAAW,OAAO,KAAA;AAClC,IAAA,MAAM,CAAA,GAAI,KAAA,CAAM,MAAA,CAAO,OAAO,CAAA;AAC9B,IAAA,IAAI,CAAA,KAAM,WAAW,OAAO,IAAA;AAC5B,IAAA,IAAI,MAAM,UAAA,IAAc,CAAA,KAAM,cAAc,CAAA,KAAM,UAAA,IAAc,MAAM,OAAA,EAAS;AAC7E,MAAA,OAAA,GAAU,KAAA,CAAM,YAAY,OAAO,CAAA;AACnC,MAAA;AAAA,IACF;AACA,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,OAAO,KAAA;AACT;AAEO,SAAS,kBACd,MAAA,EACA,UAAA,EACA,OACA,QAAA,EACA,GAAA,EACA,YAAY,CAAA,EACH;AAMT,EAAA,IAAI,UAAA,EAAY;AACd,IAAA,MAAM,MAAA,GAAS,mBAAA,CAAoB,MAAA,EAAQ,KAAK,CAAA;AAChD,IAAA,IAAI,MAAA,KAAW,qBAAqB,OAAO,MAAA;AAAA,EAC7C;AASA,EAAA,IAAI,KAAA,CAAM,iBAAA,CAAkB,MAAM,CAAA,EAAG,OAAO,MAAA;AAE5C,EAAA,MAAM,IAAA,GAAO,KAAA,CAAM,MAAA,CAAO,MAAM,CAAA;AAChC,EAAA,QAAQ,IAAA;AAAM,IACZ,KAAK,QAAA,EAAU;AACb,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,cAAA,CAAe,MAAM,CAAA;AAQzC,MAAA,MAAM,MAA+B,EAAC;AACtC,MAAA,KAAA,MAAW,CAAC,GAAA,EAAK,SAAS,KAAK,MAAA,CAAO,OAAA,CAAQ,KAAK,CAAA,EAAG;AACpD,QAAA,UAAA;AAAA,UACE,GAAA;AAAA,UACA,GAAA;AAAA,UACA,kBAAkB,SAAA,EAAW,UAAA,EAAY,KAAA,EAAO,QAAA,EAAU,KAAK,SAAS;AAAA,SAC1E;AAAA,MACF;AACA,MAAA,OAAO,GAAA;AAAA,IACT;AAAA,IACA,KAAK,OAAA;AACH,MAAA,OAAO,EAAC;AAAA,IACV,KAAK,KAAA;AACH,MAAA,2BAAW,GAAA,EAAI;AAAA,IACjB,KAAK,QAAA;AACH,MAAA,OAAO,EAAC;AAAA,IACV,KAAK,OAAA,EAAS;AACZ,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,aAAA,CAAc,MAAM,CAAA;AACxC,MAAA,OAAO,KAAA,CAAM,GAAA;AAAA,QAAI,CAAC,SAChB,iBAAA,CAAkB,IAAA,EAAM,YAAY,KAAA,EAAO,QAAA,EAAU,KAAK,SAAS;AAAA,OACrE;AAAA,IACF;AAAA,IACA,KAAK,OAAA,EAAS;AACZ,MAAA,MAAM,OAAA,GAAU,KAAA,CAAM,eAAA,CAAgB,MAAM,CAAA;AAC5C,MAAA,MAAM,KAAA,GAAQ,QAAQ,CAAC,CAAA;AACvB,MAAA,OAAO,KAAA,KAAU,SACb,MAAA,GACA,iBAAA,CAAkB,OAAO,UAAA,EAAY,KAAA,EAAO,QAAA,EAAU,GAAA,EAAK,SAAS,CAAA;AAAA,IAC1E;AAAA,IACA,KAAK,qBAAA,EAAuB;AAC1B,MAAA,MAAM,OAAA,GAAU,KAAA,CAAM,uBAAA,CAAwB,MAAM,CAAA;AACpD,MAAA,MAAM,KAAA,GAAQ,QAAQ,CAAC,CAAA;AACvB,MAAA,OAAO,KAAA,KAAU,SACb,MAAA,GACA,iBAAA,CAAkB,OAAO,UAAA,EAAY,KAAA,EAAO,QAAA,EAAU,GAAA,EAAK,SAAS,CAAA;AAAA,IAC1E;AAAA,IACA,KAAK,UAAA;AACH,MAAA,OAAO,MAAA;AAAA,IACT,KAAK,UAAA;AACH,MAAA,OAAO,IAAA;AAAA,IACT,KAAK,SAAA,EAAW;AAMd,MAAA,IAAI,UAAA,EAAY,OAAO,KAAA,CAAM,eAAA,CAAgB,MAAM,CAAA;AACnD,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,WAAA,CAAY,MAAM,CAAA;AACtC,MAAA,OAAO,KAAA,KAAU,SACb,MAAA,GACA,iBAAA,CAAkB,OAAO,UAAA,EAAY,KAAA,EAAO,QAAA,EAAU,GAAA,EAAK,SAAS,CAAA;AAAA,IAC1E;AAAA,IACA,KAAK,UAAA;AAAA,IACL,KAAK,SAAA,EAAW;AAGd,MAAA,MAAM,KAAA,GAAQ,SAAS,SAAA,GAAY,KAAA,CAAM,cAAc,MAAM,CAAA,GAAI,KAAA,CAAM,WAAA,CAAY,MAAM,CAAA;AACzF,MAAA,OAAO,KAAA,KAAU,SACb,MAAA,GACA,iBAAA,CAAkB,OAAO,UAAA,EAAY,KAAA,EAAO,QAAA,EAAU,GAAA,EAAK,SAAS,CAAA;AAAA,IAC1E;AAAA,IACA,KAAK,SAAA,EAAW;AASd,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,mBAAA,CAAoB,MAAM,CAAA;AAC9C,MAAA,IAAI,KAAA,CAAM,gBAAA,CAAiB,MAAM,CAAA,EAAG;AAClC,QAAA,IAAI,KAAA,KAAU,MAAA,IAAa,yBAAA,CAA0B,KAAA,EAAO,KAAK,CAAA,EAAG;AAClE,UAAA,OAAO,kBAAkB,KAAA,EAAO,UAAA,EAAY,KAAA,EAAO,QAAA,EAAU,KAAK,SAAS,CAAA;AAAA,QAC7E;AACA,QAAA,OAAO,MAAA;AAAA,MACT;AACA,MAAA,OAAO,KAAA,KAAU,SACb,MAAA,GACA,iBAAA,CAAkB,OAAO,UAAA,EAAY,KAAA,EAAO,QAAA,EAAU,GAAA,EAAK,SAAS,CAAA;AAAA,IAC1E;AAAA,IACA,KAAK,UAAA,EAAY;AAGf,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,YAAA,CAAa,MAAM,CAAA;AACvC,MAAA,OAAO,KAAA,KAAU,SACb,MAAA,GACA,iBAAA,CAAkB,OAAO,UAAA,EAAY,KAAA,EAAO,QAAA,EAAU,GAAA,EAAK,SAAS,CAAA;AAAA,IAC1E;AAAA,IACA,KAAK,MAAA,EAAQ;AASX,MAAA,MAAM,GAAA,GAAM,KAAA,CAAM,YAAA,CAAa,MAAM,CAAA;AACrC,MAAA,IAAI,QAAQ,MAAA,IAAa,KAAA,CAAM,MAAA,CAAO,GAAG,MAAM,WAAA,EAAa;AAC1D,QAAA,MAAMA,IAAAA,GAAM,KAAA,CAAM,aAAA,CAAc,MAAM,CAAA;AACtC,QAAA,IAAIA,IAAAA,KAAQ,MAAA,IAAa,yBAAA,CAA0BA,IAAAA,EAAK,KAAK,CAAA,EAAG;AAC9D,UAAA,OAAO,kBAAkBA,IAAAA,EAAK,UAAA,EAAY,KAAA,EAAO,QAAA,EAAU,KAAK,SAAS,CAAA;AAAA,QAC3E;AACA,QAAA,OAAO,MAAA;AAAA,MACT;AACA,MAAA,MAAM,GAAA,GAAM,KAAA,CAAM,aAAA,CAAc,MAAM,CAAA;AACtC,MAAA,MAAM,OACJ,GAAA,KAAQ,MAAA,IAAa,KAAA,CAAM,MAAA,CAAO,GAAG,CAAA,KAAM,WAAA,GACvC,GAAA,GACA,GAAA,KAAQ,UAAa,KAAA,CAAM,MAAA,CAAO,GAAG,CAAA,KAAM,WAAA,GACzC,MACC,GAAA,IAAO,GAAA;AAChB,MAAA,OAAO,IAAA,KAAS,SACZ,MAAA,GACA,iBAAA,CAAkB,MAAM,UAAA,EAAY,KAAA,EAAO,QAAA,EAAU,GAAA,EAAK,SAAS,CAAA;AAAA,IACzE;AAAA,IACA,KAAK,QAAA;AACH,MAAA,OAAO,EAAA;AAAA,IACT,KAAK,QAAA;AACH,MAAA,OAAO,CAAA;AAAA,IACT,KAAK,QAAA;AAIH,MAAA,OAAO,EAAA;AAAA,IACT,KAAK,SAAA;AACH,MAAA,OAAO,KAAA;AAAA,IACT,KAAK,MAAA;AACH,MAAA,uBAAO,IAAI,KAAK,CAAC,CAAA;AAAA,IACnB,KAAK,MAAA;AACH,MAAA,OAAO,IAAA;AAAA,IACT,KAAK,WAAA;AACH,MAAA,OAAO,MAAA;AAAA,IACT,KAAK,MAAA,EAAQ;AACX,MAAA,MAAM,MAAA,GAAS,KAAA,CAAM,aAAA,CAAc,MAAM,CAAA;AACzC,MAAA,OAAO,OAAO,CAAC,CAAA;AAAA,IACjB;AAAA,IACA,KAAK,aAAA,EAAe;AAMlB,MAAA,MAAM,MAAA,GAAS,KAAA,CAAM,mBAAA,CAAoB,MAAM,CAAA;AAC/C,MAAA,IAAI,MAAA,KAAW,QAAW,OAAO,MAAA;AACjC,MAAA,MAAM,SAAA,GAAY,MAAA,CAAO,IAAA,CAAK,MAAM,CAAA,CAAE,MAAA;AAAA,QACpC,CAAC,CAAA,KAAM,OAAO,OAAO,MAAA,CAAO,CAAC,CAAW,CAAA,KAAM;AAAA,OAChD;AACA,MAAA,IAAI,SAAA,CAAU,MAAA,KAAW,CAAA,EAAG,OAAO,MAAA;AACnC,MAAA,MAAM,KAAA,GAAQ,UAAU,CAAC,CAAA;AACzB,MAAA,OAAO,KAAA,KAAU,MAAA,GAAY,MAAA,GAAY,MAAA,CAAO,KAAK,CAAA;AAAA,IACvD;AAAA,IACA,KAAK,SAAA,EAAW;AACd,MAAA,MAAM,MAAA,GAAS,KAAA,CAAM,gBAAA,CAAiB,MAAM,CAAA;AAC5C,MAAA,OAAO,OAAO,CAAC,CAAA;AAAA,IACjB;AAAA,IACA,KAAK,KAAA;AACH,MAAA,OAAO,GAAA;AAAA,IACT,KAAK,MAAA,EAAQ;AAMX,MAAA,IAAI,SAAA,IAAa,UAAU,OAAO,MAAA;AAClC,MAAA,IAAI,KAAA;AACJ,MAAA,IAAI;AACF,QAAA,KAAA,GAAQ,KAAA,CAAM,WAAW,MAAM,CAAA;AAAA,MACjC,CAAA,CAAA,MAAQ;AACN,QAAA,OAAO,MAAA;AAAA,MACT;AACA,MAAA,OAAO,KAAA,KAAU,MAAA,GACb,MAAA,GACA,iBAAA,CAAkB,KAAA,EAAO,YAAY,KAAA,EAAO,QAAA,EAAU,GAAA,EAAK,SAAA,GAAY,CAAC,CAAA;AAAA,IAC9E;AAAA,IACA,KAAK,cAAA,EAAgB;AACnB,MAAA,MAAM,IAAA,GAAO,KAAA,CAAM,mBAAA,CAAoB,MAAM,CAAA;AAC7C,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,oBAAA,CAAqB,MAAM,CAAA;AAC/C,MAAA,MAAM,CAAA,GACJ,IAAA,KAAS,MAAA,GACL,MAAA,GACA,iBAAA,CAAkB,MAAM,UAAA,EAAY,KAAA,EAAO,QAAA,EAAU,GAAA,EAAK,SAAS,CAAA;AACzE,MAAA,MAAM,CAAA,GACJ,KAAA,KAAU,MAAA,GACN,MAAA,GACA,iBAAA,CAAkB,OAAO,UAAA,EAAY,KAAA,EAAO,QAAA,EAAU,GAAA,EAAK,SAAS,CAAA;AAM1E,MAAA,OAAO,SAAA,CAAU,GAAG,CAAC,CAAA;AAAA,IACvB;AAAA,IACA,KAAK,OAAA,EAAS;AAMZ,MAAA,IAAI,UAAA,EAAY,OAAO,KAAA,CAAM,eAAA,CAAgB,MAAM,CAAA;AACnD,MAAA,IAAI,IAAI,sBAAA,KAA2B,eAAA,IAAmB,KAAA,CAAM,aAAA,CAAc,MAAM,CAAA,EAAG;AACjF,QAAA,OAAO,KAAA,CAAM,gBAAgB,MAAM,CAAA;AAAA,MACrC;AACA,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,WAAA,CAAY,MAAM,CAAA;AACtC,MAAA,OAAO,KAAA,KAAU,SACb,MAAA,GACA,iBAAA,CAAkB,OAAO,UAAA,EAAY,KAAA,EAAO,QAAA,EAAU,GAAA,EAAK,SAAS,CAAA;AAAA,IAC1E;AAAA,IACA,KAAK,MAAA;AAMH,MAAA,OAAO,IAAA;AAAA,IACT,KAAK,KAAA;AAAA,IACL,KAAK,SAAA;AAAA,IACL,KAAK,MAAA;AAAA,IACL,KAAK,OAAA;AAAA,IACL,KAAK,SAAA;AAAA,IACL,KAAK,QAAA;AAAA,IACL,KAAK,kBAAA;AAAA,IACL,KAAK,WAAA;AAAA,IACL,KAAK,KAAA;AAAA,IACL,KAAK,QAAA;AAAA,IACL,KAAK,UAAA;AAQH,MAAA,OAAO,MAAA;AAAA,IACT;AACE,MAAA,OAAO,GAAA,CAAI,uBAAA,CAAwB,MAAA,EAAQ,IAAI,CAAA;AAAA;AAErD;;ACpZA,MAAM,KAAA,uBAAY,OAAA,EAAkC;AACpD,MAAM,KAAA,uBAAY,OAAA,EAAoC;AAEtD,MAAM,QAAA,GAA2B;AAAA,EAC/B,GAAA,CAAI,QAAQ,OAAA,EAAS;AACnB,IAAA,KAAA,CAAM,GAAA,CAAI,QAAQ,OAAO,CAAA;AACzB,IAAA,MAAM,IAAA,GAAO,KAAA,CAAM,GAAA,CAAI,MAAM,KAAK,EAAC;AACnC,IAAA,IAAA,CAAK,KAAK,OAAO,CAAA;AACjB,IAAA,KAAA,CAAM,GAAA,CAAI,QAAQ,IAAI,CAAA;AACtB,IAAA,OAAO,QAAA;AAAA,EACT,CAAA;AAAA,EACA,IAAI,MAAA,EAAQ;AACV,IAAA,OAAO,KAAA,CAAM,IAAI,MAAM,CAAA;AAAA,EACzB,CAAA;AAAA,EACA,IAAI,MAAA,EAAQ;AACV,IAAA,OAAO,KAAA,CAAM,IAAI,MAAM,CAAA;AAAA,EACzB,CAAA;AAAA,EACA,OAAO,MAAA,EAAQ;AACb,IAAA,KAAA,CAAM,OAAO,MAAM,CAAA;AACnB,IAAA,KAAA,CAAM,OAAO,MAAM,CAAA;AACnB,IAAA,OAAO,QAAA;AAAA,EACT;AACF,CAAA;AAQO,MAAM,cAAA,GAAiC;AAMvC,SAAS,sBAAsB,MAAA,EAA8C;AAClF,EAAA,OAAO,KAAA,CAAM,IAAI,MAAM,CAAA;AACzB;AAQO,SAAS,0BAA0B,MAAA,EAA6C;AACrF,EAAA,OAAO,KAAA,CAAM,GAAA,CAAI,MAAM,CAAA,IAAK,EAAC;AAC/B;;AC1CO,MAAM,qBAAA,uBACS,GAAA,CAAuB;AAAA,EACzC,QAAA;AAAA,EACA,QAAA;AAAA,EACA,SAAA;AAAA,EACA,QAAA;AAAA,EACA,MAAA;AAAA,EACA,MAAA;AAAA,EACA,WAAA;AAAA,EACA,QAAA;AAAA,EACA,OAAA;AAAA,EACA,QAAA;AAAA,EACA,UAAA;AAAA,EACA,KAAA;AAAA,EACA,KAAA;AAAA,EACA;AACF,CAAC,CAAA;AASH,MAAM,WAAA,mBAA8D,IAAI,GAAA,CAAI,CAAC,QAAQ,CAAC,CAAA;AACtF,MAAM,WAAA,mBAA8D,IAAI,GAAA,CAAI,CAAC,QAAQ,CAAC,CAAA;AACtF,MAAM,YAAA,mBAA+D,IAAI,GAAA,CAAI,CAAC,SAAS,CAAC,CAAA;AACxF,MAAM,WAAA,mBAA8D,IAAI,GAAA,CAAI,CAAC,QAAQ,CAAC,CAAA;AACtF,MAAM,SAAA,mBAA4D,IAAI,GAAA,CAAI,CAAC,MAAM,CAAC,CAAA;AAClF,MAAM,SAAA,mBAA4D,IAAI,GAAA,CAAI,CAAC,MAAM,CAAC,CAAA;AAClF,MAAM,cAAA,mBAAiE,IAAI,GAAA,CAAI,CAAC,WAAW,CAAC,CAAA;AAC5F,MAAM,WAAA,mBAA8D,IAAI,GAAA,CAAI,CAAC,QAAQ,CAAC,CAAA;AACtF,MAAM,UAAA,mBAA6D,IAAI,GAAA,CAAI,CAAC,OAAO,CAAC,CAAA;AACpF,MAAM,QAAA,mBAA2D,IAAI,GAAA,CAAI,CAAC,KAAK,CAAC,CAAA;AAChF,MAAM,4BAA4D,IAAI,GAAA,CAAI,CAAC,MAAA,EAAQ,MAAM,CAAC,CAAA;AAC1F,MAAM,WAAA,uBAAkE,GAAA,EAAI;AAErE,SAAS,kBAAA,CACd,MAAA,EACA,KAAA,EACA,QAAA,EACA,YAAY,CAAA,EACoB;AAChC,EAAA,MAAM,IAAA,GAAO,KAAA,CAAM,MAAA,CAAO,MAAM,CAAA;AAChC,EAAA,QAAQ,IAAA;AAAM,IACZ,KAAK,QAAA;AACH,MAAA,OAAO,WAAA;AAAA,IACT,KAAK,QAAA;AAAA,IACL,KAAK,KAAA;AACH,MAAA,OAAO,WAAA;AAAA,IACT,KAAK,SAAA;AACH,MAAA,OAAO,YAAA;AAAA,IACT,KAAK,QAAA;AACH,MAAA,OAAO,WAAA;AAAA,IACT,KAAK,MAAA;AACH,MAAA,OAAO,SAAA;AAAA,IACT,KAAK,MAAA;AAOH,MAAA,OAAO,SAAA;AAAA,IACT,KAAK,MAAA;AACH,MAAA,OAAO,SAAA;AAAA,IACT,KAAK,WAAA;AAAA,IACL,KAAK,MAAA;AACH,MAAA,OAAO,cAAA;AAAA,IACT,KAAK,MAAA,EAAQ;AACX,MAAA,MAAM,MAAA,GAAS,KAAA,CAAM,aAAA,CAAc,MAAM,CAAA;AACzC,MAAA,MAAM,GAAA,uBAAU,GAAA,EAAuB;AACvC,MAAA,KAAA,MAAW,KAAK,MAAA,EAAQ;AACtB,QAAA,IAAI,OAAO,CAAA,KAAM,QAAA,EAAU,GAAA,CAAI,IAAI,QAAQ,CAAA;AAAA,aAAA,IAClC,OAAO,CAAA,KAAM,QAAA,EAAU,GAAA,CAAI,IAAI,QAAQ,CAAA;AAAA,MAClD;AACA,MAAA,OAAO,GAAA,CAAI,IAAA,KAAS,CAAA,GAAI,WAAA,GAAc,GAAA;AAAA,IACxC;AAAA,IACA,KAAK,aAAA,EAAe;AAKlB,MAAA,MAAM,MAAA,GAAS,KAAA,CAAM,mBAAA,CAAoB,MAAM,CAAA;AAC/C,MAAA,IAAI,MAAA,KAAW,QAAW,OAAO,WAAA;AACjC,MAAA,MAAM,GAAA,uBAAU,GAAA,EAAuB;AACvC,MAAA,KAAA,MAAW,CAAA,IAAK,MAAA,CAAO,MAAA,CAAO,MAAM,CAAA,EAAG;AACrC,QAAA,IAAI,OAAO,CAAA,KAAM,QAAA,EAAU,GAAA,CAAI,IAAI,QAAQ,CAAA;AAAA,aAAA,IAClC,OAAO,CAAA,KAAM,QAAA,EAAU,GAAA,CAAI,IAAI,QAAQ,CAAA;AAAA,MAClD;AACA,MAAA,OAAO,GAAA,CAAI,IAAA,KAAS,CAAA,GAAI,WAAA,GAAc,GAAA;AAAA,IACxC;AAAA,IACA,KAAK,SAAA,EAAW;AACd,MAAA,MAAM,MAAA,GAAS,KAAA,CAAM,gBAAA,CAAiB,MAAM,CAAA;AAC5C,MAAA,MAAM,GAAA,uBAAU,GAAA,EAAuB;AACvC,MAAA,KAAA,MAAW,KAAK,MAAA,EAAQ,GAAA,CAAI,GAAA,CAAI,UAAA,CAAW,CAAC,CAAC,CAAA;AAC7C,MAAA,OAAO,GAAA,CAAI,IAAA,KAAS,CAAA,GAAI,qBAAA,GAAwB,GAAA;AAAA,IAClD;AAAA,IACA,KAAK,QAAA;AAAA,IACL,KAAK,QAAA;AACH,MAAA,OAAO,WAAA;AAAA,IACT,KAAK,OAAA;AAAA,IACL,KAAK,OAAA;AACH,MAAA,OAAO,UAAA;AAAA,IACT,KAAK,KAAA;AACH,MAAA,OAAO,QAAA;AAAA,IACT,KAAK,UAAA,EAAY;AACf,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,WAAA,CAAY,MAAM,CAAA;AACtC,MAAA,MAAM,QAAA,GACJ,UAAU,MAAA,GAAY,WAAA,GAAc,mBAAmB,KAAA,EAAO,KAAA,EAAO,UAAU,SAAS,CAAA;AAC1F,MAAA,MAAM,GAAA,GAAM,IAAI,GAAA,CAAuB,QAAQ,CAAA;AAC/C,MAAA,GAAA,CAAI,IAAI,WAAW,CAAA;AACnB,MAAA,OAAO,GAAA;AAAA,IACT;AAAA,IACA,KAAK,UAAA,EAAY;AACf,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,WAAA,CAAY,MAAM,CAAA;AACtC,MAAA,MAAM,QAAA,GACJ,UAAU,MAAA,GAAY,WAAA,GAAc,mBAAmB,KAAA,EAAO,KAAA,EAAO,UAAU,SAAS,CAAA;AAC1F,MAAA,MAAM,GAAA,GAAM,IAAI,GAAA,CAAuB,QAAQ,CAAA;AAC/C,MAAA,GAAA,CAAI,IAAI,MAAM,CAAA;AACd,MAAA,OAAO,GAAA;AAAA,IACT;AAAA,IACA,KAAK,SAAA;AAAA,IACL,KAAK,UAAA;AAAA,IACL,KAAK,OAAA,EAAS;AACZ,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,WAAA,CAAY,MAAM,CAAA;AACtC,MAAA,OAAO,UAAU,MAAA,GACb,qBAAA,GACA,mBAAmB,KAAA,EAAO,KAAA,EAAO,UAAU,SAAS,CAAA;AAAA,IAC1D;AAAA,IACA,KAAK,SAAA,EAAW;AAEd,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,aAAA,CAAc,MAAM,CAAA;AACxC,MAAA,OAAO,UAAU,MAAA,GACb,qBAAA,GACA,mBAAmB,KAAA,EAAO,KAAA,EAAO,UAAU,SAAS,CAAA;AAAA,IAC1D;AAAA,IACA,KAAK,SAAA,EAAW;AAId,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,mBAAA,CAAoB,MAAM,CAAA;AAC9C,MAAA,OAAO,UAAU,MAAA,GACb,qBAAA,GACA,mBAAmB,KAAA,EAAO,KAAA,EAAO,UAAU,SAAS,CAAA;AAAA,IAC1D;AAAA,IACA,KAAK,UAAA,EAAY;AAEf,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,YAAA,CAAa,MAAM,CAAA;AACvC,MAAA,OAAO,UAAU,MAAA,GACb,qBAAA,GACA,mBAAmB,KAAA,EAAO,KAAA,EAAO,UAAU,SAAS,CAAA;AAAA,IAC1D;AAAA,IACA,KAAK,MAAA,EAAQ;AAUX,MAAA,MAAM,MAAA,GAAS,KAAA,CAAM,YAAA,CAAa,MAAM,CAAA;AACxC,MAAA,MAAM,OAAA,GAAU,KAAA,CAAM,aAAA,CAAc,MAAM,CAAA;AAC1C,MAAA,MAAM,KAAA,GACJ,WAAW,MAAA,IAAa,KAAA,CAAM,OAAO,MAAM,CAAA,KAAM,WAAA,GAAc,OAAA,GAAW,MAAA,IAAU,OAAA;AACtF,MAAA,OAAO,UAAU,MAAA,GACb,qBAAA,GACA,mBAAmB,KAAA,EAAO,KAAA,EAAO,UAAU,SAAS,CAAA;AAAA,IAC1D;AAAA,IACA,KAAK,MAAA,EAAQ;AAGX,MAAA,IAAI,SAAA,IAAa,UAAU,OAAO,qBAAA;AAClC,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,UAAA,CAAW,MAAM,CAAA;AACrC,MAAA,OAAO,KAAA,KAAU,SACb,qBAAA,GACA,kBAAA,CAAmB,OAAO,KAAA,EAAO,QAAA,EAAU,YAAY,CAAC,CAAA;AAAA,IAC9D;AAAA,IACA,KAAK,OAAA;AAAA,IACL,KAAK,qBAAA,EAAuB;AAG1B,MAAA,MAAM,OAAA,GAAU,KAAA,CAAM,eAAA,CAAgB,MAAM,CAAA;AAC5C,MAAA,MAAM,GAAA,uBAAU,GAAA,EAAuB;AACvC,MAAA,KAAA,MAAW,OAAO,OAAA,EAAS;AACzB,QAAA,KAAA,MAAW,CAAA,IAAK,mBAAmB,GAAA,EAAK,KAAA,EAAO,UAAU,SAAS,CAAA,EAAG,GAAA,CAAI,GAAA,CAAI,CAAC,CAAA;AAAA,MAChF;AACA,MAAA,OAAO,GAAA,CAAI,IAAA,KAAS,CAAA,GAAI,qBAAA,GAAwB,GAAA;AAAA,IAClD;AAAA,IACA,KAAK,cAAA,EAAgB;AACnB,MAAA,MAAM,IAAA,GAAO,KAAA,CAAM,mBAAA,CAAoB,MAAM,CAAA;AAC7C,MAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,oBAAA,CAAqB,MAAM,CAAA;AAC/C,MAAA,MAAM,OAAA,GACJ,SAAS,MAAA,GACL,qBAAA,GACA,mBAAmB,IAAA,EAAM,KAAA,EAAO,UAAU,SAAS,CAAA;AACzD,MAAA,MAAM,QAAA,GACJ,UAAU,MAAA,GACN,qBAAA,GACA,mBAAmB,KAAA,EAAO,KAAA,EAAO,UAAU,SAAS,CAAA;AAC1D,MAAA,MAAM,GAAA,uBAAU,GAAA,EAAuB;AACvC,MAAA,KAAA,MAAW,CAAA,IAAK,SAAS,IAAI,QAAA,CAAS,IAAI,CAAC,CAAA,EAAG,GAAA,CAAI,GAAA,CAAI,CAAC,CAAA;AACvD,MAAA,OAAO,GAAA;AAAA,IACT;AAAA,IACA,KAAK,OAAA;AACH,MAAA,OAAO,WAAA;AAAA,IACT,KAAK,KAAA;AAAA,IACL,KAAK,SAAA;AACH,MAAA,OAAO,qBAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMT;AACE,MAAA,OAAO,qBAAA;AAAA;AAEb;;AC9OA,MAAM,aAAA,uBAAoB,OAAA,EAAgD;AAanE,SAAS,mBAAA,CACd,YACA,QAAA,EACgC;AAChC,EAAA,MAAM,MAAA,GAAS,aAAA,CAAc,GAAA,CAAI,UAAU,CAAA;AAC3C,EAAA,IAAI,MAAA,KAAW,QAAW,OAAO,MAAA;AACjC,EAAA,MAAM,GAAA,uBAAU,GAAA,EAA+B;AAC/C,EAAA,MAAM,QAAA,uBAAe,GAAA,EAAoB;AACzC,EAAA,MAAM,iBAAA,uBAAwB,GAAA,EAAqB;AACnD,EAAA,MAAM,UAAA,uBAAiB,OAAA,EAAgB;AACvC,EAAA,WAAA,CAAY,YAAY,EAAC,EAAG,KAAK,QAAA,EAAU,iBAAA,EAAmB,YAAY,QAAQ,CAAA;AAClF,EAAA,KAAA,MAAW,CAAC,MAAA,EAAQ,QAAQ,CAAA,IAAK,iBAAA,EAAmB;AAClD,IAAA,MAAM,IAAA,GAAO,QAAA,CAAS,gBAAA,CAAiB,MAAM,CAAA;AAC7C,IAAA,MAAM,QAAA,GAAW,QAAA,CAAS,GAAA,CAAI,MAAM,CAAA,IAAK,CAAA;AACzC,IAAA,IAAI,IAAA,CAAK,UAAU,QAAA,EAAU;AAC7B,IAAA,MAAM,UAAU,IAAA,CACb,KAAA,CAAM,QAAQ,CAAA,CACd,OAAyB,CAAC,GAAA,EAAK,CAAA,MAAO,EAAE,GAAG,GAAA,EAAK,GAAG,CAAA,EAAE,CAAA,EAAI,EAAE,CAAA;AAC9D,IAAA,MAAM,QAAA,GAAW,GAAA,CAAI,GAAA,CAAI,QAAQ,KAAK,EAAC;AACvC,IAAA,GAAA,CAAI,IAAI,QAAA,EAAU,EAAE,GAAG,QAAA,EAAU,GAAG,SAAS,CAAA;AAAA,EAC/C;AACA,EAAA,aAAA,CAAc,GAAA,CAAI,YAAY,GAAG,CAAA;AACjC,EAAA,OAAO,GAAA;AACT;AASA,SAAS,cAAA,CACP,MAAA,EACA,QAAA,EACA,gBAAA,EAC8B;AAC9B,EAAA,MAAM,IAAA,GAAO,iBAAiB,MAAM,CAAA;AACpC,EAAA,IAAI,IAAA,CAAK,MAAA,KAAW,CAAA,EAAG,OAAO,MAAA;AAC9B,EAAA,MAAM,GAAA,GAAM,QAAA,CAAS,GAAA,CAAI,MAAM,CAAA,IAAK,CAAA;AACpC,EAAA,MAAM,OAAA,GAAU,KAAK,IAAA,CAAK,GAAA,CAAI,KAAK,IAAA,CAAK,MAAA,GAAS,CAAC,CAAC,CAAA;AACnD,EAAA,QAAA,CAAS,GAAA,CAAI,MAAA,EAAQ,GAAA,GAAM,CAAC,CAAA;AAC5B,EAAA,OAAO,OAAA;AACT;AASA,SAAS,YACP,MAAA,EACA,IAAA,EACA,KACA,QAAA,EACA,iBAAA,EACA,YACA,QAAA,EACM;AACN,EAAA,IAAI,UAAA,CAAW,GAAA,CAAI,MAAM,CAAA,EAAG;AAC5B,EAAA,UAAA,CAAW,IAAI,MAAM,CAAA;AACrB,EAAA,IAAI;AACF,IAAA,MAAM,EAAE,KAAA,EAAO,eAAA,EAAiB,gBAAA,EAAiB,GAAI,QAAA;AACrD,IAAA,MAAM,OAAA,GAAU,gBAAA,CAAiB,IAAI,CAAA,CAAE,GAAA;AACvC,IAAA,IAAI,CAAC,GAAA,CAAI,GAAA,CAAI,OAAO,CAAA,EAAG;AACrB,MAAA,MAAM,OAAA,GAAU,cAAA,CAAe,MAAA,EAAQ,QAAA,EAAU,gBAAgB,CAAA;AACjE,MAAA,IAAI,YAAY,KAAA,CAAA,EAAW;AACzB,QAAA,GAAA,CAAI,GAAA,CAAI,SAAS,OAAO,CAAA;AACxB,QAAA,iBAAA,CAAkB,GAAA,CAAI,QAAQ,OAAO,CAAA;AAAA,MACvC;AAAA,IACF;AACA,IAAA,MAAM,MAAA,GAAS,gBAAgB,MAAM,CAAA;AACrC,IAAA,IAAI,WAAW,MAAA,IAAU,CAAC,GAAA,CAAI,GAAA,CAAI,OAAO,CAAA,EAAG;AAC1C,MAAA,MAAM,OAAA,GAAU,cAAA,CAAe,MAAA,EAAQ,QAAA,EAAU,gBAAgB,CAAA;AACjE,MAAA,IAAI,YAAY,KAAA,CAAA,EAAW;AACzB,QAAA,GAAA,CAAI,GAAA,CAAI,SAAS,OAAO,CAAA;AACxB,QAAA,iBAAA,CAAkB,GAAA,CAAI,QAAQ,OAAO,CAAA;AAAA,MACvC;AAAA,IACF;AAIA,IAAA,MAAM,IAAA,GAAO,KAAA,CAAM,MAAA,CAAO,MAAM,CAAA;AAChC,IAAA,QAAQ,IAAA;AAAM,MACZ,KAAK,QAAA,EAAU;AACb,QAAA,KAAA,MAAW,CAAC,GAAA,EAAK,KAAK,CAAA,IAAK,MAAA,CAAO,QAAQ,KAAA,CAAM,cAAA,CAAe,MAAM,CAAC,CAAA,EAAG;AACvE,UAAA,WAAA,CAAY,KAAA,EAAO,CAAC,GAAG,IAAA,EAAM,GAAG,GAAG,GAAA,EAAK,QAAA,EAAU,iBAAA,EAAmB,UAAA,EAAY,QAAQ,CAAA;AAAA,QAC3F;AACA,QAAA;AAAA,MACF;AAAA,MACA,KAAK,OAAA,EAAS;AACZ,QAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,eAAA,CAAgB,MAAM,CAAA;AAC1C,QAAA,IAAI,KAAA,KAAU,KAAA,CAAA;AACZ,UAAA,WAAA,CAAY,KAAA,EAAO,CAAC,GAAG,IAAA,EAAM,CAAC,GAAG,GAAA,EAAK,QAAA,EAAU,iBAAA,EAAmB,UAAA,EAAY,QAAQ,CAAA;AACzF,QAAA;AAAA,MACF;AAAA,MACA,KAAK,OAAA,EAAS;AACZ,QAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,aAAA,CAAc,MAAM,CAAA;AACxC,QAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,KAAA,CAAM,QAAQ,CAAA,EAAA,EAAK;AACrC,UAAA,MAAM,IAAA,GAAO,MAAM,CAAC,CAAA;AACpB,UAAA,IAAI,IAAA,KAAS,KAAA,CAAA;AACX,YAAA,WAAA,CAAY,IAAA,EAAM,CAAC,GAAG,IAAA,EAAM,CAAC,GAAG,GAAA,EAAK,QAAA,EAAU,iBAAA,EAAmB,UAAA,EAAY,QAAQ,CAAA;AAAA,QAC1F;AACA,QAAA;AAAA,MACF;AAAA,MACA,KAAK,KAAA,EAAO;AACV,QAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,eAAA,CAAgB,MAAM,CAAA;AAC1C,QAAA,IAAI,KAAA,KAAU,KAAA,CAAA;AACZ,UAAA,WAAA,CAAY,KAAA,EAAO,CAAC,GAAG,IAAA,EAAM,CAAC,GAAG,GAAA,EAAK,QAAA,EAAU,iBAAA,EAAmB,UAAA,EAAY,QAAQ,CAAA;AACzF,QAAA;AAAA,MACF;AAAA,MACA,KAAK,QAAA,EAAU;AACb,QAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,kBAAA,CAAmB,MAAM,CAAA;AAC7C,QAAA,IAAI,KAAA,KAAU,KAAA,CAAA;AACZ,UAAA,WAAA,CAAY,KAAA,EAAO,CAAC,GAAG,IAAA,EAAM,GAAG,GAAG,GAAA,EAAK,QAAA,EAAU,iBAAA,EAAmB,UAAA,EAAY,QAAQ,CAAA;AAC3F,QAAA;AAAA,MACF;AAAA,MACA,KAAK,OAAA,EAAS;AACZ,QAAA,KAAA,MAAW,GAAA,IAAO,KAAA,CAAM,eAAA,CAAgB,MAAM,CAAA,EAAG;AAC/C,UAAA,WAAA,CAAY,KAAK,IAAA,EAAM,GAAA,EAAK,QAAA,EAAU,iBAAA,EAAmB,YAAY,QAAQ,CAAA;AAAA,QAC/E;AACA,QAAA;AAAA,MACF;AAAA,MACA,KAAK,qBAAA,EAAuB;AAC1B,QAAA,KAAA,MAAW,GAAA,IAAO,KAAA,CAAM,uBAAA,CAAwB,MAAM,CAAA,EAAG;AACvD,UAAA,WAAA,CAAY,KAAK,IAAA,EAAM,GAAA,EAAK,QAAA,EAAU,iBAAA,EAAmB,YAAY,QAAQ,CAAA;AAAA,QAC/E;AACA,QAAA;AAAA,MACF;AAAA,MACA,KAAK,UAAA;AAAA,MACL,KAAK,UAAA;AAAA,MACL,KAAK,SAAA;AAAA,MACL,KAAK,UAAA;AAAA,MACL,KAAK,OAAA,EAAS;AACZ,QAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,WAAA,CAAY,MAAM,CAAA;AACtC,QAAA,IAAI,KAAA,KAAU,KAAA,CAAA;AACZ,UAAA,WAAA,CAAY,OAAO,IAAA,EAAM,GAAA,EAAK,QAAA,EAAU,iBAAA,EAAmB,YAAY,QAAQ,CAAA;AACjF,QAAA;AAAA,MACF;AAAA,MACA,KAAK,MAAA;AAAA,MACL,KAAK,UAAA,EAAY;AACf,QAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,YAAA,CAAa,MAAM,CAAA;AACvC,QAAA,IAAI,KAAA,KAAU,KAAA,CAAA;AACZ,UAAA,WAAA,CAAY,OAAO,IAAA,EAAM,GAAA,EAAK,QAAA,EAAU,iBAAA,EAAmB,YAAY,QAAQ,CAAA;AACjF,QAAA;AAAA,MACF;AAAA,MACA,KAAK,SAAA,EAAW;AACd,QAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,mBAAA,CAAoB,MAAM,CAAA;AAC9C,QAAA,IAAI,KAAA,KAAU,KAAA,CAAA;AACZ,UAAA,WAAA,CAAY,OAAO,IAAA,EAAM,GAAA,EAAK,QAAA,EAAU,iBAAA,EAAmB,YAAY,QAAQ,CAAA;AACjF,QAAA;AAAA,MACF;AAAA,MACA,KAAK,SAAA,EAAW;AACd,QAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,aAAA,CAAc,MAAM,CAAA;AACxC,QAAA,IAAI,KAAA,KAAU,KAAA,CAAA;AACZ,UAAA,WAAA,CAAY,OAAO,IAAA,EAAM,GAAA,EAAK,QAAA,EAAU,iBAAA,EAAmB,YAAY,QAAQ,CAAA;AACjF,QAAA;AAAA,MACF;AAAA,MACA,KAAK,MAAA,EAAQ;AAKX,QAAA,IAAI;AACF,UAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,UAAA,CAAW,MAAM,CAAA;AACrC,UAAA,IAAI,KAAA,KAAU,KAAA,CAAA;AACZ,YAAA,WAAA,CAAY,OAAO,IAAA,EAAM,GAAA,EAAK,QAAA,EAAU,iBAAA,EAAmB,YAAY,QAAQ,CAAA;AAAA,QACnF,CAAA,CAAA,MAAQ;AAAA,QAER;AACA,QAAA;AAAA,MACF;AAAA,MACA,KAAK,cAAA,EAAgB;AACnB,QAAA,MAAM,IAAA,GAAO,KAAA,CAAM,mBAAA,CAAoB,MAAM,CAAA;AAC7C,QAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,oBAAA,CAAqB,MAAM,CAAA;AAC/C,QAAA,IAAI,IAAA,KAAS,KAAA,CAAA;AACX,UAAA,WAAA,CAAY,MAAM,IAAA,EAAM,GAAA,EAAK,QAAA,EAAU,iBAAA,EAAmB,YAAY,QAAQ,CAAA;AAChF,QAAA,IAAI,KAAA,KAAU,KAAA,CAAA;AACZ,UAAA,WAAA,CAAY,OAAO,IAAA,EAAM,GAAA,EAAK,QAAA,EAAU,iBAAA,EAAmB,YAAY,QAAQ,CAAA;AACjF,QAAA;AAAA,MACF;AAAA,MACA;AACE,QAAA;AAAA;AACJ,EACF,CAAA,SAAE;AACA,IAAA,UAAA,CAAW,OAAO,MAAM,CAAA;AAAA,EAC1B;AACF;;;;"}

package/dist/shared/{attaform.D2SCCd4O.cjs → attaform.Bq5sX7TF.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-const paths = require('./attaform.z5j3LwJz.cjs');
+const paths = require('./attaform.D32WwKk6.cjs');
 
 function renderAttaformState(app) {
   const registry = paths.getRegistryFromApp(app);
@@ -36,4 +36,4 @@ const DEVTOOLS_WINDOW_KEY = "__attaform_devtools__";
 exports.DEVTOOLS_WINDOW_KEY = DEVTOOLS_WINDOW_KEY;
 exports.hydrateAttaformState = hydrateAttaformState;
 exports.renderAttaformState = renderAttaformState;
-//# sourceMappingURL=attaform.D2SCCd4O.cjs.map
+//# sourceMappingURL=attaform.Bq5sX7TF.cjs.map

package/dist/shared/{attaform.D2SCCd4O.cjs.map → attaform.Bq5sX7TF.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"attaform.D2SCCd4O.cjs","sources":["../../src/runtime/core/serialize.ts","../../src/runtime/core/devtools-shared.ts"],"sourcesContent":["import type { App } from 'vue'\nimport type { FormKey } from '../types/types-api'\nimport { pathKeyToDotted, type PathKey } from './paths'\nimport { getRegistryFromApp, type SerializedFormData } from './registry'\n\n/**\n * Serialised snapshot of every form in a Vue app, produced by\n * `renderAttaformState` and consumed by `hydrateAttaformState`.\n *\n * JSON-safe — pass to `JSON.stringify`, `devalue`, or any other\n * serialiser before embedding in your SSR payload.\n */\nexport type SerializedAttaformState = {\n  /** Tuples of `[formKey, snapshot]` for every form in the app. */\n  readonly forms: ReadonlyArray<readonly [FormKey, SerializedFormData]>\n}\n\n/**\n * Snapshot every form on a Vue app for SSR. Call from your server\n * entry after rendering the app:\n *\n * ```ts\n * import { renderToString } from '@vue/server-renderer'\n * import { renderAttaformState, escapeForInlineScript } from 'attaform'\n *\n * const html = await renderToString(app)\n * const state = renderAttaformState(app)\n * const payload = escapeForInlineScript(JSON.stringify(state))\n *\n * return `\n *   ${html}\n *   <script>window.__ATTAFORM_STATE__ = ${payload}</script>\n * `\n * ```\n *\n * Pair with `hydrateAttaformState` on the client to restore the\n * forms in their server-rendered state. Nuxt users don't need this —\n * `attaform/nuxt` wires SSR automatically.\n */\nexport function renderAttaformState(app: App): SerializedAttaformState {\n  const registry = getRegistryFromApp(app)\n  const forms: Array<readonly [FormKey, SerializedFormData]> = []\n  for (const [key, state] of registry.forms) {\n    // Skip the blank field when the set is empty so the\n    // wire payload stays minimal for forms that don't use it. The\n    // optional shape on the consuming side handles the absence\n    // cleanly (defaults to \"no blank paths\"). PathKey → dotted at\n    // the boundary so the wire shape matches the rest of the\n    // public path notation.\n    const transientList: string[] = []\n    for (const pk of state.blankPaths) {\n      const d = pathKeyToDotted(pk as PathKey)\n      if (d !== null) transientList.push(d)\n    }\n    forms.push([\n      key,\n      {\n        form: state.form.value,\n        schemaErrors: Array.from(state.schemaErrors.entries()),\n        userErrors: Array.from(state.userErrors.entries()),\n        fields: Array.from(state.fields.entries()),\n        ...(transientList.length > 0 ? { blankPaths: transientList } : {}),\n      },\n    ])\n  }\n  return { forms }\n}\n\n/**\n * Restore forms from a server-rendered snapshot on the client. Call\n * from your client entry before mounting:\n *\n * ```ts\n * import { createApp } from 'vue'\n * import { createAttaform, hydrateAttaformState } from 'attaform'\n *\n * const app = createApp(App).use(createAttaform())\n * hydrateAttaformState(app, window.__ATTAFORM_STATE__)\n * app.mount('#app')\n * ```\n *\n * The next `useForm({ key })` call for each serialised form picks up\n * the snapshot transparently — no further action is required.\n */\nexport function hydrateAttaformState(app: App, payload: SerializedAttaformState): void {\n  const registry = getRegistryFromApp(app)\n  for (const [key, data] of payload.forms) {\n    registry.pendingHydration.set(key, data)\n  }\n}\n","/**\n * Shared building blocks for Attaform's two devtools surfaces — the Vue\n * DevTools (Chrome-extension) inspector wired up in `./devtools.ts`, and\n * the Nuxt DevTools (overlay) panel wired up via `../../nuxt.ts` +\n * `../pages/_attaform_devtools.vue`.\n *\n * Houses the window-bridge contract both surfaces consume so a new\n * bridge field lands in one file. Both surfaces render RAW form values\n * by design — DevTools is a dev-only surface, and redaction across every\n * place a value surfaces is impractical security theater rather than a\n * real safeguard.\n */\nimport type { AttaformRegistry } from './registry'\n\n/**\n * Property key on `window` that the Nuxt-side dev plugin attaches the\n * bridge object to. The iframe-mounted overlay panel reads\n * `window.parent[DEVTOOLS_WINDOW_KEY]` to reach the host app's registry.\n *\n * Underscored + namespaced to make accidental collision with consumer\n * globals vanishingly unlikely. Stable across versions — bumping it\n * would silently disconnect older library builds from newer overlay\n * panels in the same browser tab during a library upgrade.\n */\nexport const DEVTOOLS_WINDOW_KEY = '__attaform_devtools__'\n\n/**\n * Shape of the object the host plugin attaches to `window` in dev mode.\n * The iframe overlay panel reads this to discover the live registry and\n * render its forms.\n *\n * Single-registry assumption: the latest `createAttaform()` install\n * wins. Multi-app pages (rare; typically only seen in micro-frontend\n * setups) will only see one app's forms in the panel. Documented but\n * not actively supported — the alternative (a Set of registries with\n * union-rendering) is a future call if a real consumer hits it.\n */\nexport interface AttaformDevtoolsBridge {\n  registry: AttaformRegistry\n  /**\n   * The library version, surfaced in the panel's footer for support /\n   * bug-report context. Read from `package.json` at host-plugin init.\n   */\n  version: string\n}\n\ndeclare global {\n  interface Window {\n    [DEVTOOLS_WINDOW_KEY]?: AttaformDevtoolsBridge\n  }\n}\n"],"names":["getRegistryFromApp","pathKeyToDotted"],"mappings":";;;;AAuCO,SAAS,oBAAoB,GAAA,EAAmC;AACrE,EAAA,MAAM,QAAA,GAAWA,yBAAmB,GAAG,CAAA;AACvC,EAAA,MAAM,QAAuD,EAAC;AAC9D,EAAA,KAAA,MAAW,CAAC,GAAA,EAAK,KAAK,CAAA,IAAK,SAAS,KAAA,EAAO;AAOzC,IAAA,MAAM,gBAA0B,EAAC;AACjC,IAAA,KAAA,MAAW,EAAA,IAAM,MAAM,UAAA,EAAY;AACjC,MAAA,MAAM,CAAA,GAAIC,sBAAgB,EAAa,CAAA;AACvC,MAAA,IAAI,CAAA,KAAM,IAAA,EAAM,aAAA,CAAc,IAAA,CAAK,CAAC,CAAA;AAAA,IACtC;AACA,IAAA,KAAA,CAAM,IAAA,CAAK;AAAA,MACT,GAAA;AAAA,MACA;AAAA,QACE,IAAA,EAAM,MAAM,IAAA,CAAK,KAAA;AAAA,QACjB,cAAc,KAAA,CAAM,IAAA,CAAK,KAAA,CAAM,YAAA,CAAa,SAAS,CAAA;AAAA,QACrD,YAAY,KAAA,CAAM,IAAA,CAAK,KAAA,CAAM,UAAA,CAAW,SAAS,CAAA;AAAA,QACjD,QAAQ,KAAA,CAAM,IAAA,CAAK,KAAA,CAAM,MAAA,CAAO,SAAS,CAAA;AAAA,QACzC,GAAI,cAAc,MAAA,GAAS,CAAA,GAAI,EAAE,UAAA,EAAY,aAAA,KAAkB;AAAC;AAClE,KACD,CAAA;AAAA,EACH;AACA,EAAA,OAAO,EAAE,KAAA,EAAM;AACjB;AAkBO,SAAS,oBAAA,CAAqB,KAAU,OAAA,EAAwC;AACrF,EAAA,MAAM,QAAA,GAAWD,yBAAmB,GAAG,CAAA;AACvC,EAAA,KAAA,MAAW,CAAC,GAAA,EAAK,IAAI,CAAA,IAAK,QAAQ,KAAA,EAAO;AACvC,IAAA,QAAA,CAAS,gBAAA,CAAiB,GAAA,CAAI,GAAA,EAAK,IAAI,CAAA;AAAA,EACzC;AACF;;ACjEO,MAAM,mBAAA,GAAsB;;;;;;"}
+{"version":3,"file":"attaform.Bq5sX7TF.cjs","sources":["../../src/runtime/core/serialize.ts","../../src/runtime/core/devtools-shared.ts"],"sourcesContent":["import type { App } from 'vue'\nimport type { FormKey } from '../types/types-api'\nimport { pathKeyToDotted, type PathKey } from './paths'\nimport { getRegistryFromApp, type SerializedFormData } from './registry'\n\n/**\n * Serialised snapshot of every form in a Vue app, produced by\n * `renderAttaformState` and consumed by `hydrateAttaformState`.\n *\n * JSON-safe — pass to `JSON.stringify`, `devalue`, or any other\n * serialiser before embedding in your SSR payload.\n */\nexport type SerializedAttaformState = {\n  /** Tuples of `[formKey, snapshot]` for every form in the app. */\n  readonly forms: ReadonlyArray<readonly [FormKey, SerializedFormData]>\n}\n\n/**\n * Snapshot every form on a Vue app for SSR. Call from your server\n * entry after rendering the app:\n *\n * ```ts\n * import { renderToString } from '@vue/server-renderer'\n * import { renderAttaformState, escapeForInlineScript } from 'attaform'\n *\n * const html = await renderToString(app)\n * const state = renderAttaformState(app)\n * const payload = escapeForInlineScript(JSON.stringify(state))\n *\n * return `\n *   ${html}\n *   <script>window.__ATTAFORM_STATE__ = ${payload}</script>\n * `\n * ```\n *\n * Pair with `hydrateAttaformState` on the client to restore the\n * forms in their server-rendered state. Nuxt users don't need this —\n * `attaform/nuxt` wires SSR automatically.\n */\nexport function renderAttaformState(app: App): SerializedAttaformState {\n  const registry = getRegistryFromApp(app)\n  const forms: Array<readonly [FormKey, SerializedFormData]> = []\n  for (const [key, state] of registry.forms) {\n    // Skip the blank field when the set is empty so the\n    // wire payload stays minimal for forms that don't use it. The\n    // optional shape on the consuming side handles the absence\n    // cleanly (defaults to \"no blank paths\"). PathKey → dotted at\n    // the boundary so the wire shape matches the rest of the\n    // public path notation.\n    const transientList: string[] = []\n    for (const pk of state.blankPaths) {\n      const d = pathKeyToDotted(pk as PathKey)\n      if (d !== null) transientList.push(d)\n    }\n    forms.push([\n      key,\n      {\n        form: state.form.value,\n        schemaErrors: Array.from(state.schemaErrors.entries()),\n        userErrors: Array.from(state.userErrors.entries()),\n        fields: Array.from(state.fields.entries()),\n        ...(transientList.length > 0 ? { blankPaths: transientList } : {}),\n      },\n    ])\n  }\n  return { forms }\n}\n\n/**\n * Restore forms from a server-rendered snapshot on the client. Call\n * from your client entry before mounting:\n *\n * ```ts\n * import { createApp } from 'vue'\n * import { createAttaform, hydrateAttaformState } from 'attaform'\n *\n * const app = createApp(App).use(createAttaform())\n * hydrateAttaformState(app, window.__ATTAFORM_STATE__)\n * app.mount('#app')\n * ```\n *\n * The next `useForm({ key })` call for each serialised form picks up\n * the snapshot transparently — no further action is required.\n */\nexport function hydrateAttaformState(app: App, payload: SerializedAttaformState): void {\n  const registry = getRegistryFromApp(app)\n  for (const [key, data] of payload.forms) {\n    registry.pendingHydration.set(key, data)\n  }\n}\n","/**\n * Shared building blocks for Attaform's two devtools surfaces — the Vue\n * DevTools (Chrome-extension) inspector wired up in `./devtools.ts`, and\n * the Nuxt DevTools (overlay) panel wired up via `../../nuxt.ts` +\n * `../pages/_attaform_devtools.vue`.\n *\n * Houses the window-bridge contract both surfaces consume so a new\n * bridge field lands in one file. Both surfaces render RAW form values\n * by design — DevTools is a dev-only surface, and redaction across every\n * place a value surfaces is impractical security theater rather than a\n * real safeguard.\n */\nimport type { AttaformRegistry } from './registry'\n\n/**\n * Property key on `window` that the Nuxt-side dev plugin attaches the\n * bridge object to. The iframe-mounted overlay panel reads\n * `window.parent[DEVTOOLS_WINDOW_KEY]` to reach the host app's registry.\n *\n * Underscored + namespaced to make accidental collision with consumer\n * globals vanishingly unlikely. Stable across versions — bumping it\n * would silently disconnect older library builds from newer overlay\n * panels in the same browser tab during a library upgrade.\n */\nexport const DEVTOOLS_WINDOW_KEY = '__attaform_devtools__'\n\n/**\n * Shape of the object the host plugin attaches to `window` in dev mode.\n * The iframe overlay panel reads this to discover the live registry and\n * render its forms.\n *\n * Single-registry assumption: the latest `createAttaform()` install\n * wins. Multi-app pages (rare; typically only seen in micro-frontend\n * setups) will only see one app's forms in the panel. Documented but\n * not actively supported — the alternative (a Set of registries with\n * union-rendering) is a future call if a real consumer hits it.\n */\nexport interface AttaformDevtoolsBridge {\n  registry: AttaformRegistry\n  /**\n   * The library version, surfaced in the panel's footer for support /\n   * bug-report context. Read from `package.json` at host-plugin init.\n   */\n  version: string\n}\n\ndeclare global {\n  interface Window {\n    [DEVTOOLS_WINDOW_KEY]?: AttaformDevtoolsBridge\n  }\n}\n"],"names":["getRegistryFromApp","pathKeyToDotted"],"mappings":";;;;AAuCO,SAAS,oBAAoB,GAAA,EAAmC;AACrE,EAAA,MAAM,QAAA,GAAWA,yBAAmB,GAAG,CAAA;AACvC,EAAA,MAAM,QAAuD,EAAC;AAC9D,EAAA,KAAA,MAAW,CAAC,GAAA,EAAK,KAAK,CAAA,IAAK,SAAS,KAAA,EAAO;AAOzC,IAAA,MAAM,gBAA0B,EAAC;AACjC,IAAA,KAAA,MAAW,EAAA,IAAM,MAAM,UAAA,EAAY;AACjC,MAAA,MAAM,CAAA,GAAIC,sBAAgB,EAAa,CAAA;AACvC,MAAA,IAAI,CAAA,KAAM,IAAA,EAAM,aAAA,CAAc,IAAA,CAAK,CAAC,CAAA;AAAA,IACtC;AACA,IAAA,KAAA,CAAM,IAAA,CAAK;AAAA,MACT,GAAA;AAAA,MACA;AAAA,QACE,IAAA,EAAM,MAAM,IAAA,CAAK,KAAA;AAAA,QACjB,cAAc,KAAA,CAAM,IAAA,CAAK,KAAA,CAAM,YAAA,CAAa,SAAS,CAAA;AAAA,QACrD,YAAY,KAAA,CAAM,IAAA,CAAK,KAAA,CAAM,UAAA,CAAW,SAAS,CAAA;AAAA,QACjD,QAAQ,KAAA,CAAM,IAAA,CAAK,KAAA,CAAM,MAAA,CAAO,SAAS,CAAA;AAAA,QACzC,GAAI,cAAc,MAAA,GAAS,CAAA,GAAI,EAAE,UAAA,EAAY,aAAA,KAAkB;AAAC;AAClE,KACD,CAAA;AAAA,EACH;AACA,EAAA,OAAO,EAAE,KAAA,EAAM;AACjB;AAkBO,SAAS,oBAAA,CAAqB,KAAU,OAAA,EAAwC;AACrF,EAAA,MAAM,QAAA,GAAWD,yBAAmB,GAAG,CAAA;AACvC,EAAA,KAAA,MAAW,CAAC,GAAA,EAAK,IAAI,CAAA,IAAK,QAAQ,KAAA,EAAO;AACvC,IAAA,QAAA,CAAS,gBAAA,CAAiB,GAAA,CAAI,GAAA,EAAK,IAAI,CAAA;AAAA,EACzC;AACF;;ACjEO,MAAM,mBAAA,GAAsB;;;;;;"}

package/dist/shared/{attaform.ceGEAEMk.d.ts → attaform.Bv7dRDWK.d.ts}

@@ -1,4 +1,4 @@
-import { t as FormKey, ae as SlimPrimitiveKind, C as CoercionEntry, g as CoercionRegistry, G as GenericForm, T as PathKey, S as Path, am as ValidationError, A as AbstractSchema, x as GetDisplayState, aq as WriteMeta, D as DeepPartial, ar as WriteShape, ak as ValidateOn, Y as PersistOptInRegistry, f as AttaformDefaults, aj as UseFormReturnType, a8 as RegisterValue } from './attaform.99cfHcIt.js';
+import { v as FormKey, V as PathKey, m as DisplayCtx, z as GetDisplayState, n as DisplayMachine, ag as SlimPrimitiveKind, C as CoercionEntry, g as CoercionRegistry, G as GenericForm, U as Path, ap as ValidationError, A as AbstractSchema, at as WriteMeta, D as DeepPartial, au as WriteShape, aj as TransformAbortHolder, an as ValidateOn, _ as PersistOptInRegistry, f as AttaformDefaults, am as UseFormReturnType, aa as RegisterValue } from './attaform.D0dWZsJt.js';
 import { Ref, ComputedRef, App, InjectionKey } from 'vue';
 
 /**
@@ -414,6 +414,13 @@ type WizardForms<S> = FormsRecordOf<S> & Readonly<Record<FormKey, AnyForm>>;
  *  - `submissionAttempts` — count of `wizard.handleSubmit` invocations
  *                    (success or failure). Always bumps, including on
  *                    noop-form steps.
+ *  - `submitError` — the error thrown by the most recent
+ *                    `wizard.handleSubmit` callback (or its `onError`),
+ *                    coerced to a real `Error`. Mirrors
+ *                    `form.meta.submitError`: cleared at submit entry and
+ *                    by `reset()`, parked here rather than re-thrown, so
+ *                    the handler resolves and never manufactures a
+ *                    `window` unhandledrejection. `null` on success.
  *  - `visited`     — append-only breadcrumb of navigated step keys.
  *                    `back()` does not pop; the trail is the audit
  *                    log, not the back-stack.
@@ -447,6 +454,7 @@ type UseWizardReturnType<S extends ReadonlyArray<StepSlot> = ReadonlyArray<StepS
     readonly done: boolean;
     readonly submitting: boolean;
     readonly submissionAttempts: number;
+    readonly submitError: Error | null;
     readonly visited: readonly FormKey[];
     readonly next: () => Promise<void>;
     readonly back: () => void;
@@ -455,6 +463,68 @@ type UseWizardReturnType<S extends ReadonlyArray<StepSlot> = ReadonlyArray<StepS
     readonly reset: () => void;
 };
 
+/**
+ * Per-form display engine: owns the clock and the timers that the pure
+ * `getDisplayState` reducer policy needs, so the reducer itself stays a
+ * deterministic `(prev, ctx) => next` function.
+ *
+ * It keeps a `Map` of the machines that are still *active* (a spinner is
+ * showing, a verdict is being held, or a `reviewAt` deadline is pending),
+ * a single reactive `tick` ref, and a single `setTimeout` aimed at the
+ * nearest `reviewAt` across every active field. When a field-state
+ * computed reads `resolve`, it subscribes to `tick`; when the timer
+ * fires, `tick` bumps and every dependent computed re-runs the reducer,
+ * so a field whose deadline elapsed transitions (verdict → spinner, or
+ * spinner → settled verdict) without any per-field watcher.
+ *
+ * Eviction: a machine is dropped once it reaches a terminal *idle* state
+ * with no pending review. Error / success / pending machines are retained
+ * so the reducer can hold the prior verdict under the show-delay window of
+ * the *next* validation streak (no success → idle → success flicker). The
+ * retained set is bounded by the rendered non-idle fields; none of them
+ * arm a timer, so retention costs memory, never CPU.
+ *
+ * Untrusted reducer: `getDisplayState` is consumer-overridable, so the
+ * engine treats the returned `reviewAt` as untrusted. A non-finite deadline
+ * (NaN / ±Infinity from a custom predicate's bad arithmetic) is ignored
+ * rather than handed to `setTimeout`, where it coerces to 0 and spins; an
+ * over-large finite deadline is clamped below the 32-bit `setTimeout`
+ * overflow; and the timer refuses to re-arm for the exact deadline it just
+ * fired, so a predicate re-emitting a fixed or past `reviewAt` can't drive an
+ * infinite fire loop. None of these arise from the library default, which
+ * always advances its deadline or drops it.
+ *
+ * Background tabs: `setTimeout` is throttled to >= 1s while a tab is hidden,
+ * so a min-visible hold can overshoot. A `visibilitychange` listener bumps
+ * the clock on return to the foreground, so any overdue deadline resolves at
+ * once instead of lingering.
+ *
+ * SSR: no clock, no timers, no listener. With `now` frozen and nothing
+ * validating at render, the reducer returns the plain verdict (never
+ * pending) and the engine stores nothing, so the server HTML and the
+ * client's first render agree — no hydration mismatch on the display
+ * projection.
+ */
+type DisplayEngine = {
+    /**
+     * Resolve a path's next `DisplayMachine`. Subscribes the calling
+     * computed to the engine clock, threads the path's previous machine
+     * through `reducer`, persists or evicts the result, and re-arms the
+     * single timer to the nearest deadline.
+     */
+    resolve(key: PathKey, ctx: DisplayCtx, reducer: GetDisplayState): DisplayMachine;
+    /** Drop every retained machine and cancel the timer (used by `reset()`). */
+    clear(): void;
+    /** Tear down for good: `clear()` plus detaching the visibility listener. */
+    dispose(): void;
+    /** Introspection for tests: count of retained machines. */
+    size(): number;
+    /** Introspection for tests: whether a path currently has a retained machine. */
+    has(key: PathKey): boolean;
+    /** Introspection for tests: whether a deadline timer is currently armed. */
+    hasTimer(): boolean;
+};
+
 /**
  * Schema-driven coercion of user-typed DOM values at the v-register
  * directive layer. When the slim schema declares a numeric or
@@ -669,6 +739,16 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * read.
      */
     readonly getDisplayState: GetDisplayState;
+    /**
+     * Per-form display engine: owns the clock and the single timer the timed
+     * `getDisplayState` reducer policy needs, keeping the reducer itself a
+     * pure `(prev, ctx) => next` function. The field-state computeds route
+     * every `displayState` read through `displayEngine.resolve(...)`, which
+     * threads the path's previous machine, persists or evicts the result, and
+     * re-arms the nearest-deadline timer. Constructed once at form
+     * construction; torn down via `registerCleanup` on store eviction.
+     */
+    readonly displayEngine: DisplayEngine;
     readonly submitting: Ref<boolean>;
     readonly activeSubmissions: Ref<number>;
     readonly submissionAttempts: Ref<number>;
@@ -679,7 +759,7 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * alongside the rest of the submission surface.
      */
     readonly submitted: Ref<boolean>;
-    readonly submitError: Ref<unknown>;
+    readonly submitError: Ref<Error | null>;
     readonly departAttempts: Ref<number>;
     /**
      * `true` while a function-form `defaultValues` factory is in flight.
@@ -838,6 +918,61 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * computed only re-runs when the count for ITS key changes.
      */
     readonly fieldValidationCounts: Map<PathKey, number>;
+    /**
+     * Per-path `Date.now()` stamp marking when the field's LATEST validation
+     * run started, re-anchored on every run start (every increment), deleted
+     * on the `→ 0` edge. The display reducer reads it as `ctx.validatingSince`
+     * to time the anti-flash spinner, which measures `now - validatingSince`:
+     * re-anchoring on each run means a burst of keystrokes (each aborting the
+     * prior run and starting a new one) keeps pushing the stamp forward, so the
+     * spinner stays suppressed until the user pauses rather than surfacing
+     * mid-typing. Anchoring only at the streak start would pin it to the first
+     * keystroke, because with `debounceMs: 0` the aborted run's decrement lands
+     * after the next run's increment and the count never returns to 0 between
+     * fast keystrokes. The field-state container walk takes the descendant-min
+     * so a row spinner anchors at its earliest still-active leaf. Runtime-only,
+     * never hydrated, like the counts. REACTIVE: the display computed reads this
+     * (as `ctx.validatingSince`) but not the `validating` flag, and a long
+     * validation that settles with an unchanged verdict (same error, still
+     * invalid) leaves `errors` / `valid` untouched — so a non-reactive map would
+     * leave a held `pending` spinner stranded after the run ends, until some
+     * unrelated reactive change happened to re-run the computed. Reactivity ties
+     * the computed to both the streak start (set) and end (delete).
+     */
+    readonly fieldValidatingSince: Map<PathKey, number>;
+    /**
+     * Per-path counter of in-flight async-transform runs (the async
+     * branch of the `register({ transforms })` pipeline). `> 0` drives
+     * `field.transforming` / `field.busy`. Counter, not flag, for the
+     * same overlap reason as `fieldValidationCounts`, except a superseding
+     * input releases the prior run synchronously before incrementing the
+     * new one — so the count is the live in-flight depth at the path
+     * (effectively 0 or 1). Reactive Map, like the validation counters.
+     */
+    readonly fieldTransformCounts: Map<PathKey, number>;
+    /**
+     * Per-path `ssr ? 0 : Date.now()` stamp marking when the path's latest
+     * async transform opened; the display reducer reads it (as
+     * `ctx.transformingSince`) to time the gated busy spinner. Mirrors
+     * `fieldValidatingSince` exactly: re-anchored on each run start,
+     * deleted on the `→ 0` edge, reactive for the held-spinner reason.
+     */
+    readonly fieldTransformingSince: Map<PathKey, number>;
+    /**
+     * Per-path latest async-transform failure (a rejected transform, or a
+     * resolved value the write gate refused), surfaced as
+     * `field.transformError`. Cleared when a fresh run opens at the path
+     * and on `reset()`. A channel separate from validation `errors`.
+     */
+    readonly transformErrors: Map<PathKey, Error | null>;
+    /**
+     * Form-wide count of in-flight async-transform runs. Drives the
+     * `settleTransforms` quiescence guard and the `handleSubmit` drain
+     * barrier. `Math.max(0, …)`-clamped on release so a doubled decrement
+     * (a run's own `endTransform` after a synchronous cancel release)
+     * can't drive it negative.
+     */
+    readonly activeTransforms: Ref<number>;
     /**
      * Replace the form value wholesale. Optional `meta` is forwarded to
      * every `onFormChange` listener so they can decide whether THIS write
@@ -1005,6 +1140,41 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * at entry (submit validation is authoritative) and by `reset()`.
      */
     cancelFieldValidation(): void;
+    /**
+     * Open an async-transform run at `key` — bump the run token, increment
+     * the in-flight counters, stamp `transformingSince`, clear any prior
+     * `transformError`, register `holder` for later abort. Returns the run
+     * token. See `InternalRegisterValue.beginTransform`.
+     */
+    beginTransform(key: PathKey, holder: TransformAbortHolder): number;
+    /** `true` while `token` is the live async-transform run at `key`. */
+    isCurrentTransform(key: PathKey, token: number): boolean;
+    /**
+     * Close the run `token` at `key`: release the counters (no-op if the
+     * run was already released by a supersede / cancel) and flush settled
+     * `settleTransforms` waiters.
+     */
+    endTransform(key: PathKey, token: number): void;
+    /** Record a per-field normalization failure at `key` (`field.transformError`). */
+    setTransformError(key: PathKey, err: Error): void;
+    /**
+     * Abort + release every in-flight async-transform run (all paths) and
+     * clear `transformErrors`. Mirrors `cancelFieldValidation`; called by
+     * `reset()` and store teardown.
+     */
+    cancelTransforms(): void;
+    /**
+     * Path-scoped counterpart to `cancelTransforms`: abort + release only
+     * the runs at-or-under `prefix`, clearing their `transformError`.
+     * Called by `resetField`.
+     */
+    cancelTransformsUnder(prefix: Path): void;
+    /**
+     * Resolve once async transforms are quiescent — globally (`path`
+     * omitted) or at-or-under `path`. Resolve-never-reject. See
+     * `UseFormReturnType.settleTransforms`.
+     */
+    settleTransforms(path?: string | Path): Promise<void>;
     /**
      * Kick off (or schedule) a field-level validation run for `path`. Pass
      * `path = []` to cover the whole form; `applySchemaErrorsForSubtree`

package/dist/shared/attaform.C3Doa9Pt.mjs

@@ -0,0 +1,24 @@
+import { r as resolveZodAliasTarget, Z as ZOD_UNIFIED_SPECIFIER } from './attaform.sHkHv_98.mjs';
+
+const TAP_NAME = "attaform";
+function createWebpackFamilyPlugin(tag, options) {
+  const resolveZodAlias = options.resolveZodAlias !== false;
+  const warnState = { warned: false };
+  return {
+    apply(compiler) {
+      const root = compiler.context ?? options.root ?? process.cwd();
+      const target = resolveZodAliasTarget(root, tag, resolveZodAlias, warnState);
+      if (target === null) return;
+      compiler.hooks.normalModuleFactory.tap(TAP_NAME, (factory) => {
+        factory.hooks.beforeResolve.tap(TAP_NAME, (data) => {
+          if (data.request === ZOD_UNIFIED_SPECIFIER) {
+            data.request = target;
+          }
+        });
+      });
+    }
+  };
+}
+
+export { createWebpackFamilyPlugin as c };
+//# sourceMappingURL=attaform.C3Doa9Pt.mjs.map