@duckwalk/mcp-server 0.1.2

package/dist/chunk-IIW4JPFI.js

@@ -0,0 +1,1295 @@
+// src/contract.ts
+function getDuckWalkContract() {
+  return {
+    server: {
+      name: "duckwalk-mcp",
+      version: "0.1.2"
+    },
+    guidance: {
+      summary: "Use this contract instead of searching the duckWalk repo or the user's home directory for examples.",
+      workspaceRoot: "Always pass workspaceRoot as the absolute target task workspace path when creating, reading, or updating guided sessions.",
+      gitignore: "Session creation automatically adds .guided-implementation/ to the target workspace .gitignore when no equivalent ignore rule already exists.",
+      commentStyle: "For functions or non-trivial logic in ghostCode, include short pragmatic comments that say what the code does. Only use an `Important:` comment when the behavior is safety-critical, stateful, or easy to misuse.",
+      pathfinderAuthoringHints: [
+        "Start at the real entrypoint for the user's question, such as middleware, controller, route, job handler, or event subscriber.",
+        "Follow calls, hooks, guards, and data handoffs in execution order until the question is answered.",
+        "Use one step per touchpoint, not one step per file.",
+        "Use named subranges so the walkthrough can distinguish action ranges from supporting context.",
+        "Fill step links explicitly so the graph and story can show why control moves to the next touchpoint."
+      ],
+      recommendedFlow: [
+        "Inspect only the current task workspace to choose file targets.",
+        "Call get_duckwalk_contract when you need the session shape or examples.",
+        "Call create_guided_session for implementation playback or create_pr_review_session for review playback.",
+        "Call pathfinder for question-driven codebase walkthroughs that explain architecture flow.",
+        "Only call get_guided_session when you explicitly need current session data.",
+        "Only call update_step_status when the user explicitly wants step state changed from Codex."
+      ]
+    },
+    tools: {
+      get_duckwalk_contract: {
+        description: "Returns the duckWalk contract, rules, and example payloads."
+      },
+      create_guided_session: {
+        description: "Validate and persist an implementation guided session.",
+        input: {
+          workspaceRoot: "string, absolute path, recommended",
+          session: "GuidedSession with mode implementation"
+        }
+      },
+      create_pr_review_session: {
+        description: "Validate and persist a PR review guided session.",
+        input: {
+          workspaceRoot: "string, absolute path, recommended",
+          session: "GuidedSession with mode pr_review"
+        }
+      },
+      pathfinder: {
+        description: "Validate and persist a question-driven codebase walkthrough guided session.",
+        input: {
+          workspaceRoot: "string, absolute path, recommended",
+          session: "GuidedSession with mode codebase_walkthrough"
+        }
+      },
+      get_guided_session: {
+        description: "Read the current session or a specific session by ID.",
+        input: {
+          workspaceRoot: "string, absolute path, recommended",
+          sessionId: "optional string"
+        }
+      },
+      update_step_status: {
+        description: "Update one step status in the current guided session state.",
+        input: {
+          workspaceRoot: "string, absolute path, recommended",
+          sessionId: "string",
+          stepId: "string",
+          status: ["pending", "active", "complete", "skipped"]
+        }
+      }
+    },
+    schema: {
+      sessionModes: ["implementation", "pr_review", "codebase_walkthrough"],
+      implementationStepRequiredFields: [
+        "id",
+        "order",
+        "mode",
+        "file",
+        "location",
+        "explanation",
+        "ghostCode"
+      ],
+      prReviewStepRequiredFields: [
+        "id",
+        "order",
+        "mode",
+        "file",
+        "location",
+        "explanation",
+        "review"
+      ],
+      codebaseWalkthroughRequiredFields: [
+        "question",
+        "lens",
+        "flow",
+        "id",
+        "order",
+        "mode",
+        "touchpoint",
+        "confidence",
+        "evidenceQuality",
+        "fileRationale",
+        "file",
+        "location",
+        "explanation",
+        "snippet",
+        "subranges"
+      ],
+      walkthroughFlowFields: ["summary", "path", "entrypoint?", "outcome?"],
+      walkthroughSubrangeFields: [
+        "id",
+        "label",
+        "role",
+        "range",
+        "summary?",
+        "snippet?",
+        "symbols?"
+      ],
+      walkthroughLinkFields: ["stepId", "subrangeId?", "type", "why", "viaSymbol?"],
+      walkthroughBranchFields: [
+        "id",
+        "label",
+        "condition",
+        "outcome",
+        "targetStepId?",
+        "targetSubrangeId?"
+      ],
+      walkthroughFollowUpFields: ["id", "kind", "label", "description", "stepId?", "file?"],
+      optionalStepFields: ["links?", "branches?", "symbols?"],
+      guidedFileTargetFields: ["path", "exists?", "createIfMissing?"],
+      locationStrategies: ["create_file", "line", "range", "after_text", "before_text"],
+      explanationFields: ["title", "what", "why", "how?", "impact?", "risk?", "narration?"],
+      validation: {
+        default: {
+          type: "normalised_match"
+        },
+        optionalFields: ["expectedText", "scope"]
+      },
+      prReviewRangeRule: "Each pr_review step must include a usable range through location.range or review.changedRange.",
+      codebaseWalkthroughRangeRule: "Each codebase_walkthrough step must include location.strategy = range and a usable location.range.",
+      codebaseWalkthroughSubrangeRules: [
+        "Each codebase_walkthrough step must include named subranges.",
+        "Exactly one subrange must use role primary and it must match location.range.",
+        "Additional subranges should usually use role action or context.",
+        "Subrange IDs and ranges must be unique within the step.",
+        "Links must point to real step IDs in the same walkthrough.",
+        "When links or branches target subranges, the target subrange ID must exist on the target step."
+      ]
+    },
+    examples: {
+      create_guided_session: {
+        workspaceRoot: "/absolute/path/to/task/workspace",
+        session: {
+          id: "feature-auth-middleware",
+          mode: "implementation",
+          title: "Create auth middleware",
+          summary: "Adds a reusable auth middleware and wires it into routes.",
+          createdAt: "2026-06-18T00:00:00.000Z",
+          steps: [
+            {
+              id: "step-1",
+              order: 1,
+              mode: "implementation",
+              file: {
+                path: "src/middleware/auth.ts",
+                createIfMissing: true
+              },
+              location: {
+                strategy: "create_file"
+              },
+              explanation: {
+                title: "Create the auth middleware",
+                what: "Adds a reusable authorization middleware.",
+                why: "Route handlers should not repeat auth checks."
+              },
+              ghostCode: "import type { FastifyReply, FastifyRequest } from 'fastify';\n\n// Rejects unauthenticated requests before route handlers run.\nexport async function authMiddleware(request: FastifyRequest, reply: FastifyReply) {\n  const authHeader = request.headers.authorization;\n\n  // Important: fail fast so protected handlers never run without auth.\n  if (!authHeader) {\n    return reply.code(401).send({ error: 'Missing authorization header' });\n  }\n}\n",
+              validation: {
+                type: "normalised_match"
+              }
+            }
+          ]
+        }
+      },
+      create_pr_review_session: {
+        workspaceRoot: "/absolute/path/to/task/workspace",
+        session: {
+          id: "review-auth-middleware",
+          mode: "pr_review",
+          title: "Review auth middleware changes",
+          summary: "Walks through the middleware and route wiring changes.",
+          createdAt: "2026-06-18T00:00:00.000Z",
+          steps: [
+            {
+              id: "review-step-1",
+              order: 1,
+              mode: "pr_review",
+              file: {
+                path: "src/middleware/auth.ts"
+              },
+              location: {
+                strategy: "range",
+                range: {
+                  startLine: 1,
+                  startCharacter: 0,
+                  endLine: 12,
+                  endCharacter: 0
+                }
+              },
+              explanation: {
+                title: "Review the middleware implementation",
+                what: "Adds a reusable auth check.",
+                why: "Routes should fail fast before business logic.",
+                impact: "Protected handlers now reject missing authorization headers."
+              },
+              review: {
+                beforeCode: "",
+                afterCode: "export async function authMiddleware() {}\n",
+                changedRange: {
+                  startLine: 1,
+                  startCharacter: 0,
+                  endLine: 12,
+                  endCharacter: 0
+                }
+              }
+            }
+          ]
+        }
+      },
+      pathfinder: {
+        workspaceRoot: "/absolute/path/to/task/workspace",
+        session: {
+          id: "walkthrough-authentication-flow",
+          mode: "codebase_walkthrough",
+          title: "Trace backend authentication flow",
+          summary: "Shows how a protected request moves from middleware into token validation.",
+          question: "How does authentication work in this backend project?",
+          lens: "permission_flow",
+          flow: {
+            summary: "Request -> auth middleware -> auth service -> route guard",
+            path: ["Request", "authMiddleware", "resolveAuthenticatedUser", "requireRole"],
+            entrypoint: "HTTP request to a protected route",
+            outcome: "Only authenticated requests with the right role reach the handler."
+          },
+          followUps: [
+            {
+              id: "follow-up-tests",
+              kind: "tests",
+              label: "Inspect auth tests",
+              description: "Open the middleware tests to confirm the success path and failure branches.",
+              file: "tests/auth/middleware.test.ts"
+            }
+          ],
+          createdAt: "2026-06-18T00:00:00.000Z",
+          steps: [
+            {
+              id: "walkthrough-step-1",
+              order: 1,
+              mode: "codebase_walkthrough",
+              touchpoint: "entry",
+              confidence: "direct",
+              evidenceQuality: "high",
+              fileRationale: "This file is the first protected-route touchpoint where authentication begins.",
+              file: {
+                path: "src/auth/middleware.ts"
+              },
+              location: {
+                strategy: "range",
+                range: {
+                  startLine: 1,
+                  startCharacter: 0,
+                  endLine: 12,
+                  endCharacter: 0
+                }
+              },
+              subranges: [
+                {
+                  id: "middleware-entry",
+                  label: "Middleware entry",
+                  role: "primary",
+                  range: {
+                    startLine: 1,
+                    startCharacter: 0,
+                    endLine: 12,
+                    endCharacter: 0
+                  },
+                  summary: "Reads the Authorization header and extracts the bearer token.",
+                  symbols: ["authMiddleware"]
+                },
+                {
+                  id: "downstream-policy-context",
+                  label: "Downstream policy context",
+                  role: "context",
+                  range: {
+                    startLine: 130,
+                    startCharacter: 0,
+                    endLine: 190,
+                    endCharacter: 0
+                  },
+                  summary: "Later role checks depend on the authenticated user injected here.",
+                  symbols: ["requireRole"]
+                }
+              ],
+              symbols: ["authMiddleware", "resolveAuthenticatedUser", "requireRole"],
+              explanation: {
+                title: "Start at the auth middleware",
+                what: "This middleware extracts the bearer token from the request.",
+                why: "Every protected route enters the authentication flow here.",
+                how: "The request header is parsed and the token is passed to the downstream auth service.",
+                impact: "Requests without a token fail before route handlers run."
+              },
+              snippet: "export async function authMiddleware(request, reply) {\n  const authHeader = request.headers.authorization;\n  const token = authHeader?.replace('Bearer ', '');\n}\n",
+              links: [
+                {
+                  stepId: "walkthrough-step-2",
+                  subrangeId: "token-validate",
+                  type: "calls",
+                  why: "The extracted token is validated by the auth service before the request can continue.",
+                  viaSymbol: "resolveAuthenticatedUser"
+                }
+              ],
+              branches: [
+                {
+                  id: "missing-token",
+                  label: "Missing token",
+                  condition: "The Authorization header is missing or malformed.",
+                  outcome: "The request fails before the route handler runs."
+                },
+                {
+                  id: "success-path",
+                  label: "Success path",
+                  condition: "A bearer token is present.",
+                  outcome: "The request continues into the token validation step.",
+                  targetStepId: "walkthrough-step-2",
+                  targetSubrangeId: "token-validate"
+                }
+              ]
+            },
+            {
+              id: "walkthrough-step-2",
+              order: 2,
+              mode: "codebase_walkthrough",
+              touchpoint: "transform",
+              confidence: "direct",
+              evidenceQuality: "high",
+              fileRationale: "This file turns the raw token into a trusted identity object for downstream guards.",
+              file: {
+                path: "src/auth/service.ts"
+              },
+              location: {
+                strategy: "range",
+                range: {
+                  startLine: 10,
+                  startCharacter: 0,
+                  endLine: 24,
+                  endCharacter: 0
+                }
+              },
+              subranges: [
+                {
+                  id: "token-validate",
+                  label: "Token validation",
+                  role: "primary",
+                  range: {
+                    startLine: 10,
+                    startCharacter: 0,
+                    endLine: 24,
+                    endCharacter: 0
+                  },
+                  summary: "Verifies the token and resolves the authenticated user.",
+                  symbols: ["resolveAuthenticatedUser", "verifyToken"]
+                }
+              ],
+              symbols: ["resolveAuthenticatedUser", "verifyToken"],
+              explanation: {
+                title: "Validate the token and resolve the user",
+                what: "The auth service verifies the token and builds the authenticated user context.",
+                why: "Downstream guards can only make authorization decisions from a trusted identity.",
+                how: "The token verifier decodes claims and returns a resolved actor for later guards."
+              },
+              snippet: "export async function resolveAuthenticatedUser(token) {\n  const payload = await verifyToken(token);\n  return { userId: payload.sub, roles: payload.roles };\n}\n"
+            }
+          ]
+        }
+      }
+    }
+  };
+}
+
+// ../../packages/core/src/markdown-writer.ts
+function formatStepLocation(step) {
+  const labels = [];
+  if (step.mode === "pr_review" && step.review.changedRange) {
+    labels.push(
+      `${step.review.changedRange.startLine}:${step.review.changedRange.startCharacter} - ${step.review.changedRange.endLine}:${step.review.changedRange.endCharacter}`
+    );
+  } else if (step.location.strategy === "range" && step.location.range) {
+    labels.push(
+      `${step.location.range.startLine}:${step.location.range.startCharacter} - ${step.location.range.endLine}:${step.location.range.endCharacter}`
+    );
+  } else if (step.location.strategy === "line" && step.location.line) {
+    labels.push(`${step.location.line}:${step.location.column ?? 0}`);
+  } else if ((step.location.strategy === "after_text" || step.location.strategy === "before_text") && step.location.anchorText) {
+    labels.push(step.location.anchorText);
+  }
+  for (const subrange of step.subranges ?? []) {
+    labels.push(
+      `${subrange.label} (${subrange.role}): ${subrange.range.startLine}:${subrange.range.startCharacter} - ${subrange.range.endLine}:${subrange.range.endCharacter}`
+    );
+  }
+  return labels.length > 0 ? labels.join("; ") : null;
+}
+function renderSessionMarkdown(session) {
+  const lines = [
+    `# ${session.title}`,
+    "",
+    `- Session ID: \`${session.id}\``,
+    `- Mode: \`${session.mode}\``,
+    `- Created At: \`${session.createdAt}\``,
+    "",
+    session.summary
+  ];
+  if (session.mode === "codebase_walkthrough" && session.question) {
+    lines.push("", `Question: ${session.question}`);
+  }
+  if (session.mode === "codebase_walkthrough" && session.lens) {
+    lines.push(`Lens: ${session.lens}`);
+  }
+  if (session.mode === "codebase_walkthrough" && session.flow) {
+    lines.push("", "## Flow Summary", "");
+    lines.push(`- Summary: ${session.flow.summary}`);
+    lines.push(`- Path: ${session.flow.path.join(" -> ")}`);
+    if (session.flow.entrypoint) {
+      lines.push(`- Entrypoint: ${session.flow.entrypoint}`);
+    }
+    if (session.flow.outcome) {
+      lines.push(`- Outcome: ${session.flow.outcome}`);
+    }
+  }
+  lines.push("");
+  for (const step of [...session.steps].sort((left, right) => left.order - right.order)) {
+    lines.push(`## Step ${step.order}: ${step.explanation.title}`, "");
+    lines.push(`- File: \`${step.file.path}\``);
+    lines.push(`- Location strategy: \`${step.location.strategy}\``);
+    const locationDetail = formatStepLocation(step);
+    if (locationDetail) {
+      lines.push(`- Where: ${locationDetail}`);
+    }
+    if (step.mode === "codebase_walkthrough") {
+      lines.push(`- Touchpoint: ${step.touchpoint}`);
+      lines.push(`- Confidence: ${step.confidence}`);
+      lines.push(`- Evidence quality: ${step.evidenceQuality}`);
+      lines.push(`- File rationale: ${step.fileRationale}`);
+    }
+    lines.push(`- What: ${step.explanation.what}`);
+    lines.push(`- Why: ${step.explanation.why}`);
+    if (step.explanation.how) {
+      lines.push(`- How: ${step.explanation.how}`);
+    }
+    if (step.explanation.impact) {
+      lines.push(`- Impact: ${step.explanation.impact}`);
+    }
+    if (step.explanation.risk) {
+      lines.push(`- Risk: ${step.explanation.risk}`);
+    }
+    if (step.symbols?.length) {
+      lines.push(`- Symbols: ${step.symbols.join(", ")}`);
+    }
+    lines.push("");
+    if (step.mode === "implementation") {
+      lines.push("```ts", step.ghostCode, "```", "");
+    } else if (step.mode === "pr_review") {
+      if (step.review.beforeCode) {
+        lines.push("### Before", "", "```ts", step.review.beforeCode, "```", "");
+      }
+      if (step.review.afterCode) {
+        lines.push("### After", "", "```ts", step.review.afterCode, "```", "");
+      }
+    } else {
+      lines.push("### Snippet", "", "```ts", step.snippet, "```", "");
+      if (step.subranges?.length) {
+        lines.push("### Evidence", "");
+        for (const subrange of step.subranges) {
+          lines.push(
+            `- ${subrange.label} [${subrange.role}] ${subrange.range.startLine}:${subrange.range.startCharacter} - ${subrange.range.endLine}:${subrange.range.endCharacter}`
+          );
+          if (subrange.summary) {
+            lines.push(`  Summary: ${subrange.summary}`);
+          }
+          if (subrange.symbols?.length) {
+            lines.push(`  Symbols: ${subrange.symbols.join(", ")}`);
+          }
+          if (subrange.snippet) {
+            lines.push("", "```ts", subrange.snippet, "```");
+          }
+        }
+        lines.push("");
+      }
+      if (step.links?.length) {
+        lines.push("### Links", "");
+        for (const link of step.links) {
+          const via = link.viaSymbol ? ` via ${link.viaSymbol}` : "";
+          const target = link.subrangeId ? `${link.stepId}#${link.subrangeId}` : link.stepId;
+          lines.push(`- ${link.type} -> ${target}${via}: ${link.why}`);
+        }
+        lines.push("");
+      }
+      if (step.branches?.length) {
+        lines.push("### Branches", "");
+        for (const branch of step.branches) {
+          const target = branch.targetStepId ? ` -> ${branch.targetStepId}${branch.targetSubrangeId ? `#${branch.targetSubrangeId}` : ""}` : "";
+          lines.push(`- ${branch.label}${target}`);
+          lines.push(`  Condition: ${branch.condition}`);
+          lines.push(`  Outcome: ${branch.outcome}`);
+        }
+        lines.push("");
+      }
+    }
+  }
+  if (session.mode === "codebase_walkthrough" && session.followUps?.length) {
+    lines.push("## Follow-ups", "");
+    for (const followUp of session.followUps) {
+      const target = followUp.stepId ? `step ${followUp.stepId}` : followUp.file ? `file ${followUp.file}` : "general";
+      lines.push(`- ${followUp.label} [${followUp.kind}] (${target})`);
+      lines.push(`  ${followUp.description}`);
+    }
+  }
+  return `${lines.join("\n").trim()}
+`;
+}
+
+// ../../packages/core/src/recipe-writer.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import path2 from "path";
+
+// ../../packages/core/src/state.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var guidedPaths = {
+  directoryName: ".guided-implementation",
+  currentRecipeName: "current.recipe.json",
+  currentMarkdownName: "current.recipe.md",
+  stateName: "state.json",
+  sessionsDirectoryName: "sessions"
+};
+var stepStateSchema = z.object({
+  status: z.enum(["pending", "active", "complete", "skipped"]),
+  completedAt: z.string().optional()
+});
+var guidedSessionStateSchema = z.object({
+  sessionId: z.string().min(1),
+  activeStepId: z.string().min(1).nullable(),
+  activeStepOrder: z.number().int().positive().nullable(),
+  updatedAt: z.string().min(1),
+  steps: z.record(stepStateSchema)
+});
+function resolveGuidedPaths(rootDir) {
+  const baseDir = path.join(rootDir, guidedPaths.directoryName);
+  return {
+    baseDir,
+    currentRecipePath: path.join(baseDir, guidedPaths.currentRecipeName),
+    currentMarkdownPath: path.join(baseDir, guidedPaths.currentMarkdownName),
+    statePath: path.join(baseDir, guidedPaths.stateName),
+    sessionsDir: path.join(baseDir, guidedPaths.sessionsDirectoryName)
+  };
+}
+function getSessionStatePath(paths, sessionId) {
+  return path.join(paths.sessionsDir, `${sessionId}.state.json`);
+}
+function createInitialSessionState(session) {
+  const orderedSteps = [...session.steps].sort((left, right) => left.order - right.order);
+  const firstStep = orderedSteps[0] ?? null;
+  const steps = {};
+  for (const step of orderedSteps) {
+    steps[step.id] = {
+      status: step.id === firstStep?.id ? "active" : "pending"
+    };
+  }
+  return {
+    sessionId: session.id,
+    activeStepId: firstStep?.id ?? null,
+    activeStepOrder: firstStep?.order ?? null,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    steps
+  };
+}
+async function ensureGuidedDirectories(rootDir) {
+  const paths = resolveGuidedPaths(rootDir);
+  await mkdir(paths.baseDir, { recursive: true });
+  await mkdir(paths.sessionsDir, { recursive: true });
+  return paths;
+}
+async function readGuidedState(rootDir, sessionId) {
+  const paths = resolveGuidedPaths(rootDir);
+  const statePath = sessionId ? getSessionStatePath(paths, sessionId) : paths.statePath;
+  try {
+    const raw = await readFile(statePath, "utf8");
+    return guidedSessionStateSchema.parse(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+async function writeGuidedState(rootDir, state, options = {}) {
+  const paths = await ensureGuidedDirectories(rootDir);
+  const nextState = {
+    ...state,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const payload = JSON.stringify(nextState, null, 2);
+  const sessionStatePath = getSessionStatePath(paths, nextState.sessionId);
+  await writeFile(sessionStatePath, payload);
+  if (options.writeCurrent ?? true) {
+    await writeFile(paths.statePath, payload);
+    return paths.statePath;
+  }
+  return sessionStatePath;
+}
+async function updateGuidedStepStatus(rootDir, session, stepId, status, options = {}) {
+  const existing = await readGuidedState(rootDir, session.id) ?? createInitialSessionState(session);
+  const orderedSteps = [...session.steps].sort((left, right) => left.order - right.order);
+  const currentIndex = orderedSteps.findIndex((step) => step.id === stepId);
+  if (currentIndex === -1) {
+    throw new Error(`Unknown step ID: ${stepId}`);
+  }
+  const nextSteps = {
+    ...existing.steps,
+    [stepId]: {
+      status,
+      completedAt: status === "complete" ? (/* @__PURE__ */ new Date()).toISOString() : void 0
+    }
+  };
+  let activeStepId = existing.activeStepId;
+  let activeStepOrder = existing.activeStepOrder;
+  if (status === "complete") {
+    const nextStep = orderedSteps[currentIndex + 1];
+    if (nextStep) {
+      if (nextSteps[nextStep.id]?.status !== "complete") {
+        nextSteps[nextStep.id] = { status: "active" };
+      }
+      activeStepId = nextStep.id;
+      activeStepOrder = nextStep.order;
+    } else {
+      activeStepId = null;
+      activeStepOrder = null;
+    }
+  }
+  const nextState = {
+    sessionId: session.id,
+    activeStepId,
+    activeStepOrder,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    steps: nextSteps
+  };
+  await writeGuidedState(rootDir, nextState, options);
+  return nextState;
+}
+
+// ../../packages/core/src/recipe-writer.ts
+var guidedImplementationIgnoreRule = ".guided-implementation/";
+async function ensureGuidedImplementationGitignore(rootDir) {
+  const gitignorePath = path2.join(rootDir, ".gitignore");
+  let existing = "";
+  try {
+    existing = await readFile2(gitignorePath, "utf8");
+  } catch {
+    existing = "";
+  }
+  const hasRule = existing.split(/\r?\n/).map((line) => line.trim()).some(
+    (line) => line === guidedImplementationIgnoreRule || line === ".guided-implementation" || line === ".guided-implementation/*"
+  );
+  if (hasRule) {
+    return;
+  }
+  const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+  await writeFile2(gitignorePath, `${existing}${prefix}${guidedImplementationIgnoreRule}
+`);
+}
+async function writeRecipeFiles(rootDir, session) {
+  const paths = await ensureGuidedDirectories(rootDir);
+  const recipePayload = `${JSON.stringify(session, null, 2)}
+`;
+  const markdownPayload = renderSessionMarkdown(session);
+  const sessionRecipePath = path2.join(paths.sessionsDir, `${session.id}.recipe.json`);
+  const sessionMarkdownPath = path2.join(paths.sessionsDir, `${session.id}.recipe.md`);
+  await ensureGuidedImplementationGitignore(rootDir);
+  await writeFile2(paths.currentRecipePath, recipePayload);
+  await writeFile2(paths.currentMarkdownPath, markdownPayload);
+  await writeFile2(sessionRecipePath, recipePayload);
+  await writeFile2(sessionMarkdownPath, markdownPayload);
+  await writeGuidedState(rootDir, createInitialSessionState(session));
+  return {
+    recipePath: paths.currentRecipePath,
+    markdownPath: paths.currentMarkdownPath,
+    statePath: paths.statePath,
+    sessionRecipePath,
+    sessionMarkdownPath
+  };
+}
+async function readGuidedSession(rootDir, sessionId) {
+  const paths = await ensureGuidedDirectories(rootDir);
+  const recipePath = sessionId ? path2.join(paths.sessionsDir, `${sessionId}.recipe.json`) : paths.currentRecipePath;
+  const raw = await readFile2(recipePath, "utf8");
+  return JSON.parse(raw);
+}
+
+// ../../packages/core/src/session.ts
+function getOrderedSteps(session) {
+  return [...session.steps].sort((left, right) => left.order - right.order);
+}
+function validateDuplicateStepIds(session) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const step of session.steps) {
+    if (seen.has(step.id)) {
+      throw new Error(`Duplicate step ID detected: ${step.id}`);
+    }
+    seen.add(step.id);
+  }
+}
+function validateSessionOrder(session) {
+  const ordered = getOrderedSteps(session);
+  ordered.forEach((step, index) => {
+    const expectedOrder = index + 1;
+    if (step.order !== expectedOrder) {
+      throw new Error(
+        `Invalid step ordering. Expected step ${step.id} to have order ${expectedOrder}, received ${step.order}`
+      );
+    }
+  });
+}
+function validateSessionIntegrity(session) {
+  validateDuplicateStepIds(session);
+  validateSessionOrder(session);
+}
+
+// ../../packages/core/src/session-history.ts
+import { readdir, writeFile as writeFile3 } from "fs/promises";
+
+// ../../packages/schema/src/guided-session.ts
+import { z as z2 } from "zod";
+var sessionModeSchema = z2.enum([
+  "implementation",
+  "pr_review",
+  "codebase_walkthrough"
+]);
+var stepStatusSchema = z2.enum(["pending", "active", "complete", "skipped"]);
+var narrationSchema = z2.object({
+  short: z2.string().min(1),
+  detailed: z2.string().min(1).optional()
+});
+var stepExplanationSchema = z2.object({
+  title: z2.string().min(1),
+  what: z2.string().min(1),
+  why: z2.string().min(1),
+  how: z2.string().min(1).optional(),
+  impact: z2.string().min(1).optional(),
+  risk: z2.string().min(1).optional(),
+  narration: narrationSchema.optional()
+});
+var guidedFileTargetSchema = z2.object({
+  path: z2.string().min(1),
+  exists: z2.boolean().optional(),
+  createIfMissing: z2.boolean().optional()
+});
+var guidedRangeSchema = z2.object({
+  startLine: z2.number().int().positive(),
+  startCharacter: z2.number().int().nonnegative().default(0),
+  endLine: z2.number().int().positive(),
+  endCharacter: z2.number().int().nonnegative().default(0)
+});
+var guidedLocationSchema = z2.object({
+  strategy: z2.enum(["create_file", "line", "range", "after_text", "before_text"]),
+  line: z2.number().int().positive().optional(),
+  column: z2.number().int().nonnegative().optional(),
+  range: guidedRangeSchema.optional(),
+  anchorText: z2.string().min(1).optional()
+});
+var walkthroughSubrangeRoleSchema = z2.enum(["primary", "action", "context"]);
+var walkthroughLinkTypeSchema = z2.enum([
+  "calls",
+  "returns",
+  "guards",
+  "dispatches",
+  "reads",
+  "writes",
+  "configures",
+  "emits"
+]);
+var walkthroughTouchpointTypeSchema = z2.enum([
+  "entry",
+  "guard",
+  "read",
+  "write",
+  "transform",
+  "emit",
+  "respond",
+  "config"
+]);
+var walkthroughConfidenceSchema = z2.enum(["direct", "mixed", "inferred"]);
+var walkthroughEvidenceQualitySchema = z2.enum(["high", "medium", "low"]);
+var walkthroughLensSchema = z2.enum([
+  "request_flow",
+  "data_flow",
+  "permission_flow",
+  "error_path",
+  "config_dependency_flow"
+]);
+var walkthroughFollowUpKindSchema = z2.enum([
+  "implementation",
+  "tests",
+  "config",
+  "docs",
+  "investigate"
+]);
+var walkthroughSubrangeSchema = z2.object({
+  id: z2.string().min(1),
+  label: z2.string().min(1),
+  role: walkthroughSubrangeRoleSchema,
+  range: guidedRangeSchema,
+  summary: z2.string().min(1).optional(),
+  snippet: z2.string().min(1).optional(),
+  symbols: z2.array(z2.string().min(1)).min(1).optional()
+});
+var walkthroughLinkSchema = z2.object({
+  stepId: z2.string().min(1),
+  subrangeId: z2.string().min(1).optional(),
+  type: walkthroughLinkTypeSchema,
+  why: z2.string().min(1),
+  viaSymbol: z2.string().min(1).optional()
+});
+var walkthroughBranchSchema = z2.object({
+  id: z2.string().min(1),
+  label: z2.string().min(1),
+  condition: z2.string().min(1),
+  outcome: z2.string().min(1),
+  targetStepId: z2.string().min(1).optional(),
+  targetSubrangeId: z2.string().min(1).optional()
+});
+var walkthroughFlowSchema = z2.object({
+  summary: z2.string().min(1),
+  path: z2.array(z2.string().min(1)).min(2),
+  entrypoint: z2.string().min(1).optional(),
+  outcome: z2.string().min(1).optional()
+});
+var walkthroughFollowUpSchema = z2.object({
+  id: z2.string().min(1),
+  kind: walkthroughFollowUpKindSchema,
+  label: z2.string().min(1),
+  description: z2.string().min(1),
+  stepId: z2.string().min(1).optional(),
+  file: z2.string().min(1).optional()
+});
+var stepValidationSchema = z2.object({
+  type: z2.literal("normalised_match"),
+  expectedText: z2.string().optional(),
+  scope: z2.enum(["file", "range"]).optional()
+});
+var reviewPlaybackSchema = z2.object({
+  beforeCode: z2.string().optional(),
+  afterCode: z2.string().optional(),
+  changedRange: guidedRangeSchema.optional()
+}).refine(
+  (value) => Boolean(value.beforeCode) || Boolean(value.afterCode) || Boolean(value.changedRange),
+  {
+    message: "review playback requires beforeCode, afterCode, or changedRange"
+  }
+);
+var baseStepSchema = z2.object({
+  id: z2.string().min(1),
+  order: z2.number().int().positive(),
+  mode: sessionModeSchema,
+  file: guidedFileTargetSchema,
+  location: guidedLocationSchema,
+  subranges: z2.array(walkthroughSubrangeSchema).min(1).optional(),
+  symbols: z2.array(z2.string().min(1)).min(1).optional(),
+  explanation: stepExplanationSchema,
+  validation: stepValidationSchema.optional(),
+  status: stepStatusSchema.optional()
+});
+var implementationStepSchema = baseStepSchema.extend({
+  mode: z2.literal("implementation"),
+  ghostCode: z2.string().min(1)
+});
+var prReviewStepSchema = baseStepSchema.extend({
+  mode: z2.literal("pr_review"),
+  review: reviewPlaybackSchema
+});
+var codebaseWalkthroughStepSchema = baseStepSchema.extend({
+  mode: z2.literal("codebase_walkthrough"),
+  touchpoint: walkthroughTouchpointTypeSchema,
+  confidence: walkthroughConfidenceSchema,
+  evidenceQuality: walkthroughEvidenceQualitySchema,
+  fileRationale: z2.string().min(1),
+  snippet: z2.string().min(1),
+  links: z2.array(walkthroughLinkSchema).optional(),
+  branches: z2.array(walkthroughBranchSchema).optional()
+}).superRefine((step, context) => {
+  if (step.location.strategy !== "range" || !step.location.range) {
+    context.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["location"],
+      message: "codebase walkthrough steps require a location range"
+    });
+  }
+  if (!step.explanation.how) {
+    context.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["explanation", "how"],
+      message: "codebase walkthrough steps require explanation.how"
+    });
+  }
+  if (!step.subranges?.length) {
+    context.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["subranges"],
+      message: "codebase walkthrough steps require named subranges"
+    });
+    return;
+  }
+  const primarySubranges = step.subranges.filter((subrange) => subrange.role === "primary");
+  if (primarySubranges.length !== 1) {
+    context.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["subranges"],
+      message: "codebase walkthrough steps require exactly one primary subrange"
+    });
+  }
+});
+var guidedStepSchema = z2.union([
+  implementationStepSchema,
+  prReviewStepSchema,
+  codebaseWalkthroughStepSchema
+]);
+var guidedSessionSchema = z2.object({
+  id: z2.string().min(1),
+  mode: sessionModeSchema,
+  title: z2.string().min(1),
+  summary: z2.string().min(1),
+  createdAt: z2.string().min(1),
+  question: z2.string().min(1).optional(),
+  lens: walkthroughLensSchema.optional(),
+  flow: walkthroughFlowSchema.optional(),
+  followUps: z2.array(walkthroughFollowUpSchema).optional(),
+  steps: z2.array(guidedStepSchema).min(1)
+}).superRefine((session, context) => {
+  if (session.mode === "codebase_walkthrough" && !session.question) {
+    context.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["question"],
+      message: "codebase walkthrough sessions require a question"
+    });
+  }
+  if (session.mode === "codebase_walkthrough" && !session.flow) {
+    context.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["flow"],
+      message: "codebase walkthrough sessions require a flow summary"
+    });
+  }
+  if (session.mode === "codebase_walkthrough" && !session.lens) {
+    context.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["lens"],
+      message: "codebase walkthrough sessions require a lens"
+    });
+  }
+  session.steps.forEach((step, index) => {
+    if (step.mode !== session.mode) {
+      context.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: ["steps", index, "mode"],
+        message: `step mode ${step.mode} does not match session mode ${session.mode}`
+      });
+    }
+  });
+});
+
+// ../../packages/core/src/validation.ts
+function normaliseCode(input) {
+  return input.replace(/\r\n/g, "\n").split("\n").map((line) => line.replace(/[ \t]+$/g, "")).join("\n").trim();
+}
+
+// src/service.ts
+import { z as z3 } from "zod";
+
+// src/walkthrough-validation.ts
+import { readFile as readFile3 } from "fs/promises";
+import path3 from "path";
+function validatePrReviewStepRanges(session) {
+  for (const step of session.steps) {
+    if (step.mode !== "pr_review" || (step.location.strategy !== "range" || !step.location.range) && !step.review.changedRange) {
+      throw new Error(
+        `PR review step ${step.id} requires a location range or review.changedRange`
+      );
+    }
+  }
+}
+function validateCodebaseWalkthroughSession(session) {
+  const walkthroughSteps = session.steps.map(parseWalkthroughStep);
+  validateWalkthroughGraph(session, walkthroughSteps);
+  return walkthroughSteps;
+}
+async function validateCodebaseWalkthroughWorkspace(rootDir, walkthroughSteps) {
+  for (const step of walkthroughSteps) {
+    await validateWalkthroughFileEvidence(rootDir, step);
+  }
+}
+function parseWalkthroughStep(step) {
+  if (step.mode !== "codebase_walkthrough") {
+    throw new Error(`Codebase walkthrough step ${step.id} requires mode codebase_walkthrough`);
+  }
+  if (step.location.strategy !== "range" || !step.location.range) {
+    throw new Error(`Codebase walkthrough step ${step.id} requires a location range`);
+  }
+  const walkthroughStep = codebaseWalkthroughStepSchema.parse(step);
+  const locationRange = walkthroughStep.location.range;
+  if (!locationRange) {
+    throw new Error(`Codebase walkthrough step ${walkthroughStep.id} requires a location range`);
+  }
+  if (!walkthroughStep.subranges?.length) {
+    throw new Error(`Codebase walkthrough step ${walkthroughStep.id} requires named subranges`);
+  }
+  const primarySubranges = walkthroughStep.subranges.filter(
+    (subrange) => subrange.role === "primary"
+  );
+  const primarySubrange = primarySubranges[0];
+  if (!primarySubrange || !rangeMatches(primarySubrange.range, locationRange)) {
+    throw new Error(
+      `Codebase walkthrough step ${walkthroughStep.id} primary subrange must match location.range`
+    );
+  }
+  const seenSubrangeIds = /* @__PURE__ */ new Set();
+  const seenRanges = /* @__PURE__ */ new Set();
+  for (const subrange of walkthroughStep.subranges) {
+    if (seenSubrangeIds.has(subrange.id)) {
+      throw new Error(
+        `Codebase walkthrough step ${walkthroughStep.id} contains duplicate subrange id ${subrange.id}`
+      );
+    }
+    seenSubrangeIds.add(subrange.id);
+    const key = rangeKey(subrange.range);
+    if (seenRanges.has(key)) {
+      throw new Error(
+        `Codebase walkthrough step ${walkthroughStep.id} contains duplicate subrange range ${key}`
+      );
+    }
+    seenRanges.add(key);
+  }
+  return walkthroughStep;
+}
+function rangeKey(range) {
+  return `${range.startLine}:${range.startCharacter}-${range.endLine}:${range.endCharacter}`;
+}
+function rangeMatches(left, right) {
+  return left.startLine === right.startLine && left.startCharacter === right.startCharacter && left.endLine === right.endLine && left.endCharacter === right.endCharacter;
+}
+function getRangeEvidenceText(content, range) {
+  const normalized = content.replace(/\r\n/g, "\n");
+  const lines = normalized.split("\n");
+  return lines.slice(range.startLine - 1, range.endLine).join("\n");
+}
+function snippetsOverlap(actualRangeText, expectedSnippet) {
+  const normalizedActual = normaliseCode(actualRangeText);
+  const expectedLines = normaliseCode(expectedSnippet).split("\n").map((line) => line.trim()).filter(Boolean);
+  if (!expectedLines.length) {
+    return false;
+  }
+  const matchingLineCount = expectedLines.filter((line) => normalizedActual.includes(line)).length;
+  const requiredMatches = Math.min(expectedLines.length, 2);
+  return matchingLineCount >= requiredMatches;
+}
+function validateWalkthroughLinks(steps) {
+  const stepIds = new Set(steps.map((step) => step.id));
+  const subrangesByStepId = new Map(
+    steps.map((step) => [step.id, new Set(step.subranges.map((subrange) => subrange.id))])
+  );
+  steps.forEach((step, index) => {
+    const nextOrderedStep = steps[index + 1];
+    if (nextOrderedStep && (!step.links || step.links.length === 0)) {
+      throw new Error(`Codebase walkthrough step ${step.id} requires at least one outgoing link`);
+    }
+    const seenTargetIds = /* @__PURE__ */ new Set();
+    for (const link of step.links ?? []) {
+      if (!stepIds.has(link.stepId)) {
+        throw new Error(`Codebase walkthrough step ${step.id} links to unknown step ${link.stepId}`);
+      }
+      if (link.subrangeId && !subrangesByStepId.get(link.stepId)?.has(link.subrangeId)) {
+        throw new Error(
+          `Codebase walkthrough step ${step.id} links to unknown subrange ${link.subrangeId} on ${link.stepId}`
+        );
+      }
+      if (seenTargetIds.has(link.stepId)) {
+        throw new Error(`Codebase walkthrough step ${step.id} links to ${link.stepId} more than once`);
+      }
+      seenTargetIds.add(link.stepId);
+    }
+  });
+}
+function validateWalkthroughBranches(steps) {
+  const stepIds = new Set(steps.map((step) => step.id));
+  const subrangesByStepId = new Map(
+    steps.map((step) => [step.id, new Set(step.subranges.map((subrange) => subrange.id))])
+  );
+  for (const step of steps) {
+    const seenBranchIds = /* @__PURE__ */ new Set();
+    for (const branch of step.branches ?? []) {
+      if (seenBranchIds.has(branch.id)) {
+        throw new Error(`Codebase walkthrough step ${step.id} contains duplicate branch id ${branch.id}`);
+      }
+      seenBranchIds.add(branch.id);
+      if (branch.targetSubrangeId && !branch.targetStepId) {
+        throw new Error(
+          `Codebase walkthrough step ${step.id} branch ${branch.id} requires targetStepId when targetSubrangeId is present`
+        );
+      }
+      if (branch.targetStepId && !stepIds.has(branch.targetStepId)) {
+        throw new Error(
+          `Codebase walkthrough step ${step.id} branch ${branch.id} points to unknown step ${branch.targetStepId}`
+        );
+      }
+      if (branch.targetStepId && branch.targetSubrangeId && !subrangesByStepId.get(branch.targetStepId)?.has(branch.targetSubrangeId)) {
+        throw new Error(
+          `Codebase walkthrough step ${step.id} branch ${branch.id} points to unknown subrange ${branch.targetSubrangeId} on ${branch.targetStepId}`
+        );
+      }
+    }
+  }
+}
+function validateWalkthroughFollowUps(session, steps) {
+  const stepIds = new Set(steps.map((step) => step.id));
+  for (const followUp of session.followUps ?? []) {
+    if (followUp.stepId && !stepIds.has(followUp.stepId)) {
+      throw new Error(
+        `Codebase walkthrough follow-up ${followUp.id} points to unknown step ${followUp.stepId}`
+      );
+    }
+  }
+}
+function validateWalkthroughGraph(session, steps) {
+  validateWalkthroughLinks(steps);
+  validateWalkthroughBranches(steps);
+  validateWalkthroughFollowUps(session, steps);
+}
+async function validateWalkthroughFileEvidence(rootDir, step) {
+  const filePath = path3.join(rootDir, step.file.path);
+  const fileContent = await readFile3(filePath, "utf8");
+  const snippetMatchesAnyRange = step.subranges.some(
+    (subrange) => snippetsOverlap(getRangeEvidenceText(fileContent, subrange.range), step.snippet)
+  );
+  if (!snippetMatchesAnyRange) {
+    throw new Error(
+      `Codebase walkthrough step ${step.id} snippet must overlap one of its declared subranges`
+    );
+  }
+  for (const subrange of step.subranges) {
+    if (!subrange.snippet) {
+      continue;
+    }
+    const rangeText = getRangeEvidenceText(fileContent, subrange.range);
+    if (!snippetsOverlap(rangeText, subrange.snippet)) {
+      throw new Error(
+        `Codebase walkthrough step ${step.id} subrange ${subrange.id} snippet must overlap its range`
+      );
+    }
+  }
+}
+
+// src/service.ts
+var updateStepStatusInputSchema = z3.object({
+  sessionId: z3.string().min(1),
+  stepId: z3.string().min(1),
+  status: stepStatusSchema
+});
+var validateGuidedSessionInputSchema = z3.object({
+  session: guidedSessionSchema,
+  expectMode: sessionModeSchema.optional()
+});
+function validateGuidedSessionInput(input) {
+  const payload = validateGuidedSessionInputSchema.parse(input);
+  const session = guidedSessionSchema.parse(payload.session);
+  if (payload.expectMode && session.mode !== payload.expectMode) {
+    throw new Error(`Expected session mode "${payload.expectMode}" but received "${session.mode}"`);
+  }
+  validateSessionIntegrity(session);
+  if (session.mode === "pr_review") {
+    validatePrReviewStepRanges(session);
+  }
+  if (session.mode === "codebase_walkthrough") {
+    validateCodebaseWalkthroughSession(session);
+  }
+  return {
+    valid: true,
+    session: {
+      id: session.id,
+      mode: session.mode,
+      title: session.title,
+      summary: session.summary,
+      stepCount: session.steps.length,
+      files: session.steps.map((step) => step.file.path),
+      locationStrategies: [...new Set(session.steps.map((step) => step.location.strategy))]
+    }
+  };
+}
+async function isCurrentSession(rootDir, sessionId) {
+  try {
+    const currentSession = await readGuidedSession(rootDir);
+    return currentSession.id === sessionId;
+  } catch {
+    return false;
+  }
+}
+async function createGuidedSession(rootDir, sessionInput) {
+  const session = guidedSessionSchema.parse(sessionInput);
+  validateSessionIntegrity(session);
+  const files = await writeRecipeFiles(rootDir, session);
+  return {
+    sessionId: session.id,
+    recipePath: files.recipePath,
+    markdownPath: files.markdownPath,
+    statePath: files.statePath
+  };
+}
+async function createPrReviewSession(rootDir, sessionInput) {
+  const session = guidedSessionSchema.parse(sessionInput);
+  if (session.mode !== "pr_review") {
+    throw new Error('create_pr_review_session requires mode "pr_review"');
+  }
+  validateSessionIntegrity(session);
+  validatePrReviewStepRanges(session);
+  const files = await writeRecipeFiles(rootDir, session);
+  return {
+    sessionId: session.id,
+    recipePath: files.recipePath,
+    markdownPath: files.markdownPath,
+    statePath: files.statePath
+  };
+}
+async function pathfinder(rootDir, sessionInput) {
+  const session = guidedSessionSchema.parse(sessionInput);
+  if (session.mode !== "codebase_walkthrough") {
+    throw new Error('pathfinder requires mode "codebase_walkthrough"');
+  }
+  validateSessionIntegrity(session);
+  const walkthroughSteps = validateCodebaseWalkthroughSession(session);
+  await validateCodebaseWalkthroughWorkspace(rootDir, walkthroughSteps);
+  const files = await writeRecipeFiles(rootDir, session);
+  return {
+    sessionId: session.id,
+    recipePath: files.recipePath,
+    markdownPath: files.markdownPath,
+    statePath: files.statePath
+  };
+}
+async function getGuidedSession(rootDir, sessionId) {
+  const session = guidedSessionSchema.parse(await readGuidedSession(rootDir, sessionId));
+  let state = await readGuidedState(rootDir, sessionId);
+  if (!state && sessionId && await isCurrentSession(rootDir, sessionId)) {
+    state = await readGuidedState(rootDir);
+  }
+  return {
+    session,
+    state: state ? guidedSessionStateSchema.parse(state) : null
+  };
+}
+async function updateStepStatus(rootDir, input) {
+  const payload = updateStepStatusInputSchema.parse(input);
+  const session = guidedSessionSchema.parse(await readGuidedSession(rootDir, payload.sessionId));
+  if (session.id !== payload.sessionId) {
+    throw new Error(`Session mismatch for ${payload.sessionId}`);
+  }
+  const state = await updateGuidedStepStatus(
+    rootDir,
+    session,
+    payload.stepId,
+    payload.status,
+    {
+      writeCurrent: await isCurrentSession(rootDir, session.id)
+    }
+  );
+  return {
+    sessionId: session.id,
+    stepId: payload.stepId,
+    status: payload.status,
+    state: guidedSessionStateSchema.parse(state)
+  };
+}
+
+export {
+  getDuckWalkContract,
+  validateGuidedSessionInput,
+  createGuidedSession,
+  createPrReviewSession,
+  pathfinder,
+  getGuidedSession,
+  updateStepStatus
+};
+//# sourceMappingURL=chunk-IIW4JPFI.js.map