rastack 0.0.64 → 0.0.69

package/src/rastack-dev.ts

@@ -1,32 +1,24 @@
 #!/usr/bin/env node
 
 /**
- * `rastack dev` — local development of **your app**, always over the WASM engine.
+ * `rastack dev` — local development of **your app** against the native engine.
  *
  *   rastack dev [resourcesDir] [--port <n>] [--warehouse <dir>] [--out <dir>] [--app <dir>] [--no-open]
  *
- * Compiles the resources, then boots a dependency-free static server (à la
- * `rastack design`) that hands the browser everything it needs to run the
- * developer's own app locally over WebAssembly — no native server, no cargo:
+ * Compiles the resources, starts a native `rastack-server` (`rastack-api-core`
+ * over the on-disk Iceberg warehouse), and serves the developer's app. The
+ * browser is the UI. `/api` on this origin is proxied to that process.
  *   • the developer's app (`index.html` from the resolved app root), or a
  *     Django-style welcome page when the project has no app yet,
- *   • the prebuilt WASM engine (`/wasm/…`) shipped in the package,
  *   • the compiled `schema.rastack.json` / `openapi.json`,
- *   • the committed Iceberg warehouse (`/data/warehouse/…`) to seed from.
+ *   • `/api/…` forwarded to the native server.
  *
  * It does **not** serve the admin console — that is a separate command,
- * `rastack admin`.
- *
- * The engine is resolved from the package's prebuilt bundle; if none is present
- * but a Rust + wasm toolchain is, it is built from source as a fallback.
+ * `rastack admin`. The browser does not execute the engine. There is no
+ * in-browser fallback.
  */
 
-import {
-  execFileSync,
-  spawn,
-  spawnSync,
-  type ChildProcess,
-} from "child_process";
+import { execFileSync, spawn, type ChildProcess } from "child_process";
 import * as fs from "fs";
 import * as http from "http";
 import * as net from "net";
@@ -36,25 +28,17 @@ import { cognitoRuntimeConfig } from "./deploy/config";
 import { loadConfig } from "./deploy/io";
 import {
   APP_ENTRY,
-  WASM_ENTRY,
   appRootCandidates,
   contentType,
   type DevArgs,
   parseDevArgs,
   renderWelcome,
-  wasmBundleCandidates,
 } from "./dev/harness";
-
-const HERE = __dirname; // dist/ when installed
-
-/** True when `cargo` is on PATH (the from-source wasm fallback needs it). */
-function cargoAvailable(): boolean {
-  try {
-    return spawnSync("cargo", ["--version"], { stdio: "ignore" }).status === 0;
-  } catch {
-    return false;
-  }
-}
+import {
+  ensureServerBinary,
+  startNativeServer,
+  waitForTcp,
+} from "./dev/native-server";
 
 /** First app-root candidate that holds an `index.html`, or null (→ welcome). */
 function resolveAppRoot(appDir: string): string | null {
@@ -64,30 +48,6 @@ function resolveAppRoot(appDir: string): string | null {
   return null;
 }
 
-/** Locate the prebuilt wasm bundle dir, building from source as a fallback. */
-function resolveWasmDir(): string | null {
-  for (const dir of wasmBundleCandidates(HERE)) {
-    if (fs.existsSync(path.join(dir, WASM_ENTRY))) return dir;
-  }
-  if (cargoAvailable()) {
-    console.log(
-      "\n▸ No prebuilt WASM engine found — building it from source (cargo)…\n",
-    );
-    try {
-      // Lazy require so a normal `dev` with a prebuilt bundle never loads it.
-      // eslint-disable-next-line @typescript-eslint/no-var-requires
-      require("./rastack-wasm-build").buildWasm();
-    } catch (err) {
-      console.error(`  ✗ wasm build failed: ${(err as Error).message}`);
-      return null;
-    }
-    for (const dir of wasmBundleCandidates(HERE)) {
-      if (fs.existsSync(path.join(dir, WASM_ENTRY))) return dir;
-    }
-  }
-  return null;
-}
-
 /** Serve one file if it exists and stays within `root`; else 404/403. */
 function serveUnder(
   res: http.ServerResponse,
@@ -174,8 +134,9 @@ function openBrowser(url: string): void {
 // 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.
+// stays the single command *and* keeps Metro's fast-refresh. Apps that ship
+// a built index.html use the static server below. Both proxy /api to the
+// native server.
 // ---------------------------------------------------------------------------
 
 /** True when the project is an Expo app (so `dev` should drive Metro). */
@@ -199,15 +160,7 @@ function isExpoProject(cwd: string): boolean {
   return false;
 }
 
-/** Locate the prebuilt wasm bundle without the cargo fallback (optional here). */
-function findWasmDir(): string | null {
-  for (const dir of wasmBundleCandidates(HERE)) {
-    if (fs.existsSync(path.join(dir, WASM_ENTRY))) return dir;
-  }
-  return null;
-}
-
-/** Grab an ephemeral free TCP port for Metro (avoids a fixed-port clash). */
+/** Grab an ephemeral free TCP port (Metro, or the native API beside this server). */
 function getFreePort(): Promise<number> {
   return new Promise((resolve, reject) => {
     const srv = net.createServer();
@@ -295,7 +248,7 @@ function proxyToMetro(
   );
   proxyReq.on("error", () => {
     if (!res.headersSent) res.writeHead(502);
-    res.end("Metro is not reachable.");
+    res.end("Upstream is not reachable.");
   });
   req.pipe(proxyReq);
 }
@@ -323,11 +276,12 @@ function proxyUpgrade(
 }
 
 /** `rastack dev` for an Expo app: start Metro and reverse-proxy to it. */
-async function runMetroMode(args: DevArgs, cwd: string): Promise<void> {
-  // 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();
-
+async function runMetroMode(
+  args: DevArgs,
+  cwd: string,
+  apiPort: number,
+  stopEngine: () => void,
+): Promise<void> {
   const metroPort = await getFreePort();
   console.log(`▸ Starting Metro bundler (Expo) on :${metroPort} …`);
   const metro = startMetro(cwd, metroPort);
@@ -336,6 +290,7 @@ async function runMetroMode(args: DevArgs, cwd: string): Promise<void> {
   const stop = (code = 0) => {
     if (shuttingDown) return;
     shuttingDown = true;
+    stopEngine();
     try {
       metro.kill();
     } catch {
@@ -359,9 +314,8 @@ async function runMetroMode(args: DevArgs, cwd: string): Promise<void> {
 
   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.startsWith("/api/") || url === "/api")
+      return proxyToMetro(req, res, apiPort);
     if (url === "/schema.rastack.json" || url === "/openapi.json")
       return serveUnder(res, args.outDir, path.basename(url));
     if (url === "/__rastack/cognito.json") return serveDevCognito(res, cwd);
@@ -392,7 +346,7 @@ async function runMetroMode(args: DevArgs, cwd: string): Promise<void> {
   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(`  ✓ native engine: 127.0.0.1:${apiPort} (proxied at /api)`);
     console.log(`\n  ▸ ${url}\n`);
     console.log(
       "  Edits reload live. Need the database console? Run `rastack admin`. Ctrl+C to stop.\n",
@@ -405,7 +359,9 @@ async function main(argv: string[]): Promise<void> {
   const args = parseDevArgs(argv);
   const cwd = process.cwd();
 
-  console.log(`\n  rastack dev — your app, in your browser over WASM\n`);
+  console.log(
+    `\n  rastack dev — your app in the browser, the API in native Rust\n`,
+  );
   console.log(`▸ Compiling ${args.resourcesDir} → ${args.outDir}`);
   if (!runCompile(args.resourcesDir, args.outDir)) {
     console.error("  ✗ compile failed — fix the resource graph and re-run.");
@@ -415,32 +371,64 @@ async function main(argv: string[]): Promise<void> {
   // Serve the developer's own app when there is one; otherwise the welcome page.
   const appRoot = resolveAppRoot(args.appDir);
 
+  let engine: ChildProcess;
+  let apiPort: number;
+  let stopping = false;
+  try {
+    const bin = ensureServerBinary(cwd);
+    apiPort = await getFreePort();
+    const manifest = path.resolve(cwd, args.outDir, "schema.rastack.json");
+    const warehouse = path.resolve(cwd, args.warehouseDir);
+    engine = startNativeServer({
+      bin,
+      command: "serve",
+      manifest,
+      warehouse,
+      addr: `127.0.0.1:${apiPort}`,
+    });
+    await waitForTcp(apiPort, engine);
+  } catch (err) {
+    console.error(`\n${(err as Error).message}\n`);
+    process.exit(1);
+  }
+
+  const stopEngine = () => {
+    stopping = true;
+    try {
+      engine.kill("SIGTERM");
+    } catch {
+      /* already gone */
+    }
+  };
+  engine.on("exit", (code) => {
+    if (stopping) return;
+    console.error(`\n  ✗ native engine exited (code ${code ?? "?"}).`);
+    process.exit(code ?? 1);
+  });
+
   // No static build, but an Expo source tree → drive Metro live (fast refresh).
+  // Metro mode owns the shutdown signals so it can stop both processes.
   if (!appRoot && isExpoProject(cwd)) {
-    return runMetroMode(args, cwd);
+    return runMetroMode(args, cwd, apiPort, stopEngine);
   }
 
-  const wasmDir = resolveWasmDir();
-  if (!wasmDir) {
-    console.error(
-      "\n  ✗ No WASM engine available.\n" +
-        "    Upgrade rastack for the prebuilt bundle (`rastack update`), or install\n" +
-        "    the Rust toolchain to build it from source:\n" +
-        "      rustup target add wasm32-unknown-unknown\n" +
-        "      cargo install wasm-bindgen-cli\n",
-    );
-    process.exit(1);
-  }
+  process.on("SIGINT", () => {
+    stopEngine();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    stopEngine();
+    process.exit(0);
+  });
 
   const server = http.createServer((req, res) => {
     const url = (req.url || "/").split("?")[0];
+    if (url.startsWith("/api/") || url === "/api")
+      return proxyToMetro(req, res, apiPort);
     if (req.method !== "GET") {
       res.writeHead(405).end("Method not allowed");
       return;
     }
-    // Reserved backend routes always win over the app's static files.
-    if (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 === "/__rastack/cognito.json") return serveDevCognito(res, cwd);
@@ -479,7 +467,7 @@ async function main(argv: string[]): Promise<void> {
 
   server.listen(args.port, () => {
     const url = `http://localhost:${args.port}`;
-    console.log(`  ✓ WASM engine: ${path.relative(process.cwd(), wasmDir)}`);
+    console.log(`  ✓ native engine: 127.0.0.1:${apiPort} (proxied at /api)`);
     if (appRoot)
       console.log(`  ✓ app: ${path.relative(process.cwd(), appRoot) || "."}`);
     else console.log(`  ○ no app found — serving the welcome page`);

package/src/rastack.ts

@@ -13,7 +13,7 @@
  *   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 dev     [--port n] [--warehouse d]  Local dev: run your app in-browser over WASM
+ *   rastack dev     [--port n] [--warehouse d]  Local dev: your app in the browser, the API in native Rust
  *   rastack admin   [--warehouse dir] [--port n] Full admin console — React UI (rastack/components) over the native server
  *   rastack import <file> --resource app.model  Load CSV/XLSX/PDF data and validate it (state machine)
  *   rastack scan   [files...] [--fail-on-pii]   (LEGACY, pre-Rust) Scan CSVs for PII and schema info
@@ -72,7 +72,7 @@ switch (command) {
     console.error(
       "`rastack compile` has been removed — compilation now runs automatically\n" +
         "inside the two modalities of use:\n" +
-        "  • rastack dev    local development (compiles, then serves over WASM)\n" +
+        "  • rastack dev    local development (compiles, then proxies /api to native rastack-server)\n" +
         "  • rastack ci     the deploy pipeline (compiles the manifest + OpenAPI)\n\n" +
         "Introspect the resource graph with: rastack check | list | urls\n",
     );
@@ -85,9 +85,8 @@ switch (command) {
     run("rastack-compile.js", [command, ...rest]);
     break;
   case "dev":
-    // Local development: serve your app in the browser over the WASM engine
-    // (no native server, no cargo). The admin console is a separate command,
-    // `rastack admin`. Replaces `serve` + `wasm`.
+    // Local development: serve your app and proxy /api to native rastack-server.
+    // The admin console is a separate command, `rastack admin`.
     run("rastack-dev.js", rest);
     break;
   case "admin":
@@ -162,7 +161,7 @@ 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 dev     [--port n] [--warehouse dir] [--app dir] [--no-open]  Run your app in-browser over WASM (local dev)\n` +
+        `  rastack dev     [--port n] [--warehouse dir] [--app dir] [--no-open]  App in the browser, API in native rastack-server\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 import <file.csv|.xlsx|.pdf> --resource app.model [--related app.model=<file>] [--out cleaned.json]\n` +
         `  rastack scan   [files...] [--fail-on-pii]                     (legacy, pre-Rust)\n` +

package/src/validate/transitions.ts

@@ -23,7 +23,7 @@
  * list), and this module is the *shared executable form* of it: the same pure
  * functions guard a form submit (`useForm(...).transition("board")`), the
  * record machine (`runRecordMachine` with a `previous` row in context), and —
- * re-implemented 1:1 in `rastack-api-core` — every server/WASM write. A write
+ * re-implemented 1:1 in `rastack-api-core` — every native-server write. A write
  * that jumps between states without a declared edge is rejected on every
  * surface, which is what makes a transition "a backend function that is
  * state-machine safe": the only way to move a record between states is a

package/dist/rastack-wasm-build.d.ts

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-/**
- * 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  → 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) 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)
- */
-/** Run the full compile → wasm-bindgen → optimise pipeline. Throws via `run`'s
- *  `process.exit` on a missing tool or a non-zero step. */
-export declare function buildWasm(): void;

package/dist/rastack-wasm-build.js

@@ -1,94 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * 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  → 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) 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)
- */
-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"));
-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
-    // (cargo, wasm-bindgen, wasm-opt), not untrusted input — no injection surface.
-    // nosemgrep: javascript.lang.security.detect-child-process.detect-child-process
-    const result = (0, child_process_1.spawnSync)(cmd, args, {
-        stdio: "inherit",
-        cwd,
-        env: process.env,
-    });
-    if (result.error) {
-        console.error(`\nCould not run \`${cmd}\`. Is it installed and on PATH?`);
-        if (cmd === "wasm-bindgen") {
-            console.error("  cargo install wasm-bindgen-cli");
-        }
-        process.exit(1);
-    }
-    if (result.status !== 0) {
-        process.exit(result.status ?? 1);
-    }
-}
-function has(cmd) {
-    // Probes a fixed toolchain name (e.g. "wasm-opt") for availability; not
-    // untrusted input.
-    // nosemgrep: javascript.lang.security.detect-child-process.detect-child-process
-    return (0, child_process_1.spawnSync)(cmd, ["--version"], { stdio: "ignore" }).status === 0;
-}
-/** 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 → 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: wasm/ (${(size / 1024).toFixed(0)} KB)`);
-}
-if (require.main === module) {
-    buildWasm();
-}

package/dist/wasm/package.json

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

package/dist/wasm/rastack_wasm.d.ts

@@ -1,100 +0,0 @@
-/* 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_ac0f9960a408a037___convert__closures_____invoke___wasm_bindgen_ac0f9960a408a037___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_ac0f9960a408a037___JsError___true_: (a: number, b: number, c: any) => [number, number];
-    readonly wasm_bindgen_ac0f9960a408a037___convert__closures_____invoke___js_sys_10c47e7ecd0a94ab___Function_fn_wasm_bindgen_ac0f9960a408a037___JsValue_____wasm_bindgen_ac0f9960a408a037___sys__Undefined___js_sys_10c47e7ecd0a94ab___Function_fn_wasm_bindgen_ac0f9960a408a037___JsValue_____wasm_bindgen_ac0f9960a408a037___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>;