rastack 0.0.64 → 0.0.69

package/dist/compile/model.d.ts

@@ -76,7 +76,7 @@ export interface TransitionEdgeModel {
 /**
  * A resource's declarative state machine, keyed off one state field. Compiled
  * into the manifest and enforced on every write surface: the TS record machine
- * (forms, `rastack import`) and `rastack-api-core` (server, Lambda, WASM) all
+ * (forms, `rastack import`) and `rastack-api-core` (the native server) all
  * reject a write that jumps between states without a declared edge.
  */
 export interface TransitionsModel {

package/dist/compile/run.d.ts

@@ -5,8 +5,8 @@
  *
  * This is the single entry point the two real modalities of use share instead
  * of shelling out to a standalone `compile` command:
- *   • `rastack dev` / `rastack admin` — local development (compile, then serve
- *     the app + admin in the browser over WASM), and
+ *   • `rastack dev` / `rastack admin` — local development (compile, then start
+ *     the native rastack-server; the browser is only the UI), and
  *   • `rastack ci` — the deploy pipeline (compile the manifest the Rust backend
  *     reads + the OpenAPI contract, then build/ship).
  */

package/dist/compile/run.js

@@ -44,8 +44,8 @@ const index_1 = require("./index");
  *
  * This is the single entry point the two real modalities of use share instead
  * of shelling out to a standalone `compile` command:
- *   • `rastack dev` / `rastack admin` — local development (compile, then serve
- *     the app + admin in the browser over WASM), and
+ *   • `rastack dev` / `rastack admin` — local development (compile, then start
+ *     the native rastack-server; the browser is only the UI), and
  *   • `rastack ci` — the deploy pipeline (compile the manifest the Rust backend
  *     reads + the OpenAPI contract, then build/ship).
  */

package/dist/define/index.d.ts

@@ -125,8 +125,7 @@ export interface SyncOptions {
 }
 /**
  * Row-level access control. Enforced by `rastack-api-core`, so the rules are
- * identical on the server (Lambda / `rastack serve`) and in the in-browser WASM
- * engine.
+ * identical on the native server (laptop and Lambda).
  *
  * - `ownerField` — the field that records the owning identity (the verified
  *   token `sub`). Rows are only listed/read/written by their owner; the field
@@ -164,7 +163,7 @@ export type Permission = "authenticatedOrReadOnly" | "authenticated" | "public";
  * transition may fire from, `to` the state it enters, and `set` the effect —
  * field patches the engine applies alongside the state change. The block is
  * static data: it compiles into the manifest and is enforced by
- * `rastack-api-core` on every surface (server, Lambda, in-browser WASM), so a
+ * `rastack-api-core` on the native server (laptop and Lambda), so a
  * transition behaves as a declarative, typesafe backend function with no
  * per-resource server code.
  */

package/dist/deploy/workflows.js

@@ -124,7 +124,7 @@ jobs:
       - name: Cache cargo
         uses: Swatinem/rust-cache@v2
         with:
-          workspaces: rust
+          workspaces: engine
       # cargo-lambda cross-builds the custom-runtime binary; it auto-installs
       # zig (via pip) for the cross-compile when needed.
       - name: Install cargo-lambda

package/dist/dev/harness.d.ts

@@ -1,27 +1,25 @@
 /**
- * Pure core of `rastack dev` — the local, always-WASM development server.
+ * Pure core of `rastack dev` — local development against the native Rust server.
  *
- * `rastack dev` runs **your app** in the browser over the WebAssembly engine
- * (the same app-generic `rastack-api-core` the Lambda runs, fed the app's
- * compiled manifest). No native server, no cargo: a dependency-free static
- * server hands the browser the prebuilt wasm engine, the compiled schema, the
- * committed Iceberg warehouse, and the developer's own app. It does **not**
- * serve the admin console — that is a separate command, `rastack admin`.
+ * `rastack dev` serves **your app** from Node and proxies `/api` to a native
+ * `rastack-server` process (the same `rastack-api-core` Lambda runs). The
+ * browser renders the UI. It does not execute the engine. `rastack admin` is
+ * the separate command that starts `rastack-server admin`.
  *
  * When the project has no app to serve, `dev` shows a Django-style welcome
  * page (`renderWelcome`) so a fresh scaffold still boots to something friendly.
  *
- * Everything decidable without IO lives here (arg parsing, MIME types, locating
- * the wasm bundle, resolving the app root, the HTML pages) so it is unit-tested
- * without a socket or a filesystem; `rastack-dev.ts` is the thin IO wrapper that
- * compiles, resolves the engine and the app, and serves.
+ * Everything decidable without IO lives here (arg parsing, MIME types, where
+ * the native binary is looked up, resolving the app root, the HTML pages) so
+ * it is unit-tested without a socket or a filesystem; `rastack-dev.ts` is the
+ * thin IO wrapper that compiles, starts the server, and serves.
  */
 export interface DevArgs {
     /** Where the TypeScript resource definitions live (compiled on start). */
     resourcesDir: string;
     /** Where `rastack compile` writes schema.rastack.json + openapi.json. */
     outDir: string;
-    /** The committed Iceberg warehouse served to seed the browser engine. */
+    /** The on-disk Iceberg warehouse the native server opens. */
     warehouseDir: string;
     /**
      * Explicit app root to serve at `/` (its `index.html`). Empty when unset —
@@ -71,21 +69,16 @@ export declare function parseAdminArgs(argv: string[]): AdminArgs;
 /** MIME type for a served path, defaulting to octet-stream (Iceberg data files). */
 export declare function contentType(filePath: string): string;
 /**
- * Ordered directories to look for the prebuilt wasm bundle (`rastack_wasm.js` +
- * `rastack_wasm_bg.wasm`). The bundle is shipped inside the package
- * (`dist/wasm/`, copied at build), so `rastack dev` works from any repo with no
- * cargo; the repo-local `wasm/` (from a source build) and a sibling of the
- * running module are fallbacks for development. `dirnameDir` is the directory of
- * the compiled `rastack-dev.js` (`dist/`), so `../wasm` and `./wasm` cover both
- * `dist/rastack-dev.js` → `dist/wasm` and `dist/dev/…` layouts.
+ * Ordered paths for the native `rastack-server` binary inside a workspace
+ * checkout. Release wins over debug. `RASTACK_SERVER` and `PATH` are checked
+ * by the IO wrapper, not here.
  */
-export declare function wasmBundleCandidates(dirnameDir: string, cwd?: string): string[];
-/** The name of the file that marks a directory as a usable wasm bundle. */
-export declare const WASM_ENTRY = "rastack_wasm.js";
+export declare function serverBinaryCandidates(cwd: string): string[];
 /**
  * The HTML shell served at `/` by **`rastack admin`**. It loads the bundled
- * React admin (`/dev/admin.js`), which fetches the schema/openapi, boots the
- * wasm engine, seeds it from `/data/warehouse/`, and renders the admin console.
+ * React admin (`/dev/admin.js`). `rastack admin` itself does not serve this
+ * page: the native `rastack-server admin` process serves `/admin/` and the
+ * bundle talks to that process over HTTP.
  * Deliberately tiny — all logic lives in the bundle — mirroring the
  * `rastack design` studio. `rastack dev` does **not** use this: it serves the
  * developer's own app (or the welcome page below).
@@ -94,8 +87,7 @@ export declare function renderShell(title?: string): string;
 /**
  * The Django-style welcome page `rastack dev` serves at `/` when the project
  * has **no app** to serve (no `index.html` in any `appRootCandidates` dir).
- * It confirms the dev server is up, points at the live backend endpoints the
- * WASM engine exposes, and tells you how to add an app or open the admin — the
- * "It worked!" moment of `django-admin runserver`, on brand for the stack.
+ * It confirms the dev server is up, points at the native API proxied at
+ * `/api`, and tells you how to add an app or open the admin.
  */
 export declare function renderWelcome(title?: string): string;

package/dist/dev/harness.js

@@ -1,21 +1,19 @@
 "use strict";
 /**
- * Pure core of `rastack dev` — the local, always-WASM development server.
+ * Pure core of `rastack dev` — local development against the native Rust server.
  *
- * `rastack dev` runs **your app** in the browser over the WebAssembly engine
- * (the same app-generic `rastack-api-core` the Lambda runs, fed the app's
- * compiled manifest). No native server, no cargo: a dependency-free static
- * server hands the browser the prebuilt wasm engine, the compiled schema, the
- * committed Iceberg warehouse, and the developer's own app. It does **not**
- * serve the admin console — that is a separate command, `rastack admin`.
+ * `rastack dev` serves **your app** from Node and proxies `/api` to a native
+ * `rastack-server` process (the same `rastack-api-core` Lambda runs). The
+ * browser renders the UI. It does not execute the engine. `rastack admin` is
+ * the separate command that starts `rastack-server admin`.
  *
  * When the project has no app to serve, `dev` shows a Django-style welcome
  * page (`renderWelcome`) so a fresh scaffold still boots to something friendly.
  *
- * Everything decidable without IO lives here (arg parsing, MIME types, locating
- * the wasm bundle, resolving the app root, the HTML pages) so it is unit-tested
- * without a socket or a filesystem; `rastack-dev.ts` is the thin IO wrapper that
- * compiles, resolves the engine and the app, and serves.
+ * Everything decidable without IO lives here (arg parsing, MIME types, where
+ * the native binary is looked up, resolving the app root, the HTML pages) so
+ * it is unit-tested without a socket or a filesystem; `rastack-dev.ts` is the
+ * thin IO wrapper that compiles, starts the server, and serves.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -51,12 +49,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WASM_ENTRY = exports.ADMIN_DEFAULTS = exports.APP_ENTRY = exports.DEV_DEFAULTS = void 0;
+exports.ADMIN_DEFAULTS = exports.APP_ENTRY = exports.DEV_DEFAULTS = void 0;
 exports.parseDevArgs = parseDevArgs;
 exports.appRootCandidates = appRootCandidates;
 exports.parseAdminArgs = parseAdminArgs;
 exports.contentType = contentType;
-exports.wasmBundleCandidates = wasmBundleCandidates;
+exports.serverBinaryCandidates = serverBinaryCandidates;
 exports.renderShell = renderShell;
 exports.renderWelcome = renderWelcome;
 const path = __importStar(require("path"));
@@ -157,7 +155,6 @@ const MIME = {
     ".mjs": "text/javascript; charset=utf-8",
     ".css": "text/css; charset=utf-8",
     ".json": "application/json; charset=utf-8",
-    // Critical: `WebAssembly.instantiateStreaming` requires this exact type.
     ".wasm": "application/wasm",
     ".text": "text/plain; charset=utf-8",
     ".parquet": "application/octet-stream",
@@ -168,27 +165,21 @@ function contentType(filePath) {
     return MIME[ext] ?? "application/octet-stream";
 }
 /**
- * Ordered directories to look for the prebuilt wasm bundle (`rastack_wasm.js` +
- * `rastack_wasm_bg.wasm`). The bundle is shipped inside the package
- * (`dist/wasm/`, copied at build), so `rastack dev` works from any repo with no
- * cargo; the repo-local `wasm/` (from a source build) and a sibling of the
- * running module are fallbacks for development. `dirnameDir` is the directory of
- * the compiled `rastack-dev.js` (`dist/`), so `../wasm` and `./wasm` cover both
- * `dist/rastack-dev.js` → `dist/wasm` and `dist/dev/…` layouts.
+ * Ordered paths for the native `rastack-server` binary inside a workspace
+ * checkout. Release wins over debug. `RASTACK_SERVER` and `PATH` are checked
+ * by the IO wrapper, not here.
  */
-function wasmBundleCandidates(dirnameDir, cwd = process.cwd()) {
+function serverBinaryCandidates(cwd) {
     return [
-        path.join(dirnameDir, "wasm"),
-        path.join(dirnameDir, "..", "wasm"),
-        path.join(cwd, "wasm"),
+        path.join(cwd, "engine", "target", "release", "rastack-server"),
+        path.join(cwd, "engine", "target", "debug", "rastack-server"),
     ];
 }
-/** The name of the file that marks a directory as a usable wasm bundle. */
-exports.WASM_ENTRY = "rastack_wasm.js";
 /**
  * The HTML shell served at `/` by **`rastack admin`**. It loads the bundled
- * React admin (`/dev/admin.js`), which fetches the schema/openapi, boots the
- * wasm engine, seeds it from `/data/warehouse/`, and renders the admin console.
+ * React admin (`/dev/admin.js`). `rastack admin` itself does not serve this
+ * page: the native `rastack-server admin` process serves `/admin/` and the
+ * bundle talks to that process over HTTP.
  * Deliberately tiny — all logic lives in the bundle — mirroring the
  * `rastack design` studio. `rastack dev` does **not** use this: it serves the
  * developer's own app (or the welcome page below).
@@ -233,9 +224,8 @@ function renderShell(title = "React API Stack — admin") {
 /**
  * The Django-style welcome page `rastack dev` serves at `/` when the project
  * has **no app** to serve (no `index.html` in any `appRootCandidates` dir).
- * It confirms the dev server is up, points at the live backend endpoints the
- * WASM engine exposes, and tells you how to add an app or open the admin — the
- * "It worked!" moment of `django-admin runserver`, on brand for the stack.
+ * It confirms the dev server is up, points at the native API proxied at
+ * `/api`, and tells you how to add an app or open the admin.
  */
 function renderWelcome(title = "React API Stack — dev") {
     return `<!doctype html>
@@ -282,20 +272,21 @@ function renderWelcome(title = "React API Stack — dev") {
   <div class="rocket">🚀</div>
   <h1>The dev server is running.</h1>
   <p class="lead">
-    Congratulations — <strong>rastack dev</strong> is up and your API is running
-    in the browser over WebAssembly. You're seeing this page because there's no
-    app to serve yet.
+    Congratulations — <strong>rastack dev</strong> is up. The API is a native
+    Rust process (<code>rastack-server</code>) on this machine. This page is
+    only the UI. You're seeing it because there's no app to serve yet.
   </p>
   <ul>
     <li>Add an <code>index.html</code> (in <code>public/</code>, <code>www/</code>,
       <code>app/</code>, or the project root) and reload — <code>dev</code> will serve it.
       Point it at a different folder with <code>rastack dev --app &lt;dir&gt;</code>.</li>
-    <li>Wire your app to the local engine with
-      <code>&lt;RAStackProvider mode="local"&gt;</code>.</li>
-    <li>Live backend endpoints:
+    <li>Wire your app with
+      <code>&lt;RAStackProvider mode="local"&gt;</code>. Requests go to
+      <code>/api</code> on this origin, which is proxied to the native server.</li>
+    <li>Live files:
       <a href="/schema.rastack.json">/schema.rastack.json</a>,
-      <a href="/openapi.json">/openapi.json</a>,
-      <code>/data/warehouse/…</code>, <code>/wasm/…</code>.</li>
+      <a href="/openapi.json">/openapi.json</a>.
+      The warehouse stays on disk; the browser does not load it.</li>
     <li>Want the database console instead? Run <code>rastack admin</code>.</li>
   </ul>
   <div class="foot">React API Stack — a full-stack framework on object storage.</div>

package/dist/dev/native-server.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Start the native `rastack-server` binary — the same `rastack-api-core`
+ * process Lambda runs. The browser never executes this binary. `rastack dev`
+ * proxies `/api` to it; `rastack admin` lets the binary serve `/admin` itself.
+ */
+import { type ChildProcess } from "child_process";
+export interface NativeServerOpts {
+    /** Absolute path to the `rastack-server` binary. */
+    bin: string;
+    /** `serve` is the API. `admin` mounts the React console at `/admin`. */
+    command: "serve" | "admin";
+    manifest: string;
+    warehouse: string;
+    /** `host:port` the binary binds. */
+    addr: string;
+    /** Directory that contains `admin.js` (`RASTACK_ADMIN_ASSETS`). */
+    adminAssets?: string;
+}
+/** `RASTACK_SERVER`, a workspace target dir, or `rastack-server` on PATH. */
+export declare function resolveServerBinary(cwd: string): string | null;
+/**
+ * Locate the native binary, building it with cargo when this repo's workspace
+ * is present and the binary is not. Throws when nothing native can be started.
+ */
+export declare function ensureServerBinary(cwd: string): string;
+/** Spawn `rastack-server serve|admin`. Stdio is inherited. */
+export declare function startNativeServer(opts: NativeServerOpts): ChildProcess;
+/** Resolve once the process accepts TCP, or reject if it exits or times out. */
+export declare function waitForTcp(port: number, child: ChildProcess, timeoutMs?: number): Promise<void>;

package/dist/dev/native-server.js

@@ -0,0 +1,174 @@
+"use strict";
+/**
+ * Start the native `rastack-server` binary — the same `rastack-api-core`
+ * process Lambda runs. The browser never executes this binary. `rastack dev`
+ * proxies `/api` to it; `rastack admin` lets the binary serve `/admin` itself.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveServerBinary = resolveServerBinary;
+exports.ensureServerBinary = ensureServerBinary;
+exports.startNativeServer = startNativeServer;
+exports.waitForTcp = waitForTcp;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const net = __importStar(require("net"));
+const path = __importStar(require("path"));
+const harness_1 = require("./harness");
+const MISSING = `
+  ✗ No native rastack-server binary.
+    The API does not run in the browser. rastack dev and rastack admin start
+    the native Rust server (rastack-api-core) and the page talks to it over HTTP.
+    Build it from this repo:
+
+      cargo build -p rastack-server --manifest-path engine/Cargo.toml
+
+    Or set RASTACK_SERVER to the binary. There is no in-browser engine.
+`;
+/**
+ * `rastack-server` on PATH. Walks the directories ourselves so the lookup
+ * never goes through a shell (`command -v` with `shell: true`).
+ */
+function serverOnPath() {
+    const entries = (process.env.PATH ?? "").split(path.delimiter);
+    for (const dir of entries) {
+        if (!dir)
+            continue;
+        const candidate = path.join(dir, "rastack-server");
+        try {
+            if (fs.existsSync(candidate))
+                return candidate;
+        }
+        catch {
+            // An unreadable PATH entry is not a candidate.
+        }
+    }
+    return null;
+}
+/** `RASTACK_SERVER`, a workspace target dir, or `rastack-server` on PATH. */
+function resolveServerBinary(cwd) {
+    const fromEnv = process.env.RASTACK_SERVER;
+    if (fromEnv && fs.existsSync(fromEnv))
+        return fromEnv;
+    for (const candidate of (0, harness_1.serverBinaryCandidates)(cwd)) {
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return serverOnPath();
+}
+function cargoAvailable() {
+    try {
+        return (0, child_process_1.spawnSync)("cargo", ["--version"], { stdio: "ignore" }).status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Locate the native binary, building it with cargo when this repo's workspace
+ * is present and the binary is not. Throws when nothing native can be started.
+ */
+function ensureServerBinary(cwd) {
+    const ready = resolveServerBinary(cwd);
+    if (ready)
+        return ready;
+    const manifest = path.join(cwd, "engine", "Cargo.toml");
+    if (fs.existsSync(manifest) && cargoAvailable()) {
+        console.log("\n▸ Building native rastack-server (cargo build -p rastack-server)…\n");
+        const built = (0, child_process_1.spawnSync)("cargo", ["build", "-p", "rastack-server", "--manifest-path", manifest], { stdio: "inherit" });
+        if (built.status === 0) {
+            const after = resolveServerBinary(cwd);
+            if (after)
+                return after;
+        }
+    }
+    throw new Error(MISSING.trim());
+}
+/** Spawn `rastack-server serve|admin`. Stdio is inherited. */
+function startNativeServer(opts) {
+    const env = { ...process.env };
+    if (opts.adminAssets)
+        env.RASTACK_ADMIN_ASSETS = opts.adminAssets;
+    // `bin` is resolveServerBinary's result: RASTACK_SERVER (a file that exists),
+    // a workspace target path, or a PATH entry named rastack-server. It is not
+    // request input. The command cannot be a string literal because the path
+    // depends on which of those three resolved. The nosemgrep comment has to sit
+    // on the line directly above the tainted argument — that is the line Semgrep
+    // reports, not the `spawn(` line.
+    const bin = opts.bin;
+    return (0, child_process_1.spawn)(
+    // nosemgrep: javascript.lang.security.detect-child-process.detect-child-process
+    bin, [
+        opts.command,
+        "--manifest",
+        opts.manifest,
+        "--warehouse",
+        opts.warehouse,
+        "--addr",
+        opts.addr,
+        "--insecure-dev-auth",
+    ], { stdio: "inherit", env });
+}
+/** Resolve once the process accepts TCP, or reject if it exits or times out. */
+function waitForTcp(port, child, timeoutMs = 30000) {
+    return new Promise((resolve, reject) => {
+        const deadline = Date.now() + timeoutMs;
+        let settled = false;
+        const finish = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            if (err)
+                reject(err);
+            else
+                resolve();
+        };
+        child.once("exit", (code) => finish(new Error(`rastack-server exited (${code ?? "?"}) before it accepted connections`)));
+        const tick = () => {
+            if (settled)
+                return;
+            if (Date.now() > deadline) {
+                finish(new Error(`rastack-server did not listen on 127.0.0.1:${port}`));
+                return;
+            }
+            const socket = net.connect(port, "127.0.0.1", () => {
+                socket.end();
+                finish();
+            });
+            socket.on("error", () => setTimeout(tick, 100));
+        };
+        tick();
+    });
+}

package/dist/external/envelope.d.ts

@@ -1,7 +1,7 @@
 /**
  * Normalise an upstream response into rastack's REST contract — the DRF-shaped
  * list envelope and bare detail object the typed hooks and `<DataTable>` expect,
- * identical to what the Rust API and the WASM/local engine emit.
+ * identical to what the native Rust API emits.
  *
  * External APIs rarely page the way rastack does (GitHub uses `per_page` + Link
  * headers; a GraphQL list just returns an array), so the envelope is synthesised

package/dist/external/envelope.js

@@ -2,7 +2,7 @@
 /**
  * Normalise an upstream response into rastack's REST contract — the DRF-shaped
  * list envelope and bare detail object the typed hooks and `<DataTable>` expect,
- * identical to what the Rust API and the WASM/local engine emit.
+ * identical to what the native Rust API emits.
  *
  * External APIs rarely page the way rastack does (GitHub uses `per_page` + Link
  * headers; a GraphQL list just returns an array), so the envelope is synthesised

package/dist/external/service.d.ts

@@ -1,8 +1,8 @@
 /**
  * The mini local proxy service — the "lambda you run while iterating".
  *
- * `rastack dev` already serves the app + admin over WASM for the stack's *own*
- * resources. This adds the other half for **external** resources: a request
+ * `rastack dev` proxies the stack's own resources to the native
+ * `rastack-server`. This adds the other half for **external** resources: a request
  * handler it mounts under `/api/`, so `useData("github.repo")` works locally,
  * cached, before any real Lambda is deployed. It is a thin adapter over the pure
  * {@link handleExternalRequest} core — parse the path, resolve dev auth from env

package/dist/external/service.js

@@ -2,8 +2,8 @@
 /**
  * The mini local proxy service — the "lambda you run while iterating".
  *
- * `rastack dev` already serves the app + admin over WASM for the stack's *own*
- * resources. This adds the other half for **external** resources: a request
+ * `rastack dev` proxies the stack's own resources to the native
+ * `rastack-server`. This adds the other half for **external** resources: a request
  * handler it mounts under `/api/`, so `useData("github.repo")` works locally,
  * cached, before any real Lambda is deployed. It is a thin adapter over the pure
  * {@link handleExternalRequest} core — parse the path, resolve dev auth from env

package/dist/external/types.d.ts

@@ -2,7 +2,7 @@
  * External-API bindings — how a rastack `app.model` is served from an upstream
  * REST or GraphQL API.
  *
- * The stack's own resources are served by the Rust API / WASM engine over the
+ * The stack's own resources are served by the native Rust API over the
  * `/api/{app}/v1/{model}/` contract. An **external** resource (a GitHub repo, an
  * Expo project, an AWS stack) is served by the proxy instead: it speaks the same
  * contract to the client, and translates each request into an upstream call,

package/dist/external/types.js

@@ -3,7 +3,7 @@
  * External-API bindings — how a rastack `app.model` is served from an upstream
  * REST or GraphQL API.
  *
- * The stack's own resources are served by the Rust API / WASM engine over the
+ * The stack's own resources are served by the native Rust API over the
  * `/api/{app}/v1/{model}/` contract. An **external** resource (a GitHub repo, an
  * Expo project, an AWS stack) is served by the proxy instead: it speaks the same
  * contract to the client, and translates each request into an upstream call,

package/dist/rastack-admin.d.ts

@@ -1,21 +1,13 @@
 #!/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.
  */
 export {};