@peers-app/peers-sdk 0.27.3 → 0.27.5

package/dist/logging/console-logs.table.test.js

@@ -1,156 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const SQLiteDB = require("better-sqlite3");
-const event_registry_1 = require("../data/orm/event-registry");
-const sql_data_source_1 = require("../data/orm/sql.data-source");
-const types_1 = require("../data/orm/types");
-const utils_1 = require("../utils");
-const console_logs_table_1 = require("./console-logs.table");
-class DBHarness {
-    _db = null;
-    get db() {
-        if (!this._db) {
-            this._db = new SQLiteDB(":memory:");
-            this._db.pragma("journal_mode = WAL");
-        }
-        return this._db;
-    }
-    async get(sql, params = []) {
-        return this.db.prepare(sql).get(params);
-    }
-    async all(sql, params = []) {
-        return this.db.prepare(sql).all(params);
-    }
-    async exec(sql, params = []) {
-        const result = this.db.prepare(sql).run(params);
-        return { changes: result.changes };
-    }
-    async close() {
-        this._db?.close();
-        this._db = null;
-    }
-}
-const consoleLogsMetaData = {
-    name: "ConsoleLogs",
-    description: "System-wide console log entries with cross-process visibility.",
-    primaryKeyName: "logId",
-    fields: (0, types_1.schemaToFields)(console_logs_table_1.consoleLogSchema),
-    localOnly: true,
-    indexes: [
-        { fields: ["timestamp"] },
-        { fields: ["level"] },
-        { fields: ["process"] },
-        { fields: ["processInstanceId"] },
-    ],
-};
-function createConsoleLogsTable(db) {
-    const sqlDs = new sql_data_source_1.SQLDataSource(db, consoleLogsMetaData, console_logs_table_1.consoleLogSchema);
-    const eventRegistry = new event_registry_1.EventRegistry("test-context");
-    const deps = {
-        dataSource: sqlDs,
-        eventRegistry,
-        schema: console_logs_table_1.consoleLogSchema,
-    };
-    return { table: new console_logs_table_1.ConsoleLogsTable(consoleLogsMetaData, deps), sqlDs };
-}
-describe("isClearAllCutoff", () => {
-    it("returns true when cutoff is now", () => {
-        expect((0, console_logs_table_1.isClearAllCutoff)(Date.now())).toBe(true);
-    });
-    it("returns true when cutoff is within slack window", () => {
-        expect((0, console_logs_table_1.isClearAllCutoff)(Date.now() - console_logs_table_1.CLEAR_ALL_CUTOFF_SLACK_MS + 1)).toBe(true);
-    });
-    it("returns false when cutoff is older than slack window", () => {
-        expect((0, console_logs_table_1.isClearAllCutoff)(Date.now() - console_logs_table_1.CLEAR_ALL_CUTOFF_SLACK_MS - 1)).toBe(false);
-        expect((0, console_logs_table_1.isClearAllCutoff)(Date.now() - 7 * 24 * 60 * 60 * 1000)).toBe(false);
-    });
-});
-describe("ConsoleLogsTable.deleteOldLogs", () => {
-    const db = new DBHarness();
-    afterAll(async () => {
-        await db.close();
-    });
-    beforeEach(async () => {
-        const { sqlDs } = createConsoleLogsTable(db);
-        await sqlDs.dropTableIfExists();
-        await sqlDs.initTable(true);
-    });
-    it("uses drop+recreate for clear-all cutoff without calling count", async () => {
-        const { table, sqlDs } = createConsoleLogsTable(db);
-        await sqlDs.initTable(true);
-        const now = Date.now();
-        await table.insert({
-            logId: (0, utils_1.newid)(),
-            timestamp: now - 1000,
-            level: "info",
-            process: "test",
-            processInstanceId: (0, utils_1.newid)(),
-            message: "old log",
-        });
-        const countSpy = jest.spyOn(table, "count");
-        const dropSpy = jest.spyOn(sqlDs, "dropTableIfExists");
-        const initSpy = jest.spyOn(sqlDs, "initTable");
-        await table.deleteOldLogs(Date.now());
-        expect(countSpy).not.toHaveBeenCalled();
-        expect(dropSpy).toHaveBeenCalled();
-        expect(initSpy).toHaveBeenCalledWith(true);
-        const remaining = await table.count();
-        expect(remaining).toBe(0);
-        countSpy.mockRestore();
-        dropSpy.mockRestore();
-        initSpy.mockRestore();
-    });
-    it("uses conditional delete for TTL cutoff and calls count", async () => {
-        const { table, sqlDs } = createConsoleLogsTable(db);
-        await sqlDs.initTable(true);
-        const now = Date.now();
-        const oldCutoff = now - 7 * 24 * 60 * 60 * 1000;
-        await table.insert({
-            logId: (0, utils_1.newid)(),
-            timestamp: oldCutoff - 1000,
-            level: "info",
-            process: "test",
-            processInstanceId: (0, utils_1.newid)(),
-            message: "expired log",
-        });
-        await table.insert({
-            logId: (0, utils_1.newid)(),
-            timestamp: now,
-            level: "info",
-            process: "test",
-            processInstanceId: (0, utils_1.newid)(),
-            message: "recent log",
-        });
-        const countSpy = jest.spyOn(table, "count");
-        const dropSpy = jest.spyOn(sqlDs, "dropTableIfExists");
-        const execSpy = jest.spyOn(sqlDs.db, "exec");
-        await table.deleteOldLogs(oldCutoff);
-        expect(countSpy).toHaveBeenCalledWith({ timestamp: { $lt: oldCutoff } });
-        expect(dropSpy).not.toHaveBeenCalled();
-        expect(execSpy).toHaveBeenCalledWith(`DELETE FROM "${sqlDs.tableName}" WHERE "timestamp" < $timestamp`, { timestamp: oldCutoff });
-        const remaining = await table.count();
-        expect(remaining).toBe(1);
-        countSpy.mockRestore();
-        dropSpy.mockRestore();
-        execSpy.mockRestore();
-    });
-    it("does nothing on partial delete when no rows match cutoff", async () => {
-        const { table, sqlDs } = createConsoleLogsTable(db);
-        await sqlDs.initTable(true);
-        const now = Date.now();
-        await table.insert({
-            logId: (0, utils_1.newid)(),
-            timestamp: now,
-            level: "info",
-            process: "test",
-            processInstanceId: (0, utils_1.newid)(),
-            message: "recent log",
-        });
-        const execSpy = jest.spyOn(sqlDs.db, "exec");
-        const oldCutoff = now - 7 * 24 * 60 * 60 * 1000;
-        await table.deleteOldLogs(oldCutoff);
-        expect(execSpy).not.toHaveBeenCalled();
-        expect(await table.count()).toBe(1);
-        execSpy.mockRestore();
-    });
-});

package/dist/observable.test.d.ts

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

package/dist/observable.test.js

@@ -1,309 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const observable_1 = require("./observable");
-describe("observable.ts", () => {
-    describe("observable", () => {
-        it("should be able to create an observable", () => {
-            const obs = (0, observable_1.observable)(3);
-            expect(obs()).toBe(3);
-        });
-        it("should be able to update an observable", () => {
-            const obs = (0, observable_1.observable)(3);
-            obs(4);
-            expect(obs()).toBe(4);
-        });
-        it("should be able to subscribe to an observable", () => {
-            const obs = (0, observable_1.observable)(3);
-            let value = 0;
-            const sub = obs.subscribe((newValue) => {
-                value = newValue;
-            });
-            expect(value).toBe(0);
-            obs(4);
-            expect(value).toBe(4);
-            sub.dispose();
-            obs(5);
-            expect(value).toBe(4);
-        });
-        it("should return the value when writing to itself", () => {
-            const obs = (0, observable_1.observable)(3);
-            expect(obs(4)).toBe(4);
-        });
-        it("should be able to set an observable to undefined", () => {
-            const obs = (0, observable_1.observable)(3);
-            obs(undefined);
-            expect(obs()).toBe(undefined);
-        });
-        it("should notify subscribers when value is set to undefined", () => {
-            const obs = (0, observable_1.observable)(3);
-            let value = 99;
-            const sub = obs.subscribe((newValue) => {
-                value = newValue;
-            });
-            obs(undefined);
-            expect(value).toBe(undefined);
-            sub.dispose();
-        });
-        it("should be able to initialize an observable with undefined", () => {
-            const obs = (0, observable_1.observable)(undefined);
-            expect(obs()).toBe(undefined);
-        });
-        it("should distinguish between getting (no args) and setting to undefined (with arg)", () => {
-            const obs = (0, observable_1.observable)(5);
-            // Getting with no args
-            expect(obs()).toBe(5);
-            // Setting to undefined with explicit arg
-            obs(undefined);
-            expect(obs()).toBe(undefined);
-        });
-        it("should not notify subscribers when value does not change", () => {
-            const obs = (0, observable_1.observable)(3);
-            let notifyCount = 0;
-            obs.subscribe(() => {
-                notifyCount++;
-            });
-            obs(3);
-            expect(notifyCount).toBe(0);
-            obs(4);
-            expect(notifyCount).toBe(1);
-        });
-        it("should handle setting undefined multiple times", () => {
-            const obs = (0, observable_1.observable)("test");
-            let notifyCount = 0;
-            obs.subscribe(() => {
-                notifyCount++;
-            });
-            obs(undefined);
-            expect(notifyCount).toBe(1);
-            obs(undefined);
-            // Should not notify since value hasn't changed
-            expect(notifyCount).toBe(1);
-            obs("new");
-            expect(notifyCount).toBe(2);
-            obs(undefined);
-            expect(notifyCount).toBe(3);
-        });
-        it("should correctly detect args.length for get vs set", () => {
-            const obs = (0, observable_1.observable)(10);
-            const calls = [];
-            // Wrap the observable to track calls
-            const originalObs = obs;
-            const wrappedObs = ((...args) => {
-                calls.push({ argsLength: args.length, value: args[0] });
-                return originalObs(...args);
-            });
-            Object.assign(wrappedObs, obs);
-            // Get (no args)
-            wrappedObs();
-            expect(calls[0]).toEqual({ argsLength: 0, value: undefined });
-            // Set to undefined (1 arg)
-            wrappedObs(undefined);
-            expect(calls[1]).toEqual({ argsLength: 1, value: undefined });
-            // Get again (no args)
-            wrappedObs();
-            expect(calls[2]).toEqual({ argsLength: 0, value: undefined });
-        });
-        it("should allow creating observable without initial value for types that include undefined", () => {
-            const obs = (0, observable_1.observable)();
-            expect(obs()).toBe(undefined);
-            obs("test");
-            expect(obs()).toBe("test");
-            obs(undefined);
-            expect(obs()).toBe(undefined);
-        });
-        it("should work with explicit type and initial value", () => {
-            const obs = (0, observable_1.observable)(42);
-            expect(obs()).toBe(42);
-            obs(100);
-            expect(obs()).toBe(100);
-        });
-        it("should not allow creating observable without initial value for types that cannot be undefined", () => {
-            const obs = (0, observable_1.observable)();
-            // @ts-expect-error
-            const s = obs();
-            expect(s).toBeUndefined();
-            obs("s");
-            expect(obs()).toEqual("s");
-            obs(undefined);
-            expect(obs()).toEqual(undefined);
-            const obs2 = (0, observable_1.observable)("");
-            const s2 = obs2();
-            expect(s2).toEqual("");
-            // @ts-expect-error
-            obs2(undefined);
-            expect(obs2()).toBeUndefined();
-        });
-        it("should infer type from initial value", () => {
-            // Infer number from numeric literal
-            const numObs = (0, observable_1.observable)(42);
-            const num = numObs();
-            expect(num).toBe(42);
-            // Infer string from string literal
-            const strObs = (0, observable_1.observable)("hello");
-            const str = strObs();
-            expect(str).toBe("hello");
-            // Infer boolean from boolean literal
-            const boolObs = (0, observable_1.observable)(true);
-            const bool = boolObs();
-            expect(bool).toBe(true);
-            // Infer object type
-            const objObs = (0, observable_1.observable)({ name: "test", count: 5 });
-            const obj = objObs();
-            expect(obj).toEqual({ name: "test", count: 5 });
-            // Infer array type
-            const arrObs = (0, observable_1.observable)([1, 2, 3]);
-            const arr = arrObs();
-            expect(arr).toEqual([1, 2, 3]);
-        });
-    });
-    describe("computed", () => {
-        it("should be able to create a computed observable", () => {
-            const com = (0, observable_1.computed)(() => 3);
-            expect(com()).toBe(3);
-        });
-        it("should throw if trying to set value", () => {
-            const com = (0, observable_1.computed)(() => 3);
-            expect(() => com(4)).toThrow();
-        });
-        it("should be able to create a computed observable that depends on another observable", () => {
-            const obs1 = (0, observable_1.observable)(3);
-            const com1 = (0, observable_1.computed)(() => obs1() + 1);
-            expect(com1()).toBe(4);
-            obs1(5);
-            expect(com1()).toBe(6);
-        });
-        it("should be able to create a computed observable that depends on another computed observable", () => {
-            const obs1 = (0, observable_1.observable)(3);
-            const com1 = (0, observable_1.computed)(() => obs1() + 1);
-            const com2 = (0, observable_1.computed)(() => com1() + 1);
-            expect(com2()).toBe(5);
-            obs1(5);
-            expect(com2()).toBe(7);
-        });
-        it("should be able to create a computed observable that depends on another computed observable that depends on another computed observable", () => {
-            const obs1 = (0, observable_1.observable)(3);
-            const com1 = (0, observable_1.computed)(() => obs1() + 1);
-            const com2 = (0, observable_1.computed)(() => com1() + 1);
-            const com3 = (0, observable_1.computed)(() => com2() + 1);
-            expect(com3()).toBe(6);
-        });
-        it("should notify subscribers of new value when a dependency changes", () => {
-            const obs1 = (0, observable_1.observable)(3);
-            const com1 = (0, observable_1.computed)(() => obs1() + 1);
-            let newValue = 0;
-            com1.subscribe((val) => {
-                newValue = val;
-            });
-            expect(com1()).toBe(4);
-            expect(newValue).toBe(0);
-            obs1(5);
-            expect(newValue).toBe(6);
-        });
-        it("should not notify subscribers of new value when a dependency changes if there are no subscribers", () => {
-            const obs1 = (0, observable_1.observable)(1);
-            let computeCount = 0;
-            const com1 = (0, observable_1.computed)(() => {
-                computeCount++;
-                return obs1() + 1;
-            });
-            let newValue = 0;
-            const sub = com1.subscribe((val) => {
-                newValue = val;
-            });
-            expect(computeCount).toBe(1);
-            expect(com1()).toBe(2);
-            expect(newValue).toBe(0);
-            expect(computeCount).toBe(1);
-            obs1(2);
-            expect(computeCount).toBe(2);
-            expect(com1()).toBe(3);
-            expect(newValue).toBe(3);
-            sub.dispose();
-            obs1(3);
-            expect(computeCount).toBe(2);
-            expect(com1()).toBe(4);
-            expect(computeCount).toBe(3);
-            expect(com1()).toBe(4);
-        });
-        it("should only recompute value when a dependency changes if there are subscribers", () => {
-            const obs1 = (0, observable_1.observable)(1);
-            let recomputeCount = 0;
-            const com1 = (0, observable_1.computed)(() => {
-                recomputeCount++;
-                return obs1() + recomputeCount;
-            });
-            expect(com1()).toBe(2);
-            expect(recomputeCount).toBe(1);
-            expect(com1()).toBe(2);
-            expect(recomputeCount).toBe(1);
-            obs1(2);
-            expect(recomputeCount).toBe(1);
-            expect(obs1()).toBe(2);
-            expect(recomputeCount).toBe(1);
-            // NOTE the recomputeCount only changed when we inspected com1 (lazy evaluation)
-            //      this probably won't be used much right now but if we implement `deferCompute` this can have a big impact
-            expect(com1()).toBe(4);
-            expect(recomputeCount).toBe(2);
-        });
-        it("should immediately, and still only, recompute value when a dependency changes if there are subscribers", () => {
-            const obs1 = (0, observable_1.observable)(1);
-            let recomputeCount = 0;
-            const com1 = (0, observable_1.computed)(() => {
-                recomputeCount++;
-                return obs1() + recomputeCount;
-            });
-            let newValue = 0;
-            com1.subscribe((val) => {
-                newValue = val;
-            });
-            expect(com1()).toBe(2);
-            expect(recomputeCount).toBe(1);
-            expect(newValue).toBe(0);
-            obs1(2);
-            expect(recomputeCount).toBe(2);
-            expect(newValue).toBe(4);
-            expect(recomputeCount).toBe(2);
-            expect(com1()).toBe(4);
-            expect(com1()).toBe(4);
-        });
-        it("notify should set the value and notify subscribers without recomputing", () => {
-            const obs1 = (0, observable_1.observable)(1);
-            let recomputeCount = 0;
-            const com1 = (0, observable_1.computed)(() => {
-                recomputeCount++;
-                return obs1() + recomputeCount;
-            });
-            let newValue = 0;
-            com1.subscribe((val) => {
-                newValue = val;
-            });
-            expect(com1()).toBe(2);
-            expect(recomputeCount).toBe(1);
-            expect(newValue).toBe(0);
-            obs1(2);
-            expect(recomputeCount).toBe(2);
-            expect(newValue).toBe(4);
-            expect(recomputeCount).toBe(2);
-            expect(com1()).toBe(4);
-            expect(com1()).toBe(4);
-            // com1.notifySubscribers(5);
-            // expect(newValue).toBe(5);
-            // expect(com1()).toBe(5);
-            // expect(recomputeCount).toBe(2);
-        });
-        it("should allow configuring a write function", () => {
-            const obs1 = (0, observable_1.observable)(1);
-            const com1 = (0, observable_1.computed)({
-                read: () => obs1() + 1,
-                write: (val) => obs1(val),
-            });
-            expect(com1()).toBe(2);
-            com1(2);
-            expect(obs1()).toBe(2);
-            expect(com1()).toBe(3);
-            obs1(3);
-            expect(obs1()).toBe(3);
-            expect(com1()).toBe(4);
-        });
-    });
-});

package/dist/package-build/build-package.test.d.ts

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

package/dist/package-build/build-package.test.js

@@ -1,204 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_child_process_1 = require("node:child_process");
-const node_crypto_1 = require("node:crypto");
-const promises_1 = require("node:fs/promises");
-const node_os_1 = require("node:os");
-const path = require("node:path");
-const node_vm_1 = require("node:vm");
-const isolated_artifact_1 = require("../package-loader/isolated-artifact");
-const peer_id_1 = require("../peer-id");
-const build_package_1 = require("./build-package");
-const sdkRoot = path.resolve(__dirname, "../..");
-const packageId = (0, peer_id_1.newid)();
-const contractId = (0, peer_id_1.newid)();
-let root;
-let watcher;
-function declaration(mode = "sandbox", version = "1.0.0", bad = false) {
-    return `
-    import { defineContract, definePackage, defineTool, z } from "@peers-app/peers-sdk/define";
-    import { side } from "platform-probe";
-    // <!-- Comments that SES rejects must be stripped from the provider.
-    export default definePackage((pkg) => {
-      pkg.packageId = ${JSON.stringify(packageId)};
-      pkg.version = ${JSON.stringify(version)};
-      pkg.executionMode = ${JSON.stringify(mode)};
-      pkg.provides(defineContract({
-        contractId: ${JSON.stringify(contractId)}, version: 1, name: "Probe",
-        tools: [defineTool({
-          name: "probe", usageDescription: "Probe the bundler platform.", accessLevel: 0,
-          inputSchema: z.object({}), outputSchema: z.object({ side: z.string() }),
-          handler: () => ({ side: ${bad ? '"<!--"' : "side"} }),
-        })],
-      }));
-    });
-  `;
-}
-beforeEach(async () => {
-    root = await (0, promises_1.mkdtemp)(path.join((0, node_os_1.tmpdir)(), "peers-package-test-"));
-    await (0, promises_1.mkdir)(path.join(root, "src"));
-    await (0, promises_1.mkdir)(path.join(root, "node_modules/@peers-app"), { recursive: true });
-    await (0, promises_1.symlink)(sdkRoot, path.join(root, "node_modules/@peers-app/peers-sdk"), "dir");
-    await (0, promises_1.symlink)(path.dirname(require.resolve("esbuild/package.json")), path.join(root, "node_modules/esbuild"), "dir");
-    const probe = path.join(root, "node_modules/platform-probe");
-    await (0, promises_1.mkdir)(probe);
-    await (0, promises_1.writeFile)(path.join(root, "package.json"), '{"name":"build-probe","version":"1.0.0"}');
-    await (0, promises_1.writeFile)(path.join(probe, "package.json"), JSON.stringify({
-        name: "platform-probe",
-        exports: { browser: "./browser.js", default: "./node.js" },
-    }));
-    await (0, promises_1.writeFile)(path.join(probe, "browser.js"), 'exports.side = "browser";');
-    await (0, promises_1.writeFile)(path.join(probe, "node.js"), 'exports.side = "node";');
-    await (0, promises_1.writeFile)(path.join(root, "src/package.ts"), declaration());
-});
-afterEach(async () => {
-    await watcher?.dispose();
-    watcher = undefined;
-    await (0, promises_1.rm)(root, { recursive: true, force: true });
-});
-async function probeArtifact() {
-    const artifact = (0, isolated_artifact_1.parseIsolatedPackageArtifact)(await (0, promises_1.readFile)(path.join(root, "dist/package.bundle.js"), "utf8"));
-    const handlers = [];
-    const sandbox = {
-        registerContractTool: (_id, _version, _name, handler) => handlers.push(handler),
-        registerHandler: () => undefined,
-        onWorkerStart: () => undefined,
-    };
-    try {
-        (0, node_vm_1.runInNewContext)(artifact.providerSource, { ...sandbox, self: { crypto: node_crypto_1.webcrypto }, require });
-    }
-    catch (error) {
-        throw new Error(String(error));
-    }
-    return { artifact, result: await handlers[0]({}, {}) };
-}
-test("the CLI generates a validated manifest with custom paths and no provider artifact", async () => {
-    (0, node_child_process_1.execFileSync)(process.execPath, [
-        path.join(sdkRoot, "bin/peers-package.js"),
-        "manifest",
-        "--root",
-        root,
-        "--out-dir",
-        "generated",
-    ], { encoding: "utf8" });
-    const manifest = JSON.parse(await (0, promises_1.readFile)(path.join(root, "generated/manifest.json"), "utf8"));
-    expect(manifest).toMatchObject({ packageId, guestApi: 3, version: "1.0.0" });
-    await expect((0, promises_1.readFile)(path.join(root, "generated/package.bundle.js"))).rejects.toThrow();
-    await (0, promises_1.writeFile)(path.join(root, "src/package.ts"), declaration("sandbox", ""));
-    await expect((0, build_package_1.generatePackageManifest)({ root })).rejects.toThrow(/version/);
-});
-test.each([
-    "sandbox",
-    "privileged",
-])("builds %s with its platform's dependency exports", async (mode) => {
-    await (0, promises_1.writeFile)(path.join(root, "src/package.ts"), declaration(mode));
-    const built = await (0, build_package_1.buildPackage)({ root });
-    const { artifact, result } = await probeArtifact();
-    expect(result).toEqual({ side: mode === "sandbox" ? "browser" : "node" });
-    expect(artifact.providerSource).not.toContain("<!--");
-    const raw = JSON.parse((await (0, promises_1.readFile)(built.artifactPath, "utf8")).split("\n")[1]);
-    expect(raw.manifest).toEqual(JSON.parse(await (0, promises_1.readFile)(built.manifestPath, "utf8")));
-});
-test("manifest and provider builds resolve dependencies with an output directory outside the package", async () => {
-    const outDir = await (0, promises_1.mkdtemp)(path.join((0, node_os_1.tmpdir)(), "peers-package-output-test-"));
-    try {
-        const generated = await (0, build_package_1.generatePackageManifest)({ root, outDir });
-        expect(generated.manifest.packageId).toBe(packageId);
-        expect(generated.manifestPath).toBe(path.join(outDir, "manifest.json"));
-        const built = await (0, build_package_1.buildPackage)({ root, outDir });
-        const raw = JSON.parse((await (0, promises_1.readFile)(built.artifactPath, "utf8")).split("\n")[1]);
-        expect(raw.manifest).toEqual(JSON.parse(await (0, promises_1.readFile)(built.manifestPath, "utf8")));
-    }
-    finally {
-        await (0, promises_1.rm)(outDir, { recursive: true, force: true });
-    }
-});
-test("an interrupted build leaves no scratch files in the package's source tree", async () => {
-    // Killed mid-evaluation, as Ctrl-C during a watch rebuild would: no cleanup code runs.
-    await (0, promises_1.writeFile)(path.join(root, "src/package.ts"), `process.kill(process.pid, "SIGKILL");\n${declaration()}`);
-    expect(() => (0, node_child_process_1.execFileSync)(process.execPath, [path.join(sdkRoot, "bin/peers-package.js"), "manifest", "--root", root], { stdio: "pipe" })).toThrow();
-    expect((await (0, promises_1.readdir)(root)).sort()).toEqual(["node_modules", "package.json", "src"]);
-});
-test("a failed provider build preserves both previously successful outputs", async () => {
-    const first = await (0, build_package_1.buildPackage)({ root });
-    const before = await Promise.all([(0, promises_1.readFile)(first.manifestPath), (0, promises_1.readFile)(first.artifactPath)]);
-    jest.resetModules();
-    await (0, promises_1.writeFile)(path.join(root, "src/package.ts"), declaration("sandbox", "2.0.0", true));
-    await expect((0, build_package_1.buildPackage)({ root })).rejects.toThrow(/HTML comment token/);
-    expect(await Promise.all([(0, promises_1.readFile)(first.manifestPath), (0, promises_1.readFile)(first.artifactPath)])).toEqual(before);
-});
-test("repeated builds reload external declaration dependencies, including after an evaluation failure", async () => {
-    const source = declaration().replace('pkg.version = "1.0.0";', "pkg.version = side;");
-    await (0, promises_1.writeFile)(path.join(root, "src/package.ts"), source);
-    const stdout = (0, node_child_process_1.execFileSync)(process.execPath, [
-        "-e",
-        `
-        const { writeFile } = require("node:fs/promises");
-        const { buildPackage } = require(${JSON.stringify(path.join(sdkRoot, "dist/package-build/build-package.js"))});
-        const root = ${JSON.stringify(root)};
-        const dependency = ${JSON.stringify(path.join(root, "node_modules/platform-probe/node.js"))};
-        (async () => {
-          const versions = [];
-          await writeFile(dependency, 'exports.side = "1.0.0";');
-          versions.push((await buildPackage({ root })).manifest.version);
-          await writeFile(dependency, 'exports.side = "";');
-          try { await buildPackage({ root }); throw new Error("Invalid declaration accepted"); }
-          catch (error) { if (!error.message.includes("must set version")) throw error; }
-          await writeFile(dependency, 'exports.side = "2.0.0";');
-          versions.push((await buildPackage({ root })).manifest.version);
-          process.stdout.write(JSON.stringify(versions));
-        })().catch((error) => { console.error(error); process.exitCode = 1; });
-      `,
-    ], { encoding: "utf8", timeout: 10_000 });
-    expect(JSON.parse(stdout)).toEqual(["1.0.0", "2.0.0"]);
-});
-test("watch rebuilds use the current execution mode and recover after invalid declarations", async () => {
-    const queued = [];
-    let deliver;
-    const next = () => new Promise((resolve, reject) => {
-        const pending = queued.shift();
-        if (pending)
-            return resolve(pending);
-        const timeout = setTimeout(() => reject(new Error("No watch build completed")), 10_000);
-        deliver = (value) => {
-            clearTimeout(timeout);
-            deliver = undefined;
-            resolve(value);
-        };
-    });
-    watcher = await (0, build_package_1.watchPackage)({ root }, (value) => {
-        if (deliver)
-            deliver(value);
-        else
-            queued.push(value);
-    });
-    const until = async (matches) => {
-        let value = await next();
-        while (!matches(value))
-            value = await next();
-        return value;
-    };
-    expect(await next()).not.toBeInstanceOf(Error);
-    for (const mode of ["privileged", "sandbox"]) {
-        // Jest's require cache is separate from the native cache invalidated by loadDefinition.
-        jest.resetModules();
-        await (0, promises_1.writeFile)(path.join(root, "src/package.ts"), declaration(mode));
-        expect(await until((value) => !(value instanceof Error) && value.manifest.executionMode === mode)).toMatchObject({ manifest: { executionMode: mode } });
-        expect((await probeArtifact()).result).toEqual({
-            side: mode === "sandbox" ? "browser" : "node",
-        });
-    }
-    // After changing modes, watch the active conditional dependency as well as src/package.ts.
-    await (0, promises_1.writeFile)(path.join(root, "node_modules/platform-probe/browser.js"), 'exports.side = "browser-v2";');
-    let side;
-    do {
-        expect(await next()).not.toBeInstanceOf(Error);
-        side = (await probeArtifact()).result.side;
-    } while (side !== "browser-v2");
-    jest.resetModules();
-    await (0, promises_1.writeFile)(path.join(root, "src/package.ts"), declaration("sandbox", ""));
-    expect(await until((value) => value instanceof Error)).toBeInstanceOf(Error);
-    jest.resetModules();
-    await (0, promises_1.writeFile)(path.join(root, "src/package.ts"), declaration("sandbox", "2.0.0"));
-    expect(await until((value) => !(value instanceof Error) && value.manifest.version === "2.0.0")).toMatchObject({ manifest: { version: "2.0.0" } });
-}, 30_000);

package/dist/package-build/contract-add.test.d.ts

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