@peers-app/peers-sdk 0.19.14 → 0.20.0

package/dist/contracts/system/logs-contract.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOGS_CONTRACT_VERSION = void 0;
+exports.getLogsContractDefinition = getLogsContractDefinition;
+exports.resolveLogsContract = resolveLogsContract;
+const user_context_singleton_1 = require("../../context/user-context-singleton");
+const types_1 = require("../../data/orm/types");
+const console_logs_table_1 = require("../../logging/console-logs.table");
+const system_ids_1 = require("../../system-ids");
+const contract_resolvers_1 = require("../contract-resolvers");
+/** Version of the built-in System Logs contract. */
+exports.LOGS_CONTRACT_VERSION = 1;
+let _definition;
+/**
+ * The first built-in **system contract**: read and write the local device's console logs.
+ *
+ * It declares only the `ConsoleLogs` table — the table's own methods (`list`, `count`,
+ * `deleteOldLogs`, …) are the entire surface we need, so no bespoke tools are required.
+ * The table shape is derived from {@link consoleLogSchema} so the contract stays accurate.
+ *
+ * Built lazily and memoized: reading `consoleLogsMetaData` / `consoleLogSchema` at module
+ * load would race the import cycle between the logging table and the SDK barrel, so we defer
+ * construction until first use (well after all modules have finished initializing).
+ */
+function getLogsContractDefinition() {
+    if (!_definition) {
+        _definition = {
+            contractId: system_ids_1.logsContractId,
+            version: exports.LOGS_CONTRACT_VERSION,
+            devTag: "dev",
+            name: "System Logs",
+            description: "Read and write the local device's console logs.",
+            tables: [
+                {
+                    name: console_logs_table_1.consoleLogsMetaData.name,
+                    description: console_logs_table_1.consoleLogsMetaData.description,
+                    primaryKeyName: console_logs_table_1.consoleLogsMetaData.primaryKeyName,
+                    fields: (0, types_1.schemaToFields)(console_logs_table_1.consoleLogSchema),
+                },
+            ],
+            tools: [],
+            observables: [],
+            events: [],
+        };
+    }
+    return _definition;
+}
+/**
+ * Resolve the logs contract to its live implementation for a data context: the
+ * `ConsoleLogs` table backing that context.
+ */
+function resolveLogsContract(ctx) {
+    const consoleLogs = (0, user_context_singleton_1.getTableContainer)(ctx.dataContext).getTable(console_logs_table_1.consoleLogsMetaData, console_logs_table_1.consoleLogSchema, console_logs_table_1.ConsoleLogsTable);
+    return {
+        contractId: system_ids_1.logsContractId,
+        version: exports.LOGS_CONTRACT_VERSION,
+        tables: { [console_logs_table_1.consoleLogsMetaData.name]: consoleLogs },
+    };
+}
+(0, contract_resolvers_1.registerContractResolver)(system_ids_1.logsContractId, exports.LOGS_CONTRACT_VERSION, resolveLogsContract);

package/dist/contracts/types.d.ts

@@ -1,11 +1,12 @@
 import type { Table } from "../data/orm/table";
 import type { ITableDefinition } from "../data/orm/table-definitions.type";
 import type { IToolInstance } from "../data/tools";
+import type { Event } from "../events";
 import type { Observable } from "../observable";
 import type { FieldType, IField } from "../types/field-type";
 /**
- * A versioned interface definition declaring the shape of tables, tools, and
- * observables that a package provides. Pure data — no executable code.
+ * A versioned interface definition declaring the shape of tables, tools,
+ * observables, and events that a package provides. Pure data — no executable code.
  */
 export interface IContractDefinition {
     contractId: string;
@@ -17,6 +18,12 @@ export interface IContractDefinition {
     tables: IContractTable[];
     tools: IContractTool[];
     observables: IContractObservable[];
+    /**
+     * Events a provider may emit and consumers may subscribe to. Optional so
+     * existing contract definitions stay valid; the {@link ContractBuilder} always
+     * emits an array (possibly empty) and consumers read `contract.events ?? []`.
+     */
+    events?: IContractEvent[];
 }
 /** Table shape within a contract — derived from ITableMetaData + IField[]. */
 export interface IContractTable {
@@ -39,6 +46,18 @@ export interface IContractObservable {
     valueType: FieldType;
     writable: boolean;
 }
+/**
+ * A generic event a contract provider may emit. Consumers subscribe by name; the
+ * provider only forwards payloads over the transport while at least one consumer
+ * has an active subscription (see the provider session). Pure shape — the live
+ * {@link Event} is supplied at resolution time in {@link IContractResolution.events}.
+ */
+export interface IContractEvent {
+    name: string;
+    description: string;
+    /** Shape of the payload delivered to subscribers when the event fires. */
+    payloadFields: IField[];
+}
 /**
  * A reference to a contract that a package wants to consume.
  * Recorded during `definePackage` and checked at install time.
@@ -46,6 +65,7 @@ export interface IContractObservable {
 export interface IConsumedContract {
     contractId: string;
     version: number;
+    optional?: boolean;
 }
 /**
  * Declares that the owning contract's implementation also satisfies another
@@ -86,15 +106,18 @@ export interface IResolvedContract {
     tables: Record<string, Table<any>>;
     tools: Record<string, IToolInstance>;
     observables: Record<string, Observable<any>>;
+    /** Live events the provider forwards from, keyed by contract event name. */
+    events?: Record<string, Event<any>>;
 }
 /** Outcome of a validation check. */
 export interface IValidationResult {
     valid: boolean;
     errors: IValidationError[];
 }
+/** One incompatibility found while validating a contract definition or provider. */
 export interface IValidationError {
-    /** Which element failed: `'table'`, `'tool'`, `'observable'`, `'contract'` */
-    kind: "table" | "tool" | "observable" | "contract" | "field";
+    /** Which contract element failed validation. */
+    kind: "table" | "tool" | "observable" | "event" | "contract" | "field";
     /** Name of the element (table name, tool name, etc.) */
     name: string;
     message: string;

package/dist/contracts/validate.d.ts

@@ -1,8 +1,8 @@
 import type { IAlsoImplementsDeclaration, IContractDefinition, IValidationResult } from "./types";
 /**
  * Validate that an implementation contract satisfies a target contract shape.
- * The implementation must be a superset: all contract tables, tools, and
- * observables must be present with compatible shapes.
+ * The implementation must be a superset: all contract tables, tools,
+ * observables, and events must be present with compatible shapes.
  */
 export declare function validateProviderSatisfiesContract(impl: IContractDefinition, contract: IContractDefinition): IValidationResult;
 /**

package/dist/contracts/validate.js

@@ -114,10 +114,36 @@ function validateToolFields(contractTool, implTool, direction) {
     }
     return errors;
 }
+function validateEventFields(contractEvent, implEvent) {
+    const errors = [];
+    const implFieldMap = new Map(implEvent.payloadFields.map((field) => [field.name, field]));
+    for (const contractField of contractEvent.payloadFields) {
+        const implField = implFieldMap.get(contractField.name);
+        if (!implField) {
+            if (!contractField.optional) {
+                errors.push({
+                    kind: "field",
+                    name: `${contractEvent.name}.payload.${contractField.name}`,
+                    message: `Required payload field '${contractField.name}' missing from implementation event '${implEvent.name}'`,
+                });
+            }
+            continue;
+        }
+        const compat = isFieldCompatible(contractField, implField);
+        if (compat) {
+            errors.push({
+                kind: "field",
+                name: `${contractEvent.name}.payload.${contractField.name}`,
+                message: `Payload field '${contractField.name}' in event '${implEvent.name}': ${compat}`,
+            });
+        }
+    }
+    return errors;
+}
 /**
  * Validate that an implementation contract satisfies a target contract shape.
- * The implementation must be a superset: all contract tables, tools, and
- * observables must be present with compatible shapes.
+ * The implementation must be a superset: all contract tables, tools,
+ * observables, and events must be present with compatible shapes.
  */
 function validateProviderSatisfiesContract(impl, contract) {
     const errors = [];
@@ -184,6 +210,20 @@ function validateProviderSatisfiesContract(impl, contract) {
             });
         }
     }
+    // Events
+    const implEventMap = new Map((impl.events ?? []).map((event) => [event.name, event]));
+    for (const contractEvent of contract.events ?? []) {
+        const implEvent = implEventMap.get(contractEvent.name);
+        if (!implEvent) {
+            errors.push({
+                kind: "event",
+                name: contractEvent.name,
+                message: `Event '${contractEvent.name}' required by contract but not provided by implementation`,
+            });
+            continue;
+        }
+        errors.push(...validateEventFields(contractEvent, implEvent));
+    }
     return errors.length === 0 ? ok() : fail(errors);
 }
 /**
@@ -212,11 +252,13 @@ function validateImmutability(existing, incoming) {
         tables: existing.tables,
         tools: existing.tools,
         observables: existing.observables,
+        events: existing.events ?? [],
     });
     const incomingShape = JSON.stringify({
         tables: incoming.tables,
         tools: incoming.tools,
         observables: incoming.observables,
+        events: incoming.events ?? [],
     });
     if (existingShape !== incomingShape) {
         return fail([

package/dist/data/orm/decorators.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Return whether a table method was explicitly marked for remote invocation by
+ * {@link ProxyClientTableMethodCalls}. Client proxies are recognized through their
+ * marked `__original` implementation as well.
+ */
+export declare function isContractRemoteTableMethod(method: unknown): boolean;
 /**
  * Decorator that marks a table method as server-side only.
  * When used on the client side, these methods will be automatically proxied

package/dist/data/orm/decorators.js

@@ -1,7 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isContractRemoteTableMethod = isContractRemoteTableMethod;
 exports.ProxyClientTableMethodCalls = ProxyClientTableMethodCalls;
 const rpc_types_1 = require("../../rpc-types");
+const contractRemoteTableMethod = Symbol("contractRemoteTableMethod");
+function markContractRemoteTableMethod(method) {
+    Object.defineProperty(method, contractRemoteTableMethod, { value: true });
+}
+/**
+ * Return whether a table method was explicitly marked for remote invocation by
+ * {@link ProxyClientTableMethodCalls}. Client proxies are recognized through their
+ * marked `__original` implementation as well.
+ */
+function isContractRemoteTableMethod(method) {
+    if (typeof method !== "function") {
+        return false;
+    }
+    const candidate = method;
+    return Boolean(candidate[contractRemoteTableMethod] || candidate.__original?.[contractRemoteTableMethod]);
+}
 /**
  * Decorator that marks a table method as server-side only.
  * When used on the client side, these methods will be automatically proxied
@@ -13,6 +30,9 @@ const rpc_types_1 = require("../../rpc-types");
  */
 function ProxyClientTableMethodCalls() {
     return (target, context) => {
+        if (context.kind === "method") {
+            markContractRemoteTableMethod(target);
+        }
         if (context.kind === "method" && rpc_types_1.isClient) {
             const methodName = context.name;
             // WARNING: Using typescript's magical `this` param
@@ -21,6 +41,7 @@ function ProxyClientTableMethodCalls() {
                 return rpc_types_1.rpcServerCalls.tableMethodCall(dataContextId, this.tableName, methodName, ...args);
             };
             proxyFn.__original = target;
+            markContractRemoteTableMethod(proxyFn);
             return proxyFn;
         }
         return target;

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

@@ -24,7 +24,9 @@ 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>;
+/** Returns the context-scoped table containing explicit user trust assignments. */
 export declare function UserTrustLevels(dataContext?: DataContext): import("./orm").Table<{
     userId: string;
     trustLevel: TrustLevel;

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/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>;

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

@@ -4,6 +4,12 @@ exports.getTrustLevelFn = getTrustLevelFn;
 const context_1 = require("../context");
 const data_1 = require("../data");
 const socket_type_1 = require("./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.
+ */
 function getTrustLevelFn(me, serverUrl) {
     return async function getTrustLevel(deviceInfo, _registerNew) {
         const userContext = await (0, context_1.getUserContext)();
@@ -67,12 +73,11 @@ function getTrustLevelFn(me, serverUrl) {
         }
         const effectiveUser = user ?? groupUser;
         if (effectiveUser &&
-            device &&
-            !(deviceInfo.userId === device.userId &&
-                deviceInfo.userId === effectiveUser.userId &&
-                deviceInfo.publicKey === effectiveUser.publicKey &&
-                deviceInfo.publicBoxKey === effectiveUser.publicBoxKey)) {
-            // deviceInfo does not align with local info about user and device, return Untrusted
+            (deviceInfo.userId !== effectiveUser.userId ||
+                deviceInfo.publicKey !== effectiveUser.publicKey ||
+                deviceInfo.publicBoxKey !== effectiveUser.publicBoxKey ||
+                (device ? deviceInfo.userId !== device.userId : false))) {
+            // deviceInfo does not align with local info about the user or device, return Untrusted
             // TODO check if user has changed their public keys
             return socket_type_1.TrustLevel.Untrusted;
         }
@@ -151,7 +156,7 @@ function getTrustLevelFn(me, serverUrl) {
         //     assignedAt: new Date(),
         //   }, { restoreIfDeleted: true });
         // }
-        if (newUser) {
+        if (newUser && user) {
             // TODO: I'm not sure we immediately want to save this user to the my personal db...
             await (0, data_1.Users)(userDataContext).save(user, {
                 restoreIfDeleted: true,

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

@@ -255,7 +255,7 @@ describe("getTrustLevelFn", () => {
             const result = await getTrustLevel(other);
             expect(result).not.toBe(socket_type_1.TrustLevel.Untrusted);
         });
-        it("does NOT return Untrusted when only user exists (no device record yet)", async () => {
+        it("returns Untrusted for a known user's signing-key mismatch on a new device", async () => {
             const me = makeTestIdentity();
             const other = makeTestIdentity();
             const existingUser = {
@@ -268,7 +268,21 @@ describe("getTrustLevelFn", () => {
             setupMocks(null, existingUser);
             const getTrustLevel = (0, get_trust_level_fn_1.getTrustLevelFn)(me);
             const result = await getTrustLevel(other);
-            expect(result).not.toBe(socket_type_1.TrustLevel.Untrusted);
+            expect(result).toBe(socket_type_1.TrustLevel.Untrusted);
+        });
+        it("returns Untrusted for a known user's box-key mismatch on a new device", async () => {
+            const me = makeTestIdentity();
+            const other = makeTestIdentity();
+            const existingUser = {
+                userId: other.userId,
+                publicKey: other.publicKey,
+                publicBoxKey: `different_pbk_${(0, utils_1.newid)()}`,
+                name: "Alice",
+            };
+            setupMocks(null, existingUser);
+            const getTrustLevel = (0, get_trust_level_fn_1.getTrustLevelFn)(me);
+            const result = await getTrustLevel(other);
+            expect(result).toBe(socket_type_1.TrustLevel.Untrusted);
         });
     });
     // ─── Trusted fast path ──────────────────────────────────────────────────────

package/dist/logging/console-logs.table.d.ts

@@ -35,6 +35,7 @@ export declare const consoleLogSchema: z.ZodObject<{
 export type IConsoleLog = z.infer<typeof consoleLogSchema>;
 /** Cutoff within this many ms of `Date.now()` is treated as "clear all" (manual clear). */
 export declare const CLEAR_ALL_CUTOFF_SLACK_MS = 5000;
+declare const metaData: ITableMetaData;
 /**
  * Returns whether a cutoff timestamp should trigger a full-table clear (drop + recreate)
  * rather than a conditional delete. Used when the UI calls `deleteOldLogs(Date.now())`.
@@ -65,3 +66,5 @@ export declare class ConsoleLogsTable extends Table<IConsoleLog> {
  * Returns the user's personal {@link ConsoleLogsTable} (logs are not synced across devices).
  */
 export declare function ConsoleLogs(): Promise<ConsoleLogsTable>;
+/** Table metadata for the {@link ConsoleLogsTable} (name, primary key, fields). */
+export { metaData as consoleLogsMetaData };

package/dist/logging/console-logs.table.js

@@ -34,7 +34,7 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
     done = true;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConsoleLogsTable = exports.CLEAR_ALL_CUTOFF_SLACK_MS = exports.consoleLogSchema = void 0;
+exports.consoleLogsMetaData = exports.ConsoleLogsTable = exports.CLEAR_ALL_CUTOFF_SLACK_MS = exports.consoleLogSchema = void 0;
 exports.isClearAllCutoff = isClearAllCutoff;
 exports.ConsoleLogs = ConsoleLogs;
 const zod_1 = require("zod");
@@ -73,6 +73,7 @@ const metaData = {
         { fields: ["processInstanceId"] },
     ],
 };
+exports.consoleLogsMetaData = metaData;
 /**
  * Returns whether a cutoff timestamp should trigger a full-table clear (drop + recreate)
  * rather than a conditional delete. Used when the UI calls `deleteOldLogs(Date.now())`.

package/dist/system-ids.d.ts

@@ -7,3 +7,14 @@ export declare const runWorkflowToolId = "000peers0tool0runworkflow";
 export declare const peersCorePackageId = "00mh0wlipjixk2gqmurbwee0o";
 export declare const peersCorePackageRepoUrl = "https://github.com/peers-app/peers-core";
 export declare const peersCorePublishPublicKey = "S7cQqnvVz-FVDO6Lk5zC7epSvcP_-NyBVZz9gdcj73c";
+/**
+ * Stable id of the peers **system** itself, used as the `providerPackageId` for
+ * built-in system contracts (contracts the platform provides rather than a package).
+ */
+export declare const peersSystemPackageId = "000peers0system0000000001";
+/**
+ * Contract id for the built-in **System Logs** contract (read/write the local device's
+ * console logs). This is the first minimal system contract and the proof-of-concept for
+ * contract-consumer-based remote RPC. See `contracts/system/logs-contract.ts`.
+ */
+export declare const logsContractId = "000peers0logs000000000001";

package/dist/system-ids.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.peersCorePublishPublicKey = exports.peersCorePackageRepoUrl = exports.peersCorePackageId = exports.runWorkflowToolId = exports.defaultSendMessageToolId = exports.defaultAssistantRunnerToolId = exports.openCodeAssistantId = exports.defaultAssistantId = exports.peersRootUserId = void 0;
+exports.logsContractId = exports.peersSystemPackageId = exports.peersCorePublishPublicKey = exports.peersCorePackageRepoUrl = exports.peersCorePackageId = exports.runWorkflowToolId = exports.defaultSendMessageToolId = exports.defaultAssistantRunnerToolId = exports.openCodeAssistantId = exports.defaultAssistantId = exports.peersRootUserId = void 0;
 exports.peersRootUserId = "000peers0user000000000001";
 exports.defaultAssistantId = "000peers0bot00000000shell";
 // export const defaultAssistantId = '000peers0bot000000000bot1';
@@ -11,3 +11,14 @@ exports.runWorkflowToolId = "000peers0tool0runworkflow";
 exports.peersCorePackageId = "00mh0wlipjixk2gqmurbwee0o";
 exports.peersCorePackageRepoUrl = "https://github.com/peers-app/peers-core";
 exports.peersCorePublishPublicKey = "S7cQqnvVz-FVDO6Lk5zC7epSvcP_-NyBVZz9gdcj73c";
+/**
+ * Stable id of the peers **system** itself, used as the `providerPackageId` for
+ * built-in system contracts (contracts the platform provides rather than a package).
+ */
+exports.peersSystemPackageId = "000peers0system0000000001";
+/**
+ * Contract id for the built-in **System Logs** contract (read/write the local device's
+ * console logs). This is the first minimal system contract and the proof-of-concept for
+ * contract-consumer-based remote RPC. See `contracts/system/logs-contract.ts`.
+ */
+exports.logsContractId = "000peers0logs000000000001";

package/package.json

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