@vistagenic/vista 0.2.10 → 0.2.13

package/dist/config.js

@@ -3,12 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultConfig = exports.defaultTypedApiConfig = exports.defaultStructureValidationConfig = void 0;
+exports.defaultConfig = exports.defaultCacheComponentsConfig = exports.defaultTypedApiConfig = exports.defaultStructureValidationConfig = void 0;
 exports.resolveStructureValidationConfig = resolveStructureValidationConfig;
+exports.resolveEngineVariant = resolveEngineVariant;
+exports.applyEngineVariantToEnv = applyEngineVariantToEnv;
+exports.resolveAndApplyEngineVariant = resolveAndApplyEngineVariant;
 exports.resolveTypedApiConfig = resolveTypedApiConfig;
+exports.resolveCacheComponentsConfig = resolveCacheComponentsConfig;
 exports.loadConfig = loadConfig;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
+const NodeModule = require('module');
 exports.defaultStructureValidationConfig = {
     enabled: true,
     mode: 'strict',
@@ -21,13 +26,20 @@ exports.defaultTypedApiConfig = {
     serialization: 'json',
     bodySizeLimitBytes: 1024 * 1024,
 };
+exports.defaultCacheComponentsConfig = {
+    enabled: false,
+};
 exports.defaultConfig = {
     images: {},
+    engine: {
+        variant: 'default',
+    },
     validation: {
         structure: { ...exports.defaultStructureValidationConfig },
     },
     experimental: {
         typedApi: { ...exports.defaultTypedApiConfig },
+        cacheComponents: { ...exports.defaultCacheComponentsConfig },
     },
 };
 /**
@@ -39,6 +51,49 @@ function resolveStructureValidationConfig(config) {
         ...(config.validation?.structure ?? {}),
     };
 }
+function normalizeEngineVariant(raw) {
+    const value = String(raw ?? '')
+        .trim()
+        .toLowerCase();
+    if (!value)
+        return undefined;
+    if (value === 'default' || value === 'webpack')
+        return 'default';
+    if (value === 'flashpack')
+        return 'flashpack';
+    return undefined;
+}
+function readEngineVariantFromConfig(config) {
+    if (!config || !config.engine)
+        return undefined;
+    if (typeof config.engine === 'string') {
+        return normalizeEngineVariant(config.engine);
+    }
+    return normalizeEngineVariant(config.engine.variant);
+}
+function readEngineVariantFromEnv(env) {
+    const explicit = normalizeEngineVariant(env.VISTA_ENGINE_VARIANT || env.VISTA_ENGINE);
+    if (explicit)
+        return explicit;
+    if (env.VISTA_FLASHPACK === 'true')
+        return 'flashpack';
+    if (env.VISTA_FLASHPACK === 'false')
+        return 'default';
+    return undefined;
+}
+function resolveEngineVariant(config, env = process.env) {
+    return readEngineVariantFromEnv(env) || readEngineVariantFromConfig(config) || 'default';
+}
+function applyEngineVariantToEnv(variant, env = process.env) {
+    env.VISTA_ENGINE = variant;
+    env.VISTA_ENGINE_VARIANT = variant;
+    env.VISTA_FLASHPACK = variant === 'flashpack' ? 'true' : 'false';
+    return variant;
+}
+function resolveAndApplyEngineVariant(config, env = process.env) {
+    const variant = resolveEngineVariant(config, env);
+    return applyEngineVariantToEnv(variant, env);
+}
 /**
  * Resolve and sanitize experimental typed API config.
  */
@@ -58,10 +113,28 @@ function resolveTypedApiConfig(config) {
         bodySizeLimitBytes,
     };
 }
-function mergeConfig(userConfig) {
+function resolveCacheComponentsConfig(config) {
+    const merged = {
+        ...exports.defaultCacheComponentsConfig,
+        ...(config.experimental?.cacheComponents ?? {}),
+    };
     return {
+        enabled: Boolean(merged.enabled),
+    };
+}
+function mergeConfig(userConfig) {
+    const mergedBase = {
         ...exports.defaultConfig,
         ...userConfig,
+    };
+    const resolvedEngineVariant = readEngineVariantFromConfig(userConfig) ||
+        readEngineVariantFromConfig(exports.defaultConfig) ||
+        'default';
+    return {
+        ...mergedBase,
+        engine: {
+            variant: resolvedEngineVariant,
+        },
         images: {
             ...(exports.defaultConfig.images ?? {}),
             ...(userConfig.images ?? {}),
@@ -85,20 +158,48 @@ function mergeConfig(userConfig) {
                 ...exports.defaultTypedApiConfig,
                 ...(userConfig.experimental?.typedApi ?? {}),
             },
+            cacheComponents: {
+                ...exports.defaultCacheComponentsConfig,
+                ...(userConfig.experimental?.cacheComponents ?? {}),
+            },
         },
     };
 }
+function loadBundledConfigModule(configPath, cwd) {
+    const { buildSync } = require('esbuild');
+    const result = buildSync({
+        entryPoints: [configPath],
+        absWorkingDir: cwd,
+        bundle: true,
+        platform: 'node',
+        format: 'cjs',
+        target: ['node20'],
+        write: false,
+        packages: 'external',
+        sourcemap: false,
+        logLevel: 'silent',
+    });
+    const bundledConfig = result.outputFiles?.[0]?.text;
+    if (!bundledConfig) {
+        throw new Error(`Failed to bundle config: ${configPath}`);
+    }
+    const virtualConfigPath = path_1.default.join(path_1.default.dirname(configPath), `.__vista_config_runtime__.${path_1.default.basename(configPath, path_1.default.extname(configPath))}.cjs`);
+    const runtimeModule = new NodeModule(virtualConfigPath, module);
+    runtimeModule.filename = virtualConfigPath;
+    runtimeModule.paths = NodeModule._nodeModulePaths(path_1.default.dirname(configPath));
+    runtimeModule._compile(bundledConfig, virtualConfigPath);
+    return runtimeModule.exports;
+}
 function loadConfig(cwd = process.cwd()) {
     const tsPath = path_1.default.join(cwd, 'vista.config.ts');
     const jsPath = path_1.default.join(cwd, 'vista.config.js');
     try {
         if (fs_1.default.existsSync(tsPath)) {
-            // We assume ts-node is registered by engine or bin
-            const mod = require(tsPath);
+            const mod = loadBundledConfigModule(tsPath, cwd);
             return mergeConfig(mod.default || mod);
         }
         else if (fs_1.default.existsSync(jsPath)) {
-            const mod = require(jsPath);
+            const mod = loadBundledConfigModule(jsPath, cwd);
             return mergeConfig(mod.default || mod);
         }
     }

package/dist/constants.d.ts

@@ -8,6 +8,8 @@
 export declare const FRAMEWORK_NAME = "vista";
 /** Hidden build output directory name */
 export declare const BUILD_DIR = ".vista";
+/** Flashpack workspace/runtime directory name */
+export declare const FLASH_DIR = ".flash";
 /** Base URL prefix for all framework-served assets */
 export declare const URL_PREFIX = "/_vista";
 /** Static chunks URL path */

package/dist/constants.js

@@ -6,7 +6,7 @@
  * only this file (and the Rust equivalent naming.rs) needs to change.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LOG_IGNORE_PREFIXES = exports.LOCAL_FONT_PREFIX = exports.MOUNT_ID_PREFIX = exports.THEME_SETTER = exports.WRAPPED_MARKER = exports.CLIENT_COMPONENTS_FLAG = exports.CLIENT_MANIFEST_FLAG = exports.SERVER_DEFINE = exports.BUILD_ID_DEFINE = exports.RSC_DATA_FLAG = exports.CLIENT_REFS_FLAG = exports.CONFIG_FLAG = exports.HYDRATE_DOCUMENT_FLAG = exports.STRUCTURE_ENDPOINT = exports.SSE_ENDPOINT = exports.IMAGE_ENDPOINT = exports.STATIC_CHUNKS_PATH = exports.URL_PREFIX = exports.BUILD_DIR = exports.FRAMEWORK_NAME = void 0;
+exports.LOG_IGNORE_PREFIXES = exports.LOCAL_FONT_PREFIX = exports.MOUNT_ID_PREFIX = exports.THEME_SETTER = exports.WRAPPED_MARKER = exports.CLIENT_COMPONENTS_FLAG = exports.CLIENT_MANIFEST_FLAG = exports.SERVER_DEFINE = exports.BUILD_ID_DEFINE = exports.RSC_DATA_FLAG = exports.CLIENT_REFS_FLAG = exports.CONFIG_FLAG = exports.HYDRATE_DOCUMENT_FLAG = exports.STRUCTURE_ENDPOINT = exports.SSE_ENDPOINT = exports.IMAGE_ENDPOINT = exports.STATIC_CHUNKS_PATH = exports.URL_PREFIX = exports.FLASH_DIR = exports.BUILD_DIR = exports.FRAMEWORK_NAME = void 0;
 // ============================================================================
 // Framework Identity
 // ============================================================================
@@ -17,6 +17,8 @@ exports.FRAMEWORK_NAME = 'vista';
 // ============================================================================
 /** Hidden build output directory name */
 exports.BUILD_DIR = '.vista';
+/** Flashpack workspace/runtime directory name */
+exports.FLASH_DIR = '.flash';
 // ============================================================================
 // URL Prefixes (/_vista/ — equivalent to Next.js /_next/)
 // ============================================================================

package/dist/flashpack/command.d.ts

@@ -0,0 +1,8 @@
+type FlashpackCommandPhase = 'dev' | 'build' | 'start';
+interface RunFlashpackCommandOptions {
+    cwd?: string;
+    port?: string | number;
+    strict?: boolean;
+}
+export declare function runFlashpackEngineCommand(phase: FlashpackCommandPhase, options?: RunFlashpackCommandOptions): Promise<void>;
+export default runFlashpackEngineCommand;

package/dist/flashpack/command.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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 spawn_permissions_1 = require("../server/spawn-permissions");
+const runtime_1 = require("./runtime");
+function resolveMode(phase) {
+    if (phase === 'dev') {
+        return 'development';
+    }
+    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';
+    if (phase === 'build') {
+        await (0, build_rsc_1.buildRSC)(false);
+        return;
+    }
+    if (phase === 'dev') {
+        const result = await (0, build_rsc_1.buildRSC)(true);
+        (0, rsc_engine_1.startRSCServer)({
+            port: normalizedPort,
+            compiler: result.clientCompiler,
+        });
+        return;
+    }
+    (0, rsc_engine_1.startRSCServer)({
+        port: normalizedPort,
+    });
+}
+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;
+    }
+    await new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(cargoCommand, [
+            'run',
+            '-q',
+            '-p',
+            'flashpack-cli',
+            '--',
+            '--cwd',
+            cwd,
+            '--phase',
+            phase,
+            '--mode',
+            mode,
+            '--action',
+            'run',
+            '--node',
+            process.execPath,
+            '--runner',
+            runnerPath,
+            '--port',
+            String(port),
+        ], {
+            cwd: workspaceRoot,
+            env: {
+                ...process.env,
+                VISTA_ENGINE: 'flashpack',
+                VISTA_ENGINE_VARIANT: 'flashpack',
+                VISTA_FLASHPACK: 'true',
+                VISTA_FLASHPACK_PIPELINE: 'rust-cli',
+            },
+            stdio: 'inherit',
+            windowsHide: true,
+        });
+        child.once('error', async (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) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`[flashpack] Rust command failed for ${phase} (code=${code}, signal=${signal || 'none'})`));
+        });
+    });
+}
+exports.default = runFlashpackEngineCommand;

package/dist/flashpack/runtime.d.ts

@@ -0,0 +1,39 @@
+export type FlashpackPhase = 'dev' | 'build' | 'start';
+export type FlashpackMode = 'development' | 'production';
+export interface FlashpackPrepareOptions {
+    cwd: string;
+    phase: FlashpackPhase;
+    mode: FlashpackMode;
+    allowFallback?: boolean;
+}
+export interface FlashpackPrepareResult {
+    flashDir: string;
+    rustPipelineUsed: boolean;
+    workspaceRoot: string | null;
+    graphPath: string;
+}
+export declare function findFlashpackWorkspaceRoot(startCwd: string): string | null;
+export declare function bootstrapFlashDirectories(cwd: string): string;
+export declare function resolveCargoCommand(): string;
+export interface FlashpackRustCliOptions {
+    cwd: string;
+    phase: FlashpackPhase;
+    mode: FlashpackMode;
+    action?: 'prepare' | 'run';
+    runnerPath?: string;
+    nodeCommand?: string;
+    port?: number | string;
+}
+export interface FlashpackRustCliResult {
+    flashDir: string;
+    workspaceRoot: string | null;
+    cargoCommand: string | null;
+    args: string[];
+    logPath: string;
+    graphPath: string;
+    runtimeManifestPath: string;
+    error?: string;
+    status: number | null;
+}
+export declare function runFlashpackRustCli(options: FlashpackRustCliOptions): FlashpackRustCliResult;
+export declare function prepareFlashpackRuntime(options: FlashpackPrepareOptions): FlashpackPrepareResult;

package/dist/flashpack/runtime.js

@@ -0,0 +1,249 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findFlashpackWorkspaceRoot = findFlashpackWorkspaceRoot;
+exports.bootstrapFlashDirectories = bootstrapFlashDirectories;
+exports.resolveCargoCommand = resolveCargoCommand;
+exports.runFlashpackRustCli = runFlashpackRustCli;
+exports.prepareFlashpackRuntime = prepareFlashpackRuntime;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const constants_1 = require("../constants");
+const native_scanner_1 = require("../build/rsc/native-scanner");
+function ensureDir(absolutePath) {
+    fs_1.default.mkdirSync(absolutePath, { recursive: true });
+}
+function writeJsonFile(absolutePath, payload) {
+    ensureDir(path_1.default.dirname(absolutePath));
+    fs_1.default.writeFileSync(absolutePath, JSON.stringify(payload, null, 2));
+}
+function removeLegacyFlashArtifacts(cwd, flashDir) {
+    for (const legacyPath of [
+        path_1.default.join(cwd, '.turbo'),
+        path_1.default.join(flashDir, 'cache', 'turbo'),
+        path_1.default.join(flashDir, 'turbo'),
+    ]) {
+        if (!fs_1.default.existsSync(legacyPath)) {
+            continue;
+        }
+        fs_1.default.rmSync(legacyPath, { recursive: true, force: true });
+    }
+}
+function findFlashpackWorkspaceRoot(startCwd) {
+    let current = path_1.default.resolve(startCwd);
+    while (true) {
+        const candidate = path_1.default.join(current, 'flashpack', 'xtask', 'Cargo.toml');
+        if (fs_1.default.existsSync(candidate)) {
+            return current;
+        }
+        const parent = path_1.default.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return null;
+}
+function bootstrapFlashDirectories(cwd) {
+    const flashDir = path_1.default.join(cwd, constants_1.FLASH_DIR);
+    removeLegacyFlashArtifacts(cwd, flashDir);
+    const dirs = [
+        flashDir,
+        path_1.default.join(flashDir, 'graph'),
+        path_1.default.join(flashDir, 'logs'),
+        path_1.default.join(flashDir, 'runtime'),
+        path_1.default.join(flashDir, 'state'),
+    ];
+    dirs.forEach(ensureDir);
+    return flashDir;
+}
+function resolveCargoCommand() {
+    if (process.env.CARGO && process.env.CARGO.trim().length > 0) {
+        return process.env.CARGO.trim();
+    }
+    if (process.platform === 'win32') {
+        const whereResult = (0, child_process_1.spawnSync)('where.exe', ['cargo'], {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+        });
+        if (whereResult.status === 0) {
+            const first = String(whereResult.stdout || '')
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .find((line) => line.length > 0);
+            if (first)
+                return first;
+        }
+        return 'cargo.exe';
+    }
+    const whichResult = (0, child_process_1.spawnSync)('which', ['cargo'], {
+        encoding: 'utf-8',
+        stdio: 'pipe',
+    });
+    if (whichResult.status === 0) {
+        const first = String(whichResult.stdout || '')
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .find((line) => line.length > 0);
+        if (first)
+            return first;
+    }
+    return 'cargo';
+}
+function buildRustCliArgs(options, graphPath) {
+    const args = [
+        'run',
+        '-q',
+        '-p',
+        'flashpack-cli',
+        '--',
+        '--cwd',
+        options.cwd,
+        '--phase',
+        options.phase,
+        '--mode',
+        options.mode,
+        '--action',
+        options.action || 'prepare',
+    ];
+    if (options.runnerPath) {
+        args.push('--runner', options.runnerPath);
+    }
+    if (options.nodeCommand) {
+        args.push('--node', options.nodeCommand);
+    }
+    if (options.port !== undefined && options.port !== null && String(options.port).trim().length > 0) {
+        args.push('--port', String(options.port));
+    }
+    return args;
+}
+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) {
+        return {
+            flashDir,
+            workspaceRoot: null,
+            cargoCommand: null,
+            args: [],
+            logPath,
+            graphPath,
+            runtimeManifestPath,
+            error: `Rust workspace not found from ${options.cwd}. Expected flashpack/xtask/Cargo.toml in an ancestor directory.`,
+            status: null,
+        };
+    }
+    const cargoCommand = resolveCargoCommand();
+    const args = buildRustCliArgs(options, graphPath);
+    const result = (0, child_process_1.spawnSync)(cargoCommand, args, {
+        cwd: workspaceRoot,
+        encoding: 'utf-8',
+        stdio: 'pipe',
+    });
+    const log = [
+        `[flashpack] workspace=${workspaceRoot}`,
+        `[flashpack] command=${cargoCommand} ${args.join(' ')}`,
+        `[flashpack] status=${result.status ?? 'null'}`,
+        `[flashpack] error=${result.error ? result.error.message : ''}`,
+        '[flashpack] stdout:',
+        result.stdout || '',
+        '[flashpack] stderr:',
+        result.stderr || '',
+    ].join('\n');
+    fs_1.default.writeFileSync(logPath, log);
+    return {
+        flashDir,
+        workspaceRoot,
+        cargoCommand,
+        args,
+        logPath,
+        graphPath,
+        runtimeManifestPath,
+        error: result.error
+            ? result.error.message
+            : result.status === 0
+                ? undefined
+                : (result.stderr || result.stdout || 'unknown cargo failure').trim(),
+        status: result.status ?? null,
+    };
+}
+function prepareFlashpackRuntime(options) {
+    const { cwd, phase, mode, allowFallback = true } = options;
+    const flashDir = bootstrapFlashDirectories(cwd);
+    const now = new Date().toISOString();
+    const graphPath = path_1.default.join(flashDir, 'graph', `${phase}.json`);
+    writeJsonFile(path_1.default.join(flashDir, 'state', 'latest.json'), {
+        engine: 'flashpack',
+        phase,
+        mode,
+        timestamp: now,
+        cwd,
+    });
+    writeJsonFile(graphPath, {
+        engine: 'flashpack',
+        phase,
+        mode,
+        generatedBy: 'vista-ts-bootstrap',
+        timestamp: now,
+    });
+    const appDir = path_1.default.join(cwd, 'app');
+    if ((0, native_scanner_1.isNativeAvailable)() && fs_1.default.existsSync(appDir)) {
+        const nativeScan = (0, native_scanner_1.scanAppNative)(appDir);
+        if (nativeScan) {
+            const nativeGraphPath = path_1.default.join(flashDir, 'graph', `${phase}-rust.json`);
+            writeJsonFile(nativeGraphPath, {
+                engine: 'flashpack',
+                pipeline: 'rust-napi',
+                phase,
+                mode,
+                timestamp: now,
+                appDir,
+                stats: {
+                    totalFiles: nativeScan.totalFiles,
+                    scanTimeMs: nativeScan.scanTimeMs,
+                    clientComponents: nativeScan.clientComponents.length,
+                    serverComponents: nativeScan.serverComponents.length,
+                    pages: nativeScan.pages.length,
+                    layouts: nativeScan.layouts.length,
+                    apiRoutes: nativeScan.apiRoutes.length,
+                    errors: nativeScan.errors.length,
+                },
+            });
+            return {
+                flashDir,
+                rustPipelineUsed: true,
+                workspaceRoot: null,
+                graphPath: nativeGraphPath,
+            };
+        }
+    }
+    const rustResult = runFlashpackRustCli({
+        cwd,
+        phase,
+        mode,
+        action: 'prepare',
+    });
+    if (rustResult.error || rustResult.status !== 0) {
+        const detail = rustResult.error || 'unknown cargo failure';
+        if (!allowFallback) {
+            throw new Error(`[flashpack] Rust pipeline failed: ${detail}`);
+        }
+        return {
+            flashDir,
+            rustPipelineUsed: false,
+            workspaceRoot: rustResult.workspaceRoot,
+            graphPath,
+        };
+    }
+    return {
+        flashDir,
+        rustPipelineUsed: true,
+        workspaceRoot: rustResult.workspaceRoot,
+        graphPath: rustResult.graphPath,
+    };
+}

package/dist/server/app-router-runtime.d.ts

@@ -0,0 +1,26 @@
+type InterceptionMarker = '(.)' | '(..)' | '(..)(..)' | '(...)';
+export interface MatchedAppModule {
+    filePath: string;
+    params: Record<string, string>;
+    source: 'page' | 'default' | 'interception';
+}
+export interface ParallelSlotMatch extends MatchedAppModule {
+    slotName: string;
+    slotRootDir: string;
+}
+export declare function resolveConventionModule(dir: string, stem: string): string | null;
+export declare function parseInterceptionSegment(segment: string): {
+    marker: InterceptionMarker;
+    target: string;
+} | null;
+export declare function isInterceptionRouteSegment(segment: string): boolean;
+export declare function isRouteGroupSegment(segment: string): boolean;
+export declare function isParallelRouteSegment(segment: string): boolean;
+export declare function resolveParallelSlotMatches(input: {
+    appDir: string;
+    layoutPath: string;
+    pathname: string;
+}): ParallelSlotMatch[];
+export declare function resolveDirectoryChain(rootDir: string, entryFilePath: string): string[];
+export declare function resolveNearestSegmentNotFoundPath(appDir: string, startDir: string): string | null;
+export {};