rastack 0.0.63 → 0.0.69

package/dist/compile/analyze.js

@@ -172,7 +172,17 @@ function analyzeField(name, initializer, checker) {
         const app = literalTypeProp(fieldType, "__app", checker, initializer);
         const model = literalTypeProp(fieldType, "__model", checker, initializer);
         if (app && model) {
-            return { name, type: "fk", relation: { app, model } };
+            const fk = { name, type: "fk", relation: { app, model } };
+            // `s.ref(() => X, { null: true })` — a nullable relation (a shared secret
+            // with no project, an unassigned task). The options object is the ref
+            // call's second argument, read the same way scalar constraints are.
+            if (ts.isCallExpression(initializer)) {
+                const opts = literalToValue(initializer.arguments[1]);
+                if (opts && typeof opts === "object" && opts.null === true) {
+                    fk.null = true;
+                }
+            }
+            return fk;
         }
         return undefined;
     }

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

@@ -64,6 +64,11 @@ export interface Ref<App extends string, Model extends string> {
     readonly __model: Model;
     /** The authored `() => Resource` thunk — carried at runtime. */
     readonly target?: () => ResourceType<App, Model, any>;
+    /** Optional FK constraints — `null: true` makes the relation nullable
+     * (e.g. a shared secret with no project, or an unassigned task). */
+    readonly options?: {
+        null?: boolean;
+    };
 }
 export interface StringOptions {
     maxLength?: number;
@@ -105,7 +110,9 @@ export declare const s: {
      * the relation from the *type* `Ref<App, Model>` this returns, and the
      * runtime keeps the thunk so `manifestFromResources()` can resolve it too.
      */
-    ref<A extends string, M extends string>(thunk: () => ResourceType<A, M, any>): Ref<A, M>;
+    ref<A extends string, M extends string>(thunk: () => ResourceType<A, M, any>, options?: {
+        null?: boolean;
+    }): Ref<A, M>;
 };
 export type AnyField = Scalar<string> | Ref<string, string>;
 /** Local-first sync configuration (mirrors the old Python `class Sync:`). */
@@ -118,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
@@ -157,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/define/index.js

@@ -56,8 +56,8 @@ exports.s = {
      * the relation from the *type* `Ref<App, Model>` this returns, and the
      * runtime keeps the thunk so `manifestFromResources()` can resolve it too.
      */
-    ref(thunk) {
-        return { __rastackRef: true, target: thunk };
+    ref(thunk, options) {
+        return { __rastackRef: true, target: thunk, options };
     },
 };
 /** Define a resource. Capture app/model (and options) as literal types. */

package/dist/define/manifest.js

@@ -89,11 +89,17 @@ function runtimeField(res, name, value) {
         if (!isResourceValue(target)) {
             throw new Error(`manifestFromResources: ${res.app}.${res.model}.${name} is an s.ref(...) whose target thunk did not return a resource() value`);
         }
-        return {
+        const fk = {
             name,
             type: "fk",
             relation: { app: target.app, model: target.model },
         };
+        // A nullable FK (`s.ref(() => X, { null: true })`) — e.g. a shared secret
+        // with no project — so the engine allows and stores a null relation.
+        if (field.options?.null === true) {
+            fk.null = true;
+        }
+        return fk;
     }
     if (typeof field.__rastackScalar !== "string")
         return undefined;

package/dist/deploy/io.d.ts

@@ -22,6 +22,27 @@ export declare function configPath(cwd?: string): string;
  * repo itself still works. Returns null when no candidate exists.
  */
 export declare function resolveDeployAsset(relPath: string, cwd?: string): string | null;
+/**
+ * Base URL the framework's CloudFormation templates are published at. The same
+ * site that hosts the installer (`reactapistack.com/setup.sh`) serves the base
+ * templates, so a CLI whose bundled copy is missing (a partial install, or a
+ * globally-linked dev build) can still fetch them.
+ */
+export declare const TEMPLATE_BASE_URL = "https://reactapistack.com/cloudformation";
+/**
+ * Download a published CloudFormation template to a temp file, returning its
+ * path — or null on any failure (offline, 404, write error). Used as the
+ * fallback when the template is not bundled with the install.
+ */
+export declare function downloadTemplate(name: string, base?: string): Promise<string | null>;
+/**
+ * Resolve a CloudFormation template to a local file path for `aws cloudformation
+ * deploy` (which accepts only `--template-file`). Prefers the copy bundled with
+ * the `rastack` install; when that is missing, downloads it from the React API
+ * Stack website. Returns null only when the template is neither bundled nor
+ * fetchable.
+ */
+export declare function resolveTemplateFile(name: string, cwd?: string): Promise<string | null>;
 /** Read + normalize the deploy config, or null when it does not exist yet. */
 export declare function loadConfig(cwd?: string): DeployConfig | null;
 /** Write the deploy config, creating `.rastack/` if needed. */
@@ -39,6 +60,14 @@ export declare function awsCapture(args: string[], cwd?: string): string | null;
 export declare function awsRun(args: string[], cwd?: string): void;
 /** True when the AWS CLI is on PATH. */
 export declare function awsAvailable(): boolean;
+/**
+ * The AWS account id the CLI's active credentials resolve to, or null when the
+ * CLI has no usable credentials (not logged in, an expired SSO session, or no
+ * configured profile). `init`/`bootstrap` call this to fail fast with an
+ * actionable "log in" message before attempting a stack deploy, instead of
+ * letting the first `cloudformation deploy` fail with a cryptic AWS error.
+ */
+export declare function awsIdentity(region?: string): string | null;
 /**
  * A single Output value of a CloudFormation stack, or null when the stack does
  * not exist or the key is unset. `describe-stacks` prints `None` for a missing
@@ -52,6 +81,27 @@ export declare function stackOutput(stackName: string, key: string, region: stri
  * on every `init`. Returns false when the placeholder file is missing.
  */
 export declare function uploadPlaceholder(artifactsBucket: string, region: string, cwd?: string): boolean;
+/**
+ * Deploy the tier-0 bootstrap stack, retrying once against an account that
+ * already has a GitHub OIDC provider — AWS allows only one provider per URL, so
+ * a second create is rejected and the retry tells the template to reuse the
+ * existing one. Throws on failure (after the retry). Shared by `rastack init`
+ * and `rastack bootstrap` so both stand the stack up identically.
+ */
+export declare function deployBootstrap(cfg: DeployConfig, reuseOidc: boolean, template: string): void;
+/**
+ * Ensure the tier-0 bootstrap stack exists for this account+region, **creating
+ * it when missing**, and return its artifacts/templates buckets. This is why
+ * `rastack init` is a single command that stands up *everything* — the
+ * account-level bootstrap stack and the per-app backend — with no separate
+ * `rastack bootstrap` step. Idempotent: an existing stack is reconciled in
+ * place. Throws with an actionable message when the template cannot be resolved,
+ * the deploy fails, or the buckets can't be read back.
+ */
+export declare function ensureBootstrapStack(cfg: DeployConfig, reuseOidc?: boolean): Promise<{
+    artifactsBucket: string;
+    templatesBucket: string | null;
+}>;
 /** True when the GitHub CLI is on PATH. */
 export declare function ghAvailable(): boolean;
 /**

package/dist/deploy/io.js

@@ -38,8 +38,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEMPLATE_BASE_URL = void 0;
 exports.configPath = configPath;
 exports.resolveDeployAsset = resolveDeployAsset;
+exports.downloadTemplate = downloadTemplate;
+exports.resolveTemplateFile = resolveTemplateFile;
 exports.loadConfig = loadConfig;
 exports.saveConfig = saveConfig;
 exports.gitRemoteUrl = gitRemoteUrl;
@@ -47,8 +50,11 @@ exports.canPrompt = canPrompt;
 exports.awsCapture = awsCapture;
 exports.awsRun = awsRun;
 exports.awsAvailable = awsAvailable;
+exports.awsIdentity = awsIdentity;
 exports.stackOutput = stackOutput;
 exports.uploadPlaceholder = uploadPlaceholder;
+exports.deployBootstrap = deployBootstrap;
+exports.ensureBootstrapStack = ensureBootstrapStack;
 exports.ghAvailable = ghAvailable;
 exports.ghAuthenticated = ghAuthenticated;
 exports.ghAuthLogin = ghAuthLogin;
@@ -58,6 +64,7 @@ exports.ask = ask;
 exports.withPrompt = withPrompt;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
+const https = __importStar(require("https"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const readline = __importStar(require("readline"));
@@ -97,6 +104,54 @@ function resolveDeployAsset(relPath, cwd = process.cwd()) {
     }
     return null;
 }
+/**
+ * Base URL the framework's CloudFormation templates are published at. The same
+ * site that hosts the installer (`reactapistack.com/setup.sh`) serves the base
+ * templates, so a CLI whose bundled copy is missing (a partial install, or a
+ * globally-linked dev build) can still fetch them.
+ */
+exports.TEMPLATE_BASE_URL = "https://reactapistack.com/cloudformation";
+/**
+ * Download a published CloudFormation template to a temp file, returning its
+ * path — or null on any failure (offline, 404, write error). Used as the
+ * fallback when the template is not bundled with the install.
+ */
+function downloadTemplate(name, base = exports.TEMPLATE_BASE_URL) {
+    const url = `${base}/${name}`;
+    return new Promise((resolve) => {
+        https
+            .get(url, (res) => {
+            if (res.statusCode !== 200) {
+                res.resume();
+                resolve(null);
+                return;
+            }
+            const chunks = [];
+            res.on("data", (c) => chunks.push(c));
+            res.on("end", () => {
+                try {
+                    const dest = path.join(os.tmpdir(), `rastack-${path.basename(name)}`);
+                    fs.writeFileSync(dest, Buffer.concat(chunks));
+                    resolve(dest);
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        })
+            .on("error", () => resolve(null));
+    });
+}
+/**
+ * Resolve a CloudFormation template to a local file path for `aws cloudformation
+ * deploy` (which accepts only `--template-file`). Prefers the copy bundled with
+ * the `rastack` install; when that is missing, downloads it from the React API
+ * Stack website. Returns null only when the template is neither bundled nor
+ * fetchable.
+ */
+async function resolveTemplateFile(name, cwd = process.cwd()) {
+    return resolveDeployAsset(name, cwd) ?? (await downloadTemplate(name));
+}
 /** Read + normalize the deploy config, or null when it does not exist yet. */
 function loadConfig(cwd = process.cwd()) {
     const file = configPath(cwd);
@@ -163,6 +218,26 @@ function awsRun(args, cwd = process.cwd()) {
 function awsAvailable() {
     return awsCapture(["--version"]) !== null;
 }
+/**
+ * The AWS account id the CLI's active credentials resolve to, or null when the
+ * CLI has no usable credentials (not logged in, an expired SSO session, or no
+ * configured profile). `init`/`bootstrap` call this to fail fast with an
+ * actionable "log in" message before attempting a stack deploy, instead of
+ * letting the first `cloudformation deploy` fail with a cryptic AWS error.
+ */
+function awsIdentity(region) {
+    const args = [
+        "sts",
+        "get-caller-identity",
+        "--query",
+        "Account",
+        "--output",
+        "text",
+    ];
+    if (region)
+        args.push("--region", region);
+    return awsCapture(args);
+}
 /**
  * A single Output value of a CloudFormation stack, or null when the stack does
  * not exist or the key is unset. `describe-stacks` prints `None` for a missing
@@ -210,6 +285,55 @@ function uploadPlaceholder(artifactsBucket, region, cwd = process.cwd()) {
     ]);
     return true;
 }
+/**
+ * Deploy the tier-0 bootstrap stack, retrying once against an account that
+ * already has a GitHub OIDC provider — AWS allows only one provider per URL, so
+ * a second create is rejected and the retry tells the template to reuse the
+ * existing one. Throws on failure (after the retry). Shared by `rastack init`
+ * and `rastack bootstrap` so both stand the stack up identically.
+ */
+function deployBootstrap(cfg, reuseOidc, template) {
+    try {
+        awsRun((0, config_1.bootstrapStackArgs)(cfg, reuseOidc, template));
+    }
+    catch (err) {
+        if (reuseOidc)
+            throw err;
+        console.log("  • retrying bootstrap, reusing the account's existing GitHub OIDC provider");
+        awsRun((0, config_1.bootstrapStackArgs)(cfg, true, template));
+    }
+}
+/**
+ * Ensure the tier-0 bootstrap stack exists for this account+region, **creating
+ * it when missing**, and return its artifacts/templates buckets. This is why
+ * `rastack init` is a single command that stands up *everything* — the
+ * account-level bootstrap stack and the per-app backend — with no separate
+ * `rastack bootstrap` step. Idempotent: an existing stack is reconciled in
+ * place. Throws with an actionable message when the template cannot be resolved,
+ * the deploy fails, or the buckets can't be read back.
+ */
+async function ensureBootstrapStack(cfg, reuseOidc = false) {
+    const stack = (0, config_1.bootstrapStackName)(cfg);
+    const existing = stackOutput(stack, config_1.BOOTSTRAP_ARTIFACTS_OUTPUT, cfg.region);
+    if (existing) {
+        console.log(`  ✓ bootstrap stack ${stack} already exists — reconciling`);
+    }
+    else {
+        console.log(`\n▸ Creating the tier-0 bootstrap stack ${stack} (@ ${cfg.region})`);
+    }
+    const template = await resolveTemplateFile("bootstrap.yaml");
+    if (!template) {
+        throw new Error("bootstrap.yaml template not found in the rastack package and could not be\n" +
+            "    downloaded from reactapistack.com. Reinstall rastack (`npm i -g rastack`).");
+    }
+    deployBootstrap(cfg, reuseOidc, template);
+    const artifactsBucket = stackOutput(stack, config_1.BOOTSTRAP_ARTIFACTS_OUTPUT, cfg.region);
+    const templatesBucket = stackOutput(stack, config_1.BOOTSTRAP_TEMPLATES_OUTPUT, cfg.region);
+    if (!artifactsBucket) {
+        throw new Error(`bootstrap stack ${stack} deployed but its ArtifactsBucket output could not be read.`);
+    }
+    return { artifactsBucket, templatesBucket };
+}
 // ── GitHub CLI boundary ──────────────────────────────────────────────────────
 // After the stack is up `init` wires the two repo Variables CI reads
 // (AWS_DEPLOY_ROLE_ARN / AWS_REGION) through the developer's own `gh` — already

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