rastack 0.0.56 → 0.0.58

package/dist/compile/index.d.ts

@@ -4,6 +4,7 @@ export { analyze, analyzeDsl } from "./analyze";
 export { analyzeEntities, detectCycles } from "./entities";
 export type { EntityAnalysis, EntityDiagnostic, EntityTypeExport, } from "./entities";
 export { buildManifest } from "./manifest";
+export { runCompile } from "./run";
 export { buildOpenApi, writeSchema } from "./openapi";
 export * from "./model";
 export interface CompileResult {

package/dist/compile/index.js

@@ -36,7 +36,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeSchema = exports.buildOpenApi = exports.buildManifest = exports.detectCycles = exports.analyzeEntities = exports.analyzeDsl = exports.analyze = void 0;
+exports.writeSchema = exports.buildOpenApi = exports.runCompile = exports.buildManifest = exports.detectCycles = exports.analyzeEntities = exports.analyzeDsl = exports.analyze = void 0;
 exports.resolveResourceFiles = resolveResourceFiles;
 exports.analyzeProject = analyzeProject;
 exports.detectTransitionProblems = detectTransitionProblems;
@@ -61,6 +61,8 @@ Object.defineProperty(exports, "analyzeEntities", { enumerable: true, get: funct
 Object.defineProperty(exports, "detectCycles", { enumerable: true, get: function () { return entities_2.detectCycles; } });
 var manifest_2 = require("./manifest");
 Object.defineProperty(exports, "buildManifest", { enumerable: true, get: function () { return manifest_2.buildManifest; } });
+var run_1 = require("./run");
+Object.defineProperty(exports, "runCompile", { enumerable: true, get: function () { return run_1.runCompile; } });
 var openapi_2 = require("./openapi");
 Object.defineProperty(exports, "buildOpenApi", { enumerable: true, get: function () { return openapi_2.buildOpenApi; } });
 Object.defineProperty(exports, "writeSchema", { enumerable: true, get: function () { return openapi_2.writeSchema; } });
@@ -96,7 +98,8 @@ function resolveResourceFiles(input) {
                     if (!IGNORE_DIRS.has(entry.name))
                         walk(path.join(dir, entry.name));
                 }
-                else if (/\.tsx?$/.test(entry.name) && !entry.name.endsWith(".d.ts")) {
+                else if (/\.tsx?$/.test(entry.name) &&
+                    !entry.name.endsWith(".d.ts")) {
                     files.push(path.resolve(dir, entry.name));
                 }
             }
@@ -124,7 +127,9 @@ function analyzeProject(input) {
         ...fromDsl.resources,
         ...fromInterfaces.resources.filter((r) => !defined.has(`${r.app}.${r.model}`)),
     ];
-    resources.sort((a, b) => a.app === b.app ? a.model.localeCompare(b.model) : a.app.localeCompare(b.app));
+    resources.sort((a, b) => a.app === b.app
+        ? a.model.localeCompare(b.model)
+        : a.app.localeCompare(b.app));
     // Registry entries follow the same merge rule as the resources: the DSL
     // definition wins an `app.model` collision.
     const types = [

package/dist/compile/run.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Run the compiler **in-process**, writing `schema.rastack.json` +
+ * `openapi.json` (and `rastack-env.d.ts`) into `outDir`. Prints any warnings
+ * and, on failure, the error; returns `true` on success.
+ *
+ * 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 ci` — the deploy pipeline (compile the manifest the Rust backend
+ *     reads + the OpenAPI contract, then build/ship).
+ */
+export declare function runCompile(resourcesDir: string, outDir: string): boolean;

package/dist/compile/run.js

@@ -0,0 +1,63 @@
+"use strict";
+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.runCompile = runCompile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const index_1 = require("./index");
+/**
+ * Run the compiler **in-process**, writing `schema.rastack.json` +
+ * `openapi.json` (and `rastack-env.d.ts`) into `outDir`. Prints any warnings
+ * and, on failure, the error; returns `true` on success.
+ *
+ * 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 ci` — the deploy pipeline (compile the manifest the Rust backend
+ *     reads + the OpenAPI contract, then build/ship).
+ */
+function runCompile(resourcesDir, outDir) {
+    try {
+        const result = (0, index_1.compile)(resourcesDir, outDir);
+        for (const d of result.diagnostics)
+            console.warn(`  ⚠ ${d.message}`);
+        return fs.existsSync(path.join(outDir, "schema.rastack.json"));
+    }
+    catch (err) {
+        console.error(`  ✗ ${err.message}`);
+        return false;
+    }
+}

package/dist/deploy/ci.d.ts

@@ -20,10 +20,17 @@ export type CiPhase = "check" | "build" | "deploy";
 export interface CiStep {
     /** Human label, echoed before the step runs. */
     name: string;
-    /** The shell command to execute. */
+    /** The shell command to execute (or, for an in-process step, a description). */
     run: string;
     /** Working directory relative to the repo root (default: repo root). */
     cwd?: string;
+    /**
+     * When set, the step is executed **in-process by the CLI** rather than through
+     * a shell — `run` is then a human-readable description, not a command. Today
+     * the only in-process action is `"compile"`, which the CLI runs via the shared
+     * compiler (`runCompile`) instead of shelling out to a standalone command.
+     */
+    action?: "compile";
 }
 export interface CiPlanOptions {
     /** How to invoke the rastack CLI for nested steps (default: `rastack`). */

package/dist/deploy/ci.js

@@ -21,6 +21,19 @@ exports.checkSteps = checkSteps;
 exports.buildSteps = buildSteps;
 exports.deploySteps = deploySteps;
 exports.ciPlan = ciPlan;
+/**
+ * The in-process compile step shared by `check` and `build`: it produces
+ * `schema.rastack.json` + `openapi.json` in `cfg.outDir` without a subprocess,
+ * so compilation lives inside the two modalities of use (`dev` and `ci`) rather
+ * than in a separately-invoked `compile` command.
+ */
+function compileStep(cfg) {
+    return {
+        name: "Compile manifest + OpenAPI",
+        run: `compile ${cfg.resourcesDir} ${cfg.outDir} (in-process)`,
+        action: "compile",
+    };
+}
 /**
  * A stack Output value: the literal from `cfg.outputs` if wired, else a shell
  * command substitution that resolves it live from CloudFormation. Keeping the
@@ -46,10 +59,7 @@ function checkSteps(cfg, bin) {
             name: "Validate resource graph",
             run: `${bin} check ${cfg.resourcesDir}`,
         },
-        {
-            name: "Compile manifest + OpenAPI",
-            run: `${bin} compile ${cfg.resourcesDir} ${cfg.outDir}`,
-        },
+        compileStep(cfg),
     ];
 }
 /**
@@ -58,15 +68,11 @@ function checkSteps(cfg, bin) {
  * binary together with the files it reads at `/var/task`.
  */
 function buildSteps(cfg, opts = {}) {
-    const bin = opts.bin ?? "rastack";
     const stage = stageDir(cfg);
     const archFlag = cfg.lambda.arch === "arm64" ? "--arm64" : "--x86-64";
     const jwks = stackOutput(cfg, "JwksUrl", opts.jwksUrl ?? cfg.outputs?.jwksUrl);
     return [
-        {
-            name: "Compile manifest + OpenAPI",
-            run: `${bin} compile ${cfg.resourcesDir} ${cfg.outDir}`,
-        },
+        compileStep(cfg),
         {
             name: "Cross-build the Lambda binary",
             run: `cargo lambda build --release ${archFlag} --bin ${cfg.lambda.bin} --features ${cfg.lambda.features}`,

package/dist/dev/harness.js

@@ -202,13 +202,30 @@ function renderShell(title = "React API Stack — admin") {
 <meta name="viewport" content="width=device-width, initial-scale=1" />
 <title>${title}</title>
 <style>
-  html, body { margin: 0; height: 100%; }
+  html, body { margin: 0; height: 100%; background: #F2F5FB;
+    font-family: "Inter", system-ui, -apple-system, "Segoe UI", Roboto, sans-serif; }
+  @media (prefers-color-scheme: dark) { html, body { background: #06080F; } }
   #root { min-height: 100%; }
-  .rastack-boot { font: 14px system-ui, sans-serif; padding: 2rem; color: #555; }
+  .rastack-boot { min-height: 100vh; display: flex; flex-direction: column;
+    align-items: center; justify-content: center; gap: 20px; }
+  .rastack-boot-logo { width: 60px; height: 60px; border-radius: 18px; background: #4F6BFF;
+    box-shadow: 0 8px 24px rgba(79,107,255,0.30); animation: rastack-boot-bob 3s ease-in-out infinite; }
+  .rastack-boot-track { position: relative; width: 168px; height: 4px; border-radius: 999px;
+    overflow: hidden; background: rgba(11,16,32,0.10); }
+  @media (prefers-color-scheme: dark) { .rastack-boot-track { background: rgba(233,239,255,0.14); } }
+  .rastack-boot-track::after { content: ""; position: absolute; top: 0; left: -42%; height: 100%;
+    width: 40%; border-radius: inherit; background: linear-gradient(90deg, transparent, #4F6BFF);
+    animation: rastack-boot-slide 1.25s cubic-bezier(0.5,0.1,0.3,1) infinite; }
+  @keyframes rastack-boot-bob { 0%,100% { transform: translateY(0); } 50% { transform: translateY(-3px); } }
+  @keyframes rastack-boot-slide { to { left: 100%; } }
+  @media (prefers-reduced-motion: reduce) {
+    .rastack-boot-logo { animation: none; }
+    .rastack-boot-track::after { animation: none; left: 0; width: 100%; }
+  }
 </style>
 </head>
 <body>
-<div id="root"><div class="rastack-boot">Loading the WASM engine…</div></div>
+<div id="root"><div class="rastack-boot"><div class="rastack-boot-logo"></div><div class="rastack-boot-track"></div></div></div>
 <script src="/dev/admin.js"></script>
 </body>
 </html>

package/dist/rastack-admin.js

@@ -57,16 +57,9 @@ 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.
-/** Compile the resources to schema.rastack.json + openapi.json in outDir. */
-function compile(resourcesDir, outDir) {
-    const compiler = path.join(HERE, "rastack-compile.js");
-    const result = (0, child_process_1.spawnSync)(process.execPath, [compiler, "compile", resourcesDir, outDir], { stdio: "inherit" });
-    if (result.status !== 0)
-        return false;
-    return fs.existsSync(path.join(outDir, "schema.rastack.json"));
-}
 /** Locate the prebuilt wasm bundle dir shipped in the package (no cargo fallback). */
 function resolveWasmDir() {
     for (const dir of (0, harness_1.wasmBundleCandidates)(HERE)) {
@@ -121,7 +114,7 @@ function main(argv) {
     const args = (0, harness_1.parseAdminArgs)(argv);
     console.log(`\n  rastack admin — the database console, built with React API Stack\n`);
     console.log(`▸ Compiling ${args.resourcesDir} → ${args.outDir}`);
-    if (!compile(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);
     }

package/dist/rastack-ci.js

@@ -18,6 +18,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
+const compile_1 = require("./compile");
 const ci_1 = require("./deploy/ci");
 const io_1 = require("./deploy/io");
 const PHASES = ["check", "build", "deploy"];
@@ -74,12 +75,23 @@ function printPlan(phase, steps) {
     steps.forEach((s, i) => {
         const at = s.cwd ? ` (in ${s.cwd}/)` : "";
         console.log(`  ${i + 1}. ${s.name}${at}`);
-        console.log(`     $ ${s.run}\n`);
+        // In-process steps have no shell command; `run` is a description.
+        console.log(`     ${s.action ? "» " : "$ "}${s.run}\n`);
     });
 }
-function runSteps(phase, steps) {
+function runSteps(phase, steps, cfg) {
     for (const step of steps) {
         console.log(`\n▸ ${step.name}${step.cwd ? ` (in ${step.cwd}/)` : ""}`);
+        if (step.action === "compile") {
+            // Compilation runs in-process — it lives inside `ci` (and `dev`), not in a
+            // separately-invoked `compile` command.
+            console.log(`  » ${step.run}`);
+            if (!(0, compile_1.runCompile)(cfg.resourcesDir, cfg.outDir)) {
+                console.error(`\n  ✗ step failed: ${step.name}`);
+                process.exit(1);
+            }
+            continue;
+        }
         console.log(`  $ ${step.run}`);
         try {
             // Runs a CI pipeline step derived from the developer's own deploy config
@@ -111,7 +123,7 @@ function main(argv) {
     if (plan)
         printPlan(phase, steps);
     else
-        runSteps(phase, steps);
+        runSteps(phase, steps, cfg);
 }
 if (require.main === module) {
     main(process.argv.slice(2));

package/dist/rastack-compile.d.ts

@@ -1,11 +1,14 @@
 #!/usr/bin/env node
 /**
- * `rastack compile | check | list | urls` — the TypeScript-first replacement for the
- * old Django `manage.py rastack` command.
+ * `rastack check | list | urls` — introspection over the TypeScript-first
+ * resource graph.
  *
- *   rastack compile [resourcesDir] [outDir]   defs → schema.rastack.json + openapi.json
  *   rastack check   [resourcesDir]            validate the resource graph (exit != 0 on error)
  *   rastack list    [resourcesDir]            print every resource + its fields/relations
  *   rastack urls    [resourcesDir]            print the generated /api/{app}/v1/{model}/ routes
+ *
+ * Compilation itself (defs → schema.rastack.json + openapi.json) is no longer a
+ * command here: it runs in-process inside the two modalities of use — `rastack
+ * dev`/`admin` (local) and `rastack ci` (deploy) — via the shared `runCompile`.
  */
 export {};

package/dist/rastack-compile.js

@@ -1,30 +1,23 @@
 #!/usr/bin/env node
 "use strict";
 /**
- * `rastack compile | check | list | urls` — the TypeScript-first replacement for the
- * old Django `manage.py rastack` command.
+ * `rastack check | list | urls` — introspection over the TypeScript-first
+ * resource graph.
  *
- *   rastack compile [resourcesDir] [outDir]   defs → schema.rastack.json + openapi.json
  *   rastack check   [resourcesDir]            validate the resource graph (exit != 0 on error)
  *   rastack list    [resourcesDir]            print every resource + its fields/relations
  *   rastack urls    [resourcesDir]            print the generated /api/{app}/v1/{model}/ routes
+ *
+ * Compilation itself (defs → schema.rastack.json + openapi.json) is no longer a
+ * command here: it runs in-process inside the two modalities of use — `rastack
+ * dev`/`admin` (local) and `rastack ci` (deploy) — via the shared `runCompile`.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const compile_1 = require("./compile");
 const DEFAULT_RESOURCES = "resources";
-const DEFAULT_OUT = ".rastack";
 function main(argv) {
     const [sub, ...rest] = argv;
     switch (sub) {
-        case "compile": {
-            const resourcesDir = rest[0] || DEFAULT_RESOURCES;
-            const outDir = rest[1] || DEFAULT_OUT;
-            const result = (0, compile_1.compile)(resourcesDir, outDir);
-            for (const d of result.diagnostics)
-                console.warn(`  ⚠ ${d.message}`);
-            console.log(`✓ compiled ${result.manifest.resources.length} resource(s) → ${result.files.join(", ")}`);
-            break;
-        }
         case "check": {
             const { resources, diagnostics } = (0, compile_1.analyzeProject)(rest[0] || DEFAULT_RESOURCES);
             const errors = [
@@ -54,7 +47,9 @@ function main(argv) {
             for (const r of resources) {
                 console.log(`${r.app}.${r.model}`);
                 for (const f of r.fields) {
-                    const rel = f.relation ? ` → ${f.relation.app}.${f.relation.model}` : "";
+                    const rel = f.relation
+                        ? ` → ${f.relation.app}.${f.relation.model}`
+                        : "";
                     console.log(`  ${f.name}: ${f.type}${rel}`);
                 }
                 if (r.sync) {
@@ -78,9 +73,8 @@ function main(argv) {
             break;
         }
         default:
-            console.error(`Unknown compile subcommand: "${sub}"\n\n` +
+            console.error(`Unknown subcommand: "${sub}"\n\n` +
                 `Usage:\n` +
-                `  rastack compile [resourcesDir] [outDir]\n` +
                 `  rastack check   [resourcesDir]\n` +
                 `  rastack list    [resourcesDir]\n` +
                 `  rastack urls    [resourcesDir]\n`);

package/dist/rastack-dev.js

@@ -57,21 +57,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const http = __importStar(require("http"));
+const net = __importStar(require("net"));
 const path = __importStar(require("path"));
+const compile_1 = require("./compile");
 const harness_1 = require("./dev/harness");
 const HERE = __dirname; // dist/ when installed
-/** Compile the resources to schema.rastack.json + openapi.json in outDir. */
-function compile(resourcesDir, outDir) {
-    const compiler = path.join(HERE, "rastack-compile.js");
-    const result = (0, child_process_1.spawnSync)(process.execPath, [compiler, "compile", resourcesDir, outDir], { stdio: "inherit" });
-    if (result.status !== 0)
-        return false;
-    return fs.existsSync(path.join(outDir, "schema.rastack.json"));
-}
 /** True when `cargo` is on PATH (the from-source wasm fallback needs it). */
 function cargoAvailable() {
     try {
-        return ((0, child_process_1.spawnSync)("cargo", ["--version"], { stdio: "ignore" }).status === 0);
+        return (0, child_process_1.spawnSync)("cargo", ["--version"], { stdio: "ignore" }).status === 0;
     }
     catch {
         return false;
@@ -151,14 +145,198 @@ function openBrowser(url) {
         /* non-fatal — the URL is printed anyway */
     }
 }
-function main(argv) {
+// ---------------------------------------------------------------------------
+// Live-dev mode — `rastack dev` for an Expo / react-native-web app.
+//
+// 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.
+// ---------------------------------------------------------------------------
+/** True when the project is an Expo app (so `dev` should drive Metro). */
+function isExpoProject(cwd) {
+    try {
+        const appJson = JSON.parse(fs.readFileSync(path.join(cwd, "app.json"), "utf-8"));
+        if (appJson && appJson.expo)
+            return true;
+    }
+    catch {
+        /* no app.json — fall through to package.json */
+    }
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf-8"));
+        if (pkg?.dependencies?.expo || pkg?.devDependencies?.expo)
+            return true;
+    }
+    catch {
+        /* no package.json */
+    }
+    return false;
+}
+/** Locate the prebuilt wasm bundle without the cargo fallback (optional here). */
+function findWasmDir() {
+    for (const dir of (0, harness_1.wasmBundleCandidates)(HERE)) {
+        if (fs.existsSync(path.join(dir, harness_1.WASM_ENTRY)))
+            return dir;
+    }
+    return null;
+}
+/** Grab an ephemeral free TCP port for Metro (avoids a fixed-port clash). */
+function getFreePort() {
+    return new Promise((resolve, reject) => {
+        const srv = net.createServer();
+        srv.on("error", reject);
+        srv.listen(0, "127.0.0.1", () => {
+            const addr = srv.address();
+            const port = addr && typeof addr === "object" ? addr.port : 0;
+            srv.close(() => (port ? resolve(port) : reject(new Error("no free port"))));
+        });
+    });
+}
+/** Start `expo start --web` on `port`, with a reload-enabled environment. */
+function startMetro(cwd, port) {
+    // A live dev server needs watch mode, so we must NOT set CI (Expo reads it as
+    // "reloads disabled"). BROWSER=none stops Expo opening its own tab — we front
+    // it on the rastack port. `shell:true` keeps the npx / npx.cmd split portable.
+    const env = {
+        ...process.env,
+        BROWSER: "none",
+        EXPO_NO_TELEMETRY: "1",
+    };
+    delete env.CI;
+    // nosemgrep: javascript.lang.security.detect-child-process.detect-child-process
+    const child = (0, child_process_1.spawn)(`npx expo start --web --port ${port}`, {
+        cwd,
+        env,
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: true,
+    });
+    // Surface Metro's own errors (bundling failures, port issues) with a prefix.
+    child.stderr?.on("data", (d) => process.stderr.write(`  [metro] ${d}`));
+    return child;
+}
+/** Poll Metro's `/status` until it answers `packager-status:running`. */
+function waitForMetro(port, timeoutMs = 120000) {
+    const deadline = Date.now() + timeoutMs;
+    return new Promise((resolve) => {
+        const retry = () => Date.now() > deadline ? resolve(false) : setTimeout(tick, 400);
+        const tick = () => {
+            const req = http.get({ host: "127.0.0.1", port, path: "/status", timeout: 2000 }, (res) => {
+                let body = "";
+                res.on("data", (c) => (body += c));
+                res.on("end", () => body.includes("packager-status:running") ? resolve(true) : retry());
+            });
+            req.on("error", retry);
+            req.on("timeout", () => req.destroy());
+        };
+        tick();
+    });
+}
+/** Reverse-proxy one HTTP request/response pair to Metro. */
+function proxyToMetro(req, res, port) {
+    const proxyReq = http.request({ host: "127.0.0.1", port, method: req.method, path: req.url, headers: req.headers }, (proxyRes) => {
+        res.writeHead(proxyRes.statusCode || 502, proxyRes.headers);
+        proxyRes.pipe(res);
+    });
+    proxyReq.on("error", () => {
+        if (!res.headersSent)
+            res.writeHead(502);
+        res.end("Metro is not reachable.");
+    });
+    req.pipe(proxyReq);
+}
+/** Reverse-proxy a WebSocket upgrade (Metro HMR / fast-refresh) to Metro. */
+function proxyUpgrade(req, clientSocket, head, port) {
+    const upstream = net.connect(port, "127.0.0.1", () => {
+        const lines = [`${req.method} ${req.url} HTTP/1.1`];
+        for (const [k, v] of Object.entries(req.headers)) {
+            if (Array.isArray(v))
+                v.forEach((vv) => lines.push(`${k}: ${vv}`));
+            else if (v != null)
+                lines.push(`${k}: ${v}`);
+        }
+        upstream.write(lines.join("\r\n") + "\r\n\r\n");
+        if (head && head.length)
+            upstream.write(head);
+        upstream.pipe(clientSocket);
+        clientSocket.pipe(upstream);
+    });
+    upstream.on("error", () => clientSocket.destroy());
+    clientSocket.on("error", () => upstream.destroy());
+}
+/** `rastack dev` for an Expo app: start Metro and reverse-proxy to it. */
+async function runMetroMode(args, cwd) {
+    // 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();
+    const metroPort = await getFreePort();
+    console.log(`▸ Starting Metro bundler (Expo) on :${metroPort} …`);
+    const metro = startMetro(cwd, metroPort);
+    let shuttingDown = false;
+    const stop = (code = 0) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        try {
+            metro.kill();
+        }
+        catch {
+            /* already gone */
+        }
+        process.exit(code);
+    };
+    process.on("SIGINT", () => stop(0));
+    process.on("SIGTERM", () => stop(0));
+    metro.on("exit", (code) => {
+        if (!shuttingDown) {
+            console.error(`\n  ✗ Metro exited (code ${code ?? "?"}).`);
+            process.exit(code ?? 1);
+        }
+    });
+    if (!(await waitForMetro(metroPort))) {
+        console.error("  ✗ Metro did not come up in time.");
+        return stop(1);
+    }
+    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 === "/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));
+        // Everything else → the live Metro bundle (HTML, JS, assets, HMR polls).
+        return proxyToMetro(req, res, metroPort);
+    });
+    server.on("upgrade", (req, socket, head) => proxyUpgrade(req, socket, head, metroPort));
+    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(`\n  ▸ ${url}\n`);
+        console.log("  Edits reload live. Need the database console? Run `rastack admin`. Ctrl+C to stop.\n");
+        if (args.open)
+            openBrowser(url);
+    });
+}
+async function main(argv) {
     const args = (0, harness_1.parseDevArgs)(argv);
+    const cwd = process.cwd();
     console.log(`\n  rastack dev — your app, in your browser over WASM\n`);
     console.log(`▸ Compiling ${args.resourcesDir} → ${args.outDir}`);
-    if (!compile(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);
     }
+    // Serve the developer's own app when there is one; otherwise the welcome page.
+    const appRoot = resolveAppRoot(args.appDir);
+    // No static build, but an Expo source tree → drive Metro live (fast refresh).
+    if (!appRoot && isExpoProject(cwd)) {
+        return runMetroMode(args, cwd);
+    }
     const wasmDir = resolveWasmDir();
     if (!wasmDir) {
         console.error("\n  ✗ No WASM engine available.\n" +
@@ -168,8 +346,6 @@ function main(argv) {
             "      cargo install wasm-bindgen-cli\n");
         process.exit(1);
     }
-    // Serve the developer's own app when there is one; otherwise the welcome page.
-    const appRoot = resolveAppRoot(args.appDir);
     const server = http.createServer((req, res) => {
         const url = (req.url || "/").split("?")[0];
         if (req.method !== "GET") {
@@ -220,5 +396,8 @@ function main(argv) {
     });
 }
 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.d.ts

@@ -2,8 +2,10 @@
 /**
  * rastack — unified CLI for React API Stack
  *
+ * Compilation is not a command of its own: it runs in-process inside the two
+ * modalities of use — `rastack dev`/`admin` (local) and `rastack ci` (deploy).
+ *
  * Commands:
- *   rastack compile [resourcesDir] [outDir]     TypeScript resources → schema.rastack.json + openapi.json
  *   rastack check   [resourcesDir]              Validate the resource graph
  *   rastack list    [resourcesDir]              Print resources, fields and relations
  *   rastack urls    [resourcesDir]              Print the generated /api/{app}/v1/{model}/ routes