@lovrozagar/honey 0.7.2 → 1.0.0-rc.1

package/dist/codegen-rust.js

@@ -1,1293 +0,0 @@
-/* Rust SDK emitter — generates a complete Rust crate from an OpenAPI 3.1 spec.
- *
- * Input is the SDK request model (codegen-sdk-model.ts). Every crate-level type name comes from one
- * NameScope seeded with the prelude and the runtime's own types; fields, params and methods are
- * claimed per scope; spec strings reach source only through rustString / rustDoc.
- */
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { serviceMapOf } from "./codegen.js";
-import { irErrorEnvelope, methodsOf, namespacesOf } from "./codegen-ir.js";
-import { NameScope, RUST_PRELUDE_TYPES, cmpCodeUnit, rustDoc, rustPlainSnake, rustString, rustTypeIdent, rustValueIdent, } from "./codegen-lang.js";
-import { buildSdkModel, isJsonMedia, valueCycleSchemas } from "./codegen-sdk-model.js";
-import { irRenderTopLevelRust, irRenderUseRust } from "./rust-type-emitter.js";
-let runtimeCache = null;
-export function loadRustRuntimeTemplates() {
-    if (runtimeCache)
-        return runtimeCache;
-    const names = [
-        "errors.rs",
-        "result.rs",
-        "runtime.rs",
-        "invalidation.rs",
-        "invalidation_sync.rs",
-        "sse.rs",
-        "ws.rs",
-        "realtime.rs",
-        "runtime_sync.rs",
-        "nullable.rs",
-    ];
-    const cache = new Map();
-    for (const name of names) {
-        const filePath = fileURLToPath(new URL(`./client-rust/${name}`, import.meta.url));
-        let content;
-        try {
-            content = readFileSync(filePath, "utf8");
-        }
-        catch {
-            throw new Error(`loadRustRuntimeTemplates: missing file ${filePath}`);
-        }
-        cache.set(name, content);
-    }
-    runtimeCache = cache;
-    return cache;
-}
-/** Validates and normalises a crate name. Throws if invalid per cargo rules. */
-export function validateCrateName(name) {
-    if (!/^[a-z][a-z0-9_-]*$/.test(name)) {
-        throw new Error(`Invalid crate name: ${JSON.stringify(name)}. Must match ^[a-z][a-z0-9_-]*$`);
-    }
-    return name;
-}
-/* Names the runtime modules and generated client declare or glob-import. */
-const RUST_RUNTIME_TYPES = [
-    "ApiError",
-    "AuthState",
-    "BadGatewayError",
-    "BadRequestError",
-    "Client",
-    "ClientConfig",
-    "ClientInner",
-    "ConflictError",
-    "ConnectionState",
-    "ErrField",
-    "Error",
-    "ForbiddenError",
-    "GatewayTimeoutError",
-    "InternalServerError",
-    "InvalidationConfig",
-    "LogEntry",
-    "LongpollConn",
-    "LongpollState",
-    "LongpollTransport",
-    "NotFoundError",
-    "OnAuthExpiredHook",
-    "OnLogHook",
-    "OnRequestHook",
-    "OnResponseHook",
-    "QueryValue",
-    "RateLimitError",
-    "RealtimeError",
-    "RequestBody",
-    "RequestContext",
-    "RequestMeta",
-    "RequestResult",
-    "ResponseContext",
-    "ResponseMeta",
-    "ResumableConnection",
-    "ResumableConnectionOpts",
-    "SdkResult",
-    "ServiceEntry",
-    "ServiceUnavailableError",
-    "SseConn",
-    "SseEvent",
-    "SseParser",
-    "SseState",
-    "SseTransport",
-    "StaleEntry",
-    "StaleTracker",
-    "StaleTrackerSync",
-    "StatusError",
-    "SyncAuthState",
-    "SyncClient",
-    "SyncClientConfig",
-    "SyncClientInner",
-    "SyncOnRequestHook",
-    "SyncOnResponseHook",
-    "SyncRequestBody",
-    "SyncRequestContext",
-    "SyncRequestResult",
-    "SyncResponseContext",
-    "Transport",
-    "TransportConn",
-    "TransportKind",
-    "TransportOpts",
-    "TypedWebSocket",
-    "UnauthorizedError",
-    "UnprocessableEntityError",
-    "WsConn",
-    "WsTransport",
-];
-function buildRustNames(model) {
-    const scope = new NameScope([...RUST_PRELUDE_TYPES, ...RUST_RUNTIME_TYPES]);
-    const schemaNames = new Map();
-    for (const name of model.schemaNames) {
-        const base = rustTypeIdent(name);
-        schemaNames.set(name, scope.has(base) ? scope.claim(`${base}Model`) : scope.claim(base));
-    }
-    const hoistKeys = new Map();
-    return {
-        decls: new Map(),
-        scope,
-        types: {
-            cyclic: valueCycleSchemas(model.ir.schemas),
-            hoist: (key, base) => {
-                const hit = hoistKeys.get(key);
-                if (hit)
-                    return hit;
-                const name = scope.claim(rustTypeIdent(base));
-                hoistKeys.set(key, name);
-                return name;
-            },
-            ref: (name) => schemaNames.get(name) ?? rustTypeIdent(name),
-            resolve: model.resolve,
-        },
-    };
-}
-const OPTS_RESERVED = [
-    "last_event_id",
-    "reconnect_token",
-    "protocols",
-    "idempotency_key",
-    "headers",
-    "timeout",
-    "cancel_token",
-    "sync_cancel_token",
-    "max_reconnect_attempts",
-    "reconnect_delay_ms",
-];
-/** Locals every emitted method body uses. */
-const METHOD_LOCALS = [
-    "self",
-    "opts",
-    "query",
-    "url_path",
-    "result",
-    "out",
-    "req",
-    "resp",
-    "stream",
-    "cfg",
-    "client",
-    "auth",
-    "body_value",
-    "call_headers",
-    "path_params",
-    "concrete_path",
-    "selector",
-    "request_meta",
-    "stale",
-    "targets",
-    "headers",
-];
-/** Per-status error envelopes (standard shapes only), read from the IR with refs resolved. */
-function errorEnvelopes(op, opPascal, model, names) {
-    const out = [];
-    for (const [status, response] of Object.entries(op.ir.responses).sort(([a], [b]) => cmpCodeUnit(a, b))) {
-        const code = Number.parseInt(status, 10);
-        if (!/^[0-9]{3}$/.test(status) || code < 400)
-            continue;
-        if (!response.schema || !response.contentType || !isJsonMedia(response.contentType))
-            continue;
-        const envelope = irErrorEnvelope(response.schema, model.resolve);
-        if (!envelope)
-            continue;
-        out.push({
-            keyEnumName: names.scope.claim(`${opPascal}Err${code}Key`),
-            keys: envelope.keys,
-            status: code,
-            structName: names.scope.claim(`${opPascal}Err${code}`),
-            variantName: `Status${code}`,
-        });
-    }
-    return out;
-}
-function emitErrorTypes(plan) {
-    if (plan.envelopes.length === 0 || !plan.errorEnum)
-        return [];
-    const l = [];
-    for (const env of plan.envelopes) {
-        const variants = new NameScope();
-        l.push(`#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq, Eq)]`);
-        l.push(`pub enum ${env.keyEnumName} {`);
-        for (const k of env.keys) {
-            const v = variants.claim(k === "" ? "Empty" : rustTypeIdent(k));
-            l.push(`\t#[serde(rename = ${rustString(k)})]`);
-            l.push(`\t${v},`);
-        }
-        l.push(`}`);
-        l.push(``);
-        l.push(`#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]`);
-        l.push(`pub struct ${env.structName} {`);
-        l.push(`\tpub error_key: ${env.keyEnumName},`);
-        l.push(`\tpub message: String,`);
-        l.push(`\tpub fields: std::collections::HashMap<String, Vec<crate::types::ErrField>>,`);
-        l.push(`}`);
-        l.push(``);
-    }
-    l.push(`#[derive(Debug)]`);
-    l.push(`pub enum ${plan.errorEnum} {`);
-    for (const env of plan.envelopes)
-        l.push(`\t${env.variantName}(${env.structName}),`);
-    l.push(`\tOther(Error),`);
-    l.push(`}`);
-    l.push(``);
-    return l;
-}
-function planOp(op, fnName, pathSegs, names, throwOnError, model) {
-    const opPascal = pathSegs.map(rustTypeIdent).join("");
-    const optsName = names.scope.claim(`${opPascal}Opts`);
-    const locals = new NameScope(METHOD_LOCALS);
-    const plan = {
-        action: op.segments.length === 1 ? "_call" : op.segments.slice(1).join("."),
-        envelopes: [],
-        fnName,
-        op,
-        optFields: [],
-        optsName,
-        pathParams: [],
-        resource: op.segments[0] ?? op.id,
-        resultType: "",
-    };
-    const hasBody = op.body !== undefined && op.stream !== "ws" && op.stream !== "realtime";
-    const bodyLocal = hasBody ? locals.claim("body") : "";
-    for (const p of op.pathParams)
-        plan.pathParams.push({ local: locals.claim(rustPlainSnake(p.name)), wire: p.name });
-    if (op.stream !== "realtime") {
-        const fieldScope = new NameScope(OPTS_RESERVED);
-        const params = [
-            ...op.query.map((p) => [p, "query"]),
-            ...op.headers.map((p) => [p, "header"]),
-        ];
-        for (const [p, where] of params) {
-            if (op.stream === "sse" && where === "query" && /^last[-_]?event[-_]?id$/i.test(p.name))
-                continue;
-            const ident = fieldScope.claim(rustPlainSnake(p.name));
-            const t = irRenderUseRust(p.schema, {
-                decls: names.decls,
-                fieldName: p.name,
-                names: names.types,
-                parentName: optsName,
-            });
-            plan.optFields.push({
-                ident,
-                required: p.required === true,
-                type: p.required === true || t.startsWith("Option<") ? t : `Option<${t}>`,
-                where,
-                wire: p.name,
-            });
-        }
-    }
-    if (hasBody && op.body) {
-        const b = op.body;
-        switch (b.kind) {
-            case "json": {
-                let t;
-                if (b.schema.kind === "ref")
-                    t = names.types.ref(b.schema.name);
-                else
-                    t = irRenderUseRust(b.schema, {
-                        decls: names.decls,
-                        fieldName: "Body",
-                        names: names.types,
-                        parentName: opPascal,
-                    });
-                plan.bodyParam = { asyncType: `&${t}`, local: bodyLocal, syncType: `&${t}` };
-                break;
-            }
-            case "form":
-                plan.bodyParam = {
-                    asyncType: "&std::collections::HashMap<String, String>",
-                    local: bodyLocal,
-                    syncType: "&std::collections::HashMap<String, String>",
-                };
-                break;
-            case "multipart":
-                /* multipart Form is consumed (not Clone), passed by value */
-                plan.bodyParam = {
-                    asyncType: "reqwest::multipart::Form",
-                    local: bodyLocal,
-                    syncType: "reqwest::blocking::multipart::Form",
-                };
-                break;
-            case "binary":
-                /* octet-stream body: generic over any byte stream / reader; single-shot, not retried on 401 */
-                plan.bodyParam = {
-                    asyncType: "S",
-                    generic: {
-                        async: `S`,
-                        asyncWhere: ` where S: futures::TryStream + Send + 'static, S::Error: Into<Box<dyn std::error::Error + Send + Sync>>, bytes::Bytes: From<S::Ok>`,
-                        sync: `R: std::io::Read + Send + 'static`,
-                    },
-                    local: bodyLocal,
-                    syncType: "R",
-                };
-                break;
-            case "text":
-                plan.bodyParam = { asyncType: "&str", local: bodyLocal, syncType: "&str" };
-                break;
-        }
-    }
-    if (op.stream === null) {
-        const s = op.success;
-        if (s.kind === "json") {
-            if (!s.schema)
-                plan.resultType = "serde_json::Value";
-            else if (s.schema.kind === "ref")
-                plan.resultType = names.types.ref(s.schema.name);
-            else {
-                const t = irRenderUseRust(s.schema, {
-                    decls: names.decls,
-                    fieldName: "Response",
-                    names: names.types,
-                    parentName: opPascal,
-                });
-                plan.resultType = t.startsWith("Box<") ? t.slice(4, -1) : t;
-            }
-        }
-        else if (s.kind === "text")
-            plan.resultType = "String";
-        else if (s.kind === "binary")
-            plan.resultType = "Vec<u8>";
-        /* the typed error enums exist in both modes; only safe-mode methods return them */
-        plan.envelopes = errorEnvelopes(op, opPascal, model, names);
-        if (plan.envelopes.length > 0)
-            plan.errorEnum = names.scope.claim(`${opPascal}Error`);
-    }
-    void model;
-    return plan;
-}
-function emitOptsStruct(plan) {
-    const l = [];
-    const { op, optsName } = plan;
-    const fields = [];
-    if (op.stream === "realtime") {
-        fields.push(`\tpub reconnect_token: Option<String>,`);
-        fields.push(`\tpub last_event_id: Option<String>,`);
-        fields.push(`\tpub protocols: Option<Vec<String>>,`);
-        fields.push(`\tpub max_reconnect_attempts: Option<u32>,`);
-        fields.push(`\tpub reconnect_delay_ms: Option<u64>,`);
-        fields.push(`\t#[serde(skip)]`);
-        fields.push(`\tpub headers: Option<std::collections::HashMap<String, String>>,`);
-    }
-    else {
-        for (const f of plan.optFields) {
-            const bare = f.ident.startsWith("r#") ? f.ident.slice(2) : f.ident;
-            const attrs = [];
-            if (bare !== f.wire)
-                attrs.push(`rename = ${rustString(f.wire)}`);
-            if (!f.required)
-                attrs.push(`skip_serializing_if = "Option::is_none"`);
-            if (attrs.length > 0)
-                fields.push(`\t#[serde(${attrs.join(", ")})]`);
-            fields.push(`\tpub ${f.ident}: ${f.type},`);
-        }
-        if (op.stream === "sse")
-            fields.push(`\tpub last_event_id: Option<String>,`);
-        if (op.stream === "ws") {
-            fields.push(`\tpub reconnect_token: Option<String>,`);
-            fields.push(`\tpub protocols: Option<Vec<String>>,`);
-        }
-        if (op.idempotent && op.stream === null) {
-            fields.push(`\t#[serde(skip_serializing_if = "Option::is_none")]`);
-            fields.push(`\tpub idempotency_key: Option<String>,`);
-        }
-        /* per-call headers for all non-WS methods (SSE included) */
-        if (op.stream !== "ws") {
-            fields.push(`\t#[serde(skip)]`);
-            fields.push(`\tpub headers: Option<std::collections::HashMap<String, String>>,`);
-        }
-        if (op.stream === null) {
-            fields.push(`\t#[serde(skip)]`);
-            fields.push(`\tpub timeout: Option<std::time::Duration>,`);
-            /* async consumes `cancel_token`, sync consumes `sync_cancel_token`; both runtime-only */
-            fields.push(`\t#[serde(skip)]`);
-            fields.push(`\tpub cancel_token: Option<tokio_util::sync::CancellationToken>,`);
-            fields.push(`\t#[serde(skip)]`);
-            fields.push(`\tpub sync_cancel_token: Option<std::sync::Arc<std::sync::atomic::AtomicBool>>,`);
-        }
-    }
-    l.push(`#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]`);
-    l.push(`pub struct ${optsName} {`);
-    l.push(...fields);
-    l.push(`}`);
-    l.push(``);
-    return l;
-}
-function docLines(op) {
-    const l = [];
-    if (op.summary)
-        l.push(...rustDoc(op.summary));
-    if (op.description) {
-        if (op.summary)
-            l.push(`///`);
-        l.push(...rustDoc(op.description));
-    }
-    if (op.deprecated)
-        l.push(`#[deprecated(note = "the API marks this operation deprecated")]`);
-    return l;
-}
-function pathLines(plan) {
-    if (plan.pathParams.length === 0)
-        return [`\tlet url_path = ${rustString(plan.op.path)}.to_string();`];
-    const params = plan.pathParams.map((p) => `(${rustString(p.wire)}, ${p.local})`).join(", ");
-    return [`\tlet url_path = crate::runtime::expand_path(${rustString(plan.op.path)}, &[${params}])?;`];
-}
-function queryLines(plan, opts = "opts") {
-    const q = plan.optFields.filter((f) => f.where === "query");
-    const l = [`\tlet ${q.length > 0 ? "mut " : ""}query: Vec<(String, String)> = Vec::new();`];
-    for (const f of q)
-        l.push(`\tcrate::runtime::push_serialized(${rustString(f.wire)}, &${opts}.${f.ident}, &mut query);`);
-    return l;
-}
-/** Lines that build `call_headers` from opts.headers, header params, then `extra` entries. */
-function headerLines(plan, extra = []) {
-    const l = [
-        `\tlet mut call_headers: std::collections::HashMap<String, String> = opts.headers.clone().unwrap_or_default();`,
-    ];
-    for (const f of plan.optFields.filter((x) => x.where === "header")) {
-        l.push(`\t{`);
-        l.push(`\t\tlet mut values: Vec<(String, String)> = Vec::new();`);
-        l.push(`\t\tcrate::runtime::push_serialized(${rustString(f.wire)}, &opts.${f.ident}, &mut values);`);
-        l.push(`\t\tif !values.is_empty() {`);
-        l.push(`\t\t\tcrate::runtime::set_header(&mut call_headers, ${rustString(f.wire)}, values.into_iter().map(|(_, v)| v).collect::<Vec<_>>().join(","));`);
-        l.push(`\t\t}`);
-        l.push(`\t}`);
-    }
-    l.push(...extra);
-    return l;
-}
-function bodyExpr(plan, sync) {
-    const prefix = sync ? "crate::runtime_sync::SyncRequestBody" : "crate::runtime::RequestBody";
-    const b = plan.op.body;
-    const local = plan.bodyParam?.local;
-    if (!b || !local)
-        return { expr: `${prefix}::None`, lines: [] };
-    switch (b.kind) {
-        case "json":
-            return { expr: `${prefix}::Json(&body_value)`, lines: [`\tlet body_value = serde_json::to_value(${local})?;`] };
-        case "form":
-            return { expr: `${prefix}::FormUrl(crate::runtime::form_pairs(${local}))`, lines: [] };
-        case "multipart":
-            return { expr: `${prefix}::Multipart(${local})`, lines: [] };
-        case "binary":
-            return {
-                expr: sync
-                    ? `${prefix}::Stream(reqwest::blocking::Body::new(${local}))`
-                    : `${prefix}::Stream(reqwest::Body::wrap_stream(${local}))`,
-                lines: [],
-            };
-        case "text":
-            return {
-                expr: `${prefix}::Raw(${rustString(b.contentType)}, bytes::Bytes::from(${local}.to_string()))`,
-                lines: [],
-            };
-    }
-}
-function decodeLines(plan, throwOnError) {
-    switch (plan.op.success.kind) {
-        case "text":
-            return [`\tlet out: String = String::from_utf8_lossy(&result.body).into_owned();`];
-        case "binary":
-            /* the bytes move into the result; only a safe-mode call keeps a second copy in `response` */
-            return [`\tlet out: Vec<u8> = ${throwOnError ? "result.body" : "result.body.clone()"};`];
-        default:
-            /* an empty JSON body decodes as `null` (Option / Value types accept it) */
-            return [
-                `\tlet out: ${plan.resultType} = serde_json::from_slice(if result.body.is_empty() { b"null" } else { &result.body })?;`,
-            ];
-    }
-}
-function access(selfAccess) {
-    return selfAccess === "self"
-        ? { auth: "self.inner.auth", cfg: "self.inner.cfg", http: "self.inner.http_client", stale: "self.inner.stale" }
-        : { auth: "self.client.auth", cfg: "self.client.cfg", http: "self.client.http_client", stale: "self.client.stale" };
-}
-function returnType(plan, throwOnError) {
-    if (plan.resultType === "")
-        return "Result<(), Error>";
-    if (throwOnError)
-        return `Result<${plan.resultType}, Error>`;
-    if (plan.errorEnum)
-        return `Result<SdkResult<${plan.resultType}, ${plan.errorEnum}>, Error>`;
-    return `Result<SdkResult<${plan.resultType}>, Error>`;
-}
-/** Shared tail: run the request (already bound to `result`), invalidate, decode. */
-function resultLines(plan, throwOnError, sync, a, call) {
-    const l = [];
-    const aw = sync ? "" : ".await";
-    const method = plan.op.method;
-    /* invalidation pre-flight for every call: reads see and clear staleness too */
-    const pp = plan.pathParams.map((p) => `(${rustString(p.wire)}.to_string(), ${p.local}.to_string())`).join(", ");
-    l.push(`\tlet path_params: std::collections::HashMap<String, String> = ${plan.pathParams.length > 0 ? `std::collections::HashMap::from([${pp}])` : "std::collections::HashMap::new()"};`);
-    l.push(`\tlet selector = format!("{} {}", ${rustString(method)}, url_path);`);
-    l.push(`\tlet request_meta: Option<crate::invalidation::RequestMeta> = match ${a.stale} {`);
-    l.push(`\t\tSome(ref s) => s.build_request_meta(&selector, &url_path, ${rustString(method)})${aw},`);
-    l.push(`\t\tNone => None,`);
-    l.push(`\t};`);
-    const safe = !throwOnError && plan.resultType !== "";
-    if (safe) {
-        l.push(`\tlet result = match ${call.join("\n\t\t")} {`);
-        l.push(`\t\tOk(r) => r,`);
-        l.push(`\t\tErr(Error::Api(api)) => {`);
-        l.push(`\t\t\tlet status = api.status();`);
-        if (plan.errorEnum) {
-            l.push(`\t\t\tlet body = api.body().to_vec();`);
-            l.push(`\t\t\tlet error = match status {`);
-            for (const env of plan.envelopes) {
-                l.push(`\t\t\t\t${env.status} => match serde_json::from_slice::<${env.structName}>(&body) {`);
-                l.push(`\t\t\t\t\tOk(v) => ${plan.errorEnum}::${env.variantName}(v),`);
-                l.push(`\t\t\t\t\tErr(_) => ${plan.errorEnum}::Other(Error::Api(api)),`);
-                l.push(`\t\t\t\t},`);
-            }
-            l.push(`\t\t\t\t_ => ${plan.errorEnum}::Other(Error::Api(api)),`);
-            l.push(`\t\t\t};`);
-            l.push(`\t\t\tlet mut response = crate::runtime::ResponseMeta::empty(status);`);
-            l.push(`\t\t\tresponse.body = body;`);
-            l.push(`\t\t\treturn Ok(SdkResult { data: None, error: Some(error), status, response });`);
-        }
-        else {
-            l.push(`\t\t\tlet mut response = crate::runtime::ResponseMeta::empty(status);`);
-            l.push(`\t\t\tresponse.body = api.body().to_vec();`);
-            l.push(`\t\t\treturn Ok(SdkResult { data: None, error: Some(Error::Api(api)), status, response });`);
-        }
-        l.push(`\t\t}`);
-        l.push(`\t\tErr(e) => return Err(e),`);
-        l.push(`\t};`);
-    }
-    else {
-        l.push(`\tlet result = ${call.join("\n\t\t")}?;`);
-    }
-    /* invalidation post-flight: mark declared targets stale (templated ones expanded with this
-     * call's params), then clear this key if the call read through a stale window */
-    l.push(`\tif let Some(ref stale) = ${a.stale} {`);
-    if (plan.op.invalidates.length > 0) {
-        l.push(`\t\tlet targets: Vec<String> = vec![${plan.op.invalidates.map((t) => `${rustString(t)}.to_string()`).join(", ")}];`);
-        l.push(`\t\tstale.mark_stale(&targets, &path_params, &selector)${aw};`);
-    }
-    l.push(`\t\tif let Some(ref meta) = request_meta {`);
-    l.push(`\t\t\tif meta.is_stale {`);
-    l.push(`\t\t\t\tstale.clear_stale(&selector, &url_path, ${rustString(method)}, meta.seq_snapshot)${aw};`);
-    l.push(`\t\t\t}`);
-    l.push(`\t\t}`);
-    l.push(`\t}`);
-    if (plan.resultType === "") {
-        l.push(`\tlet _ = result;`);
-        l.push(`\tOk(())`);
-        return l;
-    }
-    l.push(...decodeLines(plan, throwOnError));
-    if (throwOnError) {
-        l.push(`\tOk(out)`);
-    }
-    else {
-        /* the response snapshot takes the body, headers and URL by move */
-        l.push(`\tOk(SdkResult { data: Some(out), error: None, status: result.status, response: crate::runtime::ResponseMeta { status: result.status, headers: result.headers, url: result.url, body: result.body } })`);
-    }
-    return l;
-}
-function signature(plan, sync) {
-    const params = [`&self`];
-    for (const p of plan.pathParams)
-        params.push(`${p.local}: &str`);
-    let generics = "";
-    let where = "";
-    if (plan.bodyParam) {
-        params.push(`${plan.bodyParam.local}: ${sync ? plan.bodyParam.syncType : plan.bodyParam.asyncType}`);
-        if (plan.bodyParam.generic) {
-            generics = `<${sync ? plan.bodyParam.generic.sync : plan.bodyParam.generic.async}>`;
-            if (!sync)
-                where = plan.bodyParam.generic.asyncWhere ?? "";
-        }
-    }
-    params.push(`opts: &${plan.optsName}`);
-    return { generics, params: params.join(", "), where };
-}
-function emitMethod(plan, selfAccess, throwOnError) {
-    const l = [];
-    const { op } = plan;
-    const a = access(selfAccess);
-    l.push(...docLines(op));
-    const sig = signature(plan, false);
-    if (op.stream === "realtime") {
-        l.push(`pub async fn ${plan.fnName}(${sig.params}) -> Result<crate::realtime::ResumableConnection<serde_json::Value, serde_json::Value>, crate::realtime::RealtimeError> {`);
-        l.push(`\tlet connect_err = |e: Error| crate::realtime::RealtimeError::Connect(e);`);
-        l.push(...pathLines(plan).map((x) => x.replace(/\?;$/, ".map_err(connect_err)?;")));
-        l.push(`\tlet url = crate::runtime::build_url(&${a.cfg}.base_url, &url_path, &[]).map_err(connect_err)?;`);
-        l.push(`\tlet headers = crate::runtime::auth_headers(&${a.cfg}, &${a.auth}, opts.headers.as_ref()).await;`);
-        l.push(`\tlet rt_opts = crate::realtime::ResumableConnectionOpts {`);
-        l.push(`\t\treconnect_token: opts.reconnect_token.clone(),`);
-        l.push(`\t\tprotocols: opts.protocols.clone(),`);
-        l.push(`\t\tmax_reconnect_attempts: opts.max_reconnect_attempts,`);
-        l.push(`\t\treconnect_delay_ms: opts.reconnect_delay_ms,`);
-        l.push(`\t\tlast_event_id: opts.last_event_id.clone(),`);
-        l.push(`\t\theaders,`);
-        l.push(`\t\thttp_client: Some(${a.http}.clone()),`);
-        l.push(`\t};`);
-        l.push(`\tcrate::realtime::ResumableConnection::<serde_json::Value, serde_json::Value>::connect_with_defaults(url.to_string(), rt_opts).await`);
-        l.push(`}`);
-        l.push(``);
-        return l;
-    }
-    if (op.stream === "sse") {
-        l.push(`pub fn ${plan.fnName}${sig.generics}(${sig.params}) -> impl Stream<Item = Result<SseEvent, Error>>${sig.where} {`);
-        /* clone everything the stream needs into owned locals: the stream outlives &self/&opts */
-        if (plan.pathParams.length === 0) {
-            l.push(`\tlet url_path: Result<String, Error> = Ok(${rustString(op.path)}.to_string());`);
-        }
-        else {
-            const params = plan.pathParams.map((p) => `(${rustString(p.wire)}, ${p.local})`).join(", ");
-            l.push(`\tlet url_path = crate::runtime::expand_path(${rustString(op.path)}, &[${params}]);`);
-        }
-        l.push(...queryLines(plan));
-        l.push(...headerLines(plan, [
-            `\tcrate::runtime::set_header(&mut call_headers, "Accept", "text/event-stream".to_string());`,
-            `\tif let Some(ref lei) = opts.last_event_id {`,
-            `\t\tcrate::runtime::set_header(&mut call_headers, "Last-Event-ID", lei.clone());`,
-            `\t}`,
-        ]));
-        const body = op.body && plan.bodyParam?.local ? op.body : undefined;
-        if (body?.kind === "json")
-            l.push(`\tlet body_value = serde_json::to_value(${plan.bodyParam?.local});`);
-        l.push(`\tlet cfg = ${a.cfg}.clone();`);
-        l.push(`\tlet client = ${a.http}.clone();`);
-        l.push(`\tlet auth = std::sync::Arc::clone(&${a.auth});`);
-        if (body?.kind === "form")
-            l.push(`\tlet form = crate::runtime::form_pairs(${plan.bodyParam?.local});`);
-        if (body?.kind === "text")
-            l.push(`\tlet text = bytes::Bytes::from(${plan.bodyParam?.local}.to_string());`);
-        if (body?.kind === "multipart" || body?.kind === "binary")
-            l.push(`\tlet raw_body = ${plan.bodyParam?.local};`);
-        l.push(`\tasync_stream::stream! {`);
-        l.push(`\t\tuse futures_util::StreamExt;`);
-        l.push(`\t\tlet url_path = match url_path {`);
-        l.push(`\t\t\tOk(p) => p,`);
-        l.push(`\t\t\tErr(e) => { yield Err(e); return; }`);
-        l.push(`\t\t};`);
-        let expr = "crate::runtime::RequestBody::None";
-        if (body?.kind === "json") {
-            l.push(`\t\tlet body_value = match body_value {`);
-            l.push(`\t\t\tOk(v) => v,`);
-            l.push(`\t\t\tErr(e) => { yield Err(Error::Json(e)); return; }`);
-            l.push(`\t\t};`);
-            expr = "crate::runtime::RequestBody::Json(&body_value)";
-        }
-        else if (body?.kind === "form")
-            expr = "crate::runtime::RequestBody::FormUrl(form)";
-        else if (body?.kind === "text")
-            expr = `crate::runtime::RequestBody::Raw(${rustString(body.contentType)}, text)`;
-        else if (body?.kind === "multipart")
-            expr = "crate::runtime::RequestBody::Multipart(raw_body)";
-        else if (body?.kind === "binary")
-            expr = "crate::runtime::RequestBody::Stream(reqwest::Body::wrap_stream(raw_body))";
-        l.push(`\t\tlet opened = crate::runtime::open_stream(&client, &cfg, &auth, reqwest::Method::${op.method}, &url_path, &query, ${expr}, Some(&call_headers)).await;`);
-        l.push(`\t\tmatch opened {`);
-        l.push(`\t\t\tErr(e) => { yield Err(e); }`);
-        l.push(`\t\t\tOk(r) => {`);
-        l.push(`\t\t\t\tlet mut s = std::pin::pin!(crate::sse::parse_sse_stream(r));`);
-        l.push(`\t\t\t\twhile let Some(item) = s.next().await { yield item; }`);
-        l.push(`\t\t\t}`);
-        l.push(`\t\t}`);
-        l.push(`\t}`);
-        l.push(`}`);
-        l.push(``);
-        return l;
-    }
-    if (op.stream === "ws") {
-        l.push(`pub async fn ${plan.fnName}(${sig.params}) -> Result<TypedWebSocket, Error> {`);
-        l.push(...pathLines(plan));
-        l.push(...queryLines(plan));
-        l.push(`\tif let Some(ref rt) = opts.reconnect_token {`);
-        l.push(`\t\tquery.push(("reconnect_token".to_string(), rt.clone()));`);
-        l.push(`\t}`);
-        l.push(`\tlet url = crate::runtime::build_url(&${a.cfg}.base_url, &url_path, &query)?;`);
-        l.push(`\tlet ws_url = crate::runtime::to_ws_url(url.as_str());`);
-        l.push(`\tuse tokio_tungstenite::tungstenite::client::IntoClientRequest;`);
-        l.push(`\tlet mut req = ws_url.as_str().into_client_request().map_err(|e| Error::Other(e.to_string()))?;`);
-        l.push(`\tfor (k, v) in crate::runtime::auth_headers(&${a.cfg}, &${a.auth}, None).await {`);
-        l.push(`\t\tif let (Ok(name), Ok(val)) = (`);
-        l.push(`\t\t\ttokio_tungstenite::tungstenite::http::HeaderName::from_bytes(k.as_bytes()),`);
-        l.push(`\t\t\tv.parse::<tokio_tungstenite::tungstenite::http::HeaderValue>(),`);
-        l.push(`\t\t) {`);
-        l.push(`\t\t\treq.headers_mut().insert(name, val);`);
-        l.push(`\t\t}`);
-        l.push(`\t}`);
-        l.push(`\tif let Some(ref protos) = opts.protocols {`);
-        l.push(`\t\tif !protos.is_empty() {`);
-        l.push(`\t\t\treq.headers_mut().insert(`);
-        l.push(`\t\t\t\t"Sec-WebSocket-Protocol",`);
-        l.push(`\t\t\t\tprotos.join(", ").parse().map_err(|e: tokio_tungstenite::tungstenite::http::header::InvalidHeaderValue| Error::Other(e.to_string()))?,`);
-        l.push(`\t\t\t);`);
-        l.push(`\t\t}`);
-        l.push(`\t}`);
-        l.push(`\tlet (stream, _) = tokio_tungstenite::connect_async(req).await.map_err(|e| Error::Other(e.to_string()))?;`);
-        l.push(`\tOk(TypedWebSocket::new(stream))`);
-        l.push(`}`);
-        l.push(``);
-        return l;
-    }
-    l.push(`pub async fn ${plan.fnName}${sig.generics}(${sig.params}) -> ${returnType(plan, throwOnError)}${sig.where} {`);
-    l.push(...pathLines(plan));
-    l.push(...queryLines(plan));
-    l.push(...headerLines(plan, idempotencyLines(plan)));
-    const body = bodyExpr(plan, false);
-    l.push(...body.lines);
-    const call = [
-        `crate::runtime::do_request(`,
-        `\t&${a.http},`,
-        `\t&${a.cfg},`,
-        `\t&${a.auth},`,
-        `\treqwest::Method::${op.method},`,
-        `\t&url_path,`,
-        `\t&query,`,
-        `\t${body.expr},`,
-        `\tSome(&call_headers),`,
-        `\topts.timeout,`,
-        `\topts.cancel_token.clone(),`,
-        `\t${rustString(`${op.method} ${op.path}`)},`,
-        `\trequest_meta.as_ref(),`,
-        `).await`,
-    ];
-    l.push(...resultLines(plan, throwOnError, false, a, call));
-    l.push(`}`);
-    l.push(``);
-    return l;
-}
-function idempotencyLines(plan) {
-    if (!plan.op.idempotent || plan.op.stream !== null)
-        return [];
-    /* explicit header (any casing) > opts.idempotency_key > fresh UUID */
-    return [
-        `\tif !call_headers.keys().any(|k| k.eq_ignore_ascii_case("Idempotency-Key")) {`,
-        `\t\tlet key = opts.idempotency_key.clone().unwrap_or_else(|| uuid::Uuid::new_v4().to_string());`,
-        `\t\tcall_headers.insert("Idempotency-Key".to_string(), key);`,
-        `\t}`,
-    ];
-}
-/** emitSyncMethod is the blocking twin of emitMethod — no async, calls do_request_blocking. */
-function emitSyncMethod(plan, selfAccess, throwOnError) {
-    if (!isSyncCapable(plan.op))
-        return [];
-    const l = [];
-    const { op } = plan;
-    const a = access(selfAccess);
-    l.push(...docLines(op));
-    const sig = signature(plan, true);
-    l.push(`pub fn ${plan.fnName}${sig.generics}(${sig.params}) -> ${returnType(plan, throwOnError)} {`);
-    l.push(...pathLines(plan));
-    l.push(...queryLines(plan));
-    l.push(...headerLines(plan, idempotencyLines(plan)));
-    const body = bodyExpr(plan, true);
-    l.push(...body.lines);
-    const call = [
-        `crate::runtime_sync::do_request_blocking(`,
-        `\t&${a.http},`,
-        `\t&${a.cfg},`,
-        `\t&${a.auth},`,
-        `\treqwest::Method::${op.method},`,
-        `\t&url_path,`,
-        `\t&query,`,
-        `\t${body.expr},`,
-        `\tSome(&call_headers),`,
-        `\topts.timeout,`,
-        `\topts.sync_cancel_token.clone(),`,
-        `\t${rustString(`${op.method} ${op.path}`)},`,
-        `\trequest_meta.as_ref(),`,
-        `)`,
-    ];
-    l.push(...resultLines(plan, throwOnError, true, a, call));
-    l.push(`}`);
-    l.push(``);
-    return l;
-}
-function isSyncCapable(op) {
-    return op.stream === null;
-}
-function hasSync(node) {
-    return node.plans.some((p) => isSyncCapable(p.op)) || node.children.some((c) => hasSync(c.node));
-}
-function buildTree(model, names, throwOnError) {
-    const plans = [];
-    function visit(ns, path, modName, reserved) {
-        const isRoot = path.length === 0;
-        const pascal = path.map(rustTypeIdent).join("");
-        const node = {
-            children: [],
-            modName,
-            ns,
-            path,
-            plans: [],
-            structName: isRoot ? "Client" : names.scope.claim(`${pascal}Resource`),
-            syncStructName: isRoot ? "SyncClient" : names.scope.claim(`${pascal}ResourceSync`),
-        };
-        const members = new NameScope(reserved);
-        const modules = new NameScope();
-        const childInfo = [];
-        for (const [seg, childNs] of namespacesOf(ns)) {
-            childInfo.push({
-                accessor: members.claim(rustPlainSnake(seg)),
-                mod: modules.claim(rustPlainSnake(seg)),
-                ns: childNs,
-                seg,
-            });
-        }
-        for (const [seg, irOp] of methodsOf(ns)) {
-            const op = model.opsById.get(irOp.id);
-            if (!op)
-                continue;
-            const ident = rustValueIdent(seg);
-            const plain = ident.startsWith("r#") ? ident.slice(2) : ident;
-            const claimed = members.claim(plain);
-            const plan = planOp(op, claimed === plain ? ident : claimed, [...path, seg], names, throwOnError, model);
-            node.plans.push(plan);
-            plans.push(plan);
-        }
-        for (const c of childInfo) {
-            node.children.push({ accessor: c.accessor, node: visit(c.ns, [...path, c.seg], c.mod, ["client", "new"]) });
-        }
-        return node;
-    }
-    const root = visit(model.ir.tree, [], "", ["inner", "new", "is_stale"]);
-    return { plans, root };
-}
-/* ── files ── */
-function buildRustTypes(model, names) {
-    const body = [];
-    /* always emit shared error-envelope field type used by per-op error structs */
-    body.push(`#[derive(Debug, Clone, Serialize, Deserialize)]`);
-    body.push(`pub struct ErrField {`);
-    body.push(`\tpub error_key: String,`);
-    body.push(`\tpub message: String,`);
-    body.push(`\tpub path: String,`);
-    body.push(`}`);
-    body.push(``);
-    for (const name of model.schemaNames) {
-        if (Object.hasOwn(model.ir.schemaDescriptions, name))
-            body.push(...rustDoc(model.ir.schemaDescriptions[name]));
-        body.push(irRenderTopLevelRust(names.types.ref(name), model.ir.schemas[name], names.decls, undefined, names.types));
-        body.push(``);
-    }
-    return body.join("\n");
-}
-function typesFile(schemaSource, names) {
-    const l = [];
-    l.push(`/* Code generated by honey. DO NOT EDIT. */`);
-    l.push(``);
-    l.push(`#![allow(unused_imports, clippy::large_enum_variant)]`);
-    l.push(`use serde::{Serialize, Deserialize};`);
-    l.push(`use serde_repr::{Serialize_repr, Deserialize_repr};`);
-    l.push(`use std::collections::HashMap;`);
-    l.push(``);
-    l.push(schemaSource);
-    for (const name of [...names.decls.keys()].sort(cmpCodeUnit)) {
-        const decl = names.decls.get(name);
-        if (!decl)
-            continue;
-        l.push(decl);
-        l.push(``);
-    }
-    return l.join("\n");
-}
-function buildCargoToml(crateName, meta) {
-    /* TOML basic strings share JSON's escapes */
-    const pkgLines = [
-        `[package]`,
-        `name = "${crateName}"`,
-        `version = ${JSON.stringify(meta.version)}`,
-        `edition = "2021"`,
-        `rust-version = "1.75"`,
-    ];
-    if (meta.description)
-        pkgLines.push(`description = ${JSON.stringify(meta.description)}`);
-    if (meta.homepage)
-        pkgLines.push(`homepage = ${JSON.stringify(meta.homepage)}`);
-    if (meta.repository)
-        pkgLines.push(`repository = ${JSON.stringify(meta.repository)}`);
-    if (meta.license)
-        pkgLines.push(`license = ${JSON.stringify(meta.license)}`);
-    return [
-        ...pkgLines,
-        ``,
-        `[dependencies]`,
-        `tokio = { version = "^1.40", features = ["rt-multi-thread", "macros", "sync", "time"] }`,
-        `tokio-util = { version = "^0.7", features = ["rt"] }`,
-        `reqwest = { version = "^0.12", default-features = false, features = ["json", "stream", "rustls-tls", "multipart", "blocking"] }`,
-        `tokio-tungstenite = { version = "^0.24", features = ["rustls-tls-webpki-roots"] }`,
-        `futures = "^0.3"`,
-        `futures-util = "^0.3"`,
-        `serde = { version = "^1.0", features = ["derive"] }`,
-        `serde_json = "^1.0"`,
-        `serde_repr = "^0.1"`,
-        `url = "^2.5"`,
-        `urlencoding = "^2.1"`,
-        `regex = "^1.10"`,
-        `once_cell = "^1.20"`,
-        `bytes = "^1.7"`,
-        `uuid = { version = "^1", features = ["v4"] }`,
-        `async-trait = "^0.1"`,
-        `async-stream = "^0.3"`,
-        ``,
-    ].join("\n");
-}
-function buildLibRs(hasRealtime) {
-    const lines = [
-        `/* Code generated by honey. DO NOT EDIT. */`,
-        ``,
-        `pub mod client;`,
-        `pub mod errors;`,
-        `pub mod invalidation;`,
-        `pub mod invalidation_sync;`,
-        `pub mod nullable;`,
-        `pub mod resources;`,
-        `pub mod result;`,
-        `pub mod runtime;`,
-        `pub mod runtime_sync;`,
-        `pub mod sse;`,
-        `pub mod types;`,
-        `pub mod ws;`,
-    ];
-    if (hasRealtime)
-        lines.push(`pub mod realtime;`);
-    lines.push(``);
-    lines.push(`pub use client::Client;`);
-    lines.push(`pub use client::SyncClient;`);
-    lines.push(`pub use errors::Error;`);
-    lines.push(`pub use runtime::ClientConfig;`);
-    lines.push(`pub use runtime_sync::SyncClientConfig;`);
-    lines.push(`pub use result::SdkResult;`);
-    lines.push(``);
-    return lines.join("\n");
-}
-function fileHeader(sync) {
-    const lines = [];
-    lines.push(`/* Code generated by honey. DO NOT EDIT. */`);
-    lines.push(``);
-    lines.push(`#![allow(unused_imports, unused_variables, unused_mut, dead_code, deprecated)]`);
-    lines.push(`use std::sync::Arc;`);
-    lines.push(`use futures_util::{self, Stream};`);
-    lines.push(`use reqwest;`);
-    lines.push(`use serde::{Serialize, Deserialize};`);
-    lines.push(`use tokio_tungstenite;`);
-    lines.push(`use crate::client::ClientInner;`);
-    if (sync)
-        lines.push(`use crate::client::SyncClientInner;`);
-    lines.push(`use crate::errors::Error;`);
-    lines.push(`use crate::result::SdkResult;`);
-    lines.push(`use crate::types::*;`);
-    lines.push(`use crate::sse::SseEvent;`);
-    lines.push(`use crate::ws::TypedWebSocket;`);
-    lines.push(``);
-    return lines;
-}
-function staleInit(tracker) {
-    return [
-        `\t\tlet stale = match cfg.invalidation.clone() {`,
-        `\t\t\tSome(mut inv) if inv.stale_time > 0 => {`,
-        `\t\t\t\tif inv.stale_max_entries == 0 {`,
-        `\t\t\t\t\tinv.stale_max_entries = cfg.stale_max_entries;`,
-        `\t\t\t\t}`,
-        `\t\t\t\tSome(${tracker}::new(Some(&inv)))`,
-        `\t\t\t}`,
-        `\t\t\t_ => None,`,
-        `\t\t};`,
-    ];
-}
-function buildRustClient(root, plans, throwOnError, auth, serviceMap, realtimeIds) {
-    const body = [];
-    body.push(`pub(crate) struct ServiceEntry {`);
-    body.push(`\tpub method: &'static str,`);
-    body.push(`\tpub path: &'static str,`);
-    body.push(`\tpub params: &'static [&'static str],`);
-    body.push(`\tpub sse: bool,`);
-    body.push(`\tpub ws: bool,`);
-    body.push(`\tpub realtime: bool,`);
-    body.push(`\tpub invalidate: &'static [&'static str],`);
-    body.push(`}`);
-    body.push(``);
-    body.push(`pub(crate) static INVALIDATION_MAP: once_cell::sync::Lazy<std::collections::HashMap<&'static str, std::collections::HashMap<&'static str, ServiceEntry>>> =`);
-    body.push(`\tonce_cell::sync::Lazy::new(|| {`);
-    body.push(`\t\tlet mut map = std::collections::HashMap::new();`);
-    for (const [resource, actions] of Object.entries(serviceMap).sort(([a], [b]) => cmpCodeUnit(a, b))) {
-        body.push(`\t\t{`);
-        body.push(`\t\t\tlet mut resource_map = std::collections::HashMap::new();`);
-        for (const [action, entry] of Object.entries(actions).sort(([a], [b]) => cmpCodeUnit(a, b))) {
-            const inv = entry.invalidate ?? [];
-            const params = entry.params ?? [];
-            const opId = action === "_call" ? resource : `${resource}.${action}`;
-            body.push(`\t\t\tresource_map.insert(${rustString(action)}, ServiceEntry { method: ${rustString(String(entry.method))}, path: ${rustString(String(entry.path))}, params: &[${params.map(rustString).join(", ")}], sse: ${entry.sse === true}, ws: ${entry.ws === true}, realtime: ${realtimeIds.has(opId)}, invalidate: &[${inv.map(rustString).join(", ")}] });`);
-        }
-        body.push(`\t\t\tmap.insert(${rustString(resource)}, resource_map);`);
-        body.push(`\t\t}`);
-    }
-    body.push(`\t\tmap`);
-    body.push(`\t});`);
-    body.push(``);
-    body.push(`pub(crate) struct ClientInner {`);
-    body.push(`\tpub(crate) cfg: crate::runtime::ClientConfig,`);
-    body.push(`\tpub(crate) stale: Option<crate::invalidation::StaleTracker>,`);
-    body.push(`\tpub(crate) http_client: reqwest::Client,`);
-    body.push(`\tpub(crate) auth: std::sync::Arc<crate::runtime::AuthState>,`);
-    body.push(`}`);
-    body.push(``);
-    body.push(`/// Client is the generated SDK client.`);
-    body.push(`pub struct Client {`);
-    body.push(`\tpub(crate) inner: std::sync::Arc<ClientInner>,`);
-    for (const c of root.children)
-        body.push(`\t${c.accessor}: ${c.node.structName},`);
-    body.push(`}`);
-    body.push(``);
-    body.push(`impl Client {`);
-    body.push(`\t/// new creates a new SDK client. base_url must be non-empty.`);
-    body.push(`\tpub fn new(mut cfg: crate::runtime::ClientConfig) -> Self {`);
-    body.push(`\t\tif cfg.base_url.is_empty() {`);
-    body.push(`\t\t\tpanic!("honey sdk: ClientConfig.base_url must not be empty");`);
-    body.push(`\t\t}`);
-    body.push(`\t\t/* http_client: None → a default client that never redirects to another origin */`);
-    body.push(`\t\tlet http_client = match cfg.http_client.take() {`);
-    body.push(`\t\t\tSome(c) => c,`);
-    body.push(`\t\t\tNone => crate::runtime::default_http_client(),`);
-    body.push(`\t\t};`);
-    body.push(`\t\tif cfg.auth_header_name.is_none() {`);
-    body.push(`\t\t\tcfg.auth_header_name = Some(${rustString(auth.headerName)}.to_string());`);
-    body.push(`\t\t}`);
-    body.push(`\t\tif cfg.auth_header_prefix.is_none() {`);
-    body.push(`\t\t\tcfg.auth_header_prefix = Some(${rustString(auth.prefix)}.to_string());`);
-    body.push(`\t\t}`);
-    body.push(...staleInit("crate::invalidation::StaleTracker"));
-    body.push(`\t\tlet auth = std::sync::Arc::new(crate::runtime::AuthState::new(cfg.bearer_token.clone()));`);
-    body.push(`\t\tlet inner = std::sync::Arc::new(ClientInner { cfg, stale, http_client, auth });`);
-    body.push(`\t\tClient {`);
-    for (const c of root.children) {
-        body.push(`\t\t\t${c.accessor}: crate::resources::${c.node.modName}::new_resource(&inner),`);
-    }
-    body.push(`\t\t\tinner,`);
-    body.push(`\t\t}`);
-    body.push(`\t}`);
-    body.push(``);
-    for (const c of root.children) {
-        body.push(`\t/// ${c.accessor} returns a reference to the ${c.node.structName}.`);
-        body.push(`\tpub fn ${c.accessor}(&self) -> &${c.node.structName} {`);
-        body.push(`\t\t&self.${c.accessor}`);
-        body.push(`\t}`);
-        body.push(``);
-    }
-    for (const plan of root.plans)
-        body.push(...emitMethod(plan, "self", throwOnError).map((x) => `\t${x}`));
-    body.push(`\t/// is_stale reports whether (method, path) is currently within an active stale window.`);
-    body.push(`\tpub async fn is_stale(&self, method: &str, path: &str) -> bool {`);
-    body.push(`\t\tmatch self.inner.stale {`);
-    body.push(`\t\t\tSome(ref s) => s.is_stale(method, path).await,`);
-    body.push(`\t\t\tNone => false,`);
-    body.push(`\t\t}`);
-    body.push(`\t}`);
-    body.push(`}`);
-    body.push(``);
-    for (const plan of root.plans)
-        body.push(...emitOptsStruct(plan), ...emitErrorTypes(plan));
-    /* ── SyncClient ── */
-    const syncChildren = root.children.filter((c) => hasSync(c.node));
-    body.push(`pub(crate) struct SyncClientInner {`);
-    body.push(`\tpub(crate) cfg: crate::runtime_sync::SyncClientConfig,`);
-    body.push(`\tpub(crate) stale: Option<crate::invalidation_sync::StaleTrackerSync>,`);
-    body.push(`\tpub(crate) http_client: reqwest::blocking::Client,`);
-    body.push(`\tpub(crate) auth: std::sync::Arc<crate::runtime_sync::SyncAuthState>,`);
-    body.push(`}`);
-    body.push(``);
-    body.push(`/// SyncClient is the generated blocking SDK client.`);
-    body.push(`/// WARNING: Do not use from inside a tokio async task — reqwest blocking will deadlock.`);
-    body.push(`pub struct SyncClient {`);
-    body.push(`\tpub(crate) inner: std::sync::Arc<SyncClientInner>,`);
-    for (const c of syncChildren)
-        body.push(`\t${c.accessor}: ${c.node.syncStructName},`);
-    body.push(`}`);
-    body.push(``);
-    body.push(`impl SyncClient {`);
-    body.push(`\t/// new creates a new blocking SDK client. base_url must be non-empty.`);
-    body.push(`\tpub fn new(mut cfg: crate::runtime_sync::SyncClientConfig) -> Self {`);
-    body.push(`\t\tif cfg.base_url.is_empty() {`);
-    body.push(`\t\t\tpanic!("honey sdk: SyncClientConfig.base_url must not be empty");`);
-    body.push(`\t\t}`);
-    body.push(`\t\tlet http_client = match cfg.http_client.take() {`);
-    body.push(`\t\t\tSome(c) => c,`);
-    body.push(`\t\t\tNone => crate::runtime_sync::default_http_client_blocking(),`);
-    body.push(`\t\t};`);
-    body.push(`\t\tif cfg.auth_header_name.is_none() {`);
-    body.push(`\t\t\tcfg.auth_header_name = Some(${rustString(auth.headerName)}.to_string());`);
-    body.push(`\t\t}`);
-    body.push(`\t\tif cfg.auth_header_prefix.is_none() {`);
-    body.push(`\t\t\tcfg.auth_header_prefix = Some(${rustString(auth.prefix)}.to_string());`);
-    body.push(`\t\t}`);
-    body.push(...staleInit("crate::invalidation_sync::StaleTrackerSync"));
-    body.push(`\t\tlet auth = std::sync::Arc::new(crate::runtime_sync::SyncAuthState::new(cfg.bearer_token.clone()));`);
-    body.push(`\t\tlet inner = std::sync::Arc::new(SyncClientInner { cfg, stale, http_client, auth });`);
-    body.push(`\t\tSyncClient {`);
-    for (const c of syncChildren) {
-        body.push(`\t\t\t${c.accessor}: crate::resources::${c.node.modName}::new_resource_sync(&inner),`);
-    }
-    body.push(`\t\t\tinner,`);
-    body.push(`\t\t}`);
-    body.push(`\t}`);
-    body.push(``);
-    for (const c of syncChildren) {
-        body.push(`\t/// ${c.accessor} returns a reference to the ${c.node.syncStructName}.`);
-        body.push(`\tpub fn ${c.accessor}(&self) -> &${c.node.syncStructName} {`);
-        body.push(`\t\t&self.${c.accessor}`);
-        body.push(`\t}`);
-        body.push(``);
-    }
-    for (const plan of root.plans)
-        body.push(...emitSyncMethod(plan, "self", throwOnError).map((x) => `\t${x}`));
-    body.push(`\t/// is_stale reports whether (method, path) is currently within an active stale window.`);
-    body.push(`\tpub fn is_stale(&self, method: &str, path: &str) -> bool {`);
-    body.push(`\t\tmatch self.inner.stale {`);
-    body.push(`\t\t\tSome(ref s) => s.is_stale(method, path),`);
-    body.push(`\t\t\tNone => false,`);
-    body.push(`\t\t}`);
-    body.push(`\t}`);
-    body.push(`}`);
-    body.push(``);
-    void plans;
-    const out = [];
-    out.push(`/* Code generated by honey. DO NOT EDIT. */`);
-    out.push(``);
-    out.push(`#![allow(unused_imports, unused_variables, unused_mut, dead_code, deprecated)]`);
-    out.push(`use std::sync::Arc;`);
-    out.push(`use once_cell;`);
-    out.push(`use reqwest;`);
-    out.push(`use tokio_tungstenite;`);
-    out.push(`use futures_util::{self, Stream};`);
-    out.push(`use crate::errors::Error;`);
-    out.push(`use crate::resources::*;`);
-    out.push(`use crate::result::SdkResult;`);
-    out.push(`use crate::runtime::ClientConfig;`);
-    out.push(`use crate::sse::SseEvent;`);
-    out.push(`use crate::types::*;`);
-    out.push(`use crate::ws::TypedWebSocket;`);
-    out.push(``);
-    out.push(body.join("\n"));
-    return out.join("\n");
-}
-function buildRustResources(root, throwOnError) {
-    const files = new Map();
-    const modLines = [`/* Code generated by honey. DO NOT EDIT. */`, ``];
-    for (const c of root.children)
-        modLines.push(`pub mod ${c.node.modName};`);
-    for (const c of root.children) {
-        modLines.push(`pub use ${c.node.modName}::${c.node.structName};`);
-        if (hasSync(c.node))
-            modLines.push(`pub use ${c.node.modName}::${c.node.syncStructName};`);
-    }
-    modLines.push(``);
-    files.set("src/resources/mod.rs", modLines.join("\n"));
-    function emitNode(node, dir) {
-        const sync = hasSync(node);
-        const l = [...fileHeader(sync)];
-        for (const c of node.children)
-            l.push(`pub mod ${c.node.modName};`);
-        for (const c of node.children) {
-            l.push(`pub use ${c.node.modName}::${c.node.structName};`);
-            if (hasSync(c.node))
-                l.push(`pub use ${c.node.modName}::${c.node.syncStructName};`);
-        }
-        if (node.children.length > 0)
-            l.push(``);
-        l.push(`pub struct ${node.structName} {`);
-        l.push(`\tpub(crate) client: std::sync::Arc<crate::client::ClientInner>,`);
-        for (const c of node.children)
-            l.push(`\tpub ${c.accessor}: ${c.node.structName},`);
-        l.push(`}`);
-        l.push(``);
-        l.push(`impl ${node.structName} {`);
-        for (const c of node.children) {
-            l.push(`\tpub fn ${c.accessor}(&self) -> &${c.node.structName} {`);
-            l.push(`\t\t&self.${c.accessor}`);
-            l.push(`\t}`);
-            l.push(``);
-        }
-        for (const plan of node.plans)
-            l.push(...emitMethod(plan, "self.client", throwOnError).map((x) => `\t${x}`));
-        l.push(`}`);
-        l.push(``);
-        l.push(`pub(crate) fn new_resource(client: &std::sync::Arc<crate::client::ClientInner>) -> ${node.structName} {`);
-        l.push(`\t${node.structName} {`);
-        l.push(`\t\tclient: std::sync::Arc::clone(client),`);
-        for (const c of node.children)
-            l.push(`\t\t${c.accessor}: ${c.node.modName}::new_resource(client),`);
-        l.push(`\t}`);
-        l.push(`}`);
-        l.push(``);
-        if (sync) {
-            const syncKids = node.children.filter((c) => hasSync(c.node));
-            l.push(`pub struct ${node.syncStructName} {`);
-            l.push(`\tpub(crate) client: std::sync::Arc<crate::client::SyncClientInner>,`);
-            for (const c of syncKids)
-                l.push(`\tpub ${c.accessor}: ${c.node.syncStructName},`);
-            l.push(`}`);
-            l.push(``);
-            l.push(`impl ${node.syncStructName} {`);
-            for (const c of syncKids) {
-                l.push(`\tpub fn ${c.accessor}(&self) -> &${c.node.syncStructName} {`);
-                l.push(`\t\t&self.${c.accessor}`);
-                l.push(`\t}`);
-                l.push(``);
-            }
-            for (const plan of node.plans)
-                l.push(...emitSyncMethod(plan, "self.client", throwOnError).map((x) => `\t${x}`));
-            l.push(`}`);
-            l.push(``);
-            l.push(`pub(crate) fn new_resource_sync(client: &std::sync::Arc<crate::client::SyncClientInner>) -> ${node.syncStructName} {`);
-            l.push(`\t${node.syncStructName} {`);
-            l.push(`\t\tclient: std::sync::Arc::clone(client),`);
-            for (const c of syncKids)
-                l.push(`\t\t${c.accessor}: ${c.node.modName}::new_resource_sync(client),`);
-            l.push(`\t}`);
-            l.push(`}`);
-            l.push(``);
-        }
-        for (const plan of node.plans)
-            l.push(...emitOptsStruct(plan), ...emitErrorTypes(plan));
-        const here = [...dir, node.modName];
-        const filePath = node.children.length > 0 ? `src/resources/${here.join("/")}/mod.rs` : `src/resources/${here.join("/")}.rs`;
-        files.set(filePath, l.join("\n"));
-        for (const c of node.children)
-            emitNode(c.node, here);
-    }
-    for (const c of root.children)
-        emitNode(c.node, []);
-    return files;
-}
-export function generateRustSDK(spec, options = {}) {
-    const crateName = validateCrateName(options.crateName ?? "honey-sdk");
-    const throwOnError = options.throwOnError ?? true;
-    const input = spec;
-    const model = buildSdkModel(input);
-    const serviceMap = serviceMapOf(model.ir);
-    const names = buildRustNames(model);
-    const hasRealtime = model.ops.some((op) => op.stream === "realtime");
-    const realtimeIds = new Set(model.ops.filter((op) => op.stream === "realtime").map((op) => op.id));
-    const files = {};
-    for (const [name, content] of loadRustRuntimeTemplates()) {
-        if (name === "realtime.rs" && !hasRealtime)
-            continue;
-        files[`src/${name}`] = content;
-    }
-    /* schema types claim their names first; operations then hoist into the same table */
-    const schemaSource = buildRustTypes(model, names);
-    const { plans, root } = buildTree(model, names, throwOnError);
-    files["src/client.rs"] = buildRustClient(root, plans, throwOnError, model.ir.auth, serviceMap, realtimeIds);
-    for (const [relPath, content] of buildRustResources(root, throwOnError))
-        files[relPath] = content;
-    files["src/types.rs"] = typesFile(schemaSource, names);
-    files["src/lib.rs"] = buildLibRs(hasRealtime);
-    files["Cargo.toml"] = buildCargoToml(crateName, {
-        description: options.description,
-        homepage: options.homepage,
-        license: options.license,
-        repository: options.repository,
-        version: options.version ?? "0.1.0",
-    });
-    if (!files["src/resources/mod.rs"])
-        files["src/resources/mod.rs"] = `/* Code generated by honey. DO NOT EDIT. */\n`;
-    return { files, serviceMap };
-}
-//# sourceMappingURL=codegen-rust.js.map