@peers-app/peers-sdk 0.20.2 → 0.20.3

package/dist/context/user-context.d.ts

@@ -3,6 +3,7 @@ import { type IUser } from "../data";
 import type { DataSourceFactory, IDataChangedEvent, Table } from "../data/orm";
 import { type IPublicPrivateKeys } from "../keys";
 import { type Observable } from "../observable";
+/** Coordinates personal and group data contexts for one signed-in user. */
 export declare class UserContext {
     readonly userId: string;
     readonly dataSourceFactory: DataSourceFactory;
@@ -16,6 +17,8 @@ export declare class UserContext {
     readonly defaultDataContext: Observable<DataContext>;
     readonly loadingPromise: Promise<UserContext>;
     private personalUserSubscription?;
+    private ownUserSubscription?;
+    private groupUserSyncs;
     private _currentlyActiveGroupIdPVar?;
     constructor(userId: string, dataSourceFactory: DataSourceFactory, ephemeral?: boolean | undefined);
     private init;
@@ -42,11 +45,14 @@ export declare class UserContext {
         signature?: string | undefined;
     } | undefined>;
     syncUserAndGroupObjects(userId: string, keys: IPublicPrivateKeys, me?: IUser): Promise<void>;
+    private syncMyUserToAllGroups;
+    private syncMyUserToGroup;
     subscribeToDataChangedAcrossAllGroups<T extends {
         [key: string]: any;
     }>(table: string | Table<T>, handler: (evt: ICrossGroupSubscriptionHandlerArgs<T>) => any): import("../events").ISubscriptionResult;
     dispose(): void;
 }
+/** Event payload supplied to subscriptions spanning every group data context. */
 export interface ICrossGroupSubscriptionHandlerArgs<T> {
     name: string;
     userContext: UserContext;

package/dist/context/user-context.js

@@ -8,6 +8,7 @@ const events_1 = require("../events");
 const keys_1 = require("../keys");
 const observable_1 = require("../observable");
 const utils_1 = require("../utils");
+/** Coordinates personal and group data contexts for one signed-in user. */
 class UserContext {
     userId;
     dataSourceFactory;
@@ -21,6 +22,8 @@ class UserContext {
     defaultDataContext;
     loadingPromise;
     personalUserSubscription;
+    ownUserSubscription;
+    groupUserSyncs = new Map();
     _currentlyActiveGroupIdPVar;
     constructor(userId, dataSourceFactory, ephemeral) {
         this.userId = userId;
@@ -69,7 +72,10 @@ class UserContext {
                 this.groupDataContexts.delete(groupId);
             }
             else {
-                this.getDataContext(groupId);
+                const dataContext = this.getDataContext(groupId);
+                void this.syncMyUserToGroup(dataContext).catch((error) => {
+                    console.error(`Error syncing current user to new group ${groupId}:`, error);
+                });
             }
         });
         // load up group data contexts and set currently active group
@@ -182,6 +188,7 @@ class UserContext {
                 publicBoxKey: "",
             };
         }
+        me.name = me.name.slice(0, data_1.DISPLAY_NAME_MAX_LENGTH);
         me.publicKey = keys.publicKey;
         me.publicBoxKey = keys.publicBoxKey;
         const meSigned = (0, keys_1.addSignatureToObject)(me, keys.secretKey);
@@ -190,13 +197,7 @@ class UserContext {
             (0, keys_1.verifyObjectSignature)(meSigned);
             await (0, data_1.Users)(this.userDataContext).save(meSigned, { weakInsert: true });
         }
-        // sync my user to all my groups
-        for (const [, dataContext] of this.groupDataContexts) {
-            const groupMe = await (0, data_1.Users)(dataContext).get(me.userId);
-            if (!(0, lodash_1.isEqual)(groupMe, meSigned)) {
-                await (0, data_1.Users)(dataContext).save(meSigned, { weakInsert: true });
-            }
-        }
+        await this.syncMyUserToAllGroups();
         // sync group objects to my personal db
         for (const [, dataContext] of this.groupDataContexts) {
             if (!dataContext.groupId) {
@@ -234,6 +235,44 @@ class UserContext {
                 }
             });
         }
+        if (!this.ownUserSubscription) {
+            this.ownUserSubscription = (0, data_1.Users)(this.userDataContext).dataChanged.subscribe((evt) => {
+                if (evt.op === "delete" || evt.dataObject.userId !== this.userId) {
+                    return;
+                }
+                void this.syncMyUserToAllGroups().catch((error) => {
+                    console.error(`Error syncing current user ${this.userId} to groups:`, error);
+                });
+            });
+        }
+    }
+    async syncMyUserToAllGroups() {
+        await Promise.all(Array.from(this.groupDataContexts.values(), (dataContext) => this.syncMyUserToGroup(dataContext)));
+    }
+    async syncMyUserToGroup(dataContext) {
+        const contextId = dataContext.dataContextId;
+        const previousSync = this.groupUserSyncs.get(contextId);
+        const currentSync = (previousSync ?? Promise.resolve())
+            .catch(() => undefined)
+            .then(async () => {
+            const currentUser = await (0, data_1.Users)(this.userDataContext).get(this.userId);
+            if (!currentUser) {
+                return;
+            }
+            const groupMe = await (0, data_1.Users)(dataContext).get(currentUser.userId);
+            if (!(0, lodash_1.isEqual)(groupMe, currentUser)) {
+                await (0, data_1.Users)(dataContext).save(currentUser, { weakInsert: true });
+            }
+        });
+        this.groupUserSyncs.set(contextId, currentSync);
+        try {
+            await currentSync;
+        }
+        finally {
+            if (this.groupUserSyncs.get(contextId) === currentSync) {
+                this.groupUserSyncs.delete(contextId);
+            }
+        }
     }
     subscribeToDataChangedAcrossAllGroups(table, handler) {
         const tableName = typeof table === "string" ? table : table.tableName;
@@ -258,6 +297,7 @@ class UserContext {
     }
     dispose() {
         this.personalUserSubscription?.unsubscribe();
+        this.ownUserSubscription?.unsubscribe();
     }
 }
 exports.UserContext = UserContext;

package/dist/data/devices.d.ts

@@ -1,12 +1,18 @@
 import { z } from "zod";
 import type { DataContext } from "../context/data-context";
 import { TrustLevel } from "../device/socket.type";
+/** Maximum number of JavaScript string code units accepted for display names. */
+export declare const DISPLAY_NAME_MAX_LENGTH = 128;
+/** Shared schema for bounded user and device display names. */
+export declare const displayNameSchema: z.ZodString;
+/** Schema for a persisted, context-scoped device record. */
 export declare const deviceSchema: z.ZodObject<{
     deviceId: z.ZodEffects<z.ZodString, string, string>;
     userId: z.ZodEffects<z.ZodString, string, string>;
     firstSeen: z.ZodDate;
     lastSeen: z.ZodDate;
     name: z.ZodOptional<z.ZodString>;
+    reportedName: z.ZodOptional<z.ZodString>;
     serverUrl: z.ZodOptional<z.ZodString>;
     trustLevel: z.ZodNativeEnum<typeof TrustLevel>;
 }, "strip", z.ZodTypeAny, {
@@ -16,6 +22,7 @@ export declare const deviceSchema: z.ZodObject<{
     lastSeen: Date;
     trustLevel: TrustLevel;
     name?: string | undefined;
+    reportedName?: string | undefined;
     serverUrl?: string | undefined;
 }, {
     userId: string;
@@ -24,20 +31,72 @@ export declare const deviceSchema: z.ZodObject<{
     lastSeen: Date;
     trustLevel: TrustLevel;
     name?: string | undefined;
+    reportedName?: string | undefined;
     serverUrl?: string | undefined;
 }>;
+/** A context-scoped device record containing local state and owner-reported metadata. */
 export type IDevice = z.infer<typeof deviceSchema>;
-export interface IDeviceInfo {
+/** Schema for the signed identity and bounded presentation hints exchanged by devices. */
+export declare const deviceInfoSchema: z.ZodObject<{
+    userId: z.ZodEffects<z.ZodString, string, string>;
+    deviceId: z.ZodEffects<z.ZodString, string, string>;
+    publicKey: z.ZodString;
+    publicBoxKey: z.ZodString;
+    userName: z.ZodOptional<z.ZodString>;
+    deviceName: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    publicKey: string;
+    publicBoxKey: string;
     userId: string;
     deviceId: string;
+    userName?: string | undefined;
+    deviceName?: string | undefined;
+}, {
     publicKey: string;
     publicBoxKey: string;
-}
-export interface IDeviceHandshake extends IDeviceInfo {
+    userId: string;
+    deviceId: string;
+    userName?: string | undefined;
+    deviceName?: string | undefined;
+}>;
+/** Signed identity and optional presentation hints advertised by a device. */
+export type IDeviceInfo = z.infer<typeof deviceInfoSchema>;
+/** Schema for connection-bound device handshake contents. */
+export declare const deviceHandshakeSchema: z.ZodObject<{
+    userId: z.ZodEffects<z.ZodString, string, string>;
+    deviceId: z.ZodEffects<z.ZodString, string, string>;
+    publicKey: z.ZodString;
+    publicBoxKey: z.ZodString;
+    userName: z.ZodOptional<z.ZodString>;
+    deviceName: z.ZodOptional<z.ZodString>;
+} & {
+    connectionId: z.ZodString;
+    serverAddress: z.ZodString;
+    timestamp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    timestamp: number;
+    publicKey: string;
+    publicBoxKey: string;
+    userId: string;
+    deviceId: string;
     connectionId: string;
     serverAddress: string;
+    userName?: string | undefined;
+    deviceName?: string | undefined;
+}, {
     timestamp: number;
-}
+    publicKey: string;
+    publicBoxKey: string;
+    userId: string;
+    deviceId: string;
+    connectionId: string;
+    serverAddress: string;
+    userName?: string | undefined;
+    deviceName?: string | undefined;
+}>;
+/** Signed device information bound to one connection handshake. */
+export type IDeviceHandshake = z.infer<typeof deviceHandshakeSchema>;
+/** Returns the Devices table for a data context. */
 export declare function Devices(dataContext?: DataContext): import("..").Table<{
     userId: string;
     deviceId: string;
@@ -45,7 +104,10 @@ export declare function Devices(dataContext?: DataContext): import("..").Table<{
     lastSeen: Date;
     trustLevel: TrustLevel;
     name?: string | undefined;
+    reportedName?: string | undefined;
     serverUrl?: string | undefined;
 }>;
+/** Relay server URLs trusted by the active group. */
 export declare const trustedServers: import("./persistent-vars").PersistentVar<string[]>;
+/** Persistent identifier for the current physical/runtime device. */
 export declare const thisDeviceId: import("./persistent-vars").PersistentVar<string | undefined>;

package/dist/data/devices.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.thisDeviceId = exports.trustedServers = exports.deviceSchema = void 0;
+exports.thisDeviceId = exports.trustedServers = exports.deviceHandshakeSchema = exports.deviceInfoSchema = exports.deviceSchema = exports.displayNameSchema = exports.DISPLAY_NAME_MAX_LENGTH = void 0;
 exports.Devices = Devices;
 const zod_1 = require("zod");
 const user_context_singleton_1 = require("../context/user-context-singleton");
@@ -9,15 +9,36 @@ const zod_types_1 = require("../types/zod-types");
 const table_definitions_system_1 = require("./orm/table-definitions.system");
 const types_1 = require("./orm/types");
 const persistent_vars_1 = require("./persistent-vars");
+/** Maximum number of JavaScript string code units accepted for display names. */
+exports.DISPLAY_NAME_MAX_LENGTH = 128;
+/** Shared schema for bounded user and device display names. */
+exports.displayNameSchema = zod_1.z.string().max(exports.DISPLAY_NAME_MAX_LENGTH);
+/** Schema for a persisted, context-scoped device record. */
 exports.deviceSchema = zod_1.z.object({
     deviceId: zod_types_1.zodPeerId,
     userId: zod_types_1.zodPeerId,
     firstSeen: zod_1.z.date(),
     lastSeen: zod_1.z.date(),
-    name: zod_1.z.string().optional(),
+    name: exports.displayNameSchema.optional(),
+    reportedName: exports.displayNameSchema.optional(),
     serverUrl: zod_1.z.string().optional(),
     trustLevel: zod_1.z.nativeEnum(socket_type_1.TrustLevel),
 });
+/** Schema for the signed identity and bounded presentation hints exchanged by devices. */
+exports.deviceInfoSchema = zod_1.z.object({
+    userId: zod_types_1.zodPeerId,
+    deviceId: zod_types_1.zodPeerId,
+    publicKey: zod_1.z.string(),
+    publicBoxKey: zod_1.z.string(),
+    userName: exports.displayNameSchema.optional(),
+    deviceName: exports.displayNameSchema.optional(),
+});
+/** Schema for connection-bound device handshake contents. */
+exports.deviceHandshakeSchema = exports.deviceInfoSchema.extend({
+    connectionId: zod_1.z.string(),
+    serverAddress: zod_1.z.string(),
+    timestamp: zod_1.z.number(),
+});
 const metaData = {
     name: "Devices",
     description: "The Peer devices that this computer is aware of",
@@ -25,10 +46,13 @@ const metaData = {
     fields: (0, types_1.schemaToFields)(exports.deviceSchema),
 };
 (0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.deviceSchema);
+/** Returns the Devices table for a data context. */
 function Devices(dataContext) {
     return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.deviceSchema);
 }
+/** Relay server URLs trusted by the active group. */
 exports.trustedServers = (0, persistent_vars_1.groupVar)("trustedServers", {
     defaultValue: ["https://peers.app"],
 });
+/** Persistent identifier for the current physical/runtime device. */
 exports.thisDeviceId = (0, persistent_vars_1.deviceVar)("thisDeviceId");

package/dist/data/users.d.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 import type { DataContext } from "../context/data-context";
 import type { ISaveOptions } from "./orm/data-query";
 import { Table } from "./orm/table";
+/** Schema for a signed user profile. */
 export declare const userSchema: z.ZodObject<{
     userId: z.ZodEffects<z.ZodString, string, string>;
     name: z.ZodString;
@@ -21,17 +22,22 @@ export declare const userSchema: z.ZodObject<{
     userId: string;
     signature?: string | undefined;
 }>;
+/** A signed user profile shared across personal and group contexts. */
 export type IUser = z.infer<typeof userSchema>;
+/** User table with owner-signature enforcement outside the personal context. */
 export declare class UsersTable extends Table<IUser> {
     static isPassthrough: boolean;
     save(user: IUser, opts?: ISaveOptions): Promise<IUser>;
     signAndSave(user: IUser, opts?: ISaveOptions): Promise<IUser>;
     private static addSignatureToUser;
+    /** Enables signing for proxied `signAndSave` calls. */
     static enableUserSigning(fn: (user: IUser) => IUser): void;
     /** @deprecated Forbidden on UsersTable; use save() */
     insert(..._args: Parameters<Table<IUser>["insert"]>): never;
     /** @deprecated Forbidden on UsersTable; use save() */
     update(..._args: Parameters<Table<IUser>["update"]>): never;
 }
+/** Returns the Users table for a data context. */
 export declare function Users(dataContext?: DataContext): UsersTable;
+/** Returns the current user's personal profile. */
 export declare function getMe(): Promise<IUser>;

package/dist/data/users.js

@@ -40,14 +40,16 @@ exports.getMe = getMe;
 const zod_1 = require("zod");
 const user_context_singleton_1 = require("../context/user-context-singleton");
 const zod_types_1 = require("../types/zod-types");
+const devices_1 = require("./devices");
 const decorators_1 = require("./orm/decorators");
 const table_1 = require("./orm/table");
 const table_definitions_system_1 = require("./orm/table-definitions.system");
 const types_1 = require("./orm/types");
 const user_permissions_1 = require("./user-permissions");
+/** Schema for a signed user profile. */
 exports.userSchema = zod_1.z.object({
     userId: zod_types_1.zodPeerId,
-    name: zod_1.z.string(),
+    name: devices_1.displayNameSchema,
     publicKey: zod_1.z.string().describe("The public key the user uses to sign messages"),
     publicBoxKey: zod_1.z
         .string()
@@ -64,6 +66,7 @@ const metaData = {
     fields: (0, types_1.schemaToFields)(exports.userSchema),
     indexes: [{ fields: ["name"] }, { fields: ["publicKey"] }, { fields: ["publicBoxKey"] }],
 };
+/** User table with owner-signature enforcement outside the personal context. */
 let UsersTable = (() => {
     let _classSuper = table_1.Table;
     let _instanceExtraInitializers = [];
@@ -97,10 +100,15 @@ let UsersTable = (() => {
             if (!UsersTable.addSignatureToUser) {
                 throw new Error("User signing must be enabled to sign and save users. Call UsersTable.enableUserSigning(fn) to enable it.");
             }
+            user = {
+                ...user,
+                name: user.name.slice(0, devices_1.DISPLAY_NAME_MAX_LENGTH),
+            };
             user = UsersTable.addSignatureToUser(user);
             return this.save(user, opts);
         }
         static addSignatureToUser = undefined;
+        /** Enables signing for proxied `signAndSave` calls. */
         static enableUserSigning(fn) {
             UsersTable.addSignatureToUser = fn;
         }
@@ -120,10 +128,12 @@ let UsersTable = (() => {
 })();
 exports.UsersTable = UsersTable;
 (0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.userSchema, UsersTable);
+/** Returns the Users table for a data context. */
 function Users(dataContext) {
     return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.userSchema, UsersTable);
 }
 // let me: IUser | undefined = undefined;
+/** Returns the current user's personal profile. */
 async function getMe() {
     const userContext = await (0, user_context_singleton_1.getUserContext)();
     const me = await userContext.getMe();

package/dist/device/binary-peer-connection-v2.test.js

@@ -377,15 +377,15 @@ describe("binary-peer-connection-v2", () => {
     describe("wrapBinaryPeer", () => {
         it("should successfully handshake over wrtc protocol", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
-            const userId = `00000000000000000user001`;
+            const userId = (0, utils_1.newid)();
             const keys = (0, keys_1.newKeys)();
             const connectionId = `00000000000000000conn001`;
-            const iPeerDeviceId = `000000000000000device001`;
+            const iPeerDeviceId = (0, utils_1.newid)();
             const iPeerDevice = new device_1.Device(userId, iPeerDeviceId, keys);
             const iPeerConnection = (0, binary_peer_connection_v2_1.wrapBinaryPeer)(connectionId, iPeer, iPeerDevice, true, {
                 protocol: "wrtc",
             });
-            const rPeerDeviceId = `000000000000000device002`;
+            const rPeerDeviceId = (0, utils_1.newid)();
             const rPeerDevice = new device_1.Device(userId, rPeerDeviceId, keys);
             const rPeerConnection = (0, binary_peer_connection_v2_1.wrapBinaryPeer)(connectionId, rPeer, rPeerDevice, false, {
                 protocol: "wrtc",
@@ -400,16 +400,16 @@ describe("binary-peer-connection-v2", () => {
         });
         it("should set secureLocal/secureRemote when markTransportSecure is true", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
-            const userId = `00000000000000000user001`;
+            const userId = (0, utils_1.newid)();
             const keys = (0, keys_1.newKeys)();
             const connectionId = `00000000000000000conn001`;
-            const iPeerDeviceId = `000000000000000device001`;
+            const iPeerDeviceId = (0, utils_1.newid)();
             const iPeerDevice = new device_1.Device(userId, iPeerDeviceId, keys);
             const iPeerConnection = (0, binary_peer_connection_v2_1.wrapBinaryPeer)(connectionId, iPeer, iPeerDevice, true, {
                 protocol: "wrtc",
                 markTransportSecure: true,
             });
-            const rPeerDeviceId = `000000000000000device002`;
+            const rPeerDeviceId = (0, utils_1.newid)();
             const rPeerDevice = new device_1.Device(userId, rPeerDeviceId, keys);
             const rPeerConnection = (0, binary_peer_connection_v2_1.wrapBinaryPeer)(connectionId, rPeer, rPeerDevice, false, {
                 protocol: "wrtc",
@@ -426,13 +426,13 @@ describe("binary-peer-connection-v2", () => {
     describe("backwards compatibility", () => {
         it("wrapWrtc should work as alias and set secure flags", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
-            const userId = `00000000000000000user001`;
+            const userId = (0, utils_1.newid)();
             const keys = (0, keys_1.newKeys)();
             const connectionId = `00000000000000000conn001`;
-            const iPeerDeviceId = `000000000000000device001`;
+            const iPeerDeviceId = (0, utils_1.newid)();
             const iPeerDevice = new device_1.Device(userId, iPeerDeviceId, keys);
             const iPeerConnection = (0, binary_peer_connection_v2_1.wrapWrtc)(connectionId, iPeer, iPeerDevice, true);
-            const rPeerDeviceId = `000000000000000device002`;
+            const rPeerDeviceId = (0, utils_1.newid)();
             const rPeerDevice = new device_1.Device(userId, rPeerDeviceId, keys);
             const rPeerConnection = (0, binary_peer_connection_v2_1.wrapWrtc)(connectionId, rPeer, rPeerDevice, false);
             expect(iPeerConnection.secureLocal).toBe(true);
@@ -445,10 +445,10 @@ describe("binary-peer-connection-v2", () => {
         });
         it("binary peers should bypass StreamedSocket (handlesOwnEncoding)", async () => {
             const { iPeer } = await getMockPeerPair();
-            const userId = `00000000000000000user001`;
+            const userId = (0, utils_1.newid)();
             const keys = (0, keys_1.newKeys)();
             const connectionId = `00000000000000000conn001`;
-            const deviceId = `000000000000000device001`;
+            const deviceId = (0, utils_1.newid)();
             const device = new device_1.Device(userId, deviceId, keys);
             const connection = (0, binary_peer_connection_v2_1.wrapWrtc)(connectionId, iPeer, device, true);
             expect(connection.socket.handlesOwnEncoding).toBe(true);

package/dist/device/binary-peer-connection.test.js

@@ -78,15 +78,15 @@ describe("binary-peer-connection", () => {
     describe("wrapBinaryPeer", () => {
         it("should successfully handshake over wrtc protocol", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
-            const userId = `00000000000000000user001`;
+            const userId = (0, utils_1.newid)();
             const keys = (0, keys_1.newKeys)();
             const connectionId = `00000000000000000conn001`;
-            const iPeerDeviceId = `000000000000000device001`;
+            const iPeerDeviceId = (0, utils_1.newid)();
             const iPeerDevice = new device_1.Device(userId, iPeerDeviceId, keys);
             const iPeerConnection = (0, binary_peer_connection_1.wrapBinaryPeer)(connectionId, iPeer, iPeerDevice, true, {
                 protocol: "wrtc",
             });
-            const rPeerDeviceId = `000000000000000device002`;
+            const rPeerDeviceId = (0, utils_1.newid)();
             const rPeerDevice = new device_1.Device(userId, rPeerDeviceId, keys);
             const rPeerConnection = (0, binary_peer_connection_1.wrapBinaryPeer)(connectionId, rPeer, rPeerDevice, false, {
                 protocol: "wrtc",
@@ -102,16 +102,16 @@ describe("binary-peer-connection", () => {
         });
         it("should set secureLocal/secureRemote when markTransportSecure is true", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
-            const userId = `00000000000000000user001`;
+            const userId = (0, utils_1.newid)();
             const keys = (0, keys_1.newKeys)();
             const connectionId = `00000000000000000conn001`;
-            const iPeerDeviceId = `000000000000000device001`;
+            const iPeerDeviceId = (0, utils_1.newid)();
             const iPeerDevice = new device_1.Device(userId, iPeerDeviceId, keys);
             const iPeerConnection = (0, binary_peer_connection_1.wrapBinaryPeer)(connectionId, iPeer, iPeerDevice, true, {
                 protocol: "wrtc",
                 markTransportSecure: true,
             });
-            const rPeerDeviceId = `000000000000000device002`;
+            const rPeerDeviceId = (0, utils_1.newid)();
             const rPeerDevice = new device_1.Device(userId, rPeerDeviceId, keys);
             const rPeerConnection = (0, binary_peer_connection_1.wrapBinaryPeer)(connectionId, rPeer, rPeerDevice, false, {
                 protocol: "wrtc",
@@ -129,13 +129,13 @@ describe("binary-peer-connection", () => {
     describe("backwards compatibility", () => {
         it("wrapWrtc should work as alias and set secure flags", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
-            const userId = `00000000000000000user001`;
+            const userId = (0, utils_1.newid)();
             const keys = (0, keys_1.newKeys)();
             const connectionId = `00000000000000000conn001`;
-            const iPeerDeviceId = `000000000000000device001`;
+            const iPeerDeviceId = (0, utils_1.newid)();
             const iPeerDevice = new device_1.Device(userId, iPeerDeviceId, keys);
             const iPeerConnection = (0, binary_peer_connection_1.wrapWrtc)(connectionId, iPeer, iPeerDevice, true);
-            const rPeerDeviceId = `000000000000000device002`;
+            const rPeerDeviceId = (0, utils_1.newid)();
             const rPeerDevice = new device_1.Device(userId, rPeerDeviceId, keys);
             const rPeerConnection = (0, binary_peer_connection_1.wrapWrtc)(connectionId, rPeer, rPeerDevice, false);
             // wrapWrtc should set secure flags by default (transport-level encryption)
@@ -150,10 +150,10 @@ describe("binary-peer-connection", () => {
         });
         it("binary peers should bypass StreamedSocket (handlesOwnEncoding)", async () => {
             const { iPeer } = await getMockPeerPair();
-            const userId = `00000000000000000user001`;
+            const userId = (0, utils_1.newid)();
             const keys = (0, keys_1.newKeys)();
             const connectionId = `00000000000000000conn001`;
-            const deviceId = `000000000000000device001`;
+            const deviceId = (0, utils_1.newid)();
             const device = new device_1.Device(userId, deviceId, keys);
             const connection = (0, binary_peer_connection_1.wrapWrtc)(connectionId, iPeer, device, true);
             // The socket should NOT be wrapped in StreamedSocket

package/dist/device/connection.d.ts

@@ -1,8 +1,10 @@
-import type { IDeviceHandshake, IDeviceInfo } from "../data";
+import { type IDeviceHandshake, type IDeviceInfo } from "../data";
 import { type IDataBox } from "../keys";
 import type { Device } from "./device";
 import { type ISocket, TrustLevel } from "./socket.type";
+/** Resolves the trust assigned to an authenticated remote device identity. */
 export type GetTrustLevel = (deviceInfo: IDeviceInfo, registerNew?: boolean) => Promise<TrustLevel>;
+/** Authenticated RPC connection between two Peers devices. */
 export declare class Connection {
     readonly localDevice: Device;
     readonly localDeviceServerAddresses?: string[] | undefined;
@@ -35,10 +37,12 @@ export declare class Connection {
      */
     get encryptTraffic(): boolean;
     get remoteDeviceInfo(): {
-        userId: string;
-        deviceId: string;
         publicKey: string;
         publicBoxKey: string;
+        userId: string;
+        deviceId: string;
+        userName?: string | undefined;
+        deviceName?: string | undefined;
     };
     get connectionId(): string;
     /**
@@ -73,4 +77,5 @@ export declare class Connection {
     private closed;
     close(): Promise<void>;
 }
+/** Normalizes a peer address for transport and security comparisons. */
 export declare function normalizeAddress(address: string): string;

package/dist/device/connection.js

@@ -2,10 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Connection = void 0;
 exports.normalizeAddress = normalizeAddress;
+const data_1 = require("../data");
 const keys_1 = require("../keys");
 const utils_1 = require("../utils");
 const socket_type_1 = require("./socket.type");
 const HANDSHAKE_TIMESTAMP_TOLERANCE_MS = 300_000; // 5 minutes
+/** Authenticated RPC connection between two Peers devices. */
 class Connection {
     localDevice;
     localDeviceServerAddresses;
@@ -280,7 +282,7 @@ class Connection {
     }
     async completeHandshake(boxedHandshake) {
         const signedHandshake = this.localDevice.openBoxWithSecretKey(boxedHandshake);
-        const _handshake = signedHandshake.contents;
+        const _handshake = data_1.deviceHandshakeSchema.parse((0, keys_1.openSignedObject)(signedHandshake));
         const timeDiff = Math.abs(Date.now() - _handshake.timestamp);
         if (timeDiff > this.handshakeTimestampToleranceMs) {
             throw new Error(`Remote device's system clock is too far out of sync`);
@@ -299,8 +301,10 @@ class Connection {
             deviceId: _handshake.deviceId,
             publicKey: _handshake.publicKey,
             publicBoxKey: _handshake.publicBoxKey,
+            userName: _handshake.userName,
+            deviceName: _handshake.deviceName,
         };
-        this.trustLevel = await this.getTrustLevel(signedHandshake.contents, true);
+        this.trustLevel = await this.getTrustLevel(_handshake, true);
         if (this.trustLevel < socket_type_1.TrustLevel.Unknown) {
             this.reset();
             this.emit("reset");
@@ -320,13 +324,13 @@ class Connection {
         this.reset();
         await this.emit("reset");
         const remoteDeviceInfoSigned = await this.emit("requestDeviceInfo");
-        const remoteDeviceInfo = (0, keys_1.openSignedObject)(remoteDeviceInfoSigned);
+        const remoteDeviceInfo = data_1.deviceInfoSchema.parse((0, keys_1.openSignedObject)(remoteDeviceInfoSigned));
         if (remoteDeviceInfoSigned.publicKey !== remoteDeviceInfo.publicKey) {
             throw new Error("Device info signing key does not match claimed identity key");
         }
         const handshake = await this.initiateHandshake(remoteAddress, remoteDeviceInfo);
         const handshakeResponseBox = await this.emit("completeHandshake", handshake);
-        const handshakeResponse = await this.localDevice.openBoxedAndSignedData(handshakeResponseBox);
+        const handshakeResponse = data_1.deviceHandshakeSchema.parse(await this.localDevice.openBoxedAndSignedData(handshakeResponseBox));
         if (handshakeResponse.connectionId !== this.connectionId) {
             throw new Error(`Invalid connectionId ${handshakeResponse.connectionId}, expected ${this.connectionId}`);
         }
@@ -338,6 +342,16 @@ class Connection {
             remoteDeviceInfo.deviceId !== handshakeResponse.deviceId) {
             throw new Error("Inconsistent device info");
         }
+        const currentRemoteDeviceInfo = {
+            ...remoteDeviceInfo,
+            userName: handshakeResponse.userName !== undefined
+                ? handshakeResponse.userName
+                : remoteDeviceInfo.userName,
+            deviceName: handshakeResponse.deviceName !== undefined
+                ? handshakeResponse.deviceName
+                : remoteDeviceInfo.deviceName,
+        };
+        this._remoteDeviceInfo = currentRemoteDeviceInfo;
         this._verified = true;
         this._connectionAddress = remoteAddress;
         const secureProtocols = ["https", "wss", "wrtc"];
@@ -348,7 +362,7 @@ class Connection {
         if (this.secureLocal) {
             await this.emit("requestSecure");
         }
-        this.trustLevel = await this.getTrustLevel(remoteDeviceInfo, true);
+        this.trustLevel = await this.getTrustLevel(currentRemoteDeviceInfo, true);
         if (this.trustLevel < socket_type_1.TrustLevel.Unknown) {
             this.reset();
             this.emit("reset");
@@ -386,6 +400,7 @@ class Connection {
     }
 }
 exports.Connection = Connection;
+/** Normalizes a peer address for transport and security comparisons. */
 function normalizeAddress(address) {
     return address.toLowerCase().replace(/\/$/, "");
 }

package/dist/device/connection.test.js

@@ -48,8 +48,14 @@ function createTestSocketPair() {
 describe(connection_1.Connection, () => {
     it("should allow simulating a client and server connection handshake", async () => {
         const { clientSocket, serverSocket } = createTestSocketPair();
-        const clientDevice = new device_1.Device();
-        const serverDevice = new device_1.Device();
+        const clientDevice = new device_1.Device(undefined, undefined, undefined, {
+            userName: "Client user",
+            deviceName: "Client laptop",
+        });
+        const serverDevice = new device_1.Device(undefined, undefined, undefined, {
+            userName: "Server user",
+            deviceName: "Server desktop",
+        });
         const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
         const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ["localhost"]);
         expect(clientConnection.connectionId).toBe(serverConnection.connectionId);
@@ -60,6 +66,16 @@ describe(connection_1.Connection, () => {
         expect(response.publicBoxKey).toBe(serverDevice.publicBoxKey);
         expect(response.serverAddress).toBe("localhost");
         expect(response.connectionId).toBe(serverConnection.connectionId);
+        expect(response.userName).toBe("Server user");
+        expect(response.deviceName).toBe("Server desktop");
+        expect(clientConnection.remoteDeviceInfo).toMatchObject({
+            userName: "Server user",
+            deviceName: "Server desktop",
+        });
+        expect(serverConnection.remoteDeviceInfo).toMatchObject({
+            userName: "Client user",
+            deviceName: "Client laptop",
+        });
         serverConnection.removeAllListeners("ping");
         serverConnection.exposeRPC("ping", async (n, s) => `pong - ${n}, ${s}`);
         const pong = await clientConnection.emit("ping", 1, "hello");
@@ -176,7 +192,7 @@ describe(connection_1.Connection, () => {
         serverConnection.socket.removeAllListeners("completeHandshake");
         serverConnection.exposeRPC("completeHandshake", async (handshakeBox) => {
             const handshake = await serverConnection.completeHandshake(handshakeBox);
-            handshake.deviceId = "fake";
+            handshake.deviceId = (0, utils_1.newid)();
             return handshake;
         });
         const result = await clientConnection.doHandshake(serverAddress).catch((err) => String(err));
@@ -193,7 +209,7 @@ describe(connection_1.Connection, () => {
         serverConnection.socket.removeAllListeners("completeHandshake");
         serverConnection.exposeRPC("completeHandshake", async (handshakeBox) => {
             const handshake = await serverConnection.completeHandshake(handshakeBox);
-            handshake.userId = "fake";
+            handshake.userId = (0, utils_1.newid)();
             return handshake;
         });
         const result = await clientConnection.doHandshake(serverAddress).catch((err) => String(err));
@@ -272,9 +288,11 @@ describe(connection_1.Connection, () => {
         const originalGetHandshake = clientDevice.getHandshake.bind(clientDevice);
         clientDevice.getHandshake = (connectionId, serverAddress) => {
             const handshake = originalGetHandshake(connectionId, serverAddress);
-            // Make timestamp 2 seconds in the past (beyond tolerance)
-            handshake.contents.timestamp = Date.now() - 2000;
-            return handshake;
+            return clientDevice.signObjectWithSecretKey({
+                ...handshake.contents,
+                // Make timestamp 2 seconds in the past (beyond tolerance)
+                timestamp: Date.now() - 2000,
+            });
         };
         const result = await clientConnection
             .doHandshake("localhost")

package/dist/device/device.d.ts

@@ -1,10 +1,20 @@
-import type { IDeviceHandshake, IDeviceInfo } from "../data";
+import { type IDeviceHandshake, type IDeviceInfo } from "../data";
 import { type IDataBox, type ISignedObject } from "../keys";
+/** Optional presentation metadata advertised with signed device identity. */
+export interface IDeviceDisplayInfo {
+    userName?: string;
+    deviceName?: string;
+}
+/** Runtime cryptographic identity for a Peers device. */
 export declare class Device implements IDeviceInfo {
     readonly userId: string;
     readonly deviceId: string;
     private readonly keys;
-    constructor(userId?: string, deviceId?: string, keys?: import("../keys").IPublicPrivateKeys);
+    private _userName?;
+    private _deviceName?;
+    constructor(userId?: string, deviceId?: string, keys?: import("../keys").IPublicPrivateKeys, displayInfo?: IDeviceDisplayInfo);
+    get userName(): string | undefined;
+    get deviceName(): string | undefined;
     get publicKey(): string;
     get publicBoxKey(): string;
     signMessageWithSecretKey(msg: string): string;
@@ -16,8 +26,21 @@ export declare class Device implements IDeviceInfo {
     signAndBoxDataForKey<T>(data: T, toPublicBoxKey: string): IDataBox;
     unwrapResponse<T>(response: T | ISignedObject<T> | IDataBox): T;
     openBoxedAndSignedData<T>(data: IDataBox): T;
+    /** Updates bounded presentation metadata included in future signed identity messages. */
+    setDisplayInfo({ userName, deviceName }: IDeviceDisplayInfo): void;
     getHandshake(connectionId: string, serverAddress: string): ISignedObject<IDeviceHandshake>;
-    handshakeResponse(remoteHandshake: ISignedObject<IDeviceHandshake>, connectionId: string, thisServerAddress: string): IDeviceHandshake;
+    handshakeResponse(remoteHandshake: ISignedObject<IDeviceHandshake>, connectionId: string, thisServerAddress: string): {
+        timestamp: number;
+        publicKey: string;
+        publicBoxKey: string;
+        userId: string;
+        deviceId: string;
+        connectionId: string;
+        serverAddress: string;
+        userName?: string | undefined;
+        deviceName?: string | undefined;
+    };
     private deviceInfoSigned;
+    /** Returns cached signed identity information, refreshing after display metadata changes. */
     getDeviceInfo(): ISignedObject<IDeviceInfo>;
 }

package/dist/device/device.js

@@ -1,16 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Device = void 0;
+const data_1 = require("../data");
 const keys_1 = require("../keys");
 const utils_1 = require("../utils");
+/** Runtime cryptographic identity for a Peers device. */
 class Device {
     userId;
     deviceId;
     keys;
-    constructor(userId = (0, utils_1.newid)(), deviceId = (0, utils_1.newid)(), keys = (0, keys_1.newKeys)()) {
+    _userName;
+    _deviceName;
+    constructor(userId = (0, utils_1.newid)(), deviceId = (0, utils_1.newid)(), keys = (0, keys_1.newKeys)(), displayInfo = {}) {
         this.userId = userId;
         this.deviceId = deviceId;
         this.keys = keys;
+        this.setDisplayInfo(displayInfo);
+    }
+    get userName() {
+        return this._userName;
+    }
+    get deviceName() {
+        return this._deviceName;
     }
     get publicKey() {
         return this.keys.publicKey;
@@ -65,17 +76,32 @@ class Device {
         const signedData = this.openBoxWithSecretKey(data);
         return (0, keys_1.openSignedObject)(signedData);
     }
+    /** Updates bounded presentation metadata included in future signed identity messages. */
+    setDisplayInfo({ userName, deviceName }) {
+        userName = userName ? userName.slice(0, data_1.DISPLAY_NAME_MAX_LENGTH) : undefined;
+        deviceName = deviceName ? deviceName.slice(0, data_1.DISPLAY_NAME_MAX_LENGTH) : undefined;
+        data_1.displayNameSchema.optional().parse(userName);
+        data_1.displayNameSchema.optional().parse(deviceName);
+        if (this._userName === userName && this._deviceName === deviceName) {
+            return;
+        }
+        this._userName = userName;
+        this._deviceName = deviceName;
+        this.deviceInfoSigned = undefined;
+    }
     getHandshake(connectionId, serverAddress) {
         try {
-            const localDeviceInfo = {
+            const localDeviceInfo = data_1.deviceHandshakeSchema.parse({
                 connectionId,
                 userId: this.userId,
                 deviceId: this.deviceId,
                 publicKey: this.publicKey,
                 publicBoxKey: this.publicBoxKey,
+                userName: this.userName,
+                deviceName: this.deviceName,
                 serverAddress,
                 timestamp: Date.now(),
-            };
+            });
             const localDeviceInfoSigned = this.signObjectWithSecretKey(localDeviceInfo);
             return localDeviceInfoSigned;
         }
@@ -85,22 +111,24 @@ class Device {
     }
     handshakeResponse(remoteHandshake, connectionId, thisServerAddress) {
         try {
-            const deviceInfo = (0, keys_1.openSignedObject)(remoteHandshake);
+            const deviceInfo = data_1.deviceHandshakeSchema.parse((0, keys_1.openSignedObject)(remoteHandshake));
             if (remoteHandshake.publicKey !== deviceInfo.publicKey) {
                 throw new Error("Handshake signing key does not match claimed identity key");
             }
             if (deviceInfo.connectionId !== connectionId) {
                 throw new Error(`Invalid connectionId ${deviceInfo.connectionId}, expected ${connectionId}`);
             }
-            const handshakeResponse = {
+            const handshakeResponse = data_1.deviceHandshakeSchema.parse({
                 connectionId,
                 userId: this.userId,
                 deviceId: this.deviceId,
                 publicKey: this.publicKey,
                 publicBoxKey: this.publicBoxKey,
+                userName: this.userName,
+                deviceName: this.deviceName,
                 serverAddress: thisServerAddress,
                 timestamp: Date.now(),
-            };
+            });
             return handshakeResponse;
         }
         catch (e) {
@@ -108,14 +136,18 @@ class Device {
         }
     }
     deviceInfoSigned;
+    /** Returns cached signed identity information, refreshing after display metadata changes. */
     getDeviceInfo() {
         if (!this.deviceInfoSigned) {
-            this.deviceInfoSigned = this.signObjectWithSecretKey({
+            const deviceInfo = data_1.deviceInfoSchema.parse({
                 userId: this.userId,
                 deviceId: this.deviceId,
                 publicKey: this.publicKey,
                 publicBoxKey: this.publicBoxKey,
+                userName: this.userName,
+                deviceName: this.deviceName,
             });
+            this.deviceInfoSigned = this.signObjectWithSecretKey(deviceInfo);
         }
         return this.deviceInfoSigned;
     }

package/dist/device/device.test.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const data_1 = require("../data");
 const keys_1 = require("../keys");
 const utils_1 = require("../utils");
 const device_1 = require("./device");
@@ -51,6 +52,35 @@ describe(device_1.Device, () => {
                 expect(handshake.contents.publicBoxKey).toBe(client.publicBoxKey);
                 expect(handshake.contents.connectionId).toBe(connectionId);
             });
+            it("includes bounded display metadata and refreshes cached device info", () => {
+                const device = new device_1.Device((0, utils_1.newid)(), (0, utils_1.newid)(), (0, keys_1.newKeys)(), {
+                    userName: "Mark",
+                    deviceName: "Office laptop",
+                });
+                const originalInfo = device.getDeviceInfo();
+                expect(originalInfo.contents).toMatchObject({
+                    userName: "Mark",
+                    deviceName: "Office laptop",
+                });
+                device.setDisplayInfo({ userName: "Mark Archer", deviceName: "Kitchen display" });
+                const refreshedInfo = device.getDeviceInfo();
+                const handshake = device.getHandshake((0, utils_1.newid)(), "localhost");
+                expect(refreshedInfo).not.toBe(originalInfo);
+                expect(refreshedInfo.contents).toMatchObject({
+                    userName: "Mark Archer",
+                    deviceName: "Kitchen display",
+                });
+                expect(handshake.contents).toMatchObject({
+                    userName: "Mark Archer",
+                    deviceName: "Kitchen display",
+                });
+            });
+            it("bounds invalid local display metadata before signing it", () => {
+                const device = new device_1.Device((0, utils_1.newid)(), (0, utils_1.newid)(), (0, keys_1.newKeys)(), {
+                    deviceName: "x".repeat(data_1.DISPLAY_NAME_MAX_LENGTH + 1),
+                });
+                expect(device.getDeviceInfo().contents.deviceName).toHaveLength(data_1.DISPLAY_NAME_MAX_LENGTH);
+            });
         });
         describe("handshakeResponse", () => {
             it("should return a valid and correct handshake response object", async () => {
@@ -73,6 +103,20 @@ describe(device_1.Device, () => {
                 const handshake = client.getHandshake(c1.connectionId, "localhost");
                 expect(() => server.handshakeResponse(handshake, c2.connectionId, "localhost")).toThrow(/Invalid connectionId/);
             });
+            it("rejects signed handshake metadata that exceeds the display-name limit", () => {
+                const connectionId = (0, utils_1.newid)();
+                const handshake = client.signObjectWithSecretKey({
+                    connectionId,
+                    userId: client.userId,
+                    deviceId: client.deviceId,
+                    publicKey: client.publicKey,
+                    publicBoxKey: client.publicBoxKey,
+                    userName: "x".repeat(data_1.DISPLAY_NAME_MAX_LENGTH + 1),
+                    serverAddress: "localhost",
+                    timestamp: Date.now(),
+                });
+                expect(() => server.handshakeResponse(handshake, connectionId, "localhost")).toThrow();
+            });
             it("should reject a handshake signed by a different key than the one claimed in the payload (key confusion)", async () => {
                 const connectionId = (0, utils_1.newid)();
                 // Imposter holds a random secret key but claims the real client's publicKey/publicBoxKey.

package/dist/device/get-trust-level-fn.js

@@ -4,6 +4,15 @@ exports.getTrustLevelFn = getTrustLevelFn;
 const context_1 = require("../context");
 const data_1 = require("../data");
 const socket_type_1 = require("./socket.type");
+function applyReportedDeviceName(device, deviceInfo) {
+    if (deviceInfo.deviceName) {
+        device.reportedName = deviceInfo.deviceName;
+    }
+}
+function boundStoredDeviceNames(device) {
+    device.name = device.name?.slice(0, data_1.DISPLAY_NAME_MAX_LENGTH);
+    device.reportedName = device.reportedName?.slice(0, data_1.DISPLAY_NAME_MAX_LENGTH);
+}
 /**
  * Build the connection-handshake trust evaluator for a local user identity.
  *
@@ -31,6 +40,8 @@ function getTrustLevelFn(me, serverUrl) {
                 serverUrl,
             };
             device.lastSeen = new Date();
+            applyReportedDeviceName(device, deviceInfo);
+            boundStoredDeviceNames(device);
             const seenMoreThan2DaysAgo = Date.now() - device.firstSeen.getTime() > 1000 * 60 * 60 * 24 * 2;
             device.trustLevel = seenMoreThan2DaysAgo ? socket_type_1.TrustLevel.Trusted : socket_type_1.TrustLevel.NewDevice;
             console.log(`Updating my own device: ${deviceInfo.deviceId}`);
@@ -86,6 +97,8 @@ function getTrustLevelFn(me, serverUrl) {
             device?.trustLevel &&
             device.trustLevel >= socket_type_1.TrustLevel.Trusted) {
             device.lastSeen = new Date();
+            applyReportedDeviceName(device, deviceInfo);
+            boundStoredDeviceNames(device);
             await (0, data_1.Devices)(userDataContext).save(device, { restoreIfDeleted: true });
             return socket_type_1.TrustLevel.Trusted;
         }
@@ -113,6 +126,8 @@ function getTrustLevelFn(me, serverUrl) {
                 device.trustLevel = socket_type_1.TrustLevel.Known;
             }
         }
+        applyReportedDeviceName(device, deviceInfo);
+        boundStoredDeviceNames(device);
         _trustLevel = device.trustLevel;
         let newUser = false;
         if (!user && !groupUser) {
@@ -123,7 +138,9 @@ function getTrustLevelFn(me, serverUrl) {
                 userId: deviceInfo.userId,
                 publicKey: deviceInfo.publicKey,
                 publicBoxKey: deviceInfo.publicBoxKey,
-                name: serverUrl || `Unnamed_${deviceInfo.userId.substring(20)}`,
+                name: (deviceInfo.userName ||
+                    serverUrl ||
+                    `Unnamed_${deviceInfo.userId.substring(20)}`).slice(0, data_1.DISPLAY_NAME_MAX_LENGTH),
             };
             _trustLevel = socket_type_1.TrustLevel.NewUser;
             newUser = true;

package/dist/device/get-trust-level-fn.test.js

@@ -137,6 +137,24 @@ describe("getTrustLevelFn", () => {
             expect(savedDevice.lastSeen.getTime()).toBeGreaterThanOrEqual(before);
             expect(savedDevice.lastSeen.getTime()).toBeLessThanOrEqual(after);
         });
+        it("stores the owner-reported name without replacing a local device label", async () => {
+            const me = makeTestIdentity();
+            const deviceInfo = { ...me, deviceName: "Owner's laptop" };
+            const existingDevice = {
+                deviceId: me.deviceId,
+                userId: me.userId,
+                firstSeen: new Date(),
+                lastSeen: new Date(),
+                name: "My local label",
+                trustLevel: socket_type_1.TrustLevel.NewDevice,
+            };
+            const { devTable } = setupMocks(existingDevice);
+            await (0, get_trust_level_fn_1.getTrustLevelFn)(me)(deviceInfo);
+            expect(devTable.save).toHaveBeenCalledWith(expect.objectContaining({
+                name: "My local label",
+                reportedName: "Owner's laptop",
+            }), expect.anything());
+        });
     });
     // ─── Blocked device early exit ──────────────────────────────────────────────
     describe("explicitly blocked device (trustLevel < Unknown)", () => {
@@ -369,7 +387,11 @@ describe("getTrustLevelFn", () => {
     describe("new user and new device", () => {
         it("returns NewDevice and saves a user stub when both user and device are unseen", async () => {
             const me = makeTestIdentity();
-            const other = makeTestIdentity();
+            const other = {
+                ...makeTestIdentity(),
+                userName: "Alice",
+                deviceName: "Alice's phone",
+            };
             const { devTable, usersTable } = setupMocks(null, null, null);
             const getTrustLevel = (0, get_trust_level_fn_1.getTrustLevelFn)(me, "https://server.example.com");
             const result = await getTrustLevel(other);
@@ -381,11 +403,12 @@ describe("getTrustLevelFn", () => {
                 userId: other.userId,
                 publicKey: other.publicKey,
                 publicBoxKey: other.publicBoxKey,
-                name: "https://server.example.com",
+                name: "Alice",
             }), expect.objectContaining({ restoreIfDeleted: true, weakInsert: true }));
             expect(devTable.save).toHaveBeenCalledWith(expect.objectContaining({
                 deviceId: other.deviceId,
                 userId: other.userId,
+                reportedName: "Alice's phone",
                 serverUrl: "https://server.example.com",
                 trustLevel: socket_type_1.TrustLevel.NewDevice,
             }), expect.objectContaining({ restoreIfDeleted: true, weakInsert: true }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peers-app/peers-sdk",
-  "version": "0.20.2",
+  "version": "0.20.3",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"