@webstir-io/webstir 0.1.1 → 0.1.2

package/src/frontend-watch.ts

@@ -1,12 +1,9 @@
-import path from 'node:path';
-
-import { DevServer, type DevServerAddress } from './dev-server.ts';
+import { startBunSpaFrontendWatch } from './bun-spa-watch.ts';
+import { startBunSsgFrontendWatch } from './bun-ssg-watch.ts';
+import type { DevServerAddress } from './dev-server.ts';
 import { createStopSignal } from './stop-signal.ts';
-import { FrontendWatchDaemonClient } from './watch-daemon-client.ts';
-import { collectWatchActions, type StructuredDiagnosticPayload } from './watch-events.ts';
 import type { WorkspaceDescriptor } from './types.ts';
 import type { WatchIo, WatchOptions } from './watch.ts';
-import { WorkspaceWatcher, type WorkspaceWatchEvent } from './workspace-watcher.ts';
 
 export interface FrontendWatchSession {
   readonly address: DevServerAddress;
@@ -14,31 +11,29 @@ export interface FrontendWatchSession {
   stop(): Promise<void>;
 }
 
-interface FrontendWatchSessionOptions extends WatchOptions {
-  readonly server?: DevServer;
-}
+type FrontendWatchSessionOptions = WatchOptions;
 
 export async function runFrontendWatch(
   workspace: WorkspaceDescriptor,
   options: WatchOptions,
-  io: WatchIo
+  io: WatchIo,
 ): Promise<void> {
   const session = await startFrontendWatchSession(workspace, options, io);
 
   io.stdout.write(
-    `[webstir] watch starting\nworkspace: ${workspace.name}\nmode: ${workspace.mode}\nurl: ${session.address.origin}\n`
+    `[webstir] watch starting\nworkspace: ${workspace.name}\nmode: ${workspace.mode}\nurl: ${session.address.origin}\n`,
   );
 
   const stopSignal = createStopSignal();
 
   try {
-    const daemonExitCode = await Promise.race([
+    const sessionExitCode = await Promise.race([
       session.waitForExit(),
       stopSignal.promise.then(() => null),
     ]);
 
-    if (typeof daemonExitCode === 'number' && daemonExitCode !== 0) {
-      throw new Error(`Frontend watch daemon exited with code ${daemonExitCode}.`);
+    if (typeof sessionExitCode === 'number' && sessionExitCode !== 0) {
+      throw new Error(`Frontend watch session exited with code ${sessionExitCode}.`);
     }
   } finally {
     stopSignal.dispose();
@@ -49,97 +44,27 @@ export async function runFrontendWatch(
 export async function startFrontendWatchSession(
   workspace: WorkspaceDescriptor,
   options: FrontendWatchSessionOptions,
-  io: WatchIo
+  io: WatchIo,
 ): Promise<FrontendWatchSession> {
-  const server = options.server ?? new DevServer({
-    buildRoot: path.join(workspace.root, 'build', 'frontend'),
-    host: options.host,
-    port: options.port,
-  });
-  const ownsServer = options.server === undefined;
-  const address = await server.start();
-
-  let initialBuildReady = false;
-  const daemon = new FrontendWatchDaemonClient({
-    workspaceRoot: workspace.root,
-    verbose: options.verbose,
-    hmrVerbose: options.hmrVerbose,
-    env: options.env,
-    onLine(line) {
-      io.stdout.write(`${line}\n`);
-    },
-    onErrorLine(line) {
-      io.stderr.write(`${line}\n`);
-    },
-    onDiagnostic(payload) {
-      if (!initialBuildReady && payload.code === 'frontend.watch.pipeline.success') {
-        initialBuildReady = true;
-        io.stdout.write(`[webstir] frontend ready at ${address.origin}\n`);
-      }
-
-      void applyDiagnostic(payload, server);
-    },
-  });
-
-  const watcher = new WorkspaceWatcher({
-    workspaceRoot: workspace.root,
-    onEvent(event) {
-      void dispatchWorkspaceEvent(event, daemon);
-    },
-  });
-
-  await daemon.start();
-  await watcher.start();
-  await daemon.sendStart();
-
-  let stopPromise: Promise<void> | null = null;
-
-  return {
-    address,
-    async waitForExit() {
-      return await daemon.waitForExit();
-    },
-    async stop() {
-      stopPromise ??= (async () => {
-        await watcher.stop();
-        await daemon.stop();
-        if (ownsServer) {
-          await server.stop();
-        }
-      })();
-
-      await stopPromise;
-    },
-  };
+  return await createFrontendWatchSession(workspace, options, io);
 }
 
-async function applyDiagnostic(payload: StructuredDiagnosticPayload, server: DevServer): Promise<void> {
-  const actions = collectWatchActions(payload);
-  for (const action of actions) {
-    switch (action.type) {
-      case 'status':
-        await server.publishStatus(action.status);
-        break;
-      case 'hmr':
-        await server.publishHotUpdate(action.payload);
-        break;
-      case 'reload':
-        await server.publishReload();
-        break;
-      default:
-        break;
-    }
-  }
-}
-
-async function dispatchWorkspaceEvent(
-  event: WorkspaceWatchEvent,
-  daemon: FrontendWatchDaemonClient
-): Promise<void> {
-  if (event.type === 'reload') {
-    await daemon.sendReload();
-    return;
+async function createFrontendWatchSession(
+  workspace: WorkspaceDescriptor,
+  options: FrontendWatchSessionOptions,
+  _io: WatchIo,
+): Promise<FrontendWatchSession> {
+  if (workspace.mode === 'ssg') {
+    return await startBunSsgFrontendWatch({
+      workspaceRoot: workspace.root,
+      host: options.host,
+      port: options.port,
+    });
   }
 
-  await daemon.sendChange(event.path);
+  return await startBunSpaFrontendWatch({
+    workspaceRoot: workspace.root,
+    host: options.host,
+    port: options.port,
+  });
 }

package/src/full-watch.ts

@@ -1,9 +1,7 @@
-import path from 'node:path';
 import { createServer } from 'node:net';
 
 import { startApiWatchSession } from './api-watch.ts';
-import { DevServer } from './dev-server.ts';
-import { startFrontendWatchSession } from './frontend-watch.ts';
+import { startBunGeneratedFrontendWatch } from './bun-generated-frontend-watch.ts';
 import { createStopSignal } from './stop-signal.ts';
 import type { WorkspaceDescriptor } from './types.ts';
 import type { WatchIo, WatchOptions } from './watch.ts';
@@ -11,34 +9,32 @@ import type { WatchIo, WatchOptions } from './watch.ts';
 export async function runFullWatch(
   workspace: WorkspaceDescriptor,
   options: WatchOptions,
-  io: WatchIo
+  io: WatchIo,
 ): Promise<void> {
   const backendPort = await allocateBackendPort();
   const apiSession = await startApiWatchSession(workspace, { ...options, port: backendPort }, io);
-  const server = new DevServer({
-    buildRoot: path.join(workspace.root, 'build', 'frontend'),
-    host: options.host,
-    port: options.port,
-    apiProxyOrigin: apiSession.origin,
-  });
-
-  let frontendSession: Awaited<ReturnType<typeof startFrontendWatchSession>> | undefined;
+  let frontendSession: Awaited<ReturnType<typeof startBunGeneratedFrontendWatch>> | undefined;
 
   try {
-    frontendSession = await startFrontendWatchSession(workspace, { ...options, server }, io);
+    frontendSession = await startBunGeneratedFrontendWatch({
+      workspaceRoot: workspace.root,
+      host: options.host,
+      port: options.port,
+      apiProxyOrigin: apiSession.origin,
+    });
     io.stdout.write(
-      `[webstir] watch starting\nworkspace: ${workspace.name}\nmode: ${workspace.mode}\nurl: ${frontendSession.address.origin}\napi: ${apiSession.origin}\n`
+      `[webstir] watch starting\nworkspace: ${workspace.name}\nmode: ${workspace.mode}\nurl: ${frontendSession.address.origin}\napi: ${apiSession.origin}\n`,
     );
 
     const stopSignal = createStopSignal();
     try {
-      const daemonExitCode = await Promise.race([
+      const sessionExitCode = await Promise.race([
         frontendSession.waitForExit(),
         stopSignal.promise.then(() => null),
       ]);
 
-      if (typeof daemonExitCode === 'number' && daemonExitCode !== 0) {
-        throw new Error(`Frontend watch daemon exited with code ${daemonExitCode}.`);
+      if (typeof sessionExitCode === 'number' && sessionExitCode !== 0) {
+        throw new Error(`Frontend watch session exited with code ${sessionExitCode}.`);
       }
     } finally {
       stopSignal.dispose();
@@ -47,7 +43,6 @@ export async function runFullWatch(
     if (frontendSession) {
       await frontendSession.stop();
     }
-    await server.stop();
     await apiSession.stop();
   }
 }

package/src/index.ts

@@ -1,13 +1,20 @@
 export * from './add.ts';
 export * from './add-backend.ts';
+export * from './agent.ts';
 export * from './backend-inspect.ts';
 export * from './build-plan.ts';
 export * from './build.ts';
 export * from './dev-server.ts';
+export * from './doctor.ts';
 export * from './enable.ts';
 export * from './execute.ts';
 export * from './format.ts';
+export * from './frontend-inspect.ts';
 export * from './init.ts';
+export * from './inspect.ts';
+export * from './mcp/run-cli-json.ts';
+export * from './mcp/server.ts';
+export * from './operations.ts';
 export * from './publish.ts';
 export * from './repair.ts';
 export * from './refresh.ts';

package/src/init-assets.ts

@@ -22,37 +22,67 @@ export function getRootScaffoldAssets(): readonly ScaffoldAsset[] {
     createAsset(sharedTemplateRoot, 'Errors.500.html', 'Errors.500.html'),
     createAsset(sharedTemplateRoot, 'Errors.default.html', 'Errors.default.html'),
     createAsset(sharedTemplateRoot, 'types.global.d.ts', 'types.global.d.ts'),
-    createAsset(sharedTemplateRoot, path.join('types', 'global.d.ts'), path.join('types', 'global.d.ts')),
+    createAsset(
+      sharedTemplateRoot,
+      path.join('types', 'global.d.ts'),
+      path.join('types', 'global.d.ts'),
+    ),
   ];
 }
 
-export async function getModeScaffoldAssets(mode: WorkspaceMode): Promise<readonly ScaffoldAsset[]> {
+export async function getModeScaffoldAssets(
+  mode: WorkspaceMode,
+): Promise<readonly ScaffoldAsset[]> {
   switch (mode) {
     case 'ssg':
       return collectModeAssets([
-        { sourceRoot: path.join(ssgTemplateRoot, 'src', 'frontend'), targetRoot: path.join('src', 'frontend') },
+        {
+          sourceRoot: path.join(ssgTemplateRoot, 'src', 'frontend'),
+          targetRoot: path.join('src', 'frontend'),
+        },
       ]);
     case 'spa':
       return collectModeAssets([
-        { sourceRoot: path.join(spaTemplateRoot, 'src', 'frontend'), targetRoot: path.join('src', 'frontend') },
-        { sourceRoot: path.join(spaTemplateRoot, 'src', 'shared'), targetRoot: path.join('src', 'shared') },
+        {
+          sourceRoot: path.join(spaTemplateRoot, 'src', 'frontend'),
+          targetRoot: path.join('src', 'frontend'),
+        },
+        {
+          sourceRoot: path.join(spaTemplateRoot, 'src', 'shared'),
+          targetRoot: path.join('src', 'shared'),
+        },
       ]);
     case 'api':
       return collectModeAssets([
-        { sourceRoot: path.join(apiTemplateRoot, 'src', 'backend'), targetRoot: path.join('src', 'backend') },
-        { sourceRoot: path.join(apiTemplateRoot, 'src', 'shared'), targetRoot: path.join('src', 'shared') },
+        {
+          sourceRoot: path.join(apiTemplateRoot, 'src', 'backend'),
+          targetRoot: path.join('src', 'backend'),
+        },
+        {
+          sourceRoot: path.join(apiTemplateRoot, 'src', 'shared'),
+          targetRoot: path.join('src', 'shared'),
+        },
       ]);
     case 'full':
       return collectModeAssets([
-        { sourceRoot: path.join(fullTemplateRoot, 'src', 'frontend'), targetRoot: path.join('src', 'frontend') },
-        { sourceRoot: path.join(fullTemplateRoot, 'src', 'backend'), targetRoot: path.join('src', 'backend') },
-        { sourceRoot: path.join(fullTemplateRoot, 'src', 'shared'), targetRoot: path.join('src', 'shared') },
+        {
+          sourceRoot: path.join(fullTemplateRoot, 'src', 'frontend'),
+          targetRoot: path.join('src', 'frontend'),
+        },
+        {
+          sourceRoot: path.join(fullTemplateRoot, 'src', 'backend'),
+          targetRoot: path.join('src', 'backend'),
+        },
+        {
+          sourceRoot: path.join(fullTemplateRoot, 'src', 'shared'),
+          targetRoot: path.join('src', 'shared'),
+        },
       ]);
   }
 }
 
 async function collectModeAssets(
-  roots: readonly { sourceRoot: string; targetRoot: string }[]
+  roots: readonly { sourceRoot: string; targetRoot: string }[],
 ): Promise<readonly ScaffoldAsset[]> {
   const assets: ScaffoldAsset[] = [];
   for (const root of roots) {

package/src/init.ts

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { cp, mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
+import { mkdir, readdir } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 
@@ -7,15 +7,7 @@ import { getModeScaffoldAssets, getRootScaffoldAssets } from './init-assets.ts';
 import { monorepoRoot } from './paths.ts';
 import type { WorkspaceMode } from './types.ts';
 
-const PACKAGE_MANAGER = 'bun@1.3.5';
-const REPO_WORKSPACE_PATTERNS = [
-  'packages/contracts/*',
-  'packages/tooling/*',
-  'orchestrators/bun',
-  'apps/*',
-  'examples/demos/*',
-  'examples/demos/ssg/*',
-] as const;
+const PACKAGE_MANAGER = 'bun@1.3.11';
 
 const MODE_DESCRIPTIONS: Record<WorkspaceMode, string> = {
   ssg: 'Static site (SSG) workspace for Webstir.',
@@ -37,15 +29,26 @@ export interface InitResult {
   readonly changes: readonly string[];
 }
 
+interface ScaffoldMetadata {
+  readonly packageName?: string;
+  readonly description?: string;
+}
+
+let repoWorkspacePatternsPromise: Promise<readonly string[]> | undefined;
+
 export async function runInit(options: RunInitOptions): Promise<InitResult> {
-  const request = parseInitRequest(options.args, options.workspaceRoot, options.cwd ?? process.cwd());
+  const request = parseInitRequest(
+    options.args,
+    options.workspaceRoot,
+    options.cwd ?? process.cwd(),
+  );
   return scaffoldWorkspace(request.mode, request.workspaceRoot, { force: false });
 }
 
 export async function scaffoldWorkspace(
   mode: WorkspaceMode,
   workspaceRoot: string,
-  options: { readonly force: boolean }
+  options: { readonly force: boolean; readonly metadata?: ScaffoldMetadata },
 ): Promise<InitResult> {
   if (existsSync(workspaceRoot) && !options.force && !(await isDirectoryEmpty(workspaceRoot))) {
     throw new Error(`Refusing to initialize non-empty directory: ${workspaceRoot}`);
@@ -53,34 +56,31 @@ export async function scaffoldWorkspace(
 
   await mkdir(workspaceRoot, { recursive: true });
 
-  const packageName = resolvePackageName(workspaceRoot);
+  const packageName = resolvePackageName(workspaceRoot, options.metadata);
   const dependencySpecs = await resolveDependencySpecs(workspaceRoot);
   const changes: string[] = [];
 
   for (const asset of getRootScaffoldAssets()) {
     const targetPath = path.join(workspaceRoot, asset.targetPath);
-    await mkdir(path.dirname(targetPath), { recursive: true });
-    await cp(asset.sourcePath, targetPath, { force: true });
+    await copyAsset(asset.sourcePath, targetPath);
     changes.push(toWorkspaceRelative(workspaceRoot, targetPath));
   }
 
   for (const asset of await getModeScaffoldAssets(mode)) {
     const targetPath = path.join(workspaceRoot, asset.targetPath);
-    await mkdir(path.dirname(targetPath), { recursive: true });
-    await cp(asset.sourcePath, targetPath, { force: true });
+    await copyAsset(asset.sourcePath, targetPath);
     changes.push(toWorkspaceRelative(workspaceRoot, targetPath));
   }
 
   const packageJsonPath = path.join(workspaceRoot, 'package.json');
-  await writeFile(
+  await Bun.write(
     packageJsonPath,
-    `${JSON.stringify(createPackageJson(mode, workspaceRoot, packageName, dependencySpecs), null, 2)}\n`,
-    'utf8'
+    `${JSON.stringify(createPackageJson(mode, packageName, dependencySpecs, options.metadata), null, 2)}\n`,
   );
   changes.push('package.json');
 
   const baseTsconfigPath = path.join(workspaceRoot, 'base.tsconfig.json');
-  await writeFile(baseTsconfigPath, `${JSON.stringify(createBaseTsconfig(mode), null, 2)}\n`, 'utf8');
+  await Bun.write(baseTsconfigPath, `${JSON.stringify(createBaseTsconfig(mode), null, 2)}\n`);
   changes.push('base.tsconfig.json');
 
   return {
@@ -94,13 +94,15 @@ export async function scaffoldWorkspace(
 function parseInitRequest(
   args: readonly string[],
   workspaceOverride: string | undefined,
-  cwd: string
+  cwd: string,
 ): { readonly mode: WorkspaceMode; readonly workspaceRoot: string } {
   const [firstArg, secondArg] = args;
 
   if (workspaceOverride) {
     if (!firstArg) {
-      throw new Error('Usage: webstir init <mode> --workspace <path> or webstir init <mode> <directory>.');
+      throw new Error(
+        'Usage: webstir init <mode> --workspace <path> or webstir init <mode> <directory>.',
+      );
     }
 
     return {
@@ -128,7 +130,12 @@ function parseInitRequest(
 
 function parseWorkspaceMode(value: string): WorkspaceMode {
   const normalized = value.trim().toLowerCase();
-  if (normalized === 'ssg' || normalized === 'spa' || normalized === 'api' || normalized === 'full') {
+  if (
+    normalized === 'ssg' ||
+    normalized === 'spa' ||
+    normalized === 'api' ||
+    normalized === 'full'
+  ) {
     return normalized;
   }
 
@@ -149,7 +156,8 @@ async function isRepoWorkspacePath(workspaceRoot: string): Promise<boolean> {
     return false;
   }
 
-  return REPO_WORKSPACE_PATTERNS.some((pattern) => matchesWorkspacePattern(relative, pattern));
+  const repoWorkspacePatterns = await readRepoWorkspacePatterns();
+  return repoWorkspacePatterns.some((pattern) => matchesWorkspacePattern(relative, pattern));
 }
 
 async function resolveDependencySpecs(workspaceRoot: string): Promise<Record<string, string>> {
@@ -162,14 +170,18 @@ async function resolveDependencySpecs(workspaceRoot: string): Promise<Record<str
   }
 
   return {
-    '@webstir-io/webstir-frontend': await readInstalledPackageVersion('@webstir-io/webstir-frontend'),
+    '@webstir-io/webstir-frontend': await readInstalledPackageVersion(
+      '@webstir-io/webstir-frontend',
+    ),
     '@webstir-io/webstir-backend': await readInstalledPackageVersion('@webstir-io/webstir-backend'),
     '@webstir-io/webstir-testing': await readInstalledPackageVersion('@webstir-io/webstir-testing'),
   };
 }
 
 async function readPackageVersion(packageJsonPath: string): Promise<string> {
-  const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8')) as { readonly version?: string };
+  const packageJson = JSON.parse(await readTextFile(packageJsonPath)) as {
+    readonly version?: string;
+  };
   if (!packageJson.version) {
     throw new Error(`Missing version in ${packageJsonPath}`);
   }
@@ -179,9 +191,9 @@ async function readPackageVersion(packageJsonPath: string): Promise<string> {
 
 function createPackageJson(
   mode: WorkspaceMode,
-  workspaceRoot: string,
   packageName: string,
-  dependencySpecs: Record<string, string>
+  dependencySpecs: Record<string, string>,
+  metadata: ScaffoldMetadata | undefined,
 ): Record<string, unknown> {
   const dependencies: Record<string, string> = {
     '@webstir-io/webstir-testing': dependencySpecs['@webstir-io/webstir-testing'],
@@ -200,7 +212,7 @@ function createPackageJson(
     version: '1.0.0',
     private: true,
     type: 'module',
-    description: resolveDescription(mode, workspaceRoot),
+    description: metadata?.description ?? MODE_DESCRIPTIONS[mode],
     dependencies,
     devDependencies: {
       '@types/node': '^20.0.0',
@@ -255,33 +267,15 @@ function createBaseTsconfig(mode: WorkspaceMode): Record<string, unknown> {
       sourceMap: true,
       declaration: false,
       removeComments: true,
-      typeRoots: [
-        './types',
-        './node_modules/@types',
-      ],
+      typeRoots: ['./types', './node_modules/@types'],
       inlineSources: true,
     },
   };
 }
 
-function resolveDescription(mode: WorkspaceMode, workspaceRoot: string): string {
-  const relative = monorepoRoot
-    ? path.relative(monorepoRoot, workspaceRoot).replaceAll(path.sep, '/')
-    : '';
-  if (relative === 'examples/demos/full') {
-    return 'Webstir frontend defaults and tooling';
-  }
-
-  return MODE_DESCRIPTIONS[mode];
-}
-
-function resolvePackageName(workspaceRoot: string): string {
-  const relative = monorepoRoot
-    ? path.relative(monorepoRoot, workspaceRoot).replaceAll(path.sep, '/')
-    : '';
-  const known = getKnownWorkspacePackageName(relative);
-  if (known) {
-    return known;
+function resolvePackageName(workspaceRoot: string, metadata: ScaffoldMetadata | undefined): string {
+  if (metadata?.packageName?.trim()) {
+    return metadata.packageName;
   }
 
   return sanitizePackageName(path.basename(workspaceRoot));
@@ -293,25 +287,12 @@ async function readInstalledPackageVersion(packageName: string): Promise<string>
   return await readPackageVersion(packageJsonPath);
 }
 
-function getKnownWorkspacePackageName(relativePath: string): string | undefined {
-  switch (relativePath) {
-    case 'examples/demos/spa':
-      return 'webstir-demo-spa';
-    case 'examples/demos/api':
-      return 'webstir-demo-api';
-    case 'examples/demos/full':
-      return 'webstir-demo-full';
-    case 'examples/demos/ssg/base':
-      return 'webstir-demo-ssg-base';
-    case 'examples/demos/ssg/site':
-      return 'webstir-demo-ssg-site';
-    default:
-      return undefined;
-  }
-}
-
 function sanitizePackageName(value: string): string {
-  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+  const normalized = value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '');
   return normalized || 'webstir-project';
 }
 
@@ -327,7 +308,9 @@ function matchesWorkspacePattern(relativePath: string, pattern: string): boolean
     return false;
   }
 
-  return patternSegments.every((segment, index) => segment === '*' || segment === relativeSegments[index]);
+  return patternSegments.every(
+    (segment, index) => segment === '*' || segment === relativeSegments[index],
+  );
 }
 
 function uniqueSorted(values: readonly string[]): string[] {
@@ -337,3 +320,34 @@ function uniqueSorted(values: readonly string[]): string[] {
 function toWorkspaceRelative(workspaceRoot: string, absolutePath: string): string {
   return path.relative(workspaceRoot, absolutePath).replaceAll(path.sep, '/');
 }
+
+async function readRepoWorkspacePatterns(): Promise<readonly string[]> {
+  if (!monorepoRoot) {
+    return [];
+  }
+
+  repoWorkspacePatternsPromise ??= loadRepoWorkspacePatterns();
+  return await repoWorkspacePatternsPromise;
+}
+
+async function loadRepoWorkspacePatterns(): Promise<readonly string[]> {
+  if (!monorepoRoot) {
+    return [];
+  }
+
+  const packageJsonPath = path.join(monorepoRoot, 'package.json');
+  const packageJson = JSON.parse(await readTextFile(packageJsonPath)) as {
+    readonly workspaces?: readonly string[];
+  };
+
+  return packageJson.workspaces ?? [];
+}
+
+async function copyAsset(sourcePath: string, targetPath: string): Promise<void> {
+  await mkdir(path.dirname(targetPath), { recursive: true });
+  await Bun.write(targetPath, Bun.file(sourcePath));
+}
+
+async function readTextFile(filePath: string): Promise<string> {
+  return await Bun.file(filePath).text();
+}