@abapify/openai-codegen 0.3.6 → 0.4.5

package/dist/generate-BobARM00.mjs

@@ -0,0 +1,2957 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import SwaggerParser from "@apidevtools/swagger-parser";
+import YAML from "yaml";
+import { createHash } from "node:crypto";
+import { assign, attributeDef, builtinType, call, classDef, comment, enumType, identifierExpr, interfaceDef, literal, methodDef, methodImpl, methodParam, namedTypeRef, print, raw, section, structureType, tableType, typeDef } from "@abapify/abap-ast";
+import { join } from "node:path";
+
+//#region src/oas/types.ts
+function isRef(x) {
+	return typeof x === "object" && x !== null && typeof x.$ref === "string";
+}
+
+//#endregion
+//#region src/oas/load.ts
+const HTTP_METHODS = [
+	"get",
+	"post",
+	"put",
+	"patch",
+	"delete",
+	"head",
+	"options",
+	"trace"
+];
+function isRecord$4(x) {
+	return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function asString(x) {
+	return typeof x === "string" ? x : void 0;
+}
+function asBool(x, fallback) {
+	return typeof x === "boolean" ? x : fallback;
+}
+function asArray(x) {
+	return Array.isArray(x) ? x : [];
+}
+function asStringArray(x) {
+	return asArray(x).filter((v) => typeof v === "string");
+}
+/**
+* Load and normalize an OpenAPI 3.x spec from a file path, URL, or in-memory
+* object. YAML files (`.yaml` / `.yml`) are read manually with the `yaml`
+* library first so we always hand SwaggerParser a parsed object — this keeps
+* our behaviour identical for local files and in-memory inputs.
+*/
+async function loadSpec(input) {
+	let raw;
+	if (typeof input === "string" && /\.ya?ml$/i.test(input)) {
+		const text = await readFile(input, "utf8");
+		raw = YAML.parse(text);
+	} else if (input instanceof URL) raw = input.toString();
+	else raw = input;
+	const namedSchemas = extractComponentSchemas(raw);
+	let validated;
+	try {
+		const parserInput = typeof raw === "string" ? raw : structuredClone(raw);
+		validated = await SwaggerParser.validate(parserInput);
+	} catch (err) {
+		throw formatValidationError(err);
+	}
+	return normalizeSpec(await SwaggerParser.dereference(validated), namedSchemas);
+}
+function formatValidationError(err) {
+	if (err instanceof Error) {
+		const details = err.details;
+		if (Array.isArray(details) && details.length > 0) {
+			const top = details.slice(0, 3).map((d, i) => {
+				const msg = isRecord$4(d) && typeof d.message === "string" ? d.message : String(d);
+				return `  ${i + 1}. ${msg}`;
+			}).join("\n");
+			return /* @__PURE__ */ new Error(`OpenAPI spec validation failed:\n${top}`);
+		}
+		return /* @__PURE__ */ new Error(`OpenAPI spec validation failed: ${err.message}`);
+	}
+	return /* @__PURE__ */ new Error(`OpenAPI spec validation failed: ${String(err)}`);
+}
+function extractComponentSchemas(raw) {
+	const out = {};
+	if (!isRecord$4(raw)) return out;
+	const components = raw.components;
+	if (!isRecord$4(components)) return out;
+	const schemas = components.schemas;
+	if (!isRecord$4(schemas)) return out;
+	for (const [name, schema] of Object.entries(schemas)) if (isRecord$4(schema)) out[name] = schema;
+	return out;
+}
+/**
+* Normalize a (presumed-dereferenced) OpenAPI document into our internal
+* shape. Callers who already have a dereferenced spec may invoke this
+* directly.
+*/
+function normalizeSpec(dereferenced, namedSchemas = {}) {
+	if (!isRecord$4(dereferenced)) throw new Error("normalizeSpec: input must be an object");
+	const openapiVersion = asString(dereferenced.openapi) ?? "";
+	const info = normalizeInfo(dereferenced.info);
+	const servers = normalizeServers(dereferenced.servers);
+	const securitySchemes = normalizeSecuritySchemes(isRecord$4(dereferenced.components) ? dereferenced.components.securitySchemes : void 0);
+	const topLevelSecurity = normalizeSecurityRequirements(dereferenced.security);
+	const operations = normalizeOperations(dereferenced.paths, topLevelSecurity);
+	const schemas = Object.keys(namedSchemas).length > 0 ? namedSchemas : extractComponentSchemas(dereferenced);
+	return Object.freeze({
+		openapiVersion,
+		info,
+		servers,
+		operations,
+		schemas,
+		securitySchemes
+	});
+}
+function normalizeInfo(raw) {
+	if (!isRecord$4(raw)) return {
+		title: "",
+		version: ""
+	};
+	const info = {
+		title: asString(raw.title) ?? "",
+		version: asString(raw.version) ?? ""
+	};
+	const description = asString(raw.description);
+	if (description !== void 0) info.description = description;
+	const tos = asString(raw.termsOfService);
+	if (tos !== void 0) info.termsOfService = tos;
+	if (isRecord$4(raw.contact)) {
+		const contact = {};
+		const name = asString(raw.contact.name);
+		if (name !== void 0) contact.name = name;
+		const url = asString(raw.contact.url);
+		if (url !== void 0) contact.url = url;
+		const email = asString(raw.contact.email);
+		if (email !== void 0) contact.email = email;
+		info.contact = contact;
+	}
+	if (isRecord$4(raw.license)) {
+		const license = { name: asString(raw.license.name) ?? "" };
+		const url = asString(raw.license.url);
+		if (url !== void 0) license.url = url;
+		const id = asString(raw.license.identifier);
+		if (id !== void 0) license.identifier = id;
+		info.license = license;
+	}
+	return info;
+}
+function normalizeServers(raw) {
+	return asArray(raw).filter(isRecord$4).map((s) => {
+		const url = asString(s.url) ?? "";
+		const variables = {};
+		if (isRecord$4(s.variables)) for (const [k, v] of Object.entries(s.variables)) {
+			if (!isRecord$4(v)) continue;
+			const variable = { default: asString(v.default) ?? "" };
+			const enums = asStringArray(v.enum);
+			if (enums.length > 0) variable.enum = enums;
+			const desc = asString(v.description);
+			if (desc !== void 0) variable.description = desc;
+			variables[k] = variable;
+		}
+		const server = {
+			url,
+			variables
+		};
+		const desc = asString(s.description);
+		if (desc !== void 0) server.description = desc;
+		return server;
+	});
+}
+function normalizeSecuritySchemes(raw) {
+	const out = {};
+	if (!isRecord$4(raw)) return out;
+	for (const [name, schemeRaw] of Object.entries(raw)) {
+		if (!isRecord$4(schemeRaw)) continue;
+		const type = asString(schemeRaw.type);
+		const description = asString(schemeRaw.description);
+		switch (type) {
+			case "apiKey": {
+				const inLoc = asString(schemeRaw.in);
+				if (inLoc !== "header" && inLoc !== "query" && inLoc !== "cookie") continue;
+				const scheme = {
+					type: "apiKey",
+					name: asString(schemeRaw.name) ?? name,
+					in: inLoc
+				};
+				if (description !== void 0) scheme.description = description;
+				out[name] = scheme;
+				break;
+			}
+			case "http": {
+				const scheme = {
+					type: "http",
+					scheme: asString(schemeRaw.scheme) ?? "bearer"
+				};
+				const bf = asString(schemeRaw.bearerFormat);
+				if (bf !== void 0) scheme.bearerFormat = bf;
+				if (description !== void 0) scheme.description = description;
+				out[name] = scheme;
+				break;
+			}
+			case "oauth2": {
+				const flowsRaw = isRecord$4(schemeRaw.flows) ? schemeRaw.flows : {};
+				const scheme = {
+					type: "oauth2",
+					flows: {}
+				};
+				for (const flowName of [
+					"implicit",
+					"password",
+					"clientCredentials",
+					"authorizationCode"
+				]) {
+					const f = flowsRaw[flowName];
+					if (!isRecord$4(f)) continue;
+					const flow = { scopes: {} };
+					if (isRecord$4(f.scopes)) {
+						for (const [k, v] of Object.entries(f.scopes)) if (typeof v === "string") flow.scopes[k] = v;
+					}
+					const au = asString(f.authorizationUrl);
+					if (au !== void 0) flow.authorizationUrl = au;
+					const tu = asString(f.tokenUrl);
+					if (tu !== void 0) flow.tokenUrl = tu;
+					const ru = asString(f.refreshUrl);
+					if (ru !== void 0) flow.refreshUrl = ru;
+					scheme.flows[flowName] = flow;
+				}
+				if (description !== void 0) scheme.description = description;
+				out[name] = scheme;
+				break;
+			}
+			case "openIdConnect": {
+				const url = asString(schemeRaw.openIdConnectUrl);
+				if (url === void 0) continue;
+				const scheme = {
+					type: "openIdConnect",
+					openIdConnectUrl: url
+				};
+				if (description !== void 0) scheme.description = description;
+				out[name] = scheme;
+				break;
+			}
+		}
+	}
+	return out;
+}
+function normalizeSecurityRequirements(raw) {
+	return asArray(raw).filter(isRecord$4).map((req) => {
+		const out = {};
+		for (const [k, v] of Object.entries(req)) out[k] = asStringArray(v);
+		return out;
+	});
+}
+function normalizeOperations(pathsRaw, topLevelSecurity) {
+	const ops = [];
+	if (!isRecord$4(pathsRaw)) return ops;
+	for (const [path, pathItemRaw] of Object.entries(pathsRaw)) {
+		if (!isRecord$4(pathItemRaw)) continue;
+		const pathLevelParams = normalizeParameters(pathItemRaw.parameters);
+		for (const method of HTTP_METHODS) {
+			const opRaw = pathItemRaw[method];
+			if (!isRecord$4(opRaw)) continue;
+			const parameters = mergeParameters(pathLevelParams, normalizeParameters(opRaw.parameters));
+			const op = {
+				operationId: asString(opRaw.operationId) ?? synthesizeOperationId(method, path),
+				method,
+				path,
+				tags: asStringArray(opRaw.tags),
+				deprecated: asBool(opRaw.deprecated, false),
+				parameters,
+				responses: normalizeResponses(opRaw.responses),
+				security: opRaw.security === void 0 ? topLevelSecurity : normalizeSecurityRequirements(opRaw.security)
+			};
+			const summary = asString(opRaw.summary);
+			if (summary !== void 0) op.summary = summary;
+			const description = asString(opRaw.description);
+			if (description !== void 0) op.description = description;
+			const requestBody = normalizeRequestBody(opRaw.requestBody);
+			if (requestBody !== void 0) op.requestBody = requestBody;
+			ops.push(op);
+		}
+	}
+	return ops;
+}
+function normalizeParameters(raw) {
+	return asArray(raw).filter(isRecord$4).map((p) => {
+		const inLoc = asString(p.in);
+		if (inLoc !== "path" && inLoc !== "query" && inLoc !== "header" && inLoc !== "cookie") return;
+		const name = asString(p.name);
+		if (name === void 0) return void 0;
+		const param = {
+			name,
+			in: inLoc,
+			required: inLoc === "path" ? true : asBool(p.required, false),
+			schema: isRecord$4(p.schema) ? p.schema : {},
+			deprecated: asBool(p.deprecated, false)
+		};
+		const style = asString(p.style);
+		if (style !== void 0) param.style = style;
+		if (typeof p.explode === "boolean") param.explode = p.explode;
+		const desc = asString(p.description);
+		if (desc !== void 0) param.description = desc;
+		return param;
+	}).filter((p) => p !== void 0);
+}
+function mergeParameters(pathLevel, opLevel) {
+	const key = (p) => `${p.in}:${p.name}`;
+	const merged = /* @__PURE__ */ new Map();
+	for (const p of pathLevel) merged.set(key(p), p);
+	for (const p of opLevel) merged.set(key(p), p);
+	return [...merged.values()];
+}
+function normalizeRequestBody(raw) {
+	if (!isRecord$4(raw)) return void 0;
+	const content = {};
+	if (isRecord$4(raw.content)) for (const [mt, mtRaw] of Object.entries(raw.content)) {
+		if (!isRecord$4(mtRaw)) continue;
+		content[mt] = { schema: isRecord$4(mtRaw.schema) ? mtRaw.schema : {} };
+	}
+	const body = {
+		required: asBool(raw.required, false),
+		content
+	};
+	const desc = asString(raw.description);
+	if (desc !== void 0) body.description = desc;
+	return body;
+}
+function normalizeResponses(raw) {
+	if (!isRecord$4(raw)) return [];
+	const entries = Object.entries(raw).filter((entry) => isRecord$4(entry[1]));
+	const has2xx = entries.some(([code]) => /^2\d\d$/.test(code));
+	return entries.map(([statusCode, respRaw]) => {
+		const isSuccess = /^2\d\d$/.test(statusCode) || statusCode === "default" && !has2xx;
+		const isError = /^(4|5)\d\d$/.test(statusCode) || statusCode === "default" && has2xx;
+		const content = {};
+		if (isRecord$4(respRaw.content)) for (const [mt, mtRaw] of Object.entries(respRaw.content)) {
+			if (!isRecord$4(mtRaw)) continue;
+			content[mt] = { schema: isRecord$4(mtRaw.schema) ? mtRaw.schema : {} };
+		}
+		const headers = {};
+		if (isRecord$4(respRaw.headers)) for (const [hn, hRaw] of Object.entries(respRaw.headers)) {
+			if (!isRecord$4(hRaw)) continue;
+			const header = { schema: isRecord$4(hRaw.schema) ? hRaw.schema : {} };
+			const desc = asString(hRaw.description);
+			if (desc !== void 0) header.description = desc;
+			if (typeof hRaw.required === "boolean") header.required = hRaw.required;
+			if (typeof hRaw.deprecated === "boolean") header.deprecated = hRaw.deprecated;
+			headers[hn] = header;
+		}
+		const resp = {
+			statusCode,
+			isSuccess,
+			isError,
+			content,
+			headers
+		};
+		const desc = asString(respRaw.description);
+		if (desc !== void 0) resp.description = desc;
+		return resp;
+	});
+}
+function synthesizeOperationId(method, path) {
+	const out = [];
+	let underscore = false;
+	let braceDepth = 0;
+	for (const ch of path) {
+		if (ch === "{") {
+			braceDepth += 1;
+			continue;
+		}
+		if (ch === "}") {
+			if (braceDepth > 0) braceDepth -= 1;
+			continue;
+		}
+		if (ch >= "A" && ch <= "Z" || ch >= "a" && ch <= "z" || ch >= "0" && ch <= "9") {
+			out.push(ch);
+			underscore = false;
+		} else if (!underscore) {
+			out.push("_");
+			underscore = true;
+		}
+	}
+	let start = 0;
+	let end = out.length;
+	while (start < end && out[start] === "_") start += 1;
+	while (end > start && out[end - 1] === "_") end -= 1;
+	return `${method}_${out.slice(start, end).join("")}`;
+}
+
+//#endregion
+//#region src/types/naming.ts
+const DEFAULT_MAX_LEN = 30;
+/** Split an identifier on camelCase boundaries, non-alnum runs, and digits-prev-letter. */
+function splitWords(raw) {
+	if (!raw) return [];
+	const cleaned = raw.replaceAll(/[^A-Za-z0-9]+/g, " ").trim();
+	if (!cleaned) return [];
+	const tokens = cleaned.split(/\s+/);
+	const out = [];
+	for (const tok of tokens) {
+		const spaced = tok.replaceAll(/([A-Z])(?=[A-Z][a-z])/g, "$1 ").replaceAll(/([a-z0-9])(?=[A-Z])/g, "$1 ");
+		for (const part of spaced.split(/\s+/)) if (part) out.push(part);
+	}
+	return out;
+}
+function shortHash(raw, len = 4) {
+	return createHash("sha256").update(raw).digest("hex").slice(0, len);
+}
+/** Sanitize a raw identifier into an ABAP-safe name. */
+function sanitizeIdent(raw, kind, opts = {}) {
+	const maxLen = opts.maxLen ?? DEFAULT_MAX_LEN;
+	const prefix = opts.prefix ?? "";
+	const words = splitWords(raw);
+	const joiner = "_";
+	let base;
+	if (kind === "class") base = words.map((w) => w.toUpperCase()).join(joiner);
+	else base = words.map((w) => w.toLowerCase()).join(joiner);
+	if (!base) base = kind === "class" ? "X" : "x";
+	if (/^[0-9]/.test(base)) base = (kind === "class" ? "N_" : "n_") + base;
+	let full = prefix + base;
+	if (full.length > maxLen) {
+		const suffix = "_" + shortHash(raw, 4);
+		full = full.slice(0, Math.max(0, maxLen - suffix.length)) + suffix;
+	}
+	return full;
+}
+/** Create a collision-resolving allocator bound to a mutable name set. */
+function makeNameAllocator(usedNames) {
+	return (raw, kind, opts = {}) => {
+		const maxLen = opts.maxLen ?? DEFAULT_MAX_LEN;
+		const base = sanitizeIdent(raw, kind, opts);
+		if (!usedNames.has(base)) {
+			usedNames.add(base);
+			return base;
+		}
+		for (let i = 2; i < 1e4; i++) {
+			const suffix = "_" + i;
+			const candidate = base.slice(0, Math.max(0, maxLen - suffix.length)) + suffix;
+			if (!usedNames.has(candidate)) {
+				usedNames.add(candidate);
+				return candidate;
+			}
+		}
+		throw new Error(`makeNameAllocator: unable to resolve collision for "${raw}"`);
+	};
+}
+
+//#endregion
+//#region src/types/errors.ts
+var CyclicTypeError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CyclicTypeError";
+	}
+};
+var CollisionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CollisionError";
+	}
+};
+var UnsupportedSchemaError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "UnsupportedSchemaError";
+	}
+};
+
+//#endregion
+//#region src/types/plan.ts
+function isRecord$3(x) {
+	return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+/** Extract component schema name from a $ref like "#/components/schemas/Pet". */
+function componentNameFromRef$2(ref) {
+	const m = /^#\/components\/schemas\/(.+)$/.exec(ref);
+	return m ? m[1] : void 0;
+}
+/** Decide if a (non-ref) schema should get its own plan entry when encountered inline. */
+function isNonTrivialInline(schema) {
+	if (isRef(schema)) return false;
+	const type = schema.type;
+	const props = schema.properties;
+	if (type === "object" || isRecord$3(props)) return isRecord$3(props);
+	for (const c of [
+		"allOf",
+		"oneOf",
+		"anyOf"
+	]) if (Array.isArray(schema[c])) return true;
+	return false;
+}
+/** Walk a single schema (rooted at `rootId`) to collect:
+*  - direct dependencies on other entries (by id)
+*  - inline entries that must be allocated.
+*
+*  Descends into properties / items / combinators / additionalProperties.
+*/
+function collectFromSchema(rootId, rootSchema, plannedIds, enqueueInline, schemaToId) {
+	const deps = /* @__PURE__ */ new Set();
+	const visit = (schema, path, atRoot) => {
+		if (!isRecord$3(schema)) return;
+		if (isRef(schema)) {
+			const name = componentNameFromRef$2(schema.$ref);
+			if (name) {
+				const depId = `components.schemas.${name}`;
+				deps.add(depId);
+			}
+			return;
+		}
+		if (!atRoot) {
+			const hitId = schemaToId.get(schema);
+			if (hitId && hitId !== rootId) {
+				deps.add(hitId);
+				return;
+			}
+			if (hitId === rootId) {
+				deps.add(rootId);
+				return;
+			}
+		}
+		if (!atRoot && isNonTrivialInline(schema)) {
+			const id = `${rootId}.${path.join(".")}`;
+			if (!plannedIds.has(id)) {
+				enqueueInline(id, schema);
+				schemaToId.set(schema, id);
+			}
+			deps.add(id);
+			return;
+		}
+		const rec = schema;
+		if (isRecord$3(rec.properties)) for (const [name, sub] of Object.entries(rec.properties)) visit(sub, [
+			...path,
+			"properties",
+			name
+		], false);
+		if (rec.items !== void 0) visit(rec.items, [...path, "items"], false);
+		if (isRecord$3(rec.additionalProperties)) visit(rec.additionalProperties, [...path, "additionalProperties"], false);
+		for (const c of [
+			"allOf",
+			"anyOf",
+			"oneOf"
+		]) {
+			const arr = rec[c];
+			if (Array.isArray(arr)) arr.forEach((sub, idx) => {
+				visit(sub, [
+					...path,
+					c,
+					String(idx)
+				], false);
+			});
+		}
+	};
+	visit(rootSchema, [], true);
+	return [...deps];
+}
+/** Plan the ABAP type universe for a normalized spec. */
+function planTypes(spec, opts) {
+	const alloc = makeNameAllocator(/* @__PURE__ */ new Set());
+	const entries = [];
+	const byId = /* @__PURE__ */ new Map();
+	const plannedIds = /* @__PURE__ */ new Set();
+	const schemaToId = /* @__PURE__ */ new Map();
+	const queue = [];
+	const enqueue = (id, schema, source) => {
+		if (plannedIds.has(id)) return;
+		plannedIds.add(id);
+		schemaToId.set(schema, id);
+		queue.push({
+			id,
+			schema,
+			source
+		});
+	};
+	for (const [name, schema] of Object.entries(spec.schemas)) enqueue(`components.schemas.${name}`, schema, "component");
+	while (queue.length > 0) {
+		const item = queue.shift();
+		const abapName = alloc(inferRawName(item.id, item.source), "type", { prefix: "ty_" + (opts.typePrefix ?? "") });
+		const entry = {
+			id: item.id,
+			abapName,
+			schema: item.schema,
+			dependencies: [],
+			source: item.source
+		};
+		entries.push(entry);
+		byId.set(item.id, entry);
+		entry.dependencies = collectFromSchema(item.id, item.schema, plannedIds, (id, schema) => {
+			enqueue(id, schema, "inline");
+		}, schemaToId);
+	}
+	if (entries.some((e) => hasOpenAdditional(e.schema))) {
+		const kvId = "aux.kv";
+		const kvEntry = {
+			id: kvId,
+			abapName: alloc("kv", "type", { prefix: "ty_" + (opts.typePrefix ?? "") }),
+			schema: {
+				type: "object",
+				properties: {
+					key: { type: "string" },
+					value: { type: "string" }
+				}
+			},
+			dependencies: [],
+			source: "auxiliary"
+		};
+		entries.push(kvEntry);
+		byId.set(kvId, kvEntry);
+	}
+	const sorted = topoSort(entries);
+	return {
+		entries: Object.freeze(sorted.map((e) => Object.freeze({
+			...e,
+			dependencies: Object.freeze([...e.dependencies])
+		}))),
+		byId: new Map(sorted.map((e) => [e.id, {
+			...e,
+			dependencies: Object.freeze([...e.dependencies])
+		}]))
+	};
+}
+function hasOpenAdditional(schema) {
+	const ap = schema.additionalProperties;
+	if (ap === true) return true;
+	if (isRecord$3(ap)) return true;
+	return false;
+}
+function inferRawName(id, source) {
+	if (source === "component") {
+		const m = /^components\.schemas\.(.+)$/.exec(id);
+		return m ? m[1] : id;
+	}
+	if (source === "auxiliary") {
+		const m = /^aux\.(.+)$/.exec(id);
+		return m ? m[1] : id;
+	}
+	return id.split(".").filter((p) => p && p !== "properties" && p !== "items").slice(-2).join("_") || id;
+}
+function topoSort(entries) {
+	const byId = new Map(entries.map((e) => [e.id, e]));
+	const out = [];
+	const state = /* @__PURE__ */ new Map();
+	for (const e of entries) state.set(e.id, "white");
+	const visit = (id, stack) => {
+		const s = state.get(id);
+		if (s === "black") return;
+		const entry = byId.get(id);
+		if (!entry) return;
+		if (s === "gray") {
+			const cycleStart = stack.indexOf(id);
+			const cycle = cycleStart >= 0 ? stack.slice(cycleStart) : [id];
+			if (cycle.length === 1) {
+				entry.selfReferential = true;
+				return;
+			}
+			for (const pid of cycle) {
+				const ent = byId.get(pid);
+				if (ent) ent.selfReferential = true;
+			}
+			return;
+		}
+		state.set(id, "gray");
+		stack.push(id);
+		for (const dep of entry.dependencies) {
+			if (dep === id) {
+				entry.selfReferential = true;
+				continue;
+			}
+			if (!byId.has(dep)) continue;
+			if (state.get(dep) === "gray") {
+				const cycleStart = stack.indexOf(dep);
+				const cycle = cycleStart >= 0 ? stack.slice(cycleStart) : [dep];
+				for (const pid of [...cycle, id]) {
+					const ent = byId.get(pid);
+					if (ent) ent.selfReferential = true;
+				}
+				continue;
+			}
+			visit(dep, stack);
+		}
+		stack.pop();
+		state.set(id, "black");
+		out.push(entry);
+	};
+	for (const e of entries) visit(e.id, []);
+	if (out.length !== entries.length) throw new CyclicTypeError(`planTypes: unable to topologically sort ${entries.length} entries (got ${out.length}).`);
+	return out;
+}
+
+//#endregion
+//#region src/types/map.ts
+function isRecord$2(x) {
+	return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+/** Map a JSON Schema primitive (type+format) to an ABAP builtin type name. */
+function mapPrimitive(schema) {
+	const type = schema.type;
+	const format = schema.format;
+	if (type === "boolean") return "abap_bool";
+	if (type === "integer") return format === "int64" ? "int8" : "i";
+	if (type === "number") return format === "float" || format === "double" ? "f" : "decfloat34";
+	if (type === "string") switch (format) {
+		case "date": return "d";
+		case "date-time": return "timestampl";
+		case "uuid": return "sysuuid_x16";
+		case "byte":
+		case "binary": return "xstring";
+		default: return "string";
+	}
+	return "string";
+}
+function refToEntry(ref, plan) {
+	const m = /^#\/components\/schemas\/(.+)$/.exec(ref);
+	if (!m) return void 0;
+	return plan.byId.get(`components.schemas.${m[1]}`);
+}
+function pluckType$2(schema) {
+	const t = schema.type;
+	if (typeof t === "string") return t;
+	if (Array.isArray(t)) {
+		const nonNull = t.filter((x) => x !== "null");
+		if (nonNull.length >= 1) return nonNull[0];
+	}
+}
+function isNullable$1(schema) {
+	const rec = schema;
+	if (rec.nullable === true) return true;
+	const t = rec.type;
+	if (Array.isArray(t) && t.includes("null")) return true;
+	return false;
+}
+/** Resolve a schema to an ABAP TypeRef. */
+function mapSchemaToTypeRef(schema, plan, ctx = {}) {
+	if (isRef(schema)) {
+		const entry = refToEntry(schema.$ref, plan);
+		if (!entry) throw new UnsupportedSchemaError(`mapSchemaToTypeRef: unresolved $ref "${schema.$ref}"`);
+		return namedTypeRef({ name: entry.abapName });
+	}
+	const type = pluckType$2(schema);
+	if (type === "array") {
+		const items = schema.items;
+		const rowSchema = isRecord$2(items) ? items : {};
+		return tableType({
+			rowType: mapSchemaToTypeRef(rowSchema, plan, ctx),
+			tableKind: "standard"
+		});
+	}
+	if (type === "object" || isRecord$2(schema.properties)) {
+		const matched = findPlannedEntryBySchema$1(schema, plan, ctx.entryId);
+		if (matched) return namedTypeRef({ name: matched.abapName });
+		const fields = buildStructureFields$1(schema, plan, ctx);
+		if (fields.length === 0) return builtinType({ name: "string" });
+		return structureType({ fields });
+	}
+	if (type === void 0) {
+		for (const c of [
+			"allOf",
+			"oneOf",
+			"anyOf"
+		]) if (Array.isArray(schema[c])) {
+			const matched = findPlannedEntryBySchema$1(schema, plan, ctx.entryId);
+			if (matched) return namedTypeRef({ name: matched.abapName });
+			return builtinType({ name: "string" });
+		}
+		return builtinType({ name: "string" });
+	}
+	return builtinType({ name: mapPrimitive(schema) });
+}
+/** If a schema is identical-by-reference to a planned entry, return it. */
+function findPlannedEntryBySchema$1(schema, plan, excludeId) {
+	for (const entry of plan.entries) {
+		if (entry.id === excludeId) continue;
+		if (entry.schema === schema) return entry;
+	}
+}
+function buildEnumMembers(values) {
+	const out = [];
+	for (const v of values) if (typeof v === "string") {
+		const name = sanitizeIdent(v, "type");
+		out.push({
+			name,
+			value: v
+		});
+	} else if (typeof v === "number") out.push({
+		name: sanitizeIdent(`v_${v}`, "type"),
+		value: v
+	});
+	return out;
+}
+/** Build the list of structure fields for an object-like schema, including
+*  combinators, nullable flags, and additionalProperties escape hatch. */
+function buildStructureFields$1(schema, plan, ctx) {
+	const fields = [];
+	const seen = /* @__PURE__ */ new Map();
+	const addField = (name, type, src) => {
+		const sanitized = sanitizeIdent(name, "param");
+		const prev = seen.get(sanitized);
+		if (prev) {
+			if (prev === type || shallowTypeRefEqual(prev, type)) return;
+			throw new CollisionError(`buildStructureFields: duplicate field "${sanitized}" with conflicting types`);
+		}
+		seen.set(sanitized, type);
+		fields.push({
+			name: sanitized,
+			type
+		});
+		if (isNullable$1(src)) {
+			const flagName = sanitizeIdent(`${name}_is_null`, "param");
+			if (!seen.has(flagName)) {
+				const flagType = builtinType({ name: "abap_bool" });
+				seen.set(flagName, flagType);
+				fields.push({
+					name: flagName,
+					type: flagType
+				});
+			}
+		}
+	};
+	const allOf = schema.allOf;
+	if (Array.isArray(allOf)) for (const sub of allOf) {
+		if (!isRecord$2(sub)) continue;
+		const subSchema = sub;
+		const subProps = isRef(subSchema) ? (() => {
+			const entry = refToEntry(subSchema.$ref, plan);
+			if (!entry) return void 0;
+			return entry.schema.properties;
+		})() : subSchema.properties;
+		if (isRecord$2(subProps)) for (const [name, propSchema] of Object.entries(subProps)) {
+			if (!isRecord$2(propSchema)) continue;
+			addField(name, mapSchemaToTypeRef(propSchema, plan, ctx), propSchema);
+		}
+	}
+	const props = schema.properties;
+	if (isRecord$2(props)) for (const [name, propSchema] of Object.entries(props)) {
+		if (!isRecord$2(propSchema)) continue;
+		addField(name, mapSchemaToTypeRef(propSchema, plan, ctx), propSchema);
+	}
+	for (const combinator of ["oneOf", "anyOf"]) {
+		const arr = schema[combinator];
+		if (!Array.isArray(arr)) continue;
+		const discriminator = schema.discriminator;
+		if (isRecord$2(discriminator) && typeof discriminator.propertyName === "string") {
+			addFieldRaw(fields, seen, "kind", builtinType({ name: "string" }));
+			arr.forEach((sub, idx) => {
+				if (!isRecord$2(sub)) return;
+				const variantName = variantFieldName(sub, idx);
+				addFieldRaw(fields, seen, variantName, mapSchemaToTypeRef(sub, plan, ctx));
+			});
+		} else {
+			addFieldRaw(fields, seen, "variant_kind", builtinType({ name: "string" }));
+			arr.forEach((sub, idx) => {
+				if (!isRecord$2(sub)) return;
+				const variantName = variantFieldName(sub, idx);
+				addFieldRaw(fields, seen, variantName, mapSchemaToTypeRef(sub, plan, ctx));
+				addFieldRaw(fields, seen, `${variantName}_is_set`, builtinType({ name: "abap_bool" }));
+			});
+		}
+	}
+	const ap = schema.additionalProperties;
+	if (ap === true || isRecord$2(ap)) {
+		const kvEntry = plan.byId.get("aux.kv");
+		if (kvEntry) addFieldRaw(fields, seen, "_extra", tableType({
+			rowType: namedTypeRef({ name: kvEntry.abapName }),
+			tableKind: "hashed",
+			uniqueness: "unique",
+			keyFields: ["key"]
+		}));
+	}
+	return fields;
+}
+function addFieldRaw(fields, seen, rawName, type) {
+	const name = sanitizeIdent(rawName, "param");
+	if (seen.has(name)) return;
+	seen.set(name, type);
+	fields.push({
+		name,
+		type
+	});
+}
+function shallowTypeRefEqual(a, b) {
+	if (a.kind !== b.kind) return false;
+	if (a.kind === "BuiltinType" && b.kind === "BuiltinType") return a.name === b.name;
+	if (a.kind === "NamedTypeRef" && b.kind === "NamedTypeRef") return a.name === b.name;
+	return false;
+}
+function variantFieldName(sub, idx) {
+	if (isRef(sub)) {
+		const m = /^#\/components\/schemas\/(.+)$/.exec(sub.$ref);
+		if (m) return m[1];
+	}
+	const title = sub.title;
+	if (typeof title === "string" && title) return title;
+	return `variant_${idx}`;
+}
+/** Build a TypeDef node for a single plan entry. */
+function mapSchemaToTypeDef(entry, plan) {
+	const schema = entry.schema;
+	const ctx = { entryId: entry.id };
+	const enumValues = schema.enum;
+	const schemaType = pluckType$2(schema);
+	if (Array.isArray(enumValues) && (schemaType === "string" || schemaType === void 0)) {
+		const members = buildEnumMembers(enumValues);
+		if (members.length > 0) return { typeDef: typeDef({
+			name: entry.abapName,
+			type: enumType({
+				baseType: builtinType({ name: "string" }),
+				members
+			})
+		}) };
+	}
+	if (schemaType === "array") {
+		const items = schema.items;
+		const rowSchema = isRecord$2(items) ? items : {};
+		return { typeDef: typeDef({
+			name: entry.abapName,
+			type: tableType({
+				rowType: mapSchemaToTypeRef(rowSchema, plan, ctx),
+				tableKind: "standard"
+			})
+		}) };
+	}
+	if (schemaType === "object" || isRecord$2(schema.properties) || Array.isArray(schema.allOf) || Array.isArray(schema.oneOf) || Array.isArray(schema.anyOf)) {
+		const fields = buildStructureFields$1(schema, plan, ctx);
+		const struct = fields.length > 0 ? structureType({ fields }) : structureType({ fields: [{
+			name: "_placeholder",
+			type: builtinType({ name: "string" })
+		}] });
+		const discriminator = schema.discriminator;
+		const leadingComment = Array.isArray(schema.oneOf) && isRecord$2(discriminator) ? comment({
+			text: ` Tagged union: only one variant field is populated at a time (kind discriminator).`,
+			style: "star"
+		}) : void 0;
+		return {
+			typeDef: typeDef({
+				name: entry.abapName,
+				type: struct
+			}),
+			leadingComment
+		};
+	}
+	return { typeDef: typeDef({
+		name: entry.abapName,
+		type: builtinType({ name: mapPrimitive(schema) })
+	}) };
+}
+
+//#endregion
+//#region src/emit/naming.ts
+var NamesConfigError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "NamesConfigError";
+	}
+};
+const GLOBAL_NAME_RE = /^[ZY][A-Z0-9_]*$/;
+const LOCAL_NAME_RE = /^[a-z][a-z0-9_]*$/;
+const MAX_LEN = 30;
+const DEFAULT_LOCAL_HTTP = "lcl_http";
+const DEFAULT_LOCAL_RESPONSE = "lcl_response";
+const DEFAULT_LOCAL_JSON = "json";
+const DEFAULT_LOCAL_JSON_PARSER = "lcl_json_parser";
+function validateGlobal(field, value) {
+	if (value.length === 0) throw new NamesConfigError(`Invalid ABAP global name for "${field}": value is empty.`);
+	if (value.length > MAX_LEN) throw new NamesConfigError(`Invalid ABAP global name for "${field}": "${value}" exceeds ${MAX_LEN} characters.`);
+	if (!GLOBAL_NAME_RE.test(value)) throw new NamesConfigError(`Invalid ABAP global name for "${field}": "${value}" must start with Z or Y and contain only uppercase letters, digits, and underscores.`);
+}
+function validateLocal(field, value) {
+	if (value.length === 0) throw new NamesConfigError(`Invalid ABAP local class name for "${field}": value is empty.`);
+	if (value.length > MAX_LEN) throw new NamesConfigError(`Invalid ABAP local class name for "${field}": "${value}" exceeds ${MAX_LEN} characters.`);
+	if (!LOCAL_NAME_RE.test(value)) throw new NamesConfigError(`Invalid ABAP local class name for "${field}": "${value}" must start with a lowercase letter and contain only lowercase letters, digits, and underscores.`);
+}
+function deriveFromBase(base) {
+	const trimmed = base.trim();
+	if (trimmed.length === 0) throw new NamesConfigError("Invalid \"base\" name: value is empty or whitespace.");
+	if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(trimmed)) throw new NamesConfigError(`Invalid "base" name: "${base}" must start with a letter and contain only letters, digits, and underscores.`);
+	const upper = trimmed.toUpperCase();
+	return {
+		typesInterface: `ZIF_${upper}_TYPES`,
+		operationsInterface: `ZIF_${upper}`,
+		implementationClass: `ZCL_${upper}`,
+		exceptionClass: `ZCX_${upper}_ERROR`
+	};
+}
+function resolveNames(config) {
+	const cfg = config ?? {};
+	const hasBase = typeof cfg.base === "string" && cfg.base.trim().length > 0;
+	const hasAnyGlobalOverride = cfg.typesInterface !== void 0 || cfg.operationsInterface !== void 0 || cfg.implementationClass !== void 0 || cfg.exceptionClass !== void 0;
+	if (!hasBase && !hasAnyGlobalOverride) throw new NamesConfigError("Names configuration requires at least \"base\" or one of the individual overrides (typesInterface, operationsInterface, implementationClass, exceptionClass).");
+	const derived = hasBase ? deriveFromBase(cfg.base) : {
+		typesInterface: "",
+		operationsInterface: "",
+		implementationClass: "",
+		exceptionClass: ""
+	};
+	const typesInterface = (cfg.typesInterface ?? derived.typesInterface).trim();
+	const operationsInterface = (cfg.operationsInterface ?? derived.operationsInterface).trim();
+	const implementationClass = (cfg.implementationClass ?? derived.implementationClass).trim();
+	const exceptionClass = (cfg.exceptionClass ?? derived.exceptionClass).trim();
+	if (!typesInterface) throw new NamesConfigError("Cannot resolve \"typesInterface\": provide --base or --types-interface.");
+	if (!operationsInterface) throw new NamesConfigError("Cannot resolve \"operationsInterface\": provide --base or --operations-interface.");
+	if (!implementationClass) throw new NamesConfigError("Cannot resolve \"implementationClass\": provide --base or --class-name.");
+	if (!exceptionClass) throw new NamesConfigError("Cannot resolve \"exceptionClass\": provide --base or --exception-class.");
+	const resolved = {
+		typesInterface,
+		operationsInterface,
+		implementationClass,
+		exceptionClass,
+		localHttpClass: cfg.localHttpClass ?? DEFAULT_LOCAL_HTTP,
+		localResponseClass: cfg.localResponseClass ?? DEFAULT_LOCAL_RESPONSE,
+		localJsonClass: cfg.localJsonClass ?? DEFAULT_LOCAL_JSON,
+		localJsonParserClass: cfg.localJsonParserClass ?? DEFAULT_LOCAL_JSON_PARSER
+	};
+	validateGlobal("typesInterface", resolved.typesInterface);
+	validateGlobal("operationsInterface", resolved.operationsInterface);
+	validateGlobal("implementationClass", resolved.implementationClass);
+	validateGlobal("exceptionClass", resolved.exceptionClass);
+	validateLocal("localHttpClass", resolved.localHttpClass);
+	validateLocal("localResponseClass", resolved.localResponseClass);
+	validateLocal("localJsonClass", resolved.localJsonClass);
+	validateLocal("localJsonParserClass", resolved.localJsonParserClass);
+	return resolved;
+}
+
+//#endregion
+//#region src/emit/types-interface.ts
+/**
+* Layer-1 types interface emitter.
+*
+* Builds a single global ABAP interface (e.g. `ZIF_PETSTORE_TYPES`) that
+* declares every OpenAPI component schema as a `TYPES` entry, in
+* topological order. Naming follows the v2 convention: no `ty_` prefix —
+* the OpenAPI schema name is snake_cased directly.
+*
+* See packages/openai-codegen/AGENTS.md style references. This module
+* intentionally bypasses the existing `ty_`-prefixed `mapSchemaToTypeDef`
+* in `../types/map` and reconstructs TypeDef nodes from scratch so it can
+* honour the v2 rules (bare names, per-schema map types, cyclic back-ref
+* detection, controllable null flags, polymorphism union merge).
+*/
+/** Raised when polymorphism variants disagree on the type of a named field. */
+var PolymorphismConflictError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PolymorphismConflictError";
+	}
+};
+function emitTypesInterface(spec, plan, opts) {
+	if (!opts.name) throw new Error("emitTypesInterface: opts.name is required");
+	const ctx = buildContext(spec, plan, opts);
+	const typeDefs = [];
+	for (const entry of plan.entries) {
+		if (entry.source === "auxiliary") continue;
+		const aux = ctx.mapAux.get(entry.id);
+		if (aux) {
+			typeDefs.push(aux.entryTypeDef);
+			typeDefs.push(aux.mapTypeDef);
+		}
+		typeDefs.push(buildEntryTypeDef(entry, ctx));
+	}
+	return {
+		interface: interfaceDef({
+			name: opts.name,
+			members: typeDefs,
+			abapDoc: opts.interfaceAbapDoc
+		}),
+		typeDefs
+	};
+}
+function isRecord$1(x) {
+	return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function pluckType$1(schema) {
+	const t = schema.type;
+	if (typeof t === "string") return t;
+	if (Array.isArray(t)) {
+		const nonNull = t.filter((x) => x !== "null");
+		if (nonNull.length >= 1) return nonNull[0];
+	}
+}
+function isNullable(schema) {
+	const rec = schema;
+	if (rec.nullable === true) return true;
+	const t = rec.type;
+	if (Array.isArray(t) && t.includes("null")) return true;
+	return false;
+}
+function componentNameFromRef$1(ref) {
+	const m = /^#\/components\/schemas\/(.+)$/.exec(ref);
+	return m ? m[1] : void 0;
+}
+function originalNameFromId(id) {
+	const m = /^components\.schemas\.(.+)$/.exec(id);
+	return m ? m[1] : void 0;
+}
+/** Normalise a raw name for v2: replace `$` with `_`, then snake_case ≤ 30. */
+function v2Name(raw, allocator) {
+	return allocator(raw.replaceAll(/\$/g, "_"), "type");
+}
+function buildContext(spec, plan, opts) {
+	const alloc = makeNameAllocator(/* @__PURE__ */ new Set());
+	const nameOf = /* @__PURE__ */ new Map();
+	const originalNameOf = /* @__PURE__ */ new Map();
+	const positionOf = /* @__PURE__ */ new Map();
+	plan.entries.forEach((e, idx) => positionOf.set(e.id, idx));
+	for (const entry of plan.entries) {
+		if (entry.source === "auxiliary") continue;
+		const v2 = v2Name(deriveRawName(entry), alloc);
+		nameOf.set(entry.id, v2);
+		const orig = originalNameFromId(entry.id);
+		if (orig !== void 0) originalNameOf.set(entry.id, orig);
+	}
+	const mapAux = /* @__PURE__ */ new Map();
+	const backRefs = /* @__PURE__ */ new Map();
+	for (const entry of plan.entries) backRefs.set(entry.id, []);
+	const ctxStub = {
+		spec,
+		plan,
+		opts,
+		nameOf,
+		positionOf,
+		originalNameOf,
+		mapAux,
+		backRefs
+	};
+	for (const entry of plan.entries) {
+		if (entry.source === "auxiliary") continue;
+		const ap = entry.schema.additionalProperties;
+		if (ap === void 0 || ap === false) continue;
+		const base = nameOf.get(entry.id);
+		const entryName = v2Name(`${base}_map_entry`, alloc);
+		const mapName = v2Name(`${base}_map`, alloc);
+		const valueRef = asFieldTypeRef(resolveTypeRef(isRecord$1(ap) ? ap : { type: "string" }, entry.id, ctxStub));
+		const entryTypeDef = typeDef({
+			name: entryName,
+			type: structureType({ fields: [{
+				name: "key",
+				type: builtinType({ name: "string" })
+			}, {
+				name: "value",
+				type: valueRef
+			}] }),
+			abapDoc: [`@openapi-map-entry ${originalNameFromId(entry.id) ?? base}`]
+		});
+		const mapTypeDef = typeDef({
+			name: mapName,
+			type: tableType({
+				rowType: namedTypeRef({ name: entryName }),
+				tableKind: "standard"
+			}),
+			abapDoc: [`@openapi-map ${originalNameFromId(entry.id) ?? base}`]
+		});
+		mapAux.set(entry.id, {
+			entryName,
+			mapName,
+			entryTypeDef,
+			mapTypeDef
+		});
+	}
+	return ctxStub;
+}
+function deriveRawName(entry) {
+	const stripped = entry.abapName.replace(/^ty_/, "");
+	const orig = originalNameFromId(entry.id);
+	if (orig !== void 0) return orig;
+	return stripped || entry.id;
+}
+function buildEntryTypeDef(entry, ctx) {
+	const name = ctx.nameOf.get(entry.id);
+	const schema = entry.schema;
+	const leadingDoc = [];
+	const original = ctx.originalNameOf.get(entry.id);
+	if (original !== void 0) leadingDoc.push(`@openapi-schema ${original}`);
+	else if (entry.source === "inline") leadingDoc.push(`@openapi-path ${entry.id}`);
+	const description = schema.description;
+	if (typeof description === "string" && description.trim()) for (const line of description.split(/\r?\n/)) leadingDoc.push(`@openapi-description ${line}`);
+	const enumValues = schema.enum;
+	const schemaType = pluckType$1(schema);
+	if (Array.isArray(enumValues) && (schemaType === "string" || schemaType === void 0)) {
+		const members = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const v of enumValues) if (typeof v === "string") {
+			let nm = sanitizeIdent(v, "type");
+			let i = 2;
+			while (seen.has(nm)) nm = `${nm}_${i++}`;
+			seen.add(nm);
+			members.push({
+				name: nm,
+				value: v
+			});
+		} else if (typeof v === "number") {
+			let nm = sanitizeIdent(`v_${v}`, "type");
+			let i = 2;
+			while (seen.has(nm)) nm = `${nm}_${i++}`;
+			seen.add(nm);
+			members.push({
+				name: nm,
+				value: v
+			});
+		}
+		if (members.length > 0) return typeDef({
+			name,
+			type: enumType({
+				baseType: builtinType({ name: "string" }),
+				members
+			}),
+			abapDoc: leadingDoc.length > 0 ? leadingDoc : void 0
+		});
+	}
+	if (schemaType === "array") {
+		const items = schema.items;
+		const rowSchema = isRecord$1(items) ? items : {};
+		return typeDef({
+			name,
+			type: tableType({
+				rowType: resolveTypeRef(rowSchema, entry.id, ctx),
+				tableKind: "standard"
+			}),
+			abapDoc: finaliseDoc(leadingDoc, ctx.backRefs.get(entry.id) ?? [])
+		});
+	}
+	if (schemaType === "object" || isRecord$1(schema.properties) || Array.isArray(schema.allOf) || Array.isArray(schema.oneOf) || Array.isArray(schema.anyOf) || ctx.mapAux.has(entry.id)) {
+		const fields = buildStructureFields(entry, ctx);
+		const finalFields = fields.length > 0 ? fields : [{
+			name: "_placeholder",
+			type: builtinType({ name: "string" })
+		}];
+		return typeDef({
+			name,
+			type: structureType({ fields: finalFields }),
+			abapDoc: finaliseDoc(leadingDoc, ctx.backRefs.get(entry.id) ?? [])
+		});
+	}
+	return typeDef({
+		name,
+		type: builtinType({ name: mapPrimitiveLocal(schema) }),
+		abapDoc: finaliseDoc(leadingDoc, ctx.backRefs.get(entry.id) ?? [])
+	});
+}
+function finaliseDoc(base, backRefs) {
+	const out = [...base];
+	for (const br of backRefs) out.push(br);
+	return out.length > 0 ? out : void 0;
+}
+function buildStructureFields(entry, ctx) {
+	const schema = entry.schema;
+	const fields = [];
+	const seen = /* @__PURE__ */ new Map();
+	const addField = (rawName, rawType, src) => {
+		const type = asFieldTypeRef(rawType);
+		const fieldName = sanitizeIdent(rawName.replaceAll(/\$/g, "_"), "param");
+		const prev = seen.get(fieldName);
+		if (prev !== void 0) {
+			if (!typeRefEqual(prev, type)) throw new PolymorphismConflictError(`buildStructureFields: conflicting types for field "${fieldName}" in "${entry.id}"`);
+			return;
+		}
+		seen.set(fieldName, type);
+		fields.push({
+			name: fieldName,
+			type
+		});
+		if (ctx.opts.emitNullFlags && isNullable(src)) {
+			const flagName = sanitizeIdent(`${rawName}_is_null`, "param");
+			if (!seen.has(flagName)) {
+				const flagType = builtinType({ name: "abap_bool" });
+				seen.set(flagName, flagType);
+				fields.push({
+					name: flagName,
+					type: flagType
+				});
+			}
+		}
+	};
+	const mergeProperties = (src) => {
+		const props = src.properties;
+		if (isRecord$1(props)) for (const [propName, propSchema] of Object.entries(props)) {
+			if (!isRecord$1(propSchema)) continue;
+			const ref = resolveTypeRef(propSchema, entry.id, ctx, propName);
+			addField(propName, ref, propSchema);
+		}
+	};
+	const allOf = schema.allOf;
+	if (Array.isArray(allOf)) for (const sub of allOf) {
+		if (!isRecord$1(sub)) continue;
+		if (isRef(sub)) {
+			const refEntry = resolveRefEntry(sub.$ref, ctx);
+			if (refEntry !== void 0) mergeProperties(refEntry.schema);
+		} else mergeProperties(sub);
+	}
+	mergeProperties(schema);
+	for (const combinator of ["oneOf", "anyOf"]) {
+		const arr = schema[combinator];
+		if (!Array.isArray(arr)) continue;
+		for (const sub of arr) {
+			if (!isRecord$1(sub)) continue;
+			if (isRef(sub)) {
+				const refEntry = resolveRefEntry(sub.$ref, ctx);
+				if (refEntry !== void 0) mergeProperties(refEntry.schema);
+			} else mergeProperties(sub);
+		}
+	}
+	const aux = ctx.mapAux.get(entry.id);
+	if (aux) {
+		const fieldName = sanitizeIdent("entries", "param");
+		if (!seen.has(fieldName)) {
+			const ref = namedTypeRef({ name: aux.mapName });
+			seen.set(fieldName, ref);
+			fields.push({
+				name: fieldName,
+				type: ref
+			});
+		}
+	}
+	return fields;
+}
+function resolveRefEntry(ref, ctx) {
+	const name = componentNameFromRef$1(ref);
+	if (!name) return void 0;
+	return ctx.plan.byId.get(`components.schemas.${name}`);
+}
+function typeRefEqual(a, b) {
+	if (a.kind !== b.kind) return false;
+	if (a.kind === "BuiltinType" && b.kind === "BuiltinType") return a.name === b.name;
+	if (a.kind === "NamedTypeRef" && b.kind === "NamedTypeRef") return a.name === b.name;
+	if (a.kind === "TableType" && b.kind === "TableType") return typeRefEqual(a.rowType, b.rowType);
+	return false;
+}
+/**
+* Convert a TypeRef that may be a TableType into a form that can appear as a
+* structure-field type. The underlying ABAP printer only accepts BuiltinType
+* or NamedTypeRef inline; we synthesise a NamedTypeRef whose "name" is the
+* full inline table expression so the printer emits it verbatim.
+*/
+function asFieldTypeRef(t) {
+	if (t.kind !== "TableType") return t;
+	const row = t.rowType;
+	let rowExpr;
+	if (row.kind === "BuiltinType") rowExpr = row.name;
+	else if (row.kind === "NamedTypeRef") rowExpr = row.name;
+	else rowExpr = "string";
+	return namedTypeRef({ name: `STANDARD TABLE OF ${rowExpr} WITH EMPTY KEY` });
+}
+function resolveTypeRef(schema, ownerEntryId, ctx, fieldName) {
+	if (isRef(schema)) {
+		const target = resolveRefEntry(schema.$ref, ctx);
+		if (target === void 0) return builtinType({ name: "string" });
+		const ownerPos = ctx.positionOf.get(ownerEntryId) ?? -1;
+		const targetPos = ctx.positionOf.get(target.id) ?? -1;
+		const isBackEdge = targetPos >= 0 && ownerPos >= 0 && targetPos >= ownerPos;
+		if (target.id === ownerEntryId || isBackEdge) {
+			const targetOriginal = ctx.originalNameOf.get(target.id) ?? ctx.nameOf.get(target.id) ?? target.id;
+			const backRefs = ctx.backRefs.get(ownerEntryId);
+			if (backRefs !== void 0) {
+				const label = fieldName ? `${fieldName}:${targetOriginal}` : targetOriginal;
+				backRefs.push(`@openapi-ref ${label}`);
+			}
+			return namedTypeRef({ name: "REF TO data" });
+		}
+		return namedTypeRef({ name: ctx.nameOf.get(target.id) ?? target.abapName });
+	}
+	const type = pluckType$1(schema);
+	if (type === "array") {
+		const items = schema.items;
+		const rowSchema = isRecord$1(items) ? items : {};
+		return tableType({
+			rowType: resolveTypeRef(rowSchema, ownerEntryId, ctx, fieldName),
+			tableKind: "standard"
+		});
+	}
+	const props = schema.properties;
+	if (type === "object" || isRecord$1(props)) {
+		const matched = findPlannedEntryBySchema(schema, ctx.plan, ownerEntryId);
+		if (matched !== void 0) {
+			const name = ctx.nameOf.get(matched.id);
+			if (name !== void 0) return namedTypeRef({ name });
+		}
+		return builtinType({ name: "string" });
+	}
+	if (type === void 0) {
+		for (const c of [
+			"allOf",
+			"oneOf",
+			"anyOf"
+		]) if (Array.isArray(schema[c])) {
+			const matched = findPlannedEntryBySchema(schema, ctx.plan, ownerEntryId);
+			if (matched !== void 0) {
+				const name = ctx.nameOf.get(matched.id);
+				if (name !== void 0) return namedTypeRef({ name });
+			}
+			return builtinType({ name: "string" });
+		}
+		return builtinType({ name: "string" });
+	}
+	return builtinType({ name: mapPrimitiveLocal(schema) });
+}
+function findPlannedEntryBySchema(schema, plan, excludeId) {
+	for (const entry of plan.entries) {
+		if (entry.id === excludeId) continue;
+		if (entry.schema === schema) return entry;
+	}
+}
+function mapPrimitiveLocal(schema) {
+	const type = pluckType$1(schema);
+	const format = schema.format;
+	if (type === "boolean") return "abap_bool";
+	if (type === "integer") return format === "int64" ? "int8" : "i";
+	if (type === "number") return format === "float" || format === "double" ? "f" : "decfloat34";
+	if (type === "string") switch (format) {
+		case "date": return "d";
+		case "date-time": return "timestampl";
+		case "uuid": return "sysuuid_x16";
+		case "byte":
+		case "binary": return "xstring";
+		default: return "string";
+	}
+	return "string";
+}
+
+//#endregion
+//#region src/emit/operations-interface.ts
+/**
+* Layer 2 emitter — OPERATIONS INTERFACE (`ZIF_<base>`).
+*
+* Produces a single global ABAP interface whose methods mirror the OpenAPI
+* `operations` list 1:1. All type references point into the types interface
+* emitted by the Wave 1 Layer-1 emitter (`ZIF_<base>_TYPES`).
+*
+* The design is deliberately conservative:
+*   - RETURNING values carry a bare, natural name (no `rv_` / `rt_` prefix).
+*   - IMPORTING parameters use the OpenAPI parameter name, snake-cased.
+*   - Body parameters are always called `body`.
+*   - Every method RAISES the single generated exception class.
+*   - Cookie parameters are skipped with an `"! @openapi-todo` note.
+*
+* The emitter also returns a parallel `operations` array describing each
+* method's mapping. The Wave 2 implementation-class emitter consumes this
+* array to build per-operation bodies.
+*/
+function isRecord(x) {
+	return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function pluckType(schema) {
+	if (!schema) return void 0;
+	const t = schema.type;
+	if (typeof t === "string") return t;
+	if (Array.isArray(t)) {
+		const nonNull = t.filter((x) => x !== "null");
+		if (nonNull.length >= 1) return nonNull[0];
+	}
+}
+function isPlainObjectSchema(schema) {
+	return pluckType(schema) === "object" || isRecord(schema.properties);
+}
+function componentNameFromRef(ref) {
+	const m = /^#\/components\/schemas\/(.+)$/.exec(ref);
+	return m ? m[1] : void 0;
+}
+function buildComponentIndex(spec) {
+	const byPropSig = /* @__PURE__ */ new Map();
+	for (const [name, schema] of Object.entries(spec.schemas)) {
+		if (!isRecord(schema)) continue;
+		const props = schema.properties;
+		if (!isRecord(props)) continue;
+		const keys = Object.keys(props).sort((a, b) => a.localeCompare(b)).join(",");
+		if (keys && !byPropSig.has(keys)) byPropSig.set(keys, name);
+	}
+	return { byPropSig };
+}
+/** Identify which component schema a (possibly dereferenced) schema refers to. */
+function matchComponent(schema, index) {
+	if (!schema) return void 0;
+	if (isRef(schema)) return componentNameFromRef(schema.$ref);
+	if (!isPlainObjectSchema(schema)) return void 0;
+	const props = schema.properties;
+	if (!isRecord(props)) return void 0;
+	const sig = Object.keys(props).sort((a, b) => a.localeCompare(b)).join(",");
+	if (!sig) return void 0;
+	return index.byPropSig.get(sig);
+}
+function typeInterfaceMember(typesInterfaceName, componentName) {
+	return `${typesInterfaceName.toLowerCase()}=>${sanitizeIdent(componentName, "type")}`;
+}
+/** Render a schema as the printable form used inline after `TYPE`. */
+function renderSchemaTypeSource(schema, index, typesInterfaceName) {
+	if (!schema) return "string";
+	if (isRef(schema)) {
+		const name = componentNameFromRef(schema.$ref);
+		return name ? typeInterfaceMember(typesInterfaceName, name) : "string";
+	}
+	if (pluckType(schema) === "array") {
+		const items = schema.items;
+		return `STANDARD TABLE OF ${renderSchemaTypeSource(isRecord(items) ? items : {}, index, typesInterfaceName)}`;
+	}
+	if (isPlainObjectSchema(schema)) {
+		const comp = matchComponent(schema, index);
+		return comp ? typeInterfaceMember(typesInterfaceName, comp) : "string";
+	}
+	return mapPrimitive(schema);
+}
+/**
+* Build an ABAP `TypeRef` for a schema usable as an inline type reference.
+*
+* For array shapes we ALWAYS emit a named alias (`<ops-intf>=><name>_list`)
+* into the operations interface itself. Cloud ABAP does NOT accept inline
+* `STANDARD TABLE OF ...` clauses inside a METHODS parameter list (the SAP
+* ADT save endpoint returns "An error occured during the save operation"),
+* so every array-typed parameter or return must be a named type reference.
+* The aliases are collected via {@link registerTableAlias} and emitted as
+* TYPES declarations at the head of the interface in {@link emitOperationsInterface}.
+*/
+function schemaToTypeRef(schema, index, typesInterfaceName, opsInterfaceName, aliases) {
+	if (!schema) return builtinType({ name: "string" });
+	if (isRef(schema)) {
+		const name = componentNameFromRef(schema.$ref);
+		if (name) return namedTypeRef({ name: typeInterfaceMember(typesInterfaceName, name) });
+		return builtinType({ name: "string" });
+	}
+	if (pluckType(schema) === "array") {
+		const items = schema.items;
+		const aliasName = registerTableAlias(aliases, renderSchemaTypeSource(isRecord(items) ? items : {}, index, typesInterfaceName));
+		return namedTypeRef({ name: `${opsInterfaceName.toLowerCase()}=>${aliasName}` });
+	}
+	if (isPlainObjectSchema(schema)) {
+		const comp = matchComponent(schema, index);
+		if (comp) return namedTypeRef({ name: typeInterfaceMember(typesInterfaceName, comp) });
+		return builtinType({ name: "string" });
+	}
+	return builtinType({ name: mapPrimitive(schema) });
+}
+function createTableAliasRegistry() {
+	return {
+		aliases: /* @__PURE__ */ new Map(),
+		order: []
+	};
+}
+/** Return the alias name for a given row type, registering it if new. */
+function registerTableAlias(registry, rowType) {
+	const existing = registry.aliases.get(rowType);
+	if (existing !== void 0) return existing;
+	const alias = deriveTableAliasName(rowType, registry.aliases);
+	registry.aliases.set(rowType, alias);
+	registry.order.push(alias);
+	return alias;
+}
+/**
+* Derive an alias name from the row-type source.
+* Strip any interface prefix (`zif_foo_types=>`) and keep only the schema
+* name, then append `_list`. Collisions get a `_2`, `_3` … suffix.
+*/
+function deriveTableAliasName(rowType, existing) {
+	const taken = new Set(existing.values());
+	const base = `${(rowType.includes("=>") ? rowType.split("=>").pop() ?? rowType : rowType).replaceAll(/[^a-z0-9_]/gi, "_").toLowerCase()}_list`;
+	if (!taken.has(base)) return base;
+	let i = 2;
+	while (taken.has(`${base}_${i}`)) i += 1;
+	return `${base}_${i}`;
+}
+/** Build TypeDef nodes for every registered table alias. */
+function buildAliasTypeDefs(registry) {
+	const inverse = /* @__PURE__ */ new Map();
+	for (const [rowType, alias] of registry.aliases) inverse.set(alias, rowType);
+	return registry.order.map((alias) => {
+		const rowType = inverse.get(alias) ?? "string";
+		return typeDef({
+			name: alias,
+			type: tableType({
+				rowType: namedTypeRef({ name: rowType }),
+				tableKind: "standard"
+			})
+		});
+	});
+}
+function pickSuccess(op) {
+	const successes = op.responses.filter((r) => r.isSuccess);
+	if (successes.length === 0) return void 0;
+	let chosen;
+	chosen = successes.find((r) => r.statusCode === "200");
+	if (!chosen) chosen = successes.filter((r) => /^2\d\d$/.test(r.statusCode)).sort((a, b) => Number(a.statusCode) - Number(b.statusCode))[0] ?? successes[0];
+	const status = chosen.statusCode === "default" ? "default" : Number(chosen.statusCode);
+	const content = chosen.content;
+	const schema = (content["application/json"] ?? content["application/octet-stream"] ?? content[Object.keys(content)[0] ?? ""])?.schema;
+	const hasSchema = schema !== void 0 && Object.keys(schema).length > 0;
+	return {
+		response: chosen,
+		status,
+		schema: hasSchema ? schema : void 0
+	};
+}
+function pickRequestBodySchema$1(op) {
+	const rb = op.requestBody;
+	if (!rb) return void 0;
+	const c = rb.content;
+	const schema = (c["application/json"] ?? c["application/octet-stream"] ?? c[Object.keys(c)[0] ?? ""])?.schema;
+	if (!schema) return void 0;
+	return Object.keys(schema).length > 0 ? schema : void 0;
+}
+function deriveReturningName(schema, index) {
+	if (!schema) return "result";
+	if (isRef(schema)) {
+		const name = componentNameFromRef(schema.$ref);
+		return name ? sanitizeIdent(name, "param") : "result";
+	}
+	if (pluckType(schema) === "array") {
+		const items = schema.items;
+		if (isRecord(items)) {
+			const inner = deriveReturningName(items, index);
+			if (inner === "result") return "results";
+			return pluralize(inner);
+		}
+		return "results";
+	}
+	if (isPlainObjectSchema(schema)) {
+		const comp = matchComponent(schema, index);
+		if (comp) return sanitizeIdent(comp, "param");
+		return "result";
+	}
+	return "result";
+}
+function pluralize(name) {
+	if (!name) return "results";
+	if (/(s|x|z|ch|sh)$/i.test(name)) return `${name}_list`;
+	if (/y$/i.test(name) && !/[aeiou]y$/i.test(name)) return `${name.slice(0, -1)}ies`;
+	return `${name}s`;
+}
+function orderParams(params) {
+	const path = params.filter((p) => p.in === "path");
+	const query = params.filter((p) => p.in === "query");
+	const header = params.filter((p) => p.in === "header");
+	const cookie = params.filter((p) => p.in === "cookie");
+	return {
+		emitted: [
+			...path,
+			...query,
+			...header
+		],
+		cookieSkipped: cookie
+	};
+}
+function buildMethodAbapDoc(op, cookieSkipped) {
+	const lines = [];
+	lines.push(`@openapi-operation ${op.operationId}`);
+	lines.push(`@openapi-path ${op.method.toUpperCase()} ${op.path}`);
+	if (op.summary) {
+		for (const l of op.summary.split(/\r?\n/)) if (l.trim().length > 0) lines.push(l.trim());
+	}
+	if (op.deprecated) lines.push("@openapi-deprecated");
+	for (const c of cookieSkipped) lines.push(`@openapi-todo cookie param '${c.name}' not mapped`);
+	return lines;
+}
+function emitOperationsInterface(spec, _plan, opts) {
+	const compIndex = buildComponentIndex(spec);
+	const allocMethod = makeNameAllocator(/* @__PURE__ */ new Set());
+	const methods = [];
+	const mappings = [];
+	const tableAliases = createTableAliasRegistry();
+	const opsInterfaceName = opts.name;
+	for (const op of spec.operations) {
+		const methodName = allocMethod(op.operationId, "method");
+		const { emitted, cookieSkipped } = orderParams(op.parameters);
+		const allocParam = makeNameAllocator(/* @__PURE__ */ new Set());
+		const abapParams = [];
+		const paramMappings = [];
+		for (const p of emitted) {
+			const abapName = allocParam(p.name, "param");
+			const ref = schemaToTypeRef(p.schema, compIndex, opts.typesInterfaceName, opsInterfaceName, tableAliases);
+			abapParams.push(methodParam({
+				paramKind: "importing",
+				name: abapName,
+				typeRef: ref,
+				optional: !p.required
+			}));
+			paramMappings.push({
+				name: abapName,
+				openapiName: p.name,
+				location: p.in,
+				required: p.required,
+				typeRefSource: renderTypeRefSource(ref),
+				isTable: pluckType(p.schema) === "array"
+			});
+		}
+		const bodySchema = pickRequestBodySchema$1(op);
+		const hasBody = bodySchema !== void 0;
+		if (hasBody) {
+			const bodyName = allocParam("body", "param");
+			const ref = schemaToTypeRef(bodySchema, compIndex, opts.typesInterfaceName, opsInterfaceName, tableAliases);
+			abapParams.push(methodParam({
+				paramKind: "importing",
+				name: bodyName,
+				typeRef: ref,
+				optional: op.requestBody?.required === false ? true : false
+			}));
+		}
+		const success = pickSuccess(op);
+		let successStatus;
+		let successIsEmptyBody;
+		let returningName;
+		let returningRef;
+		if (!success) {
+			successStatus = 200;
+			successIsEmptyBody = true;
+			returningName = allocParam("success", "param");
+			returningRef = builtinType({ name: "abap_bool" });
+		} else if (success.schema === void 0) {
+			successStatus = success.status;
+			successIsEmptyBody = true;
+			returningName = allocParam("success", "param");
+			returningRef = builtinType({ name: "abap_bool" });
+		} else {
+			successStatus = success.status;
+			successIsEmptyBody = false;
+			returningName = allocParam(deriveReturningName(success.schema, compIndex), "param");
+			returningRef = schemaToTypeRef(success.schema, compIndex, opts.typesInterfaceName, opsInterfaceName, tableAliases);
+		}
+		abapParams.push(methodParam({
+			paramKind: "returning",
+			name: returningName,
+			typeRef: returningRef
+		}));
+		const errorResponses = {};
+		for (const r of op.responses) {
+			if (!r.isError) continue;
+			errorResponses[r.statusCode] = r.description ? { description: r.description } : {};
+		}
+		const method = methodDef({
+			name: methodName,
+			visibility: "public",
+			params: abapParams,
+			raising: [namedTypeRef({ name: opts.exceptionClassName.toLowerCase() })],
+			abapDoc: buildMethodAbapDoc(op, cookieSkipped)
+		});
+		methods.push(method);
+		mappings.push({
+			operationId: op.operationId,
+			methodName,
+			method: op.method.toUpperCase(),
+			path: op.path,
+			params: paramMappings,
+			hasBody,
+			successStatus,
+			successIsEmptyBody,
+			errorResponses,
+			returningName
+		});
+	}
+	const aliasTypeDefs = buildAliasTypeDefs(tableAliases);
+	return {
+		interface: interfaceDef({
+			name: opts.name.toLowerCase(),
+			members: [...aliasTypeDefs, ...methods],
+			abapDoc: opts.interfaceAbapDoc
+		}),
+		operations: mappings
+	};
+}
+function renderTypeRefSource(ref) {
+	switch (ref.kind) {
+		case "BuiltinType": return ref.name;
+		case "NamedTypeRef": return ref.name;
+		case "TableType":
+		case "StructureType": return ref.kind;
+	}
+}
+
+//#endregion
+//#region src/emit/exception-class.ts
+/**
+* Emit the generated ABAP exception class that carries HTTP error detail
+* (status code, reason phrase, raw body, response headers).
+*
+* The class inherits from `cx_static_check` and is FINAL with CREATE PUBLIC.
+* It exposes four READ-ONLY attributes and a constructor that assigns them
+* after delegating to `super->constructor( )`.
+*/
+/** Build the constructor's IMPLEMENTATION body (super call + 4 assignments). */
+function buildConstructorImpl() {
+	const superCall = call({
+		receiver: identifierExpr({ name: "super" }),
+		method: "constructor",
+		callKind: "instance",
+		args: []
+	});
+	const assignments = [
+		"status",
+		"description",
+		"body",
+		"headers"
+	].map((f) => assign({
+		target: identifierExpr({ name: `me->${f}` }),
+		value: identifierExpr({ name: f })
+	}));
+	return methodImpl({
+		name: "constructor",
+		body: [superCall, ...assignments]
+	});
+}
+function emitExceptionClass(opts) {
+	if (!opts.name) throw new Error("emitExceptionClass: required field \"name\" is missing");
+	const kvType = typeDef({
+		name: "kv",
+		type: structureType({ fields: [{
+			name: "k",
+			type: builtinType({ name: "string" })
+		}, {
+			name: "v",
+			type: builtinType({ name: "string" })
+		}] })
+	});
+	const kvsType = typeDef({
+		name: "kvs",
+		type: tableType({
+			rowType: namedTypeRef({ name: "kv" }),
+			tableKind: "standard"
+		})
+	});
+	const statusAttr = attributeDef({
+		name: "status",
+		type: builtinType({ name: "i" }),
+		visibility: "public",
+		readOnly: true
+	});
+	const descriptionAttr = attributeDef({
+		name: "description",
+		type: builtinType({ name: "string" }),
+		visibility: "public",
+		readOnly: true
+	});
+	const bodyAttr = attributeDef({
+		name: "body",
+		type: builtinType({ name: "xstring" }),
+		visibility: "public",
+		readOnly: true
+	});
+	const headersAttr = attributeDef({
+		name: "headers",
+		type: namedTypeRef({ name: "kvs" }),
+		visibility: "public",
+		readOnly: true
+	});
+	const ctor = methodDef({
+		name: "constructor",
+		visibility: "public",
+		params: [
+			methodParam({
+				paramKind: "importing",
+				name: "status",
+				typeRef: builtinType({ name: "i" })
+			}),
+			methodParam({
+				paramKind: "importing",
+				name: "description",
+				typeRef: builtinType({ name: "string" }),
+				optional: true
+			}),
+			methodParam({
+				paramKind: "importing",
+				name: "body",
+				typeRef: builtinType({ name: "xstring" }),
+				optional: true
+			}),
+			methodParam({
+				paramKind: "importing",
+				name: "headers",
+				typeRef: namedTypeRef({ name: "kvs" }),
+				optional: true
+			})
+		]
+	});
+	const publicSection = section({
+		visibility: "public",
+		members: [
+			kvType,
+			kvsType,
+			statusAttr,
+			descriptionAttr,
+			bodyAttr,
+			headersAttr,
+			ctor
+		]
+	});
+	return { class: classDef({
+		name: opts.name,
+		superclass: "cx_static_check",
+		isFinal: true,
+		sections: [publicSection],
+		implementations: [buildConstructorImpl()],
+		abapDoc: opts.interfaceAbapDoc ? [...opts.interfaceAbapDoc] : void 0
+	}) };
+}
+
+//#endregion
+//#region src/emit/templates/locals-def.abap.ts
+function buildLocalsDef(names) {
+	const { localJsonClass: JSON_CLS, localJsonParserClass: JSON_PARSER, localResponseClass: RESPONSE, localHttpClass: HTTP } = names;
+	names.exceptionClass;
+	return `* Generated by @abapify/openai-codegen - local class declarations.
+* ZERO Z-dependencies: these locals wrap SAP kernel APIs only.
+* Per-operation methods map HTTP status codes to the custom exception.
+
+CLASS ${HTTP} DEFINITION DEFERRED.
+CLASS ${RESPONSE} DEFINITION DEFERRED.
+CLASS ${JSON_PARSER} DEFINITION DEFERRED.
+CLASS ${JSON_CLS} DEFINITION DEFERRED.
+
+CLASS ${HTTP} DEFINITION FINAL CREATE PUBLIC.
+  PUBLIC SECTION.
+    TYPES: BEGIN OF kv,
+             name  TYPE string,
+             value TYPE string,
+           END OF kv.
+    TYPES kvs TYPE STANDARD TABLE OF kv WITH DEFAULT KEY.
+
+    METHODS constructor
+      IMPORTING destination TYPE string
+                server      TYPE string OPTIONAL.
+
+    METHODS fetch
+      IMPORTING method          TYPE string
+                path            TYPE string
+                query           TYPE kvs     OPTIONAL
+                headers         TYPE kvs     OPTIONAL
+                body            TYPE string  OPTIONAL
+                binary          TYPE xstring OPTIONAL
+      RETURNING VALUE(response) TYPE REF TO ${RESPONSE}
+      RAISING   cx_web_http_client_error
+                cx_http_dest_provider_error.
+
+  PRIVATE SECTION.
+    DATA destination TYPE string.
+    DATA server      TYPE string.
+
+    METHODS build_query_string
+      IMPORTING query         TYPE kvs
+      RETURNING VALUE(result) TYPE string.
+ENDCLASS.
+
+CLASS ${RESPONSE} DEFINITION FINAL CREATE PRIVATE FRIENDS ${HTTP}.
+  PUBLIC SECTION.
+    METHODS status  RETURNING VALUE(result) TYPE i.
+    METHODS body    RETURNING VALUE(result) TYPE xstring.
+    METHODS text    RETURNING VALUE(result) TYPE string.
+    METHODS header
+      IMPORTING name          TYPE string
+      RETURNING VALUE(result) TYPE string.
+    METHODS headers RETURNING VALUE(result) TYPE ${HTTP}=>kvs.
+
+  PRIVATE SECTION.
+    METHODS constructor
+      IMPORTING status_code TYPE i
+                body_bytes  TYPE xstring
+                body_text   TYPE string
+                header_list TYPE ${HTTP}=>kvs.
+
+    DATA status_code TYPE i.
+    DATA body_bytes  TYPE xstring.
+    DATA body_text   TYPE string.
+    DATA header_list TYPE ${HTTP}=>kvs.
+ENDCLASS.
+
+CLASS ${JSON_PARSER} DEFINITION FINAL CREATE PRIVATE FRIENDS ${JSON_CLS}.
+  PUBLIC SECTION.
+    METHODS to
+      IMPORTING target TYPE REF TO data.
+
+  PRIVATE SECTION.
+    METHODS constructor
+      IMPORTING json_text TYPE string.
+
+    DATA json_text TYPE string.
+ENDCLASS.
+
+CLASS ${JSON_CLS} DEFINITION FINAL CREATE PRIVATE.
+  PUBLIC SECTION.
+    CLASS-METHODS stringify
+      IMPORTING data          TYPE any
+      RETURNING VALUE(result) TYPE string.
+
+    CLASS-METHODS render
+      IMPORTING data          TYPE any
+      RETURNING VALUE(result) TYPE xstring.
+
+    CLASS-METHODS parse
+      IMPORTING source        TYPE any
+      RETURNING VALUE(result) TYPE REF TO ${JSON_PARSER}.
+ENDCLASS.
+`;
+}
+
+//#endregion
+//#region src/emit/templates/locals-imp.abap.ts
+function buildLocalsImp(names) {
+	const { localJsonClass: JSON_CLS, localJsonParserClass: JSON_PARSER, localResponseClass: RESPONSE, localHttpClass: HTTP } = names;
+	return `* Generated by @abapify/openai-codegen - local class implementations.
+* ZERO Z-dependencies: uses SAP kernel APIs only (Steampunk whitelist).
+
+CLASS ${HTTP} IMPLEMENTATION.
+
+  METHOD constructor.
+    me->destination = destination.
+    me->server      = server.
+  ENDMETHOD.
+
+  METHOD build_query_string.
+    DATA parts TYPE string_table.
+    LOOP AT query ASSIGNING FIELD-SYMBOL(<q>).
+      DATA(enc_n) = cl_web_http_utility=>escape_url( unescaped = <q>-name ).
+      DATA(enc_v) = cl_web_http_utility=>escape_url( unescaped = <q>-value ).
+      APPEND |{ enc_n }={ enc_v }| TO parts.
+    ENDLOOP.
+    result = concat_lines_of( table = parts sep = \`&\` ).
+  ENDMETHOD.
+
+  METHOD fetch.
+    " Prefix with the configured server base path when set,
+    " so OpenAPI specs with a non-root server still resolve correctly.
+    DATA full_path TYPE string.
+    full_path = COND string(
+      WHEN server IS INITIAL THEN path
+      ELSE |{ server }{ path }| ).
+    IF query IS NOT INITIAL.
+      full_path = |{ full_path }?{ build_query_string( query ) }|.
+    ENDIF.
+
+    DATA dest TYPE REF TO if_http_destination.
+    dest = cl_http_destination_provider=>create_by_destination(
+      i_destination = CONV #( destination ) ).
+
+    DATA client TYPE REF TO if_web_http_client.
+    client = cl_web_http_client_manager=>create_by_http_destination(
+      i_destination = dest ).
+
+    " All IO against client runs inside TRY ... CLEANUP so the HTTP
+    " connection is closed even when execute() / binary read / codepage
+    " conversion raise a kernel exception.
+    TRY.
+        DATA request TYPE REF TO if_web_http_request.
+        request = client->get_http_request( ).
+        request->set_uri_path( i_uri_path = full_path ).
+
+        DATA verb TYPE if_web_http_client=>method.
+        verb = SWITCH if_web_http_client=>method( method
+          WHEN 'GET'     THEN if_web_http_client=>get
+          WHEN 'POST'    THEN if_web_http_client=>post
+          WHEN 'PUT'     THEN if_web_http_client=>put
+          WHEN 'DELETE'  THEN if_web_http_client=>delete
+          WHEN 'PATCH'   THEN if_web_http_client=>patch
+          WHEN 'HEAD'    THEN if_web_http_client=>head
+          WHEN 'OPTIONS' THEN if_web_http_client=>options
+          ELSE if_web_http_client=>get ).
+
+        LOOP AT headers ASSIGNING FIELD-SYMBOL(<h>).
+          request->set_header_field( i_name  = <h>-name
+                                     i_value = <h>-value ).
+        ENDLOOP.
+
+        IF binary IS NOT INITIAL.
+          request->set_binary( i_data = binary ).
+        ELSEIF body IS NOT INITIAL.
+          request->set_text( i_text = body ).
+        ENDIF.
+
+        DATA resp TYPE REF TO if_web_http_response.
+        resp = client->execute( i_method = verb ).
+
+        DATA status_code TYPE i.
+        status_code = resp->get_status( )-code.
+
+        DATA body_bytes TYPE xstring.
+        body_bytes = resp->get_binary( ).
+
+        DATA body_text TYPE string.
+        IF body_bytes IS NOT INITIAL.
+          body_text = cl_abap_conv_codepage=>create_in( )->convert(
+            source = body_bytes ).
+        ENDIF.
+
+        DATA raw_headers TYPE if_web_http_request=>name_value_pairs.
+        raw_headers = resp->get_header_fields( ).
+
+        DATA header_list TYPE kvs.
+        LOOP AT raw_headers ASSIGNING FIELD-SYMBOL(<rh>).
+          APPEND VALUE #( name  = <rh>-name
+                          value = <rh>-value ) TO header_list.
+        ENDLOOP.
+
+        response = NEW ${RESPONSE}(
+          status_code = status_code
+          body_bytes  = body_bytes
+          body_text   = body_text
+          header_list = header_list ).
+
+        client->close( ).
+      CLEANUP.
+        client->close( ).
+    ENDTRY.
+  ENDMETHOD.
+
+ENDCLASS.
+
+CLASS ${RESPONSE} IMPLEMENTATION.
+
+  METHOD constructor.
+    me->status_code = status_code.
+    me->body_bytes  = body_bytes.
+    me->body_text   = body_text.
+    me->header_list = header_list.
+  ENDMETHOD.
+
+  METHOD status.
+    result = status_code.
+  ENDMETHOD.
+
+  METHOD body.
+    result = body_bytes.
+  ENDMETHOD.
+
+  METHOD text.
+    result = body_text.
+  ENDMETHOD.
+
+  METHOD headers.
+    result = header_list.
+  ENDMETHOD.
+
+  METHOD header.
+    DATA needle TYPE string.
+    needle = to_lower( name ).
+    LOOP AT header_list ASSIGNING FIELD-SYMBOL(<h>).
+      IF to_lower( <h>-name ) = needle.
+        result = <h>-value.
+        RETURN.
+      ENDIF.
+    ENDLOOP.
+  ENDMETHOD.
+
+ENDCLASS.
+
+CLASS ${JSON_PARSER} IMPLEMENTATION.
+
+  METHOD constructor.
+    me->json_text = json_text.
+  ENDMETHOD.
+
+  METHOD to.
+    FIELD-SYMBOLS <t> TYPE any.
+    ASSIGN target->* TO <t>.
+    /ui2/cl_json=>deserialize(
+      EXPORTING json        = json_text
+                pretty_name = /ui2/cl_json=>pretty_mode-camel_case
+      CHANGING  data        = <t> ).
+  ENDMETHOD.
+
+ENDCLASS.
+
+CLASS ${JSON_CLS} IMPLEMENTATION.
+
+  METHOD stringify.
+    result = /ui2/cl_json=>serialize(
+      data        = data
+      pretty_name = /ui2/cl_json=>pretty_mode-camel_case
+      compress    = abap_true ).
+  ENDMETHOD.
+
+  METHOD render.
+    DATA text TYPE string.
+    text = stringify( data ).
+    result = cl_abap_conv_codepage=>create_out( )->convert(
+      source = text ).
+  ENDMETHOD.
+
+  METHOD parse.
+    DATA text TYPE string.
+    FIELD-SYMBOLS <s> TYPE any.
+    ASSIGN source TO <s>.
+    " RTTI dispatch — static type inspection is used instead of the
+    " legacy DESCRIBE statement, which is not allowed on ABAP cloud.
+    DATA type_info TYPE REF TO cl_abap_typedescr.
+    type_info = cl_abap_typedescr=>describe_by_data( <s> ).
+    IF type_info->type_kind = cl_abap_typedescr=>typekind_xstring.
+      DATA bytes TYPE xstring.
+      bytes = <s>.
+      text = cl_abap_conv_codepage=>create_in( )->convert(
+        source = bytes ).
+    ELSE.
+      text = <s>.
+    ENDIF.
+    result = NEW ${JSON_PARSER}( json_text = text ).
+  ENDMETHOD.
+
+ENDCLASS.
+`;
+}
+
+//#endregion
+//#region src/emit/local-classes.ts
+function emitLocalClasses(names) {
+	const templateNames = {
+		exceptionClass: names.exceptionClass,
+		localJsonClass: names.localJsonClass,
+		localJsonParserClass: names.localJsonParserClass,
+		localResponseClass: names.localResponseClass,
+		localHttpClass: names.localHttpClass
+	};
+	return {
+		localsDef: buildLocalsDef(templateNames),
+		localsImp: buildLocalsImp(templateNames)
+	};
+}
+
+//#endregion
+//#region src/emit/response-mapper.ts
+/**
+* Response-mapper for openai-codegen v2.
+*
+* Produces the `CASE reply->status( ) ... ENDCASE.` block that lives inside
+* each generated implementation method, directly mapping the operation's
+* OpenAPI `responses` object onto ABAP branches.
+*
+* NOTE: `@abapify/abap-ast` does not currently model `CASE`/`WHEN` as a
+* dedicated statement node. To keep this change narrowly scoped (and to
+* avoid racing other agents on abap-ast), the emitted block is returned as
+* a single `raw({ source })` statement. The AST wrapper is only a transport
+* for the final ABAP source; callers append it to a method body exactly
+* like any other statement.
+*/
+/**
+* Escape an arbitrary string so it can be embedded inside an ABAP single-
+* quoted literal. Single quotes are doubled; newlines collapse to spaces.
+*/
+function escapeAbapLiteral(input) {
+	return input.replaceAll(/[\r\n]+/g, " ").replaceAll("'", "''");
+}
+/**
+* Pick which response drives the success branch.
+*
+* Preference order:
+*   1. Lowest numeric 2xx status code.
+*   2. `default` if no 2xx exists (treated as success — WHEN OTHERS).
+*   3. `undefined` — caller falls back to synthesising a generic WHEN.
+*/
+function pickSuccessStatus(responses) {
+	const twoXX = responses.filter((r) => /^2\d\d$/.test(r.statusCode)).map((r) => r.statusCode).sort((a, b) => Number(a) - Number(b));
+	if (twoXX.length > 0) return {
+		statusCode: twoXX[0],
+		whenLabel: twoXX[0]
+	};
+	const def = responses.find((r) => r.statusCode === "default");
+	if (def !== void 0 && !def.isError) return {
+		statusCode: "default",
+		whenLabel: "OTHERS"
+	};
+}
+function renderSuccessBody(opts) {
+	const { successBody } = opts;
+	const responseVar = opts.responseVarName ?? "response";
+	switch (successBody.kind) {
+		case "json": return `${opts.localJsonClassName}=>parse( ${responseVar}->body( ) )->to( REF #( ${successBody.returningName} ) ).`;
+		case "empty": return `${successBody.returningName} = abap_true.`;
+		case "binary": return `${successBody.returningName} = ${responseVar}->body( ).`;
+	}
+}
+function renderErrorBranch(statusCode, description, opts) {
+	const responseVar = opts.responseVarName ?? "response";
+	const lines = [];
+	lines.push(`  WHEN ${statusCode}.`);
+	lines.push(`    RAISE EXCEPTION NEW ${opts.exceptionClassName}(`);
+	lines.push(`      status      = ${statusCode}`);
+	if (description !== void 0 && description.length > 0) lines.push(`      description = '${escapeAbapLiteral(description)}'`);
+	lines.push(`      body        = ${responseVar}->body( ) ).`);
+	return lines;
+}
+function renderOthersBranch(description, opts) {
+	const responseVar = opts.responseVarName ?? "response";
+	const lines = [];
+	lines.push(`  WHEN OTHERS.`);
+	lines.push(`    RAISE EXCEPTION NEW ${opts.exceptionClassName}(`);
+	lines.push(`      status      = ${responseVar}->status( )`);
+	if (description !== void 0 && description.length > 0) lines.push(`      description = '${escapeAbapLiteral(description)}'`);
+	lines.push(`      body        = ${responseVar}->body( ) ).`);
+	return lines;
+}
+function mapResponseHandling(operation, opts) {
+	const responseVar = opts.responseVarName ?? "response";
+	const lines = [];
+	lines.push(`CASE ${responseVar}->status( ).`);
+	const success = pickSuccessStatus(operation.responses);
+	const successConsumedOthers = success !== void 0 && success.whenLabel === "OTHERS";
+	if (success !== void 0 && !successConsumedOthers) {
+		lines.push(`  WHEN ${success.whenLabel}.`);
+		lines.push(`    ${renderSuccessBody(opts)}`);
+	}
+	for (const resp of operation.responses) {
+		if (!resp.isError) continue;
+		if (resp.statusCode === "default") continue;
+		if (!/^\d+$/.test(resp.statusCode)) continue;
+		lines.push(...renderErrorBranch(resp.statusCode, resp.description, opts));
+	}
+	if (successConsumedOthers) {
+		lines.push(`  WHEN OTHERS.`);
+		lines.push(`    ${renderSuccessBody(opts)}`);
+	} else {
+		const defaultResp = operation.responses.find((r) => r.statusCode === "default");
+		const description = defaultResp !== void 0 && defaultResp.isError ? defaultResp.description : void 0;
+		lines.push(...renderOthersBranch(description, opts));
+	}
+	lines.push(`ENDCASE.`);
+	const source = lines.join("\n");
+	return {
+		statement: raw({ source }),
+		source
+	};
+}
+
+//#endregion
+//#region src/format/validate.ts
+/**
+* ABAP identifier validation shared by all format writers.
+*
+* Rules (SAP repository object naming):
+*   - Must start with 'Z' or 'Y' (customer namespace)
+*   - Allowed characters: A-Z, 0-9, '_'
+*   - Max 30 characters
+*   - Must be uppercase
+*/
+function assertValidClassName(name) {
+	if (typeof name !== "string" || name.length === 0) throw new Error("className must be a non-empty string");
+	if (name.length > 30) throw new Error(`Invalid ABAP class name '${name}': exceeds 30 characters`);
+	if (!/^[ZY][A-Z0-9_]*$/.test(name)) throw new Error(`Invalid ABAP class name '${name}': must be uppercase, start with Z or Y, and contain only A-Z, 0-9, _`);
+}
+
+//#endregion
+//#region src/format/abapgit.ts
+/**
+* abapGit format writer.
+*
+* Produces the canonical layout consumed by the abapGit import flow:
+*
+*   <outDir>/
+*     package.devc.xml
+*     src/<name>.clas.abap
+*     src/<name>.clas.xml
+*     src/<name>.clas.testclasses.abap   (optional)
+*     src/<name>.clas.locals_def.abap    (optional)
+*
+* File names are lowercase (abapGit convention). The `.clas.xml` envelope is
+* parameterised on CLSNAME / DESCRIPT / LANGU only — STATE/CLSCCINCL/FIXPT/
+* UNICODE are fixed to the defaults emitted by the SAP serializer for a
+* freshly-generated global class (mirrors samples/petstore-abapgit/).
+*/
+const PACKAGE_DEVC_XML = `<?xml version="1.0" encoding="utf-8"?>
+<asx:abap xmlns:asx="http://www.sap.com/abapxml" version="1.0">
+  <asx:values>
+    <DEVC>
+      <CTEXT>Generated by @abapify/openai-codegen</CTEXT>
+    </DEVC>
+  </asx:values>
+</asx:abap>
+`;
+function buildClasXml(className, description, language) {
+	return `<?xml version="1.0" encoding="utf-8"?>
+<abapGit version="v1.0.0" serializer="LCL_OBJECT_CLAS" serializer_version="v1.0.0">
+  <asx:abap xmlns:asx="http://www.sap.com/abapxml" version="1.0">
+    <asx:values>
+      <VSEOCLASS>
+        <CLSNAME>${className}</CLSNAME>
+        <LANGU>${language}</LANGU>
+        <DESCRIPT>${escapeXml(description)}</DESCRIPT>
+        <STATE>1</STATE>
+        <CLSCCINCL>X</CLSCCINCL>
+        <FIXPT>X</FIXPT>
+        <UNICODE>X</UNICODE>
+        <ABAP_LANGUAGE_VERSION>5</ABAP_LANGUAGE_VERSION>
+      </VSEOCLASS>
+    </asx:values>
+  </asx:abap>
+</abapGit>
+`;
+}
+function escapeXml(value) {
+	return value.replaceAll(/&/g, "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
+}
+async function writeAbapgitLayout(artifact, outDir) {
+	assertValidClassName(artifact.className);
+	const language = artifact.language ?? "E";
+	const description = artifact.description ?? artifact.className;
+	const base = artifact.className.toLowerCase();
+	const srcDir = join(outDir, "src");
+	await mkdir(srcDir, { recursive: true });
+	const written = [];
+	const pkgPath = join(outDir, "package.devc.xml");
+	await writeFile(pkgPath, PACKAGE_DEVC_XML, "utf-8");
+	written.push("package.devc.xml");
+	const mainAbap = join(srcDir, `${base}.clas.abap`);
+	await writeFile(mainAbap, artifact.mainSource, "utf-8");
+	written.push(`src/${base}.clas.abap`);
+	const clasXml = join(srcDir, `${base}.clas.xml`);
+	await writeFile(clasXml, buildClasXml(artifact.className, description, language), "utf-8");
+	written.push(`src/${base}.clas.xml`);
+	if (artifact.testSource !== void 0) {
+		const p = join(srcDir, `${base}.clas.testclasses.abap`);
+		await writeFile(p, artifact.testSource, "utf-8");
+		written.push(`src/${base}.clas.testclasses.abap`);
+	}
+	if (artifact.localsDefSource !== void 0) {
+		const p = join(srcDir, `${base}.clas.locals_def.abap`);
+		await writeFile(p, artifact.localsDefSource, "utf-8");
+		written.push(`src/${base}.clas.locals_def.abap`);
+	}
+	if (artifact.localsImpSource !== void 0) {
+		const p = join(srcDir, `${base}.clas.locals_imp.abap`);
+		await writeFile(p, artifact.localsImpSource, "utf-8");
+		written.push(`src/${base}.clas.locals_imp.abap`);
+	}
+	written.sort((a, b) => a.localeCompare(b));
+	return { files: written };
+}
+function buildIntfXml(name, description, language) {
+	return `<?xml version="1.0" encoding="utf-8"?>
+<abapGit version="v1.0.0" serializer="LCL_OBJECT_INTF" serializer_version="v1.0.0">
+  <asx:abap xmlns:asx="http://www.sap.com/abapxml" version="1.0">
+    <asx:values>
+      <VSEOINTERF>
+        <CLSNAME>${name}</CLSNAME>
+        <LANGU>${language}</LANGU>
+        <DESCRIPT>${escapeXml(description)}</DESCRIPT>
+        <EXPOSURE>2</EXPOSURE>
+        <STATE>1</STATE>
+        <UNICODE>X</UNICODE>
+        <ABAP_LANGUAGE_VERSION>5</ABAP_LANGUAGE_VERSION>
+      </VSEOINTERF>
+    </asx:values>
+  </asx:abap>
+</abapGit>
+`;
+}
+async function writeAbapgitInterface(artifact, outDir) {
+	assertValidClassName(artifact.name);
+	const language = artifact.language ?? "E";
+	const description = artifact.description ?? artifact.name;
+	const base = artifact.name.toLowerCase();
+	const srcDir = join(outDir, "src");
+	await mkdir(srcDir, { recursive: true });
+	const written = [];
+	const pkgPath = join(outDir, "package.devc.xml");
+	await writeFile(pkgPath, PACKAGE_DEVC_XML, "utf-8");
+	written.push("package.devc.xml");
+	const intfAbap = join(srcDir, `${base}.intf.abap`);
+	await writeFile(intfAbap, artifact.source, "utf-8");
+	written.push(`src/${base}.intf.abap`);
+	const intfXml = join(srcDir, `${base}.intf.xml`);
+	await writeFile(intfXml, buildIntfXml(artifact.name, description, language), "utf-8");
+	written.push(`src/${base}.intf.xml`);
+	written.sort((a, b) => a.localeCompare(b));
+	return { files: written };
+}
+
+//#endregion
+//#region src/format/gcts.ts
+/**
+* gCTS / AFF format writer.
+*
+* gCTS (git-enabled CTS) and AFF (SAP/abap-file-formats) share the same
+* on-disk layout: JSON metadata, per-object subdirectory named after the
+* lowercased object name, `<name>.<type>.<ext>` naming.
+*
+* For a class this produces:
+*
+*   <outDir>/
+*     package.devc.json
+*     CLAS/<name>/<name>.clas.json
+*     CLAS/<name>/<name>.clas.abap
+*     CLAS/<name>/<name>.clas.testclasses.abap   (optional)
+*     CLAS/<name>/<name>.clas.locals_def.abap    (optional)
+*     CLAS/<name>/<name>.clas.locals_imp.abap    (optional)
+*
+* The `CLAS/` object-type subdirectory mirrors the layout used by gCTS
+* repositories (objects grouped under their type code). See
+* `packages/adt-plugin-gcts/` for filename conventions.
+*/
+const PACKAGE_DEVC_JSON = JSON.stringify({
+	header: {
+		formatVersion: "1.0",
+		description: "Generated by @abapify/openai-codegen"
+	},
+	package: { softwareComponent: "LOCAL" }
+}, null, 2) + "\n";
+function buildClasJson(className, description, language) {
+	return JSON.stringify({
+		header: {
+			formatVersion: "1.0",
+			description,
+			originalLanguage: language,
+			abapLanguageVersion: "5"
+		},
+		class: {
+			name: className,
+			category: "00",
+			visibility: "public",
+			final: true,
+			abstract: false,
+			fixedPointArithmetic: true,
+			unicodeChecksActive: true
+		}
+	}, null, 2) + "\n";
+}
+async function writeGctsLayout(artifact, outDir) {
+	assertValidClassName(artifact.className);
+	const language = artifact.language ?? "E";
+	const description = artifact.description ?? artifact.className;
+	const base = artifact.className.toLowerCase();
+	const objectDir = join(outDir, "CLAS", base);
+	await mkdir(objectDir, { recursive: true });
+	const written = [];
+	const pkgPath = join(outDir, "package.devc.json");
+	await writeFile(pkgPath, PACKAGE_DEVC_JSON, "utf-8");
+	written.push("package.devc.json");
+	const metaPath = join(objectDir, `${base}.clas.json`);
+	await writeFile(metaPath, buildClasJson(artifact.className, description, language), "utf-8");
+	written.push(`CLAS/${base}/${base}.clas.json`);
+	const mainPath = join(objectDir, `${base}.clas.abap`);
+	await writeFile(mainPath, artifact.mainSource, "utf-8");
+	written.push(`CLAS/${base}/${base}.clas.abap`);
+	if (artifact.testSource !== void 0) {
+		const p = join(objectDir, `${base}.clas.testclasses.abap`);
+		await writeFile(p, artifact.testSource, "utf-8");
+		written.push(`CLAS/${base}/${base}.clas.testclasses.abap`);
+	}
+	if (artifact.localsDefSource !== void 0) {
+		const p = join(objectDir, `${base}.clas.locals_def.abap`);
+		await writeFile(p, artifact.localsDefSource, "utf-8");
+		written.push(`CLAS/${base}/${base}.clas.locals_def.abap`);
+	}
+	if (artifact.localsImpSource !== void 0) {
+		const p = join(objectDir, `${base}.clas.locals_imp.abap`);
+		await writeFile(p, artifact.localsImpSource, "utf-8");
+		written.push(`CLAS/${base}/${base}.clas.locals_imp.abap`);
+	}
+	written.sort((a, b) => a.localeCompare(b));
+	return { files: written };
+}
+function buildIntfJson(name, description, language) {
+	return JSON.stringify({
+		header: {
+			formatVersion: "1.0",
+			description,
+			originalLanguage: language,
+			abapLanguageVersion: "5"
+		},
+		interface: {
+			name,
+			visibility: "public"
+		}
+	}, null, 2) + "\n";
+}
+async function writeGctsInterface(artifact, outDir) {
+	assertValidClassName(artifact.name);
+	const language = artifact.language ?? "E";
+	const description = artifact.description ?? artifact.name;
+	const base = artifact.name.toLowerCase();
+	const objectDir = join(outDir, "INTF", base);
+	await mkdir(objectDir, { recursive: true });
+	const written = [];
+	const pkgPath = join(outDir, "package.devc.json");
+	await writeFile(pkgPath, PACKAGE_DEVC_JSON, "utf-8");
+	written.push("package.devc.json");
+	const metaPath = join(objectDir, `${base}.intf.json`);
+	await writeFile(metaPath, buildIntfJson(artifact.name, description, language), "utf-8");
+	written.push(`INTF/${base}/${base}.intf.json`);
+	const mainPath = join(objectDir, `${base}.intf.abap`);
+	await writeFile(mainPath, artifact.source, "utf-8");
+	written.push(`INTF/${base}/${base}.intf.abap`);
+	written.sort((a, b) => a.localeCompare(b));
+	return { files: written };
+}
+
+//#endregion
+//#region src/format/index.ts
+/**
+* Format plugins barrel.
+*
+* Exposes per-format writers and a {@link writeLayout} dispatch helper that
+* selects the writer from an {@link OutputFormat} string. A
+* {@link writeClientBundle} helper writes the full four-artifact client
+* (types interface, operations interface, exception class, implementation
+* class) in one shot.
+*/
+function isInterfaceArtifact(artifact) {
+	return typeof artifact.name === "string" && typeof artifact.source === "string";
+}
+function writeLayout(artifact, format, outDir) {
+	if (isInterfaceArtifact(artifact)) switch (format) {
+		case "abapgit": return writeAbapgitInterface(artifact, outDir);
+		case "gcts": return writeGctsInterface(artifact, outDir);
+		default: throw new Error(`Unknown output format: ${String(format)}`);
+	}
+	switch (format) {
+		case "abapgit": return writeAbapgitLayout(artifact, outDir);
+		case "gcts": return writeGctsLayout(artifact, outDir);
+		default: throw new Error(`Unknown output format: ${String(format)}`);
+	}
+}
+async function writeClientBundle(artifacts, format, outDir) {
+	const all = /* @__PURE__ */ new Set();
+	for (const artifact of [
+		artifacts.types,
+		artifacts.operations,
+		artifacts.exception,
+		artifacts.implementation
+	]) {
+		const r = await writeLayout(artifact, format, outDir);
+		for (const f of r.files) all.add(f);
+	}
+	return { files: [...all].sort((a, b) => a.localeCompare(b)) };
+}
+
+//#endregion
+//#region src/emit/implementation-class.ts
+/**
+* Layer 3 emitter — IMPLEMENTATION CLASS (`ZCL_<base>`).
+*
+* The generated class is deliberately minimal: it INTERFACES the operations
+* interface, holds one private reference to the bundled local HTTP client,
+* and emits one METHOD per operation whose body:
+*
+*   1. Calls `client->fetch( ... )` with method / path / query / headers /
+*      body, capturing the result in `DATA(response)`.
+*   2. Delegates to the response-mapper to emit the `CASE response->status( )`
+*      block that turns each OpenAPI response onto either a RETURNING
+*      assignment or a `RAISE EXCEPTION NEW zcx_...` statement.
+*
+* The @abapify/abap-ast printer does not currently model `CASE` / `WHEN`
+* nodes, and modelling a mixed-indent multi-line method call via the call
+* expression is awkward. For these two shapes we use `raw({ source })`
+* statements — the printer emits them verbatim at the current indent.
+*/
+function emitImplementationClass(spec, operations, opts) {
+	const { names } = opts;
+	const className = names.implementationClass;
+	const ifaceName = names.operationsInterface.toLowerCase();
+	const httpLocal = names.localHttpClass;
+	const jsonLocal = names.localJsonClass;
+	const excLocal = names.exceptionClass.toLowerCase();
+	const defaultServer = opts.defaultServer ?? "/api/v3";
+	const ctorDecl = methodDef({
+		name: "constructor",
+		visibility: "public",
+		params: [methodParam({
+			paramKind: "importing",
+			name: "destination",
+			typeRef: builtinType({ name: "string" })
+		}), methodParam({
+			paramKind: "importing",
+			name: "server",
+			typeRef: builtinType({ name: "string" }),
+			default: literal({
+				literalKind: "string",
+				value: defaultServer
+			})
+		})]
+	});
+	const publicSection = section({
+		visibility: "public",
+		members: [ctorDecl]
+	});
+	const clientAttr = attributeDef({
+		name: "client",
+		type: namedTypeRef({ name: `REF TO ${httpLocal}` }),
+		visibility: "private"
+	});
+	const privateSection = section({
+		visibility: "private",
+		members: [clientAttr]
+	});
+	const ctorImpl = methodImpl({
+		name: "constructor",
+		body: [raw({ source: `client = NEW ${httpLocal}( destination = destination server = server ).` })]
+	});
+	const byId = /* @__PURE__ */ new Map();
+	for (const op of spec.operations) byId.set(op.operationId, op);
+	const operationImpls = operations.map((mapping) => {
+		const op = byId.get(mapping.operationId);
+		if (op === void 0) throw new Error(`emitImplementationClass: operation "${mapping.operationId}" not found in spec`);
+		const bodyStmts = buildOperationBody(op, mapping, {
+			httpLocal,
+			jsonLocal,
+			exceptionClassName: excLocal
+		});
+		return methodImpl({
+			name: `${ifaceName}~${mapping.methodName}`,
+			body: bodyStmts
+		});
+	});
+	return { class: classDef({
+		name: className,
+		interfaces: [ifaceName],
+		sections: [publicSection, privateSection],
+		implementations: [ctorImpl, ...operationImpls]
+	}) };
+}
+function buildOperationBody(op, mapping, ctx) {
+	const fetchSource = renderFetchCall(mapping, isBinaryRequestBody(op, pickRequestBodySchema(op)), ctx.jsonLocal);
+	const successBody = decideSuccessBody(op, mapping);
+	const caseResult = mapResponseHandling(op, {
+		exceptionClassName: ctx.exceptionClassName,
+		localJsonClassName: ctx.jsonLocal,
+		successBody
+	});
+	const excName = ctx.exceptionClassName;
+	return [
+		raw({ source: "TRY." }),
+		raw({ source: fetchSource }),
+		caseResult.statement,
+		raw({ source: `  CATCH cx_web_http_client_error cx_http_dest_provider_error INTO DATA(_http_err).` }),
+		raw({ source: `    RAISE EXCEPTION NEW ${excName}(\n      status      = 0\n      description = _http_err->get_text( ) ).` }),
+		raw({ source: "ENDTRY." })
+	];
+}
+function renderFetchCall(mapping, bodyIsBinary, jsonLocalClass) {
+	const args = [];
+	args.push({
+		key: "method",
+		value: `'${mapping.method}'`
+	});
+	args.push({
+		key: "path",
+		value: renderPathValue(mapping)
+	});
+	const queryParams = mapping.params.filter((p) => p.location === "query");
+	if (queryParams.length > 0) {
+		const items = queryParams.map((p) => {
+			const key = escapeSingleQuotes(p.openapiName);
+			if (p.isTable) {
+				const loopVar = `_${p.name}`;
+				return `FOR ${loopVar} IN ${p.name} ( name = '${key}' value = ${loopVar} )`;
+			}
+			return `( name = '${key}' value = ${p.name} )`;
+		}).join(" ");
+		args.push({
+			key: "query",
+			value: `VALUE #( ${items} )`
+		});
+	}
+	const headerParams = mapping.params.filter((p) => p.location === "header");
+	const headerItems = [];
+	if (mapping.hasBody) {
+		if (bodyIsBinary) args.push({
+			key: "binary",
+			value: "body"
+		});
+		else {
+			args.push({
+				key: "body",
+				value: `${jsonLocalClass}=>stringify( body )`
+			});
+			headerItems.push(`( name = 'Content-Type' value = 'application/json' )`);
+		}
+	}
+	for (const h of headerParams) headerItems.push(`( name = '${escapeSingleQuotes(h.openapiName)}' value = ${h.name} )`);
+	if (headerItems.length > 0) args.push({
+		key: "headers",
+		value: `VALUE #( ${headerItems.join(" ")} )`
+	});
+	const head = "DATA(response) = client->fetch(";
+	if (args.length <= 2) return `${head} ${args.map((a) => `${a.key} = ${a.value}`).join(" ")} ).`;
+	const maxKey = Math.max(...args.map((a) => a.key.length));
+	const lines = [head];
+	args.forEach((a, idx) => {
+		const pad = " ".repeat(maxKey - a.key.length);
+		const tail = idx === args.length - 1 ? " )." : "";
+		lines.push(`  ${a.key}${pad} = ${a.value}${tail}`);
+	});
+	return lines.join("\n");
+}
+/** `'<path>'` when no path params, otherwise a `|...|` string template. */
+function renderPathValue(mapping) {
+	const pathParams = mapping.params.filter((p) => p.location === "path");
+	if (pathParams.length === 0) return `'${escapeSingleQuotes(mapping.path)}'`;
+	const byOriginal = /* @__PURE__ */ new Map();
+	for (const p of pathParams) byOriginal.set(p.openapiName, p.name);
+	let out = "|";
+	let i = 0;
+	const src = mapping.path;
+	while (i < src.length) {
+		const open = src.indexOf("{", i);
+		if (open === -1) {
+			out += src.slice(i);
+			break;
+		}
+		out += src.slice(i, open);
+		const close = src.indexOf("}", open);
+		if (close === -1) {
+			out += src.slice(open);
+			break;
+		}
+		const placeholder = src.slice(open + 1, close);
+		const abapName = byOriginal.get(placeholder) ?? placeholder;
+		out += `{ ${abapName} }`;
+		i = close + 1;
+	}
+	out += "|";
+	return out;
+}
+function decideSuccessBody(op, mapping) {
+	if (mapping.successIsEmptyBody) return {
+		kind: "empty",
+		returningName: mapping.returningName
+	};
+	const picked = pickSuccessResponse(op);
+	const schema = picked ? pickPreferredSchema(picked.content) : void 0;
+	if (schema !== void 0 && isBinarySchema(schema)) return {
+		kind: "binary",
+		returningName: mapping.returningName
+	};
+	return {
+		kind: "json",
+		returningName: mapping.returningName
+	};
+}
+function pickSuccessResponse(op) {
+	const twoXX = op.responses.filter((r) => /^2\d\d$/.test(r.statusCode)).sort((a, b) => Number(a.statusCode) - Number(b.statusCode));
+	if (twoXX.length > 0) return twoXX[0];
+	return op.responses.find((r) => r.statusCode === "default");
+}
+function pickRequestBodySchema(op) {
+	const rb = op.requestBody;
+	if (!rb) return void 0;
+	return pickPreferredSchema(rb.content);
+}
+function pickPreferredSchema(content) {
+	if (!content) return void 0;
+	const json = content["application/json"];
+	if (json !== void 0) return nonEmpty(json.schema);
+	const octet = content["application/octet-stream"];
+	if (octet !== void 0) return nonEmpty(octet.schema);
+	const first = Object.keys(content)[0];
+	if (first !== void 0) return nonEmpty(content[first].schema);
+}
+function nonEmpty(schema) {
+	if (schema === void 0) return void 0;
+	return Object.keys(schema).length > 0 ? schema : void 0;
+}
+function isBinarySchema(schema) {
+	if (!schema) return false;
+	if (isRef(schema)) return false;
+	const t = schema.type;
+	const f = schema.format;
+	return t === "string" && (f === "binary" || f === "byte");
+}
+function isBinaryRequestBody(op, schema) {
+	if (isBinarySchema(schema)) return true;
+	const content = op.requestBody?.content;
+	if (!content) return false;
+	const keys = Object.keys(content);
+	if (keys.length === 1 && keys[0] === "application/octet-stream") return true;
+	return false;
+}
+function escapeSingleQuotes(s) {
+	return s.replaceAll("'", "''");
+}
+
+//#endregion
+//#region src/generate.ts
+/**
+* End-to-end pipeline for the v2 openai-codegen emitter.
+*
+* Loads an OpenAPI spec, plans types, runs the Layer-1 / Layer-2 / exception
+* / implementation / local-class emitters, prints each ABAP node through
+* `@abapify/abap-ast`, and hands the four artifacts to the configured format
+* writer (`abapgit` or `gcts`).
+*/
+function assertSupportedTarget(target) {
+	if (target !== "s4-cloud") throw new Error(`generate: target "${target}" is not supported in v1 (only 's4-cloud').`);
+}
+function deriveDefaultServer(spec) {
+	const first = spec.servers[0]?.url;
+	if (!first || first.length === 0) return "/";
+	try {
+		const u = new URL(first);
+		return u.pathname && u.pathname.length > 0 ? u.pathname : "/";
+	} catch {
+		return first;
+	}
+}
+async function generate(options) {
+	const target = options.target ?? "s4-cloud";
+	let step = "validate-target";
+	try {
+		assertSupportedTarget(target);
+		step = "resolve-names";
+		const names = resolveNames(options.names);
+		step = "load-spec";
+		const spec = await loadSpec(options.input);
+		step = "plan-types";
+		const plan = planTypes(spec, { typePrefix: "" });
+		step = "emit-types-interface";
+		const typesIF = emitTypesInterface(spec, plan, {
+			name: names.typesInterface,
+			emitNullFlags: options.emitNullFlags ?? false,
+			interfaceAbapDoc: [`Generated types for ${names.implementationClass}.`]
+		});
+		step = "emit-operations-interface";
+		const opsIF = emitOperationsInterface(spec, plan, {
+			name: names.operationsInterface,
+			typesInterfaceName: names.typesInterface,
+			exceptionClassName: names.exceptionClass
+		});
+		step = "emit-exception-class";
+		const zcx = emitExceptionClass({ name: names.exceptionClass });
+		step = "emit-implementation-class";
+		const implResult = emitImplementationClass(spec, opsIF.operations, {
+			names,
+			defaultServer: options.defaultServer ?? deriveDefaultServer(spec)
+		});
+		step = "emit-local-classes";
+		const locals = emitLocalClasses(names);
+		step = "print";
+		const typesSource = print(typesIF.interface);
+		const opsSource = print(opsIF.interface);
+		const zcxSource = print(zcx.class);
+		const implSource = print(implResult.class);
+		step = "assemble-artifacts";
+		const types = {
+			name: names.typesInterface,
+			source: typesSource,
+			description: options.description ?? `Types for ${names.implementationClass}`
+		};
+		const operationsArtifact = {
+			name: names.operationsInterface,
+			source: opsSource,
+			description: options.description ?? `Operations for ${names.implementationClass}`
+		};
+		const exception = {
+			className: names.exceptionClass,
+			mainSource: zcxSource,
+			description: options.description ?? `Error exception for ${names.implementationClass}`
+		};
+		const implementation = {
+			className: names.implementationClass,
+			mainSource: implSource,
+			description: options.description ?? names.implementationClass,
+			localsDefSource: locals.localsDef,
+			localsImpSource: locals.localsImp
+		};
+		step = "write";
+		return {
+			files: (await writeClientBundle({
+				types,
+				operations: operationsArtifact,
+				exception,
+				implementation
+			}, options.format, options.outDir)).files,
+			resolvedNames: names,
+			typeCount: plan.entries.length,
+			operationCount: opsIF.operations.length
+		};
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		const wrapped = /* @__PURE__ */ new Error(`openai-codegen generate failed at step "${step}": ${message}`);
+		if (err instanceof Error && err.stack) wrapped.stack = err.stack;
+		throw wrapped;
+	}
+}
+
+//#endregion
+export { makeNameAllocator as C, isRef as D, normalizeSpec as E, UnsupportedSchemaError as S, loadSpec as T, mapSchemaToTypeDef as _, writeGctsLayout as a, CollisionError as b, mapResponseHandling as c, emitOperationsInterface as d, PolymorphismConflictError as f, mapPrimitive as g, resolveNames as h, writeGctsInterface as i, emitLocalClasses as l, NamesConfigError as m, writeClientBundle as n, writeAbapgitInterface as o, emitTypesInterface as p, writeLayout as r, writeAbapgitLayout as s, generate as t, emitExceptionClass as u, mapSchemaToTypeRef as v, sanitizeIdent as w, CyclicTypeError as x, planTypes as y };
+//# sourceMappingURL=generate-BobARM00.mjs.map