typespec-http-zod 0.5.0 → 0.7.0

package/dist/src/api.d.ts

@@ -211,6 +211,8 @@ export interface EmittedRoute {
     readonly alternateResponseSchema: string | undefined;
 }
 export declare function collectRoutes(program: Program, registry: SchemaRegistry, service: HttpService): EmittedRoute[];
+/** Whether emitted source references `name` as an identifier rather than as part of a longer one. */
+export declare function referencedIn(source: string, name: string): boolean;
 /**
  * The identifiers a route's validators are declared under, by what the DOCUMENT calls each one.
  *

package/dist/src/api.js

@@ -1,11 +1,11 @@
 import { emitFile, getDoc, getEncode, getSummary, isErrorModel, isNeverType, isVoidType, resolvePath, } from "@typespec/compiler";
 import { getAuthenticationForOperation, resolveRequestVisibility, Visibility, } from "@typespec/http";
-import { resolveOperationId } from "@typespec/openapi";
+import { getOperationId, resolveOperationId } from "@typespec/openapi";
 import { reportDiagnostic } from "./lib.js";
 import { SchemaRegistry, TypeRegistry } from "./registry.js";
 import { resolveStreamModule, streamedTypeOf, withStreamModule } from "./streams.js";
 import { resolveVersioningModule, serviceSnapshots } from "./versioning.js";
-import { collectExternalImports, noteDeclaredVocabularies, noteKeyVocabularies, objectKey, withContractsPackage, withSealedObjects, withVisibility, } from "./zod.js";
+import { collectExternalImports, noteDeclaredVocabularies, noteKeyVocabularies, objectKey, wireKindOf, withContractsPackage, withSealedObjects, withVisibility, } from "./zod.js";
 /**
  * `typespec-http-zod` - Zod validators and framework-free contract types from a TypeSpec HTTP
  * service, agreeing with the OpenAPI document `@typespec/openapi3` publishes from the same source.
@@ -90,6 +90,89 @@ export function successStatusesOf(operation) {
     }
     return [...new Set(codes)].toSorted((a, b) => a - b);
 }
+/**
+ * **Operation ids, deduplicated the way `@typespec/openapi3` deduplicates them.**
+ *
+ * `resolveOperationId` derives an id from the immediate parent container, so two interfaces of the
+ * same name in different namespaces both resolve to `Standard_primitive`. Every per-operation
+ * declaration here is keyed on that id, so colliding ids emitted colliding `const`s:
+ * `TS2451: Cannot redeclare block-scoped variable 'Standard_primitiveResponses'`, 72 of them on one
+ * conformance scenario, from a compile that reported success.
+ *
+ * **The document does NOT have this problem, so refusing the spec would be wrong.** Measured on
+ * 1.15.0, openapi3 publishes `Standard_primitive` and `Standard_primitive_2` - it deduplicates, and
+ * the document is valid. The same source is representable there, so it has to be representable here,
+ * and matching its ids is also what keeps the promise that identifiers are named from the operation
+ * id the document publishes.
+ *
+ * The rule is copied from `OperationIdResolver` rather than invented, including the parts that look
+ * incidental: an explicit `@operationId` wins and is NOT deduplicated or reserved, and the suffix
+ * counts from `_2`. It is not exported, so it is reproduced here and the differential compares the
+ * result against the document's own ids.
+ */
+let operationIds;
+/**
+ * Establish a fresh id resolver for one service's emission.
+ *
+ * **Scoped per SERVICE rather than per walk, because the walks see different subsets.**
+ * `collectRoutes` visits every operation with a success status; `collectRequestTypes` skips any with
+ * no body and no parameters. Deduplicating independently would let the two assign a suffix to
+ * different operations, and the artefacts would name one operation two ways.
+ *
+ * A reset rather than a wrapper, because the emission loop is `for (const snapshot of snapshots)`
+ * and awaits each service to completion before the next begins. Nothing interleaves, so there is no
+ * scope to restore, and wrapping an async body would mean threading a callback through every
+ * `emitFile` between the three walks.
+ *
+ * Left `undefined` outside an emission on purpose: `collectRoutes` is exported and a caller reaching
+ * it directly gets `resolveOperationId`'s answer unchanged rather than a suffix that depends on
+ * whatever ran before.
+ */
+function beginOperationIds() {
+    operationIds = { used: new Set(), assigned: new Set(), cache: new Map() };
+}
+/** The id this operation is emitted under, unique within the emission. */
+function operationIdOf(program, operation) {
+    const scope = operationIds;
+    const resolved = resolveOperationId(program, operation);
+    if (scope === undefined)
+        return resolved;
+    const cached = scope.cache.get(operation);
+    if (cached !== undefined)
+        return cached;
+    // An explicit `@operationId` is used as given: openapi3 neither deduplicates nor reserves it.
+    const explicit = getOperationId(program, operation) !== undefined;
+    let name = resolved;
+    if (!explicit && scope.used.has(name)) {
+        let count = 1;
+        for (;;) {
+            count += 1;
+            const candidate = `${resolved}_${count}`;
+            if (!scope.used.has(candidate)) {
+                name = candidate;
+                break;
+            }
+        }
+    }
+    if (!explicit)
+        scope.used.add(name);
+    scope.cache.set(operation, name);
+    /**
+     * **Checked after the id is settled, and reachable only through an explicit `@operationId`.** A
+     * derived id is deduplicated against `used` and cannot arrive here twice; an explicit one is never
+     * reserved, so it can equal an id already handed out, in either direction. Reported once per
+     * operation, because the cache above returns before this on every later walk.
+     */
+    if (scope.assigned.has(name)) {
+        reportDiagnostic(program, {
+            code: "duplicate-operation-id",
+            format: { operationId: name },
+            target: operation,
+        });
+    }
+    scope.assigned.add(name);
+    return name;
+}
 /** The five buckets OpenAPI can express a status RANGE as, in the order it names them. */
 const STATUS_RANGE_GROUPS = [1, 2, 3, 4, 5];
 /**
@@ -365,6 +448,21 @@ function responseContentTypesOf(operation, status) {
     }
     return [...types];
 }
+/** The type a parameter actually crosses the wire as, after any `@encode` on the property. */
+function encodedParameterType(program, property) {
+    return getEncode(program, property)?.type ?? property.type;
+}
+/**
+ * The wire kind of an ARRAY parameter's elements, or `undefined` where it is not such an array.
+ *
+ * `?ids=1,2,3` splits into strings, so each element needs the same decoding a lone scalar would.
+ */
+function elementKindOf(program, type) {
+    if (!isArrayType(type) || type.kind !== "Model")
+        return undefined;
+    const element = type.indexer?.value;
+    return element === undefined ? undefined : wireKindOf(program, element);
+}
 /** Whether a type is an array - TypeSpec models one as a `Model` carrying an integer indexer. */
 function isArrayType(type) {
     return type.kind === "Model" && type.indexer?.key.name === "integer";
@@ -583,12 +681,12 @@ function collectionDelimiterOf(program, parameter) {
  * `zod.ts` decides what becomes `z.number()`, and a second copy of that list here would stop agreeing
  * with it silently.
  */
-function wireDecoded(declared) {
+function wireDecoded(declared, kind, elementKind) {
     const NUMBER = '(raw) => (typeof raw === "string" && raw.trim() !== "" && Number.isFinite(Number(raw)) ? Number(raw) : raw)';
     const BOOLEAN = '(raw) => (raw === "true" ? true : raw === "false" ? false : raw)';
-    if (declared.startsWith("z.number()"))
+    if (kind === "number")
         return `z.preprocess(${NUMBER}, ${declared})`;
-    if (declared.startsWith("z.boolean()"))
+    if (kind === "boolean")
         return `z.preprocess(${BOOLEAN}, ${declared})`;
     /**
      * A list whose ELEMENTS are numeric or boolean - `?ids=1,2,3` after the collection split, or a
@@ -596,10 +694,8 @@ function wireDecoded(declared) {
      * the same decoder applies per element. A non-array value is left alone; the split that produces
      * the array runs outside this and may not have happened.
      */
-    const element = /^z\.array\((z\.(?:number|boolean)\(\).*)\)$/s.exec(declared);
-    if (element !== null) {
-        const inner = element[1] ?? "";
-        const decoder = inner.startsWith("z.number()") ? NUMBER : BOOLEAN;
+    if (elementKind !== undefined) {
+        const decoder = elementKind === "number" ? NUMBER : BOOLEAN;
         return `z.preprocess((raw) => (Array.isArray(raw) ? raw.map(${decoder}) : raw), ${declared})`;
     }
     return declared;
@@ -688,7 +784,14 @@ function parameterSchemasOf(program, operation, registry) {
          */
         const decoded = parameter.type === "header" && parameter.name.toLowerCase() === "content-type"
             ? mediaTypeDecoded(declared)
-            : wireDecoded(declared);
+            : wireDecoded(declared, 
+            /**
+             * `@encode` on the PROPERTY changes what crosses the wire, so the encoded type is
+             * the one to read. `@encode("unixTimestamp", int32) value: utcDateTime` is a number
+             * on the wire and a date in the spec, and reading the declared type alone stopped
+             * eighteen such parameters being decoded.
+             */
+            wireKindOf(program, encodedParameterType(program, parameter.param)), elementKindOf(program, encodedParameterType(program, parameter.param)));
         /**
          * The boxing half of the same principle: an exploded array's single occurrence arrives as a
          * bare string, so it is boxed into the one-element array the document describes before the
@@ -773,7 +876,7 @@ export function collectRoutes(program, registry, service) {
                 ? (bodyParameter?.property?.name ?? "body")
                 : undefined;
             routes.push({
-                operationId: resolveOperationId(program, operation.operation),
+                operationId: operationIdOf(program, operation.operation),
                 verb: operation.verb.toUpperCase(),
                 /**
                  * The path TEMPLATE, exactly as the document publishes it - `/widgets/{widget-id}`.
@@ -875,11 +978,40 @@ export function collectRoutes(program, registry, service) {
  * Emitting the whole set into both would leave unused imports (which lint rejects); emitting it into
  * neither is what left `routes.gen.ts` referencing `isParsableInstant` with no import at all.
  */
+/**
+ * Every identifier the emitted source mentions.
+ *
+ * **Tokenised once on the language's own identifier rule, then tested by equality.** The question is
+ * "does this file reference this name", and the two obvious ways to ask it are both wrong in ways
+ * that only appear for particular names.
+ *
+ * A pattern built from the name is wrong when the name carries a regular-expression metacharacter.
+ * `$` is a valid identifier character in JavaScript and in TypeSpec, and an anchor in a pattern, so
+ * `new RegExp(`\b${name}\b`)` reports `foo$bar` absent from source that references it verbatim -
+ * and the import is dropped, leaving the emitted module referencing an undeclared name. Escaping
+ * alone does not fix it either, because `\b` is a WORD boundary and `$` is not a word character, so
+ * there is no boundary before it to match.
+ *
+ * A substring test is wrong in the other direction: `Foo` is found inside `FooExtra`, emitting an
+ * import the file never uses. That one fails loudly at lint, which makes it the better mistake, but
+ * it is still a mistake.
+ *
+ * Tokenising has neither, needs no escaping to stay correct, and is one pass rather than one pattern
+ * per name. `typespec-hono` arrived at it after the same defect went live there: a spec whose every
+ * identifier carried a `$` emitted a file that imported nothing and did not compile.
+ */
+function identifiersIn(source) {
+    return new Set(source.match(/[A-Za-z_$][A-Za-z0-9_$]*/g) ?? []);
+}
+/** Whether emitted source references `name` as an identifier rather than as part of a longer one. */
+export function referencedIn(source, name) {
+    return identifiersIn(source).has(name);
+}
 function renderExternalImports(externals, ...bodies) {
     const haystack = bodies.join("\n");
     const lines = [];
     for (const [module, names] of externals) {
-        const used = [...names].filter((name) => new RegExp(`\\b${name}\\b`).test(haystack));
+        const used = [...names].filter((name) => referencedIn(haystack, name));
         if (used.length > 0) {
             lines.push(`import { ${used.toSorted().join(", ")} } from ${JSON.stringify(module)};\n`);
         }
@@ -1137,7 +1269,7 @@ function collectRequestTypes(program, registry, service) {
                 ? "ArrayBuffer"
                 : "string";
             entries.push({
-                operationId: resolveOperationId(program, operation.operation),
+                operationId: operationIdOf(program, operation.operation),
                 bodyRef: rawBody !== undefined
                     ? `{\n\t${rawBody}: ${rawBodyType};\n}`
                     : body === undefined
@@ -1169,7 +1301,7 @@ function collectResponseTypes(program, registry, service) {
             if (body === undefined)
                 continue;
             entries.push({
-                operationId: resolveOperationId(program, operation.operation),
+                operationId: operationIdOf(program, operation.operation),
                 ref: registry.expressionFor(body),
             });
         }
@@ -1408,6 +1540,7 @@ export async function emitHttpZod(context, wrapper = {}) {
      */
     const distinctServices = new Set(snapshots.map((snapshot) => snapshot.service.namespace.name));
     for (const snapshot of snapshots) {
+        beginOperationIds();
         const service = snapshot.service;
         const serviceName = service.namespace.name;
         const perService = options.services?.[serviceName];

package/dist/src/lib.d.ts

@@ -121,8 +121,14 @@ export declare const $lib: import("@typespec/compiler").TypeSpecLibrary<{
     "unsupported-status-code-range": {
         readonly default: import("@typespec/compiler").CallableMessage<["start", "end"]>;
     };
+    "duplicate-operation-id": {
+        readonly default: import("@typespec/compiler").CallableMessage<["operationId"]>;
+    };
+    "duplicate-declaration": {
+        readonly default: import("@typespec/compiler").CallableMessage<["name"]>;
+    };
 }, EmitterOptions, never>;
-export declare const reportDiagnostic: <C extends "empty-union" | "undeclared-discriminator" | "unknown-key-vocabulary" | "unsupported-default" | "unsupported-status-code-range" | "unsupported-type", M extends keyof {
+export declare const reportDiagnostic: <C extends "duplicate-declaration" | "duplicate-operation-id" | "empty-union" | "undeclared-discriminator" | "unknown-key-vocabulary" | "unsupported-default" | "unsupported-status-code-range" | "unsupported-type", M extends keyof {
     "unsupported-type": {
         readonly default: import("@typespec/compiler").CallableMessage<["artefact", "kind", "why", "remedy"]>;
     };
@@ -141,6 +147,12 @@ export declare const reportDiagnostic: <C extends "empty-union" | "undeclared-di
     "unsupported-status-code-range": {
         readonly default: import("@typespec/compiler").CallableMessage<["start", "end"]>;
     };
+    "duplicate-operation-id": {
+        readonly default: import("@typespec/compiler").CallableMessage<["operationId"]>;
+    };
+    "duplicate-declaration": {
+        readonly default: import("@typespec/compiler").CallableMessage<["name"]>;
+    };
 }[C]>(program: import("@typespec/compiler").Program, diag: import("@typespec/compiler").DiagnosticReport<{
     "unsupported-type": {
         readonly default: import("@typespec/compiler").CallableMessage<["artefact", "kind", "why", "remedy"]>;
@@ -160,4 +172,10 @@ export declare const reportDiagnostic: <C extends "empty-union" | "undeclared-di
     "unsupported-status-code-range": {
         readonly default: import("@typespec/compiler").CallableMessage<["start", "end"]>;
     };
+    "duplicate-operation-id": {
+        readonly default: import("@typespec/compiler").CallableMessage<["operationId"]>;
+    };
+    "duplicate-declaration": {
+        readonly default: import("@typespec/compiler").CallableMessage<["name"]>;
+    };
 }, C, M>) => void;

package/dist/src/lib.js

@@ -155,6 +155,47 @@ const diagnostics = {
             default: paramMessage `Status code range '${"start"}' to '${"end"}' cannot be published: OpenAPI can only key a range as 1XX, 2XX, 3XX, 4XX or 5XX, so no document states what this response carries and no validator may be emitted for it. Cover a whole group (\`@minValue(400) @maxValue(499)\` for 4XX) or declare the codes individually.`,
         },
     },
+    /**
+     * An explicit `@operationId` another operation already answers to.
+     *
+     * **Derived ids are deduplicated and this one cannot be.** `resolveOperationId` names an operation
+     * from its immediate parent container, so two interfaces of the same name collide, and openapi3
+     * resolves that by appending `_2`. It does NOT do so for an explicit `@operationId`: that id is
+     * returned exactly as written and is never reserved, because the author asked for that name and
+     * renaming it silently would break every client generated against the document.
+     *
+     * So a colliding explicit id is a document OpenAPI forbids, `operationId` must be unique, and
+     * openapi3 raises nothing and publishes the duplicate. Every declaration here is keyed on the id,
+     * so the emitted file declares each name twice and fails with `TS2451: Cannot redeclare
+     * block-scoped variable` from a compile that reported success.
+     *
+     * **This is the one collision worth refusing.** The derived case is representable and is emitted.
+     * This one cannot be resolved without contradicting what the author explicitly wrote.
+     */
+    "duplicate-operation-id": {
+        severity: "error",
+        messages: {
+            default: paramMessage `'${"operationId"}' is already the operation id of another operation, and OpenAPI requires it to be unique. An explicit '@operationId' is never renamed to make room, so this cannot be resolved for you. Give this operation an id no other operation uses, or remove the '@operationId' and let it be derived.`,
+        },
+    },
+    /**
+     * Two declarations claiming one TypeScript name with different bodies.
+     *
+     * **A repeat of the SAME declaration is not this and is dropped silently.** Visibility projection
+     * hands the registry a different `Type` object for one declared model, so a model reached under two
+     * visibilities is registered twice and renders identically; emitting both produced two
+     * byte-identical `export interface BodyModel` and a file that does not compile.
+     *
+     * This is the other case: one name, two different shapes. The document distinguishes them by
+     * namespace and a TypeScript module cannot, so keeping the first would publish a contract for a
+     * type nothing checks, and picking either is a guess about which the author meant.
+     */
+    "duplicate-declaration": {
+        severity: "error",
+        messages: {
+            default: paramMessage `Two different types are both named '${"name"}', and a TypeScript module cannot declare one name twice. The document tells them apart by namespace; this file cannot. Give one of them a different name, or set an explicit one with '@friendlyName'.`,
+        },
+    },
 };
 export const $lib = createTypeSpecLibrary({
     name: "typespec-http-zod",

package/dist/src/registry.d.ts

@@ -95,14 +95,6 @@ export interface TsDeclaration {
     readonly isVocabulary: boolean;
     readonly source: string;
 }
-/**
- * The same walk as {@link SchemaRegistry}, emitting plain TypeScript instead of Zod.
- *
- * Kept as a separate class rather than a mode on the schema registry because the two produce
- * different *kinds* of declaration - an `interface` versus a `const` - and their reference resolvers
- * hand back different text. Sharing {@link declaredNameOf} is the part that matters: a model named in
- * one artefact is named the same way in the other, so the emitted assertion can pair them by name.
- */
 export declare class TypeRegistry {
     #private;
     constructor(program: Program);

package/dist/src/registry.js

@@ -1,4 +1,5 @@
 import { getVisibilitySuffix, Visibility } from "@typespec/http";
+import { reportDiagnostic } from "./lib.js";
 import { propertyToTs, typeToTsBody, withTsRefResolver } from "./types.js";
 import { captureBackEdges, currentVisibility, isTransformedBy, noteBackEdge, propertyToZod, typeToZodBody, withRefResolver, withSyntheticDeclarations, } from "./zod.js";
 /**
@@ -63,10 +64,78 @@ required = [...type.properties.keys()]) {
     return model.name === "" ? spreadSourceOf(model, new Set([...seen, type]), required) : model;
 }
 const spreadSourceName = (type) => spreadSourceOf(type)?.name;
+/**
+ * ECMAScript's reserved words, which cannot name a TypeScript declaration.
+ *
+ * **A model may be named after one, and the corpus declares exactly that on purpose.** `special-words`
+ * carries `await`, `break` and the rest, and this emitter wrote `export interface await { ... }` and
+ * `export type break = z.infer<...>`, neither of which parses - `TS2427`, then the parser gives up
+ * and the whole file is lost.
+ *
+ * **This is a LIST, which this package otherwise refuses.** It is defensible here because it is
+ * not a list about our own code that drifts as the code changes: it is a closed set the language
+ * specification fixes. The guard is that `tsc` compiles a fixture declaring models named after these,
+ * so a word missing from the list fails a test rather than reaching a consumer - the list is the
+ * implementation and the compiler is the oracle.
+ *
+ * Contextual keywords are deliberately absent, because they are legal: `interface`, `string`,
+ * `number`, `any`, `never`, `public` and `yield` all name a type without complaint. Measured, rather
+ * than assumed from a language reference.
+ */
+const RESERVED_DECLARATION_NAMES = new Set([
+    "await",
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "enum",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "import",
+    "in",
+    "instanceof",
+    "new",
+    "null",
+    "return",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+]);
+/**
+ * The name a declaration is emitted under.
+ *
+ * A trailing `_` is appended where the spec's own name cannot be a TypeScript declaration. It is
+ * applied in ONE place so both walks agree: `wire-contract.gen.ts` pairs a validator against a
+ * contract type by name, and a mangling applied to one side only would break that assertion rather
+ * than the file.
+ */
+function safeDeclarationName(name) {
+    return RESERVED_DECLARATION_NAMES.has(name) ? `${name}_` : name;
+}
 /** A type earns a name when the spec gave it one - anonymous shapes stay inline where they are used. */
 function declaredNameOf(type) {
     if (type.kind === "Enum")
-        return type.name;
+        return safeDeclarationName(type.name);
     /**
      * A named union earns a declaration too.
      *
@@ -76,14 +145,16 @@ function declaredNameOf(type) {
      * would silently stop being checked at the boundary.
      */
     if (type.kind === "Union")
-        return type.name === undefined ? undefined : type.name;
+        return type.name === undefined ? undefined : safeDeclarationName(type.name);
     if (type.kind !== "Model")
         return undefined;
     // `Array`/`Record` are TypeSpec's built-in generic containers, not names worth exporting.
     if (type.name === "Array" || type.name === "Record")
         return undefined;
-    if (type.name === "")
-        return spreadSourceName(type);
+    if (type.name === "") {
+        const spread = spreadSourceName(type);
+        return spread === undefined ? undefined : safeDeclarationName(spread);
+    }
     /**
      * **A template INSTANTIATION carries the template's name, and it is not a declaration.**
      *
@@ -97,7 +168,7 @@ function declaredNameOf(type) {
      */
     if (type.templateMapper !== undefined)
         return undefined;
-    return type.name;
+    return safeDeclarationName(type.name);
 }
 const lowerFirst = (value) => value.charAt(0).toLowerCase() + value.slice(1);
 /**
@@ -344,6 +415,48 @@ export class SchemaRegistry {
  * hand back different text. Sharing {@link declaredNameOf} is the part that matters: a model named in
  * one artefact is named the same way in the other, so the emitted assertion can pair them by name.
  */
+/**
+ * Whether a rendered body is ONE object literal, and so may be emitted as an `interface`.
+ *
+ * **This was `source.startsWith("{") && !source.includes("} & ")`, which named the two shapes it had
+ * met rather than the property it needed.** A discriminated union with an envelope renders as
+ * `{ kind: "cat"; value: Cat; } | { kind: "dog"; value: Dog; }`: it starts with a brace and holds no
+ * intersection, so it was emitted as `export interface PetWithEnvelope { ... } | { ... }`. An
+ * interface cannot be a union, so the file did not parse at all - and that is the DEFAULT envelope,
+ * the shape a spec gets from writing `@discriminated` and nothing else.
+ *
+ * Balanced braces answer the question actually being asked: an interface is valid exactly when the
+ * whole body is a single `{...}`, whatever it contains. A composition operator cannot be missed,
+ * because anything following the matching close brace fails the test whatever it happens to be.
+ */
+function isSingleObjectLiteral(source) {
+    if (!source.startsWith("{"))
+        return false;
+    let depth = 0;
+    let quoted = false;
+    for (let index = 0; index < source.length; index += 1) {
+        const character = source[index];
+        // A property key may be quoted and may itself contain a brace, which is not a nesting one.
+        if (quoted) {
+            if (character === "\\")
+                index += 1;
+            else if (character === '"')
+                quoted = false;
+            continue;
+        }
+        if (character === '"')
+            quoted = true;
+        else if (character === "{")
+            depth += 1;
+        else if (character === "}") {
+            depth -= 1;
+            // Closing the outermost brace anywhere but at the very end means something follows it.
+            if (depth === 0)
+                return index === source.length - 1;
+        }
+    }
+    return false;
+}
 export class TypeRegistry {
     #program;
     #declarations = new Map();
@@ -377,7 +490,7 @@ export class TypeRegistry {
              * `{ ...pinned } & Record<string, unknown>`, and `export interface X { ... } & ...` does not parse -
              * so an intersection is emitted as a type alias instead.
              */
-            isObject: source.startsWith("{") && !source.includes("} & "),
+            isObject: isSingleObjectLiteral(source),
             /**
              * **A vocabulary alias is NOT exported.**
              *
@@ -396,7 +509,31 @@ export class TypeRegistry {
             source,
         };
         this.#declarations.set(type, declaration);
-        this.#order.push(declaration);
+        /**
+         * **Declared once per NAME, not once per `Type`, and the two are not the same thing.**
+         *
+         * `#declarations` is keyed on the `Type` object so a repeated reference resolves without
+         * re-walking. Visibility projection produces a DIFFERENT `Type` for the same declaration, so one
+         * model reached under two visibilities was emitted twice and the file did not compile:
+         * `parameters/body-optionality` declares one `model BodyModel` and `requests.gen.ts` carried two
+         * byte-identical `export interface BodyModel`, from a compile that reported success.
+         *
+         * **Identical is dropped; DIFFERING is a collision and must not be.** Two declarations sharing a
+         * name with different bodies are two different types that TypeScript can only express as one, so
+         * silently keeping the first would publish a contract for a type nothing checks. The document
+         * distinguishes them and this file cannot, which is a refusal rather than a choice.
+         */
+        const sameName = this.#order.find((candidate) => candidate.name === declaration.name);
+        if (sameName === undefined) {
+            this.#order.push(declaration);
+        }
+        else if (sameName.source !== declaration.source) {
+            reportDiagnostic(this.#program, {
+                code: "duplicate-declaration",
+                format: { name: declaration.name },
+                target: type,
+            });
+        }
         return declaration.name;
     }
     /**

package/dist/src/zod.d.ts

@@ -93,6 +93,24 @@ export declare function effectiveIndexer(model: Model): Model["indexer"];
  * for a real subtype - the same rule that decides whether a base may be sealed.
  */
 export declare function discriminatedSubtypes(program: Program, model: Model): readonly Model[];
+/**
+ * **What JSON kind a value of this type arrives as, for a parameter carried in text.**
+ *
+ * A path, query or header value is always a string on the wire, so a numeric or boolean parameter has
+ * to be decoded before the document's schema runs. Deciding WHICH decoder applies used to be done by
+ * inspecting the emitted Zod - `declared.startsWith("z.number()")` - which is a string about a string
+ * and fails silently the moment the expression is spelled any other way.
+ *
+ * It did. `@query size: 10 | 25 | 50` emits `z.union([z.literal(10), ...])`, which starts with
+ * neither, so no decoder was wrapped around it and the validator required the NUMBER 25 from a wire
+ * that can only deliver `"25"`. Measured: `?size=25` rejected, `size: 25` accepted. Every conformant
+ * caller got a 400, and no document comparison could see it, because both sides agree the parameter
+ * is a number - the disagreement is with the wire.
+ *
+ * Reading the TYPE answers the question the emitted text was standing in for. `SCALARS` remains the
+ * single list of what becomes a number, so this cannot drift from what `scalarToZod` emits.
+ */
+export declare function wireKindOf(program: Program, type: Type): "number" | "boolean" | undefined;
 /**
  * A name as an object key - quoted when it is not a legal JavaScript identifier.
  *

package/dist/src/zod.js

@@ -787,6 +787,59 @@ function modelToZod(program, model) {
         : `z.object(${shape})${suffix}${strict}`;
     return applyConstraints(program, body, model);
 }
+/**
+ * **What JSON kind a value of this type arrives as, for a parameter carried in text.**
+ *
+ * A path, query or header value is always a string on the wire, so a numeric or boolean parameter has
+ * to be decoded before the document's schema runs. Deciding WHICH decoder applies used to be done by
+ * inspecting the emitted Zod - `declared.startsWith("z.number()")` - which is a string about a string
+ * and fails silently the moment the expression is spelled any other way.
+ *
+ * It did. `@query size: 10 | 25 | 50` emits `z.union([z.literal(10), ...])`, which starts with
+ * neither, so no decoder was wrapped around it and the validator required the NUMBER 25 from a wire
+ * that can only deliver `"25"`. Measured: `?size=25` rejected, `size: 25` accepted. Every conformant
+ * caller got a 400, and no document comparison could see it, because both sides agree the parameter
+ * is a number - the disagreement is with the wire.
+ *
+ * Reading the TYPE answers the question the emitted text was standing in for. `SCALARS` remains the
+ * single list of what becomes a number, so this cannot drift from what `scalarToZod` emits.
+ */
+export function wireKindOf(program, type) {
+    if (type.kind === "Scalar") {
+        const encoded = encodedTypeOf(program, type);
+        if (encoded !== undefined && encoded !== type)
+            return wireKindOf(program, encoded);
+        for (let current = type; current !== undefined; current = current.baseScalar) {
+            const mapped = SCALARS[current.name];
+            if (mapped === undefined)
+                continue;
+            if (mapped.startsWith("z.number()"))
+                return "number";
+            if (mapped === "z.boolean()")
+                return "boolean";
+            return undefined;
+        }
+        return undefined;
+    }
+    // A literal is its own type, and a union of them is the enum form a parameter commonly takes.
+    if (type.kind === "Number")
+        return "number";
+    if (type.kind === "Boolean")
+        return "boolean";
+    if (type.kind === "Union") {
+        const kinds = new Set();
+        for (const variant of type.variants.values()) {
+            // `T | null` is still a T on the wire; the null arm needs no decoding.
+            if (variant.type.kind === "Intrinsic" && variant.type.name === "null")
+                continue;
+            kinds.add(wireKindOf(program, variant.type));
+        }
+        if (kinds.size !== 1)
+            return undefined;
+        return [...kinds][0];
+    }
+    return undefined;
+}
 /**
  * A name as an object key - quoted when it is not a legal JavaScript identifier.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typespec-http-zod",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "TypeSpec emitter and library: turn an HTTP service definition into Zod validators and framework-free contract types that agree, keyword for keyword, with the OpenAPI document @typespec/openapi3 publishes from the same source.",
   "keywords": [
     "codegen",