@entifix/react-integration 0.1.0-0

package/dist/hooks/use-entity-mutation/use-entity-mutation.d.ts

@@ -0,0 +1,22 @@
+import { EntifixError, type Entity, type EntityId } from '@entifix/core';
+import type { UseEntityMutationOptions } from './use-entity-mutation.types.js';
+/**
+ * Runs the write use-cases from a component — the mutating counterpart to
+ * {@link useDataLoading}.
+ *
+ * Inputs are provided as tags at call time ({@link EntityTag} for a save,
+ * {@link EntityIdTag} for a delete), so the use-cases stay unaware of both React
+ * and the transport behind `ctx`.
+ *
+ * `save` resolves to the entity the *repository* returned rather than the one
+ * passed in. That distinction matters: a create round-trips through the store's
+ * id generation, so only the returned entity is addressable.
+ */
+export declare function useEntityMutation<TEntity extends Entity, TContext>({ saveUc, deleteUc, ctx, }: UseEntityMutationOptions<TEntity, TContext>): {
+    save: (entity: TEntity) => Promise<TEntity | undefined>;
+    remove: (id: EntityId) => Promise<boolean>;
+    isSaving: boolean;
+    isDeleting: boolean;
+    error: EntifixError | undefined;
+};
+//# sourceMappingURL=use-entity-mutation.d.ts.map

package/dist/hooks/use-entity-mutation/use-entity-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-entity-mutation.d.ts","sourceRoot":"","sources":["../../../src/hooks/use-entity-mutation/use-entity-mutation.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,KAAK,MAAM,EAAE,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAIzE,OAAO,KAAK,EAEV,wBAAwB,EAEzB,MAAM,gCAAgC,CAAC;AAexC;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,SAAS,MAAM,EAAE,QAAQ,EAAE,EAClE,MAAM,EACN,QAAQ,EACR,GAAG,GACJ,EAAE,wBAAwB,CAAC,OAAO,EAAE,QAAQ,CAAC;mBAI3B,OAAO,KAAG,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC;iBAiB1C,QAAQ,KAAG,OAAO,CAAC,OAAO,CAAC;;;;EAiBzC"}

package/dist/hooks/use-entity-mutation/use-entity-mutation.js

@@ -0,0 +1,88 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { EntityIdTag, EntityTag } from '@entifix/business';
+import { Context, Effect } from 'effect';
+import { useCallback, useReducer } from 'react';
+const initialState = {
+    isSaving: false,
+    isDeleting: false,
+    error: undefined
+};
+function reducer(state, action) {
+    return _extends({}, state, action.set);
+}
+/**
+ * Runs the write use-cases from a component — the mutating counterpart to
+ * {@link useDataLoading}.
+ *
+ * Inputs are provided as tags at call time ({@link EntityTag} for a save,
+ * {@link EntityIdTag} for a delete), so the use-cases stay unaware of both React
+ * and the transport behind `ctx`.
+ *
+ * `save` resolves to the entity the *repository* returned rather than the one
+ * passed in. That distinction matters: a create round-trips through the store's
+ * id generation, so only the returned entity is addressable.
+ */ export function useEntityMutation({ saveUc, deleteUc, ctx }) {
+    const [state, dispatch] = useReducer(reducer, initialState);
+    const save = useCallback(async (entity)=>{
+        dispatch({
+            set: {
+                isSaving: true,
+                error: undefined
+            }
+        });
+        try {
+            const saved = await Effect.runPromise(Effect.provide(saveUc, ctx.pipe(Context.add(EntityTag, entity))));
+            dispatch({
+                set: {
+                    isSaving: false
+                }
+            });
+            return saved;
+        } catch (error) {
+            dispatch({
+                set: {
+                    isSaving: false,
+                    error: error
+                }
+            });
+            return undefined;
+        }
+    }, [
+        saveUc,
+        ctx
+    ]);
+    const remove = useCallback(async (id)=>{
+        dispatch({
+            set: {
+                isDeleting: true,
+                error: undefined
+            }
+        });
+        try {
+            await Effect.runPromise(Effect.provide(deleteUc, ctx.pipe(Context.add(EntityIdTag, id))));
+            dispatch({
+                set: {
+                    isDeleting: false
+                }
+            });
+            return true;
+        } catch (error) {
+            dispatch({
+                set: {
+                    isDeleting: false,
+                    error: error
+                }
+            });
+            return false;
+        }
+    }, [
+        deleteUc,
+        ctx
+    ]);
+    return _extends({}, state, {
+        save,
+        remove
+    });
+}
+
+//# sourceMappingURL=use-entity-mutation.js.map

package/dist/hooks/use-entity-mutation/use-entity-mutation.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hooks/use-entity-mutation/use-entity-mutation.ts"],"sourcesContent":["import { EntityIdTag, EntityTag } from '@entifix/business';\nimport { EntifixError, type Entity, type EntityId } from '@entifix/core';\nimport { Context, Effect } from 'effect';\nimport { useCallback, useReducer } from 'react';\n\nimport type {\n  UseEntityMutationAction,\n  UseEntityMutationOptions,\n  UseEntityMutationState,\n} from './use-entity-mutation.types.js';\n\nconst initialState: UseEntityMutationState = {\n  isSaving: false,\n  isDeleting: false,\n  error: undefined,\n};\n\nfunction reducer(\n  state: UseEntityMutationState,\n  action: UseEntityMutationAction,\n): UseEntityMutationState {\n  return { ...state, ...action.set };\n}\n\n/**\n * Runs the write use-cases from a component — the mutating counterpart to\n * {@link useDataLoading}.\n *\n * Inputs are provided as tags at call time ({@link EntityTag} for a save,\n * {@link EntityIdTag} for a delete), so the use-cases stay unaware of both React\n * and the transport behind `ctx`.\n *\n * `save` resolves to the entity the *repository* returned rather than the one\n * passed in. That distinction matters: a create round-trips through the store's\n * id generation, so only the returned entity is addressable.\n */\nexport function useEntityMutation<TEntity extends Entity, TContext>({\n  saveUc,\n  deleteUc,\n  ctx,\n}: UseEntityMutationOptions<TEntity, TContext>) {\n  const [state, dispatch] = useReducer(reducer, initialState);\n\n  const save = useCallback(\n    async (entity: TEntity): Promise<TEntity | undefined> => {\n      dispatch({ set: { isSaving: true, error: undefined } });\n      try {\n        const saved = await Effect.runPromise(\n          Effect.provide(saveUc, ctx.pipe(Context.add(EntityTag, entity))),\n        );\n        dispatch({ set: { isSaving: false } });\n        return saved;\n      } catch (error) {\n        dispatch({ set: { isSaving: false, error: error as EntifixError } });\n        return undefined;\n      }\n    },\n    [saveUc, ctx],\n  );\n\n  const remove = useCallback(\n    async (id: EntityId): Promise<boolean> => {\n      dispatch({ set: { isDeleting: true, error: undefined } });\n      try {\n        await Effect.runPromise(\n          Effect.provide(deleteUc, ctx.pipe(Context.add(EntityIdTag, id))),\n        );\n        dispatch({ set: { isDeleting: false } });\n        return true;\n      } catch (error) {\n        dispatch({ set: { isDeleting: false, error: error as EntifixError } });\n        return false;\n      }\n    },\n    [deleteUc, ctx],\n  );\n\n  return { ...state, save, remove };\n}\n"],"names":["EntityIdTag","EntityTag","Context","Effect","useCallback","useReducer","initialState","isSaving","isDeleting","error","undefined","reducer","state","action","set","useEntityMutation","saveUc","deleteUc","ctx","dispatch","save","entity","saved","runPromise","provide","pipe","add","remove","id"],"mappings":";AAAA,SAASA,WAAW,EAAEC,SAAS,QAAQ,oBAAoB;AAE3D,SAASC,OAAO,EAAEC,MAAM,QAAQ,SAAS;AACzC,SAASC,WAAW,EAAEC,UAAU,QAAQ,QAAQ;AAQhD,MAAMC,eAAuC;IAC3CC,UAAU;IACVC,YAAY;IACZC,OAAOC;AACT;AAEA,SAASC,QACPC,KAA6B,EAC7BC,MAA+B;IAE/B,OAAO,aAAKD,OAAUC,OAAOC,GAAG;AAClC;AAEA;;;;;;;;;;;CAWC,GACD,OAAO,SAASC,kBAAoD,EAClEC,MAAM,EACNC,QAAQ,EACRC,GAAG,EACyC;IAC5C,MAAM,CAACN,OAAOO,SAAS,GAAGd,WAAWM,SAASL;IAE9C,MAAMc,OAAOhB,YACX,OAAOiB;QACLF,SAAS;YAAEL,KAAK;gBAAEP,UAAU;gBAAME,OAAOC;YAAU;QAAE;QACrD,IAAI;YACF,MAAMY,QAAQ,MAAMnB,OAAOoB,UAAU,CACnCpB,OAAOqB,OAAO,CAACR,QAAQE,IAAIO,IAAI,CAACvB,QAAQwB,GAAG,CAACzB,WAAWoB;YAEzDF,SAAS;gBAAEL,KAAK;oBAAEP,UAAU;gBAAM;YAAE;YACpC,OAAOe;QACT,EAAE,OAAOb,OAAO;YACdU,SAAS;gBAAEL,KAAK;oBAAEP,UAAU;oBAAOE,OAAOA;gBAAsB;YAAE;YAClE,OAAOC;QACT;IACF,GACA;QAACM;QAAQE;KAAI;IAGf,MAAMS,SAASvB,YACb,OAAOwB;QACLT,SAAS;YAAEL,KAAK;gBAAEN,YAAY;gBAAMC,OAAOC;YAAU;QAAE;QACvD,IAAI;YACF,MAAMP,OAAOoB,UAAU,CACrBpB,OAAOqB,OAAO,CAACP,UAAUC,IAAIO,IAAI,CAACvB,QAAQwB,GAAG,CAAC1B,aAAa4B;YAE7DT,SAAS;gBAAEL,KAAK;oBAAEN,YAAY;gBAAM;YAAE;YACtC,OAAO;QACT,EAAE,OAAOC,OAAO;YACdU,SAAS;gBAAEL,KAAK;oBAAEN,YAAY;oBAAOC,OAAOA;gBAAsB;YAAE;YACpE,OAAO;QACT;IACF,GACA;QAACQ;QAAUC;KAAI;IAGjB,OAAO,aAAKN;QAAOQ;QAAMO;;AAC3B"}

package/dist/hooks/use-entity-mutation/use-entity-mutation.types.d.ts

@@ -0,0 +1,19 @@
+import { EntityIdTag, EntityTag } from '@entifix/business';
+import { EntifixError, Entity } from '@entifix/core';
+import { Context, Effect } from 'effect';
+export interface UseEntityMutationState {
+    isSaving: boolean;
+    isDeleting: boolean;
+    error: EntifixError | undefined;
+}
+export type UseEntityMutationAction = {
+    set: Partial<UseEntityMutationState>;
+};
+export interface UseEntityMutationOptions<TEntity extends Entity, TContext> {
+    /** A save use-case; the hook supplies {@link EntityTag}. */
+    saveUc: Effect.Effect<TEntity, EntifixError, EntityTag | TContext>;
+    /** A delete use-case; the hook supplies {@link EntityIdTag}. */
+    deleteUc: Effect.Effect<void, EntifixError, EntityIdTag | TContext>;
+    ctx: Context.Context<TContext>;
+}
+//# sourceMappingURL=use-entity-mutation.types.d.ts.map

package/dist/hooks/use-entity-mutation/use-entity-mutation.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-entity-mutation.types.d.ts","sourceRoot":"","sources":["../../../src/hooks/use-entity-mutation/use-entity-mutation.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEzC,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,EAAE,OAAO,CAAC;IACpB,KAAK,EAAE,YAAY,GAAG,SAAS,CAAC;CACjC;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,GAAG,EAAE,OAAO,CAAC,sBAAsB,CAAC,CAAC;CACtC,CAAC;AAEF,MAAM,WAAW,wBAAwB,CAAC,OAAO,SAAS,MAAM,EAAE,QAAQ;IACxE,4DAA4D;IAC5D,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,YAAY,EAAE,SAAS,GAAG,QAAQ,CAAC,CAAC;IACnE,gEAAgE;IAChE,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,WAAW,GAAG,QAAQ,CAAC,CAAC;IACpE,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;CAChC"}

package/dist/hooks/use-entity-mutation/use-entity-mutation.types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=use-entity-mutation.types.js.map

package/dist/hooks/use-entity-mutation/use-entity-mutation.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hooks/use-entity-mutation/use-entity-mutation.types.ts"],"sourcesContent":["import { EntityIdTag, EntityTag } from '@entifix/business';\nimport { EntifixError, Entity } from '@entifix/core';\nimport { Context, Effect } from 'effect';\n\nexport interface UseEntityMutationState {\n  isSaving: boolean;\n  isDeleting: boolean;\n  error: EntifixError | undefined;\n}\n\nexport type UseEntityMutationAction = {\n  set: Partial<UseEntityMutationState>;\n};\n\nexport interface UseEntityMutationOptions<TEntity extends Entity, TContext> {\n  /** A save use-case; the hook supplies {@link EntityTag}. */\n  saveUc: Effect.Effect<TEntity, EntifixError, EntityTag | TContext>;\n  /** A delete use-case; the hook supplies {@link EntityIdTag}. */\n  deleteUc: Effect.Effect<void, EntifixError, EntityIdTag | TContext>;\n  ctx: Context.Context<TContext>;\n}\n"],"names":[],"mappings":"AAcA,WAMC"}

package/dist/hooks/use-entity-record/index.d.ts

@@ -0,0 +1,3 @@
+export * from './use-entity-record.js';
+export * from './use-entity-record.types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/use-entity-record/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/use-entity-record/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,8BAA8B,CAAC"}

package/dist/hooks/use-entity-record/index.js

@@ -0,0 +1,4 @@
+export * from './use-entity-record.js';
+export * from './use-entity-record.types.js';
+
+//# sourceMappingURL=index.js.map

package/dist/hooks/use-entity-record/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hooks/use-entity-record/index.ts"],"sourcesContent":["export * from './use-entity-record.js';\nexport * from './use-entity-record.types.js';\n"],"names":[],"mappings":"AAAA,cAAc,yBAAyB;AACvC,cAAc,+BAA+B"}

package/dist/hooks/use-entity-record/use-entity-record.d.ts

@@ -0,0 +1,21 @@
+import { EntifixError, type Entity } from '@entifix/core';
+import type { UseEntityRecordOptions } from './use-entity-record.types.js';
+/**
+ * Loads a single entity by id — the read half of an entity form.
+ *
+ * The id is provided through {@link EntityIdTag} at call time, mirroring how
+ * {@link useDataLoading} provides the load request: the use-case stays
+ * environment-agnostic and the hook is the only place that knows it is running
+ * in React.
+ *
+ * When `id` is `undefined` the hook does not fetch. That is the create case —
+ * there is no record yet — and it is a deliberate no-op rather than an error.
+ */
+export declare function useEntityRecord<TEntity extends Entity, TContext>({ uc, ctx, id, }: UseEntityRecordOptions<TEntity, TContext>): {
+    reload: () => void;
+    setEntity: (entity: TEntity | undefined) => void;
+    entity: TEntity | undefined;
+    isLoading: boolean;
+    error: EntifixError | undefined;
+};
+//# sourceMappingURL=use-entity-record.d.ts.map

package/dist/hooks/use-entity-record/use-entity-record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-entity-record.d.ts","sourceRoot":"","sources":["../../../src/hooks/use-entity-record/use-entity-record.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAI1D,OAAO,KAAK,EAEV,sBAAsB,EAEvB,MAAM,8BAA8B,CAAC;AAmBtC;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,OAAO,SAAS,MAAM,EAAE,QAAQ,EAAE,EAChE,EAAE,EACF,GAAG,EACH,EAAE,GACH,EAAE,sBAAsB,CAAC,OAAO,EAAE,QAAQ,CAAC;;wBA8D/B,OAAO,GAAG,SAAS;;;;EAK/B"}

package/dist/hooks/use-entity-record/use-entity-record.js

@@ -0,0 +1,93 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { EntityIdTag } from '@entifix/business';
+import { Context, Effect } from 'effect';
+import { useCallback, useEffect, useReducer, useRef, useState } from 'react';
+function getInitialState() {
+    return {
+        entity: undefined,
+        isLoading: false,
+        error: undefined
+    };
+}
+function reducer(state, action) {
+    return _extends({}, state, action.set);
+}
+/**
+ * Loads a single entity by id — the read half of an entity form.
+ *
+ * The id is provided through {@link EntityIdTag} at call time, mirroring how
+ * {@link useDataLoading} provides the load request: the use-case stays
+ * environment-agnostic and the hook is the only place that knows it is running
+ * in React.
+ *
+ * When `id` is `undefined` the hook does not fetch. That is the create case —
+ * there is no record yet — and it is a deliberate no-op rather than an error.
+ */ export function useEntityRecord({ uc, ctx, id }) {
+    const [state, dispatch] = useReducer(reducer, getInitialState());
+    // Bumped to re-run the fetch on demand.
+    const [reloadToken, setReloadToken] = useState(0);
+    // Callers build `uc`/`ctx` inline, so they are fresh objects on every render.
+    // Holding the latest in refs keeps them out of the fetch effect's
+    // dependencies: keying the fetch on their identity would re-run it on every
+    // render, and its dispatch would render again — an unbreakable loop. The
+    // fetch is keyed on `id`/`reloadToken`, which is what actually selects a
+    // record.
+    const ucRef = useRef(uc);
+    const ctxRef = useRef(ctx);
+    // Refs may not be written during render; this runs before the fetch effect
+    // below (effects fire in declaration order), so it always sees the latest.
+    useEffect(()=>{
+        ucRef.current = uc;
+        ctxRef.current = ctx;
+    });
+    useEffect(()=>{
+        if (id == null) {
+            return;
+        }
+        // Guards against a slow response for a previous id landing after a newer one.
+        let active = true;
+        dispatch({
+            set: {
+                isLoading: true,
+                error: undefined
+            }
+        });
+        Effect.runPromise(Effect.provide(ucRef.current, ctxRef.current.pipe(Context.add(EntityIdTag, id)))).then((entity)=>{
+            if (active) {
+                dispatch({
+                    set: {
+                        entity,
+                        isLoading: false
+                    }
+                });
+            }
+        }).catch((error)=>{
+            if (active) {
+                dispatch({
+                    set: {
+                        error: error,
+                        isLoading: false
+                    }
+                });
+            }
+        });
+        return ()=>{
+            active = false;
+        };
+    }, [
+        id,
+        reloadToken
+    ]);
+    const reload = useCallback(()=>setReloadToken((token)=>token + 1), []);
+    /** Replaces the held record, e.g. with the entity a save returned. */ const setEntity = useCallback((entity)=>dispatch({
+            set: {
+                entity
+            }
+        }), []);
+    return _extends({}, state, {
+        reload,
+        setEntity
+    });
+}
+
+//# sourceMappingURL=use-entity-record.js.map

package/dist/hooks/use-entity-record/use-entity-record.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hooks/use-entity-record/use-entity-record.ts"],"sourcesContent":["import { EntityIdTag } from '@entifix/business';\nimport { EntifixError, type Entity } from '@entifix/core';\nimport { Context, Effect } from 'effect';\nimport { useCallback, useEffect, useReducer, useRef, useState } from 'react';\n\nimport type {\n  UseEntityRecordAction,\n  UseEntityRecordOptions,\n  UseEntityRecordState,\n} from './use-entity-record.types.js';\n\nfunction getInitialState<\n  TEntity extends Entity,\n>(): UseEntityRecordState<TEntity> {\n  return {\n    entity: undefined,\n    isLoading: false,\n    error: undefined,\n  };\n}\n\nfunction reducer<TEntity extends Entity>(\n  state: UseEntityRecordState<TEntity>,\n  action: UseEntityRecordAction<TEntity>,\n): UseEntityRecordState<TEntity> {\n  return { ...state, ...action.set };\n}\n\n/**\n * Loads a single entity by id — the read half of an entity form.\n *\n * The id is provided through {@link EntityIdTag} at call time, mirroring how\n * {@link useDataLoading} provides the load request: the use-case stays\n * environment-agnostic and the hook is the only place that knows it is running\n * in React.\n *\n * When `id` is `undefined` the hook does not fetch. That is the create case —\n * there is no record yet — and it is a deliberate no-op rather than an error.\n */\nexport function useEntityRecord<TEntity extends Entity, TContext>({\n  uc,\n  ctx,\n  id,\n}: UseEntityRecordOptions<TEntity, TContext>) {\n  const [state, dispatch] = useReducer(\n    reducer as (\n      state: UseEntityRecordState<TEntity>,\n      action: UseEntityRecordAction<TEntity>,\n    ) => UseEntityRecordState<TEntity>,\n    getInitialState<TEntity>(),\n  );\n  // Bumped to re-run the fetch on demand.\n  const [reloadToken, setReloadToken] = useState(0);\n\n  // Callers build `uc`/`ctx` inline, so they are fresh objects on every render.\n  // Holding the latest in refs keeps them out of the fetch effect's\n  // dependencies: keying the fetch on their identity would re-run it on every\n  // render, and its dispatch would render again — an unbreakable loop. The\n  // fetch is keyed on `id`/`reloadToken`, which is what actually selects a\n  // record.\n  const ucRef = useRef(uc);\n  const ctxRef = useRef(ctx);\n\n  // Refs may not be written during render; this runs before the fetch effect\n  // below (effects fire in declaration order), so it always sees the latest.\n  useEffect(() => {\n    ucRef.current = uc;\n    ctxRef.current = ctx;\n  });\n\n  useEffect(() => {\n    if (id == null) {\n      return;\n    }\n\n    // Guards against a slow response for a previous id landing after a newer one.\n    let active = true;\n    dispatch({ set: { isLoading: true, error: undefined } });\n\n    Effect.runPromise(\n      Effect.provide(\n        ucRef.current,\n        ctxRef.current.pipe(Context.add(EntityIdTag, id)),\n      ),\n    )\n      .then(entity => {\n        if (active) {\n          dispatch({ set: { entity, isLoading: false } });\n        }\n      })\n      .catch((error: unknown) => {\n        if (active) {\n          dispatch({ set: { error: error as EntifixError, isLoading: false } });\n        }\n      });\n\n    return () => {\n      active = false;\n    };\n  }, [id, reloadToken]);\n\n  const reload = useCallback(() => setReloadToken(token => token + 1), []);\n\n  /** Replaces the held record, e.g. with the entity a save returned. */\n  const setEntity = useCallback(\n    (entity: TEntity | undefined) => dispatch({ set: { entity } }),\n    [],\n  );\n\n  return { ...state, reload, setEntity };\n}\n"],"names":["EntityIdTag","Context","Effect","useCallback","useEffect","useReducer","useRef","useState","getInitialState","entity","undefined","isLoading","error","reducer","state","action","set","useEntityRecord","uc","ctx","id","dispatch","reloadToken","setReloadToken","ucRef","ctxRef","current","active","runPromise","provide","pipe","add","then","catch","reload","token","setEntity"],"mappings":";AAAA,SAASA,WAAW,QAAQ,oBAAoB;AAEhD,SAASC,OAAO,EAAEC,MAAM,QAAQ,SAAS;AACzC,SAASC,WAAW,EAAEC,SAAS,EAAEC,UAAU,EAAEC,MAAM,EAAEC,QAAQ,QAAQ,QAAQ;AAQ7E,SAASC;IAGP,OAAO;QACLC,QAAQC;QACRC,WAAW;QACXC,OAAOF;IACT;AACF;AAEA,SAASG,QACPC,KAAoC,EACpCC,MAAsC;IAEtC,OAAO,aAAKD,OAAUC,OAAOC,GAAG;AAClC;AAEA;;;;;;;;;;CAUC,GACD,OAAO,SAASC,gBAAkD,EAChEC,EAAE,EACFC,GAAG,EACHC,EAAE,EACwC;IAC1C,MAAM,CAACN,OAAOO,SAAS,GAAGhB,WACxBQ,SAIAL;IAEF,wCAAwC;IACxC,MAAM,CAACc,aAAaC,eAAe,GAAGhB,SAAS;IAE/C,8EAA8E;IAC9E,kEAAkE;IAClE,4EAA4E;IAC5E,yEAAyE;IACzE,yEAAyE;IACzE,UAAU;IACV,MAAMiB,QAAQlB,OAAOY;IACrB,MAAMO,SAASnB,OAAOa;IAEtB,2EAA2E;IAC3E,2EAA2E;IAC3Ef,UAAU;QACRoB,MAAME,OAAO,GAAGR;QAChBO,OAAOC,OAAO,GAAGP;IACnB;IAEAf,UAAU;QACR,IAAIgB,MAAM,MAAM;YACd;QACF;QAEA,8EAA8E;QAC9E,IAAIO,SAAS;QACbN,SAAS;YAAEL,KAAK;gBAAEL,WAAW;gBAAMC,OAAOF;YAAU;QAAE;QAEtDR,OAAO0B,UAAU,CACf1B,OAAO2B,OAAO,CACZL,MAAME,OAAO,EACbD,OAAOC,OAAO,CAACI,IAAI,CAAC7B,QAAQ8B,GAAG,CAAC/B,aAAaoB,OAG9CY,IAAI,CAACvB,CAAAA;YACJ,IAAIkB,QAAQ;gBACVN,SAAS;oBAAEL,KAAK;wBAAEP;wBAAQE,WAAW;oBAAM;gBAAE;YAC/C;QACF,GACCsB,KAAK,CAAC,CAACrB;YACN,IAAIe,QAAQ;gBACVN,SAAS;oBAAEL,KAAK;wBAAEJ,OAAOA;wBAAuBD,WAAW;oBAAM;gBAAE;YACrE;QACF;QAEF,OAAO;YACLgB,SAAS;QACX;IACF,GAAG;QAACP;QAAIE;KAAY;IAEpB,MAAMY,SAAS/B,YAAY,IAAMoB,eAAeY,CAAAA,QAASA,QAAQ,IAAI,EAAE;IAEvE,oEAAoE,GACpE,MAAMC,YAAYjC,YAChB,CAACM,SAAgCY,SAAS;YAAEL,KAAK;gBAAEP;YAAO;QAAE,IAC5D,EAAE;IAGJ,OAAO,aAAKK;QAAOoB;QAAQE;;AAC7B"}

package/dist/hooks/use-entity-record/use-entity-record.types.d.ts

@@ -0,0 +1,22 @@
+import { EntityIdTag } from '@entifix/business';
+import { EntifixError, Entity, EntityId } from '@entifix/core';
+import { Context, Effect } from 'effect';
+export interface UseEntityRecordState<TEntity extends Entity> {
+    entity: TEntity | undefined;
+    isLoading: boolean;
+    error: EntifixError | undefined;
+}
+export type UseEntityRecordAction<TEntity extends Entity> = {
+    set: Partial<UseEntityRecordState<TEntity>>;
+};
+export interface UseEntityRecordOptions<TEntity extends Entity, TContext> {
+    /** A get use-case; the hook supplies {@link EntityIdTag}. */
+    uc: Effect.Effect<TEntity, EntifixError, EntityIdTag | TContext>;
+    ctx: Context.Context<TContext>;
+    /**
+     * The record to load. `undefined` means "nothing to load yet" — the create
+     * case — and the hook stays idle rather than fetching.
+     */
+    id: EntityId;
+}
+//# sourceMappingURL=use-entity-record.types.d.ts.map

package/dist/hooks/use-entity-record/use-entity-record.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-entity-record.types.d.ts","sourceRoot":"","sources":["../../../src/hooks/use-entity-record/use-entity-record.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEzC,MAAM,WAAW,oBAAoB,CAAC,OAAO,SAAS,MAAM;IAC1D,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC;IAC5B,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,YAAY,GAAG,SAAS,CAAC;CACjC;AAED,MAAM,MAAM,qBAAqB,CAAC,OAAO,SAAS,MAAM,IAAI;IAC1D,GAAG,EAAE,OAAO,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAAC;CAC7C,CAAC;AAEF,MAAM,WAAW,sBAAsB,CAAC,OAAO,SAAS,MAAM,EAAE,QAAQ;IACtE,6DAA6D;IAC7D,EAAE,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,YAAY,EAAE,WAAW,GAAG,QAAQ,CAAC,CAAC;IACjE,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC/B;;;OAGG;IACH,EAAE,EAAE,QAAQ,CAAC;CACd"}

package/dist/hooks/use-entity-record/use-entity-record.types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=use-entity-record.types.js.map

package/dist/hooks/use-entity-record/use-entity-record.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hooks/use-entity-record/use-entity-record.types.ts"],"sourcesContent":["import { EntityIdTag } from '@entifix/business';\nimport { EntifixError, Entity, EntityId } from '@entifix/core';\nimport { Context, Effect } from 'effect';\n\nexport interface UseEntityRecordState<TEntity extends Entity> {\n  entity: TEntity | undefined;\n  isLoading: boolean;\n  error: EntifixError | undefined;\n}\n\nexport type UseEntityRecordAction<TEntity extends Entity> = {\n  set: Partial<UseEntityRecordState<TEntity>>;\n};\n\nexport interface UseEntityRecordOptions<TEntity extends Entity, TContext> {\n  /** A get use-case; the hook supplies {@link EntityIdTag}. */\n  uc: Effect.Effect<TEntity, EntifixError, EntityIdTag | TContext>;\n  ctx: Context.Context<TContext>;\n  /**\n   * The record to load. `undefined` means \"nothing to load yet\" — the create\n   * case — and the hook stays idle rather than fetching.\n   */\n  id: EntityId;\n}\n"],"names":[],"mappings":"AAcA,WASC"}

package/dist/hooks/use-entity-use-cases/index.d.ts

@@ -0,0 +1,2 @@
+export * from './use-entity-use-cases.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/use-entity-use-cases/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/use-entity-use-cases/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC"}

package/dist/hooks/use-entity-use-cases/index.js

@@ -0,0 +1,3 @@
+export * from './use-entity-use-cases.js';
+
+//# sourceMappingURL=index.js.map

package/dist/hooks/use-entity-use-cases/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hooks/use-entity-use-cases/index.ts"],"sourcesContent":["export * from './use-entity-use-cases.js';\n"],"names":[],"mappings":"AAAA,cAAc,4BAA4B"}

package/dist/hooks/use-entity-use-cases/use-entity-use-cases.d.ts

@@ -0,0 +1,25 @@
+import { type Entity, type EntityConstructor, type EntityMetadataDocument, type EntityMetadataSource } from '@entifix/core';
+export interface UseEntityUseCasesResult {
+    /** Undefined until the document arrives; a surface renders its defaults meanwhile. */
+    metadata?: EntityMetadataDocument;
+    isLoading: boolean;
+    error?: unknown;
+}
+/**
+ * Reads what this caller may do with an entity, from the service.
+ *
+ * The source is a parameter rather than resolved from context because the two
+ * consumers reach their service differently — one through the config-driven REST
+ * adapters, one through a shell's own same-origin routes — and a hook that knew
+ * about both would have to know about neither's layer.
+ *
+ * The query key sits under `'entity-metadata'`, deliberately **outside** the
+ * `['entity', …]` namespace: `useReactiveInvalidation` invalidates
+ * `['entity', <key>]` wholesale whenever a row changes, and affordances do not
+ * change when a record does. Keeping it out is what stops every save refetching
+ * this. `staleTime: Infinity` for the same reason — the document changes with
+ * the deployment and the caller's grants, neither of which moves inside a
+ * session.
+ */
+export declare function useEntityUseCases<TEntity extends Entity>(entityConstructor: EntityConstructor<TEntity>, source: EntityMetadataSource | undefined): UseEntityUseCasesResult;
+//# sourceMappingURL=use-entity-use-cases.d.ts.map

package/dist/hooks/use-entity-use-cases/use-entity-use-cases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-entity-use-cases.d.ts","sourceRoot":"","sources":["../../../src/hooks/use-entity-use-cases/use-entity-use-cases.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EACX,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EAE1B,MAAM,eAAe,CAAC;AAGvB,MAAM,WAAW,uBAAuB;IACtC,sFAAsF;IACtF,QAAQ,CAAC,EAAE,sBAAsB,CAAC;IAClC,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,SAAS,MAAM,EACtD,iBAAiB,EAAE,iBAAiB,CAAC,OAAO,CAAC,EAC7C,MAAM,EAAE,oBAAoB,GAAG,SAAS,GACvC,uBAAuB,CAyBzB"}

package/dist/hooks/use-entity-use-cases/use-entity-use-cases.js

@@ -0,0 +1,47 @@
+import { envelopeEntityName } from '@entifix/core';
+import { skipToken, useQuery } from '@tanstack/react-query';
+/**
+ * Reads what this caller may do with an entity, from the service.
+ *
+ * The source is a parameter rather than resolved from context because the two
+ * consumers reach their service differently — one through the config-driven REST
+ * adapters, one through a shell's own same-origin routes — and a hook that knew
+ * about both would have to know about neither's layer.
+ *
+ * The query key sits under `'entity-metadata'`, deliberately **outside** the
+ * `['entity', …]` namespace: `useReactiveInvalidation` invalidates
+ * `['entity', <key>]` wholesale whenever a row changes, and affordances do not
+ * change when a record does. Keeping it out is what stops every save refetching
+ * this. `staleTime: Infinity` for the same reason — the document changes with
+ * the deployment and the caller's grants, neither of which moves inside a
+ * session.
+ */ export function useEntityUseCases(entityConstructor, source) {
+    var _query_error;
+    // An **optional** source, so a caller with none to offer — a generated page
+    // whose service exposes no `$metadata` route — needs no placeholder to hand
+    // over. A hook cannot be called conditionally, so the query is always created
+    // and simply disabled; fetching-and-failing instead would have TanStack Query
+    // *retry* a rejecting promise on a loop for a capability nobody asked for.
+    const enabled = source !== undefined;
+    const query = useQuery({
+        queryKey: [
+            'entity-metadata',
+            envelopeEntityName(entityConstructor)
+        ],
+        // `skipToken` rather than `enabled`, because it is what lets the closure
+        // keep the narrowed `source` — the `enabled` form needs a non-null
+        // assertion in a `queryFn` that provably never runs.
+        queryFn: source ? ()=>source.fetchMetadata(entityConstructor) : skipToken,
+        staleTime: Infinity
+    });
+    return {
+        metadata: query.data,
+        // A disabled query sits in `pending` forever, so `isLoading` would be
+        // permanently true and every action surface would render a skeleton that
+        // never resolves. Nothing is in flight when nothing was asked for.
+        isLoading: enabled && query.isLoading,
+        error: (_query_error = query.error) != null ? _query_error : undefined
+    };
+}
+
+//# sourceMappingURL=use-entity-use-cases.js.map

package/dist/hooks/use-entity-use-cases/use-entity-use-cases.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hooks/use-entity-use-cases/use-entity-use-cases.ts"],"sourcesContent":["import {\n  type Entity,\n  type EntityConstructor,\n  type EntityMetadataDocument,\n  type EntityMetadataSource,\n  envelopeEntityName,\n} from '@entifix/core';\nimport { skipToken, useQuery } from '@tanstack/react-query';\n\nexport interface UseEntityUseCasesResult {\n  /** Undefined until the document arrives; a surface renders its defaults meanwhile. */\n  metadata?: EntityMetadataDocument;\n  isLoading: boolean;\n  error?: unknown;\n}\n\n/**\n * Reads what this caller may do with an entity, from the service.\n *\n * The source is a parameter rather than resolved from context because the two\n * consumers reach their service differently — one through the config-driven REST\n * adapters, one through a shell's own same-origin routes — and a hook that knew\n * about both would have to know about neither's layer.\n *\n * The query key sits under `'entity-metadata'`, deliberately **outside** the\n * `['entity', …]` namespace: `useReactiveInvalidation` invalidates\n * `['entity', <key>]` wholesale whenever a row changes, and affordances do not\n * change when a record does. Keeping it out is what stops every save refetching\n * this. `staleTime: Infinity` for the same reason — the document changes with\n * the deployment and the caller's grants, neither of which moves inside a\n * session.\n */\nexport function useEntityUseCases<TEntity extends Entity>(\n  entityConstructor: EntityConstructor<TEntity>,\n  source: EntityMetadataSource | undefined,\n): UseEntityUseCasesResult {\n  // An **optional** source, so a caller with none to offer — a generated page\n  // whose service exposes no `$metadata` route — needs no placeholder to hand\n  // over. A hook cannot be called conditionally, so the query is always created\n  // and simply disabled; fetching-and-failing instead would have TanStack Query\n  // *retry* a rejecting promise on a loop for a capability nobody asked for.\n  const enabled = source !== undefined;\n\n  const query = useQuery({\n    queryKey: ['entity-metadata', envelopeEntityName(entityConstructor)],\n    // `skipToken` rather than `enabled`, because it is what lets the closure\n    // keep the narrowed `source` — the `enabled` form needs a non-null\n    // assertion in a `queryFn` that provably never runs.\n    queryFn: source ? () => source.fetchMetadata(entityConstructor) : skipToken,\n    staleTime: Infinity,\n  });\n\n  return {\n    metadata: query.data,\n    // A disabled query sits in `pending` forever, so `isLoading` would be\n    // permanently true and every action surface would render a skeleton that\n    // never resolves. Nothing is in flight when nothing was asked for.\n    isLoading: enabled && query.isLoading,\n    error: query.error ?? undefined,\n  };\n}\n"],"names":["envelopeEntityName","skipToken","useQuery","useEntityUseCases","entityConstructor","source","query","enabled","undefined","queryKey","queryFn","fetchMetadata","staleTime","Infinity","metadata","data","isLoading","error"],"mappings":"AAAA,SAKEA,kBAAkB,QACb,gBAAgB;AACvB,SAASC,SAAS,EAAEC,QAAQ,QAAQ,wBAAwB;AAS5D;;;;;;;;;;;;;;;CAeC,GACD,OAAO,SAASC,kBACdC,iBAA6C,EAC7CC,MAAwC;QAwB/BC;IAtBT,4EAA4E;IAC5E,4EAA4E;IAC5E,8EAA8E;IAC9E,8EAA8E;IAC9E,2EAA2E;IAC3E,MAAMC,UAAUF,WAAWG;IAE3B,MAAMF,QAAQJ,SAAS;QACrBO,UAAU;YAAC;YAAmBT,mBAAmBI;SAAmB;QACpE,yEAAyE;QACzE,mEAAmE;QACnE,qDAAqD;QACrDM,SAASL,SAAS,IAAMA,OAAOM,aAAa,CAACP,qBAAqBH;QAClEW,WAAWC;IACb;IAEA,OAAO;QACLC,UAAUR,MAAMS,IAAI;QACpB,sEAAsE;QACtE,yEAAyE;QACzE,mEAAmE;QACnEC,WAAWT,WAAWD,MAAMU,SAAS;QACrCC,KAAK,GAAEX,eAAAA,MAAMW,KAAK,YAAXX,eAAeE;IACxB;AACF"}

package/dist/hooks/use-wizard/index.d.ts

@@ -0,0 +1,3 @@
+export * from './use-wizard.js';
+export * from './use-wizard.types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/use-wizard/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/use-wizard/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC"}

package/dist/hooks/use-wizard/index.js

@@ -0,0 +1,4 @@
+export * from './use-wizard.js';
+export * from './use-wizard.types.js';
+
+//# sourceMappingURL=index.js.map

package/dist/hooks/use-wizard/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hooks/use-wizard/index.ts"],"sourcesContent":["export * from './use-wizard.js';\nexport * from './use-wizard.types.js';\n"],"names":[],"mappings":"AAAA,cAAc,kBAAkB;AAChC,cAAc,wBAAwB"}

package/dist/hooks/use-wizard/use-wizard.d.ts

@@ -0,0 +1,19 @@
+import type { UseWizardOptions, UseWizardResult } from './use-wizard.types.js';
+/**
+ * Drives one wizard: where the operator is, what they have answered, and the
+ * per-step draft each form step edits.
+ *
+ * **The draft lives here, above the forms.** A form step calls `useEntityForm`
+ * itself — React's hook count must stay fixed, so N form steps cannot be N hook
+ * calls in one component — and it unmounts when it is not the active step. What
+ * makes Back safe is therefore not keeping the step mounted but keeping its
+ * values out of it: {@link UseWizardResult.draftStoreFor} hands the step an
+ * `EntityDraftStore` viewing this state, and the step is free to come and go
+ * ([ADR 0045](../../../../../../../docs/adr/0045-the-wizard-a-step-graph-and-a-submit-that-hands-off.md)).
+ *
+ * It holds no router and performs no submit. `onStepChange` reports where the
+ * operator went so a shell can write the URL, and finishing is the host's — this
+ * hook does not know a transaction exists.
+ */
+export declare function useWizard({ definition, draft, errored, onStepChange, }: UseWizardOptions): UseWizardResult;
+//# sourceMappingURL=use-wizard.d.ts.map

package/dist/hooks/use-wizard/use-wizard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-wizard.d.ts","sourceRoot":"","sources":["../../../src/hooks/use-wizard/use-wizard.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE/E;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,EACxB,UAAU,EACV,KAAK,EACL,OAAO,EACP,YAAY,GACb,EAAE,gBAAgB,GAAG,eAAe,CAoIpC"}

package/dist/hooks/use-wizard/use-wizard.js

@@ -0,0 +1,136 @@
+'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { advanceWizard, canFinish as canFinishWizard, emptyWizardState, entryStep, goBackWizard, goToWizardStep, stepStatuses, withStepValue } from '@entifix/core';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+/**
+ * Drives one wizard: where the operator is, what they have answered, and the
+ * per-step draft each form step edits.
+ *
+ * **The draft lives here, above the forms.** A form step calls `useEntityForm`
+ * itself — React's hook count must stay fixed, so N form steps cannot be N hook
+ * calls in one component — and it unmounts when it is not the active step. What
+ * makes Back safe is therefore not keeping the step mounted but keeping its
+ * values out of it: {@link UseWizardResult.draftStoreFor} hands the step an
+ * `EntityDraftStore` viewing this state, and the step is free to come and go
+ * ([ADR 0045](../../../../../../../docs/adr/0045-the-wizard-a-step-graph-and-a-submit-that-hands-off.md)).
+ *
+ * It holds no router and performs no submit. `onStepChange` reports where the
+ * operator went so a shell can write the URL, and finishing is the host's — this
+ * hook does not know a transaction exists.
+ */ export function useWizard({ definition, draft, errored, onStepChange }) {
+    const entry = useMemo(()=>entryStep(definition), [
+        definition
+    ]);
+    const [state, setState] = useState(()=>emptyWizardState(entry.id));
+    const [isResumed, setResumed] = useState(false);
+    /**
+   * The state as of the last commit, mirrored so a handler can read it without
+   * a stale closure **and without doing its work inside a `setState` updater** —
+   * an updater runs twice under StrictMode, which would fire `onStepChange`
+   * and the persistence write twice per advance.
+   */ const stateRef = useRef(state);
+    const touched = useRef(false);
+    const adopted = useRef(false);
+    const save = draft == null ? void 0 : draft.save;
+    const persisted = draft == null ? void 0 : draft.state;
+    const commit = useCallback((updated)=>{
+        const current = stateRef.current;
+        if (updated === current) return;
+        touched.current = true;
+        stateRef.current = updated;
+        setState(updated);
+        save == null ? void 0 : save(updated);
+        if (updated.activeStep !== current.activeStep) {
+            // Resuming is a fact about arriving. Once the operator moves, the recap
+            // has been read or ignored, and a banner that never leaves stops being
+            // read at all.
+            setResumed(false);
+            onStepChange == null ? void 0 : onStepChange(updated.activeStep);
+        }
+    }, [
+        save,
+        onStepChange
+    ]);
+    const apply = useCallback((next)=>commit(next(stateRef.current)), [
+        commit
+    ]);
+    /**
+   * A persisted wizard is adopted **once, and only while untouched**.
+   *
+   * The store hydrates from an effect (`skipHydration`, ADR 0032), so it arrives
+   * after the first render and cannot be a `useState` initializer. Adopting it
+   * more than once would let a later hydration overwrite what the operator has
+   * since typed, and adopting it after a first edit would do the same on the
+   * very first keystroke.
+   */ useEffect(()=>{
+        if (adopted.current || touched.current || persisted === undefined) return;
+        adopted.current = true;
+        stateRef.current = persisted;
+        setState(persisted);
+        // Only a wizard that was genuinely mid-flow is a resume; one persisted on
+        // its first step has nothing to recap.
+        setResumed(persisted.history.length > 0);
+    }, [
+        persisted
+    ]);
+    /**
+   * One draft store per step id, minted once and kept forever.
+   *
+   * `useEntityForm` writes from an effect keyed on `save`, so a new identity per
+   * render would make every render a write. A `Map` in a ref rather than a memo
+   * because the set of steps a caller asks for grows as the flow is walked, and
+   * a memo keyed on that set would rebuild every entry whenever one was added.
+   */ const stores = useRef(new Map());
+    const draftStoreFor = useCallback((stepId)=>{
+        let store = stores.current.get(stepId);
+        if (store === undefined) {
+            store = {
+                save: (values)=>apply((current)=>withStepValue(current, stepId, {
+                            kind: 'form',
+                            values
+                        })),
+                clear: ()=>apply((current)=>withStepValue(current, stepId, {
+                            kind: 'none'
+                        }))
+            };
+            stores.current.set(stepId, store);
+        }
+        const value = state.steps[stepId];
+        return _extends({}, (value == null ? void 0 : value.kind) === 'form' ? {
+            draft: value.values
+        } : {}, {
+            save: store.save,
+            clear: store.clear
+        });
+    }, [
+        apply,
+        state
+    ]);
+    return {
+        state,
+        activeStep: state.activeStep,
+        steps: stepStatuses(definition, state, errored),
+        canFinish: canFinishWizard(definition, state),
+        isResumed,
+        draftStoreFor,
+        setStepValue: useCallback((stepId, value)=>apply((current)=>withStepValue(current, stepId, value)), [
+            apply
+        ]),
+        next: useCallback(()=>apply((current)=>advanceWizard(definition, current)), [
+            apply,
+            definition
+        ]),
+        previous: useCallback(()=>apply(goBackWizard), [
+            apply
+        ]),
+        goTo: useCallback((stepId)=>apply((current)=>goToWizardStep(current, stepId)), [
+            apply
+        ]),
+        reset: useCallback(()=>apply(()=>emptyWizardState(entry.id)), [
+            apply,
+            entry
+        ])
+    };
+}
+
+//# sourceMappingURL=use-wizard.js.map