rastack 0.0.43 → 0.0.45

package/src/rastack-wasm-build.ts

@@ -1,14 +1,17 @@
 #!/usr/bin/env node
 
 /**
- * `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)
  */
@@ -56,47 +59,55 @@ function has(cmd: string): boolean {
   return 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",
+/** Run the full compile → wasm-bindgen → optimise pipeline. Throws via `run`'s
+ *  `process.exit` on a missing tool or a non-zero step. */
+export function buildWasm(): void {
+  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",
-    "wasm32-unknown-unknown",
-  ],
-  rustDir,
-);
+    "web",
+    "--out-dir",
+    outDir,
+    "--out-name",
+    "rastack_wasm",
+    wasmPath,
+  ]);
 
-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.writeFileSync(
+    path.join(outDir, "package.json"),
+    JSON.stringify({ type: "module", sideEffects: false }, null, 2) + "\n",
+  );
 
-// Mark the emitted bundle as ESM so Node and bundlers treat it correctly
-// without forcing the parent rastack package to be a module.
-fs.writeFileSync(
-  path.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.join(outDir, "rastack_wasm_bg.wasm");
+    run("wasm-opt", ["-Oz", "-o", bg, bg]);
+  } else {
+    console.log("· wasm-opt not found — skipping size optimisation (optional)");
+  }
 
-if (has("wasm-opt")) {
-  console.log("→ wasm-opt -Oz");
-  const bg = path.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.statSync(path.join(outDir, "rastack_wasm_bg.wasm")).size;
+  console.log(`✓ wasm engine built: tools/wasm/ (${(size / 1024).toFixed(0)} KB)`);
 }
 
-const size = fs.statSync(path.join(outDir, "rastack_wasm_bg.wasm")).size;
-console.log(
-  `✓ wasm engine built: stack/wasm/ (${(size / 1024).toFixed(0)} KB)`,
-);
+if (require.main === module) {
+  buildWasm();
+}

package/src/rastack.ts

@@ -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 admin   [--warehouse dir]           Run the Rust admin (Django-admin-style DB browser)
- *   rastack wasm                                Compile the API to WebAssembly (in-browser local dev)
+ *   rastack dev     [--port n] [--warehouse d]  Local dev: run the app + admin in-browser over WASM
+ *   rastack admin   [--warehouse dir] [--port n] Full admin console — React UI (rastack/components) over the native server
  *   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)
@@ -23,7 +22,7 @@
  *   rastack update [<version>] [--check]        Update the CLI in place (self-update)
  */
 
-import { execSync, spawnSync } from "child_process";
+import { execSync } from "child_process";
 import { readFileSync } from "fs";
 import path from "path";
 
@@ -58,30 +57,6 @@ function run(script: string, args: string[] = rest) {
   }
 }
 
-/** Invoke the compiled Rust server binary (built by `cargo build` in rust/). */
-function runRust(subcommand: string) {
-  const repoRoot = path.resolve(__dirname, "..", "..");
-  const binary =
-    process.env.RASTACK_SERVER_BIN ||
-    path.join(repoRoot, "rust", "target", "release", "rastack-server");
-  // Runs the locally-built Rust server binary with a fixed internal subcommand
-  // ("serve"/"admin"); `rest` is the developer's own CLI args, not untrusted
-  // input — no command-injection surface.
-  // nosemgrep: javascript.lang.security.detect-child-process.detect-child-process
-  const result = spawnSync(binary, [subcommand, ...rest], {
-    stdio: "inherit",
-    env: process.env,
-  });
-  if (result.error) {
-    console.error(
-      `Could not run the Rust server (${binary}). Build it first:\n` +
-        `  cd rust && cargo build --release\n`,
-    );
-    process.exit(1);
-  }
-  process.exit(result.status ?? 0);
-}
-
 switch (command) {
   case "--version":
   case "-v":
@@ -95,15 +70,17 @@ 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);
+    // Full Django-admin-style console: the native Rust server serves React API
+    // Stack's own React admin (built from `rastack/components` + `rastack/theme`)
+    // over the real Iceberg warehouse. `rastack-admin.js` compiles, wires the
+    // bundle in, and boots the server.
+    run("rastack-admin.js", rest);
     break;
   case "tokens":
     // Design tokens → CSS custom properties + typed theme.
@@ -156,8 +133,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] [--port n] [--no-open]  Full admin console (React UI over the native server; 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/test/dev.spec.ts

@@ -0,0 +1,373 @@
+import {
+  ADMIN_DEFAULTS,
+  DEV_DEFAULTS,
+  WASM_ENTRY,
+  contentType,
+  parseAdminArgs,
+  parseDevArgs,
+  renderShell,
+  wasmBundleCandidates,
+} from "../src/dev/harness";
+import {
+  boolFilterOptions,
+  buildWriteBody,
+  changelistHeaders,
+  coerceFormValue,
+  distinctValueOptions,
+  errorDetail,
+  fieldControlType,
+  filterableFields,
+  findResource,
+  fkFilterOptions,
+  formFields,
+  initialFormValues,
+  listPath,
+  detailPath,
+  optionLabel,
+  optionsFromRows,
+  pageCount,
+  parseManifest,
+  readListEnvelope,
+  withFilters,
+  PAGE_SIZE,
+  type AdminResource,
+} from "../admin/adapters";
+
+// -- harness core -----------------------------------------------------------
+
+describe("rastack dev — arg parsing", () => {
+  it("defaults resources/out/warehouse/port and opens the browser", () => {
+    expect(parseDevArgs([])).toEqual(DEV_DEFAULTS);
+    expect(DEV_DEFAULTS.port).toBe(4321);
+    expect(DEV_DEFAULTS.warehouseDir).toBe("data/warehouse");
+  });
+
+  it("reads --port, --warehouse, --out, --no-open and a positional dir", () => {
+    const args = parseDevArgs([
+      "app/resources",
+      "--port",
+      "5000",
+      "--warehouse",
+      "data/wh",
+      "--out",
+      "build",
+      "--no-open",
+    ]);
+    expect(args).toEqual({
+      resourcesDir: "app/resources",
+      outDir: "build",
+      warehouseDir: "data/wh",
+      port: 5000,
+      open: false,
+    });
+  });
+
+  it("ignores a non-numeric --port (keeps the default)", () => {
+    expect(parseDevArgs(["--port", "abc"]).port).toBe(4321);
+  });
+});
+
+describe("rastack admin — arg parsing", () => {
+  it("defaults to the server's port 8000 and the same dirs as dev", () => {
+    expect(parseAdminArgs([])).toEqual(ADMIN_DEFAULTS);
+    expect(ADMIN_DEFAULTS.port).toBe(8000);
+    expect(ADMIN_DEFAULTS.warehouseDir).toBe("data/warehouse");
+  });
+
+  it("reads --port, --warehouse, --out, --no-open and a positional dir", () => {
+    expect(
+      parseAdminArgs(["res", "--port", "9100", "--warehouse", "wh", "--no-open"]),
+    ).toEqual({
+      resourcesDir: "res",
+      outDir: ".rastack",
+      warehouseDir: "wh",
+      port: 9100,
+      open: false,
+    });
+  });
+});
+
+describe("rastack dev — content types", () => {
+  it("maps wasm to application/wasm (required for streaming instantiation)", () => {
+    expect(contentType("/wasm/rastack_wasm_bg.wasm")).toBe("application/wasm");
+  });
+  it("maps the common asset types", () => {
+    expect(contentType("/dev/admin.js")).toBe("text/javascript; charset=utf-8");
+    expect(contentType("/schema.rastack.json")).toBe(
+      "application/json; charset=utf-8",
+    );
+    expect(contentType("a/version-hint.text")).toBe("text/plain; charset=utf-8");
+    expect(contentType("data/v3.parquet")).toBe("application/octet-stream");
+  });
+  it("falls back to octet-stream for unknown extensions", () => {
+    expect(contentType("mystery.bin")).toBe("application/octet-stream");
+  });
+});
+
+describe("rastack dev — wasm bundle resolution", () => {
+  it("includes the installed dist/wasm and repo tools/wasm locations", () => {
+    const dirs = wasmBundleCandidates("/opt/rastack/dist", "/repo");
+    expect(dirs).toContain("/opt/rastack/dist/wasm");
+    expect(dirs).toContain("/repo/tools/wasm");
+    // The entry filename the resolver probes for.
+    expect(WASM_ENTRY).toBe("rastack_wasm.js");
+  });
+});
+
+describe("rastack dev — HTML shell", () => {
+  it("mounts #root and loads the bundled admin", () => {
+    const html = renderShell();
+    expect(html).toContain('<div id="root">');
+    expect(html).toContain('<script src="/dev/admin.js">');
+    expect(html.startsWith("<!doctype html>")).toBe(true);
+  });
+});
+
+// -- admin adapters ---------------------------------------------------------
+
+/** The in-repo airline fixtures, in manifest JSON shape. */
+const MANIFEST = {
+  version: 1,
+  resources: [
+    {
+      app: "airports",
+      model: "airport",
+      fields: [
+        { name: "code", type: "string", maxLength: 3, unique: true },
+        { name: "name", type: "string", maxLength: 120 },
+      ],
+      search: ["code", "name"],
+      admin: { listDisplay: ["code", "name"] },
+    },
+    {
+      app: "airports",
+      model: "terminal",
+      fields: [
+        {
+          name: "airport",
+          type: "fk",
+          relation: { app: "airports", model: "airport" },
+        },
+        { name: "label", type: "string", maxLength: 20 },
+        { name: "active", type: "bool", null: true },
+      ],
+    },
+    {
+      app: "airports",
+      model: "secret",
+      fields: [{ name: "value", type: "string" }],
+      admin: false,
+    },
+  ],
+};
+
+describe("admin adapters — manifest parsing", () => {
+  const resources = parseManifest(MANIFEST);
+
+  it("parses resources, fields, search, listDisplay and admin visibility", () => {
+    const airport = findResource(resources, "airports", "airport")!;
+    expect(airport.key).toBe("airports.airport");
+    expect(airport.label).toBe("Airport");
+    expect(airport.search).toEqual(["code", "name"]);
+    expect(airport.listDisplay).toEqual(["code", "name"]);
+    expect(airport.adminEnabled).toBe(true);
+
+    const secret = findResource(resources, "airports", "secret")!;
+    expect(secret.adminEnabled).toBe(false);
+  });
+
+  it("accepts a JSON string as well as an object", () => {
+    expect(parseManifest(JSON.stringify(MANIFEST)).length).toBe(3);
+  });
+
+  it("carries FK relation + nullability on fields", () => {
+    const terminal = findResource(resources, "airports", "terminal")!;
+    const fk = terminal.fields.find((f) => f.name === "airport")!;
+    expect(fk.type).toBe("fk");
+    expect(fk.relation).toEqual({ app: "airports", model: "airport" });
+    const active = terminal.fields.find((f) => f.name === "active")!;
+    expect(active.nullable).toBe(true);
+  });
+});
+
+describe("admin adapters — changelist", () => {
+  const resources = parseManifest(MANIFEST);
+  const airport = findResource(resources, "airports", "airport")!;
+  const terminal = findResource(resources, "airports", "terminal")!;
+
+  it("prepends an id column, then listDisplay (else all fields)", () => {
+    expect(changelistHeaders(airport).map((h) => h.key)).toEqual([
+      "id",
+      "code",
+      "name",
+    ]);
+    // terminal has no listDisplay → all fields after id
+    expect(changelistHeaders(terminal).map((h) => h.key)).toEqual([
+      "id",
+      "airport",
+      "label",
+      "active",
+    ]);
+  });
+
+  it("uses the admin's fixed page size and correct page count", () => {
+    expect(PAGE_SIZE).toBe(25);
+    expect(pageCount(0, 25)).toBe(1);
+    expect(pageCount(25, 25)).toBe(1);
+    expect(pageCount(26, 25)).toBe(2);
+  });
+
+  it("reads the DRF list envelope defensively", () => {
+    expect(readListEnvelope({ count: 2, results: [{ id: 1 }] })).toEqual({
+      count: 2,
+      results: [{ id: 1 }],
+    });
+    expect(readListEnvelope(undefined)).toEqual({ count: 0, results: [] });
+  });
+
+  it("builds the REST paths the WASM engine answers", () => {
+    expect(listPath("airports", "airport")).toBe("/api/airports/v1/airport/");
+    expect(detailPath("airports", "airport", 7)).toBe(
+      "/api/airports/v1/airport/7/",
+    );
+  });
+});
+
+describe("admin adapters — forms", () => {
+  const resources = parseManifest(MANIFEST);
+  const airport = findResource(resources, "airports", "airport")!;
+  const terminal = findResource(resources, "airports", "terminal")!;
+
+  it("chooses controls from the field datatype (FK → select)", () => {
+    const fk = terminal.fields.find((f) => f.name === "airport")!;
+    const label = terminal.fields.find((f) => f.name === "label")!;
+    const active = terminal.fields.find((f) => f.name === "active")!;
+    expect(fieldControlType(fk)).toBe("select");
+    expect(fieldControlType(label)).toBe("text");
+    expect(fieldControlType(active)).toBe("boolean");
+  });
+
+  it("seeds initial values (blank strings, false for booleans)", () => {
+    expect(initialFormValues(terminal)).toEqual({
+      airport: "",
+      label: "",
+      active: false,
+    });
+  });
+
+  it("coerces values like the Rust admin (numbers/bools parsed, empties omitted)", () => {
+    const fk = terminal.fields.find((f) => f.name === "airport")!;
+    const active = terminal.fields.find((f) => f.name === "active")!;
+    const label = terminal.fields.find((f) => f.name === "label")!;
+    expect(coerceFormValue(fk, "12")).toBe(12);
+    expect(coerceFormValue(active, "true")).toBe(true);
+    expect(coerceFormValue(active, false)).toBe(false);
+    expect(coerceFormValue(label, "")).toBeUndefined(); // omitted
+  });
+
+  it("builds a write body, omitting empty non-bool fields", () => {
+    const body = buildWriteBody(terminal, {
+      airport: "3",
+      label: "",
+      active: true,
+    });
+    expect(body).toEqual({ airport: 3, active: true });
+    expect("label" in body).toBe(false);
+  });
+
+  it("labels FK options by the first string field, else #id", () => {
+    expect(optionLabel({ id: 5, code: "JFK", name: "Kennedy" })).toBe(
+      "JFK (#5)",
+    );
+    expect(optionLabel({ id: 9 })).toBe("#9");
+    expect(optionsFromRows([{ id: 1, code: "LAX" }])).toEqual([
+      { label: "LAX (#1)", value: 1 },
+    ]);
+  });
+
+  it("form fields exclude the primary key", () => {
+    const withPk: AdminResource = {
+      ...airport,
+      fields: [
+        { name: "id", type: "int", primaryKey: true, nullable: false },
+        ...airport.fields,
+      ],
+    };
+    expect(formFields(withPk).map((f) => f.name)).toEqual(["code", "name"]);
+  });
+
+  it("extracts a {detail} error message", () => {
+    expect(errorDetail({ detail: "nope" })).toBe("nope");
+    expect(errorDetail("raw string")).toBe("raw string");
+    expect(errorDetail({})).toBe("Request failed");
+  });
+});
+
+describe("admin adapters — Linear-style filters", () => {
+  const resources = parseManifest(MANIFEST);
+  const airport = findResource(resources, "airports", "airport")!;
+  const terminal = findResource(resources, "airports", "terminal")!;
+
+  it("offers FK, boolean and non-unique string fields as facets", () => {
+    // `airport`: `code` is unique (an identifier, not a facet), `name` is a
+    // plain string → a single `choice` facet.
+    expect(filterableFields(airport)).toEqual([
+      { name: "name", label: "Name", kind: "choice" },
+    ]);
+    // `terminal`: FK + string + bool all filterable.
+    expect(filterableFields(terminal)).toEqual([
+      {
+        name: "airport",
+        label: "Airport",
+        kind: "fk",
+        relation: { app: "airports", model: "airport" },
+      },
+      { name: "label", label: "Label", kind: "choice" },
+      { name: "active", label: "Active", kind: "bool" },
+    ]);
+  });
+
+  it("booleans are True/False", () => {
+    expect(boolFilterOptions()).toEqual([
+      { value: "true", label: "True" },
+      { value: "false", label: "False" },
+    ]);
+  });
+
+  it("distinct values become sorted options, dropping empties", () => {
+    const rows = [
+      { label: "B" },
+      { label: "A" },
+      { label: "B" },
+      { label: "" },
+      { label: null },
+    ];
+    expect(distinctValueOptions(rows, "label")).toEqual([
+      { value: "A", label: "A" },
+      { value: "B", label: "B" },
+    ]);
+  });
+
+  it("drops a high-cardinality field (no useful facet)", () => {
+    const rows = Array.from({ length: 5 }, (_, i) => ({ v: `x${i}` }));
+    expect(distinctValueOptions(rows, "v", 3)).toEqual([]);
+  });
+
+  it("FK options reuse the option-label heuristic against the target rows", () => {
+    expect(
+      fkFilterOptions([
+        { id: 1, code: "JFK" },
+        { id: 2, code: "LHR" },
+      ]),
+    ).toEqual([
+      { value: "1", label: "JFK (#1)" },
+      { value: "2", label: "LHR (#2)" },
+    ]);
+  });
+
+  it("merges filters under the reserved keys (page/search always win)", () => {
+    expect(
+      withFilters({ page: "2", search: "x" }, { status: "active", page: "9" }),
+    ).toEqual({ status: "active", page: "2", search: "x" });
+  });
+});

package/wasm/package.json

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

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