gsd-pi 2.73.0 → 2.73.1-dev.6ddfa43

package/src/resources/extensions/gsd/tests/model-isolation.test.ts

@@ -1,6 +1,8 @@
 /**
- * Tests for model config isolation between concurrent instances (#650, #1065)
- * and session-scoped model precedence behavior.
+ * Tests for model config isolation between concurrent instances (#650, #1065),
+ * session-scoped model precedence behavior including manual session override,
+ * GSD preferences override of settings.json defaults (#3517), and custom
+ * provider precedence over PREFERENCES.md when set via `/gsd model` (#4122).
  */
 
 import { describe, it, beforeEach, afterEach } from "node:test";
@@ -214,3 +216,90 @@ describe("manual session model override precedence", () => {
       "should be null when no model source is available");
   });
 });
+
+// ─── Custom provider session model wins over PREFERENCES.md (#4122) ─────────
+
+describe("custom provider session model overrides PREFERENCES.md (#4122)", () => {
+  // Mirrors the auto-start.ts logic:
+  //   sessionProviderIsCustom && ctx.model
+  //     ? ctx.model
+  //     : (preferredModel ?? ctx.model ?? null)
+  function selectStartModel(args: {
+    ctxModel: { provider: string; id: string } | null;
+    preferredModel: { provider: string; id: string } | undefined;
+    sessionProviderIsCustom: boolean;
+  }): { provider: string; id: string } | null {
+    const { ctxModel, preferredModel, sessionProviderIsCustom } = args;
+    if (sessionProviderIsCustom && ctxModel) {
+      return { provider: ctxModel.provider, id: ctxModel.id };
+    }
+    return preferredModel
+      ?? (ctxModel ? { provider: ctxModel.provider, id: ctxModel.id } : null);
+  }
+
+  it("custom provider from /gsd model wins over PREFERENCES.md built-in default", () => {
+    // User runs `/gsd model ollama/llama3.1:8b`, then `/gsd auto`.
+    // PREFERENCES.md still has the project-template claude-code default.
+    const ctxModel = { provider: "ollama", id: "llama3.1:8b" };
+    const preferredModel = { provider: "claude-code", id: "claude-sonnet-4-6" };
+
+    const snapshot = selectStartModel({
+      ctxModel,
+      preferredModel,
+      sessionProviderIsCustom: true,
+    });
+
+    assert.equal(snapshot?.provider, "ollama",
+      "custom-provider session model must win over PREFERENCES.md");
+    assert.equal(snapshot?.id, "llama3.1:8b",
+      "custom-provider session model id must be preserved");
+    assert.notEqual(snapshot?.provider, "claude-code",
+      "claude-code from PREFERENCES.md must NOT be selected when session is custom");
+  });
+
+  it("built-in session provider still defers to PREFERENCES.md (#3517 preserved)", () => {
+    // ctx.model is a built-in provider (claude-code) but PREFERENCES.md has
+    // an explicit openai-codex preference.  PREFERENCES.md should still win.
+    const ctxModel = { provider: "claude-code", id: "claude-sonnet-4-6" };
+    const preferredModel = { provider: "openai-codex", id: "gpt-5.4" };
+
+    const snapshot = selectStartModel({
+      ctxModel,
+      preferredModel,
+      sessionProviderIsCustom: false,
+    });
+
+    assert.equal(snapshot?.provider, "openai-codex",
+      "PREFERENCES.md must still win when session provider is built-in");
+    assert.equal(snapshot?.id, "gpt-5.4");
+  });
+
+  it("custom provider with no PREFERENCES.md still uses ctx.model", () => {
+    const ctxModel = { provider: "vllm", id: "qwen2.5-coder:32b" };
+
+    const snapshot = selectStartModel({
+      ctxModel,
+      preferredModel: undefined,
+      sessionProviderIsCustom: true,
+    });
+
+    assert.equal(snapshot?.provider, "vllm");
+    assert.equal(snapshot?.id, "qwen2.5-coder:32b");
+  });
+
+  it("null ctx.model with custom flag falls through to preferredModel", () => {
+    // Defensive: sessionProviderIsCustom can only be true if ctx.model exists,
+    // but verify the guard works if that invariant is ever broken.
+    const preferredModel = { provider: "claude-code", id: "claude-sonnet-4-6" };
+
+    const snapshot = selectStartModel({
+      ctxModel: null,
+      preferredModel,
+      sessionProviderIsCustom: true,
+    });
+
+    assert.equal(snapshot?.provider, "claude-code",
+      "should fall back to preferredModel when ctx.model is null");
+  });
+});
+

package/src/resources/extensions/gsd/tests/park-milestone.test.ts

@@ -3,10 +3,22 @@ import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
+import { execSync } from 'node:child_process';
 
 import { deriveState, invalidateStateCache, getActiveMilestoneId } from '../state.ts';
 import { clearPathCache } from '../paths.ts';
 import { parkMilestone, unparkMilestone, discardMilestone, isParked, getParkedReason } from '../milestone-actions.ts';
+import {
+  closeDatabase,
+  getMilestone,
+  getMilestoneSlices,
+  getSliceTasks,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+} from "../gsd-db.ts";
+import { createWorktree } from "../worktree-manager.ts";
 
 
 
@@ -60,9 +72,29 @@ function createMilestone(base: string, mid: string, opts?: { withRoadmap?: boole
 }
 
 function cleanup(base: string): void {
+  try {
+    closeDatabase();
+  } catch {
+    // ignore
+  }
   rmSync(base, { recursive: true, force: true });
 }
 
+function run(cmd: string, cwd: string): string {
+  return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function initGitRepo(base: string): void {
+  writeFileSync(join(base, "README.md"), "# test\n", "utf-8");
+  writeFileSync(join(base, ".gsd", "STATE.md"), "# State\n", "utf-8");
+  run("git init", base);
+  run("git config user.email test@test.com", base);
+  run("git config user.name Test", base);
+  run("git add .", base);
+  run('git commit -m "init"', base);
+  run("git branch -M main", base);
+}
+
 function clearCaches(): void {
   clearPathCache();
   invalidateStateCache();
@@ -294,6 +326,38 @@ test('discardMilestone updates queue order', () => {
     }
 });
 
+test('discardMilestone removes DB rows, worktree, and milestone branch', () => {
+    const base = createFixtureBase();
+    try {
+      createMilestone(base, 'M001', { withRoadmap: true });
+      initGitRepo(base);
+      clearCaches();
+
+      assert.ok(openDatabase(join(base, '.gsd', 'gsd.db')), 'database opens');
+      insertMilestone({ id: 'M001', title: 'Discard me', status: 'active' });
+      insertSlice({ milestoneId: 'M001', id: 'S01', title: 'Only slice', status: 'pending' });
+      insertTask({ milestoneId: 'M001', sliceId: 'S01', id: 'T01', title: 'Only task', status: 'pending' });
+
+      const wt = createWorktree(base, 'M001', { branch: 'milestone/M001' });
+      assert.ok(existsSync(wt.path), 'worktree exists before discard');
+      assert.ok(run('git branch', base).includes('milestone/M001'), 'milestone branch exists before discard');
+      assert.ok(getMilestone('M001'), 'milestone exists in DB before discard');
+      assert.equal(getMilestoneSlices('M001').length, 1, 'slice exists in DB before discard');
+      assert.equal(getSliceTasks('M001', 'S01').length, 1, 'task exists in DB before discard');
+
+      const success = discardMilestone(base, 'M001');
+      assert.ok(success, 'discardMilestone returns true');
+
+      assert.equal(getMilestone('M001'), null, 'milestone row removed from DB');
+      assert.equal(getMilestoneSlices('M001').length, 0, 'slice rows removed from DB');
+      assert.equal(getSliceTasks('M001', 'S01').length, 0, 'task rows removed from DB');
+      assert.ok(!existsSync(wt.path), 'worktree removed after discard');
+      assert.ok(!run('git branch', base).includes('milestone/M001'), 'milestone branch removed after discard');
+    } finally {
+      cleanup(base);
+    }
+});
+
   // ─── Test 12: All milestones parked → no active milestone ─────────────
 test('All milestones parked → no active', async () => {
     const base = createFixtureBase();

package/src/resources/extensions/gsd/tests/preferences.test.ts

@@ -134,6 +134,53 @@ test("invalid value types produce errors and fall back to undefined", () => {
   }
 });
 
+test("flat_rate_providers: accepts string array", () => {
+  const { errors, preferences } = validatePreferences({
+    flat_rate_providers: ["my-proxy", "private-cli"],
+  });
+  assert.equal(errors.length, 0);
+  assert.deepEqual(preferences.flat_rate_providers, ["my-proxy", "private-cli"]);
+});
+
+test("flat_rate_providers: trims whitespace and drops empty entries", () => {
+  const { errors, preferences } = validatePreferences({
+    flat_rate_providers: ["  my-proxy  ", "", "   ", "private-cli"],
+  });
+  assert.equal(errors.length, 0);
+  assert.deepEqual(preferences.flat_rate_providers, ["my-proxy", "private-cli"]);
+});
+
+test("flat_rate_providers: non-array rejected", () => {
+  const { errors } = validatePreferences({
+    flat_rate_providers: "my-proxy" as any,
+  });
+  assert.ok(
+    errors.some(e => e.includes("flat_rate_providers")),
+    "should error on non-array value",
+  );
+});
+
+test("flat_rate_providers: non-string elements rejected", () => {
+  const { errors } = validatePreferences({
+    flat_rate_providers: ["ok", 123 as any, "also-ok"],
+  });
+  assert.ok(
+    errors.some(e => e.includes("flat_rate_providers")),
+    "should error when array contains non-strings",
+  );
+});
+
+test("flat_rate_providers is a recognized preference key (no warning)", () => {
+  const { warnings } = validatePreferences({
+    flat_rate_providers: ["my-proxy"],
+  });
+  assert.equal(
+    warnings.filter(w => w.includes("flat_rate_providers")).length,
+    0,
+    "flat_rate_providers must be in KNOWN_PREFERENCE_KEYS",
+  );
+});
+
 test("valid values pass through correctly", () => {
   const { preferences: p1 } = validatePreferences({ budget_enforcement: "halt" });
   assert.equal(p1.budget_enforcement, "halt");

package/src/resources/extensions/gsd/tests/subagent-model-dispatch.test.ts

@@ -0,0 +1,267 @@
+/**
+ * Regression tests for subagent model preference wiring.
+ *
+ * Fixes: subagent_model config in reactive_execution was validated and stored
+ * but never passed through to subagent dispatch instruction strings, so the
+ * executing agent autonomously chose "sonnet" instead of the configured model.
+ *
+ * Issue: gsd-build/gsd-2#4078
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { validatePreferences } from "../preferences-validation.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const promptsSrc = readFileSync(join(__dirname, "..", "auto-prompts.ts"), "utf-8");
+const dispatchSrc = readFileSync(join(__dirname, "..", "auto-dispatch.ts"), "utf-8");
+
+// ─── Preference Validation ────────────────────────────────────────────────
+
+test("reactive_execution: subagent_model is preserved in validated preferences", () => {
+  const result = validatePreferences({
+    reactive_execution: {
+      enabled: true,
+      max_parallel: 2,
+      isolation_mode: "same-tree",
+      subagent_model: "claude-opus-4-6",
+    },
+  });
+  assert.equal(result.errors.length, 0);
+  assert.equal(
+    result.preferences.reactive_execution?.subagent_model,
+    "claude-opus-4-6",
+    "subagent_model should be preserved through validation",
+  );
+});
+
+test("reactive_execution: subagent_model rejects empty string", () => {
+  const result = validatePreferences({
+    reactive_execution: {
+      enabled: true,
+      max_parallel: 2,
+      isolation_mode: "same-tree",
+      subagent_model: "",
+    } as any,
+  });
+  assert.ok(
+    result.errors.some((e) => e.includes("subagent_model")),
+    "empty subagent_model should produce a validation error",
+  );
+});
+
+// ─── Structural: Prompt Builders Accept subagentModel ────────────────────
+
+test("buildReactiveExecutePrompt: accepts subagentModel parameter", () => {
+  const fnStart = promptsSrc.indexOf("export async function buildReactiveExecutePrompt");
+  assert.ok(fnStart !== -1, "buildReactiveExecutePrompt should be exported");
+  const signature = promptsSrc.slice(fnStart, fnStart + 300);
+  assert.ok(
+    signature.includes("subagentModel"),
+    "buildReactiveExecutePrompt should accept a subagentModel parameter",
+  );
+});
+
+test("buildParallelResearchSlicesPrompt: accepts subagentModel parameter", () => {
+  const fnStart = promptsSrc.indexOf("export async function buildParallelResearchSlicesPrompt");
+  assert.ok(fnStart !== -1, "buildParallelResearchSlicesPrompt should be exported");
+  const signature = promptsSrc.slice(fnStart, fnStart + 300);
+  assert.ok(
+    signature.includes("subagentModel"),
+    "buildParallelResearchSlicesPrompt should accept a subagentModel parameter",
+  );
+});
+
+test("buildGateEvaluatePrompt: accepts subagentModel parameter", () => {
+  const fnStart = promptsSrc.indexOf("export async function buildGateEvaluatePrompt");
+  assert.ok(fnStart !== -1, "buildGateEvaluatePrompt should be exported");
+  const signature = promptsSrc.slice(fnStart, fnStart + 300);
+  assert.ok(
+    signature.includes("subagentModel"),
+    "buildGateEvaluatePrompt should accept a subagentModel parameter",
+  );
+});
+
+// ─── Structural: Instruction Strings Inject Model ────────────────────────
+
+test("buildReactiveExecutePrompt: instruction string uses subagentModel when set", () => {
+  const fnStart = promptsSrc.indexOf("export async function buildReactiveExecutePrompt");
+  const fnEnd = promptsSrc.indexOf("\nexport async function", fnStart + 1);
+  const fnBody = promptsSrc.slice(fnStart, fnEnd);
+  assert.ok(
+    fnBody.includes("subagentModel"),
+    "buildReactiveExecutePrompt body should reference subagentModel",
+  );
+  // The instruction line must be dynamic (not a plain string literal)
+  assert.ok(
+    !fnBody.includes('"Use this as the prompt for a `subagent` call:"'),
+    "instruction should not be a plain static string — model must be injectable",
+  );
+});
+
+test("buildParallelResearchSlicesPrompt: instruction string uses subagentModel when set", () => {
+  const fnStart = promptsSrc.indexOf("export async function buildParallelResearchSlicesPrompt");
+  const fnEnd = promptsSrc.indexOf("\nexport async function", fnStart + 1);
+  const fnBody = promptsSrc.slice(fnStart, fnEnd);
+  assert.ok(
+    fnBody.includes("subagentModel"),
+    "buildParallelResearchSlicesPrompt body should reference subagentModel",
+  );
+});
+
+test("buildGateEvaluatePrompt: instruction string uses subagentModel when set", () => {
+  const fnStart = promptsSrc.indexOf("export async function buildGateEvaluatePrompt");
+  const fnEnd = promptsSrc.indexOf("\nexport async function", fnStart + 1);
+  const fnBody = promptsSrc.slice(fnStart, fnEnd);
+  assert.ok(
+    fnBody.includes("subagentModel"),
+    "buildGateEvaluatePrompt body should reference subagentModel",
+  );
+});
+
+// ─── Structural: Dispatch Wires Model to Prompt Builders ─────────────────
+
+test("auto-dispatch: passes model to buildReactiveExecutePrompt", () => {
+  // Find the reactive-execute dispatch rule
+  const ruleStart = dispatchSrc.indexOf("reactive-execute (parallel dispatch)");
+  assert.ok(ruleStart !== -1, "reactive-execute dispatch rule should exist");
+  const ruleBlock = dispatchSrc.slice(ruleStart, ruleStart + 1000);
+  assert.ok(
+    ruleBlock.includes("subagent_model") || ruleBlock.includes("subagentModel"),
+    "reactive-execute rule should resolve and pass the subagent model",
+  );
+});
+
+test("auto-dispatch: passes model to buildParallelResearchSlicesPrompt", () => {
+  const callIdx = dispatchSrc.indexOf("buildParallelResearchSlicesPrompt(");
+  assert.ok(callIdx !== -1, "buildParallelResearchSlicesPrompt call should exist");
+  // The call site should pass a model argument (not just 4 args)
+  const callSite = dispatchSrc.slice(callIdx, callIdx + 300);
+  assert.ok(
+    callSite.includes("subagentModel") || callSite.includes("resolveModelWithFallbacksForUnit"),
+    "buildParallelResearchSlicesPrompt call should include model argument",
+  );
+});
+
+test("auto-dispatch: passes model to buildGateEvaluatePrompt", () => {
+  const callIdx = dispatchSrc.indexOf("buildGateEvaluatePrompt(");
+  assert.ok(callIdx !== -1, "buildGateEvaluatePrompt call should exist");
+  const callSite = dispatchSrc.slice(callIdx, callIdx + 300);
+  assert.ok(
+    callSite.includes("subagentModel") || callSite.includes("resolveModelWithFallbacksForUnit"),
+    "buildGateEvaluatePrompt call should include model argument",
+  );
+});
+
+// ─── Integration: Prompt Output Contains Model String ────────────────────
+
+test("buildReactiveExecutePrompt: output contains model string when subagentModel provided", async (t) => {
+  const { buildReactiveExecutePrompt } = await import("../auto-prompts.ts");
+  const repo = mkdtempSync(join(tmpdir(), "gsd-subagent-model-reactive-"));
+  t.after(() => rmSync(repo, { recursive: true, force: true }));
+
+  const gsd = join(repo, ".gsd", "milestones", "M001", "slices", "S01");
+  mkdirSync(join(gsd, "tasks"), { recursive: true });
+
+  writeFileSync(
+    join(gsd, "S01-PLAN.md"),
+    [
+      "# S01: Test Slice",
+      "",
+      "**Goal:** Verify model injection",
+      "**Demo:** Model appears in subagent prompt",
+      "",
+      "## Tasks",
+      "",
+      "- [ ] **T01: Task One** `est:15m`",
+      "  Do something.",
+      "",
+    ].join("\n"),
+  );
+
+  writeFileSync(
+    join(gsd, "tasks", "T01-PLAN.md"),
+    [
+      "# T01: Task One",
+      "",
+      "## Description",
+      "Do something.",
+      "",
+      "## Inputs",
+      "",
+      "- `src/config.json` — Config",
+      "",
+      "## Expected Output",
+      "",
+      "- `src/out.ts` — Result",
+    ].join("\n"),
+  );
+
+  const prompt = await buildReactiveExecutePrompt(
+    "M001", "Test Milestone", "S01", "Test Slice",
+    ["T01"], repo, "claude-opus-4-6",
+  );
+
+  assert.ok(
+    prompt.includes('model: "claude-opus-4-6"'),
+    `Prompt should contain model instruction. Got:\n${prompt.slice(0, 500)}`,
+  );
+});
+
+test("buildReactiveExecutePrompt: no model instruction when subagentModel omitted", async (t) => {
+  const { buildReactiveExecutePrompt } = await import("../auto-prompts.ts");
+  const repo = mkdtempSync(join(tmpdir(), "gsd-subagent-model-none-"));
+  t.after(() => rmSync(repo, { recursive: true, force: true }));
+
+  const gsd = join(repo, ".gsd", "milestones", "M001", "slices", "S01");
+  mkdirSync(join(gsd, "tasks"), { recursive: true });
+
+  writeFileSync(
+    join(gsd, "S01-PLAN.md"),
+    [
+      "# S01: Test Slice",
+      "",
+      "**Goal:** Verify no model when omitted",
+      "**Demo:** No model string",
+      "",
+      "## Tasks",
+      "",
+      "- [ ] **T01: Task One** `est:15m`",
+      "  Do something.",
+      "",
+    ].join("\n"),
+  );
+
+  writeFileSync(
+    join(gsd, "tasks", "T01-PLAN.md"),
+    [
+      "# T01: Task One",
+      "",
+      "## Description",
+      "Do something.",
+      "",
+      "## Inputs",
+      "",
+      "- `src/config.json` — Config",
+      "",
+      "## Expected Output",
+      "",
+      "- `src/out.ts` — Result",
+    ].join("\n"),
+  );
+
+  const prompt = await buildReactiveExecutePrompt(
+    "M001", "Test Milestone", "S01", "Test Slice",
+    ["T01"], repo,
+    // no subagentModel
+  );
+
+  assert.ok(
+    !prompt.includes('with model:'),
+    "Prompt should not contain model instruction when subagentModel is omitted",
+  );
+});

package/dist/web/standalone/.next/static/chunks/app/page-7115e62689b5fd84.js

@@ -1 +0,0 @@
-(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[8974],{5214:(e,t,n)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0}),Object.defineProperty(t,"workAsyncStorage",{enumerable:!0,get:function(){return r.workAsyncStorageInstance}});let r=n(17828)},15726:(e,t,n)=>{Promise.resolve().then(n.bind(n,66919))},17828:(e,t,n)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0}),Object.defineProperty(t,"workAsyncStorageInstance",{enumerable:!0,get:function(){return r}});let r=(0,n(64054).createAsyncLocalStorage)()},21957:(e,t,n)=>{"use strict";function r({moduleIds:e}){return null}Object.defineProperty(t,"__esModule",{value:!0}),Object.defineProperty(t,"PreloadChunks",{enumerable:!0,get:function(){return r}}),n(95155),n(47650),n(5214),n(2451),n(53887)},37206:(e,t,n)=>{"use strict";n.d(t,{default:()=>u.a});var r=n(75707),u=n.n(r)},41112:(e,t,n)=>{"use strict";function r({reason:e,children:t}){return t}Object.defineProperty(t,"__esModule",{value:!0}),Object.defineProperty(t,"BailoutToCSR",{enumerable:!0,get:function(){return r}}),n(1980)},64054:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n={bindSnapshot:function(){return s},createAsyncLocalStorage:function(){return a},createSnapshot:function(){return i}};for(var r in n)Object.defineProperty(t,r,{enumerable:!0,get:n[r]});let u=Object.defineProperty(Error("Invariant: AsyncLocalStorage accessed in runtime where it is not available"),"__NEXT_ERROR_CODE",{value:"E504",enumerable:!1,configurable:!0});class l{disable(){throw u}getStore(){}run(){throw u}exit(){throw u}enterWith(){throw u}static bind(e){return e}}let o="u">typeof globalThis&&globalThis.AsyncLocalStorage;function a(){return o?new o:new l}function s(e){return o?o.bind(e):l.bind(e)}function i(){return o?o.snapshot():function(e,...t){return e(...t)}}},66919:(e,t,n)=>{"use strict";n.r(t),n.d(t,{default:()=>l});var r=n(95155);let u=(0,n(37206).default)(()=>Promise.all([n.e(1838),n.e(6079),n.e(4986),n.e(2008),n.e(2826)]).then(n.bind(n,62826)).then(e=>e.GSDAppShell),{loadableGenerated:{webpack:()=>[62826]},ssr:!1,loading:()=>(0,r.jsx)("div",{className:"flex h-screen items-center justify-center bg-background text-sm text-muted-foreground",children:"Loading workspace…"})});function l(){return(0,r.jsx)(u,{})}},68635:(e,t,n)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0}),Object.defineProperty(t,"default",{enumerable:!0,get:function(){return s}});let r=n(95155),u=n(12115),l=n(41112);function o(e){return{default:e&&"default"in e?e.default:e}}n(21957);let a={loader:()=>Promise.resolve(o(()=>null)),loading:null,ssr:!0},s=function(e){let t={...a,...e},n=(0,u.lazy)(()=>t.loader().then(o)),s=t.loading;function i(e){let o=s?(0,r.jsx)(s,{isLoading:!0,pastDelay:!0,error:null}):null,a=!t.ssr||!!t.loading,i=a?u.Suspense:u.Fragment,c=t.ssr?(0,r.jsxs)(r.Fragment,{children:[null,(0,r.jsx)(n,{...e})]}):(0,r.jsx)(l.BailoutToCSR,{reason:"next/dynamic",children:(0,r.jsx)(n,{...e})});return(0,r.jsx)(i,{...a?{fallback:o}:{},children:c})}return i.displayName="LoadableComponent",i}},75707:(e,t,n)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0}),Object.defineProperty(t,"default",{enumerable:!0,get:function(){return u}});let r=n(73623)._(n(68635));function u(e,t){let n={};"function"==typeof e&&(n.loader=e);let u={...n,...t};return(0,r.default)({...u,modules:u.loadableGenerated?.modules})}("function"==typeof t.default||"object"==typeof t.default&&null!==t.default)&&void 0===t.default.__esModule&&(Object.defineProperty(t.default,"__esModule",{value:!0}),Object.assign(t.default,t),e.exports=t.default)}},e=>{e.O(0,[8441,3794,7358],()=>e(e.s=15726)),_N_E=e.O()}]);

package/dist/web/standalone/.next/static/chunks/main-app-d3d4c336195465f9.js

@@ -1 +0,0 @@
-(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[7358],{2852:(e,s,n)=>{Promise.resolve().then(n.t.bind(n,27123,23)),Promise.resolve().then(n.t.bind(n,61304,23)),Promise.resolve().then(n.t.bind(n,78616,23)),Promise.resolve().then(n.t.bind(n,64777,23)),Promise.resolve().then(n.t.bind(n,57121,23)),Promise.resolve().then(n.t.bind(n,74581,23)),Promise.resolve().then(n.t.bind(n,90484,23)),Promise.resolve().then(n.bind(n,86869))},19393:()=>{}},e=>{var s=s=>e(e.s=s);e.O(0,[8441,3794],()=>(s(83861),s(2852))),_N_E=e.O()}]);

package/dist/web/standalone/.next/static/chunks/next/dist/client/components/builtin/global-error-ab5a8926e07ec673.js

@@ -1 +0,0 @@
-(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[9337],{52560:(e,s,_)=>{Promise.resolve().then(_.t.bind(_,27123,23))}},e=>{e.O(0,[8441,3794,7358],()=>e(e.s=52560)),_N_E=e.O()}]);