@peers-app/peers-sdk 0.27.3 → 0.27.5

package/dist/data/orm/types.test.js

@@ -1,409 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const zod_1 = require("zod");
-const field_type_1 = require("../../types/field-type");
-const zod_types_1 = require("../../types/zod-types");
-const utils_1 = require("../../utils");
-const types_1 = require("./types");
-describe("types", () => {
-    it("fieldsToSchema", () => {
-        const someDate = new Date();
-        const groupFields = [
-            { name: "groupId", description: "The id of the group", type: field_type_1.FieldType.id },
-            { name: "groupName", description: "The name of the group", type: field_type_1.FieldType.string },
-            {
-                name: "groupDescription",
-                description: "The description of the group",
-                type: field_type_1.FieldType.string,
-            },
-            {
-                name: "createdAt",
-                description: "The date the group was created",
-                type: field_type_1.FieldType.Date,
-                defaultValue: () => someDate,
-            },
-            {
-                name: "owningUserIds",
-                description: "The ids of the users who own the group",
-                type: field_type_1.FieldType.string,
-                isArray: true,
-            },
-            {
-                name: "isPublic",
-                description: "Whether the group is public or private",
-                type: field_type_1.FieldType.boolean,
-                optional: true,
-            },
-            {
-                name: "fileIds",
-                description: "The ids of files attached to this chat entry",
-                type: field_type_1.FieldType.string,
-                isArray: true,
-                optional: true,
-            },
-        ];
-        const groupSchema = (0, types_1.fieldsToSchema)(groupFields);
-        const groupSchemaExpected = zod_1.z.object({
-            groupId: zod_1.z.string().describe("The id of the group"),
-            groupName: zod_1.z.string().describe("The name of the group"),
-            groupDescription: zod_1.z.string().describe("The description of the group"),
-            createdAt: zod_1.z
-                .date()
-                .describe("The date the group was created")
-                .default(() => someDate),
-            owningUserIds: zod_1.z.string().array().describe("The ids of the users who own the group"),
-            isPublic: zod_1.z.boolean().optional().describe("Whether the group is public or private"),
-            fileIds: zod_1.z
-                .string()
-                .array()
-                .optional()
-                .describe("The ids of files attached to this chat entry"),
-        });
-        const aGroup = {
-            groupId: (0, utils_1.newid)(),
-            groupName: "group",
-            groupDescription: "group description",
-            createdAt: new Date(),
-            owningUserIds: ["1"],
-            isPublic: true,
-        };
-        const aGroup2 = { ...aGroup, createdAt: undefined };
-        const r1 = groupSchema.parse(aGroup2);
-        const r1e = groupSchemaExpected.parse(aGroup2);
-        expect(r1.createdAt).toEqual(someDate);
-        expect(r1e.createdAt).toEqual(someDate);
-        // @ts-expect-error
-        delete aGroup.groupId;
-        expect(() => groupSchema.parse(aGroup)).toThrow("groupId");
-        expect(() => groupSchemaExpected.parse(aGroup)).toThrow("groupId");
-    });
-    it("schemaToFields", () => {
-        const groupSchema = zod_1.z.object({
-            groupId: zod_1.z.string().describe("The id of the group"),
-            groupName: zod_1.z.string().describe("The name of the group"),
-            groupDescription: zod_1.z.string().describe("The description of the group"),
-            createdAt: zod_1.z.date().describe("The date the group was created"), //.default(() => new Date()),
-            owningUserIds: zod_1.z.string().array().describe("The ids of the users who own the group"),
-            isPublic: zod_1.z.boolean().optional().describe("Whether the group is public or private"),
-            instructionResults: zod_1.z
-                .any()
-                .array()
-                .describe("The results of the instructions that have been run."),
-            fileIds: zod_1.z
-                .string()
-                .array()
-                .optional()
-                .describe("The ids of files attached to this chat entry"),
-        });
-        const groupFields = (0, types_1.schemaToFields)(groupSchema);
-        const groupFieldsExpected = [
-            { name: "groupId", description: "The id of the group", type: field_type_1.FieldType.string },
-            { name: "groupName", description: "The name of the group", type: field_type_1.FieldType.string },
-            {
-                name: "groupDescription",
-                description: "The description of the group",
-                type: field_type_1.FieldType.string,
-            },
-            { name: "createdAt", description: "The date the group was created", type: field_type_1.FieldType.Date }, //defaultValue: () => new Date() },
-            {
-                name: "owningUserIds",
-                description: "The ids of the users who own the group",
-                type: field_type_1.FieldType.string,
-                isArray: true,
-            },
-            {
-                name: "isPublic",
-                description: "Whether the group is public or private",
-                type: field_type_1.FieldType.boolean,
-                optional: true,
-            },
-            {
-                name: "instructionResults",
-                description: "The results of the instructions that have been run.",
-                type: field_type_1.FieldType.any,
-                isArray: true,
-            },
-            {
-                name: "fileIds",
-                description: "The ids of files attached to this chat entry",
-                type: field_type_1.FieldType.string,
-                isArray: true,
-                optional: true,
-            },
-        ];
-        expect(groupFields).toEqual(groupFieldsExpected);
-    });
-    it("schemaToFields should detect zodPeerId as FieldType.id", () => {
-        const schema = zod_1.z.object({
-            recordId: zod_types_1.zodPeerId.describe("A peer id field"),
-            optionalRef: zod_types_1.zodPeerId.optional().describe("An optional peer id"),
-        });
-        const fields = (0, types_1.schemaToFields)(schema);
-        expect(fields.find((f) => f.name === "recordId")?.type).toBe(field_type_1.FieldType.id);
-        expect(fields.find((f) => f.name === "optionalRef")?.type).toBe(field_type_1.FieldType.id);
-    });
-    it("schemaToFields should NOT classify plain z.string() as id just because name ends in Id", () => {
-        const schema = zod_1.z.object({
-            externalId: zod_1.z.string().describe("An external system identifier"),
-            channelId: zod_1.z.string().describe("A channel reference"),
-            name: zod_1.z.string().describe("A plain string"),
-        });
-        const fields = (0, types_1.schemaToFields)(schema);
-        expect(fields.find((f) => f.name === "externalId")?.type).toBe(field_type_1.FieldType.string);
-        expect(fields.find((f) => f.name === "channelId")?.type).toBe(field_type_1.FieldType.string);
-        expect(fields.find((f) => f.name === "name")?.type).toBe(field_type_1.FieldType.string);
-    });
-    it("schemaToFields should NOT classify a non-id string refinement as FieldType.id", () => {
-        const zodEmail = zod_1.z.string().refine((val) => val.includes("@"), { message: "Must be an email" });
-        const zodNonEmpty = zod_1.z
-            .string()
-            .refine((val) => val.length > 0, { message: "Must not be empty" });
-        const schema = zod_1.z.object({
-            email: zodEmail.describe("An email address"),
-            requiredField: zodNonEmpty.describe("A non-empty string"),
-            peerId: zod_types_1.zodPeerId.describe("A real peer id"),
-        });
-        const fields = (0, types_1.schemaToFields)(schema);
-        expect(fields.find((f) => f.name === "email")?.type).toBe(field_type_1.FieldType.string);
-        expect(fields.find((f) => f.name === "requiredField")?.type).toBe(field_type_1.FieldType.string);
-        expect(fields.find((f) => f.name === "peerId")?.type).toBe(field_type_1.FieldType.id);
-    });
-    it("fieldsToSchema should merge with optional code schema for most-constrained validation", () => {
-        const codeSchema = zod_1.z.object({
-            recordId: zod_types_1.zodPeerId.describe("A peer id"),
-            label: zod_1.z.string().min(1).describe("Non-empty label"),
-        });
-        const fields = [
-            { name: "recordId", description: "A peer id", type: field_type_1.FieldType.string },
-            { name: "label", description: "Non-empty label", type: field_type_1.FieldType.string },
-        ];
-        const mergedSchema = (0, types_1.fieldsToSchema)(fields, codeSchema);
-        const validId = (0, utils_1.newid)();
-        // Valid peer id should pass the merged schema
-        expect(() => mergedSchema.parse({ recordId: validId, label: "hello" })).not.toThrow();
-        // Empty string should fail: the code schema's zodPeerId rejects it
-        expect(() => mergedSchema.parse({ recordId: "", label: "hello" })).toThrow();
-        // Empty label should fail: the code schema's .min(1) rejects it
-        expect(() => mergedSchema.parse({ recordId: validId, label: "" })).toThrow();
-    });
-    it("round-trip: fieldsToSchema id fields should survive schemaToFields detection", () => {
-        // fieldsToSchema creates z.string().refine(isid) for FieldType.id fields.
-        // schemaToFields should detect that refinement as FieldType.id so round-trips are consistent.
-        const fields = [
-            { name: "recordId", description: "A peer id", type: field_type_1.FieldType.id },
-            { name: "label", description: "A label", type: field_type_1.FieldType.string },
-        ];
-        const schema = (0, types_1.fieldsToSchema)(fields);
-        const roundTrippedFields = (0, types_1.schemaToFields)(schema);
-        expect(roundTrippedFields.find((f) => f.name === "recordId")?.type).toBe(field_type_1.FieldType.id);
-        expect(roundTrippedFields.find((f) => f.name === "label")?.type).toBe(field_type_1.FieldType.string);
-    });
-    it("fieldsToSchema merge should handle optional zodPeerId fields correctly", () => {
-        const codeSchema = zod_1.z.object({
-            ownerId: zod_types_1.zodPeerId.describe("The owner"),
-            referrerId: zod_types_1.zodPeerId.optional().describe("Optional referrer"),
-        });
-        const fields = [
-            { name: "ownerId", description: "The owner", type: field_type_1.FieldType.string },
-            {
-                name: "referrerId",
-                description: "Optional referrer",
-                type: field_type_1.FieldType.string,
-                optional: true,
-            },
-        ];
-        const mergedSchema = (0, types_1.fieldsToSchema)(fields, codeSchema);
-        const validId = (0, utils_1.newid)();
-        const validId2 = (0, utils_1.newid)();
-        // Both provided and valid
-        expect(() => mergedSchema.parse({ ownerId: validId, referrerId: validId2 })).not.toThrow();
-        // Optional field omitted
-        expect(() => mergedSchema.parse({ ownerId: validId })).not.toThrow();
-        // Optional field present but invalid
-        expect(() => mergedSchema.parse({ ownerId: validId, referrerId: "not-a-valid-id" })).toThrow();
-        // Required field missing
-        expect(() => mergedSchema.parse({ referrerId: validId })).toThrow();
-        // Required field invalid
-        expect(() => mergedSchema.parse({ ownerId: "bad", referrerId: validId })).toThrow();
-    });
-    it("initRecord pattern: code schema defaults should work even after JSON round-trip of fields", () => {
-        const codeSchema = zod_1.z.object({
-            recordId: zod_types_1.zodPeerId.describe("A peer id"),
-            label: zod_1.z.string().default("untitled").describe("A label with default"),
-            createdAt: zod_1.z
-                .date()
-                .default(() => new Date())
-                .describe("Date with factory default"),
-            count: zod_1.z.number().default(0).describe("A count with default"),
-        });
-        // Simulate the real flow: code schema -> fields -> JSON (sync) -> parse back
-        const fields = (0, types_1.schemaToFields)(codeSchema);
-        const fieldsAfterJson = JSON.parse(JSON.stringify(fields));
-        // Function defaults like () => new Date() are lost through JSON
-        const mergedSchema = (0, types_1.fieldsToSchema)(fieldsAfterJson, codeSchema);
-        const validId = (0, utils_1.newid)();
-        const data = { recordId: validId };
-        // Simulate what Table.initRecord does: apply code schema first for defaults,
-        // then fall back to merged schema
-        const defaults = {};
-        const shape = codeSchema.shape;
-        for (const field of fieldsAfterJson) {
-            if (shape[field.name]) {
-                const codeValue = shape[field.name].safeParse(data[field.name]);
-                if (codeValue.success) {
-                    defaults[field.name] = codeValue.data;
-                    continue;
-                }
-            }
-            const zodField = mergedSchema.shape[field.name];
-            const value = zodField.safeParse(data[field.name]);
-            if (value.success) {
-                defaults[field.name] = value.data;
-            }
-        }
-        const result = { ...defaults, ...data };
-        expect(result.label).toBe("untitled");
-        expect(result.createdAt).toBeInstanceOf(Date);
-        expect(result.count).toBe(0);
-        expect(result.recordId).toBe(validId);
-    });
-    it("fieldsToSchema without code schema should work as before", () => {
-        const fields = [
-            { name: "recordId", description: "A peer id", type: field_type_1.FieldType.id },
-            { name: "label", description: "A label", type: field_type_1.FieldType.string },
-        ];
-        const schema = (0, types_1.fieldsToSchema)(fields);
-        const validId = (0, utils_1.newid)();
-        expect(() => schema.parse({ recordId: validId, label: "hello" })).not.toThrow();
-        expect(() => schema.parse({ recordId: "", label: "hello" })).toThrow();
-    });
-    describe("the richer IR", () => {
-        const fields = [
-            { name: "mode", type: field_type_1.FieldType.string, enumValues: ["on", "off"] },
-            { name: "note", type: field_type_1.FieldType.string, optional: true },
-            {
-                name: "where",
-                type: field_type_1.FieldType.object,
-                fields: [
-                    { name: "city", type: field_type_1.FieldType.string },
-                    { name: "unit", type: field_type_1.FieldType.string, enumValues: ["F", "C"], optional: true },
-                ],
-            },
-            { name: "tags", type: field_type_1.FieldType.object, isArray: true },
-        ];
-        const valid = {
-            mode: "on",
-            where: { city: "Austin", unit: "F", extra: 1 },
-            tags: [{ a: 1 }],
-        };
-        it("fieldsToSchema checks types and keeps an object's keys", () => {
-            const schema = (0, types_1.fieldsToSchema)(fields);
-            expect(schema.parse(valid)).toEqual(valid);
-            // An empty optional field is removed first (withoutEmptyFields); null itself isn't a value.
-            expect(schema.safeParse({ ...valid, note: null }).success).toBe(false);
-            // Enum values and nested fields describe; the Runtime doesn't enforce them.
-            expect(schema.safeParse({ ...valid, mode: "dim", where: { city: 3 } }).success).toBe(true);
-            expect(schema.safeParse({ ...valid, mode: 1 }).success).toBe(false);
-            expect(schema.safeParse({ ...valid, mode: null }).success).toBe(false);
-            expect(schema.safeParse({ ...valid, where: "Austin" }).success).toBe(false);
-        });
-        it("fieldsToSchema still defers an object to an intersected author schema", () => {
-            const codeSchema = zod_1.z.object({ when: zod_1.z.object({ at: zod_1.z.coerce.date() }) });
-            const schema = (0, types_1.fieldsToSchema)([{ name: "when", type: field_type_1.FieldType.object }], codeSchema);
-            expect(schema.parse({ when: { at: "2026-01-01" } }).when.at).toBeInstanceOf(Date);
-        });
-        it("fieldsToShapeSchema checks enum values and nested fields", () => {
-            const schema = (0, types_1.fieldsToShapeSchema)(fields);
-            expect(schema.parse(valid)).toEqual(valid);
-            expect(schema.safeParse({ ...valid, mode: "dim" }).success).toBe(false);
-            expect(schema.safeParse({ ...valid, where: { city: 3 } }).success).toBe(false);
-            expect(schema.safeParse({ ...valid, where: { city: "Austin", unit: "K" } }).success).toBe(false);
-            const mixed = (0, types_1.fieldsToShapeSchema)([
-                { name: "size", type: field_type_1.FieldType.any, enumValues: [1, "large", true] },
-                { name: "one", type: field_type_1.FieldType.number, enumValues: [3] },
-            ]);
-            expect(mixed.safeParse({ size: true, one: 3 }).success).toBe(true);
-            expect(mixed.safeParse({ size: false, one: 3 }).success).toBe(false);
-            expect(mixed.safeParse({ size: 1, one: 4 }).success).toBe(false);
-        });
-        it("comparableTableFields keeps only the keys a table version is compared on", () => {
-            expect((0, types_1.comparableTableFields)([
-                {
-                    type: field_type_1.FieldType.object,
-                    name: "where",
-                    defaultValue: {},
-                    fields: [],
-                    enumValues: ["x"],
-                    optional: true,
-                    future: 1,
-                },
-            ])).toEqual([{ name: "where", type: field_type_1.FieldType.object, optional: true }]);
-        });
-    });
-    describe("withoutEmptyFields", () => {
-        const fields = [
-            { name: "title", type: field_type_1.FieldType.string },
-            { name: "note", type: field_type_1.FieldType.string, optional: true },
-            {
-                name: "where",
-                type: field_type_1.FieldType.object,
-                optional: true,
-                fields: [
-                    { name: "city", type: field_type_1.FieldType.string },
-                    { name: "unit", type: field_type_1.FieldType.string, optional: true },
-                ],
-            },
-            {
-                name: "stops",
-                type: field_type_1.FieldType.object,
-                isArray: true,
-                fields: [{ name: "at", type: field_type_1.FieldType.string, optional: true }],
-            },
-            { name: "data", type: field_type_1.FieldType.any, optional: true },
-        ];
-        it("removes null and undefined optional fields, in declared nested fields too", () => {
-            const value = {
-                title: "a",
-                note: null,
-                where: { city: "Austin", unit: null },
-                stops: [{ at: null }, { at: "noon" }],
-                data: { inner: null },
-                extra: null,
-            };
-            expect((0, types_1.withoutEmptyFields)(fields, value)).toEqual({
-                title: "a",
-                where: { city: "Austin" },
-                stops: [{}, { at: "noon" }],
-                // Values the fields don't describe, and keys they don't list, are left as they are.
-                data: { inner: null },
-                extra: null,
-            });
-            expect(value.note).toBeNull();
-            expect(value.where.unit).toBeNull();
-            expect((0, types_1.withoutEmptyFields)(fields, { ...value, note: undefined, where: null })).not.toHaveProperty("where");
-        });
-        it("keeps an empty required field, and returns the value itself when nothing is removed", () => {
-            const required = { title: null, stops: [] };
-            expect((0, types_1.withoutEmptyFields)(fields, required)).toBe(required);
-            const clean = { title: "a", where: { city: "Austin" }, stops: [{ at: "noon" }] };
-            expect((0, types_1.withoutEmptyFields)(fields, clean)).toBe(clean);
-            expect((0, types_1.withoutEmptyFields)(fields, null)).toBeNull();
-            expect((0, types_1.withoutEmptyFields)(fields, ["a"])).toEqual(["a"]);
-        });
-        it("deletes own undefined keys at every described depth", () => {
-            const value = { note: undefined, where: { unit: undefined }, stops: [{ at: undefined }] };
-            const cleaned = (0, types_1.withoutEmptyFields)(fields, value);
-            expect(cleaned).toStrictEqual({ where: {}, stops: [{}] });
-            expect(value).toHaveProperty("note");
-            expect(value.where).toHaveProperty("unit");
-        });
-        it("lets parsing fill a default for null just as for a missing field", () => {
-            const defaulted = [{ name: "rank", type: field_type_1.FieldType.number, defaultValue: 5 }];
-            for (const value of [{ rank: null }, { rank: undefined }, {}]) {
-                const cleaned = (0, types_1.withoutEmptyFields)(defaulted, value);
-                expect(cleaned).toStrictEqual({});
-                expect((0, types_1.fieldsToSchema)(defaulted).parse(cleaned)).toStrictEqual({ rank: 5 });
-            }
-        });
-    });
-});

package/dist/data/package-table-identity.test.d.ts

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

package/dist/data/package-table-identity.test.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("../utils");
-const package_table_identity_1 = require("./package-table-identity");
-describe("package-scoped table identity", () => {
-    test("appends trusted package identity to the logical table name", () => {
-        const packageId = (0, utils_1.newid)();
-        const tableId = (0, package_table_identity_1.packageScopedTableId)(packageId, "Settings");
-        const metaData = {
-            packageId,
-            tableId,
-            name: "Settings",
-            description: "Package settings",
-            primaryKeyName: "settingId",
-            fields: [],
-        };
-        expect((0, package_table_identity_1.packageScopedTableName)(packageId, "Settings")).toBe(`Settings_${packageId}`);
-        expect((0, utils_1.getFullTableName)(metaData)).toBe(`Settings_${packageId}`);
-        expect((0, utils_1.getFullTableName)(metaData)).not.toContain(tableId);
-        expect((0, utils_1.isid)(tableId)).toBe(true);
-        expect((0, utils_1.isDeterministicTableId)(tableId)).toBe(true);
-    });
-    test("keeps existing table naming unchanged", () => {
-        const tableId = (0, utils_1.newid)();
-        expect((0, utils_1.getFullTableName)({
-            tableId,
-            name: "Settings",
-            description: "Existing table",
-            primaryKeyName: "settingId",
-            fields: [],
-        })).toBe(`Settings_${tableId}`);
-    });
-    test("uses package and logical name for stable internal IDs", () => {
-        const packageId = (0, utils_1.newid)();
-        expect((0, package_table_identity_1.packageScopedTableId)(packageId, "One")).toBe((0, package_table_identity_1.packageScopedTableId)(packageId, "One"));
-        expect((0, package_table_identity_1.packageScopedTableId)(packageId, "One")).not.toBe((0, package_table_identity_1.packageScopedTableId)(packageId, "Two"));
-        expect((0, package_table_identity_1.packageScopedTableId)(packageId, "One")).not.toBe((0, package_table_identity_1.packageScopedTableId)((0, utils_1.newid)(), "One"));
-    });
-    test("rejects invalid package IDs and empty logical names", () => {
-        expect(() => (0, package_table_identity_1.packageScopedTableName)("not-an-id", "Settings")).toThrow(/package ID/);
-        expect(() => (0, package_table_identity_1.packageScopedTableName)((0, utils_1.newid)(), " ")).toThrow(/non-empty/);
-        expect(() => (0, package_table_identity_1.packageScopedTableName)((0, utils_1.newid)(), 'State"; DROP TABLE Users; --')).toThrow(/only letters, numbers, and underscores/);
-        expect((0, package_table_identity_1.validateIsolatedSqlIdentifier)("state_value", "field")).toBe("state_value");
-        expect(() => (0, package_table_identity_1.validateIsolatedSqlIdentifier)("state.value", "field")).toThrow(/field/);
-    });
-});

package/dist/data/package-version-permissions.test.d.ts

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

package/dist/data/package-version-permissions.test.js

@@ -1,107 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const keys_1 = require("../keys");
-const utils_1 = require("../utils");
-const group_member_roles_1 = require("./group-member-roles");
-const package_version_permissions_1 = require("./package-version-permissions");
-describe("Package Version Permissions", () => {
-    const writerKeys = (0, keys_1.newKeys)();
-    const adminKeys = (0, keys_1.newKeys)();
-    function makePV(overrides = {}) {
-        return {
-            packageVersionId: (0, utils_1.newid)(),
-            packageId: (0, utils_1.newid)(),
-            version: "1.0.0",
-            versionTag: "dev",
-            packageVersionHash: "testhash",
-            packageBundleFileId: (0, utils_1.newid)(),
-            packageBundleFileHash: "bundlehash",
-            signature: "",
-            createdBy: (0, utils_1.newid)(),
-            createdAt: new Date().toISOString(),
-            ...overrides,
-        };
-    }
-    describe("dev versions", () => {
-        it("allows Writer to sign a dev version", async () => {
-            const pv = (0, keys_1.addSignatureToObject)(makePV({ versionTag: "dev" }), writerKeys.secretKey);
-            await expect((0, package_version_permissions_1.verifyPackageVersionSignature)(pv, "test-group", group_member_roles_1.GroupMemberRole.Writer)).resolves.toBeUndefined();
-        });
-        it("allows Admin to sign a dev version", async () => {
-            const pv = (0, keys_1.addSignatureToObject)(makePV({ versionTag: "dev" }), adminKeys.secretKey);
-            await expect((0, package_version_permissions_1.verifyPackageVersionSignature)(pv, "test-group", group_member_roles_1.GroupMemberRole.Admin)).resolves.toBeUndefined();
-        });
-        it("rejects Reader signing a dev version", async () => {
-            const pv = (0, keys_1.addSignatureToObject)(makePV({ versionTag: "dev" }), writerKeys.secretKey);
-            await expect((0, package_version_permissions_1.verifyPackageVersionSignature)(pv, "test-group", group_member_roles_1.GroupMemberRole.Reader)).rejects.toThrow("Only group writers or above");
-        });
-    });
-    describe("beta versions", () => {
-        it("allows Admin to sign a beta version", async () => {
-            const pv = (0, keys_1.addSignatureToObject)(makePV({ versionTag: "beta" }), adminKeys.secretKey);
-            await expect((0, package_version_permissions_1.verifyPackageVersionSignature)(pv, "test-group", group_member_roles_1.GroupMemberRole.Admin)).resolves.toBeUndefined();
-        });
-        it("allows Owner to sign a beta version", async () => {
-            const pv = (0, keys_1.addSignatureToObject)(makePV({ versionTag: "beta" }), adminKeys.secretKey);
-            await expect((0, package_version_permissions_1.verifyPackageVersionSignature)(pv, "test-group", group_member_roles_1.GroupMemberRole.Owner)).resolves.toBeUndefined();
-        });
-        it("rejects Writer signing a beta version", async () => {
-            const pv = (0, keys_1.addSignatureToObject)(makePV({ versionTag: "beta" }), writerKeys.secretKey);
-            await expect((0, package_version_permissions_1.verifyPackageVersionSignature)(pv, "test-group", group_member_roles_1.GroupMemberRole.Writer)).rejects.toThrow("Only group admins can create or update beta/stable");
-        });
-    });
-    describe("stable versions", () => {
-        it("allows Admin to sign a stable version", async () => {
-            const pv = (0, keys_1.addSignatureToObject)(makePV({ versionTag: "stable" }), adminKeys.secretKey);
-            await expect((0, package_version_permissions_1.verifyPackageVersionSignature)(pv, "test-group", group_member_roles_1.GroupMemberRole.Admin)).resolves.toBeUndefined();
-        });
-        it("rejects Writer signing a stable version", async () => {
-            const pv = (0, keys_1.addSignatureToObject)(makePV({ versionTag: "stable" }), writerKeys.secretKey);
-            await expect((0, package_version_permissions_1.verifyPackageVersionSignature)(pv, "test-group", group_member_roles_1.GroupMemberRole.Writer)).rejects.toThrow("Only group admins can create or update beta/stable");
-        });
-    });
-    describe("promotion scenarios (dev → beta → stable)", () => {
-        it("rejects Writer promoting dev to beta", async () => {
-            const devPV = makePV({ versionTag: "dev" });
-            const promoted = { ...devPV, versionTag: "beta" };
-            const signed = (0, keys_1.addSignatureToObject)(promoted, writerKeys.secretKey);
-            await expect((0, package_version_permissions_1.verifyPackageVersionSignature)(signed, "test-group", group_member_roles_1.GroupMemberRole.Writer)).rejects.toThrow("Only group admins can create or update beta/stable");
-        });
-        it("rejects Writer promoting dev to stable", async () => {
-            const devPV = makePV({ versionTag: "dev" });
-            const promoted = { ...devPV, versionTag: "stable" };
-            const signed = (0, keys_1.addSignatureToObject)(promoted, writerKeys.secretKey);
-            await expect((0, package_version_permissions_1.verifyPackageVersionSignature)(signed, "test-group", group_member_roles_1.GroupMemberRole.Writer)).rejects.toThrow("Only group admins can create or update beta/stable");
-        });
-        it("rejects Writer promoting beta to stable", async () => {
-            const betaPV = makePV({ versionTag: "beta" });
-            const promoted = { ...betaPV, versionTag: "stable" };
-            const signed = (0, keys_1.addSignatureToObject)(promoted, writerKeys.secretKey);
-            await expect((0, package_version_permissions_1.verifyPackageVersionSignature)(signed, "test-group", group_member_roles_1.GroupMemberRole.Writer)).rejects.toThrow("Only group admins can create or update beta/stable");
-        });
-        it("allows Admin promoting dev to beta", async () => {
-            const devPV = makePV({ versionTag: "dev" });
-            const promoted = { ...devPV, versionTag: "beta" };
-            const signed = (0, keys_1.addSignatureToObject)(promoted, adminKeys.secretKey);
-            await expect((0, package_version_permissions_1.verifyPackageVersionSignature)(signed, "test-group", group_member_roles_1.GroupMemberRole.Admin)).resolves.toBeUndefined();
-        });
-        it("allows Admin promoting beta to stable", async () => {
-            const betaPV = makePV({ versionTag: "beta" });
-            const promoted = { ...betaPV, versionTag: "stable" };
-            const signed = (0, keys_1.addSignatureToObject)(promoted, adminKeys.secretKey);
-            await expect((0, package_version_permissions_1.verifyPackageVersionSignature)(signed, "test-group", group_member_roles_1.GroupMemberRole.Admin)).resolves.toBeUndefined();
-        });
-    });
-    describe("signature tampering", () => {
-        it("rejects a tampered package version", async () => {
-            const pv = (0, keys_1.addSignatureToObject)(makePV({ versionTag: "dev" }), writerKeys.secretKey);
-            pv.version = "9.9.9";
-            await expect((0, package_version_permissions_1.verifyPackageVersionSignature)(pv, "test-group", group_member_roles_1.GroupMemberRole.Admin)).rejects.toThrow();
-        });
-        it("rejects a version with tag changed after signing", async () => {
-            const pv = (0, keys_1.addSignatureToObject)(makePV({ versionTag: "dev" }), writerKeys.secretKey);
-            pv.versionTag = "stable";
-            await expect((0, package_version_permissions_1.verifyPackageVersionSignature)(pv, "test-group", group_member_roles_1.GroupMemberRole.Admin)).rejects.toThrow();
-        });
-    });
-});

package/dist/data/package-version-resolver.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Regression tests for device-local package version resolution.
- */
-export {};