rastack 0.0.57 → 0.0.59

package/dist/rastack-dev.js

@@ -57,6 +57,7 @@ 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");
@@ -144,14 +145,208 @@ 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.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+            console.error(`\n  ✗ Port ${args.port} is already in use — is \`rastack dev\` already running?\n` +
+                `    Stop it, or pick another port: rastack dev --port <n>\n`);
+        }
+        else {
+            console.error(`\n  ✗ dev server error: ${err.message}`);
+        }
+        stop(1);
+    });
+    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 (!(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" +
@@ -161,8 +356,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") {
@@ -213,5 +406,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-wasm-build.d.ts

@@ -5,7 +5,7 @@
  *
  * Pipeline:
  *   1. cargo build -p rastack-wasm --release --target wasm32-unknown-unknown
- *   2. wasm-bindgen --target web  → tools/wasm/rastack_wasm.js + rastack_wasm_bg.wasm
+ *   2. wasm-bindgen --target web  → wasm/rastack_wasm.js + rastack_wasm_bg.wasm
  *   3. wasm-opt -Oz (if available) to shrink the binary
  *
  * This is invoked by the release CI (to bundle a prebuilt engine into the npm

package/dist/rastack-wasm-build.js

@@ -6,7 +6,7 @@
  *
  * Pipeline:
  *   1. cargo build -p rastack-wasm --release --target wasm32-unknown-unknown
- *   2. wasm-bindgen --target web  → tools/wasm/rastack_wasm.js + rastack_wasm_bg.wasm
+ *   2. wasm-bindgen --target web  → wasm/rastack_wasm.js + rastack_wasm_bg.wasm
  *   3. wasm-opt -Oz (if available) to shrink the binary
  *
  * This is invoked by the release CI (to bundle a prebuilt engine into the npm
@@ -23,9 +23,9 @@ exports.buildWasm = buildWasm;
 const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const repoRoot = path_1.default.resolve(__dirname, "..", "..");
-const rustDir = path_1.default.join(repoRoot, "rust");
-const outDir = path_1.default.join(repoRoot, "tools", "wasm");
+const repoRoot = path_1.default.resolve(__dirname, "..");
+const rustDir = path_1.default.join(repoRoot, "engine");
+const outDir = path_1.default.join(repoRoot, "wasm");
 const wasmPath = path_1.default.join(rustDir, "target", "wasm32-unknown-unknown", "release", "rastack_wasm.wasm");
 function run(cmd, args, cwd = repoRoot) {
     // Local build tool: `cmd`/`args` are the fixed toolchain invocations below
@@ -65,7 +65,7 @@ function buildWasm() {
         "--target",
         "wasm32-unknown-unknown",
     ], rustDir);
-    console.log("→ wasm-bindgen → tools/wasm/");
+    console.log("→ wasm-bindgen → wasm/");
     run("wasm-bindgen", [
         "--target",
         "web",
@@ -87,7 +87,7 @@ function buildWasm() {
         console.log("· wasm-opt not found — skipping size optimisation (optional)");
     }
     const size = fs_1.default.statSync(path_1.default.join(outDir, "rastack_wasm_bg.wasm")).size;
-    console.log(`✓ wasm engine built: tools/wasm/ (${(size / 1024).toFixed(0)} KB)`);
+    console.log(`✓ wasm engine built: wasm/ (${(size / 1024).toFixed(0)} KB)`);
 }
 if (require.main === module) {
     buildWasm();

package/external.ts

@@ -0,0 +1,10 @@
+/**
+ * `rastack/external` — the external-API proxy core.
+ *
+ * Serve external REST/GraphQL APIs (GitHub, Expo, AWS) over the rastack
+ * `/api/{app}/v1/{model}/` contract so the normal typed hooks consume them
+ * unchanged. The same core runs in two adapters: the mini service inside
+ * `rastack dev` ({@link createExternalService}) and an AWS Lambda behind API
+ * Gateway ({@link handleLambdaEvent}).
+ */
+export * from "./src/external";

package/hooks/query/delete.ts

@@ -1,6 +1,9 @@
 import { AxiosResponse } from "axios";
-import { UseMutationResult } from "react-query/types/react/types";
-import { useMutation, useQueryClient } from "react-query";
+import {
+  useMutation,
+  useQueryClient,
+  type UseMutationResult,
+} from "@tanstack/react-query";
 import { IDeleteQueryResult } from "./interfaces";
 import { API } from "./api";
 
@@ -15,8 +18,8 @@ export function useDeleteQuery<TResult>({
 }: DeleteQueryProps): IDeleteQueryResult<TResult> {
   const queryClient = useQueryClient();
 
-  return useMutation(
-    async (params: { id?: string }) => {
+  return useMutation({
+    mutationFn: async (params: { id?: string }) => {
       if (params.id === undefined) {
         throw new Error("ID is required for delete operation");
       }
@@ -36,12 +39,10 @@ export function useDeleteQuery<TResult>({
       // assume `.results` exists on an empty body.
       return response.data?.results ?? response.data ?? null;
     },
-    {
-      onSuccess: () => {
-        if (listQueryCacheKey) {
-          queryClient.invalidateQueries(listQueryCacheKey);
-        }
-      },
+    onSuccess: () => {
+      if (listQueryCacheKey) {
+        queryClient.invalidateQueries({ queryKey: [listQueryCacheKey] });
+      }
     },
-  ) as UseMutationResult<TResult>;
+  }) as UseMutationResult<TResult>;
 }

package/hooks/query/fetch.ts

@@ -1,5 +1,5 @@
 import { AxiosResponse } from "axios";
-import { useQuery } from "react-query";
+import { useQuery } from "@tanstack/react-query";
 import { API } from "./api";
 import { stringifyQueryParams } from "./url";
 import { GetQueryOptions, IGetQueryResult } from "./interfaces";
@@ -31,9 +31,9 @@ export function useGetQuery<TParam, TResult>({
 
   const params = options?.params;
 
-  return useQuery(
-    [queryKey, getUrl, params],
-    async () => {
+  return useQuery({
+    queryKey: [queryKey, getUrl, params],
+    queryFn: async () => {
       const urlParams = stringifyQueryParams(pathParameters, params);
       const serverURL = `${getUrl}${urlParams ? `?${urlParams}` : ""}`;
 
@@ -41,8 +41,6 @@ export function useGetQuery<TParam, TResult>({
 
       return response.data;
     },
-    {
-      enabled: isAuthenticated && isRequiredParamsPresent,
-    },
-  );
+    enabled: isAuthenticated && isRequiredParamsPresent,
+  });
 }

package/hooks/query/interfaces.ts

@@ -1,7 +1,4 @@
-import {
-  UseMutationResult,
-  UseQueryResult,
-} from "react-query/types/react/types";
+import { UseMutationResult, UseQueryResult } from "@tanstack/react-query";
 import { ExtractKey } from "../../types";
 
 export interface IPaginationActions {

package/hooks/query/list.ts

@@ -1,5 +1,5 @@
 import { AxiosResponse } from "axios";
-import { useQuery } from "react-query";
+import { useQuery } from "@tanstack/react-query";
 import { useEffect, useState } from "react";
 import {
   IFilterActions,
@@ -125,14 +125,21 @@ export function useGetPaginatedQueryList<TParam, TResult>({
     }
   };
 
-  const query = useQuery<IPaginatedResponse<TResult>>(
-    [queryKey, getUrl, options?.params, serverQueryParamState],
-    fetchData,
-    {
-      enabled: isRequiredQueryParamsPresent && isAuthenticated,
-      onSuccess: options?.onSuccess,
-    },
-  );
+  const query = useQuery<IPaginatedResponse<TResult>>({
+    queryKey: [queryKey, getUrl, options?.params, serverQueryParamState],
+    queryFn: fetchData,
+    enabled: isRequiredQueryParamsPresent && isAuthenticated,
+  });
+
+  // react-query v5 dropped the query-level `onSuccess` callback; mirror it with
+  // an effect so callers that pass `options.onSuccess` keep firing on each new
+  // successful result.
+  useEffect(() => {
+    if (query.isSuccess && query.data) {
+      options?.onSuccess?.(query.data);
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [query.isSuccess, query.data]);
 
   // The list envelope is either nested (`{ pagination: { count, last } }`, the
   // Django/DRF-paginated shape) or flat DRF-classic (`{ count, next, previous,

package/hooks/query/update.ts

@@ -1,5 +1,5 @@
 import { AxiosResponse } from "axios";
-import { useMutation, useQueryClient } from "react-query";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { IUpdateQueryResult, WriteQueryVariables } from "./interfaces";
 import { API } from "./api";
 import { stringifyQueryParams } from "./url";
@@ -29,8 +29,9 @@ export function useUpdateQuery<TParams, TPayload, TResult>({
     unknown,
     WriteQueryVariables<TParams, TPayload>,
     unknown
-  >(({ params, payload }) => {
-    return new Promise((resolve, reject) => {
+  >({
+    mutationFn: ({ params, payload }) => {
+      return new Promise((resolve, reject) => {
       let urlType: "put" | "patch" | "post" = "patch";
       let url: string | undefined;
 
@@ -73,16 +74,17 @@ export function useUpdateQuery<TParams, TPayload, TResult>({
       getAPIFunction(urlType, url, payload)
         .then((response: AxiosResponse<TResult>) => {
           if (itemQueryCacheKey) {
-            queryClient.invalidateQueries([itemQueryCacheKey]);
+            queryClient.invalidateQueries({ queryKey: [itemQueryCacheKey] });
           }
           if (listQueryCacheKey) {
-            queryClient.invalidateQueries(listQueryCacheKey);
+            queryClient.invalidateQueries({ queryKey: [listQueryCacheKey] });
           }
           resolve(response.data);
         })
         .catch((error) => {
           reject(error);
         });
-    });
+      });
+    },
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rastack",
-  "version": "0.0.57",
+  "version": "0.0.59",
   "description": "",
   "main": "runtime.ts",
   "types": "runtime.ts",
@@ -11,9 +11,32 @@
   "publishConfig": {
     "access": "public"
   },
+  "files": [
+    "admin",
+    "auth",
+    "cache",
+    "components",
+    "hooks",
+    "provider",
+    "sync",
+    "theme",
+    "src",
+    "scripts",
+    "dist",
+    "define.ts",
+    "db.ts",
+    "validate.ts",
+    "plugin.ts",
+    "external.ts",
+    "tokens.ts",
+    "types.ts",
+    "runtime.ts",
+    "CHANGELOG.md"
+  ],
   "scripts": {
     "format": "prettier --write \"**/*.{ts,tsx,md}\"",
     "build": "tsc && cp src/.prettierrc dist/.prettierrc && node scripts/copy-templates.js && node scripts/build-admin.js && node scripts/copy-wasm.js",
+    "dev:install": "node scripts/dev-install.mjs",
     "start": "node dist/index.js",
     "test": "jest"
   },
@@ -38,7 +61,6 @@
     "luxon": "^3.7.2",
     "minimatch": "^10.2.5",
     "prettier": "^3.9.5",
-    "react-query": "^3.39.3",
     "typescript": "~5.9.3",
     "usehooks-ts": "^3.1.1"
   },
@@ -46,6 +68,7 @@
     "react": "^19.2.7"
   },
   "devDependencies": {
+    "@testing-library/react-hooks": "8.0.1",
     "@types/jest": "^30.0.0",
     "@types/js-yaml": "^4.0.9",
     "@types/mocha": "^10.0.6",

package/scripts/copy-templates.js

@@ -13,7 +13,7 @@
 const fs = require("fs");
 const path = require("path");
 
-const repoRoot = path.resolve(__dirname, "..", "..");
+const repoRoot = path.resolve(__dirname, "..");
 const srcDir = path.join(repoRoot, "deploy", "cloudformation");
 const destDir = path.join(__dirname, "..", "dist", "templates", "cloudformation");
 

package/scripts/copy-wasm.js

@@ -17,7 +17,7 @@ const entry = path.join(src, "rastack_wasm.js");
 
 if (!fs.existsSync(entry)) {
   console.log(
-    "copy-wasm: no prebuilt engine at tools/wasm (skipping — build it with " +
+    "copy-wasm: no prebuilt engine at wasm/ (skipping — build it with " +
       "rastack-wasm-build.js to ship it).",
   );
   process.exit(0);

package/scripts/dev-install.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+/**
+ * dev-install — fast local build + install of the rastack CLI.
+ *
+ * Compiles `src/ → dist/` with the local TypeScript, then merge-copies the fresh
+ * dist over the globally installed copy (`~/.rastack/node_modules/rastack/dist`)
+ * so `rastack` and `ras` on the PATH immediately run the new code. The copy
+ * merges (it never deletes), which preserves the shipped runtime artifacts that
+ * already live there — the wasm engine, the admin bundle, and the templates —
+ * none of which a tsc-only build emits.
+ *
+ * This is the fast local iteration loop; a full `npm run build && npm pack`
+ * publish is unchanged. Usage:
+ *
+ *   node scripts/dev-install.mjs [--prefix <dir>]   # defaults to ~/.rastack
+ */
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const TOOLS = path.resolve(HERE, "..");
+
+function flag(name, fallback) {
+  const i = process.argv.indexOf(name);
+  return i !== -1 && process.argv[i + 1] ? process.argv[i + 1] : fallback;
+}
+
+// The install prefix rastack ships into (the hosted installer uses ~/.rastack).
+const prefix = flag("--prefix", path.join(os.homedir(), ".rastack"));
+const target = path.join(prefix, "node_modules", "rastack");
+
+if (!fs.existsSync(target)) {
+  console.error(
+    `  ✗ no rastack install found at ${target}\n` +
+      "    Install it first (hosted installer / npm install -g rastack), or pass --prefix <dir>.",
+  );
+  process.exit(1);
+}
+
+// 1) Compile TypeScript → dist/. Run tsc through node (avoids the Windows .cmd
+//    spawn EINVAL) so this loop is identical on every platform.
+console.log("▸ tsc — compiling src → dist");
+const tscJs = path.join(TOOLS, "node_modules", "typescript", "bin", "tsc");
+execFileSync(process.execPath, [tscJs, "-p", path.join(TOOLS, "tsconfig.json")], {
+  stdio: "inherit",
+  cwd: TOOLS,
+});
+
+// 2) Merge-copy the fresh dist over the global install (never delete → the wasm
+//    engine, admin bundle and templates already there are left untouched).
+console.log(`▸ installing → ${target}`);
+fs.cpSync(path.join(TOOLS, "dist"), path.join(target, "dist"), { recursive: true });
+fs.copyFileSync(path.join(TOOLS, "package.json"), path.join(target, "package.json"));
+
+const version = JSON.parse(
+  fs.readFileSync(path.join(target, "package.json"), "utf-8"),
+).version;
+console.log(
+  `  ✓ installed rastack ${version} — \`rastack\` and \`ras\` now run this local build`,
+);

package/src/deploy/ci.ts

@@ -83,7 +83,7 @@ function stackOutput(
 
 /** The Lambda staging directory `cargo lambda build` writes the binary into. */
 function stageDir(cfg: DeployConfig): string {
-  return `rust/target/lambda/${cfg.lambda.bin}`;
+  return `engine/target/lambda/${cfg.lambda.bin}`;
 }
 
 /** `check` — validate the resource graph and compile the manifest. A CI gate. */
@@ -118,7 +118,7 @@ export function buildSteps(
     {
       name: "Cross-build the Lambda binary",
       run: `cargo lambda build --release ${archFlag} --bin ${cfg.lambda.bin} --features ${cfg.lambda.features}`,
-      cwd: "rust",
+      cwd: "engine",
     },
     {
       name: "Bake the Cognito JWKS into the bundle",

package/src/deploy/io.ts

@@ -39,8 +39,8 @@ export function resolveDeployAsset(
   const candidates = [
     // Installed package: dist/deploy/io.js → dist/templates/cloudformation/…
     path.join(__dirname, "..", "templates", "cloudformation", relPath),
-    // Running from TS source: tools/src/deploy/io.ts → repo-root deploy/…
-    path.join(__dirname, "..", "..", "..", "deploy", "cloudformation", relPath),
+    // Running from TS source: src/deploy/io.ts → repo-root deploy/…
+    path.join(__dirname, "..", "..", "deploy", "cloudformation", relPath),
     // Invoked inside the framework repo itself (cwd is the repo root).
     path.join(cwd, "deploy", "cloudformation", relPath),
   ];