typespec-http-zod 0.28.0 → 0.30.0

package/dist/src/constraints.d.ts

@@ -15,6 +15,21 @@ import { type Program, type Type } from "@typespec/compiler";
  * asserts that no emitted file carries a `.refine(` outside the one multipart-file carve-out.
  */
 export declare function applyConstraints(program: Program, expression: string, target: Type): string;
+/**
+ * **Whether this diagnostic has already been raised against this declaration.**
+ *
+ * Keyed on the code as well as the target. Keying on the target alone once made the memo shared
+ * between every pattern diagnostic, so whichever ran first claimed the declaration and silenced
+ * the rest: measured on `^(\w+\s?)*\-$`, one warning where two were due. The ReDoS judgement has
+ * since moved to a linter rule, which reports per declaration by construction, so that pairing can
+ * no longer meet here - but a memo keyed on the target alone is the wrong shape for the next
+ * diagnostic added beside this one, and costs nothing to keep right.
+ *
+ * The de-duplication itself is per declaration, because emission reaches a scalar once per USE -
+ * 153 times for a single scalar in the reference service - and repeating one warning that often
+ * is noise a reader learns to skip, which is how a real one gets missed.
+ */
+export declare function firstReportOf(program: Program, code: string, target: Type): boolean;
 /**
  * **Whether a `@pattern` can be proven safe against catastrophic backtracking.**
  *

package/dist/src/constraints.js

@@ -1,6 +1,7 @@
 import { getEncode, getMaxItems, getMaxLength, getMaxValue, getMinItems, getMinLength, getMinValue, getMinValueExclusive, getMaxValueExclusive, getPattern, } from "@typespec/compiler";
 import { defaultMaxSteps, isSafePattern } from "redos-detector";
 import { reportDiagnostic } from "./lib.js";
+import { escapeNonAscii } from "./literal.js";
 /**
  * Constraint decorators -> the Zod modifiers that enforce them.
  *
@@ -18,15 +19,16 @@ import { reportDiagnostic } from "./lib.js";
  */
 export function applyConstraints(program, expression, target) {
     let result = expression;
-    const minLength = getMinLength(program, target);
-    const maxLength = getMaxLength(program, target);
-    const minValue = getMinValue(program, target);
-    const maxValue = getMaxValue(program, target);
-    const minItems = getMinItems(program, target);
-    const maxItems = getMaxItems(program, target);
-    const pattern = getPattern(program, target);
-    const minExclusive = getMinValueExclusive(program, target);
-    const maxExclusive = getMaxValueExclusive(program, target);
+    const read = (get) => declaredOn(program, target, get);
+    const minLength = read(getMinLength);
+    const maxLength = read(getMaxLength);
+    const minValue = read(getMinValue);
+    const maxValue = read(getMaxValue);
+    const minItems = read(getMinItems);
+    const maxItems = read(getMaxItems);
+    const pattern = read(getPattern);
+    const minExclusive = read(getMinValueExclusive);
+    const maxExclusive = read(getMaxValueExclusive);
     /**
      * **A numeric bound says nothing about a value carried as text.** `@encode(string)` is legal on a
      * numeric property and makes the wire value a string, so the expression here is `z.string()` while
@@ -72,6 +74,30 @@ export function applyConstraints(program, expression, target) {
     }
     return result;
 }
+/**
+ * **A constraint on a scalar is read up its `extends` chain: the nearest scalar declaring it wins.**
+ *
+ * The compiler's getters read the decorators of the one type they are handed, and this read the
+ * scalar a property NAMED. So `scalar ShortWord extends Word` with `@pattern` on `Word` validated
+ * as a bare `z.string()`, and every value the pattern forbids was accepted - while the document
+ * published the pattern on `ShortWord`. `@typespec/openapi3`'s `#getSchemaForScalar` builds a
+ * derived scalar from its base's schema and then applies its own decorators over it, so a keyword
+ * the derived scalar declares REPLACES the base's rather than adding to it. Reading the nearest
+ * declaration per keyword is that rule exactly: `Overrides extends Word` with its own `@pattern`
+ * publishes only its own, and enforcing both would refuse what the document accepts.
+ *
+ * A property is not a chain: its type's constraints are applied where the type is rendered.
+ */
+function declaredOn(program, target, get) {
+    if (target.kind !== "Scalar")
+        return get(program, target);
+    for (let current = target; current !== undefined; current = current.baseScalar) {
+        const value = get(program, current);
+        if (value !== undefined)
+            return value;
+    }
+    return undefined;
+}
 /**
  * Whether the value this type puts on the wire is text because `@encode` says so. Read from the
  * property and then from its scalar, which is where an encoding declared once for a named scalar
@@ -134,7 +160,7 @@ const reported = new WeakMap();
  * 153 times for a single scalar in the reference service - and repeating one warning that often
  * is noise a reader learns to skip, which is how a real one gets missed.
  */
-function firstReportOf(program, code, target) {
+export function firstReportOf(program, code, target) {
     let byCode = reported.get(program);
     if (byCode === undefined) {
         byCode = new Map();
@@ -210,7 +236,7 @@ export function patternIsProvablySafe(pattern) {
  * instead of guessing at an equivalence.
  */
 export function patternToRegex(pattern) {
-    return `/${escapeSlashes(pattern)}/${unicodeSafe(pattern) ? "u" : ""}`;
+    return `/${escapeNonAscii(escapeSlashes(pattern))}/${unicodeSafe(pattern) ? "u" : ""}`;
 }
 /**
  * **Escapes the slashes a regex literal needs escaped, and only those.**
@@ -232,7 +258,15 @@ function escapeSlashes(pattern) {
     for (let index = 0; index < pattern.length; index += 1) {
         const character = pattern[index];
         if (character === "\\") {
-            escaped += character + (pattern[index + 1] ?? "");
+            const next = pattern[index + 1] ?? "";
+            /**
+             * **An identity escape of a character outside printable ASCII loses its backslash**, because
+             * the character is about to be written as `\uXXXX` and `\\uXXXX` would be a literal
+             * backslash followed by `u`. An accented letter matches the same thing escaped or not; under
+             * the `u` flag the escape is a syntax error, and `unicodeSafe` has already sent such a
+             * pattern to the bare form.
+             */
+            escaped += /[^\x20-\x7e]/.test(next) ? next : character + next;
             index += 1;
             continue;
         }

package/dist/src/lib.d.ts

@@ -162,17 +162,29 @@ export declare const $lib: import("@typespec/compiler").TypeSpecLibrary<{
     "unenforceable-encoded-bound": {
         readonly default: import("@typespec/compiler").CallableMessage<["name"]>;
     };
+    "unenforceable-property-name": {
+        readonly default: import("@typespec/compiler").CallableMessage<["name"]>;
+    };
+    "optional-prototype-name": {
+        readonly default: import("@typespec/compiler").CallableMessage<["name", "name", "name"]>;
+    };
     "duplicate-operation-id": {
         readonly default: import("@typespec/compiler").CallableMessage<["operationId"]>;
     };
     "inline-cycle": {
         readonly default: import("@typespec/compiler").CallableMessage<["type"]>;
     };
+    "encode-cycle": {
+        readonly default: import("@typespec/compiler").CallableMessage<["type", "chain"]>;
+    };
+    "shared-input-key": {
+        readonly default: import("@typespec/compiler").CallableMessage<["operation", "first", "key", "second", "key", "key"]>;
+    };
     "duplicate-declaration": {
         readonly default: import("@typespec/compiler").CallableMessage<["name"]>;
     };
 }, EmitterOptions, never>;
-export declare const reportDiagnostic: <C extends "default-on-required-property" | "duplicate-declaration" | "duplicate-operation-id" | "empty-union" | "inline-cycle" | "non-unicode-pattern" | "truncated-doc-comment" | "undeclared-discriminator" | "unenforceable-encoded-bound" | "unknown-key-vocabulary" | "unmirrorable-seal" | "unsupported-default" | "unsupported-status-code-range" | "unsupported-type", M extends keyof {
+export declare const reportDiagnostic: <C extends "default-on-required-property" | "duplicate-declaration" | "duplicate-operation-id" | "empty-union" | "encode-cycle" | "inline-cycle" | "non-unicode-pattern" | "optional-prototype-name" | "shared-input-key" | "truncated-doc-comment" | "undeclared-discriminator" | "unenforceable-encoded-bound" | "unenforceable-property-name" | "unknown-key-vocabulary" | "unmirrorable-seal" | "unsupported-default" | "unsupported-status-code-range" | "unsupported-type", M extends keyof {
     "unsupported-type": {
         readonly default: import("@typespec/compiler").CallableMessage<["artefact", "kind", "why", "remedy"]>;
     };
@@ -206,12 +218,24 @@ export declare const reportDiagnostic: <C extends "default-on-required-property"
     "unenforceable-encoded-bound": {
         readonly default: import("@typespec/compiler").CallableMessage<["name"]>;
     };
+    "unenforceable-property-name": {
+        readonly default: import("@typespec/compiler").CallableMessage<["name"]>;
+    };
+    "optional-prototype-name": {
+        readonly default: import("@typespec/compiler").CallableMessage<["name", "name", "name"]>;
+    };
     "duplicate-operation-id": {
         readonly default: import("@typespec/compiler").CallableMessage<["operationId"]>;
     };
     "inline-cycle": {
         readonly default: import("@typespec/compiler").CallableMessage<["type"]>;
     };
+    "encode-cycle": {
+        readonly default: import("@typespec/compiler").CallableMessage<["type", "chain"]>;
+    };
+    "shared-input-key": {
+        readonly default: import("@typespec/compiler").CallableMessage<["operation", "first", "key", "second", "key", "key"]>;
+    };
     "duplicate-declaration": {
         readonly default: import("@typespec/compiler").CallableMessage<["name"]>;
     };
@@ -249,12 +273,24 @@ export declare const reportDiagnostic: <C extends "default-on-required-property"
     "unenforceable-encoded-bound": {
         readonly default: import("@typespec/compiler").CallableMessage<["name"]>;
     };
+    "unenforceable-property-name": {
+        readonly default: import("@typespec/compiler").CallableMessage<["name"]>;
+    };
+    "optional-prototype-name": {
+        readonly default: import("@typespec/compiler").CallableMessage<["name", "name", "name"]>;
+    };
     "duplicate-operation-id": {
         readonly default: import("@typespec/compiler").CallableMessage<["operationId"]>;
     };
     "inline-cycle": {
         readonly default: import("@typespec/compiler").CallableMessage<["type"]>;
     };
+    "encode-cycle": {
+        readonly default: import("@typespec/compiler").CallableMessage<["type", "chain"]>;
+    };
+    "shared-input-key": {
+        readonly default: import("@typespec/compiler").CallableMessage<["operation", "first", "key", "second", "key", "key"]>;
+    };
     "duplicate-declaration": {
         readonly default: import("@typespec/compiler").CallableMessage<["name"]>;
     };

package/dist/src/lib.js

@@ -297,6 +297,48 @@ const diagnostics = {
             default: paramMessage `The bound on '${"name"}' cannot be enforced, and is not emitted. '@encode(string)' makes the wire value text, so '@minValue'/'@maxValue' would become a check on how many CHARACTERS it has - '@minValue(10)' would refuse '"42"' - and the exclusive form has no string equivalent at all. The document is no help either: it publishes 'minimum' on a 'type: string' schema, which JSON Schema ignores, so a validator enforcing the bound would refuse what the published contract accepts. Declare the bound as a '@pattern', which the document publishes and every caller can read, or remove '@encode(string)' and let the value be a number.`,
         },
     },
+    /**
+     * **A property whose wire name is `__proto__` is published, and no Zod validator can check it.**
+     *
+     * Zod skips a declared `__proto__` key on purpose, so prototype pollution cannot reach through a
+     * parse (colinhacks/zod#6386): a value of any type, or none, is accepted for it and dropped from
+     * the result. The document publishes it like any other property, and nothing emitted can enforce
+     * it - which is the case `unenforceable-encoded-bound` reports for a bound, for the same reason:
+     * the spec is representable, so refusing it would make it emit under one emitter and not the
+     * other, and serving it silently would leave a validator looser than its contract unsaid.
+     *
+     * The key is still DECLARED, as a computed `["__proto__"]`, because a plain `__proto__:` in an
+     * object literal sets the shape's prototype instead. Measured: that dropped the property from the
+     * published JSON Schema, and under `seal-object-schemas` refused every body carrying it as an
+     * unrecognised key - the opposite of what the document says.
+     */
+    "unenforceable-property-name": {
+        severity: "warning",
+        messages: {
+            default: paramMessage `'${"name"}' is published as a property and cannot be validated: Zod skips a key named '__proto__' on purpose (colinhacks/zod#6386), so any value, or none, is accepted for it and dropped from the parsed result. The published schema still states it. Give it another wire name if its value has to be checked.`,
+        },
+    },
+    /**
+     * **An optional property named after an `Object.prototype` member refuses every value that
+     * leaves it out.**
+     *
+     * Zod reads a property as `input[key]`, so an absent `constructor`, `toString`, `valueOf` or any
+     * other inherited member reads as the function every object inherits, and is refused as the wrong
+     * type (colinhacks/zod#6666, open). A required one is unaffected, because a value that leaves it
+     * out is refused either way. The emitted validators are right and inherit the defect - on
+     * requests and responses alike - and the only repair in emitted code, a `z.preprocess` onto a
+     * null-prototype copy, would cost the model `.shape` and `.extend`.
+     *
+     * Reported where the property is optional, which includes the PATCH position that makes a
+     * required property optional. When Zod ships the fix, the peer floor moves to it and this retires:
+     * `test/inheritednames` pins the defect so that release is noticed.
+     */
+    "optional-prototype-name": {
+        severity: "warning",
+        messages: {
+            default: paramMessage `'${"name"}' is optional here, and the validator refuses every value that leaves it out: Zod reads an absent '${"name"}' as the member every object inherits from Object.prototype, a function, and rejects it (colinhacks/zod#6666). A value that carries '${"name"}' validates normally. Give it a wire name Object.prototype does not have, or declare it required, until Zod releases a fix.`,
+        },
+    },
     "duplicate-operation-id": {
         severity: "error",
         messages: {
@@ -338,6 +380,44 @@ const diagnostics = {
             default: paramMessage `'${"type"}' closes a reference cycle without passing through anything this emitter can declare, so the cycle has no name to reference itself by. A template instantiation is inlined rather than declared, exactly as '@typespec/openapi3' inlines it, and that emitter refuses the same spec with its own 'inline-cycle' error. Give the type a name with '@friendlyName' so it becomes a declaration, or break the cycle.`,
         },
     },
+    /**
+     * **An `@encode` chain that returns to where it started never reaches a wire type.**
+     *
+     * `@encode("x", Pong) scalar Ping` and `@encode("x", Ping) scalar Pong` compile cleanly - the
+     * compiler checks neither the encoding's name nor where its type leads - and the walks here
+     * followed `@encode` by calling themselves on the encoded type. Measured before this existed:
+     * `RangeError: Maximum call stack size exceeded`, "Emitter crashed! This is a bug."
+     *
+     * **An error, as `inline-cycle` is.** A value of such a scalar has no form on the wire to validate,
+     * so there is no validator to emit. openapi3 reads one link of the chain and publishes a schema
+     * with no `type` at all - `{ format: "x" }` - which states nothing about the value either.
+     */
+    "encode-cycle": {
+        severity: "error",
+        messages: {
+            default: paramMessage `'${"type"}' is encoded as ${"chain"}: the '@encode' chain returns to a scalar it already passed, so it never reaches a type that crosses the wire. Encode one of them as a standard scalar such as 'string', or break the cycle.`,
+        },
+    },
+    /**
+     * **Two inputs of one operation handed to its handler under one key.**
+     *
+     * A handler's input is the path, query, header and cookie groups spread into one object, with the
+     * body merged or named beside them. `@header("x") a: string` beside `@query("x") b: int32` therefore
+     * reached the handler as one `x`, the header's string replacing the validated number, while the
+     * input was typed `number & string`. `@typespec/http` refuses only a path and a query parameter of
+     * one name; the rest compiled with no diagnostic (typespec-http-graphql, 2026-10-16).
+     *
+     * **A warning, because the spec is valid and openapi3 publishes it**: the parameters are distinct on
+     * the wire. It is the input this package states that cannot carry both, so the key is typed and
+     * validated as both declarations at once, and the contract types still compile. A server emitter
+     * reading `EmittedRoute.sharedInputKeys` declines to mount the operation.
+     */
+    "shared-input-key": {
+        severity: "warning",
+        messages: {
+            default: paramMessage `'${"operation"}' takes the ${"first"} '${"key"}' and the ${"second"} '${"key"}', and a handler's input holds one value under each key, so '${"key"}' is stated as both declarations at once and accepts only a value satisfying both. Give one of them a different name.`,
+        },
+    },
     "duplicate-declaration": {
         severity: "error",
         messages: {

package/dist/src/literal.d.ts

@@ -0,0 +1,27 @@
+/**
+ * **A value as a JavaScript literal whose source is ASCII.**
+ *
+ * `JSON.stringify` is the right spelling for spec text that becomes code - a key, an enum value, a
+ * media type, a description - because it quotes and escapes exactly as a string literal needs. It
+ * leaves every other character as it is, and no file this package generates may carry one: a
+ * consumer commits the output, and an invisible character in it has held a block comment open past
+ * its terminator in the sibling package. `test/portability.test.ts` grades every emitted file.
+ *
+ * Measured once descriptions reached the output: `@typespec/http-specs`' `payload/xml` documents its
+ * models as `"\u00a71.1 \u2014 Contains fields of primitive types."`, and the section sign and the dash went
+ * straight into `schemas.gen.ts`. Every other site had the same exposure and was ASCII only because
+ * no spec in the corpus happened to put a non-ASCII character in a key or a value.
+ *
+ * So every character outside printable ASCII is written as a `\uXXXX` escape: the same string at
+ * run time, in either quote position, and in a TypeScript literal type. An astral character is two
+ * UTF-16 units, escaped one at a time, which is how JavaScript spells it.
+ */
+export declare function literal(value: unknown): string;
+/**
+ * Every UTF-16 unit outside printable ASCII as a `\uXXXX` escape. A string literal and a regular
+ * expression read the escape alike, with or without the `u` flag: under it, an escaped surrogate pair
+ * is the one code point the pair spells.
+ */
+export declare function escapeNonAscii(source: string): string;
+/** One UTF-16 unit as `\uXXXX`. */
+export declare function unicodeEscape(unit: string): string;

package/dist/src/literal.js

@@ -0,0 +1,33 @@
+/**
+ * **A value as a JavaScript literal whose source is ASCII.**
+ *
+ * `JSON.stringify` is the right spelling for spec text that becomes code - a key, an enum value, a
+ * media type, a description - because it quotes and escapes exactly as a string literal needs. It
+ * leaves every other character as it is, and no file this package generates may carry one: a
+ * consumer commits the output, and an invisible character in it has held a block comment open past
+ * its terminator in the sibling package. `test/portability.test.ts` grades every emitted file.
+ *
+ * Measured once descriptions reached the output: `@typespec/http-specs`' `payload/xml` documents its
+ * models as `"\u00a71.1 \u2014 Contains fields of primitive types."`, and the section sign and the dash went
+ * straight into `schemas.gen.ts`. Every other site had the same exposure and was ASCII only because
+ * no spec in the corpus happened to put a non-ASCII character in a key or a value.
+ *
+ * So every character outside printable ASCII is written as a `\uXXXX` escape: the same string at
+ * run time, in either quote position, and in a TypeScript literal type. An astral character is two
+ * UTF-16 units, escaped one at a time, which is how JavaScript spells it.
+ */
+export function literal(value) {
+    return escapeNonAscii(JSON.stringify(value));
+}
+/**
+ * Every UTF-16 unit outside printable ASCII as a `\uXXXX` escape. A string literal and a regular
+ * expression read the escape alike, with or without the `u` flag: under it, an escaped surrogate pair
+ * is the one code point the pair spells.
+ */
+export function escapeNonAscii(source) {
+    return source.replace(/[^\x20-\x7e]/g, unicodeEscape);
+}
+/** One UTF-16 unit as `\uXXXX`. */
+export function unicodeEscape(unit) {
+    return `\\u${unit.charCodeAt(0).toString(16).padStart(4, "0")}`;
+}

package/dist/src/registry.js

@@ -1,8 +1,8 @@
-import { getFriendlyName, } from "@typespec/compiler";
+import { getDoc, getFriendlyName, } from "@typespec/compiler";
 import { getVisibilitySuffix, Visibility } from "@typespec/http";
 import { reportDiagnostic } from "./lib.js";
 import { propertyToTs, propertyTypeToTs, typeToTsBody, withTsRefResolver } from "./types.js";
-import { captureBackEdges, currentVisibility, isOptionalAt, isTransformedBy, noteBackEdge, propertyToZod, UNREPRESENTABLE, typeToZodBody, withDeferredAnnotator, withRefResolver, withSyntheticDeclarations, } from "./zod.js";
+import { captureBackEdges, currentVisibility, described, isOptionalAt, isTransformedBy, noteBackEdge, propertyToZod, UNREPRESENTABLE, typeToZodBody, withDeferredAnnotator, withRefResolver, withSyntheticDeclarations, } from "./zod.js";
 /**
  * The name an ANONYMOUS payload model inherits from the single model it spreads.
  *
@@ -394,7 +394,17 @@ export class SchemaRegistry {
          * and the emitted `const` would read itself while initialising. `z.lazy()` defers the whole body
          * instead, which is the only place left to put the deferral once no property can hold it.
          */
-        const source = rendered.deferred ? `z.lazy(() => ${rendered.value})` : rendered.value;
+        /**
+         * **The description goes on the declaration's own body, so the exported const IS the
+         * described schema.** Every reference then names that one instance, which is what keeps
+         * identity, `z.compile`'s clone (it inherits the description through its parent link) and
+         * Zod's `$ref` extraction all intact. Described at a reference instead, each use would be a
+         * fresh clone. Read from the canonical type, because an anonymous payload has its doc only on
+         * the model it was spread from, and a visibility projection carries the doc of the model it
+         * projects - as openapi3 publishes one component for both.
+         */
+        const body = rendered.deferred ? `z.lazy(() => ${rendered.value})` : rendered.value;
+        const source = described(body, getDoc(this.#program, canonicalTypeFor(type)));
         const declaration = {
             identifier,
             typeName: name,
@@ -441,8 +451,8 @@ export class SchemaRegistry {
      * them.
      *
      * **Subtypes are deliberately NOT walked here, because nothing would be walking them.** A
-     * discriminated base renders as `z.discriminatedUnion` over its subtypes, and rendering that
-     * already asks the registry for each one. A loop here looked load-bearing and was measured not to
+     * discriminated base renders as a dispatch over its subtypes - `z.discriminatedUnion`, beside a base
+     * arm where its discriminator is open - and rendering that already asks the registry for each one. A loop here looked load-bearing and was measured not to
      * be: removing it left all 23 polymorphism and differential arms green.
      *
      * **Wrapped in {@link captureBackEdges} and the result discarded.** This call can land on a
@@ -523,7 +533,20 @@ export class SchemaRegistry {
      * drift.
      */
     #structuralBodyOf(type) {
-        return withTsRefResolver((candidate) => declaredNameOf(this.#program, candidate), () => typeToTsBody(this.#program, type));
+        return withTsRefResolver((candidate) => this.#typeNameOf(candidate), () => typeToTsBody(this.#program, type));
+    }
+    /**
+     * **The TypeScript name a reference resolves to is the one {@link expressionFor} declares it
+     * under**, visibility suffix included. Resolved by the bare name, a cycle through a model a
+     * request projects typed the projection's back edges by the READ shape: `NodeCreate`'s
+     * `children` became `Node[]`, which carries a property the request never sends, and the declared
+     * validator did not satisfy its own annotation (`TS2375`).
+     */
+    #typeNameOf(candidate) {
+        const bare = declaredNameOf(this.#program, candidate);
+        if (bare === undefined)
+            return undefined;
+        return nameAt(bare, visibilityFor(this.#program, candidate, currentVisibility()));
     }
     /**
      * Render `type` without consulting its own declaration, but letting nested types use theirs.
@@ -567,7 +590,7 @@ export class SchemaRegistry {
     #deferredAnnotationOf(property) {
         if (property.defaultValue !== undefined)
             return undefined;
-        const declared = withTsRefResolver((candidate) => declaredNameOf(this.#program, candidate), () => propertyTypeToTs(this.#program, property));
+        const declared = withTsRefResolver((candidate) => this.#typeNameOf(candidate), () => propertyTypeToTs(this.#program, property));
         const core = `z.ZodType<${declared}, ${declared}>`;
         const optional = property.optional || isOptionalAt(this.#program, property);
         return `: ${optional ? `z.ZodExactOptional<${core}>` : core}`;

package/dist/src/results.js

@@ -1,4 +1,5 @@
 import { CONTENTLESS_STATUS_CODES, STATUS_CODES } from "./statuses.js";
+import { literal } from "./literal.js";
 /**
  * **A media type's essence: `type/subtype`, lowercased, with no parameters** (RFC 9110 section
  * 8.3.1). Two media types are the same type exactly when their essences are equal, so every
@@ -41,7 +42,7 @@ export function isMediaRange(mediaType) {
  */
 export function mediaTypeTypeOf(mediaType) {
     if (!isMediaRange(mediaType))
-        return JSON.stringify(mediaType);
+        return literal(mediaType);
     if (mediaType === "*/*")
         return "string";
     return `\`${mediaType.slice(0, -1)}\${string}\``;

package/dist/src/types.js

@@ -1,6 +1,7 @@
 import { getDiscriminatedUnion, isNeverType, resolveEncodedName, } from "@typespec/compiler";
 import { reportDiagnostic } from "./lib.js";
-import { discriminatedSubtypes, effectiveIndexer, emitsDefault, encodedTypeOf, inheritedAndOwnProperties, isOptionalAt, isPayloadProperty, objectKey, refusalTarget, withDeclarationSite, } from "./zod.js";
+import { literal } from "./literal.js";
+import { discriminatedBaseOf, discriminatedSubtypes, effectiveIndexer, emitsDefault, encodeCycleOf, encodedTypeOf, inheritedAndOwnProperties, isOptionalAt, isPayloadProperty, objectKey, refusalTarget, withDeclarationSite, } from "./zod.js";
 /**
  * TypeSpec type -> plain TypeScript type text.
  *
@@ -74,8 +75,12 @@ function refuse(program, type, why, remedy = "") {
 function scalarToTs(program, scalar) {
     // A scalar declaration can carry the encoding itself - see `scalarToZod`.
     const encoded = encodedTypeOf(program, scalar);
-    if (encoded !== undefined && encoded !== scalar)
-        return scalarToTs(program, encoded);
+    if (encoded !== undefined && encoded !== scalar) {
+        // Reported once, by the schema walk - see `encodeCycleOf`.
+        return encodeCycleOf(program, scalar) === undefined
+            ? scalarToTs(program, encoded)
+            : UNREPRESENTABLE;
+    }
     let current = scalar;
     // Walk `extends` so `scalar TrimmedString extends string` resolves to the primitive underneath.
     while (current !== undefined) {
@@ -102,7 +107,7 @@ function scalarToTs(program, scalar) {
 }
 function enumToTs(target) {
     const values = [...target.members.values()].map((member) => member.value ?? member.name);
-    return values.map((value) => JSON.stringify(value)).join(" | ");
+    return values.map((value) => literal(value)).join(" | ");
 }
 function unionToTs(program, union) {
     /**
@@ -115,7 +120,7 @@ function unionToTs(program, union) {
     if (discriminated !== undefined && discriminated.defaultVariant === undefined) {
         const { envelope, discriminatorPropertyName, envelopePropertyName } = discriminated.options;
         const arms = [...discriminated.variants.entries()].map(([name, variant]) => {
-            const tag = `${objectKey(discriminatorPropertyName)}: ${JSON.stringify(name)};`;
+            const tag = `${objectKey(discriminatorPropertyName)}: ${literal(name)};`;
             const inner = typeToTs(program, variant);
             // No injection: with no envelope the variant declares the discriminator itself, or the union
             // is refused in `zod.ts`. Nothing is added that the document does not publish.
@@ -152,11 +157,26 @@ function modelToTs(program, model) {
      * the emitter disagreeing with itself - one TypeSpec, walked twice - and this is the second defect
      * of that class it has found. The first was a vocabulary inlined by one walk and referenced by the
      * other.
+     *
+     * **An open base adds itself as the last arm**, as `modelToZod` does: a value whose discriminator
+     * names no subtype is the base's own object. The base arm's discriminator keeps its declared type
+     * here; TypeScript cannot say "a string other than these", and the validator's refinement does not
+     * change what it accepts as input, so `z.input` and this type stay identical.
      */
-    const subtypes = discriminatedSubtypes(program, model);
-    if (subtypes.length > 0) {
-        return subtypes.map((derived) => typeToTs(program, derived)).join(" | ");
+    const base = discriminatedBaseOf(program, model);
+    if (base !== undefined) {
+        const arms = discriminatedSubtypes(program, model).map((derived) => typeToTs(program, derived));
+        if (base.open)
+            arms.push(modelObjectToTs(program, model, base));
+        return arms.join(" | ");
     }
+    return modelObjectToTs(program, model);
+}
+/**
+ * A model as the object of its own properties, inherited ones included - for a discriminated base,
+ * its base arm, with the `string` discriminator openapi3 adds where the base declares none.
+ */
+function modelObjectToTs(program, model, base) {
     const indexer = effectiveIndexer(model);
     const indexerKey = indexer?.key.name;
     // Inherited properties included - see `inheritedAndOwnProperties`. Both artefacts describe the
@@ -213,6 +233,10 @@ function modelToTs(program, model) {
         .filter((property) => isPayloadProperty(program, property))
         .filter((property) => !isNeverType(property.type))
         .map((property) => `\t${withDeclarationSite(property, () => propertyToTs(program, property))}`);
+    if (base !== undefined &&
+        !declared.some((property) => resolveEncodedName(program, property, "application/json") === base.propertyName)) {
+        entries.push(`\t${objectKey(base.propertyName)}: string;`);
+    }
     /**
      * **The indexer is deliberately NOT intersected in.**
      *
@@ -369,13 +393,13 @@ export function typeToTsBody(program, type) {
         case "Union":
             return unionToTs(program, type);
         case "String":
-            return JSON.stringify(type.value);
+            return literal(type.value);
         case "Number":
             return String(type.value);
         case "Boolean":
             return String(type.value);
         case "EnumMember":
-            return JSON.stringify(type.value ?? type.name);
+            return literal(type.value ?? type.name);
         // A named union variant is a referable type - `DogKind.Golden`. See the note in `zod.ts`.
         case "UnionVariant":
             return typeToTs(program, type.type);

package/dist/src/uri-template.d.ts

@@ -1,15 +1,3 @@
-/**
- * RFC 6570 URI templates, read for what a server has to mount and what it has to decode.
- *
- * **`HttpOperation.uriTemplate`, never `HttpOperation.path`.** `path` drops every operator, so
- * `array{.param*}`, `array{;param}` and `array{/param}` all become `array{param}`, and a route mounted
- * from it answers 404 to the URL its own contract declares. Measured on `@typespec/http-specs`
- * `routes`: 30 of its mock server's URIs, plus the query-continuation six.
- *
- * `parseUriTemplate` is copied from `@typespec/http` 1.16.0 (`dist/src/uri-template.js`, MIT), which
- * implements it but does not export it, so the template is split exactly as the library that built
- * it splits it.
- */
 /**
  * One `/`-delimited segment of a route, as a server has to mount it.
  *

package/dist/src/uri-template.js

@@ -1,3 +1,4 @@
+import { literal } from "./literal.js";
 /**
  * RFC 6570 URI templates, read for what a server has to mount and what it has to decode.
  *
@@ -128,7 +129,7 @@ export function needsExpansionDecoding(segment, shape) {
  * {@link URI_EXPANSION_SOURCE}, declared once in `schemas.gen.ts` when something calls it.
  */
 export function uriExpansionCall(spec) {
-    return `(raw, ctx) => uriExpansion(raw, ctx, { prefix: ${JSON.stringify(spec.prefix)}, suffix: ${JSON.stringify(spec.suffix)}, operator: ${JSON.stringify(spec.operator)}, name: ${JSON.stringify(spec.name)}, explode: ${spec.explode}, shape: ${JSON.stringify(spec.shape)}, values: ${JSON.stringify(spec.values)} })`;
+    return `(raw, ctx) => uriExpansion(raw, ctx, { prefix: ${literal(spec.prefix)}, suffix: ${literal(spec.suffix)}, operator: ${literal(spec.operator)}, name: ${literal(spec.name)}, explode: ${spec.explode}, shape: ${literal(spec.shape)}, values: ${literal(spec.values)} })`;
 }
 /**
  * **RFC 6570 section 3.2, run backwards.** A router hands over the text of the segment an expression
@@ -209,7 +210,7 @@ function uriExpansion(
  * gatherer itself is {@link EXPLODED_QUERY_SOURCE}.
  */
 export function explodedQueryCall(spec) {
-    return `(raw) => explodedQuery(raw, { name: ${JSON.stringify(spec.name)}, others: ${JSON.stringify(spec.others)}, keys: ${JSON.stringify(spec.keys ?? null)}, numbers: ${JSON.stringify(spec.numbers)}, booleans: ${JSON.stringify(spec.booleans)}, values: ${JSON.stringify(spec.values)} })`;
+    return `(raw) => explodedQuery(raw, { name: ${literal(spec.name)}, others: ${literal(spec.others)}, keys: ${literal(spec.keys ?? null)}, numbers: ${literal(spec.numbers)}, booleans: ${literal(spec.booleans)}, values: ${literal(spec.values)} })`;
 }
 /**
  * **`{?param*}` over a record or a model expands to the object's own keys**, `?a=1&b=2` and