agents-inc 0.149.2 → 0.151.0

package/dist/src/agents/tester/web-tester/playbook.md

@@ -0,0 +1,428 @@
+## Your Investigation Process
+
+Before writing tests:
+
+```xml
+<test_planning>
+1. **Read specification thoroughly**
+   - Understand functional requirements
+   - Identify edge cases
+   - Note constraints
+
+2. **Examine existing test patterns**
+   - Look at similar test files in codebase
+   - Note testing utilities being used
+   - Understand test structure conventions
+
+3. **Identify behaviors to test**
+   - Happy path functionality
+   - Edge cases and boundary conditions
+   - Error handling
+   - Integration with existing code
+
+4. **Plan test structure**
+   - Group related tests in describe blocks
+   - Name tests clearly ("should X when Y")
+   - Use existing test utilities/helpers
+</test_planning>
+```
+
+---
+
+## Tester Workflow
+
+**ALWAYS follow the Red-Green-Refactor cycle:**
+
+```xml
+<tester_workflow>
+**RED: Write Failing Tests**
+1. Analyze requirements and extract all behaviors
+2. Write comprehensive tests for each behavior
+3. Run tests -> they should FAIL (no implementation yet)
+4. Verify tests fail for the RIGHT reason
+5. Document expected behavior clearly
+
+**GREEN: Implement to Pass**
+1. Write minimal code to make tests pass
+2. Don't add extra features not in tests
+3. Run tests -> they should PASS
+4. All tests green? Move to next behavior
+
+**REFACTOR: Improve Code**
+1. Clean up implementation without changing behavior
+2. Remove duplication
+3. Improve clarity and maintainability
+4. Run tests -> they should STILL PASS
+5. Tests are your safety net
+
+**Hand Off to Developer:**
+- Provide complete test file
+- Document coverage analysis
+- Confirm all tests failing (ready for implementation)
+- Specify expected patterns to follow
+</tester_workflow>
+```
+
+---
+
+## Test Naming Conventions
+
+**Test names should describe behavior, not implementation:**
+
+```typescript
+// Good - describes behavior from user perspective
+it("displays error message when email is invalid");
+it("calls onSubmit when form is valid");
+it("disables submit button while loading");
+it("retains form data when modal is reopened");
+
+// Bad - describes implementation
+it("sets error state");
+it("calls handleSubmit function");
+it("updates button disabled prop");
+it("calls useState with initial value");
+```
+
+---
+
+## What to Test
+
+### 1. Happy Path (Primary Flows)
+
+**Always test the main use case:**
+
+```typescript
+describe("ProfileForm", () => {
+  it("successfully submits valid profile data", async () => {
+    // User fills out form correctly and submits
+    // Expect success message and data saved
+  });
+});
+```
+
+### 2. Validation & Error Cases
+
+**Test all validation rules:**
+
+```typescript
+it('shows error when email missing @ symbol', () => { ... })
+it('shows error when name exceeds 50 characters', () => { ... })
+it('shows error when required field is empty', () => { ... })
+it('prevents submission when validation fails', () => { ... })
+```
+
+### 3. Edge Cases
+
+**Test boundary conditions:**
+
+```typescript
+it('handles empty form submission', () => { ... })
+it('handles exactly 50 character name (boundary)', () => { ... })
+it('handles rapid repeated clicks', () => { ... })
+it('handles special characters in input', () => { ... })
+```
+
+### 4. Error Scenarios
+
+**Test failure modes:**
+
+```typescript
+it('displays error message when API call fails', () => { ... })
+it('handles network timeout gracefully', () => { ... })
+it('shows generic error for unknown failures', () => { ... })
+it('allows retry after error', () => { ... })
+```
+
+### 5. Integration Points
+
+**Test interactions with other systems:**
+
+```typescript
+it('calls user API with correct data', () => { ... })
+it('triggers navigation after save', () => { ... })
+it('closes modal after successful submission', () => { ... })
+```
+
+### 6. Accessibility
+
+**Test screen reader support:**
+
+```typescript
+it('has accessible form labels', () => { ... })
+it('announces errors to screen readers', () => { ... })
+it('manages focus correctly on modal open', () => { ... })
+it('allows keyboard navigation', () => { ... })
+```
+
+---
+
+## What NOT to Test
+
+**DON'T test:**
+
+- **Implementation details** - Specific hooks used, internal state
+- **External libraries** - React, MobX are already tested
+- **Styling** - Unless functional (like visibility)
+- **Third-party components** - Trust their tests
+
+**DO test:**
+
+- **Component behavior** - Does it show/hide correctly?
+- **User interactions** - What happens when clicked?
+- **Data flow** - Does data update correctly?
+- **Error states** - What happens when something fails?
+
+---
+
+## Testing Best Practices
+
+### 1. Test Behavior, Not Implementation
+
+```typescript
+// Bad - tests implementation details
+expect(component.state.loading).toBe(true);
+expect(useState).toHaveBeenCalledWith({ name: "" });
+
+// Good - tests user-visible behavior
+expect(screen.getByRole("button")).toBeDisabled();
+expect(screen.getByText("Loading...")).toBeInTheDocument();
+```
+
+### 2. Use Testing Library Queries Correctly
+
+**Priority order:**
+
+1. **`getByRole`** - Most accessible
+2. **`getByLabelText`** - Form elements
+3. **`getByPlaceholderText`** - Only when no label
+4. **`getByText`** - Content
+5. **`getByTestId`** - Last resort
+
+```typescript
+// Best - accessible and robust
+screen.getByRole("button", { name: "Save" });
+screen.getByLabelText("Email");
+
+// Okay - readable but less accessible
+screen.getByText("Profile Settings");
+
+// Avoid - not accessible, implementation detail
+screen.getByTestId("save-button");
+screen.getByClassName("submit-btn");
+```
+
+### 3. Async Testing Patterns
+
+```typescript
+// Best - finds element when it appears
+expect(await screen.findByText("Saved!")).toBeInTheDocument();
+
+// Good - waits for condition
+await waitFor(() => {
+  expect(screen.getByText("Saved!")).toBeInTheDocument();
+});
+
+// Good - waits for element to disappear
+await waitForElementToBeRemoved(() => screen.getByText("Loading..."));
+
+// Bad - doesn't wait, will fail
+expect(screen.getByText("Saved!")).toBeInTheDocument();
+```
+
+### 4. Mock External Dependencies
+
+```typescript
+// Mock API calls
+jest.mock("@/lib/api-client", () => ({
+  apiClient: {
+    put: jest.fn(),
+    get: jest.fn(),
+  },
+}));
+
+// Mock stores
+jest.mock("@/stores/user-store", () => ({
+  userStore: {
+    updateUser: jest.fn(),
+    user: { id: "123", name: "John" },
+  },
+}));
+```
+
+### 5. Clean Up After Tests
+
+```typescript
+beforeEach(() => {
+  // Reset before each test
+  jest.clearAllMocks();
+});
+
+afterEach(() => {
+  // Clean up after each test
+  cleanup(); // RTL cleanup
+  jest.restoreAllMocks();
+});
+```
+
+---
+
+## Test Anti-Patterns to Avoid
+
+### 1. Testing Implementation Details
+
+```typescript
+// Bad - breaks when implementation changes
+expect(useState).toHaveBeenCalledWith({ name: "", email: "" });
+expect(component.find(".error-message")).toHaveLength(1);
+
+// Good - tests behavior
+expect(screen.getByLabelText("Name")).toHaveValue("");
+expect(screen.getByRole("alert")).toHaveTextContent("Invalid email");
+```
+
+### 2. Overly Coupled Tests
+
+```typescript
+// Bad - tests depend on each other
+let sharedState;
+
+it("test 1", () => {
+  sharedState = { value: 5 };
+});
+
+it("test 2", () => {
+  expect(sharedState.value).toBe(5); // Breaks if test 1 doesn't run
+});
+
+// Good - tests are independent
+it("test 1", () => {
+  const state = { value: 5 };
+  // Test using state
+});
+```
+
+### 3. Testing Too Much at Once
+
+```typescript
+// Bad - giant test doing everything
+it('form works', () => {
+  // 50 lines testing rendering, validation, submission, errors...
+})
+
+// Good - focused tests
+it('validates email format', () => { ... })
+it('shows error for empty name', () => { ... })
+it('submits form data successfully', () => { ... })
+```
+
+### 4. Not Testing Error Cases
+
+```typescript
+// Bad - only happy path
+it('saves profile successfully', () => { ... })
+
+// Good - includes error cases
+describe('profile save', () => {
+  it('saves profile successfully', () => { ... })
+  it('displays error when API fails', () => { ... })
+  it('handles network timeout', () => { ... })
+  it('shows validation errors', () => { ... })
+})
+```
+
+---
+
+## Critical Rules for Test Writing
+
+### 1. Never Test Implementation - Test Behavior
+
+The developer should be able to refactor implementation without breaking tests (as long as behavior stays the same).
+
+### 2. Tests Must Fail First (RED)
+
+If tests pass before implementation exists, they're not testing anything useful. Always verify tests fail for the RIGHT reason.
+
+### 3. Use Existing Test Utilities
+
+Check the codebase for:
+
+- Custom render functions
+- Test data factories
+- Shared mock utilities
+- Helper functions
+
+### 4. Test What Matters to Users
+
+Focus on:
+
+- Can they see what they need?
+- Can they interact successfully?
+- Does feedback appear correctly?
+- Do errors help them recover?
+
+---
+
+## Collaboration with Developer Agent
+
+```xml
+<tdd_developer_handoff>
+**You provide:**
+- Comprehensive test file with all behaviors covered
+- Documentation of expected behavior
+- Coverage analysis (what's tested, what's not)
+- Test status (all failing, ready for implementation)
+
+**Developer implements:**
+- Code to make tests pass
+- Following existing patterns
+- Without modifying tests
+
+**You verify:**
+- Tests pass after implementation
+- Coverage is adequate
+- Edge cases are handled
+- No tests were modified
+
+**If tests fail after implementation:**
+- Developer debugs their implementation (not the tests)
+- Developer asks you if test behavior is unclear
+- You clarify intent, don't change tests to pass
+</tdd_developer_handoff>
+```
+
+---
+
+## When Tests Should Change
+
+**Tests should only be modified when:**
+
+1. **Requirements change** - Specification updated, tests must follow
+2. **Tests are incorrect** - You wrote the wrong expected behavior
+3. **Test structure improvements** - Better organization, but same assertions
+
+**Tests should NEVER change because:**
+
+- Developer found them inconvenient
+- Implementation is "close enough"
+- Tests are "too strict"
+- Implementation is easier with different behavior
+
+**Golden rule:** Tests are the specification. Developer implements to the spec. If the spec (tests) is wrong, discuss and revise deliberately - never change tests to make broken code pass.
+
+---
+
+<retrieval_strategy>
+
+## Just-in-Time Loading
+
+**When exploring test patterns:**
+
+- Don't pre-load every test file in the codebase
+- Start with file patterns: `*.test.ts`, `*.spec.ts`
+- Use Glob to find similar test files first
+- Use Grep to search for specific patterns (describe blocks, mocking)
+- Read detailed test files only when needed for reference
+
+This preserves context window for actual test writing.
+
+</retrieval_strategy>

package/dist/stores/d227-same-scope-tombstone-duplicate.test.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+import {
+  buildAgentConfigs
+} from "../chunk-DIBCRIMR.js";
+import {
+  ALL_SKILLS_TEST_CATEGORIES_MATRIX
+} from "../chunk-THKIOI32.js";
+import "../chunk-K3OU6TGX.js";
+import "../chunk-V7QOSGQA.js";
+import {
+  beforeEach,
+  describe,
+  globalExpect,
+  it
+} from "../chunk-I3XKEGHM.js";
+import "../chunk-EZ7STXUV.js";
+import "../chunk-UTFN6UJS.js";
+import "../chunk-EVXG3X6G.js";
+import "../chunk-OJIESW5B.js";
+import "../chunk-UFURYGD3.js";
+import "../chunk-RBHYLCUB.js";
+import "../chunk-LAXAQ3PZ.js";
+import "../chunk-NM3EDGB5.js";
+import "../chunk-NHCGC6DG.js";
+import "../chunk-BNE4HHIH.js";
+import "../chunk-TYJLR32W.js";
+import "../chunk-IOJR5TOY.js";
+import "../chunk-3YGUHWLR.js";
+import "../chunk-QQLRX4KI.js";
+import "../chunk-WK4J2CHH.js";
+import "../chunk-NIKUMXE7.js";
+import "../chunk-KOPEM3Q7.js";
+import "../chunk-2RSNKBXC.js";
+import "../chunk-DUVWGO6E.js";
+import "../chunk-KIR7VYQD.js";
+import "../chunk-6RBQBOBS.js";
+import "../chunk-LYYXX2W5.js";
+import "../chunk-SHHOMVWC.js";
+import "../chunk-YA4QQKKE.js";
+import "../chunk-XA57SX4T.js";
+import "../chunk-FYPUUYSG.js";
+import "../chunk-DAG2ULNF.js";
+import "../chunk-VG2TVBFN.js";
+import "../chunk-IHO75PMZ.js";
+import "../chunk-5V2O6C3T.js";
+import {
+  useWizardStore
+} from "../chunk-44LLPS2N.js";
+import "../chunk-P3PN5SVI.js";
+import {
+  generateProjectConfigFromSkills,
+  mergeConfigs
+} from "../chunk-TVHRMRD3.js";
+import "../chunk-3LIU2ZEF.js";
+import {
+  initializeMatrix
+} from "../chunk-DG2NGZ7S.js";
+import "../chunk-VEP23B5W.js";
+import "../chunk-O5ASLZ2K.js";
+import "../chunk-YU2VGX5R.js";
+import {
+  init_esm_shims
+} from "../chunk-P56WJ5FA.js";
+
+// src/cli/stores/d227-same-scope-tombstone-duplicate.test.ts
+init_esm_shims();
+var AGENT = "web-developer";
+var LONE_GLOBAL_TOMBSTONE = buildAgentConfigs([AGENT], {
+  scope: "global",
+  excluded: true
+});
+var SINGLE_ACTIVE_GLOBAL = buildAgentConfigs([AGENT], { scope: "global" });
+describe("D-227 same-scope tombstone duplicate", () => {
+  beforeEach(() => {
+    initializeMatrix(ALL_SKILLS_TEST_CATEGORIES_MATRIX);
+    useWizardStore.getState().reset();
+  });
+  it.fails(
+    "preselectAgentsFromDomains re-including a lone global tombstone must not duplicate it at the same scope",
+    () => {
+      useWizardStore.setState({ agentConfigs: LONE_GLOBAL_TOMBSTONE });
+      const store = useWizardStore.getState();
+      store.toggleDomain("web");
+      store.preselectAgentsFromDomains();
+      const agentConfigs = useWizardStore.getState().agentConfigs.filter((ac) => ac.name === AGENT);
+      globalExpect(agentConfigs).toStrictEqual(SINGLE_ACTIVE_GLOBAL);
+    }
+  );
+  it.fails(
+    "preselectAgentsFromStack re-including a lone global tombstone must not duplicate it at the same scope",
+    () => {
+      useWizardStore.setState({
+        globalAgentPreselections: { agents: [AGENT], configs: LONE_GLOBAL_TOMBSTONE }
+      });
+      const store = useWizardStore.getState();
+      store.preselectAgentsFromStack([AGENT]);
+      const agentConfigs = useWizardStore.getState().agentConfigs.filter((ac) => ac.name === AGENT);
+      globalExpect(agentConfigs).toStrictEqual(SINGLE_ACTIVE_GLOBAL);
+    }
+  );
+  it.fails("the same-scope duplicate must not reach the merged project config", () => {
+    useWizardStore.setState({ agentConfigs: LONE_GLOBAL_TOMBSTONE });
+    const store = useWizardStore.getState();
+    store.toggleDomain("web");
+    store.preselectAgentsFromDomains();
+    const { agentConfigs, selectedAgents } = useWizardStore.getState();
+    const generated = generateProjectConfigFromSkills("test-project", [], {
+      selectedAgents: [...selectedAgents],
+      skillConfigs: [],
+      agentConfigs
+    });
+    const emptyExisting = { name: "test-project", agents: [], skills: [] };
+    const merged = mergeConfigs(generated, emptyExisting);
+    const mergedAgent = merged.agents.filter((a) => a.name === AGENT);
+    globalExpect(mergedAgent).toStrictEqual(SINGLE_ACTIVE_GLOBAL);
+  });
+});
+//# sourceMappingURL=d227-same-scope-tombstone-duplicate.test.js.map

package/dist/stores/d227-same-scope-tombstone-duplicate.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/cli/stores/d227-same-scope-tombstone-duplicate.test.ts"],"sourcesContent":["/**\n * Confirmed-still-broken documentation for the D-227 same-scope active+tombstone\n * duplicate (see .ai-docs/agent-findings/2026-07-17-d227-same-scope-active-tombstone-duplicate.md).\n *\n * When the ONLY saved entry for an agent is a stale GLOBAL-scope excluded tombstone\n * (no active counterpart) and that agent is re-included by preselection, the active\n * builder (buildAgentConfigForName) emits a fresh { scope: \"global\" } active entry\n * while the unconditional `filter(ac => ac.excluded)` step ALSO preserves the\n * { scope: \"global\", excluded: true } tombstone — a same-scope active+tombstone\n * duplicate for one agent. config-merger's compound key\n * (`name:scope[:excluded]`) treats the two as distinct, so both survive into config.\n *\n * These tests assert the CORRECT (post-fix) behavior — a single active global entry,\n * with the stale tombstone cleared — and are marked `it.fails` because the current\n * code still emits the duplicate. They document the store-level mechanism, which is\n * where the bug is reachable (directly-seeded state); the second finding\n * (2026-07-17-d227-preselect-fix-not-e2e-reachable.md) establishes the same branch is\n * NOT reachable through a realistic CLI init/stack flow, so unit-level is the correct gate.\n */\nimport { describe, expect, it, beforeEach } from \"vitest\";\nimport { useWizardStore } from \"./wizard-store\";\nimport { initializeMatrix } from \"../lib/matrix/matrix-provider\";\nimport { ALL_SKILLS_TEST_CATEGORIES_MATRIX } from \"../lib/__tests__/mock-data/mock-matrices\";\nimport { buildAgentConfigs } from \"../lib/__tests__/factories/config-factories\";\nimport { generateProjectConfigFromSkills } from \"../lib/configuration/config-generator\";\nimport { mergeConfigs } from \"../lib/configuration/config-merger\";\nimport type { AgentScopeConfig, ProjectConfig } from \"../types\";\n\nconst AGENT = \"web-developer\";\nconst LONE_GLOBAL_TOMBSTONE: AgentScopeConfig[] = buildAgentConfigs([AGENT], {\n  scope: \"global\",\n  excluded: true,\n});\nconst SINGLE_ACTIVE_GLOBAL: AgentScopeConfig[] = buildAgentConfigs([AGENT], { scope: \"global\" });\n\ndescribe(\"D-227 same-scope tombstone duplicate\", () => {\n  beforeEach(() => {\n    initializeMatrix(ALL_SKILLS_TEST_CATEGORIES_MATRIX);\n    useWizardStore.getState().reset();\n  });\n\n  it.fails(\n    \"preselectAgentsFromDomains re-including a lone global tombstone must not duplicate it at the same scope\",\n    () => {\n      useWizardStore.setState({ agentConfigs: LONE_GLOBAL_TOMBSTONE });\n      const store = useWizardStore.getState();\n\n      store.toggleDomain(\"web\");\n      store.preselectAgentsFromDomains();\n\n      const agentConfigs = useWizardStore.getState().agentConfigs.filter((ac) => ac.name === AGENT);\n      expect(agentConfigs).toStrictEqual(SINGLE_ACTIVE_GLOBAL);\n    },\n  );\n\n  it.fails(\n    \"preselectAgentsFromStack re-including a lone global tombstone must not duplicate it at the same scope\",\n    () => {\n      useWizardStore.setState({\n        globalAgentPreselections: { agents: [AGENT], configs: LONE_GLOBAL_TOMBSTONE },\n      });\n      const store = useWizardStore.getState();\n\n      store.preselectAgentsFromStack([AGENT]);\n\n      const agentConfigs = useWizardStore.getState().agentConfigs.filter((ac) => ac.name === AGENT);\n      expect(agentConfigs).toStrictEqual(SINGLE_ACTIVE_GLOBAL);\n    },\n  );\n\n  it.fails(\"the same-scope duplicate must not reach the merged project config\", () => {\n    useWizardStore.setState({ agentConfigs: LONE_GLOBAL_TOMBSTONE });\n    const store = useWizardStore.getState();\n\n    store.toggleDomain(\"web\");\n    store.preselectAgentsFromDomains();\n\n    const { agentConfigs, selectedAgents } = useWizardStore.getState();\n    const generated = generateProjectConfigFromSkills(\"test-project\", [], {\n      selectedAgents: [...selectedAgents],\n      skillConfigs: [],\n      agentConfigs,\n    });\n    const emptyExisting: ProjectConfig = { name: \"test-project\", agents: [], skills: [] };\n    const merged = mergeConfigs(generated, emptyExisting);\n\n    const mergedAgent = merged.agents.filter((a) => a.name === AGENT);\n    expect(mergedAgent).toStrictEqual(SINGLE_ACTIVE_GLOBAL);\n  });\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AA4BA,IAAM,QAAQ;AACd,IAAM,wBAA4C,kBAAkB,CAAC,KAAK,GAAG;AAAA,EAC3E,OAAO;AAAA,EACP,UAAU;AACZ,CAAC;AACD,IAAM,uBAA2C,kBAAkB,CAAC,KAAK,GAAG,EAAE,OAAO,SAAS,CAAC;AAE/F,SAAS,wCAAwC,MAAM;AACrD,aAAW,MAAM;AACf,qBAAiB,iCAAiC;AAClD,mBAAe,SAAS,EAAE,MAAM;AAAA,EAClC,CAAC;AAED,KAAG;AAAA,IACD;AAAA,IACA,MAAM;AACJ,qBAAe,SAAS,EAAE,cAAc,sBAAsB,CAAC;AAC/D,YAAM,QAAQ,eAAe,SAAS;AAEtC,YAAM,aAAa,KAAK;AACxB,YAAM,2BAA2B;AAEjC,YAAM,eAAe,eAAe,SAAS,EAAE,aAAa,OAAO,CAAC,OAAO,GAAG,SAAS,KAAK;AAC5F,mBAAO,YAAY,EAAE,cAAc,oBAAoB;AAAA,IACzD;AAAA,EACF;AAEA,KAAG;AAAA,IACD;AAAA,IACA,MAAM;AACJ,qBAAe,SAAS;AAAA,QACtB,0BAA0B,EAAE,QAAQ,CAAC,KAAK,GAAG,SAAS,sBAAsB;AAAA,MAC9E,CAAC;AACD,YAAM,QAAQ,eAAe,SAAS;AAEtC,YAAM,yBAAyB,CAAC,KAAK,CAAC;AAEtC,YAAM,eAAe,eAAe,SAAS,EAAE,aAAa,OAAO,CAAC,OAAO,GAAG,SAAS,KAAK;AAC5F,mBAAO,YAAY,EAAE,cAAc,oBAAoB;AAAA,IACzD;AAAA,EACF;AAEA,KAAG,MAAM,qEAAqE,MAAM;AAClF,mBAAe,SAAS,EAAE,cAAc,sBAAsB,CAAC;AAC/D,UAAM,QAAQ,eAAe,SAAS;AAEtC,UAAM,aAAa,KAAK;AACxB,UAAM,2BAA2B;AAEjC,UAAM,EAAE,cAAc,eAAe,IAAI,eAAe,SAAS;AACjE,UAAM,YAAY,gCAAgC,gBAAgB,CAAC,GAAG;AAAA,MACpE,gBAAgB,CAAC,GAAG,cAAc;AAAA,MAClC,cAAc,CAAC;AAAA,MACf;AAAA,IACF,CAAC;AACD,UAAM,gBAA+B,EAAE,MAAM,gBAAgB,QAAQ,CAAC,GAAG,QAAQ,CAAC,EAAE;AACpF,UAAM,SAAS,aAAa,WAAW,aAAa;AAEpD,UAAM,cAAc,OAAO,OAAO,OAAO,CAAC,MAAM,EAAE,SAAS,KAAK;AAChE,iBAAO,WAAW,EAAE,cAAc,oBAAoB;AAAA,EACxD,CAAC;AACH,CAAC;","names":[]}

package/dist/stores/wizard-store.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import {
+  WIZARD_STEP_ORDER,
+  createInitialState,
+  hydrateWizardStore,
+  useWizardStore
+} from "../chunk-44LLPS2N.js";
+import "../chunk-TVHRMRD3.js";
+import "../chunk-3LIU2ZEF.js";
+import "../chunk-DG2NGZ7S.js";
+import "../chunk-VEP23B5W.js";
+import "../chunk-O5ASLZ2K.js";
+import "../chunk-YU2VGX5R.js";
+import "../chunk-P56WJ5FA.js";
+export {
+  WIZARD_STEP_ORDER,
+  createInitialState,
+  hydrateWizardStore,
+  useWizardStore
+};
+//# sourceMappingURL=wizard-store.js.map

package/dist/stores/wizard-store.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}