@voltro/cli 0.27.0 → 0.29.0

package/dist/{manifestBuild-BnzAxp2O.js → manifestBuild-C4R1EdHn.js}

@@ -1,4 +1,4 @@
-import { O as e } from "./inspect-CUCCzw2I.js";
+import { j as e } from "./inspect-BMvQpwqy.js";
 import { JSONSchema as t } from "effect";
 //#region src/manifestBuild.ts
 var n = (e) => {

package/dist/manifestBuild-Ck_90gZy.js

@@ -0,0 +1,2 @@
+import { t as e } from "./manifestBuild-C4R1EdHn.js";
+export { e as buildRpcEntry };

package/dist/sdkgen-CW5NbYF0.js

@@ -0,0 +1,582 @@
+import { t as e } from "./cliRuntime-Oh517vCV.js";
+import { dirname as t, isAbsolute as n, join as r } from "node:path";
+import { Effect as i } from "effect";
+import { createLogger as a } from "@voltro/logger";
+import { promises as o } from "node:fs";
+//#region src/sdkgen/schemaIr.ts
+var s = () => ({
+	models: /* @__PURE__ */ new Map(),
+	enums: /* @__PURE__ */ new Map(),
+	inProgress: /* @__PURE__ */ new Set()
+}), c = (e) => e.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter((e) => e.length > 0), l = (e) => {
+	let t = c(e);
+	if (t.length === 0) return "Value";
+	let n = t.map((e) => e.charAt(0).toUpperCase() + e.slice(1)).join("");
+	return /^[0-9]/.test(n) ? `T${n}` : n;
+}, u = (e) => {
+	let t = l(e);
+	return t.charAt(0).toLowerCase() + t.slice(1);
+}, d = (e) => {
+	let t = c(e);
+	if (t.length === 0) return "VALUE";
+	let n = t.map((e) => e.toUpperCase()).join("_");
+	return /^[0-9]/.test(n) ? `V_${n}` : n;
+}, f = (e) => typeof e == "object" && !!e && e.type === "null", p = (e) => l(e.split("/").pop() ?? e), m = (e) => e.every((e) => typeof e == "string"), h = (e, t, n) => (e.enums.has(t) || e.enums.set(t, {
+	name: t,
+	values: n
+}), {
+	kind: "ref",
+	name: t
+}), g = (e, t, n, r) => {
+	let i = e.$ref;
+	if (typeof i == "string") {
+		let e = p(i);
+		if (r.models.has(e) || r.enums.has(e) || r.inProgress.has(e)) return {
+			kind: "ref",
+			name: e
+		};
+		let t = n[i.split("/").pop() ?? ""];
+		if (t === void 0) return { kind: "unknown" };
+		r.inProgress.add(e);
+		let a = g(t, e, n, r);
+		return r.inProgress.delete(e), a;
+	}
+	let a = e.type;
+	if (Array.isArray(a)) {
+		let i = a.filter((e) => e !== "null"), o = a.includes("null"), s = g({
+			...e,
+			...i.length === 1 ? { type: i[0] } : { type: void 0 }
+		}, t, n, r);
+		return o ? {
+			kind: "optional",
+			inner: s
+		} : s;
+	}
+	let o = e.anyOf ?? e.oneOf;
+	if (Array.isArray(o)) {
+		let e = o.filter(f), i = o.filter((e) => !f(e));
+		if (i.length === 1 && i[0] !== void 0) {
+			let a = g(i[0], t, n, r);
+			return e.length > 0 ? {
+				kind: "optional",
+				inner: a
+			} : a;
+		}
+		return { kind: "unknown" };
+	}
+	let s = e.enum;
+	if (Array.isArray(s) && s.length > 0 && m(s)) return h(r, t, [...s]);
+	switch (a) {
+		case "string": return { kind: "string" };
+		case "integer": return { kind: "integer" };
+		case "number": return { kind: "number" };
+		case "boolean": return { kind: "boolean" };
+		case "array": {
+			let i = e.items;
+			return {
+				kind: "array",
+				element: i !== void 0 && typeof i == "object" && !Array.isArray(i) ? g(i, `${t}Item`, n, r) : { kind: "unknown" }
+			};
+		}
+		case "object": {
+			let i = e.properties;
+			if (i === void 0 || Object.keys(i).length === 0) return { kind: "unknown" };
+			let a = new Set(Array.isArray(e.required) ? e.required : []);
+			r.inProgress.add(t);
+			let o = Object.entries(i).map(([e, i]) => {
+				let o = g(i, `${t}${l(e)}`, n, r);
+				return {
+					jsonName: e,
+					type: !a.has(e) && o.kind !== "optional" ? {
+						kind: "optional",
+						inner: o
+					} : o
+				};
+			});
+			return r.inProgress.delete(t), r.models.set(t, {
+				name: t,
+				fields: o
+			}), {
+				kind: "ref",
+				name: t
+			};
+		}
+		default: return { kind: "unknown" };
+	}
+}, _ = (e, t, n) => e === void 0 ? void 0 : g(e, t, e.$defs ?? e.definitions ?? {}, n), v = (e, t) => e.name.localeCompare(t.name), y = (e) => {
+	let t = s();
+	return {
+		procedures: [...e.procedures].sort((e, t) => e.tag.localeCompare(t.tag)).map((e) => {
+			let n = l(e.tag);
+			return {
+				tag: e.tag,
+				kind: e.kind,
+				methodName: u(e.tag),
+				input: _(e.input, `${n}Input`, t),
+				output: _(e.output, `${n}Output`, t)
+			};
+		}),
+		models: [...t.models.values()].sort(v),
+		enums: [...t.enums.values()].sort(v)
+	};
+}, b = /^[A-Za-z_][A-Za-z0-9_]*$/, x = /* @__PURE__ */ new Set(/* @__PURE__ */ "associatedtype.class.deinit.enum.extension.fileprivate.func.import.init.inout.internal.let.open.operator.private.protocol.public.rethrows.static.struct.subscript.typealias.var.break.case.continue.default.defer.do.else.fallthrough.for.guard.if.in.repeat.return.switch.where.while.as.catch.false.is.nil.super.self.Self.throw.throws.true.try.Type.Protocol".split(".")), S = /* @__PURE__ */ new Set(/* @__PURE__ */ "as.break.class.continue.do.else.false.for.fun.if.in.interface.is.null.object.package.return.super.this.throw.true.try.typealias.typeof.val.var.when.while".split(".")), C = (e, t) => {
+	if (b.test(e)) return t.has(e) ? {
+		ident: `\`${e}\``,
+		needsAlias: !1
+	} : {
+		ident: e,
+		needsAlias: !1
+	};
+	let n = u(e);
+	return {
+		ident: b.test(n) ? n : `field_${n.replace(/[^A-Za-z0-9_]/g, "")}`,
+		needsAlias: !0
+	};
+}, w = (e) => C(e, x), ee = (e) => C(e, S), T = "// Generated by `voltro build api --target kotlin`. Do not edit by hand.", E = (e) => {
+	switch (e.kind) {
+		case "string": return "String";
+		case "integer": return "Int";
+		case "number": return "Double";
+		case "boolean": return "Boolean";
+		case "unknown": return "JsonElement";
+		case "array": return `List<${E(e.element)}>`;
+		case "optional": return `${E(e.inner)}?`;
+		case "ref": return e.name;
+	}
+}, D = (e) => e.kind === "optional", O = (e) => {
+	if (e.fields.length === 0) return `@Serializable\npublic class ${e.name}`;
+	let t = ["@Serializable", `public data class ${e.name}(`];
+	for (let n of e.fields) {
+		let e = ee(n.jsonName), r = e.needsAlias ? `@SerialName(${JSON.stringify(n.jsonName)}) ` : "", i = D(n.type) ? " = null" : "";
+		t.push(`    ${r}val ${e.ident}: ${E(n.type)}${i},`);
+	}
+	return t.push(")"), t.join("\n");
+}, k = (e) => {
+	let t = ["@Serializable", `public enum class ${e.name} {`];
+	for (let n of e.values) t.push(`    @SerialName(${JSON.stringify(n)}) ${d(n)},`);
+	return t.push("}"), t.join("\n");
+}, A = (e) => e.output ? E(e.output) : "JsonElement", j = (e, t) => {
+	let n = t.filter((e) => e.kind !== "stream"), r = [
+		"/** One-shot RPC client (query / mutation / action) over HTTP. */",
+		`public class ${e}(`,
+		"    private val baseUrl: String,",
+		"    public var auth: AuthContext = AuthContext(),",
+		"    private val transport: RpcTransport = RpcTransport(),",
+		") {"
+	];
+	for (let e of n) {
+		let t = A(e);
+		e.input === void 0 ? r.push("", `    /** \`${e.tag}\` (${e.kind}) */`, `    public suspend fun ${e.methodName}(): ${t} =`, `        transport.call(baseUrl, auth, ${JSON.stringify(e.tag)}, EmptyPayload)`) : r.push("", `    /** \`${e.tag}\` (${e.kind}) */`, `    public suspend fun ${e.methodName}(input: ${E(e.input)}): ${t} =`, `        transport.call(baseUrl, auth, ${JSON.stringify(e.tag)}, input)`);
+	}
+	return r.push("}"), r.join("\n");
+}, M = (e, t) => {
+	let n = t.filter((e) => e.kind === "stream"), r = [
+		"/** Reactive subscription client over WebSocket — one Flow per server-push procedure. */",
+		`public class ${e}(`,
+		"    private val socketUrl: String,",
+		"    public var auth: AuthContext = AuthContext(),",
+		"    private val transport: SocketTransport = SocketTransport(),",
+		") {"
+	];
+	for (let e of n) {
+		let t = A(e);
+		e.input === void 0 ? r.push("", `    /** \`${e.tag}\` (stream) */`, `    public fun ${e.methodName}(): Flow<${t}> =`, `        transport.subscribe(socketUrl, auth, ${JSON.stringify(e.tag)}, EmptyPayload)`) : r.push("", `    /** \`${e.tag}\` (stream) */`, `    public fun ${e.methodName}(input: ${E(e.input)}): Flow<${t}> =`, `        transport.subscribe(socketUrl, auth, ${JSON.stringify(e.tag)}, input)`);
+	}
+	return r.push("}"), r.join("\n");
+}, N = (e) => `${T}
+package ${e}
+
+/**
+ * Authentication + tenant context carried on every request. The bearer token
+ * and tenant id are injected as request headers by the transport.
+ */
+public data class AuthContext(
+    public val token: String? = null,
+    public val tenant: String? = null,
+) {
+    /** The header pairs this context contributes. Empty when unauthenticated. */
+    public fun headers(): List<Pair<String, String>> = buildList {
+        token?.let { add("authorization" to "Bearer $it") }
+        tenant?.let { add("x-tenant" to it) }
+    }
+}
+`, P = (e) => `${T}
+package ${e}
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+/**
+ * Device registration for push notifications.
+ *
+ * STUB — this registers the device TOKEN with the app's registerDevice
+ * procedure (the storage side). The SENDER (APNs / FCM) is deliberately NOT part
+ * of the generated SDK: it needs per-tenant Apple / Firebase credentials managed
+ * by provider provisioning, which is server infrastructure, not client code.
+ */
+@Serializable
+public data class PushRegistration(
+    @SerialName("deviceToken") val deviceToken: String,
+    val platform: String = "android",
+    val locale: String? = null,
+    val timezone: String? = null,
+)
+`, F = (e) => `${T}
+package ${e}
+
+import io.ktor.client.HttpClient
+import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
+import io.ktor.client.plugins.websocket.WebSockets
+import io.ktor.client.plugins.websocket.webSocketSession
+import io.ktor.client.request.header
+import io.ktor.client.request.post
+import io.ktor.client.request.setBody
+import io.ktor.client.statement.HttpResponse
+import io.ktor.client.statement.bodyAsText
+import io.ktor.http.ContentType
+import io.ktor.http.contentType
+import io.ktor.serialization.kotlinx.json.json
+import io.ktor.websocket.Frame
+import io.ktor.websocket.readText
+import io.ktor.websocket.send
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.serializer
+
+/** Empty payload for no-argument procedures. */
+@Serializable
+public object EmptyPayload
+
+/**
+ * The RPC request envelope sent to the api. Mirrors the wire shape
+ * \`{ _tag: "Request", id, tag, payload, headers }\`.
+ */
+@Serializable
+internal data class RpcRequest<Payload>(
+    val _tag: String = "Request",
+    val id: String,
+    val tag: String,
+    val payload: Payload,
+    val headers: Map<String, String> = emptyMap(),
+)
+
+internal val sdkJson: Json = Json { ignoreUnknownKeys = true; encodeDefaults = true }
+
+/**
+ * HTTP transport for one-shot calls.
+ *
+ * NOTE — the exact @effect/rpc response FRAMING is the one seam to validate
+ * against a live server; this decodes the success value from the response body.
+ * Correct type mapping + one method per procedure is the generator's guarantee;
+ * the wire framing is the cross-language integration step.
+ */
+public class RpcTransport(private val client: HttpClient = defaultClient()) {
+    public suspend inline fun <reified Payload, reified Result> call(
+        baseUrl: String, auth: AuthContext, tag: String, payload: Payload,
+    ): Result {
+        val response: HttpResponse = client.post("$baseUrl/rpc") {
+            contentType(ContentType.Application.Json)
+            for ((k, v) in auth.headers()) header(k, v)
+            setBody(RpcRequest(id = randomId(), tag = tag, payload = payload))
+        }
+        return sdkJson.decodeFromString(serializer(), response.bodyAsText())
+    }
+
+    public companion object {
+        public fun defaultClient(): HttpClient = HttpClient {
+            install(ContentNegotiation) { json(sdkJson) }
+        }
+    }
+}
+
+/** WebSocket transport for reactive subscriptions. */
+public class SocketTransport(private val client: HttpClient = defaultClient()) {
+    public inline fun <reified Payload, reified Value> subscribe(
+        socketUrl: String, auth: AuthContext, tag: String, payload: Payload,
+    ): Flow<Value> = flow {
+        val session = client.webSocketSession(socketUrl)
+        val serializer: KSerializer<Value> = serializer()
+        session.send(sdkJson.encodeToString(RpcRequest(id = randomId(), tag = tag, payload = payload)))
+        for (frame in session.incoming) {
+            if (frame is Frame.Text) {
+                emit(sdkJson.decodeFromString(serializer, frame.readText()))
+            }
+        }
+    }
+
+    public companion object {
+        public fun defaultClient(): HttpClient = HttpClient {
+            install(WebSockets)
+            install(ContentNegotiation) { json(sdkJson) }
+        }
+    }
+}
+
+internal expect fun randomId(): String
+
+/** A raw JSON value, for schemas with no faithful static type. */
+public typealias AnyJson = JsonElement
+`, I = (e) => `// ${T.replace("// ", "")}
+plugins {
+    kotlin("multiplatform") version "2.0.20"
+    kotlin("plugin.serialization") version "2.0.20"
+}
+
+group = "com.voltro"
+version = "0.1.0"
+
+kotlin {
+    jvm()
+    iosArm64()
+    iosSimulatorArm64()
+
+    sourceSets {
+        val commonMain by getting {
+            dependencies {
+                implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.1")
+                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.1")
+                implementation("io.ktor:ktor-client-core:2.3.12")
+                implementation("io.ktor:ktor-client-content-negotiation:2.3.12")
+                implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.12")
+                implementation("io.ktor:ktor-client-websockets:2.3.12")
+            }
+        }
+    }
+}
+
+// Generated Kotlin Multiplatform module: ${e}
+`, L = (e, t, n) => {
+	let r = `src/commonMain/kotlin/${n.replace(/\./g, "/")}`, i = [...e.enums.map(k), ...e.models.map(O)].join("\n\n");
+	return [
+		{
+			path: "build.gradle.kts",
+			content: I(t)
+		},
+		{
+			path: `${r}/Models.kt`,
+			content: `${T}\npackage ${n}\n\nimport kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.JsonElement\n\n${i}${i ? "\n" : ""}`
+		},
+		{
+			path: `${r}/Client.kt`,
+			content: `${T}\npackage ${n}\n\nimport kotlinx.serialization.json.JsonElement\n\n${j(`${t}Client`, e.procedures)}\n`
+		},
+		{
+			path: `${r}/Subscriptions.kt`,
+			content: `${T}\npackage ${n}\n\nimport kotlinx.coroutines.flow.Flow\nimport kotlinx.serialization.json.JsonElement\n\n${M(`${t}Subscriptions`, e.procedures)}\n`
+		},
+		{
+			path: `${r}/Auth.kt`,
+			content: N(n)
+		},
+		{
+			path: `${r}/Push.kt`,
+			content: P(n)
+		},
+		{
+			path: `${r}/RpcTransport.kt`,
+			content: F(n)
+		}
+	];
+}, R = (e) => {
+	switch (e.kind) {
+		case "string": return "String";
+		case "integer": return "Int";
+		case "number": return "Double";
+		case "boolean": return "Bool";
+		case "unknown": return "AnyCodable";
+		case "array": return `[${R(e.element)}]`;
+		case "optional": return `${R(e.inner)}?`;
+		case "ref": return e.name;
+	}
+}, z = (e) => e.kind === "optional", B = (e) => {
+	let t = [`public struct ${e.name}: Codable, Equatable, Sendable {`], n = e.fields.map((e) => ({
+		field: e,
+		id: w(e.jsonName)
+	}));
+	for (let { field: e, id: r } of n) t.push(`    public var ${r.ident}: ${R(e.type)}`);
+	if (n.some(({ id: e }) => e.needsAlias)) {
+		t.push("", "    enum CodingKeys: String, CodingKey {");
+		for (let { field: e, id: r } of n) t.push(r.needsAlias ? `        case ${r.ident} = ${JSON.stringify(e.jsonName)}` : `        case ${r.ident}`);
+		t.push("    }");
+	}
+	let r = n.map(({ field: e, id: t }) => z(e.type) ? `${t.ident}: ${R(e.type)} = nil` : `${t.ident}: ${R(e.type)}`);
+	t.push("", `    public init(${r.join(", ")}) {`);
+	for (let { id: e } of n) t.push(`        self.${e.ident} = ${e.ident}`);
+	return t.push("    }", "}"), t.join("\n");
+}, te = (e) => {
+	let t = [`public enum ${e.name}: String, Codable, Sendable {`];
+	for (let n of e.values) {
+		let e = w(n).ident;
+		t.push(e === n ? `    case ${e}` : `    case ${e} = ${JSON.stringify(n)}`);
+	}
+	return t.push("}"), t.join("\n");
+}, V = (e) => {
+	let t = e.output ? R(e.output) : "AnyCodable";
+	return e.input === void 0 ? {
+		signature: "()",
+		payload: "EmptyPayload()",
+		returns: t
+	} : {
+		signature: `(_ input: ${R(e.input)})`,
+		payload: "input",
+		returns: t
+	};
+}, H = (e, t) => {
+	let n = t.filter((e) => e.kind !== "stream"), r = [
+		"/// One-shot RPC client (query / mutation / action) over HTTP.",
+		`public struct ${e}: Sendable {`,
+		"    public let baseURL: URL",
+		"    public var auth: AuthContext",
+		"    private let transport: RpcTransport",
+		"",
+		"    public init(baseURL: URL, auth: AuthContext = AuthContext(), session: URLSession = .shared) {",
+		"        self.baseURL = baseURL",
+		"        self.auth = auth",
+		"        self.transport = RpcTransport(session: session)",
+		"    }"
+	];
+	for (let e of n) {
+		let { signature: t, payload: n, returns: i } = V(e);
+		r.push("", `    /// \`${e.tag}\` (${e.kind})`, `    public func ${e.methodName}${t} async throws -> ${i} {`, `        try await transport.call(baseURL: baseURL, auth: auth, tag: ${JSON.stringify(e.tag)}, payload: ${n})`, "    }");
+	}
+	return r.push("}"), r.join("\n");
+}, U = (e, t) => {
+	let n = t.filter((e) => e.kind === "stream"), r = [
+		"/// Reactive subscription client over WebSocket. Each method opens a stream",
+		"/// for one server-push procedure and yields decoded values as they arrive.",
+		`public final class ${e}: @unchecked Sendable {`,
+		"    public let socketURL: URL",
+		"    public var auth: AuthContext",
+		"    private let transport: SocketTransport",
+		"",
+		"    public init(socketURL: URL, auth: AuthContext = AuthContext(), session: URLSession = .shared) {",
+		"        self.socketURL = socketURL",
+		"        self.auth = auth",
+		"        self.transport = SocketTransport(session: session)",
+		"    }"
+	];
+	for (let e of n) {
+		let t = e.output ? R(e.output) : "AnyCodable", { signature: n, payload: i } = V(e);
+		r.push("", `    /// \`${e.tag}\` (stream)`, `    public func ${e.methodName}${n} -> AsyncThrowingStream<${t}, Error> {`, `        transport.subscribe(socketURL: socketURL, auth: auth, tag: ${JSON.stringify(e.tag)}, payload: ${i})`, "    }");
+	}
+	return r.push("}"), r.join("\n");
+}, W = "import Foundation\n\n/// Authentication + tenant context carried on every request. The bearer token\n/// and tenant id are injected as request headers by the transport.\npublic struct AuthContext: Sendable {\n    public var token: String?\n    public var tenant: String?\n\n    public init(token: String? = nil, tenant: String? = nil) {\n        self.token = token\n        self.tenant = tenant\n    }\n\n    /// The header pairs this context contributes. Empty when unauthenticated.\n    public func headers() -> [(String, String)] {\n        var out: [(String, String)] = []\n        if let token = token { out.append((\"authorization\", \"Bearer \\(token)\")) }\n        if let tenant = tenant { out.append((\"x-tenant\", tenant)) }\n        return out\n    }\n}\n", G = "import Foundation\n\n/// Device registration for push notifications.\n///\n/// STUB — this registers the device TOKEN with the app's `registerDevice`\n/// procedure (the storage side). The SENDER (APNs / FCM) is deliberately NOT\n/// part of the generated SDK: it needs per-tenant Apple Developer / Firebase\n/// credentials managed by provider provisioning, which is server infrastructure,\n/// not client code. Wire this to your app's registerDevice mutation.\npublic struct PushRegistration: Codable, Equatable, Sendable {\n    public var deviceToken: String\n    public var platform: String\n    public var locale: String?\n    public var timezone: String?\n\n    public init(deviceToken: String, platform: String = \"ios\", locale: String? = nil, timezone: String? = nil) {\n        self.deviceToken = deviceToken\n        self.platform = platform\n        self.locale = locale\n        self.timezone = timezone\n    }\n}\n\npublic extension AuthContext {\n    /// Convenience: build a registration payload after the OS issues a token.\n    static func pushRegistration(deviceToken: String, platform: String = \"ios\") -> PushRegistration {\n        PushRegistration(deviceToken: deviceToken, platform: platform)\n    }\n}\n", K = "import Foundation\n\n/// The RPC request envelope sent to the api's `/rpc` endpoint. Mirrors the\n/// wire shape `{ _tag: \"Request\", id, tag, payload, headers }`.\nstruct RpcRequest<Payload: Encodable>: Encodable {\n    let _tag = \"Request\"\n    let id: String\n    let tag: String\n    let payload: Payload\n    let headers: [String: String]\n}\n\n/// An empty payload for no-argument procedures.\nstruct EmptyPayload: Encodable {}\n\n/// A dynamic JSON value for schemas with no faithful static type.\npublic struct AnyCodable: Codable, Equatable, Sendable {\n    public let value: Data\n    public init(from decoder: Decoder) throws {\n        let container = try decoder.singleValueContainer()\n        if let raw = try? container.decode(AnyCodableRaw.self) {\n            self.value = raw.data\n        } else {\n            self.value = Data()\n        }\n    }\n    public func encode(to encoder: Encoder) throws {\n        var container = encoder.singleValueContainer()\n        try container.encode(AnyCodableRaw(data: value))\n    }\n}\n\nstruct AnyCodableRaw: Codable {\n    let data: Data\n    init(data: Data) { self.data = data }\n    init(from decoder: Decoder) throws {\n        let container = try decoder.singleValueContainer()\n        let json = try container.decode(JSONValue.self)\n        self.data = try JSONEncoder().encode(json)\n    }\n    func encode(to encoder: Encoder) throws {\n        var container = encoder.singleValueContainer()\n        try container.encode(try JSONDecoder().decode(JSONValue.self, from: data))\n    }\n}\n\nindirect enum JSONValue: Codable {\n    case null\n    case bool(Bool)\n    case number(Double)\n    case string(String)\n    case array([JSONValue])\n    case object([String: JSONValue])\n    init(from decoder: Decoder) throws {\n        let c = try decoder.singleValueContainer()\n        if c.decodeNil() { self = .null }\n        else if let b = try? c.decode(Bool.self) { self = .bool(b) }\n        else if let n = try? c.decode(Double.self) { self = .number(n) }\n        else if let s = try? c.decode(String.self) { self = .string(s) }\n        else if let a = try? c.decode([JSONValue].self) { self = .array(a) }\n        else if let o = try? c.decode([String: JSONValue].self) { self = .object(o) }\n        else { self = .null }\n    }\n    func encode(to encoder: Encoder) throws {\n        var c = encoder.singleValueContainer()\n        switch self {\n        case .null: try c.encodeNil()\n        case .bool(let b): try c.encode(b)\n        case .number(let n): try c.encode(n)\n        case .string(let s): try c.encode(s)\n        case .array(let a): try c.encode(a)\n        case .object(let o): try c.encode(o)\n        }\n    }\n}\n\npublic enum RpcError: Error {\n    case http(status: Int, body: Data)\n    case decoding(Error)\n    case transport(Error)\n}\n\n/// HTTP transport for one-shot calls.\n///\n/// NOTE — the exact @effect/rpc response FRAMING (success/failure envelope over\n/// HTTP) is the one seam that must be validated against a live server; this\n/// decodes the success value from the response body and surfaces non-2xx as\n/// `RpcError.http`. Correct type mapping + one method per procedure is what the\n/// generator guarantees; the wire framing is the cross-language integration step.\nstruct RpcTransport: Sendable {\n    let session: URLSession\n\n    func call<Payload: Encodable, Result: Decodable>(\n        baseURL: URL, auth: AuthContext, tag: String, payload: Payload\n    ) async throws -> Result {\n        var request = URLRequest(url: baseURL.appendingPathComponent(\"rpc\"))\n        request.httpMethod = \"POST\"\n        request.setValue(\"application/json\", forHTTPHeaderField: \"content-type\")\n        for (k, v) in auth.headers() { request.setValue(v, forHTTPHeaderField: k) }\n        let envelope = RpcRequest(id: UUID().uuidString, tag: tag, payload: payload, headers: [:])\n        request.httpBody = try JSONEncoder().encode(envelope)\n        let (data, response): (Data, URLResponse)\n        do { (data, response) = try await session.data(for: request) }\n        catch { throw RpcError.transport(error) }\n        if let http = response as? HTTPURLResponse, !(200...299).contains(http.statusCode) {\n            throw RpcError.http(status: http.statusCode, body: data)\n        }\n        do { return try JSONDecoder().decode(Result.self, from: data) }\n        catch { throw RpcError.decoding(error) }\n    }\n}\n\n/// WebSocket transport for reactive subscriptions.\nstruct SocketTransport: Sendable {\n    let session: URLSession\n\n    func subscribe<Payload: Encodable, Value: Decodable>(\n        socketURL: URL, auth: AuthContext, tag: String, payload: Payload\n    ) -> AsyncThrowingStream<Value, Error> {\n        AsyncThrowingStream { continuation in\n            let task = session.webSocketTask(with: socketURL)\n            task.resume()\n            let envelope = RpcRequest(id: UUID().uuidString, tag: tag, payload: payload, headers: [:])\n            if let frame = try? JSONEncoder().encode(envelope), let text = String(data: frame, encoding: .utf8) {\n                task.send(.string(text)) { _ in }\n            }\n            func receive() {\n                task.receive { result in\n                    switch result {\n                    case .failure(let error):\n                        continuation.finish(throwing: error)\n                    case .success(let message):\n                        let data: Data?\n                        switch message {\n                        case .string(let s): data = s.data(using: .utf8)\n                        case .data(let d): data = d\n                        @unknown default: data = nil\n                        }\n                        if let data = data, let value = try? JSONDecoder().decode(Value.self, from: data) {\n                            continuation.yield(value)\n                        }\n                        receive()\n                    }\n                }\n            }\n            receive()\n            continuation.onTermination = { _ in task.cancel(with: .goingAway, reason: nil) }\n        }\n    }\n}\n", q = (e) => `// swift-tools-version:5.9
+import PackageDescription
+
+let package = Package(
+    name: ${JSON.stringify(e)},
+    platforms: [.iOS(.v15), .macOS(.v12)],
+    products: [
+        .library(name: ${JSON.stringify(e)}, targets: [${JSON.stringify(e)}]),
+    ],
+    targets: [
+        .target(name: ${JSON.stringify(e)}, path: "Sources/${e}"),
+    ]
+)
+`, J = "// Generated by `voltro build api --target swift`. Do not edit by hand.", Y = (e, t) => {
+	let n = `Sources/${t}`, r = [...e.enums.map(te), ...e.models.map(B)].join("\n\n");
+	return [
+		{
+			path: "Package.swift",
+			content: q(t)
+		},
+		{
+			path: `${n}/Models.swift`,
+			content: `${J}\nimport Foundation\n\n${r}${r ? "\n" : ""}`
+		},
+		{
+			path: `${n}/Client.swift`,
+			content: `${J}\nimport Foundation\n\n${H(`${t}Client`, e.procedures)}\n`
+		},
+		{
+			path: `${n}/Subscriptions.swift`,
+			content: `${J}\nimport Foundation\n\n${U(`${t}Subscriptions`, e.procedures)}\n`
+		},
+		{
+			path: `${n}/Auth.swift`,
+			content: `${J}\n${W}`
+		},
+		{
+			path: `${n}/Push.swift`,
+			content: `${J}\n${G}`
+		},
+		{
+			path: `${n}/RpcTransport.swift`,
+			content: `${J}\n${K}`
+		}
+	];
+}, X = a({ scope: "voltro:sdk" }), Z = "VoltroClient", Q = "com.voltro.client", ne = (e, t) => {
+	let n = y(e), r = t.packageName ?? Z;
+	return t.target === "swift" ? Y(n, r) : L(n, r, t.kotlinPackage ?? Q);
+}, re = async (e, n) => {
+	for (let i of e) {
+		let e = r(n, i.path);
+		await o.mkdir(t(e), { recursive: !0 }), await o.writeFile(e, i.content, "utf8");
+	}
+}, ie = async (e) => {
+	let { offlineManifest: t } = await import("./checkCommand-DBvZvCh1.js"), { manifest: n } = await t(e);
+	return n;
+}, ae = async (e) => {
+	let t = ne(await (e.manifestProvider ?? ie)(e.root), {
+		target: e.target,
+		...e.packageName === void 0 ? {} : { packageName: e.packageName },
+		...e.kotlinPackage === void 0 ? {} : { kotlinPackage: e.kotlinPackage }
+	});
+	return await re(t, e.outDir), {
+		files: t,
+		outDir: e.outDir
+	};
+}, $ = (e, t) => {
+	let n = e.indexOf(t);
+	return n !== -1 && n + 1 < e.length ? e[n + 1] : void 0;
+}, oe = (e, t) => {
+	let i = $(e, "--target");
+	if (i !== "swift" && i !== "kotlin") return { error: `--target must be "swift" or "kotlin" (got ${i === void 0 ? "<none>" : JSON.stringify(i)})` };
+	let a = $(e, "--out"), o = $(e, "--name"), s = $(e, "--kotlin-package"), c = new Set([
+		i,
+		a,
+		o,
+		s
+	].filter((e) => e !== void 0)), l = /* @__PURE__ */ new Set([
+		"--target",
+		"--out",
+		"--name",
+		"--kotlin-package"
+	]), u = e.find((e) => !e.startsWith("-") && e !== "api" && !l.has(e) && !c.has(e));
+	return {
+		target: i,
+		root: u ? n(u) ? u : r(t, u) : t,
+		...a === void 0 ? {} : { outDir: a },
+		...o === void 0 ? {} : { packageName: o },
+		...s === void 0 ? {} : { kotlinPackage: s }
+	};
+}, se = (e, t) => r(e, "sdk", t), ce = async (t, n = process.cwd()) => {
+	let r = oe(t, n);
+	if ("error" in r) return console.error(`voltro build --target: ${r.error}`), 1;
+	let a = r.outDir ?? se(r.root, r.target);
+	return e(i.gen(function* () {
+		let e = yield* i.tryPromise({
+			try: () => ae({
+				root: r.root,
+				target: r.target,
+				outDir: a,
+				...r.packageName === void 0 ? {} : { packageName: r.packageName },
+				...r.kotlinPackage === void 0 ? {} : { kotlinPackage: r.kotlinPackage }
+			}),
+			catch: (e) => e
+		}).pipe(i.orDie);
+		return yield* i.sync(() => X.info("SDK generated", {
+			target: r.target,
+			files: e.files.length,
+			out: a
+		})), 0;
+	}), { scope: "voltro:sdk" });
+};
+//#endregion
+export { ce as runSdkBuildCommand };