@wingman-ai/gateway 0.1.0

package/dist/tests/bunSqliteAdapter.test.cjs

@@ -0,0 +1,265 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const promises_namespaceObject = require("node:fs/promises");
+const isBun = void 0 !== globalThis.Bun;
+const describeIfBun = isBun ? external_vitest_namespaceObject.describe : external_vitest_namespaceObject.describe.skip;
+describeIfBun("BunSqliteAdapter", ()=>{
+    const testDbPath = "./test-adapter.db";
+    let BunSqliteAdapter;
+    let Database;
+    let adapter;
+    (0, external_vitest_namespaceObject.beforeAll)(async ()=>{
+        const module = await import("../cli/core/database/bunSqliteAdapter.cjs");
+        BunSqliteAdapter = module.BunSqliteAdapter;
+        const sqliteModule = await import("bun:sqlite");
+        Database = sqliteModule.Database;
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        adapter = new BunSqliteAdapter(testDbPath);
+    });
+    (0, external_vitest_namespaceObject.afterEach)(async ()=>{
+        try {
+            adapter.close();
+            await (0, promises_namespaceObject.unlink)(testDbPath);
+        } catch  {}
+    });
+    (0, external_vitest_namespaceObject.describe)("constructor", ()=>{
+        (0, external_vitest_namespaceObject.it)("should create adapter from file path", ()=>{
+            (0, external_vitest_namespaceObject.expect)(adapter).toBeDefined();
+        });
+        (0, external_vitest_namespaceObject.it)("should create adapter from existing Database instance", ()=>{
+            const db = new Database(":memory:");
+            const memAdapter = new BunSqliteAdapter(db);
+            (0, external_vitest_namespaceObject.expect)(memAdapter).toBeDefined();
+            memAdapter.close();
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("exec and run", ()=>{
+        (0, external_vitest_namespaceObject.it)("should execute SQL statements to create tables via exec", ()=>{
+            const result = adapter.exec(`
+        CREATE TABLE users (
+          id INTEGER PRIMARY KEY,
+          name TEXT NOT NULL
+        );
+      `);
+            (0, external_vitest_namespaceObject.expect)(result).toBeDefined();
+        });
+        (0, external_vitest_namespaceObject.it)("should execute SQL statements to create tables via run", ()=>{
+            const result = adapter.run(`
+        CREATE TABLE posts (
+          id INTEGER PRIMARY KEY,
+          content TEXT NOT NULL
+        );
+      `);
+            (0, external_vitest_namespaceObject.expect)(result).toBeDefined();
+        });
+        (0, external_vitest_namespaceObject.it)("should create multiple tables in one exec call", ()=>{
+            adapter.exec(`
+        CREATE TABLE accounts (id INTEGER PRIMARY KEY, name TEXT);
+        CREATE TABLE transactions (id INTEGER PRIMARY KEY, account_id INTEGER);
+      `);
+            const stmt = adapter.prepare("INSERT INTO accounts (name) VALUES (?)");
+            const result = stmt.run("Alice");
+            (0, external_vitest_namespaceObject.expect)(result).toBeDefined();
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("prepare and run", ()=>{
+        (0, external_vitest_namespaceObject.beforeEach)(()=>{
+            adapter.exec(`
+        CREATE TABLE users (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          name TEXT NOT NULL,
+          email TEXT
+        );
+      `);
+        });
+        (0, external_vitest_namespaceObject.it)("should prepare and execute INSERT statement", ()=>{
+            const stmt = adapter.prepare("INSERT INTO users (name, email) VALUES (?, ?)");
+            const result = stmt.run("John Doe", "john@example.com");
+            (0, external_vitest_namespaceObject.expect)(result).toBeDefined();
+            (0, external_vitest_namespaceObject.expect)(result.changes).toBe(1);
+        });
+        (0, external_vitest_namespaceObject.it)("should prepare and execute UPDATE statement", ()=>{
+            const insertStmt = adapter.prepare("INSERT INTO users (name) VALUES (?)");
+            insertStmt.run("Jane");
+            const updateStmt = adapter.prepare("UPDATE users SET name = ? WHERE name = ?");
+            const result = updateStmt.run("Jane Doe", "Jane");
+            (0, external_vitest_namespaceObject.expect)(result.changes).toBe(1);
+        });
+        (0, external_vitest_namespaceObject.it)("should prepare and execute DELETE statement", ()=>{
+            const insertStmt = adapter.prepare("INSERT INTO users (name) VALUES (?)");
+            insertStmt.run("User1");
+            insertStmt.run("User2");
+            const deleteStmt = adapter.prepare("DELETE FROM users WHERE name = ?");
+            const result = deleteStmt.run("User1");
+            (0, external_vitest_namespaceObject.expect)(result.changes).toBe(1);
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("prepare and get", ()=>{
+        (0, external_vitest_namespaceObject.beforeEach)(()=>{
+            adapter.exec(`
+        CREATE TABLE users (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          name TEXT NOT NULL,
+          age INTEGER
+        );
+      `);
+            const stmt = adapter.prepare("INSERT INTO users (name, age) VALUES (?, ?)");
+            stmt.run("Alice", 30);
+            stmt.run("Bob", 25);
+        });
+        (0, external_vitest_namespaceObject.it)("should get a single row", ()=>{
+            const stmt = adapter.prepare("SELECT * FROM users WHERE name = ?");
+            const row = stmt.get("Alice");
+            (0, external_vitest_namespaceObject.expect)(row).toBeDefined();
+            (0, external_vitest_namespaceObject.expect)(row.name).toBe("Alice");
+            (0, external_vitest_namespaceObject.expect)(row.age).toBe(30);
+        });
+        (0, external_vitest_namespaceObject.it)("should return undefined for non-existent row", ()=>{
+            const stmt = adapter.prepare("SELECT * FROM users WHERE name = ?");
+            const row = stmt.get("NonExistent");
+            (0, external_vitest_namespaceObject.expect)(row).toBeUndefined();
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("prepare and all", ()=>{
+        (0, external_vitest_namespaceObject.beforeEach)(()=>{
+            adapter.exec(`
+        CREATE TABLE users (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          name TEXT NOT NULL,
+          active INTEGER DEFAULT 1
+        );
+      `);
+            const stmt = adapter.prepare("INSERT INTO users (name, active) VALUES (?, ?)");
+            stmt.run("Alice", 1);
+            stmt.run("Bob", 1);
+            stmt.run("Charlie", 0);
+        });
+        (0, external_vitest_namespaceObject.it)("should get all matching rows", ()=>{
+            const stmt = adapter.prepare("SELECT * FROM users WHERE active = ?");
+            const rows = stmt.all(1);
+            (0, external_vitest_namespaceObject.expect)(rows).toHaveLength(2);
+            (0, external_vitest_namespaceObject.expect)(rows[0].name).toBe("Alice");
+            (0, external_vitest_namespaceObject.expect)(rows[1].name).toBe("Bob");
+        });
+        (0, external_vitest_namespaceObject.it)("should return empty array when no matches", ()=>{
+            const stmt = adapter.prepare("SELECT * FROM users WHERE name = ?");
+            const rows = stmt.all("Nobody");
+            (0, external_vitest_namespaceObject.expect)(rows).toHaveLength(0);
+        });
+        (0, external_vitest_namespaceObject.it)("should get all rows without parameters", ()=>{
+            const stmt = adapter.prepare("SELECT * FROM users");
+            const rows = stmt.all();
+            (0, external_vitest_namespaceObject.expect)(rows).toHaveLength(3);
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("transaction", ()=>{
+        (0, external_vitest_namespaceObject.beforeEach)(()=>{
+            adapter.exec(`
+        CREATE TABLE accounts (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          name TEXT NOT NULL,
+          balance INTEGER DEFAULT 0
+        );
+      `);
+        });
+        (0, external_vitest_namespaceObject.it)("should execute transaction successfully", ()=>{
+            const insertMany = adapter.transaction((names)=>{
+                const stmt = adapter.prepare("INSERT INTO accounts (name, balance) VALUES (?, ?)");
+                for (const name of names)stmt.run(name, 100);
+            });
+            insertMany([
+                "Alice",
+                "Bob",
+                "Charlie"
+            ]);
+            const stmt = adapter.prepare("SELECT COUNT(*) as count FROM accounts");
+            const result = stmt.get();
+            (0, external_vitest_namespaceObject.expect)(result.count).toBe(3);
+        });
+        (0, external_vitest_namespaceObject.it)("should rollback transaction on error", ()=>{
+            const failedTransaction = adapter.transaction(()=>{
+                const stmt = adapter.prepare("INSERT INTO accounts (name, balance) VALUES (?, ?)");
+                stmt.run("Alice", 100);
+                throw new Error("Transaction failed");
+            });
+            (0, external_vitest_namespaceObject.expect)(()=>failedTransaction()).toThrow("Transaction failed");
+            const stmt = adapter.prepare("SELECT COUNT(*) as count FROM accounts");
+            const result = stmt.get();
+            (0, external_vitest_namespaceObject.expect)(result.count).toBe(0);
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("pragma", ()=>{
+        (0, external_vitest_namespaceObject.it)("should execute pragma statements", ()=>{
+            const result = adapter.pragma("journal_mode", true);
+            (0, external_vitest_namespaceObject.expect)(result).toBeDefined();
+        });
+        (0, external_vitest_namespaceObject.it)("should return pragma result without simplify", ()=>{
+            const result = adapter.pragma("journal_mode", false);
+            (0, external_vitest_namespaceObject.expect)(result).toBeDefined();
+            (0, external_vitest_namespaceObject.expect)(typeof result).toBe("object");
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("close", ()=>{
+        (0, external_vitest_namespaceObject.it)("should close database connection", ()=>{
+            const tempDb = new BunSqliteAdapter(":memory:");
+            (0, external_vitest_namespaceObject.expect)(()=>tempDb.close()).not.toThrow();
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("inTransaction", ()=>{
+        (0, external_vitest_namespaceObject.it)("should return false by default", ()=>{
+            (0, external_vitest_namespaceObject.expect)(adapter.inTransaction).toBe(false);
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("SqliteSaver compatibility", ()=>{
+        (0, external_vitest_namespaceObject.it)("should be compatible with LangGraph checkpoint operations", ()=>{
+            adapter.exec(`
+        CREATE TABLE checkpoints (
+          thread_id TEXT NOT NULL,
+          checkpoint_ns TEXT NOT NULL DEFAULT '',
+          checkpoint_id TEXT NOT NULL,
+          parent_checkpoint_id TEXT,
+          type TEXT,
+          checkpoint BLOB NOT NULL,
+          metadata BLOB NOT NULL,
+          PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id)
+        );
+
+        CREATE TABLE checkpoint_writes (
+          thread_id TEXT NOT NULL,
+          checkpoint_ns TEXT NOT NULL DEFAULT '',
+          checkpoint_id TEXT NOT NULL,
+          task_id TEXT NOT NULL,
+          idx INTEGER NOT NULL,
+          channel TEXT NOT NULL,
+          type TEXT,
+          value BLOB,
+          PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id, task_id, idx)
+        );
+      `);
+            const insertStmt = adapter.prepare(`
+        INSERT INTO checkpoints (thread_id, checkpoint_id, checkpoint, metadata)
+        VALUES (?, ?, ?, ?)
+      `);
+            const result = insertStmt.run("thread-1", "checkpoint-1", JSON.stringify({
+                data: "test"
+            }), JSON.stringify({
+                version: 1
+            }));
+            (0, external_vitest_namespaceObject.expect)(result.changes).toBe(1);
+            const selectStmt = adapter.prepare("SELECT * FROM checkpoints WHERE thread_id = ?");
+            const row = selectStmt.get("thread-1");
+            (0, external_vitest_namespaceObject.expect)(row).toBeDefined();
+            (0, external_vitest_namespaceObject.expect)(row.thread_id).toBe("thread-1");
+            (0, external_vitest_namespaceObject.expect)(row.checkpoint_id).toBe("checkpoint-1");
+            const deleteStmt = adapter.prepare("DELETE FROM checkpoints WHERE thread_id = ?");
+            const deleteResult = deleteStmt.run("thread-1");
+            (0, external_vitest_namespaceObject.expect)(deleteResult.changes).toBe(1);
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/bunSqliteAdapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/bunSqliteAdapter.test.js

@@ -0,0 +1,259 @@
+import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { unlink } from "node:fs/promises";
+const isBun = void 0 !== globalThis.Bun;
+const describeIfBun = isBun ? describe : describe.skip;
+describeIfBun("BunSqliteAdapter", ()=>{
+    const testDbPath = "./test-adapter.db";
+    let BunSqliteAdapter;
+    let Database;
+    let adapter;
+    beforeAll(async ()=>{
+        const module = await import("../cli/core/database/bunSqliteAdapter.js");
+        BunSqliteAdapter = module.BunSqliteAdapter;
+        const sqliteModule = await import("bun:sqlite");
+        Database = sqliteModule.Database;
+    });
+    beforeEach(()=>{
+        adapter = new BunSqliteAdapter(testDbPath);
+    });
+    afterEach(async ()=>{
+        try {
+            adapter.close();
+            await unlink(testDbPath);
+        } catch  {}
+    });
+    describe("constructor", ()=>{
+        it("should create adapter from file path", ()=>{
+            expect(adapter).toBeDefined();
+        });
+        it("should create adapter from existing Database instance", ()=>{
+            const db = new Database(":memory:");
+            const memAdapter = new BunSqliteAdapter(db);
+            expect(memAdapter).toBeDefined();
+            memAdapter.close();
+        });
+    });
+    describe("exec and run", ()=>{
+        it("should execute SQL statements to create tables via exec", ()=>{
+            const result = adapter.exec(`
+        CREATE TABLE users (
+          id INTEGER PRIMARY KEY,
+          name TEXT NOT NULL
+        );
+      `);
+            expect(result).toBeDefined();
+        });
+        it("should execute SQL statements to create tables via run", ()=>{
+            const result = adapter.run(`
+        CREATE TABLE posts (
+          id INTEGER PRIMARY KEY,
+          content TEXT NOT NULL
+        );
+      `);
+            expect(result).toBeDefined();
+        });
+        it("should create multiple tables in one exec call", ()=>{
+            adapter.exec(`
+        CREATE TABLE accounts (id INTEGER PRIMARY KEY, name TEXT);
+        CREATE TABLE transactions (id INTEGER PRIMARY KEY, account_id INTEGER);
+      `);
+            const stmt = adapter.prepare("INSERT INTO accounts (name) VALUES (?)");
+            const result = stmt.run("Alice");
+            expect(result).toBeDefined();
+        });
+    });
+    describe("prepare and run", ()=>{
+        beforeEach(()=>{
+            adapter.exec(`
+        CREATE TABLE users (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          name TEXT NOT NULL,
+          email TEXT
+        );
+      `);
+        });
+        it("should prepare and execute INSERT statement", ()=>{
+            const stmt = adapter.prepare("INSERT INTO users (name, email) VALUES (?, ?)");
+            const result = stmt.run("John Doe", "john@example.com");
+            expect(result).toBeDefined();
+            expect(result.changes).toBe(1);
+        });
+        it("should prepare and execute UPDATE statement", ()=>{
+            const insertStmt = adapter.prepare("INSERT INTO users (name) VALUES (?)");
+            insertStmt.run("Jane");
+            const updateStmt = adapter.prepare("UPDATE users SET name = ? WHERE name = ?");
+            const result = updateStmt.run("Jane Doe", "Jane");
+            expect(result.changes).toBe(1);
+        });
+        it("should prepare and execute DELETE statement", ()=>{
+            const insertStmt = adapter.prepare("INSERT INTO users (name) VALUES (?)");
+            insertStmt.run("User1");
+            insertStmt.run("User2");
+            const deleteStmt = adapter.prepare("DELETE FROM users WHERE name = ?");
+            const result = deleteStmt.run("User1");
+            expect(result.changes).toBe(1);
+        });
+    });
+    describe("prepare and get", ()=>{
+        beforeEach(()=>{
+            adapter.exec(`
+        CREATE TABLE users (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          name TEXT NOT NULL,
+          age INTEGER
+        );
+      `);
+            const stmt = adapter.prepare("INSERT INTO users (name, age) VALUES (?, ?)");
+            stmt.run("Alice", 30);
+            stmt.run("Bob", 25);
+        });
+        it("should get a single row", ()=>{
+            const stmt = adapter.prepare("SELECT * FROM users WHERE name = ?");
+            const row = stmt.get("Alice");
+            expect(row).toBeDefined();
+            expect(row.name).toBe("Alice");
+            expect(row.age).toBe(30);
+        });
+        it("should return undefined for non-existent row", ()=>{
+            const stmt = adapter.prepare("SELECT * FROM users WHERE name = ?");
+            const row = stmt.get("NonExistent");
+            expect(row).toBeUndefined();
+        });
+    });
+    describe("prepare and all", ()=>{
+        beforeEach(()=>{
+            adapter.exec(`
+        CREATE TABLE users (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          name TEXT NOT NULL,
+          active INTEGER DEFAULT 1
+        );
+      `);
+            const stmt = adapter.prepare("INSERT INTO users (name, active) VALUES (?, ?)");
+            stmt.run("Alice", 1);
+            stmt.run("Bob", 1);
+            stmt.run("Charlie", 0);
+        });
+        it("should get all matching rows", ()=>{
+            const stmt = adapter.prepare("SELECT * FROM users WHERE active = ?");
+            const rows = stmt.all(1);
+            expect(rows).toHaveLength(2);
+            expect(rows[0].name).toBe("Alice");
+            expect(rows[1].name).toBe("Bob");
+        });
+        it("should return empty array when no matches", ()=>{
+            const stmt = adapter.prepare("SELECT * FROM users WHERE name = ?");
+            const rows = stmt.all("Nobody");
+            expect(rows).toHaveLength(0);
+        });
+        it("should get all rows without parameters", ()=>{
+            const stmt = adapter.prepare("SELECT * FROM users");
+            const rows = stmt.all();
+            expect(rows).toHaveLength(3);
+        });
+    });
+    describe("transaction", ()=>{
+        beforeEach(()=>{
+            adapter.exec(`
+        CREATE TABLE accounts (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          name TEXT NOT NULL,
+          balance INTEGER DEFAULT 0
+        );
+      `);
+        });
+        it("should execute transaction successfully", ()=>{
+            const insertMany = adapter.transaction((names)=>{
+                const stmt = adapter.prepare("INSERT INTO accounts (name, balance) VALUES (?, ?)");
+                for (const name of names)stmt.run(name, 100);
+            });
+            insertMany([
+                "Alice",
+                "Bob",
+                "Charlie"
+            ]);
+            const stmt = adapter.prepare("SELECT COUNT(*) as count FROM accounts");
+            const result = stmt.get();
+            expect(result.count).toBe(3);
+        });
+        it("should rollback transaction on error", ()=>{
+            const failedTransaction = adapter.transaction(()=>{
+                const stmt = adapter.prepare("INSERT INTO accounts (name, balance) VALUES (?, ?)");
+                stmt.run("Alice", 100);
+                throw new Error("Transaction failed");
+            });
+            expect(()=>failedTransaction()).toThrow("Transaction failed");
+            const stmt = adapter.prepare("SELECT COUNT(*) as count FROM accounts");
+            const result = stmt.get();
+            expect(result.count).toBe(0);
+        });
+    });
+    describe("pragma", ()=>{
+        it("should execute pragma statements", ()=>{
+            const result = adapter.pragma("journal_mode", true);
+            expect(result).toBeDefined();
+        });
+        it("should return pragma result without simplify", ()=>{
+            const result = adapter.pragma("journal_mode", false);
+            expect(result).toBeDefined();
+            expect(typeof result).toBe("object");
+        });
+    });
+    describe("close", ()=>{
+        it("should close database connection", ()=>{
+            const tempDb = new BunSqliteAdapter(":memory:");
+            expect(()=>tempDb.close()).not.toThrow();
+        });
+    });
+    describe("inTransaction", ()=>{
+        it("should return false by default", ()=>{
+            expect(adapter.inTransaction).toBe(false);
+        });
+    });
+    describe("SqliteSaver compatibility", ()=>{
+        it("should be compatible with LangGraph checkpoint operations", ()=>{
+            adapter.exec(`
+        CREATE TABLE checkpoints (
+          thread_id TEXT NOT NULL,
+          checkpoint_ns TEXT NOT NULL DEFAULT '',
+          checkpoint_id TEXT NOT NULL,
+          parent_checkpoint_id TEXT,
+          type TEXT,
+          checkpoint BLOB NOT NULL,
+          metadata BLOB NOT NULL,
+          PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id)
+        );
+
+        CREATE TABLE checkpoint_writes (
+          thread_id TEXT NOT NULL,
+          checkpoint_ns TEXT NOT NULL DEFAULT '',
+          checkpoint_id TEXT NOT NULL,
+          task_id TEXT NOT NULL,
+          idx INTEGER NOT NULL,
+          channel TEXT NOT NULL,
+          type TEXT,
+          value BLOB,
+          PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id, task_id, idx)
+        );
+      `);
+            const insertStmt = adapter.prepare(`
+        INSERT INTO checkpoints (thread_id, checkpoint_id, checkpoint, metadata)
+        VALUES (?, ?, ?, ?)
+      `);
+            const result = insertStmt.run("thread-1", "checkpoint-1", JSON.stringify({
+                data: "test"
+            }), JSON.stringify({
+                version: 1
+            }));
+            expect(result.changes).toBe(1);
+            const selectStmt = adapter.prepare("SELECT * FROM checkpoints WHERE thread_id = ?");
+            const row = selectStmt.get("thread-1");
+            expect(row).toBeDefined();
+            expect(row.thread_id).toBe("thread-1");
+            expect(row.checkpoint_id).toBe("checkpoint-1");
+            const deleteStmt = adapter.prepare("DELETE FROM checkpoints WHERE thread_id = ?");
+            const deleteResult = deleteStmt.run("thread-1");
+            expect(deleteResult.changes).toBe(1);
+        });
+    });
+});

package/dist/tests/candleRange.test.cjs

@@ -0,0 +1,48 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const candleRange_cjs_namespaceObject = require("../tools/finance/candleRange.cjs");
+const secondsPerDay = 86400;
+const fixedNow = new Date("2026-01-01T00:00:00Z");
+const fixedEnd = Math.floor(fixedNow.getTime() / 1000);
+(0, external_vitest_namespaceObject.describe)("candle range caps", ()=>{
+    (0, external_vitest_namespaceObject.it)("defaults intraday lookback to the cap", ()=>{
+        const range = (0, candleRange_cjs_namespaceObject.resolveCandleRange)({
+            resolution: "60",
+            now: fixedNow
+        });
+        (0, external_vitest_namespaceObject.expect)(range.maxLookbackDays).toBe(candleRange_cjs_namespaceObject.DEFAULT_CANDLE_MAX_DAYS_INTRADAY);
+        (0, external_vitest_namespaceObject.expect)(range.from).toBe(fixedEnd - candleRange_cjs_namespaceObject.DEFAULT_CANDLE_MAX_DAYS_INTRADAY * secondsPerDay);
+        (0, external_vitest_namespaceObject.expect)(range.capped).toBe(false);
+    });
+    (0, external_vitest_namespaceObject.it)("defaults daily lookback to the cap", ()=>{
+        const range = (0, candleRange_cjs_namespaceObject.resolveCandleRange)({
+            resolution: "D",
+            now: fixedNow
+        });
+        (0, external_vitest_namespaceObject.expect)(range.maxLookbackDays).toBe(candleRange_cjs_namespaceObject.DEFAULT_CANDLE_MAX_DAYS_DAILY);
+        (0, external_vitest_namespaceObject.expect)(range.from).toBe(fixedEnd - candleRange_cjs_namespaceObject.DEFAULT_CANDLE_MAX_DAYS_DAILY * secondsPerDay);
+    });
+    (0, external_vitest_namespaceObject.it)("clamps intraday ranges that exceed the cap", ()=>{
+        const range = (0, candleRange_cjs_namespaceObject.resolveCandleRange)({
+            resolution: "15",
+            now: fixedNow,
+            from: fixedEnd - (candleRange_cjs_namespaceObject.DEFAULT_CANDLE_MAX_DAYS_INTRADAY + 10) * secondsPerDay
+        });
+        (0, external_vitest_namespaceObject.expect)(range.from).toBe(fixedEnd - candleRange_cjs_namespaceObject.DEFAULT_CANDLE_MAX_DAYS_INTRADAY * secondsPerDay);
+        (0, external_vitest_namespaceObject.expect)(range.capped).toBe(true);
+    });
+    (0, external_vitest_namespaceObject.it)("respects lookback days within the cap", ()=>{
+        const range = (0, candleRange_cjs_namespaceObject.resolveCandleRange)({
+            resolution: "1",
+            now: fixedNow,
+            lookbackDays: 30
+        });
+        (0, external_vitest_namespaceObject.expect)(range.from).toBe(fixedEnd - 30 * secondsPerDay);
+        (0, external_vitest_namespaceObject.expect)(range.capped).toBe(false);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/candleRange.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/candleRange.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { DEFAULT_CANDLE_MAX_DAYS_DAILY, DEFAULT_CANDLE_MAX_DAYS_INTRADAY, resolveCandleRange } from "../tools/finance/candleRange.js";
+const secondsPerDay = 86400;
+const fixedNow = new Date("2026-01-01T00:00:00Z");
+const fixedEnd = Math.floor(fixedNow.getTime() / 1000);
+describe("candle range caps", ()=>{
+    it("defaults intraday lookback to the cap", ()=>{
+        const range = resolveCandleRange({
+            resolution: "60",
+            now: fixedNow
+        });
+        expect(range.maxLookbackDays).toBe(DEFAULT_CANDLE_MAX_DAYS_INTRADAY);
+        expect(range.from).toBe(fixedEnd - DEFAULT_CANDLE_MAX_DAYS_INTRADAY * secondsPerDay);
+        expect(range.capped).toBe(false);
+    });
+    it("defaults daily lookback to the cap", ()=>{
+        const range = resolveCandleRange({
+            resolution: "D",
+            now: fixedNow
+        });
+        expect(range.maxLookbackDays).toBe(DEFAULT_CANDLE_MAX_DAYS_DAILY);
+        expect(range.from).toBe(fixedEnd - DEFAULT_CANDLE_MAX_DAYS_DAILY * secondsPerDay);
+    });
+    it("clamps intraday ranges that exceed the cap", ()=>{
+        const range = resolveCandleRange({
+            resolution: "15",
+            now: fixedNow,
+            from: fixedEnd - (DEFAULT_CANDLE_MAX_DAYS_INTRADAY + 10) * secondsPerDay
+        });
+        expect(range.from).toBe(fixedEnd - DEFAULT_CANDLE_MAX_DAYS_INTRADAY * secondsPerDay);
+        expect(range.capped).toBe(true);
+    });
+    it("respects lookback days within the cap", ()=>{
+        const range = resolveCandleRange({
+            resolution: "1",
+            now: fixedNow,
+            lookbackDays: 30
+        });
+        expect(range.from).toBe(fixedEnd - 30 * secondsPerDay);
+        expect(range.capped).toBe(false);
+    });
+});