@vistagenic/vista 0.3.6 → 0.3.8

package/dist/deploy/utils.js

@@ -134,23 +134,33 @@ function flattenPrerenderedFlight(pagesDir, targetDir) {
         fs_1.default.copyFileSync(absolutePath, dest);
     });
 }
-function writeStaticRscRedirects(targetDir) {
+function writeStaticRscRedirects(pagesDir, targetDir) {
     const redirectsPath = path_1.default.join(targetDir, '_redirects');
     const lines = [
         '/rsc /rsc/index.rsc 200',
         '/rsc/ /rsc/index.rsc 200',
-        '/rsc/*.rsc /rsc/:splat.rsc 200',
-        '/rsc/* /rsc/:splat.rsc 200',
     ];
+    walkFiles(pagesDir, (_absolutePath, relativePath) => {
+        const posix = relativePath.replace(/\\/g, '/');
+        if (!posix.endsWith('.rsc'))
+            return;
+        const routePath = posix.replace(/\.rsc$/, '');
+        const flightPath = `/rsc/${posix}`;
+        lines.push(`${flightPath} ${flightPath} 200`);
+        if (routePath === 'index')
+            return;
+        lines.push(`/rsc/${routePath} ${flightPath} 200`);
+    });
     fs_1.default.writeFileSync(redirectsPath, `${lines.join('\n')}\n`, 'utf8');
 }
 /** Copy webpack assets to `/_vista/static` and flatten HTML + Flight for file-based CDNs. */
 function prepareStaticCdnOutput(targetDir) {
     const staticDir = path_1.default.join(targetDir, 'static');
+    const pagesDir = path_1.default.join(staticDir, 'pages');
     copyDirectoryRecursive(staticDir, path_1.default.join(targetDir, '_vista', 'static'));
-    flattenPrerenderedPages(path_1.default.join(staticDir, 'pages'), targetDir);
-    flattenPrerenderedFlight(path_1.default.join(staticDir, 'pages'), targetDir);
-    writeStaticRscRedirects(targetDir);
+    flattenPrerenderedPages(pagesDir, targetDir);
+    flattenPrerenderedFlight(pagesDir, targetDir);
+    writeStaticRscRedirects(pagesDir, targetDir);
 }
 function copyStaticHostAssets(cwd, vistaDir, targetDir) {
     copyDirectoryRecursive(path_1.default.join(cwd, 'public'), targetDir);

package/dist/flashpack/command.d.ts

@@ -3,6 +3,7 @@ interface RunFlashpackCommandOptions {
     cwd?: string;
     port?: string | number;
     strict?: boolean;
+    action?: 'prepare' | 'run';
 }
 export declare function runFlashpackEngineCommand(phase: FlashpackCommandPhase, options?: RunFlashpackCommandOptions): Promise<void>;
 export default runFlashpackEngineCommand;

package/dist/flashpack/command.js

@@ -4,10 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runFlashpackEngineCommand = runFlashpackEngineCommand;
-const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
-const build_rsc_1 = require("../bin/build-rsc");
-const rsc_engine_1 = require("../server/rsc-engine");
+const fs_1 = __importDefault(require("fs"));
+const module_1 = require("module");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const dev_client_runtime_1 = require("../bin/dev-client-runtime");
 const spawn_permissions_1 = require("../server/spawn-permissions");
 const runtime_1 = require("./runtime");
 function resolveMode(phase) {
@@ -16,70 +18,47 @@ function resolveMode(phase) {
     }
     return process.env.NODE_ENV === 'development' ? 'development' : 'production';
 }
-function getRunnerPath() {
-    return path_1.default.resolve(__dirname, '..', 'bin', 'flashpack-runner.js');
-}
 function formatRustFailure(message) {
     return `[flashpack] Rust command unavailable: ${message}`;
 }
-async function fallbackToCore(phase, port) {
-    const normalizedPort = Number(port || process.env.PORT || 3003) || 3003;
-    process.env.VISTA_ENGINE = 'flashpack';
-    process.env.VISTA_ENGINE_VARIANT = 'flashpack';
-    process.env.VISTA_FLASHPACK = 'true';
-    process.env.VISTA_FLASHPACK_PIPELINE = 'js-fallback';
-    console.warn(`[flashpack] Using explicit webpack Flight SSR fallback for ${phase} (same inline-Flight contract; not renderToString).`);
-    if (phase === 'build') {
-        await (0, build_rsc_1.buildRSC)(false);
-        return;
+function vistaVersion() {
+    try {
+        const require = (0, module_1.createRequire)(__filename);
+        const pkg = require('../../package.json');
+        return pkg.version || '0.3.8';
     }
-    if (phase === 'dev') {
-        const result = await (0, build_rsc_1.buildRSC)(true);
-        (0, rsc_engine_1.startRSCServer)({
-            port: normalizedPort,
-            compiler: result.clientCompiler,
-        });
-        return;
+    catch {
+        return '0.3.8';
     }
-    (0, rsc_engine_1.startRSCServer)({
-        port: normalizedPort,
-    });
+}
+function installDevClient(cwd) {
+    const file = path_1.default.join(cwd, '.flash', 'dev', 'vista-dev.js');
+    fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+    fs_1.default.writeFileSync(file, (0, dev_client_runtime_1.getSharedDevClientSource)(String(Date.now())));
+}
+function networkHost() {
+    const interfaces = os_1.default.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+        for (const iface of interfaces[name] || []) {
+            if (iface.family === 'IPv4' && !iface.internal)
+                return iface.address;
+        }
+    }
+    return '';
 }
 async function runFlashpackEngineCommand(phase, options = {}) {
     const cwd = options.cwd || process.cwd();
-    const strict = options.strict ?? process.env.VISTA_FLASHPACK_STRICT !== 'false';
     const mode = resolveMode(phase);
-    const runnerPath = getRunnerPath();
     const port = options.port || process.env.PORT || 3003;
-    const prepare = (0, runtime_1.runFlashpackRustCli)({
-        cwd,
-        phase: phase,
-        mode,
-        action: 'prepare',
-    });
-    if (prepare.error || prepare.status !== 0) {
-        if (strict) {
-            throw new Error(formatRustFailure(prepare.error || 'unknown failure'));
-        }
-        await fallbackToCore(phase, port);
-        return;
-    }
-    const workspaceRoot = prepare.workspaceRoot;
-    const cargoCommand = prepare.cargoCommand;
-    if (!workspaceRoot || !cargoCommand) {
-        if (strict) {
-            throw new Error('[flashpack] Rust workspace unavailable for flashpack command.');
-        }
-        await fallbackToCore(phase, port);
-        return;
+    const action = options.action || 'run';
+    const launch = (0, runtime_1.resolveFlashpackLaunch)(cwd);
+    const ssrRunner = action === 'run' ? (0, runtime_1.resolveFlashpackSsrRunner)(cwd) : null;
+    if (action === 'run') {
+        installDevClient(cwd);
     }
     await new Promise((resolve, reject) => {
-        const child = (0, child_process_1.spawn)(cargoCommand, [
-            'run',
-            '-q',
-            '-p',
-            'flashpack-cli',
-            '--',
+        const child = (0, child_process_1.spawn)(launch.command, [
+            ...launch.args,
             '--cwd',
             cwd,
             '--phase',
@@ -87,40 +66,27 @@ async function runFlashpackEngineCommand(phase, options = {}) {
             '--mode',
             mode,
             '--action',
-            'run',
-            '--node',
-            process.execPath,
-            '--runner',
-            runnerPath,
-            '--port',
-            String(port),
+            action,
+            ...(action === 'run' ? ['--port', String(port)] : []),
+            ...(ssrRunner ? ['--ssr-runner', ssrRunner] : []),
         ], {
-            cwd: workspaceRoot,
+            cwd: launch.cwd,
             env: {
                 ...process.env,
                 VISTA_ENGINE: 'flashpack',
                 VISTA_ENGINE_VARIANT: 'flashpack',
                 VISTA_FLASHPACK: 'true',
-                VISTA_FLASHPACK_PIPELINE: 'rust-cli',
+                VISTA_FLASHPACK_PIPELINE: 'rust-swc',
+                VISTA_VERSION: vistaVersion(),
+                VISTA_NETWORK_HOST: networkHost(),
             },
             stdio: 'inherit',
             windowsHide: true,
         });
-        child.once('error', async (error) => {
+        child.once('error', (error) => {
             const message = (0, spawn_permissions_1.isPermissionDeniedSpawnError)(error)
                 ? formatRustFailure(`spawn blocked by environment permissions (${(0, spawn_permissions_1.getErrorMessage)(error)})`)
                 : formatRustFailure((0, spawn_permissions_1.getErrorMessage)(error));
-            if (!strict) {
-                try {
-                    await fallbackToCore(phase, port);
-                    resolve();
-                    return;
-                }
-                catch (fallbackError) {
-                    reject(fallbackError);
-                    return;
-                }
-            }
             reject(new Error(message));
         });
         child.once('exit', (code, signal) => {

package/dist/flashpack/runtime.d.ts

@@ -12,6 +12,17 @@ export interface FlashpackPrepareResult {
     workspaceRoot: string | null;
     graphPath: string;
 }
+export declare function flashpackPlatformTriple(): string;
+export declare function flashpackBinaryName(): string;
+export declare function findBundledFlashpackBinary(startCwd?: string): string | null;
+export declare function resolveFlashpackSsrRunner(startCwd?: string): string | null;
+export interface FlashpackLaunch {
+    command: string;
+    args: string[];
+    cwd: string;
+    source: 'binary' | 'workspace';
+}
+export declare function resolveFlashpackLaunch(startCwd?: string): FlashpackLaunch;
 export declare function findFlashpackWorkspaceRoot(startCwd: string): string | null;
 export declare function bootstrapFlashDirectories(cwd: string): string;
 export declare function resolveCargoCommand(): string;
@@ -36,4 +47,5 @@ export interface FlashpackRustCliResult {
     status: number | null;
 }
 export declare function runFlashpackRustCli(options: FlashpackRustCliOptions): FlashpackRustCliResult;
+export declare function flashpackCratesBound(flashDir: string): boolean;
 export declare function prepareFlashpackRuntime(options: FlashpackPrepareOptions): FlashpackPrepareResult;

package/dist/flashpack/runtime.js

@@ -3,10 +3,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.flashpackPlatformTriple = flashpackPlatformTriple;
+exports.flashpackBinaryName = flashpackBinaryName;
+exports.findBundledFlashpackBinary = findBundledFlashpackBinary;
+exports.resolveFlashpackSsrRunner = resolveFlashpackSsrRunner;
+exports.resolveFlashpackLaunch = resolveFlashpackLaunch;
 exports.findFlashpackWorkspaceRoot = findFlashpackWorkspaceRoot;
 exports.bootstrapFlashDirectories = bootstrapFlashDirectories;
 exports.resolveCargoCommand = resolveCargoCommand;
 exports.runFlashpackRustCli = runFlashpackRustCli;
+exports.flashpackCratesBound = flashpackCratesBound;
 exports.prepareFlashpackRuntime = prepareFlashpackRuntime;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -33,6 +39,86 @@ function removeLegacyFlashArtifacts(cwd, flashDir) {
         fs_1.default.rmSync(legacyPath, { recursive: true, force: true });
     }
 }
+function flashpackPlatformTriple() {
+    return `${process.platform}-${process.arch}`;
+}
+function flashpackBinaryName() {
+    return process.platform === 'win32' ? 'flashpack-cli.exe' : 'flashpack-cli';
+}
+function pushPackageRoot(roots, root) {
+    const resolved = path_1.default.resolve(root);
+    if (!roots.includes(resolved))
+        roots.push(resolved);
+    try {
+        const real = fs_1.default.realpathSync(resolved);
+        if (!roots.includes(real))
+            roots.push(real);
+    }
+    catch {
+        // The package root may not exist at this path.
+    }
+}
+function vistaPackageRoots() {
+    const roots = [];
+    pushPackageRoot(roots, path_1.default.resolve(__dirname, '..', '..'));
+    if (process.argv[1]) {
+        pushPackageRoot(roots, path_1.default.resolve(path_1.default.dirname(process.argv[1]), '..'));
+    }
+    return roots;
+}
+function findBundledFlashpackBinary(startCwd = process.cwd()) {
+    const relative = path_1.default.join('native', flashpackPlatformTriple(), flashpackBinaryName());
+    // Prefer the monorepo package binary over a stale pnpm store copy.
+    const workspaceRoot = findFlashpackWorkspaceRoot(startCwd);
+    const roots = [
+        ...(workspaceRoot ? [path_1.default.join(workspaceRoot, 'packages', 'vista')] : []),
+        ...vistaPackageRoots(),
+    ];
+    for (const root of roots) {
+        const binary = path_1.default.join(root, relative);
+        if (fs_1.default.existsSync(binary))
+            return binary;
+    }
+    return null;
+}
+function resolveFlashpackSsrRunner(startCwd = process.cwd()) {
+    // Prefer the workspace package so newly added bin/*.mjs files (e.g. agent playground)
+    // are visible even when pnpm's store copy is stale.
+    const workspaceRoot = findFlashpackWorkspaceRoot(startCwd);
+    const roots = [
+        ...(workspaceRoot ? [path_1.default.join(workspaceRoot, 'packages', 'vista')] : []),
+        ...vistaPackageRoots(),
+    ];
+    for (const root of roots) {
+        const runner = path_1.default.join(root, 'bin', 'flashpack-ssr.mjs');
+        if (fs_1.default.existsSync(runner))
+            return runner;
+    }
+    return null;
+}
+function resolveFlashpackLaunch(startCwd = process.cwd()) {
+    const fromSource = process.env.VISTA_FLASHPACK_FROM_SOURCE === '1';
+    const binary = findBundledFlashpackBinary(startCwd);
+    if (binary && !fromSource) {
+        return {
+            command: binary,
+            args: [],
+            cwd: startCwd,
+            source: 'binary',
+        };
+    }
+    const workspaceRoot = findFlashpackWorkspaceRoot(startCwd);
+    if (workspaceRoot) {
+        return {
+            command: resolveCargoCommand(),
+            args: ['run', '-q', '-p', 'flashpack-cli', '--'],
+            cwd: workspaceRoot,
+            source: 'workspace',
+        };
+    }
+    throw new Error(`[flashpack] Native binary for ${flashpackPlatformTriple()} is not in this vista package. ` +
+        'The published package ships it under native/<platform>/. Reinstall @vistagenic/vista.');
+}
 function findFlashpackWorkspaceRoot(startCwd) {
     let current = path_1.default.resolve(startCwd);
     while (true) {
@@ -93,13 +179,9 @@ function resolveCargoCommand() {
     }
     return 'cargo';
 }
-function buildRustCliArgs(options, graphPath) {
+function buildRustCliArgs(options, launch) {
     const args = [
-        'run',
-        '-q',
-        '-p',
-        'flashpack-cli',
-        '--',
+        ...launch.args,
         '--cwd',
         options.cwd,
         '--phase',
@@ -122,11 +204,14 @@ function buildRustCliArgs(options, graphPath) {
 }
 function runFlashpackRustCli(options) {
     const flashDir = bootstrapFlashDirectories(options.cwd);
-    const workspaceRoot = findFlashpackWorkspaceRoot(options.cwd);
     const graphPath = path_1.default.join(flashDir, 'graph', `${options.phase}-rust.json`);
     const runtimeManifestPath = path_1.default.join(flashDir, 'runtime', `${options.phase}-manifest.json`);
     const logPath = path_1.default.join(flashDir, 'logs', `${options.phase}-cli.log`);
-    if (!workspaceRoot) {
+    let launch;
+    try {
+        launch = resolveFlashpackLaunch(options.cwd);
+    }
+    catch (error) {
         return {
             flashDir,
             workspaceRoot: null,
@@ -135,20 +220,20 @@ function runFlashpackRustCli(options) {
             logPath,
             graphPath,
             runtimeManifestPath,
-            error: `Rust workspace not found from ${options.cwd}. Expected flashpack/xtask/Cargo.toml in an ancestor directory.`,
+            error: error instanceof Error ? error.message : String(error),
             status: null,
         };
     }
-    const cargoCommand = resolveCargoCommand();
-    const args = buildRustCliArgs(options, graphPath);
-    const result = (0, child_process_1.spawnSync)(cargoCommand, args, {
-        cwd: workspaceRoot,
+    const workspaceRoot = launch.source === 'workspace' ? launch.cwd : findFlashpackWorkspaceRoot(options.cwd);
+    const args = buildRustCliArgs(options, launch);
+    const result = (0, child_process_1.spawnSync)(launch.command, args, {
+        cwd: launch.cwd,
         encoding: 'utf-8',
         stdio: 'pipe',
     });
     const log = [
-        `[flashpack] workspace=${workspaceRoot}`,
-        `[flashpack] command=${cargoCommand} ${args.join(' ')}`,
+        `[flashpack] source=${launch.source}`,
+        `[flashpack] command=${launch.command} ${args.join(' ')}`,
         `[flashpack] status=${result.status ?? 'null'}`,
         `[flashpack] error=${result.error ? result.error.message : ''}`,
         '[flashpack] stdout:',
@@ -160,7 +245,7 @@ function runFlashpackRustCli(options) {
     return {
         flashDir,
         workspaceRoot,
-        cargoCommand,
+        cargoCommand: launch.command,
         args,
         logPath,
         graphPath,
@@ -173,6 +258,18 @@ function runFlashpackRustCli(options) {
         status: result.status ?? null,
     };
 }
+function flashpackCratesBound(flashDir) {
+    try {
+        const parsed = JSON.parse(fs_1.default.readFileSync(path_1.default.join(flashDir, 'pipeline', 'bound.json'), 'utf8'));
+        return (parsed.pipeline === 'flashpack-cli' &&
+            Array.isArray(parsed.crates) &&
+            parsed.crates.includes('flashpack-ecmascript') &&
+            parsed.crates.includes('flashpack-resolve'));
+    }
+    catch {
+        return false;
+    }
+}
 function prepareFlashpackRuntime(options) {
     const { cwd, phase, mode, allowFallback = true } = options;
     const flashDir = bootstrapFlashDirectories(cwd);
@@ -215,12 +312,6 @@ function prepareFlashpackRuntime(options) {
                     errors: nativeScan.errors.length,
                 },
             });
-            return {
-                flashDir,
-                rustPipelineUsed: true,
-                workspaceRoot: null,
-                graphPath: nativeGraphPath,
-            };
         }
     }
     const rustResult = runFlashpackRustCli({
@@ -241,6 +332,17 @@ function prepareFlashpackRuntime(options) {
             graphPath,
         };
     }
+    if (!flashpackCratesBound(flashDir)) {
+        if (!allowFallback) {
+            throw new Error('[flashpack] Rust pipeline did not bind the Flashpack crates.');
+        }
+        return {
+            flashDir,
+            rustPipelineUsed: false,
+            workspaceRoot: rustResult.workspaceRoot,
+            graphPath,
+        };
+    }
     return {
         flashDir,
         rustPipelineUsed: true,

package/dist/metadata/generate.d.ts

@@ -17,6 +17,7 @@ export interface MetadataRendererProps {
 export declare function MetadataRenderer({ metadata, parentTemplate, }: MetadataRendererProps): React.ReactElement;
 /**
  * Converts metadata to HTML string for SSR injection.
+ * Applies title template from merged metadata when parentTemplate is omitted.
  */
 export declare function generateMetadataHtml(metadata: Metadata, parentTemplate?: string): string;
 export default MetadataRenderer;