@puku-ai/sdk 4.0.3 → 4.0.5

package/dist/vendor/internal/request-options.cjs

@@ -0,0 +1,31 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FallbackEncoder = exports.BetaFallbackState = void 0;
+/**
+ * Tracks which fallback a sequence of requests is pinned to.
+ *
+ * Create one (`new BetaFallbackState()`) and pass it via the `fallbackState`
+ * request option on every request that should share the pin — the turns of one
+ * conversation, or any wider scope the stickiness should apply to;
+ * `betaRefusalFallbackMiddleware` mutates it in place when a model refuses.
+ */
+class BetaFallbackState {
+    /**
+     * Index into the fallback chain the requests are pinned to.
+     *
+     * `undefined` (or -1) targets the original request params; the middleware
+     * sets it to the index of the fallback that accepted the request.
+     */
+    index;
+}
+exports.BetaFallbackState = BetaFallbackState;
+const FallbackEncoder = ({ headers, body }) => {
+    return {
+        bodyHeaders: {
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify(body),
+    };
+};
+exports.FallbackEncoder = FallbackEncoder;

package/dist/vendor/internal/request-signal.cjs

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRequestSignalCleanup = registerRequestSignalCleanup;
+exports.armAbandonmentBackstop = armAbandonmentBackstop;
+exports.releaseRequestSignal = releaseRequestSignal;
+/**
+ * Tracks the removal of the per-request abort listener that
+ * `fetchWithTimeout` attaches to a caller-provided signal, so the listener's
+ * lifetime matches the request instead of the signal.
+ *
+ * Without removal, a long-lived signal (e.g. one AbortController reused for
+ * a whole session) accumulates one `{ once: true }` listener plus its bound
+ * AbortController per HTTP attempt until the signal fires or is collected,
+ * and Node warns at the 11th listener. The listener must survive until the
+ * response body is settled - removing it when fetch resolves (headers) would
+ * break aborting an in-flight body read - so the code that finishes the body
+ * (response parsing, stream teardown, retry/error handling) calls
+ * `releaseRequestSignal` with the request's controller.
+ */
+const cleanups = new WeakMap();
+const registry = typeof globalThis.FinalizationRegistry === 'function' ?
+    new globalThis.FinalizationRegistry((controller) => releaseRequestSignal(controller))
+    : null;
+// Module-scope factory so the cleanup closure captures exactly the signal and
+// the listener - built at the `fetchWithTimeout` call site it would share that
+// scope's context and retain the request body for as long as the cleanup is
+// held (same reason `_makeAbort` exists in client.ts).
+function makeCleanup(signal, listener) {
+    return () => signal.removeEventListener('abort', listener);
+}
+function registerRequestSignalCleanup(controller, signal, listener) {
+    cleanups.set(controller, makeCleanup(signal, listener));
+}
+// The registered target is the response BODY, not the Response: a caller can
+// keep a reader on the body and drop the Response wrapper (`.asResponse()`),
+// and the listener must survive for as long as anything can still read - the
+// body is what a live read keeps alive.
+function armAbandonmentBackstop(body, controller) {
+    if (cleanups.has(controller))
+        registry?.register(body, controller, controller);
+}
+function releaseRequestSignal(controller) {
+    const cleanup = cleanups.get(controller);
+    if (cleanup) {
+        cleanups.delete(controller);
+        registry?.unregister(controller);
+        cleanup();
+    }
+}

package/dist/vendor/internal/shim-types.cjs

@@ -0,0 +1,3 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/vendor/internal/shims.cjs

@@ -0,0 +1,91 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultFetch = getDefaultFetch;
+exports.makeReadableStream = makeReadableStream;
+exports.ReadableStreamFrom = ReadableStreamFrom;
+exports.ReadableStreamToAsyncIterable = ReadableStreamToAsyncIterable;
+exports.CancelReadableStream = CancelReadableStream;
+function getDefaultFetch() {
+    if (typeof fetch !== 'undefined') {
+        return fetch;
+    }
+    throw new Error('`fetch` is not defined as a global; Either pass `fetch` to the client, `new PukuAI({ fetch })` or polyfill the global, `globalThis.fetch = fetch`');
+}
+function makeReadableStream(...args) {
+    const ReadableStream = globalThis.ReadableStream;
+    if (typeof ReadableStream === 'undefined') {
+        // Note: All of the platforms / runtimes we officially support already define
+        // `ReadableStream` as a global, so this should only ever be hit on unsupported runtimes.
+        throw new Error('`ReadableStream` is not defined as a global; You will need to polyfill it, `globalThis.ReadableStream = ReadableStream`');
+    }
+    return new ReadableStream(...args);
+}
+function ReadableStreamFrom(iterable) {
+    let iter = Symbol.asyncIterator in iterable ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
+    return makeReadableStream({
+        start() { },
+        async pull(controller) {
+            const { done, value } = await iter.next();
+            if (done) {
+                controller.close();
+            }
+            else {
+                controller.enqueue(value);
+            }
+        },
+        async cancel() {
+            await iter.return?.();
+        },
+    });
+}
+/**
+ * Most browsers don't yet have async iterable support for ReadableStream,
+ * and Node has a very different way of reading bytes from its "ReadableStream".
+ *
+ * This polyfill was pulled from
+ */
+function ReadableStreamToAsyncIterable(stream) {
+    if (stream[Symbol.asyncIterator])
+        return stream;
+    const reader = stream.getReader();
+    return {
+        async next() {
+            try {
+                const result = await reader.read();
+                if (result?.done)
+                    reader.releaseLock(); // release lock when stream becomes closed
+                return result;
+            }
+            catch (e) {
+                reader.releaseLock(); // release lock when stream becomes errored
+                throw e;
+            }
+        },
+        async return() {
+            const cancelPromise = reader.cancel();
+            reader.releaseLock();
+            await cancelPromise;
+            return { done: true, value: undefined };
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+    };
+}
+/**
+ * Cancels a ReadableStream we don't need to consume.
+ * See https://undici.nodejs.org/#/?id=garbage-collection
+ */
+async function CancelReadableStream(stream) {
+    if (stream === null || typeof stream !== 'object')
+        return;
+    if (stream[Symbol.asyncIterator]) {
+        await stream[Symbol.asyncIterator]().return?.();
+        return;
+    }
+    const reader = stream.getReader();
+    const cancelPromise = reader.cancel();
+    reader.releaseLock();
+    await cancelPromise;
+}

package/dist/vendor/internal/stainless-helper-header.cjs

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * Single source of truth for the `x-stainless-helper` telemetry header — the
+ * key, the closed value vocabulary, and per-object helper tagging. The
+ * append-don't-clobber merge for the header itself lives in
+ * {@link import('../internal/headers').buildHeaders} via `APPEND_HEADERS`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDK_HELPER_SYMBOL = exports.STAINLESS_HELPER_METHOD_HEADER = exports.STAINLESS_HELPER_HEADER = void 0;
+exports.helperHeader = helperHeader;
+exports.wasCreatedByStainlessHelper = wasCreatedByStainlessHelper;
+exports.collectStainlessHelpers = collectStainlessHelpers;
+exports.stainlessHelperHeader = stainlessHelperHeader;
+exports.stainlessHelperHeaderFromFile = stainlessHelperHeaderFromFile;
+/**
+ * Telemetry header naming the SDK helper(s) a request came from. Always this
+ * lowercase form; `buildHeaders` matches it case-insensitively for its append
+ * semantics, but a single canonical casing keeps every call site greppable.
+ */
+exports.STAINLESS_HELPER_HEADER = 'x-stainless-helper';
+/** Telemetry header naming the SDK method (e.g. `stream`) in use. */
+exports.STAINLESS_HELPER_METHOD_HEADER = 'x-stainless-helper-method';
+/**
+ * The `{ 'x-stainless-helper': value }` header dict, for passing into
+ * `buildHeaders` (which comma-appends `x-stainless-helper` across sources)
+ * or as `defaultHeaders`/per-request `headers`.
+ */
+function helperHeader(value) {
+    return { [exports.STAINLESS_HELPER_HEADER]: value };
+}
+/**
+ * Symbol used to mark objects created by SDK helpers for tracking.
+ * The value is the helper name (e.g., 'mcpTool', 'betaZodTool').
+ */
+exports.SDK_HELPER_SYMBOL = Symbol('puku.sdk.stainlessHelper');
+function wasCreatedByStainlessHelper(value) {
+    return typeof value === 'object' && value !== null && exports.SDK_HELPER_SYMBOL in value;
+}
+/**
+ * Collects helper names from tools and messages arrays.
+ * Returns a deduplicated array of helper names found.
+ */
+function collectStainlessHelpers(tools, messages) {
+    const helpers = new Set();
+    // Collect from tools
+    if (tools) {
+        for (const tool of tools) {
+            if (wasCreatedByStainlessHelper(tool)) {
+                helpers.add(tool[exports.SDK_HELPER_SYMBOL]);
+            }
+        }
+    }
+    // Collect from messages and their content blocks
+    if (messages) {
+        for (const message of messages) {
+            if (wasCreatedByStainlessHelper(message)) {
+                helpers.add(message[exports.SDK_HELPER_SYMBOL]);
+            }
+            const content = message.content;
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (wasCreatedByStainlessHelper(block)) {
+                        helpers.add(block[exports.SDK_HELPER_SYMBOL]);
+                    }
+                }
+            }
+        }
+    }
+    return Array.from(helpers);
+}
+/**
+ * Builds x-stainless-helper header value from tools and messages.
+ * Returns an empty object if no helpers are found.
+ */
+function stainlessHelperHeader(tools, messages) {
+    const helpers = collectStainlessHelpers(tools, messages);
+    if (helpers.length === 0)
+        return {};
+    return { [exports.STAINLESS_HELPER_HEADER]: helpers.join(', ') };
+}
+/**
+ * Builds x-stainless-helper header value from a file object.
+ * Returns an empty object if the file is not marked with a helper.
+ */
+function stainlessHelperHeaderFromFile(file) {
+    if (wasCreatedByStainlessHelper(file)) {
+        return { [exports.STAINLESS_HELPER_HEADER]: file[exports.SDK_HELPER_SYMBOL] };
+    }
+    return {};
+}

package/dist/vendor/internal/stream-utils.cjs

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadableStreamToAsyncIterable = ReadableStreamToAsyncIterable;
+/**
+ * Most browsers don't yet have async iterable support for ReadableStream,
+ * and Node has a very different way of reading bytes from its "ReadableStream".
+ *
+ * This polyfill was pulled from
+ */
+function ReadableStreamToAsyncIterable(stream) {
+    if (stream[Symbol.asyncIterator])
+        return stream;
+    const reader = stream.getReader();
+    return {
+        async next() {
+            try {
+                const result = await reader.read();
+                if (result?.done)
+                    reader.releaseLock(); // release lock when stream becomes closed
+                return result;
+            }
+            catch (e) {
+                reader.releaseLock(); // release lock when stream becomes errored
+                throw e;
+            }
+        },
+        async return() {
+            const cancelPromise = reader.cancel();
+            reader.releaseLock();
+            await cancelPromise;
+            return { done: true, value: undefined };
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+    };
+}

package/dist/vendor/internal/to-file.cjs

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toFile = toFile;
+const uploads_1 = require("./uploads");
+const uploads_2 = require("./uploads");
+/**
+ * This check adds the arrayBuffer() method type because it is available and used at runtime
+ */
+const isBlobLike = (value) => value != null &&
+    typeof value === 'object' &&
+    typeof value.size === 'number' &&
+    typeof value.type === 'string' &&
+    typeof value.text === 'function' &&
+    typeof value.slice === 'function' &&
+    typeof value.arrayBuffer === 'function';
+/**
+ * This check adds the arrayBuffer() method type because it is available and used at runtime
+ */
+const isFileLike = (value) => value != null &&
+    typeof value === 'object' &&
+    typeof value.name === 'string' &&
+    typeof value.lastModified === 'number' &&
+    isBlobLike(value);
+const isResponseLike = (value) => value != null &&
+    typeof value === 'object' &&
+    typeof value.url === 'string' &&
+    typeof value.blob === 'function';
+/**
+ * Helper for creating a {@link File} to pass to an SDK upload method from a variety of different data formats
+ * @param value the raw content of the file. Can be an {@link Uploadable}, BlobLikePart, or AsyncIterable of BlobLikeParts
+ * @param {string=} name the name of the file. If omitted, toFile will try to determine a file name from bits if possible
+ * @param {Object=} options additional properties
+ * @param {string=} options.type the MIME type of the content
+ * @param {number=} options.lastModified the last modified timestamp
+ * @returns a {@link File} with the given properties
+ */
+async function toFile(value, name, options) {
+    (0, uploads_2.checkFileSupport)();
+    // If it's a promise, resolve it.
+    value = await value;
+    name ||= (0, uploads_1.getName)(value, true);
+    // If we've been given a `File` we don't need to do anything if the name / options
+    // have not been customised.
+    if (isFileLike(value)) {
+        if (value instanceof File && name == null && options == null) {
+            return value;
+        }
+        return (0, uploads_1.makeFile)([await value.arrayBuffer()], name ?? value.name, {
+            type: value.type,
+            lastModified: value.lastModified,
+            ...options,
+        });
+    }
+    if (isResponseLike(value)) {
+        const blob = await value.blob();
+        name ||= new URL(value.url).pathname.split(/[\\/]/).pop();
+        return (0, uploads_1.makeFile)(await getBytes(blob), name, options);
+    }
+    const parts = await getBytes(value);
+    if (!options?.type) {
+        const type = parts.find((part) => typeof part === 'object' && 'type' in part && part.type);
+        if (typeof type === 'string') {
+            options = { ...options, type };
+        }
+    }
+    return (0, uploads_1.makeFile)(parts, name, options);
+}
+async function getBytes(value) {
+    let parts = [];
+    if (typeof value === 'string' ||
+        ArrayBuffer.isView(value) || // includes Uint8Array, Buffer, etc.
+        value instanceof ArrayBuffer) {
+        parts.push(value);
+    }
+    else if (isBlobLike(value)) {
+        parts.push(value instanceof Blob ? value : await value.arrayBuffer());
+    }
+    else if ((0, uploads_1.isAsyncIterable)(value) // includes Readable, ReadableStream, etc.
+    ) {
+        for await (const chunk of value) {
+            parts.push(...(await getBytes(chunk))); // TODO, consider validating?
+        }
+    }
+    else {
+        const constructor = value?.constructor?.name;
+        throw new Error(`Unexpected data type: ${typeof value}${constructor ? `; constructor: ${constructor}` : ''}${propsForError(value)}`);
+    }
+    return parts;
+}
+function propsForError(value) {
+    if (typeof value !== 'object' || value === null)
+        return '';
+    const props = Object.getOwnPropertyNames(value);
+    return `; props: [${props.map((p) => `"${p}"`).join(', ')}]`;
+}

package/dist/vendor/internal/types.cjs

@@ -0,0 +1,3 @@
+"use strict";
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/vendor/internal/uploads.cjs

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createForm = exports.multipartFormRequestOptions = exports.maybeMultipartFormRequestOptions = exports.isAsyncIterable = exports.checkFileSupport = void 0;
+exports.makeFile = makeFile;
+exports.getName = getName;
+const shims_1 = require("./shims");
+const checkFileSupport = () => {
+    if (typeof File === 'undefined') {
+        const { process } = globalThis;
+        const isOldNode = typeof process?.versions?.node === 'string' && parseInt(process.versions.node.split('.')) < 20;
+        throw new Error('`File` is not defined as a global, which is required for file uploads.' +
+            (isOldNode ?
+                " Update to Node 20 LTS or newer, or set `globalThis.File` to `import('node:buffer').File`."
+                : ''));
+    }
+};
+exports.checkFileSupport = checkFileSupport;
+/**
+ * Construct a `File` instance. This is used to ensure a helpful error is thrown
+ * for environments that don't define a global `File` yet.
+ */
+function makeFile(fileBits, fileName, options) {
+    (0, exports.checkFileSupport)();
+    return new File(fileBits, fileName ?? 'unknown_file', options);
+}
+function getName(value, stripPath) {
+    const val = (typeof value === 'object' &&
+        value !== null &&
+        (('name' in value && value.name && String(value.name)) ||
+            ('url' in value && value.url && String(value.url)) ||
+            ('filename' in value && value.filename && String(value.filename)) ||
+            ('path' in value && value.path && String(value.path)))) ||
+        '';
+    return stripPath ? val.split(/[\\/]/).pop() || undefined : val;
+}
+const isAsyncIterable = (value) => value != null && typeof value === 'object' && typeof value[Symbol.asyncIterator] === 'function';
+exports.isAsyncIterable = isAsyncIterable;
+/**
+ * Returns a multipart/form-data request if any part of the given request body contains a File / Blob value.
+ * Otherwise returns the request as is.
+ */
+const maybeMultipartFormRequestOptions = async (opts, fetch) => {
+    if (!hasUploadableValue(opts.body))
+        return opts;
+    return { ...opts, body: await (0, exports.createForm)(opts.body, fetch) };
+};
+exports.maybeMultipartFormRequestOptions = maybeMultipartFormRequestOptions;
+const multipartFormRequestOptions = async (opts, fetch, stripFilenames = true) => {
+    return { ...opts, body: await (0, exports.createForm)(opts.body, fetch, stripFilenames) };
+};
+exports.multipartFormRequestOptions = multipartFormRequestOptions;
+const supportsFormDataMap = /* @__PURE__ */ new WeakMap();
+/**
+ * node-fetch doesn't support the global FormData object in recent node versions. Instead of sending
+ * properly-encoded form data, it just stringifies the object, resulting in a request body of "[object FormData]".
+ * This function detects if the fetch function provided supports the global FormData object to avoid
+ * confusing error messages later on.
+ */
+function supportsFormData(fetchObject) {
+    const fetch = typeof fetchObject === 'function' ? fetchObject : fetchObject.fetch;
+    const cached = supportsFormDataMap.get(fetch);
+    if (cached)
+        return cached;
+    const promise = (async () => {
+        try {
+            const FetchResponse = ('Response' in fetch ?
+                fetch.Response
+                : (await fetch('data:,')).constructor);
+            const data = new FormData();
+            if (data.toString() === (await new FetchResponse(data).text())) {
+                return false;
+            }
+            return true;
+        }
+        catch {
+            // avoid false negatives
+            return true;
+        }
+    })();
+    supportsFormDataMap.set(fetch, promise);
+    return promise;
+}
+const createForm = async (body, fetch, stripFilenames = true) => {
+    if (!(await supportsFormData(fetch))) {
+        throw new TypeError('The provided fetch function does not support file uploads with the current global FormData class.');
+    }
+    const form = new FormData();
+    await Promise.all(Object.entries(body || {}).map(([key, value]) => addFormValue(form, key, value, stripFilenames)));
+    return form;
+};
+exports.createForm = createForm;
+// Blob, not File: bare Blobs and Bun.file() results don't inherit from File.
+const isUploadable = (value) => typeof value === 'object' &&
+    value !== null &&
+    (value instanceof Response || (0, exports.isAsyncIterable)(value) || value instanceof Blob);
+const hasUploadableValue = (value) => {
+    if (isUploadable(value))
+        return true;
+    if (Array.isArray(value))
+        return value.some(hasUploadableValue);
+    if (value && typeof value === 'object') {
+        for (const k in value) {
+            if (hasUploadableValue(value[k]))
+                return true;
+        }
+    }
+    return false;
+};
+const addFormValue = async (form, key, value, stripFilenames) => {
+    if (value === undefined)
+        return;
+    if (value == null) {
+        throw new TypeError(`Received null for "${key}"; to pass null in FormData, you must use the string 'null'`);
+    }
+    // TODO: make nested formats configurable
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        form.append(key, String(value));
+    }
+    else if (value instanceof Response) {
+        let options = {};
+        const contentType = value.headers.get('Content-Type');
+        if (contentType) {
+            options = { type: contentType };
+        }
+        form.append(key, makeFile([await value.blob()], getName(value, stripFilenames), options));
+    }
+    else if ((0, exports.isAsyncIterable)(value)) {
+        form.append(key, makeFile([await new Response((0, shims_1.ReadableStreamFrom)(value)).blob()], getName(value, stripFilenames)));
+    }
+    else if (value instanceof Blob) {
+        form.append(key, makeFile([value], getName(value, stripFilenames) || undefined, { type: value.type }));
+    }
+    else if (Array.isArray(value)) {
+        await Promise.all(value.map((entry) => addFormValue(form, key + '[]', entry, stripFilenames)));
+    }
+    else if (typeof value.then === 'function') {
+        throw new TypeError(`Received a Promise for "${key}"; await it first, e.g. \`await toFile(...)\``);
+    }
+    else if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+        throw new TypeError(`Received ${value.constructor.name} for "${key}"; to upload raw bytes, wrap them with \`await toFile(bytes, 'filename')\``);
+    }
+    else if (typeof value === 'object') {
+        await Promise.all(Object.entries(value).map(([name, prop]) => addFormValue(form, `${key}[${name}]`, prop, stripFilenames)));
+    }
+    else {
+        throw new TypeError(`Invalid value given to form, expected a string, number, boolean, object, Array, File or Blob but got ${value} instead`);
+    }
+};

package/dist/vendor/internal/utils/abort.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkAbort = linkAbort;
+/**
+ * Chain an external {@link AbortSignal} into a local {@link AbortController}:
+ * the controller aborts whenever `external` aborts (synchronously if it is
+ * already aborted).
+ *
+ * Returns a cleanup function that detaches the listener. Callers MUST invoke it
+ * on their normal teardown path — `{ once: true }` only removes the listener if
+ * abort actually fires, so a long-lived `external` signal  would otherwise leak one
+ * listener per controller.
+ */
+function linkAbort(external, controller) {
+    if (!external)
+        return () => { };
+    if (external.aborted) {
+        controller.abort();
+        return () => { };
+    }
+    const onAbort = () => controller.abort();
+    external.addEventListener('abort', onAbort);
+    return () => external.removeEventListener('abort', onAbort);
+}

package/dist/vendor/internal/utils/async-queue.cjs

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncQueue = void 0;
+/**
+ * Single-consumer async queue that bridges background producers to an
+ * `AsyncIterator`-style reader. Producers `push()` items; the consumer awaits
+ * `next()`. `close()` is idempotent and wakes any pending `next()` with
+ * `done: true`. `tryShift()` synchronously drains remaining items after
+ * iteration has been signalled to stop.
+ */
+class AsyncQueue {
+    #items = [];
+    #waiters = [];
+    #closed = false;
+    /** Enqueue an item, or hand it directly to a waiting reader. Returns `false` once closed. */
+    push(item) {
+        if (this.#closed)
+            return false;
+        const w = this.#waiters.shift();
+        if (w)
+            w({ done: false, value: item });
+        else
+            this.#items.push(item);
+        return true;
+    }
+    /** Mark the queue done. Idempotent; wakes every pending reader with `done: true`. */
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        while (this.#waiters.length > 0) {
+            const w = this.#waiters.shift();
+            w({ done: true, value: undefined });
+        }
+    }
+    /**
+     * Resolve with the next item, or `done: true` once the queue is closed and
+     * drained. When `signal` is supplied, aborting it resolves a pending read
+     * with `done: true` (cancellation is pushed down here rather than handled by
+     * an outer `Promise.race`).
+     */
+    next(signal) {
+        if (this.#items.length > 0) {
+            return Promise.resolve({ done: false, value: this.#items.shift() });
+        }
+        if (this.#closed || signal?.aborted) {
+            return Promise.resolve({ done: true, value: undefined });
+        }
+        return new Promise((resolve) => {
+            const waiter = (r) => {
+                signal?.removeEventListener('abort', onAbort);
+                resolve(r);
+            };
+            const onAbort = () => {
+                const idx = this.#waiters.indexOf(waiter);
+                if (idx >= 0)
+                    this.#waiters.splice(idx, 1);
+                resolve({ done: true, value: undefined });
+            };
+            this.#waiters.push(waiter);
+            signal?.addEventListener('abort', onAbort, { once: true });
+        });
+    }
+    /** Synchronously remove and return the next buffered item, or `undefined` if empty. */
+    tryShift() {
+        return this.#items.shift();
+    }
+}
+exports.AsyncQueue = AsyncQueue;