@mysten-incubation/devstack 0.2.0 → 0.4.0

package/dist/build-integrations/vite/index.mjs

@@ -1,22 +1,17 @@
-import { decodeIdConfig } from "../../orchestrators/codegen/id-config.mjs";
-import { resolveNetworkOptions } from "../../orchestrators/network-options.mjs";
+import { decodeDeployment, decodeNetworkDeployment } from "../../orchestrators/codegen/deployment.mjs";
 import { resolveDiscoveryEnv } from "../runtime/resolve-discovery-env.mjs";
 import { discoverManifestPath } from "../runtime/discover.mjs";
 import "../runtime/index.mjs";
-import { existsSync, readFileSync } from "node:fs";
-import { isAbsolute, resolve } from "node:path";
+import { resolveNetworkOptions } from "../../orchestrators/network-options.mjs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
 //#region src/build-integrations/vite/index.ts
 /** Default import-alias prefix. Customizable via `options.alias` (some
 *  apps prefer `@gen`, `~generated`, …). The app MUST use the SAME
 *  prefix in three derivable places: this plugin option, the
 *  `tsconfig` `paths` entry, and its import specifiers. */
 const DEFAULT_GENERATED_ALIAS = "@generated";
-/** Default dev-extras import-alias prefix. Resolves the PRIMARY stack's
-*  `.devstack/stacks/<stack>/generated-extras` tree (dev-only / secret
-*  artifacts — `accounts.ts`, `dev-wallet.ts`). Mirror the `@generated`
-*  three-place discipline: this option, the `tsconfig` `paths` entry,
-*  and the import specifiers. */
-const DEFAULT_DEV_EXTRAS_ALIAS = "@devstack-dev";
 /** The committed generated-bindings subpath, relative to the Vite root.
 *  The single source of bindings — written by `devstack codegen` — that
 *  `@generated` always resolves to (absent the `options.generatedDir`
@@ -32,7 +27,7 @@ const RESOLVED_VIRTUAL_DEV_WALLET_ID = "\0virtual:devstack-dev-wallet";
 *  misroutes to the SPA fallback). Used for the injected `<script src>`. */
 const VIRTUAL_DEV_WALLET_SCRIPT_SRC = `/@id/__x00__${VIRTUAL_DEV_WALLET_ID}`;
 /** Best-effort, SYNC read of a string-valued field at `dottedPath` (e.g.
-*  `'codegen.idsFile'`, `'identity.network'`) from the active stack's
+*  `'codegen.deploymentFile'`, `'identity.network'`) from the active stack's
 *  manifest. Walks each path segment as a nested object, returning the leaf
 *  value, or `null` on ANY miss (absent / partially-written / version-
 *  mismatched manifest, a non-object hop, a missing or non-string/empty
@@ -41,9 +36,9 @@ const VIRTUAL_DEV_WALLET_SCRIPT_SRC = `/@id/__x00__${VIRTUAL_DEV_WALLET_ID}`;
 *  and throws on a version mismatch) so an out-of-date or partially-written
 *  manifest degrades gracefully instead of crashing the dev server. Never
 *  throws — the single discover→parse→guard→degrade-to-null reader every
-*  manifest field above (`codegen.idsFile`, `codegen.extrasDir`,
-*  `identity.network`) routes through. */
-const readManifestField = (env, cwd, dottedPath) => {
+*  manifest field above (`codegen.deploymentFile`, `identity.network`)
+*  routes through. */
+const readManifestObject = (env, cwd) => {
 	try {
 		const { stack, stateDir } = resolveDiscoveryEnv(env, { cwd });
 		const manifestPath = discoverManifestPath({
@@ -53,49 +48,138 @@ const readManifestField = (env, cwd, dottedPath) => {
 			cwd
 		});
 		if (manifestPath === void 0 || !existsSync(manifestPath)) return null;
-		let node = JSON.parse(readFileSync(manifestPath, "utf8"));
-		for (const segment of dottedPath.split(".")) {
-			if (typeof node !== "object" || node === null) return null;
-			node = node[segment];
-		}
-		return typeof node === "string" && node.length > 0 ? node : null;
+		return JSON.parse(readFileSync(manifestPath, "utf8"));
 	} catch {
 		return null;
 	}
 };
-/** The gitignored `devstack-ids.json` path the boot wrote for the active
-*  stack (`codegen.idsFile`), or `null` on any miss. */
-const readIdsFileFromManifest = (env, cwd) => readManifestField(env, cwd, "codegen.idsFile");
-/** SYNC read + schema-decode of an id-config FILE. The MISSING-file case
-*  (absent path, no file on disk) collapses to `null` so the Vite config
+/** Walk `dottedPath` over an already-parsed manifest object, returning the
+*  non-empty string leaf or `null` on ANY miss (non-object hop, missing /
+*  non-string / empty leaf). Lets one parsed manifest serve several field
+*  reads without re-parsing. */
+const pickManifestString = (manifest, dottedPath) => {
+	let node = manifest;
+	for (const segment of dottedPath.split(".")) {
+		if (typeof node !== "object" || node === null) return null;
+		node = node[segment];
+	}
+	return typeof node === "string" && node.length > 0 ? node : null;
+};
+const readManifestField = (env, cwd, dottedPath) => pickManifestString(readManifestObject(env, cwd), dottedPath);
+/** The gitignored `deployment.json` path the boot wrote for the active
+*  stack (`codegen.deploymentFile`), or `null` on any miss. */
+const readIdsFileFromManifest = (env, cwd) => readManifestField(env, cwd, "codegen.deploymentFile");
+/** SYNC read + schema-decode of a deployment ENVELOPE file. The MISSING-file
+*  case (absent path, no file on disk) collapses to `null` so the Vite config
 *  load degrades gracefully when no stack has booted / no committed file is
-*  wired. A PRESENT-but-malformed file is NOT swallowed: it flows through
-*  the shared {@link decodeIdConfig}, which THROWS on bad JSON or a shape
-*  that violates `IdConfigSchema` — surfacing a genuinely broken committed
-*  id-config at config-load instead of silently injecting `null`. */
-const readIdConfigFile = (idsFile) => {
-	if (idsFile === null || !existsSync(idsFile)) return null;
-	return decodeIdConfig(readFileSync(idsFile, "utf8"));
+*  wired. A PRESENT-but-malformed file is NOT swallowed: it flows through the
+*  shared {@link decodeDeployment}, which THROWS on bad JSON or a shape that
+*  violates `DevstackDeploymentSchema` — surfacing a genuinely broken
+*  deployment at config-load instead of silently injecting `null`. */
+const readDeploymentFile = (file) => {
+	if (file === null || !existsSync(file)) return null;
+	return decodeDeployment(readFileSync(file, "utf8"));
+};
+/** The LIVE local-stack deployment envelope for the active stack — the
+*  `deployment.json` boot wrote (via the manifest `codegen.deploymentFile`),
+*  or `null` on any miss. Read fresh so a republish reaches the app. */
+const readLiveEnvelope = (env, root) => readDeploymentFile(readIdsFileFromManifest(env, root));
+/** Resolve + validate the committed per-network deployments — the
+*  `deployments` option's thunks, each `() => Promise<{ deployment }>`. Each
+*  `deployment` is validated against `NetworkDeploymentSchema` (loud-fail on a
+*  malformed committed file) and stamped `{ network: <key>, local: false }` so
+*  the envelope key is authoritative and the deploy filter treats it as a real
+*  (non-local) network. Empty when no `deployments` are supplied. */
+const resolveCommittedNetworks = async (deployments) => {
+	const committed = {};
+	for (const [net, thunk] of Object.entries(deployments)) committed[net] = {
+		...decodeNetworkDeployment((await thunk()).deployment, `deployments['${net}']`),
+		network: net,
+		local: false
+	};
+	return committed;
 };
-/** Resolve the on-chain ids to inject as the `__DEVSTACK_IDS__` global —
-*  ALWAYS from an id-config FILE (same schema in dev and prod), never a
-*  JSON env blob. Dev (`serve`): the live `devstack-ids.json` (via the
-*  manifest `codegen.idsFile`). Prod (`build`): the committed known-
-*  deployment file — the plugin `ids` option, else the `DEVSTACK_IDS_FILE`
-*  env (a PATH pointer, not data). Neither ⇒ `null`, so the generated
-*  resolver throws loudly at id-access time. */
-const resolveInjectedIds = (env, root, command, idsOption) => {
+/** Auto-discover the committed per-network deployment thunks by globbing
+*  `<root>/deployments/*.ts` (D7 — "just drop a file" UX). Each filename
+*  (sans `.ts`) becomes a live network name keyed to a thunk that
+*  dynamically `import()`s the absolute file path and reads its `deployment`
+*  export (the `dump-deployment`-emitted / hand-written
+*  `export const deployment = {…} satisfies AppNetworkDeployment`). Returns
+*  `{}` when there is no `deployments/` dir (a clean clone / template — a
+*  pure types-only `deployment.ts` with an empty `ProvidedDeployments`). The
+*  explicit `deployments` option overrides this entirely (custom dir/paths).
+*  File CONTENTS are not read here — only the import is wired; ids load when
+*  Vite transforms the thunk at build/serve. */
+const autoDiscoverDeployments = (root) => {
+	const deploymentsDir = resolve(root, "deployments");
+	if (!existsSync(deploymentsDir)) return {};
+	const thunks = {};
+	let files;
+	try {
+		files = readdirSync(deploymentsDir);
+	} catch {
+		return {};
+	}
+	for (const file of files) {
+		if (!file.endsWith(".ts") || file.endsWith(".d.ts")) continue;
+		const net = file.slice(0, -3);
+		if (net.length === 0) continue;
+		const abs = resolve(deploymentsDir, file);
+		thunks[net] = () => import(
+			/* @vite-ignore */
+			pathToFileURL(abs).href
+);
+	}
+	return thunks;
+};
+/** The committed per-network deployments to merge — the explicit
+*  `deployments` option when supplied, else auto-discovery of
+*  `<root>/deployments/*.ts` (D7). */
+const resolveDeploymentThunks = (options, root) => options.deployments !== void 0 ? { ...options.deployments } : autoDiscoverDeployments(root);
+/** The first key of a record, or `undefined` when empty. */
+const firstKey = (record) => Object.keys(record)[0];
+/** Merge the committed + live deployments into the envelope to inject as
+*  `__DEVSTACK_DEPLOYMENT__`.
+*   - `command === 'build'` (DEPLOY): the committed, NON-local networks only —
+*     the live local network is dropped. Empty ⇒ `null` (the generated
+*     resolver throws loudly at access time).
+*   - dev `serve` (and config-load default): the committed networks OVERLAID
+*     with the live local network(s), the live default winning. No live
+*     envelope ⇒ committed only (default = `defaultNetwork` option / first
+*     committed key).
+*  The live envelope's entries are forced `local: true` (they ARE the running
+*  local stack) so a later `build` would drop them. */
+const mergeDeployment = (command, committed, live, defaultNetworkOption) => {
 	if (command === "build") {
-		const pointer = idsOption ?? env["DEVSTACK_IDS_FILE"];
-		if (pointer === void 0 || pointer.length === 0) return null;
-		return readIdConfigFile(isAbsolute(pointer) ? pointer : resolve(root, pointer));
+		if (Object.keys(committed).length === 0) return null;
+		const fallback = firstKey(committed);
+		return {
+			defaultNetwork: defaultNetworkOption !== void 0 && committed[defaultNetworkOption] !== void 0 ? defaultNetworkOption : fallback,
+			networks: committed,
+			accounts: {}
+		};
+	}
+	const networks = { ...committed };
+	if (live !== null) {
+		for (const [net, dep] of Object.entries(live.networks)) networks[net] = {
+			...dep,
+			network: net,
+			local: true
+		};
+		return {
+			defaultNetwork: live.defaultNetwork,
+			networks,
+			accounts: live.accounts ?? {}
+		};
 	}
-	return readIdConfigFile(readIdsFileFromManifest(env, root));
+	const fallback = firstKey(networks);
+	if (fallback === void 0) return null;
+	return {
+		defaultNetwork: defaultNetworkOption !== void 0 && networks[defaultNetworkOption] !== void 0 ? defaultNetworkOption : fallback,
+		networks,
+		accounts: {}
+	};
 };
-/** The manifest-recorded dev-extras tree (`codegen.extrasDir`) the
-*  `@devstack-dev` alias points at for the active stack, or `null` on any
-*  miss. */
-const readExtrasDirFromManifest = (env, cwd) => readManifestField(env, cwd, "codegen.extrasDir");
 /**
 * Build the devstack Vite plugin that aliases `options.alias`
 * (default `@generated`) at the committed `<root>/src/generated` tree.
@@ -106,34 +190,53 @@ const readExtrasDirFromManifest = (env, cwd) => readManifestField(env, cwd, "cod
 *     // or devstackVitePlugin({ alias: '@gen' })
 *
 * The plugin's `config` hook merges `resolve.alias[<prefix>] = <dir>`
-* into the user config (Vite deep-merges the returned partial). Sync;
-* reads `process.env` + the manifest (for `__DEVSTACK_IDS__` / the
-* `@devstack-dev` extras dir) once at config-load.
+* into the user config (Vite deep-merges the returned partial). Async
+* (it awaits the committed `deployments` thunks); reads `process.env` +
+* the manifest (for `__DEVSTACK_DEPLOYMENT__`) once at config-load.
 */
-/** Derive the cold-start fallback dev-extras dir
-*  (`<root>/.devstack/stacks/<stack>/generated-extras`) for the active
-*  stack — used when no manifest / `codegen.extrasDir` is on disk yet.
-*  Mirrors `output-location.ts`'s `extrasDirFor`. Best-effort: a
-*  discovery failure collapses to the `default` stack name. */
-const fallbackExtrasDir = (env, root) => {
-	let stack = "default";
+/** The on-disk dev-wallet pairing-token for the active stack, given the
+*  already-resolved `deploymentFile` path (the manifest's
+*  `codegen.deploymentFile`). The token lives in a `0o600` side-channel file
+*  (`<stackRoot>/wallet/token`, written by `pairing.ts`), NEVER in the
+*  world-readable `deployment.json`. The boot writes `deployment.json` into the
+*  SAME `<stackRoot>`, so the token sits at `<dirname(deploymentFile)>/wallet/
+*  token`. Read in Node by the `load` hook (which runs server-side) so the
+*  secret stays off the manifest/deployment surface. Returns `null` on any
+*  miss (including a `null` deployment file). */
+const readDevWalletToken = (deploymentFile) => {
+	if (deploymentFile === null) return null;
+	const tokenFile = resolve(dirname(deploymentFile), "wallet", "token");
 	try {
-		stack = resolveDiscoveryEnv(env, { cwd: root }).stack;
-	} catch {}
-	return resolve(root, ".devstack", "stacks", stack, "generated-extras");
-};
-/** Resolve the dev-extras dir for the active stack (shared by the alias
-*  config and the dev-wallet virtual module). Explicit option wins, else
-*  manifest `codegen.extrasDir`, else the derived cold-start path. */
-const resolveExtrasDir = (options, root, env) => {
-	const explicitExtras = options.extrasDir;
-	return explicitExtras !== void 0 ? resolve(root, explicitExtras) : readExtrasDirFromManifest(env, root) ?? fallbackExtrasDir(env, root);
+		if (!existsSync(tokenFile)) return null;
+		const raw = readFileSync(tokenFile, "utf8").trim();
+		return /^[0-9a-f]{32}$/.test(raw) ? raw : null;
+	} catch {
+		return null;
+	}
 };
+/** Escape a `JSON.stringify` result for safe embedding in an inline
+*  `<script>` element's text. Unlike an external file, inline-script text is
+*  parsed by the HTML tokenizer first, so a raw `<\/script>` (or `<!--`) inside
+*  any string value would terminate the tag early — and a lone `<` is enough to
+*  matter. We escape `<` / `>` / `&` to their `\uXXXX` JS-string forms (valid
+*  inside JSON-as-JS, and inert to the HTML tokenizer) and the U+2028/U+2029
+*  line separators (legal in JSON strings but illegal as raw JS line
+*  terminators in older engines). Used ONLY on the inline-script injection path
+*  — the `define` build path embeds into a JS module, not HTML, so it needs no
+*  such escaping. */
+const escapeForInlineScript = (json) => json.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/[\u2028\u2029]/g, (ch) => "\\u" + ch.charCodeAt(0).toString(16).padStart(4, "0"));
+/** A boolean env flag is truthy when set to `'1'` or `'true'`
+*  (case-insensitive). Shared by the auto-approve + e2e env readers. */
+const isTruthyEnvFlag = (raw) => raw === "1" || raw?.toLowerCase() === "true";
 /** Read the `DEVSTACK_AUTO_APPROVE` env (`'1'`/`'true'`, case-insensitive). */
-const autoApproveFromEnv = (env) => {
-	const raw = env["DEVSTACK_AUTO_APPROVE"];
-	return raw === "1" || raw?.toLowerCase() === "true";
-};
+const autoApproveFromEnv = (env) => isTruthyEnvFlag(env["DEVSTACK_AUTO_APPROVE"]);
+/** True under a Playwright e2e run (`DEVSTACK_E2E` set to `'1'`/`'true'`,
+*  case-insensitive). DEDICATED signal — distinct from `DEVSTACK_AUTO_APPROVE`
+*  — driving the injected `__DEVSTACK_E2E__` global. Gates dApp Kit's
+*  `autoConnect` ON only under e2e, so a normal `pnpm dev` serve exercises the
+*  real connect UX. A prod `vite build` never sets the env ⇒ injects `false`
+*  (tree-shakeable). */
+const e2eFromEnv = (env) => isTruthyEnvFlag(env["DEVSTACK_E2E"]);
 /** Lit packages deduped to a single instance. The injected dev-wallet UI and
 *  the app's dapp-kit UI are both Lit-based; if Vite loads two Lit copies they
 *  register custom elements in separate realms, and the second realm's element
@@ -146,6 +249,19 @@ const LIT_DEDUPE = [
 	"lit-element",
 	"@lit/reactive-element"
 ];
+/** Filter {@link LIT_DEDUPE} to the packages actually installed at the app
+*  root (`<root>/node_modules/<pkg>`). `resolve.dedupe` forces Vite to
+*  resolve each listed package from the ROOT copy — but under pnpm's strict
+*  layout a package is only surfaced at the root when the app declares it as
+*  a direct dependency. Listing a package that is merely a phantom
+*  (transitive-only, reachable solely under `@mysten/dapp-kit-core`'s nested
+*  store dir) makes Vite's resolver look for a root copy that does not exist
+*  and FAIL the production build with `Rollup failed to resolve import
+*  "lit"`. So we dedupe only what the app truly hoists: the `app` template
+*  declares `lit` (all dapp-kit-core Lit usage routes through the `lit`
+*  meta-package, so one `lit` ⇒ one nested `@lit/reactive-element`); the
+*  sub-packages stay phantom and are correctly dropped here. */
+const resolvableLitDedupe = (root) => LIT_DEDUPE.filter((pkg) => existsSync(resolve(root, "node_modules", ...pkg.split("/"))));
 /** The dev-wallet entry points the injected virtual module imports. They are
 *  reached only through the `<script>` this plugin adds in `transformIndexHtml`,
 *  so Vite's initial dep scan never sees them and re-optimizes mid-session the
@@ -164,33 +280,47 @@ const DEV_WALLET_OPTIMIZE_ENTRIES = ["@mysten-incubation/dev-wallet/inject", "@m
 const devWalletInstalled = (root) => existsSync(resolve(root, "node_modules", "@mysten-incubation", "dev-wallet", "package.json"));
 const devstackVitePlugin = (options = {}) => {
 	const alias = options.alias ?? "@generated";
-	const devExtrasAlias = options.devExtrasAlias ?? "@devstack-dev";
 	const injectDevWallet = options.injectDevWallet ?? true;
 	let resolvedRoot = process.cwd();
-	let resolvedExtrasDir = null;
 	let isServe = false;
+	let devWalletPresent = false;
+	let resolvedCommittedNetworks = {};
+	let liveEnvelopeFresh = false;
+	let liveEnvelopeCache = null;
+	const readLiveEnvelopeCached = (env) => {
+		if (liveEnvelopeFresh) return liveEnvelopeCache;
+		const live = readLiveEnvelope(env, resolvedRoot);
+		if (live !== null) {
+			liveEnvelopeCache = live;
+			liveEnvelopeFresh = true;
+		} else liveEnvelopeCache = null;
+		return live;
+	};
 	return {
 		name: "devstack:generated-alias",
-		config: (config, configEnv) => {
+		config: async (config, configEnv) => {
 			const root = config.root ?? process.cwd();
 			resolvedRoot = root;
 			const env = process.env;
 			const command = configEnv?.command ?? config.command ?? "build";
 			const explicit = options.generatedDir;
 			const generatedDir = explicit !== void 0 ? resolve(root, explicit) : resolve(root, GENERATED_SUBPATH);
-			const extrasDir = resolveExtrasDir(options, root, env);
-			resolvedExtrasDir = extrasDir;
-			const includeDevWallet = injectDevWallet && devWalletInstalled(root);
-			const injectedIds = resolveInjectedIds(env, root, command, options.ids);
+			devWalletPresent = devWalletInstalled(root);
+			const includeDevWallet = injectDevWallet && devWalletPresent;
+			resolvedCommittedNetworks = await resolveCommittedNetworks(resolveDeploymentThunks(options, root));
+			const injectedLive = command === "build" ? null : readLiveEnvelope(env, root);
+			const injectedDeployment = mergeDeployment(command, resolvedCommittedNetworks, injectedLive, options.defaultNetwork);
+			const isVitest = env["VITEST"] !== void 0;
+			const deploymentDefine = command === "serve" && !isVitest ? "globalThis.__DEVSTACK_DEPLOYMENT_LIVE__" : JSON.stringify(injectedDeployment ?? null);
 			return {
 				resolve: {
-					alias: {
-						[alias]: generatedDir,
-						[devExtrasAlias]: extrasDir
-					},
-					dedupe: [...LIT_DEDUPE]
+					alias: { [alias]: generatedDir },
+					dedupe: resolvableLitDedupe(root)
+				},
+				define: {
+					__DEVSTACK_DEPLOYMENT__: deploymentDefine,
+					__DEVSTACK_E2E__: JSON.stringify(e2eFromEnv(env))
 				},
-				define: { __DEVSTACK_IDS__: JSON.stringify(injectedIds ?? null) },
 				...includeDevWallet ? { optimizeDeps: { include: [...DEV_WALLET_OPTIMIZE_ENTRIES] } } : {}
 			};
 		},
@@ -202,47 +332,86 @@ const devstackVitePlugin = (options = {}) => {
 		},
 		load: (id) => {
 			if (id !== RESOLVED_VIRTUAL_DEV_WALLET_ID) return void 0;
-			const extrasDir = resolvedExtrasDir ?? resolveExtrasDir(options, resolvedRoot, process.env);
-			const devWalletFile = resolve(extrasDir, "dev-wallet.ts");
-			const accountsFile = resolve(extrasDir, "accounts.ts");
-			if (!injectDevWallet || !isServe || !existsSync(devWalletFile) || !existsSync(accountsFile)) return "export {};";
 			const env = process.env;
-			const netOpts = resolveNetworkOptions(readManifestField(env, resolvedRoot, "identity.network") ?? "mainnet", options.networkOptions);
+			const manifest = readManifestObject(env, resolvedRoot);
+			const token = readDevWalletToken(pickManifestString(manifest, "codegen.deploymentFile"));
+			if (!injectDevWallet || !isServe || token === null) return "export {};";
+			const netOpts = resolveNetworkOptions(pickManifestString(manifest, "identity.network") ?? "mainnet", options.networkOptions);
 			const autoApprove = options.autoApprove ?? (autoApproveFromEnv(env) || netOpts.autoApproveSigning);
 			return [
 				`import { registerDevstackDevWallet } from '@mysten-incubation/dev-wallet/inject';`,
-				`import { parseDevstackToken } from '@mysten-incubation/dev-wallet/adapters';`,
-				`import { devWallet } from '${devExtrasAlias}/dev-wallet.js';`,
-				`import { accounts } from '${devExtrasAlias}/accounts.js';`,
 				`import { config as __devstackConfig } from '${alias}/config.js';`,
-				`registerDevstackDevWallet({`,
-				`  serverOrigin: devWallet.walletUrl,`,
-				`  token: parseDevstackToken(devWallet.pairUrl),`,
-				`  accounts,`,
-				`  rpcUrl: __devstackConfig.networks[__devstackConfig.network].rpc,`,
-				`  network: devWallet.network,`,
-				`  autoApprove: ${autoApprove ? "true" : "false"},`,
-				`  mountUI: true,`,
-				`}).catch((err) => console.error('[devstack] dev-wallet injection failed:', err));`
+				`import { resolveAccounts, optionalValue } from '${alias}/config-runtime.js';`,
+				`const __devstackToken = ${JSON.stringify(token)};`,
+				`const __devstackAccounts = Object.fromEntries(`,
+				`  Object.entries(resolveAccounts()).map(([__name, __address]) => [`,
+				`    __name,`,
+				`    { name: __name, address: __address },`,
+				`  ]),`,
+				`);`,
+				`const __devstackNetworks = Object.fromEntries(`,
+				`  Object.entries(__devstackConfig.networks).map(([__net, __dep]) => [`,
+				`    __net,`,
+				`    { rpc: __dep.rpc, faucet: __dep.faucet ?? null },`,
+				`  ]),`,
+				`);`,
+				`const __devstackDefaultDep = __devstackConfig.networks[__devstackConfig.defaultNetwork];`,
+				`const __devstackConnection = __devstackDefaultDep`,
+				`  ? optionalValue(__devstackDefaultDep, 'dev-wallet', 'connection')`,
+				`  : undefined;`,
+				`if (__devstackConnection) {`,
+				`  registerDevstackDevWallet({`,
+				`    serverOrigin: __devstackConnection.walletUrl,`,
+				`    token: __devstackToken,`,
+				`    accounts: __devstackAccounts,`,
+				`    networks: __devstackNetworks,`,
+				`    defaultNetwork: __devstackConfig.defaultNetwork,`,
+				`    autoApprove: ${autoApprove ? "true" : "false"},`,
+				`    mountUI: true,`,
+				`  }).catch((err) => console.error('[devstack] dev-wallet injection failed:', err));`,
+				`}`
 			].join("\n");
 		},
+		configureServer: (server) => {
+			if (!isServe) return;
+			const env = process.env;
+			const idsFile = readIdsFileFromManifest(env, resolvedRoot);
+			if (idsFile === null) return;
+			server.watcher.add(idsFile);
+			const reloadOnIdsChange = (changed) => {
+				if (resolve(resolvedRoot, changed) !== resolve(idsFile)) return;
+				liveEnvelopeFresh = false;
+				(server.hot ?? server.ws)?.send({ type: "full-reload" });
+			};
+			server.watcher.on("change", reloadOnIdsChange);
+			server.watcher.on("add", reloadOnIdsChange);
+		},
 		transformIndexHtml: (html) => {
-			if (!injectDevWallet || !isServe) return void 0;
+			if (!isServe) return void 0;
+			const env = process.env;
+			const live = readLiveEnvelopeCached(env);
+			const liveDeployment = mergeDeployment("serve", resolvedCommittedNetworks, live, options.defaultNetwork);
+			const tags = [{
+				tag: "script",
+				children: `globalThis.__DEVSTACK_DEPLOYMENT_LIVE__ = ${escapeForInlineScript(JSON.stringify(liveDeployment ?? null))};`,
+				injectTo: "head-prepend"
+			}];
+			if (injectDevWallet && devWalletPresent) tags.push({
+				tag: "script",
+				attrs: {
+					type: "module",
+					src: VIRTUAL_DEV_WALLET_SCRIPT_SRC
+				},
+				injectTo: "head"
+			});
 			return {
 				html,
-				tags: [{
-					tag: "script",
-					attrs: {
-						type: "module",
-						src: VIRTUAL_DEV_WALLET_SCRIPT_SRC
-					},
-					injectTo: "head"
-				}]
+				tags
 			};
 		}
 	};
 };
 //#endregion
-export { DEFAULT_DEV_EXTRAS_ALIAS, DEFAULT_GENERATED_ALIAS, devstackVitePlugin };
+export { DEFAULT_GENERATED_ALIAS, devstackVitePlugin };
 
 //# sourceMappingURL=index.mjs.map