typespec-http-zod 0.23.0 → 0.24.0

package/README.md

@@ -148,6 +148,8 @@ carries the whole id, so `op readWidget` in `namespace Widgets` becomes `Widgets
 - [Reference](docs/reference.md): every option, every diagnostic, and the known limits.
 - [Oracles](docs/oracles.md): every artefact this emitter produces, and what compares it to the
   thing it has to agree with.
+- [Releasing](docs/releasing.md): why this package publishes first, and how to rehearse a
+  two-package release against a local registry.
 
 ## Licence
 

package/dist/src/api.d.ts

@@ -373,6 +373,8 @@ export interface ResolvedServiceOptions {
     readonly contractsOutputDir: string | undefined;
     readonly contractsPackage: string | undefined;
     readonly sealObjectSchemas: boolean;
+    /** Whether every emitted validator is wrapped in `z.compile()`. See the option's own docblock. */
+    readonly compileSchemas: boolean;
     readonly keyVocabularies: readonly string[];
     readonly runtimeModule: string;
     /** The command that regenerates, for the banner. `undefined` keeps the generic line. */

package/dist/src/api.js

@@ -680,7 +680,9 @@ function multipartSchemaOf(body, registry) {
                     : registry.expressionFor(type);
         // `multi` is `HttpPart<T>[]` - the same part repeated, which arrives as an array.
         const value = part.multi === true ? `z.array(${inner})` : inner;
-        return `\t${objectKey(part.name ?? "")}: ${part.optional === true ? `${value}.optional()` : value},`;
+        // `.exactOptional()` for the same reason as a model property: `parseBody` yields present keys
+        // only, so an absent part is an absent key rather than an explicit `undefined`.
+        return `\t${objectKey(part.name ?? "")}: ${part.optional === true ? `${value}.exactOptional()` : value},`;
     });
     const shape = entries.length === 0 ? "z.object({})" : `z.object({\n${entries.join("\n")}\n})`;
     /**
@@ -1266,7 +1268,26 @@ function renderExternalImports(externals, ...bodies) {
  * validate a request or a response against, and every oracle that graded those validators had to read
  * a server to find them. See {@link nameRouteSchemas}.
  */
-function renderSchemas(registry, externals, routeDeclarations, runtimeModule) {
+/**
+ * **`z.compile(...)` around a validator, when `compile-schemas` asks for it.**
+ *
+ * Zod walks the schema once and emits a flat, loop-free function through `new Function`, falling back
+ * to the ordinary parser for anything it cannot handle. Measured on zod 4.5.2 before this was written:
+ * `z.toJSONSchema` output is byte-identical, `_zod.def` is unchanged and still readable, and verdicts
+ * AND parsed output match for every construct this emitter writes - including `z.preprocess`,
+ * `.exactOptional()` and a `z.lazy()` cycle. So the two oracles that read a schema rather than run it
+ * are unaffected, and the wrapper is transparent.
+ *
+ * **A cyclic declaration is wrapped too, and that was worth checking rather than assuming.** The
+ * emitted form names the const being defined from inside its own `z.lazy()` body, and this repository
+ * has already shipped a break of exactly that shape - `.strict()` reads `shape` eagerly and throws
+ * `Cannot access 'X' before initialization` during module initialisation. Measured on the emitted
+ * shape: `z.compile()` does not force the lazy body, and the declaration parses.
+ */
+function compiled(expression, on) {
+    return on ? `z.compile(${expression})` : expression;
+}
+function renderSchemas(registry, externals, routeDeclarations, runtimeModule, compileSchemas) {
     const declarations = registry.declarations().map((d) => {
         /**
          * **A declaration on a CYCLE cannot take its type from `z.infer`, because that is the loop.**
@@ -1277,7 +1298,7 @@ function renderSchemas(registry, externals, routeDeclarations, runtimeModule) {
          * with no cycle emits byte-identical output to before.
          */
         if (d.structural === undefined) {
-            return `\nexport const ${d.identifier} = ${d.source};\nexport type ${d.typeName} = Exact<z.infer<typeof ${d.identifier}>>;\n`;
+            return `\nexport const ${d.identifier} = ${compiled(d.source, compileSchemas)};\nexport type ${d.typeName} = z.infer<typeof ${d.identifier}>;\n`;
         }
         const declared = d.structural.startsWith("{")
             ? `export interface ${d.typeName} ${d.structural}`
@@ -1308,7 +1329,22 @@ function renderSchemas(registry, externals, routeDeclarations, runtimeModule) {
          * than from this type, so no handler signature is affected.
          */
         const annotation = d.annotated === true ? `: z.ZodType<${d.typeName}, ${d.typeName}>` : "";
-        return `\n${declared}\nexport const ${d.identifier}${annotation} = ${d.source};\n`;
+        /**
+         * **A deferred declaration is NEVER compiled, and this was measured rather than reasoned.**
+         *
+         * `z.lazy()` is on Zod's own list of constructs the compiler cannot handle, and here the body
+         * forward-references a `const` declared further down the module. Wrapping it emitted output that
+         * loaded fine and then threw `Cannot read properties of undefined (reading '_zod')` on the first
+         * parse - the walk captures the reference while it is still in the temporal dead zone, so the
+         * failure surfaces at request time rather than at import.
+         *
+         * **Keyed on `annotated`, the fact the registry already holds** - it is set exactly when the
+         * declaration is deferred, which is exactly when `z.lazy()` is written - rather than on the
+         * shape of the emitted text. A model on a cycle whose back edge sits on a GETTER is a different
+         * case and is compiled like any other: measured, it parses, because a getter is not resolved
+         * until something reads it.
+         */
+        return `\n${declared}\nexport const ${d.identifier}${annotation} = ${compiled(d.source, compileSchemas && d.annotated !== true)};\n`;
     });
     /**
      * **Written only when something in the file names it**, like the `ResponseArm` import below and for
@@ -1327,39 +1363,24 @@ function renderSchemas(registry, externals, routeDeclarations, runtimeModule) {
      * rendered content for the same reason.
      */
     /**
-     * **`Exact` narrows an inferred optional to what the wire can carry.**
+     * **`Exact<>` lived here until `0.24.0`, and `z.exactOptional()` replaced it.**
      *
-     * `z.infer` of `.optional()` gives `p?: T | undefined`, which under `exactOptionalPropertyTypes`
-     * admits an explicitly-undefined property. **JSON has no `undefined`**, and the document says the
-     * same thing by leaving the property out of `required`, so the inferred type is wider than the
-     * wire and a consumer reading a payload had to strip it at the boundary.
+     * It was a mapped type over `z.infer` that stripped `| undefined` off every optional property,
+     * because `.optional()` infers `p?: T | undefined` and **JSON has no `undefined`** - the document
+     * says "absent or a value" by leaving the property out of `required`, so the inferred type was
+     * wider than both the document and the wire.
      *
-     * **It does NOT match the contract type, and this docblock used to claim it did.** The
-     * contract types in `requests.gen.ts` keep `?: T | undefined` on purpose: they are the floor a
-     * PRODUCER supplies, and `{ p: undefined }` serialises identically to omitting `p`, so refusing
-     * it would cost every producer a conditional spread and buy the wire nothing. Measured when this
-     * was "fixed" to agree: `(ctx, input) => ok(input)` - return what you were given - stopped
-     * compiling.
+     * The reasoning was right and it was applied to only one of the two artefacts. The VALIDATOR went
+     * on accepting `{ p: undefined }`, so one program published a type refusing a value beside a
+     * validator admitting it, compared by nothing. Emitting `.exactOptional()` makes `z.infer` produce
+     * `p?: T` directly - at every depth, which a shallow mapped type never reached - so the narrowing
+     * happens once, in the schema, and this helper has nothing left to do.
      *
-     * So the two surfaces differ on this axis deliberately, exactly as they differ on openness: this
-     * one is the narrow view of what ARRIVES, the contract type is the permissive floor for what you
-     * may SEND. A reader comparing them will find them unequal and should - the emitted assertion
-     * pairs the contract against raw `z.input`, not against this. They differ on a second axis for
-     * the same reason: a defaulted property is present here, because a default has fired by the time
-     * a value arrives, and optional in the contract type, because a caller may omit it.
-     *
-     * Derived from the same schema rather than hand-written beside it, so there is still one source of
-     * truth: a mapped type cannot drift from the thing it maps.
-     *
-     * Emitted only where a declaration names it, like the imports beside it.
+     * The contract types in `requests.gen.ts` still keep `?: T | undefined` on purpose: they are the
+     * floor a PRODUCER supplies, and `{ p: undefined }` serialises identically to omitting `p`, so
+     * refusing it there would cost every producer a conditional spread and buy the wire nothing.
+     * Narrowing THAT surface was tried in `0.19.0` and reverted - it broke `(ctx, input) => ok(input)`.
      */
-    const EXACT_HELPER = `
-/** An inferred type narrowed to what JSON can carry: an optional property is absent or a value. */
-type Exact<T> = { [K in keyof T as undefined extends T[K] ? never : K]: T[K] } & {
-	[K in keyof T as undefined extends T[K] ? K : never]?: Exclude<T[K], undefined>;
-};
-`;
-    const usesExact = declarations.some((d) => d.includes("Exact<"));
     const usesZod = new Set([...declarations, ...routeDeclarations].join("").match(/[A-Za-z_$][\w$]*/g) ?? []).has("z");
     const parts = [generatedBanner()];
     if (usesZod)
@@ -1376,8 +1397,6 @@ type Exact<T> = { [K in keyof T as undefined extends T[K] ? never : K]: T[K] } &
         parts.push(`import type { ResponseArm } from ${JSON.stringify(runtimeModule)};\n`);
     }
     parts.push(renderExternalImports(externals, [...declarations, ...routeDeclarations].join("")));
-    if (usesExact)
-        parts.push(EXACT_HELPER);
     parts.push(declarations.join(""));
     if (routeDeclarations.length > 0)
         parts.push(`\n${routeDeclarations.join("\n")}\n`);
@@ -1394,7 +1413,7 @@ type Exact<T> = { [K in keyof T as undefined extends T[K] ? never : K]: T[K] } &
 const isIdentifier = (expression) => /^[A-Za-z_$][\w$]*$/.test(expression);
 const schemaConst = (operationId, suffix) => `${operationId}${suffix}`;
 /** `[the name to refer to it by, the `const` line to emit]` - the line is absent when none is needed. */
-function namedSchema(operationId, suffix, expression) {
+function namedSchema(operationId, suffix, expression, compileSchemas) {
     if (expression === undefined)
         return { name: undefined, declaration: undefined };
     if (isIdentifier(expression))
@@ -1411,7 +1430,7 @@ function namedSchema(operationId, suffix, expression) {
      * Exporting also gives an application the request shape by name, which is what the per-operation
      * type aliases will be built from.
      */
-    return { name, declaration: `export const ${name} = ${expression};` };
+    return { name, declaration: `export const ${name} = ${compiled(expression, compileSchemas)};` };
 }
 /**
  * Which `verb path` slots carry more than one operation.
@@ -1453,13 +1472,13 @@ function sharedSlots(routes) {
  * Declaring them here dissolves all three: the library mints the names AND emits them, and a server
  * emitter imports what it is told rather than agreeing about it.
  */
-function nameRouteSchemas(routes) {
+function nameRouteSchemas(routes, compileSchemas) {
     const shared = sharedSlots(routes);
     const declarations = [];
     const names = new Map();
     for (const route of routes) {
         const declare = (suffix, expression) => {
-            const resolved = namedSchema(route.operationId, suffix, expression);
+            const resolved = namedSchema(route.operationId, suffix, expression, compileSchemas);
             if (resolved.declaration !== undefined)
                 declarations.push(resolved.declaration);
             return resolved.name;
@@ -1913,6 +1932,26 @@ type Identical<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends
  * dropped from a shape that has other keys, and kept - with its value type still mapped - from one
  * that does not.
  */
+/**
+ * \u26a0\ufe0f **An optional property is \`?: T\` here and \`?: T | undefined\` in the contract type, and that is
+ * deliberate on both sides.**
+ *
+ * The validator emits \`.exactOptional()\`, so what ARRIVES is absent or a value - JSON cannot carry an
+ * \`undefined\` and the document says exactly that by leaving the property out of \`required\`. The
+ * contract type is the floor a PRODUCER supplies, and \`{ p: undefined }\` serialises identically to
+ * omitting \`p\`, so refusing it would cost every producer a conditional spread and buy the wire
+ * nothing. Narrowing THAT surface was tried in \`0.19.0\` and reverted: it broke
+ * \`(ctx, input) => ok(input)\`.
+ *
+ * So the two disagree on exactly one axis, on purpose, and this widens the inferred side to the
+ * producer floor before comparing - the same job \`Declared\` does for openness, in the same pass
+ * rather than a second deep one. Every other kind of drift still fails: a property that changes type,
+ * appears, disappears or changes optionality is untouched by this.
+ */
+type Supplied<T, K extends keyof T> = {} extends Pick<T, K>
+	? Declared<T[K]> | undefined
+	: Declared<T[K]>;
+
 type DeclaredKeyOf<T> = keyof {
 	[K in keyof T as string extends K
 		? never
@@ -1931,7 +1970,9 @@ type Declared<T> = T extends (...args: never[]) => unknown
 			: readonly Declared<Element>[]
 		: T extends object
 			? [DeclaredKeyOf<T>] extends [never]
-				? { [K in keyof T]: Declared<T[K]> }
+				? // A shape with no declared keys is a dictionary: it has no optional property to widen,
+					// and an index signature satisfies \`{} extends Pick<T, K>\` for every value type.
+					{ [K in keyof T]: Declared<T[K]> }
 				: {
 						[K in keyof T as string extends K
 							? never
@@ -1939,7 +1980,7 @@ type Declared<T> = T extends (...args: never[]) => unknown
 								? never
 								: symbol extends K
 									? never
-									: K]: Declared<T[K]>;
+									: K]: Supplied<T, K>;
 					}
 			: T;
 
@@ -2077,6 +2118,7 @@ export async function emitHttpZod(context, wrapper = {}) {
             contractsOutputDir: perService?.["contracts-output-dir"] ?? options["contracts-output-dir"],
             contractsPackage: perService?.["contracts-package"] ?? options["contracts-package"],
             sealObjectSchemas: perService?.["seal-object-schemas"] ?? options["seal-object-schemas"] ?? false,
+            compileSchemas: perService?.["compile-schemas"] ?? options["compile-schemas"] ?? false,
             keyVocabularies: perService?.["key-vocabularies"] ?? options["key-vocabularies"] ?? [],
             runtimeModule: perService?.["runtime-module"] ?? options["runtime-module"] ?? defaultRuntimeModule,
             regenerateHint: perService?.["regenerate-hint"] ?? options["regenerate-hint"],
@@ -2133,10 +2175,10 @@ export async function emitHttpZod(context, wrapper = {}) {
          * anything is written - and it has to happen HERE rather than in a server emitter, or the
          * validators it produces never reach this package's own output.
          */
-        const { names, declarations } = nameRouteSchemas(routes);
+        const { names, declarations } = nameRouteSchemas(routes, resolved.compileSchemas);
         await emitFile(context.program, {
             path: resolvePath(outputDir, "schemas.gen.ts"),
-            content: renderSchemas(registry, externals, declarations, resolved.runtimeModule),
+            content: renderSchemas(registry, externals, declarations, resolved.runtimeModule, resolved.compileSchemas),
         });
         if (resolved.contractsOutputDir !== undefined) {
             const types = new TypeRegistry(context.program);

package/dist/src/constraints.d.ts

@@ -6,12 +6,13 @@ import { type Program, type Type } from "@typespec/compiler";
  * over: the spec author writes standard TypeSpec rather than a dialect, and `@typespec/openapi3`
  * documents them without any help from us.
  *
- * **`@refine` is the ONE that is still ours, and it is on its way out.** It is not a constraint -
- * it is an arbitrary predicate, which a type language has no way to say and therefore no document
- * can publish, so a validator enforcing it enforces something no caller can read. `@trimmed` was the
- * other one and is gone: `.trim()` is a transform, and transforming a value before validating it
- * makes the runtime accept inputs the published contract rejects. The spec states `@pattern`
- * instead, which openapi3 publishes.
+ * **This package ships no decorators of its own, and the two it used to have are gone.** `@refine`
+ * was an arbitrary predicate, which a type language has no way to say and therefore no document can
+ * publish, so a validator enforcing it enforced something no caller could read. `@trimmed` was the
+ * other: `.trim()` is a transform, and transforming a value before validating it makes the runtime
+ * accept inputs the published contract rejects. The spec states `@pattern` instead, which openapi3
+ * publishes. `src/tsp-index.ts` exports `$lib` and no `$decorators`, and `vocabulary.test.ts`
+ * 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;
 /**

package/dist/src/constraints.js

@@ -6,12 +6,13 @@ import { getMaxItems, getMaxLength, getMaxValue, getMinItems, getMinLength, getM
  * over: the spec author writes standard TypeSpec rather than a dialect, and `@typespec/openapi3`
  * documents them without any help from us.
  *
- * **`@refine` is the ONE that is still ours, and it is on its way out.** It is not a constraint -
- * it is an arbitrary predicate, which a type language has no way to say and therefore no document
- * can publish, so a validator enforcing it enforces something no caller can read. `@trimmed` was the
- * other one and is gone: `.trim()` is a transform, and transforming a value before validating it
- * makes the runtime accept inputs the published contract rejects. The spec states `@pattern`
- * instead, which openapi3 publishes.
+ * **This package ships no decorators of its own, and the two it used to have are gone.** `@refine`
+ * was an arbitrary predicate, which a type language has no way to say and therefore no document can
+ * publish, so a validator enforcing it enforced something no caller could read. `@trimmed` was the
+ * other: `.trim()` is a transform, and transforming a value before validating it makes the runtime
+ * accept inputs the published contract rejects. The spec states `@pattern` instead, which openapi3
+ * publishes. `src/tsp-index.ts` exports `$lib` and no `$decorators`, and `vocabulary.test.ts`
+ * asserts that no emitted file carries a `.refine(` outside the one multipart-file carve-out.
  */
 export function applyConstraints(program, expression, target) {
     let result = expression;

package/dist/src/lib.d.ts

@@ -42,6 +42,38 @@ export interface EmitterOptions {
      * stating it outright rather than an emitter option deciding.
      */
     "seal-object-schemas"?: boolean;
+    /**
+     * Whether every emitted validator is wrapped in `z.compile()`.
+     *
+     * **A pre-compiled schema parses the same values to the same results, only faster.** Zod walks the
+     * schema once and emits a flat, loop-free function through `new Function`, then falls back to the
+     * ordinary parser for anything it cannot handle - so errors, parsed output and JSON Schema
+     * serialisation are unchanged. Measured on an emitted five-property model at zod 4.5.2:
+     * `safeParse` goes from 371 ns to 51 ns.
+     *
+     * **Off by default, because it is a trade rather than a free win.** Compilation happens at module
+     * scope, so it costs startup time in proportion to the number of schemas, and buys nothing until
+     * enough requests arrive to pay that back. Measured on two emitted modules at zod 4.5.2: 25
+     * declarations in 3.3 ms and 73 in 5.7 ms, so 0.08-0.13 ms each depending on how much the schema
+     * does.
+     *
+     * **Measured at scale rather than extrapolated:** a generated 580-operation service (58 models,
+     * 1218 declarations, 638 of them compiled) evaluates its schema module in ~93 ms uncompiled and
+     * ~132 ms compiled - so about **40 ms of extra startup**, roughly a tenth of a Cloudflare Worker's
+     * 400 ms startup budget. It boots and serves on `workerd` at that size with the fast path live. It also needs
+     * `new Function`, which a CSP or no-eval environment refuses; Zod degrades to the uncompiled
+     * schema there rather than throwing, so setting this is never unsafe, merely sometimes pointless.
+     *
+     * **On Cloudflare Workers this is the only route to a compiled schema.** `new Function` is
+     * permitted during a Worker's STARTUP phase (`allow_eval_during_startup`, the default from
+     * compatibility date 2025-06-01) and module scope is startup, so wrapping here works. Zod's own
+     * `import "zod/compile"` does not: it compiles on first PARSE, which happens inside a request,
+     * where the runtime refuses. Only the emitter owns the module scope these schemas are built in.
+     *
+     * A recursive model emits `z.lazy()`, which cannot be compiled. Zod returns it uncompiled and it
+     * goes on parsing normally, so the option is safe to set on any spec.
+     */
+    "compile-schemas"?: boolean;
     /**
      * Models whose PROPERTY NAMES are also emitted as a runtime tuple.
      *
@@ -100,6 +132,7 @@ export interface EmitterOptions {
         "contracts-output-dir"?: string;
         "contracts-package"?: string;
         "seal-object-schemas"?: boolean;
+        "compile-schemas"?: boolean;
         "key-vocabularies"?: string[];
         "runtime-module"?: string;
         "regenerate-hint"?: string;

package/dist/src/lib.js

@@ -12,6 +12,7 @@ export const EmitterOptionsSchema = {
         "contracts-output-dir": { type: "string", nullable: true },
         "contracts-package": { type: "string", nullable: true },
         "seal-object-schemas": { type: "boolean", nullable: true },
+        "compile-schemas": { type: "boolean", nullable: true },
         "key-vocabularies": { type: "array", items: { type: "string" }, nullable: true },
         "runtime-module": { type: "string", nullable: true },
         "regenerate-hint": { type: "string", nullable: true },
@@ -26,6 +27,7 @@ export const EmitterOptionsSchema = {
                     "contracts-output-dir": { type: "string", nullable: true },
                     "contracts-package": { type: "string", nullable: true },
                     "seal-object-schemas": { type: "boolean", nullable: true },
+                    "compile-schemas": { type: "boolean", nullable: true },
                     "key-vocabularies": { type: "array", items: { type: "string" }, nullable: true },
                     "runtime-module": { type: "string", nullable: true },
                     "regenerate-hint": { type: "string", nullable: true },

package/dist/src/zod.js

@@ -1021,7 +1021,25 @@ export function propertyToZod(program, property) {
     const defaulted = defaultOf(program, property);
     if (defaulted !== undefined)
         return `${base}.default(${defaulted})`;
-    return optional ? `${base}.optional()` : base;
+    /**
+     * **`.exactOptional()`, because the document says the KEY may be absent and nothing more.**
+     *
+     * `.optional()` additionally accepts an explicit `undefined`, and **JSON cannot carry one** - so
+     * for a body the validator was admitting a value no conformant request can contain, and for a
+     * parameter one no transport produces. The document says exactly "absent or a value" by leaving
+     * the property out of `required`, and this is the construct that says the same.
+     *
+     * **The emitted TYPE has said this since `0.17.0`; only the validator disagreed.** `Exact<>` was
+     * written to strip `| undefined` back off `z.infer`, with a docblock arguing precisely this - so
+     * one program published a type refusing `{ note: undefined }` beside a validator accepting it, and
+     * nothing compared them. `z.infer` of `.exactOptional()` is `note?: T` natively and at every depth,
+     * which a shallow mapped type never managed, so `Exact<>` is deleted rather than kept beside it.
+     *
+     * Measured on zod 4.5.2 before the change: `z.toJSONSchema` is byte-identical for the two, so the
+     * differential's serialisation axis is untouched, and `def.type` is still `"optional"`, so the
+     * shape describers read it unchanged.
+     */
+    return optional ? `${base}.exactOptional()` : base;
 }
 /**
  * A default value as a JS literal, or `undefined` where this emitter cannot render one.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typespec-http-zod",
-  "version": "0.23.0",
+  "version": "0.24.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",
@@ -55,13 +55,14 @@
     "@typespec/streams": "0.85.0",
     "@typespec/versioning": "0.85.0",
     "@typespec/xml": "0.85.0",
+    "ajv": "^8.20.0",
     "oxfmt": "^0.63.0",
     "oxlint": "^1.78.0",
     "typescript": "~7.0.2",
     "typespec-http-zod": "link:.",
     "vitest": "^4.1.9",
     "yaml": "^2.9.0",
-    "zod": "^4.4.3"
+    "zod": "^4.5.2"
   },
   "peerDependencies": {
     "@typespec/compiler": "^1.15.0",
@@ -69,7 +70,7 @@
     "@typespec/openapi": "^1.15.0",
     "@typespec/streams": "^0.85.0",
     "@typespec/versioning": "^0.85.0",
-    "zod": "^4.0.0"
+    "zod": "^4.5.0"
   },
   "peerDependenciesMeta": {
     "@typespec/streams": {