@gratiaos/pad-core 1.0.0

package/dist/events.js

@@ -0,0 +1,96 @@
+/**
+ * Garden Pads — event helpers & lightweight in-memory bus.
+ *
+ * - Framework-agnostic signal bus (padEvents) for local adapters/tests.
+ * - DOM CustomEvent utilities for cross-frame / cross-app communication.
+ *
+ * CustomEvent names are stable and kebab/colon cased:
+ *   - "pad:open"              — request the host to open a pad by id
+ *   - "pad:close"             — request the host to close a pad (optional id)
+ *   - "pad:bulletin:updated"  — pad announces its bulletin/feed changed
+ */
+/* ──────────────────────────────────────────────────────────────────────────
+ * 1) Lightweight in-memory bus (no DOM required)
+ * -------------------------------------------------------------------------- */
+const listeners = new Set();
+/**
+ * Local, synchronous pub/sub for pads. Useful in tests or headless contexts.
+ * Host shells may bridge this to DOM CustomEvents if needed.
+ */
+export const padEvents = {
+    /** Broadcast a signal to all listeners. */
+    send(msg) {
+        listeners.forEach((l) => {
+            try {
+                l(msg);
+            }
+            catch {
+                // ignore listener errors by design
+            }
+        });
+    },
+    /** Subscribe to signals; returns an unsubscribe function. */
+    on(fn) {
+        listeners.add(fn);
+        return () => {
+            listeners.delete(fn);
+        };
+    },
+    /** Clear all listeners — primarily for tests. */
+    clear() {
+        listeners.clear();
+    },
+};
+/* ──────────────────────────────────────────────────────────────────────────
+ * 2) DOM CustomEvent helpers
+ * -------------------------------------------------------------------------- */
+export const PAD_OPEN_EVENT = 'pad:open';
+export const PAD_CLOSE_EVENT = 'pad:close';
+export const PAD_BULLETIN_UPDATED_EVENT = 'pad:bulletin:updated';
+/** Safe default target for dispatching/observing pad events. */
+function getTarget(target) {
+    // Prefer an explicit target; otherwise window if present; else fallback to a simple EventTarget.
+    if (target)
+        return target;
+    const maybeWindow = typeof globalThis !== 'undefined' && typeof globalThis.window !== 'undefined'
+        ? globalThis.window
+        : undefined;
+    if (maybeWindow)
+        return maybeWindow;
+    // Last resort for SSR/tests without JSDOM:
+    // Creating one per call is OK; callers in SSR typically pass a target anyway.
+    return new EventTarget();
+}
+/** Dispatch a `pad:open` request. */
+export function dispatchPadOpen(detail, target) {
+    getTarget(target).dispatchEvent(new CustomEvent(PAD_OPEN_EVENT, { detail, bubbles: true }));
+}
+/** Dispatch a `pad:close` request. */
+export function dispatchPadClose(detail = {}, target) {
+    getTarget(target).dispatchEvent(new CustomEvent(PAD_CLOSE_EVENT, { detail, bubbles: true }));
+}
+/** Dispatch a `pad:bulletin:updated` announcement. */
+export function dispatchPadBulletinUpdated(detail = {}, target) {
+    getTarget(target).dispatchEvent(new CustomEvent(PAD_BULLETIN_UPDATED_EVENT, { detail, bubbles: true }));
+}
+/** Listen for `pad:open`. */
+export function onPadOpen(handler, target) {
+    const t = getTarget(target);
+    const fn = (ev) => handler(ev.detail, ev);
+    t.addEventListener(PAD_OPEN_EVENT, fn);
+    return () => t.removeEventListener(PAD_OPEN_EVENT, fn);
+}
+/** Listen for `pad:close`. */
+export function onPadClose(handler, target) {
+    const t = getTarget(target);
+    const fn = (ev) => handler(ev.detail, ev);
+    t.addEventListener(PAD_CLOSE_EVENT, fn);
+    return () => t.removeEventListener(PAD_CLOSE_EVENT, fn);
+}
+/** Listen for `pad:bulletin:updated`. */
+export function onPadBulletinUpdated(handler, target) {
+    const t = getTarget(target);
+    const fn = (ev) => handler(ev.detail, ev);
+    t.addEventListener(PAD_BULLETIN_UPDATED_EVENT, fn);
+    return () => t.removeEventListener(PAD_BULLETIN_UPDATED_EVENT, fn);
+}

package/dist/hooks/usePadMood.d.ts

@@ -0,0 +1,15 @@
+import { type PadMood } from '..';
+/**
+ * usePadMood
+ * ----------
+ * Minimal mood state that stays in sync with the global pad event bus.
+ *
+ * • Local state follows PAD.MOOD.SET messages.
+ * • The setter also broadcasts a PAD.MOOD.SET so other listeners can attune.
+ * • Default mood is 'soft' (can be overridden).
+ *
+ * Example:
+ *   const [mood, setMood] = usePadMood();
+ *   // setMood('focused')
+ */
+export declare function usePadMood(defaultMood?: PadMood): readonly [PadMood, (next: PadMood) => void];

package/dist/hooks/usePadMood.js

@@ -0,0 +1,46 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { padEvents } from '..';
+/**
+ * usePadMood
+ * ----------
+ * Minimal mood state that stays in sync with the global pad event bus.
+ *
+ * • Local state follows PAD.MOOD.SET messages.
+ * • The setter also broadcasts a PAD.MOOD.SET so other listeners can attune.
+ * • Default mood is 'soft' (can be overridden).
+ *
+ * Example:
+ *   const [mood, setMood] = usePadMood();
+ *   // setMood('focused')
+ */
+export function usePadMood(defaultMood = 'soft') {
+    const [mood, setMood] = useState(defaultMood);
+    const mounted = useRef(true);
+    // Track mount to avoid setState after unmount
+    useEffect(() => {
+        mounted.current = true;
+        return () => {
+            mounted.current = false;
+        };
+    }, []);
+    // Subscribe to global pad signals
+    useEffect(() => {
+        const off = padEvents.on((msg) => {
+            if (msg.type === 'PAD.MOOD.SET' && mounted.current) {
+                setMood(msg.mood);
+            }
+        });
+        return off;
+    }, []);
+    // Local setter that also broadcasts
+    const set = useCallback((next) => {
+        setMood(next);
+        try {
+            padEvents.send({ type: 'PAD.MOOD.SET', mood: next });
+        }
+        catch {
+            // no-op: keep local state even if broadcasting fails
+        }
+    }, []);
+    return [mood, set];
+}

package/dist/id.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @gratiaos/pad-core — ID & slug helpers
+ *
+ * Goals:
+ * - Stable, URL-safe IDs without external deps.
+ * - Prefer cryptographically strong randomness when available.
+ * - Human-friendly slugs (lowercase, hyphenated).
+ *
+ * These helpers are used by pads for local keys, DOM ids, and
+ * deep-linking (e.g. `/pads/:slug-id` or `#pad=slug-id`).
+ */
+/**
+ * Generate a compact, time-ordered id.
+ *
+ * Shape: `<ts36><rand10>` — e.g., `lrl7y3q3r7j2a4m1z9`
+ * - `ts36`: Date.now() in base36 so newer ids sort after older ones.
+ * - `rand10`: 10 base36 characters for collision resistance.
+ */
+export declare function uid(): string;
+/** Short random token (default 6 chars) — URL/DOM safe. */
+export declare function shortid(len?: number): string;
+/**
+ * Convert arbitrary text to a URL/DOM-safe slug.
+ * - lowercases
+ * - strips accents/diacritics when possible
+ * - replaces non-alphanumerics with single `-`
+ * - trims leading/trailing `-`
+ */
+export declare function slug(s: string): string;
+/**
+ * Build a human-friendly stable key that includes a slug plus a short random suffix.
+ * Useful for deep-links and list keys (e.g., `focus-marker-8k2b9c`).
+ */
+export declare function slugId(title: string, suffixLen?: number): string;

package/dist/id.js

@@ -0,0 +1,76 @@
+/**
+ * @gratiaos/pad-core — ID & slug helpers
+ *
+ * Goals:
+ * - Stable, URL-safe IDs without external deps.
+ * - Prefer cryptographically strong randomness when available.
+ * - Human-friendly slugs (lowercase, hyphenated).
+ *
+ * These helpers are used by pads for local keys, DOM ids, and
+ * deep-linking (e.g. `/pads/:slug-id` or `#pad=slug-id`).
+ */
+/** Internal: generate `n` base36 chars using crypto when available. */
+function randomBase36(n) {
+    const alphabet = '0123456789abcdefghijklmnopqrstuvwxyz';
+    // Use Web Crypto if present for stronger randomness.
+    const cryptoObj = typeof globalThis !== 'undefined' && globalThis.crypto ? globalThis.crypto : undefined;
+    if (cryptoObj?.getRandomValues) {
+        const buf = new Uint8Array(n);
+        cryptoObj.getRandomValues(buf);
+        let out = '';
+        for (let i = 0; i < n; i++) {
+            // Map uniformly to 0..35
+            out += alphabet[buf[i] % 36];
+        }
+        return out;
+    }
+    // Fallback: Math.random (less strong, still fine for UI ids).
+    let out = '';
+    for (let i = 0; i < n; i++) {
+        out += alphabet[Math.floor(Math.random() * 36)];
+    }
+    return out;
+}
+/**
+ * Generate a compact, time-ordered id.
+ *
+ * Shape: `<ts36><rand10>` — e.g., `lrl7y3q3r7j2a4m1z9`
+ * - `ts36`: Date.now() in base36 so newer ids sort after older ones.
+ * - `rand10`: 10 base36 characters for collision resistance.
+ */
+export function uid() {
+    const ts = Date.now().toString(36);
+    return ts + randomBase36(10);
+}
+/** Short random token (default 6 chars) — URL/DOM safe. */
+export function shortid(len = 6) {
+    const n = Math.max(1, Math.min(32, Math.floor(len)));
+    return randomBase36(n);
+}
+/**
+ * Convert arbitrary text to a URL/DOM-safe slug.
+ * - lowercases
+ * - strips accents/diacritics when possible
+ * - replaces non-alphanumerics with single `-`
+ * - trims leading/trailing `-`
+ */
+export function slug(s) {
+    const base = (s ?? '')
+        // Strip diacritics if available
+        .normalize?.('NFKD')
+        ?.replace(/[\u0300-\u036f]/g, '') ??
+        s ??
+        '';
+    return base
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+/**
+ * Build a human-friendly stable key that includes a slug plus a short random suffix.
+ * Useful for deep-links and list keys (e.g., `focus-marker-8k2b9c`).
+ */
+export function slugId(title, suffixLen = 6) {
+    const head = slug(title) || 'item';
+    return `${head}-${shortid(suffixLen)}`;
+}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Garden Pads Core — Public API barrel.
+ *
+ * This package provides:
+ * - Types that describe pads, scenes, registry metadata, and events.
+ * - A simple in-memory registry for discoverability & ordering.
+ * - Hash/URL helpers to deep-link into a pad/scene.
+ * - A tiny event bus for host ↔ pad coordination.
+ * - Catalog utilities to build shelf-ready rows and grouped views.
+ *
+ * Keep this file small and stable: consumers import from here.
+ */
+export type * from './types.js';
+export { createRegistry, sortPads, registerAll, globalRegistry } from './registry.js';
+export { DEFAULT_HASH_KEY, getActivePadId, setActivePadId, clearActivePadId, hrefForPad, onPadRouteChange } from './route.js';
+export { padEvents, dispatchPadOpen, dispatchPadClose, dispatchPadBulletinUpdated, onPadOpen, onPadClose, onPadBulletinUpdated } from './events.js';
+export { SCENE_ENTER, SCENE_COMPLETE, dispatchSceneEnter, dispatchSceneComplete, onSceneEnter, onSceneComplete, type SceneEnterDetail, type SceneCompleteDetail, type SceneVia, } from './scene-events.js';
+export { uid, slug } from './id.js';
+export { type CatalogEntry, toCatalogEntry, buildCatalog, mergeRegistries, buildCatalogFromMany, filterCatalog, groupCatalog, pathForPad, findPad, ensurePad, } from './catalog.js';
+export * from './hooks/usePadMood';
+export { setRealtimePort, getRealtimePort, getRealtimeCircleId, onRealtimePortChange } from './realtime/registry.js';

package/dist/index.js

@@ -0,0 +1,23 @@
+/**
+ * Garden Pads Core — Public API barrel.
+ *
+ * This package provides:
+ * - Types that describe pads, scenes, registry metadata, and events.
+ * - A simple in-memory registry for discoverability & ordering.
+ * - Hash/URL helpers to deep-link into a pad/scene.
+ * - A tiny event bus for host ↔ pad coordination.
+ * - Catalog utilities to build shelf-ready rows and grouped views.
+ *
+ * Keep this file small and stable: consumers import from here.
+ */
+export { createRegistry, sortPads, registerAll, globalRegistry } from './registry.js';
+export { DEFAULT_HASH_KEY, getActivePadId, setActivePadId, clearActivePadId, hrefForPad, onPadRouteChange } from './route.js';
+export { padEvents, dispatchPadOpen, dispatchPadClose, dispatchPadBulletinUpdated, onPadOpen, onPadClose, onPadBulletinUpdated } from './events.js';
+// Scene events (Pad & Scene coordination)
+export { SCENE_ENTER, SCENE_COMPLETE, dispatchSceneEnter, dispatchSceneComplete, onSceneEnter, onSceneComplete, } from './scene-events.js';
+export { uid, slug } from './id.js';
+// Catalog helpers (used by shelves/browsers in UIs)
+export { toCatalogEntry, buildCatalog, mergeRegistries, buildCatalogFromMany, filterCatalog, groupCatalog, pathForPad, findPad, ensurePad, } from './catalog.js';
+export * from './hooks/usePadMood';
+// Realtime registry (optional integration used by scene-events)
+export { setRealtimePort, getRealtimePort, getRealtimeCircleId, onRealtimePortChange } from './realtime/registry.js';

package/dist/realtime/index.d.ts

@@ -0,0 +1,24 @@
+import { type RealtimePort } from './port';
+import { type WebRtcConfig } from './webrtc-adapter';
+/**
+ * Realtime adapter factory
+ * --------------------------------------------------------
+ * Provides a single entry point for Garden Core to create
+ * a realtime adapter based on environment or explicit config.
+ */
+export type RealtimeKind = 'sim' | 'webrtc' | 'none';
+export interface RealtimeOptions {
+    kind?: RealtimeKind;
+    webrtc?: Partial<WebRtcConfig>;
+}
+/**
+ * createRealtime — main factory
+ *
+ * Auto-detects environment by checking NODE_ENV / import.meta.env
+ * or explicit `kind` parameter. Returns a valid RealtimePort.
+ */
+export declare function createRealtime(opts?: RealtimeOptions): RealtimePort;
+/** Convenience re-exports */
+export * from './port';
+export * from './sim-adapter';
+export * from './webrtc-adapter';

package/dist/realtime/index.js

@@ -0,0 +1,38 @@
+import { NotImplementedPort } from './port';
+import { createSimAdapter } from './sim-adapter';
+import { createWebRtcAdapter } from './webrtc-adapter';
+/**
+ * createRealtime — main factory
+ *
+ * Auto-detects environment by checking NODE_ENV / import.meta.env
+ * or explicit `kind` parameter. Returns a valid RealtimePort.
+ */
+export function createRealtime(opts = {}) {
+    const env = (typeof import.meta !== 'undefined' && import.meta.env && import.meta.env.MODE) ||
+        (typeof globalThis !== 'undefined' && globalThis.process && globalThis.process.env?.NODE_ENV) ||
+        'development';
+    const kind = opts.kind || (env === 'development' ? 'sim' : 'webrtc');
+    try {
+        if (kind === 'sim') {
+            return createSimAdapter();
+        }
+        if (kind === 'webrtc') {
+            const cfg = {
+                signalUrl: opts.webrtc?.signalUrl || 'wss://signal.firecircle.dev',
+                circleId: opts.webrtc?.circleId || 'firecircle',
+                peerId: opts.webrtc?.peerId,
+                iceServers: opts.webrtc?.iceServers,
+            };
+            return createWebRtcAdapter(cfg);
+        }
+        return NotImplementedPort;
+    }
+    catch (err) {
+        console.error('[realtime] failed to create adapter', err);
+        return NotImplementedPort;
+    }
+}
+/** Convenience re-exports */
+export * from './port';
+export * from './sim-adapter';
+export * from './webrtc-adapter';

package/dist/realtime/port.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Realtime Port (Pad Core)
+ * -------------------------------------------------------
+ * A small interface that abstracts the network layer so the Garden can run
+ * over simulation, WebRTC, libp2p, etc., without changing UI code.
+ */
+export type CircleId = string;
+export type PeerId = string;
+export type Topic = 'presence' | 'scenes' | 'pads' | 'assets';
+export declare const TOPIC_PRESENCE: Topic;
+export declare const TOPIC_SCENES: Topic;
+export declare const TOPIC_PADS: Topic;
+export declare const TOPIC_ASSETS: Topic;
+/** Compose a namespaced topic for a circle (e.g., `presence:firecircle`). */
+export declare function ns(circleId: CircleId, topic: Topic): string;
+/**
+ * Versioned envelope for all realtime messages.
+ */
+export type MessageEnvelope<T = unknown> = {
+    v: 1;
+    type: Topic;
+    circleId: CircleId;
+    sender: PeerId;
+    ts: number;
+    body: T;
+};
+/**
+ * RealtimePort — the single contract the app talks to.
+ *
+ * Implementations:
+ *  - SimAdapter (playground, offline)
+ *  - WebRtcAdapter (signaling via WS, data via WebRTC)
+ *  - Future: Libp2pAdapter, etc.
+ */
+export interface RealtimePort {
+    /** current connection status */
+    status(): 'disconnected' | 'connecting' | 'connected';
+    /** stable peer id for this device/session */
+    myPeerId(): PeerId;
+    /** Join a circle (room). Subsequent pub/sub calls refer to the joined circle. */
+    joinCircle(circleId: CircleId): Promise<void>;
+    /** Leave the currently joined circle (if any). */
+    leaveCircle(): Promise<void>;
+    /**
+     * Publish a message to a topic in the current circle.
+     * `payload` can be an object or a pre-encoded Uint8Array.
+     */
+    publish<T = unknown>(topic: Topic, payload: T | Uint8Array): void;
+    /**
+     * Subscribe to a topic in the current circle. Returns an unsubscribe fn.
+     * Handler receives the *decoded* payload if JSON, plus the raw envelope.
+     */
+    subscribe<T = unknown>(topic: Topic, handler: (payload: T, envelope: MessageEnvelope<T>) => void): () => void;
+}
+export declare function encodeJson(obj: unknown): Uint8Array;
+export declare function decodeJson<T = unknown>(bytesOrObj: Uint8Array | T): T;
+/** Small helper to stamp an envelope. */
+export declare function envelope<T = unknown>(circleId: CircleId, sender: PeerId, type: Topic, body: T): MessageEnvelope<T>;
+/** Type guards */
+export declare function isUint8Array(v: unknown): v is Uint8Array;
+export declare function isObject(v: unknown): v is Record<string, unknown>;
+/**
+ * Factory hook-up placeholder — real adapters will live in sibling files.
+ * Keeping here for callers that want a single import site.
+ */
+export type PortFactory = () => RealtimePort;
+export declare const NotImplementedPort: RealtimePort;

package/dist/realtime/port.js

@@ -0,0 +1,64 @@
+/**
+ * Realtime Port (Pad Core)
+ * -------------------------------------------------------
+ * A small interface that abstracts the network layer so the Garden can run
+ * over simulation, WebRTC, libp2p, etc., without changing UI code.
+ */
+export const TOPIC_PRESENCE = 'presence';
+export const TOPIC_SCENES = 'scenes';
+export const TOPIC_PADS = 'pads';
+export const TOPIC_ASSETS = 'assets';
+/** Compose a namespaced topic for a circle (e.g., `presence:firecircle`). */
+export function ns(circleId, topic) {
+    return `${topic}:${circleId}`;
+}
+/** -----------------------------------------------------
+ * JSON/Binary helpers (loose, minimal)
+ * ----------------------------------------------------*/
+const enc = typeof TextEncoder !== 'undefined' ? new TextEncoder() : undefined;
+const dec = typeof TextDecoder !== 'undefined' ? new TextDecoder() : undefined;
+export function encodeJson(obj) {
+    const text = JSON.stringify(obj);
+    return enc ? enc.encode(text) : new TextEncoder().encode(text);
+}
+export function decodeJson(bytesOrObj) {
+    if (bytesOrObj && typeof bytesOrObj === 'object' && !(bytesOrObj instanceof Uint8Array)) {
+        return bytesOrObj; // already an object
+    }
+    const str = dec ? dec.decode(bytesOrObj) : new TextDecoder().decode(bytesOrObj);
+    try {
+        return JSON.parse(str);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Small helper to stamp an envelope. */
+export function envelope(circleId, sender, type, body) {
+    return { v: 1, type, circleId, sender, ts: Date.now(), body };
+}
+/** Type guards */
+export function isUint8Array(v) {
+    return v instanceof Uint8Array;
+}
+export function isObject(v) {
+    return typeof v === 'object' && v !== null && !isUint8Array(v);
+}
+export const NotImplementedPort = {
+    status: () => 'disconnected',
+    myPeerId: () => 'peer:noop',
+    async joinCircle() {
+        throw new Error('RealtimePort not configured');
+    },
+    async leaveCircle() {
+        /* noop */
+    },
+    publish() {
+        /* noop */
+    },
+    subscribe() {
+        return () => {
+            /* noop */
+        };
+    },
+};

package/dist/realtime/registry.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Realtime Registry (Pad Core)
+ * -------------------------------------------------------
+ * A tiny in-memory registry used by pad-core to *optionally* bridge
+ * DOM-based events with a realtime transport (Sim/WebRTC/etc.).
+ *
+ * Responsibilities:
+ *  - Hold a single active RealtimePort (+ circleId) selected by the host app.
+ *  - Notify listeners when the active port changes (connect/disconnect/swap).
+ *  - Let features (e.g., scene-events) *query* the current port and circle.
+ *
+ * Notes:
+ *  - This registry does not create connections. The host (e.g., Playground)
+ *    should call `setRealtimePort(rt, circleId)` after a successful join.
+ *  - Consumers can subscribe via `onRealtimePortChange` to attach topic
+ *    subscriptions when a port becomes available.
+ */
+import type { RealtimePort, CircleId } from './port.js';
+/**
+ * Set the active realtime adapter and circle context.
+ * Call this from the host app (e.g., Playground) *after* joining a circle.
+ * Passing `null` disconnects the registry and notifies listeners.
+ */
+export declare function setRealtimePort(port: RealtimePort | null, circleId?: CircleId | null): void;
+/** Get the current active realtime adapter (or null if none). */
+export declare function getRealtimePort(): RealtimePort | null;
+/** Get the current circle id (or null if none is registered). */
+export declare function getRealtimeCircleId(): CircleId | null;
+/**
+ * Subscribe to changes of the active realtime port/circle.
+ * Returns an unsubscribe function. Safe to call multiple times.
+ */
+export declare function onRealtimePortChange(listener: (port: RealtimePort | null, circleId: CircleId | null) => void): () => void;

package/dist/realtime/registry.js

@@ -0,0 +1,36 @@
+// Singleton state for the current realtime adapter and circle context
+let _port = null;
+let _circleId = null;
+// Subscribers notified whenever `setRealtimePort(...)` changes state
+const listeners = new Set();
+/**
+ * Set the active realtime adapter and circle context.
+ * Call this from the host app (e.g., Playground) *after* joining a circle.
+ * Passing `null` disconnects the registry and notifies listeners.
+ */
+export function setRealtimePort(port, circleId) {
+    _port = port ?? null;
+    _circleId = circleId ?? null;
+    for (const listener of listeners) {
+        try {
+            listener(_port, _circleId);
+        }
+        catch { }
+    }
+}
+/** Get the current active realtime adapter (or null if none). */
+export function getRealtimePort() {
+    return _port;
+}
+/** Get the current circle id (or null if none is registered). */
+export function getRealtimeCircleId() {
+    return _circleId;
+}
+/**
+ * Subscribe to changes of the active realtime port/circle.
+ * Returns an unsubscribe function. Safe to call multiple times.
+ */
+export function onRealtimePortChange(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}

package/dist/realtime/sim-adapter.d.ts

@@ -0,0 +1,16 @@
+import { type CircleId, type Topic, type MessageEnvelope, type RealtimePort } from './port';
+export declare class SimAdapter implements RealtimePort {
+    private _peerId;
+    private _circleId;
+    private _status;
+    constructor();
+    status(): "disconnected" | "connecting" | "connected";
+    myPeerId(): string;
+    joinCircle(circleId: CircleId): Promise<void>;
+    leaveCircle(): Promise<void>;
+    publish<T = unknown>(topic: Topic, payload: T | Uint8Array): void;
+    subscribe<T = unknown>(topic: Topic, handler: (payload: T, envelope: MessageEnvelope<T>) => void): () => void;
+    private _emitSystem;
+}
+/** Factory to create a new SimAdapter easily */
+export declare function createSimAdapter(): RealtimePort;