attaform 0.24.3 → 0.25.0

package/dist/shared/{attaform.0zueP54D.d.mts → attaform.DS_zBcdr.d.ts}

@@ -1,4 +1,4 @@
-import { F as FormKey, W as PathKey, m as DisplayCtx, d as GetDisplayState, n as DisplayMachine, V as Path, aa as SlimPrimitiveKind, C as CoercionEntry, g as CoercionRegistry, G as GenericForm, ag as ValidationError, a as AbstractSchema, ak as WriteMeta, j as DeepPartial, al as WriteShape, at as TransformAbortHolder, ae as ValidateOn, A as AttaformDefaults, b as UseFormReturnType, c as RegisterValue } from './attaform.DUc6cetN.mjs';
+import { F as FormKey, b as UseFormReturnType, G as GenericForm, W as PathKey, m as DisplayCtx, d as GetDisplayState, n as DisplayMachine, V as Path, aa as SlimPrimitiveKind, C as CoercionEntry, g as CoercionRegistry, ag as ValidationError, a as AbstractSchema, ak as WriteMeta, j as DeepPartial, al as WriteShape, at as TransformAbortHolder, ae as ValidateOn, A as AttaformDefaults, c as RegisterValue } from './attaform.i_LA3X9o.js';
 import { Ref, ComputedRef, App, InjectionKey } from 'vue';
 
 /**
@@ -137,23 +137,27 @@ declare const _lazyBrand: unique symbol;
  */
 type LazyMarker<Ctx = WizardCtx> = {
     readonly [_lazyBrand]: true;
-    readonly resolve: (ctx: Ctx) => AnyForm | string | undefined;
+    readonly resolve: (ctx: Ctx) => AnyForm | string | null | undefined;
 };
 /**
  * One position in the source `useWizard({ steps })` array. Each slot
- * resolves to a compiled `{ key, form }` step:
+ * resolves to a compiled `{ key, form }` step, or drops out:
  *
  *  - `AnyForm`         — a form declared via `useForm`. Surfaced as-is.
  *  - `string`          — bare key. The wizard generates a noop form
  *                        under the hood so the external surface stays
  *                        uniform across affordance positions (intro,
  *                        terms, congratulations, review surfaces).
+ *  - `null` / `undefined` — a literal absence, dropped from the compiled
+ *                        list. Lets a conditional step read inline as
+ *                        `cond ? form : null` without pre-filtering the
+ *                        array.
  *  - function          — eager slot, re-evaluates reactively. Returns
- *                        one of the above, or `undefined` to drop the
- *                        slot from the compiled list.
+ *                        one of the above, or `null` / `undefined` to
+ *                        drop the slot from the compiled list.
  *  - `LazyMarker`      — memoized function slot (see `lazy`).
  */
-type StepSlot<Ctx = WizardCtx> = AnyForm | string | ((ctx: Ctx) => AnyForm | string | undefined) | LazyMarker<Ctx>;
+type StepSlot<Ctx = WizardCtx> = AnyForm | string | null | undefined | ((ctx: Ctx) => AnyForm | string | null | undefined) | LazyMarker<Ctx>;
 /**
  * Shape returned by the `restore` callback. Carries the active step's
  * key; intentionally open-ended (object form) so future additions land
@@ -178,8 +182,9 @@ type WizardRestoreFn = () => WizardRestoreState | undefined;
 type WizardPersistFn = (state: WizardRestoreState) => void;
 /**
  * Submit context passed to the `onSubmit` callback registered via
- * `wizard.handleSubmit(onSubmit, onError?)`. Same shape on every step;
- * `isFinal` distinguishes intermediate vs final calls.
+ * `wizard.handleSubmit(onSubmit, onError?)`. `handleSubmit` always
+ * processes the whole step list, so `values` carries every form's
+ * parsed output regardless of which step fired the submit.
  *
  *  - `values` — namespaced aggregate keyed by form key, mirroring
  *               `wizard.allValues`. Reflects parsed output for every
@@ -190,9 +195,11 @@ type WizardPersistFn = (state: WizardRestoreState) => void;
  *               because the form ref carries its schema info.
  *  - `currentKey` — key of the step that fired this submission.
  *  - `isFinal`   — `true` when `currentKey` is the last position in
- *               `wizard.steps`. Intermediate calls validate the active
- *               form only and advance; final calls validate every form
- *               and stay on the terminal step.
+ *               `wizard.steps`. Positional only: it reports where the
+ *               submit fired, never what got validated. A user who steps
+ *               back, edits, and submits from the middle sees
+ *               `isFinal === false`, yet the whole list is still
+ *               processed and `done` still latches on success.
  */
 type WizardSubmitContext = {
     readonly values: Readonly<Record<FormKey, unknown>>;
@@ -209,9 +216,11 @@ type WizardSubmitContext = {
 type WizardOnSubmit = (ctx: WizardSubmitContext) => void | Promise<void>;
 /**
  * Optional `onError` callback registered via `wizard.handleSubmit`.
- * Receives the aggregate error list. Entries originate from per-form
- * validation, activation failures (`atta:activation-failed`), and a
- * submit callback that left errors on a processed step (the
+ * Receives the aggregate error list spanning EVERY step (handleSubmit
+ * validates the whole wizard), so a failed submit surfaces every form's
+ * errors at once, not just the active step's. Entries originate from
+ * per-form validation, activation failures (`atta:activation-failed`),
+ * and a submit callback that left errors on a processed step (the
  * `setErrors(...); return` server-rejection path). Sync or async; the
  * returned promise gates `wizard.submitting`.
  */
@@ -296,24 +305,55 @@ type WizardOptions = {
      */
     readonly persist?: WizardPersistFn | false;
 };
+/**
+ * True when a single slot is guaranteed to contribute exactly one
+ * compiled step: a bare form or affordance string that is neither
+ * nullish nor a (maybe-absent) function / `lazy()` slot. One of these
+ * anywhere in the tuple proves the compiled list is non-empty.
+ */
+type IsGuaranteedStep<T> = [null] extends [T] ? false : [undefined] extends [T] ? false : T extends LazyMarker | ((...args: unknown[]) => unknown) ? false : T extends string ? true : T extends {
+    readonly key: string;
+} ? true : false;
 /**
  * Predicate: is the steps tuple statically guaranteed to compile to a
- * non-empty list? A tuple passes when (a) it's not the empty array
- * literal and (b) it carries no function or `lazy()` slot — those
- * slot kinds can resolve to `undefined` at runtime and drop the
- * compiled position. Form slots and bare-string affordance slots
- * always preserve their position; a tuple made of only those kinds is
- * statically safe.
+ * non-empty list? True when at least one element is a guaranteed step
+ * (see `IsGuaranteedStep`). Function / `lazy()` slots may resolve to
+ * nothing, and `null` / `undefined` (a literal absence or a
+ * `cond ? form : null` union) is an explicit drop, so none of those
+ * prove non-emptiness; a tuple of only maybe-absent slots stays
+ * honestly `| undefined`.
  *
  * Used to narrow `currentStep` / `activeForm` to their non-`undefined`
  * shapes in the common-case wizard, while keeping the honest union
  * everywhere a runtime drop is reachable.
  */
-type StaticallyNonEmpty<S> = S extends readonly [] ? false : S extends readonly (infer Item)[] ? Item extends LazyMarker | ((...args: unknown[]) => unknown) ? false : true : false;
+type StaticallyNonEmpty<S> = S extends readonly [infer First, ...infer Rest] ? IsGuaranteedStep<First> extends true ? true : StaticallyNonEmpty<Rest> : false;
 /** Active step's key, narrowed to `string` when `S` is statically safe. */
 type CurrentStepOf<S> = StaticallyNonEmpty<S> extends true ? FormKey : FormKey | undefined;
-/** Active step's form handle, narrowed to `AnyForm` when `S` is statically safe. */
-type ActiveFormOf<S> = StaticallyNonEmpty<S> extends true ? AnyForm : AnyForm | undefined;
+/**
+ * Active step's form handle, schema-erased to `UseFormReturnType<GenericForm>`
+ * and narrowed to non-`undefined` when `S` is statically safe. The runtime
+ * value is a live facade over the active step, so reads (`.values`, `.meta`,
+ * `.history`) and `.handleSubmit` always target the current step. Values are
+ * loose here because the active step's schema is not statically known; reach
+ * for the original form ref or `ctx.get(ref)` when you need typed per-step
+ * values.
+ */
+type ActiveFormOf<S> = StaticallyNonEmpty<S> extends true ? UseFormReturnType<GenericForm> : UseFormReturnType<GenericForm> | undefined;
+/**
+ * Per-slot contribution to {@link FormsRecordOf}. Strips a `null` /
+ * `undefined` (a literal absence or a `cond ? form : null` union) off the
+ * slot first, so a conditionally-present form still maps to its key and
+ * stays concretely typed on `wizard.forms`; a purely nullish slot
+ * contributes nothing.
+ */
+type SlotRecord<First, F = Exclude<First, null | undefined>> = [F] extends [never] ? unknown : F extends string ? {
+    readonly [P in F]: AnyForm;
+} : F extends {
+    readonly key: infer K extends string;
+} ? {
+    readonly [P in K]: F;
+} : unknown;
 /**
  * Recursive tuple walk that builds the static portion of
  * `wizard.forms`. Each step slot contributes to the record:
@@ -325,7 +365,9 @@ type ActiveFormOf<S> = StaticallyNonEmpty<S> extends true ? AnyForm : AnyForm |
  *    the form's own `key` becomes the record key, and the value is
  *    the concrete form handle type — so drilling
  *    `wizard.forms.shipping.values.address` carries the schema-derived
- *    field types through.
+ *    field types through. A form kept behind a `cond ? form : null`
+ *    conditional still maps to its key.
+ *  - **`null` / `undefined` slot**: contributes nothing.
  *  - **Function / `lazy()` slot**: contributes nothing to the static
  *    map. Runtime-resolved forms are still reachable via the
  *    catch-all index signature on `WizardForms` (typed as `AnyForm`).
@@ -336,13 +378,7 @@ type ActiveFormOf<S> = StaticallyNonEmpty<S> extends true ? AnyForm : AnyForm |
 type FormsRecordOf<S> = S extends readonly [
     infer First,
     ...infer Rest extends ReadonlyArray<StepSlot>
-] ? (First extends string ? {
-    readonly [P in First]: AnyForm;
-} : First extends {
-    readonly key: infer K extends string;
-} ? {
-    readonly [P in K]: First;
-} : unknown) & FormsRecordOf<Rest> : unknown;
+] ? SlotRecord<First> & FormsRecordOf<Rest> : unknown;
 /**
  * `wizard.forms` typed view. Combines the static per-step type map
  * with a catch-all `Record<FormKey, AnyForm>` fallback so:
@@ -376,9 +412,15 @@ type WizardForms<S> = FormsRecordOf<S> & Readonly<Record<FormKey, AnyForm>>;
  *                    slots). Otherwise reads as `string | undefined`
  *                    so the degenerate case (empty list at runtime)
  *                    surfaces honestly.
- *  - `activeForm`  — the active step's form handle. Same narrowing as
- *                    `currentStep`. Noop forms cover string slots in
- *                    the normal path.
+ *  - `activeForm`  — a LIVE view of the active step's form. Operating
+ *                    through it always targets the current step, so a
+ *                    handler captured once at setup
+ *                    (`wizard.activeForm.handleSubmit(() =>
+ *                    wizard.next())`) retargets as the wizard advances.
+ *                    No longer `===` the raw per-step handle; reach for
+ *                    `wizard.forms[key]` when you need raw identity.
+ *                    Same `undefined` narrowing as `currentStep`. Noop
+ *                    forms cover string slots in the normal path.
  *  - `activeIndex` — 0-based position of the active step.
  *  - `isFinalStep` — `true` when `currentStep === steps[count - 1].key`.
  *  - `steps`       — ordered list of compiled `{ key, form }` slots.
@@ -404,13 +446,13 @@ type WizardForms<S> = FormsRecordOf<S> & Readonly<Record<FormKey, AnyForm>>;
  *                    Forward-looking; reactive to current form
  *                    validity. Gates "Finish button enable" style UI.
  *  - `done`        — monotonic latch: flips `true` the first time a
- *                    final-step `handleSubmit` resolves without throwing
- *                    AND leaves no errors set on any step, and stays
- *                    `true` through subsequent edits or invalidations. A
- *                    callback that calls `setErrors` and returns (the
- *                    documented server-rejection path) is a failed submit,
- *                    so it does not flip `done`. Only `reset()` flips it
- *                    back. Gates "show success card" style UI that should
+ *                    `handleSubmit` resolves without throwing AND leaves
+ *                    no errors set on any step, and stays `true` through
+ *                    subsequent edits or invalidations. A callback that
+ *                    calls `setErrors` and returns (the documented
+ *                    server-rejection path) is a failed submit, so it
+ *                    does not flip `done`. Only `reset()` flips it back.
+ *                    Gates "show success card" style UI that should
  *                    reflect submission history rather than current
  *                    validity.
  *  - `submitting`  — `true` while a `wizard.handleSubmit` call is in
@@ -434,11 +476,23 @@ type WizardForms<S> = FormsRecordOf<S> & Readonly<Record<FormKey, AnyForm>>;
  *                    `back()` does not pop; the trail is the audit
  *                    log, not the back-stack.
  *  - `next/back/goTo` — pure navigation. Refuses while `submitting`.
- *  - `handleSubmit(onSubmit, onError?)` — universal across all steps.
- *                    Intermediate calls validate the active form and
- *                    advance; final calls validate every form. Returns
- *                    an event handler suitable for `<form @submit>` or
- *                    imperative use.
+ *  - `tryNext()`   — validate the active step, then advance iff it
+ *                    passed; invalid input keeps the pin put under the
+ *                    form's standard error reveal (first error focused,
+ *                    display state advanced). The inline-bindable
+ *                    shorthand for `activeForm.handleSubmit(() =>
+ *                    next())`. Resolves to whether the pin moved. No-ops
+ *                    to `false` on a degenerate or final-step wizard
+ *                    (finish via `handleSubmit`).
+ *  - `handleSubmit(onSubmit, onError?)` — always validates the entire
+ *                    step list, from any step, and never advances the
+ *                    pin: on success it latches `done`; on any error it
+ *                    focuses the first failing step and fires `onError`
+ *                    with errors spanning every step. To gate advancing
+ *                    a step on its own validity, compose with the active
+ *                    form's submit: `activeForm.handleSubmit(() =>
+ *                    wizard.next())`. Returns an event handler suitable
+ *                    for `<form @submit>` or imperative use.
  *  - `reset()`     — zeros wizard lifecycle (`submissionAttempts`,
  *                    `visited`), resets every form, returns
  *                    `currentStep` to `steps[0].key`, and invokes
@@ -468,6 +522,7 @@ type UseWizardReturnType<S extends ReadonlyArray<StepSlot> = ReadonlyArray<StepS
     readonly next: () => Promise<void>;
     readonly back: () => void;
     readonly goTo: (key: string) => void;
+    readonly tryNext: () => Promise<boolean>;
     readonly handleSubmit: (onSubmit: WizardOnSubmit, onError?: WizardOnError) => (event?: Event) => Promise<void>;
     readonly reset: () => void;
 };
@@ -1073,6 +1128,14 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * source there).
      */
     markConnectedOptimistically(path: Path): void;
+    /**
+     * Client-side connected mark for a `v-register` component host that binds
+     * value via the v-model channel but has no single inner control to latch
+     * (a composite widget, or none found). The directive calls it on mount
+     * (`true`) and unmount (`false`). Distinct from the SSR-only
+     * `markConnectedOptimistically`; idempotent on the leading edge.
+     */
+    markHostConnected(path: Path, connected: boolean): void;
     /**
      * Leaf-only pristine check. `originals` is populated via
      * `diffAndApply`'s `added` patches, which fire only on primitive
@@ -1538,8 +1601,10 @@ type InjectFormInput = {
  * independent of component-tree position.
  *
  * Returns `null` when no matching form exists (no ambient ancestor, or
- * the named key isn't registered). A dev-mode warning points at the
- * call site to help diagnose typos. Always narrow before using:
+ * the named key isn't registered yet). A dev-mode warning points at the
+ * call site, lists the registered keys, and flags the mount-timing case
+ * (a form created by a child or sibling isn't registered until its own
+ * setup runs). Always narrow before using:
  *
  * ```ts
  * const form = injectForm<Shape>('signup')
@@ -1642,9 +1707,10 @@ declare function useRegister<V = unknown>(): UseRegisterReturn<V> | undefined;
  *
  * The wizard's surface is read-only from the consumer's side:
  * navigation (`next` / `back` / `goTo`) walks positional indices,
- * `handleSubmit` validates the active form on intermediate steps and
- * the whole wizard on the final step, and URL synchronization rides on
- * `restore` / `persist` callbacks that default to `?step=<key>`.
+ * `handleSubmit` validates the whole step list from any step and never
+ * advances (gate advance with `activeForm.handleSubmit(() =>
+ * wizard.next())`), and URL synchronization rides on `restore` /
+ * `persist` callbacks that default to `?step=<key>`.
  */
 declare function useWizard<const S extends ReadonlyArray<StepSlot>>(options: WizardOptions & {
     readonly steps: S;
@@ -1688,8 +1754,10 @@ type InjectWizardInput = {
  * constructed with `useWizard({ steps, key })` to be reachable.
  *
  * Returns `null` when no matching wizard exists (no ambient ancestor,
- * or the named key isn't registered). A dev-mode warning points at the
- * call site to help diagnose typos. Always narrow before using:
+ * or the named key isn't registered yet). A dev-mode warning points at
+ * the call site, lists the registered keys, and flags the mount-timing
+ * case (a wizard created by a child or sibling isn't registered until
+ * its own setup runs). Always narrow before using:
  *
  * ```ts
  * const wizard = injectWizard('signup')
@@ -1739,13 +1807,13 @@ declare function injectWizard(input?: string | InjectWizardInput): UseWizardRetu
  *    this one.
  *  - `wizard.reset()` clears every lazy slot's cache so a reboot truly
  *    resolves from scratch.
- *  - Resolving to `undefined` drops the slot from the compiled list
- *    until the resolver next re-fires.
+ *  - Resolving to `null` or `undefined` drops the slot from the compiled
+ *    list until the resolver next re-fires.
  *
  * The runtime brand returned by `lazy()` is opaque. Use
  * {@link isLazyMarker} to detect it.
  */
-declare function lazy<Ctx = WizardCtx>(resolve: (ctx: Ctx) => AnyForm | string | undefined): LazyMarker<Ctx>;
+declare function lazy<Ctx = WizardCtx>(resolve: (ctx: Ctx) => AnyForm | string | null | undefined): LazyMarker<Ctx>;
 
 /**
  * Stable identifiers for library-emitted `ValidationError` codes.

package/dist/shared/{attaform.DvqdxvNU.d.mts → attaform.DmKLa4tL.d.cts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { G as GenericForm, u as FlatPath, O as NestedType, F as FormKey, U as UseFormConfiguration, a as AbstractSchema, ar as AcceptableDefaults, af as ValidateOnConfig, b as UseFormReturnType } from './attaform.DUc6cetN.mjs';
+import { G as GenericForm, u as FlatPath, O as NestedType, F as FormKey, U as UseFormConfiguration, a as AbstractSchema, ar as AcceptableDefaults, af as ValidateOnConfig, b as UseFormReturnType } from './attaform.i_LA3X9o.cjs';
 
 /**
  * The shape `form.values.<key>` returns at runtime.

package/dist/shared/{attaform.DgbHNLf_.mjs → attaform.OLtKd9gM.mjs}

@@ -1,4 +1,4 @@
-import { i as getRegistryFromApp, m as pathKeyToDotted } from './attaform.C5qkSN6t.mjs';
+import { i as getRegistryFromApp, m as pathKeyToDotted } from './attaform.CqwcTExO.mjs';
 
 function renderAttaformState(app) {
   const registry = getRegistryFromApp(app);
@@ -32,4 +32,4 @@ function hydrateAttaformState(app, payload) {
 const DEVTOOLS_WINDOW_KEY = "__attaform_devtools__";
 
 export { DEVTOOLS_WINDOW_KEY as D, hydrateAttaformState as h, renderAttaformState as r };
-//# sourceMappingURL=attaform.DgbHNLf_.mjs.map
+//# sourceMappingURL=attaform.OLtKd9gM.mjs.map

package/dist/shared/{attaform.DgbHNLf_.mjs.map → attaform.OLtKd9gM.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"attaform.DgbHNLf_.mjs","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":[],"mappings":";;AAuCO,SAAS,oBAAoB,GAAA,EAAmC;AACrE,EAAA,MAAM,QAAA,GAAW,mBAAmB,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,GAAI,gBAAgB,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,GAAW,mBAAmB,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.OLtKd9gM.mjs","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":[],"mappings":";;AAuCO,SAAS,oBAAoB,GAAA,EAAmC;AACrE,EAAA,MAAM,QAAA,GAAW,mBAAmB,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,GAAI,gBAAgB,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,GAAW,mBAAmB,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.WvcckZMD.mjs → attaform.Vp2-CWZB.mjs}

@@ -3,6 +3,7 @@ import { isRef } from 'vue';
 const V_REGISTER_MARKER = Symbol.for("attaform:v-register-directive");
 const REGISTER_OWNER_MARKER = Symbol.for("attaform:register-owner-marker");
 const SSR_COMPONENT_HOST_MODIFIER = "attaformComponentHost";
+const V_REGISTER_COMPILED_MODIFIER = "attaformCompiled";
 function isRegisterValue(val) {
   if (typeof val !== "object" || val === null) return false;
   if (!("innerRef" in val)) return false;
@@ -17,5 +18,5 @@ function isTransforming(value) {
   return isRegisterValue(value) && value.transforming;
 }
 
-export { REGISTER_OWNER_MARKER as R, SSR_COMPONENT_HOST_MODIFIER as S, V_REGISTER_MARKER as V, isTransforming as a, isRegisterValue as i };
-//# sourceMappingURL=attaform.WvcckZMD.mjs.map
+export { REGISTER_OWNER_MARKER as R, SSR_COMPONENT_HOST_MODIFIER as S, V_REGISTER_COMPILED_MODIFIER as V, isTransforming as a, V_REGISTER_MARKER as b, isRegisterValue as i };
+//# sourceMappingURL=attaform.Vp2-CWZB.mjs.map

package/dist/shared/attaform.Vp2-CWZB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"attaform.Vp2-CWZB.mjs","sources":["../../src/runtime/core/register-protocol.ts"],"sourcesContent":["import { isRef } from 'vue'\nimport type { InternalRegisterValue, RegisterValue } from '../types/types-api'\n\n// Shared register-protocol primitives: the markers and value guards that\n// the v-register directive, its file / lifecycle satellites, and\n// useRegister all build on. They live in this leaf (depending only on vue\n// and the types module) so those modules don't import directive.ts back,\n// which would form an import cycle.\n\n/**\n * Marker installed on the v-register directive object so consumers\n * (notably `useRegister`) can identify it in a child vnode's\n * directive list even when the consumer's bundler hasn't installed\n * attaform's compile-time transforms. `Symbol.for(...)` round-trips\n * across duplicate bundle copies: `attaform` and `attaform/zod` can\n * land on different `vRegister` references in the playground or\n * under pnpm-hoist edge cases, but both carry the same marker.\n */\nexport const V_REGISTER_MARKER: unique symbol = Symbol.for('attaform:v-register-directive')\n\n/**\n * Marker on the rendered root DOM element. Set by `useRegister`'s\n * `onMounted` hook; read by the directive's deferred warn check to\n * skip the \"is a no-op\" warn for components that handle binding via\n * an inner v-register.\n *\n * `Symbol.for(...)` so the marker round-trips across duplicate copies\n * of attaform — see `assignKey` in core/directive.ts for the same\n * reasoning. `useRegister` and the directive are typically loaded\n * from the same module copy, but a consumer importing from\n * `attaform/zod` (Vite-optimized bundle) and the Nuxt\n * plugin's relative-path import (live ESM) can land on different\n * copies; a global symbol means the marker check still works.\n */\nexport const REGISTER_OWNER_MARKER: unique symbol = Symbol.for('attaform:register-owner-marker')\n\n/**\n * Directive modifier the `componentBridgeTransform` stamps onto a\n * `v-register` that lands on a component host (or kebab custom element).\n * It is the compile-time -> runtime signal the directive's `getSSRProps`\n * reads under compiled SSR, where Vue passes a `null` vnode and the host\n * is otherwise indistinguishable from a native control. autoAria then\n * suppresses its attrs on the host root (the inner control the component\n * re-binds via useRegister carries them). Namespaced to avoid collision\n * with any author-written modifier. (#404)\n */\nexport const SSR_COMPONENT_HOST_MODIFIER = 'attaformComponentHost'\n\n/**\n * Directive modifier the `redundantBindingWarnTransform` stamps onto\n * every `v-register` it processes. It is the compile-time -> runtime\n * signal that Attaform's template transforms are active, and it lets the\n * runtime redundant-binding diagnostic (in the directive's `created`\n * hook) stand down.\n *\n * The hand-off matters because `inputTextAreaNodeTransform` strips the\n * author's `value` / `checked` and injects its own. Once that has run,\n * `vnode.props` no longer reflects what the author wrote, so a runtime\n * check would flag every field. With this marker present the compile\n * layer owns detection (it reads the authored props BEFORE injection);\n * with it absent (no bundler plugin) the runtime layer reads the\n * untouched `vnode.props` directly. Exactly one layer fires per\n * consumer, never both.\n *\n * Namespaced to avoid collision with any author-written modifier, like\n * `SSR_COMPONENT_HOST_MODIFIER` above.\n */\nexport const V_REGISTER_COMPILED_MODIFIER = 'attaformCompiled'\n\n/**\n * Type guard for a `RegisterValue`. Returns `true` when `val` looks\n * like the object returned from `form.register(path)`.\n *\n * ```ts\n * if (isRegisterValue(slotValue)) {\n *   // slotValue.innerRef is now a Ref<unknown>\n * }\n * ```\n *\n * Useful when building wrapper components that accept either a\n * `RegisterValue` or a plain ref via the same prop.\n */\nexport function isRegisterValue<Value = unknown>(val: unknown): val is RegisterValue<Value> {\n  if (typeof val !== 'object' || val === null) return false\n  if (!('innerRef' in val)) return false\n  if (!isRef(val.innerRef)) return false\n  if (!('registerElement' in val)) return false\n  if (typeof val.registerElement !== 'function') return false\n  if (!('setValueWithInternalPath' in val)) return false\n  if (typeof val.setValueWithInternalPath !== 'function') return false\n  return true\n}\n\n/**\n * `true` while a deferred async transform is in flight at this path.\n * `beginTransform` flips it synchronously inside the assigner, so a\n * listener's post-write force-sync block reads it (right after the\n * assigner returns) to skip snapping the DOM back to stale storage —\n * the resolved value is painted in by the orchestrator's `syncDom`\n * once the run lands.\n */\nexport function isTransforming(value: unknown): boolean {\n  return isRegisterValue(value) && (value as InternalRegisterValue).transforming\n}\n"],"names":[],"mappings":";;AAkBO,MAAM,iBAAA,GAAmC,MAAA,CAAO,GAAA,CAAI,+BAA+B;AAgBnF,MAAM,qBAAA,GAAuC,MAAA,CAAO,GAAA,CAAI,gCAAgC;AAYxF,MAAM,2BAAA,GAA8B;AAqBpC,MAAM,4BAAA,GAA+B;AAerC,SAAS,gBAAiC,GAAA,EAA2C;AAC1F,EAAA,IAAI,OAAO,GAAA,KAAQ,QAAA,IAAY,GAAA,KAAQ,MAAM,OAAO,KAAA;AACpD,EAAA,IAAI,EAAE,UAAA,IAAc,GAAA,CAAA,EAAM,OAAO,KAAA;AACjC,EAAA,IAAI,CAAC,KAAA,CAAM,GAAA,CAAI,QAAQ,GAAG,OAAO,KAAA;AACjC,EAAA,IAAI,EAAE,iBAAA,IAAqB,GAAA,CAAA,EAAM,OAAO,KAAA;AACxC,EAAA,IAAI,OAAO,GAAA,CAAI,eAAA,KAAoB,UAAA,EAAY,OAAO,KAAA;AACtD,EAAA,IAAI,EAAE,0BAAA,IAA8B,GAAA,CAAA,EAAM,OAAO,KAAA;AACjD,EAAA,IAAI,OAAO,GAAA,CAAI,wBAAA,KAA6B,UAAA,EAAY,OAAO,KAAA;AAC/D,EAAA,OAAO,IAAA;AACT;AAUO,SAAS,eAAe,KAAA,EAAyB;AACtD,EAAA,OAAO,eAAA,CAAgB,KAAK,CAAA,IAAM,KAAA,CAAgC,YAAA;AACpE;;;;"}

package/dist/shared/{attaform.CqlLImc1.cjs → attaform.Xe8dATED.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
-const injectWizard = require('./attaform.CB1kYKUB.cjs');
-const paths = require('./attaform.DQcdvxKZ.cjs');
-const walkFieldMeta = require('./attaform.BVjueUPu.cjs');
+const injectWizard = require('./attaform.BkUzunyB.cjs');
+const paths = require('./attaform.3heDHayA.cjs');
+const walkFieldMeta = require('./attaform.B5YcWrKi.cjs');
 const zod = require('zod');
 
 const fieldMeta = walkFieldMeta.fieldMetaStore;
@@ -1299,4 +1299,4 @@ exports.unwrapPipe = unwrapPipe;
 exports.useForm = useForm;
 exports.withMeta = withMeta;
 exports.zodV4Adapter = zodV4Adapter;
-//# sourceMappingURL=attaform.CqlLImc1.cjs.map
+//# sourceMappingURL=attaform.Xe8dATED.cjs.map