attaform 0.28.0 → 0.30.0

package/skills/attaform/references/wizards.md

@@ -12,6 +12,8 @@ A step slot is one of:
 - a **function** returning any of those, for runtime branching,
 - a `lazy((ctx) => ...)`-wrapped function, which memoizes its resolution and re-fires only when its own tracked reads change.
 
+`gate(slot)` wraps any of them rather than being a kind of its own: it marks that position a hard prerequisite and leaves how the slot resolves alone. A function slot may return one, so whether a position is a gate can itself be a runtime decision.
+
 ```ts
 import { useForm, useWizard } from 'attaform'
 
@@ -24,7 +26,7 @@ const wizard = useWizard({ key: 'onboarding', steps: [account, 'review', profile
 ## Navigation vs submission
 
 - **`wizard.tryNext(): Promise<boolean>`** is the gated Next. It validates the active step and advances only on a clean pass, revealing that step's errors in place otherwise. It resolves to whether it advanced, and it is inline-bindable: `@click="wizard.tryNext()"`.
-- **`wizard.next()` / `wizard.back()` / `wizard.goTo(key)`** are positional moves with no validation gate. Use them for a Back button or a jump; use `tryNext` for a forward move that should validate.
+- **`wizard.next()` / `wizard.back()` / `wizard.goTo(key)`** are positional moves with no validation gate. Use them for a Back button or a jump; use `tryNext` for a forward move that should validate. Two exceptions: they refuse while a submit is in flight, and `next()` on an **uncleared `gate()` step behaves as `tryNext()`**, so wiring Next straight to it can never skip the gate's confirmation. Once that gate clears, `next()` is plain navigation again and does not re-submit.
 - **`wizard.handleSubmit(onSubmit, onError?)`** validates **every** step from any position and calls `onSubmit` once with all forms' values. It **never advances**. Wire it to the final Submit.
 
 For a forward move that runs a custom callback before advancing, compose the step form's own submit with `next`:
@@ -58,9 +60,9 @@ const onComplete = wizard.handleSubmit(async (ctx) => {
 
 The wizard handle exposes the flow's rolled-up state, all reactive:
 
-- `wizard.forms[key]`: the live form handle for a step (a facade typed as a form).
+- `wizard.forms[key]`: the step's own form handle, identity-equal to the `useForm` ref that was slotted in.
 - `wizard.allValues` / `wizard.allErrors`: every form's values / aggregate errors, keyed.
-- `wizard.activeForm`: the currently active step's form facade.
+- `wizard.activeForm`: a live facade over whichever step is active, so a handler captured once retargets as the pin moves. Not the handle itself: use `wizard.forms[key]` for that.
 - `wizard.statuses`: per-form status. Plus `wizard.progress`, `wizard.canAdvance`, `wizard.canGoBack`, `wizard.isFinalStep`, `wizard.visited`.
 
 ## A declarative step registry
@@ -94,11 +96,11 @@ const wizard = useWizard({
 
 Everything derives from the registry: the step slots, the titles, any persisted key list. Add, remove, reorder, or gate a step by editing the registry alone. Do not add speculative registry fields with no consumer; add a hook when the second consumer arrives.
 
-## Keyed injection resolves by tree and timing
+## Keyed injection resolves by name and timing
 
-A string key passed to `injectForm('account')` or `injectWizard('onboarding')` _reads_ like a global address but resolves by the **caller's component-tree position and mount timing**, not as a global lookup:
+A string key passed to `injectForm('account')` or `injectWizard('onboarding')` is a name in Attaform's app-level registry, not a location in the component tree:
 
-- `provide` / `inject` is descendant-only, so a form created in a **leaf** is unreachable from an **ancestor**.
-- A keyed form is not resolvable until the creating component's `setup` has run, so mount order matters.
+- **Position-independent.** The lookup reaches any component in the app: a sibling branch, a floating toolbar, a teleported modal. Extracting a wrapper or changing how deep a component sits never changes what a key resolves to. The no-key ambient form is the opposite, and is the one that runs on `provide` / `inject`: it reaches descendants of the owning `useForm` only.
+- **Time-dependent.** The registry entry appears when the owner's own `useForm({ key })` / `useWizard({ key })` setup runs, and not before.
 
-The consequence: a purely structural refactor can silently break a lookup. The stable shape is to **lift a shared form's creation to the coordinating ancestor** (the component that owns the wizard) and have leaves `injectForm(key)` it downward by a prop key. Always chain `?.` on the result, which is `T | null`.
+Together they give one rule: **resolve downward.** Vue runs a parent's setup before its children's, so a descendant reaching an ancestor's keyed form always resolves, while an ancestor reaching a descendant's gets `null`. The stable shape is to **lift a shared form's creation to the coordinating ancestor** (the component that owns the wizard) and reach for it at or below that point. Always chain `?.` on the result, which is `T | null`.

package/dist/chunks/fingerprint.mjs

@@ -1,183 +0,0 @@
-import { c as canonicalStringify } from '../shared/attaform.BJGA_UOS.mjs';
-
-const cyclicSentinel = "<cyclic>";
-function fingerprintZodSchema(schema) {
-  const cache = /* @__PURE__ */ new WeakMap();
-  const inProgress = /* @__PURE__ */ new WeakSet();
-  return visit(schema, cache, inProgress);
-}
-function visit(schema, cache, inProgress) {
-  const key = schema;
-  const cached = cache.get(key);
-  if (cached !== void 0) return cached;
-  if (inProgress.has(key)) return cyclicSentinel;
-  inProgress.add(key);
-  try {
-    const computed = computeFingerprint(schema, cache, inProgress);
-    cache.set(key, computed);
-    return computed;
-  } finally {
-    inProgress.delete(key);
-  }
-}
-function getDef(schema) {
-  return schema._def;
-}
-function computeFingerprint(schema, cache, inProgress) {
-  const def = getDef(schema);
-  const kind = def.typeName ?? "ZodUnknown";
-  const recurse = (child) => visit(child, cache, inProgress);
-  switch (kind) {
-    case "ZodString":
-    case "ZodNumber":
-    case "ZodBigInt":
-    case "ZodDate":
-      return `${kind}${formatChecks(def.checks)}`;
-    case "ZodBoolean":
-    case "ZodNull":
-    case "ZodUndefined":
-    case "ZodAny":
-    case "ZodUnknown":
-    case "ZodNaN":
-    case "ZodVoid":
-    case "ZodNever":
-      return kind;
-    case "ZodLiteral":
-      return `ZodLiteral:${canonicalStringify(def.value)}`;
-    case "ZodEnum": {
-      const values = Array.isArray(def.values) ? def.values : [];
-      const sorted = [...values].sort((a, b) => {
-        const as = String(a);
-        const bs = String(b);
-        return as < bs ? -1 : as > bs ? 1 : 0;
-      });
-      return `ZodEnum:${canonicalStringify(sorted)}`;
-    }
-    case "ZodNativeEnum": {
-      const values = def.values && typeof def.values === "object" && !Array.isArray(def.values) ? Object.values(def.values) : [];
-      const sorted = [...values].sort((a, b) => {
-        const as = String(a);
-        const bs = String(b);
-        return as < bs ? -1 : as > bs ? 1 : 0;
-      });
-      return `ZodNativeEnum:${canonicalStringify(sorted)}`;
-    }
-    case "ZodObject": {
-      const shape = readShapeSafely(def);
-      const sortedEntries = Object.entries(shape).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${recurse(v)}`);
-      return `ZodObject{${sortedEntries.join(",")}}${formatChecks(def.checks)}`;
-    }
-    case "ZodArray":
-      return `ZodArray[${def.type === void 0 ? "?" : recurse(def.type)}]${formatChecks(def.checks)}`;
-    case "ZodTuple": {
-      const items = def.items ?? [];
-      return `ZodTuple[${items.map(recurse).join(",")}]`;
-    }
-    case "ZodRecord": {
-      const keyPart = def.keyType === void 0 ? "?" : recurse(def.keyType);
-      const valuePart = def.valueType === void 0 ? "?" : recurse(def.valueType);
-      return `ZodRecord<${keyPart},${valuePart}>`;
-    }
-    case "ZodUnion": {
-      const options = (def.options ?? []).map(recurse).sort();
-      return `ZodUnion(${options.join("|")})`;
-    }
-    case "ZodDiscriminatedUnion": {
-      const disc = def.discriminator ?? "?";
-      const options = (def.options ?? []).map(recurse).sort();
-      return `ZodDiscriminatedUnion[${JSON.stringify(disc)}](${options.join("|")})`;
-    }
-    case "ZodOptional": {
-      const inner = def.innerType;
-      return inner === void 0 ? "ZodOptional(?)" : `ZodOptional(${recurse(inner)})`;
-    }
-    case "ZodNullable": {
-      const inner = def.innerType;
-      return inner === void 0 ? "ZodNullable(?)" : `ZodNullable(${recurse(inner)})`;
-    }
-    case "ZodDefault": {
-      const inner = def.innerType;
-      return `ZodDefault[${defaultFactoryRepr(def.defaultValue)}](${inner === void 0 ? "?" : recurse(inner)})`;
-    }
-    case "ZodReadonly": {
-      const inner = def.innerType;
-      return inner === void 0 ? "ZodReadonly(?)" : `ZodReadonly(${recurse(inner)})`;
-    }
-    case "ZodEffects": {
-      const effectType = def.effect?.type ?? "effect";
-      const inner = def.schema;
-      return `ZodEffects:${effectType}:fn:*(${inner === void 0 ? "?" : recurse(inner)})`;
-    }
-    case "ZodPipeline": {
-      const inner = def.in ?? def.out;
-      return inner === void 0 ? "ZodPipeline(?)" : `ZodPipeline(${recurse(inner)})`;
-    }
-    case "ZodCatch": {
-      const inner = def.innerType ?? def.schema;
-      const catchRepr = defaultFactoryRepr(def.catchValue);
-      return `ZodCatch[${catchRepr}](${inner === void 0 ? "?" : recurse(inner)})`;
-    }
-    case "ZodLazy": {
-      const resolve = def.getter;
-      if (typeof resolve !== "function") return "ZodLazy(?)";
-      try {
-        const inner = resolve();
-        return `ZodLazy(${recurse(inner)})`;
-      } catch {
-        return "ZodLazy(?)";
-      }
-    }
-    case "ZodIntersection": {
-      const leftPart = def.left === void 0 ? "?" : recurse(def.left);
-      const rightPart = def.right === void 0 ? "?" : recurse(def.right);
-      const parts = [leftPart, rightPart].sort();
-      return `ZodIntersection(${parts.join("&")})`;
-    }
-    case "ZodSet": {
-      const inner = def.valueType;
-      return inner === void 0 ? "ZodSet(?)" : `ZodSet<${recurse(inner)}>${formatChecks(def.checks)}`;
-    }
-    case "ZodBranded": {
-      const inner = def.type;
-      return inner === void 0 ? "ZodBranded(?)" : `ZodBranded(${recurse(inner)})`;
-    }
-    // Structural opacity — schemas whose runtime behaviour isn't
-    // introspectable via `_def` fall here. Still distinguishable
-    // from other kinds by the returned string.
-    case "ZodPromise":
-    case "ZodFunction":
-    case "ZodMap":
-    case "ZodSymbol":
-    default:
-      return `${kind}:*`;
-  }
-}
-function readShapeSafely(def) {
-  if (typeof def.shape !== "function") return {};
-  try {
-    return def.shape();
-  } catch {
-    return {};
-  }
-}
-function defaultFactoryRepr(factory) {
-  if (typeof factory !== "function") return "none";
-  let first;
-  let second;
-  try {
-    first = factory();
-    second = factory();
-  } catch {
-    return "fn:*";
-  }
-  if (!Object.is(first, second)) return "fn:*";
-  if (typeof first === "function") return "fn:*";
-  return canonicalStringify(first);
-}
-function formatChecks(checks) {
-  if (!Array.isArray(checks) || checks.length === 0) return "";
-  const parts = checks.map((c) => canonicalStringify(c)).sort();
-  return `[${parts.join(";")}]`;
-}
-
-export { fingerprintZodSchema };

package/dist/chunks/fingerprint2.mjs

@@ -1,159 +0,0 @@
-import { c as canonicalStringify } from '../shared/attaform.BJGA_UOS.mjs';
-import { k as kindOf, g as getIntersectionLeft, b as getIntersectionRight, c as unwrapLazy, d as unwrapInner, e as unwrapPipe, f as getDiscriminator, h as getDiscriminatedOptions, i as getUnionOptions, j as getRecordKeyType, l as getRecordValueType, m as getTupleItems, n as getSetValueType, o as getArrayElement, p as getObjectShape, q as getEnumValues, r as getLiteralValues, s as getChecks, t as getCatchDefault, v as getDefaultValue } from '../shared/attaform.NLmerepI.mjs';
-
-const cyclicSentinel = "<cyclic>";
-function fingerprintZodSchema(schema) {
-  const cache = /* @__PURE__ */ new WeakMap();
-  const inProgress = /* @__PURE__ */ new WeakSet();
-  return visit(schema, cache, inProgress);
-}
-function visit(schema, cache, inProgress) {
-  const cached = cache.get(schema);
-  if (cached !== void 0) return cached;
-  if (inProgress.has(schema)) return cyclicSentinel;
-  inProgress.add(schema);
-  try {
-    const computed = computeFingerprint(schema, cache, inProgress);
-    cache.set(schema, computed);
-    return computed;
-  } finally {
-    inProgress.delete(schema);
-  }
-}
-function computeFingerprint(schema, cache, inProgress) {
-  const kind = kindOf(schema);
-  const recurse = (child) => visit(child, cache, inProgress);
-  switch (kind) {
-    // Kind-only leaves: no further structure to descend into.
-    case "boolean":
-    case "null":
-    case "undefined":
-    case "any":
-    case "unknown":
-    case "nan":
-    case "void":
-    case "never":
-      return kind;
-    // Leaves with checks (min/max/email/regex/...). Checks are
-    // canonicalised and sorted so `.min(3).max(10)` and `.max(10).min(3)`
-    // produce identical fingerprints.
-    case "string":
-    case "number":
-    case "bigint":
-    case "date":
-      return `${kind}${formatChecks(schema)}`;
-    case "literal": {
-      const values = [...getLiteralValues(schema)].sort((a, b) => {
-        const as = canonicalStringify(a);
-        const bs = canonicalStringify(b);
-        return as < bs ? -1 : as > bs ? 1 : 0;
-      });
-      return `literal:${canonicalStringify(values)}`;
-    }
-    case "enum":
-      return `enum:${canonicalStringify([...getEnumValues(schema)].sort((a, b) => compare(a, b)))}`;
-    case "object": {
-      const shape = getObjectShape(schema);
-      const sortedEntries = Object.entries(shape).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${recurse(v)}`);
-      return `object{${sortedEntries.join(",")}}${formatChecks(schema)}`;
-    }
-    case "array":
-      return `array[${recurse(getArrayElement(schema))}]${formatChecks(schema)}`;
-    case "set":
-      return `set<${recurse(getSetValueType(schema))}>${formatChecks(schema)}`;
-    case "tuple":
-      return `tuple[${getTupleItems(schema).map(recurse).join(",")}]`;
-    case "record":
-      return `record<${recurse(getRecordKeyType(schema))},${recurse(getRecordValueType(schema))}>`;
-    case "union": {
-      const options = getUnionOptions(schema).map(recurse).sort();
-      return `union(${options.join("|")})`;
-    }
-    case "discriminated-union": {
-      const disc = getDiscriminator(schema) ?? "?";
-      const options = getDiscriminatedOptions(schema).map(recurse).sort();
-      return `dunion[${JSON.stringify(disc)}](${options.join("|")})`;
-    }
-    case "optional": {
-      const inner = unwrapInner(schema);
-      return inner === void 0 ? "optional(?)" : `optional(${recurse(inner)})`;
-    }
-    case "nullable": {
-      const inner = unwrapInner(schema);
-      return inner === void 0 ? "nullable(?)" : `nullable(${recurse(inner)})`;
-    }
-    case "default": {
-      const inner = unwrapInner(schema);
-      return `default[${stableValueRepr(getDefaultValue, schema)}](${inner === void 0 ? "?" : recurse(inner)})`;
-    }
-    case "readonly": {
-      const inner = unwrapInner(schema);
-      return inner === void 0 ? "readonly(?)" : `readonly(${recurse(inner)})`;
-    }
-    case "pipe": {
-      const inner = unwrapPipe(schema);
-      return inner === void 0 ? "pipe(?)" : `pipe(${recurse(inner)})`;
-    }
-    case "catch": {
-      const inner = unwrapInner(schema);
-      return `catch[${stableValueRepr(getCatchDefault, schema)}](${inner === void 0 ? "?" : recurse(inner)})`;
-    }
-    case "lazy": {
-      const inner = unwrapLazy(schema);
-      return inner === void 0 ? "lazy(?)" : `lazy(${recurse(inner)})`;
-    }
-    case "intersection": {
-      const left = getIntersectionLeft(schema);
-      const right = getIntersectionRight(schema);
-      const leftFp = left === void 0 ? "?" : recurse(left);
-      const rightFp = right === void 0 ? "?" : recurse(right);
-      const parts = [leftFp, rightFp].sort();
-      return `intersection(${parts.join("&")})`;
-    }
-    // Structural shape isn't observable for these. Bucket them into
-    // kind-only fingerprints — a schema-mismatch warning can't do
-    // better than "both are `custom`" here, but that still catches
-    // `object` vs `custom` mismatches. `map` / `symbol` / `function`
-    // are rejected at adapter construction; kept here for exhaustive
-    // switch safety when `fingerprintSchema` is called from tooling.
-    case "promise":
-    case "custom":
-    case "template-literal":
-    case "transform":
-    case "file":
-    case "map":
-    case "symbol":
-    case "function":
-      return `${kind}:*`;
-    default: {
-      const _ = kind;
-      return `unknown:${String(_)}`;
-    }
-  }
-}
-function stableValueRepr(get, schema) {
-  const first = get(schema);
-  const second = get(schema);
-  if (!Object.is(first, second) || typeof first === "function") return "fn:*";
-  return canonicalStringify(first);
-}
-function formatChecks(schema) {
-  const checks = getChecks(schema);
-  if (checks.length === 0) return "";
-  const parts = checks.map((c) => serializeCheck(c)).sort();
-  return `[${parts.join(";")}]`;
-}
-function serializeCheck(check) {
-  if (check !== null && typeof check === "object") {
-    const def = check._zod?.def;
-    if (def !== void 0) return canonicalStringify(def);
-  }
-  return canonicalStringify(check);
-}
-function compare(a, b) {
-  const as = String(a);
-  const bs = String(b);
-  return as < bs ? -1 : as > bs ? 1 : 0;
-}
-
-export { fingerprintZodSchema };

package/dist/dev/chunks/fingerprint.mjs

@@ -1,183 +0,0 @@
-import { c as canonicalStringify } from '../shared/attaform-dev.BJGA_UOS.mjs';
-
-const cyclicSentinel = "<cyclic>";
-function fingerprintZodSchema(schema) {
-  const cache = /* @__PURE__ */ new WeakMap();
-  const inProgress = /* @__PURE__ */ new WeakSet();
-  return visit(schema, cache, inProgress);
-}
-function visit(schema, cache, inProgress) {
-  const key = schema;
-  const cached = cache.get(key);
-  if (cached !== void 0) return cached;
-  if (inProgress.has(key)) return cyclicSentinel;
-  inProgress.add(key);
-  try {
-    const computed = computeFingerprint(schema, cache, inProgress);
-    cache.set(key, computed);
-    return computed;
-  } finally {
-    inProgress.delete(key);
-  }
-}
-function getDef(schema) {
-  return schema._def;
-}
-function computeFingerprint(schema, cache, inProgress) {
-  const def = getDef(schema);
-  const kind = def.typeName ?? "ZodUnknown";
-  const recurse = (child) => visit(child, cache, inProgress);
-  switch (kind) {
-    case "ZodString":
-    case "ZodNumber":
-    case "ZodBigInt":
-    case "ZodDate":
-      return `${kind}${formatChecks(def.checks)}`;
-    case "ZodBoolean":
-    case "ZodNull":
-    case "ZodUndefined":
-    case "ZodAny":
-    case "ZodUnknown":
-    case "ZodNaN":
-    case "ZodVoid":
-    case "ZodNever":
-      return kind;
-    case "ZodLiteral":
-      return `ZodLiteral:${canonicalStringify(def.value)}`;
-    case "ZodEnum": {
-      const values = Array.isArray(def.values) ? def.values : [];
-      const sorted = [...values].sort((a, b) => {
-        const as = String(a);
-        const bs = String(b);
-        return as < bs ? -1 : as > bs ? 1 : 0;
-      });
-      return `ZodEnum:${canonicalStringify(sorted)}`;
-    }
-    case "ZodNativeEnum": {
-      const values = def.values && typeof def.values === "object" && !Array.isArray(def.values) ? Object.values(def.values) : [];
-      const sorted = [...values].sort((a, b) => {
-        const as = String(a);
-        const bs = String(b);
-        return as < bs ? -1 : as > bs ? 1 : 0;
-      });
-      return `ZodNativeEnum:${canonicalStringify(sorted)}`;
-    }
-    case "ZodObject": {
-      const shape = readShapeSafely(def);
-      const sortedEntries = Object.entries(shape).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${recurse(v)}`);
-      return `ZodObject{${sortedEntries.join(",")}}${formatChecks(def.checks)}`;
-    }
-    case "ZodArray":
-      return `ZodArray[${def.type === void 0 ? "?" : recurse(def.type)}]${formatChecks(def.checks)}`;
-    case "ZodTuple": {
-      const items = def.items ?? [];
-      return `ZodTuple[${items.map(recurse).join(",")}]`;
-    }
-    case "ZodRecord": {
-      const keyPart = def.keyType === void 0 ? "?" : recurse(def.keyType);
-      const valuePart = def.valueType === void 0 ? "?" : recurse(def.valueType);
-      return `ZodRecord<${keyPart},${valuePart}>`;
-    }
-    case "ZodUnion": {
-      const options = (def.options ?? []).map(recurse).sort();
-      return `ZodUnion(${options.join("|")})`;
-    }
-    case "ZodDiscriminatedUnion": {
-      const disc = def.discriminator ?? "?";
-      const options = (def.options ?? []).map(recurse).sort();
-      return `ZodDiscriminatedUnion[${JSON.stringify(disc)}](${options.join("|")})`;
-    }
-    case "ZodOptional": {
-      const inner = def.innerType;
-      return inner === void 0 ? "ZodOptional(?)" : `ZodOptional(${recurse(inner)})`;
-    }
-    case "ZodNullable": {
-      const inner = def.innerType;
-      return inner === void 0 ? "ZodNullable(?)" : `ZodNullable(${recurse(inner)})`;
-    }
-    case "ZodDefault": {
-      const inner = def.innerType;
-      return `ZodDefault[${defaultFactoryRepr(def.defaultValue)}](${inner === void 0 ? "?" : recurse(inner)})`;
-    }
-    case "ZodReadonly": {
-      const inner = def.innerType;
-      return inner === void 0 ? "ZodReadonly(?)" : `ZodReadonly(${recurse(inner)})`;
-    }
-    case "ZodEffects": {
-      const effectType = def.effect?.type ?? "effect";
-      const inner = def.schema;
-      return `ZodEffects:${effectType}:fn:*(${inner === void 0 ? "?" : recurse(inner)})`;
-    }
-    case "ZodPipeline": {
-      const inner = def.in ?? def.out;
-      return inner === void 0 ? "ZodPipeline(?)" : `ZodPipeline(${recurse(inner)})`;
-    }
-    case "ZodCatch": {
-      const inner = def.innerType ?? def.schema;
-      const catchRepr = defaultFactoryRepr(def.catchValue);
-      return `ZodCatch[${catchRepr}](${inner === void 0 ? "?" : recurse(inner)})`;
-    }
-    case "ZodLazy": {
-      const resolve = def.getter;
-      if (typeof resolve !== "function") return "ZodLazy(?)";
-      try {
-        const inner = resolve();
-        return `ZodLazy(${recurse(inner)})`;
-      } catch {
-        return "ZodLazy(?)";
-      }
-    }
-    case "ZodIntersection": {
-      const leftPart = def.left === void 0 ? "?" : recurse(def.left);
-      const rightPart = def.right === void 0 ? "?" : recurse(def.right);
-      const parts = [leftPart, rightPart].sort();
-      return `ZodIntersection(${parts.join("&")})`;
-    }
-    case "ZodSet": {
-      const inner = def.valueType;
-      return inner === void 0 ? "ZodSet(?)" : `ZodSet<${recurse(inner)}>${formatChecks(def.checks)}`;
-    }
-    case "ZodBranded": {
-      const inner = def.type;
-      return inner === void 0 ? "ZodBranded(?)" : `ZodBranded(${recurse(inner)})`;
-    }
-    // Structural opacity — schemas whose runtime behaviour isn't
-    // introspectable via `_def` fall here. Still distinguishable
-    // from other kinds by the returned string.
-    case "ZodPromise":
-    case "ZodFunction":
-    case "ZodMap":
-    case "ZodSymbol":
-    default:
-      return `${kind}:*`;
-  }
-}
-function readShapeSafely(def) {
-  if (typeof def.shape !== "function") return {};
-  try {
-    return def.shape();
-  } catch {
-    return {};
-  }
-}
-function defaultFactoryRepr(factory) {
-  if (typeof factory !== "function") return "none";
-  let first;
-  let second;
-  try {
-    first = factory();
-    second = factory();
-  } catch {
-    return "fn:*";
-  }
-  if (!Object.is(first, second)) return "fn:*";
-  if (typeof first === "function") return "fn:*";
-  return canonicalStringify(first);
-}
-function formatChecks(checks) {
-  if (!Array.isArray(checks) || checks.length === 0) return "";
-  const parts = checks.map((c) => canonicalStringify(c)).sort();
-  return `[${parts.join(";")}]`;
-}
-
-export { fingerprintZodSchema };