eve 0.39.2 → 0.40.0

package/dist/src/compiled/@workflow/core/serialization.d.ts

@@ -84,8 +84,16 @@ export declare const FRAMED_STREAM_MAX_TOTAL_RECONNECTS = 1000;
  * bytes buffered before the cut are discarded — the server will resend the
  * in-flight chunk in full from the new startIndex.
  *
- * A clean upstream close (EOF with no error) signals the stream is truly
- * done; we close the wrapper and do not reconnect.
+ * A clean upstream close (EOF with no error) is NOT trusted as completion
+ * on its own: some transport paths normalize a mid-stream abort into a
+ * graceful end (observed in production on Vercel response streaming, where
+ * the server's max-duration abort arrives at the client as a clean EOF).
+ * On EOF the wrapper verifies against the stream's authoritative metadata
+ * (`streams.getInfo`) that the stream is complete AND that every chunk up to
+ * `done` was delivered; otherwise it reconnects from the next chunk exactly
+ * like an errored connection. If the metadata read itself fails, the EOF is
+ * trusted (legacy behavior) rather than failing a read that may well be
+ * complete.
  *
  * Negative `startIndex` values (last-N semantics) skip the reconnect
  * machinery because we cannot compute an absolute resume position without

package/dist/src/compiled/@workflow/core/telemetry.d.ts

@@ -81,6 +81,12 @@ export declare function trace<T>(spanName: string, ...args: [fn: (span?: Span) =
  * callback. No-op when OpenTelemetry is not available.
  */
 export declare function recordElapsedSpan(spanName: string, startEpochMs: number, opts?: SpanOptions): Promise<void>;
+/**
+ * Records the same user-code interval as the inner `step.execute` span. The
+ * configured OpenTelemetry meter provider attaches resource dimensions such as
+ * service.name, so this avoids accepting a caller-controlled service tag.
+ */
+export declare function recordStepExecutionDuration(durationMs: number, status: 'ok' | 'error'): Promise<void>;
 /**
  * Applies the workflow suspension algebraic effect to an active span.
  */

package/dist/src/compiled/@workflow/core/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "5.0.0-beta.42";
+export declare const version = "5.0.0-beta.43";
 //# sourceMappingURL=version.d.ts.map

package/dist/src/compiled/@workflow/core/workflow.js

@@ -1 +1 @@
-import{Xn as e,Zn as t,_r as n,fr as r,vr as i,yr as a}from"../../_chunks/workflow/wait-until-BPSgt1Wg.js";import{i as o,u as s}from"../../_chunks/workflow/dist-CqvWKNQv.js";import"../../_chunks/workflow/dist-DpYyXbJv.js";import{i as c}from"../../_chunks/workflow/workflow-routes-CwqB063q.js";import{c as l,i as u,o as d,r as f,t as p}from"../../_chunks/workflow/attribute-changes-B8K0pwpH.js";import{t as m}from"../../_chunks/workflow/sleep-7TgF3i-e.js";import{t as h}from"../../_chunks/workflow/run-lq7-eG0l.js";t(e,h);function g(e){let t=globalThis[n];return t||u(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,g),t(e)}function _(e){let{respondWith:t,token:n,...r}=e??{};if(n!==void 0)throw Error("`createWebhook()` does not accept a `token` option. Webhook tokens are always randomly generated. Use `createHook()` with `resumeHook()` for deterministic token patterns.");let i;t!==void 0&&(i={respondWith:t});let a=g({...r,metadata:i,isWebhook:!0}),{url:o}=l();return a.url=c(o,{type:`webhook`,token:a.token}),a}function v(){function e(t,n){d(`defineHook().resume()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,e)}return{create(e){return g(e)},resume:e}}async function y(e,t={}){let n=p(e,t);if(n.length===0)return;let r=t.allowReservedAttributes===!0,i=globalThis[a];if(!i)throw new o("setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await i(n,r?{allowReservedAttributes:!0}:{})}function b(e={}){let{namespace:t}=e,n=globalThis[i](t);return Object.create(globalThis.WritableStream.prototype,{[r]:{value:n,writable:!1}})}function x(){f(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,x)}function S(){d(`resumeHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,S)}export{o as FatalError,s as RetryableError,g as createHook,_ as createWebhook,v as defineHook,x as getStepMetadata,l as getWorkflowMetadata,b as getWritable,S as resumeHook,y as setAttributes,m as sleep};
+import{Qn as e,Zn as t,br as n,pr as r,vr as i,yr as a}from"../../_chunks/workflow/wait-until-BZHmJCAW.js";import{i as o,u as s}from"../../_chunks/workflow/dist-CqvWKNQv.js";import"../../_chunks/workflow/dist-DpYyXbJv.js";import{i as c}from"../../_chunks/workflow/workflow-routes-CwqB063q.js";import{c as l,i as u,o as d,r as f,t as p}from"../../_chunks/workflow/attribute-changes-DXbpwBdw.js";import{t as m}from"../../_chunks/workflow/sleep-CxFsdxB_.js";import{t as h}from"../../_chunks/workflow/run-cIeex2KF.js";e(t,h);function g(e){let t=globalThis[i];return t||u(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,g),t(e)}function _(e){let{respondWith:t,token:n,...r}=e??{};if(n!==void 0)throw Error("`createWebhook()` does not accept a `token` option. Webhook tokens are always generated for you. Use `createHook()` with `resumeHook()` for deterministic token patterns.");let i;t!==void 0&&(i={respondWith:t});let a=g({...r,metadata:i,isWebhook:!0}),{url:o}=l();return a.url=c(o,{type:`webhook`,token:a.token}),a}function v(){function e(t,n){d(`defineHook().resume()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,e)}return{create(e){return g(e)},resume:e}}async function y(e,t={}){let r=p(e,t);if(r.length===0)return;let i=t.allowReservedAttributes===!0,a=globalThis[n];if(!a)throw new o("setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await a(r,i?{allowReservedAttributes:!0}:{})}function b(e={}){let{namespace:t}=e,n=globalThis[a](t);return Object.create(globalThis.WritableStream.prototype,{[r]:{value:n,writable:!1}})}function x(){f(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,x)}function S(){d(`resumeHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,S)}export{o as FatalError,s as RetryableError,g as createHook,_ as createWebhook,v as defineHook,x as getStepMetadata,l as getWorkflowMetadata,b as getWritable,S as resumeHook,y as setAttributes,m as sleep};

package/dist/src/compiled/@workflow/world/env-config.d.ts

@@ -29,6 +29,16 @@ export interface EnvNumberOptions {
  * `[min, max]` when provided.
  */
 export declare function envNumber(name: string, fallback: number, options?: EnvNumberOptions): number;
+/**
+ * Resolve a boolean feature flag from `process.env[name]`.
+ *
+ * Matches the convention the runtime flags already use (`WORKFLOW_TURBO`,
+ * `WORKFLOW_SLOT_IDENTITY`, …): unset or empty takes `fallback`, and the only
+ * values that force a side are `0` / `false` and `1` / `true`
+ * (case-insensitive). Anything else falls back rather than throwing — a flag is
+ * an escape hatch, not a hard requirement — and warns once per process.
+ */
+export declare function envFlag(name: string, fallback: boolean, env?: Record<string, string | undefined>): boolean;
 export declare function getMaxEventsPerRun(): number;
 /**
  * Reset the warn-once cache. Test-only — exported so unit tests can exercise

package/dist/src/compiled/@workflow/world/events.d.ts

@@ -876,6 +876,102 @@ export type EventResult<T extends EventType = EventType> = {
 } : T extends 'step_started' ? {
     step: StartedStep;
 } : unknown);
+/**
+ * One event of a batch write ({@link Storage.events.createBatch}), in request
+ * order — which is the order the events land in the run's log.
+ */
+export interface BatchEventRequest {
+    /** The event, same discriminated union the single `create` takes. */
+    event: CreateEventRequest;
+    /**
+     * Client event time for this event. Under slot identity this is the source
+     * of the durable event's `createdAt` (a slot id carries no time), so the
+     * timestamp a replay observes is the one the writer chose — set it to the
+     * instant the event logically occurred.
+     */
+    occurredAt?: Date;
+    /**
+     * Compute-instance attribution for this event, same as the single create's
+     * {@link CreateEventParams.computeInstanceId}. Set on the `step_started`
+     * half of a pre-claimed inline pair so a batched claim attributes the
+     * executing instance exactly like the lazy claim it replaces.
+     */
+    computeInstanceId?: string;
+}
+/** Per-batch parameters for {@link Storage.events.createBatch}. */
+export interface CreateEventBatchParams {
+    resolveData?: ResolveData;
+    /**
+     * Request id for per-write attribution, same as the single create's
+     * {@link CreateEventParams.requestId}: stamped on every event in the batch
+     * so a batched write's usage facts and telemetry carry the same request
+     * attribution its single-path twin would.
+     */
+    requestId?: string;
+}
+/**
+ * One event's outcome in a batch response, index-aligned with the submitted
+ * events. `error === undefined` discriminates success.
+ *
+ * A batch is processed as a whole (HTTP 200 whenever the World evaluated it);
+ * each event reports the outcome its OWN single `create` would have had:
+ *
+ * - success → `status: 200` plus the committed event and the same
+ *   materialized entity the single create returns (`step` for step events,
+ *   `wait` for wait events, `run` for run terminals);
+ * - rejection → the status code and error code the single create would have
+ *   failed with, so callers reuse their single-path conflict handling per
+ *   event. A `409`/`conflict` means the entity was not in the prior state
+ *   the event requires — most commonly because an earlier delivery already
+ *   applied the same event, but possibly because the entity reached a
+ *   DIFFERENT state (e.g. `step_completed` conflicting because the step
+ *   failed). A 409 alone does not prove the equivalent effect was applied;
+ *   a caller that needs effect-equivalence consults the entity (returned on
+ *   sibling successes, or reloaded).
+ *
+ * The batch is atomic per attempt, not all-or-nothing across the submitted
+ * set: a World may drop rejected events and commit the survivors, so a batch
+ * can return a mix of 200s and 409s from one call.
+ *
+ * Retry semantics: a transport retry of a committed batch converges to
+ * per-event 409s ONLY for entity-conditioned events — creates and terminal
+ * transitions. A standalone bare `step_started` or a `step_retrying`
+ * re-patches its step on every attempt and does NOT converge, and
+ * `hook_received` appends a new row per attempt — `world-vercel` rejects
+ * `hook_received` in a batch outright and only auto-retries batches whose
+ * every event is retry-convergent.
+ *
+ * The born-running `step_created`+`step_started` pair converges (the pair's
+ * create fences it) but is still excluded from auto-retry, because
+ * convergence alone is not enough for the caller: a pair 409 means "this step
+ * already exists", and on a retry that is indistinguishable from "my own
+ * previous attempt committed it". A caller that reads the 409 as a lost claim
+ * would skip a body it actually owns, so a batch carrying a `step_started`
+ * runs single-attempt and leaves transient-failure recovery to queue
+ * redelivery.
+ */
+export type BatchEventItemResult = {
+    status: 200;
+    error?: undefined;
+    message?: undefined;
+    event: Event;
+    run?: WorkflowRun;
+    step?: Step;
+    wait?: Wait;
+} | {
+    status: number;
+    error: string;
+    message: string;
+    event?: undefined;
+    run?: undefined;
+    step?: undefined;
+    wait?: undefined;
+};
+/** Result of {@link Storage.events.createBatch}. */
+export interface EventBatchResult {
+    /** One entry per submitted event, in request order. */
+    results: BatchEventItemResult[];
+}
 export interface GetEventParams {
     resolveData?: ResolveData;
 }

package/dist/src/compiled/@workflow/world/index.d.ts

@@ -2,12 +2,13 @@ export type * from './analytics.js';
 export { ANALYTICS_EVENTS_GET_MANY_LIMIT, AnalyticsAttributeKeySchema, AnalyticsEventSchema, AnalyticsHookSchema, AnalyticsRunSchema, AnalyticsStepSchema, AnalyticsWaitSchema, } from './analytics.js';
 export type * from './attributes.js';
 export { ATTRIBUTE_KEY_MAX_LENGTH, ATTRIBUTE_MAX_PER_RUN, ATTRIBUTE_VALUE_MAX_BYTES, AttributeChangeSchema, AttributeChangesSchema, AttributeValidationError, applyAttributeChanges, PARENT_RUN_ID_ATTRIBUTE, RESERVED_ATTRIBUTE_KEY_PREFIX, ROOT_RUN_ID_ATTRIBUTE, validateAttributeChanges, validateAttributeKey, validateAttributeValue, } from './attributes.js';
-export { _resetEnvWarnCacheForTests, type EnvNumberOptions, envNumber, getMaxEventsPerRun, } from './env-config.js';
+export { _resetEnvWarnCacheForTests, type EnvNumberOptions, envFlag, envNumber, getMaxEventsPerRun, } from './env-config.js';
 export type * from './events.js';
 export { BaseEventSchema, CHILD_ENTITY_CREATION_EVENT_TYPES, CreateEventSchema, EVENT_DATA_PAYLOAD_FIELD_BY_EVENT_TYPE, EVENT_DATA_REF_FIELDS, EventSchema, EventTypeSchema, entityEventClass, getEventDataPayloadField, getEventDataRefFields, HOOK_EVENTS_REQUIRING_EXISTENCE, HOOK_LIFECYCLE_EVENT_TYPES, HookCreatedEventSchema, isChildEntityCreationEvent, isChildEntityCreationEventType, isHookEventRequiringExistence, isHookLifecycleEventType, isRunEventType, isStepEventType, isTerminalRunEventType, isTerminalStepEventType, isWaitEventType, RUN_EVENT_TYPES, STEP_EVENT_TYPES, stripEventDataRefs, TERMINAL_RUN_EVENT_TYPES, TERMINAL_STEP_EVENT_TYPES, TerminalRunEventTypeSchema, WAIT_EVENT_TYPES, } from './events.js';
 export type * from './hooks.js';
 export { HOOK_RESUME_DEDUP_VERSION, HOOK_RESUME_INPUT_VERSION, HookResumeCapabilitiesSchema, HookSchema, } from './hooks.js';
 export type * from './interfaces.js';
+export { isNodeHttpEnabled, NODE_HTTP_DEFAULT, NODE_HTTP_ENV_VAR, } from './node-http-flag.js';
 export type * from './queue.js';
 export { getQueueTopicPrefix, HealthCheckPayloadSchema, MessageId, parseQueueName, QueuePayloadSchema, QueuePrefix, RunInputSchema, resolveQueueNamespace, ValidQueueName, WorkflowInvokePayloadSchema, } from './queue.js';
 export { reenqueueActiveRuns } from './recovery.js';

package/dist/src/compiled/@workflow/world/interfaces.d.ts

@@ -1,6 +1,6 @@
 import type { Analytics } from './analytics.js';
 import type { AttributeChange, ExperimentalSetAttributesResult } from './attributes.js';
-import type { CreateEventParams, CreateEventRequest, Event, EventResult, GetEventParams, ListEventsByCorrelationIdParams, ListEventsParams, RunCreatedEventRequest } from './events.js';
+import type { BatchEventRequest, CreateEventBatchParams, CreateEventParams, CreateEventRequest, Event, EventBatchResult, EventResult, GetEventParams, ListEventsByCorrelationIdParams, ListEventsParams, RunCreatedEventRequest } from './events.js';
 import type { GetHookParams, Hook, ListHooksParams } from './hooks.js';
 import type { Queue } from './queue.js';
 import type { BulkCancelWorkflowRunsRequest, BulkCancelWorkflowRunsResult, GetWorkflowRunParams, ListWorkflowRunsParams, WorkflowRun, WorkflowRunWithoutData } from './runs.js';
@@ -226,6 +226,43 @@ export interface Storage {
          * @returns Promise resolving to the created event and affected entity
          */
         create<T extends CreateEventRequest>(runId: string, data: T, params?: CreateEventParams): Promise<EventResult<T['eventType']>>;
+        /**
+         * OPTIONAL batch write — append an ordered list of events to the run's
+         * log in one durable, atomic-per-attempt write, with a per-event outcome
+         * for each (see {@link BatchEventItemResult}). The events land in request
+         * order at consecutive slots. A concurrent writer may push the whole
+         * batch to slots above the caller's view of the log; no skipped-event
+         * report accompanies the result, so a position-tracking caller compares
+         * the committed slots against its expectation and reloads the log to
+         * observe what landed in between. Its local view stays a strict PREFIX
+         * of the log — never a hole — so replaying it stays correct and the
+         * next reload self-corrects.
+         *
+         * Presence of the method IS the capability declaration: the core runtime
+         * batches only when the World implements it (and the run's spec version
+         * supports slot identity); absent, every write takes the single-event
+         * `create` path unchanged. A World must implement it with real
+         * atomicity per attempt — a lost race must leave nothing behind — or not
+         * implement it at all.
+         *
+         * Size limits are the caller's problem: Worlds enforce their own caps
+         * (world-vercel enforces an event-count cap and a byte budget over frame
+         * meta plus inline-bound payloads) and reject an oversized batch with a
+         * request-level error. The core fold sizes its chunks accordingly.
+         *
+         * Not expressible in a batch (Worlds reject the whole batch with a
+         * request-level error): `run_created`, `run_started`, `run_cancelled`,
+         * `hook_created`, `hook_disposed`, `attr_set`, and more events targeting
+         * one entity than a single write can express (the one legal combination
+         * is `step_created` followed by `step_started` for the same step, which
+         * creates the step born-running — the step's input MUST ride the
+         * `step_created`; a `step_started` carrying a payload rejects the whole
+         * batch). Events outside this list keep their own ordering requirements:
+         * a caller mixing a batch with single writes (hook or attribute events)
+         * owns those barriers itself — the core runtime simply never batches a
+         * suspension that carries hook or attribute writes.
+         */
+        createBatch?(runId: string, events: BatchEventRequest[], params?: CreateEventBatchParams): Promise<EventBatchResult>;
         get(runId: string, eventId: string, params?: GetEventParams): Promise<Event>;
         list(params: ListEventsParams): Promise<PaginatedResponse<Event>>;
         listByCorrelationId(params: ListEventsByCorrelationIdParams): Promise<PaginatedResponse<Event>>;

package/dist/src/compiled/@workflow/world/node-http-flag.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Transport selection for the HTTP-backed Worlds (Vercel and local).
+ *
+ * Both adapters normally issue their requests through the global `fetch`,
+ * handing it a hand-built undici `Agent` (wrapped in a `RetryAgent`) so they can
+ * set connection pooling, HTTP/2, receive windows, per-request timeouts, and a
+ * retry policy tuned per call site. That is undici twice over: the dispatcher
+ * the adapter builds, and the undici implementation behind `fetch` itself.
+ *
+ * {@link NODE_HTTP_ENV_VAR} switches those requests onto a client built on
+ * `node:http` / `node:https`, which reach the network through `node:net` /
+ * `node:tls` with no undici in the path at all. It exists for a deployment
+ * where undici is not a usable dependency: a bundler that mangles its
+ * `node:http2` require, or a runtime that ships no working copy of it.
+ *
+ * See `@workflow/world/node-http.js` for the client itself, and the
+ * `WORKFLOW_NODE_HTTP` docs entry for what the swap costs.
+ */
+/** Environment variable that selects the `node:http` / `node:https` transport. */
+export declare const NODE_HTTP_ENV_VAR = "WORKFLOW_NODE_HTTP";
+/**
+ * Default for {@link NODE_HTTP_ENV_VAR}.
+ *
+ * The undici path stays the default because it is the one every deployment has
+ * run so far. This transport is opt-in, for the deployments that cannot use
+ * undici at all.
+ */
+export declare const NODE_HTTP_DEFAULT = false;
+/**
+ * Whether the HTTP Worlds should send their requests over Node's core HTTP
+ * client instead of `fetch` + a custom undici dispatcher.
+ *
+ * Read lazily on every call rather than at module load, so a test or a single
+ * process can exercise both transports.
+ *
+ * An explicitly-supplied dispatcher (`createVercelWorld({ dispatcher })`) still
+ * wins over this flag: passing one is an instruction to use undici, so the
+ * request goes back through `fetch` with that dispatcher.
+ */
+export declare function isNodeHttpEnabled(env?: Record<string, string | undefined>): boolean;
+//# sourceMappingURL=node-http-flag.d.ts.map

package/dist/src/compiled/@workflow/world/node-http.d.ts

@@ -0,0 +1,81 @@
+/**
+ * A `fetch`-shaped client built on Node's core HTTP modules.
+ *
+ * `node:http` / `node:https` sit directly on `node:net` / `node:tls`, so a
+ * request issued here involves no undici at all: not the adapter's own
+ * `Agent`, and not the one behind the runtime's global `fetch`. That is the
+ * whole point of this module: it is the transport
+ * {@link ./node-http-flag.js | WORKFLOW_NODE_HTTP} selects, for a deployment
+ * where undici is not a usable dependency (a bundler that mangles its
+ * `node:http2` require, a runtime that ships no working copy of it).
+ *
+ * The returned value is a platform `Response` built around a streaming body,
+ * so every consumer shape the Worlds use keeps working: `text()`, `json()`,
+ * `arrayBuffer()`, and reading `body` as a `ReadableStream` / async iterable
+ * while the response is still arriving.
+ *
+ * Node builtins are imported statically here, which is why this module is
+ * reached by subpath (`@workflow/world/node-http.js`) and is deliberately not
+ * re-exported from the package index: `@workflow/world` is also consumed by
+ * browser bundles that must not pull `node:https` into their graph.
+ */
+import http from 'node:http';
+import https from 'node:https';
+/**
+ * Keep-alive connection pools, one per scheme. Mirrors the role of an undici
+ * `Agent`: a caller builds a pair once and hands it to every request that
+ * should share its sockets.
+ */
+export interface NodeHttpAgents {
+    http: http.Agent;
+    https: https.Agent;
+}
+export interface NodeHttpAgentOptions {
+    /** Max concurrent sockets per origin. Mirrors undici's `connections`. */
+    maxSockets: number;
+    /** How long an idle socket is kept. Mirrors undici's `keepAliveTimeout`. */
+    keepAliveMs: number;
+}
+/**
+ * Build a keep-alive pool pair. Both schemes are created up front because the
+ * scheme is a property of each request URL, not of the pool: a local queue
+ * delivering to `http://localhost` and a World talking to an `https://` origin
+ * both go through {@link nodeHttpFetch}.
+ */
+export declare function createNodeHttpAgents(options: NodeHttpAgentOptions): NodeHttpAgents;
+/** Close both pools and drop their idle sockets. */
+export declare function destroyNodeHttpAgents(agents: NodeHttpAgents): void;
+export interface NodeHttpFetchInit {
+    method?: string;
+    headers?: Headers;
+    /** Fully-buffered request body. Streaming uploads are not supported. */
+    body?: Uint8Array | string | null;
+    /** Composed caller/timeout signal. Rejects with `signal.reason`, like `fetch`. */
+    signal?: AbortSignal;
+    /** Connection pool to dispatch on. Omitted means Node's global agent. */
+    agents?: NodeHttpAgents;
+    /**
+     * Give up if response headers do not arrive within this many ms. `0` or
+     * omitted means no deadline, matching undici's `headersTimeout`.
+     *
+     * Starts when the request is handed a socket, matching where undici starts
+     * its own: waiting for a free socket does not consume the budget, connecting
+     * does (undici bounds that separately with `connectTimeout`).
+     */
+    headersTimeoutMs?: number;
+    /**
+     * Give up after this many ms with no progress on the response body. `0` or
+     * omitted means no deadline, matching undici's `bodyTimeout`.
+     */
+    bodyTimeoutMs?: number;
+}
+/**
+ * Issue one request over Node's core HTTP client and resolve with a platform
+ * `Response`.
+ *
+ * Differences from `fetch` that callers here rely on not mattering: redirects
+ * are not followed (every Worlds endpoint answers directly), the request body
+ * must be fully buffered, and no cookie or cache handling is applied.
+ */
+export declare function nodeHttpFetch(url: string, init?: NodeHttpFetchInit): Promise<Response>;
+//# sourceMappingURL=node-http.d.ts.map