@decentrl/sdk 0.0.1

package/dist/identity-manager.js

@@ -0,0 +1,62 @@
+import { DecentrlSDKError } from './errors.js';
+import { deserializeKeys, serializeIdentity } from './identity-serialization.js';
+export class IdentityManager {
+    identity = null;
+    listeners = new Set();
+    transport = null;
+    setTransport(transport) {
+        this.transport = transport;
+    }
+    getIdentity() {
+        return this.identity;
+    }
+    requireIdentity() {
+        if (!this.identity) {
+            throw new DecentrlSDKError('Identity not initialized. Call create() or load() first.', 'IDENTITY_NOT_INITIALIZED');
+        }
+        return this.identity;
+    }
+    async create(options) {
+        if (this.identity) {
+            throw new DecentrlSDKError('Identity already exists. Call reset() first to create a new one.', 'IDENTITY_ALREADY_EXISTS');
+        }
+        if (!this.transport) {
+            throw new DecentrlSDKError('Transport not set', 'NO_TRANSPORT');
+        }
+        const serialized = await this.transport.createIdentity(options);
+        return this.load(serialized);
+    }
+    load(serialized) {
+        this.identity = {
+            did: serialized.did,
+            alias: serialized.alias,
+            mediatorDid: serialized.mediatorDid,
+            mediatorEndpoint: serialized.mediatorEndpoint,
+            keys: deserializeKeys(serialized),
+            mediatorContract: serialized.mediatorContract,
+        };
+        // Sync with transport
+        this.transport?.loadIdentity?.(serialized);
+        this.notify();
+        return this.identity;
+    }
+    serialize() {
+        const identity = this.requireIdentity();
+        return serializeIdentity(identity);
+    }
+    reset() {
+        this.identity = null;
+        this.notify();
+    }
+    onChange(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    notify() {
+        for (const listener of this.listeners) {
+            listener(this.identity);
+        }
+    }
+}

package/dist/identity-serialization.d.ts

@@ -0,0 +1,5 @@
+import { type DecentrlIdentityKeys } from '@decentrl/crypto';
+import type { IdentityState, SerializedIdentity } from './types.js';
+export declare const serializeIdentity: (identity: IdentityState) => SerializedIdentity;
+export declare const deserializeKeys: (serialized: SerializedIdentity) => DecentrlIdentityKeys;
+//# sourceMappingURL=identity-serialization.d.ts.map

package/dist/identity-serialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity-serialization.d.ts","sourceRoot":"","sources":["../src/identity-serialization.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,KAAK,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACzF,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEpE,eAAO,MAAM,iBAAiB,GAAI,UAAU,aAAa,KAAG,kBAiB1D,CAAC;AAEH,eAAO,MAAM,eAAe,GAAI,YAAY,kBAAkB,KAAG,oBAU/D,CAAC"}

package/dist/identity-serialization.js

@@ -0,0 +1,30 @@
+import { base64Decode, base64Encode } from '@decentrl/crypto';
+export const serializeIdentity = (identity) => ({
+    did: identity.did,
+    alias: identity.alias,
+    mediatorDid: identity.mediatorDid,
+    mediatorEndpoint: identity.mediatorEndpoint,
+    keys: {
+        signing: {
+            privateKey: base64Encode(identity.keys.signing.privateKey),
+            publicKey: base64Encode(identity.keys.signing.publicKey),
+        },
+        encryption: {
+            privateKey: base64Encode(identity.keys.encryption.privateKey),
+            publicKey: base64Encode(identity.keys.encryption.publicKey),
+        },
+        storageKey: base64Encode(identity.keys.storageKey),
+    },
+    mediatorContract: identity.mediatorContract,
+});
+export const deserializeKeys = (serialized) => ({
+    signing: {
+        privateKey: base64Decode(serialized.keys.signing.privateKey),
+        publicKey: base64Decode(serialized.keys.signing.publicKey),
+    },
+    encryption: {
+        privateKey: base64Decode(serialized.keys.encryption.privateKey),
+        publicKey: base64Decode(serialized.keys.encryption.publicKey),
+    },
+    storageKey: base64Decode(serialized.keys.storageKey),
+});

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export { DecentrlClient } from './client.js';
+export { ContractManager } from './contract-manager.js';
+export type { DecentrlApp } from './define-app.js';
+export { defineDecentrlApp } from './define-app.js';
+export type { DirectTransportOptions, HttpPost } from './direct-transport.js';
+export { DirectTransport } from './direct-transport.js';
+export type { DecentrlSDKErrorCode } from './errors.js';
+export { DecentrlSDKError } from './errors.js';
+export { EventProcessor } from './event-processor.js';
+export { IdentityManager } from './identity-manager.js';
+export type { PersistOptions } from './persistence.js';
+export { StateStore } from './state-store.js';
+export { SyncManager } from './sync-manager.js';
+export type { DecentrlTransport } from './transport.js';
+export type { ArchivedContract, DecentrlAppConfig, DecentrlClientConfig, EventDefinition, EventDefinitions, EventEnvelope, EventMeta, IdentityState, InferState, PaginatedResult, PaginationMeta, PendingContractRequest, PublishOptions, QueryOptions, SerializedIdentity, SerializedKeyPair, StateDefinitions, StateListener, StateSliceDefinition, StoredSignedContract, SyncOptions, } from './types.js';
+export type { ConnectionStatus, WebSocketTransportCallbacks, WebSocketTransportIdentity, } from './websocket-transport.js';
+export { deriveWsUrl, WebSocketTransport } from './websocket-transport.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,YAAY,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,YAAY,EAAE,sBAAsB,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAC9E,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,YAAY,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,YAAY,EACX,gBAAgB,EAChB,iBAAiB,EACjB,oBAAoB,EACpB,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,SAAS,EACT,aAAa,EACb,UAAU,EACV,eAAe,EACf,cAAc,EACd,sBAAsB,EACtB,cAAc,EACd,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,EACb,oBAAoB,EACpB,oBAAoB,EACpB,WAAW,GACX,MAAM,YAAY,CAAC;AACpB,YAAY,EACX,gBAAgB,EAChB,2BAA2B,EAC3B,0BAA0B,GAC1B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/index.js

@@ -0,0 +1,10 @@
+export { DecentrlClient } from './client.js';
+export { ContractManager } from './contract-manager.js';
+export { defineDecentrlApp } from './define-app.js';
+export { DirectTransport } from './direct-transport.js';
+export { DecentrlSDKError } from './errors.js';
+export { EventProcessor } from './event-processor.js';
+export { IdentityManager } from './identity-manager.js';
+export { StateStore } from './state-store.js';
+export { SyncManager } from './sync-manager.js';
+export { deriveWsUrl, WebSocketTransport } from './websocket-transport.js';

package/dist/persistence.d.ts

@@ -0,0 +1,11 @@
+import type { SerializedIdentity } from './types.js';
+export interface PersistOptions {
+    /** localStorage key prefix. Identity stored at `${key}:identity`, state at `${key}:state` */
+    key: string;
+}
+export declare function loadPersistedIdentity(opts: PersistOptions): SerializedIdentity | null;
+export declare function persistIdentity(opts: PersistOptions, identity: SerializedIdentity | null): void;
+export declare function loadPersistedState<T extends Record<string, unknown>>(opts: PersistOptions): T | null;
+export declare function persistState(opts: PersistOptions, state: Record<string, unknown>): void;
+export declare function clearPersisted(opts: PersistOptions): void;
+//# sourceMappingURL=persistence.d.ts.map

package/dist/persistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.d.ts","sourceRoot":"","sources":["../src/persistence.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD,MAAM,WAAW,cAAc;IAC9B,6FAA6F;IAC7F,GAAG,EAAE,MAAM,CAAC;CACZ;AAUD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,cAAc,GAAG,kBAAkB,GAAG,IAAI,CAkBrF;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,EAAE,kBAAkB,GAAG,IAAI,GAAG,IAAI,CAgB/F;AAED,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnE,IAAI,EAAE,cAAc,GAClB,CAAC,GAAG,IAAI,CAkBV;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAYvF;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAazD"}

package/dist/persistence.js

@@ -0,0 +1,82 @@
+function getStorage() {
+    try {
+        return typeof localStorage !== 'undefined' ? localStorage : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function loadPersistedIdentity(opts) {
+    const storage = getStorage();
+    if (!storage) {
+        return null;
+    }
+    try {
+        const raw = storage.getItem(`${opts.key}:identity`);
+        if (!raw) {
+            return null;
+        }
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function persistIdentity(opts, identity) {
+    const storage = getStorage();
+    if (!storage) {
+        return;
+    }
+    try {
+        if (identity) {
+            storage.setItem(`${opts.key}:identity`, JSON.stringify(identity));
+        }
+        else {
+            storage.removeItem(`${opts.key}:identity`);
+        }
+    }
+    catch {
+        // Silently fail (quota exceeded, etc.)
+    }
+}
+export function loadPersistedState(opts) {
+    const storage = getStorage();
+    if (!storage) {
+        return null;
+    }
+    try {
+        const raw = storage.getItem(`${opts.key}:state`);
+        if (!raw) {
+            return null;
+        }
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function persistState(opts, state) {
+    const storage = getStorage();
+    if (!storage) {
+        return;
+    }
+    try {
+        storage.setItem(`${opts.key}:state`, JSON.stringify(state));
+    }
+    catch {
+        // Silently fail
+    }
+}
+export function clearPersisted(opts) {
+    const storage = getStorage();
+    if (!storage) {
+        return;
+    }
+    try {
+        storage.removeItem(`${opts.key}:identity`);
+        storage.removeItem(`${opts.key}:state`);
+    }
+    catch {
+        // Silently fail
+    }
+}

package/dist/state-store.d.ts

@@ -0,0 +1,12 @@
+import type { StateListener } from './types.js';
+export declare class StateStore<TState extends Record<string, unknown>> {
+    private state;
+    private listeners;
+    constructor(initialState: TState);
+    getState: () => TState;
+    setSlice<K extends keyof TState>(key: K, value: TState[K]): void;
+    subscribe: (listener: StateListener<TState>) => (() => void);
+    reset(initialState: TState): void;
+    private notify;
+}
+//# sourceMappingURL=state-store.d.ts.map

package/dist/state-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-store.d.ts","sourceRoot":"","sources":["../src/state-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,qBAAa,UAAU,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC7D,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,SAAS,CAAoC;gBAEzC,YAAY,EAAE,MAAM;IAIhC,QAAQ,QAAO,MAAM,CAEnB;IAEF,QAAQ,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI;IAShE,SAAS,GAAI,UAAU,aAAa,CAAC,MAAM,CAAC,KAAG,CAAC,MAAM,IAAI,CAAC,CAMzD;IAEF,KAAK,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAKjC,OAAO,CAAC,MAAM;CAKd"}

package/dist/state-store.js

@@ -0,0 +1,32 @@
+export class StateStore {
+    state;
+    listeners = new Set();
+    constructor(initialState) {
+        this.state = { ...initialState };
+    }
+    getState = () => {
+        return this.state;
+    };
+    setSlice(key, value) {
+        if (this.state[key] === value) {
+            return;
+        }
+        this.state = { ...this.state, [key]: value };
+        this.notify();
+    }
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    };
+    reset(initialState) {
+        this.state = { ...initialState };
+        this.notify();
+    }
+    notify() {
+        for (const listener of this.listeners) {
+            listener(this.state);
+        }
+    }
+}

package/dist/sync-manager.d.ts

@@ -0,0 +1,33 @@
+import type { ContractManager } from './contract-manager.js';
+import type { EventProcessor } from './event-processor.js';
+import type { IdentityManager } from './identity-manager.js';
+import type { DecentrlTransport } from './transport.js';
+import type { EventDefinitions, StateDefinitions, SyncOptions } from './types.js';
+import { type ConnectionStatus } from './websocket-transport.js';
+type StatusListener = (status: ConnectionStatus) => void;
+export declare class SyncManager<TEvents extends EventDefinitions, TState extends StateDefinitions<TEvents>> {
+    private eventProcessor;
+    private contractManager;
+    private identityManager;
+    private transport;
+    private intervalId;
+    private isSyncing;
+    private wsTransport;
+    private connectionStatus;
+    private statusListeners;
+    private unsubscribePush;
+    private unsubscribeContractsPush;
+    private currentOptions;
+    constructor(eventProcessor: EventProcessor<TEvents, TState>, contractManager: ContractManager, identityManager: IdentityManager, transport: DecentrlTransport);
+    start(options?: SyncOptions): void;
+    stop(): void;
+    tick(onError?: (error: unknown) => void): Promise<void>;
+    getConnectionStatus: () => ConnectionStatus;
+    onConnectionStatusChange: (listener: StatusListener) => (() => void);
+    get isRunning(): boolean;
+    private loadStoredEvents;
+    private processUntaggedEvents;
+    private startWebSocket;
+}
+export {};
+//# sourceMappingURL=sync-manager.d.ts.map

package/dist/sync-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-manager.d.ts","sourceRoot":"","sources":["../src/sync-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAiB,gBAAgB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACjG,OAAO,EAAE,KAAK,gBAAgB,EAAmC,MAAM,0BAA0B,CAAC;AAElG,KAAK,cAAc,GAAG,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,CAAC;AAEzD,qBAAa,WAAW,CACvB,OAAO,SAAS,gBAAgB,EAChC,MAAM,SAAS,gBAAgB,CAAC,OAAO,CAAC;IAYvC,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,SAAS;IAblB,OAAO,CAAC,UAAU,CAA+C;IACjE,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,WAAW,CAAmC;IACtD,OAAO,CAAC,gBAAgB,CAAoC;IAC5D,OAAO,CAAC,eAAe,CAA6B;IACpD,OAAO,CAAC,eAAe,CAA6B;IACpD,OAAO,CAAC,wBAAwB,CAA6B;IAC7D,OAAO,CAAC,cAAc,CAAmB;gBAGhC,cAAc,EAAE,cAAc,CAAC,OAAO,EAAE,MAAM,CAAC,EAC/C,eAAe,EAAE,eAAe,EAChC,eAAe,EAAE,eAAe,EAChC,SAAS,EAAE,iBAAiB;IAGrC,KAAK,CAAC,OAAO,GAAE,WAAgB,GAAG,IAAI;IA+DtC,IAAI,IAAI,IAAI;IAsBN,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAyC7D,mBAAmB,QAAO,gBAAgB,CAExC;IAEF,wBAAwB,GAAI,UAAU,cAAc,KAAG,CAAC,MAAM,IAAI,CAAC,CAMjE;IAEF,IAAI,SAAS,IAAI,OAAO,CAEvB;YAEa,gBAAgB;YA6BhB,qBAAqB;IA4CnC,OAAO,CAAC,cAAc;CA+DtB"}

package/dist/sync-manager.js

@@ -0,0 +1,244 @@
+import { deriveWsUrl, WebSocketTransport } from './websocket-transport.js';
+export class SyncManager {
+    eventProcessor;
+    contractManager;
+    identityManager;
+    transport;
+    intervalId = null;
+    isSyncing = false;
+    wsTransport = null;
+    connectionStatus = 'disconnected';
+    statusListeners = new Set();
+    unsubscribePush = null;
+    unsubscribeContractsPush = null;
+    currentOptions = {};
+    constructor(eventProcessor, contractManager, identityManager, transport) {
+        this.eventProcessor = eventProcessor;
+        this.contractManager = contractManager;
+        this.identityManager = identityManager;
+        this.transport = transport;
+    }
+    start(options = {}) {
+        this.stop();
+        this.currentOptions = options;
+        // If transport supports push-based events, subscribe
+        if (this.transport.onEvents) {
+            this.unsubscribePush = this.transport.onEvents((events) => {
+                try {
+                    this.eventProcessor.processBatch(events);
+                }
+                catch (err) {
+                    console.error('[Decentrl] Failed to process pushed events:', err);
+                }
+                // Tag enrichment for non-ephemeral pushed events
+                if (events.some((e) => !e.meta.ephemeral)) {
+                    this.processUntaggedEvents().catch((err) => console.debug('[Decentrl] Failed to process untagged events:', err));
+                }
+            });
+            if (this.transport.onContractsChanged) {
+                this.unsubscribeContractsPush = this.transport.onContractsChanged(() => {
+                    this.contractManager.refresh();
+                });
+            }
+            // Still do an initial sync tick + slower polling for contracts
+            this.tick(options.onError);
+            const intervalMs = options.fallbackIntervalMs ?? 30_000;
+            this.intervalId = setInterval(() => {
+                this.tick(options.onError);
+            }, intervalMs);
+            // Load stored events from mediator to catch up on offline period
+            this.loadStoredEvents().catch((err) => console.debug('[Decentrl] loadStoredEvents() failed:', err));
+            // Process any events that haven't been tagged by the app yet
+            this.processUntaggedEvents().catch((err) => console.debug('[Decentrl] processUntaggedEvents() failed:', err));
+            return;
+        }
+        const intervalMs = options.intervalMs ?? 3000;
+        // Run immediately
+        this.tick(options.onError);
+        this.intervalId = setInterval(() => {
+            this.tick(options.onError);
+        }, intervalMs);
+        // Start WebSocket if available and enabled
+        const useWebSocket = options.websocket !== false;
+        if (useWebSocket && typeof globalThis.WebSocket !== 'undefined') {
+            this.startWebSocket(options);
+        }
+    }
+    stop() {
+        if (this.intervalId !== null) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+        if (this.wsTransport) {
+            this.wsTransport.disconnect();
+            this.wsTransport = null;
+        }
+        if (this.unsubscribePush) {
+            this.unsubscribePush();
+            this.unsubscribePush = null;
+        }
+        if (this.unsubscribeContractsPush) {
+            this.unsubscribeContractsPush();
+            this.unsubscribeContractsPush = null;
+        }
+    }
+    async tick(onError) {
+        if (this.isSyncing) {
+            return;
+        }
+        this.isSyncing = true;
+        try {
+            const processedEvents = await this.transport.processPendingEvents();
+            this.eventProcessor.processBatch(processedEvents);
+            // Enrich any unprocessed events with app-computed tags
+            if (processedEvents.length > 0) {
+                await this.processUntaggedEvents();
+            }
+            // Refresh contracts
+            await this.contractManager.refresh();
+            // Auto-renew expiring contracts
+            const autoRenew = this.currentOptions.autoRenew;
+            if (autoRenew?.enabled) {
+                await this.contractManager.processAutoRenewals(autoRenew.threshold);
+            }
+            // Clean up old superseded contracts
+            try {
+                await this.contractManager.processContractCleanup();
+            }
+            catch (err) {
+                console.error('[Decentrl] Contract cleanup failed:', err);
+            }
+        }
+        catch (error) {
+            if (onError) {
+                onError(error);
+            }
+        }
+        finally {
+            this.isSyncing = false;
+        }
+    }
+    getConnectionStatus = () => {
+        return this.connectionStatus;
+    };
+    onConnectionStatusChange = (listener) => {
+        this.statusListeners.add(listener);
+        return () => {
+            this.statusListeners.delete(listener);
+        };
+    };
+    get isRunning() {
+        return this.intervalId !== null;
+    }
+    async loadStoredEvents() {
+        if (!this.transport.queryEvents) {
+            return;
+        }
+        try {
+            let page = 0;
+            const pageSize = 50;
+            while (true) {
+                const result = await this.transport.queryEvents({
+                    pagination: { page, pageSize },
+                });
+                if (result.data.length > 0) {
+                    this.eventProcessor.processBatch(result.data);
+                }
+                if ((page + 1) * pageSize >= result.pagination.total) {
+                    break;
+                }
+                page++;
+            }
+        }
+        catch (err) {
+            console.debug('[Decentrl] loadStoredEvents() failed:', err);
+        }
+    }
+    async processUntaggedEvents() {
+        if (!this.transport.queryUnprocessedEvents) {
+            return;
+        }
+        if (!this.transport.updateEventTags) {
+            return;
+        }
+        try {
+            let page = 0;
+            const pageSize = 50;
+            while (true) {
+                const result = await this.transport.queryUnprocessedEvents({ page, pageSize });
+                if (result.data.length === 0) {
+                    break;
+                }
+                this.eventProcessor.processBatch(result.data);
+                const tagUpdates = result.data
+                    .filter((e) => !e.meta.ephemeral)
+                    .map((e) => ({
+                    eventId: e._mediatorEventId ?? e.meta.eventId,
+                    tags: this.eventProcessor.computeTagsSafe(e.type, e.data),
+                }));
+                if (tagUpdates.length > 0) {
+                    await this.transport.updateEventTags(tagUpdates);
+                }
+                if ((page + 1) * pageSize >= result.pagination.total) {
+                    break;
+                }
+                page++;
+            }
+        }
+        catch (err) {
+            console.debug('[Decentrl] processUntaggedEvents failed:', err);
+        }
+    }
+    startWebSocket(options) {
+        const identity = this.identityManager.getIdentity();
+        if (!identity) {
+            return;
+        }
+        const wsUrl = deriveWsUrl(identity.mediatorEndpoint);
+        this.wsTransport = new WebSocketTransport(() => {
+            const id = this.identityManager.getIdentity();
+            return id ? { did: id.did, keys: id.keys } : null;
+        }, () => wsUrl, {
+            onPendingEvents: async (events) => {
+                try {
+                    if (this.transport.processPreFetchedPendingEvents) {
+                        const processed = await this.transport.processPreFetchedPendingEvents(events);
+                        this.eventProcessor.processBatch(processed);
+                    }
+                }
+                catch (error) {
+                    options.onError?.(error);
+                }
+            },
+            onContractsUpdated: async () => {
+                try {
+                    await this.contractManager.refresh();
+                }
+                catch (error) {
+                    options.onError?.(error);
+                }
+            },
+            onStatusChange: (status) => {
+                this.connectionStatus = status;
+                // Adjust polling interval based on WS connection
+                if (this.intervalId !== null) {
+                    clearInterval(this.intervalId);
+                    const intervalMs = status === 'connected'
+                        ? (options.fallbackIntervalMs ?? 30_000)
+                        : (options.intervalMs ?? 3000);
+                    this.intervalId = setInterval(() => {
+                        this.tick(options.onError);
+                    }, intervalMs);
+                    // Trigger immediate catch-up tick when WS connects
+                    if (status === 'connected') {
+                        this.tick(options.onError);
+                    }
+                }
+                for (const listener of this.statusListeners) {
+                    listener(status);
+                }
+            },
+        });
+        this.wsTransport.connect();
+    }
+}

package/dist/tag-templates.d.ts

@@ -0,0 +1,2 @@
+export declare function evaluateTagTemplates(templates: string[], data: unknown): string[];
+//# sourceMappingURL=tag-templates.d.ts.map

package/dist/tag-templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag-templates.d.ts","sourceRoot":"","sources":["../src/tag-templates.ts"],"names":[],"mappings":"AAAA,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,OAAO,GAAG,MAAM,EAAE,CAEjF"}

package/dist/tag-templates.js

@@ -0,0 +1,23 @@
+export function evaluateTagTemplates(templates, data) {
+    return templates.map((t) => evaluateTemplate(t, data));
+}
+function evaluateTemplate(template, data) {
+    return template.replace(/\$\{([^}]+)\}/g, (_, path) => {
+        return String(resolveProperty(data, path) ?? '');
+    });
+}
+const BLOCKED_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+function resolveProperty(obj, path) {
+    const parts = path.split(/[.[\]]+/).filter(Boolean);
+    let value = obj;
+    for (const part of parts) {
+        if (BLOCKED_KEYS.has(part)) {
+            return undefined;
+        }
+        if (value == null || typeof value !== 'object') {
+            return undefined;
+        }
+        value = value[part];
+    }
+    return value;
+}

package/dist/test-helpers.d.ts

@@ -0,0 +1,15 @@
+import type { ContractManager } from './contract-manager.js';
+import type { EventProcessor } from './event-processor.js';
+import type { IdentityManager } from './identity-manager.js';
+import type { DecentrlTransport } from './transport.js';
+import type { EventDefinitions, StateDefinitions, StoredSignedContract } from './types.js';
+export declare const makeContract: (overrides: Partial<StoredSignedContract> & {
+    participantDid: string;
+    expiresAt: number;
+    timestamp: number;
+}) => StoredSignedContract;
+export declare const createMockIdentityManager: (overrides?: Partial<Record<keyof IdentityManager, unknown>>) => IdentityManager;
+export declare const createMockTransport: (overrides?: Partial<DecentrlTransport>) => DecentrlTransport;
+export declare const createMockEventProcessor: (overrides?: Partial<Record<string, unknown>>) => EventProcessor<EventDefinitions, StateDefinitions<EventDefinitions>>;
+export declare const createMockContractManager: (overrides?: Partial<Record<string, unknown>>) => ContractManager;
+//# sourceMappingURL=test-helpers.d.ts.map

package/dist/test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../src/test-helpers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAE3F,eAAO,MAAM,YAAY,GACxB,WAAW,OAAO,CAAC,oBAAoB,CAAC,GAAG;IAC1C,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CAClB,KACC,oBAsBD,CAAC;AAEH,eAAO,MAAM,yBAAyB,GACrC,YAAW,OAAO,CAAC,MAAM,CAAC,MAAM,eAAe,EAAE,OAAO,CAAC,CAAM,KAqB9C,eAAe,CAAC;AAElC,eAAO,MAAM,mBAAmB,GAAI,YAAW,OAAO,CAAC,iBAAiB,CAAM,KAW5D,iBAAiB,CAAC;AAEpC,eAAO,MAAM,wBAAwB,GAAI,YAAW,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAM,KAKvE,cAAc,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,gBAAgB,CAAC,CAAC,CAAC;AAEvF,eAAO,MAAM,yBAAyB,GAAI,YAAW,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAM,KAMxE,eAAe,CAAC"}