rastack 0.0.42 → 0.0.44

package/dist/rastack-wasm-build.js

@@ -1,14 +1,17 @@
 #!/usr/bin/env node
 "use strict";
 /**
- * `rastack wasm` — compile the Rust API to WebAssembly for in-browser local dev.
+ * Compile the Rust API to WebAssembly for in-browser local dev — the engine
+ * `rastack dev` serves and `<RAStackProvider mode="local">` loads.
  *
  * Pipeline:
  *   1. cargo build -p rastack-wasm --release --target wasm32-unknown-unknown
- *   2. wasm-bindgen --target web  → stack/wasm/rastack_wasm.js + rastack_wasm_bg.wasm
+ *   2. wasm-bindgen --target web  → tools/wasm/rastack_wasm.js + rastack_wasm_bg.wasm
  *   3. wasm-opt -Oz (if available) to shrink the binary
  *
- * The generated bundle is what `<RAStackProvider mode="local">` loads. Prereqs:
+ * This is invoked by the release CI (to bundle a prebuilt engine into the npm
+ * package) and by `rastack dev` as a from-source fallback when no prebuilt
+ * bundle is present but the toolchain is. Prereqs:
  *   rustup target add wasm32-unknown-unknown
  *   cargo install wasm-bindgen-cli   (version must match the wasm-bindgen crate)
  */
@@ -16,6 +19,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildWasm = buildWasm;
 const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -49,35 +53,42 @@ function has(cmd) {
     // nosemgrep: javascript.lang.security.detect-child-process.detect-child-process
     return (0, child_process_1.spawnSync)(cmd, ["--version"], { stdio: "ignore" }).status === 0;
 }
-console.log("→ cargo build -p rastack-wasm --release (wasm32-unknown-unknown)");
-run("cargo", [
-    "build",
-    "-p",
-    "rastack-wasm",
-    "--release",
-    "--target",
-    "wasm32-unknown-unknown",
-], rustDir);
-console.log("→ wasm-bindgen → stack/wasm/");
-run("wasm-bindgen", [
-    "--target",
-    "web",
-    "--out-dir",
-    outDir,
-    "--out-name",
-    "rastack_wasm",
-    wasmPath,
-]);
-// Mark the emitted bundle as ESM so Node and bundlers treat it correctly
-// without forcing the parent rastack package to be a module.
-fs_1.default.writeFileSync(path_1.default.join(outDir, "package.json"), JSON.stringify({ type: "module", sideEffects: false }, null, 2) + "\n");
-if (has("wasm-opt")) {
-    console.log("→ wasm-opt -Oz");
-    const bg = path_1.default.join(outDir, "rastack_wasm_bg.wasm");
-    run("wasm-opt", ["-Oz", "-o", bg, bg]);
+/** Run the full compile → wasm-bindgen → optimise pipeline. Throws via `run`'s
+ *  `process.exit` on a missing tool or a non-zero step. */
+function buildWasm() {
+    console.log("→ cargo build -p rastack-wasm --release (wasm32-unknown-unknown)");
+    run("cargo", [
+        "build",
+        "-p",
+        "rastack-wasm",
+        "--release",
+        "--target",
+        "wasm32-unknown-unknown",
+    ], rustDir);
+    console.log("→ wasm-bindgen → tools/wasm/");
+    run("wasm-bindgen", [
+        "--target",
+        "web",
+        "--out-dir",
+        outDir,
+        "--out-name",
+        "rastack_wasm",
+        wasmPath,
+    ]);
+    // Mark the emitted bundle as ESM so Node and bundlers treat it correctly
+    // without forcing the parent rastack package to be a module.
+    fs_1.default.writeFileSync(path_1.default.join(outDir, "package.json"), JSON.stringify({ type: "module", sideEffects: false }, null, 2) + "\n");
+    if (has("wasm-opt")) {
+        console.log("→ wasm-opt -Oz");
+        const bg = path_1.default.join(outDir, "rastack_wasm_bg.wasm");
+        run("wasm-opt", ["-Oz", "-o", bg, bg]);
+    }
+    else {
+        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)`);
 }
-else {
-    console.log("· wasm-opt not found — skipping size optimisation (optional)");
+if (require.main === module) {
+    buildWasm();
 }
-const size = fs_1.default.statSync(path_1.default.join(outDir, "rastack_wasm_bg.wasm")).size;
-console.log(`✓ wasm engine built: stack/wasm/ (${(size / 1024).toFixed(0)} KB)`);

package/dist/rastack.d.ts

@@ -10,9 +10,8 @@
  *   rastack generate [--schema-only]            Generate typed hooks from OpenAPI
  *   rastack tokens  [input] [outDir]            Compile design tokens → CSS vars + typed theme
  *   rastack design  [input] [--port n]          Live design-system studio (showcase + edit)
- *   rastack serve   [--warehouse dir]           Run the Rust API over an Iceberg warehouse
+ *   rastack dev     [--port n] [--warehouse d]  Local dev: run the app + admin in-browser over WASM
  *   rastack admin   [--warehouse dir]           Run the Rust admin (Django-admin-style DB browser)
- *   rastack wasm                                Compile the API to WebAssembly (in-browser local dev)
  *   rastack scan   [files...] [--fail-on-pii]   Scan CSVs for PII and schema info
  *   rastack seed   [--env dev] [--source gs://] Load CSVs into Iceberg namespace
  *   rastack bootstrap [--owner o] [--repo r]    Stand the tier-0 AWS account stack up (once per account+region)

package/dist/rastack.js

@@ -11,9 +11,8 @@
  *   rastack generate [--schema-only]            Generate typed hooks from OpenAPI
  *   rastack tokens  [input] [outDir]            Compile design tokens → CSS vars + typed theme
  *   rastack design  [input] [--port n]          Live design-system studio (showcase + edit)
- *   rastack serve   [--warehouse dir]           Run the Rust API over an Iceberg warehouse
+ *   rastack dev     [--port n] [--warehouse d]  Local dev: run the app + admin in-browser over WASM
  *   rastack admin   [--warehouse dir]           Run the Rust admin (Django-admin-style DB browser)
- *   rastack wasm                                Compile the API to WebAssembly (in-browser local dev)
  *   rastack scan   [files...] [--fail-on-pii]   Scan CSVs for PII and schema info
  *   rastack seed   [--env dev] [--source gs://] Load CSVs into Iceberg namespace
  *   rastack bootstrap [--owner o] [--repo r]    Stand the tier-0 AWS account stack up (once per account+region)
@@ -90,16 +89,14 @@ switch (command) {
         // rastack-compile dispatches on its own first argument, so pass the command.
         run("rastack-compile.js", [command, ...rest]);
         break;
-    case "serve":
-        runRust("serve");
+    case "dev":
+        // Local development: serve the app + admin in the browser over the WASM
+        // engine (no native server, no cargo). Replaces `serve` + `wasm`.
+        run("rastack-dev.js", rest);
         break;
     case "admin":
         runRust("admin");
         break;
-    case "wasm":
-        // Compile the API to WebAssembly for in-browser local dev.
-        run("rastack-wasm-build.js", rest);
-        break;
     case "tokens":
         // Design tokens → CSS custom properties + typed theme.
         run("rastack-tokens.js", rest);
@@ -150,8 +147,8 @@ switch (command) {
             `  rastack generate [--schema-only]\n` +
             `  rastack tokens  [input] [outDir] [--prefix p]  Compile design tokens → CSS vars + typed theme\n` +
             `  rastack design  [input] [--port n]             Live design-system studio (showcase + edit)\n` +
-            `  rastack serve | admin [--warehouse dir]\n` +
-            `  rastack wasm                                Compile the API to WebAssembly (browser local dev)\n` +
+            `  rastack dev     [--port n] [--warehouse dir] [--no-open]  Run the app + admin in-browser over WASM (local dev)\n` +
+            `  rastack admin   [--warehouse dir]              Run the native Rust admin (needs a built rastack-server)\n` +
             `  rastack scan   [files...] [--fail-on-pii]\n` +
             `  rastack seed   [--env dev|staging] [--source gs://bucket/ | ./myapp-dev/]\n` +
             `  rastack bootstrap [--owner o] [--repo r] [--region r] [--prefix p] [--reuse-oidc] [--print]  Stand the AWS account stack up\n` +

package/dist/update.d.ts

@@ -52,6 +52,17 @@ export declare function npmBinary(platform?: string): string;
  * shell means no injection surface).
  */
 export declare function npmSpawnShell(platform?: string): boolean;
+/**
+ * The single command string used to launch npm on platforms that must go through
+ * a shell (Windows — see `npmSpawnShell`). Node 22+ deprecates passing an args
+ * *array* together with `shell: true` (DEP0190: the args are concatenated, not
+ * escaped), so the shell path builds one string and runs it via `execSync`
+ * instead. Joining with spaces is safe here because every token is a fixed
+ * literal except the version, which `sanitizeVersion` constrains to
+ * `[A-Za-z0-9._-]` (no shell metacharacters). POSIX never uses this — it keeps
+ * the shell-free, array-based `execFile`, which has no concatenation at all.
+ */
+export declare function npmShellCommand(binary: string, args: string[]): string;
 /** The npm package spec to install for a target version. */
 export declare function installSpec(version: string): string;
 /** The `npm <args>` (after the `npm` binary) that installs the target globally. */

package/dist/update.js

@@ -15,6 +15,7 @@ exports.parseUpdateFlags = parseUpdateFlags;
 exports.sanitizeVersion = sanitizeVersion;
 exports.npmBinary = npmBinary;
 exports.npmSpawnShell = npmSpawnShell;
+exports.npmShellCommand = npmShellCommand;
 exports.installSpec = installSpec;
 exports.npmInstallArgs = npmInstallArgs;
 exports.globalPrefixFromPackageDir = globalPrefixFromPackageDir;
@@ -88,6 +89,19 @@ function npmBinary(platform = process.platform) {
 function npmSpawnShell(platform = process.platform) {
     return platform === "win32";
 }
+/**
+ * The single command string used to launch npm on platforms that must go through
+ * a shell (Windows — see `npmSpawnShell`). Node 22+ deprecates passing an args
+ * *array* together with `shell: true` (DEP0190: the args are concatenated, not
+ * escaped), so the shell path builds one string and runs it via `execSync`
+ * instead. Joining with spaces is safe here because every token is a fixed
+ * literal except the version, which `sanitizeVersion` constrains to
+ * `[A-Za-z0-9._-]` (no shell metacharacters). POSIX never uses this — it keeps
+ * the shell-free, array-based `execFile`, which has no concatenation at all.
+ */
+function npmShellCommand(binary, args) {
+    return [binary, ...args].join(" ");
+}
 /** The npm package spec to install for a target version. */
 function installSpec(version) {
     return !version || version === "latest" ? "rastack" : `rastack@${version}`;

package/dist/wasm/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "module",
+  "sideEffects": false
+}

package/dist/wasm/rastack_wasm.d.ts

@@ -0,0 +1,100 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * The in-browser API engine. Cheap to clone (everything behind `Arc`), which
+ * is what lets each async call own its state without borrowing across `await`.
+ */
+export class RastackApi {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Snapshot the entire warehouse to a blob for persistence (`data/` folder,
+     * IndexedDB, or an upload to S3).
+     */
+    exportWarehouse(): Promise<any>;
+    /**
+     * Handle one request. `query` is a `{ [k]: string }` object, `body` any
+     * JSON value (or `undefined`). Resolves to `{ status, body }`.
+     */
+    handle(method: string, path: string, query: any, body: any): Promise<any>;
+    /**
+     * Seed the warehouse from a blob previously produced by
+     * [`export_warehouse`](Self::export_warehouse) (the `data/` folder or an
+     * IndexedDB/OPFS snapshot).
+     */
+    importWarehouse(blob: Uint8Array): Promise<any>;
+    /**
+     * Build an engine from the compiled manifest (`schema.rastack.json`) and an
+     * optional OpenAPI document (`openapi.json`, served at `/api/schema/`).
+     */
+    constructor(manifest_json: string, openapi_json?: string | null);
+    /**
+     * Seed one Iceberg file (metadata or data file) at its warehouse key. The
+     * provider walks the committed `data/warehouse` Iceberg tree over HTTP and
+     * calls this for each file, so the browser reads the *actual* Iceberg files
+     * — no bundled blob.
+     */
+    seedFile(key: string, bytes: Uint8Array): Promise<any>;
+    /**
+     * Run subsequent requests as a signed-in identity (the Cognito `sub` and
+     * `cognito:groups` claims). Owner fields are stamped from — and row
+     * filters and tenant scoping keyed by — this subject, matching the server
+     * byte-for-byte. Pass no subject to fall back to the trusted local
+     * context.
+     */
+    setAuth(subject: string | null | undefined, groups: any): void;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_rastackapi_free: (a: number, b: number) => void;
+    readonly rastackapi_exportWarehouse: (a: number) => any;
+    readonly rastackapi_handle: (a: number, b: number, c: number, d: number, e: number, f: any, g: any) => any;
+    readonly rastackapi_importWarehouse: (a: number, b: number, c: number) => any;
+    readonly rastackapi_new: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly rastackapi_seedFile: (a: number, b: number, c: number, d: number, e: number) => any;
+    readonly rastackapi_setAuth: (a: number, b: number, c: number, d: any) => [number, number];
+    readonly rust_zstd_wasm_shim_calloc: (a: number, b: number) => number;
+    readonly rust_zstd_wasm_shim_free: (a: number) => void;
+    readonly rust_zstd_wasm_shim_malloc: (a: number) => number;
+    readonly rust_zstd_wasm_shim_memcmp: (a: number, b: number, c: number) => number;
+    readonly rust_zstd_wasm_shim_memcpy: (a: number, b: number, c: number) => number;
+    readonly rust_zstd_wasm_shim_memmove: (a: number, b: number, c: number) => number;
+    readonly rust_zstd_wasm_shim_memset: (a: number, b: number, c: number) => number;
+    readonly rust_zstd_wasm_shim_qsort: (a: number, b: number, c: number, d: number) => void;
+    readonly wasm_bindgen_1a7aa9db5392c486___convert__closures_____invoke___wasm_bindgen_1a7aa9db5392c486___JsValue__core_7d5f0a2ba6a62c33___result__Result_____wasm_bindgen_1a7aa9db5392c486___JsError___true_: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen_1a7aa9db5392c486___convert__closures_____invoke___js_sys_191ff9fb2bd47800___Function_fn_wasm_bindgen_1a7aa9db5392c486___JsValue_____wasm_bindgen_1a7aa9db5392c486___sys__Undefined___js_sys_191ff9fb2bd47800___Function_fn_wasm_bindgen_1a7aa9db5392c486___JsValue_____wasm_bindgen_1a7aa9db5392c486___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_exn_store: (a: number) => void;
+    readonly __externref_table_alloc: () => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_destroy_closure: (a: number, b: number) => void;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;