rastack 0.0.63 → 0.0.69

package/src/rastack-admin.ts

@@ -1,81 +1,29 @@
 #!/usr/bin/env node
 
 /**
- * `rastack admin` — the full, Django-admin-style console, served **in the
- * browser over the prebuilt WebAssembly engine** (exactly like `rastack dev`).
+ * `rastack admin` — the Django-admin-style console, served by the native
+ * `rastack-server` process.
  *
  *   rastack admin [resourcesDir] [--warehouse <dir>] [--port <n>] [--out <dir>] [--no-open]
  *
- * The console is React API Stack's own React admin (`tools/admin`, built from
- * `rastack/components` + `rastack/theme`). This command compiles the resources,
- * then boots a dependency-free static server that hands the browser everything
- * it needs to run the admin locally over WASM — no native server, no cargo:
- *   • the bundled React admin (`/dev/admin.js`), which defaults to `mode:"local"`,
- *   • the prebuilt WASM engine (`/wasm/…`) shipped in the package,
- *   • the compiled `schema.rastack.json` / `openapi.json`,
- *   • the committed Iceberg warehouse (`/data/warehouse/…`) to seed from.
- *
- * The engine is the single prebuilt `.wasm` bundle shipped in the npm package;
- * if it is missing the command errors and points at `rastack update` — it never
- * falls back to a from-source cargo build.
+ * Compiles the resources, then starts `rastack-server admin`. That process is
+ * the API (`rastack-api-core`) and it serves the React bundle at `/admin/`.
+ * The browser renders the console and calls `/api` on that same origin.
+ * The engine does not run in the browser.
  */
 
 import { execFileSync } from "child_process";
 import * as fs from "fs";
-import * as http from "http";
 import * as path from "path";
 import { runCompile } from "./compile";
+import { parseAdminArgs } from "./dev/harness";
 import {
-  WASM_ENTRY,
-  contentType,
-  parseAdminArgs,
-  renderShell,
-  wasmBundleCandidates,
-} from "./dev/harness";
-
-const HERE = __dirname; // dist/ when installed — the bundle lives beside us.
-
-/** Locate the prebuilt wasm bundle dir shipped in the package (no cargo fallback). */
-function resolveWasmDir(): string | null {
-  for (const dir of wasmBundleCandidates(HERE)) {
-    if (fs.existsSync(path.join(dir, WASM_ENTRY))) return dir;
-  }
-  return null;
-}
+  ensureServerBinary,
+  startNativeServer,
+  waitForTcp,
+} from "./dev/native-server";
 
-/** Serve one file if it exists and stays within `root`; else 404/403. */
-function serveUnder(
-  res: http.ServerResponse,
-  root: string,
-  relPath: string,
-): void {
-  const safeRoot = path.resolve(root);
-  const rel = decodeURIComponent(relPath).replace(/^\/+/, "");
-  const target = path.resolve(safeRoot, rel);
-  // Path-traversal guard: the resolved target must stay inside the root.
-  if (target !== safeRoot && !target.startsWith(safeRoot + path.sep)) {
-    res.writeHead(403).end("Forbidden");
-    return;
-  }
-  fs.readFile(target, (err, data) => {
-    if (err) {
-      res.writeHead(404).end("Not found");
-      return;
-    }
-    res.writeHead(200, { "Content-Type": contentType(target) }).end(data);
-  });
-}
-
-/** Serve an exact file (no traversal concern — a fixed internal artifact). */
-function serveFile(res: http.ServerResponse, file: string): void {
-  fs.readFile(file, (err, data) => {
-    if (err) {
-      res.writeHead(404).end("Not found");
-      return;
-    }
-    res.writeHead(200, { "Content-Type": contentType(file) }).end(data);
-  });
-}
+const HERE = __dirname; // dist/ when installed — admin.js lives beside us.
 
 /** Best-effort open the default browser at `url`. */
 function openBrowser(url: string): void {
@@ -92,11 +40,12 @@ function openBrowser(url: string): void {
   }
 }
 
-function main(argv: string[]): void {
+async function main(argv: string[]): Promise<void> {
   const args = parseAdminArgs(argv);
+  const cwd = process.cwd();
 
   console.log(
-    `\n  rastack admin — the database console, built with React API Stack\n`,
+    `\n  rastack admin — the database console, on the native Rust server\n`,
   );
   console.log(`▸ Compiling ${args.resourcesDir} → ${args.outDir}`);
   if (!runCompile(args.resourcesDir, args.outDir)) {
@@ -104,16 +53,6 @@ function main(argv: string[]): void {
     process.exit(1);
   }
 
-  const wasmDir = resolveWasmDir();
-  if (!wasmDir) {
-    console.error(
-      "\n  ✗ No prebuilt WASM engine found in this rastack install.\n" +
-        "    Update rastack to pull the prebuilt bundle:\n" +
-        "      rastack update\n",
-    );
-    process.exit(1);
-  }
-
   const adminBundle = path.join(HERE, "admin.js");
   if (!fs.existsSync(adminBundle)) {
     console.error(
@@ -122,41 +61,61 @@ function main(argv: string[]): void {
     process.exit(1);
   }
 
-  const server = http.createServer((req, res) => {
-    const url = (req.url || "/").split("?")[0];
-    if (req.method !== "GET") {
-      res.writeHead(405).end("Method not allowed");
-      return;
-    }
-    if (url === "/" || url === "/index.html") {
-      res
-        .writeHead(200, { "Content-Type": "text/html; charset=utf-8" })
-        .end(renderShell("React API Stack — admin"));
-      return;
-    }
-    if (url === "/dev/admin.js") return serveFile(res, adminBundle);
-    if (url.startsWith("/wasm/"))
-      return serveUnder(res, wasmDir, url.slice("/wasm/".length));
-    if (url === "/schema.rastack.json" || url === "/openapi.json")
-      return serveUnder(res, args.outDir, path.basename(url));
-    if (url.startsWith("/data/warehouse/"))
-      return serveUnder(
-        res,
-        args.warehouseDir,
-        url.slice("/data/warehouse/".length),
-      );
-    res.writeHead(404).end("Not found");
+  let bin: string;
+  try {
+    bin = ensureServerBinary(cwd);
+  } catch (err) {
+    console.error(`\n${(err as Error).message}\n`);
+    process.exit(1);
+  }
+
+  const manifest = path.resolve(cwd, args.outDir, "schema.rastack.json");
+  const warehouse = path.resolve(cwd, args.warehouseDir);
+  const child = startNativeServer({
+    bin,
+    command: "admin",
+    manifest,
+    warehouse,
+    addr: `127.0.0.1:${args.port}`,
+    adminAssets: HERE,
   });
 
-  server.listen(args.port, () => {
-    const url = `http://localhost:${args.port}`;
-    console.log(`  ✓ WASM engine: ${path.relative(process.cwd(), wasmDir)}`);
-    console.log(`\n  ▸ ${url}\n`);
-    console.log("  Press Ctrl+C to stop.\n");
-    if (args.open) openBrowser(url);
+  const stop = () => {
+    try {
+      child.kill("SIGTERM");
+    } catch {
+      /* already gone */
+    }
+  };
+  process.on("SIGINT", () => {
+    stop();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    stop();
+    process.exit(0);
   });
+
+  try {
+    await waitForTcp(args.port, child);
+  } catch (err) {
+    console.error(`\n${(err as Error).message}\n`);
+    stop();
+    process.exit(1);
+  }
+
+  const url = `http://127.0.0.1:${args.port}/admin/`;
+  console.log(`  ✓ native engine: ${bin}`);
+  console.log(`\n  ▸ ${url}\n`);
+  console.log("  Press Ctrl+C to stop.\n");
+  if (args.open) openBrowser(url);
+
+  child.on("exit", (code) => process.exit(code ?? 0));
 }
 
 if (require.main === module) {
-  main(process.argv.slice(2));
+  main(process.argv.slice(2)).catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
 }

package/src/rastack-bootstrap.ts

@@ -25,11 +25,8 @@
  */
 
 import {
-  BOOTSTRAP_ARTIFACTS_OUTPUT,
-  BOOTSTRAP_TEMPLATES_OUTPUT,
   DeployConfig,
   PartialDeployConfig,
-  bootstrapStackArgs,
   bootstrapStackCommand,
   bootstrapStackName,
   mergeConfig,
@@ -40,12 +37,12 @@ import {
 import {
   ask,
   awsAvailable,
-  awsRun,
+  awsIdentity,
   canPrompt,
+  ensureBootstrapStack,
   gitRemoteUrl,
   loadConfig,
   resolveDeployAsset,
-  stackOutput,
   uploadPlaceholder,
   withPrompt,
 } from "./deploy/io";
@@ -164,47 +161,12 @@ function printPlan(cfg: DeployConfig, reuseOidc: boolean): void {
 }
 
 /**
- * Deploy the bootstrap stack, retrying once against an account that already has
- * a GitHub OIDC provider (AWS allows only one per URL) when the caller did not
- * already ask to reuse it.
+ * Stand the tier-0 bootstrap stack up and upload the Lambda placeholder. The
+ * deploy (with the GitHub-OIDC-reuse retry) and template resolution are shared
+ * with `rastack init` via `ensureBootstrapStack`, so both stand the stack up
+ * identically.
  */
-function deployBootstrap(cfg: DeployConfig, reuseOidc: boolean): void {
-  const template = resolveDeployAsset("bootstrap.yaml");
-  if (!template) {
-    console.error(
-      "  ✗ bootstrap.yaml template not found in the rastack package. Reinstall\n" +
-        "    rastack (`npm i -g rastack`) or run from the framework repo.",
-    );
-    process.exit(1);
-  }
-  try {
-    awsRun(bootstrapStackArgs(cfg, reuseOidc, template));
-  } catch (err) {
-    if (reuseOidc) {
-      console.error(
-        `\n  ✗ bootstrap stack deploy failed.\n    ${(err as Error).message}`,
-      );
-      process.exit(1);
-    }
-    // The most common cause is an account that already has a GitHub OIDC
-    // provider. Retry telling the template to reuse it instead of creating a
-    // second (which CloudFormation rejects).
-    console.log(
-      "  • retrying bootstrap, reusing the account's existing GitHub OIDC provider",
-    );
-    try {
-      awsRun(bootstrapStackArgs(cfg, true, template));
-    } catch (retryErr) {
-      console.error(
-        `\n  ✗ bootstrap stack deploy failed.\n    ${(retryErr as Error).message}`,
-      );
-      process.exit(1);
-    }
-  }
-}
-
-/** Stand the tier-0 bootstrap stack up and upload the Lambda placeholder. */
-function standUp(cfg: DeployConfig, reuseOidc: boolean): void {
+async function standUp(cfg: DeployConfig, reuseOidc: boolean): Promise<void> {
   if (!awsAvailable()) {
     console.error(
       "  ✗ the AWS CLI is not on PATH. Install it and configure credentials,\n" +
@@ -213,33 +175,26 @@ function standUp(cfg: DeployConfig, reuseOidc: boolean): void {
     process.exit(1);
   }
 
-  const stack = bootstrapStackName(cfg);
-  const existing = stackOutput(stack, BOOTSTRAP_ARTIFACTS_OUTPUT, cfg.region);
-  if (existing) {
-    console.log(
-      `\n▸ Bootstrap stack ${stack} already exists — reconciling (idempotent).`,
-    );
-  } else {
-    console.log(`\n▸ Creating bootstrap stack ${stack} (@ ${cfg.region})`);
-  }
-  deployBootstrap(cfg, reuseOidc);
-
-  const artifactsBucket = stackOutput(
-    stack,
-    BOOTSTRAP_ARTIFACTS_OUTPUT,
-    cfg.region,
-  );
-  const templatesBucket = stackOutput(
-    stack,
-    BOOTSTRAP_TEMPLATES_OUTPUT,
-    cfg.region,
-  );
-  if (!artifactsBucket) {
+  // Verify the AWS CLI is logged in before attempting a stack deploy.
+  const account = awsIdentity(cfg.region);
+  if (!account) {
     console.error(
-      "  ✗ bootstrap stack deployed but its ArtifactsBucket output could not be read.",
+      "  ✗ the AWS CLI has no usable credentials — it is not logged in.\n" +
+        "    Run `aws configure` (or `aws sso login`), then re-run `rastack bootstrap`.\n" +
+        "    Or re-run with --print to see the command.",
     );
     process.exit(1);
   }
+  console.log(`  ✓ AWS account ${account} (${cfg.region})`);
+
+  const stack = bootstrapStackName(cfg);
+  const { artifactsBucket, templatesBucket } = await ensureBootstrapStack(
+    cfg,
+    reuseOidc,
+  ).catch((err: Error) => {
+    console.error(`\n  ✗ ${err.message}`);
+    process.exit(1);
+  });
   console.log(`  ✓ artifacts bucket:  ${artifactsBucket}`);
   if (templatesBucket) console.log(`  ✓ templates bucket:  ${templatesBucket}`);
 
@@ -299,7 +254,7 @@ async function main(argv: string[]): Promise<void> {
     }
   }
 
-  standUp(cfg, flags.reuseOidc);
+  await standUp(cfg, flags.reuseOidc);
 }
 
 if (require.main === module) {

package/src/rastack-design.ts

@@ -12,8 +12,7 @@
  * source and hitting **Save** writes it back and recompiles `tokens.css` /
  * `tokens.ts`, so the rest of the app picks the change up on reload.
  *
- * In keeping with the local-first ethos (the whole API runs in the browser via
- * WASM), the studio needs no build step and no external dependencies.
+ * The studio needs no build step and no external dependencies.
  */
 
 import * as http from "http";

package/src/rastack-dev.ts

@@ -1,32 +1,24 @@
 #!/usr/bin/env node
 
 /**
- * `rastack dev` — local development of **your app**, always over the WASM engine.
+ * `rastack dev` — local development of **your app** against the native engine.
  *
  *   rastack dev [resourcesDir] [--port <n>] [--warehouse <dir>] [--out <dir>] [--app <dir>] [--no-open]
  *
- * Compiles the resources, then boots a dependency-free static server (à la
- * `rastack design`) that hands the browser everything it needs to run the
- * developer's own app locally over WebAssembly — no native server, no cargo:
+ * Compiles the resources, starts a native `rastack-server` (`rastack-api-core`
+ * over the on-disk Iceberg warehouse), and serves the developer's app. The
+ * browser is the UI. `/api` on this origin is proxied to that process.
  *   • the developer's app (`index.html` from the resolved app root), or a
  *     Django-style welcome page when the project has no app yet,
- *   • the prebuilt WASM engine (`/wasm/…`) shipped in the package,
  *   • the compiled `schema.rastack.json` / `openapi.json`,
- *   • the committed Iceberg warehouse (`/data/warehouse/…`) to seed from.
+ *   • `/api/…` forwarded to the native server.
  *
  * It does **not** serve the admin console — that is a separate command,
- * `rastack admin`.
- *
- * The engine is resolved from the package's prebuilt bundle; if none is present
- * but a Rust + wasm toolchain is, it is built from source as a fallback.
+ * `rastack admin`. The browser does not execute the engine. There is no
+ * in-browser fallback.
  */
 
-import {
-  execFileSync,
-  spawn,
-  spawnSync,
-  type ChildProcess,
-} from "child_process";
+import { execFileSync, spawn, type ChildProcess } from "child_process";
 import * as fs from "fs";
 import * as http from "http";
 import * as net from "net";
@@ -36,25 +28,17 @@ import { cognitoRuntimeConfig } from "./deploy/config";
 import { loadConfig } from "./deploy/io";
 import {
   APP_ENTRY,
-  WASM_ENTRY,
   appRootCandidates,
   contentType,
   type DevArgs,
   parseDevArgs,
   renderWelcome,
-  wasmBundleCandidates,
 } from "./dev/harness";
-
-const HERE = __dirname; // dist/ when installed
-
-/** True when `cargo` is on PATH (the from-source wasm fallback needs it). */
-function cargoAvailable(): boolean {
-  try {
-    return spawnSync("cargo", ["--version"], { stdio: "ignore" }).status === 0;
-  } catch {
-    return false;
-  }
-}
+import {
+  ensureServerBinary,
+  startNativeServer,
+  waitForTcp,
+} from "./dev/native-server";
 
 /** First app-root candidate that holds an `index.html`, or null (→ welcome). */
 function resolveAppRoot(appDir: string): string | null {
@@ -64,30 +48,6 @@ function resolveAppRoot(appDir: string): string | null {
   return null;
 }
 
-/** Locate the prebuilt wasm bundle dir, building from source as a fallback. */
-function resolveWasmDir(): string | null {
-  for (const dir of wasmBundleCandidates(HERE)) {
-    if (fs.existsSync(path.join(dir, WASM_ENTRY))) return dir;
-  }
-  if (cargoAvailable()) {
-    console.log(
-      "\n▸ No prebuilt WASM engine found — building it from source (cargo)…\n",
-    );
-    try {
-      // Lazy require so a normal `dev` with a prebuilt bundle never loads it.
-      // eslint-disable-next-line @typescript-eslint/no-var-requires
-      require("./rastack-wasm-build").buildWasm();
-    } catch (err) {
-      console.error(`  ✗ wasm build failed: ${(err as Error).message}`);
-      return null;
-    }
-    for (const dir of wasmBundleCandidates(HERE)) {
-      if (fs.existsSync(path.join(dir, WASM_ENTRY))) return dir;
-    }
-  }
-  return null;
-}
-
 /** Serve one file if it exists and stays within `root`; else 404/403. */
 function serveUnder(
   res: http.ServerResponse,
@@ -174,8 +134,9 @@ function openBrowser(url: string): void {
 // A React Native (Expo) app has no static `index.html`: its web build is a
 // Metro bundle. Rather than make the developer run a second tool, `dev` starts
 // Expo's Metro dev server itself and reverse-proxies to it, so `rastack dev`
-// stays the single command *and* keeps Metro's fast-refresh. The WASM
-// static-serve path remains the default for apps that ship a built index.html.
+// stays the single command *and* keeps Metro's fast-refresh. Apps that ship
+// a built index.html use the static server below. Both proxy /api to the
+// native server.
 // ---------------------------------------------------------------------------
 
 /** True when the project is an Expo app (so `dev` should drive Metro). */
@@ -199,15 +160,7 @@ function isExpoProject(cwd: string): boolean {
   return false;
 }
 
-/** Locate the prebuilt wasm bundle without the cargo fallback (optional here). */
-function findWasmDir(): string | null {
-  for (const dir of wasmBundleCandidates(HERE)) {
-    if (fs.existsSync(path.join(dir, WASM_ENTRY))) return dir;
-  }
-  return null;
-}
-
-/** Grab an ephemeral free TCP port for Metro (avoids a fixed-port clash). */
+/** Grab an ephemeral free TCP port (Metro, or the native API beside this server). */
 function getFreePort(): Promise<number> {
   return new Promise((resolve, reject) => {
     const srv = net.createServer();
@@ -295,7 +248,7 @@ function proxyToMetro(
   );
   proxyReq.on("error", () => {
     if (!res.headersSent) res.writeHead(502);
-    res.end("Metro is not reachable.");
+    res.end("Upstream is not reachable.");
   });
   req.pipe(proxyReq);
 }
@@ -323,11 +276,12 @@ function proxyUpgrade(
 }
 
 /** `rastack dev` for an Expo app: start Metro and reverse-proxy to it. */
-async function runMetroMode(args: DevArgs, cwd: string): Promise<void> {
-  // The wasm engine is optional here — an Expo/RN-web app runs its own engine —
-  // so a missing bundle is fine. When present, the reserved backend routes work.
-  const wasmDir = findWasmDir();
-
+async function runMetroMode(
+  args: DevArgs,
+  cwd: string,
+  apiPort: number,
+  stopEngine: () => void,
+): Promise<void> {
   const metroPort = await getFreePort();
   console.log(`▸ Starting Metro bundler (Expo) on :${metroPort} …`);
   const metro = startMetro(cwd, metroPort);
@@ -336,6 +290,7 @@ async function runMetroMode(args: DevArgs, cwd: string): Promise<void> {
   const stop = (code = 0) => {
     if (shuttingDown) return;
     shuttingDown = true;
+    stopEngine();
     try {
       metro.kill();
     } catch {
@@ -359,9 +314,8 @@ async function runMetroMode(args: DevArgs, cwd: string): Promise<void> {
 
   const server = http.createServer((req, res) => {
     const url = (req.url || "/").split("?")[0];
-    // Reserved backend routes win when the engine bundle is available.
-    if (wasmDir && url.startsWith("/wasm/"))
-      return serveUnder(res, wasmDir, url.slice("/wasm/".length));
+    if (url.startsWith("/api/") || url === "/api")
+      return proxyToMetro(req, res, apiPort);
     if (url === "/schema.rastack.json" || url === "/openapi.json")
       return serveUnder(res, args.outDir, path.basename(url));
     if (url === "/__rastack/cognito.json") return serveDevCognito(res, cwd);
@@ -392,7 +346,7 @@ async function runMetroMode(args: DevArgs, cwd: string): Promise<void> {
   server.listen(args.port, () => {
     const url = `http://localhost:${args.port}`;
     console.log(`  ✓ Metro live on :${metroPort} — fast refresh on`);
-    if (wasmDir) console.log(`  ✓ WASM engine: ${path.relative(cwd, wasmDir)}`);
+    console.log(`  ✓ native engine: 127.0.0.1:${apiPort} (proxied at /api)`);
     console.log(`\n  ▸ ${url}\n`);
     console.log(
       "  Edits reload live. Need the database console? Run `rastack admin`. Ctrl+C to stop.\n",
@@ -405,7 +359,9 @@ async function main(argv: string[]): Promise<void> {
   const args = parseDevArgs(argv);
   const cwd = process.cwd();
 
-  console.log(`\n  rastack dev — your app, in your browser over WASM\n`);
+  console.log(
+    `\n  rastack dev — your app in the browser, the API in native Rust\n`,
+  );
   console.log(`▸ Compiling ${args.resourcesDir} → ${args.outDir}`);
   if (!runCompile(args.resourcesDir, args.outDir)) {
     console.error("  ✗ compile failed — fix the resource graph and re-run.");
@@ -415,32 +371,64 @@ async function main(argv: string[]): Promise<void> {
   // Serve the developer's own app when there is one; otherwise the welcome page.
   const appRoot = resolveAppRoot(args.appDir);
 
+  let engine: ChildProcess;
+  let apiPort: number;
+  let stopping = false;
+  try {
+    const bin = ensureServerBinary(cwd);
+    apiPort = await getFreePort();
+    const manifest = path.resolve(cwd, args.outDir, "schema.rastack.json");
+    const warehouse = path.resolve(cwd, args.warehouseDir);
+    engine = startNativeServer({
+      bin,
+      command: "serve",
+      manifest,
+      warehouse,
+      addr: `127.0.0.1:${apiPort}`,
+    });
+    await waitForTcp(apiPort, engine);
+  } catch (err) {
+    console.error(`\n${(err as Error).message}\n`);
+    process.exit(1);
+  }
+
+  const stopEngine = () => {
+    stopping = true;
+    try {
+      engine.kill("SIGTERM");
+    } catch {
+      /* already gone */
+    }
+  };
+  engine.on("exit", (code) => {
+    if (stopping) return;
+    console.error(`\n  ✗ native engine exited (code ${code ?? "?"}).`);
+    process.exit(code ?? 1);
+  });
+
   // No static build, but an Expo source tree → drive Metro live (fast refresh).
+  // Metro mode owns the shutdown signals so it can stop both processes.
   if (!appRoot && isExpoProject(cwd)) {
-    return runMetroMode(args, cwd);
+    return runMetroMode(args, cwd, apiPort, stopEngine);
   }
 
-  const wasmDir = resolveWasmDir();
-  if (!wasmDir) {
-    console.error(
-      "\n  ✗ No WASM engine available.\n" +
-        "    Upgrade rastack for the prebuilt bundle (`rastack update`), or install\n" +
-        "    the Rust toolchain to build it from source:\n" +
-        "      rustup target add wasm32-unknown-unknown\n" +
-        "      cargo install wasm-bindgen-cli\n",
-    );
-    process.exit(1);
-  }
+  process.on("SIGINT", () => {
+    stopEngine();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    stopEngine();
+    process.exit(0);
+  });
 
   const server = http.createServer((req, res) => {
     const url = (req.url || "/").split("?")[0];
+    if (url.startsWith("/api/") || url === "/api")
+      return proxyToMetro(req, res, apiPort);
     if (req.method !== "GET") {
       res.writeHead(405).end("Method not allowed");
       return;
     }
-    // Reserved backend routes always win over the app's static files.
-    if (url.startsWith("/wasm/"))
-      return serveUnder(res, wasmDir, url.slice("/wasm/".length));
     if (url === "/schema.rastack.json" || url === "/openapi.json")
       return serveUnder(res, args.outDir, path.basename(url));
     if (url === "/__rastack/cognito.json") return serveDevCognito(res, cwd);
@@ -479,7 +467,7 @@ async function main(argv: string[]): Promise<void> {
 
   server.listen(args.port, () => {
     const url = `http://localhost:${args.port}`;
-    console.log(`  ✓ WASM engine: ${path.relative(process.cwd(), wasmDir)}`);
+    console.log(`  ✓ native engine: 127.0.0.1:${apiPort} (proxied at /api)`);
     if (appRoot)
       console.log(`  ✓ app: ${path.relative(process.cwd(), appRoot) || "."}`);
     else console.log(`  ○ no app found — serving the welcome page`);