@peers-app/peers-sdk 0.16.4 → 0.16.6

package/dist/events.js

@@ -1,37 +1,195 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Emitter = exports.Event = void 0;
+exports.notifyClientConnected = notifyClientConnected;
+exports.subscribePrefix = subscribePrefix;
 exports.subscribe = subscribe;
 exports.subscribeDebounce = subscribeDebounce;
 exports.emit = emit;
 exports.unionEvents = unionEvents;
 const rpc_types_1 = require("./rpc-types");
 const unitTests = process.env.NODE_ENV === "test";
-const subscriptions = [];
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+// ─── Subscription Storage ────────────────────────────────────────────────────
+/** Subscriptions indexed by exact event name for O(1) dispatch. */
+const nameIndex = new Map();
+/** Subscriptions that use custom filter functions (checked on every emit). */
+const wildcardSubscriptions = new Set();
+function addSubscription(subscription) {
+    if (subscription.eventName) {
+        let bucket = nameIndex.get(subscription.eventName);
+        if (!bucket) {
+            bucket = new Set();
+            nameIndex.set(subscription.eventName, bucket);
+        }
+        bucket.add(subscription);
+    }
+    else {
+        wildcardSubscriptions.add(subscription);
+    }
+}
+function removeSubscription(subscription) {
+    if (subscription.eventName) {
+        const bucket = nameIndex.get(subscription.eventName);
+        if (bucket) {
+            const removed = bucket.delete(subscription);
+            if (bucket.size === 0) {
+                nameIndex.delete(subscription.eventName);
+            }
+            return removed;
+        }
+        return false;
+    }
+    return wildcardSubscriptions.delete(subscription);
+}
+// ─── Client → Server Subscription Registration ──────────────────────────────
+// In multi-process mode (Electron), the client tells the server which event
+// names/prefixes it cares about so the server can skip forwarding unneeded events.
+/** Reference counts for event names registered with the server. */
+const clientNameRefCounts = new Map();
+/** Reference counts for event prefixes registered with the server. */
+const clientPrefixRefCounts = new Map();
+/** Whether the client-server connection is established (for deferred registration). */
+let clientConnected = false;
+/** Names pending registration (accumulated before connection is ready). */
+const pendingNameSubscriptions = new Set();
+/** Prefixes pending registration (accumulated before connection is ready). */
+const pendingPrefixSubscriptions = new Set();
+/**
+ * Notify the events system that the client connection is ready.
+ * Flushes any subscriptions that were registered before the connection.
+ */
+function notifyClientConnected() {
+    clientConnected = true;
+    if (pendingNameSubscriptions.size > 0) {
+        const names = [...pendingNameSubscriptions];
+        pendingNameSubscriptions.clear();
+        rpc_types_1.rpcServerCalls.subscribeEvents(names).catch((err) => {
+            console.error("Failed to register pending event subscriptions with server", err);
+        });
+    }
+    if (pendingPrefixSubscriptions.size > 0) {
+        const prefixes = [...pendingPrefixSubscriptions];
+        pendingPrefixSubscriptions.clear();
+        rpc_types_1.rpcServerCalls.subscribePrefixes(prefixes).catch((err) => {
+            console.error("Failed to register pending prefix subscriptions with server", err);
+        });
+    }
+}
+function clientRegisterName(name) {
+    if (unitTests || (0, rpc_types_1.isSingleProcessClient)())
+        return;
+    const count = clientNameRefCounts.get(name) || 0;
+    clientNameRefCounts.set(name, count + 1);
+    if (count === 0) {
+        if (clientConnected) {
+            rpc_types_1.rpcServerCalls.subscribeEvents([name]).catch((err) => {
+                console.error(`Failed to register event subscription with server: ${name}`, err);
+            });
+        }
+        else {
+            pendingNameSubscriptions.add(name);
+        }
+    }
+}
+function clientUnregisterName(name) {
+    if (unitTests || (0, rpc_types_1.isSingleProcessClient)())
+        return;
+    const count = clientNameRefCounts.get(name) || 0;
+    if (count <= 1) {
+        clientNameRefCounts.delete(name);
+        pendingNameSubscriptions.delete(name);
+        if (clientConnected) {
+            rpc_types_1.rpcServerCalls.unsubscribeEvents([name]).catch((err) => {
+                console.error(`Failed to unregister event subscription with server: ${name}`, err);
+            });
+        }
+    }
+    else {
+        clientNameRefCounts.set(name, count - 1);
+    }
+}
+/**
+ * Register a prefix-based event subscription with the server.
+ * Events whose name starts with this prefix will be forwarded to the client.
+ * Returns an unsubscribe function that decrements the refcount.
+ */
+function subscribePrefix(prefix) {
+    if (!rpc_types_1.isClient || unitTests || (0, rpc_types_1.isSingleProcessClient)()) {
+        return () => { };
+    }
+    const count = clientPrefixRefCounts.get(prefix) || 0;
+    clientPrefixRefCounts.set(prefix, count + 1);
+    if (count === 0) {
+        if (clientConnected) {
+            rpc_types_1.rpcServerCalls.subscribePrefixes([prefix]).catch((err) => {
+                console.error(`Failed to register prefix subscription with server: ${prefix}`, err);
+            });
+        }
+        else {
+            pendingPrefixSubscriptions.add(prefix);
+        }
+    }
+    return () => {
+        const current = clientPrefixRefCounts.get(prefix) || 0;
+        if (current <= 1) {
+            clientPrefixRefCounts.delete(prefix);
+            pendingPrefixSubscriptions.delete(prefix);
+            if (clientConnected) {
+                rpc_types_1.rpcServerCalls.unsubscribePrefixes([prefix]).catch((err) => {
+                    console.error(`Failed to unregister prefix subscription with server: ${prefix}`, err);
+                });
+            }
+        }
+        else {
+            clientPrefixRefCounts.set(prefix, current - 1);
+        }
+    };
+}
+// ─── Server-Side Event Forwarding Gate ───────────────────────────────────────
+// The server uses this to decide whether to forward an event to the client.
+/** Event names the client has subscribed to. Server-side only. */
+const serverClientNames = new Set();
+/** Event prefixes the client has subscribed to. Server-side only. */
+const serverClientPrefixes = new Set();
+/**
+ * Check whether the client wants this event.
+ * Used by the server to gate `rpcClientCalls.emitEvent`.
+ */
+function clientWantsEvent(event) {
+    if (serverClientNames.has(event.name))
+        return true;
+    for (const prefix of serverClientPrefixes) {
+        if (event.name.startsWith(prefix))
+            return true;
+    }
+    return false;
+}
+// ─── Public API ──────────────────────────────────────────────────────────────
 function subscribe(nameOrFilter, handler) {
+    let eventName;
+    let filter;
     if (typeof nameOrFilter === "string") {
-        const name = nameOrFilter;
-        nameOrFilter = (evt) => evt.name === name;
+        eventName = nameOrFilter;
+        filter = (evt) => evt.name === eventName;
+    }
+    else {
+        filter = nameOrFilter;
+    }
+    const subscription = { filter, handler, eventName };
+    addSubscription(subscription);
+    if (rpc_types_1.isClient && eventName) {
+        clientRegisterName(eventName);
     }
-    const filter = nameOrFilter;
-    const subscription = {
-        filter,
-        handler,
-    };
-    subscriptions.push(subscription);
     return {
         unsubscribe: () => {
-            const iSub = subscriptions.indexOf(subscription);
-            if (iSub >= 0) {
-                subscriptions.splice(iSub, 1);
-                return true;
+            const removed = removeSubscription(subscription);
+            if (removed && rpc_types_1.isClient && eventName) {
+                clientUnregisterName(eventName);
             }
-            return false;
+            return removed;
         },
     };
 }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function subscribeDebounce(nameOrFilter, handler, debounceMs) {
     let pid = 0;
     const handlerDebounced = (evt) => {
@@ -46,37 +204,64 @@ function subscribeDebounce(nameOrFilter, handler, debounceMs) {
     return subscribe(nameOrFilter, handlerDebounced);
 }
 async function emit(event, dontPropagate) {
-    const matchedHandlerPromises = subscriptions
-        .filter((subscription) => subscription.filter(event))
-        .map(async (subscription) => {
+    const matched = [];
+    const bucket = nameIndex.get(event.name);
+    if (bucket) {
+        for (const sub of bucket) {
+            matched.push(sub);
+        }
+    }
+    for (const sub of wildcardSubscriptions) {
+        if (sub.filter(event)) {
+            matched.push(sub);
+        }
+    }
+    const handlerPromises = matched.map(async (subscription) => {
         try {
             return await subscription.handler(event);
         }
         catch (err) {
-            console.error(`An unhandled error occurred in a handler while processing event: ${JSON.stringify({ event, subscription })}`, err);
+            console.error(`An unhandled error occurred in a handler while processing event: ${JSON.stringify({ event })}`, err);
             return false;
         }
     });
-    // if (!(dontPropagate || unitTests)) {
-    //   matchedHandlerPromises.push(
-    //     isClient
-    //       ? rpcServerCalls.emitEvent(event).catch((err) => { console.error(`Error while propagating event to server`, err); return false; })
-    //       : rpcClientCalls.emitEvent(event).catch((err) => { console.error(`Error while propagating event to client`, err); return false; })
-    //   );
-    // }
     if (!(dontPropagate || unitTests || (0, rpc_types_1.isSingleProcessClient)())) {
-        matchedHandlerPromises.push(rpc_types_1.rpcClientCalls.emitEvent(event).catch((err) => {
-            console.error(`Error while propagating event to client`, err);
-            return false;
-        }));
+        if (clientWantsEvent(event)) {
+            handlerPromises.push(rpc_types_1.rpcClientCalls.emitEvent(event).catch((err) => {
+                console.error(`Error while propagating event to client`, err);
+                return false;
+            }));
+        }
     }
-    const results = await Promise.all(matchedHandlerPromises);
-    // if any handlers returned false (or errored), return false, otherwise return true
+    const results = await Promise.all(handlerPromises);
     return !results.some((r) => r === false);
 }
 if (rpc_types_1.isClient) {
     rpc_types_1.rpcClientCalls.emitEvent = (event) => emit(event, true);
 }
+// Server-side: register RPC handlers for client subscription management
+if (!rpc_types_1.isClient) {
+    rpc_types_1.rpcServerCalls.subscribeEvents = async (names) => {
+        for (const name of names) {
+            serverClientNames.add(name);
+        }
+    };
+    rpc_types_1.rpcServerCalls.unsubscribeEvents = async (names) => {
+        for (const name of names) {
+            serverClientNames.delete(name);
+        }
+    };
+    rpc_types_1.rpcServerCalls.subscribePrefixes = async (prefixes) => {
+        for (const prefix of prefixes) {
+            serverClientPrefixes.add(prefix);
+        }
+    };
+    rpc_types_1.rpcServerCalls.unsubscribePrefixes = async (prefixes) => {
+        for (const prefix of prefixes) {
+            serverClientPrefixes.delete(prefix);
+        }
+    };
+}
 class Event {
     _eventName;
     constructor(_eventName) {
@@ -119,7 +304,6 @@ class Emitter {
     }
 }
 exports.Emitter = Emitter;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function unionEvents(...events) {
     const eventName = events.map((s) => s.eventName()).join("|");
     return {

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./context";
+export * from "./contracts";
 export * from "./data";
 export * as data from "./data";
 export * from "./data/orm";

package/dist/index.js

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tools = exports.workflowLogSchema = exports.WorkflowLogs = exports.getLogger = exports.orm = exports.data = void 0;
 __exportStar(require("./context"), exports);
+__exportStar(require("./contracts"), exports);
 __exportStar(require("./data"), exports);
 exports.data = require("./data");
 __exportStar(require("./data/orm"), exports);

package/dist/package-loader/contract-package-loader.d.ts

@@ -0,0 +1,23 @@
+import type { DataContext } from "../context/data-context";
+import type { ContractRegistry } from "../contracts/registry";
+import type { IPackageDefinitionResult } from "../contracts/types";
+/**
+ * Installs a contract-based package into a DataContext.
+ *
+ * Handles packages that export an `IPackageDefinitionResult` from `definePackage()`.
+ * Registers contracts in the provided ContractRegistry, saves tools/assistants/workflows
+ * with the `packageId` from the definition set, and registers table definitions.
+ */
+export declare function installContractPackage(dataContext: DataContext, packageDefinition: IPackageDefinitionResult, opts?: {
+    registry?: ContractRegistry;
+}): Promise<void>;
+/**
+ * Attempts to extract an `IPackageDefinitionResult` from a bundle's module exports.
+ * Returns undefined if the bundle doesn't export a contract-based package definition.
+ */
+export declare function extractPackageDefinition(bundleExports: Record<string, unknown>): IPackageDefinitionResult | undefined;
+/**
+ * Determines whether a bundle exports a contract-based package definition,
+ * indicating it should be installed via the new contract-aware path.
+ */
+export declare function hasPackageDefinition(bundleExports: Record<string, unknown>): boolean;

package/dist/package-loader/contract-package-loader.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installContractPackage = installContractPackage;
+exports.extractPackageDefinition = extractPackageDefinition;
+exports.hasPackageDefinition = hasPackageDefinition;
+const tools_1 = require("../data/tools");
+const tools_2 = require("../tools");
+/**
+ * Installs a contract-based package into a DataContext.
+ *
+ * Handles packages that export an `IPackageDefinitionResult` from `definePackage()`.
+ * Registers contracts in the provided ContractRegistry, saves tools/assistants/workflows
+ * with the `packageId` from the definition set, and registers table definitions.
+ */
+async function installContractPackage(dataContext, packageDefinition, opts) {
+    const { packageId } = packageDefinition;
+    const registry = opts?.registry;
+    // Register contracts in the in-memory registry
+    if (registry) {
+        for (const contract of packageDefinition.contracts) {
+            const key = `${contract.contractId}@${contract.version}`;
+            const alsoImpl = packageDefinition.alsoImplements.get(key) ?? [];
+            const result = registry.register(packageId, contract, alsoImpl);
+            if (!result.valid) {
+                console.error(`[ContractPackageLoader] Contract registration failed for ${contract.name}:`, result.errors);
+            }
+        }
+    }
+    // Install tool instances with packageId
+    for (const toolInstance of packageDefinition.toolInstances) {
+        (0, tools_2.registerTool)(toolInstance);
+        const toolWithPackageId = { ...toolInstance.tool, packageId };
+        await (0, tools_1.Tools)(dataContext).save(toolWithPackageId);
+    }
+    // Install table definitions
+    for (const tableDefinition of packageDefinition.tableDefinitions) {
+        dataContext.tableContainer.registerTableDefinition(tableDefinition, {
+            overwrite: true,
+        });
+    }
+    // Install assistants with packageId
+    const { Assistants } = await Promise.resolve().then(() => require("../data/assistants"));
+    for (const assistant of packageDefinition.assistants) {
+        const assistantWithPackageId = { ...assistant, packageId };
+        await Assistants(dataContext).save(assistantWithPackageId);
+    }
+}
+/**
+ * Attempts to extract an `IPackageDefinitionResult` from a bundle's module exports.
+ * Returns undefined if the bundle doesn't export a contract-based package definition.
+ */
+function extractPackageDefinition(bundleExports) {
+    const def = bundleExports?.packageDefinition;
+    if (def && Array.isArray(def.contracts) && def.contracts.length > 0) {
+        return def;
+    }
+    return undefined;
+}
+/**
+ * Determines whether a bundle exports a contract-based package definition,
+ * indicating it should be installed via the new contract-aware path.
+ */
+function hasPackageDefinition(bundleExports) {
+    return extractPackageDefinition(bundleExports) !== undefined;
+}

package/dist/package-loader/index.d.ts

@@ -1 +1,2 @@
+export * from "./contract-package-loader";
 export * from "./package-loader";

package/dist/package-loader/index.js

@@ -14,4 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./contract-package-loader"), exports);
 __exportStar(require("./package-loader"), exports);

package/dist/package-loader/package-loader.d.ts

@@ -6,8 +6,12 @@ export declare class PackageLoader {
     static PeersSDK: any;
     static Zod: any;
     private packageInstances;
+    /** Packages that were installed via the contract-based path (tools/assistants/tables already saved with packageId). */
+    private contractInstalledPackages;
     require: (<T>(module: string) => T) | undefined;
     constructor(dataContext: DataContext);
+    /** Returns true if a package was installed via the contract-based definePackage() path. */
+    isContractInstalled(packageId: string): boolean;
     loadAllPackages(opts?: {
         force?: boolean;
     }): Promise<void>;
@@ -16,6 +20,13 @@ export declare class PackageLoader {
         localPath?: string;
     }): Promise<IPeersPackage | undefined>;
     private _readLocalBundle;
+    /**
+     * Post-correction: if the package definition carries version/versionTag,
+     * update the active IPackageVersion record to match. This fixes cases where
+     * the PV record was created with stale or placeholder values (e.g. "0.0.1")
+     * before the bundle was evaluated.
+     */
+    private correctPackageVersion;
     private _evaluateBundle;
 }
 export declare function setDefaultRequire(require: <T>(module: string) => T): void;

package/dist/package-loader/package-loader.js

@@ -7,15 +7,22 @@ const package_versions_1 = require("../data/package-versions");
 const packages_1 = require("../data/packages");
 const tools_1 = require("../data/tools");
 const tools_2 = require("../tools");
+const contract_package_loader_1 = require("./contract-package-loader");
 class PackageLoader {
     dataContext;
     static PeersSDK;
     static Zod;
     packageInstances = {};
+    /** Packages that were installed via the contract-based path (tools/assistants/tables already saved with packageId). */
+    contractInstalledPackages = new Set();
     require = undefined;
     constructor(dataContext) {
         this.dataContext = dataContext;
     }
+    /** Returns true if a package was installed via the contract-based definePackage() path. */
+    isContractInstalled(packageId) {
+        return this.contractInstalledPackages.has(packageId);
+    }
     async loadAllPackages(opts) {
         const packages = await (0, packages_1.Packages)(this.dataContext).list();
         await Promise.all(packages.filter((pkg) => !pkg.disabled).map((pkg) => this.loadPackage(pkg, opts)));
@@ -91,6 +98,36 @@ class PackageLoader {
             return;
         }
     }
+    /**
+     * Post-correction: if the package definition carries version/versionTag,
+     * update the active IPackageVersion record to match. This fixes cases where
+     * the PV record was created with stale or placeholder values (e.g. "0.0.1")
+     * before the bundle was evaluated.
+     */
+    correctPackageVersion(pkg, def) {
+        if (!pkg.activePackageVersionId)
+            return;
+        if (!def.version && !def.versionTag)
+            return;
+        const pvTable = (0, package_versions_1.PackageVersions)(this.dataContext);
+        pvTable.get(pkg.activePackageVersionId).then((pv) => {
+            if (!pv)
+                return;
+            let needsUpdate = false;
+            const updated = { ...pv };
+            if (def.version && pv.version !== def.version) {
+                updated.version = def.version;
+                needsUpdate = true;
+            }
+            if (def.versionTag && pv.versionTag !== def.versionTag) {
+                updated.versionTag = def.versionTag;
+                needsUpdate = true;
+            }
+            if (needsUpdate) {
+                pvTable.save(updated);
+            }
+        });
+    }
     _evaluateBundle(pkg, bundleCode) {
         // Node.js built-in modules that do not exist in React Native (and would cause
         // a fatal native error if passed through to RN's require). We block them here
@@ -156,18 +193,32 @@ class PackageLoader {
             const bundleFunction = new Function("module", "exports", "require", bundleCode);
             bundleFunction(module, moduleExports, customRequire);
             const bundleExports = module.exports;
+            // Check for contract-based package definition (new path)
+            const packageDefinition = (0, contract_package_loader_1.extractPackageDefinition)(bundleExports);
+            if (packageDefinition) {
+                if (packageDefinition.packageId !== pkg.packageId) {
+                    console.warn(`[PackageLoader] packageId mismatch: definition has "${packageDefinition.packageId}" but DB record has "${pkg.packageId}"`);
+                }
+                (0, contract_package_loader_1.installContractPackage)(this.dataContext, packageDefinition);
+                this.contractInstalledPackages.add(packageDefinition.packageId);
+                this.correctPackageVersion(pkg, packageDefinition);
+            }
+            // Legacy path: extract IPeersPackage for backward compat
             const packageInstance = bundleExports?.exports || bundleExports?.package || bundleExports?.default || bundleExports;
             this.packageInstances[pkg.packageId] = packageInstance;
             if (packageInstance && typeof packageInstance === "object") {
-                packageInstance.toolInstances?.forEach((toolInstance) => {
-                    (0, tools_2.registerTool)(toolInstance);
-                    (0, tools_1.Tools)(this.dataContext).save(toolInstance.tool);
-                });
-                packageInstance.tableDefinitions?.forEach((tableDefinition) => {
-                    this.dataContext.tableContainer.registerTableDefinition(tableDefinition, {
-                        overwrite: true,
+                // Skip legacy tool/table registration if the contract path already handled it
+                if (!packageDefinition) {
+                    packageInstance.toolInstances?.forEach((toolInstance) => {
+                        (0, tools_2.registerTool)(toolInstance);
+                        (0, tools_1.Tools)(this.dataContext).save(toolInstance.tool);
+                    });
+                    packageInstance.tableDefinitions?.forEach((tableDefinition) => {
+                        this.dataContext.tableContainer.registerTableDefinition(tableDefinition, {
+                            overwrite: true,
+                        });
                     });
-                });
+                }
                 return packageInstance;
             }
             return;

package/dist/rpc-types.d.ts

@@ -116,6 +116,10 @@ export declare const rpcServerCalls: {
     voiceDisable: () => Promise<void>;
     voiceEnable: () => Promise<void>;
     flushDatabases: () => Promise<void>;
+    subscribeEvents: (names: string[]) => Promise<void>;
+    unsubscribeEvents: (names: string[]) => Promise<void>;
+    subscribePrefixes: (prefixes: string[]) => Promise<void>;
+    unsubscribePrefixes: (prefixes: string[]) => Promise<void>;
 };
 export declare const rpcClientCalls: {
     ping: (msg: string) => Promise<string>;

package/dist/rpc-types.js

@@ -67,10 +67,11 @@ exports.rpcServerCalls = {
     // Flush all in-memory database snapshots to durable storage (IndexedDB in PWA).
     // No-op on Electron where better-sqlite3 writes are synchronous to disk.
     flushDatabases: (async () => { }),
-    // TODO try to get rid of this and rely on the client-side table and server-side table individually emitting events
-    // TODO TODO before deleting this, check if we can stop client-side tables from emitting events and rely solely on server-side tables
-    //           propagating events with rpcClientCalls.emitEvent.  It's very likely we're currently seeing two events for every one write originating from the UI
-    // emitEvent: _na as ((event: IEventData) => Promise<boolean>),
+    // Event subscription management (for selective proxying)
+    subscribeEvents: rpcStub("subscribeEvents"),
+    unsubscribeEvents: rpcStub("unsubscribeEvents"),
+    subscribePrefixes: rpcStub("subscribePrefixes"),
+    unsubscribePrefixes: rpcStub("unsubscribePrefixes"),
 };
 exports.rpcClientCalls = {
     ping: async (msg) => `pong: ${msg}`,

package/dist/types/workflow.d.ts

@@ -40,6 +40,7 @@ export declare const workflowSchema: z.ZodObject<{
     createdBy: z.ZodEffects<z.ZodString, string, string>;
     createdAt: z.ZodDefault<z.ZodDate>;
     updatedAt: z.ZodDefault<z.ZodDate>;
+    packageId: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     description: string;
@@ -54,12 +55,14 @@ export declare const workflowSchema: z.ZodObject<{
         subWorkflowId?: string | undefined;
     }[];
     updatedAt: Date;
+    packageId?: string | undefined;
 }, {
     name: string;
     description: string;
     createdBy: string;
     workflowId: string;
     defaultAssistantId: string;
+    packageId?: string | undefined;
     createdAt?: Date | undefined;
     instructions?: {
         markdown?: string | undefined;

package/dist/types/workflow.js

@@ -35,4 +35,5 @@ exports.workflowSchema = zod_1.z.object({
         .date()
         .default(() => new Date())
         .describe("The date the workflow was last updated"),
+    packageId: zod_types_1.zodPeerId.optional().describe("The package that installed this workflow, if any"),
 });

package/dist/utils.d.ts

@@ -31,6 +31,21 @@ export declare function simpleHash(str: string): number;
 export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 /** `simpleHash` of JSON-stable stringification of an object. */
 export declare function simpleObjectHash(obj: any): number;
+/**
+ * Generates a deterministic 25-character peer ID for a persistent variable.
+ * The ID has the fixed prefix `000pvar0` (8 chars) followed by 17 base-36 characters
+ * derived from a SHA-512 hash of the input name. Two calls with the same name always
+ * return the same ID.
+ *
+ * @param name The persistent variable name as stored in the database
+ *   (already includes group suffixes for groupDevice/groupUser scopes)
+ */
+export declare function deterministicPvarId(name: string): string;
+/**
+ * Returns whether a peer ID was generated by {@link deterministicPvarId}
+ * (starts with the `000pvar0` prefix).
+ */
+export declare function isDeterministicPvarId(id: string): boolean;
 /** Resolves after `ms` milliseconds (0 yields a microtask-yield on most runtimes). */
 export declare function sleep(ms?: number): Promise<void>;
 /** Turns `fooBar` into `Foo Bar` for labels (also replaces `_` with space). */