attaform 0.27.0 → 0.27.2

package/dist/shared/{attaform.DQT7_-FO.cjs → attaform.CXHebpij.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 const vue = require('vue');
-const devtoolsShared = require('./attaform.Co5LNRnv.cjs');
+const devtoolsShared = require('./attaform.BBaMFa-k.cjs');
 const registerProtocol = require('./attaform.yUrz7C2z.cjs');
 
 function safeAssign(target, key, value) {
@@ -595,7 +595,17 @@ const AttaformErrorCode = {
    * keeps them; a bare `Error` or a non-Error throw defaults here at the
    * form-level path `[]`.
    */
-  SubmitError: "atta:submit-error"
+  SubmitError: "atta:submit-error",
+  /**
+   * Synthesized by `wizard.handleSubmit` when the whole-wizard submit
+   * would otherwise succeed but a `gate()` step is still uncleared. A
+   * gate clears only on its member form's clean submit (confirmation), so
+   * a downstream step that happens to be valid-by-default must not let the
+   * wizard finish past an unconfirmed prerequisite. Emitted at the gate
+   * form's key (path `[]`) so the aggregate error pipeline routes focus to
+   * the gate, and `done` never latches.
+   */
+  GateNotCleared: "atta:gate-not-cleared"
 };
 function makeBlankRequiredError(segments, formKey) {
   return {
@@ -610,6 +620,7 @@ function isGateOpen(field, formMeta) {
   return formMeta.submissionAttempts > 0 || field.blurredAfterInteraction === true;
 }
 function computeVerdict(field, formMeta) {
+  if (field.disabled === true) return "idle";
   if (!isGateOpen(field, formMeta)) return "idle";
   const hasOwnError = field.errors.some(
     (e) => e.path.length === field.path.length && e.path.every((s, i) => s === field.path[i])
@@ -817,6 +828,7 @@ function buildLeafFieldStateBase(state, segments, key, formInstanceId) {
     ...computeFieldIdentity(formInstanceId, state.formKey, key),
     key: state.arrayElementKey(segments),
     blank: state.blankPaths.has(key),
+    disabled: state.effectiveDisabled.value,
     label,
     description: resolved.description,
     placeholder: resolved.placeholder,
@@ -1004,6 +1016,7 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
       ...computeFieldIdentity(formInstanceId, state.formKey, key),
       key: state.arrayElementKey(segments),
       blank,
+      disabled: state.effectiveDisabled.value,
       label,
       description: resolved.description,
       placeholder: resolved.placeholder,
@@ -1058,7 +1071,8 @@ function decorateWithDerivedProps(base, state, getFormMetaBase, key, validatingS
     rollupApplies = true;
   }
   const submitValidating = rollupApplies && isRoot && state.submitting.value && state.activeValidations.value > 0;
-  const displayState = machine.display === "pending" || submitValidating ? "pending" : rollupApplies && revealedDescendantError ? "error" : machine.display;
+  const resolvedDisplayState = machine.display === "pending" || submitValidating ? "pending" : rollupApplies && revealedDescendantError ? "error" : machine.display;
+  const displayState = base.disabled === true ? "idle" : resolvedDisplayState;
   return {
     ...base,
     displayState,
@@ -1646,6 +1660,7 @@ const FIELD_STATE_KEYS = /* @__PURE__ */ new Set([
   "aria",
   "key",
   "blank",
+  "disabled",
   "label",
   "description",
   "placeholder",
@@ -2415,6 +2430,9 @@ function buildRegister(state, formInstanceId, instanceConfig) {
         return Object.prototype.toString.call(raw);
       }
     });
+    const hostModelValue = vue.computed(
+      () => state.blankPaths.has(pathKey) ? void 0 : innerRef.value
+    );
     const slimDefault = state.schema.getDefaultAtPath(segments);
     const slimTypes = state.schema.getSlimPrimitiveTypesAtPath(segments);
     const acceptsUndefined = slimTypes.has("undefined");
@@ -2434,19 +2452,18 @@ function buildRegister(state, formInstanceId, instanceConfig) {
     const isRequired = state.schema.isRequiredAtPath(segments);
     const ariaEnabled = options?.autoAria ?? formAutoAria;
     const ariaDisplayState = getDisplayStateAt !== void 0 ? vue.computed(() => getDisplayStateAt(segments)) : void 0;
+    const markBlank = () => state.setValueAtPath(segments, slimDefault, withInstanceMeta({ blank: true }));
     const internalRv = {
       innerRef,
       displayValue,
+      hostModelValue,
+      // Live form-freeze flag for the compile-time transforms' `:disabled`
+      // bind (native attribute + component-host prop) and custom
+      // `useRegister` integrations. Reads the form-level effective freeze,
+      // so every binding on a disabled form reports `true`.
+      disabled: vue.computed(() => state.effectiveDisabled.value),
       lastTypedForm,
-      markBlank: () => {
-        return state.setValueAtPath(
-          segments,
-          slimDefault,
-          withInstanceMeta({
-            blank: true
-          })
-        );
-      },
+      markBlank,
       markInteracted: () => {
         state.markInteracted(segments);
       },
@@ -2464,7 +2481,8 @@ function buildRegister(state, formInstanceId, instanceConfig) {
       },
       setValueFromHost: (value) => {
         state.markInteracted(segments);
-        const accepted = state.setValueAtPath(segments, value, withInstanceMeta(void 0));
+        const isBlankSignal = value === "" && !acceptsString || value === null && !slimTypes.has("null") || value === void 0 && !acceptsUndefined;
+        const accepted = isBlankSignal ? markBlank() : state.setValueAtPath(segments, value, withInstanceMeta(void 0));
         if (devtoolsShared.__DEV__) {
           const dedupeKey = `${formInstanceId}:${pathKey}`;
           const isWired = () => (state.elements.get(pathKey)?.elements.size ?? 0) > 0 || state.getFieldRecord(segments)?.connected === true;
@@ -2911,6 +2929,9 @@ function buildFormApi(state, formInstanceId, options = {}) {
       get blank() {
         return rootBase().blank;
       },
+      get disabled() {
+        return rootBase().disabled;
+      },
       get label() {
         return rootBase().label;
       },
@@ -3229,6 +3250,9 @@ function buildFormApi(state, formInstanceId, options = {}) {
       get blank() {
         return rootFieldState.value.blank;
       },
+      get disabled() {
+        return rootFieldState.value.disabled;
+      },
       get label() {
         return rootFieldState.value.label;
       },
@@ -4271,6 +4295,24 @@ function createFormStore(options) {
   const submitted = vue.ref(false);
   const submitError = vue.ref(null);
   const departAttempts = vue.ref(0);
+  const externalLock = vue.ref(false);
+  let warnedDisabledThrow = false;
+  let warnedDisabledWrite = false;
+  const effectiveDisabled = vue.computed(() => {
+    let own = false;
+    try {
+      own = Boolean(vue.toValue(options.disabled));
+    } catch (err) {
+      if (devtoolsShared.__DEV__ && !warnedDisabledThrow) {
+        warnedDisabledThrow = true;
+        console.warn(
+          `[attaform] useForm({ disabled }) getter threw for form "${String(formKey)}"; treating its config as enabled. Fix the getter to clear this warning.`,
+          err
+        );
+      }
+    }
+    return own || externalLock.value;
+  });
   const submissionGeneration = vue.ref(0);
   const activeValidations = vue.ref(0);
   const pathSnapshots = /* @__PURE__ */ new Map();
@@ -4564,6 +4606,15 @@ function createFormStore(options) {
     commitWritePatches(patches, meta);
   }
   function setValueAtPath(path, value, meta) {
+    if (effectiveDisabled.value) {
+      if (devtoolsShared.__DEV__ && !warnedDisabledWrite) {
+        warnedDisabledWrite = true;
+        console.warn(
+          `[attaform] Ignored a write to a disabled form ("${String(formKey)}"). Value writes no-op while \`disabled\` resolves truthy. This warning fires once.`
+        );
+      }
+      return false;
+    }
     if (meta?.arrayOp !== void 0 && Array.isArray(value)) {
       for (const idx of freshElementIndices(meta.arrayOp)) {
         value[idx] = stripSymbolsDeep(value[idx]);
@@ -5127,6 +5178,7 @@ function createFormStore(options) {
     }
   }
   function markFocused(path, focused, meta) {
+    if (effectiveDisabled.value) return;
     const { key } = devtoolsShared.canonicalizePath(path);
     const current = fields.get(key);
     touchFieldRecord(key, path, {
@@ -5174,6 +5226,7 @@ function createFormStore(options) {
     }
   }
   function markInteracted(path) {
+    if (effectiveDisabled.value) return;
     const { key } = devtoolsShared.canonicalizePath(path);
     if (fields.get(key)?.interacted === true) return;
     touchFieldRecord(key, path, { interacted: true });
@@ -5490,6 +5543,8 @@ function createFormStore(options) {
     submitted,
     submitError,
     departAttempts,
+    effectiveDisabled,
+    externalLock,
     hydrating,
     hydrateError,
     defaultValuesFactory,
@@ -5877,6 +5932,7 @@ function mergeWithDefaults(defaults, configuration) {
   const onInvalidSubmit = configuration.onInvalidSubmit ?? defaults.onInvalidSubmit;
   const history = configuration.history ?? defaults.history;
   const rememberVariants = configuration.rememberVariants ?? defaults.rememberVariants;
+  const disabled = configuration.disabled ?? defaults.disabled;
   const coerce = configuration.coerce ?? defaults.coerce;
   const validateOn = configuration.validateOn ?? defaults.validateOn;
   const debounceMs = configuration.debounceMs ?? defaults.debounceMs;
@@ -5889,6 +5945,7 @@ function mergeWithDefaults(defaults, configuration) {
     ...onInvalidSubmit === void 0 ? {} : { onInvalidSubmit },
     ...history === void 0 ? {} : { history },
     ...rememberVariants === void 0 ? {} : { rememberVariants },
+    ...disabled === void 0 ? {} : { disabled },
     ...coerce === void 0 ? {} : { coerce },
     ...validateOn === void 0 ? {} : { validateOn },
     ...debounceMs === void 0 ? {} : { debounceMs },
@@ -5934,6 +5991,7 @@ function buildFreshState(key, schema, configuration, registry) {
       }
     } : {},
     ...configuration.rememberVariants !== void 0 ? { rememberVariants: configuration.rememberVariants } : {},
+    ...configuration.disabled !== void 0 ? { disabled: configuration.disabled } : {},
     ...configuration.coerce !== void 0 ? { coerce: configuration.coerce } : {},
     ...configuration.getDisplayState !== void 0 ? { getDisplayState: configuration.getDisplayState } : {},
     ...initialBlankPaths !== void 0 ? { initialBlankPaths } : {}
@@ -6158,6 +6216,14 @@ function isLazyMarker(value) {
   return typeof value === "object" && value !== null && LAZY_BRAND in value;
 }
 
+const GATE_BRAND = /* @__PURE__ */ Symbol.for("attaform/wizard-gate");
+function gate(step) {
+  return { [GATE_BRAND]: true, inner: step };
+}
+function isGateMarker(value) {
+  return typeof value === "object" && value !== null && GATE_BRAND in value;
+}
+
 const NOOP_WIZARD_HISTORY = {
   push() {
   },
@@ -6281,14 +6347,17 @@ const PENDING_STATUS = {
   valid: false,
   dirty: false,
   submitted: false,
-  errorCount: 0
+  errorCount: 0,
+  locked: false
 };
 const NOOP_VALID_STATUS = {
   valid: true,
   dirty: false,
   submitted: false,
-  errorCount: 0
+  errorCount: 0,
+  locked: false
 };
+const EMPTY_LOCK_SET = /* @__PURE__ */ new Set();
 function asStatusSource(form) {
   return form;
 }
@@ -6355,7 +6424,7 @@ function useWizard(options) {
     }
   }
   const lazyEpoch = vue.ref(0);
-  const lazyComputeds = /* @__PURE__ */ new Map();
+  const lazyComputeds = /* @__PURE__ */ new WeakMap();
   const activeKey = vue.ref("");
   const formsAccumulator = /* @__PURE__ */ new Map();
   for (const slot of rawSteps) {
@@ -6391,50 +6460,44 @@ function useWizard(options) {
       return activeKey.value === "" ? void 0 : activeKey.value;
     }
   };
-  function resolveSlot(slot, index, ctx) {
-    if (slot === void 0 || slot === null) return void 0;
-    if (typeof slot === "string") {
-      return getOrBuildNoop(slot);
-    }
-    if (isLazyMarker(slot)) {
-      const c = lazyComputeds.get(index);
-      return c === void 0 ? void 0 : resolveSlotResult(c.value);
+  function lazyComputedFor(marker) {
+    const cached = lazyComputeds.get(marker);
+    if (cached !== void 0) return cached;
+    const c = vue.computed(() => {
+      void lazyEpoch.value;
+      return marker.resolve(slotCtx);
+    });
+    lazyComputeds.set(marker, c);
+    return c;
+  }
+  const MAX_SLOT_DEPTH = 32;
+  function normalizeSlot(slot, ctx, gated, depth) {
+    if (depth > MAX_SLOT_DEPTH) {
+      if (devtoolsShared.__DEV__) {
+        console.warn(
+          `[attaform] useWizard: a step slot nested past ${MAX_SLOT_DEPTH} levels (gate / lazy / function); dropping it. Check for a resolver that returns itself.`
+        );
+      }
+      return void 0;
     }
+    if (slot === void 0 || slot === null) return void 0;
+    if (typeof slot === "string") return { form: getOrBuildNoop(slot), gated };
+    if (isGateMarker(slot)) return normalizeSlot(slot.inner, ctx, true, depth + 1);
+    if (isLazyMarker(slot)) return normalizeSlot(lazyComputedFor(slot).value, ctx, gated, depth + 1);
     if (typeof slot === "function") {
       const result = slot(ctx);
-      return resolveSlotResult(result);
+      return normalizeSlot(result, ctx, gated, depth + 1);
     }
-    if (isAnyForm(slot)) return slot;
+    if (isAnyForm(slot)) return { form: slot, gated };
     return void 0;
   }
-  function resolveSlotResult(result) {
-    if (result === void 0 || result === null) return void 0;
-    if (typeof result === "string") {
-      return getOrBuildNoop(result);
-    }
-    return result;
-  }
-  for (let i = 0; i < rawSteps.length; i++) {
-    const slot = rawSteps[i];
-    if (isLazyMarker(slot)) {
-      const idx = i;
-      const marker = slot;
-      lazyComputeds.set(
-        idx,
-        vue.computed(() => {
-          void lazyEpoch.value;
-          return marker.resolve(slotCtx);
-        })
-      );
-    }
-  }
   const compiledSteps = vue.computed(() => {
     const out = [];
     const seen = /* @__PURE__ */ new Set();
     for (let i = 0; i < rawSteps.length; i++) {
-      const slot = rawSteps[i];
-      const form = resolveSlot(slot, i, slotCtx);
-      if (form === void 0) continue;
+      const norm = normalizeSlot(rawSteps[i], slotCtx, false, 0);
+      if (norm === void 0) continue;
+      const { form, gated } = norm;
       if (seen.has(form.key)) {
         if (devtoolsShared.__DEV__) {
           console.warn(
@@ -6445,7 +6508,7 @@ function useWizard(options) {
       }
       seen.add(form.key);
       trackOnce(form);
-      out.push({ key: form.key, form });
+      out.push({ key: form.key, form, isGate: gated });
     }
     return out;
   });
@@ -6481,12 +6544,12 @@ function useWizard(options) {
     if (key === "") return;
     if (list.some((step) => step.key === key)) return;
     if (list.length === 0) {
-      activeKey.value = "";
+      commitActiveKey("");
       return;
     }
     const oldIndex = prevList.findIndex((step) => step.key === key);
     const slid = list[oldIndex < 0 ? 0 : Math.min(oldIndex, list.length - 1)];
-    if (slid !== void 0) activeKey.value = slid.key;
+    if (slid !== void 0) commitActiveKey(slid.key);
   });
   const activeFormFacade = new Proxy({}, {
     get(_target, prop) {
@@ -6620,6 +6683,136 @@ function useWizard(options) {
       };
     }
   });
+  const mightGate = rawSteps.some(
+    (slot) => isGateMarker(slot) || isLazyMarker(slot) || typeof slot === "function"
+  );
+  const clearedGates = vue.reactive(/* @__PURE__ */ new Set());
+  const seededSampled = /* @__PURE__ */ new Set();
+  function isGateVerdictSettled(key) {
+    const store = registry.forms.get(key);
+    if (store === void 0) return false;
+    return store.defaultsResolved.value === true && store.firstValidationDone.value === true && store.activeValidations.value === 0;
+  }
+  function isGateFormValid(key) {
+    const form = formsRecord.value[key] ?? formsAccumulator.get(key);
+    if (form === void 0) return false;
+    return asStatusSource(form).meta?.valid ?? false;
+  }
+  function sampleSeededGate(key) {
+    if (seededSampled.has(key)) return;
+    if (noopForms.has(key)) return;
+    if (!isGateVerdictSettled(key)) return;
+    seededSampled.add(key);
+    if (isGateFormValid(key)) clearedGates.add(key);
+  }
+  const gateSubs = /* @__PURE__ */ new Map();
+  function reconcileGates() {
+    const gateKeys = /* @__PURE__ */ new Set();
+    for (const step of compiledSteps.value) if (step.isGate) gateKeys.add(step.key);
+    for (const key of gateKeys) {
+      if (!gateSubs.has(key)) {
+        const store = registry.forms.get(key);
+        if (store !== void 0) {
+          gateSubs.set(
+            key,
+            store.onSubmitSuccess(() => {
+              clearedGates.add(key);
+            })
+          );
+        }
+      }
+      sampleSeededGate(key);
+    }
+    for (const [key, unsub] of gateSubs) {
+      if (!gateKeys.has(key)) {
+        unsub();
+        gateSubs.delete(key);
+      }
+    }
+  }
+  const gatePositions = vue.computed(
+    () => compiledSteps.value.filter((step) => step.isGate).map((step) => step.key)
+  );
+  const navLockSet = vue.computed(() => {
+    const out = /* @__PURE__ */ new Set();
+    let sealed = false;
+    for (const step of compiledSteps.value) {
+      if (sealed) {
+        out.add(step.key);
+        continue;
+      }
+      if (step.isGate && !clearedGates.has(step.key)) sealed = true;
+    }
+    return out.size === 0 ? EMPTY_LOCK_SET : out;
+  });
+  const freezeSet = vue.computed(() => {
+    const out = new Set(navLockSet.value);
+    for (const key of gatePositions.value) if (clearedGates.has(key)) out.add(key);
+    return out.size === 0 ? EMPTY_LOCK_SET : out;
+  });
+  function lastReachableKey() {
+    const list = compiledSteps.value;
+    const locked = navLockSet.value;
+    let last;
+    for (const step of list) {
+      if (locked.has(step.key)) break;
+      last = step.key;
+    }
+    return last;
+  }
+  function resolveLandingKey(target) {
+    if (!navLockSet.value.has(target)) return target;
+    const redirect = lastReachableKey();
+    if (redirect === void 0) return target;
+    if (!isFormReady(redirect)) return target;
+    return redirect;
+  }
+  function commitActiveKey(target) {
+    const landing = target === "" ? "" : resolveLandingKey(target);
+    if (activeKey.value !== landing) activeKey.value = landing;
+    return landing;
+  }
+  if (mightGate) {
+    vue.watch(
+      () => {
+        const parts = [];
+        for (const step of compiledSteps.value) {
+          if (!step.isGate) continue;
+          const store = registry.forms.get(step.key);
+          const settled = store !== void 0 && isGateVerdictSettled(step.key);
+          parts.push(`${step.key}:${store !== void 0 ? 1 : 0}:${settled ? 1 : 0}`);
+        }
+        return parts.join("|");
+      },
+      reconcileGates,
+      { immediate: true }
+    );
+    let previouslyFrozen = [];
+    vue.watchEffect(() => {
+      const frozen = freezeSet.value;
+      for (const key of previouslyFrozen) {
+        if (!frozen.has(key)) {
+          const store = registry.forms.get(key);
+          if (store !== void 0) store.externalLock.value = false;
+        }
+      }
+      for (const key of frozen) {
+        const store = registry.forms.get(key);
+        if (store !== void 0) store.externalLock.value = true;
+      }
+      previouslyFrozen = [...frozen];
+    });
+    if (vue.getCurrentScope() !== void 0) {
+      vue.onScopeDispose(() => {
+        for (const key of previouslyFrozen) {
+          const store = registry.forms.get(key);
+          if (store !== void 0) store.externalLock.value = false;
+        }
+        for (const unsub of gateSubs.values()) unsub();
+        gateSubs.clear();
+      });
+    }
+  }
   const seedRef = vue.ref(void 0);
   const seedInput = options.defaultStatuses;
   if (seedInput !== void 0) {
@@ -6643,6 +6836,7 @@ function useWizard(options) {
     if (cached !== void 0) return cached;
     const source = asStatusSource(form);
     const computedStatus = vue.computed(() => {
+      const locked = navLockSet.value.has(form.key);
       if (isFormReady(form.key)) {
         const meta = source.meta;
         if (meta !== void 0 && meta !== null) {
@@ -6650,16 +6844,17 @@ function useWizard(options) {
             valid: meta.valid,
             dirty: meta.dirty,
             submitted: meta.submitted,
-            errorCount: meta.errorCount
+            errorCount: meta.errorCount,
+            locked
           };
         }
       }
-      if (noopForms.has(form.key)) return NOOP_VALID_STATUS;
-      const seedMap = seedRef.value;
-      if (seedMap !== void 0 && Object.hasOwn(seedMap, form.key)) {
-        return seedMap[form.key];
+      if (noopForms.has(form.key)) {
+        return locked ? { ...NOOP_VALID_STATUS, locked: true } : NOOP_VALID_STATUS;
       }
-      return PENDING_STATUS;
+      const seed = seedRef.value?.[form.key];
+      if (seed !== void 0) return { ...seed, locked };
+      return locked ? { ...PENDING_STATUS, locked: true } : PENDING_STATUS;
     });
     statusCache.set(form.key, computedStatus);
     return computedStatus;
@@ -6775,8 +6970,8 @@ function useWizard(options) {
     initialKey = firstKey();
   }
   if (initialKey !== void 0) {
-    activeKey.value = initialKey;
-    visited.value = [initialKey];
+    const landing = commitActiveKey(initialKey);
+    visited.value = [landing];
   }
   if (registry.ssr) {
     for (const step of compiledSteps.value) {
@@ -6808,8 +7003,8 @@ function useWizard(options) {
           return;
         }
         if (step === activeKey.value) return;
-        activeKey.value = step;
-        if (!visited.value.includes(step)) visited.value.push(step);
+        const landing = commitActiveKey(step);
+        if (!visited.value.includes(landing)) visited.value.push(landing);
       }
     );
   }
@@ -6841,11 +7036,11 @@ function useWizard(options) {
   }
   function moveTo(key, options2) {
     if (activeKey.value === key) return;
-    activeKey.value = key;
-    if (!visited.value.includes(key)) visited.value.push(key);
+    const landing = commitActiveKey(key);
+    if (!visited.value.includes(landing)) visited.value.push(landing);
     const list = compiledSteps.value;
     for (const step of list) {
-      if (step.key === key) {
+      if (step.key === landing) {
         activateForm(step.form);
         return;
       }
@@ -6855,6 +7050,14 @@ function useWizard(options) {
     const store = registry.forms.get(key);
     if (store !== void 0) store.departAttempts.value += 1;
   }
+  function advanceOne() {
+    const list = compiledSteps.value;
+    const idx = activeIndex.value;
+    if (idx < 0 || idx >= list.length - 1) return;
+    recordDeparture(activeKey.value);
+    const target = list[idx + 1];
+    moveTo(target.key);
+  }
   async function next() {
     if (submitting.value) {
       if (devtoolsShared.__DEV__) {
@@ -6880,9 +7083,12 @@ function useWizard(options) {
       }
       return;
     }
-    recordDeparture(activeKey.value);
-    const target = list[idx + 1];
-    moveTo(target.key);
+    const active = list[idx];
+    if (active !== void 0 && active.isGate) {
+      await tryNext();
+      return;
+    }
+    advanceOne();
   }
   async function tryNext() {
     if (submitting.value) {
@@ -6909,13 +7115,13 @@ function useWizard(options) {
     }
     const form = activeForm.value;
     if (form === void 0) return false;
-    let advanced = false;
+    const before = activeKey.value;
+    let ranClean = false;
     await asHandleSubmitSource(form).handleSubmit(() => {
-      const before = activeKey.value;
-      next();
-      advanced = activeKey.value !== before;
+      ranClean = true;
     })();
-    return advanced;
+    if (ranClean) advanceOne();
+    return activeKey.value !== before;
   }
   function back() {
     if (submitting.value) {
@@ -6955,6 +7161,11 @@ function useWizard(options) {
       }
       return;
     }
+    if (devtoolsShared.__DEV__ && navLockSet.value.has(key)) {
+      console.warn(
+        `[attaform] wizard.goTo("${key}"): that step sits behind an uncleared gate(); the navigation was refused. Clear the gate before navigating here.`
+      );
+    }
     if (key !== activeKey.value) recordDeparture(activeKey.value);
     moveTo(key);
   }
@@ -7014,6 +7225,20 @@ function useWizard(options) {
     }
     return out;
   }
+  function collectUnclearedGateErrors() {
+    const out = [];
+    for (const step of compiledSteps.value) {
+      if (step.isGate && !clearedGates.has(step.key)) {
+        out.push({
+          formKey: step.key,
+          path: [],
+          message: `Step "${step.key}" is a gate that has not been cleared. Submit it to continue.`,
+          code: AttaformErrorCode.GateNotCleared
+        });
+      }
+    }
+    return out;
+  }
   async function focusFirstWizardError(errors) {
     if (options.focusFirstError === false) return;
     const firstFailedKey = errors[0]?.formKey;
@@ -7070,7 +7295,9 @@ function useWizard(options) {
         }
         submissionAttempts.value += 1;
         const errors = collectErrors(results);
-        if (errors.length === 0) {
+        const gateErrors = mightGate ? collectUnclearedGateErrors() : [];
+        const blocking = gateErrors.length > 0 ? [...errors, ...gateErrors] : errors;
+        if (blocking.length === 0) {
           const valuesMap = {};
           for (const step of list) {
             const processed = results.get(step.key);
@@ -7096,10 +7323,10 @@ function useWizard(options) {
           }
           done.value = true;
         } else {
-          await focusFirstWizardError(errors);
+          await focusFirstWizardError(blocking);
           if (onError !== void 0) {
             try {
-              await onError(errors);
+              await onError(blocking);
             } catch (cause) {
               throw new devtoolsShared.SubmitErrorHandlerError("User-provided onError threw", { cause });
             }
@@ -7116,21 +7343,35 @@ function useWizard(options) {
     submissionAttempts.value = 0;
     done.value = false;
     submitError.value = null;
+    if (mightGate) {
+      clearedGates.clear();
+      seededSampled.clear();
+    }
     lazyEpoch.value += 1;
     for (const step of compiledSteps.value) {
       const full = asSubmissionSource(step.form);
       if (typeof full.reset === "function") full.reset();
     }
+    if (mightGate) reconcileGates();
     const firstStep = compiledSteps.value[0];
     if (firstStep !== void 0) {
-      activeKey.value = firstStep.key;
-      visited.value = [firstStep.key];
+      const landing = commitActiveKey(firstStep.key);
+      visited.value = [landing];
       if (persistCallback !== void 0) {
-        lastPersisted = firstStep.key;
-        persistCallback({ step: firstStep.key });
+        lastPersisted = landing;
+        persistCallback({ step: landing });
       }
     }
   }
+  if (mightGate) {
+    vue.watchEffect(() => {
+      const key = activeKey.value;
+      if (key === "" || !navLockSet.value.has(key)) return;
+      const redirect = lastReachableKey();
+      if (redirect === void 0 || redirect === key || !isFormReady(redirect)) return;
+      moveTo(redirect);
+    });
+  }
   if (vue.getCurrentScope() !== void 0) {
     vue.onScopeDispose(() => {
       historyHandle.dispose();
@@ -7332,6 +7573,7 @@ exports.defaultCoercionRules = defaultCoercionRules;
 exports.defaultDisplayState = defaultDisplayState;
 exports.defineCoercion = defineCoercion;
 exports.escapeForInlineScript = escapeForInlineScript;
+exports.gate = gate;
 exports.getAtPath = getAtPath;
 exports.humanize = humanize;
 exports.injectForm = injectForm;
@@ -7348,4 +7590,4 @@ exports.unset = unset;
 exports.useAbstractForm = useAbstractForm;
 exports.useRegister = useRegister;
 exports.useWizard = useWizard;
-//# sourceMappingURL=attaform.DQT7_-FO.cjs.map
+//# sourceMappingURL=attaform.CXHebpij.cjs.map