akm-cli 0.7.0 → 0.7.1

package/dist/tests/commands/show.test.js

@@ -1,294 +0,0 @@
-import { afterAll, afterEach, beforeEach, describe, expect, test } from "bun:test";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { akmShowUnified as akmShow } from "../../src/commands/show";
-import { saveConfig } from "../../src/core/config";
-// Trigger source-provider self-registration
-import "../../src/sources/providers/index";
-const createdTmpDirs = [];
-function createTmpDir(prefix = "akm-show-") {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    createdTmpDirs.push(dir);
-    return dir;
-}
-function writeFile(filePath, content = "") {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, content);
-}
-afterAll(() => {
-    for (const dir of createdTmpDirs) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-const originalXdgCacheHome = process.env.XDG_CACHE_HOME;
-const originalXdgConfigHome = process.env.XDG_CONFIG_HOME;
-const originalStashDir = process.env.AKM_STASH_DIR;
-let testCacheDir = "";
-let testConfigDir = "";
-let stashDir = "";
-beforeEach(() => {
-    testCacheDir = createTmpDir("akm-show-cache-");
-    testConfigDir = createTmpDir("akm-show-config-");
-    stashDir = createTmpDir("akm-show-stash-");
-    for (const sub of ["scripts", "skills", "commands", "agents", "knowledge"]) {
-        fs.mkdirSync(path.join(stashDir, sub), { recursive: true });
-    }
-    process.env.XDG_CACHE_HOME = testCacheDir;
-    process.env.XDG_CONFIG_HOME = testConfigDir;
-    process.env.AKM_STASH_DIR = stashDir;
-});
-afterEach(() => {
-    if (originalXdgCacheHome === undefined) {
-        delete process.env.XDG_CACHE_HOME;
-    }
-    else {
-        process.env.XDG_CACHE_HOME = originalXdgCacheHome;
-    }
-    if (originalXdgConfigHome === undefined) {
-        delete process.env.XDG_CONFIG_HOME;
-    }
-    else {
-        process.env.XDG_CONFIG_HOME = originalXdgConfigHome;
-    }
-    if (originalStashDir === undefined) {
-        delete process.env.AKM_STASH_DIR;
-    }
-    else {
-        process.env.AKM_STASH_DIR = originalStashDir;
-    }
-    if (testCacheDir) {
-        fs.rmSync(testCacheDir, { recursive: true, force: true });
-        testCacheDir = "";
-    }
-    if (testConfigDir) {
-        fs.rmSync(testConfigDir, { recursive: true, force: true });
-        testConfigDir = "";
-    }
-});
-// ── Installed ref with missing asset ─────────────────────────────────────────
-describe("akmShow installed ref", () => {
-    test("throws with add guidance when origin is not installed", async () => {
-        const installedStashRoot = createTmpDir("akm-show-installed-root-");
-        // Create the type subdirectory so it is a valid stash root, but do NOT
-        // create the actual asset file.
-        fs.mkdirSync(path.join(installedStashRoot, "scripts"), { recursive: true });
-        saveConfig({
-            semanticSearchMode: "off",
-            installed: [
-                {
-                    id: "test-pkg",
-                    source: "npm",
-                    ref: "test-pkg",
-                    artifactUrl: "https://example.com/test-pkg.tgz",
-                    stashRoot: installedStashRoot,
-                    cacheDir: installedStashRoot,
-                    installedAt: new Date().toISOString(),
-                },
-            ],
-        });
-        // Use an origin that is NOT installed so resolveSourcesForOrigin returns
-        // empty, triggering the add-guidance error path.
-        await expect(akmShow({ ref: "npm:@other/missing-pkg//script:missing.sh" })).rejects.toThrow(/akm add/);
-    });
-    test("resolves installed-stash style nested agent refs", async () => {
-        const installedStashRoot = createTmpDir("akm-show-installed-agent-");
-        writeFile(path.join(installedStashRoot, "tools", "agents", "svelte-file-editor.md"), ["---", "name: svelte-file-editor", "description: Svelte editor", "---", "Use Svelte tools."].join("\n"));
-        saveConfig({
-            semanticSearchMode: "off",
-            installed: [
-                {
-                    id: "github:sveltejs/ai-tools",
-                    source: "github",
-                    ref: "github:sveltejs/ai-tools",
-                    artifactUrl: "https://example.com/svelte-tools.tgz",
-                    stashRoot: installedStashRoot,
-                    cacheDir: installedStashRoot,
-                    installedAt: new Date().toISOString(),
-                },
-            ],
-        });
-        const result = await akmShow({ ref: "github:sveltejs/ai-tools//agent:tools/agents/svelte-file-editor" });
-        expect(result.type).toBe("agent");
-        expect(result.origin).toBe("github:sveltejs/ai-tools");
-        expect(result.path).toContain(path.join("tools", "agents", "svelte-file-editor.md"));
-        expect(result.prompt).toContain("Use Svelte tools.");
-    });
-    test("resolves installed-stash style nested skill refs", async () => {
-        const installedStashRoot = createTmpDir("akm-show-installed-skill-");
-        writeFile(path.join(installedStashRoot, "tools", "skills", "svelte-code-writer", "SKILL.md"), ["---", "name: svelte-code-writer", "description: Svelte writer", "---", "# Svelte writer"].join("\n"));
-        saveConfig({
-            semanticSearchMode: "off",
-            installed: [
-                {
-                    id: "github:sveltejs/ai-tools",
-                    source: "github",
-                    ref: "github:sveltejs/ai-tools",
-                    artifactUrl: "https://example.com/svelte-tools.tgz",
-                    stashRoot: installedStashRoot,
-                    cacheDir: installedStashRoot,
-                    installedAt: new Date().toISOString(),
-                },
-            ],
-        });
-        const result = await akmShow({ ref: "github:sveltejs/ai-tools//skill:tools/skills/svelte-code-writer" });
-        expect(result.type).toBe("skill");
-        expect(result.origin).toBe("github:sveltejs/ai-tools");
-        expect(result.path).toContain(path.join("tools", "skills", "svelte-code-writer", "SKILL.md"));
-        expect(result.content).toContain("# Svelte writer");
-    });
-});
-// ── Search path resolution ───────────────────────────────────────────────────
-describe("akmShow search path", () => {
-    test("resolves from search path directories", async () => {
-        const searchPathDir = createTmpDir("akm-show-searchpath-");
-        writeFile(path.join(searchPathDir, "scripts", "deploy.sh"), "#!/usr/bin/env bash\necho deploy\n");
-        saveConfig({ semanticSearchMode: "off", sources: [{ type: "filesystem", path: searchPathDir }] });
-        const result = await akmShow({ ref: "script:deploy.sh" });
-        expect(result.type).toBe("script");
-        expect(result.name).toBe("deploy.sh");
-        expect(result.path).toContain(searchPathDir);
-    });
-});
-// ── editability flags ────────────────────────────────────────────────────────
-describe("akmShow editability", () => {
-    test("working stash asset has editable true", async () => {
-        writeFile(path.join(stashDir, "scripts", "local.sh"), "#!/usr/bin/env bash\necho local\n");
-        saveConfig({ semanticSearchMode: "off" });
-        const result = await akmShow({ ref: "script:local.sh" });
-        expect(result.type).toBe("script");
-        expect(result.origin).toBeNull();
-        expect(result.action).toContain("Execute the run command");
-        expect(result.editable).toBe(true);
-        expect(result.editHint).toBeUndefined();
-    });
-    test("search path asset has editable true", async () => {
-        const searchPathDir = createTmpDir("akm-show-searchpath-editable-");
-        writeFile(path.join(searchPathDir, "scripts", "remote.sh"), "#!/usr/bin/env bash\necho remote\n");
-        saveConfig({ semanticSearchMode: "off", sources: [{ type: "filesystem", path: searchPathDir }] });
-        const result = await akmShow({ ref: "script:remote.sh" });
-        expect(result.type).toBe("script");
-        expect(result.origin).toBeNull();
-        expect(result.editable).toBe(true);
-        expect(result.editHint).toBeUndefined();
-    });
-    test("installed (cache-managed) asset has editable false with editHint", async () => {
-        const installedStashRoot = createTmpDir("akm-show-installed-resolve-");
-        writeFile(path.join(installedStashRoot, "scripts", "deploy.sh"), "#!/usr/bin/env bash\necho deploy\n");
-        saveConfig({
-            semanticSearchMode: "off",
-            installed: [
-                {
-                    id: "installed-pkg",
-                    source: "npm",
-                    ref: "npm:installed-pkg",
-                    artifactUrl: "https://example.com/installed-pkg.tgz",
-                    stashRoot: installedStashRoot,
-                    cacheDir: installedStashRoot,
-                    installedAt: new Date().toISOString(),
-                },
-            ],
-        });
-        const result = await akmShow({ ref: "script:deploy.sh" });
-        expect(result.type).toBe("script");
-        expect(result.origin).toBe("installed-pkg");
-        expect(result.editable).toBe(false);
-        expect(result.editHint).toContain("akm clone");
-        expect(result.editHint).toContain("script:deploy.sh");
-    });
-});
-// ── Content-based classification via new renderer pipeline ─────────────────
-describe("akmShow content-based classification", () => {
-    test("model alone in commands/ stays a command (directory wins over weak agent signal)", async () => {
-        // model is shared frontmatter (OpenCode convention). In commands/,
-        // the directory matcher (specificity 10) beats the model-only agent
-        // signal (specificity 8), so this stays a command.
-        writeFile(path.join(stashDir, "commands", "deploy.md"), ["---", "model: gpt-4", "description: Deploy command", "---", "Deploy $ARGUMENTS."].join("\n"));
-        saveConfig({ semanticSearchMode: "off" });
-        const result = await akmShow({ ref: "command:deploy.md" });
-        expect(result.type).toBe("command");
-        expect(result.template).toBe("Deploy $ARGUMENTS.");
-        expect(result.modelHint).toBe("gpt-4");
-        expect(result.parameters).toEqual(["ARGUMENTS"]);
-    });
-    test("tools frontmatter in commands/ overrides to agent (strong signal)", async () => {
-        // tools/toolPolicy are agent-exclusive signals at specificity 20,
-        // which beats the commands/ directory matcher at 10.
-        writeFile(path.join(stashDir, "commands", "hybrid.md"), ["---", "tools:", "  read: allow", "model: gpt-4", "---", "You are a hybrid agent."].join("\n"));
-        saveConfig({ semanticSearchMode: "off" });
-        const result = await akmShow({ ref: "command:hybrid.md" });
-        expect(result.type).toBe("agent");
-        expect(result.action).toContain("verbatim");
-        expect(result.prompt).toContain("You are a hybrid agent.");
-    });
-    test("command in commands/ directory extracts OpenCode-style frontmatter", async () => {
-        writeFile(path.join(stashDir, "commands", "deploy.md"), [
-            "---",
-            "description: Deploy to production",
-            "model: claude-sonnet-4-20250514",
-            "agent: build",
-            "---",
-            "Deploy $ARGUMENTS to production.",
-        ].join("\n"));
-        saveConfig({ semanticSearchMode: "off" });
-        const result = await akmShow({ ref: "command:deploy.md" });
-        expect(result.type).toBe("command");
-        expect(result.template).toBe("Deploy $ARGUMENTS to production.");
-        expect(result.description).toBe("Deploy to production");
-        expect(result.modelHint).toBe("claude-sonnet-4-20250514");
-        expect(result.agent).toBe("build");
-        expect(result.parameters).toEqual(["ARGUMENTS"]);
-    });
-    test("command parameter extraction includes positional placeholders", async () => {
-        writeFile(path.join(stashDir, "commands", "positional.md"), ["---", "description: Positional args", "---", "Run release $1 with notes from $2 and flag $9."].join("\n"));
-        saveConfig({ semanticSearchMode: "off" });
-        const result = await akmShow({ ref: "command:positional.md" });
-        expect(result.type).toBe("command");
-        expect(result.parameters).toEqual(["$1", "$2", "$9"]);
-    });
-    test("command parameter extraction includes named placeholders", async () => {
-        writeFile(path.join(stashDir, "commands", "named.md"), ["---", "description: Named args", "---", "Deploy {{env}} with {{version}} using {{env}} again."].join("\n"));
-        saveConfig({ semanticSearchMode: "off" });
-        const result = await akmShow({ ref: "command:named.md" });
-        expect(result.type).toBe("command");
-        expect(result.parameters).toEqual(["env", "version"]);
-    });
-    test("script in scripts/ directory uses new renderer pipeline", async () => {
-        writeFile(path.join(stashDir, "scripts", "build.sh"), "#!/usr/bin/env bash\necho build\n");
-        saveConfig({ semanticSearchMode: "off" });
-        const result = await akmShow({ ref: "script:build.sh" });
-        expect(result.type).toBe("script");
-        expect(result.run).toBeDefined();
-        expect(result.run).toContain("bash");
-    });
-    test("$ARGUMENTS in body classifies .md as command even outside commands/", async () => {
-        writeFile(path.join(stashDir, "knowledge", "deploy-cmd.md"), ["---", "description: Deploy helper", "---", "Deploy $ARGUMENTS to staging."].join("\n"));
-        saveConfig({ semanticSearchMode: "off" });
-        // $ARGUMENTS placeholder (specificity 18) beats knowledge/ directory hint (10)
-        const result = await akmShow({ ref: "knowledge:deploy-cmd.md" });
-        expect(result.type).toBe("command");
-        expect(result.template).toBe("Deploy $ARGUMENTS to staging.");
-        expect(result.description).toBe("Deploy helper");
-    });
-    test("agent frontmatter classifies .md as command even outside commands/", async () => {
-        writeFile(path.join(stashDir, "agents", "build-cmd.md"), ["---", "agent: build", "description: Build dispatch", "---", "Build the project."].join("\n"));
-        saveConfig({ semanticSearchMode: "off" });
-        // agent frontmatter (specificity 18) beats agents/ directory hint (15)
-        const result = await akmShow({ ref: "agent:build-cmd.md" });
-        expect(result.type).toBe("command");
-        expect(result.template).toBe("Build the project.");
-        expect(result.agent).toBe("build");
-    });
-    test("knowledge view modes work through new renderer pipeline", async () => {
-        writeFile(path.join(stashDir, "knowledge", "guide.md"), ["# Intro", "Welcome.", "", "## Setup", "Install things.", "", "## Usage", "Use things."].join("\n"));
-        saveConfig({ semanticSearchMode: "off" });
-        const tocResult = await akmShow({ ref: "knowledge:guide.md", view: { mode: "toc" } });
-        expect(tocResult.content).toContain("Intro");
-        expect(tocResult.content).toContain("Setup");
-        const sectionResult = await akmShow({
-            ref: "knowledge:guide.md",
-            view: { mode: "section", heading: "Setup" },
-        });
-        expect(sectionResult.content).toContain("Install things.");
-    });
-});

package/dist/tests/common.test.js

@@ -1,266 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { hasErrnoCode, isAssetType, isWithin, jsonWithByteCap, ResponseTooLargeError, readBodyWithByteCap, resolveStashDir, toPosix, } from "../src/core/common";
-// ── resolveStashDir ──────────────────────────────────────────────────────────
-describe("resolveStashDir", () => {
-    const origEnv = process.env.AKM_STASH_DIR;
-    const origXdgConfigHome = process.env.XDG_CONFIG_HOME;
-    const origHome = process.env.HOME;
-    let testConfigHome;
-    beforeEach(() => {
-        testConfigHome = fs.mkdtempSync(path.join(os.tmpdir(), "akm-common-test-config-"));
-        process.env.XDG_CONFIG_HOME = testConfigHome;
-    });
-    afterEach(() => {
-        if (origEnv === undefined) {
-            delete process.env.AKM_STASH_DIR;
-        }
-        else {
-            process.env.AKM_STASH_DIR = origEnv;
-        }
-        if (origXdgConfigHome === undefined) {
-            delete process.env.XDG_CONFIG_HOME;
-        }
-        else {
-            process.env.XDG_CONFIG_HOME = origXdgConfigHome;
-        }
-        if (origHome === undefined) {
-            delete process.env.HOME;
-        }
-        else {
-            process.env.HOME = origHome;
-        }
-        if (testConfigHome) {
-            fs.rmSync(testConfigHome, { recursive: true, force: true });
-        }
-    });
-    test("throws when no stash dir is configured and default does not exist", () => {
-        delete process.env.AKM_STASH_DIR;
-        // Point HOME to a tmp dir without an akm subdirectory
-        const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "akm-common-test-home-"));
-        process.env.HOME = tmpHome;
-        try {
-            expect(() => resolveStashDir()).toThrow("No stash directory found");
-        }
-        finally {
-            fs.rmSync(tmpHome, { recursive: true, force: true });
-        }
-    });
-    test("throws when AKM_STASH_DIR points to nonexistent path", () => {
-        process.env.AKM_STASH_DIR = "/nonexistent/path/that/does/not/exist";
-        expect(() => resolveStashDir()).toThrow("Unable to read");
-    });
-    test("throws when AKM_STASH_DIR path is a file, not a directory", () => {
-        const tmpFile = path.join(os.tmpdir(), `akm-common-test-file-${Date.now()}`);
-        fs.writeFileSync(tmpFile, "not a directory");
-        try {
-            process.env.AKM_STASH_DIR = tmpFile;
-            expect(() => resolveStashDir()).toThrow("must point to a directory");
-        }
-        finally {
-            fs.unlinkSync(tmpFile);
-        }
-    });
-    test("returns resolved path for valid AKM_STASH_DIR", () => {
-        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "akm-common-test-"));
-        try {
-            process.env.AKM_STASH_DIR = tmpDir;
-            const result = resolveStashDir();
-            expect(result).toBe(path.resolve(tmpDir));
-        }
-        finally {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-    });
-    test("reads stashDir from config.json when env var is not set", () => {
-        delete process.env.AKM_STASH_DIR;
-        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "akm-common-test-stash-"));
-        try {
-            const configDir = path.join(testConfigHome, "akm");
-            fs.mkdirSync(configDir, { recursive: true });
-            fs.writeFileSync(path.join(configDir, "config.json"), JSON.stringify({ stashDir: tmpDir }));
-            const result = resolveStashDir();
-            expect(result).toBe(path.resolve(tmpDir));
-        }
-        finally {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-    });
-    test("uses default stash dir when it exists", () => {
-        delete process.env.AKM_STASH_DIR;
-        const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "akm-common-test-home-"));
-        const defaultStash = path.join(tmpHome, "akm");
-        fs.mkdirSync(defaultStash, { recursive: true });
-        process.env.HOME = tmpHome;
-        try {
-            const result = resolveStashDir();
-            expect(result).toBe(defaultStash);
-        }
-        finally {
-            fs.rmSync(tmpHome, { recursive: true, force: true });
-        }
-    });
-    test("env var takes precedence over config.json stashDir", () => {
-        const envDir = fs.mkdtempSync(path.join(os.tmpdir(), "akm-common-test-env-"));
-        const configDir = fs.mkdtempSync(path.join(os.tmpdir(), "akm-common-test-cfg-"));
-        try {
-            process.env.AKM_STASH_DIR = envDir;
-            const configRoot = path.join(testConfigHome, "akm");
-            fs.mkdirSync(configRoot, { recursive: true });
-            fs.writeFileSync(path.join(configRoot, "config.json"), JSON.stringify({ stashDir: configDir }));
-            const result = resolveStashDir();
-            expect(result).toBe(path.resolve(envDir));
-        }
-        finally {
-            fs.rmSync(envDir, { recursive: true, force: true });
-            fs.rmSync(configDir, { recursive: true, force: true });
-        }
-    });
-});
-// ── toPosix ──────────────────────────────────────────────────────────────────
-describe("toPosix", () => {
-    test("already-posix paths are unchanged", () => {
-        expect(toPosix("foo/bar/baz")).toBe("foo/bar/baz");
-    });
-    test("backslash paths are converted to forward slashes", () => {
-        expect(toPosix("foo\\bar\\baz")).toBe("foo/bar/baz");
-    });
-    test("mixed separators are normalized", () => {
-        expect(toPosix("foo\\bar/baz")).toBe("foo/bar/baz");
-    });
-    test("empty string returns empty string", () => {
-        expect(toPosix("")).toBe("");
-    });
-});
-// ── hasErrnoCode ─────────────────────────────────────────────────────────────
-describe("hasErrnoCode", () => {
-    test("returns true for error with matching code", () => {
-        const err = Object.assign(new Error("fail"), { code: "ENOENT" });
-        expect(hasErrnoCode(err, "ENOENT")).toBe(true);
-    });
-    test("returns false for error with non-matching code", () => {
-        const err = Object.assign(new Error("fail"), { code: "EACCES" });
-        expect(hasErrnoCode(err, "ENOENT")).toBe(false);
-    });
-    test("returns false for string error", () => {
-        expect(hasErrnoCode("some string error", "ENOENT")).toBe(false);
-    });
-    test("returns false for null", () => {
-        expect(hasErrnoCode(null, "ENOENT")).toBe(false);
-    });
-    test("returns false for object without code property", () => {
-        expect(hasErrnoCode({ message: "fail" }, "ENOENT")).toBe(false);
-    });
-    test("returns false for undefined", () => {
-        expect(hasErrnoCode(undefined, "ENOENT")).toBe(false);
-    });
-});
-// ── isAssetType ──────────────────────────────────────────────────────────────
-describe("isAssetType", () => {
-    test("returns true for all valid types", () => {
-        expect(isAssetType("skill")).toBe(true);
-        expect(isAssetType("command")).toBe(true);
-        expect(isAssetType("agent")).toBe(true);
-        expect(isAssetType("knowledge")).toBe(true);
-        expect(isAssetType("script")).toBe(true);
-    });
-    test("returns false for invalid strings", () => {
-        expect(isAssetType("widget")).toBe(false);
-        expect(isAssetType("")).toBe(false);
-        expect(isAssetType("tool")).toBe(false);
-        expect(isAssetType("plugin")).toBe(false);
-    });
-});
-// ── isWithin ────────────────────────────────────────────────────────────────
-describe("isWithin", () => {
-    test("returns true for path inside root", () => {
-        expect(isWithin("/root/sub/file.txt", "/root")).toBe(true);
-    });
-    test("returns true for path equal to root", () => {
-        expect(isWithin("/root", "/root")).toBe(true);
-    });
-    test("returns false for path outside root", () => {
-        expect(isWithin("/other/file.txt", "/root")).toBe(false);
-    });
-    test("returns false for parent traversal", () => {
-        expect(isWithin("/root/../etc/passwd", "/root")).toBe(false);
-    });
-    test("returns true for nested subdirectory", () => {
-        expect(isWithin("/root/a/b/c/d.txt", "/root")).toBe(true);
-    });
-    test("returns false for sibling directory with similar prefix", () => {
-        expect(isWithin("/root-other/file.txt", "/root")).toBe(false);
-    });
-});
-// ── readBodyWithByteCap / jsonWithByteCap ────────────────────────────────────
-describe("readBodyWithByteCap", () => {
-    function makeResponse(body, init) {
-        const res = new Response(body, { headers: init?.headers });
-        if (init?.url)
-            Object.defineProperty(res, "url", { value: init.url });
-        return res;
-    }
-    test("reads small bodies verbatim", async () => {
-        const text = await readBodyWithByteCap(makeResponse("hello world"), 1024);
-        expect(text).toBe("hello world");
-    });
-    test("handles empty bodies", async () => {
-        const text = await readBodyWithByteCap(makeResponse(""), 1024);
-        expect(text).toBe("");
-    });
-    test("refuses before reading if Content-Length exceeds cap", async () => {
-        const body = "x".repeat(1000);
-        const response = makeResponse(body, {
-            headers: { "content-length": "1000" },
-            url: "http://example.invalid/too-big",
-        });
-        await expect(readBodyWithByteCap(response, 100)).rejects.toBeInstanceOf(ResponseTooLargeError);
-    });
-    test("aborts mid-stream when Content-Length is absent but body exceeds cap", async () => {
-        const stream = new ReadableStream({
-            start(controller) {
-                // 5 chunks of 1000 bytes each = 5000 bytes; cap at 2500.
-                for (let i = 0; i < 5; i++) {
-                    controller.enqueue(new TextEncoder().encode("x".repeat(1000)));
-                }
-                controller.close();
-            },
-        });
-        const response = new Response(stream);
-        await expect(readBodyWithByteCap(response, 2500)).rejects.toBeInstanceOf(ResponseTooLargeError);
-    });
-    test("accepts body right at the cap", async () => {
-        const body = "x".repeat(100);
-        const text = await readBodyWithByteCap(makeResponse(body), 100);
-        expect(text.length).toBe(100);
-    });
-    test("decodes multi-chunk UTF-8 bodies correctly", async () => {
-        const stream = new ReadableStream({
-            start(controller) {
-                controller.enqueue(new TextEncoder().encode("hello "));
-                controller.enqueue(new TextEncoder().encode("world"));
-                controller.close();
-            },
-        });
-        const response = new Response(stream);
-        const text = await readBodyWithByteCap(response, 1024);
-        expect(text).toBe("hello world");
-    });
-});
-describe("jsonWithByteCap", () => {
-    test("parses small JSON bodies", async () => {
-        const data = await jsonWithByteCap(new Response(JSON.stringify({ hello: "world" })), 1024);
-        expect(data.hello).toBe("world");
-    });
-    test("rejects oversized JSON before parse", async () => {
-        const big = JSON.stringify({ data: "x".repeat(2000) });
-        const response = new Response(big, { headers: { "content-length": String(big.length) } });
-        await expect(jsonWithByteCap(response, 500)).rejects.toBeInstanceOf(ResponseTooLargeError);
-    });
-    test("propagates JSON.parse errors for malformed input", async () => {
-        const response = new Response("{not json");
-        await expect(jsonWithByteCap(response, 1024)).rejects.toThrow();
-    });
-});