@peers-app/peers-sdk 0.19.14 → 0.20.1

package/dist/data/package-versions.d.ts

@@ -54,8 +54,8 @@ declare const schema: z.ZodObject<{
     version: string;
     signature: string;
     packageId: string;
-    createdBy: string;
     createdAt: string;
+    createdBy: string;
     packageVersionId: string;
     packageVersionHash: string;
     packageBundleFileId: string;
@@ -82,8 +82,8 @@ declare const schema: z.ZodObject<{
     version: string;
     signature: string;
     packageId: string;
-    createdBy: string;
     createdAt: string;
+    createdBy: string;
     packageVersionId: string;
     packageVersionHash: string;
     packageBundleFileId: string;

package/dist/data/peer-types.d.ts

@@ -91,7 +91,7 @@ declare const valueTypeSchema: z.ZodObject<{
     iconClass?: string | undefined;
 }>;
 export type IPeerType = z.infer<typeof valueTypeSchema>;
-export declare function PeerTypes(dataContext?: DataContext): import("./orm").Table<{
+export declare function PeerTypes(dataContext?: DataContext): import("..").Table<{
     name: string;
     schema: {
         type: import("./tools").IOSchemaType;

package/dist/data/persistent-vars.d.ts

@@ -52,20 +52,37 @@ declare const schema: z.ZodObject<{
     modifiedAt?: number | undefined;
     packageId?: string | undefined;
 }>;
+/** Table metadata for persisted observable variables. */
 export declare const persistentVarsMetaData: ITableMetaData;
+/** Stored record for one persistent variable. */
 export type IPersistentVar = z.infer<typeof schema>;
+/** Persistent-variable table with deterministic IDs and secret-value handling. */
 export declare class PersistentVarsTable extends Table<IPersistentVar> {
+    /** Insert a persistent variable through the canonical save path. */
     insert(persistentVar: IPersistentVar): Promise<IPersistentVar>;
+    /** Update a persistent variable through the canonical save path. */
     update(persistentVar: IPersistentVar): Promise<IPersistentVar>;
+    /** Save a variable, assigning its deterministic ID and encrypting new secret plaintext. */
     save(persistentVar: IPersistentVar, opts?: ISaveOptions): Promise<IPersistentVar>;
+    /**
+     * Replace a legacy random record ID without re-encrypting its already-stored value.
+     *
+     * Migration is storage-only: the value and modified timestamp are preserved. If the
+     * deterministic record already exists, it wins and the duplicate legacy row is removed.
+     */
+    migrateLegacyId(persistentVar: IPersistentVar): Promise<IPersistentVar>;
+    /** Return a stored variable's raw value by name. */
     getPersistentVarValue<T>(name: string): Promise<T | undefined>;
 }
+/** Return the persistent-variable table for a data context. */
 export declare function PersistentVars(dataContext?: DataContext): PersistentVarsTable;
+/** Reactive persistent value with an awaitable initial load and explicit deletion. */
 export type PersistentVar<T> = Observable<T> & {
     loadingPromise: Promise<PersistentVar<T>>;
     /** Delete the persistent variable from the database and reset to default value */
     delete: () => Promise<void>;
 };
+/** Resolve a persistent-variable record by name, preferring device scope. */
 export declare function getPersistentVar(name: string, dataContext?: DataContext): Promise<IPersistentVar | undefined>;
 interface IPersistentVarOptionsBase {
     scope?: "device" | "user" | "group" | "groupDevice" | "groupUser";

package/dist/data/persistent-vars.js

@@ -5,6 +5,40 @@
  * Tests for this module are located in peers-device/src/persistent-vars.test.ts
  * (requires SQLite which is not available in peers-sdk)
  */
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PersistentVarsTable = exports.persistentVarsMetaData = void 0;
 exports.PersistentVars = PersistentVars;
@@ -21,6 +55,7 @@ const observable_1 = require("../observable");
 const rpc_types_1 = require("../rpc-types");
 const zod_types_1 = require("../types/zod-types");
 const utils_1 = require("../utils");
+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");
@@ -44,6 +79,7 @@ const schema = zod_1.z.object({
         .optional()
         .describe("The package that owns this persistent variable, if any"),
 });
+/** Table metadata for persisted observable variables. */
 exports.persistentVarsMetaData = {
     name: "PersistentVars",
     description: "table to persist variables across sessions and devices",
@@ -52,46 +88,93 @@ exports.persistentVarsMetaData = {
     iconClassName: "bi bi-braces",
     indexes: [{ fields: ["name"], unique: true }],
 };
-class PersistentVarsTable extends table_1.Table {
-    async insert(persistentVar) {
-        return this.save(persistentVar);
-    }
-    async update(persistentVar) {
-        return this.save(persistentVar);
-    }
-    async save(persistentVar, opts) {
-        if (!persistentVar.persistentVarId) {
-            persistentVar.persistentVarId = (0, utils_1.deterministicPvarId)(persistentVar.name);
+/** Persistent-variable table with deterministic IDs and secret-value handling. */
+let PersistentVarsTable = (() => {
+    let _classSuper = table_1.Table;
+    let _instanceExtraInitializers = [];
+    let _migrateLegacyId_decorators;
+    return class PersistentVarsTable extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _migrateLegacyId_decorators = [(0, decorators_1.ProxyClientTableMethodCalls)()];
+            __esDecorate(this, null, _migrateLegacyId_decorators, { kind: "method", name: "migrateLegacyId", static: false, private: false, access: { has: obj => "migrateLegacyId" in obj, get: obj => obj.migrateLegacyId }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        /** Insert a persistent variable through the canonical save path. */
+        async insert(persistentVar) {
+            return this.save(persistentVar);
+        }
+        /** Update a persistent variable through the canonical save path. */
+        async update(persistentVar) {
+            return this.save(persistentVar);
+        }
+        /** Save a variable, assigning its deterministic ID and encrypting new secret plaintext. */
+        async save(persistentVar, opts) {
+            if (!persistentVar.persistentVarId) {
+                persistentVar.persistentVarId = (0, utils_1.deterministicPvarId)(persistentVar.name);
+            }
+            const dbVar = await this.get(persistentVar.persistentVarId);
+            if (persistentVar.isSecret &&
+                persistentVar.value.value !== undefined &&
+                (!rpc_types_1.isClient || (0, rpc_types_1.isSingleProcessClient)())) {
+                if (!dbVar ||
+                    dbVar.value.value !== persistentVar.value.value ||
+                    dbVar.isSecret !== persistentVar.isSecret) {
+                    persistentVar.value.value = await rpc_types_1.rpcServerCalls.encryptData(persistentVar.value.value || "", this.groupId);
+                }
+            }
+            persistentVar.modifiedAt = Date.now();
+            opts ??= {};
+            opts = { saveAsSnapshot: true, ...opts };
+            return super.save(persistentVar, opts);
+        }
+        /**
+         * Replace a legacy random record ID without re-encrypting its already-stored value.
+         *
+         * Migration is storage-only: the value and modified timestamp are preserved. If the
+         * deterministic record already exists, it wins and the duplicate legacy row is removed.
+         */
+        async migrateLegacyId(persistentVar) {
+            if ((0, utils_1.isDeterministicPvarId)(persistentVar.persistentVarId)) {
+                return persistentVar;
+            }
+            const deterministicId = (0, utils_1.deterministicPvarId)(persistentVar.name);
+            const existing = await this.get(deterministicId);
+            await super.delete(persistentVar);
+            if (existing) {
+                return existing;
+            }
+            const migrated = { ...persistentVar, persistentVarId: deterministicId };
+            try {
+                return await super.save(migrated, { saveAsSnapshot: true });
+            }
+            catch (error) {
+                await super.save(persistentVar, { saveAsSnapshot: true }).catch(() => { });
+                throw error;
+            }
         }
-        const dbVar = await this.get(persistentVar.persistentVarId);
-        if (persistentVar.isSecret &&
-            persistentVar.value.value !== undefined &&
-            (!rpc_types_1.isClient || (0, rpc_types_1.isSingleProcessClient)())) {
-            if (!dbVar ||
-                dbVar.value.value !== persistentVar.value.value ||
-                dbVar.isSecret !== persistentVar.isSecret) {
-                persistentVar.value.value = await rpc_types_1.rpcServerCalls.encryptData(persistentVar.value.value || "", this.groupId);
+        /** Return a stored variable's raw value by name. */
+        async getPersistentVarValue(name) {
+            const pVars = await this.list({ name });
+            if (pVars.length > 1) {
+                console.warn(`Multiple persistent variables found with name "${name}". Using the last one.`);
             }
+            const pVar = pVars[pVars.length - 1];
+            return pVar?.value?.value;
         }
-        persistentVar.modifiedAt = Date.now();
-        opts ??= {};
-        opts = { saveAsSnapshot: true, ...opts };
-        return super.save(persistentVar, opts);
-    }
-    async getPersistentVarValue(name) {
-        const pVars = await this.list({ name });
-        if (pVars.length > 1) {
-            console.warn(`Multiple persistent variables found with name "${name}". Using the last one.`);
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _instanceExtraInitializers);
         }
-        const pVar = pVars[pVars.length - 1];
-        return pVar?.value?.value;
-    }
-}
+    };
+})();
 exports.PersistentVarsTable = PersistentVarsTable;
 (0, table_definitions_system_1.registerSystemTableDefinition)(exports.persistentVarsMetaData, schema, PersistentVarsTable);
+/** Return the persistent-variable table for a data context. */
 function PersistentVars(dataContext) {
     return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(exports.persistentVarsMetaData, schema, PersistentVarsTable);
 }
+/** Resolve a persistent-variable record by name, preferring device scope. */
 async function getPersistentVar(name, dataContext) {
     const pVars = await PersistentVars(dataContext).list({ name });
     if (!pVars.length) {
@@ -210,10 +293,7 @@ function persistentVarFactory(name, opts) {
                         }
                     }
                     if (dbRec && !(0, utils_1.isDeterministicPvarId)(dbRec.persistentVarId)) {
-                        const newId = (0, utils_1.deterministicPvarId)(name);
-                        await table.delete(dbRec);
-                        dbRec.persistentVarId = newId;
-                        dbRec = await table.save(dbRec);
+                        dbRec = await table.migrateLegacyId(dbRec);
                     }
                     if (!dbRec) {
                         dbRec = {

package/dist/data/persistent-vars.migration.test.d.ts

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

package/dist/data/persistent-vars.migration.test.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const originalClientFlag = process.env.PEERS_IS_CLIENT;
+function createEventRegistry() {
+    return {
+        getEmitter: jest.fn().mockReturnValue({
+            event: { subscribe: jest.fn() },
+            emit: jest.fn(),
+        }),
+    };
+}
+function createLegacyRecord(name) {
+    return {
+        persistentVarId: "00mriijkhq94msfe9m2j6quwp",
+        name,
+        scope: "device",
+        isSecret: true,
+        value: { value: "encrypted:ciphertext" },
+        modifiedAt: 1234,
+    };
+}
+afterEach(() => {
+    if (originalClientFlag === undefined) {
+        delete process.env.PEERS_IS_CLIENT;
+    }
+    else {
+        process.env.PEERS_IS_CLIENT = originalClientFlag;
+    }
+    jest.resetModules();
+    jest.restoreAllMocks();
+});
+describe("PersistentVars legacy ID migration", () => {
+    it("uses one custom table RPC from a renderer client", async () => {
+        process.env.PEERS_IS_CLIENT = "true";
+        jest.resetModules();
+        await jest.isolateModulesAsync(async () => {
+            jest.doMock("../context/user-context-singleton", () => ({
+                getTableContainer: jest.fn(),
+                getUserContext: jest.fn(),
+            }));
+            const { PersistentVarsTable, persistentVarsMetaData } = await Promise.resolve().then(() => require("./persistent-vars"));
+            const { ClientProxyDataSource } = await Promise.resolve().then(() => require("./orm/client-proxy.data-source"));
+            const { rpcServerCalls } = await Promise.resolve().then(() => require("../rpc-types"));
+            const record = createLegacyRecord("rendererMigration");
+            const migrated = { ...record, persistentVarId: "00mriijkhq94msfe9m2j6quwq" };
+            const tableMethodCall = jest.fn().mockResolvedValue(migrated);
+            rpcServerCalls.tableMethodCall = tableMethodCall;
+            const dataContextId = "00mriijkhq94msfe9m2j6qabc";
+            const table = new PersistentVarsTable(persistentVarsMetaData, {
+                dataSource: new ClientProxyDataSource(persistentVarsMetaData, undefined, dataContextId),
+                eventRegistry: createEventRegistry(),
+            });
+            await expect(table.migrateLegacyId(record)).resolves.toEqual(migrated);
+            expect(tableMethodCall).toHaveBeenCalledTimes(1);
+            expect(tableMethodCall).toHaveBeenCalledWith(dataContextId, "PersistentVars", "migrateLegacyId", record);
+        });
+    });
+    it("removes a legacy duplicate when the canonical record already exists", async () => {
+        delete process.env.PEERS_IS_CLIENT;
+        jest.resetModules();
+        await jest.isolateModulesAsync(async () => {
+            jest.doMock("../context/user-context-singleton", () => ({
+                getTableContainer: jest.fn(),
+                getUserContext: jest.fn(),
+            }));
+            const { PersistentVarsTable, persistentVarsMetaData } = await Promise.resolve().then(() => require("./persistent-vars"));
+            const { deterministicPvarId } = await Promise.resolve().then(() => require("../utils"));
+            const legacy = createLegacyRecord("existingCanonical");
+            const canonical = {
+                ...legacy,
+                persistentVarId: deterministicPvarId(legacy.name),
+                value: { value: "encrypted:canonical" },
+            };
+            const deleteRecord = jest.fn().mockResolvedValue(undefined);
+            const save = jest.fn();
+            const table = new PersistentVarsTable(persistentVarsMetaData, {
+                dataSource: {
+                    tableName: "PersistentVars",
+                    primaryKeyName: "persistentVarId",
+                    get: jest.fn().mockResolvedValue(canonical),
+                    list: jest.fn(),
+                    count: jest.fn(),
+                    save,
+                    insert: jest.fn(),
+                    update: jest.fn(),
+                    delete: deleteRecord,
+                },
+                eventRegistry: createEventRegistry(),
+            });
+            await expect(table.migrateLegacyId(legacy)).resolves.toEqual(canonical);
+            expect(deleteRecord).toHaveBeenCalledWith(legacy);
+            expect(save).not.toHaveBeenCalled();
+        });
+    });
+    it("restores the legacy record when writing the canonical ID fails", async () => {
+        delete process.env.PEERS_IS_CLIENT;
+        jest.resetModules();
+        await jest.isolateModulesAsync(async () => {
+            jest.doMock("../context/user-context-singleton", () => ({
+                getTableContainer: jest.fn(),
+                getUserContext: jest.fn(),
+            }));
+            const { PersistentVarsTable, persistentVarsMetaData } = await Promise.resolve().then(() => require("./persistent-vars"));
+            const legacy = createLegacyRecord("rollbackMigration");
+            const migrationError = new Error("canonical write failed");
+            const deleteRecord = jest.fn().mockResolvedValue(undefined);
+            const save = jest.fn().mockRejectedValueOnce(migrationError).mockResolvedValueOnce(legacy);
+            const table = new PersistentVarsTable(persistentVarsMetaData, {
+                dataSource: {
+                    tableName: "PersistentVars",
+                    primaryKeyName: "persistentVarId",
+                    get: jest.fn().mockResolvedValue(undefined),
+                    list: jest.fn(),
+                    count: jest.fn(),
+                    save,
+                    insert: jest.fn(),
+                    update: jest.fn(),
+                    delete: deleteRecord,
+                },
+                eventRegistry: createEventRegistry(),
+            });
+            await expect(table.migrateLegacyId(legacy)).rejects.toBe(migrationError);
+            expect(deleteRecord).toHaveBeenCalledWith(legacy);
+            expect(save).toHaveBeenCalledTimes(2);
+            expect(save.mock.calls[0][0]).toMatchObject({
+                name: legacy.name,
+                value: legacy.value,
+            });
+            expect(save.mock.calls[0][0].persistentVarId).not.toBe(legacy.persistentVarId);
+            expect(save.mock.calls[1][0]).toEqual(legacy);
+        });
+    });
+});

package/dist/data/table-definitions-table.d.ts

@@ -34,7 +34,7 @@ export type ITableDefinitionRecord = z.infer<typeof tableDefinitionRecordSchema>
  *
  * @param dataContext - Optional data context; when omitted the singleton context is used.
  */
-export declare function TableDefinitions(dataContext?: DataContext): import("./orm").Table<{
+export declare function TableDefinitions(dataContext?: DataContext): import("..").Table<{
     name: string;
     metaData: {} & {
         [k: string]: any;

package/dist/data/tool-tests.d.ts

@@ -26,7 +26,7 @@ export declare const toolTestSchema: z.ZodObject<{
     mocks?: any;
 }>;
 export type IToolTest = z.infer<typeof toolTestSchema>;
-export declare function ToolTests(dataContext?: DataContext): import("./orm").Table<{
+export declare function ToolTests(dataContext?: DataContext): import("..").Table<{
     code: string;
     description: string;
     toolId: string;

package/dist/data/tools.d.ts

@@ -313,7 +313,7 @@ export interface IToolInstance {
     inputSchema?: z.ZodObject<any>;
     outputSchema?: z.ZodObject<any>;
 }
-export declare function Tools(dataContext?: DataContext): import("./orm").Table<{
+export declare function Tools(dataContext?: DataContext): import("..").Table<{
     code: string;
     name: string;
     toolId: string;

package/dist/data/user-trust-levels.d.ts

@@ -24,8 +24,10 @@ export declare const userTrustLevelSchema: z.ZodObject<{
     assignedAt?: Date | undefined;
     notes?: string | undefined;
 }>;
+/** A trust assignment for one user within a specific data context. */
 export type IUserTrustLevel = z.infer<typeof userTrustLevelSchema>;
-export declare function UserTrustLevels(dataContext?: DataContext): import("./orm").Table<{
+/** Returns the context-scoped table containing explicit user trust assignments. */
+export declare function UserTrustLevels(dataContext?: DataContext): import("..").Table<{
     userId: string;
     trustLevel: TrustLevel;
     assignedAt?: Date | undefined;

package/dist/data/user-trust-levels.js

@@ -33,6 +33,7 @@ const metaData = {
     indexes: [{ fields: ["trustLevel"] }],
 };
 (0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.userTrustLevelSchema);
+/** Returns the context-scoped table containing explicit user trust assignments. */
 function UserTrustLevels(dataContext) {
     return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.userTrustLevelSchema);
 }
@@ -41,7 +42,7 @@ function UserTrustLevels(dataContext) {
  * Returns TrustLevel.Unknown if no trust level has been assigned.
  */
 async function getUserTrustLevel(dataContext, userId) {
-    const userContext = await (0, user_context_singleton_1.getUserContext)();
+    const userContext = dataContext.userContext;
     if (dataContext === userContext.userDataContext && userContext.userId === userId) {
         return socket_type_1.TrustLevel.Self;
     }

package/dist/data/user-trust-levels.test.d.ts

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

package/dist/data/user-trust-levels.test.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const socket_type_1 = require("../device/socket.type");
+const utils_1 = require("../utils");
+const user_trust_levels_1 = require("./user-trust-levels");
+function makeDataContext(userId, trustRecord) {
+    const get = jest.fn().mockResolvedValue(trustRecord);
+    const userContext = { userId };
+    const dataContext = {
+        userContext,
+        tableContainer: {
+            getTable: jest.fn().mockReturnValue({ get }),
+        },
+    };
+    Object.assign(userContext, { userDataContext: dataContext });
+    return { dataContext, get };
+}
+describe("getUserTrustLevel", () => {
+    it("derives Self from the supplied personal context without a global user context", async () => {
+        const userId = (0, utils_1.newid)();
+        const { dataContext, get } = makeDataContext(userId);
+        await expect((0, user_trust_levels_1.getUserTrustLevel)(dataContext, userId)).resolves.toBe(socket_type_1.TrustLevel.Self);
+        expect(get).not.toHaveBeenCalled();
+    });
+    it("reads explicit trust from the supplied context", async () => {
+        const remoteUserId = (0, utils_1.newid)();
+        const { dataContext, get } = makeDataContext((0, utils_1.newid)(), {
+            trustLevel: socket_type_1.TrustLevel.Trusted,
+        });
+        await expect((0, user_trust_levels_1.getUserTrustLevel)(dataContext, remoteUserId)).resolves.toBe(socket_type_1.TrustLevel.Trusted);
+        expect(get).toHaveBeenCalledWith(remoteUserId);
+    });
+    it("returns Unknown when the supplied context has no trust assignment", async () => {
+        const { dataContext } = makeDataContext((0, utils_1.newid)());
+        await expect((0, user_trust_levels_1.getUserTrustLevel)(dataContext, (0, utils_1.newid)())).resolves.toBe(socket_type_1.TrustLevel.Unknown);
+    });
+});

package/dist/data/voice-messages.d.ts

@@ -23,7 +23,7 @@ export declare const voiceMessageSchema: z.ZodObject<{
     threadId?: string | undefined;
 }>;
 export type IVoiceMessage = z.infer<typeof voiceMessageSchema>;
-export declare function VoiceMessages(dataContext?: DataContext): import("./orm").Table<{
+export declare function VoiceMessages(dataContext?: DataContext): import("..").Table<{
     content: string;
     role: "user" | "assistant";
     createdAt: Date;

package/dist/data/workflow-logs.d.ts

@@ -66,7 +66,7 @@ export declare const workflowLogSchema: z.ZodObject<{
     isError?: boolean | undefined;
 }>;
 export type IWorkflowLog = z.infer<typeof workflowLogSchema>;
-export declare function WorkflowLogs(dataContext?: DataContext): import("./orm").Table<{
+export declare function WorkflowLogs(dataContext?: DataContext): import("..").Table<{
     workflowLogId: string;
     workflowRunId: string;
     contextId: string;

package/dist/data/workflow-runs.d.ts

@@ -32,6 +32,7 @@ export declare const workflowRunSchema: z.ZodObject<{
     parentWorkflowRunId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     defaultAssistantId: z.ZodEffects<z.ZodString, string, string>;
 }, "strip", z.ZodTypeAny, {
+    createdAt: Date;
     defaultAssistantId: string;
     instructions: {
         markdown?: string | undefined;
@@ -39,7 +40,6 @@ export declare const workflowRunSchema: z.ZodObject<{
         directCallToolId?: string | undefined;
         subWorkflowId?: string | undefined;
     }[];
-    createdAt: Date;
     workflowRunId: string;
     parentMessageId: string;
     currentInstructionIndex: number;
@@ -57,6 +57,7 @@ export declare const workflowRunSchema: z.ZodObject<{
     defaultAssistantId: string;
     workflowRunId: string;
     parentMessageId: string;
+    createdAt?: Date | undefined;
     workflowId?: string | undefined;
     instructions?: {
         markdown?: string | undefined;
@@ -64,7 +65,6 @@ export declare const workflowRunSchema: z.ZodObject<{
         directCallToolId?: string | undefined;
         subWorkflowId?: string | undefined;
     }[] | undefined;
-    createdAt?: Date | undefined;
     scheduleDT?: Date | undefined;
     currentInstructionIndex?: number | undefined;
     instructionResults?: any[] | undefined;

package/dist/data/workflows.d.ts

@@ -1,7 +1,9 @@
 import type { DataContext } from "../context/data-context";
-export declare function Workflows(dataContext?: DataContext): import("./orm").Table<{
+export declare function Workflows(dataContext?: DataContext): import("..").Table<{
     name: string;
     description: string;
+    createdAt: Date;
+    updatedAt: Date;
     workflowId: string;
     defaultAssistantId: string;
     instructions: {
@@ -11,7 +13,5 @@ export declare function Workflows(dataContext?: DataContext): import("./orm").Ta
         subWorkflowId?: string | undefined;
     }[];
     createdBy: string;
-    createdAt: Date;
-    updatedAt: Date;
     packageId?: string | undefined;
 }>;

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

@@ -35,7 +35,9 @@ export interface IBinaryPeer {
      */
     getBufferedAmount?(): number;
 }
+/** Backwards-compatible name for a WebRTC binary peer. */
 export type IWebRTCPeer = IBinaryPeer;
+/** Options for wrapping a binary transport in a verified Peers connection. */
 export interface WrapBinaryPeerOptions {
     /** Protocol identifier used for server address (e.g., 'wrtc' or 'ws') */
     protocol: "wrtc" | "ws";

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

@@ -324,9 +324,19 @@ function createBinaryPeerSocket(connectionId, peer, protocol = "binary") {
             return;
         }
         if (message.type === "call") {
-            const handler = handlers[message.eventName];
+            const eventName = message.eventName;
+            const handler = eventName ? handlers[eventName] : undefined;
             if (!handler) {
-                console.warn(`No handler for event: ${message.eventName}`);
+                const error = eventName
+                    ? `No handler registered for event: ${eventName}`
+                    : "RPC call did not include an event name";
+                console.warn(error);
+                const responseMessage = {
+                    type: "callback",
+                    callbackId: message.callbackId,
+                    error,
+                };
+                sendRPC(encodeMessage(responseMessage));
                 return;
             }
             try {

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

@@ -117,6 +117,29 @@ describe("binary-peer-connection-v2", () => {
             iPeer.destroy();
             rPeer.destroy();
         });
+        it("should return an error when the remote event has no handler", async () => {
+            const { iPeer, rPeer } = await getMockPeerPair();
+            const socketA = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("a", iPeer, "ws");
+            (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("b", rPeer, "ws");
+            const warning = jest.spyOn(console, "warn").mockImplementation(() => { });
+            try {
+                const response = await new Promise((resolve) => {
+                    socketA.emit("missing-event", {}, (error, result) => {
+                        resolve({ error, result });
+                    });
+                });
+                expect(response).toEqual({
+                    error: "No handler registered for event: missing-event",
+                    result: undefined,
+                });
+                expect(warning).toHaveBeenCalledWith("No handler registered for event: missing-event");
+            }
+            finally {
+                warning.mockRestore();
+                iPeer.destroy();
+                rPeer.destroy();
+            }
+        });
         it("should handle Uint8Array args without txEncode", async () => {
             const { iPeer, rPeer } = await getMockPeerPair();
             const socketA = (0, binary_peer_connection_v2_1.createBinaryPeerSocket)("a", iPeer, "ws");

package/dist/device/get-trust-level-fn.d.ts

@@ -1,3 +1,9 @@
 import { type IDeviceInfo } from "../data";
 import { TrustLevel } from "./socket.type";
+/**
+ * Build the connection-handshake trust evaluator for a local user identity.
+ *
+ * Known user keys are authoritative even for a newly observed device: a claimed identity
+ * whose signing or box key differs from the stored user record is rejected as untrusted.
+ */
 export declare function getTrustLevelFn(me: Pick<IDeviceInfo, "userId" | "publicKey" | "publicBoxKey">, serverUrl?: string): (deviceInfo: IDeviceInfo, _registerNew?: boolean) => Promise<TrustLevel>;