rastack 0.0.63 → 0.0.69

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 {};

package/dist/rastack-admin.js

@@ -1,23 +1,15 @@
 #!/usr/bin/env node
 "use strict";
 /**
- * `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.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -55,47 +47,11 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
-const http = __importStar(require("http"));
 const path = __importStar(require("path"));
 const compile_1 = require("./compile");
 const harness_1 = require("./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() {
-    for (const dir of (0, harness_1.wasmBundleCandidates)(HERE)) {
-        if (fs.existsSync(path.join(dir, harness_1.WASM_ENTRY)))
-            return dir;
-    }
-    return null;
-}
-/** Serve one file if it exists and stays within `root`; else 404/403. */
-function serveUnder(res, root, relPath) {
-    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": (0, harness_1.contentType)(target) }).end(data);
-    });
-}
-/** Serve an exact file (no traversal concern — a fixed internal artifact). */
-function serveFile(res, file) {
-    fs.readFile(file, (err, data) => {
-        if (err) {
-            res.writeHead(404).end("Not found");
-            return;
-        }
-        res.writeHead(200, { "Content-Type": (0, harness_1.contentType)(file) }).end(data);
-    });
-}
+const native_server_1 = require("./dev/native-server");
+const HERE = __dirname; // dist/ when installed — admin.js lives beside us.
 /** Best-effort open the default browser at `url`. */
 function openBrowser(url) {
     const cmd = process.platform === "darwin"
@@ -110,57 +66,73 @@ function openBrowser(url) {
         /* non-fatal — the URL is printed anyway */
     }
 }
-function main(argv) {
+async function main(argv) {
     const args = (0, harness_1.parseAdminArgs)(argv);
-    console.log(`\n  rastack admin — the database console, built with React API Stack\n`);
+    const cwd = process.cwd();
+    console.log(`\n  rastack admin — the database console, on the native Rust server\n`);
     console.log(`▸ Compiling ${args.resourcesDir} → ${args.outDir}`);
     if (!(0, compile_1.runCompile)(args.resourcesDir, args.outDir)) {
         console.error("  ✗ compile failed — fix the resource graph and re-run.");
         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("  ✗ admin bundle (dist/admin.js) not found — reinstall rastack.");
         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;
+    let bin;
+    try {
+        bin = (0, native_server_1.ensureServerBinary)(cwd);
+    }
+    catch (err) {
+        console.error(`\n${err.message}\n`);
+        process.exit(1);
+    }
+    const manifest = path.resolve(cwd, args.outDir, "schema.rastack.json");
+    const warehouse = path.resolve(cwd, args.warehouseDir);
+    const child = (0, native_server_1.startNativeServer)({
+        bin,
+        command: "admin",
+        manifest,
+        warehouse,
+        addr: `127.0.0.1:${args.port}`,
+        adminAssets: HERE,
+    });
+    const stop = () => {
+        try {
+            child.kill("SIGTERM");
         }
-        if (url === "/" || url === "/index.html") {
-            res
-                .writeHead(200, { "Content-Type": "text/html; charset=utf-8" })
-                .end((0, harness_1.renderShell)("React API Stack — admin"));
-            return;
+        catch {
+            /* already gone */
         }
-        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");
+    };
+    process.on("SIGINT", () => {
+        stop();
+        process.exit(0);
     });
-    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);
+    process.on("SIGTERM", () => {
+        stop();
+        process.exit(0);
     });
+    try {
+        await (0, native_server_1.waitForTcp)(args.port, child);
+    }
+    catch (err) {
+        console.error(`\n${err.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/dist/rastack-bootstrap.js

@@ -124,60 +124,31 @@ function printPlan(cfg, reuseOidc) {
         "  ArtifactsBucket to create app backends. Nothing here is app-specific.\n");
 }
 /**
- * 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, reuseOidc) {
-    const template = (0, io_1.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 {
-        (0, io_1.awsRun)((0, config_1.bootstrapStackArgs)(cfg, reuseOidc, template));
-    }
-    catch (err) {
-        if (reuseOidc) {
-            console.error(`\n  ✗ bootstrap stack deploy failed.\n    ${err.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 {
-            (0, io_1.awsRun)((0, config_1.bootstrapStackArgs)(cfg, true, template));
-        }
-        catch (retryErr) {
-            console.error(`\n  ✗ bootstrap stack deploy failed.\n    ${retryErr.message}`);
-            process.exit(1);
-        }
-    }
-}
-/** Stand the tier-0 bootstrap stack up and upload the Lambda placeholder. */
-function standUp(cfg, reuseOidc) {
+async function standUp(cfg, reuseOidc) {
     if (!(0, io_1.awsAvailable)()) {
         console.error("  ✗ the AWS CLI is not on PATH. Install it and configure credentials,\n" +
             "    or re-run with --print to see the command.");
         process.exit(1);
     }
-    const stack = (0, config_1.bootstrapStackName)(cfg);
-    const existing = (0, io_1.stackOutput)(stack, config_1.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 = (0, io_1.stackOutput)(stack, config_1.BOOTSTRAP_ARTIFACTS_OUTPUT, cfg.region);
-    const templatesBucket = (0, io_1.stackOutput)(stack, config_1.BOOTSTRAP_TEMPLATES_OUTPUT, cfg.region);
-    if (!artifactsBucket) {
-        console.error("  ✗ bootstrap stack deployed but its ArtifactsBucket output could not be read.");
+    // Verify the AWS CLI is logged in before attempting a stack deploy.
+    const account = (0, io_1.awsIdentity)(cfg.region);
+    if (!account) {
+        console.error("  ✗ 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 = (0, config_1.bootstrapStackName)(cfg);
+    const { artifactsBucket, templatesBucket } = await (0, io_1.ensureBootstrapStack)(cfg, reuseOidc).catch((err) => {
+        console.error(`\n  ✗ ${err.message}`);
+        process.exit(1);
+    });
     console.log(`  ✓ artifacts bucket:  ${artifactsBucket}`);
     if (templatesBucket)
         console.log(`  ✓ templates bucket:  ${templatesBucket}`);
@@ -220,7 +191,7 @@ async function main(argv) {
             return;
         }
     }
-    standUp(cfg, flags.reuseOidc);
+    await standUp(cfg, flags.reuseOidc);
 }
 if (require.main === module) {
     main(process.argv.slice(2)).catch((err) => {

package/dist/rastack-design.d.ts

@@ -11,7 +11,6 @@
  * 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.
  */
 export {};

package/dist/rastack-design.js

@@ -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.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;

package/dist/rastack-dev.d.ts

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