genoc 0.5.1 → 0.5.3

package/README.md

@@ -58,10 +58,11 @@ import type { Requester } from 'genoc/runtime';
 For the full `Requester` type signature and binary and stream handling, see [Usage](./docs/usage.md).
 
 ```typescript
-import { createClient } from './client.js';
 import type { Requester } from 'genoc/runtime';
 import { RequesterFailError, ErrorResponse } from 'genoc/runtime';
 
+import { createClient } from './client.js';
+
 const baseUrl = 'https://api.example.com';
 
 const requester: Requester = async (method, path, options) => {

package/dist/analyzer/analyze.js

@@ -3,7 +3,7 @@ import { buildSchemaRenameMap, buildTypeJsDoc, sanitizeJsDocText, sanitizeTypeNa
 import { operationEmissions, RESERVED_TYPE_NAMES } from '../utils/operation-naming.js';
 import { escapeStringLiteral } from '../utils/string.js';
 import { buildDiscriminatorRegistry, renameAwareTypeName } from './discriminator-registry.js';
-import { analyzePathsDetailed } from './path-analyzer.js';
+import { analyzePathsDetailed, collectFormProperties, findBinaryFieldNames, schemaContainsBinary, } from './path-analyzer.js';
 import { SchemaMapper } from './schema-mapper.js';
 /**
  * Indent unit matching `INDENT_UNIT` in schema-mapper.ts (2 spaces, pinned by
@@ -338,6 +338,7 @@ function analyzeServers(servers) {
 export function analyze(doc, opts = {}) {
     const resolver = opts.resolver ?? new RefResolver(doc);
     const strategy = opts.strategy ?? 'path-based';
+    const warn = opts.warnSink ?? writeWarning;
     const schemaNameList = doc.components?.schemas ? Object.keys(doc.components.schemas) : [];
     const renameMap = buildSchemaRenameMap(schemaNameList, RESERVED_TYPE_NAMES);
     for (const [original, renamed] of renameMap) {
@@ -360,7 +361,7 @@ export function analyze(doc, opts = {}) {
     // source for discriminator translation: the mapper's ref-translation seam
     // consumes it, and the always-emitted `{Base}Variant` unions below are
     // emitted from it.
-    const discriminatorRegistry = buildDiscriminatorRegistry(doc.components?.schemas, resolver, renameMap, allSchemaNames, writeWarning);
+    const discriminatorRegistry = buildDiscriminatorRegistry(doc.components?.schemas, resolver, renameMap, allSchemaNames, warn);
     const mapper = new SchemaMapper(resolver, {
         typeNameGenerator: renamingTypeGenerator,
         emittedNames: allSchemaNames,
@@ -472,14 +473,28 @@ export function analyze(doc, opts = {}) {
         if (emissions.headers) {
             opLines.push(`export type ${emissions.headers} = ${buildParamTypeBody(op.headerParams, mapper)};`);
         }
+        // A urlencoded body declaring `format: binary` fields cannot transport
+        // them — the generated client would silently type the files as plain
+        // strings. Warn and name the offending fields (merged through allOf).
+        if (op.requestBody?.contentTypes[0] === 'application/x-www-form-urlencoded' &&
+            rawBodySchema !== undefined &&
+            schemaContainsBinary(rawBodySchema, resolver)) {
+            const fieldNames = findBinaryFieldNames(rawBodySchema, resolver);
+            const fieldList = fieldNames.length > 0
+                ? ` declaring binary fields (${fieldNames.map((n) => `"${n}"`).join(', ')})`
+                : ' declaring binary data';
+            warn(`Warning: the request body of ${op.method.toUpperCase()} ${op.path} uses content type "application/x-www-form-urlencoded"${fieldList}, but urlencoded form data cannot transport binary files. File uploads require "multipart/form-data"; the generated client types these fields as plain strings.\n`);
+        }
         // Section 3: Request body types
         const bodyJsDoc = op.requestBody ? buildDescriptionJsDoc(op.requestBody.description) : '';
         if (op.requestBody?.isMultipart && rawBodySchema !== undefined) {
-            const schema = resolver.resolveSchema(rawBodySchema);
-            const requiredSet = new Set(schema.required ?? []);
+            // Form fields come from the allOf-merged walk: a body declaring its
+            // fields via `allOf` members (resolving `$ref`s) previously produced an
+            // empty property walk — `Record<string, never>` and dropped appends.
+            const { properties, required: requiredSet } = collectFormProperties(rawBodySchema, resolver);
             const propLines = [];
             const fileUploadProperties = [];
-            for (const [name, propSchema] of Object.entries(schema.properties ?? {})) {
+            for (const [name, propSchema] of properties) {
                 const resolved = resolver.resolveSchema(propSchema);
                 const optional = requiredSet.has(name) ? '' : '?';
                 let tsType;

package/dist/analyzer/discriminator-registry.d.ts

@@ -49,10 +49,18 @@ export interface DiscriminatorVariantEntry {
     isNullable: boolean;
     /** Owning family id — the discriminator base's raw component name. */
     familyId: string;
-    /** The exact `$ref` string that produced this entry (mapping value or oneOf/anyOf member ref). */
+    /** The exact `$ref` string that produced this entry (mapping value, oneOf/anyOf member ref, canonical base ref, or implicit allOf child ref). */
     refStr: string;
     /** Rename-aware type name for the ref (same derivation as the mapper's `typeNameGenerator`). */
     typeName: string;
+    /**
+     * True for the family base's own entry — the base participates in its own
+     * family union (self-mapped, or no `oneOf`/`anyOf` of its own). Consumers:
+     * same-family-spine base-ref translation routes through the entry seam
+     * (`Omit<Base, P>`), and the mapper skips the `{ P: string }` placeholder on
+     * the base's own definition because the literal replaces it.
+     */
+    isBaseMember: boolean;
 }
 /**
  * One discriminator family: a component schema declaring `discriminator`
@@ -73,7 +81,7 @@ export interface DiscriminatorFamily {
     propertyName: string;
     /** Collision-safe `{Base}Variant` union name (D6 — via the reserved-name machinery). */
     variantUnionName: string;
-    /** Union member type names (rename-aware, deduped; mapping order, then unmapped oneOf/anyOf refs). */
+    /** Union member type names (rename-aware, deduped; entry insertion order: base, mapping, unmapped oneOf/anyOf refs, implicit allOf children). */
     variantUnionMembers: string[];
     /** Family entries keyed by the FULL `$ref` string (mapping value or oneOf/anyOf member ref). */
     entriesByRef: Map<string, DiscriminatorVariantEntry>;

package/dist/analyzer/discriminator-registry.js

@@ -103,9 +103,36 @@ export function buildDiscriminatorRegistry(schemas, resolver, renameMap, allSche
     };
     if (!schemas)
         return registry;
-    // Pass 1 — discover families; per family, register mapping entries first
-    // (D3: mapping key wins), then implicit oneOf/anyOf variants absent from
-    // the mapping (literal = own const > single-value enum > RAW ref segment).
+    // Implicit allOf children (issue #93): a schema whose `allOf` references a
+    // family base DIRECTLY is a variant of that family even when `mapping` and
+    // the base's own oneOf/anyOf leave it out. Index childName → the set of
+    // canonical `#/components/schemas/…` refs it allOfs, once, up front —
+    // grandchildren (allOf a child, not the base) stay out by construction.
+    const allOfBasesByChild = new Map();
+    for (const [childName, childSchema] of Object.entries(schemas)) {
+        let childResolved;
+        try {
+            childResolved = resolver.resolve(childSchema);
+        }
+        catch {
+            continue;
+        }
+        if (!childResolved.allOf)
+            continue;
+        const bases = new Set();
+        for (const member of childResolved.allOf) {
+            if (!isRefObject(member) || !member.$ref.startsWith('#/components/schemas/'))
+                continue;
+            bases.add(`#/components/schemas/${encodePointerSegment(rawRefSegment(member.$ref))}`);
+        }
+        if (bases.size > 0)
+            allOfBasesByChild.set(childName, bases);
+    }
+    // Pass 1 — discover families; per family, register the base's own entry
+    // when it joins its family (self-mapped, or no oneOf/anyOf of its own),
+    // then mapping entries (D3: mapping key wins), then implicit oneOf/anyOf
+    // variants absent from the mapping (literal = own const > single-value
+    // enum > RAW ref segment), then implicit allOf children absent from both.
     for (const [name, schema] of Object.entries(schemas)) {
         const resolved = resolver.resolve(schema);
         const disc = resolved.discriminator;
@@ -121,12 +148,46 @@ export function buildDiscriminatorRegistry(schemas, resolver, renameMap, allSche
             variantUnionMembers: [],
             entriesByRef: new Map(),
         };
+        // Base membership (#93): a CONCRETE base (no oneOf/anyOf of its own) is a
+        // variant of its own family even when `mapping` omits it — with no other
+        // members the family would otherwise reference an empty union. A base
+        // listed in its own mapping joins too (its key wins the literal, D3).
+        // Insertion order matters: the base entry lands FIRST so union members
+        // read `{Base} | <mapped…> | <implicit…>`.
+        const baseHasOwnUnion = (resolved.oneOf?.length ?? 0) > 0 || (resolved.anyOf?.length ?? 0) > 0;
+        const selfMappingKey = disc.mapping
+            ? Object.entries(disc.mapping).find(([, refStr]) => refStr === family.baseRefStr)?.[0]
+            : undefined;
+        if (selfMappingKey !== undefined || !baseHasOwnUnion) {
+            const ownBaseLiteral = resolveOwnDiscriminatorLiteral(resolved, disc.propertyName, resolver);
+            if (selfMappingKey !== undefined &&
+                ownBaseLiteral !== undefined &&
+                ownBaseLiteral.value !== selfMappingKey) {
+                warn(`Warning: Discriminator mapping key "${selfMappingKey}" for "${family.baseRefStr}" conflicts with its own declared ${ownBaseLiteral.source} literal "${ownBaseLiteral.value}"; the mapping key wins.\n`);
+            }
+            family.entriesByRef.set(family.baseRefStr, {
+                propertyName: disc.propertyName,
+                // Base literal precedence: self-mapping key > own const/enum > raw
+                // component name (the runtime value, NOT the sanitized type name).
+                literalValue: escapeStringLiteral(selfMappingKey ?? ownBaseLiteral?.value ?? name),
+                isNamed: true, // the base is by definition an emitted component schema
+                isUnion: baseHasOwnUnion,
+                isNullable: resolved.nullable === true ||
+                    (Array.isArray(resolved.type) ? resolved.type.includes('null') : false),
+                isBaseMember: true,
+                familyId,
+                refStr: family.baseRefStr,
+                typeName: family.baseTypeName,
+            });
+        }
         const mappedRefStrs = new Set();
         if (disc.mapping) {
             for (const [mappingKey, refStr] of Object.entries(disc.mapping)) {
                 if (mappedRefStrs.has(refStr))
                     continue; // two keys → same target: first key wins
                 mappedRefStrs.add(refStr);
+                if (family.entriesByRef.has(refStr))
+                    continue; // base self-mapping — the base entry already carries it
                 const target = resolveTargetSchema(resolver, refStr);
                 const own = resolveOwnDiscriminatorLiteral(target, disc.propertyName, resolver);
                 if (own !== undefined && own.value !== mappingKey) {
@@ -140,6 +201,7 @@ export function buildDiscriminatorRegistry(schemas, resolver, renameMap, allSche
                     isUnion: (target?.oneOf?.length ?? 0) > 0 || (target?.anyOf?.length ?? 0) > 0,
                     isNullable: target?.nullable === true ||
                         (Array.isArray(target?.type) ? target.type.includes('null') : false),
+                    isBaseMember: false,
                     familyId,
                     refStr,
                     typeName: renameAwareTypeName(renameMap, rawSegment),
@@ -153,8 +215,8 @@ export function buildDiscriminatorRegistry(schemas, resolver, renameMap, allSche
                 implicitRefs.push(member.$ref);
         }
         for (const refStr of implicitRefs) {
-            if (mappedRefStrs.has(refStr))
-                continue; // already registered via mapping
+            if (mappedRefStrs.has(refStr) || family.entriesByRef.has(refStr))
+                continue; // already registered
             const target = resolveTargetSchema(resolver, refStr);
             const own = resolveOwnDiscriminatorLiteral(target, disc.propertyName, resolver);
             const rawSegment = rawRefSegment(refStr);
@@ -168,17 +230,46 @@ export function buildDiscriminatorRegistry(schemas, resolver, renameMap, allSche
                 isUnion: (target?.oneOf?.length ?? 0) > 0 || (target?.anyOf?.length ?? 0) > 0,
                 isNullable: target?.nullable === true ||
                     (Array.isArray(target?.type) ? target.type.includes('null') : false),
+                isBaseMember: false,
                 familyId,
                 refStr,
                 typeName: renameAwareTypeName(renameMap, rawSegment),
             };
             family.entriesByRef.set(refStr, entry);
         }
+        // Implicit allOf children (#93): direct `allOf` refs to the base count as
+        // variants even when `mapping` leaves them out; anything already present
+        // (mapping target, implicit oneOf/anyOf ref, the base itself) is skipped,
+        // so children land in component order after the mapped/implicit members.
+        for (const [childName, bases] of allOfBasesByChild) {
+            if (!bases.has(family.baseRefStr))
+                continue;
+            const childRefStr = `#/components/schemas/${encodePointerSegment(childName)}`;
+            if (family.entriesByRef.has(childRefStr))
+                continue;
+            const target = resolveTargetSchema(resolver, childRefStr);
+            const own = resolveOwnDiscriminatorLiteral(target, disc.propertyName, resolver);
+            const entry = {
+                propertyName: disc.propertyName,
+                // Same D3 fallback chain as unmapped oneOf/anyOf variants.
+                literalValue: escapeStringLiteral(own?.value ?? childName),
+                isNamed: allSchemaNames.has(renameAwareTypeName(renameMap, childName)),
+                isUnion: (target?.oneOf?.length ?? 0) > 0 || (target?.anyOf?.length ?? 0) > 0,
+                isNullable: target?.nullable === true ||
+                    (Array.isArray(target?.type) ? target.type.includes('null') : false),
+                isBaseMember: false,
+                familyId,
+                refStr: childRefStr,
+                typeName: renameAwareTypeName(renameMap, childName),
+            };
+            family.entriesByRef.set(childRefStr, entry);
+        }
         registry.families.set(familyId, family);
     }
     // Pass 2 — flat lookups + per-family name index + union members
-    // (mapping order, then unmapped oneOf/anyOf refs; deduped by refStr and
-    // by typeName — alias refs to one emitted name collapse).
+    // (entry insertion order: base, then mapping, then unmapped oneOf/anyOf
+    // refs, then implicit allOf children; deduped by refStr and by typeName
+    // — alias refs to one emitted name collapse).
     for (const family of registry.families.values()) {
         const memberNames = [];
         const seenNames = new Set();

package/dist/analyzer/path-analyzer.d.ts

@@ -82,6 +82,37 @@ export interface AnalyzedOperation {
     /** Raw operation-level `security`; `undefined` = inherit the document default. */
     security?: SecurityRequirementObject[];
 }
+/**
+ * Deep, ref-resolving, cycle-safe check: does any schema node reachable from
+ * `schema` (through `properties`, `items`, `allOf`/`oneOf`/`anyOf` members and
+ * schema-valued `additionalProperties`) declare `format: binary`? Unlike
+ * {@link isBinarySchema} this catches binary data buried in composed schemas —
+ * e.g. a `files` array of binary strings hidden inside an `allOf` member.
+ */
+export declare function schemaContainsBinary(schema: SchemaObject | ReferenceObject | undefined, resolver: RefResolver): boolean;
+/**
+ * The flattened form fields of a request body schema: the root object's own
+ * `properties`/`required` merged with those of every `allOf` member,
+ * recursively, resolving `$ref`s. Later same-named members do not override
+ * earlier ones (first-write wins, matching the mapper's `allOf` array-order
+ * rendering); member `required` lists are unioned.
+ *
+ * Motivation: multipart bodies declaring their fields via `allOf` (a common
+ * upstream-spec shape) previously produced an empty property walk — the
+ * generated body type collapsed to `Record<string, never>` and every FormData
+ * append was silently dropped.
+ */
+export declare function collectFormProperties(schema: SchemaObject | ReferenceObject | undefined, resolver: RefResolver, properties?: Map<string, SchemaObject | ReferenceObject>, required?: Set<string>, visited?: Set<SchemaObject>): {
+    properties: Map<string, SchemaObject | ReferenceObject>;
+    required: Set<string>;
+};
+/**
+ * Names of the (allOf-merged) top-level form fields whose subtree contains
+ * `format: binary` — for warnings that name the offending fields. Empty when
+ * the binary data sits outside any named field (e.g. the whole body schema
+ * is a binary string) or there is no binary data at all.
+ */
+export declare function findBinaryFieldNames(schema: SchemaObject | ReferenceObject | undefined, resolver: RefResolver): string[];
 /**
  * Analyzer-internal analysis result: the analyzed operations plus the raw
  * request body schemas in a PARALLEL ARRAY (same length and order as

package/dist/analyzer/path-analyzer.js

@@ -12,6 +12,103 @@ function isBinarySchema(schema, resolver) {
         return false;
     return resolver.resolveSchema(schema).format === 'binary';
 }
+/**
+ * Deep, ref-resolving, cycle-safe check: does any schema node reachable from
+ * `schema` (through `properties`, `items`, `allOf`/`oneOf`/`anyOf` members and
+ * schema-valued `additionalProperties`) declare `format: binary`? Unlike
+ * {@link isBinarySchema} this catches binary data buried in composed schemas —
+ * e.g. a `files` array of binary strings hidden inside an `allOf` member.
+ */
+export function schemaContainsBinary(schema, resolver) {
+    return containsBinary(schema, resolver, new Set());
+}
+function containsBinary(schema, resolver, visited) {
+    if (!schema)
+        return false;
+    const resolved = resolver.resolveSchema(schema);
+    // Cycle guard on resolved object identity (a self-referencing $ref chain
+    // would otherwise recurse forever; schema-mapper uses the same pattern).
+    if (visited.has(resolved))
+        return false;
+    visited.add(resolved);
+    if (resolved.format === 'binary')
+        return true;
+    if (resolved.items !== undefined) {
+        if (containsBinary(resolved.items, resolver, visited))
+            return true;
+    }
+    for (const member of resolved.allOf ?? []) {
+        if (containsBinary(member, resolver, visited))
+            return true;
+    }
+    for (const member of resolved.oneOf ?? []) {
+        if (containsBinary(member, resolver, visited))
+            return true;
+    }
+    for (const member of resolved.anyOf ?? []) {
+        if (containsBinary(member, resolver, visited))
+            return true;
+    }
+    for (const propSchema of Object.values(resolved.properties ?? {})) {
+        if (containsBinary(propSchema, resolver, visited))
+            return true;
+    }
+    if (typeof resolved.additionalProperties === 'object' && resolved.additionalProperties !== null) {
+        if (containsBinary(resolved.additionalProperties, resolver, visited))
+            return true;
+    }
+    return false;
+}
+/**
+ * The flattened form fields of a request body schema: the root object's own
+ * `properties`/`required` merged with those of every `allOf` member,
+ * recursively, resolving `$ref`s. Later same-named members do not override
+ * earlier ones (first-write wins, matching the mapper's `allOf` array-order
+ * rendering); member `required` lists are unioned.
+ *
+ * Motivation: multipart bodies declaring their fields via `allOf` (a common
+ * upstream-spec shape) previously produced an empty property walk — the
+ * generated body type collapsed to `Record<string, never>` and every FormData
+ * append was silently dropped.
+ */
+export function collectFormProperties(schema, resolver, properties = new Map(), required = new Set(), visited = new Set()) {
+    if (!schema)
+        return { properties, required };
+    const resolved = resolver.resolveSchema(schema);
+    // Cycle guard on resolved identity (same pattern as containsBinary above).
+    if (visited.has(resolved))
+        return { properties, required };
+    visited.add(resolved);
+    // allOf members come first, mirroring the mapper's `A & B` member order.
+    for (const member of resolved.allOf ?? []) {
+        collectFormProperties(member, resolver, properties, required, visited);
+    }
+    for (const name of resolved.required ?? []) {
+        required.add(name);
+    }
+    for (const [name, propSchema] of Object.entries(resolved.properties ?? {})) {
+        if (!properties.has(name)) {
+            properties.set(name, propSchema);
+        }
+    }
+    return { properties, required };
+}
+/**
+ * Names of the (allOf-merged) top-level form fields whose subtree contains
+ * `format: binary` — for warnings that name the offending fields. Empty when
+ * the binary data sits outside any named field (e.g. the whole body schema
+ * is a binary string) or there is no binary data at all.
+ */
+export function findBinaryFieldNames(schema, resolver) {
+    const { properties } = collectFormProperties(schema, resolver);
+    const names = [];
+    for (const [name, propSchema] of properties) {
+        if (containsBinary(propSchema, resolver, new Set())) {
+            names.push(name);
+        }
+    }
+    return names;
+}
 function resolveParameter(param, resolver) {
     return resolver.resolve(param);
 }

package/dist/analyzer/schema-mapper.js

@@ -76,6 +76,7 @@ function spineForEntry(entry) {
         familyId: entry.familyId,
         propertyName: entry.propertyName,
         literalValue: entry.literalValue,
+        isBaseMember: entry.isBaseMember,
     };
 }
 /**
@@ -266,6 +267,14 @@ export class SchemaMapper {
             return result;
         }
         if (s.type === undefined) {
+            // OpenAPI permits omitting `type`: a schema carrying `properties`
+            // and/or `additionalProperties` is an object schema regardless. Map it
+            // through the object branch instead of degrading to `unknown`; a
+            // genuinely unconstrained schema (no keywords to infer from) stays
+            // `unknown` (any JSON value).
+            if (s.properties !== undefined || s.additionalProperties !== undefined) {
+                return this.mapObject(s, name, context, visited, indent, spine);
+            }
             return { tsType: 'unknown', imports: [] };
         }
         if (Array.isArray(s.type)) {
@@ -354,9 +363,21 @@ export class SchemaMapper {
         const canonical = this.canonicalSchemasRef(refStr);
         const baseFamily = registry.baseRefs.get(refStr) ?? registry.baseRefs.get(canonical);
         if (baseFamily) {
+            const baseEntry = baseFamily.entriesByRef.get(baseFamily.baseRefStr);
+            if (spine && spine.familyId === baseFamily.familyId && baseEntry) {
+                // Member base inside its own family spine (#93): the base joins as a
+                // variant through the entry seam — `Omit<Base, P>` — so the child's
+                // literal append never collides with the base's own.
+                return this.mapSameFamilySpineRef(baseEntry, context, visited, indent);
+            }
             if (spine && spine.familyId === baseFamily.familyId) {
                 return { tsType: baseFamily.baseTypeName, imports: [baseFamily.baseTypeName] };
             }
+            // Empty family (#93): no members at all — refs fall back to the bare
+            // base name instead of an undeclared `{Base}Variant` union.
+            if (baseFamily.variantUnionMembers.length === 0) {
+                return { tsType: baseFamily.baseTypeName, imports: [baseFamily.baseTypeName] };
+            }
             return { tsType: baseFamily.variantUnionName, imports: [baseFamily.variantUnionName] };
         }
         const entry = registry.byRef.get(refStr) ?? registry.byRef.get(canonical);
@@ -650,7 +671,9 @@ export class SchemaMapper {
         const memberIndent = indentBy(indent + 1);
         const memberLines = [];
         const allImports = [];
-        if (schema.discriminator) {
+        if (schema.discriminator && !spine?.isBaseMember) {
+            // A member base's placeholder (`"${discPropName}": string;`) is skipped:
+            // its literal append replaces the declared property outright (#93).
             const discPropName = schema.discriminator.propertyName;
             const discIndex = filteredPropNames.indexOf(discPropName);
             if (discIndex !== -1) {

package/dist/analyzer/types.d.ts

@@ -148,4 +148,6 @@ export interface AnalyzeOptions {
      * Omitted is treated as `'3.1'`.
      */
     effectiveVersion?: '3.0' | '3.1';
+    /** Warning sink; defaults to `process.stderr.write`. Mirrors the mapper's `warnSink`. */
+    warnSink?: (message: string) => void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genoc",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "Generate typed HTTP clients from OpenAPI 3.0 / 3.1 specifications",
   "keywords": [
     "client",
@@ -48,12 +48,12 @@
   },
   "devDependencies": {
     "@changesets/cli": "^2.31.0",
-    "@types/node": "^26.6.2",
-    "oxfmt": "^0.70.0",
-    "oxlint": "^1.85.0",
+    "@types/node": "^26.6.5",
+    "oxfmt": "^0.75.0",
+    "oxlint": "^1.90.0",
     "typescript": "^6.0.3",
-    "undici": "^8",
-    "vitest": "^5.0.1"
+    "undici": "^8.12.3",
+    "vitest": "^5.0.5"
   },
   "peerDependencies": {
     "undici": "^6.13.0 || ^7 || ^8"