@titannio/webtoolkit-cli 1.3.0

package/dist/config.d.ts

@@ -0,0 +1,306 @@
+export type CleanLevel = 'empty' | 'cache' | 'deep' | 'nuclear';
+export type ReinstallPolicy = 'ask' | 'always' | 'never';
+export type RemovalKind = 'dir' | 'file' | 'empty-dir';
+export type CleanerOptions = {
+    level?: CleanLevel;
+    dryRun: boolean;
+    noStorePrune: boolean;
+    interactive: boolean;
+    reinstall: ReinstallPolicy;
+};
+export type Removal = {
+    kind: RemovalKind;
+    relPath: string;
+};
+export type LevelConfig = {
+    label: string;
+    removeEmptyDirs: boolean;
+    removableDirNames: string[];
+    removableFileNames: string[];
+    removableFileSuffixes: string[];
+    removableFilePrefixes: string[];
+    removableFilePatterns: string[];
+    removableSpecificFiles: string[];
+};
+export type CleanerConfig = {
+    workspaceRootNames: string[];
+    protectedRootNames: string[];
+    skipEmptyDirNames: string[];
+    skipArtifactDirNames: string[];
+    levels: Record<CleanLevel, LevelConfig>;
+};
+export type WebToolkitCliConfig = {
+    packageManager: string;
+    cleaner: CleanerConfig;
+    tasks: Record<string, TaskConfig>;
+    guards?: GuardsConfig;
+    documentation?: DocumentationConfig;
+    workspaceTests?: WorkspaceTestsConfig;
+    repoCheck?: RepoCheckConfig;
+    releaseGate?: ReleaseGateConfig;
+    validate?: ValidateConfig;
+    jsdocReport?: JSDocReportConfig;
+    bundleAudit?: BundleAuditConfig;
+    upgrade?: UpgradeConfig;
+    devWatch?: DevWatchConfig;
+    devGrid?: DevGridConfig;
+    environment?: EnvironmentConfig;
+};
+export type PathScanGuardConfig = {
+    includePaths: string[];
+    excludePatterns?: string[];
+};
+export type SchemaGuardConfig = PathScanGuardConfig & {
+    centralDirectory: string;
+    builders: string[];
+};
+export type AnyGuardConfig = PathScanGuardConfig;
+export type RebuildPreflightTargetConfig = {
+    warningTitle: string;
+    turboFilters: string[];
+    relevantBuildPackages: string[];
+};
+export type RebuildPreflightGuardConfig = {
+    targets: Record<string, RebuildPreflightTargetConfig>;
+};
+export type TsconfigFileCheckConfig = {
+    path: string;
+    requiredIncludes?: string[];
+    compilerOptions?: Record<string, string | number | boolean>;
+    publicAliases?: string[];
+};
+export type TextFileCheckConfig = {
+    path: string;
+    forbiddenStrings: string[];
+};
+export type TsconfigGuardConfig = {
+    packageScope?: string;
+    configs: TsconfigFileCheckConfig[];
+    textFiles?: TextFileCheckConfig[];
+};
+export type LayerConfig = {
+    name: string;
+    paths: string[];
+    exclude?: string[];
+};
+export type DalServiceRepositoryGuardConfig = {
+    sourceDirectory: string;
+    tsconfig: string;
+    excludePatterns?: string[];
+    layers: LayerConfig[];
+    forbiddenDependencies: Record<string, string[]>;
+};
+export type CodePatternRuleConfig = {
+    includePaths: string[];
+    allowedPathPatterns?: string[];
+};
+export type CodePatternGuardConfig = {
+    tsconfig: string;
+    modelsDirectory: string;
+    rules: Record<string, CodePatternRuleConfig>;
+};
+export type WorkspacePeerRequirementConfig = {
+    dependency: string;
+    providers: string[];
+    consumers: string[];
+};
+export type WorkspaceManifestGuardConfig = {
+    packageRoots: string[];
+    requireWorkspaceProtocol: boolean;
+    peerRequirements: WorkspacePeerRequirementConfig[];
+};
+export type RepositoryHygieneGuardConfig = {
+    forbiddenPathPatterns: string[];
+    allowedPathPatterns: string[];
+};
+export type PackageSurfaceGuardConfig = {
+    packageDirectories: string[];
+    forbiddenPublishedPatterns: string[];
+};
+export type GuardsConfig = {
+    any?: AnyGuardConfig;
+    codePattern?: CodePatternGuardConfig;
+    dalServiceRepository?: DalServiceRepositoryGuardConfig;
+    internalLink?: PathScanGuardConfig;
+    packageSurface?: PackageSurfaceGuardConfig;
+    rebuildPreflight?: RebuildPreflightGuardConfig;
+    repositoryHygiene?: RepositoryHygieneGuardConfig;
+    schema?: SchemaGuardConfig;
+    tsconfig?: TsconfigGuardConfig;
+    workspaceManifest?: WorkspaceManifestGuardConfig;
+};
+export type DocumentationMetadataRule = {
+    equals?: string;
+    unique?: boolean;
+    repositoryPaths?: boolean;
+    minItems?: number;
+};
+export type DocumentationPairedDocumentsConfig = {
+    target: string;
+    index?: string;
+    table?: {
+        header: string[];
+        fileColumn: string;
+        minRows?: number;
+    };
+    finalSection?: {
+        heading: string;
+        minItems?: number;
+    };
+};
+export type DocumentationCollectionConfig = {
+    files: string[];
+    exclude?: string[];
+    index?: string;
+    metadata?: Record<string, DocumentationMetadataRule>;
+    pairedDocuments?: DocumentationPairedDocumentsConfig;
+};
+export type DocumentationConfig = {
+    files: string[];
+    excludeDirectories?: string[];
+    checks?: {
+        singleH1?: boolean;
+        headingOrder?: boolean;
+        localLinks?: boolean;
+        reachability?: {
+            entrypoints: string[];
+            files: string[];
+        };
+    };
+    requiredFiles?: string[];
+    collections?: DocumentationCollectionConfig[];
+    inventories?: Array<{
+        document: string;
+        sources: string[];
+        minMatches?: number;
+    }>;
+};
+export type TaskOutputMode = 'inherit' | 'buffered';
+type TaskStepBaseConfig = {
+    label: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    appendArgs?: boolean;
+    outputMode?: TaskOutputMode;
+};
+export type CommandStepConfig = TaskStepBaseConfig & {
+    command: string;
+    builtinGuard?: never;
+};
+export type BuiltinGuardStepConfig = TaskStepBaseConfig & {
+    builtinGuard: string;
+    command?: never;
+};
+export type TaskStepConfig = CommandStepConfig | BuiltinGuardStepConfig;
+export type TaskConfig = {
+    title?: string;
+    failFast?: boolean;
+    outputMode?: TaskOutputMode;
+    steps: TaskStepConfig[];
+};
+export type WorkspaceTargetConfig = {
+    name: string;
+    package: string;
+    path: string;
+};
+export type WorkspaceTestsConfig = {
+    workspaces: WorkspaceTargetConfig[];
+    errorLogFile?: string;
+    testFilePattern?: string;
+    ignoreDirNames?: string[];
+    maxFailureExcerptLines?: number;
+};
+export type RepoCheckConfig = {
+    title?: string;
+    failFast?: boolean;
+    steps: TaskStepConfig[];
+};
+export type ReleaseGateStageConfig = {
+    name: string;
+    command?: string;
+    args?: string[];
+    package?: string;
+    script?: string;
+    files?: string[];
+};
+export type ReleaseGateConfig = {
+    stages: ReleaseGateStageConfig[];
+};
+export type ValidateConfig = {
+    steps: TaskStepConfig[];
+    postSteps?: TaskStepConfig[];
+};
+export type JSDocReportConfig = {
+    includePaths: string[];
+    excludePatterns?: string[];
+    reportFile?: string;
+    maxLineLength?: number;
+    promptForReport?: boolean;
+};
+export type BundleAuditConfig = {
+    appDirs: string[];
+    top?: number;
+    rawWarningBytes?: number;
+};
+export type UpgradeConfig = {
+    defaultCooldownDays?: number;
+    protectedDependencyUpstreamHints?: Record<string, string[]>;
+    protectedOverridesFile?: string;
+    singletonGuardCommand?: CommandStepConfig;
+};
+export type DevAppConfig = {
+    displayName: string;
+    port: number;
+    filter?: string;
+    color?: string;
+};
+export type DevWatchConfig = {
+    apps: Record<string, DevAppConfig>;
+    defaultApps: string[];
+    backendApp?: string;
+    host?: string;
+    backendPortCleanupGraceMs?: number;
+};
+export type DevGridPaneConfig = {
+    title: string;
+    command: string;
+    silentCommand?: string;
+    fontSize?: number;
+};
+export type DevGridRowConfig = {
+    panes: DevGridPaneConfig[];
+};
+export type DevGridLayoutConfig = {
+    rows: DevGridRowConfig[];
+};
+export type DevGridConfig = {
+    layout: DevGridLayoutConfig;
+    fallbackScript?: string;
+    silentFallbackScript?: string;
+    preflightCommand?: CommandStepConfig;
+};
+export type EnvironmentConfig = {
+    requiredNodeMajor?: number;
+    packageManager?: string;
+    corepackHome?: string;
+};
+type PartialLevelConfig = Partial<Omit<LevelConfig, 'removableFilePatterns'> & {
+    removableFilePatterns: string[];
+}>;
+type PartialCleanerConfig = Partial<Omit<CleanerConfig, 'levels'> & {
+    levels: Partial<Record<CleanLevel, PartialLevelConfig>>;
+}>;
+type PartialWebToolkitCliConfig = Partial<Omit<WebToolkitCliConfig, 'cleaner'> & {
+    cleaner: PartialCleanerConfig;
+    tasks: Record<string, TaskConfig>;
+}>;
+export declare const defaultConfig: WebToolkitCliConfig;
+export declare function pathExists(target: string): Promise<boolean>;
+export declare function findConfigPath(startDir: string): Promise<string | null>;
+export declare function mergeConfig(override?: PartialWebToolkitCliConfig): WebToolkitCliConfig;
+export declare function loadConfig(cwd: string): Promise<{
+    config: WebToolkitCliConfig;
+    configPath: string | null;
+}>;
+export {};

package/dist/config.js

@@ -0,0 +1,173 @@
+import { access, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { validateConfig } from './config-reference.js';
+const configFileName = 'config.json';
+const configDirName = '.webtoolkit-cli';
+const cacheDirNames = [
+    '.turbo',
+    '.cache',
+    '.parcel-cache',
+    '.vite',
+    '.next',
+    '.nuxt',
+    '.nyc_output',
+    '.rpt2_cache',
+    '.rts2_cache_cjs',
+    '.rts2_cache_es',
+    '.rts2_cache_umd',
+    '.wrangler',
+];
+const deepDirNames = ['dist', 'build', 'coverage'];
+const cacheFileNames = ['.eslintcache', '.stylelintcache', 'vitest-results.json'];
+const deepFileSuffixes = ['.tsbuildinfo', '.lcov'];
+const deepFilePrefixes = ['vite.config.ts.timestamp-'];
+const deepFilePatterns = [
+    '^npm-debug\\.log',
+    '^yarn-debug\\.log',
+    '^yarn-error\\.log',
+    '^lerna-debug\\.log',
+    '^\\.pnpm-debug\\.log',
+    '^report\\.\\d+\\.\\d+\\.\\d+\\.\\d+\\.json$',
+];
+export const defaultConfig = {
+    packageManager: 'pnpm',
+    tasks: {},
+    cleaner: {
+        workspaceRootNames: ['apps', 'packages'],
+        protectedRootNames: ['apps', 'scripts'],
+        skipEmptyDirNames: [
+            'node_modules',
+            '.pnpm-store',
+            '.git',
+            '.idea',
+            '.vscode',
+            '.vercel',
+            '.trae',
+            '.agent',
+        ],
+        skipArtifactDirNames: ['.git'],
+        levels: {
+            empty: {
+                label: 'Empty directories only',
+                removeEmptyDirs: true,
+                removableDirNames: [],
+                removableFileNames: [],
+                removableFileSuffixes: [],
+                removableFilePrefixes: [],
+                removableFilePatterns: [],
+                removableSpecificFiles: [],
+            },
+            cache: {
+                label: 'Caches and temp artifacts',
+                removeEmptyDirs: true,
+                removableDirNames: cacheDirNames,
+                removableFileNames: cacheFileNames,
+                removableFileSuffixes: [],
+                removableFilePrefixes: [],
+                removableFilePatterns: [],
+                removableSpecificFiles: [],
+            },
+            deep: {
+                label: 'Deep clean (without node_modules)',
+                removeEmptyDirs: true,
+                removableDirNames: [...cacheDirNames, ...deepDirNames],
+                removableFileNames: cacheFileNames,
+                removableFileSuffixes: deepFileSuffixes,
+                removableFilePrefixes: deepFilePrefixes,
+                removableFilePatterns: deepFilePatterns,
+                removableSpecificFiles: [],
+            },
+            nuclear: {
+                label: 'Nuclear clean',
+                removeEmptyDirs: true,
+                removableDirNames: [...cacheDirNames, ...deepDirNames, 'node_modules'],
+                removableFileNames: cacheFileNames,
+                removableFileSuffixes: deepFileSuffixes,
+                removableFilePrefixes: deepFilePrefixes,
+                removableFilePatterns: deepFilePatterns,
+                removableSpecificFiles: [],
+            },
+        },
+    },
+};
+export async function pathExists(target) {
+    try {
+        await access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function findConfigPath(startDir) {
+    let current = path.resolve(startDir);
+    while (true) {
+        const candidate = path.join(current, configDirName, configFileName);
+        if (await pathExists(candidate))
+            return candidate;
+        const next = path.dirname(current);
+        if (next === current)
+            return null;
+        current = next;
+    }
+}
+function mergeLevelConfig(base, override) {
+    if (!override)
+        return { ...base };
+    return {
+        label: override.label ?? base.label,
+        removeEmptyDirs: override.removeEmptyDirs ?? base.removeEmptyDirs,
+        removableDirNames: override.removableDirNames ?? base.removableDirNames,
+        removableFileNames: override.removableFileNames ?? base.removableFileNames,
+        removableFileSuffixes: override.removableFileSuffixes ?? base.removableFileSuffixes,
+        removableFilePrefixes: override.removableFilePrefixes ?? base.removableFilePrefixes,
+        removableFilePatterns: override.removableFilePatterns ?? base.removableFilePatterns,
+        removableSpecificFiles: override.removableSpecificFiles ?? base.removableSpecificFiles,
+    };
+}
+export function mergeConfig(override = {}) {
+    const cleanerOverride = override.cleaner ?? {};
+    return {
+        packageManager: override.packageManager ?? defaultConfig.packageManager,
+        tasks: override.tasks ?? defaultConfig.tasks,
+        guards: override.guards,
+        documentation: override.documentation,
+        workspaceTests: override.workspaceTests,
+        repoCheck: override.repoCheck,
+        releaseGate: override.releaseGate,
+        validate: override.validate,
+        jsdocReport: override.jsdocReport,
+        bundleAudit: override.bundleAudit,
+        upgrade: override.upgrade,
+        devWatch: override.devWatch,
+        devGrid: override.devGrid,
+        environment: override.environment,
+        cleaner: {
+            workspaceRootNames: cleanerOverride.workspaceRootNames ?? defaultConfig.cleaner.workspaceRootNames,
+            protectedRootNames: cleanerOverride.protectedRootNames ?? defaultConfig.cleaner.protectedRootNames,
+            skipEmptyDirNames: cleanerOverride.skipEmptyDirNames ?? defaultConfig.cleaner.skipEmptyDirNames,
+            skipArtifactDirNames: cleanerOverride.skipArtifactDirNames ?? defaultConfig.cleaner.skipArtifactDirNames,
+            levels: {
+                empty: mergeLevelConfig(defaultConfig.cleaner.levels.empty, cleanerOverride.levels?.empty),
+                cache: mergeLevelConfig(defaultConfig.cleaner.levels.cache, cleanerOverride.levels?.cache),
+                deep: mergeLevelConfig(defaultConfig.cleaner.levels.deep, cleanerOverride.levels?.deep),
+                nuclear: mergeLevelConfig(defaultConfig.cleaner.levels.nuclear, cleanerOverride.levels?.nuclear),
+            },
+        },
+    };
+}
+export async function loadConfig(cwd) {
+    const configPath = await findConfigPath(cwd);
+    if (!configPath)
+        return { config: mergeConfig(), configPath: null };
+    const raw = await readFile(configPath, 'utf8');
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`Invalid .webtoolkit-cli/config.json: ${error.message}`);
+    }
+    validateConfig(parsed);
+    return { config: mergeConfig(parsed), configPath };
+}

package/dist/dev-grid.d.ts

@@ -0,0 +1,7 @@
+import type { WebToolkitCliConfig } from './config.js';
+type Runtime = {
+    cwd: string;
+    config: WebToolkitCliConfig;
+};
+export declare function runDevGrid(runtime: Runtime, rawArgs: string[]): void;
+export {};

package/dist/dev-grid.js

@@ -0,0 +1,181 @@
+import { createHash } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { runCommandInherited } from './process.js';
+const WINDOWS_TERMINAL_FRAGMENT_APP_NAME = 'WebToolkit.Cli';
+const WINDOWS_TERMINAL_FRAGMENT_FILE_NAME = 'dev-grid.json';
+function getPowerShellExecutable() {
+    const pwshResult = spawnSync('where.exe', ['pwsh'], { stdio: 'ignore', windowsHide: true });
+    return pwshResult.status === 0 ? 'pwsh' : 'powershell.exe';
+}
+function hasWindowsTerminal() {
+    const result = spawnSync('where.exe', ['wt.exe'], { stdio: 'ignore', windowsHide: true });
+    return result.status === 0;
+}
+function createPaneCommand(command) {
+    return [getPowerShellExecutable(), '-NoLogo', '-NoExit', '-Command', command];
+}
+function createPaneArgs(repoRoot, subcommand, orientation, pane, silent, profileName, size) {
+    const args = [subcommand];
+    if (orientation)
+        args.push(orientation);
+    if (size !== undefined)
+        args.push('--size', String(Number(size.toFixed(6))));
+    if (profileName)
+        args.push('--profile', profileName);
+    args.push('--startingDirectory', repoRoot, '--title', pane.title, '--suppressApplicationTitle', ...createPaneCommand(silent ? pane.silentCommand ?? pane.command : pane.command));
+    return args;
+}
+function getValidatedDevGridRows(rows) {
+    if (!rows.length)
+        throw new Error('devGrid.layout.rows is not configured.');
+    for (const [rowIndex, row] of rows.entries()) {
+        if (!row.panes.length)
+            throw new Error(`devGrid.layout.rows[${rowIndex}].panes is not configured.`);
+        for (const pane of row.panes) {
+            if (pane.fontSize === undefined)
+                continue;
+            if (!Number.isInteger(pane.fontSize) || pane.fontSize <= 0) {
+                throw new Error(`devGrid pane "${pane.title}" has invalid fontSize ${String(pane.fontSize)}. Use a positive integer.`);
+            }
+        }
+    }
+    return rows;
+}
+function getWindowsTerminalFragmentFilePath() {
+    const localAppData = process.env.LOCALAPPDATA;
+    if (!localAppData) {
+        throw new Error('LOCALAPPDATA is not defined. Cannot configure Windows Terminal fragment profiles for devGrid.');
+    }
+    return join(localAppData, 'Microsoft', 'Windows Terminal', 'Fragments', WINDOWS_TERMINAL_FRAGMENT_APP_NAME, WINDOWS_TERMINAL_FRAGMENT_FILE_NAME);
+}
+function buildPaneProfileName(repoRoot, pane) {
+    const hash = createHash('sha1')
+        .update(`${repoRoot}\n${pane.title}\n${String(pane.fontSize)}`)
+        .digest('hex')
+        .slice(0, 12);
+    return `WebToolkit Dev Grid ${hash}`;
+}
+function preparePaneProfiles(repoRoot, panes) {
+    const panesWithFontSize = panes.filter((pane) => pane.fontSize !== undefined);
+    if (!panesWithFontSize.length)
+        return new Map();
+    const fragmentFilePath = getWindowsTerminalFragmentFilePath();
+    mkdirSync(dirname(fragmentFilePath), { recursive: true });
+    const profiles = panesWithFontSize.map((pane) => ({
+        name: buildPaneProfileName(repoRoot, pane),
+        hidden: true,
+        commandline: getPowerShellExecutable(),
+        fontSize: pane.fontSize,
+    }));
+    writeFileSync(fragmentFilePath, `${JSON.stringify({ profiles }, null, 2)}\n`, 'utf8');
+    return new Map(profiles.map((profile, index) => [panesWithFontSize[index], profile.name]));
+}
+function createWindowsTerminalCommands(repoRoot, rows, silent, windowName, paneProfiles) {
+    const firstPane = rows[0].panes[0];
+    const commands = [
+        ['--window', windowName, '--maximized', ...createPaneArgs(repoRoot, 'new-tab', null, firstPane, silent, paneProfiles.get(firstPane))],
+    ];
+    for (let rowIndex = 1; rowIndex < rows.length; rowIndex += 1) {
+        const pane = rows[rowIndex].panes[0];
+        const remainingRows = rows.length - rowIndex;
+        commands.push([
+            '--window',
+            windowName,
+            ...createPaneArgs(repoRoot, 'split-pane', '--horizontal', pane, silent, paneProfiles.get(pane), remainingRows / (remainingRows + 1)),
+        ]);
+    }
+    if (rows.length > 1)
+        commands.push(['--window', windowName, 'move-focus', 'first']);
+    for (const [rowIndex, row] of rows.entries()) {
+        for (let paneIndex = 1; paneIndex < row.panes.length; paneIndex += 1) {
+            const pane = row.panes[paneIndex];
+            const remainingPanes = row.panes.length - paneIndex;
+            commands.push([
+                '--window',
+                windowName,
+                ...createPaneArgs(repoRoot, 'split-pane', '--vertical', pane, silent, paneProfiles.get(pane), remainingPanes / (remainingPanes + 1)),
+            ]);
+        }
+        if (rowIndex < rows.length - 1)
+            commands.push(['--window', windowName, 'move-focus', 'down']);
+    }
+    return commands;
+}
+function runStep(runtime, step) {
+    if (!step.command) {
+        throw new Error(`Dev grid step "${step.label}" must define command.`);
+    }
+    const code = runCommandInherited({
+        command: step.command,
+        args: step.args ?? [],
+        cwd: step.cwd,
+        env: step.env,
+    }, runtime.cwd);
+    if (code !== 0)
+        process.exit(code);
+}
+function runFallback(runtime, script, reason, dryRun) {
+    const normalizedScript = normalizeFallbackScript(script);
+    if (dryRun) {
+        process.stdout.write(`${JSON.stringify({ executable: runtime.config.packageManager, args: ['run', normalizedScript], reason }, null, 2)}\n`);
+        process.exit(0);
+    }
+    process.stderr.write(`${reason} Falling back to \`${runtime.config.packageManager} run ${normalizedScript}\`.\n`);
+    const executable = process.platform === 'win32' ? `${runtime.config.packageManager}.cmd` : runtime.config.packageManager;
+    const result = spawnSync(executable, ['run', normalizedScript], { cwd: runtime.cwd, stdio: 'inherit' });
+    if (result.error)
+        throw result.error;
+    process.exit(result.status ?? 1);
+}
+function normalizeFallbackScript(script) {
+    const normalized = script.trim().replace(/\s+/gu, ' ');
+    const match = normalized.match(/^(?:npm|pnpm|yarn) run (.+)$/u);
+    return match ? match[1] : normalized;
+}
+function sleep(milliseconds) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
+}
+export function runDevGrid(runtime, rawArgs) {
+    const config = runtime.config.devGrid;
+    if (!config?.layout?.rows?.length)
+        throw new Error('devGrid.layout.rows is not configured.');
+    const rows = getValidatedDevGridRows(config.layout.rows);
+    const panes = rows.flatMap((row) => row.panes);
+    const silent = rawArgs.includes('--silent');
+    const dryRun = rawArgs.includes('--dry-run');
+    const fallbackScript = silent ? config.silentFallbackScript ?? config.fallbackScript : config.fallbackScript;
+    if (process.platform !== 'win32') {
+        if (!fallbackScript)
+            throw new Error('Windows Terminal grid is unavailable and no devGrid.fallbackScript is configured.');
+        runFallback(runtime, fallbackScript, 'Windows Terminal grid is unavailable on this platform.', dryRun);
+        return;
+    }
+    if (!dryRun && config.preflightCommand)
+        runStep(runtime, config.preflightCommand);
+    if (!hasWindowsTerminal()) {
+        if (!fallbackScript)
+            throw new Error('Windows Terminal (`wt.exe`) is unavailable and no devGrid.fallbackScript is configured.');
+        runFallback(runtime, fallbackScript, 'Windows Terminal (`wt.exe`) is not available.', dryRun);
+        return;
+    }
+    const windowName = `webtoolkit-dev-grid-${Date.now()}-${process.pid}`;
+    const paneProfiles = preparePaneProfiles(runtime.cwd, panes);
+    const commands = createWindowsTerminalCommands(runtime.cwd, rows, silent, windowName, paneProfiles);
+    if (dryRun) {
+        process.stdout.write(`${JSON.stringify({ executable: 'wt.exe', commands }, null, 2)}\n`);
+        return;
+    }
+    for (const [index, commandArgs] of commands.entries()) {
+        const result = spawnSync('wt.exe', commandArgs, { cwd: runtime.cwd, windowsHide: true, stdio: 'pipe', encoding: 'utf8' });
+        if (result.error)
+            throw result.error;
+        if (result.status !== 0) {
+            const details = result.stderr?.trim() || result.stdout?.trim() || `exit code ${result.status}`;
+            throw new Error(`Windows Terminal command failed: ${details}`);
+        }
+        if (index < commands.length - 1)
+            sleep(250);
+    }
+}

package/dist/dev-watch.d.ts

@@ -0,0 +1,13 @@
+import type { WebToolkitCliConfig } from './config.js';
+type Runtime = {
+    cwd: string;
+    config: WebToolkitCliConfig;
+};
+export declare function resolveDevWatchSpawnSpec(command: string, commandArgs: string[]): {
+    command: string;
+    args: string[];
+    detached: boolean;
+};
+export declare function parseWindowsNetstatListeningPids(output: string, port: number): number[];
+export declare function runDevWatch(runtime: Runtime, rawArgs: string[]): Promise<void>;
+export {};