@peers-app/peers-sdk 0.27.2 → 0.27.4

package/dist/define/serve-members.test.d.ts

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

package/dist/define/serve-members.test.js

@@ -1,630 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const zod_1 = require("zod");
-const observable_1 = require("../observable");
-const contract_members_1 = require("../package-loader/contract-members");
-const isolated_artifact_1 = require("../package-loader/isolated-artifact");
-const peer_id_1 = require("../peer-id");
-const field_type_1 = require("../types/field-type");
-const zod_types_1 = require("../types/zod-types");
-const define_package_1 = require("./define-package");
-const events_1 = require("./events");
-const manifest_1 = require("./manifest");
-const observables_1 = require("./observables");
-const serve_members_1 = require("./serve-members");
-const table_1 = require("./table");
-const vars_1 = require("./vars");
-/** A ctx whose owned-table and variable calls answer from memory, recording each call. */
-function fakeContext() {
-    const rows = new Map();
-    const vars = new Map();
-    const calls = [];
-    const ctx = new Proxy({}, {
-        get(_target, method) {
-            return async (...args) => {
-                if (method === "callOwnedTable") {
-                    const [table, operation, rest] = args;
-                    calls.push(`${table}.${operation}`);
-                    if (operation === "save") {
-                        const row = rest[0];
-                        rows.set(row.itemId, row);
-                        return row;
-                    }
-                    if (operation === "get")
-                        return rows.get(rest[0]);
-                    if (operation === "list")
-                        return [...rows.values()];
-                    if (operation === "count")
-                        return rows.size;
-                    if (operation === "delete")
-                        return rows.delete(rest[0]);
-                    return undefined;
-                }
-                if (method === "getOwnedPersistentVar")
-                    return vars.get(JSON.stringify(args)) ?? null;
-                if (method === "setOwnedPersistentVar") {
-                    vars.set(JSON.stringify(args.slice(0, 2)), args[2]);
-                    return args[2];
-                }
-                return null;
-            };
-        },
-    });
-    return { ctx, rows, vars, calls };
-}
-const itemSchema = zod_1.z.object({
-    itemId: zod_types_1.zodPeerId,
-    title: zod_1.z.string(),
-    hidden: zod_1.z.boolean().default(false),
-});
-class ItemsTable extends table_1.PackageTable {
-    async save(item) {
-        return super.save({ ...item, title: item.title.trim() });
-    }
-    dataChanged(event) {
-        return event.dataObject.hidden
-            ? undefined
-            : {
-                ...event,
-                dataObject: { ...event.dataObject, title: event.dataObject.title.toUpperCase() },
-            };
-    }
-}
-const Items = (0, table_1.defineTable)({
-    name: "Items",
-    description: "Items.",
-    primaryKeyName: "itemId",
-    schema: itemSchema,
-    tableClass: ItemsTable,
-});
-describe("PackageTable", () => {
-    test("a save omits fields left undefined, so they're stored unset", async () => {
-        const { ctx, rows } = fakeContext();
-        const Notes = (0, table_1.defineTable)({
-            name: "Notes",
-            description: "Notes.",
-            primaryKeyName: "itemId",
-            schema: zod_1.z.object({ itemId: zod_types_1.zodPeerId, title: zod_1.z.string(), link: zod_1.z.string().optional() }),
-        });
-        const id = (0, peer_id_1.newid)();
-        await Notes(ctx).save({ itemId: id, title: "a", link: undefined });
-        expect(Object.hasOwn(rows.get(id) ?? {}, "link")).toBe(false);
-    });
-    test("the package's own calls go through its class, and super parses with the schema", async () => {
-        const { ctx, rows } = fakeContext();
-        const items = Items(ctx);
-        expect(items).toBeInstanceOf(ItemsTable);
-        const id = (0, peer_id_1.newid)();
-        const saved = await items.save({ itemId: id, title: "  milk  " });
-        expect(saved).toEqual({ itemId: id, title: "milk", hidden: false });
-        expect(rows.get(id)).toEqual(saved);
-        // A table without a class gets PackageTable's methods.
-        const Plain = (0, table_1.defineTable)({
-            name: "Plain",
-            description: "Plain.",
-            primaryKeyName: "itemId",
-            schema: itemSchema,
-        });
-        expect(Plain(ctx)).toBeInstanceOf(table_1.PackageTable);
-        expect(Plain(ctx).dataChanged({ dataObject: saved, op: "insert", source: "local" })).toEqual({
-            dataObject: saved,
-            op: "insert",
-            source: "local",
-        });
-    });
-    test("storage replies clean old nested empty fields before provider code reads them", async () => {
-        const schema = itemSchema.extend({
-            detail: zod_1.z.object({ note: zod_1.z.string().optional(), data: zod_1.z.unknown() }),
-            stops: zod_1.z.array(zod_1.z.object({ note: zod_1.z.string().optional() })),
-        });
-        const Notes = (0, table_1.defineTable)({
-            ...Items.definition,
-            name: "Notes",
-            schema,
-            tableClass: undefined,
-        });
-        // A table definition stored before richer IR has no nested fields to clean on the host.
-        const stored = {
-            itemId: (0, peer_id_1.newid)(),
-            title: "old",
-            hidden: false,
-            detail: { note: null, data: null },
-            stops: [{ note: null }],
-        };
-        const ctx = {
-            ...fakeContext().ctx,
-            callOwnedTable: async (_name, operation) => (operation === "list" ? [stored] : stored),
-        };
-        const expected = { ...stored, detail: { data: null }, stops: [{}] };
-        const notes = Notes(ctx);
-        await expect(notes.get(stored.itemId)).resolves.toStrictEqual(expected);
-        await expect(notes.list()).resolves.toStrictEqual([expected]);
-        await expect(notes.findOne()).resolves.toStrictEqual(expected);
-        await expect(notes.save(expected)).resolves.toStrictEqual(expected);
-        expect(stored.detail).toStrictEqual({ note: null, data: null });
-        expect(stored.stops).toStrictEqual([{ note: null }]);
-    });
-    test("tableClass must extend PackageTable", () => {
-        expect(() => (0, table_1.defineTable)({
-            name: "Bad",
-            description: "Bad.",
-            primaryKeyName: "itemId",
-            schema: itemSchema,
-            tableClass: class {
-            },
-        })).toThrow("tableClass must extend PackageTable");
-    });
-});
-describe("serveContractMembers", () => {
-    const level = (0, observable_1.observable)(1);
-    const theme = (0, vars_1.deviceVar)("serve-members-theme", { defaultValue: "light" });
-    const saved = (0, events_1.defineEvent)({
-        name: "saved",
-        description: "Saved.",
-        payloadSchema: zod_1.z.object({ count: zod_1.z.number() }),
-    });
-    const Contract = (0, define_package_1.defineContract)({
-        contractId: (0, peer_id_1.newid)(),
-        version: 1,
-        name: "Items",
-        tables: [Items],
-        events: [saved],
-        observables: [
-            (0, observables_1.defineObservable)({
-                name: "level",
-                description: "Level.",
-                schema: zod_1.z.number().int().max(10),
-                writable: true,
-                source: level,
-            }),
-            (0, observables_1.defineObservable)({
-                name: "theme",
-                description: "Theme.",
-                schema: zod_1.z.enum(["light", "dark"]),
-                writable: true,
-                source: theme,
-            }),
-            {
-                name: "stored",
-                description: "IR, stored in a variable.",
-                valueType: field_type_1.FieldType.string,
-                writable: true,
-                persistentVar: { scope: "device", name: "stored", defaultValue: "start" },
-            },
-        ],
-    });
-    function serve() {
-        const handlers = new Map();
-        (0, serve_members_1.serveContractMembers)(Contract, (name, handler) => handlers.set(name, handler));
-        const call = handlers.get((0, contract_members_1.contractMemberHandlerName)(Contract.contractId, 1));
-        const deliver = handlers.get((0, contract_members_1.contractDeliveryHandlerName)(Contract.contractId, 1));
-        if (!call || !deliver)
-            throw new Error("handlers not registered");
-        return { call, deliver };
-    }
-    test("table calls reach the table's class; subscriptions are accepted", async () => {
-        const { call } = serve();
-        const { ctx, calls } = fakeContext();
-        const id = (0, peer_id_1.newid)();
-        const table = (operation, args = []) => Promise.resolve().then(() => call({ member: "table", name: "Items", operation, args }, ctx));
-        await expect(table("save", [{ itemId: id, title: " eggs " }])).resolves.toEqual({
-            itemId: id,
-            title: "eggs",
-            hidden: false,
-        });
-        await expect(table("count")).resolves.toBe(1);
-        await expect(table("subscribe")).resolves.toBeNull();
-        await expect(table("insert")).rejects.toThrow("is not callable");
-        await expect(Promise.resolve().then(() => call({ member: "table", name: "Missing", operation: "list", args: [] }, ctx))).rejects.toThrow("has no table 'Missing'");
-        expect(calls).toEqual(["Items.save", "Items.count"]);
-    });
-    test("outgoing changes pass through the class; events and values pass unchanged", async () => {
-        const { deliver } = serve();
-        const { ctx } = fakeContext();
-        const change = (hidden) => ({
-            member: "table",
-            name: "Items",
-            value: { op: "insert", source: "local", dataObject: { itemId: "a", title: "x", hidden } },
-        });
-        await expect(deliver(change(false), ctx)).resolves.toEqual({
-            send: true,
-            value: {
-                op: "insert",
-                source: "local",
-                dataObject: { itemId: "a", title: "X", hidden: false },
-            },
-        });
-        await expect(deliver(change(true), ctx)).resolves.toEqual({ send: false });
-        await expect(deliver({ member: "event", name: "saved", value: { count: 1 } }, ctx)).resolves.toEqual({ send: true, value: { count: 1 } });
-    });
-    test("table overrides' replies and deliveries omit undefined fields at the member boundary", async () => {
-        const notesSchema = itemSchema.extend({ note: zod_1.z.string().optional() });
-        class NotesTable extends table_1.PackageTable {
-            async get(id) {
-                return { itemId: id, title: "note", hidden: false, note: undefined };
-            }
-            dataChanged(event) {
-                return { ...event, dataObject: { ...event.dataObject, note: undefined } };
-            }
-        }
-        const Notes = (0, table_1.defineTable)({
-            ...Items.definition,
-            name: "Notes",
-            schema: notesSchema,
-            tableClass: NotesTable,
-        });
-        const contract = (0, define_package_1.defineContract)({
-            contractId: (0, peer_id_1.newid)(),
-            version: 1,
-            name: "Notes",
-            tables: [Notes],
-        });
-        const handlers = new Map();
-        (0, serve_members_1.serveContractMembers)(contract, (name, handler) => handlers.set(name, handler));
-        const call = handlers.get((0, contract_members_1.contractMemberHandlerName)(contract.contractId, 1));
-        const deliver = handlers.get((0, contract_members_1.contractDeliveryHandlerName)(contract.contractId, 1));
-        if (!call || !deliver)
-            throw new Error("handlers not registered");
-        const { ctx } = fakeContext();
-        const row = await call({ member: "table", name: "Notes", operation: "get", args: ["a"] }, ctx);
-        expect(Object.hasOwn(row, "note")).toBe(false);
-        const change = (await deliver({ member: "table", name: "Notes", value: { op: "insert", source: "local", dataObject: row } }, ctx));
-        expect(change.send).toBe(true);
-        expect(Object.hasOwn(change.value.dataObject, "note")).toBe(false);
-        await expect(call({ member: "table", name: "Notes", operation: "delete", args: ["a"] }, ctx)).resolves.toBeNull();
-    });
-    test("table overrides' rows and changes leave out empty fields, as stored rows do", async () => {
-        const tagsSchema = itemSchema.extend({ tag: zod_1.z.string().nullish(), data: zod_1.z.unknown() });
-        const empty = { tag: null, data: null };
-        const incoming = jest.fn();
-        const itemId = (0, peer_id_1.newid)();
-        class TagsTable extends table_1.PackageTable {
-            async save(row) {
-                incoming(row);
-                return super.save(row);
-            }
-            async get(id) {
-                return { itemId: id, title: "tag", hidden: false, ...empty };
-            }
-            async list() {
-                return [await this.get(itemId)];
-            }
-            dataChanged(event) {
-                incoming(event.dataObject);
-                return { ...event, dataObject: { ...event.dataObject, ...empty } };
-            }
-        }
-        const Tags = (0, table_1.defineTable)({
-            ...Items.definition,
-            name: "Tags",
-            schema: tagsSchema,
-            tableClass: TagsTable,
-        });
-        const contract = (0, define_package_1.defineContract)({
-            contractId: (0, peer_id_1.newid)(),
-            version: 1,
-            name: "Tags",
-            tables: [Tags],
-        });
-        const handlers = new Map();
-        (0, serve_members_1.serveContractMembers)(contract, (name, handler) => handlers.set(name, handler));
-        const call = handlers.get((0, contract_members_1.contractMemberHandlerName)(contract.contractId, 1));
-        const deliver = handlers.get((0, contract_members_1.contractDeliveryHandlerName)(contract.contractId, 1));
-        if (!call || !deliver)
-            throw new Error("handlers not registered");
-        const { ctx } = fakeContext();
-        // `data` isn't described field by field, so it keeps its null.
-        const row = { itemId, title: "tag", hidden: false, data: null };
-        await expect(call({ member: "table", name: "Tags", operation: "get", args: [itemId] }, ctx)).resolves.toStrictEqual(row);
-        await expect(call({ member: "table", name: "Tags", operation: "list", args: [] }, ctx)).resolves.toStrictEqual([row]);
-        const sent = { ...row, tag: null };
-        await expect(call({ member: "table", name: "Tags", operation: "save", args: [sent] }, ctx)).resolves.toStrictEqual(row);
-        expect(incoming).toHaveBeenLastCalledWith(row);
-        expect(sent).toHaveProperty("tag", null);
-        const change = { op: "insert", source: "local", dataObject: row };
-        await expect(deliver({ member: "table", name: "Tags", value: { ...change, dataObject: sent } }, ctx)).resolves.toStrictEqual({ send: true, value: change });
-        expect(incoming).toHaveBeenLastCalledWith(row);
-    });
-    test("observables read and write their sources", async () => {
-        const { call } = serve();
-        const { ctx, vars } = fakeContext();
-        await (0, observables_1.servePackageObservables)([Contract], ctx);
-        const observableCall = (name, operation, args = []) => Promise.resolve().then(() => call({ member: "observable", name, operation, args }, ctx));
-        await expect(observableCall("level", "get")).resolves.toBe(1);
-        await expect(observableCall("level", "set", [4])).resolves.toBe(4);
-        expect(level()).toBe(4);
-        await expect(observableCall("level", "set", [40])).rejects.toThrow();
-        expect(level()).toBe(4);
-        await expect(observableCall("theme", "get")).resolves.toBe("light");
-        await expect(observableCall("theme", "set", ["dark"])).resolves.toBe("dark");
-        expect(theme()).toBe("dark");
-        await expect(observableCall("stored", "get")).resolves.toBe("start");
-        await expect(observableCall("stored", "set", ["next"])).resolves.toBe("next");
-        expect(vars.get(JSON.stringify(["device", "stored"]))).toBe("next");
-        await expect(observableCall("stored", "subscribe")).resolves.toBeNull();
-    });
-    test("stored observable calls reject failed loads and saves, and later writes recover", async () => {
-        const { call } = serve();
-        const { ctx } = fakeContext();
-        let failRead = true;
-        let failWrite = false;
-        const failing = {
-            ...ctx,
-            watchOwnedPersistentVar: async () => () => { },
-            getOwnedPersistentVar: async () => {
-                if (failRead)
-                    throw new Error("storage read failed");
-                return "dark";
-            },
-            setOwnedPersistentVar: async () => {
-                if (failWrite)
-                    throw new Error("storage write failed");
-                return "dark";
-            },
-        };
-        const errors = jest.spyOn(console, "error").mockImplementation(() => { });
-        try {
-            await (0, vars_1.bindPackageVars)(failing);
-            const themeCall = (operation, args = []) => call({ member: "observable", name: "theme", operation, args }, failing);
-            await expect(themeCall("get")).rejects.toThrow("storage read failed");
-            failRead = false;
-            failWrite = true;
-            // The refresh succeeds, but must not hide the failed save.
-            await expect(themeCall("set", ["light"])).rejects.toThrow("storage write failed");
-            failWrite = false;
-            await expect(themeCall("set", ["dark"])).resolves.toBe("dark");
-            await expect(themeCall("get")).resolves.toBe("dark");
-        }
-        finally {
-            errors.mockRestore();
-        }
-    });
-    test("a stored observable write that persisted succeeds even when the refresh after it fails", async () => {
-        const { call } = serve();
-        const { ctx } = fakeContext();
-        let stored = "light";
-        let failRead = false;
-        const controlled = {
-            ...ctx,
-            watchOwnedPersistentVar: async () => () => { },
-            getOwnedPersistentVar: async () => {
-                if (failRead)
-                    throw new Error("storage read failed");
-                return stored;
-            },
-            setOwnedPersistentVar: async (_scope, _name, value) => {
-                stored = value;
-                // The save is done; the read that refreshes the mirror after it fails.
-                failRead = true;
-                return value;
-            },
-        };
-        await (0, vars_1.bindPackageVars)(controlled);
-        const errors = jest.spyOn(console, "error").mockImplementation(() => { });
-        try {
-            await expect(call({ member: "observable", name: "theme", operation: "set", args: ["dark"] }, controlled)).resolves.toBe("dark");
-            expect(stored).toBe("dark");
-            expect(errors).toHaveBeenCalledWith('Reading package variable "serve-members-theme" failed', expect.any(Error));
-        }
-        finally {
-            errors.mockRestore();
-        }
-    });
-    test("a stored observable read returns its storage result while a newer refresh is pending", async () => {
-        const { call } = serve();
-        const { ctx } = fakeContext();
-        let refresh;
-        const reads = [];
-        let holding = false;
-        const controlled = {
-            ...ctx,
-            watchOwnedPersistentVar: async (_scope, name, handler) => {
-                if (name === "serve-members-theme")
-                    refresh = handler;
-                return () => { };
-            },
-            getOwnedPersistentVar: async (_scope, name) => {
-                if (name !== "serve-members-theme" || !holding)
-                    return "light";
-                return new Promise((resolve) => reads.push(resolve));
-            },
-        };
-        await (0, vars_1.bindPackageVars)(controlled);
-        holding = true;
-        const reading = call({ member: "observable", name: "theme", operation: "get" }, controlled);
-        // Let the contract read issue its storage request, then start a newer watch refresh.
-        await Promise.resolve();
-        const refreshing = refresh?.();
-        expect(reads).toHaveLength(2);
-        reads[0]("dark");
-        try {
-            // The mirror is still "light": only the newer refresh may apply to it. That must
-            // not replace the value this contract read actually received from storage.
-            await expect(reading).resolves.toBe("dark");
-            expect(theme()).toBe("light");
-        }
-        finally {
-            reads[1]("dark");
-            await refreshing;
-        }
-        expect(theme()).toBe("dark");
-    });
-    test("a stored observable write replies with its own value when a later write fails", async () => {
-        const { call } = serve();
-        const { ctx } = fakeContext();
-        let stored = "light";
-        let release;
-        const firstSave = new Promise((resolve) => {
-            release = resolve;
-        });
-        const controlled = {
-            ...ctx,
-            watchOwnedPersistentVar: async () => () => { },
-            getOwnedPersistentVar: async () => stored,
-            setOwnedPersistentVar: async (_scope, _name, value) => {
-                if (value === "light")
-                    throw new Error("later save failed");
-                await firstSave;
-                stored = value;
-                return value;
-            },
-        };
-        await (0, vars_1.bindPackageVars)(controlled);
-        const write = (value) => call({ member: "observable", name: "theme", operation: "set", args: [value] }, controlled);
-        const errors = jest.spyOn(console, "error").mockImplementation(() => { });
-        try {
-            const first = write("dark");
-            const later = expect(write("light")).rejects.toThrow("later save failed");
-            release();
-            const reply = await first;
-            await later;
-            expect(stored).toBe("dark");
-            expect(reply).toBe("dark");
-        }
-        finally {
-            errors.mockRestore();
-        }
-    });
-    test.each([
-        true,
-        false,
-    ])("a subscriber's reentrant write cannot replace the contract save's result (first fails: %s)", async (firstFails) => {
-        const { call } = serve();
-        const { ctx } = fakeContext();
-        let stored = "light";
-        const controlled = {
-            ...ctx,
-            watchOwnedPersistentVar: async () => () => { },
-            getOwnedPersistentVar: async () => stored,
-            setOwnedPersistentVar: async (_scope, _name, value) => {
-                if ((value === "dark") === firstFails)
-                    throw new Error(`save ${value} failed`);
-                stored = value;
-                return value;
-            },
-        };
-        await (0, vars_1.bindPackageVars)(controlled);
-        const subscription = theme.subscribe((value) => {
-            if (value === "dark")
-                theme("light");
-        });
-        const errors = jest.spyOn(console, "error").mockImplementation(() => { });
-        try {
-            const writing = call({ member: "observable", name: "theme", operation: "set", args: ["dark"] }, controlled);
-            if (firstFails)
-                await expect(writing).rejects.toThrow("save dark failed");
-            else
-                await expect(writing).resolves.toBe("dark");
-            await theme.loadingPromise;
-            expect(stored).toBe(firstFails ? "light" : "dark");
-        }
-        finally {
-            subscription.dispose();
-            errors.mockRestore();
-        }
-    });
-    test("a queued stored write persists its captured value even if the package mutates the source", async () => {
-        const state = (0, vars_1.deviceVar)("serve-members-mutable", { defaultValue: { count: 0 } });
-        const Mutable = (0, define_package_1.defineContract)({
-            contractId: (0, peer_id_1.newid)(),
-            version: 1,
-            name: "Mutable",
-            observables: [
-                (0, observables_1.defineObservable)({
-                    name: "state",
-                    description: "Mutable state.",
-                    schema: zod_1.z.object({ count: zod_1.z.number() }),
-                    writable: true,
-                    source: state,
-                }),
-            ],
-        });
-        let call;
-        (0, serve_members_1.serveContractMembers)(Mutable, (name, handler) => {
-            if (name === (0, contract_members_1.contractMemberHandlerName)(Mutable.contractId, 1))
-                call = handler;
-        });
-        const { ctx } = fakeContext();
-        let stored = { count: 0 };
-        let writes = 0;
-        const controlled = {
-            ...ctx,
-            watchOwnedPersistentVar: async () => () => { },
-            getOwnedPersistentVar: async () => ({ ...stored }),
-            setOwnedPersistentVar: async (_scope, _name, value) => {
-                if (++writes > 1)
-                    throw new Error("later save failed");
-                stored = { ...value };
-                return stored;
-            },
-        };
-        await (0, vars_1.bindPackageVars)(controlled);
-        const errors = jest.spyOn(console, "error").mockImplementation(() => { });
-        try {
-            const first = call({ member: "observable", name: "state", operation: "set", args: [{ count: 1 }] }, controlled);
-            // A package can mutate its object and explicitly notify. That is a later write;
-            // it must not change the value captured by the already queued contract write.
-            state().count = 2;
-            state.notifySubscribers();
-            await expect(first).resolves.toEqual({ count: 1 });
-            await state.loadingPromise;
-            expect(stored).toEqual({ count: 1 });
-        }
-        finally {
-            errors.mockRestore();
-        }
-    });
-    test("a stored observable's pushed values leave out empty fields, as its reads do", async () => {
-        const place = (0, vars_1.deviceVar)("serve-members-place", { defaultValue: { city: "" } });
-        const Places = (0, define_package_1.defineContract)({
-            contractId: (0, peer_id_1.newid)(),
-            version: 1,
-            name: "Places",
-            observables: [
-                (0, observables_1.defineObservable)({
-                    name: "place",
-                    description: "A place.",
-                    schema: zod_1.z.object({ city: zod_1.z.string(), zone: zod_1.z.string().optional(), data: zod_1.z.unknown() }),
-                    source: place,
-                }),
-            ],
-        });
-        const handlers = new Map();
-        (0, serve_members_1.serveContractMembers)(Places, (name, handler) => handlers.set(name, handler));
-        const call = handlers.get((0, contract_members_1.contractMemberHandlerName)(Places.contractId, 1));
-        const deliver = handlers.get((0, contract_members_1.contractDeliveryHandlerName)(Places.contractId, 1));
-        if (!call || !deliver)
-            throw new Error("handlers not registered");
-        // Stored by the package's own code or an older build: the host pushes it from storage.
-        const stored = { city: "Austin", zone: null, data: null };
-        const { ctx } = fakeContext();
-        const controlled = {
-            ...ctx,
-            watchOwnedPersistentVar: async () => () => { },
-            getOwnedPersistentVar: async () => stored,
-        };
-        await (0, vars_1.bindPackageVars)(controlled);
-        const expected = { city: "Austin", data: null };
-        await expect(call({ member: "observable", name: "place", operation: "get", args: [] }, controlled)).resolves.toEqual(expected);
-        await expect(deliver({ member: "observable", name: "place", value: stored }, controlled)).resolves.toEqual({ send: true, value: expected });
-        expect(stored).toEqual({ city: "Austin", zone: null, data: null });
-    });
-});
-describe("guest API 3", () => {
-    test("a package declared with definePackage serves its own members", () => {
-        const manifest = (0, manifest_1.buildPackageManifest)((0, define_package_1.definePackage)((pkg) => {
-            pkg.packageId = (0, peer_id_1.newid)();
-            pkg.version = "1.0.0";
-            pkg.provides((0, define_package_1.defineContract)({ contractId: (0, peer_id_1.newid)(), version: 1, name: "C", tables: [Items] }));
-        }));
-        expect(manifest.guestApi).toBe(3);
-        expect((0, isolated_artifact_1.servesContractMembers)(manifest)).toBe(true);
-        expect((0, isolated_artifact_1.servesContractMembers)({ guestApi: 2 })).toBe(false);
-        const artifact = (guestApi) => ({
-            manifest: { ...manifest, guestApi },
-            providerSource: "/* provider */",
-        });
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact(2))).not.toThrow();
-        expect(() => (0, isolated_artifact_1.validateIsolatedPackageArtifact)(artifact(4))).toThrow("manifest.guestApi must be 2 or 3 when set");
-    });
-});

package/dist/define/vars.test.d.ts

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

package/dist/define/vars.test.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = require("./index");
-const vars_1 = require("./vars");
-test("the public variable helpers retain value types and reject persistence failures", async () => {
-    const variable = (0, index_1.deviceVar)("awaited", { defaultValue: 0 });
-    let stored = 0;
-    let failRead = false;
-    let failWrite = false;
-    const ctx = {
-        watchOwnedPersistentVar: async () => () => undefined,
-        getOwnedPersistentVar: async () => {
-            if (failRead)
-                throw new Error("durable read failed");
-            return stored;
-        },
-        setOwnedPersistentVar: async (_scope, _name, value) => {
-            if (failWrite)
-                throw new Error("durable save failed");
-            stored = value;
-        },
-    };
-    await (0, vars_1.bindPackageVars)(ctx);
-    const saved = await (0, index_1.writePackageVar)(variable, 7);
-    const read = await (0, index_1.readPackageVar)(variable);
-    expect([saved, read]).toEqual([7, 7]);
-    const errors = jest.spyOn(console, "error").mockImplementation(() => undefined);
-    try {
-        failWrite = true;
-        await expect((0, index_1.writePackageVar)(variable, 8)).rejects.toThrow("durable save failed");
-        failWrite = false;
-        await expect((0, index_1.writePackageVar)(variable, 9)).resolves.toBe(9);
-        failRead = true;
-        await expect((0, index_1.readPackageVar)(variable)).rejects.toThrow("durable read failed");
-    }
-    finally {
-        errors.mockRestore();
-    }
-});

package/dist/device/binary-peer-connection-v2.test.d.ts

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