@peers-app/peers-sdk 0.19.13 → 0.20.0

package/dist/contracts/contract-resolvers.d.ts

@@ -0,0 +1,66 @@
+import type { DataContext } from "../context/data-context";
+import type { UserContext } from "../context/user-context";
+import type { IDeviceInfo } from "../data/devices";
+import { type IContractProviderRouter } from "./contract-provider-router";
+import { type IContractCall, type IContractResolution } from "./contract-proxy";
+import type { IContractTransport } from "./contract-transport";
+/**
+ * Produces the live {@link IContractResolution} for a contract, scoped to a data context.
+ * System contracts register a resolver on import so the provider side can map a contract
+ * call to real tables / tools / observables at execution time.
+ */
+export type ContractResolver = (ctx: {
+    dataContext: DataContext;
+}) => IContractResolution | Promise<IContractResolution>;
+/** Connection-authenticated identity fields used to authorize remote contract calls. */
+export type ContractRemoteIdentity = Pick<IDeviceInfo, "deviceId" | "userId" | "publicKey" | "publicBoxKey">;
+/**
+ * Register the resolver that provides the live implementation for a contract version.
+ * Later registrations for the same contract+version replace earlier ones (matching the
+ * registry's "latest provider wins for dev contracts" behavior).
+ */
+export declare function registerContractResolver(contractId: string, version: number, resolver: ContractResolver): void;
+/** Look up the resolver for a contract version, if one is registered. */
+export declare function getContractResolver(contractId: string, version: number): ContractResolver | undefined;
+/**
+ * Check whether a connection-authenticated remote identity has full contract authority.
+ *
+ * The identity must match a valid self-signed Users record in the provider's personal or
+ * shared-group data, and the provider's personal context must assign the caller exactly
+ * {@link TrustLevel.Self}. Unsigned discovery stubs and key mismatches fail closed.
+ */
+export declare function isSelfTrustedContractCaller(userContext: UserContext, remoteIdentity: ContractRemoteIdentity): Promise<boolean>;
+/**
+ * Create the local-object provider router for one verified device connection.
+ *
+ * The router derives caller identity from the connection owner supplied by the host,
+ * authorizes every call before invoking a registered resolver, normalizes omitted data
+ * contexts to the local user's personal context, and caches stateful endpoints per
+ * contract/version/data-context route. The caller must match a valid signed Users record
+ * and have exact Self trust in the provider's personal context. Explicit data-context ids
+ * retain their existing behavior after authorization.
+ *
+ * @param transport  Contract transport backed by one verified connection.
+ * @param opts.userContext  Local user context that owns provider data.
+ * @param opts.remoteIdentity  Identity derived from the verified remote connection.
+ */
+export declare function createUserContextContractProviderRouter(transport: IContractTransport, opts: {
+    userContext: UserContext;
+    remoteIdentity: ContractRemoteIdentity;
+}): IContractProviderRouter;
+/**
+ * Provider-side request/response glue: apply the signed-identity Self-trust host gate,
+ * resolve the contract for the authorized data context, build a stateless provider, and
+ * execute the call.
+ *
+ * Used by transports (e.g. the connection `CONTRACT_CALL_RPC` handler) to run an inbound
+ * {@link IContractCall} against local state.
+ *
+ * @param call  The inbound contract call.
+ * @param opts.userContext  The local user context executing the call.
+ * @param opts.remoteIdentity  Identity derived from the verified remote connection.
+ */
+export declare function handleContractCall(call: IContractCall, opts: {
+    userContext: UserContext;
+    remoteIdentity: ContractRemoteIdentity;
+}): Promise<any>;

package/dist/contracts/contract-resolvers.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerContractResolver = registerContractResolver;
+exports.getContractResolver = getContractResolver;
+exports.isSelfTrustedContractCaller = isSelfTrustedContractCaller;
+exports.createUserContextContractProviderRouter = createUserContextContractProviderRouter;
+exports.handleContractCall = handleContractCall;
+const user_permissions_1 = require("../data/user-permissions");
+const user_trust_levels_1 = require("../data/user-trust-levels");
+const users_1 = require("../data/users");
+const socket_type_1 = require("../device/socket.type");
+const contract_provider_router_1 = require("./contract-provider-router");
+const contract_proxy_1 = require("./contract-proxy");
+const types_1 = require("./types");
+const resolvers = new Map();
+/**
+ * Register the resolver that provides the live implementation for a contract version.
+ * Later registrations for the same contract+version replace earlier ones (matching the
+ * registry's "latest provider wins for dev contracts" behavior).
+ */
+function registerContractResolver(contractId, version, resolver) {
+    resolvers.set((0, types_1.contractKey)(contractId, version), resolver);
+}
+/** Look up the resolver for a contract version, if one is registered. */
+function getContractResolver(contractId, version) {
+    return resolvers.get((0, types_1.contractKey)(contractId, version));
+}
+/**
+ * Check whether a connection-authenticated remote identity has full contract authority.
+ *
+ * The identity must match a valid self-signed Users record in the provider's personal or
+ * shared-group data, and the provider's personal context must assign the caller exactly
+ * {@link TrustLevel.Self}. Unsigned discovery stubs and key mismatches fail closed.
+ */
+async function isSelfTrustedContractCaller(userContext, remoteIdentity) {
+    const identityContexts = [userContext.userDataContext, ...userContext.groupDataContexts.values()];
+    let hasVerifiedIdentity = false;
+    for (const dataContext of identityContexts) {
+        const user = await (0, users_1.Users)(dataContext).get(remoteIdentity.userId);
+        if (!user?.signature ||
+            user.userId !== remoteIdentity.userId ||
+            user.publicKey !== remoteIdentity.publicKey ||
+            user.publicBoxKey !== remoteIdentity.publicBoxKey) {
+            continue;
+        }
+        try {
+            (0, user_permissions_1.verifyUserSignature)(user);
+            hasVerifiedIdentity = true;
+            break;
+        }
+        catch {
+            // A different context may contain the valid signed record.
+        }
+    }
+    if (!hasVerifiedIdentity) {
+        return false;
+    }
+    const trustLevel = remoteIdentity.userId === userContext.userId
+        ? socket_type_1.TrustLevel.Self
+        : ((await (0, user_trust_levels_1.UserTrustLevels)(userContext.userDataContext).get(remoteIdentity.userId))
+            ?.trustLevel ?? socket_type_1.TrustLevel.Unknown);
+    return trustLevel === socket_type_1.TrustLevel.Self;
+}
+async function authorizeUserContextCall(call, userContext, remoteIdentity) {
+    const context = {
+        callerUserId: remoteIdentity.userId,
+        localUserId: userContext.userId,
+    };
+    if (!(await isSelfTrustedContractCaller(userContext, remoteIdentity))) {
+        throw new Error(`Permission denied: ${call.member} '${call.name}'.${call.operation} on contract ${call.contractId}`);
+    }
+    return {
+        dataContextId: call.dataContextId || userContext.userId,
+        context,
+    };
+}
+/**
+ * Create the local-object provider router for one verified device connection.
+ *
+ * The router derives caller identity from the connection owner supplied by the host,
+ * authorizes every call before invoking a registered resolver, normalizes omitted data
+ * contexts to the local user's personal context, and caches stateful endpoints per
+ * contract/version/data-context route. The caller must match a valid signed Users record
+ * and have exact Self trust in the provider's personal context. Explicit data-context ids
+ * retain their existing behavior after authorization.
+ *
+ * @param transport  Contract transport backed by one verified connection.
+ * @param opts.userContext  Local user context that owns provider data.
+ * @param opts.remoteIdentity  Identity derived from the verified remote connection.
+ */
+function createUserContextContractProviderRouter(transport, opts) {
+    const { userContext, remoteIdentity } = opts;
+    const context = {
+        callerUserId: remoteIdentity.userId,
+        localUserId: userContext.userId,
+    };
+    return (0, contract_provider_router_1.createContractProviderRouter)(transport, {
+        context,
+        authorizeCall: (call) => authorizeUserContextCall(call, userContext, remoteIdentity),
+        resolveEndpoint: async ({ contractId, version, dataContextId, notify }) => {
+            const resolver = getContractResolver(contractId, version);
+            if (!resolver) {
+                throw new Error(`No contract provider registered for ${contractId} v${version}`);
+            }
+            const dataContext = userContext.getDataContext(dataContextId || userContext.userId);
+            const resolution = await resolver({ dataContext });
+            return (0, contract_proxy_1.createContractProviderEndpoint)(resolution, { notify });
+        },
+    });
+}
+/**
+ * Provider-side request/response glue: apply the signed-identity Self-trust host gate,
+ * resolve the contract for the authorized data context, build a stateless provider, and
+ * execute the call.
+ *
+ * Used by transports (e.g. the connection `CONTRACT_CALL_RPC` handler) to run an inbound
+ * {@link IContractCall} against local state.
+ *
+ * @param call  The inbound contract call.
+ * @param opts.userContext  The local user context executing the call.
+ * @param opts.remoteIdentity  Identity derived from the verified remote connection.
+ */
+async function handleContractCall(call, opts) {
+    const { userContext, remoteIdentity } = opts;
+    const authorization = await authorizeUserContextCall(call, userContext, remoteIdentity);
+    const resolver = getContractResolver(call.contractId, call.version);
+    if (!resolver) {
+        throw new Error(`No contract provider registered for ${call.contractId} v${call.version}`);
+    }
+    const routedCall = {
+        ...call,
+        dataContextId: authorization.dataContextId,
+    };
+    const dataContext = userContext.getDataContext(authorization.dataContextId || userContext.userId);
+    const resolution = await resolver({ dataContext });
+    const provider = (0, contract_proxy_1.createContractProvider)(resolution);
+    return provider(routedCall, authorization.context);
+}

package/dist/contracts/contract-transport.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Transport-agnostic bidirectional channel that every contract proxy sits on.
+ *
+ * The transport is a dumb, symmetric duplex: `emit(channel, ...args)` sends on a
+ * named channel and resolves with the peer handler's return value (the ack), and
+ * `on(channel, handler)` registers a handler whose resolved value becomes that ack.
+ * All contract-specific routing (which contract, which member, subscriptions, …)
+ * lives *above* this layer in the payload; the transport itself is unaware of it.
+ *
+ * This is deliberately the common denominator of the primitives we already have:
+ * a device {@link IDuplexEmitter} ({@link Connection}), a socket.io `Socket`, and the
+ * `ISocket` abstraction all expose `emit(name, ...) -> Promise<ack>` + `on(name, handler)`
+ * + listener registration. Adapters below wrap each of those (plus an in-process pair for tests) into
+ * the same {@link IContractTransport} shape so proxies work unchanged whether the provider
+ * runs in the same process, another iframe, the UI↔server socket, or a remote device.
+ */
+/**
+ * A minimal, symmetric, bidirectional channel for contract traffic.
+ *
+ * Both `emit` and `on` are available on each end, so provider→consumer pushes use the
+ * exact same code path as consumer→provider requests (the pusher just ignores the
+ * returned promise).
+ */
+export interface IContractTransport {
+    /**
+     * Send `args` on the named `channel`; resolves with the peer handler's returned
+     * value (the ack), or rejects if the peer handler throws / rejects.
+     */
+    emit(channel: string, ...args: any[]): Promise<any>;
+    /**
+     * Register a `handler` for the named `channel`. The handler's resolved value is
+     * returned to the emitter as the ack. Returns an unsubscribe function that removes
+     * this handler.
+     */
+    on(channel: string, handler: (...args: any[]) => any | Promise<any>): () => void;
+}
+/**
+ * The structural shape of a duplex RPC emitter (notably a device {@link Connection})
+ * that {@link connectionContractTransport} wraps.
+ *
+ * Declared structurally so `peers-sdk`'s contract layer does not import `Connection`
+ * (avoiding an import cycle) yet a `Connection` — and anything else exposing the same
+ * `emit`/`on` surface — satisfies it.
+ */
+export interface IDuplexEmitter {
+    /** Send an RPC and resolve with the remote handler's result. */
+    emit(eventName: string, ...args: any[]): Promise<any>;
+    /** Register a handler invoked with the emitter's positional args. */
+    on(eventName: string, handler: (...args: any[]) => any): void;
+}
+/**
+ * Fixed channel for consumer→provider request/response traffic (tool runs, table
+ * methods, observable get/set, and subscribe/unsubscribe). Value matches
+ * the legacy `CONTRACT_CALL_RPC` event name so existing provider registrations keep
+ * working unchanged.
+ */
+export declare const CONTRACT_REQUEST_CHANNEL = "contractCall";
+/**
+ * Fixed channel for provider→consumer event, table `dataChanged`, and observable
+ * notifications. Subscription ids in each payload let many consumers share one
+ * underlying connection.
+ */
+export declare const CONTRACT_NOTIFY_CHANNEL = "contractNotify";
+/**
+ * Wrap a duplex RPC emitter (e.g. a device {@link Connection}) as an
+ * {@link IContractTransport}. `emit` delegates directly. `on` uses one adapter-owned
+ * dispatcher per emitter/channel and returns an unsubscribe that removes only the caller's
+ * handler from that dispatcher; it never uses a coarse `removeAllListeners`.
+ *
+ * Multiple notify listeners may share one connection and dispose independently. The request
+ * channel intentionally accepts one handler only: a connection-wide provider router owns
+ * multiplexing contracts and data contexts. Stacking fixed-resolution provider sessions on
+ * one request channel is unsupported.
+ *
+ * ```ts
+ * const logs = createContractConsumer(logsContractDefinition, connectionContractTransport(connection));
+ * await logs.tables.ConsoleLogs.list({ level: "error" }, { pageSize: 20 });
+ * ```
+ *
+ * @param emitter  The underlying duplex emitter (Connection-like) to delegate to.
+ */
+export declare function connectionContractTransport(emitter: IDuplexEmitter): IContractTransport;
+/**
+ * Create a cross-wired pair of {@link IContractTransport}s that talk to each other in the
+ * same process. Whatever one end `emit`s on a channel is delivered to the other end's
+ * handler for that channel; the handler's resolved value is returned to the emitter as
+ * the ack, and a thrown/rejected handler rejects the emit. Both ends are fully symmetric,
+ * so either side can act as consumer, provider, or both.
+ *
+ * Intended for tests and same-process contract wiring (no real network transport).
+ *
+ * @returns `[a, b]` — two transports wired to each other.
+ */
+export declare function inProcessTransportPair(): [IContractTransport, IContractTransport];

package/dist/contracts/contract-transport.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * Transport-agnostic bidirectional channel that every contract proxy sits on.
+ *
+ * The transport is a dumb, symmetric duplex: `emit(channel, ...args)` sends on a
+ * named channel and resolves with the peer handler's return value (the ack), and
+ * `on(channel, handler)` registers a handler whose resolved value becomes that ack.
+ * All contract-specific routing (which contract, which member, subscriptions, …)
+ * lives *above* this layer in the payload; the transport itself is unaware of it.
+ *
+ * This is deliberately the common denominator of the primitives we already have:
+ * a device {@link IDuplexEmitter} ({@link Connection}), a socket.io `Socket`, and the
+ * `ISocket` abstraction all expose `emit(name, ...) -> Promise<ack>` + `on(name, handler)`
+ * + listener registration. Adapters below wrap each of those (plus an in-process pair for tests) into
+ * the same {@link IContractTransport} shape so proxies work unchanged whether the provider
+ * runs in the same process, another iframe, the UI↔server socket, or a remote device.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTRACT_NOTIFY_CHANNEL = exports.CONTRACT_REQUEST_CHANNEL = void 0;
+exports.connectionContractTransport = connectionContractTransport;
+exports.inProcessTransportPair = inProcessTransportPair;
+/**
+ * Fixed channel for consumer→provider request/response traffic (tool runs, table
+ * methods, observable get/set, and subscribe/unsubscribe). Value matches
+ * the legacy `CONTRACT_CALL_RPC` event name so existing provider registrations keep
+ * working unchanged.
+ */
+exports.CONTRACT_REQUEST_CHANNEL = "contractCall";
+/**
+ * Fixed channel for provider→consumer event, table `dataChanged`, and observable
+ * notifications. Subscription ids in each payload let many consumers share one
+ * underlying connection.
+ */
+exports.CONTRACT_NOTIFY_CHANNEL = "contractNotify";
+const connectionDispatcherStates = new WeakMap();
+/**
+ * Wrap a duplex RPC emitter (e.g. a device {@link Connection}) as an
+ * {@link IContractTransport}. `emit` delegates directly. `on` uses one adapter-owned
+ * dispatcher per emitter/channel and returns an unsubscribe that removes only the caller's
+ * handler from that dispatcher; it never uses a coarse `removeAllListeners`.
+ *
+ * Multiple notify listeners may share one connection and dispose independently. The request
+ * channel intentionally accepts one handler only: a connection-wide provider router owns
+ * multiplexing contracts and data contexts. Stacking fixed-resolution provider sessions on
+ * one request channel is unsupported.
+ *
+ * ```ts
+ * const logs = createContractConsumer(logsContractDefinition, connectionContractTransport(connection));
+ * await logs.tables.ConsoleLogs.list({ level: "error" }, { pageSize: 20 });
+ * ```
+ *
+ * @param emitter  The underlying duplex emitter (Connection-like) to delegate to.
+ */
+function connectionContractTransport(emitter) {
+    return {
+        emit: (channel, ...args) => emitter.emit(channel, ...args),
+        on: (channel, handler) => {
+            let channelStates = connectionDispatcherStates.get(emitter);
+            if (!channelStates) {
+                channelStates = new Map();
+                connectionDispatcherStates.set(emitter, channelStates);
+            }
+            let state = channelStates.get(channel);
+            if (!state) {
+                const handlers = new Set();
+                const dispatcher = async (...args) => {
+                    const results = await Promise.all([...handlers].map((registered) => {
+                        try {
+                            return Promise.resolve(registered(...args));
+                        }
+                        catch (error) {
+                            return Promise.reject(error);
+                        }
+                    }));
+                    return channel === exports.CONTRACT_REQUEST_CHANNEL ? results[0] : undefined;
+                };
+                state = { handlers, dispatcher };
+                channelStates.set(channel, state);
+                emitter.on(channel, dispatcher);
+            }
+            if (channel === exports.CONTRACT_REQUEST_CHANNEL && state.handlers.size > 0) {
+                throw new Error("Contract request channel already has a handler; use one connection-wide provider router");
+            }
+            state.handlers.add(handler);
+            let active = true;
+            return () => {
+                if (!active) {
+                    return;
+                }
+                active = false;
+                state?.handlers.delete(handler);
+            };
+        },
+    };
+}
+/**
+ * Build one end of an in-process transport pair. `on` registers into `localHandlers`;
+ * `emit` invokes the peer's handlers concurrently and awaits them. A single handler's
+ * result is returned as its ack; multi-listener notification channels resolve `undefined`.
+ * The request channel enforces a single handler so tests cannot accidentally hide missing
+ * provider routing behind last-handler-wins behavior.
+ */
+function makeInProcessTransport(localHandlers, remoteHandlers) {
+    return {
+        emit: async (channel, ...args) => {
+            const handlers = remoteHandlers.get(channel);
+            if (!handlers || handlers.size === 0) {
+                return undefined;
+            }
+            const results = await Promise.all([...handlers].map((handler) => {
+                try {
+                    return Promise.resolve(handler(...args));
+                }
+                catch (error) {
+                    return Promise.reject(error);
+                }
+            }));
+            return results.length === 1 ? results[0] : undefined;
+        },
+        on: (channel, handler) => {
+            let set = localHandlers.get(channel);
+            if (!set) {
+                set = new Set();
+                localHandlers.set(channel, set);
+            }
+            if (channel === exports.CONTRACT_REQUEST_CHANNEL && set.size > 0) {
+                throw new Error("Contract request channel already has a handler; use one provider router");
+            }
+            set.add(handler);
+            let active = true;
+            return () => {
+                if (!active) {
+                    return;
+                }
+                active = false;
+                set?.delete(handler);
+            };
+        },
+    };
+}
+/**
+ * Create a cross-wired pair of {@link IContractTransport}s that talk to each other in the
+ * same process. Whatever one end `emit`s on a channel is delivered to the other end's
+ * handler for that channel; the handler's resolved value is returned to the emitter as
+ * the ack, and a thrown/rejected handler rejects the emit. Both ends are fully symmetric,
+ * so either side can act as consumer, provider, or both.
+ *
+ * Intended for tests and same-process contract wiring (no real network transport).
+ *
+ * @returns `[a, b]` — two transports wired to each other.
+ */
+function inProcessTransportPair() {
+    const handlersA = new Map();
+    const handlersB = new Map();
+    return [
+        makeInProcessTransport(handlersA, handlersB),
+        makeInProcessTransport(handlersB, handlersA),
+    ];
+}

package/dist/contracts/contracts.table.d.ts

@@ -4,7 +4,7 @@ import { Table } from "../data/orm/table";
 import { type ITableMetaData } from "../data/orm/types";
 /**
  * Zod schema for persisted contracts.
- * The `shape` field stores the serialized `{ tables, tools, observables }` JSON
+ * The `shape` field stores the serialized `{ tables, tools, observables, events }` JSON
  * so the full `IContractDefinition` can be rehydrated without re-extracting from
  * live package code.
  */

package/dist/contracts/contracts.table.js

@@ -10,7 +10,7 @@ const types_1 = require("../data/orm/types");
 const zod_types_1 = require("../types/zod-types");
 /**
  * Zod schema for persisted contracts.
- * The `shape` field stores the serialized `{ tables, tools, observables }` JSON
+ * The `shape` field stores the serialized `{ tables, tools, observables, events }` JSON
  * so the full `IContractDefinition` can be rehydrated without re-extracting from
  * live package code.
  */
@@ -20,7 +20,7 @@ const schema = zod_1.z.object({
     devTag: zod_1.z.string().optional().describe("'dev' if the contract shape is still mutable"),
     name: zod_1.z.string().describe("Human-readable contract name"),
     description: zod_1.z.string().describe("Contract description"),
-    shape: zod_1.z.string().describe("JSON-serialized { tables, tools, observables }"),
+    shape: zod_1.z.string().describe("JSON-serialized { tables, tools, observables, events }"),
     registeredAt: zod_1.z.string().describe("ISO 8601 timestamp of first registration"),
 });
 exports.contractsSchema = schema;

package/dist/contracts/index.d.ts

@@ -1,9 +1,14 @@
 export { ContractBuilder, definePackage, PackageBuilder } from "./builder";
+export { type ContractCallAuthorizer, type ContractProviderEndpointResolver, createContractProviderRouter, type IAuthorizedContractRoute, type IContractProviderEndpointRequest, type IContractProviderRouter, type IContractProviderRouterOptions, } from "./contract-provider-router";
 export { ContractProviders, ContractProvidersTable, contractProvidersMetaData, contractProvidersSchema, type IContractProviderRecord, } from "./contract-providers.table";
+export { CONTRACT_CALL_RPC, type ContractMemberType, type ContractNotificationSink, type ContractPermissionCheck, createContractConsumer, createContractProvider, createContractProviderEndpoint, createContractProviderSession, type IContractCall, type IContractCallContext, type IContractConsumer, type IContractNotification, type IContractProviderEndpoint, type IContractProviderEndpointOptions, type IContractProviderSession, type IContractProviderSessionOptions, type IContractResolution, sameUserContractPermissionCheck, } from "./contract-proxy";
+export { type ContractRemoteIdentity, type ContractResolver, createUserContextContractProviderRouter, getContractResolver, handleContractCall, isSelfTrustedContractCaller, registerContractResolver, } from "./contract-resolvers";
+export { CONTRACT_NOTIFY_CHANNEL, CONTRACT_REQUEST_CHANNEL, connectionContractTransport, type IContractTransport, type IDuplexEmitter, inProcessTransportPair, } from "./contract-transport";
 export { Contracts, ContractsTable, contractsMetaData, contractsSchema, type IContractRecord, } from "./contracts.table";
 export { extractTableShape, extractToolShape, type IExtractableTableDef, type IExtractableToolInstance, setSchemaToFieldsFn, } from "./extract";
 export { PersistentContractRegistry } from "./persistent-registry";
 export { ContractRegistry } from "./registry";
-export type { IAlsoImplementsDeclaration, IConsumedContract, IContractDefinition, IContractObservable, IContractTable, IContractTool, IPackageDefinitionResult, IResolvedContract, IValidationError, IValidationResult, } from "./types";
+export { getLogsContractDefinition, LOGS_CONTRACT_VERSION, resolveLogsContract, } from "./system/logs-contract";
+export type { IAlsoImplementsDeclaration, IConsumedContract, IContractDefinition, IContractEvent, IContractObservable, IContractTable, IContractTool, IPackageDefinitionResult, IResolvedContract, IValidationError, IValidationResult, } from "./types";
 export { contractKey } from "./types";
 export { validateAlsoImplements, validateImmutability, validateProviderSatisfiesContract, } from "./validate";

package/dist/contracts/index.js

@@ -1,15 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateProviderSatisfiesContract = exports.validateImmutability = exports.validateAlsoImplements = exports.contractKey = exports.ContractRegistry = exports.PersistentContractRegistry = exports.setSchemaToFieldsFn = exports.extractToolShape = exports.extractTableShape = exports.contractsSchema = exports.contractsMetaData = exports.ContractsTable = exports.Contracts = exports.contractProvidersSchema = exports.contractProvidersMetaData = exports.ContractProvidersTable = exports.ContractProviders = exports.PackageBuilder = exports.definePackage = exports.ContractBuilder = void 0;
+exports.validateProviderSatisfiesContract = exports.validateImmutability = exports.validateAlsoImplements = exports.contractKey = exports.resolveLogsContract = exports.LOGS_CONTRACT_VERSION = exports.getLogsContractDefinition = exports.ContractRegistry = exports.PersistentContractRegistry = exports.setSchemaToFieldsFn = exports.extractToolShape = exports.extractTableShape = exports.contractsSchema = exports.contractsMetaData = exports.ContractsTable = exports.Contracts = exports.inProcessTransportPair = exports.connectionContractTransport = exports.CONTRACT_REQUEST_CHANNEL = exports.CONTRACT_NOTIFY_CHANNEL = exports.registerContractResolver = exports.isSelfTrustedContractCaller = exports.handleContractCall = exports.getContractResolver = exports.createUserContextContractProviderRouter = exports.sameUserContractPermissionCheck = exports.createContractProviderSession = exports.createContractProviderEndpoint = exports.createContractProvider = exports.createContractConsumer = exports.CONTRACT_CALL_RPC = exports.contractProvidersSchema = exports.contractProvidersMetaData = exports.ContractProvidersTable = exports.ContractProviders = exports.createContractProviderRouter = exports.PackageBuilder = exports.definePackage = exports.ContractBuilder = void 0;
 var builder_1 = require("./builder");
 Object.defineProperty(exports, "ContractBuilder", { enumerable: true, get: function () { return builder_1.ContractBuilder; } });
 Object.defineProperty(exports, "definePackage", { enumerable: true, get: function () { return builder_1.definePackage; } });
 Object.defineProperty(exports, "PackageBuilder", { enumerable: true, get: function () { return builder_1.PackageBuilder; } });
+var contract_provider_router_1 = require("./contract-provider-router");
+Object.defineProperty(exports, "createContractProviderRouter", { enumerable: true, get: function () { return contract_provider_router_1.createContractProviderRouter; } });
 var contract_providers_table_1 = require("./contract-providers.table");
 Object.defineProperty(exports, "ContractProviders", { enumerable: true, get: function () { return contract_providers_table_1.ContractProviders; } });
 Object.defineProperty(exports, "ContractProvidersTable", { enumerable: true, get: function () { return contract_providers_table_1.ContractProvidersTable; } });
 Object.defineProperty(exports, "contractProvidersMetaData", { enumerable: true, get: function () { return contract_providers_table_1.contractProvidersMetaData; } });
 Object.defineProperty(exports, "contractProvidersSchema", { enumerable: true, get: function () { return contract_providers_table_1.contractProvidersSchema; } });
+var contract_proxy_1 = require("./contract-proxy");
+Object.defineProperty(exports, "CONTRACT_CALL_RPC", { enumerable: true, get: function () { return contract_proxy_1.CONTRACT_CALL_RPC; } });
+Object.defineProperty(exports, "createContractConsumer", { enumerable: true, get: function () { return contract_proxy_1.createContractConsumer; } });
+Object.defineProperty(exports, "createContractProvider", { enumerable: true, get: function () { return contract_proxy_1.createContractProvider; } });
+Object.defineProperty(exports, "createContractProviderEndpoint", { enumerable: true, get: function () { return contract_proxy_1.createContractProviderEndpoint; } });
+Object.defineProperty(exports, "createContractProviderSession", { enumerable: true, get: function () { return contract_proxy_1.createContractProviderSession; } });
+Object.defineProperty(exports, "sameUserContractPermissionCheck", { enumerable: true, get: function () { return contract_proxy_1.sameUserContractPermissionCheck; } });
+var contract_resolvers_1 = require("./contract-resolvers");
+Object.defineProperty(exports, "createUserContextContractProviderRouter", { enumerable: true, get: function () { return contract_resolvers_1.createUserContextContractProviderRouter; } });
+Object.defineProperty(exports, "getContractResolver", { enumerable: true, get: function () { return contract_resolvers_1.getContractResolver; } });
+Object.defineProperty(exports, "handleContractCall", { enumerable: true, get: function () { return contract_resolvers_1.handleContractCall; } });
+Object.defineProperty(exports, "isSelfTrustedContractCaller", { enumerable: true, get: function () { return contract_resolvers_1.isSelfTrustedContractCaller; } });
+Object.defineProperty(exports, "registerContractResolver", { enumerable: true, get: function () { return contract_resolvers_1.registerContractResolver; } });
+var contract_transport_1 = require("./contract-transport");
+Object.defineProperty(exports, "CONTRACT_NOTIFY_CHANNEL", { enumerable: true, get: function () { return contract_transport_1.CONTRACT_NOTIFY_CHANNEL; } });
+Object.defineProperty(exports, "CONTRACT_REQUEST_CHANNEL", { enumerable: true, get: function () { return contract_transport_1.CONTRACT_REQUEST_CHANNEL; } });
+Object.defineProperty(exports, "connectionContractTransport", { enumerable: true, get: function () { return contract_transport_1.connectionContractTransport; } });
+Object.defineProperty(exports, "inProcessTransportPair", { enumerable: true, get: function () { return contract_transport_1.inProcessTransportPair; } });
 var contracts_table_1 = require("./contracts.table");
 Object.defineProperty(exports, "Contracts", { enumerable: true, get: function () { return contracts_table_1.Contracts; } });
 Object.defineProperty(exports, "ContractsTable", { enumerable: true, get: function () { return contracts_table_1.ContractsTable; } });
@@ -23,6 +43,10 @@ var persistent_registry_1 = require("./persistent-registry");
 Object.defineProperty(exports, "PersistentContractRegistry", { enumerable: true, get: function () { return persistent_registry_1.PersistentContractRegistry; } });
 var registry_1 = require("./registry");
 Object.defineProperty(exports, "ContractRegistry", { enumerable: true, get: function () { return registry_1.ContractRegistry; } });
+var logs_contract_1 = require("./system/logs-contract");
+Object.defineProperty(exports, "getLogsContractDefinition", { enumerable: true, get: function () { return logs_contract_1.getLogsContractDefinition; } });
+Object.defineProperty(exports, "LOGS_CONTRACT_VERSION", { enumerable: true, get: function () { return logs_contract_1.LOGS_CONTRACT_VERSION; } });
+Object.defineProperty(exports, "resolveLogsContract", { enumerable: true, get: function () { return logs_contract_1.resolveLogsContract; } });
 var types_1 = require("./types");
 Object.defineProperty(exports, "contractKey", { enumerable: true, get: function () { return types_1.contractKey; } });
 var validate_1 = require("./validate");

package/dist/contracts/persistent-registry.js

@@ -30,6 +30,7 @@ class PersistentContractRegistry {
             tables: definition.tables,
             tools: definition.tools,
             observables: definition.observables,
+            events: definition.events ?? [],
         });
         if (existingContract) {
             await contractsTable.save({
@@ -122,7 +123,7 @@ class PersistentContractRegistry {
     }
     /** Convert a persisted contract record back to an `IContractDefinition`. */
     recordToDefinition(record) {
-        const { tables, tools, observables } = JSON.parse(record.shape);
+        const { tables, tools, observables, events } = JSON.parse(record.shape);
         return {
             contractId: record.contractId,
             version: record.version,
@@ -132,6 +133,7 @@ class PersistentContractRegistry {
             tables,
             tools,
             observables,
+            events: events ?? [],
         };
     }
 }

package/dist/contracts/system/logs-contract.d.ts

@@ -0,0 +1,24 @@
+import type { DataContext } from "../../context/data-context";
+import type { IContractResolution } from "../contract-proxy";
+import type { IContractDefinition } from "../types";
+/** Version of the built-in System Logs contract. */
+export declare const LOGS_CONTRACT_VERSION = 1;
+/**
+ * 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).
+ */
+export declare function getLogsContractDefinition(): IContractDefinition;
+/**
+ * Resolve the logs contract to its live implementation for a data context: the
+ * `ConsoleLogs` table backing that context.
+ */
+export declare function resolveLogsContract(ctx: {
+    dataContext: DataContext;
+}): IContractResolution;