@smthrs/gateway 0.35.0 → 1.0.0-rc.3

package/dist/vendor/cjs/node/NodeSocket.d.ts

@@ -0,0 +1,38 @@
+import type * as Duration from "effect/Duration";
+import type * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Socket from "effect/unstable/socket/Socket";
+/**
+ * @since 4.0.0
+ */
+export * from "../node-shared/NodeSocket.js";
+/**
+ * Provides a `Socket.WebSocketConstructor`, using `globalThis.WebSocket` when
+ * available and falling back to the `ws` package otherwise.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerWebSocketConstructor: Layer.Layer<Socket.WebSocketConstructor>;
+/**
+ * Provides a `Socket.WebSocketConstructor` backed explicitly by the `ws`
+ * package.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerWebSocketConstructorWS: Layer.Layer<Socket.WebSocketConstructor>;
+/**
+ * Creates a `Socket.Socket` layer for a WebSocket URL using the Node WebSocket
+ * constructor layer, honoring protocol, open-timeout, and high-water-mark
+ * options.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerWebSocket: (url: string | Effect.Effect<string>, options?: {
+    readonly openTimeout?: Duration.Input | undefined;
+    readonly protocols?: string | Array<string> | undefined;
+    readonly highWaterMark?: number | undefined;
+} | undefined) => Layer.Layer<Socket.Socket, never, never>;
+//# sourceMappingURL=NodeSocket.d.ts.map

package/dist/vendor/cjs/node/NodeSocket.js

@@ -0,0 +1 @@
+module.exports = require("../../node/NodeSocket.js")

package/dist/vendor/cjs/node/NodeSocketServer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @since 4.0.0
+ */
+/**
+ * @since 4.0.0
+ */
+export * from "../node-shared/NodeSocketServer.js";
+//# sourceMappingURL=NodeSocketServer.d.ts.map

package/dist/vendor/cjs/node/NodeSocketServer.js

@@ -0,0 +1 @@
+module.exports = require("../../node/NodeSocketServer.js")

package/dist/vendor/cjs/node/NodeStdio.d.ts

@@ -0,0 +1,11 @@
+import type * as Layer from "effect/Layer";
+import type { Stdio } from "effect/Stdio";
+/**
+ * Provides the `Stdio` service backed by the current process arguments,
+ * stdin, stdout, and stderr streams.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<Stdio>;
+//# sourceMappingURL=NodeStdio.d.ts.map

package/dist/vendor/cjs/node/NodeStdio.js

@@ -0,0 +1 @@
+module.exports = require("../../node/NodeStdio.js")

package/dist/vendor/cjs/node/NodeStream.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @since 4.0.0
+ */
+/**
+ * @since 4.0.0
+ */
+export * from "../node-shared/NodeStream.js";
+//# sourceMappingURL=NodeStream.d.ts.map

package/dist/vendor/cjs/node/NodeStream.js

@@ -0,0 +1 @@
+module.exports = require("../../node/NodeStream.js")

package/dist/vendor/cjs/node/NodeTerminal.d.ts

@@ -0,0 +1,21 @@
+import type { Effect } from "effect/Effect";
+import type { Layer } from "effect/Layer";
+import type { Scope } from "effect/Scope";
+import type { Terminal, UserInput } from "effect/Terminal";
+/**
+ * Creates a scoped `Terminal` service backed by process stdin/stdout, using the
+ * optional predicate to decide when key input should end the input stream.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const make: (shouldQuit?: (input: UserInput) => boolean) => Effect<Terminal, never, Scope>;
+/**
+ * Provides the default process-backed `Terminal` service, ending key input on
+ * the default quit keys.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer<Terminal>;
+//# sourceMappingURL=NodeTerminal.d.ts.map

package/dist/vendor/cjs/node/NodeTerminal.js

@@ -0,0 +1 @@
+module.exports = require("../../node/NodeTerminal.js")

package/dist/vendor/cjs/node/NodeWorker.d.ts

@@ -0,0 +1,22 @@
+import * as Layer from "effect/Layer";
+import * as Worker from "effect/unstable/workers/Worker";
+import type * as ChildProcess from "node:child_process";
+import type * as WorkerThreads from "node:worker_threads";
+/**
+ * Provides the Node `WorkerPlatform` for `worker_threads` workers and child
+ * process workers, wiring messages, errors, and exits into Effect workers and
+ * terminating the worker if graceful shutdown times out.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerPlatform: Layer.Layer<Worker.WorkerPlatform>;
+/**
+ * Provides the Node `WorkerPlatform` together with a `Worker.Spawner` created
+ * from the supplied worker or child-process spawning function.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: (spawn: (id: number) => WorkerThreads.Worker | ChildProcess.ChildProcess) => Layer.Layer<Worker.WorkerPlatform | Worker.Spawner>;
+//# sourceMappingURL=NodeWorker.d.ts.map

package/dist/vendor/cjs/node/NodeWorker.js

@@ -0,0 +1 @@
+module.exports = require("../../node/NodeWorker.js")

package/dist/vendor/cjs/node/NodeWorkerRunner.d.ts

@@ -0,0 +1,12 @@
+import * as Layer from "effect/Layer";
+import * as WorkerRunner from "effect/unstable/workers/WorkerRunner";
+/**
+ * Provides the `WorkerRunnerPlatform` for code running inside a Node worker
+ * thread or child process, routing parent messages to the registered handler
+ * and sending responses back through the parent channel.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<WorkerRunner.WorkerRunnerPlatform>;
+//# sourceMappingURL=NodeWorkerRunner.d.ts.map

package/dist/vendor/cjs/node/NodeWorkerRunner.js

@@ -0,0 +1 @@
+module.exports = require("../../node/NodeWorkerRunner.js")

package/dist/vendor/cjs/node/Undici.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Re-export of the Undici HTTP client package used by the Node platform.
+ *
+ * This module gives Effect applications a package-local import for Undici
+ * primitives while working with `@effect/platform-node`. Import named Undici
+ * APIs from here when configuring Node HTTP client dispatchers, creating agents
+ * or mock agents, setting the process-global dispatcher, or sharing the same
+ * Undici types with integrations that use the platform HTTP client.
+ *
+ * The module does not wrap or reinterpret Undici behavior. It forwards the
+ * installed `undici` named exports and default export, so connection pooling,
+ * dispatcher lifetimes, mocking, aborts, and request options follow Undici's
+ * own semantics.
+ *
+ * @since 4.0.0
+ */
+import Undici from "undici";
+/**
+ * @category re-exports
+ * @since 4.0.0
+ */
+export * from "undici";
+/**
+ * @category re-exports
+ * @since 4.0.0
+ */
+export default Undici;
+//# sourceMappingURL=Undici.d.ts.map

package/dist/vendor/cjs/node/Undici.js

@@ -0,0 +1 @@
+module.exports = require("../../node/Undici.js")

package/dist/vendor/cjs/node/index.d.ts

@@ -0,0 +1,100 @@
+/**
+ * @since 4.0.0
+ */
+/**
+ * @since 4.0.0
+ */
+export * as NodeChildProcessSpawner from "./NodeChildProcessSpawner.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeClusterHttp from "./NodeClusterHttp.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeClusterSocket from "./NodeClusterSocket.ts";
+/**
+ * @since 1.0.0
+ */
+export * as NodeCrypto from "./NodeCrypto.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeFileSystem from "./NodeFileSystem.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeHttpClient from "./NodeHttpClient.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeHttpIncomingMessage from "./NodeHttpIncomingMessage.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeHttpPlatform from "./NodeHttpPlatform.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeHttpServer from "./NodeHttpServer.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeHttpServerRequest from "./NodeHttpServerRequest.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeMultipart from "./NodeMultipart.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeMultipartParser from "./NodeMultipartParser.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodePath from "./NodePath.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeRedis from "./NodeRedis.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeRuntime from "./NodeRuntime.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeServices from "./NodeServices.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeSink from "./NodeSink.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeSocket from "./NodeSocket.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeSocketServer from "./NodeSocketServer.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeStdio from "./NodeStdio.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeStream from "./NodeStream.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeTerminal from "./NodeTerminal.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeWorker from "./NodeWorker.ts";
+/**
+ * @since 4.0.0
+ */
+export * as NodeWorkerRunner from "./NodeWorkerRunner.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/vendor/cjs/node/index.js

@@ -0,0 +1 @@
+module.exports = require("../../node/index.js")

package/dist/vendor/cjs/node-shared/NodeChildProcessSpawner.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Shared Node.js implementation of the child process spawner service.
+ *
+ * This module adapts `node:child_process.spawn` to the Effect
+ * `ChildProcessSpawner` service. Provide {@link layer} to run `ChildProcess`
+ * commands in Node-compatible runtimes: commands get scoped process handles
+ * with stdin sinks, stdout and stderr streams, exit-code waiting,
+ * interruption-time cleanup, process killing, and custom file-descriptor pipes.
+ *
+ * The implementation sits below the command-building API. It validates and
+ * resolves `cwd` through the Effect `FileSystem` and `Path` services,
+ * translates Node errno failures to `PlatformError`, and uses scopes to
+ * terminate referenced children when the owning effect is interrupted or
+ * finalized. Pipelines are flattened by {@link flattenCommand} and spawned one
+ * process at a time, wiring the selected source stream (`stdout`, `stderr`,
+ * `all`, or `fdN`) to the destination `stdin` or `fdN`.
+ *
+ * Scoped release and `kill` wait for the signalled process group. Without
+ * `forceKillAfter`, the wait is limited to one second and never escalates.
+ * With it, cleanup may take the configured duration plus a final one-second
+ * wait after `SIGKILL`. Zombie descendants can consume either full bound. On
+ * Windows, `taskkill` terminates the tree and only the leader's exit is awaited.
+ *
+ * @since 4.0.0
+ */
+import type * as Arr from "effect/Array";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Path from "effect/Path";
+import * as ChildProcess from "effect/unstable/process/ChildProcess";
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+/**
+ * Layer that provides the `NodeChildProcessSpawner` implementation.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<ChildProcessSpawner, never, FileSystem.FileSystem | Path.Path>;
+/**
+ * Result of flattening a pipeline of commands.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface FlattenedPipeline {
+    readonly commands: Arr.NonEmptyReadonlyArray<ChildProcess.StandardCommand>;
+    readonly pipeOptions: ReadonlyArray<ChildProcess.PipeOptions>;
+}
+/**
+ * Flattens a `Command` into an array of `StandardCommand`s along with pipe
+ * options for each connection.
+ *
+ * @category transforming
+ * @since 4.0.0
+ */
+export declare const flattenCommand: (command: ChildProcess.Command) => FlattenedPipeline;
+//# sourceMappingURL=NodeChildProcessSpawner.d.ts.map

package/dist/vendor/cjs/node-shared/NodeChildProcessSpawner.js

@@ -0,0 +1 @@
+module.exports = require("../../node-shared/NodeChildProcessSpawner.js")

package/dist/vendor/cjs/node-shared/NodeClusterSocket.d.ts

@@ -0,0 +1,22 @@
+import * as Layer from "effect/Layer";
+import * as Runners from "effect/unstable/cluster/Runners";
+import * as ShardingConfig from "effect/unstable/cluster/ShardingConfig";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+import type * as SocketServer from "effect/unstable/socket/SocketServer";
+/**
+ * Provides the cluster `RpcClientProtocol` by opening TCP sockets to runner
+ * addresses and using the current RPC serialization service.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerClientProtocol: Layer.Layer<Runners.RpcClientProtocol, never, RpcSerialization.RpcSerialization>;
+/**
+ * Provides the socket server used by cluster runners, listening on
+ * `ShardingConfig.runnerListenAddress` or `runnerAddress`.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerSocketServer: Layer.Layer<SocketServer.SocketServer, SocketServer.SocketServerError, ShardingConfig.ShardingConfig>;
+//# sourceMappingURL=NodeClusterSocket.d.ts.map

package/dist/vendor/cjs/node-shared/NodeClusterSocket.js

@@ -0,0 +1 @@
+module.exports = require("../../node-shared/NodeClusterSocket.js")

package/dist/vendor/cjs/node-shared/NodeCrypto.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Node-compatible implementation of Effect's `Crypto` service.
+ *
+ * This module builds the service from `node:crypto`, using `randomBytes` for
+ * random data and `createHash` for supported digest algorithms. It exports
+ * `make` as the concrete service value and `layer` for providing it through
+ * Effect context.
+ *
+ * @since 1.0.0
+ */
+import * as EffectCrypto from "effect/Crypto";
+import * as Layer from "effect/Layer";
+/**
+ * The default Node.js Crypto service implementation.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const make: EffectCrypto.Crypto;
+/**
+ * Layer that provides the Node.js Crypto service implementation.
+ *
+ * @category layers
+ * @since 1.0.0
+ */
+export declare const layer: Layer.Layer<EffectCrypto.Crypto>;
+//# sourceMappingURL=NodeCrypto.d.ts.map

package/dist/vendor/cjs/node-shared/NodeCrypto.js

@@ -0,0 +1 @@
+module.exports = require("../../node-shared/NodeCrypto.js")

package/dist/vendor/cjs/node-shared/NodeFileSystem.d.ts

@@ -0,0 +1,11 @@
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+/**
+ * Provides the `FileSystem` service backed by Node filesystem APIs, including
+ * file operations, directory operations, links, metadata, and file watching.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<FileSystem.FileSystem>;
+//# sourceMappingURL=NodeFileSystem.d.ts.map

package/dist/vendor/cjs/node-shared/NodeFileSystem.js

@@ -0,0 +1 @@
+module.exports = require("../../node-shared/NodeFileSystem.js")

package/dist/vendor/cjs/node-shared/NodeHttpCompression.d.ts

@@ -0,0 +1,36 @@
+import type * as Platform from "effect/unstable/http/HttpPlatform";
+import type { Duplex } from "node:stream";
+/**
+ * The compression algorithms supported by the runtime's `node:zlib`. `zstd`
+ * requires Node.js 22.15 or newer.
+ *
+ * @category constants
+ * @since 4.0.0
+ */
+export declare const algorithms: ReadonlySet<Platform.CompressionAlgorithm>;
+/**
+ * Creates a `Compression` that compresses byte-array bodies in one shot with
+ * the asynchronous `node:zlib` APIs, setting the exact `Content-Length` of the
+ * compressed body. All other bodies are delegated to `fallback`.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const make: (fallback: Platform.Compression) => Platform.Compression;
+/**
+ * Creates a `node:zlib` compression transform stream that flushes each input
+ * chunk, for streaming response bodies.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const compressTransform: (algorithm: Platform.CompressionAlgorithm, options?: Platform.CompressionOptions | undefined) => Duplex;
+/**
+ * A Web `ReadableStream` version of `compressTransform`, for platforms that
+ * stream response bodies as Web streams.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const compressTransformWeb: (algorithm: Platform.CompressionAlgorithm, options?: Platform.CompressionOptions | undefined) => (stream: ReadableStream<Uint8Array>) => ReadableStream<Uint8Array>;
+//# sourceMappingURL=NodeHttpCompression.d.ts.map

package/dist/vendor/cjs/node-shared/NodeHttpCompression.js

@@ -0,0 +1 @@
+module.exports = require("../../node-shared/NodeHttpCompression.js")

package/dist/vendor/cjs/node-shared/NodePath.d.ts

@@ -0,0 +1,27 @@
+import * as Layer from "effect/Layer";
+import { Path } from "effect/Path";
+/**
+ * Provides the `Path` service using Node's POSIX path implementation plus
+ * file URL conversion helpers.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerPosix: Layer.Layer<Path>;
+/**
+ * Provides the `Path` service using Node's Windows path implementation plus
+ * file URL conversion helpers.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layerWin32: Layer.Layer<Path>;
+/**
+ * Provides the default `Path` service using the host platform's Node path
+ * implementation plus file URL conversion helpers.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export declare const layer: Layer.Layer<Path>;
+//# sourceMappingURL=NodePath.d.ts.map

package/dist/vendor/cjs/node-shared/NodePath.js

@@ -0,0 +1 @@
+module.exports = require("../../node-shared/NodePath.js")

package/dist/vendor/cjs/node-shared/NodeRuntime.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Node-compatible process runner for Effect programs.
+ *
+ * This module provides the shared `runMain` implementation used by
+ * Node-compatible platform packages. It runs one Effect as the main process
+ * fiber, interrupts that fiber on `SIGINT` or `SIGTERM`, and delegates final
+ * exit-code handling to the configured teardown.
+ *
+ * @since 4.0.0
+ */
+import type { Effect } from "effect/Effect";
+import * as Runtime from "effect/Runtime";
+/**
+ * Runs an Effect as the Node process main program, interrupting the fiber on
+ * `SIGINT` or `SIGTERM` and invoking the configured teardown to determine the
+ * process exit code.
+ *
+ * @category running
+ * @since 4.0.0
+ */
+export declare const runMain: {
+    /**
+     * Runs an Effect as the Node process main program, interrupting the fiber on
+     * `SIGINT` or `SIGTERM` and invoking the configured teardown to determine the
+     * process exit code.
+     *
+     * @category running
+     * @since 4.0.0
+     */
+    (options?: {
+        readonly disableErrorReporting?: boolean | undefined;
+        readonly teardown?: Runtime.Teardown | undefined;
+    }): <E, A>(effect: Effect<A, E>) => void;
+    /**
+     * Runs an Effect as the Node process main program, interrupting the fiber on
+     * `SIGINT` or `SIGTERM` and invoking the configured teardown to determine the
+     * process exit code.
+     *
+     * @category running
+     * @since 4.0.0
+     */
+    <E, A>(effect: Effect<A, E>, options?: {
+        readonly disableErrorReporting?: boolean | undefined;
+        readonly teardown?: Runtime.Teardown | undefined;
+    }): void;
+};
+//# sourceMappingURL=NodeRuntime.d.ts.map

package/dist/vendor/cjs/node-shared/NodeRuntime.js

@@ -0,0 +1 @@
+module.exports = require("../../node-shared/NodeRuntime.js")

package/dist/vendor/cjs/node-shared/NodeSink.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Sink adapters for writing Effect chunks into Node writable streams.
+ *
+ * `fromWritable` creates a `Sink`, `fromWritableChannel` creates a lower-level
+ * `Channel`, and `pullIntoWritable` writes from an existing pull loop. All
+ * three adapters respect writable-stream backpressure, map writable errors with
+ * the supplied `onError` function, and can end the writable when the upstream
+ * data is done.
+ *
+ * @since 4.0.0
+ */
+import type { NonEmptyReadonlyArray } from "effect/Array";
+import * as Channel from "effect/Channel";
+import { type LazyArg } from "effect/Function";
+import * as Pull from "effect/Pull";
+import * as Sink from "effect/Sink";
+import type { Writable } from "node:stream";
+/**
+ * Creates a `Sink` that writes chunks to a Node writable stream, respecting
+ * backpressure, mapping writable errors with `onError`, and ending the stream
+ * on completion unless `endOnDone` is `false`.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const fromWritable: <E, A = Uint8Array | string>(options: {
+    readonly evaluate: LazyArg<Writable | NodeJS.WritableStream>;
+    readonly onError: (error: unknown) => E;
+    readonly endOnDone?: boolean | undefined;
+    readonly encoding?: BufferEncoding | undefined;
+}) => Sink.Sink<void, A, never, E>;
+/**
+ * Creates a `Channel` that pulls chunks from upstream and writes them to a
+ * Node writable stream, respecting backpressure and optionally ending the
+ * writable when upstream is done.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export declare const fromWritableChannel: <IE, E, A = Uint8Array | string>(options: {
+    readonly evaluate: LazyArg<Writable | NodeJS.WritableStream>;
+    readonly onError: (error: unknown) => E;
+    readonly endOnDone?: boolean | undefined;
+    readonly encoding?: BufferEncoding | undefined;
+}) => Channel.Channel<never, IE | E, void, NonEmptyReadonlyArray<A>, IE>;
+/**
+ * Writes Effect chunks into a Node writable stream.
+ *
+ * **When to use**
+ *
+ * Use to implement custom Node stream adapters that already have an upstream
+ * pull and need direct control over a writable stream.
+ *
+ * **Details**
+ *
+ * The loop waits for `drain` when needed, fails on writable errors, and ends
+ * the writable on upstream completion unless `endOnDone` is `false`.
+ *
+ * @category converting
+ * @since 4.0.0
+ */
+export declare const pullIntoWritable: <A, IE, E>(options: {
+    readonly pull: Pull.Pull<NonEmptyReadonlyArray<A>, IE, unknown>;
+    readonly writable: Writable;
+    readonly onError: (error: unknown) => E;
+    readonly endOnDone?: boolean | undefined;
+    readonly encoding?: BufferEncoding | undefined;
+}) => Pull.Pull<never, IE | E, unknown>;
+//# sourceMappingURL=NodeSink.d.ts.map

package/dist/vendor/cjs/node-shared/NodeSink.js

@@ -0,0 +1 @@
+module.exports = require("../../node-shared/NodeSink.js")