convex-rust 0.0.0-stage → 0.1.0

package/dist/cli/demangle.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Rust symbol demangler: v0 (`_R...`, spec: rust-lang.github.io/rfcs/2603-rust-symbol-name-mangling-v0.html)
+ * and legacy (`_ZN...E`). Best effort for display only: generics are shown, lifetimes and const
+ * details are simplified, and anything unparsable is returned unchanged.
+ */
+/** Demangled name, or the input when it is not a Rust symbol (or cannot be parsed). */
+export declare function demangle(name: string): string;

package/dist/cli/demangle.js

@@ -0,0 +1,328 @@
+/**
+ * Rust symbol demangler: v0 (`_R...`, spec: rust-lang.github.io/rfcs/2603-rust-symbol-name-mangling-v0.html)
+ * and legacy (`_ZN...E`). Best effort for display only: generics are shown, lifetimes and const
+ * details are simplified, and anything unparsable is returned unchanged.
+ */
+const BASIC = {
+    a: "i8", b: "bool", c: "char", d: "f64", e: "str", f: "f32", h: "u8", i: "isize", j: "usize", l: "i32", m: "u32",
+    n: "i128", o: "u128", s: "i16", t: "u16", u: "()", v: "...", x: "i64", y: "u64", z: "!", p: "_",
+};
+const B62 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+class Fail extends Error {
+}
+class V0 {
+    s;
+    i = 0;
+    depth = 0;
+    constructor(s) {
+        this.s = s;
+    }
+    peek() {
+        return this.s[this.i] ?? "";
+    }
+    next() {
+        if (this.i >= this.s.length)
+            throw new Fail();
+        return this.s[this.i++];
+    }
+    /** `<base-62-number> = {digit | lower | upper} "_"`: "_" is 0, otherwise the value plus one. */
+    base62() {
+        if (this.peek() === "_") {
+            this.i++;
+            return 0;
+        }
+        let n = 0;
+        for (;;) {
+            const c = this.next();
+            if (c === "_")
+                return n + 1;
+            const d = B62.indexOf(c);
+            if (d < 0)
+                throw new Fail();
+            n = n * 62 + d;
+        }
+    }
+    /** Optional `s<base62>` disambiguator. */
+    disambiguator() {
+        if (this.peek() === "s") {
+            this.i++;
+            this.base62();
+        }
+    }
+    ident() {
+        this.disambiguator();
+        if (this.peek() === "u")
+            this.i++; // punycode: shown undecoded
+        let len = 0;
+        let digits = 0;
+        while (/[0-9]/.test(this.peek())) {
+            len = len * 10 + Number(this.next());
+            digits++;
+            if (len === 0)
+                break; // "0" is the empty name (closures)
+        }
+        if (digits === 0)
+            throw new Fail();
+        if (this.peek() === "_")
+            this.i++;
+        if (this.i + len > this.s.length)
+            throw new Fail();
+        const out = this.s.slice(this.i, this.i + len);
+        this.i += len;
+        return out;
+    }
+    backref(f) {
+        const off = this.base62();
+        if (off >= this.i)
+            throw new Fail();
+        const saved = this.i;
+        this.i = off;
+        try {
+            return f();
+        }
+        finally {
+            this.i = saved;
+        }
+    }
+    enter(f) {
+        if (++this.depth > 120)
+            throw new Fail();
+        try {
+            return f();
+        }
+        finally {
+            this.depth--;
+        }
+    }
+    path() {
+        return this.enter(() => {
+            const c = this.next();
+            switch (c) {
+                case "C":
+                    return this.ident();
+                case "M": {
+                    this.disambiguator();
+                    this.path();
+                    return `<${this.type()}>`;
+                }
+                case "X": {
+                    this.disambiguator();
+                    this.path();
+                    const ty = this.type();
+                    return `<${ty} as ${this.path()}>`;
+                }
+                case "Y": {
+                    const ty = this.type();
+                    return `<${ty} as ${this.path()}>`;
+                }
+                case "N": {
+                    const ns = this.next();
+                    const parent = this.path();
+                    const name = this.ident();
+                    if (ns === "C")
+                        return `${parent}::{closure${name ? `:${name}` : ""}}`;
+                    if (ns === "S")
+                        return `${parent}::{shim${name ? `:${name}` : ""}}`;
+                    return `${parent}::${name}`;
+                }
+                case "I": {
+                    const p = this.path();
+                    const args = [];
+                    while (this.peek() !== "E") {
+                        const a = this.genericArg();
+                        if (a !== null)
+                            args.push(a);
+                    }
+                    this.i++;
+                    return args.length ? `${p}::<${args.join(", ")}>` : p;
+                }
+                case "B":
+                    return this.backref(() => this.path());
+                default:
+                    throw new Fail();
+            }
+        });
+    }
+    genericArg() {
+        const c = this.peek();
+        if (c === "L") {
+            this.i++;
+            this.base62();
+            return null;
+        }
+        if (c === "K") {
+            this.i++;
+            return this.konst();
+        }
+        return this.type();
+    }
+    konst() {
+        const c = this.peek();
+        if (c === "p") {
+            this.i++;
+            return "_";
+        }
+        if (c === "B") {
+            this.i++;
+            return this.backref(() => this.konst());
+        }
+        const ty = this.type();
+        let neg = false;
+        if (this.peek() === "n") {
+            this.i++;
+            neg = true;
+        }
+        let hex = "";
+        while (this.peek() !== "_")
+            hex += this.next();
+        this.i++;
+        if (ty === "bool")
+            return hex === "1" ? "true" : "false";
+        return (neg ? "-" : "") + (hex === "" ? "0" : BigInt("0x" + hex).toString());
+    }
+    lifetime() {
+        if (this.peek() === "L") {
+            this.i++;
+            this.base62();
+        }
+    }
+    type() {
+        return this.enter(() => {
+            const c = this.peek();
+            if (c >= "a" && c <= "z" && c in BASIC) {
+                this.i++;
+                return BASIC[c];
+            }
+            switch (c) {
+                case "A": {
+                    this.i++;
+                    const t = this.type();
+                    return `[${t}; ${this.konst()}]`;
+                }
+                case "S":
+                    this.i++;
+                    return `[${this.type()}]`;
+                case "T": {
+                    this.i++;
+                    const ts = [];
+                    while (this.peek() !== "E")
+                        ts.push(this.type());
+                    this.i++;
+                    return `(${ts.join(", ")}${ts.length === 1 ? "," : ""})`;
+                }
+                case "R":
+                case "Q": {
+                    this.i++;
+                    this.lifetime();
+                    return `&${c === "Q" ? "mut " : ""}${this.type()}`;
+                }
+                case "P":
+                case "O":
+                    this.i++;
+                    return `*${c === "O" ? "mut" : "const"} ${this.type()}`;
+                case "F": {
+                    this.i++;
+                    if (this.peek() === "G") {
+                        this.i++;
+                        this.base62();
+                    }
+                    if (this.peek() === "U")
+                        this.i++;
+                    if (this.peek() === "K") {
+                        this.i++;
+                        if (this.peek() === "C")
+                            this.i++;
+                        else
+                            this.ident();
+                    }
+                    const ps = [];
+                    while (this.peek() !== "E")
+                        ps.push(this.type());
+                    this.i++;
+                    const ret = this.type();
+                    return `fn(${ps.join(", ")})${ret === "()" ? "" : ` -> ${ret}`}`;
+                }
+                case "D": {
+                    this.i++;
+                    if (this.peek() === "G") {
+                        this.i++;
+                        this.base62();
+                    }
+                    const bounds = [];
+                    while (this.peek() !== "E") {
+                        let b = this.path();
+                        const assoc = [];
+                        while (this.peek() === "p") {
+                            this.i++;
+                            const n = this.ident();
+                            assoc.push(`${n} = ${this.type()}`);
+                        }
+                        if (assoc.length)
+                            b += `<${assoc.join(", ")}>`;
+                        bounds.push(b);
+                    }
+                    this.i++;
+                    this.lifetime();
+                    return `dyn ${bounds.join(" + ")}`;
+                }
+                case "B":
+                    this.i++;
+                    return this.backref(() => this.type());
+                default:
+                    return this.path();
+            }
+        });
+    }
+}
+function demangleV0(name) {
+    const m = name.match(/^_R(\d*)/);
+    if (!m)
+        return name;
+    // Backref offsets count from the start of the symbol after `_R` (and the optional version digits).
+    const body = name.slice(m[0].length).replace(/\.[A-Za-z].*$/, "");
+    const p = new V0(body);
+    try {
+        return p.path();
+    }
+    catch {
+        return name;
+    }
+}
+const LEGACY_ESCAPES = {
+    SP: "@", BP: "*", RF: "&", LT: "<", GT: ">", LP: "(", RP: ")", C: ",", u20: " ", u27: "'", u5b: "[", u5d: "]", u7b: "{", u7d: "}", u3b: ";", u2b: "+", u22: '"',
+};
+function demangleLegacy(name) {
+    const s = name.replace(/\.(?:llvm|cold|part|isra|constprop)[\w.]*$/, "");
+    if (!s.startsWith("_ZN") || !s.endsWith("E"))
+        return name;
+    const parts = [];
+    let i = 3;
+    const end = s.length - 1;
+    while (i < end) {
+        let j = i;
+        while (j < end && s.charCodeAt(j) >= 48 && s.charCodeAt(j) <= 57)
+            j++;
+        if (j === i)
+            return name;
+        const len = Number(s.slice(i, j));
+        if (j + len > end)
+            return name;
+        parts.push(s.slice(j, j + len));
+        i = j + len;
+    }
+    if (parts.length > 1 && /^h[0-9a-f]{16}$/.test(parts[parts.length - 1]))
+        parts.pop();
+    return parts
+        .map((p) => (p.startsWith("_$") ? p.slice(1) : p)
+        .replace(/\.\./g, "::")
+        .replace(/\$([A-Za-z0-9]+)\$/g, (m, k) => LEGACY_ESCAPES[k] ?? m))
+        .join("::");
+}
+/** Demangled name, or the input when it is not a Rust symbol (or cannot be parsed). */
+export function demangle(name) {
+    if (name.startsWith("_R"))
+        return demangleV0(name);
+    if (name.startsWith("_ZN"))
+        return demangleLegacy(name);
+    return name;
+}

package/dist/cli/diagnostics.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Friendly explanations for cargo failures when building for wasm32-wasip1.
+ * Cargo's own output is always kept; the hints are appended after it.
+ *
+ * Data-driven: each {@link Rule} looks at the captured stderr and returns zero
+ * or more {@link Finding}s. A finding may name a crate, in which case the
+ * caller can show who pulls it in (`cargo tree -i <crate>`).
+ */
+export interface Finding {
+    /** Stable rule id. */
+    rule: string;
+    /** Headline: what went wrong. */
+    title: string;
+    /** Actionable advice, one bullet per entry. */
+    advice: string[];
+    /** Crate worth running `cargo tree -i` on. */
+    crate?: string;
+}
+export interface Rule {
+    id: string;
+    match: (stderr: string) => Finding[];
+}
+export declare const RULES: Rule[];
+/** Findings for a failed `cargo build` (stderr as captured). */
+export declare function diagnoseCargoFailure(stderr: string): Finding[];
+/** Arguments of the `cargo tree` call that shows who depends on `crate`. */
+export declare function cargoTreeArgs(crate: string): string[];
+/** Human-readable text for findings; `trees` maps crate -> `cargo tree` output. */
+export declare function formatFindings(findings: Finding[], trees?: Record<string, string>): string;
+/**
+ * Hint for a runtime (host) error message from a Rust action, for cases the
+ * build cannot catch. Returns null when the text is not recognised.
+ */
+export declare function diagnoseRuntimeError(text: string): string | null;

package/dist/cli/diagnostics.js

@@ -0,0 +1,296 @@
+/**
+ * Friendly explanations for cargo failures when building for wasm32-wasip1.
+ * Cargo's own output is always kept; the hints are appended after it.
+ *
+ * Data-driven: each {@link Rule} looks at the captured stderr and returns zero
+ * or more {@link Finding}s. A finding may name a crate, in which case the
+ * caller can show who pulls it in (`cargo tree -i <crate>`).
+ */
+const TARGET = "wasm32-wasip1";
+const NODE_FALLBACK = 'If you cannot avoid it, move that work to a `"use node"` action and call it with `ctx.run_action`.';
+const WASI_SDK_ADVICE = "It builds with a wasi-sdk C compiler: run `npx convex-rust build --wasi-sdk` (downloads ~180 MB once to ~/.cache/convex-rust, or set WASI_SDK_PATH to your own wasi-sdk). Verified to build and run for this crate.";
+/** Crates with C code that cannot be compiled for wasm32-wasip1 as-is. */
+const C_DEPS = {
+    "openssl-sys": {
+        what: "OpenSSL",
+        advice: [
+            'Switch the crate that pulls it in to a rustls/pure-Rust feature (for example `default-features = false, features = ["rustls-tls"]`), or drop TLS: HTTP goes through the built-in `reqwest` shim (`ctx.fetch`), which needs no TLS stack.',
+            NODE_FALLBACK,
+        ],
+    },
+    ring: {
+        what: "ring (C and assembly)",
+        advice: [
+            WASI_SDK_ADVICE,
+            "Or disable the feature that needs `ring`, or pick a pure-Rust backend (RustCrypto: `sha2`, `hmac`, `aes-gcm`, ...).",
+            "For `jsonwebtoken`, enable the `rust_crypto` feature instead of `aws_lc_rs`.",
+            "For AWS services use the `convex_aws` crate (HTTP over `ctx.fetch`) instead of the SDK's default TLS client.",
+            NODE_FALLBACK,
+        ],
+    },
+    "aws-lc-sys": {
+        what: "AWS-LC (C)",
+        advice: [
+            "For AWS services use the `convex_aws` crate (HTTP over `ctx.fetch`); do not enable the SDK's default HTTPS connector.",
+            "For `jsonwebtoken`, enable the `rust_crypto` feature instead of `aws_lc_rs`.",
+            "For `rustls`, avoid the `aws_lc_rs` provider (use `default-features = false`), or avoid rustls: outgoing HTTP does not need it here.",
+            NODE_FALLBACK,
+        ],
+    },
+    "libsqlite3-sys": {
+        what: "SQLite (C)",
+        advice: [
+            `${WASI_SDK_ADVICE} (\`rusqlite\` with the \`bundled\` feature; in-memory databases only, the host has no filesystem, and it adds ~1.4 MB to the wasm.)`,
+            "Convex is already your database: store the data in Convex tables via `ctx.run_query` / `ctx.run_mutation`.",
+            'If you need SQLite itself, call a `"use node"` action with `ctx.run_action`.',
+        ],
+    },
+    "zstd-sys": {
+        what: "zstd (C)",
+        advice: [
+            WASI_SDK_ADVICE,
+            "Or use a pure-Rust codec (`ruzstd`, `lz4_flex`) or disable the dependency's zstd feature.",
+            NODE_FALLBACK,
+        ],
+    },
+    "lzma-sys": {
+        what: "liblzma (C)",
+        advice: [
+            "Use a pure-Rust codec (`lzma-rs`) or disable the dependency's lzma feature.",
+        ],
+    },
+    "bzip2-sys": {
+        what: "libbz2 (C)",
+        advice: [
+            "Use `bzip2` with the pure-Rust `libbz2-rs-sys` backend, or disable the feature.",
+        ],
+    },
+    "libz-sys": {
+        what: "zlib (C)",
+        advice: ["Use `flate2` with the `rust_backend` (miniz_oxide) feature."],
+    },
+};
+const GENERIC_C_ADVICE = [
+    "If `wasi-sdk` is not installed, try `npx convex-rust build --wasi-sdk` (or set WASI_SDK_PATH): many C crates build with it (verified: zstd-sys, libsqlite3-sys bundled, ring 0.17).",
+    "Look for a feature flag on the dependency that selects a pure-Rust implementation, or replace the crate.",
+    `Only zstd-sys, libsqlite3-sys and ring are verified to build for ${TARGET}. ${NODE_FALLBACK}`,
+];
+/** Raw-socket database/network drivers: no sockets in v1. */
+const SOCKET_CRATES = [
+    "sqlx",
+    "tokio-postgres",
+    "postgres",
+    "mongodb",
+    "redis",
+    "mysql_async",
+    "mysql",
+    "diesel",
+    "lettre",
+    "rdkafka",
+    "lapin",
+    "async-nats",
+    "tiberius",
+    "scylla",
+];
+const SOCKET_ADVICE = [
+    "`use rust` v1 has no raw sockets (no TCP/UDP/DNS), so crates that open their own connections cannot run.",
+    "Use an HTTP-based driver or the vendor's HTTP API, which works through `reqwest`/`ctx.fetch` (for example Neon or PlanetScale serverless HTTP drivers, Supabase REST, Upstash Redis REST).",
+    'Or do the socket work in a `"use node"` action and call it with `ctx.run_action`.',
+];
+const THREAD_ADVICE = [
+    "`use rust` runs single-threaded: rayon's thread pool and `std::thread::spawn` compile but cannot start threads at runtime.",
+    'Replace `par_iter()` with `iter()`, or run the parallel work in a `"use node"` action via `ctx.run_action`.',
+];
+function compilingCrates(stderr) {
+    const out = new Set();
+    for (const m of stderr.matchAll(/^\s*(?:Compiling|Checking)\s+([\w.-]+)\s+v/gm)) {
+        out.add(m[1]);
+    }
+    for (const m of stderr.matchAll(/could not compile `([\w.-]+)`/g)) {
+        out.add(m[1]);
+    }
+    return out;
+}
+function failedBuildScripts(stderr) {
+    return [
+        ...stderr.matchAll(/failed to run custom build command for `([\w.-]+) v/g),
+    ].map((m) => m[1]);
+}
+export const RULES = [
+    {
+        id: "missing-target",
+        match: (s) => /can't find crate for `(std|core)`|target may not be installed|is not installed for the toolchain|does not support target/.test(s)
+            ? [
+                {
+                    rule: "missing-target",
+                    title: `The ${TARGET} Rust target is not installed`,
+                    advice: [`Run: rustup target add ${TARGET}`],
+                },
+            ]
+            : [],
+    },
+    {
+        id: "c-dep",
+        match: (s) => {
+            const out = [];
+            for (const name of new Set(failedBuildScripts(s))) {
+                if (name === "psm")
+                    continue;
+                const known = C_DEPS[name];
+                if (!known && !name.endsWith("-sys"))
+                    continue;
+                out.push({
+                    rule: "c-dep",
+                    title: known
+                        ? `\`${name}\` needs a C library (${known.what}) that is not available for ${TARGET}`
+                        : `\`${name}\` builds native code that is not available for ${TARGET}`,
+                    advice: known ? known.advice : GENERIC_C_ADVICE,
+                    crate: name,
+                });
+            }
+            return out;
+        },
+    },
+    {
+        id: "c-toolchain",
+        match: (s) => {
+            const isC = /failed to find tool "[^"]*"|wasm32-wasi[\w-]*-clang|No available targets are compatible with triple "wasm32|error occurred in cc-rs/.test(s);
+            if (!isC)
+                return [];
+            const failed = failedBuildScripts(s);
+            // Already reported with specific advice by the `c-dep` rule.
+            if (failed.some((c) => C_DEPS[c] || c.endsWith("-sys")))
+                return [];
+            const crate = failed.find((c) => c !== "psm");
+            return [
+                {
+                    rule: "c-toolchain",
+                    title: `A dependency compiles C code and no C compiler for ${TARGET} was found`,
+                    advice: GENERIC_C_ADVICE,
+                    ...(crate ? { crate } : {}),
+                },
+            ];
+        },
+    },
+    {
+        id: "sockets",
+        match: (s) => {
+            const socketError = /Socket2 doesn't support the compile target|could not find `(net|unix)` in `(sys|mio)`|unresolved import `(mio|tokio)::net`|mio[^\n]*(not supported|unsupported)[^\n]*(platform|target)|(socket2|mio)[^\n]*not supported on this platform/i.test(s);
+            if (!socketError)
+                return [];
+            const crates = compilingCrates(s);
+            const drivers = SOCKET_CRATES.filter((c) => crates.has(c));
+            return [
+                {
+                    rule: "sockets",
+                    title: drivers.length > 0
+                        ? `${drivers.map((d) => `\`${d}\``).join(", ")} need raw sockets, which ${TARGET} does not have`
+                        : `A dependency needs raw sockets (socket2 / mio / tokio net), which ${TARGET} does not have`,
+                    advice: SOCKET_ADVICE,
+                    crate: /socket2/i.test(s) ? "socket2" : "mio",
+                },
+            ];
+        },
+    },
+    {
+        id: "getrandom",
+        match: (s) => /getrandom/.test(s) &&
+            /the wasm\d*-unknown-unknown targets are not supported by default|target is not supported|unsupported target|wasm_js/i.test(s)
+            ? [
+                {
+                    rule: "getrandom",
+                    title: "`getrandom` rejects the target it is being built for",
+                    advice: [
+                        `On ${TARGET} getrandom needs no \`js\` / \`wasm_js\` feature. This error usually means the build is not for ${TARGET}: check that \`.cargo/config.toml\` still has \`[build] target = "${TARGET}"\` and that no \`--target\` override or \`getrandom_backend\` cfg in RUSTFLAGS is set.`,
+                        "If it persists, run `cargo update -p getrandom` (very old releases do not know WASI), and make sure no dependency enables the `custom` or `js` backend.",
+                    ],
+                    crate: "getrandom",
+                },
+            ]
+            : [],
+    },
+    {
+        id: "psm",
+        match: (s) => /section too large/i.test(s) ||
+            failedBuildScripts(s).includes("psm") ||
+            /could not compile `psm`/.test(s)
+            ? [
+                {
+                    rule: "psm",
+                    title: "`psm` (pulled in by `stacker`) fails to build for wasm",
+                    advice: [
+                        "Commit `Cargo.lock` and pin a working version of the dependent crate (`cargo update -p <crate> --precise <version>`), or drop the dependency that uses `stacker`.",
+                    ],
+                    crate: "psm",
+                },
+            ]
+            : [],
+    },
+    {
+        id: "rayon",
+        match: (s) => /could not compile `(rayon|rayon-core)`/.test(s)
+            ? [
+                {
+                    rule: "rayon",
+                    title: "`rayon` needs OS threads, which are not available in `use rust`",
+                    advice: THREAD_ADVICE,
+                    crate: "rayon",
+                },
+            ]
+            : [],
+    },
+];
+/** Findings for a failed `cargo build` (stderr as captured). */
+export function diagnoseCargoFailure(stderr) {
+    const seen = new Set();
+    const out = [];
+    for (const rule of RULES) {
+        for (const f of rule.match(stderr)) {
+            const key = `${f.rule}:${f.crate ?? ""}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push(f);
+        }
+    }
+    return out;
+}
+/** Arguments of the `cargo tree` call that shows who depends on `crate`. */
+export function cargoTreeArgs(crate) {
+    return ["tree", "-i", crate, "--target", TARGET, "-e", "normal"];
+}
+/** Human-readable text for findings; `trees` maps crate -> `cargo tree` output. */
+export function formatFindings(findings, trees = {}) {
+    const lines = [];
+    for (const f of findings) {
+        lines.push("", `Hint: ${f.title}.`);
+        for (const a of f.advice)
+            lines.push(`  - ${a}`);
+        if (!f.crate)
+            continue;
+        const tree = trees[f.crate]?.trimEnd();
+        if (tree) {
+            lines.push(`  Who depends on \`${f.crate}\` (cargo ${cargoTreeArgs(f.crate).join(" ")}):`, ...tree
+                .split("\n")
+                .slice(0, 25)
+                .map((l) => `    ${l}`));
+        }
+        else {
+            lines.push(`  To see who pulls it in: cargo ${cargoTreeArgs(f.crate).join(" ")}`);
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Hint for a runtime (host) error message from a Rust action, for cases the
+ * build cannot catch. Returns null when the text is not recognised.
+ */
+export function diagnoseRuntimeError(text) {
+    if (/failed to spawn thread|ThreadPoolBuildError|global thread pool has not been initialized|operation not supported on this platform.*thread|thread::spawn/i.test(text)) {
+        return `Hint: this looks like a thread being started. ${THREAD_ADVICE.join(" ")}`;
+    }
+    if (/sock_(connect|open|accept)|Unsupported.*(tcp|socket)/i.test(text)) {
+        return `Hint: raw sockets are not available in \`use rust\`. ${SOCKET_ADVICE.slice(1).join(" ")}`;
+    }
+    return null;
+}

package/dist/cli/generate.d.ts

@@ -0,0 +1,29 @@
+import { RustManifestEntry } from "./manifest.js";
+export declare const GENERATED_HEADER = "// @generated by convex-rust. Do not edit.";
+export interface GenerateOptions {
+    entries: RustManifestEntry[];
+    /** File name of the wasm below `<out>/_wasm/`, e.g. `hello_rust.wasm`. */
+    wasmFile: string;
+    /**
+     * Directory of the generated files, relative to the Convex functions
+     * directory, with `/` separators (default `rust`).
+     */
+    outRelToFunctions?: string;
+    /**
+     * Short content hash of the wasm, written into each module. `convex dev` does not watch
+     * `.wasm` imports, so this makes a wasm-only change touch a watched `.ts` file.
+     */
+    wasmHash?: string;
+    /** Environment variable names the guest may read (`build --env`). */
+    env?: string[];
+    /**
+     * Per-module wasm (`build --split`): Convex module name -> wasm file below `<out>/_wasm/` and its
+     * content hash. Modules not listed use `wasmFile`.
+     */
+    moduleWasm?: Map<string, {
+        file: string;
+        hash: string;
+    }>;
+}
+/** Generated files, keyed by path relative to the out dir. */
+export declare function generateFiles(opts: GenerateOptions): Map<string, string>;