@xyd-js/opensdk-java 0.0.0-build-f0c10f6-20260703195526

package/dist/index.js

@@ -0,0 +1,2138 @@
+// src/emitter.ts
+import { generate } from "@xyd-js/opensdk-framework";
+
+// src/javawriter.ts
+var HEADER = "Code generated by opensdk. DO NOT EDIT.";
+function javaFile(pkg, imports, body) {
+  const parts = [`// ${HEADER}`, "", `package ${pkg};`];
+  const uniqueSorted = [...new Set(imports)].sort();
+  if (uniqueSorted.length > 0) {
+    parts.push("", uniqueSorted.map((i) => `import ${i};`).join("\n"));
+  }
+  parts.push("", body.trimEnd());
+  return `${parts.join("\n")}
+`;
+}
+function javaDoc(text, indent = "") {
+  const raw = (text || "").trim();
+  if (!raw) return "";
+  const lines = raw.split("\n");
+  if (lines.length === 1) return `${indent}/** ${lines[0].trim()} */`;
+  const body = lines.map((l) => `${indent} * ${l.trim()}`).join("\n");
+  return `${indent}/**
+${body}
+${indent} */`;
+}
+
+// src/naming.ts
+function splitWords(input) {
+  return input.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[^a-zA-Z0-9]+/).map((w) => w.trim().toLowerCase()).filter(Boolean);
+}
+function capitalize(word) {
+  return word.charAt(0).toUpperCase() + word.slice(1);
+}
+function safeIdent(s) {
+  return /^[0-9]/.test(s) ? `_${s}` : s;
+}
+function pascalCase(input) {
+  return safeIdent(splitWords(input).map(capitalize).join(""));
+}
+function camelCase(input) {
+  const words = splitWords(input);
+  if (words.length === 0) return "value";
+  const head = words[0];
+  const name = safeIdent(head + words.slice(1).map(capitalize).join(""));
+  return JAVA_KEYWORDS.has(name) ? `${name}_` : name;
+}
+var UNCOUNTABLE = /* @__PURE__ */ new Set(["data", "media", "series"]);
+function singularize(word) {
+  if (word.length < 3 || UNCOUNTABLE.has(word)) return word;
+  if (word.endsWith("ies") && word.length > 4) return `${word.slice(0, -3)}y`;
+  if (/(?:sses|xes|ches|shes|uses)$/.test(word) && word.length > 4) return word.slice(0, -2);
+  if (/(?:ss|us|is)$/.test(word)) return word;
+  if (word.endsWith("s")) return word.slice(0, -1);
+  return word;
+}
+function singularPascalCase(input) {
+  const words = splitWords(input);
+  if (words.length === 0) return "";
+  const last = words.length - 1;
+  return safeIdent(words.map((w, i) => capitalize(i === last ? singularize(w) : w)).join(""));
+}
+function resourceQualifier(segments) {
+  return segments.map(singularPascalCase).join("");
+}
+function serviceTypeName(segments) {
+  return `${resourceQualifier(segments)}Service`;
+}
+function javaMethodName(action) {
+  switch (action) {
+    case "create":
+    case "list":
+    case "retrieve":
+    case "update":
+    case "delete":
+      return action;
+    default:
+      return camelCase(action);
+  }
+}
+function screamingSnakeCase(input) {
+  const s = splitWords(input).join("_").toUpperCase().replace(/[^A-Z0-9_]/g, "");
+  return safeIdent(s) || "VALUE";
+}
+function javaPackageName(input) {
+  const clean = splitWords(input).join("").replace(/[^a-z0-9]/g, "");
+  return clean || "client";
+}
+var JAVA_KEYWORDS = /* @__PURE__ */ new Set([
+  "abstract",
+  "assert",
+  "boolean",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "class",
+  "const",
+  "continue",
+  "default",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "extends",
+  "final",
+  "finally",
+  "float",
+  "for",
+  "goto",
+  "if",
+  "implements",
+  "import",
+  "instanceof",
+  "int",
+  "interface",
+  "long",
+  "native",
+  "new",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "short",
+  "static",
+  "strictfp",
+  "super",
+  "switch",
+  "synchronized",
+  "this",
+  "throw",
+  "throws",
+  "transient",
+  "try",
+  "void",
+  "volatile",
+  "while",
+  "true",
+  "false",
+  "null",
+  "var",
+  "record",
+  "yield"
+]);
+
+// src/client.ts
+function renderClientFile(spec, ctx) {
+  const resources = spec.resources || [];
+  const fieldLines = ["  private final Transport transport;"];
+  for (const r of resources) fieldLines.push(`  private final ${serviceTypeName([r.name])} ${camelCase(r.name)};`);
+  const ctorLines = [
+    "    this.transport = new Transport(baseUrl, apiKey);",
+    ...resources.map((r) => `    this.${camelCase(r.name)} = new ${serviceTypeName([r.name])}(transport);`)
+  ];
+  const ctor = `  public Client(String apiKey, String baseUrl) {
+${ctorLines.join("\n")}
+  }`;
+  const accessors = resources.map((r) => `  public ${serviceTypeName([r.name])} ${camelCase(r.name)}() {
+    return ${camelCase(r.name)};
+  }`).join("\n\n");
+  const defaultBaseUrl = JSON.stringify(ctx.baseURL);
+  const keyExpr = ctx.envVar ? `apiKey != null ? apiKey : System.getenv(${JSON.stringify(ctx.envVar)})` : "apiKey";
+  const fromEnvDoc = ctx.envVar ? javaDoc(`Create a client seeded with the credential from ${ctx.envVar}.`, "  ") : javaDoc("Create a client using the default configuration.", "  ");
+  const builder = `  public static final class Builder {
+    private String apiKey;
+    private String baseUrl = ${defaultBaseUrl};
+
+    public Builder apiKey(String apiKey) {
+      this.apiKey = apiKey;
+      return this;
+    }
+
+    public Builder baseUrl(String baseUrl) {
+      this.baseUrl = baseUrl;
+      return this;
+    }
+
+    public Client build() {
+      String key = ${keyExpr};
+      return new Client(key, baseUrl);
+    }
+  }`;
+  const doc = javaDoc(`Client is the ${spec.info.title} API client.`);
+  const head = doc ? `${doc}
+` : "";
+  const members = [
+    fieldLines.join("\n"),
+    ctor,
+    accessors,
+    "  public static Builder builder() {\n    return new Builder();\n  }",
+    `${fromEnvDoc}
+  public static Client fromEnv() {
+    return builder().build();
+  }`,
+    builder
+  ].filter(Boolean).join("\n\n");
+  const body = `${head}public final class Client {
+${members}
+}`;
+  return javaFile(ctx.fullPackage, [], body);
+}
+
+// src/example-java.ts
+import { planMethodExample } from "@xyd-js/opensdk-framework";
+
+// src/javatype.ts
+function unionMapping(type) {
+  if (type.kind !== "union") return null;
+  const disc = type.discriminator;
+  if (!(disc == null ? void 0 : disc.propertyName) || !disc.mapping || Object.keys(disc.mapping).length === 0) return null;
+  return { property: disc.propertyName, mapping: disc.mapping };
+}
+function isConstField(field) {
+  const ref = field.type;
+  return (ref == null ? void 0 : ref.kind) === "scalar" && ref.const !== void 0;
+}
+function constLiteral(value) {
+  if (typeof value === "number") return `${value}L`;
+  if (typeof value === "boolean") return String(value);
+  return JSON.stringify(String(value));
+}
+function isBinaryTypeRef(ref, types, seen = /* @__PURE__ */ new Set()) {
+  if (!ref) return false;
+  if (ref.kind === "scalar") return ref.scalar === "string" && ref.format === "binary";
+  if (ref.kind === "array") return isBinaryTypeRef(ref.items, types, seen);
+  if (ref.kind === "ref" && ref.name) {
+    if (seen.has(ref.name)) return false;
+    seen.add(ref.name);
+    const named = types.get(ref.name);
+    if (!named) return false;
+    if (named.kind === "union") return (named.variants || []).some((v) => isBinaryTypeRef(v, types, seen));
+    if (named.kind === "alias") return isBinaryTypeRef(named.of, types, seen);
+  }
+  return false;
+}
+function queryKind(ref, types) {
+  if (!ref) return "scalar";
+  if (ref.kind === "scalar") return "scalar";
+  if (ref.kind === "array") return "array";
+  if (ref.kind === "map") return "map";
+  if (ref.kind === "ref" && ref.name) {
+    const named = types.get(ref.name);
+    if ((named == null ? void 0 : named.kind) === "enum") return "scalar";
+    if ((named == null ? void 0 : named.kind) === "alias") return queryKind(named.of, types);
+    return "object";
+  }
+  return "object";
+}
+function javaType(ref, types) {
+  if (!ref) return "Object";
+  switch (ref.kind) {
+    case "scalar":
+      return javaScalar(ref.scalar, ref.format);
+    case "array":
+      return `List<${javaType(ref.items, types)}>`;
+    case "map":
+      return `Map<String, ${javaType(ref.values, types)}>`;
+    case "ref":
+      return javaRefType(ref.name, types);
+    default:
+      return "Object";
+  }
+}
+function javaScalar(scalar, format) {
+  switch (scalar) {
+    case "string":
+      return format === "binary" ? "byte[]" : "String";
+    case "integer":
+      return "Long";
+    case "number":
+      return "Double";
+    case "boolean":
+      return "Boolean";
+    default:
+      return "Object";
+  }
+}
+function javaRefType(name, types) {
+  if (!name) return "Object";
+  const named = types.get(name);
+  if (!named) return "Object";
+  if (named.kind === "struct" || named.kind === "enum") return pascalCase(name);
+  if (named.kind === "alias") return javaType(named.of, types);
+  return "Object";
+}
+function lambdaVar(depth) {
+  return depth === 0 ? "__e" : `__e${depth}`;
+}
+function javaDecode(ref, src, types, depth = 0) {
+  if (!ref) return src;
+  switch (ref.kind) {
+    case "scalar":
+      return scalarDecode(ref.scalar, ref.format, src);
+    case "array": {
+      const v = lambdaVar(depth);
+      return `Json.mapList(${src}, ${v} -> ${javaDecode(ref.items, v, types, depth + 1)})`;
+    }
+    case "map": {
+      const v = lambdaVar(depth);
+      return `Json.mapValues(${src}, ${v} -> ${javaDecode(ref.values, v, types, depth + 1)})`;
+    }
+    case "ref":
+      return refDecode(ref.name, src, types);
+    default:
+      return src;
+  }
+}
+function scalarDecode(scalar, format, src) {
+  switch (scalar) {
+    case "string":
+      return format === "binary" ? `Json.asBytes(${src})` : `Json.asString(${src})`;
+    case "integer":
+      return `Json.asLong(${src})`;
+    case "number":
+      return `Json.asDouble(${src})`;
+    case "boolean":
+      return `Json.asBoolean(${src})`;
+    default:
+      return src;
+  }
+}
+function refDecode(name, src, types) {
+  if (!name) return src;
+  const named = types.get(name);
+  if (!named) return src;
+  if (named.kind === "struct" || named.kind === "enum") return `${pascalCase(name)}.fromJson(${src})`;
+  if (named.kind === "alias") return javaDecode(named.of, src, types);
+  if (named.kind === "union" && unionMapping(named)) return `${pascalCase(name)}.fromJson(${src})`;
+  return src;
+}
+
+// src/example-java.ts
+var MOCK_BASE_URL = "http://localhost:4010";
+function generateJavaTests(spec, ctx) {
+  const files = [];
+  for (const resource of spec.resources || []) {
+    const file = resourceTestFile(resource, ctx);
+    if (file) files.push(file);
+  }
+  return files;
+}
+function resourceTestFile(top, ctx) {
+  const className = `${serviceTypeName([top.name])}Test`;
+  const calls = [];
+  const methods = [];
+  let needsRequireContains = false;
+  const walk = (resource, segments) => {
+    for (const method of resource.methods || []) {
+      for (const t of renderMethodTests(segments, method, ctx)) {
+        calls.push(`    ${t.name}(client);`);
+        methods.push(t);
+        if (t.name.endsWith("PathParams")) needsRequireContains = true;
+      }
+    }
+    for (const sub of resource.resources || []) walk(sub, [...segments, sub.name]);
+  };
+  walk(top, [top.name]);
+  if (methods.length === 0) return null;
+  const helper = needsRequireContains ? `
+
+  private static void requireContains(String actual, String needle) {
+    if (actual == null || !actual.contains(needle)) {
+      throw new AssertionError("missing substring [" + needle + "] in: " + actual);
+    }
+  }` : "";
+  const body = `/**
+ * A dependency-free assertion test for ${serviceTypeName([top.name])} \u2014 run with plain \`java ${className}\`.
+ */
+public final class ${className} {
+  private static final String BASE_URL =
+      System.getenv().getOrDefault("TEST_API_BASE_URL", ${JSON.stringify(MOCK_BASE_URL)});
+
+  public static void main(String[] args) {
+    Client client = Client.builder().baseUrl(BASE_URL).apiKey("My API Key").build();
+${calls.join("\n")}
+    System.out.println(${JSON.stringify(`${className} OK`)});
+  }
+
+${methods.map((m) => m.body).join("\n\n")}${helper}
+}`;
+  return { path: `${ctx.srcDir}${className}.java`, content: javaFile(ctx.fullPackage, [], body) };
+}
+function renderMethodTests(segments, method, ctx) {
+  const qualifier = resourceQualifier(segments);
+  const methodName = javaMethodName(method.action);
+  const pascalMethod = pascalCase(methodName);
+  const chain = clientChain(segments);
+  const constNames = new Set(constBodyFieldNames(method, ctx));
+  const required = planMethodExample(method, ctx.types);
+  const withOptional = required.hasOptional;
+  const example = withOptional ? planMethodExample(method, ctx.types, { withOptional: true }) : required;
+  const out = [];
+  const pathArgs = example.pathArgs.map((pa) => renderJavaExample(pa.value, ctx));
+  const params = methodHasParams(method, ctx) ? renderParamsBuilder(segments, method, pascalMethod, example, constNames, ctx) : null;
+  const testName = `test${qualifier}${pascalMethod}${withOptional ? "WithOptionalParams" : ""}`;
+  out.push({ name: testName, body: renderMainTest(testName, callExpr(chain, methodName, pathArgs, params)) });
+  const guardIdx = (method.pathParams || []).findIndex(
+    (p) => {
+      var _a;
+      return ((_a = p.type) == null ? void 0 : _a.kind) === "scalar" && p.type.scalar === "string" && p.required !== false;
+    }
+  );
+  if (guardIdx >= 0) {
+    const guardArgs = required.pathArgs.map((pa, i) => i === guardIdx ? '""' : renderJavaExample(pa.value, ctx));
+    const guardParams = methodHasParams(method, ctx) ? renderParamsBuilder(segments, method, pascalMethod, required, constNames, ctx) : null;
+    const guardName = `test${qualifier}${pascalMethod}PathParams`;
+    out.push({ name: guardName, body: renderGuardTest(guardName, methodName, callExpr(chain, methodName, guardArgs, guardParams)) });
+  }
+  return out;
+}
+function callExpr(chain, methodName, pathArgs, params) {
+  const args = [...pathArgs];
+  if (params) args.push(params);
+  return `${chain}.${methodName}(${args.join(", ")})`;
+}
+function renderParamsBuilder(segments, method, pascalMethod, example, constNames, ctx) {
+  const cls = `${resourceQualifier(segments)}${pascalMethod}Params`;
+  const fields = example.fields.filter((f) => !constNames.has(f.name));
+  if (fields.length === 0) return `${cls}.builder().build()`;
+  const setters = fields.map((f) => `          .${camelCase(f.name)}(${renderJavaExample(f.value, ctx)})`).join("\n");
+  return `${cls}.builder()
+${setters}
+          .build()`;
+}
+function renderMainTest(name, call) {
+  return `  private static void ${name}(Client client) {
+    try {
+      ${call};
+    } catch (ApiException expected) {
+      // Offline: no mock server answering \u2014 a transport/HTTP error is acceptable here.
+    }
+  }`;
+}
+function renderGuardTest(name, methodName, call) {
+  return `  private static void ${name}(Client client) {
+    try {
+      ${call};
+      throw new AssertionError(${JSON.stringify(`expected a missing required path param error for ${methodName}`)});
+    } catch (IllegalArgumentException expected) {
+      requireContains(expected.getMessage(), "missing required");
+    }
+  }`;
+}
+function clientChain(segments) {
+  return `client.${segments.map((s) => `${camelCase(s)}()`).join(".")}`;
+}
+function methodHasParams(method, ctx) {
+  var _a, _b;
+  const body = requestBodyFields(method, ctx.types);
+  return body.length > 0 || (((_a = method.queryParams) == null ? void 0 : _a.length) ?? 0) > 0 || (((_b = method.headerParams) == null ? void 0 : _b.length) ?? 0) > 0;
+}
+function requestBodyFields(method, types) {
+  var _a;
+  const ref = (_a = method.requestBody) == null ? void 0 : _a.type;
+  if ((ref == null ? void 0 : ref.kind) === "ref" && ref.name) {
+    const named = types.get(ref.name);
+    if (named == null ? void 0 : named.fields) return named.fields;
+  }
+  return [];
+}
+function constBodyFieldNames(method, ctx) {
+  return requestBodyFields(method, ctx.types).filter(isConstField).map((f) => f.name);
+}
+function renderJavaExample(value, ctx) {
+  switch (value.kind) {
+    case "string":
+      return JSON.stringify(value.value);
+    case "integer":
+      return `${value.value}L`;
+    case "number":
+      return Number.isInteger(value.value) ? `${value.value}.0` : String(value.value);
+    case "boolean":
+      return value.value ? "true" : "false";
+    case "null":
+      return "null";
+    case "binary":
+      return '"Example data".getBytes(java.nio.charset.StandardCharsets.UTF_8)';
+    case "enum":
+      return renderEnumConst(value.typeName, value.value, ctx);
+    case "const":
+      return constLiteral(value.value);
+    case "array":
+      return isRenderableElement(value.item) ? `java.util.List.of(${renderJavaExample(value.item, ctx)})` : "java.util.List.of()";
+    case "map":
+      return isRenderableElement(value.value) ? `java.util.Map.of("key", ${renderJavaExample(value.value, ctx)})` : "java.util.Map.of()";
+    // An open union field is typed Object; render its planned variant so a
+    // REQUIRED union field (e.g. model: string|enum) gets a non-null value the
+    // builder's required-guard accepts (a scalar/enum variant is Object-assignable).
+    case "union":
+      return renderJavaExample(value.variant, ctx);
+    // A model POJO is decode-only (no builder), but every generated struct has a
+    // public no-arg constructor (its own `fromJson` uses `new X()`), so a
+    // REQUIRED object-typed field gets a valid non-null instance the builder's
+    // required-guard accepts. Falls back to null only for a type with no class.
+    case "object": {
+      const named = value.typeName ? ctx.types.get(value.typeName) : void 0;
+      return (named == null ? void 0 : named.kind) === "struct" ? `new ${pascalCase(value.typeName)}()` : "null";
+    }
+    case "any":
+      return "null";
+    default:
+      return "null";
+  }
+}
+function isRenderableElement(value) {
+  return ["string", "integer", "number", "boolean", "enum", "const", "binary"].includes(value.kind);
+}
+function renderEnumConst(typeName, rawValue, ctx) {
+  var _a;
+  const named = ctx.types.get(typeName);
+  const ev = (_a = named == null ? void 0 : named.values) == null ? void 0 : _a.find((v) => v.value === rawValue);
+  const member = screamingSnakeCase(String((ev == null ? void 0 : ev.name) ?? (ev == null ? void 0 : ev.value) ?? rawValue)) || "VALUE";
+  return `${pascalCase(typeName)}.${member}`;
+}
+
+// src/model.ts
+function renderTypeFiles(types, ctx) {
+  const files = [];
+  for (const type of types) {
+    if (type.kind === "struct") files.push(structFile(type, ctx));
+    else if (type.kind === "enum") files.push(enumFile(type, ctx));
+    else if (type.kind === "union" && unionMapping(type)) files.push(unionFile(type, ctx));
+  }
+  return files;
+}
+function unionFile(type, ctx) {
+  const name = pascalCase(type.name);
+  const mapped = unionMapping(type);
+  const entries = Object.entries(mapped.mapping).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  const cases = entries.map(
+    ([value, variant]) => `    if (${JSON.stringify(value)}.equals(discriminator)) {
+      return ${pascalCase(variant)}.fromJson(json);
+    }`
+  ).join("\n");
+  const doc = javaDoc(
+    type.description || `Decode helper for the ${name} union, selecting the concrete variant by its ${JSON.stringify(mapped.property)} discriminator.`
+  );
+  const head = doc ? `${doc}
+` : "";
+  const body = `${head}public final class ${name} {
+  private ${name}() {
+  }
+
+  /**
+   * Decode JSON into the concrete ${name} variant selected by the ${JSON.stringify(mapped.property)}
+   * discriminator. An unknown or absent discriminator keeps the raw parsed value.
+   */
+  public static Object fromJson(Object json) {
+    if (!(json instanceof Map)) {
+      return json;
+    }
+    Object discriminator = ((Map<?, ?>) json).get(${JSON.stringify(mapped.property)});
+${cases}
+    return json;
+  }
+}`;
+  return { path: `${ctx.srcDir}${name}.java`, content: javaFile(ctx.fullPackage, ["java.util.Map"], body) };
+}
+function structFile(type, ctx) {
+  const name = pascalCase(type.name);
+  const fields = type.fields || [];
+  const fieldTypes = fields.map((f) => javaType(f.type, ctx.types));
+  const imports = ["java.util.LinkedHashMap", "java.util.Map"];
+  if (fieldTypes.some((t) => t.includes("List<"))) imports.push("java.util.List");
+  const doc = javaDoc(type.description);
+  const head = doc ? `${doc}
+` : "";
+  const fieldDecls = fields.map((f, i) => `  private ${fieldTypes[i]} ${camelCase(f.name)};`).join("\n");
+  const accessors = fields.map((f, i) => `  public ${fieldTypes[i]} ${camelCase(f.name)}() {
+    return ${camelCase(f.name)};
+  }`).join("\n\n");
+  const fromJson = structFromJson(name, fields, ctx);
+  const toJsonMap = structToJsonMap(fields);
+  const bodyParts = fields.length ? [fieldDecls, accessors, fromJson, toJsonMap] : [emptyFromJson(name), emptyToJsonMap()];
+  const body = `${head}public final class ${name} implements Json.JsonSerializable {
+${bodyParts.join("\n\n")}
+}`;
+  return { path: `${ctx.srcDir}${name}.java`, content: javaFile(ctx.fullPackage, imports, body) };
+}
+function structFromJson(name, fields, ctx) {
+  const assigns = fields.map((f) => `    out.${camelCase(f.name)} = ${javaDecode(f.type, `map.get(${JSON.stringify(f.name)})`, ctx.types)};`).join("\n");
+  return `  public static ${name} fromJson(Object json) {
+    if (json == null) {
+      return null;
+    }
+    @SuppressWarnings("unchecked")
+    Map<String, Object> map = (Map<String, Object>) json;
+    ${name} out = new ${name}();
+${assigns}
+    return out;
+  }`;
+}
+function structToJsonMap(fields) {
+  const puts = fields.map((f) => {
+    const member = camelCase(f.name);
+    const key = JSON.stringify(f.name);
+    if (isConstField(f)) return `    map.put(${key}, ${member} != null ? ${member} : ${constLiteral(f.type.const)});`;
+    if (f.required) return `    map.put(${key}, ${member});`;
+    return `    if (${member} != null) {
+      map.put(${key}, ${member});
+    }`;
+  }).join("\n");
+  return `  @Override
+  public Map<String, Object> toJsonMap() {
+    Map<String, Object> map = new LinkedHashMap<>();
+${puts}
+    return map;
+  }`;
+}
+function emptyFromJson(name) {
+  return `  public static ${name} fromJson(Object json) {
+    return json == null ? null : new ${name}();
+  }`;
+}
+function emptyToJsonMap() {
+  return `  @Override
+  public Map<String, Object> toJsonMap() {
+    return new LinkedHashMap<>();
+  }`;
+}
+function enumFile(type, ctx) {
+  const name = pascalCase(type.name);
+  const isInt = type.base === "integer";
+  const valueType = isInt ? "long" : "String";
+  const values = type.values || [];
+  const doc = javaDoc(type.description);
+  const head = doc ? `${doc}
+` : "";
+  const members = values.length ? `${values.map((v) => `  ${enumMember(name, v)}(${enumLiteral(v.value, isInt)})`).join(",\n")};` : "  ;";
+  const equalsExpr = isInt ? "item.value == value" : "item.value.equals(value)";
+  const coerce = isInt ? "Json.asLong(json)" : "Json.asString(json)";
+  const body = `${head}public enum ${name} implements Json.JsonEnum {
+${members}
+
+  private final ${valueType} value;
+
+  ${name}(${valueType} value) {
+    this.value = value;
+  }
+
+  public ${valueType} value() {
+    return value;
+  }
+
+  @Override
+  public Object jsonValue() {
+    return value;
+  }
+
+  public static ${name} fromValue(${valueType} value) {
+    for (${name} item : values()) {
+      if (${equalsExpr}) {
+        return item;
+      }
+    }
+    throw new IllegalArgumentException("unknown ${name} value: " + value);
+  }
+
+  public static ${name} fromJson(Object json) {
+    return json == null ? null : fromValue(${coerce});
+  }
+}`;
+  return { path: `${ctx.srcDir}${name}.java`, content: javaFile(ctx.fullPackage, [], body) };
+}
+function enumMember(enumName, value) {
+  const member = screamingSnakeCase(String(value.name ?? value.value));
+  return member || "VALUE";
+}
+function enumLiteral(value, isInt) {
+  if (isInt) return String(value);
+  return JSON.stringify(String(value));
+}
+
+// src/project.ts
+import { sdkBehavior } from "@xyd-js/opensdk-core";
+function resolveJavaOptions(spec, ctx) {
+  var _a, _b, _c, _d;
+  const options = ctx.emitterOptions;
+  const pkg = options.packageName ?? javaPackageName(spec.info.title);
+  const basePackage = options.basePackage ?? "com.example";
+  const fullPackage = `${basePackage}.${pkg}`;
+  const security = (_a = spec.security) == null ? void 0 : _a[0];
+  const behavior = sdkBehavior(spec);
+  const userAgent = behavior.userAgent.sdkIdentifierTemplate.split("{package}").join(pkg).split("{language}").join("java").split("{version}").join(spec.info.version || "0.0.0");
+  return {
+    pkg,
+    basePackage,
+    fullPackage,
+    srcDir: `src/main/java/${fullPackage.split(".").join("/")}/`,
+    types: ctx.types,
+    behavior,
+    baseURL: options.baseURL ?? ((_b = spec.servers) == null ? void 0 : _b[0]) ?? "",
+    envVar: ((_d = (_c = spec.security) == null ? void 0 : _c.find((s) => s.envVar)) == null ? void 0 : _d.envVar) ?? null,
+    authKind: (security == null ? void 0 : security.kind) ?? null,
+    authName: (security == null ? void 0 : security.name) ?? null,
+    userAgent
+  };
+}
+function xmlEscape(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function pomXml(ctx, spec) {
+  var _a, _b;
+  const info = spec.info;
+  const meta = [`  <name>${xmlEscape(info.title)}</name>`];
+  if (info.homepage) meta.push(`  <url>${xmlEscape(info.homepage)}</url>`);
+  if ((_a = info.license) == null ? void 0 : _a.identifier) {
+    meta.push(
+      "  <licenses>",
+      `    <license><name>${xmlEscape(info.license.identifier)}</name></license>`,
+      "  </licenses>"
+    );
+  }
+  if ((_b = info.contact) == null ? void 0 : _b.name) {
+    meta.push(
+      "  <developers>",
+      `    <developer><name>${xmlEscape(info.contact.name)}</name></developer>`,
+      "  </developers>"
+    );
+  }
+  if (info.repository) meta.push("  <scm>", `    <url>${xmlEscape(info.repository)}</url>`, "  </scm>");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <groupId>${ctx.basePackage}</groupId>
+  <artifactId>${ctx.pkg}-java</artifactId>
+  <version>${info.version || "0.0.0"}</version>
+  <packaging>jar</packaging>
+${meta.join("\n")}
+
+  <properties>
+    <maven.compiler.release>11</maven.compiler.release>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+</project>
+`;
+}
+
+// src/runtime.ts
+import { walkMethods } from "@xyd-js/opensdk-core";
+import { planOperation as planOperation2 } from "@xyd-js/opensdk-framework";
+
+// src/service.ts
+import { planOperation } from "@xyd-js/opensdk-framework";
+function methodEncoding(method, plan, types) {
+  let encoding = plan.encoding ?? "json";
+  if (encoding === "json" && requestBodyFields2(method, types).some((f) => isBinaryTypeRef(f.type, types))) {
+    encoding = "multipart";
+  }
+  return encoding;
+}
+function renderResourceFiles(resources, ctx) {
+  const files = [];
+  const walk = (resource, segments) => {
+    files.push(serviceFile(resource, segments, ctx));
+    for (const method of resource.methods || []) {
+      const paramsFile = paramsFile2(resource, segments, method, ctx);
+      if (paramsFile) files.push(paramsFile);
+    }
+    for (const sub of resource.resources || []) walk(sub, [...segments, sub.name]);
+  };
+  for (const resource of resources) walk(resource, [resource.name]);
+  return files;
+}
+function planParams(segments, method, plan, ctx) {
+  const query = plan.paramGroups.query;
+  const header = plan.paramGroups.header;
+  const bodyFields = requestBodyFields2(method, ctx.types);
+  if (bodyFields.length === 0 && query.length === 0 && header.length === 0) return null;
+  const className = `${resourceQualifier(segments)}${pascalCase(javaMethodName(method.action))}Params`;
+  return { className, bodyFields, query, header };
+}
+function requestBodyFields2(method, types) {
+  var _a;
+  const ref = (_a = method.requestBody) == null ? void 0 : _a.type;
+  if ((ref == null ? void 0 : ref.kind) === "ref" && ref.name) {
+    const named = types.get(ref.name);
+    if (named == null ? void 0 : named.fields) return named.fields;
+  }
+  return [];
+}
+function serviceFile(resource, segments, ctx) {
+  const cls = serviceTypeName(segments);
+  const subs = resource.resources || [];
+  const imports = /* @__PURE__ */ new Set();
+  const fieldLines = ["  private final Transport transport;"];
+  for (const sub of subs) fieldLines.push(`  private final ${serviceTypeName([...segments, sub.name])} ${camelCase(sub.name)};`);
+  const ctorLines = ["    this.transport = transport;"];
+  for (const sub of subs) {
+    ctorLines.push(`    this.${camelCase(sub.name)} = new ${serviceTypeName([...segments, sub.name])}(transport);`);
+  }
+  const ctor = `  ${cls}(Transport transport) {
+${ctorLines.join("\n")}
+  }`;
+  const accessors = subs.map(
+    (sub) => `  public ${serviceTypeName([...segments, sub.name])} ${camelCase(sub.name)}() {
+    return ${camelCase(sub.name)};
+  }`
+  );
+  const methods = (resource.methods || []).map((m) => methodDef(resource, segments, m, ctx, imports));
+  const doc = javaDoc(resource.description);
+  const head = doc ? `${doc}
+` : "";
+  const members = [fieldLines.join("\n"), ctor, ...accessors, ...methods].filter(Boolean).join("\n\n");
+  const body = `${head}public final class ${cls} {
+${members}
+}`;
+  return { path: `${ctx.srcDir}${cls}.java`, content: javaFile(ctx.fullPackage, [...imports], body) };
+}
+function methodDef(resource, segments, method, ctx, imports) {
+  var _a;
+  const plan = planOperation(method, ctx.types);
+  const name = javaMethodName(method.action);
+  const pathParams = plan.paramGroups.path;
+  const params = planParams(segments, method, plan, ctx);
+  const args = pathParams.map((p) => `${javaType(p.type, ctx.types)} ${camelCase(p.name)}`);
+  if (params) args.push(`${params.className} params`);
+  const lines = [];
+  for (const p of pathParams) {
+    if (((_a = p.type) == null ? void 0 : _a.kind) !== "scalar" || p.type.scalar !== "string") continue;
+    const n = camelCase(p.name);
+    lines.push(
+      `    if (${n} == null || ${n}.isEmpty()) {
+      throw new IllegalArgumentException(${JSON.stringify(`missing required ${p.name} parameter`)});
+    }`
+    );
+  }
+  lines.push(`    Transport.Request request = new Transport.Request(${JSON.stringify(method.httpMethod.toUpperCase())}, ${pathExpr(method.path, pathParams)});`);
+  if (plan.binaryContentType) {
+    lines.push(`    request.accept(${JSON.stringify(plan.binaryContentType)});`);
+  }
+  if (params) {
+    if (params.bodyFields.length > 0) {
+      imports.add("java.util.LinkedHashMap");
+      imports.add("java.util.Map");
+      lines.push("    Map<String, Object> body = new LinkedHashMap<>();");
+      for (const f of params.bodyFields) lines.push(bodyPut(f));
+      lines.push("    request.body(body);");
+      const encoding = methodEncoding(method, plan, ctx.types);
+      if (encoding !== "json") lines.push(`    request.encoding(${JSON.stringify(encoding)});`);
+    }
+    for (const q of params.query) lines.push(queryLine(q, ctx, imports));
+    for (const h of params.header) lines.push(headerLine(h));
+  }
+  const ret = returnPlan(method, plan, ctx);
+  lines.push(ret.statement);
+  const doc = javaDoc(method.description, "  ");
+  const head = doc ? `${doc}
+` : "";
+  return `${head}  public ${ret.type} ${name}(${args.join(", ")}) {
+${lines.join("\n")}
+  }`;
+}
+function bodyPut(field) {
+  const member = camelCase(field.name);
+  const key = JSON.stringify(field.name);
+  if (isConstField(field)) return `    body.put(${key}, ${constLiteral(field.type.const)});`;
+  if (field.required) return `    body.put(${key}, params.${member}());`;
+  return `    params.${member}().ifPresent(value -> body.put(${key}, value));`;
+}
+function queryLine(q, ctx, imports) {
+  const member = camelCase(q.name);
+  const key = q.wireName ?? q.name;
+  const wire = JSON.stringify(key);
+  const kind = queryKind(q.type, ctx.types);
+  const deepObject = q.style === "deepObject";
+  if (kind === "array") {
+    if (q.explode === false) {
+      imports.add("java.util.ArrayList");
+      imports.add("java.util.List");
+      const join = (values, indent) => `${indent}List<String> parts = new ArrayList<>();
+${indent}for (Object value : ${values}) {
+${indent}  parts.add(String.valueOf(value));
+${indent}}
+${indent}request.query(${wire}, String.join(",", parts));`;
+      if (q.required) return `    {
+${join(`params.${member}()`, "      ")}
+    }`;
+      return `    params.${member}().ifPresent(values -> {
+${join("values", "      ")}
+    });`;
+    }
+    if (q.required) {
+      return `    for (Object value : params.${member}()) {
+      request.query(${wire}, String.valueOf(value));
+    }`;
+    }
+    return `    params.${member}().ifPresent(values -> {
+      for (Object value : values) {
+        request.query(${wire}, String.valueOf(value));
+      }
+    });`;
+  }
+  if (kind === "map") {
+    if (deepObject) {
+      const sub = JSON.stringify(`${key}[`);
+      const forEach = `forEach((mapKey, mapValue) -> request.query(${sub} + mapKey + "]", String.valueOf(mapValue)))`;
+      if (q.required) return `    params.${member}().${forEach};`;
+      return `    params.${member}().ifPresent(entries -> entries.${forEach});`;
+    }
+    if (q.required) return `    request.query(${wire}, Json.encode(params.${member}()));`;
+    return `    params.${member}().ifPresent(value -> request.query(${wire}, Json.encode(value)));`;
+  }
+  if (kind === "object") {
+    if (q.required) return `    request.query(${wire}, Json.encode(params.${member}()));`;
+    return `    params.${member}().ifPresent(value -> request.query(${wire}, Json.encode(value)));`;
+  }
+  if (q.required) return `    request.query(${wire}, String.valueOf(params.${member}()));`;
+  return `    params.${member}().ifPresent(value -> request.query(${wire}, String.valueOf(value)));`;
+}
+function headerLine(h) {
+  const member = camelCase(h.name);
+  const wire = JSON.stringify(h.wireName ?? h.name);
+  if (h.required) return `    request.header(${wire}, String.valueOf(params.${member}()));`;
+  return `    params.${member}().ifPresent(value -> request.header(${wire}, String.valueOf(value)));`;
+}
+function returnPlan(method, plan, ctx) {
+  var _a, _b;
+  if (plan.binaryContentType) return { type: "byte[]", statement: "    return transport.executeRaw(request);" };
+  if (plan.pageName) {
+    const item = javaType((_a = method.pagination) == null ? void 0 : _a.itemType, ctx.types);
+    const decode = javaDecode((_b = method.pagination) == null ? void 0 : _b.itemType, "__e", ctx.types, 1);
+    return {
+      type: `${plan.pageName}<${item}>`,
+      statement: `    return ${plan.pageName}.fromJson(transport.execute(request), __e -> ${decode});`
+    };
+  }
+  const primary = plan.method.primaryResponse;
+  if (!primary || plan.primaryResponse === "none") {
+    return { type: "void", statement: "    transport.execute(request);" };
+  }
+  const type = javaType(primary, ctx.types);
+  const decoded = javaDecode(primary, "transport.execute(request)", ctx.types);
+  return { type, statement: `    return ${decoded};` };
+}
+function pathExpr(path2, pathParams) {
+  const normalized = path2.startsWith("/") ? path2 : `/${path2}`;
+  if (!normalized.includes("{")) return JSON.stringify(normalized);
+  const byName = new Map(pathParams.map((p) => [p.name, camelCase(p.name)]));
+  const parts = [];
+  const regex = /\{([^}]+)\}/g;
+  let last = 0;
+  let match = regex.exec(normalized);
+  while (match !== null) {
+    const literal = normalized.slice(last, match.index);
+    if (literal) parts.push(JSON.stringify(literal));
+    const member = byName.get(match[1]) ?? camelCase(match[1]);
+    parts.push(`Transport.encodePath(${member})`);
+    last = match.index + match[0].length;
+    match = regex.exec(normalized);
+  }
+  const tail = normalized.slice(last);
+  if (tail) parts.push(JSON.stringify(tail));
+  return parts.join(" + ");
+}
+function paramsFile2(resource, segments, method, ctx) {
+  const plan = planOperation(method, ctx.types);
+  const params = planParams(segments, method, plan, ctx);
+  if (!params) return null;
+  const slots = [];
+  for (const f of params.bodyFields) {
+    if (isConstField(f)) continue;
+    slots.push({ member: camelCase(f.name), type: javaType(f.type, ctx.types), required: !!f.required });
+  }
+  for (const p of [...params.query, ...params.header]) {
+    slots.push({ member: camelCase(p.name), type: javaType(p.type, ctx.types), required: !!p.required });
+  }
+  const imports = [];
+  if (slots.some((s) => !s.required)) imports.push("java.util.Optional");
+  if (slots.some((s) => s.type.includes("List<"))) imports.push("java.util.List");
+  if (slots.some((s) => s.type.includes("Map<"))) imports.push("java.util.Map");
+  const fieldDecls = slots.map((s) => `  private final ${s.type} ${s.member};`).join("\n");
+  const ctorAssigns = slots.map((s) => `    this.${s.member} = builder.${s.member};`).join("\n");
+  const accessors = slots.map(
+    (s) => s.required ? `  public ${s.type} ${s.member}() {
+    return ${s.member};
+  }` : `  public Optional<${s.type}> ${s.member}() {
+    return Optional.ofNullable(${s.member});
+  }`
+  ).join("\n\n");
+  const builderFields = slots.map((s) => `    private ${s.type} ${s.member};`).join("\n");
+  const setters = slots.map(
+    (s) => `    public Builder ${s.member}(${s.type} ${s.member}) {
+      this.${s.member} = ${s.member};
+      return this;
+    }`
+  ).join("\n\n");
+  const requiredChecks = slots.filter((s) => s.required).map(
+    (s) => `      if (${s.member} == null) {
+        throw new IllegalStateException(${JSON.stringify(`${s.member} is required`)});
+      }`
+  ).join("\n");
+  const build = `    public ${params.className} build() {
+` + (requiredChecks ? `${requiredChecks}
+` : "") + `      return new ${params.className}(this);
+    }`;
+  const builder = `  public static final class Builder {
+${builderFields}
+
+${setters}
+
+${build}
+  }`;
+  const doc = javaDoc(method.description ? `Parameters for ${javaMethodName(method.action)}: ${method.description}` : "");
+  const head = doc ? `${doc}
+` : "";
+  const body = `${head}public final class ${params.className} {
+${fieldDecls}
+
+  private ${params.className}(Builder builder) {
+${ctorAssigns}
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+${accessors}
+
+${builder}
+}`;
+  return { path: `${ctx.srcDir}${params.className}.java`, content: javaFile(ctx.fullPackage, imports, body) };
+}
+
+// src/runtime.ts
+var B = "\\";
+function runtimeFiles(spec, ctx) {
+  const plans = walkMethods(spec).map(({ method }) => planOperation2(method, ctx.types));
+  const needsForm = walkMethods(spec).some(({ method }) => methodEncoding(method, planOperation2(method, ctx.types), ctx.types) !== "json");
+  const pageKinds = new Set(plans.map((p) => p.pageName).filter((p) => p !== null));
+  const files = [
+    { path: `${ctx.srcDir}Json.java`, content: javaFile(ctx.fullPackage, JSON_IMPORTS, jsonBody()) },
+    ...errorFiles(ctx),
+    { path: `${ctx.srcDir}Transport.java`, content: javaFile(ctx.fullPackage, transportImports(needsForm), transportBody(ctx, needsForm)) }
+  ];
+  for (const kind of pageKinds) files.push(pageFile(kind, ctx));
+  return files;
+}
+var JSON_IMPORTS = ["java.util.ArrayList", "java.util.LinkedHashMap", "java.util.List", "java.util.Map"];
+function jsonBody() {
+  return `/**
+ * A tiny, dependency-free JSON codec. The encoder walks Maps, Lists, Strings,
+ * Numbers, Booleans and the generated JsonSerializable / JsonEnum types; the
+ * parser is a small recursive-descent reader producing Map / List / String /
+ * Long / Double / Boolean / null. Coercion helpers ({@link #asString} etc.) and
+ * the element-mapping helpers ({@link #mapList} / {@link #mapValues}) drive the
+ * generated models' fromJson / toJsonMap.
+ */
+public final class Json {
+  private Json() {
+  }
+
+  /** Implemented by generated models so the encoder can serialize them. */
+  public interface JsonSerializable {
+    Map<String, Object> toJsonMap();
+  }
+
+  /** Implemented by generated enums so the encoder can serialize their wire value. */
+  public interface JsonEnum {
+    Object jsonValue();
+  }
+
+  /** Maps a parsed-JSON element to a typed value (list/map element decoding). */
+  public interface Mapper<T> {
+    T apply(Object value);
+  }
+
+  // ---- encode --------------------------------------------------------------
+
+  public static String encode(Object value) {
+    StringBuilder sb = new StringBuilder();
+    write(sb, value);
+    return sb.toString();
+  }
+
+  private static void write(StringBuilder sb, Object value) {
+    if (value == null) {
+      sb.append("null");
+    } else if (value instanceof String) {
+      writeString(sb, (String) value);
+    } else if (value instanceof Boolean) {
+      sb.append(value.toString());
+    } else if (value instanceof Number) {
+      sb.append(writeNumber((Number) value));
+    } else if (value instanceof JsonEnum) {
+      write(sb, ((JsonEnum) value).jsonValue());
+    } else if (value instanceof JsonSerializable) {
+      write(sb, ((JsonSerializable) value).toJsonMap());
+    } else if (value instanceof Map) {
+      writeObject(sb, (Map<?, ?>) value);
+    } else if (value instanceof Iterable) {
+      writeArray(sb, (Iterable<?>) value);
+    } else {
+      writeString(sb, value.toString());
+    }
+  }
+
+  private static String writeNumber(Number number) {
+    if (number instanceof Double || number instanceof Float) {
+      double d = number.doubleValue();
+      if (d == Math.floor(d) && !Double.isInfinite(d)) {
+        return Long.toString((long) d);
+      }
+      return Double.toString(d);
+    }
+    return number.toString();
+  }
+
+  private static void writeObject(StringBuilder sb, Map<?, ?> map) {
+    sb.append('{');
+    boolean first = true;
+    for (Map.Entry<?, ?> entry : map.entrySet()) {
+      if (!first) {
+        sb.append(',');
+      }
+      first = false;
+      writeString(sb, String.valueOf(entry.getKey()));
+      sb.append(':');
+      write(sb, entry.getValue());
+    }
+    sb.append('}');
+  }
+
+  private static void writeArray(StringBuilder sb, Iterable<?> items) {
+    sb.append('[');
+    boolean first = true;
+    for (Object item : items) {
+      if (!first) {
+        sb.append(',');
+      }
+      first = false;
+      write(sb, item);
+    }
+    sb.append(']');
+  }
+
+  private static void writeString(StringBuilder sb, String value) {
+    sb.append('"');
+    for (int i = 0; i < value.length(); i++) {
+      char c = value.charAt(i);
+      if (c == '"' || c == '${B}${B}') {
+        sb.append('${B}${B}').append(c);
+      } else if (c == '${B}n') {
+        sb.append('${B}${B}').append('n');
+      } else if (c == '${B}r') {
+        sb.append('${B}${B}').append('r');
+      } else if (c == '${B}t') {
+        sb.append('${B}${B}').append('t');
+      } else if (c < 0x20) {
+        sb.append(String.format("${B}${B}u%04x", (int) c));
+      } else {
+        sb.append(c);
+      }
+    }
+    sb.append('"');
+  }
+
+  // ---- parse ---------------------------------------------------------------
+
+  public static Object parse(String text) {
+    return new Parser(text).parseDocument();
+  }
+
+  // ---- coercion ------------------------------------------------------------
+
+  public static String asString(Object value) {
+    return value == null ? null : value.toString();
+  }
+
+  public static Long asLong(Object value) {
+    if (value == null) {
+      return null;
+    }
+    if (value instanceof Number) {
+      return ((Number) value).longValue();
+    }
+    return Long.parseLong(value.toString());
+  }
+
+  public static Double asDouble(Object value) {
+    if (value == null) {
+      return null;
+    }
+    if (value instanceof Number) {
+      return ((Number) value).doubleValue();
+    }
+    return Double.parseDouble(value.toString());
+  }
+
+  public static Boolean asBoolean(Object value) {
+    if (value == null) {
+      return null;
+    }
+    if (value instanceof Boolean) {
+      return (Boolean) value;
+    }
+    return Boolean.parseBoolean(value.toString());
+  }
+
+  public static byte[] asBytes(Object value) {
+    if (value == null) {
+      return null;
+    }
+    if (value instanceof byte[]) {
+      return (byte[]) value;
+    }
+    return value.toString().getBytes(java.nio.charset.StandardCharsets.UTF_8);
+  }
+
+  public static <T> List<T> mapList(Object raw, Mapper<T> mapper) {
+    if (!(raw instanceof List)) {
+      return null;
+    }
+    List<?> source = (List<?>) raw;
+    List<T> out = new ArrayList<>(source.size());
+    for (Object item : source) {
+      out.add(mapper.apply(item));
+    }
+    return out;
+  }
+
+  public static <T> Map<String, T> mapValues(Object raw, Mapper<T> mapper) {
+    if (!(raw instanceof Map)) {
+      return null;
+    }
+    Map<?, ?> source = (Map<?, ?>) raw;
+    Map<String, T> out = new LinkedHashMap<>();
+    for (Map.Entry<?, ?> entry : source.entrySet()) {
+      out.put(String.valueOf(entry.getKey()), mapper.apply(entry.getValue()));
+    }
+    return out;
+  }
+
+  // ---- recursive-descent parser -------------------------------------------
+
+  private static final class Parser {
+    private final String s;
+    private int i;
+
+    Parser(String s) {
+      this.s = s;
+    }
+
+    Object parseDocument() {
+      skipWhitespace();
+      Object value = parseValue();
+      skipWhitespace();
+      return value;
+    }
+
+    private Object parseValue() {
+      skipWhitespace();
+      char c = peek();
+      switch (c) {
+        case '{':
+          return parseObject();
+        case '[':
+          return parseArray();
+        case '"':
+          return parseString();
+        case 't':
+        case 'f':
+          return parseBoolean();
+        case 'n':
+          return parseNull();
+        default:
+          return parseNumber();
+      }
+    }
+
+    private Map<String, Object> parseObject() {
+      Map<String, Object> out = new LinkedHashMap<>();
+      expect('{');
+      skipWhitespace();
+      if (peek() == '}') {
+        i++;
+        return out;
+      }
+      while (true) {
+        skipWhitespace();
+        String key = parseString();
+        skipWhitespace();
+        expect(':');
+        out.put(key, parseValue());
+        skipWhitespace();
+        char c = next();
+        if (c == '}') {
+          break;
+        }
+        if (c != ',') {
+          throw error("expected ',' or '}'");
+        }
+      }
+      return out;
+    }
+
+    private List<Object> parseArray() {
+      List<Object> out = new ArrayList<>();
+      expect('[');
+      skipWhitespace();
+      if (peek() == ']') {
+        i++;
+        return out;
+      }
+      while (true) {
+        out.add(parseValue());
+        skipWhitespace();
+        char c = next();
+        if (c == ']') {
+          break;
+        }
+        if (c != ',') {
+          throw error("expected ',' or ']'");
+        }
+      }
+      return out;
+    }
+
+    private String parseString() {
+      expect('"');
+      StringBuilder sb = new StringBuilder();
+      while (true) {
+        char c = next();
+        if (c == '"') {
+          break;
+        }
+        if (c == '${B}${B}') {
+          char esc = next();
+          switch (esc) {
+            case '"':
+              sb.append('"');
+              break;
+            case '${B}${B}':
+              sb.append('${B}${B}');
+              break;
+            case '/':
+              sb.append('/');
+              break;
+            case 'n':
+              sb.append('${B}n');
+              break;
+            case 'r':
+              sb.append('${B}r');
+              break;
+            case 't':
+              sb.append('${B}t');
+              break;
+            case 'b':
+              sb.append('${B}b');
+              break;
+            case 'f':
+              sb.append('${B}f');
+              break;
+            case 'u':
+              String hex = s.substring(i, i + 4);
+              i += 4;
+              sb.append((char) Integer.parseInt(hex, 16));
+              break;
+            default:
+              throw error("invalid escape: ${B}${B}" + esc);
+          }
+        } else {
+          sb.append(c);
+        }
+      }
+      return sb.toString();
+    }
+
+    private Object parseNumber() {
+      int start = i;
+      while (i < s.length() && isNumberChar(s.charAt(i))) {
+        i++;
+      }
+      String token = s.substring(start, i);
+      if (token.isEmpty()) {
+        throw error("invalid token");
+      }
+      if (token.indexOf('.') >= 0 || token.indexOf('e') >= 0 || token.indexOf('E') >= 0) {
+        return Double.parseDouble(token);
+      }
+      try {
+        return Long.parseLong(token);
+      } catch (NumberFormatException ex) {
+        return Double.parseDouble(token);
+      }
+    }
+
+    private Boolean parseBoolean() {
+      if (s.startsWith("true", i)) {
+        i += 4;
+        return Boolean.TRUE;
+      }
+      if (s.startsWith("false", i)) {
+        i += 5;
+        return Boolean.FALSE;
+      }
+      throw error("invalid literal");
+    }
+
+    private Object parseNull() {
+      if (s.startsWith("null", i)) {
+        i += 4;
+        return null;
+      }
+      throw error("invalid literal");
+    }
+
+    private boolean isNumberChar(char c) {
+      return (c >= '0' && c <= '9') || c == '-' || c == '+' || c == '.' || c == 'e' || c == 'E';
+    }
+
+    private void skipWhitespace() {
+      while (i < s.length()) {
+        char c = s.charAt(i);
+        if (c == ' ' || c == '${B}t' || c == '${B}n' || c == '${B}r') {
+          i++;
+        } else {
+          break;
+        }
+      }
+    }
+
+    private char peek() {
+      if (i >= s.length()) {
+        throw error("unexpected end of input");
+      }
+      return s.charAt(i);
+    }
+
+    private char next() {
+      if (i >= s.length()) {
+        throw error("unexpected end of input");
+      }
+      return s.charAt(i++);
+    }
+
+    private void expect(char expected) {
+      char actual = next();
+      if (actual != expected) {
+        throw error("expected '" + expected + "' but found '" + actual + "'");
+      }
+    }
+
+    private RuntimeException error(String message) {
+      return new IllegalArgumentException("JSON parse error at " + i + ": " + message);
+    }
+  }
+}`;
+}
+function errorFiles(ctx) {
+  const { statusCodeMap, clientErrorKind, serverErrorKind } = ctx.behavior.errors;
+  const mapped = Object.entries(statusCodeMap).map(([status, kind]) => [Number(status), kind]).filter(([status]) => Number.isFinite(status)).sort((a, b) => a[0] - b[0]);
+  const byClass = /* @__PURE__ */ new Map();
+  for (const [status, kind] of mapped) {
+    const cls = errorClassName(kind);
+    if (!cls) continue;
+    const entry = byClass.get(cls) ?? { kind, statuses: [] };
+    entry.statuses.push(status);
+    byClass.set(cls, entry);
+  }
+  const serverCls = errorClassName(serverErrorKind);
+  if (serverCls && !byClass.has(serverCls)) byClass.set(serverCls, { kind: serverErrorKind, statuses: [] });
+  const clientCls = errorClassName(clientErrorKind);
+  if (clientCls && !byClass.has(clientCls)) byClass.set(clientCls, { kind: clientErrorKind, statuses: [] });
+  const files = [
+    { path: `${ctx.srcDir}ApiException.java`, content: javaFile(ctx.fullPackage, [], apiExceptionBody(mapped, serverErrorKind, clientErrorKind)) }
+  ];
+  for (const [cls, { kind, statuses }] of byClass) {
+    files.push({ path: `${ctx.srcDir}${cls}.java`, content: javaFile(ctx.fullPackage, [], subclassBody(cls, kind, statuses)) });
+  }
+  return files;
+}
+function errorClassName(kind) {
+  if (kind === "API") return null;
+  return `${pascalCase(kind)}Exception`;
+}
+function apiExceptionBody(mapped, serverKind, clientKind) {
+  const cases = mapped.map(([status, kind]) => {
+    const cls = errorClassName(kind);
+    const expr = cls ? `new ${cls}(statusCode, message, rawBody, requestId)` : `new ApiException(statusCode, message, rawBody, requestId, ${JSON.stringify(kind)})`;
+    return `      case ${status}:
+        return ${expr};`;
+  }).join("\n");
+  const switchBlock = mapped.length ? `    switch (statusCode) {
+${cases}
+    }
+` : "";
+  const serverCls = errorClassName(serverKind);
+  const serverBranch = serverCls ? `    if (statusCode >= 500) {
+      return new ${serverCls}(statusCode, message, rawBody, requestId);
+    }
+` : "";
+  const clientCls = errorClassName(clientKind);
+  const clientReturn = clientCls ? `    return new ${clientCls}(statusCode, message, rawBody, requestId);` : `    return new ApiException(statusCode, message, rawBody, requestId, ${JSON.stringify(clientKind)});`;
+  return `/**
+ * A non-2xx API response: the HTTP status, a best-effort message, the raw body
+ * bytes, the server-assigned request id (from the configured request-id header)
+ * and the policy error kind. Mapped statuses arrive as a concrete subclass
+ * (e.g. {@link NotFoundException}) via {@link #of}.
+ */
+public class ApiException extends RuntimeException {
+  private final int statusCode;
+  private final byte[] rawBody;
+  private final String requestId;
+  private final String kind;
+
+  public ApiException(int statusCode, String message) {
+    this(statusCode, message, new byte[0], null, "API");
+  }
+
+  protected ApiException(int statusCode, String message, byte[] rawBody, String requestId, String kind) {
+    super(message);
+    this.statusCode = statusCode;
+    this.rawBody = rawBody == null ? new byte[0] : rawBody;
+    this.requestId = requestId;
+    this.kind = kind;
+  }
+
+  public int statusCode() {
+    return statusCode;
+  }
+
+  public byte[] rawBody() {
+    return rawBody;
+  }
+
+  /** The server-assigned request id (sdk.telemetry.requestIdHeader), or null. */
+  public String requestId() {
+    return requestId;
+  }
+
+  /** The status-mapped error kind (sdk.errors), e.g. "NotFound" or "API". */
+  public String kind() {
+    return kind;
+  }
+
+  /** Dispatch a non-2xx response to its status-mapped exception kind (sdk.errors). */
+  public static ApiException of(int statusCode, String message, byte[] rawBody, String requestId) {
+${switchBlock}${serverBranch}${clientReturn}
+  }
+}`;
+}
+function subclassBody(cls, kind, statuses) {
+  const reason = statuses.length ? `HTTP ${statuses.join("/")} responses` : `unmapped ${cls.includes("Internal") ? "5xx" : "error"} responses`;
+  return `/** The ${JSON.stringify(kind)} error kind (${reason}). */
+public final class ${cls} extends ApiException {
+  public ${cls}(int statusCode, String message, byte[] rawBody, String requestId) {
+    super(statusCode, message, rawBody, requestId, ${JSON.stringify(kind)});
+  }
+}`;
+}
+function pageFile(kind, ctx) {
+  const imports = ["java.util.ArrayList", "java.util.LinkedHashMap", "java.util.List", "java.util.Map"];
+  const decodeData = `    Map<?, ?> map = json instanceof Map ? (Map<?, ?>) json : new LinkedHashMap<>();
+    List<T> data = Json.mapList(map.get("data"), mapper);
+    if (data == null) {
+      data = new ArrayList<>();
+    }`;
+  if (kind === "Page") {
+    const body2 = `/** One page of a marker-less list: the whole collection in one \`data\` envelope. */
+public final class Page<T> {
+  private final List<T> data;
+
+  private Page(List<T> data) {
+    this.data = data;
+  }
+
+  /** The items in this page. */
+  public List<T> data() {
+    return data;
+  }
+
+  /** Decode a {data:[...]} envelope, mapping each item with the supplied mapper. */
+  public static <T> Page<T> fromJson(Object json, Json.Mapper<T> mapper) {
+${decodeData}
+    return new Page<>(data);
+  }
+}`;
+    return { path: `${ctx.srcDir}Page.java`, content: javaFile(ctx.fullPackage, imports, body2) };
+  }
+  const marker = kind === "CursorPage" ? "a cursor-paginated list: `data` plus a `has_more` marker" : "an offset-paginated list: `data` plus an optional `has_more` marker";
+  const body = `/** One page of ${marker}. */
+public final class ${kind}<T> {
+  private final List<T> data;
+  private final boolean hasMore;
+
+  private ${kind}(List<T> data, boolean hasMore) {
+    this.data = data;
+    this.hasMore = hasMore;
+  }
+
+  /** The items in this page. */
+  public List<T> data() {
+    return data;
+  }
+
+  /** Whether the server reports more pages after this one. */
+  public boolean hasMore() {
+    return hasMore;
+  }
+
+  /** Decode a {data:[...], has_more:bool} envelope, mapping each item with the supplied mapper. */
+  public static <T> ${kind}<T> fromJson(Object json, Json.Mapper<T> mapper) {
+${decodeData}
+    Boolean hasMore = Json.asBoolean(map.get("has_more"));
+    return new ${kind}<>(data, hasMore != null && hasMore);
+  }
+}`;
+  return { path: `${ctx.srcDir}${kind}.java`, content: javaFile(ctx.fullPackage, imports, body) };
+}
+function transportImports(needsForm) {
+  const imports = [
+    "java.net.URI",
+    "java.net.URLEncoder",
+    "java.net.http.HttpClient",
+    "java.net.http.HttpRequest",
+    "java.net.http.HttpResponse",
+    "java.nio.charset.StandardCharsets",
+    "java.time.Duration",
+    "java.util.ArrayList",
+    "java.util.LinkedHashMap",
+    "java.util.List",
+    "java.util.Map"
+  ];
+  if (needsForm) imports.push("java.io.ByteArrayOutputStream", "java.io.IOException", "java.util.UUID");
+  return imports;
+}
+function javaMs(ms) {
+  return `${ms}L`;
+}
+function javaDouble(value) {
+  return Number.isInteger(value) ? `${value}.0` : String(value);
+}
+function transportBody(ctx, needsForm) {
+  const authHeader = authHeaderBlock(ctx);
+  const authQuery = authQueryBlock(ctx);
+  const { retry, timeout, userAgent, telemetry } = ctx.behavior;
+  const statuses = retry.retryableStatusCodes;
+  const statusSet = statuses.length ? `java.util.Set.of(${statuses.join(", ")})` : "java.util.Collections.<Integer>emptySet()";
+  const timeoutBlock = timeout.timeoutEnvVar ? `  private static final long DEFAULT_TIMEOUT_MS = resolveTimeoutMs();
+
+  /** The default per-request timeout (sdk.timeout), overridable via the ${timeout.timeoutEnvVar} env var (ms). */
+  private static long resolveTimeoutMs() {
+    String raw = System.getenv(${JSON.stringify(timeout.timeoutEnvVar)});
+    if (raw != null && !raw.isEmpty()) {
+      try {
+        long ms = Long.parseLong(raw);
+        if (ms >= 0) {
+          return ms;
+        }
+      } catch (NumberFormatException ignored) {
+        // fall through to the default
+      }
+    }
+    return ${javaMs(timeout.defaultTimeoutMs)};
+  }` : `  private static final long DEFAULT_TIMEOUT_MS = ${javaMs(timeout.defaultTimeoutMs)};`;
+  const agents = Object.entries(userAgent.aiAgentEnvVars);
+  const runtimeLine = userAgent.includeRuntimeVersion ? `    ua = ua + " java/" + System.getProperty("java.version");
+` : "";
+  const agentBlock = agents.length > 0 ? `    String[][] agents = {
+` + agents.map(([envVar, slug]) => `      {${JSON.stringify(envVar)}, ${JSON.stringify(slug)}},`).join("\n") + `
+    };
+    for (String[] agent : agents) {
+      String value = System.getenv(agent[0]);
+      if (value != null && !value.isEmpty()) {
+        ua = ua + " agent/" + agent[1];
+        break;
+      }
+    }
+` : "";
+  const jsonEncode = `      payload = Json.encode(request.body).getBytes(StandardCharsets.UTF_8);
+      contentType = "application/json";`;
+  const encodeBranch = needsForm ? `      switch (request.encoding) {
+        case "multipart": {
+          Multipart multipart = encodeMultipart(asMap(request.body));
+          payload = multipart.body;
+          contentType = multipart.contentType;
+          break;
+        }
+        case "form":
+          payload = encodeForm(asMap(request.body));
+          contentType = "application/x-www-form-urlencoded";
+          break;
+        default:
+${jsonEncode.replace(/^ {6}/gm, "          ")}
+          break;
+      }` : jsonEncode;
+  const retryAfterHelper = retry.honorRetryAfterHeader ? `
+
+  /** The Retry-After delay in millis (delta-seconds or HTTP-date, capped at 60s), or -1 if absent. */
+  private static long retryAfterMs(HttpResponse<byte[]> response) {
+    String value = response.headers().firstValue("Retry-After").orElse(null);
+    if (value == null) {
+      return -1;
+    }
+    value = value.trim();
+    try {
+      long seconds = Long.parseLong(value);
+      if (seconds >= 0) {
+        return Math.min(seconds * 1000L, 60000L);
+      }
+    } catch (NumberFormatException ignored) {
+      // not a delta-seconds value; try the HTTP-date form
+    }
+    try {
+      java.time.ZonedDateTime when = java.time.ZonedDateTime.parse(value, java.time.format.DateTimeFormatter.RFC_1123_DATE_TIME);
+      long wait = Duration.between(java.time.ZonedDateTime.now(), when).toMillis();
+      if (wait > 0) {
+        return Math.min(wait, 60000L);
+      }
+    } catch (java.time.format.DateTimeParseException ignored) {
+      // unparseable Retry-After; fall back to backoff
+    }
+    return -1;
+  }` : "";
+  const retryAfterCall = retry.honorRetryAfterHeader ? `    if (HONOR_RETRY_AFTER_HEADER && response != null) {
+      long retryAfter = retryAfterMs(response);
+      if (retryAfter >= 0) {
+        return retryAfter;
+      }
+    }
+` : "";
+  const encodersBlock = needsForm ? `
+
+  @SuppressWarnings("unchecked")
+  private static Map<String, Object> asMap(Object value) {
+    return (Map<String, Object>) value;
+  }
+
+  /** application/x-www-form-urlencoded: repeated keys for list values, JSON for compound values. */
+  private static byte[] encodeForm(Map<String, Object> body) {
+    StringBuilder sb = new StringBuilder();
+    for (Map.Entry<String, Object> entry : body.entrySet()) {
+      Object value = entry.getValue();
+      if (value instanceof Iterable) {
+        for (Object item : (Iterable<?>) value) {
+          appendForm(sb, entry.getKey(), item);
+        }
+      } else {
+        appendForm(sb, entry.getKey(), value);
+      }
+    }
+    return sb.toString().getBytes(StandardCharsets.UTF_8);
+  }
+
+  private static void appendForm(StringBuilder sb, String key, Object value) {
+    if (sb.length() > 0) {
+      sb.append('&');
+    }
+    sb.append(encodeQuery(key)).append('=').append(encodeQuery(formValue(value)));
+  }
+
+  private static String formValue(Object value) {
+    if (value instanceof byte[]) {
+      return new String((byte[]) value, StandardCharsets.UTF_8);
+    }
+    if (value instanceof Map || value instanceof Iterable) {
+      return Json.encode(value);
+    }
+    return String.valueOf(value);
+  }
+
+  /** A hand-built multipart/form-data body: byte[] values become file parts, everything else a field. */
+  private static Multipart encodeMultipart(Map<String, Object> body) {
+    String boundary = "----opensdk" + UUID.randomUUID().toString().replace("-", "");
+    ByteArrayOutputStream out = new ByteArrayOutputStream();
+    try {
+      for (Map.Entry<String, Object> entry : body.entrySet()) {
+        Object value = entry.getValue();
+        if (value instanceof Iterable) {
+          for (Object item : (Iterable<?>) value) {
+            writePart(out, boundary, entry.getKey(), item);
+          }
+        } else {
+          writePart(out, boundary, entry.getKey(), value);
+        }
+      }
+      out.write(("--" + boundary + "--${B}r${B}n").getBytes(StandardCharsets.UTF_8));
+    } catch (IOException e) {
+      throw new ApiException(0, "multipart encoding failed: " + e.getMessage());
+    }
+    return new Multipart(out.toByteArray(), "multipart/form-data; boundary=" + boundary);
+  }
+
+  private static void writePart(ByteArrayOutputStream out, String boundary, String name, Object value) throws IOException {
+    out.write(("--" + boundary + "${B}r${B}n").getBytes(StandardCharsets.UTF_8));
+    if (value instanceof byte[]) {
+      out.write(("Content-Disposition: form-data; name=${B}"" + name + "${B}"; filename=${B}"" + name + "${B}"${B}r${B}n").getBytes(StandardCharsets.UTF_8));
+      out.write("Content-Type: application/octet-stream${B}r${B}n${B}r${B}n".getBytes(StandardCharsets.UTF_8));
+      out.write((byte[]) value);
+    } else {
+      out.write(("Content-Disposition: form-data; name=${B}"" + name + "${B}"${B}r${B}n${B}r${B}n").getBytes(StandardCharsets.UTF_8));
+      out.write(formValue(value).getBytes(StandardCharsets.UTF_8));
+    }
+    out.write("${B}r${B}n".getBytes(StandardCharsets.UTF_8));
+  }
+
+  private static final class Multipart {
+    final byte[] body;
+    final String contentType;
+
+    Multipart(byte[] body, String contentType) {
+      this.body = body;
+      this.contentType = contentType;
+    }
+  }` : "";
+  return `/**
+ * The HTTP transport: builds the URL + query + headers, attaches the configured
+ * credential, encodes the request body (json / multipart / form), performs the
+ * request via {@link java.net.http.HttpClient} with a policy-driven retry loop
+ * (sdk.retry) and default timeout (sdk.timeout), and maps a non-2xx response to
+ * a status-mapped {@link ApiException}. Dependency-free \u2014 java.net.http + the
+ * Json codec only.
+ */
+public final class Transport {
+  private static final String DEFAULT_BASE_URL = ${JSON.stringify(ctx.baseURL)};
+  private static final String USER_AGENT = userAgent();
+  private static final int MAX_RETRIES = ${retry.maxRetries};
+  private static final java.util.Set<Integer> RETRYABLE_STATUS_CODES = ${statusSet};
+  private static final boolean RETRY_CONNECTION_ERRORS = ${retry.retryConnectionErrors};
+  private static final boolean HONOR_RETRY_AFTER_HEADER = ${retry.honorRetryAfterHeader};
+  private static final long BACKOFF_INITIAL_DELAY_MS = ${javaMs(retry.backoff.initialDelayMs)};
+  private static final long BACKOFF_MAX_DELAY_MS = ${javaMs(retry.backoff.maxDelayMs)};
+  private static final double BACKOFF_MULTIPLIER = ${javaDouble(retry.backoff.multiplier)};
+  private static final double BACKOFF_JITTER = ${javaDouble(retry.backoff.jitter)};
+  private static final String REQUEST_ID_HEADER = ${JSON.stringify(telemetry.requestIdHeader)};
+${timeoutBlock}
+
+  private final String baseUrl;
+  private final String apiKey;
+  private final HttpClient http;
+
+  public Transport(String baseUrl, String apiKey) {
+    this.baseUrl = (baseUrl == null || baseUrl.isEmpty()) ? DEFAULT_BASE_URL : baseUrl;
+    this.apiKey = apiKey;
+    this.http = HttpClient.newHttpClient();
+  }
+
+  /** The SDK User-Agent (sdk.userAgent): the identifier plus an AI-agent slug when a known env var is set. */
+  private static String userAgent() {
+    String ua = ${JSON.stringify(ctx.userAgent)};
+${runtimeLine}${agentBlock}    return ua;
+  }
+
+  /** A single request, assembled by the generated service methods. */
+  public static final class Request {
+    final String method;
+    final String path;
+    final Map<String, List<String>> query = new LinkedHashMap<>();
+    final Map<String, String> headers = new LinkedHashMap<>();
+    Object body;
+    String encoding = "json";
+    String accept;
+
+    public Request(String method, String path) {
+      this.method = method;
+      this.path = path;
+    }
+
+    public Request query(String key, String value) {
+      query.computeIfAbsent(key, unused -> new ArrayList<>()).add(value);
+      return this;
+    }
+
+    public Request header(String key, String value) {
+      headers.put(key, value);
+      return this;
+    }
+
+    public Request body(Object value) {
+      this.body = value;
+      return this;
+    }
+
+    public Request encoding(String encoding) {
+      this.encoding = encoding;
+      return this;
+    }
+
+    public Request accept(String contentType) {
+      this.accept = contentType;
+      return this;
+    }
+  }
+
+  /** Perform the request and return the parsed JSON body (null for an empty body). */
+  public Object execute(Request request) {
+    HttpResponse<byte[]> response = send(request);
+    byte[] bytes = response.body();
+    if (bytes == null || bytes.length == 0) {
+      return null;
+    }
+    return Json.parse(new String(bytes, StandardCharsets.UTF_8));
+  }
+
+  /** Perform the request and return the raw response bytes (binary downloads). */
+  public byte[] executeRaw(Request request) {
+    return send(request).body();
+  }
+
+  private HttpResponse<byte[]> send(Request request) {
+    HttpRequest httpRequest = buildRequest(request);
+    int attempt = 0;
+    while (true) {
+      HttpResponse<byte[]> response;
+      try {
+        response = http.send(httpRequest, HttpResponse.BodyHandlers.ofByteArray());
+      } catch (java.io.IOException e) {
+        if (RETRY_CONNECTION_ERRORS && attempt < MAX_RETRIES) {
+          sleep(retryDelayMs(attempt, null));
+          attempt++;
+          continue;
+        }
+        throw new ApiException(0, "request failed: " + e.getMessage());
+      } catch (InterruptedException e) {
+        Thread.currentThread().interrupt();
+        throw new ApiException(0, "request interrupted: " + e.getMessage());
+      }
+      int status = response.statusCode();
+      if (status >= 400) {
+        if (attempt < MAX_RETRIES && RETRYABLE_STATUS_CODES.contains(status)) {
+          sleep(retryDelayMs(attempt, response));
+          attempt++;
+          continue;
+        }
+        byte[] body = response.body();
+        String requestId = response.headers().firstValue(REQUEST_ID_HEADER).orElse(null);
+        String message = errorMessage(body);
+        throw ApiException.of(status, message != null ? message : "HTTP " + status, body, requestId);
+      }
+      return response;
+    }
+  }
+
+  /** Assemble the immutable HttpRequest once (the body is encoded up front so retries replay the same bytes). */
+  private HttpRequest buildRequest(Request request) {
+    HttpRequest.Builder builder = HttpRequest.newBuilder().uri(URI.create(buildUrl(request)));
+    builder.header("User-Agent", USER_AGENT);
+    if (DEFAULT_TIMEOUT_MS > 0) {
+      builder.timeout(Duration.ofMillis(DEFAULT_TIMEOUT_MS));
+    }
+    if (request.accept != null) {
+      builder.header("Accept", request.accept);
+    }
+    for (Map.Entry<String, String> entry : request.headers.entrySet()) {
+      builder.header(entry.getKey(), entry.getValue());
+    }
+${authHeader}    if (request.body != null) {
+      byte[] payload;
+      String contentType;
+${encodeBranch}
+      builder.header("Content-Type", contentType);
+      builder.method(request.method, HttpRequest.BodyPublishers.ofByteArray(payload));
+    } else {
+      builder.method(request.method, HttpRequest.BodyPublishers.noBody());
+    }
+    return builder.build();
+  }
+
+  /** The delay before the next retry attempt: Retry-After when honored, else jittered exponential backoff (sdk.retry). */
+  private static long retryDelayMs(int attempt, HttpResponse<byte[]> response) {
+${retryAfterCall}    double delay = BACKOFF_INITIAL_DELAY_MS * Math.pow(BACKOFF_MULTIPLIER, attempt);
+    delay = Math.min(delay, BACKOFF_MAX_DELAY_MS);
+    return (long) (delay + delay * BACKOFF_JITTER * Math.random());
+  }${retryAfterHelper}
+
+  private static void sleep(long millis) {
+    if (millis <= 0) {
+      return;
+    }
+    try {
+      Thread.sleep(millis);
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt();
+    }
+  }
+
+  private String buildUrl(Request request) {
+    StringBuilder sb = new StringBuilder();
+    String trimmed = baseUrl.endsWith("/") ? baseUrl.substring(0, baseUrl.length() - 1) : baseUrl;
+    sb.append(trimmed);
+    sb.append(request.path.startsWith("/") ? request.path : "/" + request.path);
+    Map<String, List<String>> query = new LinkedHashMap<>(request.query);
+${authQuery}    if (!query.isEmpty()) {
+      sb.append('?');
+      boolean first = true;
+      for (Map.Entry<String, List<String>> entry : query.entrySet()) {
+        for (String value : entry.getValue()) {
+          sb.append(first ? "" : "&");
+          first = false;
+          sb.append(encodeQuery(entry.getKey())).append('=').append(encodeQuery(value));
+        }
+      }
+    }
+    return sb.toString();
+  }
+
+  /** URL-encode a path segment (spaces as %20, not '+'). */
+  public static String encodePath(String value) {
+    return URLEncoder.encode(value, StandardCharsets.UTF_8).replace("+", "%20");
+  }
+
+  private static String encodeQuery(String value) {
+    return URLEncoder.encode(value, StandardCharsets.UTF_8);
+  }
+
+  /** Best-effort message from a JSON error envelope ({"error": {"message": ...}} etc.). */
+  private static String errorMessage(byte[] body) {
+    if (body == null || body.length == 0) {
+      return null;
+    }
+    try {
+      Object parsed = Json.parse(new String(body, StandardCharsets.UTF_8));
+      if (parsed instanceof Map) {
+        Map<?, ?> map = (Map<?, ?>) parsed;
+        Object error = map.get("error");
+        if (error instanceof Map) {
+          Object message = ((Map<?, ?>) error).get("message");
+          if (message instanceof String) {
+            return (String) message;
+          }
+        }
+        if (error instanceof String) {
+          return (String) error;
+        }
+        for (String key : new String[] {"message", "detail"}) {
+          Object value = map.get(key);
+          if (value instanceof String) {
+            return (String) value;
+          }
+        }
+      }
+    } catch (RuntimeException ignored) {
+      // fall through to null
+    }
+    return null;
+  }${encodersBlock}
+}`;
+}
+function authHeaderBlock(ctx) {
+  const name = ctx.authName || "";
+  switch (ctx.authKind) {
+    case "bearer":
+      return `    if (apiKey != null) {
+      builder.header("Authorization", "Bearer " + apiKey);
+    }
+`;
+    case "apiKey-header":
+      return `    if (apiKey != null) {
+      builder.header(${JSON.stringify(name)}, apiKey);
+    }
+`;
+    case "apiKey-cookie":
+      return `    if (apiKey != null) {
+      builder.header("Cookie", ${JSON.stringify(`${name}=`)} + apiKey);
+    }
+`;
+    default:
+      return "";
+  }
+}
+function authQueryBlock(ctx) {
+  if (ctx.authKind !== "apiKey-query") return "";
+  const name = ctx.authName || "";
+  return `    if (apiKey != null) {
+      query.computeIfAbsent(${JSON.stringify(name)}, unused -> new ArrayList<>()).add(apiKey);
+    }
+`;
+}
+
+// src/emitter.ts
+var javaEmitter = {
+  language: "java",
+  fileHeader() {
+    return HEADER;
+  },
+  generateProject(spec, ctx) {
+    const jctx = resolveJavaOptions(spec, ctx);
+    return [{ path: "pom.xml", content: pomXml(jctx, spec), writeMode: "skipIfExists" }];
+  },
+  generateClient(spec, ctx) {
+    const jctx = resolveJavaOptions(spec, ctx);
+    return [{ path: `${jctx.srcDir}Client.java`, content: renderClientFile(spec, jctx) }];
+  },
+  generateTypes(types, ctx) {
+    const jctx = resolveJavaOptions(ctx.spec, ctx);
+    return renderTypeFiles(types, jctx);
+  },
+  generateResources(resources, ctx) {
+    const jctx = resolveJavaOptions(ctx.spec, ctx);
+    return renderResourceFiles(resources, jctx);
+  },
+  generateRuntime(spec, ctx) {
+    const jctx = resolveJavaOptions(spec, ctx);
+    return runtimeFiles(spec, jctx);
+  },
+  // The SDK's OWN dependency-free assertion test suite (one class per top-level
+  // resource, runnable with plain `java`). Default ON; opt out with
+  // emitterOptions.tests === false (same gate as the Go/Python emitters).
+  generateTests(spec, ctx) {
+    if (ctx.emitterOptions.tests === false) return [];
+    const jctx = resolveJavaOptions(spec, ctx);
+    return generateJavaTests(spec, jctx);
+  }
+};
+function opensdkJava(spec, options = {}) {
+  return generate(spec, javaEmitter, options);
+}
+
+// src/publish.ts
+import * as path from "path";
+import { runCommand } from "@xyd-js/opensdk-framework";
+function publishJava(dir, opts = {}) {
+  if (opts.dryRun) {
+    runCommand("mvn", ["-q", "-DskipTests", "package"], { cwd: dir });
+    return;
+  }
+  const args = ["-q", "-DskipTests", "deploy"];
+  if (opts.registry) {
+    const repo = /^\w+:\/\//.test(opts.registry) ? opts.registry : `file://${path.resolve(opts.registry)}`;
+    args.push(`-DaltDeploymentRepository=opensdk::default::${repo}`);
+  }
+  runCommand("mvn", args, { cwd: dir });
+}
+
+// src/index.ts
+import { writeProject } from "@xyd-js/opensdk-framework";
+export {
+  javaEmitter,
+  opensdkJava,
+  publishJava,
+  writeProject
+};
+//# sourceMappingURL=index.js.map