@vistagenic/vista 0.3.5 → 0.3.8

package/bin/flashpack-ssr.mjs

@@ -0,0 +1,81 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire, register } from 'node:module';
+import { pathToFileURL } from 'node:url';
+
+function readArg(name) {
+  const index = process.argv.indexOf(name);
+  if (index === -1 || index + 1 >= process.argv.length) return '';
+  return process.argv[index + 1];
+}
+
+const cwd = path.resolve(readArg('--cwd') || process.cwd());
+const requestPath = readArg('--path') || '/';
+const modulesDir = path.join(cwd, '.flash', 'dev', 'modules');
+const shimsDir = path.join(cwd, '.flash', 'dev', 'ssr');
+
+const registered = register(new URL('./flashpack-ssr-loader.mjs', import.meta.url), {
+  parentURL: import.meta.url,
+  data: { modulesDir, shimsDir },
+});
+if (registered && typeof registered.then === 'function') {
+  await registered;
+}
+
+function moduleFile(relativePath) {
+  const file = path.join(modulesDir, ...relativePath.split('/'));
+  return fs.existsSync(file) ? file : null;
+}
+
+const appRequire = createRequire(path.join(cwd, 'package.json'));
+const { createElement } = appRequire('react');
+const { renderToReadableStream } = appRequire('react-dom/server');
+
+const rootFile = moduleFile('app/root.tsx.js') || moduleFile('app/root.jsx.js');
+if (!rootFile) {
+  throw new Error('flashpack ssr: app/root was not compiled');
+}
+
+const pathname = requestPath.replace(/\/$/, '') || '/';
+let pageFile = null;
+let pageProps = {};
+let layoutFile = null;
+
+if (pathname === '/docs' || pathname.startsWith('/docs/')) {
+  layoutFile = moduleFile('app/docs/layout.tsx.js');
+  if (pathname === '/docs') {
+    pageFile = moduleFile('app/docs/page.tsx.js');
+  } else {
+    pageFile = moduleFile('app/docs/[...slug]/page.tsx.js');
+    pageProps = { params: { slug: pathname.split('/').filter(Boolean).slice(1) } };
+  }
+}
+
+if (!pageFile) {
+  pageFile =
+    moduleFile('app/index.tsx.js') ||
+    moduleFile('app/index.jsx.js') ||
+    moduleFile('app/page.tsx.js') ||
+    moduleFile('app/page.jsx.js');
+}
+
+if (!pageFile) {
+  throw new Error(`flashpack ssr: no page module for ${pathname}`);
+}
+
+const rootMod = await import(pathToFileURL(rootFile).href);
+const pageMod = await import(pathToFileURL(pageFile).href);
+const Root = rootMod.default;
+const Page = pageMod.default;
+let page = createElement(Page, pageProps);
+if (page && typeof page.then === 'function') {
+  page = await page;
+}
+if (layoutFile) {
+  const layoutMod = await import(pathToFileURL(layoutFile).href);
+  page = createElement(layoutMod.default, { children: page });
+}
+
+const stream = await renderToReadableStream(createElement(Root, { children: page }));
+await stream.allReady;
+process.stdout.write(await new Response(stream).text());

package/bin/flashpack-vendor.mjs

@@ -0,0 +1,97 @@
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const cwd = path.resolve(process.argv[2] || '');
+const spec = process.argv[3] || '';
+const outfile = path.resolve(process.argv[4] || '');
+
+function loadEsbuild() {
+  const bases = [cwd, path.resolve(cwd, '../..'), path.resolve(cwd, '../../..')];
+  for (const base of bases) {
+    try {
+      return createRequire(path.join(base, 'package.json'))('esbuild');
+    } catch {
+      // try the next root
+    }
+  }
+  const pnpm = path.resolve(cwd, '../../node_modules/.pnpm');
+  if (!fs.existsSync(pnpm)) {
+    throw new Error('esbuild is not installed');
+  }
+  const versions = fs.readdirSync(pnpm).filter((name) => name.startsWith('esbuild@')).sort();
+  const version = versions.at(-1);
+  if (!version) throw new Error('esbuild is not installed');
+  return createRequire(path.join(pnpm, version, 'node_modules', 'esbuild', 'package.json'))('esbuild');
+}
+
+function namedExports(specifier) {
+  try {
+    const loaded = createRequire(path.join(cwd, 'package.json'))(specifier);
+    const source = loaded && (typeof loaded === 'object' || typeof loaded === 'function') ? loaded : {};
+    return Object.keys(source).filter(
+      (name) => name !== 'default' && name !== '__esModule' && /^[A-Za-z_$][\w$]*$/.test(name)
+    );
+  } catch {
+    return [];
+  }
+}
+
+const reactGlobals = {
+  react: '__VISTA_REACT__',
+  'react-dom': '__VISTA_REACT_DOM__',
+  'react-dom/client': '__VISTA_REACT_DOM_CLIENT__',
+  'react/jsx-runtime': '__VISTA_JSX__',
+  'react/jsx-dev-runtime': '__VISTA_JSX_DEV__',
+};
+
+function writeReactShim(specifier, file) {
+  const globalName = reactGlobals[specifier];
+  const lines = namedExports(specifier).map(
+    (name) => `export const ${name} = ns[${JSON.stringify(name)}];`
+  );
+  fs.writeFileSync(
+    file,
+    `const ns = window[${JSON.stringify(globalName)}];\n${lines.join('\n')}\nexport default ns;\n`
+  );
+}
+
+const esbuild = loadEsbuild();
+if (reactGlobals[spec]) {
+  fs.mkdirSync(path.dirname(outfile), { recursive: true });
+  writeReactShim(spec, outfile);
+  process.exit(0);
+}
+const exportLines = namedExports(spec).map(
+  (name) => `export const ${name} = namespace[${JSON.stringify(name)}];`
+);
+fs.mkdirSync(path.dirname(outfile), { recursive: true });
+await esbuild.build({
+  absWorkingDir: cwd,
+  stdin: {
+    contents: `import * as namespace from ${JSON.stringify(spec)};\n${exportLines.join('\n')}\nexport default namespace.default ?? namespace;\n`,
+    resolveDir: cwd,
+    sourcefile: 'flashpack-vendor.js',
+  },
+  bundle: true,
+  format: 'esm',
+  platform: 'browser',
+  target: ['es2022'],
+  outfile,
+  logLevel: 'silent',
+  define: {
+    'process.env.NODE_ENV': '"development"',
+  },
+  mainFields: ['browser', 'module', 'main'],
+  plugins: [
+    {
+      name: 'vista-shared-react',
+      setup(build) {
+        build.onResolve({ filter: /^react($|\/)|^react-dom($|\/)/ }, (args) => {
+          if (!Object.prototype.hasOwnProperty.call(reactGlobals, args.path)) return null;
+          return { path: `/_flashpack/mod/${args.path}`, external: true };
+        });
+      },
+    },
+  ],
+});

package/bin/vista.js

@@ -86,11 +86,23 @@ if (
   process.exit(1);
 }
 
+function readPackageEngine(cwd) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+    const vista = pkg && pkg.vista;
+    const raw = typeof vista === 'string' ? vista : vista && vista.engine;
+    return normalizeEngineVariant(raw);
+  } catch {
+    return null;
+  }
+}
+
 const envEngineVariant = normalizeEngineVariant(
   process.env.VISTA_ENGINE_VARIANT ||
     process.env.VISTA_ENGINE ||
     (process.env.VISTA_FLASHPACK === 'true' ? 'flashpack' : '')
 );
+const packageEngineVariant = readPackageEngine(process.cwd());
 
 let configEngineVariant = null;
 try {
@@ -108,7 +120,7 @@ try {
 }
 
 const forcedByFlag = explicitEngineVariant || (explicitFlashpack ? 'flashpack' : null) || (explicitDefaultEngine ? 'default' : null);
-const engineVariant = forcedByFlag || envEngineVariant || configEngineVariant || 'default';
+const engineVariant = forcedByFlag || envEngineVariant || packageEngineVariant || configEngineVariant || 'default';
 process.env.VISTA_ENGINE = engineVariant;
 process.env.VISTA_ENGINE_VARIANT = engineVariant;
 process.env.VISTA_FLASHPACK = engineVariant === 'flashpack' ? 'true' : 'false';
@@ -117,21 +129,7 @@ process.env.VISTA_FLASHPACK = engineVariant === 'flashpack' ? 'true' : 'false';
 const { markStartTime } = require('../dist/server/logger');
 markStartTime();
 
-if (command === 'dev') {
-  forceRuntimeEnv('development');
-  console.log(`[vista] Engine: ${process.env.VISTA_ENGINE}`);
-  const useFlashpack = process.env.VISTA_ENGINE === 'flashpack';
-  if (useFlashpack) {
-    const { runFlashpackEngineCommand } = require('../dist/flashpack/command');
-    runFlashpackEngineCommand('dev', {
-      cwd: process.cwd(),
-      port: process.env.PORT || 3003,
-    }).catch((err) => {
-      console.error('Flashpack dev failed:', err);
-      process.exit(1);
-    });
-    return;
-  }
+function startFlightDev() {
   const { buildRSC } = require('../dist/bin/build-rsc');
   const { startRSCServer } = require('../dist/server/rsc-engine');
 
@@ -146,25 +144,26 @@ if (command === 'dev') {
       console.error('RSC Build failed:', err);
       process.exit(1);
     });
-} else if (command === 'build') {
-  forceRuntimeEnv('production');
-  console.log(`[vista] Engine: ${process.env.VISTA_ENGINE}`);
-  const useFlashpack = process.env.VISTA_ENGINE === 'flashpack';
-  if (useFlashpack) {
+}
+
+if (command === 'dev') {
+  forceRuntimeEnv('development');
+  if (process.env.VISTA_ENGINE === 'flashpack') {
     const { runFlashpackEngineCommand } = require('../dist/flashpack/command');
-    runFlashpackEngineCommand('build', {
+    runFlashpackEngineCommand('dev', {
       cwd: process.cwd(),
-    })
-      .then(() => {
-        console.log('');
-        console.log('Production build complete!');
-      })
-      .catch((err) => {
-        console.error('Flashpack build failed:', err);
-        process.exit(1);
-      });
+      action: 'run',
+      port: process.env.PORT || 3003,
+    }).catch((err) => {
+      console.error('Flashpack dev failed:', err);
+      process.exit(1);
+    });
     return;
   }
+  startFlightDev();
+} else if (command === 'build') {
+  forceRuntimeEnv('production');
+  console.log(`[vista] Engine: ${process.env.VISTA_ENGINE}`);
   const { buildRSC } = require('../dist/bin/build-rsc');
 
   buildRSC(false)
@@ -176,20 +175,32 @@ if (command === 'dev') {
       console.error('RSC Build failed:', err);
       process.exit(1);
     });
-} else if (command === 'start') {
-  forceRuntimeEnv('production');
-  console.log(`[vista] Engine: ${process.env.VISTA_ENGINE}`);
-  if (process.env.VISTA_ENGINE === 'flashpack') {
-    const { runFlashpackEngineCommand } = require('../dist/flashpack/command');
-    runFlashpackEngineCommand('start', {
+} else if (command === 'bind') {
+  const rust = require('../dist/rust');
+  const route = getFlagValue('--route') || '(shop)/products/[id]';
+  const folders = route.split('/').filter((part) => part.length > 0);
+  console.log(`[vista] rust native=${rust.nativeBindingsLoaded()}`);
+  for (const folder of folders) {
+    const classified = rust.classifyAppSegment(folder);
+    console.log(`[vista] ${folder} -> ${classified.kind} (${classified.segment})`);
+  }
+  console.log(`[vista] pattern ${rust.routePattern(folders)}`);
+  console.log(`[vista] error ${rust.encodeVistaErrorCode('ROUTE_MISSING')}`);
+  console.log(`[vista] taskless ${rust.tasklessSteps(true).join(' -> ')}`);
+  if (engineVariant === 'flashpack') {
+    const { prepareFlashpackRuntime } = require('../dist/flashpack/runtime');
+    const prepared = prepareFlashpackRuntime({
       cwd: process.cwd(),
-      port: process.env.PORT || 3003,
-    }).catch((err) => {
-      console.error('Flashpack start failed:', err);
-      process.exit(1);
+      phase: 'build',
+      mode: 'production',
+      allowFallback: true,
     });
-    return;
+    console.log(`[vista] flashpack crates bound=${prepared.rustPipelineUsed}`);
+    if (!prepared.rustPipelineUsed) process.exit(1);
   }
+} else if (command === 'start') {
+  forceRuntimeEnv('production');
+  console.log(`[vista] Engine: ${process.env.VISTA_ENGINE}`);
   const standaloneServerPath = path.join(process.cwd(), '.vista', 'standalone', 'server.js');
   if (fs.existsSync(standaloneServerPath)) {
     const standalone = require(standaloneServerPath);
@@ -216,6 +227,7 @@ if (command === 'dev') {
   console.log('  start   Start production server');
   console.log('  deploy  Build and deploy to a hosting platform');
   console.log('  g       Generate typed API scaffolds (api-init, router, procedure)');
+  console.log('  bind    Classify a route and, with --flashpack, bind the Rust crates');
   console.log('');
   console.log('Options:');
   console.log('  --engine <default|flashpack>   Select engine variant');
@@ -230,5 +242,7 @@ if (command === 'dev') {
   console.log('  vista dev --flashpack   # Start dev server with Flashpack mode');
   console.log('  vista build          # Production Flight RSC/SSR build');
   console.log('  vista g api-init     # Generate typed API starter files');
+  console.log('  vista bind --route "(shop)/products/[id]"');
+  console.log('  vista bind --flashpack');
   console.log('');
 }

package/dist/ai/providers/base.js

@@ -75,11 +75,17 @@ function resolveModel(model, options = {}) {
                 baseURL: options.baseURL || process.env.GROQ_BASE_URL || 'https://api.groq.com/openai/v1',
                 apiKey: options.apiKey || process.env.GROQ_API_KEY || '',
             });
+        case 'openrouter':
+            return (0, openai_1.createOpenAIModel)({
+                ...modelOptions,
+                baseURL: options.baseURL || process.env.OPENROUTER_BASE_URL || 'https://openrouter.ai/api/v1',
+                apiKey: options.apiKey || process.env.OPENROUTER_API_KEY || '',
+            });
         case 'mock':
             return (0, mock_1.createMockModel)({
                 modelName,
             });
         default:
-            throw new Error(`Unsupported model provider "${provider}". Supported providers: openai, anthropic, gemini, ollama, nvidia, groq, mock.`);
+            throw new Error(`Unsupported model provider "${provider}". Supported providers: openai, anthropic, gemini, ollama, nvidia, groq, openrouter, mock.`);
     }
 }

package/dist/bin/build-rsc.js

@@ -23,6 +23,7 @@ const server_manifest_1 = require("../build/rsc/server-manifest");
 const file_scanner_1 = require("./file-scanner");
 const config_1 = require("../config");
 const constants_1 = require("../constants");
+const runtime_1 = require("../flashpack/runtime");
 const structure_validator_1 = require("../server/structure-validator");
 const static_generator_1 = require("../server/static-generator");
 const structure_log_1 = require("../server/structure-log");
@@ -383,6 +384,21 @@ async function buildRSC(watch = false) {
     }
     if (_debug)
         console.log(`[vista:build] Engine variant: ${engineVariant}`);
+    if (engineVariant === 'flashpack') {
+        const prepared = (0, runtime_1.prepareFlashpackRuntime)({
+            cwd,
+            phase: watch ? 'dev' : 'build',
+            mode: watch ? 'development' : 'production',
+            allowFallback: process.env.VISTA_FLASHPACK_STRICT !== 'true',
+        });
+        if (!prepared.rustPipelineUsed) {
+            const message = '[vista] Flashpack crates were not bound. Run `vista bind --flashpack` after the Rust CLI is available.';
+            if (process.env.VISTA_FLASHPACK_STRICT === 'true') {
+                throw new Error(message);
+            }
+            console.warn(message);
+        }
+    }
     if (structureConfig.enabled) {
         const result = (0, structure_validator_1.validateAppStructure)({ cwd });
         (0, structure_log_1.logValidationResult)(result, structureConfig.logLevel);

package/dist/bin/build.js

@@ -44,19 +44,25 @@ function runPostCSS(cwd, vistaDir) {
         }
     }
 }
+function urlSegmentForNode(node) {
+    if (!node.segment)
+        return null;
+    if (node.kind === 'group' || node.kind === 'parallel' || node.kind === 'interception') {
+        return null;
+    }
+    if (node.kind === 'dynamic')
+        return `:${node.segment}`;
+    if (node.kind === 'catch-all')
+        return `:${node.segment}*`;
+    if (node.kind === 'optional-catch-all')
+        return `:${node.segment}*?`;
+    return node.segment;
+}
 function collectRouteArtifactEntries(node, segments = [], entries = []) {
     const nextSegments = [...segments];
-    if (node.segment) {
-        if (node.kind === 'dynamic') {
-            nextSegments.push(`:${node.segment}`);
-        }
-        else if (node.kind === 'catch-all') {
-            nextSegments.push(`:${node.segment}*`);
-        }
-        else if (node.kind !== 'group') {
-            nextSegments.push(node.segment);
-        }
-    }
+    const urlPiece = urlSegmentForNode(node);
+    if (urlPiece)
+        nextSegments.push(urlPiece);
     if (node.indexPath) {
         const pattern = nextSegments.length === 0 ? '/' : `/${nextSegments.join('/')}`;
         const type = pattern.includes('*')

package/dist/bin/deploy.js

@@ -26,6 +26,7 @@ function printHelp() {
     console.log('');
     console.log('Options:');
     console.log('  --target <auto|render|vercel|cloudflare|netlify|docker>');
+    console.log('  --output <standalone|static|hybrid>');
     console.log('  --prod                 Production deploy (default)');
     console.log('  --preview              Preview/staging deploy');
     console.log('  --dry-run              Build + emit + validate only');
@@ -64,6 +65,11 @@ async function runDeployCommand(flags, options = {}) {
         (options.error ?? console.error)(`[vista:deploy] Unsupported target "${target}". Use one of: ${(0, deploy_1.listKnownTargets)().join(', ')}`);
         return 1;
     }
+    const output = getFlagValue(flags, '--output');
+    if (output && !['standalone', 'static', 'hybrid'].includes(output)) {
+        (options.error ?? console.error)(`[vista:deploy] Unsupported output "${output}". Use one of: standalone, static, hybrid`);
+        return 1;
+    }
     const cwd = options.cwd ?? process.cwd();
     const dryRun = flags.includes('--dry-run');
     const skipBuild = flags.includes('--skip-build');
@@ -78,6 +84,7 @@ async function runDeployCommand(flags, options = {}) {
         const result = await (0, deploy_1.runDeploy)({
             cwd,
             target,
+            output: output,
             dryRun,
             skipBuild,
             prod,

package/dist/bin/dev-client-runtime.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The same development client the default engine injects:
+ * devtools indicator, error overlay, and runtime error reporting.
+ * Flashpack serves this file instead of keeping a second error UI.
+ */
+export declare function getSharedDevClientSource(bootSessionId: string): string;

package/dist/bin/dev-client-runtime.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSharedDevClientSource = getSharedDevClientSource;
+const dev_error_overlay_snippet_1 = require("./dev-error-overlay-snippet");
+const devtools_indicator_snippet_1 = require("./devtools-indicator-snippet");
+/**
+ * The same development client the default engine injects:
+ * devtools indicator, error overlay, and runtime error reporting.
+ * Flashpack serves this file instead of keeping a second error UI.
+ */
+function getSharedDevClientSource(bootSessionId) {
+    return `${(0, devtools_indicator_snippet_1.getDevToolsIndicatorBootstrapSource)(bootSessionId)}
+${(0, dev_error_overlay_snippet_1.getDevErrorOverlayBootstrapSource)()}
+${sharedRuntimeReporterSource()}
+`;
+}
+function sharedRuntimeReporterSource() {
+    return `
+function buildRuntimeMessage(title, error) {
+  var value = error;
+  var text = '';
+  if (value && typeof value === 'object') {
+    if (typeof value.message === 'string' && value.message.trim().length > 0) {
+      text = value.message;
+    }
+    if (typeof value.stack === 'string' && value.stack.trim().length > 0) {
+      text = text ? text + '\\n\\n' + value.stack : value.stack;
+    }
+    if (!text && typeof value.toString === 'function') {
+      var asString = String(value);
+      if (asString && asString !== '[object Object]') text = asString;
+    }
+  } else if (typeof error === 'string') {
+    text = error;
+  } else if (error != null) {
+    text = String(error);
+  }
+  if (!text || text === 'undefined' || text === 'null') {
+    text = 'Unknown runtime error (no message or stack from the browser).';
+  }
+  if (text.indexOf(title) === 0) return text;
+  return title + '\\n\\n' + text;
+}
+
+function revealBootHold() {
+  try {
+    document.documentElement.setAttribute('data-vista-ready', '');
+  } catch (err) {}
+}
+
+function reportDevRuntimeError(title, error) {
+  if (typeof window === 'undefined') return;
+  revealBootHold();
+  var indicator = window.__VISTA_DEVTOOLS_INDICATOR__;
+  var overlay = window.__VISTA_DEV_ERROR_OVERLAY__;
+  var message = buildRuntimeMessage(title, error);
+  if (indicator && typeof indicator.setError === 'function') {
+    try {
+      if (typeof indicator.ensureAttached === 'function') indicator.ensureAttached();
+    } catch (err) {}
+    indicator.setError(title, 1);
+  }
+  // Always open the overlay for hard runtime failures — capture/minimize alone
+  // leaves a white page when boot never finished painting.
+  if (overlay && typeof overlay.show === 'function') {
+    overlay.show([message]);
+  } else if (overlay && typeof overlay.capture === 'function') {
+    overlay.capture([message]);
+  }
+  if (typeof fetch === 'function') {
+    fetch('/_flashpack/client-error', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ title: title, message: message }),
+    }).catch(function () {});
+  }
+}
+
+if (typeof window !== 'undefined') {
+  window.addEventListener('error', function (event) {
+    reportDevRuntimeError('Runtime Error', event.error || event.message || 'Script error');
+  });
+  window.addEventListener('unhandledrejection', function (event) {
+    reportDevRuntimeError('Unhandled Promise Rejection', event.reason);
+  });
+  var nativeConsoleError = console.error.bind(console);
+  console.error = function () {
+    nativeConsoleError.apply(console, arguments);
+    var text = Array.prototype.map.call(arguments, function (item) {
+      return item && item.stack ? item.stack : String(item);
+    }).join('\\n');
+    if (/data-cursor-ref/.test(text)) return;
+    if (/Hydration|Uncaught|TypeError|ReferenceError/.test(text)) {
+      reportDevRuntimeError('Runtime Error', text);
+    }
+  };
+}
+`;
+}