codebay 0.11.1 → 0.12.0

package/.mochi/svelte-compile/{chunk-bpqwf1nw.js → chunk-pqb403fh.js}

@@ -55,6 +55,17 @@ function setSoundEnabled(on) {
     return;
   localStorage.setItem(SOUND_KEY, on ? "on" : "off");
 }
+var TAB_SHORTCUTS_KEY = "codebay.tabShortcuts";
+function tabShortcutsEnabled() {
+  if (typeof localStorage === "undefined")
+    return true;
+  return localStorage.getItem(TAB_SHORTCUTS_KEY) !== "off";
+}
+function setTabShortcutsEnabled(on) {
+  if (typeof localStorage === "undefined")
+    return;
+  localStorage.setItem(TAB_SHORTCUTS_KEY, on ? "on" : "off");
+}
 
 // src/sound.ts
 var SOUNDS = {
@@ -110,4 +121,4 @@ function playChime(state) {
   el.play().then(() => console.log(`[chime] playChime(${state}) \u2014 playing`)).catch((err) => console.warn(`[chime] playChime(${state}) \u2014 play rejected:`, err?.message ?? err));
 }
 
-export { Terminal, Layout_template, Plus, soundEnabled, setSoundEnabled, unlockAudio, playChime };
+export { Terminal, Layout_template, Plus, soundEnabled, setSoundEnabled, tabShortcutsEnabled, setTabShortcutsEnabled, unlockAudio, playChime };

package/.mochi/svelte-css/AppShell-22m1mjm8nq2hn.css

@@ -0,0 +1 @@
+.app.ide.svelte-1duc7gd{display:flex;flex-direction:column;height:100vh}.panes.svelte-1duc7gd{position:relative;flex:1;min-height:0}.panes.hidden.svelte-1duc7gd{display:none}.pane.svelte-1duc7gd{position:absolute;inset:0}.pane.svelte-1duc7gd:not(.active){display:none}iframe.svelte-1duc7gd{display:block;--buncss-light: ;--buncss-dark:initial;color-scheme:dark;border:0;width:100%;height:100%}.empty.svelte-1duc7gd{position:absolute;display:flex;color:var(--ink-faint);font-family:var(--font-mono);text-transform:uppercase;letter-spacing:.06em;justify-content:center;align-items: center;font-size:13px;inset:0}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "codebay",
-	"version": "0.11.1",
+	"version": "0.12.0",
 	"description": "Web UI for spinning up isolated devcontainer instances from any local folder, each with a browser-based VS Code (code-server) — built for parallel Claude Code workflows.",
 	"type": "module",
 	"license": "MIT",

package/src/components/AppShell.svelte

@@ -9,6 +9,7 @@
 	import IdeLoader from './IdeLoader.svelte';
 	import TerminalSplit from './TerminalSplit.svelte';
 	import { playChime, unlockAudio } from '../sound.ts';
+	import { tabShortcutsEnabled } from '../settings.ts';
 	import { liveStream } from '../live.ts';
 	import { apiPost } from '../api.ts';
 	import { syncTheme } from '../theme.ts';
@@ -189,7 +190,7 @@
 	// for its own tabs and can't be intercepted, and Ctrl+Alt is AltGr on many European
 	// layouts, so it would collide with typing punctuation.
 	function jumpToTab(e: KeyboardEvent, fromFrame: boolean) {
-		if (!e.altKey || e.ctrlKey || e.metaKey || editingId) return;
+		if (!e.altKey || e.ctrlKey || e.metaKey || editingId || !tabShortcutsEnabled()) return;
 		// `code`, not `key`: Alt+digit emits punctuation on macOS layouts.
 		const digit = /^Digit([1-9])$/.exec(e.code)?.[1];
 		if (!digit) return;
@@ -440,6 +441,9 @@
 		height: 100%;
 		border: 0;
 		display: block;
+		/* An embedded document takes its prefers-color-scheme from the embedder, so without this
+		   Codebay's own light theme makes code-server's startup theme resolve light. */
+		color-scheme: dark;
 	}
 	.empty {
 		position: absolute;

package/src/components/SettingsView.svelte

@@ -4,6 +4,7 @@
 	import Power from '@lucide/svelte/icons/power';
 	import RotateCcw from '@lucide/svelte/icons/rotate-ccw';
 	import Volume2 from '@lucide/svelte/icons/volume-2';
+	import Keyboard from '@lucide/svelte/icons/keyboard';
 	import PawPrint from '@lucide/svelte/icons/paw-print';
 	import SunMoon from '@lucide/svelte/icons/sun-moon';
 	import ThemePicker from './ThemePicker.svelte';
@@ -27,7 +28,12 @@
 	import { flushSync } from 'svelte';
 	import { enhance } from 'mochi-framework';
 	import type { MochiEnhanceOptions } from 'mochi-framework';
-	import { soundEnabled, setSoundEnabled } from '../settings.ts';
+	import {
+		soundEnabled,
+		setSoundEnabled,
+		tabShortcutsEnabled,
+		setTabShortcutsEnabled
+	} from '../settings.ts';
 	import { playChime, unlockAudio } from '../sound.ts';
 	import Button from './Button.svelte';
 	import CoinButton from './CoinButton.svelte';
@@ -133,6 +139,7 @@
 
 	// Defaults to on during SSR, where localStorage doesn't exist.
 	let sound = $state(soundEnabled());
+	let tabShortcuts = $state(tabShortcutsEnabled());
 
 	// DB-backed, so it initializes from the prop. Undefined is the off state — the header keeps its box logo.
 	// svelte-ignore state_referenced_locally
@@ -780,6 +787,11 @@
 		if (on) playChime('done');
 	}
 
+	function toggleTabShortcuts(on: boolean) {
+		tabShortcuts = on;
+		setTabShortcutsEnabled(on);
+	}
+
 	// State is object-shaped (the chosen sprite), so this can't reuse the boolean `toggleOpts`.
 	const petToggleOpts: MochiEnhanceOptions<{ enabled: boolean; name?: string }, ActionFailure> = {
 		onPending: (v) => (savingPet = v),
@@ -1980,6 +1992,29 @@
 			</div>
 		</section>
 
+		<section class="card">
+			<div class="row">
+				<div class="label">
+					<Keyboard size={20} />
+					<div class="text">
+						<div class="name">Tab keyboard shortcuts</div>
+						<div class="desc">
+							Jump between open instance tabs with <code>Alt</code>+<code>1</code>–<code>9</code> (9 is
+							always the last tab). Turn off to leave those keystrokes to the editor.
+						</div>
+					</div>
+				</div>
+				<label class="switch">
+					<input
+						type="checkbox"
+						checked={tabShortcuts}
+						onchange={(e) => toggleTabShortcuts(e.currentTarget.checked)}
+					/>
+					<span class="track"><span class="thumb"></span></span>
+				</label>
+			</div>
+		</section>
+
 		<section class="card">
 			<form class="row" method="POST" action="?/petToggle" {@attach enhance(petToggleOpts)}>
 				<div class="label">

package/src/container-injections/code-server-dark.ts

@@ -0,0 +1,216 @@
+import { checkPresence, execInContainer, type ExecTarget } from '../lib/exec.server.ts';
+import { editJsonFile, readJsonFile } from '../lib/container-files.server.ts';
+import { CODE_SERVER_SETTINGS } from '../lib/devcontainer.server.ts';
+import type { Injection } from '../lib/injections.server.ts';
+
+/** Locates the bundled VS Code from the binary; shared prelude for the resolve and the check. */
+const WALK_TO_BUNDLE =
+	`p=$(command -v code-server) || exit 1; p=$(readlink -f "$p"); ` +
+	`while [ "$p" != "/" ]; do for c in "$p" "$p/lib/vscode"; do `;
+
+/**
+ * Walks up from the resolved binary rather than assuming /usr/lib/code-server: the feature and the
+ * standalone tarball put the wrapper at different depths, and only one of the two layouts keeps the
+ * bundled VS Code directly above `bin/`. Prints the root on the last line — `bash -lc` runs profile
+ * scripts whose stdout comes first, so callers must read the last line, never the whole capture.
+ */
+export const RESOLVE_ROOT_SCRIPT =
+	WALK_TO_BUNDLE +
+	`[ -d "$c/extensions/theme-defaults" ] && { printf '\\n%s\\n' "$c"; exit 0; }; done; ` +
+	`p=$(dirname "$p"); done; exit 1`;
+
+/**
+ * Whitespace-tolerant because the shipped manifest is minified (`"uiTheme":"vs"`) while our own
+ * rewrite pretty-prints it — a fixed-spacing pattern would miss the unpatched file and report green.
+ * The closing quote is what keeps `"vs"` from also matching `"vs-dark"`.
+ */
+const LIGHT_UI_THEME_RE = '"uiTheme"[[:space:]]*:[[:space:]]*"(vs|hc-light)"';
+
+/**
+ * Resolve and probe in one exec: `check()` runs on every health tick, in the same `Promise.all` as
+ * the `codeServerAccessible` probe that gates mounting the IDE iframe, so a second round trip here
+ * would slow the boot-time fast cadence for no gain — the root can't move for a container's life.
+ */
+export const CHECK_SCRIPT =
+	WALK_TO_BUNDLE +
+	`m="$c/extensions/theme-defaults/package.json"; ` +
+	`[ -f "$m" ] && { grep -qE '${LIGHT_UI_THEME_RE}' "$m" && echo 0 || echo 1; exit 0; }; done; ` +
+	`p=$(dirname "$p"); done; echo 0`;
+
+/**
+ * The builtin-extension scan is cached against the mtime of the `extensions/` **directory**, which
+ * rewriting a manifest inside it does not touch — so without invalidating both the cache file and
+ * that mtime, the running server and the next window keep serving the pre-rewrite themes.
+ */
+const CLEAR_BUILTIN_CACHE =
+	`rm -f ~/.local/share/code-server/CachedProfilesData/*/extensions.builtin.cache 2>/dev/null; ` +
+	`exit 0`;
+
+const SETTINGS_DIR = '$h/.local/share/code-server/User';
+
+/**
+ * VS Code matches `workbench.colorTheme` against a theme's *settingsId*, which is its manifest `id`
+ * (the label is only a fallback for entries without one) — so this reads ids, never the nls labels.
+ * The order tracks the build default (`ThemeSettingDefaults.COLOR_THEME_DARK`) across versions,
+ * because pinning exactly that id is what lets the workbench paint its real dark colors before any
+ * extension loads. Anything unrecognised falls back to whatever dark theme the build does ship.
+ */
+const PREFERRED_DARK_IDS = ['Dark 2026', 'Default Dark Modern', 'Dark Modern', 'Dark+'];
+
+const THEME_KEYS = [
+	'workbench.colorTheme',
+	'workbench.preferredDarkColorTheme',
+	'workbench.preferredLightColorTheme'
+];
+
+/** A root path we are about to interpolate into a shell script, so nothing exotic may pass. */
+const SAFE_PATH = /^\/[A-Za-z0-9._+\-/]+$/;
+
+/** Mirrors `checkPresence`: only the last line is ours, everything before it is login-shell noise. */
+function lastLine(stdout: string): string {
+	return stdout.trimEnd().split('\n').pop()?.trim() ?? '';
+}
+
+interface ThemeContribution {
+	id?: string;
+	uiTheme?: string;
+	path?: string;
+}
+
+function themesOf(manifest: Record<string, unknown>): ThemeContribution[] | null {
+	const contributes = manifest.contributes;
+	if (typeof contributes !== 'object' || contributes === null) return null;
+	const themes = (contributes as Record<string, unknown>).themes;
+	return Array.isArray(themes) ? (themes as ThemeContribution[]) : null;
+}
+
+/** Null when the build ships no identifiable dark theme — better to leave the staged settings alone than pin an id nothing resolves. */
+export function pickDarkThemeId(manifest: Record<string, unknown>): string | null {
+	const ids = (themesOf(manifest) ?? [])
+		.filter((t) => t?.uiTheme === 'vs-dark' && typeof t.id === 'string' && t.id.trim())
+		.map((t) => t.id!.trim());
+	if (!ids.length) return null;
+	return PREFERRED_DARK_IDS.find((id) => ids.includes(id)) ?? ids[0]!;
+}
+
+/**
+ * Selecting by `uiTheme` rather than by filename is load-bearing: the light set is
+ * 2026-light/light_modern/light_plus/light_vs *and* hc_light, so a `light*.json` glob silently
+ * misses two of them. Repointing `path` too, since the light JSONs stay light on disk.
+ */
+export function darkenThemeManifest(manifest: Record<string, unknown>): {
+	next: Record<string, unknown>;
+	changed: number;
+} {
+	const themes = themesOf(manifest);
+	if (!themes) return { next: manifest, changed: 0 };
+
+	const pathFor = (ui: string) =>
+		themes.find((t) => t?.uiTheme === ui && typeof t.path === 'string')?.path;
+	const darkPath = pathFor('vs-dark');
+	const hcDarkPath = pathFor('hc-black');
+
+	let changed = 0;
+	const nextThemes = themes.map((theme) => {
+		if (theme?.uiTheme === 'vs' && darkPath) {
+			changed++;
+			return { ...theme, uiTheme: 'vs-dark', path: darkPath };
+		}
+		if (theme?.uiTheme === 'hc-light' && hcDarkPath) {
+			changed++;
+			return { ...theme, uiTheme: 'hc-black', path: hcDarkPath };
+		}
+		return theme;
+	});
+
+	const contributes = manifest.contributes as Record<string, unknown>;
+	return {
+		next: { ...manifest, contributes: { ...contributes, themes: nextThemes } },
+		changed
+	};
+}
+
+/** Only the writes need root; resolution runs as the remote user, whose PATH also carries a per-user standalone install. */
+const rootTarget = (target: ExecTarget): ExecTarget => ({ containerId: target.containerId });
+
+async function resolveRoot(target: ExecTarget): Promise<string | null> {
+	const res = await execInContainer(target, { script: RESOLVE_ROOT_SCRIPT, capture: true });
+	if (!res.ok) return null;
+	const root = lastLine(res.stdout);
+	return SAFE_PATH.test(root) ? root : null;
+}
+
+/**
+ * VS Code Web's pre-extension paint falls back to `isWeb ? LIGHT : DARK` whenever it has no usable
+ * cached theme, so pinning the theme in settings alone can never keep the first frame dark. This
+ * closes both halves: it pins the theme id *this* build uses (so the workbench stops discarding its
+ * own cache), and rewrites the bundled manifest so the light themes render dark if one is selected.
+ */
+export const codeServerDark: Injection = {
+	id: 'code-server-dark',
+	label: 'code-server dark theme',
+	// code-server-only; terminal-mode instances never run a workbench.
+	modes: ['ide'],
+
+	async apply(target, log) {
+		log('Forcing code-server dark theme…\n');
+		const root = await resolveRoot(target);
+		if (!root) {
+			log('⚠ code-server install not found — dark theme left to the staged settings\n');
+			return;
+		}
+
+		const themeDir = `${root}/extensions/theme-defaults`;
+		const manifest = await readJsonFile(target, { dir: themeDir, name: 'package.json' });
+		if (!manifest) {
+			log('⚠ Could not read the bundled theme manifest — dark theme left to the staged settings\n');
+			return;
+		}
+
+		const darkTheme = pickDarkThemeId(manifest);
+		if (!darkTheme) {
+			log('⚠ No dark theme found in the bundled manifest — staged settings left as they are\n');
+		} else {
+			// Seeded from the staged defaults so this still writes a complete file on the path where
+			// the launcher's own copy silently failed, rather than a settings.json of three keys.
+			const settings = await editJsonFile(
+				target,
+				{ dir: SETTINGS_DIR, name: 'settings.json' },
+				(current) => ({
+					...CODE_SERVER_SETTINGS,
+					...current,
+					...Object.fromEntries(THEME_KEYS.map((k) => [k, darkTheme]))
+				})
+			);
+			log(
+				settings.ok
+					? `✓ Pinned code-server theme to "${darkTheme}"\n`
+					: `⚠ Could not pin the code-server theme: ${settings.error}\n`
+			);
+		}
+
+		if (darkenThemeManifest(manifest).changed === 0) {
+			log('· No light themes to darken in this build\n');
+			return;
+		}
+		const written = await editJsonFile(
+			rootTarget(target),
+			{ dir: themeDir, name: 'package.json' },
+			(current) => darkenThemeManifest(current).next
+		);
+		if (!written.ok) {
+			log(`⚠ Could not darken the built-in light themes: ${written.error}\n`);
+			return;
+		}
+		await execInContainer(target, { script: CLEAR_BUILTIN_CACHE });
+		// Bumping the scan's cache key; root because the bundled tree isn't the remote user's.
+		await execInContainer(rootTarget(target), {
+			script: `touch "${root}/extensions" 2>/dev/null; exit 0`
+		});
+		log('✓ Built-in light themes now render dark\n');
+	},
+
+	check(target) {
+		return checkPresence(target, CHECK_SCRIPT);
+	}
+};

package/src/lib/devcontainer.server.ts

@@ -124,12 +124,17 @@ const MANAGER_GIT_EXCLUDES = [
 const EXCLUDE_MARKER_START = '# >>> codebay (auto-generated) >>>';
 const EXCLUDE_MARKER_END = '# <<< codebay <<<';
 
-const CODE_SERVER_SETTINGS = {
+export const CODE_SERVER_SETTINGS = {
+	// Overwritten at boot by the code-server-dark injection with the id this build actually
+	// ships; the legacy label only has to carry a code-server old enough to still use it.
 	'workbench.colorTheme': 'Default Dark Modern',
-	// Stop VS Code re-resolving the theme from the OS/browser color scheme at runtime —
-	// that re-resolution (fired on focus/tab-switch) is what randomly flips the editor to
-	// light. Pinning both preferred themes to dark keeps either branch dark even if it does.
-	'window.autoDetectColorScheme': false,
+	// Counter-intuitive, and the opposite of what this file used to say: VS Code Web's
+	// pre-extension paint is `getPreferredColorScheme() ?? (isWeb ? LIGHT : DARK)`, and
+	// getPreferredColorScheme returns undefined unless detection is on — so turning detection
+	// OFF is what forced that first paint to light. On is only safe because both preferred
+	// themes below are the same dark theme, making either branch dark.
+	'window.autoDetectColorScheme': true,
+	// Left off so the high-contrast branch (which could resolve hcLight) stays unreachable.
 	'window.autoDetectHighContrast': false,
 	'workbench.preferredDarkColorTheme': 'Default Dark Modern',
 	'workbench.preferredLightColorTheme': 'Default Dark Modern',
@@ -241,10 +246,20 @@ const terminalTask = (permissionMode: ClaudePermissionMode) => ({
 	problemMatcher: []
 });
 
+const CODE_SERVER_USER_DIR = '~/.local/share/code-server/User';
+
+/**
+ * Seeds the file only when it's missing. `relaunchSurface` re-runs this launcher *after* the
+ * injections have rewritten the theme id to the one the installed build uses, so an unconditional
+ * copy would put the stale staged id back and re-arm the very cache mismatch this all exists to
+ * avoid. A rebuild always gets a fresh container, so the staged defaults still land on every build.
+ * `[ -f ]` rather than `cp -n`, which busybox coreutils don't reliably carry.
+ */
 const CODE_SERVER_APPLY_SETTINGS =
-	`mkdir -p ~/.local/share/code-server/User && ` +
+	`mkdir -p ${CODE_SERVER_USER_DIR}; ` +
+	`[ -f ${CODE_SERVER_USER_DIR}/settings.json ] || ` +
 	`cp -f \\"$PWD/.devcontainer/${CODE_SERVER_SETTINGS_FILE}\\" ` +
-	`~/.local/share/code-server/User/settings.json 2>/dev/null;`;
+	`${CODE_SERVER_USER_DIR}/settings.json 2>/dev/null;`;
 
 // Fully detached (redirects + </dev/null + &) because `devcontainer up` waits for postStart's
 // pipes to close — an attached download would keep the whole boot on the Open VSX critical path.

package/src/lib/injections.server.ts

@@ -8,6 +8,7 @@ import { gitIdentity } from '../container-injections/git-identity.ts';
 import { claudeCodeCredentials } from '../container-injections/claude-code-credentials.ts';
 import { claudeCodeCustom } from '../container-injections/claude-code-custom.ts';
 import { claudeCodeIdeExtension } from '../container-injections/claude-code-ide-extension.ts';
+import { codeServerDark } from '../container-injections/code-server-dark.ts';
 import { claudeCodeInstall } from '../container-injections/claude-code-install.ts';
 import { claudeCodeUpdate } from '../container-injections/claude-code-update.ts';
 import { claudeCodeModels } from '../container-injections/claude-code-models.ts';
@@ -69,8 +70,9 @@ function buildStages(claudeInjection: Injection): Injection[][] {
 			claudeEffortLevel
 		],
 		// git-identity needs stage 1's safe.directory; ttyd shares the apt/dpkg lock with tmux and
-		// the /usr/local/bin symlink with claude-code-install, so it trails both.
-		[gitIdentity, attentionHooks, claudeCodeModels, ttyd, claudeCodeUpdate],
+		// the /usr/local/bin symlink with claude-code-install, so it trails both. code-server-dark
+		// drops the extension cache, so it must not run while stage 1 is still installing into it.
+		[gitIdentity, attentionHooks, claudeCodeModels, ttyd, claudeCodeUpdate, codeServerDark],
 		[githubCredentials, claudeStatusline, claudePermissionMode],
 		[claudeModel, claudeAliases],
 		// claude-trust edits ~/.claude.json, which the stage-1 Claude slot also writes.

package/src/settings.ts

@@ -12,3 +12,16 @@ export function setSoundEnabled(on: boolean): void {
 	if (typeof localStorage === 'undefined') return;
 	localStorage.setItem(SOUND_KEY, on ? 'on' : 'off');
 }
+
+const TAB_SHORTCUTS_KEY = 'codebay.tabShortcuts';
+
+/** Defaults to on — only an explicit 'off' disables the Alt+1-9 tab jumps. */
+export function tabShortcutsEnabled(): boolean {
+	if (typeof localStorage === 'undefined') return true;
+	return localStorage.getItem(TAB_SHORTCUTS_KEY) !== 'off';
+}
+
+export function setTabShortcutsEnabled(on: boolean): void {
+	if (typeof localStorage === 'undefined') return;
+	localStorage.setItem(TAB_SHORTCUTS_KEY, on ? 'on' : 'off');
+}

package/src/shell.html

@@ -64,9 +64,9 @@
 				--attn-waiting: light-dark(#f59e0b, #ff7a2f);
 				/* Softened in dark — a saturated blue is the one hue that fights the warm ground. */
 				--info: light-dark(#388bfd, #6c9fd8);
-				/* The pixel matrix. 3.5% white over a near-black ground is invisible, so
+				/* The pixel matrix. 2.5% white over a near-black ground is invisible, so
 	           dark gets amber at double the alpha to read as a grid rather than noise. */
-				--grid-line: light-dark(rgba(0, 0, 0, 0.035), rgba(217, 150, 58, 0.07));
+				--grid-line: light-dark(rgba(0, 0, 0, 0.025), rgba(217, 150, 58, 0.05));
 				/* --attn-done at reduced opacity — reads correctly on both themes' track color. */
 				--switch-on-bg: rgba(34, 197, 94, 0.32);
 				/* The two dim levels, named so they stay consistent. Deliberately not
@@ -120,16 +120,27 @@
 			body {
 				margin: 0;
 				font-family: var(--font-sans);
-				/* Pale LCD panel with a faint pixel-grid matrix overlay. */
-				background:
-					repeating-linear-gradient(0deg, var(--grid-line) 0 1px, transparent 1px 3px),
-					repeating-linear-gradient(90deg, var(--grid-line) 0 1px, transparent 1px 3px), var(--bg);
+				background: var(--bg);
 				color: var(--ink);
 				font-size: 14px;
 				line-height: 1.55;
 				min-height: 100vh;
 				-webkit-font-smoothing: antialiased;
 			}
+			/* The faint pixel-grid matrix overlay lives on a viewport-fixed layer
+			   so it rasters once and is never re-tiled as the page scrolls. The 4px
+			   cell keeps the 1px lines sparse enough to avoid moiré against the
+			   physical pixel grid under fractional display scaling. */
+			body::before {
+				content: '';
+				position: fixed;
+				inset: 0;
+				z-index: -1;
+				pointer-events: none;
+				background:
+					repeating-linear-gradient(0deg, var(--grid-line) 0 1px, transparent 1px 4px),
+					repeating-linear-gradient(90deg, var(--grid-line) 0 1px, transparent 1px 4px);
+			}
 		</style>
 		{{mochi.head}} {{mochi.css}}
 	</head>

package/.mochi/svelte-client/HydratableIsland-dammyce5.js

@@ -1 +0,0 @@
-import{jb as a}from"/_mochi/client/chunk-566rqq4c.js";import"/_mochi/client/chunk-czkxd74n.js";export{a as registerComponent};