karajan-code 3.3.0 → 3.4.0

package/node_modules/@karajan/core/tests/pricing/index.test.js

@@ -0,0 +1,95 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+import {
+  getModelPricing,
+  listKnownModels,
+  _resetCache,
+} from "../../src/pricing/index.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REGISTRY_PATH = join(__dirname, "../../src/pricing/model-pricing.json");
+
+describe("pricing — model-pricing.json structure", () => {
+  it("is valid JSON with a _meta block", () => {
+    const raw = readFileSync(REGISTRY_PATH, "utf8");
+    const data = JSON.parse(raw);
+    expect(data._meta).toBeDefined();
+    expect(data._meta.currency).toBe("USD");
+    expect(data._meta.updatedAt).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+    expect(data._meta.unit).toMatch(/1M tokens/);
+  });
+
+  it("every entry (except _meta) has inputPerMTok, outputPerMTok and source", () => {
+    const raw = readFileSync(REGISTRY_PATH, "utf8");
+    const data = JSON.parse(raw);
+    for (const [key, entry] of Object.entries(data)) {
+      if (key.startsWith("_")) continue;
+      expect(typeof entry.inputPerMTok).toBe("number");
+      expect(typeof entry.outputPerMTok).toBe("number");
+      expect(entry.inputPerMTok).toBeGreaterThanOrEqual(0);
+      expect(entry.outputPerMTok).toBeGreaterThanOrEqual(0);
+      expect(typeof entry.source).toBe("string");
+      expect(entry.source.length).toBeGreaterThan(0);
+    }
+  });
+});
+
+describe("pricing — getModelPricing()", () => {
+  beforeEach(() => _resetCache());
+
+  it("returns full pricing for a known Anthropic model", () => {
+    const p = getModelPricing("claude-opus-4-7");
+    expect(p).not.toBeNull();
+    expect(p.inputPerMTok).toBe(15.0);
+    expect(p.outputPerMTok).toBe(75.0);
+    expect(p.currency).toBe("USD");
+    expect(p.source).toBe("anthropic");
+    expect(p.updatedAt).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+  });
+
+  it("returns full pricing for an OpenAI model", () => {
+    const p = getModelPricing("gpt-4o");
+    expect(p).not.toBeNull();
+    expect(p.source).toBe("openai");
+    expect(p.inputPerMTok).toBeGreaterThan(0);
+  });
+
+  it("returns full pricing for a Google model", () => {
+    const p = getModelPricing("gemini-1.5-flash");
+    expect(p).not.toBeNull();
+    expect(p.source).toBe("google");
+  });
+
+  it("returns null for an unknown model", () => {
+    expect(getModelPricing("nonexistent-model-xyz")).toBeNull();
+  });
+
+  it("returns null for the _meta key (does not leak metadata)", () => {
+    expect(getModelPricing("_meta")).toBeNull();
+  });
+
+  it("returns null for empty / non-string inputs", () => {
+    expect(getModelPricing("")).toBeNull();
+    expect(getModelPricing(null)).toBeNull();
+    expect(getModelPricing(undefined)).toBeNull();
+    expect(getModelPricing(42)).toBeNull();
+  });
+});
+
+describe("pricing — listKnownModels()", () => {
+  it("returns a non-empty list and never includes _meta", () => {
+    const models = listKnownModels();
+    expect(Array.isArray(models)).toBe(true);
+    expect(models.length).toBeGreaterThan(5);
+    expect(models).not.toContain("_meta");
+  });
+
+  it("every listed model resolves via getModelPricing", () => {
+    for (const m of listKnownModels()) {
+      expect(getModelPricing(m)).not.toBeNull();
+    }
+  });
+});

package/node_modules/@karajan/core/tests/process.test.js

@@ -0,0 +1,22 @@
+import { describe, it, expect } from "vitest";
+import { runCommand } from "../src/process.js";
+
+describe("@karajan/core/process", () => {
+  it("captures stdout from a real subprocess", async () => {
+    const r = await runCommand("node", ["-e", "process.stdout.write('hi')"]);
+    expect(r.exitCode).toBe(0);
+    expect(r.stdout).toBe("hi");
+  });
+
+  it("returns exitCode 1 + spawnError when binary missing (ENOENT)", async () => {
+    const r = await runCommand("__definitely_not_a_real_bin__", []);
+    expect(r.exitCode).toBe(1);
+    expect(r.stderr).toBeTruthy();
+  });
+
+  it("times out and reports timedOut", async () => {
+    const r = await runCommand("node", ["-e", "setInterval(() => {}, 1000)"], { timeout: 200 });
+    expect(r.timedOut).toBe(true);
+    expect(r.exitCode).toBe(143);
+  });
+});

package/node_modules/@karajan/core/tests/run-registry.test.js

@@ -0,0 +1,71 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+  registerRun,
+  unregisterRun,
+  listActiveRuns,
+  runsDir,
+} from "../src/run-registry.js";
+
+describe("@karajan/core/run-registry", () => {
+  let tmpHome;
+  let originalKarajanHome;
+
+  beforeEach(() => {
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "kj-runreg-"));
+    originalKarajanHome = process.env.KARAJAN_HOME;
+    process.env.KARAJAN_HOME = tmpHome;
+  });
+
+  afterEach(() => {
+    if (originalKarajanHome === undefined) delete process.env.KARAJAN_HOME;
+    else process.env.KARAJAN_HOME = originalKarajanHome;
+    fs.rmSync(tmpHome, { recursive: true, force: true });
+  });
+
+  it("runsDir hangs off KARAJAN_HOME/runs", () => {
+    expect(runsDir()).toBe(path.join(path.resolve(tmpHome), "runs"));
+  });
+
+  it("registerRun → listActiveRuns round-trips for the live process", () => {
+    const runId = registerRun({
+      pid: process.pid,
+      planId: "PLN-1",
+      huIds: ["HU-1"],
+      projectDir: "/tmp/x",
+      source: "test",
+    });
+    expect(runId).toMatch(/^run-\d+-\d+-[a-z0-9]+$/);
+    const list = listActiveRuns({ planId: "PLN-1" });
+    expect(list.length).toBe(1);
+    expect(list[0].pid).toBe(process.pid);
+    unregisterRun(runId);
+    expect(listActiveRuns({ planId: "PLN-1" })).toEqual([]);
+  });
+
+  it("listActiveRuns reaps entries with dead PIDs from disk", () => {
+    fs.mkdirSync(runsDir(), { recursive: true });
+    const deadEntry = {
+      runId: "run-dead",
+      pid: 999_999_999,
+      planId: "PLN-x",
+      huIds: null,
+      projectDir: null,
+      source: "test",
+      startedAt: new Date().toISOString(),
+    };
+    fs.writeFileSync(
+      path.join(runsDir(), "run-dead.json"),
+      JSON.stringify(deadEntry),
+    );
+    expect(listActiveRuns()).toEqual([]);
+    expect(fs.existsSync(path.join(runsDir(), "run-dead.json"))).toBe(false);
+  });
+
+  it("registerRun returns null when pid is missing", () => {
+    expect(registerRun({})).toBeNull();
+    expect(registerRun({ pid: 0 })).toBeNull();
+  });
+});

package/node_modules/@karajan/core/tests/shared-paths.test.js

@@ -0,0 +1,30 @@
+// Smoke coverage for the @karajan/core/shared-paths extraction
+// (KJC-TSK-0511 PR2). Full unit coverage stays next to the CLI;
+// this file proves the new package entry point resolves and returns
+// stable paths so a future workspace-wiring regression fails loudly.
+import { sep } from "node:path";
+import { describe, it, expect } from "vitest";
+
+import {
+  SHARED_DIR_NAME,
+  getSharedRoot,
+  getSharedPlansDir,
+  getSharedHuStoriesDir,
+  isSharedPath,
+} from "../src/shared-paths.js";
+
+describe("@karajan/core/shared-paths", () => {
+  it("constants and joins land inside the project dir", () => {
+    expect(SHARED_DIR_NAME).toBe(".karajan-shared");
+    expect(getSharedRoot("/tmp/proj")).toBe(`/tmp/proj${sep}.karajan-shared`);
+    expect(getSharedPlansDir("/tmp/proj").endsWith(`${sep}plans`)).toBe(true);
+    expect(getSharedHuStoriesDir("/tmp/proj").endsWith(`${sep}hu-stories`)).toBe(true);
+  });
+
+  it("isSharedPath recognises only paths within .karajan-shared", () => {
+    expect(isSharedPath("/repo/.karajan-shared/plans/x.json")).toBe(true);
+    expect(isSharedPath("/repo/local/plans/x.json")).toBe(false);
+    expect(isSharedPath("")).toBe(false);
+    expect(isSharedPath(null)).toBe(false);
+  });
+});

package/node_modules/@karajan/core/tests/standby.test.js

@@ -0,0 +1,66 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { tmpdir } from "node:os";
+import { mkdtempSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import {
+  persistStandby, loadStandby, listPendingStandby, markStandbyDone,
+  acquireStandbyLock, standbyDir,
+} from "../src/standby-store.js";
+import {
+  scheduleResume, cancelScheduled, _resetScheduledForTests,
+} from "../src/standby-scheduler.js";
+
+let tmp;
+beforeEach(() => {
+  tmp = mkdtempSync(join(tmpdir(), "kj-core-standby-"));
+  process.env.KJ_HOME = tmp;
+  _resetScheduledForTests();
+});
+afterEach(() => {
+  delete process.env.KJ_HOME;
+  rmSync(tmp, { recursive: true, force: true });
+});
+
+describe("@karajan/core/standby-store", () => {
+  it("persists + loads + lists pending sessions", () => {
+    persistStandby({ sessionId: "s_1", cooldownUntil: "2099-01-01T00:00:00Z", reason: "QUOTA" });
+    const loaded = loadStandby("s_1");
+    expect(loaded.sessionId).toBe("s_1");
+    expect(listPendingStandby()).toHaveLength(1);
+    expect(standbyDir().startsWith(tmp)).toBe(true);
+  });
+
+  it("markStandbyDone moves the file under done/", () => {
+    persistStandby({ sessionId: "s_2", cooldownUntil: "2099-01-01T00:00:00Z" });
+    expect(markStandbyDone("s_2")).toBe(true);
+    expect(loadStandby("s_2")).toBe(null);
+  });
+
+  it("acquireStandbyLock is exclusive", () => {
+    const a = acquireStandbyLock("s_3");
+    expect(a.acquired).toBe(true);
+    const b = acquireStandbyLock("s_3");
+    expect(b.acquired).toBe(false);
+    a.release();
+    const c = acquireStandbyLock("s_3");
+    expect(c.acquired).toBe(true);
+    c.release();
+  });
+});
+
+describe("@karajan/core/standby-scheduler", () => {
+  it("scheduleResume with expired cooldown fires immediate", async () => {
+    const cb = vi.fn();
+    const r = scheduleResume({ sessionId: "s_4", cooldownUntil: "1990-01-01T00:00:00Z", onResume: cb });
+    expect(r.scheduled).toBe(true);
+    expect(r.immediate).toBe(true);
+    await new Promise((res) => setImmediate(res));
+    expect(cb).toHaveBeenCalledWith("s_4");
+  });
+
+  it("cancelScheduled removes a queued timeout", () => {
+    scheduleResume({ sessionId: "s_5", cooldownUntil: "2099-01-01T00:00:00Z", onResume: () => {} });
+    expect(cancelScheduled("s_5")).toBe(true);
+    expect(cancelScheduled("s_5")).toBe(false);
+  });
+});

package/node_modules/@karajan/core/tests/vec-store.test.js

@@ -0,0 +1,98 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+  openVecStore,
+  insertChunk,
+  searchSimilar,
+  countChunks,
+  projectSlug,
+  deleteChunksBySource,
+  findChunkByHash,
+  getLastIndexedCommit,
+  setLastIndexedCommit,
+  dbPath,
+} from "../src/vec-store.js";
+
+describe("@karajan/core/vec-store", () => {
+  let tmpDir;
+  let originalRagDb;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "kj-vecstore-"));
+    originalRagDb = process.env.KJ_RAG_DB;
+    process.env.KJ_RAG_DB = path.join(tmpDir, "rag.db");
+  });
+
+  afterEach(() => {
+    if (originalRagDb === undefined) delete process.env.KJ_RAG_DB;
+    else process.env.KJ_RAG_DB = originalRagDb;
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("dbPath honours KJ_RAG_DB env", () => {
+    expect(dbPath()).toBe(path.join(tmpDir, "rag.db"));
+  });
+
+  it("openVecStore initialises chunks + vec_chunks + fts tables", () => {
+    const db = openVecStore({ dim: 4 });
+    expect(countChunks(db)).toBe(0);
+    db.close();
+  });
+
+  it("insertChunk + searchSimilar round-trip", () => {
+    const db = openVecStore({ dim: 4 });
+    const id = insertChunk(db, {
+      source: "/a.md",
+      kind: "code",
+      text: "hola mundo",
+      embedding: [1, 0, 0, 0],
+    });
+    expect(id).toBeGreaterThan(0);
+    const hits = searchSimilar(db, [1, 0, 0, 0], 1);
+    expect(hits.length).toBe(1);
+    expect(hits[0].text).toBe("hola mundo");
+    db.close();
+  });
+
+  it("deleteChunksBySource removes chunks + vec rows", () => {
+    const db = openVecStore({ dim: 4 });
+    insertChunk(db, { source: "/x.md", kind: "code", text: "a", embedding: [1, 0, 0, 0] });
+    insertChunk(db, { source: "/x.md", kind: "code", text: "b", embedding: [0, 1, 0, 0] });
+    expect(deleteChunksBySource(db, "/x.md")).toBe(2);
+    expect(countChunks(db)).toBe(0);
+    db.close();
+  });
+
+  it("projectSlug normalises basenames", () => {
+    expect(projectSlug("/home/me/My Project")).toBe("my-project");
+    expect(projectSlug("/home/me/karajan-code/")).toBe("karajan-code");
+    expect(projectSlug(null)).toBeNull();
+  });
+
+  it("findChunkByHash scopes to project", () => {
+    const db = openVecStore({ dim: 4 });
+    insertChunk(db, {
+      source: "/y.md",
+      kind: "code",
+      text: "hi",
+      embedding: [1, 0, 0, 0],
+      project: "p1",
+      contentHash: "h1",
+    });
+    expect(findChunkByHash(db, "h1", "p1").source).toBe("/y.md");
+    expect(findChunkByHash(db, "h1", "p2")).toBeNull();
+    db.close();
+  });
+
+  it("get/setLastIndexedCommit persists per-project watermark", () => {
+    const db = openVecStore({ dim: 4 });
+    expect(getLastIndexedCommit(db, "p1")).toBeNull();
+    setLastIndexedCommit(db, "p1", "abc123");
+    expect(getLastIndexedCommit(db, "p1")).toBe("abc123");
+    setLastIndexedCommit(db, "p1", "def456");
+    expect(getLastIndexedCommit(db, "p1")).toBe("def456");
+    db.close();
+  });
+});

package/node_modules/@karajan/core/vitest.config.js

@@ -0,0 +1,12 @@
+// Local Vitest config for @karajan/core so the workspace package does
+// not inherit the root config (which excludes `packages/**` and points
+// at a global setup file outside the workspace).
+
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["tests/**/*.test.js"],
+    environment: "node",
+  },
+});

package/node_modules/@sec-ant/readable-stream/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Ze-Zheng Wu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@sec-ant/readable-stream/README.md

@@ -0,0 +1,230 @@
+# @sec-ant/readable-stream
+
+[![npm version](https://img.shields.io/npm/v/@sec-ant/readable-stream?cacheSeconds=300)](https://www.npmjs.com/package/@sec-ant/readable-stream/v/latest) [![npm downloads](https://img.shields.io/npm/dm/@sec-ant/readable-stream?cacheSeconds=300)](https://www.npmjs.com/package/@sec-ant/readable-stream/v/latest) [![](https://img.shields.io/jsdelivr/npm/hm/@sec-ant/readable-stream?cacheSeconds=300&color=ff5627)](https://www.jsdelivr.com/package/npm/@sec-ant/readable-stream) [![bundlephobia minzipped](https://img.shields.io/bundlephobia/minzip/@sec-ant/readable-stream?cacheSeconds=300)](https://bundlephobia.com/package/@sec-ant/readable-stream@latest) [![npm license](https://img.shields.io/npm/l/@sec-ant/readable-stream?cacheSeconds=300)](https://www.npmjs.com/package/@sec-ant/readable-stream/v/latest)
+
+A tiny, zero-dependency yet spec-compliant asynchronous iterator polyfill/ponyfill for [`ReadableStream`](https://developer.mozilla.org/docs/Web/API/ReadableStream)s.
+
+## Features
+
+### Asynchronously iterate a `ReadableStream`
+
+With this package, you can consume a `ReadableStream` as an `AsyncIterable`.
+
+- spec: https://streams.spec.whatwg.org/#rs-asynciterator
+- tests: https://github.com/Sec-ant/readable-stream/blob/main/tests/asyncIterator.spec.ts (copied from [wpt](https://github.com/web-platform-tests/wpt/blob/309231a7f3e900d04914bc4963b016efd9989a00/streams/readable-streams/async-iterator.any.js))
+
+### Convert an `AsyncIterable` or an `Iterable` into a `ReadableStream`
+
+With this package, you can construct a `ReadableStream` from an `AsyncIterable` or an `Iterable`.
+
+- spec: https://streams.spec.whatwg.org/#rs-from
+- tests: https://github.com/Sec-ant/readable-stream/blob/main/tests/fromAnyIterable.spec.ts (copied from [wpt](https://github.com/web-platform-tests/wpt/blob/309231a7f3e900d04914bc4963b016efd9989a00/streams/readable-streams/from.any.js))
+
+This package passes all the aforementioned tests.
+
+## Install
+
+```bash
+npm i @sec-ant/readable-stream
+```
+
+## Usage
+
+### Ponyfill
+
+This package can be imported as a _ponyfill_ to avoid side effects:
+
+#### `asyncIterator`
+
+Path:
+
+```
+@sec-ant/readable-stream/ponyfill/asyncIterator
+```
+
+Example:
+
+```ts
+import {
+  asyncIterator,
+  type ReadableStreamIteratorOptions,
+} from "@sec-ant/readable-stream/ponyfill/asyncIterator";
+
+const readableStream = (await fetch("https://www.example.org/")).body;
+
+let total = 0;
+for await (const chunk of asyncIterator.call(readableStream)) {
+  total += chunk.length;
+}
+
+console.log(total);
+```
+
+Check https://streams.spec.whatwg.org/#rs-class-definition and https://streams.spec.whatwg.org/#rs-asynciterator for further explanation on `ReadableStreamIteratorOptions`.
+
+#### `fromAnyIterable`
+
+Path:
+
+```
+@sec-ant/readable-stream/ponyfill/fromAnyIterable
+```
+
+Example:
+
+```ts
+import { fromAnyIterable } from "@sec-ant/readable-stream/ponyfill/fromAnyIterable";
+
+const readableStream = fromAnyIterable(["a", "b"]);
+```
+
+#### All-in-One
+
+Path:
+
+```
+@sec-ant/readable-stream/ponyfill
+```
+
+Example:
+
+```ts
+import {
+  fromAnyIterable,
+  asyncIterator,
+  type ReadableStreamIteratorOptions,
+} from "@sec-ant/readable-stream/ponyfill";
+```
+
+### Polyfill
+
+This package can be imported as a drop-in _polyfill_ with side effects.
+
+#### `ReadableStream.prototype[Symbol.asyncIterator]` and `ReadableStream.prototype.values`
+
+Path:
+
+```
+@sec-ant/readable-stream/polyfill/asyncIterator
+```
+
+Example:
+
+```ts
+import "@sec-ant/readable-stream/polyfill/asyncIterator";
+
+const readableStream = (await fetch("https://www.example.org/")).body;
+
+let total = 0;
+for await (const chunk of readableStream) {
+  total += chunk.length;
+}
+
+console.log(total);
+```
+
+#### `ReadableStream.from`
+
+Path:
+
+```
+@sec-ant/readable-stream/polyfill/fromAnyIterable
+```
+
+Example:
+
+```js
+import "@sec-ant/readable-stream/polyfill/fromAnyIterable";
+
+const readableStream = ReadableStream.from(["a", "b"]);
+```
+
+Note that `ReadableStream.from` is not typed because [declared vars cannot be overridden](https://github.com/microsoft/TypeScript/issues/36146).
+
+#### All-in-One
+
+Path:
+
+```
+@sec-ant/readable-stream/polyfill
+```
+
+Example:
+
+```ts
+import "@sec-ant/readable-stream/polyfill";
+```
+
+### Ponyfill + Polyfill
+
+#### `asyncIterator`
+
+Path:
+
+```
+@sec-ant/readable-stream/asyncIterator
+```
+
+Example:
+
+```ts
+import {
+  asyncIterator,
+  type ReadableStreamIteratorOptions,
+} from "@sec-ant/readable-stream/asyncIterator";
+// also with side effects
+```
+
+#### `fromAnyIterable`
+
+Path:
+
+```
+@sec-ant/readable-stream/fromAnyIterable
+```
+
+Example:
+
+```ts
+import { fromAnyIterable } from "@sec-ant/readable-stream/fromAnyIterable";
+// also with side effects
+```
+
+#### All-in-One
+
+Path:
+
+```
+@sec-ant/readable-stream
+```
+
+Example:
+
+```ts
+import {
+  fromAnyIterable,
+  asyncIterator,
+  type ReadableStreamIteratorOptions,
+} from "@sec-ant/readable-stream";
+// also with side effects
+```
+
+### Types
+
+You can also use this package to augment the `ReadableStream` type for async iteration if the runtime already supports it but the type system does not.
+
+Path:
+
+```
+@sec-ant/readable-stream/async-iterator
+```
+
+Example:
+
+```ts
+/// <reference types="@sec-ant/readable-stream/async-iterator" />
+```
+
+## License
+
+MIT

package/node_modules/@sec-ant/readable-stream/dist/core/asyncIterablePrototype.d.ts

@@ -0,0 +1 @@
+export declare const AsyncIterablePrototype: object;

package/node_modules/@sec-ant/readable-stream/dist/core/asyncIterator.d.ts

@@ -0,0 +1,27 @@
+/**
+ * the implementer that does all the heavy works
+ */
+declare class ReadableStreamAsyncIterableIteratorImpl<R, TReturn> implements AsyncIterator<R> {
+    #private;
+    constructor(reader: ReadableStreamDefaultReader<R>, preventCancel: boolean);
+    next(): Promise<IteratorResult<R, undefined>>;
+    return(value?: TReturn): Promise<IteratorReturnResult<TReturn>>;
+}
+declare const implementSymbol: unique symbol;
+/**
+ * declare `ReadableStreamAsyncIterableIterator` interaface
+ */
+interface ReadableStreamAsyncIterableIterator<R, TReturn> extends AsyncIterableIterator<R> {
+    [implementSymbol]: ReadableStreamAsyncIterableIteratorImpl<R, TReturn>;
+}
+export interface ReadableStreamIteratorOptions {
+    preventCancel?: boolean;
+}
+/**
+ * Get an async iterable iterator from a readable stream
+ * @param this
+ * @param readableStreamIteratorOptions
+ * @returns
+ */
+export declare function asyncIterator<R, TReturn>(this: ReadableStream<R>, { preventCancel }?: ReadableStreamIteratorOptions): ReadableStreamAsyncIterableIterator<R, TReturn>;
+export {};

package/node_modules/@sec-ant/readable-stream/dist/core/fromAnyIterable.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Create a new readable stream from an async iterable or a sync iterable
+ * @param iterable
+ * @returns a readable stream
+ */
+export declare function fromAnyIterable<R>(iterable: Iterable<R> | AsyncIterable<R>): ReadableStream<R>;