@frontiers-labs/argon 0.4.0

package/dist/codegen/rust.js

@@ -0,0 +1,1076 @@
+// Rust SSR backend: ModuleIR → a dependency-free .rs file.
+//
+// Emission is type-directed: the IR carries inferred types, so strings are
+// borrowed (&str) where possible and owned (String) where required, props
+// support sequences (Vec<T>), and generated components get an idiomatic
+// `new(...)` constructor taking `impl Into<String>` / `impl IntoIterator`.
+import { attrPositions, isMarkup, markupValue, referencedNames, valueExprIndices, visitExpr, visitStmt, } from "../ir.js";
+import { assertNoDiagnostics } from "../diagnostics.js";
+import { MARKER_RE } from "../template.js";
+import { serialize } from "../html.js";
+import { isBooleanAttr } from "../html-attrs.js";
+export function compileRust(module, opts = {}) {
+    assertNoDiagnostics(analyze(module), module.source);
+    return new RustGen(module, opts).generate();
+}
+// ── Naming ───────────────────────────────────────────────────────────────────
+function snake(name) {
+    return name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+function kebab(name) {
+    return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+// ── SSR analysis ─────────────────────────────────────────────────────────────
+//
+// Lowering already marked everything the SSR subset cannot express as opaque
+// nodes carrying diagnostics; here we collect the ones that are actually
+// reachable from server-rendered values.
+// Props may be scalars, interface (struct) types, or arrays of either —
+// every shape the compiler can both render in Rust and serialize for
+// hydration with a generated (dependency-free) JSON encoder.
+function supportedProp(type, structs, seen = new Set()) {
+    switch (type.kind) {
+        case "string":
+        case "number":
+        case "boolean":
+            return true;
+        case "struct": {
+            if (seen.has(type.name))
+                return true;
+            const struct = structs.get(type.name);
+            if (!struct)
+                return false;
+            seen.add(type.name);
+            return struct.fields.every(f => supportedProp(f.type, structs, seen));
+        }
+        case "array":
+        case "fixed":
+            return supportedProp(type.elem, structs, seen);
+        case "tuple":
+            return type.elems.every(e => supportedProp(e, structs, seen));
+        case "option":
+            return supportedProp(type.inner, structs, seen);
+        default:
+            return false;
+    }
+}
+function analyze(module) {
+    const diagnostics = [];
+    if (module.components.length === 0) {
+        return [{
+                code: "ARGON001",
+                target: "all",
+                message: "No Argon component found.",
+                span: { start: 0, end: 0 },
+                hint: "Export a capitalized multi-word function returning Component with a TSX template.",
+            }];
+    }
+    const collectOpaque = (expr) => {
+        visitExpr(expr, e => {
+            if (e.kind === "opaque")
+                diagnostics.push(e.diagnostic);
+        });
+    };
+    for (const component of module.components) {
+        for (const prop of component.props) {
+            if (!supportedProp(prop.type, module.structs)) {
+                diagnostics.push({
+                    code: "ARGON102",
+                    target: "ssr",
+                    message: `Rust SSR props support scalars, interface types, and arrays of them; '${prop.name}' is unsupported.`,
+                    span: component.span,
+                    hint: "Annotate the prop with string/number/boolean, an interface declared in this file, or an array of those.",
+                });
+            }
+        }
+        for (const stmt of component.setup) {
+            if (stmt.kind === "opaque")
+                diagnostics.push(stmt.diagnostic);
+            else if (stmt.kind === "let")
+                collectOpaque(stmt.init);
+        }
+        for (const index of valueExprIndices(component.template)) {
+            collectOpaque(component.template.exprs[index]);
+        }
+    }
+    for (const decl of reachableDecls(module, module.components)) {
+        if (decl.kind === "opaque")
+            diagnostics.push(decl.diagnostic);
+    }
+    return diagnostics;
+}
+function reachableDecls(module, components) {
+    const byName = new Map(module.decls.map(d => [d.name, d]));
+    const roots = new Set();
+    for (const component of components) {
+        for (const stmt of component.setup) {
+            if (stmt.kind === "let")
+                for (const name of referencedNames(stmt.init))
+                    roots.add(name);
+        }
+        for (const index of valueExprIndices(component.template)) {
+            for (const name of referencedNames(component.template.exprs[index]))
+                roots.add(name);
+        }
+    }
+    const seen = new Set();
+    const order = [];
+    const visit = (name) => {
+        if (seen.has(name))
+            return;
+        const decl = byName.get(name);
+        if (!decl)
+            return;
+        seen.add(name);
+        if (decl.kind === "fn") {
+            for (const stmt of decl.body) {
+                visitStmt(stmt, e => {
+                    for (const ref of referencedNames(e))
+                        visit(ref);
+                });
+            }
+        }
+        else if (decl.kind === "table") {
+            for (const entry of decl.entries)
+                for (const ref of referencedNames(entry.value))
+                    visit(ref);
+        }
+        order.push(decl);
+    };
+    for (const root of roots)
+        visit(root);
+    // Preserve module source order for readable output.
+    const picked = new Set(order.map(d => d.name));
+    return module.decls.filter(d => picked.has(d.name));
+}
+// ── Types ────────────────────────────────────────────────────────────────────
+function rustType(type) {
+    switch (type.kind) {
+        case "string": return "String";
+        case "number": return "f64";
+        case "boolean": return "bool";
+        case "array": return `Vec<${rustType(type.elem)}>`;
+        case "fixed": return `[${rustType(type.elem)}; ${type.size}]`;
+        case "tuple": return `(${type.elems.map(rustType).join(", ")})`;
+        case "struct": return type.name;
+        case "option": return `Option<${rustType(type.inner)}>`;
+        case "unknown": return "f64";
+    }
+}
+function borrowedType(type) {
+    switch (type.kind) {
+        case "string": return "&str";
+        case "array": return `&[${rustType(type.elem)}]`;
+        case "fixed": return `&[${rustType(type.elem)}; ${type.size}]`;
+        case "struct": return `&${type.name}`;
+        default: return rustType(type);
+    }
+}
+function isCopy(type) {
+    switch (type.kind) {
+        case "number":
+        case "boolean":
+            return true;
+        case "tuple": return type.elems.every(isCopy);
+        case "fixed": return isCopy(type.elem);
+        case "option": return isCopy(type.inner);
+        default: return false;
+    }
+}
+// A place expression: borrowing it costs nothing, moving it out may not be
+// allowed — owned contexts must clone.
+function isPlace(e) {
+    return e.kind === "ref" || e.kind === "member" || e.kind === "index";
+}
+class RustGen {
+    module;
+    opts;
+    out = [];
+    fns = new Map();
+    // Locals that are usize loop indices and need an `as f64` cast when read.
+    usizeVars = new Set();
+    // Setup locals holding markup (a JSX string), so reads render raw not escaped.
+    markupLocals = new Set();
+    // Structs that need a generated argon_json() impl for prop hydration.
+    jsonStructs = new Set();
+    needsEscape = false;
+    needsEscapeText = false;
+    needsStrSlice = false;
+    needsSlice = false;
+    needsPad = false;
+    needsJsonStr = false;
+    needsJsonStrings = false;
+    needsJsonNumbers = false;
+    constructor(module, opts = {}) {
+        this.module = module;
+        this.opts = opts;
+        for (const decl of module.decls) {
+            if (decl.kind === "fn")
+                this.fns.set(decl.name, { params: decl.params, ret: decl.ret });
+        }
+    }
+    generate() {
+        for (const struct of this.module.structs.values())
+            this.emitStruct(struct);
+        for (const decl of reachableDecls(this.module, this.module.components))
+            this.emitDecl(decl);
+        const impls = this.module.components.map(c => this.emitComponent(c));
+        const jsonImpls = this.emitJsonImpls();
+        return [
+            "// Generated by Argon compiler — do not edit by hand.",
+            "// SSR output: deterministic HTML only. Event handlers and browser APIs stay in the CSR bundle.",
+            "#[allow(unused_imports)]",
+            "use std::fmt::Write as _;",
+            "",
+            ...this.helpers(),
+            ...this.out,
+            ...jsonImpls,
+            ...impls,
+        ].join("\n");
+    }
+    helpers() {
+        const helpers = [];
+        if (this.needsEscape) {
+            // Inside a double-quoted attribute value only `&` and `"` can break out;
+            // leaving `<`/`>` intact keeps hydration JSON and href values readable.
+            helpers.push(`fn argon_escape_attr(value: &str) -> String {
+    let mut out = String::with_capacity(value.len());
+    for c in value.chars() {
+        match c {
+            '&' => out.push_str("&amp;"),
+            '"' => out.push_str("&quot;"),
+            c => out.push(c),
+        }
+    }
+    out
+}
+`);
+        }
+        if (this.needsEscapeText) {
+            // Text content: neutralize markup so an interpolated value cannot inject
+            // elements. `unsafeHtml(...)` opts a trusted string out of this.
+            helpers.push(`fn argon_escape_text(value: &str) -> String {
+    let mut out = String::with_capacity(value.len());
+    for c in value.chars() {
+        match c {
+            '&' => out.push_str("&amp;"),
+            '<' => out.push_str("&lt;"),
+            '>' => out.push_str("&gt;"),
+            c => out.push(c),
+        }
+    }
+    out
+}
+`);
+        }
+        if (this.needsStrSlice) {
+            // JS String.slice: indices count from the end when negative and clamp to
+            // bounds. We count Unicode scalars (JS counts UTF-16 units).
+            helpers.push(`fn argon_str_slice(value: &str, start: f64, end: Option<f64>) -> String {
+    let chars: Vec<char> = value.chars().collect();
+    let len = chars.len() as isize;
+    let norm = |i: f64| -> isize { let i = i as isize; if i < 0 { (len + i).max(0) } else { i.min(len) } };
+    let a = norm(start);
+    let b = end.map(norm).unwrap_or(len);
+    if a >= b { return String::new(); }
+    chars[a as usize..b as usize].iter().collect()
+}
+`);
+        }
+        if (this.needsPad) {
+            helpers.push(`fn argon_pad(value: &str, width: f64, pad: &str, start: bool) -> String {
+    let len = value.chars().count();
+    let target = width as usize;
+    let pad_chars: Vec<char> = pad.chars().collect();
+    if len >= target || pad_chars.is_empty() { return value.to_string(); }
+    let fill: String = (0..target - len).map(|i| pad_chars[i % pad_chars.len()]).collect();
+    if start { format!("{}{}", fill, value) } else { format!("{}{}", value, fill) }
+}
+`);
+        }
+        if (this.needsSlice) {
+            // JS Array.slice: end-relative negative indices, clamped to bounds.
+            helpers.push(`fn argon_slice<T: Clone>(value: &[T], start: f64, end: Option<f64>) -> Vec<T> {
+    let len = value.len() as isize;
+    let norm = |i: f64| -> isize { let i = i as isize; if i < 0 { (len + i).max(0) } else { i.min(len) } };
+    let a = norm(start);
+    let b = end.map(norm).unwrap_or(len);
+    if a >= b { return Vec::new(); }
+    value[a as usize..b as usize].to_vec()
+}
+`);
+        }
+        if (this.needsJsonStrings)
+            this.needsJsonStr = true;
+        if (this.needsJsonStr) {
+            helpers.push(String.raw `fn argon_json_str(value: &str) -> String {
+    let mut out = String::with_capacity(value.len() + 2);
+    out.push('"');
+    for c in value.chars() {
+        match c {
+            '"' => out.push_str("\\\""),
+            '\\' => out.push_str("\\\\"),
+            '\n' => out.push_str("\\n"),
+            c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
+            c => out.push(c),
+        }
+    }
+    out.push('"');
+    out
+}
+` + "\n");
+        }
+        if (this.needsJsonStrings) {
+            helpers.push(`fn argon_json_strings(values: &[String]) -> String {
+    let parts: Vec<String> = values.iter().map(|v| argon_json_str(v)).collect();
+    format!("[{}]", parts.join(","))
+}
+`);
+        }
+        if (this.needsJsonNumbers) {
+            helpers.push(`fn argon_json_numbers(values: &[f64]) -> String {
+    let parts: Vec<String> = values.iter().map(|v| v.to_string()).collect();
+    format!("[{}]", parts.join(","))
+}
+`);
+        }
+        return helpers;
+    }
+    // ── Structs and module declarations ──────────────────────────────────────
+    emitStruct(struct) {
+        const fields = struct.fields.map(f => `    pub ${snake(f.name)}: ${rustType(f.type)},`);
+        this.out.push(`#[derive(Clone, PartialEq)]\npub struct ${struct.name} {\n${fields.join("\n")}\n}\n`);
+    }
+    emitDecl(decl) {
+        if (decl.kind === "css") {
+            this.out.push(`const ${snake(decl.name).toUpperCase()}: &str = ${JSON.stringify(decl.text)};\n`);
+        }
+        else if (decl.kind === "table") {
+            const arms = decl.entries.map(e => `        ${JSON.stringify(e.key)} => ${this.owned(e.value)},`);
+            arms.push(`        _ => ${this.owned(decl.entries[0].value)},`);
+            this.out.push(`fn ${snake(decl.name)}(key: &str) -> ${rustType(decl.valueType)} {\n    match key {\n${arms.join("\n")}\n    }\n}\n`);
+        }
+        else if (decl.kind === "fn") {
+            const params = decl.params.map(p => `${snake(p.name)}: ${borrowedType(p.type)}`);
+            const body = decl.body.map(s => "    " + this.stmt(s)).join("\n");
+            this.out.push(`// argon: ${this.loc(decl.span.start)}\nfn ${snake(decl.name)}(${params.join(", ")}) -> ${rustType(decl.ret)} {\n${body}\n}\n`);
+        }
+    }
+    // ── Component ──────────────────────────────────────────────────────────────
+    emitComponent(component) {
+        this.markupLocals = new Set();
+        for (const stmt of component.setup) {
+            if (stmt.kind === "let" && !stmt.tuple && markupValue(stmt.init, this.markupLocals)) {
+                this.markupLocals.add(stmt.names[0]);
+            }
+        }
+        const fields = component.props.map(p => `    pub ${snake(p.name)}: ${rustType(p.type)},`);
+        const prelude = component.setup
+            .filter(s => s.kind === "let")
+            .map(s => "        " + this.stmt(s))
+            .join("\n");
+        const segments = this.templateSegments(component);
+        const renderBody = segments
+            .map(s => ("lit" in s ? (s.lit ? `        __out.push_str("${rustStrLit(s.lit)}");` : "") : s.code))
+            .filter(Boolean)
+            .join("\n");
+        // Optional props contribute their whole ` data-x="..."` chunk dynamically:
+        // an absent value omits the attribute, so the client hydrates undefined.
+        const dataAttrs = component.props
+            .map(p => (p.type.kind === "option" ? "{}" : ` data-${kebab(p.name)}=\\"{}\\"`))
+            .join("");
+        const attrArgs = component.props.map(p => this.dataAttrValue(p));
+        const wrapper = `format!("<${component.tagName}${dataAttrs}>{}</${component.tagName}>", ${[...attrArgs, "self.render_inner()"].join(", ")})`;
+        return `// argon: ${this.loc(component.span.start)}
+#[derive(Clone)]
+pub struct ${component.className} {
+${fields.join("\n")}
+}
+
+impl ${component.className} {
+${this.emitNew(component.props)}
+
+    // The declarative shadow DOM alone — what a composing parent inlines
+    // inside the host tag it renders itself.
+    pub fn render_inner(&self) -> String {
+${prelude}${prelude ? "\n" : ""}        let mut __out = String::new();
+${renderBody}
+        format!("<template shadowrootmode=\\"open\\">{}</template>", __out)
+    }
+
+    pub fn render(&self) -> String {
+        ${wrapper}
+    }
+}
+
+impl std::fmt::Display for ${component.className} {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.render())
+    }
+}
+`;
+    }
+    emitNew(props) {
+        const params = [];
+        const inits = [];
+        for (const prop of props) {
+            const name = snake(prop.name);
+            switch (prop.type.kind) {
+                case "string":
+                    params.push(`${name}: impl Into<String>`);
+                    inits.push(`${name}: ${name}.into()`);
+                    break;
+                case "struct":
+                    // `impl Into<T>` lets callers feed their own types (DB rows etc.)
+                    // through a single From impl.
+                    params.push(`${name}: impl Into<${prop.type.name}>`);
+                    inits.push(`${name}: ${name}.into()`);
+                    break;
+                case "array":
+                    if (prop.type.elem.kind === "string" || prop.type.elem.kind === "struct") {
+                        params.push(`${name}: impl IntoIterator<Item = impl Into<${rustType(prop.type.elem)}>>`);
+                        inits.push(`${name}: ${name}.into_iter().map(Into::into).collect()`);
+                    }
+                    else {
+                        params.push(`${name}: impl IntoIterator<Item = ${rustType(prop.type.elem)}>`);
+                        inits.push(`${name}: ${name}.into_iter().collect()`);
+                    }
+                    break;
+                default:
+                    params.push(`${name}: ${rustType(prop.type)}`);
+                    inits.push(name);
+            }
+        }
+        const body = inits.length > 0 ? `Self { ${inits.join(", ")} }` : "Self {}";
+        return `    pub fn new(${params.join(", ")}) -> Self {
+        ${body}
+    }`;
+    }
+    dataAttrValue(prop) {
+        const field = `self.${snake(prop.name)}`;
+        if (prop.type.kind === "option") {
+            const value = this.attrValue("v", prop.type.inner);
+            return `match &${field} { Some(v) => format!(" data-${kebab(prop.name)}=\\"{}\\"", ${value}), None => String::new() }`;
+        }
+        return this.attrValue(field, prop.type);
+    }
+    attrValue(path, type) {
+        if (type.kind === "string") {
+            this.needsEscape = true;
+            return `argon_escape_attr(&${path})`;
+        }
+        if (type.kind === "number" || type.kind === "boolean") {
+            return path;
+        }
+        this.needsEscape = true;
+        return `argon_escape_attr(&${this.jsonValue(path, type)})`;
+    }
+    // A Rust expression producing the JSON encoding of `path`. The compiler
+    // knows every field type, so serializers are generated — no serde needed.
+    jsonValue(path, type) {
+        switch (type.kind) {
+            case "string":
+                this.needsJsonStr = true;
+                return `argon_json_str(&${path})`;
+            case "number":
+            case "boolean":
+                return `${path}.to_string()`;
+            case "struct":
+                this.jsonStructs.add(type.name);
+                return `${path}.argon_json()`;
+            case "array":
+            case "fixed":
+                if (type.elem.kind === "string") {
+                    this.needsJsonStrings = true;
+                    return `argon_json_strings(&${path})`;
+                }
+                if (type.elem.kind === "number") {
+                    this.needsJsonNumbers = true;
+                    return `argon_json_numbers(&${path})`;
+                }
+                return `format!("[{}]", ${path}.iter().map(|v| ${this.jsonValue("v", type.elem)}).collect::<Vec<String>>().join(","))`;
+            case "tuple": {
+                const parts = type.elems.map((elem, i) => this.jsonValue(`${path}.${i}`, elem));
+                return `format!("[{}]", [${parts.join(", ")}].join(","))`;
+            }
+            case "option":
+                return `${path}.as_ref().map(|v| ${this.jsonValue("v", type.inner)}).unwrap_or_else(|| "null".to_string())`;
+            case "unknown":
+                return `${path}.to_string()`;
+        }
+    }
+    // fn argon_json(&self) -> String impls for every struct reachable from a
+    // component prop, keyed by the original TS field names so the hydrated
+    // client sees the same shape it renders with.
+    emitJsonImpls() {
+        const impls = [];
+        // jsonValue() can enqueue nested structs while we emit; drain until stable.
+        const done = new Set();
+        while (true) {
+            const next = [...this.jsonStructs].find(name => !done.has(name));
+            if (!next)
+                break;
+            done.add(next);
+            const struct = this.module.structs.get(next);
+            if (!struct)
+                continue;
+            const parts = struct.fields.map(f => `\\"${f.name}\\":{}`).join(",");
+            const args = struct.fields.map(f => this.jsonValue(`self.${snake(f.name)}`, f.type));
+            impls.push(`impl ${struct.name} {
+    fn argon_json(&self) -> String {
+        format!("{{${parts}}}"${args.length ? ", " + args.join(", ") : ""})
+    }
+}
+`);
+        }
+        return impls;
+    }
+    // ── Template → write! sequence ─────────────────────────────────────────────
+    //
+    // The declarative template is emitted as one `write!` per interpolation
+    // (interleaved with `push_str` of the static HTML), each on its own line and
+    // preceded by a `// argon: file.tsx:line:col` comment. A rustc error then
+    // lands on a meaningful line pointing back at the source expression, instead
+    // of somewhere inside a single 700-column format! string.
+    templateSegments(component) {
+        const NUL = String.fromCharCode(0);
+        // Classify each marker by its position in the template: an attribute value
+        // (HTML-attribute-escaped), a bound boolean attribute (present-or-absent),
+        // or text content (HTML-text-escaped unless it is markup).
+        const attrOf = new Map();
+        const boolAttr = new Set();
+        // 0.3 compat renders every marker verbatim: no attribute/text distinction,
+        // no boolean-attribute collapse, no escaping.
+        if (!this.opts.compat03) {
+            for (const b of component.template.attrBindings) {
+                for (const idx of b.exprIndices)
+                    attrOf.set(idx, b.attr);
+                if (isBooleanAttr(b.attr) && b.exprIndices.length === 1 && b.value.replace(MARKER_RE, "") === "") {
+                    boolAttr.add(b.exprIndices[0]);
+                }
+            }
+        }
+        let html = serialize(component.template.nodes);
+        // Collapse a bound boolean attribute to a single whole-chunk marker so it
+        // can render as the bare ` name` or nothing.
+        html = html.replace(new RegExp(`\\s([a-zA-Z][a-zA-Z0-9-]*)="${NUL}(\\d+)${NUL}"`, "g"), (m, _name, idx) => boolAttr.has(Number(idx)) ? `${NUL}${idx}${NUL}` : m);
+        const segments = [];
+        const re = new RegExp(`${NUL}(\\d+)${NUL}`, "g");
+        let last = 0;
+        let m;
+        while ((m = re.exec(html)) !== null) {
+            if (m.index > last)
+                segments.push({ lit: html.slice(last, m.index) });
+            const index = Number(m[1]);
+            const expr = component.template.exprs[index];
+            const span = component.template.exprSpans[index];
+            const loc = span ? `        // argon: ${this.loc(span.start)}\n` : "";
+            let write;
+            if (expr.kind === "toFixed") {
+                write = `write!(__out, "{:.${expr.digits}}", ${this.expr(expr.value)}).ok();`;
+            }
+            else if (this.opts.compat03) {
+                write = `write!(__out, "{}", ${this.expr(expr)}).ok();`;
+            }
+            else if (boolAttr.has(index)) {
+                write = `write!(__out, "{}", if ${this.truthy(expr)} { " ${attrOf.get(index)}" } else { "" }).ok();`;
+            }
+            else if (attrOf.has(index)) {
+                // A composed child's prop value already encodes and escapes itself.
+                write = `write!(__out, "{}", ${expr.kind === "propattr" ? this.expr(expr) : this.attrText(expr)}).ok();`;
+            }
+            else {
+                write = `write!(__out, "{}", ${this.renderText(expr)}).ok();`;
+            }
+            segments.push({ code: loc + "        " + write });
+            last = re.lastIndex;
+        }
+        if (last < html.length)
+            segments.push({ lit: html.slice(last) });
+        return segments;
+    }
+    // `file.tsx:line:col` for a source offset.
+    loc(pos) {
+        const lc = this.module.source.getLineAndCharacterOfPosition(pos);
+        return `${basename(this.module.source.fileName)}:${lc.line + 1}:${lc.character + 1}`;
+    }
+    // A boolean condition for a bound boolean attribute (`disabled={expr}`).
+    truthy(e) {
+        if (e.type.kind === "option")
+            return `${this.operand(e)}.unwrap_or(false)`;
+        return this.operand(e);
+    }
+    // Render a value into HTML text content: markup passes through raw, a scalar
+    // string is HTML-text-escaped, numbers/booleans stringify as-is.
+    renderText(e) {
+        if (markupValue(e, this.markupLocals))
+            return this.markup(e, false);
+        if (e.type.kind === "string") {
+            this.needsEscapeText = true;
+            if (e.kind === "str")
+                return `argon_escape_text(${JSON.stringify(e.value)})`;
+            if (e.kind === "ref" && e.space === "param")
+                return `argon_escape_text(${this.expr(e)})`;
+            return `argon_escape_text(&${this.operand(e)})`;
+        }
+        return this.expr(e);
+    }
+    // Render a value into a double-quoted attribute: strings and JSON payloads
+    // are attribute-escaped; numbers/booleans stringify as-is.
+    attrText(e) {
+        if (e.type.kind === "number" || e.type.kind === "boolean")
+            return this.expr(e);
+        this.needsEscape = true;
+        if (e.type.kind === "string") {
+            if (e.kind === "str")
+                return `argon_escape_attr(${JSON.stringify(e.value)})`;
+            if (e.kind === "ref" && e.space === "param")
+                return `argon_escape_attr(${this.expr(e)})`;
+            return `argon_escape_attr(&${this.operand(e)})`;
+        }
+        return `argon_escape_attr(&${this.jsonValue(this.operand(e), e.type)})`;
+    }
+    // Render markup (already-HTML) raw, escaping only interpolated scalar parts.
+    // `owned` forces a String result (needed inside conditional branches).
+    markup(e, owned) {
+        switch (e.kind) {
+            case "str": return owned ? `${JSON.stringify(e.value)}.to_string()` : JSON.stringify(e.value);
+            case "template": return this.markupTemplate(e);
+            case "construct": return this.construct(e);
+            case "raw": return owned ? this.owned(e.inner) : this.expr(e.inner);
+            case "cond": {
+                // Two static markup-literal branches stay borrowed &str; anything
+                // dynamic or escaped forces both to owned String so their types match.
+                // Each branch renders by its own kind: markup raw, a plain string escaped.
+                const bothStr = isMarkup(e.whenTrue) && isMarkup(e.whenFalse) && e.whenTrue.kind === "str" && e.whenFalse.kind === "str";
+                const branch = (b) => {
+                    if (isMarkup(b))
+                        return this.markup(b, !bothStr);
+                    if (b.type.kind === "string") {
+                        this.needsEscapeText = true;
+                        return b.kind === "str" ? `argon_escape_text(${JSON.stringify(b.value)})` : `argon_escape_text(&${this.operand(b)})`;
+                    }
+                    return this.owned(b);
+                };
+                return `if ${this.expr(e.cond)} { ${branch(e.whenTrue)} } else { ${branch(e.whenFalse)} }`;
+            }
+            case "join":
+                if (e.array.kind === "map") {
+                    return `${this.iterChain(e.array, r => this.renderText(r))}.collect::<Vec<String>>().join(${JSON.stringify(e.sep)})`;
+                }
+                return this.join(e);
+            // A ref to a markup local: its value is already HTML.
+            default: return owned ? this.owned(e) : this.expr(e);
+        }
+    }
+    markupTemplate(e) {
+        const inAttr = attrPositions(e.quasis);
+        let fmt = escapeBraces(e.quasis[0]);
+        const args = [];
+        e.parts.forEach((part, i) => {
+            if (part.kind === "toFixed") {
+                fmt += `{:.${part.digits}}`;
+                args.push(this.expr(part.value));
+            }
+            else {
+                fmt += "{}";
+                // A composed child's prop value self-encodes; otherwise escape by
+                // position (attribute value vs text content).
+                args.push(part.kind === "propattr" ? this.expr(part) : inAttr[i] ? this.attrText(part) : this.renderText(part));
+            }
+            fmt += escapeBraces(e.quasis[i + 1]);
+        });
+        return `format!(${JSON.stringify(fmt)}${args.length ? ", " + args.join(", ") : ""})`;
+    }
+    // ── Statements ─────────────────────────────────────────────────────────────
+    stmt(stmt) {
+        if (stmt.kind === "let") {
+            if (stmt.tuple) {
+                return `let (${stmt.names.map(snake).join(", ")}) = ${this.expr(stmt.init)};`;
+            }
+            // Markup stored in a local escapes its interpolated parts, so reading it
+            // raw later cannot inject unescaped values.
+            const init = isMarkup(stmt.init) ? this.markup(stmt.init, true) : this.owned(stmt.init);
+            return `let ${snake(stmt.names[0])} = ${init};`;
+        }
+        // A tail return is the block's trailing expression (implicit).
+        if (stmt.kind === "return")
+            return this.owned(stmt.value);
+        if (stmt.kind === "if")
+            return this.ifStmt(stmt);
+        // Opaque statements are filtered out by analyze() before emission.
+        return "";
+    }
+    ifStmt(stmt) {
+        const body = (stmts) => stmts.map(s => this.blockStmt(s)).join(" ");
+        const els = stmt.else ? ` else { ${body(stmt.else)} }` : "";
+        return `if ${this.expr(stmt.cond)} { ${body(stmt.then)} }${els}`;
+    }
+    // Inside a control-flow block, a return is an early return and needs the
+    // explicit keyword (the tail return at function scope stays implicit).
+    blockStmt(stmt) {
+        if (stmt.kind === "return")
+            return `return ${this.owned(stmt.value)};`;
+        return this.stmt(stmt);
+    }
+    // ── Expressions ────────────────────────────────────────────────────────────
+    // Emit a value in display/borrow position: string literals stay &str.
+    expr(e) {
+        switch (e.kind) {
+            case "str": return JSON.stringify(e.value);
+            case "num": return e.text.includes(".") || e.text.includes("e") ? e.text : `${e.text}.0`;
+            case "bool": return String(e.value);
+            case "ref": return this.ref(e.name, e.space);
+            case "member": return `${this.operand(e.object)}.${snake(e.name)}`;
+            // JS string length counts UTF-16 units; we count Unicode scalars, which
+            // agrees for the BMP. Array/slice length is element count.
+            case "length":
+                return e.object.type.kind === "string"
+                    ? `(${this.operand(e.object)}.chars().count() as f64)`
+                    : `(${this.operand(e.object)}.len() as f64)`;
+            case "index": return this.index(e.object, e.index);
+            case "lookup": return `${snake(e.table)}(${this.borrowStr(e.key)})`;
+            case "exists":
+                // Definite values compared against undefined fold to a constant.
+                if (e.object.type.kind !== "option")
+                    return String(e.present);
+                return `${this.operand(e.object)}.${e.present ? "is_some" : "is_none"}()`;
+            case "unwrap":
+                // The enclosing presence test guarantees Some; borrow for display.
+                return isCopy(e.type)
+                    ? `${this.expr(e.object)}.unwrap()`
+                    : `${this.expr(e.object)}.as_ref().unwrap()`;
+            case "unary": return `${e.op}(${this.expr(e.operand)})`;
+            case "binary": return this.binary(e);
+            case "cond": return this.cond(e);
+            case "template": return this.template(e);
+            case "call": return this.callExpr(e);
+            case "map": return `${this.iterChain(e)}.collect::<Vec<${rustType(elemOf(e.type))}>>()`;
+            case "join": return this.join(e);
+            case "minmax": {
+                const bound = e.op === "min" ? "f64::INFINITY" : "f64::NEG_INFINITY";
+                return `${this.iterOver(e.array)}.fold(${bound}, f64::${e.op})`;
+            }
+            case "math": return this.mathExpr(e);
+            case "strmethod": return this.strMethod(e);
+            case "arrmethod": return this.arrMethod(e);
+            case "toFixed": return `format!("{:.${e.digits}}", ${this.expr(e.value)})`;
+            case "arr": return this.arrLiteral(e);
+            case "obj": {
+                const decl = e.struct ? this.module.structs.get(e.struct) : undefined;
+                const fields = e.fields.map(f => {
+                    const declared = decl?.fields.find(df => df.name === f.name)?.type;
+                    const value = this.owned(f.value);
+                    // Definite values land in optional fields wrapped in Some(...).
+                    const wrap = declared?.kind === "option" && f.value.type.kind !== "option";
+                    return `${snake(f.name)}: ${wrap ? `Some(${value})` : value}`;
+                });
+                // Omitted optional fields default to None.
+                const provided = new Set(e.fields.map(f => f.name));
+                const omitted = (decl?.fields ?? [])
+                    .filter(df => df.type.kind === "option" && !provided.has(df.name))
+                    .map(df => `${snake(df.name)}: None`);
+                return `${e.struct} { ${[...fields, ...omitted].join(", ")} }`;
+            }
+            case "propattr": return this.propAttr(e);
+            case "construct": return this.construct(e);
+            case "raw": return this.expr(e.inner);
+            case "opaque": return "/* unreachable: opaque */ unreachable!()";
+        }
+    }
+    // A composed child's prop value in attribute position: the same encoding
+    // the child's own wrapper uses, so the child hydrates identically.
+    propAttr(e) {
+        if (e.propType.kind === "number" || e.propType.kind === "boolean")
+            return this.expr(e.value);
+        this.needsEscape = true;
+        if (e.propType.kind === "string")
+            return `argon_escape_attr(&${this.operand(e.value)})`;
+        return `argon_escape_attr(&${this.jsonValue(this.operand(e.value), e.propType)})`;
+    }
+    // A composed child's shadow DOM: construct it with the parent's values and
+    // inline its declarative template. Cross-file children live in sibling
+    // modules named after their source file.
+    construct(e) {
+        const target = e.module ? `super::${e.module}::${e.className}` : e.className;
+        const args = e.props.map(p => {
+            if (!p.value)
+                return "None";
+            const value = this.owned(p.value);
+            return p.type.kind === "option" && p.value.type.kind !== "option" ? `Some(${value})` : value;
+        });
+        return `${target}::new(${args.join(", ")}).render_inner()`;
+    }
+    // Emit a value in owned position (let binding, struct field, collect item):
+    // ensures strings are String and non-Copy places are cloned.
+    owned(e) {
+        if (e.kind === "str")
+            return `${JSON.stringify(e.value)}.to_string()`;
+        if (e.kind === "cond" && e.type.kind === "string") {
+            return `if ${this.expr(e.cond)} { ${this.owned(e.whenTrue)} } else { ${this.owned(e.whenFalse)} }`;
+        }
+        if (e.kind === "binary" && e.op === "||" && e.type.kind === "string") {
+            return `{ let __v = ${this.owned(e.left)}; if __v.is_empty() { ${this.owned(e.right)} } else { __v } }`;
+        }
+        if (e.kind === "unwrap") {
+            return isCopy(e.type)
+                ? `${this.expr(e.object)}.unwrap()`
+                : `${this.expr(e.object)}.clone().unwrap()`;
+        }
+        if (isPlace(e) && !isCopy(e.type)) {
+            if (e.kind === "ref" && e.space === "param") {
+                // Borrowed params: &str/&[T] → owned.
+                return e.type.kind === "string" ? `${this.expr(e)}.to_string()` : `${this.expr(e)}.to_vec()`;
+            }
+            return `${this.expr(e)}.clone()`;
+        }
+        return this.expr(e);
+    }
+    // Emit a &str-typed argument (lookup keys, &str params).
+    borrowStr(e) {
+        if (e.kind === "str")
+            return JSON.stringify(e.value);
+        if (e.kind === "ref" && e.space === "param" && e.type.kind === "string")
+            return this.expr(e);
+        return `&${this.operand(e)}`;
+    }
+    // Wrap operands whose Rust spelling could bind differently in parens.
+    operand(e) {
+        const needsParens = e.kind === "binary" || e.kind === "cond" || e.kind === "unary";
+        return needsParens ? `(${this.expr(e)})` : this.expr(e);
+    }
+    ref(name, space) {
+        if (space === "prop")
+            return `self.${snake(name)}`;
+        if (space === "global")
+            return snake(name).toUpperCase();
+        if (this.usizeVars.has(name))
+            return `(${snake(name)} as f64)`;
+        return snake(name);
+    }
+    index(object, index) {
+        const idx = index.kind === "num" && !index.text.includes(".")
+            ? index.text
+            : `(${this.expr(index)}) as usize`;
+        return `${this.operand(object)}[${idx}]`;
+    }
+    binary(e) {
+        const { op, left, right } = e;
+        if (op === "??") {
+            // Lowering guarantees a definite right side.
+            if (left.type.kind !== "option")
+                return this.expr(left);
+            if (isCopy(left.type))
+                return `${this.operand(left)}.unwrap_or(${this.expr(right)})`;
+            return `${this.operand(left)}.clone().unwrap_or_else(|| ${this.owned(right)})`;
+        }
+        if (op === "+" && e.type.kind === "string") {
+            return `format!("{}{}", ${this.expr(left)}, ${this.expr(right)})`;
+        }
+        if (op === "||" && left.type.kind === "number") {
+            // JS `x || fallback` on numbers: fall back when zero.
+            return `{ let __v = ${this.expr(left)}; if __v == 0.0 { ${this.expr(right)} } else { __v } }`;
+        }
+        if (op === "||" && left.type.kind === "string") {
+            return `{ let __v = ${this.owned(left)}; if __v.is_empty() { ${this.owned(right)} } else { __v } }`;
+        }
+        return `${this.operand(left)} ${op} ${this.operand(right)}`;
+    }
+    cond(e) {
+        let whenTrue = this.expr(e.whenTrue);
+        let whenFalse = this.expr(e.whenFalse);
+        if (e.type.kind === "string" && !(e.whenTrue.kind === "str" && e.whenFalse.kind === "str")) {
+            // Branch types must match; mixed literal/String branches go owned.
+            whenTrue = this.owned(e.whenTrue);
+            whenFalse = this.owned(e.whenFalse);
+        }
+        return `if ${this.expr(e.cond)} { ${whenTrue} } else { ${whenFalse} }`;
+    }
+    template(e) {
+        let fmt = escapeBraces(e.quasis[0]);
+        const args = [];
+        e.parts.forEach((part, i) => {
+            if (part.kind === "toFixed") {
+                fmt += `{:.${part.digits}}`;
+                args.push(this.expr(part.value));
+            }
+            else {
+                fmt += "{}";
+                args.push(this.expr(part));
+            }
+            fmt += escapeBraces(e.quasis[i + 1]);
+        });
+        return `format!(${JSON.stringify(fmt)}${args.length ? ", " + args.join(", ") : ""})`;
+    }
+    callExpr(e) {
+        const sig = this.fns.get(e.fn);
+        const args = e.args.map((arg, i) => {
+            const param = sig?.params[i]?.type;
+            if (!param)
+                return this.expr(arg);
+            if (param.kind === "string")
+                return this.borrowStr(arg);
+            if (param.kind === "array" || param.kind === "fixed" || param.kind === "struct") {
+                if (arg.kind === "ref" && arg.space === "param")
+                    return this.expr(arg);
+                return `&${this.expr(arg)}`;
+            }
+            return this.expr(arg);
+        });
+        return `${snake(e.fn)}(${args.join(", ")})`;
+    }
+    // Emitted in `f64::fn(args)` associated-function form so a literal receiver
+    // (e.g. Math.max(0, x)) is never an ambiguous numeric type.
+    mathExpr(e) {
+        const a = e.args.map(x => this.expr(x));
+        switch (e.fn) {
+            case "min":
+            case "max":
+                return a.reduce((acc, x, i) => (i === 0 ? x : `f64::${e.fn}(${acc}, ${x})`));
+            case "floor":
+            case "ceil":
+            case "trunc":
+            case "abs":
+            case "sqrt":
+                return `f64::${e.fn}(${a[0]})`;
+            // JS Math.round is half-up (toward +∞), which floor(x + 0.5) reproduces
+            // exactly; f64::round would round half away from zero.
+            case "round":
+                return `f64::floor(${a[0]} + 0.5)`;
+            // JS Math.sign(0) is 0; f64::signum(0.0) is 1.0, so inline the comparison.
+            case "sign":
+                return `{ let __s: f64 = ${a[0]}; if __s > 0.0 { 1.0 } else if __s < 0.0 { -1.0 } else { 0.0 } }`;
+            case "pow":
+                return `f64::powf(${a[0]}, ${a[1]})`;
+            default:
+                return `0.0 /* unsupported math */`;
+        }
+    }
+    strMethod(e) {
+        const recv = this.operand(e.object);
+        const arg = (i) => this.strArg(e.args[i]);
+        const usize = (i) => `(${this.expr(e.args[i])} as usize)`;
+        switch (e.method) {
+            case "toUpperCase": return `${recv}.to_uppercase()`;
+            case "toLowerCase": return `${recv}.to_lowercase()`;
+            case "trim": return `${recv}.trim().to_string()`;
+            case "includes": return `${recv}.contains(${arg(0)})`;
+            case "startsWith": return `${recv}.starts_with(${arg(0)})`;
+            case "endsWith": return `${recv}.ends_with(${arg(0)})`;
+            case "repeat": return `${recv}.repeat(${usize(0)})`;
+            case "charAt": return `${recv}.chars().nth(${usize(0)}).map(|c| c.to_string()).unwrap_or_default()`;
+            case "replaceAll": return `${recv}.replace(${arg(0)}, ${arg(1)})`;
+            case "slice": {
+                this.needsStrSlice = true;
+                const end = e.args[1] ? `Some(${this.expr(e.args[1])})` : "None";
+                return `argon_str_slice(${this.borrowStr(e.object)}, ${this.expr(e.args[0])}, ${end})`;
+            }
+            case "padStart":
+            case "padEnd": {
+                this.needsPad = true;
+                const pad = e.args[1] ? this.strArg(e.args[1]) : `" "`;
+                return `argon_pad(${this.borrowStr(e.object)}, ${this.expr(e.args[0])}, ${pad}, ${e.method === "padStart"})`;
+            }
+            default: return `String::new()`;
+        }
+    }
+    arrMethod(e) {
+        const obj = this.operand(e.object);
+        const elem = elemOf(e.object.type);
+        // Predicate methods: the closure param is &T in every case; a Copy element
+        // is deref-bound so numeric/boolean predicates read a value.
+        if (e.param && e.body) {
+            const p = snake(e.param);
+            const body = isCopy(elem) ? `{ let ${p} = *${p}; ${this.expr(e.body)} }` : this.expr(e.body);
+            switch (e.method) {
+                case "filter": return `${obj}.clone().into_iter().filter(|${p}| ${body}).collect::<Vec<${rustType(elem)}>>()`;
+                case "find": return `${obj}.clone().into_iter().find(|${p}| ${body})`;
+                case "some": return `${obj}.iter().any(|${p}| ${body})`;
+                case "every": return `${obj}.iter().all(|${p}| ${body})`;
+            }
+        }
+        if (e.method === "includes")
+            return `${obj}.contains(&${this.owned(e.args[0])})`;
+        if (e.method === "indexOf") {
+            return `${obj}.iter().position(|__x| __x == &${this.owned(e.args[0])}).map(|__i| __i as f64).unwrap_or(-1.0)`;
+        }
+        // slice
+        this.needsSlice = true;
+        const end = e.args[1] ? `Some(${this.expr(e.args[1])})` : "None";
+        return `argon_slice(&${obj}, ${this.expr(e.args[0])}, ${end})`;
+    }
+    // A string method's &str argument (patterns for contains/replace).
+    strArg(e) {
+        if (e.kind === "str")
+            return JSON.stringify(e.value);
+        if (e.kind === "ref" && e.space === "param" && e.type.kind === "string")
+            return this.expr(e);
+        return `${this.operand(e)}.as_str()`;
+    }
+    join(e) {
+        if (e.array.kind === "map") {
+            return `${this.iterChain(e.array)}.collect::<Vec<String>>().join(${JSON.stringify(e.sep)})`;
+        }
+        // A string array joins directly; other element types stringify first
+        // (JS coerces, e.g. [1,2].join('-') === '1-2').
+        if (elemOf(e.array.type).kind === "string") {
+            return `${this.expr(e.array)}.join(${JSON.stringify(e.sep)})`;
+        }
+        return `${this.iterOver(e.array)}.map(|__v| __v.to_string()).collect::<Vec<String>>().join(${JSON.stringify(e.sep)})`;
+    }
+    iterOver(array) {
+        if (array.kind === "map")
+            return this.iterChain(array);
+        const elem = elemOf(array.type);
+        const adapt = isCopy(elem) || elem.kind === "unknown" ? ".copied()" : ".cloned()";
+        return `${this.expr(array)}.iter()${adapt}`;
+    }
+    iterChain(e, renderResult = r => this.owned(r)) {
+        const source = this.iterOver(e.array);
+        let params;
+        if (e.indexVar) {
+            const item = typeof e.item === "string" ? snake(e.item) : `(${e.item.map(snake).join(", ")})`;
+            params = `(${snake(e.indexVar)}, ${item})`;
+            this.usizeVars.add(e.indexVar);
+        }
+        else if (typeof e.item === "string") {
+            params = snake(e.item);
+        }
+        else {
+            params = `(${e.item.map(snake).join(", ")})`;
+        }
+        const stmts = e.body.stmts.map(s => this.stmt(s) + " ");
+        const result = renderResult(e.body.result);
+        const body = stmts.length > 0 ? `{ ${stmts.join("")}${result} }` : result;
+        if (e.indexVar)
+            this.usizeVars.delete(e.indexVar);
+        const enumerate = e.indexVar ? ".enumerate()" : "";
+        return `${source}${enumerate}.map(|${params}| ${body})`;
+    }
+    arrLiteral(e) {
+        if (e.type.kind === "array")
+            return `vec![${e.elems.map(el => this.owned(el)).join(", ")}]`;
+        if (e.type.kind === "fixed")
+            return `[${e.elems.map(el => this.owned(el)).join(", ")}]`;
+        return `(${e.elems.map(el => this.expr(el)).join(", ")})`;
+    }
+}
+function elemOf(type) {
+    if (type.kind === "array" || type.kind === "fixed")
+        return type.elem;
+    return { kind: "unknown" };
+}
+function escapeBraces(text) {
+    return text.replace(/\{/g, "{{").replace(/\}/g, "}}");
+}
+// Escape a static HTML segment for a Rust string literal (push_str). Only the
+// backslash and double-quote need escaping; newlines are kept verbatim (Rust
+// string literals may span lines), matching the previous format!-string form.
+function rustStrLit(text) {
+    return text.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function basename(file) {
+    const slash = Math.max(file.lastIndexOf("/"), file.lastIndexOf("\\"));
+    return slash === -1 ? file : file.slice(slash + 1);
+}
+//# sourceMappingURL=rust.js.map