maka-agent 0.2.1-dev.91.20261018 → 0.2.2-dev.97.20261024

package/node_modules/@maka/core/dist/runtime-event.js

@@ -31,6 +31,7 @@
  * Phase 1 scope: types + small pure helpers only. No storage, runner,
  * projection, or ledger logic lives here. Those arrive in later nodes.
  */
+import { decodeEventWaitProvenance } from './event-wait-delivery.js';
 import { isWorkHubActionReceipt } from './workhub-action-result.js';
 import { isToolCallOutcome } from './tool-result-status.js';
 import { isModelRetryDecision } from './model-failure.js';
@@ -182,6 +183,7 @@ const TEXT_CONTENT_SHAPE = defineObjectShape()(['kind', 'text'], [
     'quotes',
     'inlineReferences',
     'steering',
+    'runtimeContextName',
     'providerOptions',
 ]);
 const THINKING_CONTENT_SHAPE = defineObjectShape()(['kind', 'text'], ['signature', 'providerOptions']);
@@ -236,7 +238,7 @@ const INVOCATION_ROOT_SHAPES = {
     user: defineObjectShape()(['kind'], []),
     context_compact: defineObjectShape()(['kind'], []),
     scheduled_task: defineObjectShape()(['kind', 'scheduledTaskId'], []),
-    goal: defineObjectShape()(['kind', 'goalId'], []),
+    goal: defineObjectShape()(['kind', 'goalId'], ['eventWait']),
     agent_graph_supervisor_wake: defineObjectShape()(['kind', 'wakeId', 'attemptId'], []),
     legacy_automation: defineObjectShape()(['kind', 'legacyAutomationId'], []),
 };
@@ -378,11 +380,15 @@ export function decodeRuntimeEvent(value) {
             content: {
                 kind: 'text',
                 ...normalizeMessageContent(value.content),
+                ...(value.content.interrupted === true ? { interrupted: true } : {}),
                 ...(value.content.summary !== undefined ? { summary: value.content.summary } : {}),
                 ...(value.content.origin !== undefined
                     ? { origin: decodeTurnOrigin(value.content.origin) }
                     : {}),
                 ...(value.content.steering === true ? { steering: true } : {}),
+                ...(value.content.runtimeContextName !== undefined
+                    ? { runtimeContextName: value.content.runtimeContextName }
+                    : {}),
             },
         };
     }
@@ -408,6 +414,9 @@ function isRuntimeEventContent(value) {
                 (value.summary !== undefined && typeof value.summary !== 'string') ||
                 (value.origin !== undefined && !isTurnOrigin(value.origin)) ||
                 (value.steering !== undefined && value.steering !== true) ||
+                (value.runtimeContextName !== undefined &&
+                    (typeof value.runtimeContextName !== 'string' ||
+                        value.runtimeContextName.length === 0)) ||
                 (value.interrupted !== undefined && value.interrupted !== true) ||
                 (value.providerOptions !== undefined && !isRecord(value.providerOptions))) {
                 return false;
@@ -538,7 +547,9 @@ function isRuntimeInvocationRootAuthority(value) {
             return (hasExactShape(value, INVOCATION_ROOT_SHAPES.scheduled_task) &&
                 isNonEmptyString(value.scheduledTaskId));
         case 'goal':
-            return hasExactShape(value, INVOCATION_ROOT_SHAPES.goal) && isNonEmptyString(value.goalId);
+            return (hasExactShape(value, INVOCATION_ROOT_SHAPES.goal) &&
+                isNonEmptyString(value.goalId) &&
+                isEventWaitProvenance(value.eventWait));
         case 'agent_graph_supervisor_wake':
             return (hasExactShape(value, INVOCATION_ROOT_SHAPES.agent_graph_supervisor_wake) &&
                 isNonEmptyString(value.wakeId) &&
@@ -882,3 +893,14 @@ export function createRuntimeEventId(prefix = 'rt-event') {
     __runtimeEventSeq += 1;
     return `${prefix}_${Date.now().toString(36)}_${__runtimeEventSeq.toString(36)}`;
 }
+function isEventWaitProvenance(value) {
+    if (value === undefined)
+        return true;
+    try {
+        decodeEventWaitProvenance(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/node_modules/@maka/core/dist/runtime-invocation.js

@@ -16,6 +16,15 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+/**
+ * One physical execution attempt, as the event spine describes it.
+ *
+ * An invocation is an opening fact, the events that follow it, and — once it
+ * has ended — a terminal event. Everything a reader used to take from a mutable
+ * Run header is a projection of those three, so there is nothing here that a
+ * writer could set independently of the events.
+ */
+import { sameEventWaitProvenance } from './event-wait-delivery.js';
 import { isTerminalRuntimeEvent } from './runtime-event.js';
 /** Persisted namespace used only by deterministic legacy-transcript conversion runs. */
 export const TRANSCRIPT_LEDGER_INVOCATION_ID_PREFIX = 'transcript-';
@@ -205,6 +214,7 @@ export function invocationMatchesHostedRootExecution(invocation, execution) {
         case 'goal':
             return (root.kind === 'goal' &&
                 root.goalId === execution.goalId &&
+                sameEventWaitProvenance(root.eventWait, execution.eventWait) &&
                 source.kind === 'fresh' &&
                 lineageIsExactly(lineage, {}));
         case 'agent_graph_supervisor_wake':

package/node_modules/@maka/core/dist/session-checkin.js

@@ -0,0 +1,31 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/** Check-in card vocabulary shared by the Runtime, the Host protocol and clients. */
+export const CHECKIN_MAX_CARDS = 4;
+export const CHECKIN_TITLE_MAX_CHARS = 80;
+export const CHECKIN_QUOTE_MAX_CHARS = 300;
+export const CHECKIN_INSTRUCTION_MAX_CHARS = 2_000;
+export const CHECKIN_CARD_ACTIONS = ['resume', 'continue', 'new_session', 'answer'];
+export const CHECKIN_EVIDENCE_SOURCES = ['signal', 'user_request', 'assistant_message'];
+export function isCheckinCardAction(value) {
+    return typeof value === 'string' && CHECKIN_CARD_ACTIONS.includes(value);
+}
+export function isCheckinEvidenceSource(value) {
+    return (typeof value === 'string' && CHECKIN_EVIDENCE_SOURCES.includes(value));
+}

package/node_modules/@maka/core/dist/tool-ledger-scanner.js

@@ -588,15 +588,7 @@ function validateTransitionShape(events, expectedTransition) {
         (expectedTransition === 't2_outcome' &&
             actual.length === 1 &&
             actual[0] === 'function_response' &&
-            events[0]?.refs?.operationId !== undefined) ||
-        (expectedTransition === 'recovery_bundle' &&
-            ((actual.length === 2 &&
-                actual[0] === 'reconcile_result' &&
-                actual[1] === 'recovery_decision') ||
-                (actual.length === 3 &&
-                    actual[0] === 'reconcile_result' &&
-                    actual[1] === 'function_response' &&
-                    actual[2] === 'recovery_decision')));
+            events[0]?.refs?.operationId !== undefined);
     if (valid)
         return { ok: true };
     return {

package/node_modules/@maka/core/dist/tool-recovery-bundle.js

@@ -19,14 +19,6 @@
 import { canonicalToolArgsHash } from './tool-args-identity.js';
 import { validateToolLedgerEventLane, } from './tool-ledger-scanner.js';
 import { isToolRecoveryFactEnvelope, } from './tool-recovery-fact.js';
-export class ToolRecoveryBundleValidationError extends Error {
-    code;
-    name = 'ToolRecoveryBundleValidationError';
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-    }
-}
 export function validateToolRecoveryEventBundle(input) {
     const { operation } = input;
     const call = input.callEvent.content;
@@ -135,13 +127,8 @@ export function validateToolRecoveryEventBundle(input) {
     }
     return { ok: true, reconcile, decision };
 }
-export function assertToolRecoveryEventBundle(input) {
-    const result = validateToolRecoveryEventBundle(input);
-    if (!result.ok)
-        throw new ToolRecoveryBundleValidationError(result.code, result.message);
-    return { reconcile: result.reconcile, decision: result.decision };
-}
 /**
+ * Read compatibility for historical recovery bundles. Current tools never produce these facts.
  * Interprets the recovery tail of one scanner-owned operation. Resolver and
  * projection rebuild must consume this result instead of independently
  * assembling facts or defining their own causal-order rules.

package/node_modules/@maka/core/dist/turn-origin.js

@@ -16,12 +16,13 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { decodeEventWaitProvenance } from './event-wait-delivery.js';
 import { defineObjectShape, hasExactShape, isRecord } from './record-schema.js';
 const EXTERNAL_CONNECTOR_ORIGIN_SHAPE = defineObjectShape()(['kind', 'connectorId'], ['senderId']);
 const SCHEDULED_TASK_ORIGIN_SHAPE = defineObjectShape()(['kind', 'scheduledTaskId'], []);
 const CLOUD_ACTIVATION_ORIGIN_SHAPE = defineObjectShape()(['kind', 'activationId'], []);
 const LEGACY_AUTOMATION_ORIGIN_SHAPE = defineObjectShape()(['kind', 'automationId'], []);
-const GOAL_ORIGIN_SHAPE = defineObjectShape()(['kind', 'goalId'], []);
+const GOAL_ORIGIN_SHAPE = defineObjectShape()(['kind', 'goalId'], ['eventWait']);
 const AGENT_GRAPH_ORIGIN_SHAPE = defineObjectShape()(['kind', 'graphId', 'wakeId', 'attemptId'], []);
 /** Decode a persisted or runtime turn origin, normalizing released Automation rows. */
 export function decodeTurnOrigin(value) {
@@ -72,7 +73,18 @@ export function decodeTurnOrigin(value) {
     if (hasExactShape(value, GOAL_ORIGIN_SHAPE) &&
         value.kind === 'goal' &&
         typeof value.goalId === 'string') {
-        return { kind: 'goal', goalId: value.goalId };
+        try {
+            return {
+                kind: 'goal',
+                goalId: value.goalId,
+                ...(value.eventWait === undefined
+                    ? {}
+                    : { eventWait: decodeEventWaitProvenance(value.eventWait) }),
+            };
+        }
+        catch {
+            return undefined;
+        }
     }
     if (hasExactShape(value, AGENT_GRAPH_ORIGIN_SHAPE) &&
         value.kind === 'agent_graph' &&

package/node_modules/@maka/core/dist/usage-stats/types.js

@@ -27,6 +27,7 @@ export const MODEL_CALL_KINDS = [
     'goal_evaluation',
     'session_title',
     'session_recap',
+    'session_checkin',
     'prompt_suggestion',
     'daily_review',
     'memory_extraction',

package/node_modules/@maka/core/package.json

@@ -23,6 +23,7 @@
     "./tool-result-preview": "./dist/tool-result-preview.js",
     "./workspace-version-authority": "./dist/workspace-version-authority.js",
     "./runtime-policy": "./dist/runtime-policy.js",
+    "./event-wait-delivery": "./dist/event-wait-delivery.js",
     "./event-wait": "./dist/event-wait.js",
     "./goal": "./dist/goal.js",
     "./execution-log-coverage": "./dist/execution-log-coverage.js",
@@ -87,6 +88,7 @@
     "./agent-graph-client-projection": "./dist/agent-graph-client-projection.js",
     "./agent-graph-supervisor-wake": "./dist/agent-graph-supervisor-wake.js",
     "./session-todo": "./dist/session-todo.js",
+    "./session-checkin": "./dist/session-checkin.js",
     "./external-session": "./dist/external-session.js",
     "./daily-review": "./dist/daily-review.js",
     "./work-board": "./dist/work-board.js",
@@ -147,6 +149,7 @@
     "./project": "./dist/project.js",
     "./pty-output-view": "./dist/pty-output-view.js",
     "./relative-time": "./dist/relative-time.js",
+    "./assistant-turn-ids": "./dist/assistant-turn-ids.js",
     "./archive-retention": "./dist/archive-retention.js",
     "./run-composition": "./dist/run-composition.js",
     "./runtime-event-store": "./dist/runtime-event-store.js",

package/node_modules/@maka/eval/node_modules/undici/README.md

@@ -86,6 +86,24 @@ Using [benchmark-http2.js](https://github.com/nodejs/undici/blob/main/benchmarks
 
 Node.js includes a built-in `fetch()` implementation powered by undici starting from Node.js v18. However, there are important differences between using the built-in fetch and installing undici as a separate module.
 
+### WebAssembly requirement
+
+Undici's HTTP/1 parser requires WebAssembly. There is no alternative parser when
+WebAssembly is unavailable, for example in Node.js configurations where
+`--jitless` disables it. The existence of `fetch` does not imply that it can make
+HTTP/1 requests in that environment.
+
+When the HTTP/1 parser is needed without WebAssembly, Client and dispatcher
+requests fail with an `Error` whose code is `ERR_WEBASSEMBLY_NOT_SUPPORTED`.
+`fetch` rejects with a `TypeError` carrying that error in `error.cause`. Importing
+Undici, accessing `fetch`, and using `Headers`, `FormData`, `Request`, or `Response`
+do not themselves require the HTTP/1 parser.
+
+The error is defined locally in Undici and does not depend on Node.js providing
+that error code. For built-in fetch, this behavior depends on the bundled Undici
+version. Node.js receives upstream fixes through its normal vendored Undici
+update, rather than changes to the generated bundle alone.
+
 ### Built-in Fetch (Node.js v18+)
 
 Node.js's built-in fetch is powered by a bundled version of undici:
@@ -773,14 +791,18 @@ and `undici.Agent`) which will enable the family autoselection algorithm when es
 
 ## Collaborators
 
-* [__Daniele Belardi__](https://github.com/dnlup), <https://www.npmjs.com/~dnlup>
-* [__Ethan Arrowood__](https://github.com/ethan-arrowood), <https://www.npmjs.com/~ethan_arrowood>
+* [__Aras Abbasi__](https://github.com/Uzlopak)
+* [__Carlos Fuentes__](https://github.com/metcoder95), <https://www.npmjs.com/~metcoder95>
+* [__Ethan Arrowood__](https://github.com/Ethan-Arrowood), <https://www.npmjs.com/~ethan_arrowood>
 * [__Matteo Collina__](https://github.com/mcollina), <https://www.npmjs.com/~matteo.collina>
 * [__Matthew Aitken__](https://github.com/KhafraDev), <https://www.npmjs.com/~khaf>
+* [__Mert Can Altin__](https://github.com/mertcanaltin), <https://www.npmjs.com/~mertcanaltin>
 * [__Robert Nagy__](https://github.com/ronag), <https://www.npmjs.com/~ronag>
-* [__Szymon Marczak__](https://github.com/szmarczak), <https://www.npmjs.com/~szmarczak>
+* [__Trivikram Kamat__](https://github.com/trivikr), <https://www.npmjs.com/~trivikr>
+* [__tsctx__](https://github.com/tsctx)
 
 ## Past Collaborators
+* [__Szymon Marczak__](https://github.com/szmarczak), <https://www.npmjs.com/~szmarczak>
 * [__Tomas Della Vedova__](https://github.com/delvedor), <https://www.npmjs.com/~delvedor>
 
 ### Releasers

package/node_modules/@maka/eval/node_modules/undici/docs/docs/api/CacheStore.md

@@ -42,7 +42,8 @@ added: v7.0.0
 Stores cached responses in memory. The store enforces upper bounds on the total
 number of responses, the total size of all responses, and the size of any single
 response. When a limit is exceeded, the store evicts approximately half of its
-entries and emits a [`'maxSizeExceeded'`](#event-maxsizeexceeded) event.
+entries, least recently used first, and emits a
+[`'maxSizeExceeded'`](#event-maxsizeexceeded) event.
 
 ```mjs
 import { interceptors, cacheStores, Agent, setGlobalDispatcher } from 'undici'
@@ -163,7 +164,9 @@ added: v7.0.0
 -->
 
 Stores cached responses in a SQLite database using the [`node:sqlite`][] API.
-The constructor throws when [`node:sqlite`][] is not available.
+The constructor throws when [`node:sqlite`][] is not available. Response bodies
+larger than `compressThreshold` are stored compressed with zstd and
+decompressed when read back, saving database space.
 
 ```mjs
 import { interceptors, cacheStores, Agent, setGlobalDispatcher } from 'undici'
@@ -189,9 +192,16 @@ added: v7.0.0
   * `maxEntrySize` {number} The maximum size, in bytes, of a single response
     body. Responses whose body exceeds this value are not cached. Must not
     exceed `2000000000` (2 GB). **Default:** `2000000000` (2 GB).
+  * `compressThreshold` {number} The size, in bytes, above which a response
+    body is stored compressed with zstd. Responses with an easily compressible
+    Content-Type (e.g. json, xml, plain text) are compressed regardless of
+    size. Requires a Node version with zstd
+    support (22.19+); when unavailable, bodies are stored uncompressed.
+    **Default:** `1048576` (1 MiB).
 
-`maxCount` and `maxEntrySize` must be non-negative integers; a `TypeError` is
-thrown otherwise, or if `maxEntrySize` is greater than 2 GB.
+`maxCount`, `maxEntrySize`, and `compressThreshold` must be non-negative
+integers; a `TypeError` is thrown otherwise, or if `maxEntrySize` is greater
+than 2 GB.
 
 ### `sqliteCacheStore.close()`
 
@@ -225,7 +235,8 @@ added: v7.0.0
   See [`GetResult`](#getresult).
 
 Looks up a cached response for `key`, comparing the request method and every
-header named in the stored `vary` map.
+header named in the stored `vary` map. A body that was stored compressed is
+decompressed before being returned.
 
 ### `sqliteCacheStore.set(key, value)`
 
@@ -240,9 +251,11 @@ added: v7.0.0
 * Returns: {undefined}
 
 Writes a response into the database directly, without going through a stream. If
-the body exceeds `maxEntrySize`, nothing is stored. When an entry already exists
-for `key` it is overwritten; otherwise a new row is inserted and old entries are
-pruned to honour `maxCount`. This method is used internally by
+the body exceeds `maxEntrySize`, nothing is stored. A body larger than
+`compressThreshold`, or with an easily compressible Content-Type (e.g. json,
+xml, plain text), is compressed with zstd before being written. When an entry
+already exists for `key` it is overwritten; otherwise a new row is inserted and
+old entries are pruned to honour `maxCount`. This method is used internally by
 [`sqliteCacheStore.createWriteStream()`](#sqlitecachestorecreatewritestreamkey-value).
 
 ### `sqliteCacheStore.createWriteStream(key, value)`
@@ -260,7 +273,9 @@ added: v7.0.0
 
 Returns a {Writable} stream used to write the response body into the store. When
 the stream finishes, the buffered body is committed via
-[`sqliteCacheStore.set()`](#sqlitecachestoresetkey-value). If the body exceeds
+[`sqliteCacheStore.set()`](#sqlitecachestoresetkey-value), where bodies larger
+than `compressThreshold` or with an easily compressible Content-Type are
+compressed with zstd. If the body exceeds
 `maxEntrySize`, the stream is destroyed and nothing is stored.
 
 ### `sqliteCacheStore.delete(key)`

package/node_modules/@maka/eval/node_modules/undici/docs/docs/api/Client.md

@@ -116,8 +116,8 @@ added: v1.0.0
   * `maxConcurrentStreams` {number} _Deprecated: use h2Options.useH2c instead_ The maximum number of concurrent HTTP/2
     streams for a single session. Once h2 is negotiated this — not `pipelining`,
     which is HTTP/1.1 only — is the ceiling used to dispatch in-flight requests.
-    It may be overridden by the server's `SETTINGS_MAX_CONCURRENT_STREAMS`
-    frame. **Default:** `100`.
+    The server's `SETTINGS_MAX_CONCURRENT_STREAMS` can lower this limit, but
+    not raise it. **Default:** `100`.
   * `connectionWindowSize` {number} _Deprecated: use h2Options.connectionWindowSize instead_ The HTTP/2 connection-level flow-control
     window size set via `ClientHttp2Session.setLocalWindowSize()`. Must be a
     positive integer. **Default:** `524288`.
@@ -130,8 +130,8 @@ added: v1.0.0
     * `maxConcurrentStreams` {number} The maximum number of concurrent HTTP/2
       streams for a single session. Once h2 is negotiated this — not `pipelining`,
       which is HTTP/1.1 only — is the ceiling used to dispatch in-flight requests.
-      It may be overridden by the server's `SETTINGS_MAX_CONCURRENT_STREAMS`
-      frame. **Default:** `100`.
+      The server's `SETTINGS_MAX_CONCURRENT_STREAMS` can lower this limit, but
+      not raise it. **Default:** `100`.
     * `connectionWindowSize` {number} The HTTP/2 connection-level flow-control
       window size set via `ClientHttp2Session.setLocalWindowSize()`. Must be a
       positive integer. **Default:** `524288`.
@@ -148,8 +148,13 @@ added: v1.0.0
       payloads, and decompressed (`permessage-deflate`) messages. Set to `0` to
       disable the limit. **Default:** `134217728`.
   * `eventSource` {Object} (optional) EventSource-specific configuration.
-    * `maxEventSize` {number} The maximum allowed event size, in bytes, for
-      EventSource messages. Set to `0` to disable the limit.
+    * `maxEventSize` {number} The maximum total bytes of data and metadata
+      field values retained for a pending EventSource event. Each unfinished
+      line is separately limited to this value plus seven syntax bytes, before
+      its line ending arrives. The number of `data:` lines per event and input
+      chunks buffered for an unfinished line are each limited to
+      `min(131072, max(1024, floor(maxEventSize / 128)))` to bound object overhead.
+      Set to `0` to disable these limits.
       **Default:** `buffer.kStringMaxLength`.
 * Returns: {Client}
 

package/node_modules/@maka/eval/node_modules/undici/docs/docs/api/Dispatcher.md

@@ -209,6 +209,9 @@ added: v4.0.0
   * `path` {string} The request path.
   * `method` {string} The HTTP method, e.g. `'GET'` or `'POST'`.
   * `body` {string|Buffer|Uint8Array|Readable|FormData|null} The request body.
+    Undici's network clients require a `FormData` body created by the same
+    undici package instance. A body from another source, including Node.js's
+    built-in `FormData`, is rejected with an `InvalidArgumentError`.
     **Default:** `null`.
   * `headers` {UndiciHeaders} Request headers. **Default:** `null`.
   * `query` {Object} Query string parameters embedded into the request URL. Both

package/node_modules/@maka/eval/node_modules/undici/docs/docs/api/Errors.md

@@ -18,7 +18,7 @@ if (err instanceof errors.ConnectTimeoutError) {
 }
 ```
 
-All errors, except [`HTTPParserError`][], extend [`UndiciError`][]. Each error
+All errors, except [`HTTPParserError`][] and `WebAssemblyNotSupportedError`, extend [`UndiciError`][]. Each error
 carries a stable `code` string (for example `UND_ERR_CONNECT_TIMEOUT`) and a
 `name`.
 
@@ -32,6 +32,37 @@ if (err.code === 'UND_ERR_CONNECT_TIMEOUT') {
 }
 ```
 
+## Timeout-related errors
+
+The timeout errors below are controlled by dispatcher/client options:
+
+| Error code | When it is thrown | Related option |
+| ---------- | ----------------- | -------------- |
+| `UND_ERR_CONNECT_TIMEOUT` | A connection could not be established before the connection timeout elapsed. | [`connect.timeout`](Client.md) |
+| `UND_ERR_HEADERS_TIMEOUT` | The full response headers were not received before the headers timeout elapsed. | [`headersTimeout`](Client.md) |
+| `UND_ERR_BODY_TIMEOUT` | While reading the response body, no new data arrived before the body timeout elapsed. | [`bodyTimeout`](Client.md) |
+| `UND_ERR_SOCKET` | A generic socket-level failure happened. | Inspect `error.socket` for connection details. |
+
+### Configuring timeouts for `fetch`
+
+If you are using `fetch` (including Node.js built-in `fetch`), configure timeouts
+through the global dispatcher:
+
+```js
+import { Agent, setGlobalDispatcher, fetch } from 'undici'
+
+setGlobalDispatcher(new Agent({
+  connect: { timeout: 10_000 }, // connection phase
+  headersTimeout: 15_000, // wait for response headers
+  bodyTimeout: 30_000 // wait between response body chunks
+}))
+
+await fetch('https://example.com/data')
+```
+
+You can inspect timeout error codes from `error.code` or (for wrapped fetch
+errors) from `error.cause?.code`.
+
 ## Class: `UndiciError`
 
 <!-- YAML
@@ -52,6 +83,35 @@ on a well-known symbol rather than the prototype chain.
 * `name` {string} Always `'UndiciError'`.
 * `code` {string} Always `'UND_ERR'`.
 
+## Class: `WebAssemblyNotSupportedError`
+
+* Extends: {Error}
+
+WebAssembly is unavailable when Undici initializes its HTTP/1 parser. Undici does
+not provide an alternative parser for environments without WebAssembly, including
+Node.js configurations where `--jitless` disables it. The check is performed when
+the parser is needed, not when importing Undici or accessing `fetch`.
+
+* `name` {string} Always `'Error'`.
+* `code` {string} Always `'ERR_WEBASSEMBLY_NOT_SUPPORTED'`.
+* `message` {string} By default `'WebAssembly is not supported in this environment, but is required for HTTP/1 parsing'`.
+
+Client and dispatcher requests report this error directly. `fetch` rejects with
+a `TypeError` whose `cause` is this error:
+
+```js
+try {
+  await fetch('http://localhost:3000')
+} catch (error) {
+  if (error.cause?.code === 'ERR_WEBASSEMBLY_NOT_SUPPORTED') {
+    // HTTP/1 parsing requires WebAssembly in this environment.
+  }
+}
+```
+
+`Headers`, `FormData`, `Request`, `Response`, and other operations that do not need
+the HTTP/1 parser remain usable without WebAssembly.
+
 ## Class: `ConnectTimeoutError`
 
 <!-- YAML
@@ -436,6 +496,7 @@ The response returned an error status code. This is raised, for example, when th
 * `code` {string} Always `'UND_ERR_RESPONSE'`.
 * `statusCode` {number} The HTTP status code of the response.
 * `body` {Object|string|null} The response body.
+* `bodyTruncated` {boolean} Whether `body` was truncated by a configured limit.
 * `headers` {Object|string[]|null} The response headers.
 
 ### `new ResponseError(message, code, options)`
@@ -445,6 +506,7 @@ The response returned an error status code. This is raised, for example, when th
 * `options` {Object}
   * `headers` {Object|string[]|null} The response headers. (optional)
   * `body` {Object|string|null} The response body. (optional)
+  * `bodyTruncated` {boolean} Whether `body` was truncated. **Default:** `false`.
 
 ## Class: `ProxyConnectionError`
 
@@ -512,6 +574,19 @@ The maximum number of allowed origins has been reached.
 * `name` {string} Always `'MaxOriginsReachedError'`.
 * `code` {string} Always `'UND_ERR_MAX_ORIGINS_REACHED'`.
 
+## Class: `MaxRedirectsError`
+
+<!-- YAML
+added: v8.12.0
+-->
+
+* Extends: {UndiciError}
+
+The maximum number of redirects has been reached.
+
+* `name` {string} Always `'MaxRedirectsError'`.
+* `code` {string} Always `'UND_ERR_REDIRECT_MAX'`.
+
 ## Class: `Socks5ProxyError`
 
 <!-- YAML

package/node_modules/@maka/eval/node_modules/undici/docs/docs/api/H2CClient.md

@@ -55,8 +55,9 @@ added: v7.7.0
   hostname, and port. Only the `http:` protocol is supported.
 * `options` {H2CClientOptions} (optional)
   * `maxConcurrentStreams` {number} The maximum number of concurrent HTTP/2
-    streams for the session. It is advertised to the server and may be overridden
-    by a remote `SETTINGS` frame. Must be a positive integer. **Default:** `100`.
+    streams for the session. The server's `SETTINGS_MAX_CONCURRENT_STREAMS` can
+    lower this limit, but not raise it. Must be a positive integer.
+    **Default:** `100`.
   * `pipelining` {number} The number of concurrent requests multiplexed over the
     single connection. For an `H2CClient` this is aliased to
     `maxConcurrentStreams` and may not exceed it. Must be a positive integer.

package/node_modules/@maka/eval/node_modules/undici/docs/docs/api/Interceptors.md

@@ -163,9 +163,10 @@ Follows HTTP redirects (3xx responses) automatically.
   * `maxRedirections` {number} Maximum number of redirects to follow. Passing
     `0` disables redirect following entirely. **Default:** `undefined`
     (inherits from the per-request `maxRedirections` option).
-  * `throwOnMaxRedirect` {boolean} When `true`, throws an error once the
-    redirect limit is reached instead of returning the final redirect response.
-    **Default:** `false`.
+  * `throwOnMaxRedirect` {boolean} When `true`, throws an error when a
+    redirect would be followed but the redirect limit has been reached, instead
+    of returning that redirect response. A non-redirect response after exactly
+    `maxRedirections` redirects is returned normally. **Default:** `false`.
   * `stripHeadersOnRedirect` {string[]} List of header names to remove from
     the request when following any redirect. **Default:** `[]`.
   * `stripHeadersOnCrossOriginRedirect` {string[]} List of header names to
@@ -198,7 +199,10 @@ const agent = new Agent().compose(
 ## `interceptors.decompress([opts])`
 
 Automatically decompresses response bodies encoded with `gzip`, `x-gzip`,
-`br` (Brotli), `deflate`, `compress`, `x-compress`, or `zstd`.
+`br` (Brotli), `deflate`, or `zstd`. Any other coding, including `compress`
+and `x-compress`, is left untouched, matching `fetch()`. As required by
+[RFC 9659](https://www.rfc-editor.org/rfc/rfc9659.html), a `zstd` frame that
+requires a window size larger than 8 MB fails to decode.
 
 > **Experimental:** This interceptor is experimental and subject to change.
 > A one-time `ExperimentalWarning` is emitted on first use.
@@ -244,8 +248,11 @@ The error body is automatically decoded for `application/json` and
 
 **Parameters**
 
-* `opts` {Object} (optional) — currently reserved for future use; may be
-  omitted.
+* `opts` {Object} (optional)
+  * `maxSize` {number} Maximum number of response body bytes to include in the
+    error. If the body exceeds this limit, the resulting `ResponseError`
+    contains the retained prefix with `bodyTruncated` set to `true`. Set to `0`
+    to disable the limit. **Default:** `1048576` (1 MiB).
 
 **Returns:** {Dispatcher.DispatcherComposeInterceptor}
 
@@ -334,8 +341,21 @@ backing store.
 
 **Parameters**
 
-* `opts` {CacheHandler.CacheOptions} (optional) See the
-  [`CacheStore`](./CacheStore.md) documentation for accepted fields.
+* `opts` {Object} (optional)
+  * `store` {CacheStore} The store that cached responses are kept in. See
+    [`CacheStore`](./CacheStore.md). **Default:** a new `MemoryCacheStore`.
+  * `methods` {string[]} The HTTP methods to cache. Only safe methods are
+    allowed (`GET`, `HEAD`, `OPTIONS`, `TRACE`) and at least one is required.
+    **Default:** `['GET']`.
+  * `cacheByDefault` {number} RFC 9111 allows caching responses that are not
+    explicitly marked as cacheable or not cacheable. Set this to cache such
+    responses. **Default:** `undefined`.
+  * `type` {string} Whether the cache is `'shared'` or `'private'`, which
+    decides how directives such as `s-maxage` and `private` are applied.
+    **Default:** `'shared'`.
+  * `origins` {(string|RegExp)[]} Only requests to these origins are cached.
+    Strings are compared case-insensitively. **Default:** `undefined` (all
+    origins are cached).
 
 **Returns:** {Dispatcher.DispatcherComposeInterceptor}