windows-development-sandbox 1.18.3 → 1.20.0

package/dist/app/features/sandbox/sandbox.run.js

@@ -3,7 +3,10 @@
 import path from 'node:path';
 import { safeText } from '../../../core/util/index.js';
 import { SandboxChannel } from '../../../host/channel/index.js';
+import { readSandboxFacts } from '../../../host/health/index.js';
 import { LifeRecord, readLastEnd } from '../../../host/life/index.js';
+import { cleanUpLeftovers, endSandboxPrograms, restartSandboxService } from '../../../host/sandbox/index.js';
+import { judgeSandbox } from '../../../host/health/index.js';
 import { runningOwner } from '../../../host/sharing/index.js';
 import { requireOnPc, requireRunning } from '../../../cli/commands/context.js';
 import { hereDir } from '../../../cli/commands/projects/here.js';
@@ -11,7 +14,7 @@ import { lookAtSandbox, useSharedSandbox } from '../../../cli/commands/shared-us
 import { SandboxService } from '../../../cli/services/index.js';
 import { implement, typedConfirm } from '../../context.js';
 import { cancelled } from '../../kernel/index.js';
-import { hideWindow, sandboxStatus, showWindow, stopSandbox } from './sandbox.def.js';
+import { cleanUpSandbox, hideWindow, sandboxStatus, showWindow, stopSandbox, } from './sandbox.def.js';
 /** Another user's sandbox that is not shared: whose it is, and nothing else. */
 function limitedStatus(view, folder) {
     const owner = view.owner;
@@ -39,8 +42,10 @@ export const sandboxStatusRun = implement(sandboxStatus, async (asked) => {
     const report = await new SandboxService(view.ctx).status();
     const { storageRoot, dataPath } = view.ctx;
     const lastEnd = readLastEnd(() => new LifeRecord(storageRoot, dataPath).read(), dataPath, report.sandbox.running);
+    const leftover = report.sandbox.running ? judgeSandbox(await readSandboxFacts(storageRoot, dataPath, false)) : null;
     return {
         ...(lastEnd ? { lastEnd } : {}),
+        ...(leftover?.state === 'leftover' ? { leftover: { text: leftover.why } } : {}),
         ...(view.line ? { shared: { line: view.line, limited: false, startedBy: view.ctx.borrowed?.user ?? null } } : {}),
         ...report,
         sandbox: { ...report.sandbox, daemon: safeText(report.sandbox.daemon) },
@@ -61,6 +66,41 @@ export const hideWindowRun = implement(hideWindow, async (ctx, _input, io) => {
     await new SandboxService(ctx).hideWindow();
     return { message: 'Sandbox window hidden. Bring it back with: sbx-show' };
 });
+/**
+ * A dead sandbox leaves Windows Sandbox programs behind and Windows then refuses to start a new one ("signed out"):
+ * ends them after asking, and restarts the Windows Sandbox service when asked to (or when they will not go).
+ */
+export const cleanUpSandboxRun = implement(cleanUpSandbox, async (ctx, input, io) => {
+    requireOnPc('cleanup');
+    const { storageRoot, dataPath } = ctx;
+    const lines = [];
+    const outcome = await cleanUpLeftovers({
+        facts: () => readSandboxFacts(storageRoot, dataPath, true),
+        end: endSandboxPrograms,
+        restartService: restartSandboxService,
+        confirm: (q) => io.confirm({
+            ...q,
+            danger: true,
+            noTerminal: { message: 'Nothing was closed.', fix: 'Add --yes to answer yes.' },
+        }),
+        say: (line) => {
+            lines.push(line);
+            io.log(line);
+        },
+        alsoService: input.service === true,
+    });
+    if (outcome === 'cleaned' || outcome === 'service-restarted')
+        new SandboxChannel(dataPath, () => false).reset();
+    const message = {
+        nothing: 'No Windows Sandbox program is left over.',
+        alive: lines[lines.length - 1] ?? 'A sandbox is working; nothing was closed.',
+        declined: 'Nothing was closed.',
+        cleaned: 'The leftover Windows Sandbox programs are closed. A new sandbox can start now.',
+        'service-restarted': 'The Windows Sandbox service was restarted. A new sandbox can start now.',
+        failed: 'The Windows Sandbox service could not be restarted.',
+    }[outcome];
+    return { outcome, message };
+});
 /**
  * Stopping ends every project's sessions: it says which, and the sessions of other projects need a yes (also on the
  * command line, where --yes gives it; a script without it fails rather than end them by accident).

package/dist/app/features/settings/categories.def.js

@@ -31,7 +31,7 @@ export const CATEGORIES = [
         id: 'agents',
         label: 'Agents & sessions',
         description: 'The agents you can start (also: Agents section), attaching your terminal to them, the (Beta) web UI and agent commands, which of your Claude settings are copied in, and reopening sessions.',
-        keys: ['harnesses', 'attach', 'web', 'agentCommands', 'claudeProfile', 'resume'],
+        keys: ['harnesses', 'codex', 'attach', 'web', 'agentCommands', 'claudeProfile', 'resume'],
     },
     {
         id: 'network',
@@ -58,7 +58,7 @@ export const SETTINGS_ELSEWHERE = ['apps'];
 const NAMES = {
     sandbox: 'Sandbox machine',
     attach: 'Attaching your terminal',
-    agentCommands: 'Agent commands (Beta)',
+    agentCommands: 'Agent commands',
     web: 'Web UI (Beta)',
     provisioning: 'Provisioning',
     downloads: 'Downloads',
@@ -90,6 +90,7 @@ const NAMES = {
     projects: 'Projects',
     resume: 'Reopening sessions',
     harnesses: 'Agents',
+    codex: 'Codex',
     databases: 'Databases',
     toolchains: 'Toolchains',
     git: 'Git',
@@ -142,6 +143,8 @@ const LABELS = {
     'projects.wsbShare': 'Add folders while the sandbox runs',
     'projects.liveFolders': 'Add folders through HCS (alpha, untested)',
     'projects.all': 'Map all known projects at start',
+    'codex.sandboxMode': "Codex's own sandbox",
+    'codex.windowsSandbox': 'Windows sandbox mode for Codex',
     'claudeProfile.hostDir': 'Claude folder on this PC',
     'claudeProfile.globalStateFile': 'Claude state file on this PC',
 };

package/dist/app/features/settings/settings-rows.js

@@ -6,6 +6,7 @@ import { NEVER_LOOSER } from '../../../core/local-config/index.js';
 import { redactSecrets } from '../../../core/schema/index.js';
 import { fail } from '../../../core/util/index.js';
 import { closest } from '../../../cli/validate.js';
+import { isToolchainReady } from '../../../shared/readiness.js';
 import { fieldOf } from '../../kernel/index.js';
 import { categoryOf, labelOf, nameOf } from './categories.def.js';
 /** Every editable setting of a file, each in its category (settings covered by another section are left out). */
@@ -24,7 +25,10 @@ export function settingsOf(file) {
                     section: several && category.id !== 'general' ? nameOf(top) : undefined,
                 },
             ];
-        return node.leaves([top]).map(({ key, node: leaf }) => {
+        return node
+            .leaves([top])
+            .filter(({ key }) => top !== 'toolchains' || isToolchainReady(key[1]))
+            .map(({ key, node: leaf }) => {
             const heading = [
                 several ? nameOf(top) : undefined,
                 key.length > 2 ? key.slice(1, -1).map(nameOf).join(' › ') : undefined,

package/dist/app/features/settings/settings.run.d.ts

@@ -1,5 +1,7 @@
+import type { Config } from '../../../core/types.js';
 import { type AppContext } from '../../context.js';
 import { type SettingsFiles } from './settings-rows.js';
+import { type Scope } from './settings.def.js';
 /** The file `sandbox config export` writes when none is named. */
 export declare const DEFAULT_EXPORT = "sandbox-settings.json";
 /** Your own settings file (the one --config names) and the project file of the current folder. */
@@ -48,6 +50,12 @@ export declare const getSettingRun: import("../../kernel/define.js").Implementat
 /** The file of a scope, and the setting a key names in it. */
 /** incoming with every *** that stands where saved has a text replaced by that saved text. Pure. */
 export declare function keepShownSecrets(saved: unknown, incoming: unknown): unknown;
+/** What brings this PC in line with a changed agentCommands setting (the real service, or a fake in a test). */
+export interface AgentCommandsReconciler {
+    reconcile(config: Config): unknown;
+}
+/** After your own settings change: a key under agentCommands also changes this PC (files, PATH), on every surface. */
+export declare function applyAgentCommandsChange(ctx: AppContext, scope: Scope, key: string, service?: AgentCommandsReconciler): void;
 export declare const setSettingRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{
     scope: import("zod").ZodDefault<import("zod").ZodEnum<{
         project: "project";

package/dist/app/features/settings/settings.run.js

@@ -7,6 +7,7 @@ import { loadConfig } from '../../../core/config/index.js';
 import { REDACTED, redactSecrets } from '../../../core/schema/index.js';
 import { fail, safeText, writeJson } from '../../../core/util/index.js';
 import { hereDir } from '../../../cli/commands/projects/here.js';
+import { AgentCommandsService } from '../../../cli/services/agent-commands-service.js';
 import { implement } from '../../context.js';
 import { allowedText, cancelled, valueFromText } from '../../kernel/index.js';
 import { CATEGORIES } from './categories.def.js';
@@ -66,6 +67,12 @@ function target(ctx, scope, name) {
     const file = settingsFiles(ctx)[scope];
     return { ...findSetting(file, name), file };
 }
+/** After your own settings change: a key under agentCommands also changes this PC (files, PATH), on every surface. */
+export function applyAgentCommandsChange(ctx, scope, key, service = new AgentCommandsService(ctx)) {
+    if (scope !== 'user' || !/^agentCommands(\.|$)/.test(key))
+        return;
+    service.reconcile(freshConfig(ctx));
+}
 export const setSettingRun = implement(setSetting, (ctx, input) => {
     const { key, node, file } = target(ctx, input.scope, input.key);
     if (node.isSection)
@@ -81,6 +88,7 @@ export const setSettingRun = implement(setSetting, (ctx, input) => {
     const outcome = file.set(key, value);
     if (typeof outcome === 'object')
         fail('Could not change ' + input.key + ': ' + outcome.problems.join('; '), 'Nothing was written.');
+    applyAgentCommandsChange(ctx, input.scope, input.key);
     return {
         key: input.key,
         changed: outcome === 'saved',
@@ -96,6 +104,7 @@ export const resetSettingRun = implement(resetSetting, (ctx, input) => {
     const outcome = file.set(key, undefined);
     if (typeof outcome === 'object')
         fail('Could not reset ' + input.key + ': ' + outcome.problems.join('; '), 'Nothing was written.');
+    applyAgentCommandsChange(ctx, input.scope, input.key);
     return {
         key: input.key,
         changed: outcome === 'saved',

package/dist/app/features/updates/updates.run.js

@@ -3,7 +3,7 @@
 // runs, rollback on failure) stays in host/update.
 import { userDir } from '../../../core/config/index.js';
 import { errMsg, fail } from '../../../core/util/index.js';
-import { MigrateService, NPM_UPDATE_COMMAND, UpdateService } from '../../../cli/services/index.js';
+import { AgentCommandsService, MigrateService, NPM_UPDATE_COMMAND, UpdateService, } from '../../../cli/services/index.js';
 import { implement } from '../../context.js';
 import { cancelled } from '../../kernel/index.js';
 import { describeResult, whereOf } from './update-lines.js';
@@ -73,7 +73,17 @@ export const runUpdateRun = implement(runUpdate, async (ctx, input, io) => {
     // A folder of the user's choosing is installed from only on the command line (the web and the menu send no feed).
     if (input.feed !== undefined && input.feed !== ctx.options.feed)
         fail('--feed works only on the command line.');
-    return updateWith(UpdateService.forPackage(ctx.packageRoot, input.feed, { userDir: userDir() }), input, io);
+    const result = await updateWith(UpdateService.forPackage(ctx.packageRoot, input.feed, { userDir: userDir() }), input, io);
+    // The agent commands (claude, codex ...) point at the program: bring them in line with what is installed now.
+    if (ctx.loaded.config.agentCommands.enabled && !input.check && !input.rollback && !input.auto) {
+        try {
+            new AgentCommandsService(ctx).reconcile(ctx.loaded.config);
+        }
+        catch {
+            // The update itself worked; the agent commands are put right at the next launch.
+        }
+    }
+    return result;
 });
 /** sandbox migrate's work, given the service (tests pass their own). */
 export async function migrateWith(service, input, io) {

package/dist/app/features/vpn/vpn.def.d.ts

@@ -31,6 +31,17 @@ export declare const VpnStatusSchema: z.ZodObject<{
         }>;
         text: z.ZodString;
     }, z.core.$strip>>;
+    lastFailure: z.ZodNullable<z.ZodObject<{
+        code: z.ZodEnum<{
+            auth: "auth";
+            unreachable: "unreachable";
+            driver: "driver";
+            timeout: "timeout";
+            other: "other";
+        }>;
+        text: z.ZodString;
+        at: z.ZodString;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type VpnStatus = z.output<typeof VpnStatusSchema>;
 export declare const vpnStatus: import("../../kernel/define.js").QueryDef<z.ZodObject<{
@@ -62,6 +73,17 @@ export declare const vpnStatus: import("../../kernel/define.js").QueryDef<z.ZodO
         }>;
         text: z.ZodString;
     }, z.core.$strip>>;
+    lastFailure: z.ZodNullable<z.ZodObject<{
+        code: z.ZodEnum<{
+            auth: "auth";
+            unreachable: "unreachable";
+            driver: "driver";
+            timeout: "timeout";
+            other: "other";
+        }>;
+        text: z.ZodString;
+        at: z.ZodString;
+    }, z.core.$strip>>;
 }, z.core.$strip>, "vpn.status">;
 export declare const vpnLogin: import("../../kernel/define.js").OperationDef<z.ZodObject<{}, z.core.$strict>, z.ZodObject<{
     message: z.ZodString;
@@ -108,5 +130,16 @@ export declare const vpnView: import("../../kernel/define.js").ViewDef<{
             }>;
             text: z.ZodString;
         }, z.core.$strip>>;
+        lastFailure: z.ZodNullable<z.ZodObject<{
+            code: z.ZodEnum<{
+                auth: "auth";
+                unreachable: "unreachable";
+                driver: "driver";
+                timeout: "timeout";
+                other: "other";
+            }>;
+            text: z.ZodString;
+            at: z.ZodString;
+        }, z.core.$strip>>;
     }, z.core.$strip>, "vpn.status">;
 }, Record<string, never>, "vpn">;

package/dist/app/features/vpn/vpn.def.js

@@ -37,6 +37,14 @@ export const VpnStatusSchema = z.object({
     })
         .nullable()
         .describe("The running sandbox's tunnel, when one runs with the VPN on"),
+    lastFailure: z
+        .object({
+        code: z.enum(['auth', 'unreachable', 'driver', 'timeout', 'other']).describe('Why the last attempt failed'),
+        text: z.string().describe('The reason in plain words'),
+        at: z.string().describe('When (ISO date and time)'),
+    })
+        .nullable()
+        .describe("The last sandbox's VPN attempt, when it failed (kept after the sandbox closed)"),
 });
 export const vpnStatus = defineQuery({
     id: 'vpn.status',
@@ -125,6 +133,16 @@ export function vpnPage(s) {
         wireguard
             ? { id: 'login', label: 'Login', value: 'not needed (the keys are in your config)', tone: 'muted' }
             : { id: 'login', label: 'Login', value: LOGIN_TEXT[s.login] + savedDate, tone: LOGIN_TONE[s.login] },
+        ...(s.lastFailure
+            ? [
+                {
+                    id: 'lastAttempt',
+                    label: 'Last attempt',
+                    value: s.lastFailure.text + ' (' + s.lastFailure.at.slice(0, 16).replace('T', ' ') + ')',
+                    tone: 'danger',
+                },
+            ]
+            : []),
         ...(s.running
             ? [
                 {
@@ -137,14 +155,14 @@ export function vpnPage(s) {
             : []),
     ];
     const notes = [
-        ...(!wireguard && s.login === 'none'
-            ? [{ text: 'Next: sandbox vpn login', tone: 'muted', only: 'cli' }]
-            : []),
         ...(s.login === 'unreadable'
+            ? [{ text: 'Only the Windows user that saved it can read it. Save it again.', tone: 'muted' }]
+            : []),
+        ...(s.lastFailure?.code === 'auth' && s.provider === 'nordvpn'
             ? [
                 {
-                    text: 'Only the Windows user that saved it can read it. Save it again: sandbox vpn login',
-                    tone: 'muted',
+                    text: 'NordVPN refused the login. It needs the service credentials (Nord Account > NordVPN > Manual setup), not your e-mail and password.',
+                    tone: 'warn',
                 },
             ]
             : []),
@@ -152,12 +170,18 @@ export function vpnPage(s) {
     ];
     // Turning it on or off is the vpn.enabled setting (it applies from the next start).
     const toggle = action(setSetting, { scope: 'user', key: 'vpn.enabled', value: !s.enabled }, { label: s.enabled ? 'Turn the VPN off' : 'Turn the VPN on', verb: s.enabled ? 'turn off' : 'turn on', key: 'o' });
+    const refused = s.lastFailure?.code === 'auth';
     const actions = [
         toggle,
+        ...(s.lastFailure?.code === 'unreachable' && s.protocol === 'udp'
+            ? [
+                action(setSetting, { scope: 'user', key: 'vpn.protocol', value: 'tcp' }, { label: 'Try TCP instead of UDP', verb: 'use tcp', key: 't' }),
+            ]
+            : []),
         ...(wireguard
             ? []
             : [
-                action(vpnLogin, {}, { key: 'v', verb: 'save login' }),
+                action(vpnLogin, {}, { key: 'v', verb: 'save login', ...(refused ? { label: 'Save the login again…' } : {}) }),
                 ...(s.login !== 'none' ? [action(vpnLogout, {}, { key: 'x', verb: 'delete login' })] : []),
             ]),
     ];

package/dist/app/features/vpn/vpn.run.d.ts

@@ -27,6 +27,17 @@ export declare const vpnStatusRun: import("../../kernel/define.js").Implementati
         }>;
         text: import("zod").ZodString;
     }, import("zod/v4/core").$strip>>;
+    lastFailure: import("zod").ZodNullable<import("zod").ZodObject<{
+        code: import("zod").ZodEnum<{
+            auth: "auth";
+            unreachable: "unreachable";
+            driver: "driver";
+            timeout: "timeout";
+            other: "other";
+        }>;
+        text: import("zod").ZodString;
+        at: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
 }, import("zod/v4/core").$strip>, "vpn.status">, import("../../../cli/commands/context.js").Context>;
 export declare const vpnLoginRun: import("../../kernel/define.js").Implementation<import("../../kernel/define.js").OperationDef<import("zod").ZodObject<{}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
     message: import("zod").ZodString;

package/dist/app/features/vpn/vpn.run.js

@@ -32,8 +32,11 @@ export const vpnLoginRun = implement(vpnLogin, async (ctx, _input, io) => {
     if (password === undefined)
         cancelled();
     service.save({ username, password });
+    const warning = service.warning({ username, password });
+    if (warning)
+        io.log(warning, 'warn');
     VPN_WARNINGS.forEach((w) => io.log(w, 'muted'));
-    return { message: 'Saved. Turn the VPN on with: sandbox config set vpn.enabled true' };
+    return { message: 'Saved. Use "Turn the VPN on" on the VPN page to use it from the next start.' };
 });
 export const vpnLogoutRun = implement(vpnLogout, async (ctx, _input, io) => {
     requireOnPc('vpn logout');

package/dist/app/kernel/rpc.d.ts

@@ -57,8 +57,8 @@ export declare const ServerMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     text: z.ZodString;
     tone: z.ZodOptional<z.ZodEnum<{
         ok: "ok";
-        muted: "muted";
         warn: "warn";
+        muted: "muted";
         danger: "danger";
         accent: "accent";
     }>>;

package/dist/app/registry.js

@@ -1,6 +1,6 @@
 import { fail } from '../core/util/errors.js';
 import { accessNeeded, allows, invoke, OWNER, refusalText, NO_QUESTIONS, onSurface, } from './kernel/index.js';
-import { addAgentRun, listAgentsRun, makeDefaultAgentRun, removeAgentRun, startAgentRun, } from './features/agents/index.js';
+import { addAgentRun, agentEnvRun, agentsEnvSetRun, listAgentsRun, makeDefaultAgentRun, removeAgentRun, startAgentRun, } from './features/agents/index.js';
 import { defaultAccountRun, listAccountsRun, removeAccountRun, renameAccountRun, saveAccountRun, useAccountRun, listServicesRun, serviceImportRun, serviceLoginRun, serviceLogoutRun, } from './features/accounts/index.js';
 import { listAppsRun, requestAppRun, setCustomAppsRun, toggleAppRun } from './features/apps/index.js';
 import { browseFolderRun } from './features/files/index.js';
@@ -8,7 +8,7 @@ import { cleanDataRun, pruneStorageRun, showDataRun } from './features/data/inde
 import { changeDataFolderRun, containedOffRun, containedOnRun, containedStatusRun, moveStorageRun, showStorageRun, useStorageRun, } from './features/storage/index.js';
 import { addProjectRun, allProjectsRun, chooseProjectsRun, excludeProjectRun, includeProjectRun, listProjectsRun, projectRootsRun, removeProjectRun, } from './features/projects/index.js';
 import { checkHealthRun, enableSandboxRun, lastHealthRun, repairHealthRun } from './features/health/index.js';
-import { hideWindowRun, sandboxStatusRun, showWindowRun, stopSandboxRun } from './features/sandbox/index.js';
+import { cleanUpSandboxRun, hideWindowRun, sandboxStatusRun, showWindowRun, stopSandboxRun, } from './features/sandbox/index.js';
 import { listLogsRun, tailLogRun } from './features/logs/index.js';
 import { listAuditRun } from './features/audit/index.js';
 import { closeSessionRun, listSessionsRun, restartSessionsRun, startShellRun } from './features/sessions/index.js';
@@ -16,6 +16,7 @@ import { exportConfigRun, getSettingRun, importConfigRun, listSettingsRun, reset
 import { migrateSettingsRun, runUpdateRun, updatesStatusRun } from './features/updates/index.js';
 import { checkEngineRun, cleanEngineRun, engineLeftoversRun, engineStatusRun } from './features/engine/index.js';
 import { openWebRun, startWebRun, stopWebRun, webStatusRun } from './features/web/index.js';
+import { agentCommandsOffRun, agentCommandsOnRun, agentCommandsStatusRun } from './features/agent-commands/index.js';
 import { vpnLoginRun, vpnLogoutRun, vpnStatusRun } from './features/vpn/index.js';
 import { githubLoginRun, githubLogoutRun, githubStatusRun } from './features/github/index.js';
 import { accessStatusRun, allowDeviceRun, lanOffRun, lanOnRun, revokeAccessRun, revokeAllAccessRun, } from './features/access/index.js';
@@ -24,6 +25,7 @@ export const IMPLEMENTATIONS = [
     showWindowRun,
     hideWindowRun,
     stopSandboxRun,
+    cleanUpSandboxRun,
     listSessionsRun,
     restartSessionsRun,
     startShellRun,
@@ -33,6 +35,8 @@ export const IMPLEMENTATIONS = [
     makeDefaultAgentRun,
     removeAgentRun,
     listAgentsRun,
+    agentEnvRun,
+    agentsEnvSetRun,
     listSettingsRun,
     getSettingRun,
     setSettingRun,
@@ -88,6 +92,9 @@ export const IMPLEMENTATIONS = [
     vpnStatusRun,
     vpnLoginRun,
     vpnLogoutRun,
+    agentCommandsStatusRun,
+    agentCommandsOnRun,
+    agentCommandsOffRun,
     githubStatusRun,
     githubLoginRun,
     githubLogoutRun,

package/dist/bin/agent-sandbox.js

@@ -2,8 +2,8 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   run
-} from "./chunk-3G53NNZP.js";
-import "./chunk-FQWYCF6L.js";
+} from "./chunk-DK4NTBUF.js";
+import "./chunk-Z2P5OGKL.js";
 
 // src/bin/agent-sandbox.ts
 run(process.argv.slice(2));

package/dist/bin/{chunk-M6XUQK53.js → chunk-2IMT7ZCT.js}

@@ -1,7 +1,7 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   attach
-} from "./chunk-FQWYCF6L.js";
+} from "./chunk-Z2P5OGKL.js";
 export {
   attach
 };