@lovrozagar/honey 0.6.8 → 0.7.1

package/src/rust-type-emitter.ts

@@ -1,90 +1,54 @@
 /* Rust type emitter — IR-based printer with raw-schema shims for backward compatibility. */
 
 import { schemaToIR } from "./codegen-ir.ts"
-import type { IRSchema } from "./codegen-ir.ts"
-import { goPascal } from "./go-type-emitter.ts"
-
-export const RUST_KEYWORDS = new Set([
-	"as",
-	"break",
-	"const",
-	"continue",
-	"crate",
-	"else",
-	"enum",
-	"extern",
-	"false",
-	"fn",
-	"for",
-	"if",
-	"impl",
-	"in",
-	"let",
-	"loop",
-	"match",
-	"mod",
-	"move",
-	"mut",
-	"pub",
-	"ref",
-	"return",
-	"self",
-	"Self",
-	"static",
-	"struct",
-	"super",
-	"trait",
-	"true",
-	"type",
-	"unsafe",
-	"use",
-	"where",
-	"while",
-	"async",
-	"await",
-	"dyn",
-	/* reserved / future */
-	"abstract",
-	"become",
-	"box",
-	"do",
-	"final",
-	"macro",
-	"override",
-	"priv",
-	"typeof",
-	"unsized",
-	"virtual",
-	"yield",
-	"try",
-])
+import type { IRField, IRSchema } from "./codegen-ir.ts"
+import {
+	NameScope,
+	RUST_KEYWORDS,
+	cmpCodeUnit,
+	pascalWords,
+	rustPlainSnake,
+	rustString,
+	rustTypeIdent,
+	rustValueIdent,
+	snakeWords,
+} from "./codegen-lang.ts"
+
+export { RUST_KEYWORDS }
 
 export function rustPascal(name: string): string {
-	return goPascal(name)
+	return rustTypeIdent(name)
 }
 
 export function rustSnake(name: string): string {
-	return name
-		.replace(/([a-z0-9])([A-Z])/g, "$1_$2")
-		.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
-		.replace(/[-\s]+/g, "_")
-		.replace(/[^a-zA-Z0-9_]/g, "_")
-		.toLowerCase()
+	return snakeWords(name) || "value"
 }
 
 /** Returns a safe Rust field identifier (snake_case; reserved keywords get `_` suffix). */
 export function rustIdent(name: string): string {
-	const snake = rustSnake(name)
-	if (RUST_KEYWORDS.has(snake)) return `${snake}_`
-	return snake
+	return rustPlainSnake(name)
 }
 
 /** Returns a safe Rust method identifier (snake_case; reserved keywords get `r#` raw-ident prefix). */
 export function rustMethodIdent(name: string): string {
-	const snake = rustSnake(name)
-	/* raw identifiers are the only valid escape for fn names — `_` suffix changes the API */
-	if (RUST_KEYWORDS.has(snake)) return `r#${snake}`
-	return snake
+	return rustValueIdent(name)
+}
+
+/** Crate-level naming shared by every type the SDK emits. */
+export type RustTypeNames = {
+	ref: (schemaName: string) => string
+	/** Unique crate-level type name; the same key always gets the same name. */
+	hoist: (key: string, base: string) => string
+	/** Component schemas on a by-value cycle; references to them are boxed. */
+	cyclic: Set<string>
+	resolve: (schema: IRSchema) => IRSchema
+}
+
+const DEFAULT_NAMES: RustTypeNames = {
+	cyclic: new Set(),
+	hoist: (_key, base) => base,
+	ref: (name) => rustPascal(name),
+	resolve: (s) => s,
 }
 
 export type RustRenderUseCtx = {
@@ -93,28 +57,34 @@ export type RustRenderUseCtx = {
 	decls: Map<string, string>
 	circularRefs?: Set<string>
 	depth?: number
+	names?: RustTypeNames
+}
+
+function variantName(raw: string, scope: NameScope): string {
+	const base = raw === "" ? "Empty" : rustTypeIdent(raw)
+	return scope.claim(base === "Self_" ? "SelfValue" : base)
 }
 
 function renderHoistedStringEnum(typeName: string, enumVals: unknown[]): string {
 	const l: string[] = []
 	l.push(`#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]`)
 	l.push(`pub enum ${typeName} {`)
-	for (const raw of enumVals.map(String)) {
-		const variant = rustPascal(raw)
-		if (raw !== variant) {
-			l.push(`\t#[serde(rename = ${JSON.stringify(raw)})]`)
-		}
+	const scope = new NameScope()
+	const variants: string[] = []
+	for (const raw of enumVals.filter((v) => v !== null).map(String)) {
+		const variant = variantName(raw, scope)
+		variants.push(variant)
+		if (raw !== variant) l.push(`\t#[serde(rename = ${rustString(raw)})]`)
 		l.push(`\t${variant},`)
 	}
 	l.push(`}`)
 	/* Separate impl block so the derive list stays unchanged — derive(Default) would require
 	 * #[default] on a variant, which breaks callers that assert the exact derive substring. */
-	if (enumVals.length > 0) {
-		const firstVariant = rustPascal(String(enumVals[0]))
+	if (variants.length > 0) {
 		l.push(``)
 		l.push(`impl Default for ${typeName} {`)
 		l.push(`\tfn default() -> Self {`)
-		l.push(`\t\tSelf::${firstVariant}`)
+		l.push(`\t\tSelf::${variants[0]}`)
 		l.push(`\t}`)
 		l.push(`}`)
 	}
@@ -128,6 +98,7 @@ function renderHoistedIntEnum(typeName: string, enumVals: unknown[]): string {
 	l.push(`pub enum ${typeName} {`)
 	for (const v of enumVals) {
 		const n = Number(v)
+		if (!Number.isInteger(n)) continue
 		const label = n >= 0 ? `L${n}` : `Neg${Math.abs(n)}`
 		l.push(`\t${label} = ${n},`)
 	}
@@ -160,23 +131,39 @@ function constBaseType(val: unknown): string {
 	return "String"
 }
 
+function hoist(ctx: RustRenderUseCtx, render: (name: string) => string): string {
+	const names = ctx.names ?? DEFAULT_NAMES
+	const name = names.hoist(`${ctx.parentName}.${ctx.fieldName}`, hoistEnumName(ctx.parentName, ctx.fieldName))
+	if (!ctx.decls.has(name)) {
+		/* placeholder prevents infinite recursion on self-referential schemas */
+		ctx.decls.set(name, "")
+		ctx.decls.set(name, render(name))
+	}
+	return name
+}
+
 /**
  * Render an IR schema as a Rust type expression for a struct field position.
  * Mutates `ctx.decls` when hoisting enums or anonymous structs.
  */
 export function irRenderUseRust(ir: IRSchema, ctx: RustRenderUseCtx, depth = 0): string {
 	if (depth > 12) return "serde_json::Value"
+	const names = ctx.names ?? DEFAULT_NAMES
 
 	switch (ir.kind) {
 		case "ref": {
-			const rustName = rustPascal(ir.name)
-			if (ctx.circularRefs?.has(rustName)) return `Box<${rustName}>`
+			const rustName = names.ref(ir.name)
+			if (ctx.circularRefs?.has(rustName) || names.cyclic.has(ir.name)) return `Box<${rustName}>`
 			return rustName
 		}
 
 		case "allOf": {
+			if (ctx.names && ir.parts.length > 1) {
+				return hoist(ctx, (name) => irRenderTopLevelRust(name, ir, ctx.decls, undefined, ctx.names))
+			}
 			const firstRef = ir.parts.find((p) => p.kind === "ref")
-			if (firstRef && firstRef.kind === "ref") return rustPascal(firstRef.name)
+			if (firstRef && firstRef.kind === "ref") return names.ref(firstRef.name)
+			if (ctx.names && ir.parts.length === 1) return irRenderUseRust(ir.parts[0], ctx, depth + 1)
 			return "serde_json::Value"
 		}
 
@@ -190,21 +177,17 @@ export function irRenderUseRust(ir: IRSchema, ctx: RustRenderUseCtx, depth = 0):
 		}
 
 		case "union": {
+			if (ctx.names) {
+				return hoist(ctx, (name) => irRenderTopLevelRust(name, ir, ctx.decls, undefined, ctx.names))
+			}
 			/* union at use-position → always serde_json::Value */
 			return "serde_json::Value"
 		}
 
 		case "scalar": {
 			if (ir.enum) {
-				const name = hoistEnumName(ctx.parentName, ctx.fieldName)
-				if (!ctx.decls.has(name)) {
-					if (ir.type === "string") {
-						ctx.decls.set(name, renderHoistedStringEnum(name, ir.enum as unknown[]))
-					} else {
-						ctx.decls.set(name, renderHoistedIntEnum(name, ir.enum as unknown[]))
-					}
-				}
-				return name
+				if (ir.type === "string") return hoist(ctx, (name) => renderHoistedStringEnum(name, ir.enum as unknown[]))
+				if (ir.type === "integer") return hoist(ctx, (name) => renderHoistedIntEnum(name, ir.enum as unknown[]))
 			}
 			const prim = primitiveFor(ir.type)
 			if (prim) return prim
@@ -216,8 +199,10 @@ export function irRenderUseRust(ir: IRSchema, ctx: RustRenderUseCtx, depth = 0):
 		}
 
 		case "array": {
-			const el = irRenderUseRust(ir.items, ctx, depth + 1)
-			return `Vec<${el}>`
+			const itemCtx = ctx.names ? { ...ctx, fieldName: `${ctx.fieldName}Item` } : ctx
+			const el = irRenderUseRust(ir.items, itemCtx, depth + 1)
+			/* a Vec already breaks a recursive cycle */
+			return `Vec<${el.startsWith("Box<") ? el.slice(4, -1) : el}>`
 		}
 
 		case "tuple": {
@@ -230,21 +215,14 @@ export function irRenderUseRust(ir: IRSchema, ctx: RustRenderUseCtx, depth = 0):
 
 			if (fields.length === 0) {
 				if (additional !== undefined && additional !== false) {
-					const valType = irRenderUseRust(additional, ctx, depth + 1)
-					return `HashMap<String, ${valType}>`
+					const valType = irRenderUseRust(additional, { ...ctx, fieldName: `${ctx.fieldName}Value` }, depth + 1)
+					return `std::collections::HashMap<String, ${valType.startsWith("Box<") ? valType.slice(4, -1) : valType}>`
 				}
 				if (additional === false) return "serde_json::Value"
-				return "HashMap<String, serde_json::Value>"
+				return "std::collections::HashMap<String, serde_json::Value>"
 			}
 
-			const hoistedName = hoistEnumName(ctx.parentName, ctx.fieldName)
-			if (!ctx.decls.has(hoistedName)) {
-				/* placeholder prevents infinite recursion on self-referential schemas */
-				ctx.decls.set(hoistedName, "")
-				const hoisted = irRenderTopLevelRust(hoistedName, ir, ctx.decls)
-				ctx.decls.set(hoistedName, hoisted)
-			}
-			return hoistedName
+			return hoist(ctx, (name) => irRenderTopLevelRust(name, ir, ctx.decls, undefined, ctx.names))
 		}
 
 		case "binary": {
@@ -257,6 +235,83 @@ export function irRenderUseRust(ir: IRSchema, ctx: RustRenderUseCtx, depth = 0):
 	}
 }
 
+type RustField = {
+	ident: string
+	key: string
+	type: string
+	required: boolean
+	/** Optional + nullable: `Option<Option<T>>`, absent / null / value. */
+	triState: boolean
+}
+
+function structFields(
+	typeName: string,
+	fields: IRField[],
+	scope: NameScope,
+	decls: Map<string, string>,
+	circularRefs: Set<string>,
+	names: RustTypeNames | undefined,
+): RustField[] {
+	return fields
+		.slice()
+		.sort((a, b) => cmpCodeUnit(a.name, b.name))
+		.map((field) => {
+			const ft = irRenderUseRust(field.schema, {
+				circularRefs,
+				decls,
+				depth: 1,
+				fieldName: field.name,
+				names,
+				parentName: typeName,
+			})
+			const triState = !field.required && field.schema.kind === "nullable"
+			let type: string
+			if (field.required) type = circularRefs.has(ft) && !ft.startsWith("Box<") ? `Box<${ft}>` : ft
+			else if (triState) type = `Option<${ft.startsWith("Option<") ? ft : `Option<${ft}>`}>`
+			else type = ft.startsWith("Option<") ? ft : `Option<${ft}>`
+			return { ident: claimField(field.name, scope), key: field.name, required: field.required, triState, type }
+		})
+}
+
+/** Field identifier unique in `scope`; a keyword gets a `_` suffix (`type` → `type_`). */
+function claimField(key: string, scope: NameScope): string {
+	return scope.claim(rustPlainSnake(key))
+}
+
+function pushField(l: string[], f: RustField): void {
+	const bare = f.ident.startsWith("r#") ? f.ident.slice(2) : f.ident
+	if (bare !== f.key) l.push(`\t#[serde(rename = ${rustString(f.key)})]`)
+	if (f.triState) {
+		l.push(
+			`\t#[serde(default, skip_serializing_if = "Option::is_none", deserialize_with = "crate::nullable::deserialize")]`,
+		)
+	} else if (!f.required) l.push(`\t#[serde(skip_serializing_if = "Option::is_none")]`)
+	l.push(`\tpub ${f.ident}: ${f.type},`)
+}
+
+function discriminatorValues(
+	variant: IRSchema,
+	propertyName: string,
+	mapping: Record<string, string> | undefined,
+	names: RustTypeNames,
+): string[] {
+	if (variant.kind === "ref") {
+		const mapped = mapping
+			? Object.entries(mapping)
+					.filter(([, t]) => t === variant.name)
+					.map(([k]) => k)
+			: []
+		if (mapped.length > 0) return mapped
+	}
+	const resolved = names.resolve(variant)
+	if (resolved.kind === "object") {
+		const f = resolved.fields.find((x) => x.name === propertyName)
+		if (f?.schema.kind === "const" && typeof f.schema.value === "string") return [f.schema.value]
+		if (f?.schema.kind === "scalar" && f.schema.enum) return f.schema.enum.map(String)
+	}
+	return variant.kind === "ref" ? [variant.name] : []
+}
+
 /**
  * `raw` 4th arg is for the const-with-declared-type branch only: IR `const` kind
  * strips the type field; `raw.type` provides the override.
@@ -266,19 +321,19 @@ export function irRenderTopLevelRust(
 	ir: IRSchema,
 	decls: Map<string, string>,
 	raw?: Record<string, unknown>,
+	names?: RustTypeNames,
 ): string {
-	const typeName = rustPascal(name)
+	const n = names ?? DEFAULT_NAMES
+	const typeName = names ? name : rustPascal(name)
 	const circularRefs = new Set([typeName])
 
 	if (ir.kind === "scalar" && ir.enum) {
-		if (ir.type === "string") {
-			return renderHoistedStringEnum(typeName, ir.enum as unknown[])
-		}
-		return renderHoistedIntEnum(typeName, ir.enum as unknown[])
+		if (ir.type === "string") return renderHoistedStringEnum(typeName, ir.enum as unknown[])
+		if (ir.type === "integer") return renderHoistedIntEnum(typeName, ir.enum as unknown[])
 	}
 
 	if (ir.kind === "const") {
-		const rawType = raw?.type as string | undefined
+		const rawType = ir.type ?? (raw?.type as string | undefined)
 		const base = rawType ? (primitiveFor(rawType) ?? "String") : constBaseType(ir.value)
 		return [`#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]`, `pub struct ${typeName}(pub ${base});`].join(
 			"\n",
@@ -289,45 +344,79 @@ export function irRenderTopLevelRust(
 		const l: string[] = []
 		l.push(`#[derive(Debug, Clone, Serialize, Deserialize)]`)
 		l.push(`pub struct ${typeName} {`)
+		const scope = new NameScope()
 		for (const part of ir.parts) {
 			if (part.kind === "ref") {
-				const refName = rustPascal(part.name)
+				const refName = n.ref(part.name)
 				l.push(`\t#[serde(flatten)]`)
-				l.push(`\tpub ${rustIdent(refName.toLowerCase())}: ${refName},`)
+				l.push(`\tpub ${claimField(refName, scope)}: ${refName},`)
 				continue
 			}
 			if (part.kind !== "object") continue
-			const sorted = part.fields.slice().sort((a, b) => a.name.localeCompare(b.name))
-			for (const field of sorted) {
-				const fieldIdent = rustIdent(field.name)
-				const ft = irRenderUseRust(field.schema, {
-					circularRefs,
-					decls,
-					depth: 1,
-					fieldName: field.name,
-					parentName: typeName,
-				})
-				const finalType = !field.required && !ft.startsWith("Option<") ? `Option<${ft}>` : ft
-				const needsRename = fieldIdent !== field.name
-				const needsSkip = !field.required
-				if (needsRename) {
-					l.push(`\t#[serde(rename = ${JSON.stringify(field.name)})]`)
-				}
-				if (needsSkip) {
-					l.push(`\t#[serde(skip_serializing_if = "Option::is_none")]`)
+			for (const f of structFields(typeName, part.fields, scope, decls, circularRefs, names)) pushField(l, f)
+		}
+		l.push(`}`)
+		return l.join("\n")
+	}
+
+	if (ir.kind === "union" && ir.discriminator && names) {
+		const prop = ir.discriminator.propertyName
+		const scope = new NameScope(["Unknown"])
+		const variants: Array<{ variant: string; type: string; values: string[] }> = []
+		ir.variants.forEach((v, i) => {
+			const values = discriminatorValues(v, prop, ir.discriminator?.mapping, n)
+			let type: string
+			if (v.kind === "ref") type = n.ref(v.name)
+			else if (v.kind === "object") {
+				type = n.hoist(`${typeName}.variant${i}`, `${typeName}${rustPascal(values[0] ?? `Variant${i}`)}`)
+				if (!decls.has(type)) {
+					decls.set(type, "")
+					decls.set(type, irRenderTopLevelRust(type, v, decls, undefined, names))
 				}
-				l.push(`\tpub ${fieldIdent}: ${finalType},`)
-			}
+			} else return
+			variants.push({ type, values, variant: variantName(values[0] ?? type, scope) })
+		})
+		const l: string[] = []
+		l.push(`/// ${typeName} holds exactly one variant, selected by the ${rustString(prop)} property.`)
+		l.push(`/// A tag no variant declares deserializes to \`Unknown\` with the raw payload.`)
+		l.push(`#[derive(Debug, Clone)]`)
+		l.push(`pub enum ${typeName} {`)
+		for (const v of variants) l.push(`\t${v.variant}(${v.type}),`)
+		l.push(`\tUnknown(serde_json::Value),`)
+		l.push(`}`)
+		l.push(``)
+		l.push(`impl Serialize for ${typeName} {`)
+		l.push(`\tfn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {`)
+		l.push(`\t\tmatch self {`)
+		for (const v of variants) l.push(`\t\t\t${typeName}::${v.variant}(v) => v.serialize(s),`)
+		l.push(`\t\t\t${typeName}::Unknown(v) => v.serialize(s),`)
+		l.push(`\t\t}`)
+		l.push(`\t}`)
+		l.push(`}`)
+		l.push(``)
+		l.push(`impl<'de> Deserialize<'de> for ${typeName} {`)
+		l.push(`\tfn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {`)
+		l.push(`\t\tlet v = serde_json::Value::deserialize(d)?;`)
+		l.push(`\t\tlet tag = v.get(${rustString(prop)}).and_then(|t| t.as_str()).unwrap_or_default().to_string();`)
+		l.push(`\t\tmatch tag.as_str() {`)
+		for (const v of variants) {
+			if (v.values.length === 0) continue
+			l.push(
+				`\t\t\t${v.values.map(rustString).join(" | ")} => serde_json::from_value(v).map(${typeName}::${v.variant}).map_err(serde::de::Error::custom),`,
+			)
 		}
+		l.push(`\t\t\t_ => Ok(${typeName}::Unknown(v)),`)
+		l.push(`\t\t}`)
+		l.push(`\t}`)
 		l.push(`}`)
 		return l.join("\n")
 	}
 
 	if (ir.kind === "union" && ir.discriminator) {
-		const discProp = ir.discriminator.propertyName
+		/* legacy shim path (no naming context): serde's internal tagging */
 		const l: string[] = []
 		l.push(`#[derive(Debug, Clone, Serialize, Deserialize)]`)
-		l.push(`#[serde(tag = ${JSON.stringify(discProp)})]`)
+		l.push(`#[serde(tag = ${rustString(ir.discriminator.propertyName)})]`)
 		l.push(`pub enum ${typeName} {`)
 		for (const v of ir.variants) {
 			if (v.kind === "ref") {
@@ -342,25 +431,49 @@ export function irRenderTopLevelRust(
 	}
 
 	if (ir.kind === "union") {
+		const consts = ir.variants.filter(
+			(v): v is Extract<IRSchema, { kind: "const" }> => v.kind === "const" && typeof v.value === "string",
+		)
+		if (names && consts.length > 0 && consts.length === ir.variants.length) {
+			return renderHoistedStringEnum(
+				typeName,
+				consts.map((c) => c.value),
+			)
+		}
 		const l: string[] = []
 		l.push(`#[derive(Debug, Clone, Serialize, Deserialize)]`)
 		l.push(`#[serde(untagged)]`)
 		l.push(`pub enum ${typeName} {`)
-		for (let i = 0; i < ir.variants.length; i++) {
-			const v = ir.variants[i]
+		const others = names ? ir.variants.filter((v) => !consts.includes(v as never)) : ir.variants
+		if (names && consts.length > 0) {
+			/* const strings as one string enum, tried first: a unit variant cannot match a string */
+			const literal = n.hoist(`${typeName}.literal`, `${typeName}Literal`)
+			if (!decls.has(literal))
+				decls.set(
+					literal,
+					renderHoistedStringEnum(
+						literal,
+						consts.map((c) => c.value),
+					),
+				)
+			l.push(`\tLiteral(${literal}),`)
+		}
+		for (let i = 0; i < others.length; i++) {
+			const v = others[i]
+			const index = ir.variants.indexOf(v)
 			if (v.kind === "ref") {
-				const refName = rustPascal(v.name)
-				l.push(`\tVariant${i}(${refName}),`)
+				const refName = n.ref(v.name)
+				l.push(`\tVariant${index}(${n.cyclic.has(v.name) ? `Box<${refName}>` : refName}),`)
 			} else {
 				const inner = irRenderUseRust(v, {
 					circularRefs,
 					decls,
 					depth: 1,
-					fieldName: `variant${i}`,
+					fieldName: `variant${index}`,
+					names,
 					parentName: typeName,
 				})
-				const finalType = inner === "serde_json::Value" ? "serde_json::Value" : inner
-				l.push(`\tVariant${i}(${finalType}),`)
+				l.push(`\tVariant${index}(${inner}),`)
 			}
 		}
 		l.push(`}`)
@@ -375,45 +488,23 @@ export function irRenderTopLevelRust(
 				circularRefs,
 				decls,
 				fieldName: "Value",
+				names,
 				parentName: typeName,
 			})
-			return `pub type ${typeName} = HashMap<String, ${valType}>;`
+			return `pub type ${typeName} = std::collections::HashMap<String, ${valType}>;`
 		}
 
 		if (fields.length === 0) {
 			if (additional === false) return `#[derive(Debug, Clone, Serialize, Deserialize)]\npub struct ${typeName};`
-			return `pub type ${typeName} = HashMap<String, serde_json::Value>;`
+			return `pub type ${typeName} = std::collections::HashMap<String, serde_json::Value>;`
 		}
 
-		const sorted = fields.slice().sort((a, b) => a.name.localeCompare(b.name))
+		const scope = new NameScope()
+		const extraIdent = additional ? scope.claim("extra") : ""
 		const l: string[] = []
 		l.push(`#[derive(Debug, Clone, Serialize, Deserialize)]`)
 		l.push(`pub struct ${typeName} {`)
-		for (const field of sorted) {
-			const fieldIdent = rustIdent(field.name)
-			const ft = irRenderUseRust(field.schema, {
-				circularRefs,
-				decls,
-				depth: 1,
-				fieldName: field.name,
-				parentName: typeName,
-			})
-			let finalType: string
-			if (field.required) {
-				finalType = circularRefs.has(ft) && !ft.startsWith("Box<") ? `Box<${ft}>` : ft
-			} else {
-				finalType = ft.startsWith("Option<") ? ft : `Option<${ft}>`
-			}
-			const needsRename = fieldIdent !== field.name
-			const needsSkip = !field.required
-			if (needsRename) {
-				l.push(`\t#[serde(rename = ${JSON.stringify(field.name)})]`)
-			}
-			if (needsSkip) {
-				l.push(`\t#[serde(skip_serializing_if = "Option::is_none")]`)
-			}
-			l.push(`\tpub ${fieldIdent}: ${finalType},`)
-		}
+		for (const f of structFields(typeName, fields, scope, decls, circularRefs, names)) pushField(l, f)
 
 		if (additional) {
 			const valType = irRenderUseRust(additional, {
@@ -421,10 +512,11 @@ export function irRenderTopLevelRust(
 				decls,
 				depth: 1,
 				fieldName: "Extra",
+				names,
 				parentName: typeName,
 			})
 			l.push(`\t#[serde(flatten)]`)
-			l.push(`\tpub extra: HashMap<String, ${valType}>,`)
+			l.push(`\tpub ${extraIdent}: std::collections::HashMap<String, ${valType}>,`)
 		}
 
 		l.push(`}`)
@@ -435,6 +527,7 @@ export function irRenderTopLevelRust(
 		circularRefs,
 		decls,
 		fieldName: "Value",
+		names,
 		parentName: typeName,
 	})
 	return `pub type ${typeName} = ${aliased};`
@@ -451,3 +544,5 @@ export function renderUseRust(schema: Record<string, unknown> | undefined, ctx:
 export function renderTopLevelRust(name: string, schema: Record<string, unknown>, decls: Map<string, string>): string {
 	return irRenderTopLevelRust(name, schemaToIR(schema), decls, schema)
 }
+
+export { pascalWords }

package/src/secure-headers.ts

@@ -1,5 +1,6 @@
 import { namedMiddleware } from "./middleware.ts"
 import type { MiddlewareFn } from "./middleware.ts"
+import { withHeaders } from "./with-headers.ts"
 
 type SecureHeadersOptions = {
 	contentSecurityPolicy?: string
@@ -58,12 +59,15 @@ export function secureHeaders(options?: SecureHeadersOptions): MiddlewareFn<{},
 		headers.push(["cross-origin-embedder-policy", opts.crossOriginEmbedderPolicy])
 	}
 
+	/* A header the handler already set wins: a route with a stricter CSP or
+	 * `X-Frame-Options: DENY` must not be loosened by the app-wide default. */
 	const mw: MiddlewareFn<{}, {}> = async (_ctx, next) => {
 		const response = await next()
-		for (const [name, value] of headers) {
-			response.headers.set(name, value)
-		}
-		return response
+		return withHeaders(response, (out) => {
+			for (const [name, value] of headers) {
+				if (!out.has(name)) out.set(name, value)
+			}
+		})
 	}
 
 	return namedMiddleware("secureHeaders", mw)

package/src/serve-register.ts

@@ -1,6 +1,10 @@
 import { startHoneyServer } from "./serve.ts"
 import { registerServeRuntime } from "./serve-slot.ts"
 
+export type { HoneyServeOptions, ServeHandle } from "./serve.ts"
+/** Starts a server for `app` on the given runtime. Production build entries call this directly. */
+export { startHoneyServer }
+
 export function enableServe(): void {
 	registerServeRuntime((app, options) => startHoneyServer(app as never, options))
 }