rastack 0.0.55 → 0.0.57

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.d.ts

@@ -1,16 +1,20 @@
 /**
  * Pure core of `rastack dev` — the local, always-WASM development server.
  *
- * `rastack dev` boots the app + admin **in the browser** over the WebAssembly
- * engine (the same app-generic `rastack-api-core` the Lambda runs, fed the app's
+ * `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, and
- * the committed Iceberg warehouse, and a bundled React admin drives it.
+ * 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`.
+ *
+ * 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, the HTML shell) 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 serves.
+ * 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.
  */
 export interface DevArgs {
     /** Where the TypeScript resource definitions live (compiled on start). */
@@ -19,6 +23,12 @@ export interface DevArgs {
     outDir: string;
     /** The committed Iceberg warehouse served to seed the browser engine. */
     warehouseDir: string;
+    /**
+     * Explicit app root to serve at `/` (its `index.html`). Empty when unset —
+     * the IO wrapper then probes `appRootCandidates`, falling back to the welcome
+     * page when none holds an `index.html`.
+     */
+    appDir: string;
     /** Port the dev server listens on. */
     port: number;
     /** Open the browser on start (false with `--no-open`). */
@@ -26,10 +36,21 @@ export interface DevArgs {
 }
 export declare const DEV_DEFAULTS: DevArgs;
 /**
- * Parse `rastack dev` args: `--port`, `--warehouse`, `--out`, `--no-open`, and a
- * single positional resources dir. Unknown flags are ignored (forgiving CLI).
+ * Parse `rastack dev` args: `--port`, `--warehouse`, `--out`, `--app`,
+ * `--no-open`, and a single positional resources dir. Unknown flags are ignored
+ * (forgiving CLI).
  */
 export declare function parseDevArgs(argv: string[]): DevArgs;
+/** The file that marks a directory as a servable app root. */
+export declare const APP_ENTRY = "index.html";
+/**
+ * Ordered directories to probe for the developer's app (`index.html`). An
+ * explicit `--app <dir>` wins outright; otherwise `dev` looks in the
+ * conventional static roots and finally the project root. The IO wrapper picks
+ * the first candidate that actually holds an `index.html`; if none does, it
+ * serves the welcome page instead.
+ */
+export declare function appRootCandidates(appDir: string, cwd?: string): string[];
 /** Args for `rastack admin` — like `DevArgs`, but bound to a real server port. */
 export interface AdminArgs {
     resourcesDir: string;
@@ -62,9 +83,19 @@ export declare function wasmBundleCandidates(dirnameDir: string, cwd?: string):
 /** The name of the file that marks a directory as a usable wasm bundle. */
 export declare const WASM_ENTRY = "rastack_wasm.js";
 /**
- * The HTML shell served at `/`. 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. Deliberately tiny —
- * all logic lives in the bundle — mirroring the `rastack design` studio.
+ * 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.
+ * 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).
  */
 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.
+ */
+export declare function renderWelcome(title?: string): string;

package/dist/dev/harness.js

@@ -2,16 +2,20 @@
 /**
  * Pure core of `rastack dev` — the local, always-WASM development server.
  *
- * `rastack dev` boots the app + admin **in the browser** over the WebAssembly
- * engine (the same app-generic `rastack-api-core` the Lambda runs, fed the app's
+ * `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, and
- * the committed Iceberg warehouse, and a bundled React admin drives it.
+ * 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`.
+ *
+ * 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, the HTML shell) 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 serves.
+ * 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.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -47,27 +51,31 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WASM_ENTRY = exports.ADMIN_DEFAULTS = exports.DEV_DEFAULTS = void 0;
+exports.WASM_ENTRY = 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.renderShell = renderShell;
+exports.renderWelcome = renderWelcome;
 const path = __importStar(require("path"));
 exports.DEV_DEFAULTS = {
     resourcesDir: "resources",
     outDir: ".rastack",
     warehouseDir: "data/warehouse",
+    appDir: "",
     port: 4321,
     open: true,
 };
 /**
- * Parse `rastack dev` args: `--port`, `--warehouse`, `--out`, `--no-open`, and a
- * single positional resources dir. Unknown flags are ignored (forgiving CLI).
+ * Parse `rastack dev` args: `--port`, `--warehouse`, `--out`, `--app`,
+ * `--no-open`, and a single positional resources dir. Unknown flags are ignored
+ * (forgiving CLI).
  */
 function parseDevArgs(argv) {
     const positional = [];
-    let { resourcesDir, outDir, warehouseDir, port, open } = exports.DEV_DEFAULTS;
+    let { resourcesDir, outDir, warehouseDir, appDir, port, open } = exports.DEV_DEFAULTS;
     for (let i = 0; i < argv.length; i++) {
         const a = argv[i];
         if (a === "--port")
@@ -76,6 +84,8 @@ function parseDevArgs(argv) {
             warehouseDir = argv[++i] ?? warehouseDir;
         else if (a === "--out")
             outDir = argv[++i] ?? outDir;
+        else if (a === "--app")
+            appDir = argv[++i] ?? appDir;
         else if (a === "--no-open")
             open = false;
         else if (!a.startsWith("-"))
@@ -85,10 +95,25 @@ function parseDevArgs(argv) {
         resourcesDir: positional[0] || resourcesDir,
         outDir,
         warehouseDir,
+        appDir,
         port,
         open,
     };
 }
+/** The file that marks a directory as a servable app root. */
+exports.APP_ENTRY = "index.html";
+/**
+ * Ordered directories to probe for the developer's app (`index.html`). An
+ * explicit `--app <dir>` wins outright; otherwise `dev` looks in the
+ * conventional static roots and finally the project root. The IO wrapper picks
+ * the first candidate that actually holds an `index.html`; if none does, it
+ * serves the welcome page instead.
+ */
+function appRootCandidates(appDir, cwd = process.cwd()) {
+    if (appDir)
+        return [path.resolve(cwd, appDir)];
+    return ["public", "www", "app", "."].map((d) => path.resolve(cwd, d));
+}
 exports.ADMIN_DEFAULTS = {
     resourcesDir: "resources",
     outDir: ".rastack",
@@ -162,12 +187,14 @@ function wasmBundleCandidates(dirnameDir, cwd = process.cwd()) {
 /** 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 `/`. 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. Deliberately tiny —
- * all logic lives in the bundle — mirroring the `rastack design` studio.
+ * 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.
+ * 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).
  */
-function renderShell(title = "React API Stack — dev") {
+function renderShell(title = "React API Stack — admin") {
     return `<!doctype html>
 <html lang="en">
 <head>
@@ -187,3 +214,77 @@ function renderShell(title = "React API Stack — dev") {
 </html>
 `;
 }
+/**
+ * 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.
+ */
+function renderWelcome(title = "React API Stack — dev") {
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>${title}</title>
+<style>
+  :root { color-scheme: light dark; }
+  * { box-sizing: border-box; }
+  html, body { margin: 0; min-height: 100%; }
+  body {
+    font: 15px/1.6 system-ui, -apple-system, "Segoe UI", sans-serif;
+    color: #1f2328; background: #f6f8fa;
+    display: flex; align-items: center; justify-content: center; padding: 2rem;
+  }
+  .card {
+    max-width: 640px; width: 100%; background: #fff; border: 1px solid #d0d7de;
+    border-radius: 14px; padding: 2.5rem; box-shadow: 0 1px 3px rgba(0,0,0,.06);
+  }
+  .rocket { font-size: 2.5rem; line-height: 1; }
+  h1 { font-size: 1.5rem; margin: .75rem 0 .25rem; }
+  p.lead { color: #57606a; margin: 0 0 1.5rem; }
+  code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+    background: #eff1f3; padding: .1em .4em; border-radius: 5px; font-size: .9em; }
+  ul { padding-left: 1.1rem; margin: 0; }
+  li { margin: .4rem 0; }
+  a { color: #0969da; text-decoration: none; }
+  a:hover { text-decoration: underline; }
+  .foot { margin-top: 1.75rem; padding-top: 1.25rem; border-top: 1px solid #eaeef2;
+    color: #6e7781; font-size: .85rem; }
+  @media (prefers-color-scheme: dark) {
+    body { color: #e6edf3; background: #0d1117; }
+    .card { background: #161b22; border-color: #30363d; box-shadow: none; }
+    p.lead { color: #8b949e; }
+    code { background: #21262d; }
+    .foot { border-color: #21262d; color: #8b949e; }
+  }
+</style>
+</head>
+<body>
+<div class="card">
+  <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.
+  </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:
+      <a href="/schema.rastack.json">/schema.rastack.json</a>,
+      <a href="/openapi.json">/openapi.json</a>,
+      <code>/data/warehouse/…</code>, <code>/wasm/…</code>.</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>
+</div>
+</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.d.ts

@@ -1,17 +1,21 @@
 #!/usr/bin/env node
 /**
- * `rastack dev` — local development, always over the WASM engine.
+ * `rastack dev` — local development of **your app**, always over the WASM engine.
  *
- *   rastack dev [resourcesDir] [--port <n>] [--warehouse <dir>] [--out <dir>] [--no-open]
+ *   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 app +
- * admin locally over WebAssembly — no native server, no cargo:
- *   • the bundled React admin (`/dev/admin.js`),
+ * `rastack design`) that hands the browser everything it needs to run the
+ * developer's own app locally over WebAssembly — no native server, no cargo:
+ *   • 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.
  *
+ * 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.
  */