gsd-pi 2.78.0 → 2.78.1-dev.2ff77b0ce

package/dist/resources/extensions/browser-tools/tests/capture-sharp-optional.test.cjs

@@ -1,91 +0,0 @@
-/**
- * Regression tests for the optional sharp dependency in capture.ts.
- *
- * Behaviour:
- *   - constrainScreenshot must fall back to returning the raw buffer
- *     unchanged when sharp is unavailable, rather than throwing.
- *   - When sharp IS available, oversized screenshots get resized.
- *
- * No source-grep. The test drives the real constrainScreenshot function
- * after seeding the module-private `_sharp` cache via the test-only
- * `__setSharpForTesting` export.
- */
-
-const { describe, it, afterEach } = require("node:test");
-const assert = require("node:assert/strict");
-const jiti = require("jiti")(__filename, { interopDefault: true, debug: false });
-
-const { constrainScreenshot, __setSharpForTesting } = jiti("../capture.ts");
-
-describe("constrainScreenshot — sharp unavailable (null)", () => {
-	afterEach(() => {
-		// Clear the test override so later tests don't inherit a null sharp.
-		__setSharpForTesting(undefined);
-	});
-
-	it("returns the raw buffer unchanged when sharp is null", async () => {
-		__setSharpForTesting(null);
-
-		const rawBuffer = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]); // PNG magic bytes
-		const result = await constrainScreenshot(null, rawBuffer, "image/png", 80);
-
-		assert.strictEqual(
-			result,
-			rawBuffer,
-			"constrainScreenshot must return the exact same buffer instance when sharp is null",
-		);
-	});
-
-	it("returns the raw buffer unchanged for JPEG input when sharp is null", async () => {
-		__setSharpForTesting(null);
-
-		const rawBuffer = Buffer.from([0xff, 0xd8, 0xff, 0xe0]); // JPEG magic bytes
-		const result = await constrainScreenshot(null, rawBuffer, "image/jpeg", 80);
-
-		assert.strictEqual(result, rawBuffer);
-	});
-});
-
-describe("constrainScreenshot — sharp available", () => {
-	afterEach(() => {
-		__setSharpForTesting(undefined);
-	});
-
-	it("passes through a small image unchanged (below cap)", async () => {
-		const sharp = require("sharp");
-		const small = await sharp({
-			create: {
-				width: 400,
-				height: 300,
-				channels: 3,
-				background: { r: 128, g: 128, b: 128 },
-			},
-		})
-			.jpeg({ quality: 80 })
-			.toBuffer();
-
-		const result = await constrainScreenshot(null, small, "image/jpeg", 80);
-		const meta = await sharp(result).metadata();
-		assert.equal(meta.width, 400, "small images must not be resized");
-		assert.equal(meta.height, 300);
-	});
-
-	it("resizes an oversized image to within 1568px", async () => {
-		const sharp = require("sharp");
-		const big = await sharp({
-			create: {
-				width: 3000,
-				height: 2000,
-				channels: 3,
-				background: { r: 128, g: 128, b: 128 },
-			},
-		})
-			.jpeg({ quality: 80 })
-			.toBuffer();
-
-		const result = await constrainScreenshot(null, big, "image/jpeg", 80);
-		const meta = await sharp(result).metadata();
-		assert.ok(meta.width <= 1568, `width ${meta.width} must be <= 1568`);
-		assert.ok(meta.height <= 1568, `height ${meta.height} must be <= 1568`);
-	});
-});

package/dist/resources/extensions/gsd/auto-loop.js

@@ -1,13 +0,0 @@
-/**
- * auto-loop.ts — Barrel re-export for the auto-loop pipeline modules.
- *
- * The implementation has been split into focused modules under auto/.
- * This file preserves the original public API so external consumers
- * (auto.ts, auto-timeout-recovery.ts, agent-end-recovery.ts, tests)
- * continue to work without changes.
- */
-export { autoLoop, runUokKernelLoop, runLegacyAutoLoop } from "./auto/loop.js";
-export { isInfrastructureError, INFRA_ERROR_CODES } from "./auto/infra-errors.js";
-export { resolveAgentEnd, resolveAgentEndCancelled, isSessionSwitchInFlight, _hasPendingResolveForTest, _resetPendingResolve, _setActiveSession } from "./auto/resolve.js";
-export { detectStuck } from "./auto/detect-stuck.js";
-export { runUnit } from "./auto/run-unit.js";

package/dist/resources/extensions/gsd/prompts/guided-complete-slice.md

@@ -1,3 +0,0 @@
-Complete slice {{sliceId}} ("{{sliceTitle}}") of milestone {{milestoneId}}. Your working directory is `{{workingDirectory}}` — all file operations must use this path. All tasks are done. Your slice summary is the primary record of what was built — downstream agents (reassess-roadmap, future slice researchers) read it to understand what this slice delivered and what to watch out for. Use the **Slice Summary** and **UAT** output templates below to understand the expected structure. {{skillActivation}} Call `gsd_slice_complete` to record completion — the tool writes `{{sliceId}}-SUMMARY.md`, `{{sliceId}}-UAT.md`, and toggles the roadmap checkbox atomically. Fill the `UAT Type` plus `Not Proven By This UAT` sections explicitly in `uatContent` so the artifact states what class of acceptance it covers and what still remains unproven. Review task summaries for `key_decisions` and ensure any significant ones are in `.gsd/DECISIONS.md`. If the slice involved runtime behavior, fill the Operational Readiness section (Q8) in the summary: health signal, failure signal, recovery procedure, and monitoring gaps. Omit for simple slices. Do not commit or merge manually — the system handles this after the unit completes.
-
-{{inlinedTemplates}}

package/dist/resources/extensions/gsd/prompts/guided-execute-task.md

@@ -1,3 +0,0 @@
-Execute the next task: {{taskId}} ("{{taskTitle}}") in slice {{sliceId}} of milestone {{milestoneId}}. Read the task plan (`{{taskId}}-PLAN.md`), load relevant summaries from prior tasks, and execute each step. Verify must-haves when done. If the task touches UI, browser flows, DOM behavior, or user-visible web state, exercise the real flow in the browser, prefer `browser_batch` for obvious sequences, prefer `browser_assert` for explicit pass/fail verification, use `browser_diff` when an action's effect is ambiguous, and use browser diagnostics when validating async or failure-prone UI. If you made an architectural, pattern, or library decision, append it to `.gsd/DECISIONS.md`. Use the **Task Summary** output template below. Call `gsd_task_complete` to record completion (it writes the summary, toggles the checkbox, and persists to DB atomically). {{skillActivation}} If running long and not all steps are finished, stop implementing and prioritize writing a clean partial summary over attempting one more step — a recoverable handoff is more valuable than a half-finished step with no documentation. If verification fails, debug methodically: form a hypothesis and test that specific theory before changing anything, change one variable at a time, read entire functions not just the suspect line, distinguish observable facts from assumptions, and if 3+ fixes fail without progress stop and reassess your mental model — list what you know for certain, what you've ruled out, and form fresh hypotheses. Don't fix symptoms — understand why something fails before changing code. If the task plan includes Failure Modes, Load Profile, or Negative Tests sections, implement and verify them: handle each dependency's error/timeout/malformed paths (Q5), protect against identified 10x breakpoints (Q6), and write specified negative test cases (Q7).
-
-{{inlinedTemplates}}

package/dist/resources/extensions/gsd/prompts/guided-plan-milestone.md

@@ -1,30 +0,0 @@
-Plan milestone {{milestoneId}} ("{{milestoneTitle}}"). Read `.gsd/DECISIONS.md` if it exists — respect existing decisions. Read `.gsd/REQUIREMENTS.md` if it exists and treat Active requirements as the capability contract. If `REQUIREMENTS.md` is missing, continue in legacy compatibility mode but explicitly note missing requirement coverage. Use the **Roadmap** output template below to shape the milestone planning payload you send to `gsd_plan_milestone`. Call `gsd_plan_milestone` to persist the milestone planning fields and render `{{milestoneId}}-ROADMAP.md` from DB state. Do **not** write `{{milestoneId}}-ROADMAP.md`, `ROADMAP.md`, or other planning artifacts manually. If planning produces structural decisions, append them to `.gsd/DECISIONS.md`. {{skillActivation}} Fill the Horizontal Checklist section with cross-cutting concerns considered during planning (requirements re-read, decisions re-evaluated, graceful shutdown, revenue paths, auth boundary, shared resources, reconnection). Omit for trivial milestones.
-
-## Requirement Rules
-
-- Every relevant Active requirement must be mapped to a slice, deferred, blocked with reason, or moved out of scope.
-- Each requirement gets one primary owner and may have supporting slices.
-- Surface orphaned Active requirements instead of silently ignoring them.
-- Product-facing milestones should cover launchability, primary user loop, continuity, and failure visibility when relevant.
-
-## Planning Doctrine
-
-- **Risk-first means proof-first.** The earliest slices should prove the hardest thing works by shipping the real feature through the uncertain path. If auth is the risk, the first slice ships a real login page with real session handling that a user can actually use — not a CLI command that returns "authenticated: true". Proof is the shipped feature working. There is no separate "proof" artifact. Do not plan spikes, proof-of-concept slices, or validation-only slices — the proof is the real feature, built through the risky path.
-- **Every slice is vertical, demoable, and shippable.** Every slice ships real, user-facing functionality. "Demoable" means the intended user can exercise the capability through its real interface — for a web app that's the UI, for a CLI tool that's the terminal, for an API that's a consuming client or curl. The test is: can someone *use* it, not just *assert* it passes. A slice that only proves something but doesn't ship real working code is not a slice — restructure it.
-- **Brownfield bias.** When planning against an existing codebase, ground slices in existing modules, conventions, and seams. Prefer extending real patterns over inventing new ones.
-- **Each slice should establish something downstream slices can depend on.** Think about what stable surface this slice creates for later work — an API, a data shape, a proven integration path.
-- **Avoid foundation-only slices.** If a slice doesn't produce something demoable end-to-end, it's probably a layer, not a vertical slice. Restructure it. Exception: if the infrastructure *is* the product surface (a new protocol, extension API, or provider interface), the slice is vertical by definition — the downstream consumer is the demo.
-- **Verification-first.** When planning slices, know what "done" looks like before detailing implementation. Each slice's demo line should describe concrete, verifiable evidence — not vague "it works" claims.
-- **Plan for integrated reality, not just local proof.** Distinguish contract proof from live integration proof. If the milestone involves multiple runtime boundaries, one slice must explicitly prove the assembled system through the real entrypoint or runtime path.
-- **Truthful demo lines only.** If a slice is proven by fixtures or tests only, say so. Do not phrase harness-level proof as if the user can already perform the live end-to-end behavior unless that has actually been exercised.
-- **Completion must imply capability.** If every slice in this roadmap were completed exactly as written, the milestone's promised outcome should actually work at the proof level claimed. Do not write slices that can all be checked off while the user-visible capability still does not exist.
-- **Don't invent risks.** If the project is straightforward, skip the proof strategy and just ship value in smart order. Not everything has major unknowns.
-- **Ship features, not proofs.** A completed slice should leave the product in a state where the new capability is actually usable through its real interface. A login flow slice ends with a working login page, not a middleware function. An API slice ends with endpoints that return real data from a real store, not hardcoded fixtures. A dashboard slice ends with a real dashboard rendering real data, not a component that renders mock props. If a slice can't ship the real thing yet because a dependency isn't built, it should ship with realistic stubs that are clearly marked for replacement — but the user-facing surface must be real.
-- **Ambition matches the milestone.** The number and depth of slices should match the milestone's ambition. A milestone promising "core platform with auth, data model, and primary user loop" should have enough slices to actually deliver all three as working features — not two proof-of-concept slices and a note that "the rest will come in the next milestone." If the milestone's context promises an outcome, the roadmap must deliver it.
-
-## Secret Forecasting
-
-After writing the roadmap, analyze the slices and their boundary maps for external service dependencies (third-party APIs, SaaS platforms, cloud providers, databases requiring credentials, OAuth providers, etc.). If this milestone requires any external API keys or secrets, use the **Secrets Manifest** output template below for the expected format and write `{{secretsOutputPath}}` listing every predicted secret as an H3 section with the Service name, a direct Dashboard URL to the console page where the key is created, a Format hint showing what the key looks like, Status set to `pending`, and Destination (`dotenv`, `vercel`, or `convex`). Include numbered step-by-step guidance for obtaining each key. If this milestone does not require any external API keys or secrets, skip this step entirely — do not create an empty manifest.
-
-
-{{inlinedTemplates}}

package/dist/resources/extensions/gsd/prompts/guided-plan-slice.md

@@ -1,3 +0,0 @@
-Plan slice {{sliceId}} ("{{sliceTitle}}") of milestone {{milestoneId}}. Read `.gsd/DECISIONS.md` if it exists — respect existing decisions. Read `.gsd/REQUIREMENTS.md` if it exists — identify which Active requirements the roadmap says this slice owns or supports, and ensure the plan delivers them. Read the roadmap boundary map, any existing context/research files, and dependency summaries. Use the **Slice Plan** and **Task Plan** output templates below. Decompose into tasks with must-haves. Fill the `Proof Level` and `Integration Closure` sections truthfully so the plan says what class of proof this slice really delivers and what end-to-end wiring still remains. Call `gsd_plan_slice` to persist the slice plan — the tool writes `{{sliceId}}-PLAN.md` and individual `T##-PLAN.md` files to disk and persists to DB. Do **not** write plan files manually — use the DB-backed tool so state stays consistent. If planning produces structural decisions, call `gsd_decision_save` for each — the tool auto-assigns IDs and regenerates `.gsd/DECISIONS.md` automatically. {{skillActivation}} Before finishing, self-audit the plan: every must-have maps to at least one task, every task has complete sections (steps, must-haves, verification, observability impact, inputs, and expected output), task ordering is consistent with no circular references, every pair of artifacts that must connect has an explicit wiring step, task scope targets 2–5 steps and 3–8 files (6–8 steps or 8–10 files — consider splitting; 10+ steps or 12+ files — must split), the plan honors locked decisions from context/research/decisions artifacts, the proof-level wording does not overclaim live integration if only fixture/contract proof is planned, every Active requirement this slice owns has at least one task with verification that proves it is met, and every task produces real user-facing progress — if the slice has a UI surface at least one task builds the real UI, if it has an API at least one task connects it to a real data source, and showing the completed result to a non-technical stakeholder would demonstrate real product progress rather than developer artifacts, and quality gate coverage — for non-trivial slices, Threat Surface (Q3: abuse, data exposure, input trust) and Requirement Impact (Q4: requirements touched, re-verify, decisions revisited) sections are present. For non-trivial tasks, Failure Modes (Q5), Load Profile (Q6), and Negative Tests (Q7) are filled in task plans.
-
-{{inlinedTemplates}}

package/dist/resources/extensions/gsd/tests/auto-supervisor.test.mjs

@@ -1,53 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, readFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { writeUnitRuntimeRecord, readUnitRuntimeRecord } from '../unit-runtime.ts';
-import { resolveAutoSupervisorConfig } from '../preferences.ts';
-
-test('resolveAutoSupervisorConfig provides safe timeout defaults', () => {
-  const supervisor = resolveAutoSupervisorConfig();
-  assert.equal(supervisor.soft_timeout_minutes, 20);
-  assert.equal(supervisor.idle_timeout_minutes, 10);
-  assert.equal(supervisor.hard_timeout_minutes, 30);
-});
-
-test('writeUnitRuntimeRecord persists progress and recovery metadata defaults', () => {
-  const base = mkdtempSync(join(tmpdir(), 'gsd-auto-supervisor-'));
-  const startedAt = 1234567890;
-
-  writeUnitRuntimeRecord(base, 'plan-milestone', 'M010', startedAt, {
-    phase: 'dispatched',
-    lastProgressAt: startedAt,
-    progressCount: 1,
-    lastProgressKind: 'dispatch',
-  });
-
-  const runtime = readUnitRuntimeRecord(base, 'plan-milestone', 'M010');
-  assert.ok(runtime);
-  assert.equal(runtime.phase, 'dispatched');
-  assert.equal(runtime.lastProgressAt, startedAt);
-  assert.equal(runtime.progressCount, 1);
-  assert.equal(runtime.lastProgressKind, 'dispatch');
-  assert.equal(runtime.recoveryAttempts, 0);
-});
-
-test('writeUnitRuntimeRecord keeps explicit recovery attempt fields', () => {
-  const base = mkdtempSync(join(tmpdir(), 'gsd-auto-supervisor-'));
-  const startedAt = 2234567890;
-
-  writeUnitRuntimeRecord(base, 'research-milestone', 'M011', startedAt, {
-    phase: 'timeout',
-    recoveryAttempts: 2,
-    lastRecoveryReason: 'idle',
-    lastProgressAt: startedAt + 50,
-    progressCount: 3,
-    lastProgressKind: 'recovery-retry',
-  });
-
-  const runtime = JSON.parse(readFileSync(join(base, '.gsd/runtime/units/research-milestone-M011.json'), 'utf8'));
-  assert.equal(runtime.recoveryAttempts, 2);
-  assert.equal(runtime.lastRecoveryReason, 'idle');
-  assert.equal(runtime.lastProgressKind, 'recovery-retry');
-});

package/dist/resources/extensions/gsd/tests/dist-redirect.mjs

@@ -1,112 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { fileURLToPath } from 'node:url';
-
-const require = createRequire(import.meta.url);
-
-const ROOT = new URL("../../../../../", import.meta.url);
-
-export function resolve(specifier, context, nextResolve) {
-  // 1. Redirect all workspace package bare imports to source.
-  //    CI portability runs don't build any packages/ dist artifacts, so every
-  //    @gsd/* specifier (including transitive ones pulled in by pi-coding-agent
-  //    source itself) must resolve to the TypeScript source entrypoint.
-  if (specifier === "../../packages/pi-coding-agent/src/index.js") {
-    specifier = new URL("packages/pi-coding-agent/src/index.ts", ROOT).href;
-  } else if (specifier === "@gsd/pi-coding-agent") {
-    specifier = new URL("packages/pi-coding-agent/src/index.ts", ROOT).href;
-  } else if (specifier === "@gsd/pi-ai/oauth") {
-    specifier = new URL("packages/pi-ai/src/utils/oauth/index.ts", ROOT).href;
-  } else if (specifier === "@gsd/pi-ai") {
-    specifier = new URL("packages/pi-ai/src/index.ts", ROOT).href;
-  } else if (specifier === "@gsd/pi-agent-core") {
-    specifier = new URL("packages/pi-agent-core/src/index.ts", ROOT).href;
-  } else if (specifier === "@gsd/pi-tui") {
-    specifier = new URL("packages/pi-tui/src/index.ts", ROOT).href;
-  } else if (specifier === "@gsd/native") {
-    specifier = new URL("packages/native/src/index.ts", ROOT).href;
-  } else if (specifier.startsWith("@gsd/native/")) {
-    // Sub-path imports like @gsd/native/fd, @gsd/native/text, etc.
-    const subpath = specifier.slice("@gsd/native/".length);
-    specifier = new URL(`packages/native/src/${subpath}/index.ts`, ROOT).href;
-  }
-  // 2. Redirect packages/*/dist/ → packages/*/src/ with .js→.ts for strip-types
-  //    Also handles local imports — skip rewrite for dist/ paths that are real compiled artifacts.
-
-  else if (specifier.endsWith('.js') && (specifier.startsWith('./') || specifier.startsWith('../'))) {
-    if (context.parentURL && context.parentURL.includes('/src/')) {
-      if (specifier.includes('/dist/')) {
-        specifier = specifier.replace('/dist/', '/src/').replace(/\.js$/, '.ts');
-      } else {
-        specifier = specifier.replace(/\.js$/, '.ts');
-      }
-    }
-  }
-  // 3. Extensionless relative imports from web/ (Next.js convention).
-  //    Transpiled .tsx files emit extensionless imports — try .ts then .tsx.
-  else if (
-    (specifier.startsWith('./') || specifier.startsWith('../')) &&
-    !specifier.match(/\.\w+$/) &&
-    context.parentURL &&
-    context.parentURL.includes('/web/')
-  ) {
-    const baseUrl = new URL(specifier, context.parentURL);
-    for (const ext of ['.ts', '.tsx']) {
-      const candidate = fileURLToPath(baseUrl) + ext;
-      if (existsSync(candidate)) {
-        specifier = baseUrl.href + ext;
-        break;
-      }
-
-    }
-  }
-
-  return nextResolve(specifier, context);
-}
-
-export function load(url, context, nextLoad) {
-  // Node's --experimental-strip-types handles plain .ts but not .tsx and not
-  // all TypeScript syntax used by workspace packages (parameter properties,
-  // decorators, etc.). Transpile all workspace package source files and .tsx
-  // files through TypeScript's transpileModule to avoid those crashes.
-  const shouldTranspileWithTypeScript =
-    url.endsWith('.tsx') ||
-    (url.endsWith('.ts') && url.includes('/packages/') && url.includes('/src/'));
-
-  if (shouldTranspileWithTypeScript) {
-    const ts = require('typescript');
-    const source = readFileSync(fileURLToPath(url), 'utf-8');
-    const { outputText } = ts.transpileModule(source, {
-      fileName: fileURLToPath(url),
-      compilerOptions: {
-        jsx: ts.JsxEmit.ReactJSX,
-        module: ts.ModuleKind.ESNext,
-        target: ts.ScriptTarget.ESNext,
-        esModuleInterop: true,
-        experimentalDecorators: true,
-        emitDecoratorMetadata: true,
-      },
-    });
-    // Inject CJS-compatible globals (__dirname, __filename, require) so that
-    // workspace packages compiled as ESM can still use them.  This avoids the
-    // need for import.meta.url behind indirect invocation patterns that fail in
-    // CJS and in dynamically-created scopes.
-    // Only inject globals that the source file doesn't already declare itself.
-    const preambleLines = [
-      'import { fileURLToPath as __preamble_fUTP } from "node:url";',
-      'import { dirname as __preamble_dn } from "node:path";',
-      'import { createRequire as __preamble_cR } from "node:module";',
-    ];
-    if (!outputText.includes('const __filename') && !outputText.includes('let __filename')) {
-      preambleLines.push('const __filename = __preamble_fUTP(import.meta.url);');
-    }
-    if (!outputText.includes('const __dirname') && !outputText.includes('let __dirname')) {
-      preambleLines.push('const __dirname = __preamble_dn(__preamble_fUTP(import.meta.url));');
-    }
-    if (!outputText.includes('const require') && !outputText.includes('let require')) {
-      preambleLines.push('const require = __preamble_cR(import.meta.url);');
-    }
-    return { format: 'module', source: preambleLines.join('\n') + '\n' + outputText, shortCircuit: true };
-  }
-  return nextLoad(url, context);
-}

package/dist/resources/extensions/gsd/tests/resolve-ts-hooks.mjs

@@ -1,23 +0,0 @@
-import { fileURLToPath } from 'node:url';
-
-const ROOT = new URL("../../../../../", import.meta.url);
-const PACKAGES_ROOT = fileURLToPath(new URL("packages/", ROOT));
-
-export function resolve(specifier, context, nextResolve) {
-  let tsSpecifier = specifier;
-  if (specifier.includes('@gsd/')) {
-    tsSpecifier = specifier.replace('@gsd/', PACKAGES_ROOT).replace('/dist/', '/src/');
-    if (tsSpecifier.includes('/packages/pi-ai') && !tsSpecifier.endsWith('.ts')) {
-        tsSpecifier = tsSpecifier.replace(/\/packages\/pi-ai$/, '/packages/pi-ai/src/index.ts');
-    } else if (!tsSpecifier.includes('/src/') && !tsSpecifier.endsWith('.ts')) {
-        // Fallback for other gsd packages like pi-coding-agent, pi-tui, pi-agent-core
-        tsSpecifier = tsSpecifier.replace(/\/packages\/([^\/]+)$/, '/packages/$1/src/index.ts');
-    } else if (!tsSpecifier.endsWith('.ts') && !tsSpecifier.endsWith('.js') && !tsSpecifier.endsWith('.mjs')) {
-        tsSpecifier += '/index.ts';
-    }
-  } else if (specifier.endsWith('.js')) {
-    tsSpecifier = specifier.replace(/\.js$/, '.ts');
-  }
-
-  return nextResolve(tsSpecifier, context);
-}

package/dist/resources/extensions/gsd/tests/resolve-ts.mjs

@@ -1,5 +0,0 @@
-import { register } from 'node:module';
-import { pathToFileURL } from 'node:url';
-
-// Register hook to redirect imports to the dist directory
-register(new URL('./dist-redirect.mjs', import.meta.url), pathToFileURL('./'));