typespec-http-zod 0.29.0 → 0.31.0

package/dist/src/types.d.ts

@@ -1,4 +1,14 @@
 import { type ModelProperty, type Program, type Type } from "@typespec/compiler";
+import { type Merged, type PropertyPosition } from "./zod.js";
+/**
+ * **A type the document publishes that no TypeSpec type stands for** - an envelope, `PetCat` -
+ * declared under its name by the registry, as the schema registry declares its validator.
+ */
+export declare function withTsSyntheticDeclarations<T>(hook: (name: string, build: () => string, site: Type) => string, run: () => T): T;
+/**
+ * A merged value as TypeScript - `z.input` of what `mergedToZod` writes for it, node for node.
+ */
+export declare function mergedToTs(program: Program, value: Merged): string;
 /**
  * A property line, including its optionality marker.
  *
@@ -15,8 +25,8 @@ import { type ModelProperty, type Program, type Type } from "@typespec/compiler"
  * Shared with the annotation the registry writes on a deferred (getter) property, so the type that
  * annotation claims is by construction the type this walk renders for the same property.
  */
-export declare function propertyTypeToTs(program: Program, property: ModelProperty): string;
-export declare function propertyToTs(program: Program, property: ModelProperty, wireName?: string): string;
+export declare function propertyTypeToTs(program: Program, property: ModelProperty, position?: PropertyPosition): string;
+export declare function propertyToTs(program: Program, property: ModelProperty, wireName?: string, position?: PropertyPosition): string;
 export declare function withTsRefResolver<T>(resolver: (type: Type) => string | undefined, run: () => T): T;
 export declare function typeToTs(program: Program, type: Type): string;
 /**

package/dist/src/types.js

@@ -1,7 +1,8 @@
-import { getDiscriminatedUnion, isNeverType, resolveEncodedName, } from "@typespec/compiler";
+import { getDiscriminatedUnion, resolveEncodedName, } from "@typespec/compiler";
+import { firstReportOf } from "./constraints.js";
 import { reportDiagnostic } from "./lib.js";
 import { literal } from "./literal.js";
-import { discriminatedSubtypes, effectiveIndexer, emitsDefault, encodedTypeOf, inheritedAndOwnProperties, isOptionalAt, isPayloadProperty, objectKey, refusalTarget, withDeclarationSite, } from "./zod.js";
+import { ANY_JSON_TS, atDeclaration, atItem, atPosition, atReading, constrainedMembersOf, constrainingKeywords, discriminatedBaseOf, discriminatedSubtypes, dispatchedVariantsOf, effectiveIndexer, emitsDefault, encodedIntersects, encodedValueOf, envelopeNameOf, envelopeVisibilityOf, exclusiveSiteOf, holdsRefusedMember, implicitlyOptional, inParameterPosition, isExclusiveHere, isOptionalAt, isRawBytes, isTypelessMember, multipartBinaryContext, keptMembersOf, LIST_TEMPLATE_REMEDY, listTemplateInstanceWhy, membersToWrite, nullableInnerOf, objectKey, objectOfModel, OWN_POSITION, refusalTarget, replacesFormOf, scalarEncodingOf, sealedBaseExtensionOf, TUPLE_PARAMETER, undeclaredVariantOf, unsatisfiableSubtype, withDeclarationSite, withExclusiveSite, withVisibility, } from "./zod.js";
 /**
  * TypeSpec type -> plain TypeScript type text.
  *
@@ -65,22 +66,29 @@ const UNREPRESENTABLE = "never";
  * `withDeclarationSite` in `zod.ts`, whose scope this walk shares.
  */
 function refuse(program, type, why, remedy = "") {
-    reportDiagnostic(program, {
-        code: "unsupported-type",
-        target: refusalTarget(type),
-        format: { artefact: "a TypeScript type", kind: type.kind, why, remedy },
-    });
+    // Once per declaration, whichever walk reaches it first: both walk every type.
+    const target = refusalTarget(type);
+    if (firstReportOf(program, "unsupported-type", target, `${type.kind} ${why}`)) {
+        reportDiagnostic(program, {
+            code: "unsupported-type",
+            target,
+            format: { artefact: "a TypeScript type", kind: type.kind, why, remedy },
+        });
+    }
     return UNREPRESENTABLE;
 }
 function scalarToTs(program, scalar) {
-    // A scalar declaration can carry the encoding itself - see `scalarToZod`.
-    const encoded = encodedTypeOf(program, scalar);
-    if (encoded !== undefined && encoded !== scalar)
+    // A scalar declaration can carry the encoding itself, or inherit it - see `scalarEncodingOf`.
+    const encoded = scalarEncodingOf(program, scalar)?.encoded;
+    // A scalar that is not standard states no type; the schema walk reports it.
+    if (encoded !== undefined && !program.checker.isStdType(encoded))
+        return UNREPRESENTABLE;
+    if (encoded !== undefined)
         return scalarToTs(program, encoded);
     let current = scalar;
     // Walk `extends` so `scalar TrimmedString extends string` resolves to the primitive underneath.
     while (current !== undefined) {
-        const mapped = SCALARS[current.name];
+        const mapped = program.checker.isStdType(current) ? SCALARS[current.name] : undefined;
         if (mapped !== undefined)
             return mapped;
         current = current.baseScalar;
@@ -101,6 +109,22 @@ function scalarToTs(program, scalar) {
      */
     return "unknown";
 }
+/** Declares a shape no type stands for under a name - see `withTsSyntheticDeclarations`. */
+let declareSynthetic;
+/**
+ * **A type the document publishes that no TypeSpec type stands for** - an envelope, `PetCat` -
+ * declared under its name by the registry, as the schema registry declares its validator.
+ */
+export function withTsSyntheticDeclarations(hook, run) {
+    const previous = declareSynthetic;
+    declareSynthetic = hook;
+    try {
+        return run();
+    }
+    finally {
+        declareSynthetic = previous;
+    }
+}
 function enumToTs(target) {
     const values = [...target.members.values()].map((member) => member.value ?? member.name);
     return values.map((value) => literal(value)).join(" | ");
@@ -115,17 +139,39 @@ function unionToTs(program, union) {
     const [discriminated] = getDiscriminatedUnion(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)}: ${literal(name)};`;
+        // Refused by the Zod walk as `undeclared-discriminator`, and `never` on both sides.
+        if (envelope === "none" &&
+            [...discriminated.variants.values()].some((variant) => {
+                const why = undeclaredVariantOf(program, variant, discriminatorPropertyName);
+                return why === "missing" || why === "open";
+            })) {
+            return UNREPRESENTABLE;
+        }
+        // A variant no value can be is dropped, as `unionToZod` drops it.
+        const variants = dispatchedVariantsOf(program, union);
+        if (variants.length === 0)
+            return UNREPRESENTABLE;
+        const arms = variants.map(([name, variant]) => {
+            // Optional where the envelope is published at a PATCH - see `envelopeVisibilityOf`.
+            const optional = implicitlyOptional(envelopeVisibilityOf(program, union, variant)) ? "?" : "";
+            const tag = `${objectKey(discriminatorPropertyName)}${optional}: ${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.
-            return envelope === "none"
-                ? inner
-                : `{ ${tag} ${objectKey(envelopePropertyName)}: ${inner}; }`;
+            if (envelope === "none")
+                return inner;
+            const wrapper = `{ ${tag} ${objectKey(envelopePropertyName)}${optional}: ${inner}; }`;
+            // Declared under the component openapi3 publishes it as, as the validator is.
+            const declared = envelopeNameOf(program, union, name, variant);
+            return declared === undefined
+                ? wrapper
+                : (declareSynthetic?.(declared, () => wrapper, union) ?? wrapper);
         });
         return arms.join(" | ");
     }
+    // Refused with the validator, which says why - see `holdsRefusedMember`.
+    if (holdsRefusedMember(program, union, isExclusiveHere(program, union)))
+        return UNREPRESENTABLE;
     const variants = [...union.variants.values()].map((variant) => variant.type);
     if (variants.length === 0) {
         reportDiagnostic(program, {
@@ -135,7 +181,10 @@ function unionToTs(program, union) {
         });
         return UNREPRESENTABLE;
     }
-    return variants.map((type) => typeToTs(program, type)).join(" | ");
+    // A raw `bytes` member of a multipart part's union is any value - see `withMultipartBinary`.
+    return variants
+        .map((type) => multipartBinaryContext() && isRawBytes(program, type) ? "unknown" : typeToTs(program, type))
+        .join(" | ");
 }
 function modelToTs(program, model) {
     /**
@@ -153,67 +202,80 @@ 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.
+     *
+     * **The base itself is the last arm**, as `modelToZod` writes it: a value that is no valid instance
+     * of the subtype its discriminator names is the base's own object, which is what the document
+     * validates it as. `z.input` of the union and this type are therefore 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));
+        arms.push(modelObjectToTs(program, model));
+        return arms.join(" | ");
     }
+    return modelObjectToTs(program, model);
+}
+/**
+ * A model as the object of its own properties, inherited ones included - for a discriminated base,
+ * the base, with the `string` discriminator openapi3 adds where the base declares none.
+ */
+function modelObjectToTs(program, model) {
+    // Refused by the Zod walk - `sealed-base-extended`, `invalid-subtype-discriminator` - and `never`
+    // on both sides.
+    const extension = sealedBaseExtensionOf(program, model);
+    if (extension?.required === true || unsatisfiableSubtype(program, model))
+        return UNREPRESENTABLE;
     const indexer = effectiveIndexer(model);
-    const indexerKey = indexer?.key.name;
-    // Inherited properties included - see `inheritedAndOwnProperties`. Both artefacts describe the
-    // same model, so a base whose properties reach one and not the other is a contradiction we ship.
-    const declared = inheritedAndOwnProperties(model);
-    if (indexerKey === "integer" && indexer !== undefined) {
-        const element = typeToTs(program, indexer.value);
+    if (indexer?.key.name === "integer") {
+        const element = atItem(program, model, () => typeToTs(program, indexer.value));
         // Parenthesised so `A | B` as an element does not become `A | B[]`.
         return /[|&\s]/.test(element) ? `(${element})[]` : `${element}[]`;
     }
+    // Inherited properties included, each judged where it is published, and the discriminator openapi3
+    // adds - the object `modelObjectToZod` writes, from the one `objectOfModel` both walks read.
+    return mergedToTs(program, objectOfModel(program, model));
+}
+/**
+ * An object as TypeScript: the same members `objectToZod` writes, a dictionary as a `Record`.
+ *
+ * **A string indexer only means "dictionary" when the model declares NO properties.** The same trap
+ * `modelToZod` had, and it bites harder here: every permissive response model is
+ * `{ ...pinned fields; ...Record<unknown> }`, so reading the indexer first would type all 97 of them
+ * as a bare `Record<string, unknown>` - a type that satisfies any assertion about what the response
+ * contains, which is precisely the check this file exists to feed.
+ *
+ * **Metadata, invisible and `never` properties are left out here, as on the Zod side, and the two
+ * must agree** - both read one member list. Two walks over one TypeSpec have to agree about which
+ * properties exist, or `wire-contract.gen.ts` pairs a validator against a type describing a
+ * different shape.
+ */
+/** Whether a merged dictionary is written as an object of its own - see `mergedToTs`. */
+let spellingDictionaries = false;
+function objectToTs(program, object) {
+    const { rest } = object;
     /**
-     * **A string indexer only means "dictionary" when the model declares NO properties.**
-     *
-     * The same trap `modelToZod` had, and it bites harder here: every permissive response model is
-     * `{ ...pinned fields; ...Record<unknown> }`, so reading the indexer first would type all 97 of them
-     * as a bare `Record<string, unknown>` - a type that satisfies any assertion about what the response
-     * contains, which is precisely the check this file exists to feed.
+     * **A dictionary is an object with an indexer and no member where it is used** - the wire
+     * assertion's own reading of `z.input`. A model whose only properties are a `@header` or a
+     * create-only key, returned by a GET, is validated as `z.object({}).catchall(...)` there, and was
+     * typed `{}` for declaring properties, which the assertion refused.
      */
-    // `Record<never>` states closedness rather than a value type - see `modelToZod`. A model that is
-    // only that is an object with no declared properties, not a dictionary of an unwalkable type.
-    if (indexerKey === "string" &&
-        indexer !== undefined &&
-        !isNeverType(indexer.value) &&
-        declared.length === 0) {
-        return `Record<string, ${typeToTs(program, indexer.value)}>`;
+    const dictionary = object.dictionary || object.members.length === 0;
+    // The library's `Record`, whatever the spec names its own - see `LIBRARY_NAMES_WRITTEN_BARE` -
+    // or an object of its own, where a union writes it twice - see `mergedToTs`.
+    const dictionaryOf = (value) => spellingDictionaries ? `{ [key: string]: ${value} }` : `globalThis.Record<string, ${value}>`;
+    if (dictionary && rest === "loose")
+        return dictionaryOf("unknown");
+    if (dictionary && typeof rest !== "string") {
+        const value = mergedToTs(program, rest);
+        /**
+         * A dictionary of nothing admits only `{}`, the empty object an empty model is written as;
+         * `Record<string, never>` is how Zod infers both, and the wire contract reads it as `{}`.
+         */
+        return value === UNREPRESENTABLE ? "{}" : dictionaryOf(value);
     }
-    /**
-     * **A `never` property is dropped here too, and this walk is where the refusal actually came
-     * from.** `modelToZod` filters it because `@typespec/openapi3` omits such a property from the
-     * document entirely - `model N { value: never; other: string }` publishes as `{other}` with
-     * `required: ["other"]`. This walk had no property filter at all, so it reached `typeToTs`, hit the
-     * `Intrinsic` case and reported `unsupported-type` from a type with no source node - which is why
-     * the diagnostic pointed at `<unknown location>` and why filtering the Zod side alone did not
-     * silence it.
-     *
-     * Two walks over one TypeSpec have to agree about which properties exist, or `wire-contract.gen.ts`
-     * pairs a validator against a type describing a different shape. That assertion is the only thing
-     * that catches this emitter disagreeing with itself, and it cannot catch a disagreement that
-     * aborts the compile first.
-     */
-    /**
-     * **Metadata is filtered out here, as it is on the Zod side, and the two must agree.**
-     *
-     * `metadataInfo.isPayloadProperty` is what decides whether a property is in the BODY at this
-     * position: a `@query` or `@header` property is carried separately, and an `@invisible` one is
-     * carried nowhere. `modelToZod` has asked since it was written; this walk never did, so a
-     * contract type listed properties the validator beside it refuses as unknown keys.
-     *
-     * **Applied AFTER the dictionary check above, deliberately.** That check reads the UNFILTERED
-     * list, because a model whose only properties are metadata is still a declared object rather than
-     * a dictionary, and filtering first would flip it to `Record<string, T>` on one side alone.
-     */
-    const entries = declared
-        .filter((property) => isPayloadProperty(program, property))
-        .filter((property) => !isNeverType(property.type))
-        .map((property) => `\t${withDeclarationSite(property, () => propertyToTs(program, property))}`);
+    const entries = object.members.map(({ key, property, position }) => property === undefined
+        ? `\t${objectKey(key)}${position.required ? "" : "?"}: ${mergedToTs(program, position.value ?? { kind: "never" })};`
+        : `\t${withDeclarationSite(property, () => atPosition(position, () => atDeclaration(program, property, () => propertyToTs(program, property, undefined, position))))}`);
     /**
      * **The indexer is deliberately NOT intersected in.**
      *
@@ -246,6 +308,73 @@ function modelToTs(program, model) {
      */
     return entries.length === 0 ? "{}" : `{\n${entries.join("\n")}\n}`;
 }
+/**
+ * A merged value as TypeScript - `z.input` of what `mergedToZod` writes for it, node for node.
+ */
+export function mergedToTs(program, value) {
+    switch (value.kind) {
+        case "never":
+        case "refused":
+            return UNREPRESENTABLE;
+        case "type": {
+            const typed = () => typeWithKeywordsToTs(program, value.type, value.keywords);
+            return value.at === undefined ? typed() : withVisibility(value.at, typed);
+        }
+        case "whole":
+            return propertyValueToTs(program, value.property);
+        case "nullable":
+            return `${mergedToTs(program, value.inner)} | null`;
+        case "union": {
+            // The members the validator writes - see `membersToWrite`.
+            const members = membersToWrite(program, value);
+            const texts = members.map((member) => mergedToTs(program, member));
+            /**
+             * **A dictionary written twice is written as two objects.** TypeScript reads
+             * `Record<string, unknown>` twice as the one type it names, where the validator writes two
+             * objects - `z.xor([z.looseObject({}), z.looseObject({})])`, a `@oneOf` of two merged
+             * members alike - whose two `z.input` types are two, and the wire assertion told them apart
+             * (`TS2344`). Spelled as an object, each is a type of its own, as each validator's is.
+             */
+            return members
+                .map((member, index) => {
+                const text = texts[index];
+                if (texts.indexOf(text) === texts.lastIndexOf(text))
+                    return text;
+                const previous = spellingDictionaries;
+                spellingDictionaries = true;
+                try {
+                    return mergedToTs(program, member);
+                }
+                finally {
+                    spellingDictionaries = previous;
+                }
+            })
+                .join(" | ");
+        }
+        case "all":
+            return value.parts.map((part) => `(${mergedToTs(program, part)})`).join(" & ");
+        case "array": {
+            const list = value.list;
+            const element = list === undefined
+                ? mergedToTs(program, value.element)
+                : atItem(program, list, () => mergedToTs(program, value.element));
+            return /[|&\s]/.test(element) ? `(${element})[]` : `${element}[]`;
+        }
+        case "object":
+            return objectToTs(program, value);
+    }
+}
+/** A type with keywords on it: the members they leave - see `keptMembersOf`. */
+function typeWithKeywordsToTs(program, type, keywords) {
+    const sources = constrainingKeywords(program, keywords);
+    if (sources.length === 0)
+        return typeToTs(program, type);
+    const member = (each) => isTypelessMember(program, each) ? `(${ANY_JSON_TS})` : typeToTs(program, each);
+    const members = keptMembersOf(program, type, sources);
+    if (members === undefined)
+        return member(type);
+    return members.length === 0 ? UNREPRESENTABLE : members.map(member).join(" | ");
+}
 /**
  * A property line, including its optionality marker.
  *
@@ -262,7 +391,17 @@ function modelToTs(program, model) {
  * Shared with the annotation the registry writes on a deferred (getter) property, so the type that
  * annotation claims is by construction the type this walk renders for the same property.
  */
-export function propertyTypeToTs(program, property) {
+export function propertyTypeToTs(program, property, position = OWN_POSITION) {
+    // What the declarations above it leave of the value - see `PropertyPosition`.
+    if (position.never || position.refused !== undefined)
+        return UNREPRESENTABLE;
+    if (position.nullOnly)
+        return "null";
+    if (position.value !== undefined)
+        return mergedToTs(program, position.value);
+    return atReading(program, property, () => propertyValueToTs(program, property, position));
+}
+function propertyValueToTs(program, property, position = OWN_POSITION) {
     /**
      * **`@encode` changes the wire TYPE, and `encodedTypeOf` is the one rule for when it does.** This
      * read `getEncode(...).type` directly, so it missed the exception the Zod walk makes: an array
@@ -270,14 +409,57 @@ export function propertyTypeToTs(program, property) {
      * back into the declared list. So `WireInputs` said `colors: string` for a pipe-delimited query
      * whose handler is given `string[]` - two walks of one property, one of them knowing a rule.
      */
-    const encoded = encodedTypeOf(program, property);
-    return typeToTs(program, encoded ?? property.type);
+    /**
+     * **And `encodedValueOf` is the rule for what the value then is**, read exactly as the Zod walk
+     * reads it, so `z.input` and this type agree: the declared type where the document keeps it beside
+     * the encoded scalar, the scalar where it does not, both where each constrains the other, and
+     * `never` where no value is both. A nullable property stays nullable.
+     */
+    const encoding = encodedValueOf(program, property);
+    switch (encoding.kind) {
+        case "declared": {
+            // A constrained union keeps the members its own keywords allow - see `constrainedMembersOf`.
+            const members = constrainedMembersOf(program, property, position);
+            const inner = nullableInnerOf(property.type);
+            // A `null` a declaration above refuses is left out, as the validator leaves it out.
+            if (members === undefined) {
+                const declared = position.nonNull && inner !== undefined ? inner : property.type;
+                // A property's `@oneOf` makes its inline union exclusive, as the Zod walk reads it.
+                return withExclusiveSite(exclusiveSiteOf(program, property, declared), () => typeToTs(program, declared));
+            }
+            const text = members.length === 0
+                ? UNREPRESENTABLE
+                : members
+                    .map((member) => isTypelessMember(program, member) ? `(${ANY_JSON_TS})` : typeToTs(program, member))
+                    .join(" | ");
+            return inner === undefined || position.nonNull ? text : orNull(text, true);
+        }
+        case "unsatisfiable":
+            return UNREPRESENTABLE;
+        case "replaced":
+            return orNull(typeToTs(program, encoding.scalar), encoding.nullable && !position.nonNull);
+        case "both": {
+            const member = (each) => replacesFormOf(program, encoding, each)
+                ? typeToTs(program, encoding.scalar)
+                : typeToTs(program, each);
+            const kept = Array.isArray(encoding.kept)
+                ? encoding.kept.map(member).join(" | ")
+                : member(encoding.kept);
+            const value = encodedIntersects(program, property, encoding)
+                ? `${typeToTs(program, encoding.scalar)} & (${kept})`
+                : kept;
+            return orNull(value, encoding.nullable);
+        }
+    }
+}
+function orNull(text, nullable) {
+    return nullable ? `${text} | null` : text;
 }
-export function propertyToTs(program, property, wireName) {
+export function propertyToTs(program, property, wireName, position = OWN_POSITION) {
     // The WIRE name, resolved exactly as `zod.ts` resolves it - `wire-contract.gen.ts` asserts the
     // emitted Zod infers this type, so the two must name every property identically or it fails.
     const key = objectKey(wireName ?? resolveEncodedName(program, property, "application/json"));
-    const value = propertyTypeToTs(program, property);
+    const value = propertyTypeToTs(program, property, position);
     /**
      * **A defaulted property used to be REQUIRED here, and that was the OUTPUT type's answer to a
      * question this file does not ask.**
@@ -333,9 +515,12 @@ export function propertyToTs(program, property, wireName) {
      * what `propertyToZod` has always consulted. This walk read `property.optional` alone, so an
      * update contract demanded every field while the validator beside it accepted any subset.
      */
-    if (!(property.optional || isOptionalAt(program, property)))
+    if (position.required || !(property.optional || isOptionalAt(program, property))) {
         return `${key}: ${value};`;
-    return emitsDefault(program, property) ? `${key}?: ${value} | undefined;` : `${key}?: ${value};`;
+    }
+    return emitsDefault(program, property, position)
+        ? `${key}?: ${value} | undefined;`
+        : `${key}?: ${value};`;
 }
 /** Installed by the registry so a named model is declared once and referenced everywhere else. */
 let resolveRef = () => undefined;
@@ -363,8 +548,13 @@ export function typeToTsBody(program, type) {
     switch (type.kind) {
         case "Scalar":
             return scalarToTs(program, type);
-        case "Model":
+        case "Model": {
+            // Refused as the schema walk refuses it - see `listTemplateInstanceWhy`.
+            const why = listTemplateInstanceWhy(program, type);
+            if (why !== undefined)
+                return refuse(program, type, why, LIST_TEMPLATE_REMEDY);
             return modelToTs(program, type);
+        }
         case "Enum":
             return enumToTs(type);
         case "Union":
@@ -386,9 +576,17 @@ export function typeToTsBody(program, type) {
             if (type.name === "unknown")
                 return "unknown";
             if (type.name === "void" || type.name === "never") {
-                return refuse(program, type, `\`${type.name}\` has no runtime representation`, "Give the position a type a value can inhabit. A `never` PROPERTY is dropped to match the document, and `Record<never>` seals the model, so neither of those reaches here.");
+                return refuse(program, type, `\`${type.name}\` has no runtime representation`, "Give the position a type a value can inhabit. A `never` property or parameter is dropped to match the document, and `Record<never>` seals the model, so none of those reaches here.");
             }
             return refuse(program, type, `intrinsic "${type.name}"`, "This emitter has no rule for that intrinsic. Replace it with a declared scalar or model.");
+        // `z.input` of the schema walk's `z.tuple([...exactOptional], z.unknown())`.
+        case "Tuple": {
+            if (inParameterPosition()) {
+                return refuse(program, type, TUPLE_PARAMETER.why, TUPLE_PARAMETER.remedy);
+            }
+            const positions = type.values.map((value) => `(${typeToTs(program, value)})?`);
+            return `[${[...positions, "...unknown[]"].join(", ")}]`;
+        }
         default:
             return refuse(program, type, "no rule for this kind", "Replace it with a model, scalar, enum or union, which are the kinds this emitter walks.");
     }