@croct/sdk 0.17.12 → 0.18.1

package/README.md

@@ -1,24 +1,22 @@
 <p align="center">
-    <a href="https://croct.com">
-        <img src="https://cdn.croct.io/brand/logo/repo-icon-green.svg" alt="Croct" height="80" />
-    </a>
-    <br />
-    <strong>SDK JS</strong>
-    <br />
-    The official Croct SDK for JavaScript.
+  <a href="https://croct.com" target="_blank">
+    <picture>
+        <source media="(min-width: 769px) and (prefers-color-scheme: light)" srcset="https://github.com/croct-tech/plug-js/blob/master/.github/assets/header-light.svg">
+        <source media="(min-width: 769px) and (prefers-color-scheme: dark)" srcset="https://github.com/croct-tech/plug-js/blob/master/.github/assets/header-dark.svg">
+        <source media="(max-width: 768px) and (prefers-color-scheme: dark)" srcset="https://github.com/croct-tech/plug-js/blob/master/.github/assets/header-dark-mobile.svg">
+        <source media="(max-width: 768px) and (prefers-color-scheme: light)" srcset="https://github.com/croct-tech/plug-js/blob/master/.github/assets/header-light-mobile.svg">
+        <img src="https://github.com/croct-tech/plug-js/blob/master/.github/assets/header-light-mobile.svg" alt="Croct JavaScript SDK" title="Croct JavaScript SDK" width="100%">
+    </picture>
+  </a>
+  <br/>
+  <strong>SDK JS</strong><br/>
+  The official Croct SDK for JavaScript.
 </p>
+
 <p align="center">
     <a href="https://www.npmjs.com/package/@croct/sdk"><img alt="Version" src="https://img.shields.io/npm/v/@croct/sdk"/></a>
     <a href="https://github.com/croct-tech/sdk-js/actions?query=workflow%3AValidations"><img alt="Build" src="https://github.com/croct-tech/sdk-js/workflows/Validations/badge.svg"/></a>
-    <a href="https://codeclimate.com/repos/5e7251b3172af05fe9000e27/maintainability"><img alt="Maintainability" src="https://api.codeclimate.com/v1/badges/c44df78a3ed891af11bb/maintainability"/></a>
     <a href="https://codeclimate.com/repos/5e7251b3172af05fe9000e27/test_coverage"><img alt="Coverage" src="https://api.codeclimate.com/v1/badges/c44df78a3ed891af11bb/test_coverage"/></a>
-    <br />
-    <br />
-    <a href="https://github.com/croct-tech/sdk-js/releases">📦Releases</a>
-    ·
-    <a href="https://github.com/croct-tech/sdk-js/issues/new?labels=bug&template=bug-report.md">🐞Report Bug</a>
-    ·
-    <a href="https://github.com/croct-tech/sdk-js/issues/new?labels=enhancement&template=feature-request.md">✨Request Feature</a>
 </p>
 
 ## Installation

package/activeRecord.cjs

@@ -20,7 +20,7 @@ __export(activeRecord_exports, {
   ActiveRecord: () => ActiveRecord
 });
 module.exports = __toCommonJS(activeRecord_exports);
-var import_schema = require("./schema");
+var import_schema = require('./schema/index.cjs');
 const operationSchema = {
   add: import_schema.addOperation,
   set: import_schema.setOperation,

package/activeRecord.d.cts

@@ -0,0 +1,26 @@
+import { JsonValue, JsonStructure } from '@croct/json';
+import { Patch } from './patch.cjs';
+import { TrackingEvent } from './trackingEvents.cjs';
+import './utilityTypes.cjs';
+
+declare abstract class ActiveRecord<T extends TrackingEvent> {
+    private readonly operations;
+    set(value: JsonValue): this;
+    set(property: string, value: JsonValue): this;
+    add(property: string, value: JsonValue): this;
+    combine(property: string, value: JsonValue): this;
+    merge(value: JsonStructure): this;
+    merge(property: string, value: JsonStructure): this;
+    increment(property: string, amount?: number): this;
+    decrement(property: string, amount?: number): this;
+    clear(property: string): this;
+    unset(property: string): this;
+    remove(property: string, value: JsonValue): this;
+    private pushOperation;
+    protected reset(): this;
+    abstract save(): Promise<T>;
+    protected isDirty(): boolean;
+    protected buildPatch(): Patch;
+}
+
+export { ActiveRecord };

package/activeRecord.js

@@ -8,7 +8,7 @@ import {
   setOperation,
   unsetOperation,
   removeOperation
-} from "./schema";
+} from "./schema/index.js";
 const operationSchema = {
   add: addOperation,
   set: setOperation,

package/apiKey.d.cts

@@ -0,0 +1,48 @@
+type ParsedPrivateKey = {
+    algorithm: string;
+    encodedKey: string;
+};
+declare class ApiKey {
+    private static readonly IDENTIFIER_PATTERN;
+    private static readonly PRIVATE_KEY_PATTERN;
+    private static readonly ALGORITHMS;
+    private readonly identifier;
+    private readonly privateKey?;
+    private importedKey;
+    private constructor();
+    static from(apiKey: string | ApiKey): ApiKey;
+    static parse(apiKey: string): ApiKey;
+    static of(identifier: string, privateKey?: string): ApiKey;
+    getIdentifier(): string;
+    getIdentifierHash(): Promise<string>;
+    hasPrivateKey(): boolean;
+    getPrivateKey(): string;
+    sign(data: string): Promise<string>;
+    getSigningAlgorithm(): string;
+    private importKey;
+    private getParsedPrivateKey;
+    export(): string;
+    toString(): string;
+    /**
+     * Create an array buffer from a string.
+     *
+     * @see https://developers.google.com/web/updates/2012/06/How-to-convert-ArrayBuffer-to-and-from-String
+     *
+     * @param data The string to convert.
+     * @returns The array buffer.
+     */
+    private static createByteArrayFromString;
+    private static createByteArrayFromHexString;
+    /**
+     * Convert an array buffer to a string.
+     *
+     * @see https://developers.google.com/web/updates/2012/06/How-to-convert-ArrayBuffer-to-and-from-String
+     *
+     * @param buffer The buffer to convert.
+     * @returns The string.
+     */
+    private static convertBufferToString;
+    private static convertBufferToHexString;
+}
+
+export { ApiKey, type ParsedPrivateKey };

package/base64Url.d.cts

@@ -0,0 +1,4 @@
+declare function base64UrlEncode(value: string, utf8?: boolean): string;
+declare function base64UrlDecode(value: string, utf8?: boolean): string;
+
+export { base64UrlDecode, base64UrlEncode };

package/cache/cache.d.cts

@@ -0,0 +1,17 @@
+interface Cache {
+    get(): string | null;
+    put(value: string): void;
+    clear(): void;
+}
+interface CacheListener {
+    (value: string | null): void;
+}
+interface ObservableCache extends Cache {
+    addListener(listener: CacheListener): void;
+    removeListener(listener: CacheListener): void;
+}
+declare namespace ObservableCache {
+    function isObservable(cache: Cache): cache is ObservableCache;
+}
+
+export { type Cache, type CacheListener, ObservableCache };

package/cache/cookieCache.d.cts

@@ -0,0 +1,22 @@
+import { Cache } from './cache.cjs';
+
+type CookieCacheConfiguration = {
+    name: string;
+    secure?: boolean;
+    maxAge?: number;
+    domain?: string;
+    path?: string;
+    sameSite?: 'strict' | 'lax' | 'none';
+};
+declare class CookieCache implements Cache {
+    private readonly config;
+    constructor(config: CookieCacheConfiguration, defaultSecure?: boolean);
+    get(): string | null;
+    put(value: string): void;
+    clear(): void;
+    private static serializeCookie;
+    private static encode;
+    private static decode;
+}
+
+export { CookieCache, type CookieCacheConfiguration };

package/cache/fallbackCache.d.cts

@@ -0,0 +1,11 @@
+import { Cache } from './cache.cjs';
+
+declare class FallbackCache implements Cache {
+    private readonly caches;
+    constructor(...caches: Cache[]);
+    get(): string | null;
+    put(value: string): void;
+    clear(): void;
+}
+
+export { FallbackCache };

package/cache/inMemoryCache.d.cts

@@ -0,0 +1,11 @@
+import { Cache } from './cache.cjs';
+
+declare class InMemoryCache implements Cache {
+    private cache?;
+    constructor(cache?: string);
+    get(): string | null;
+    put(value: string): void;
+    clear(): void;
+}
+
+export { InMemoryCache };

package/cache/index.cjs

@@ -23,14 +23,14 @@ __export(cache_exports, {
   LocalStorageCache: () => import_localStorageCache.LocalStorageCache
 });
 module.exports = __toCommonJS(cache_exports);
-__reExport(cache_exports, require("./cache"), module.exports);
-var import_fallbackCache = require("./fallbackCache");
-var import_inMemoryCache = require("./inMemoryCache");
-var import_localStorageCache = require("./localStorageCache");
+__reExport(cache_exports, require('./cache.cjs'), module.exports);
+var import_fallbackCache = require('./fallbackCache.cjs');
+var import_inMemoryCache = require('./inMemoryCache.cjs');
+var import_localStorageCache = require('./localStorageCache.cjs');
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   FallbackCache,
   InMemoryCache,
   LocalStorageCache,
-  ...require("./cache")
+  ...require('./cache.cjs')
 });

package/cache/index.d.cts

@@ -0,0 +1,4 @@
+export { Cache, CacheListener, ObservableCache } from './cache.cjs';
+export { FallbackCache } from './fallbackCache.cjs';
+export { InMemoryCache } from './inMemoryCache.cjs';
+export { LocalStorageCache } from './localStorageCache.cjs';

package/cache/index.js

@@ -1,7 +1,7 @@
-export * from "./cache";
-import { FallbackCache } from "./fallbackCache";
-import { InMemoryCache } from "./inMemoryCache";
-import { LocalStorageCache } from "./localStorageCache";
+export * from "./cache.js";
+import { FallbackCache } from "./fallbackCache.js";
+import { InMemoryCache } from "./inMemoryCache.js";
+import { LocalStorageCache } from "./localStorageCache.js";
 export {
   FallbackCache,
   InMemoryCache,

package/cache/localStorageCache.d.cts

@@ -0,0 +1,19 @@
+import { ObservableCache, CacheListener } from './cache.cjs';
+
+declare class LocalStorageCache implements ObservableCache {
+    private readonly storage;
+    private readonly key;
+    private value;
+    private readonly listeners;
+    constructor(storage: Storage, key: string);
+    static autoSync(cache: LocalStorageCache): (() => void);
+    get(): string | null;
+    put(value: string): void;
+    clear(): void;
+    addListener(listener: CacheListener): void;
+    removeListener(listener: CacheListener): void;
+    private notifyChange;
+    private sync;
+}
+
+export { LocalStorageCache };

package/channel/channel.cjs

@@ -20,7 +20,7 @@ __export(channel_exports, {
   MessageDeliveryError: () => MessageDeliveryError
 });
 module.exports = __toCommonJS(channel_exports);
-var import_error = require("../error");
+var import_error = require('../error.cjs');
 class MessageDeliveryError extends Error {
   constructor(message, retryable) {
     super(message);

package/channel/channel.d.cts

@@ -0,0 +1,24 @@
+declare class MessageDeliveryError extends Error {
+    readonly retryable: boolean;
+    constructor(message: string, retryable: boolean);
+    static retryable(cause: unknown): MessageDeliveryError;
+    static nonRetryable(cause: unknown): MessageDeliveryError;
+    private static fromCause;
+}
+interface Closeable {
+    close(): Promise<void>;
+}
+interface OutputChannel<O> extends Closeable {
+    publish(message: O): Promise<void>;
+}
+type ChannelListener<T> = {
+    (message: T): void;
+};
+interface InputChannel<I> extends Closeable {
+    subscribe(listener: ChannelListener<I>): void;
+    unsubscribe(listener: ChannelListener<I>): void;
+}
+interface DuplexChannel<I, O> extends InputChannel<I>, OutputChannel<O> {
+}
+
+export { type ChannelListener, type Closeable, type DuplexChannel, type InputChannel, MessageDeliveryError, type OutputChannel };

package/channel/channel.js

@@ -1,4 +1,4 @@
-import { formatMessage } from "../error";
+import { formatMessage } from "../error.js";
 class MessageDeliveryError extends Error {
   constructor(message, retryable) {
     super(message);

package/channel/encodedChannel.d.cts

@@ -0,0 +1,12 @@
+import { OutputChannel } from './channel.cjs';
+import { Transformer } from '../transformer.cjs';
+
+declare class EncodedChannel<D, E> implements OutputChannel<D> {
+    private readonly encode;
+    private readonly channel;
+    constructor(channel: OutputChannel<E>, encoder: Transformer<D, E>);
+    publish(message: D): Promise<void>;
+    close(): Promise<void>;
+}
+
+export { EncodedChannel };

package/channel/guaranteedChannel.cjs

@@ -21,8 +21,8 @@ __export(guaranteedChannel_exports, {
   TimeStamper: () => TimeStamper
 });
 module.exports = __toCommonJS(guaranteedChannel_exports);
-var import_logging = require("../logging");
-var import_channel = require("./channel");
+var import_logging = require('../logging/index.cjs');
+var import_channel = require('./channel.cjs');
 class TimeStamper {
   generate() {
     return String(Date.now());

package/channel/guaranteedChannel.d.cts

@@ -0,0 +1,33 @@
+import { Logger } from '../logging/logger.cjs';
+import { OutputChannel, DuplexChannel } from './channel.cjs';
+
+type MessageStamper<M, S> = {
+    generate(message: M): S;
+};
+declare class TimeStamper implements MessageStamper<any, string> {
+    generate(): string;
+}
+type Envelope<M, S> = {
+    id: S;
+    message: M;
+};
+type Options = {
+    ackTimeout: number;
+};
+type Configuration<M, S> = Partial<Options> & {
+    channel: DuplexChannel<S, Envelope<M, S>>;
+    stamper: MessageStamper<M, S>;
+    logger?: Logger;
+};
+declare class GuaranteedChannel<M, S> implements OutputChannel<M> {
+    private readonly channel;
+    private readonly stamper;
+    private readonly logger;
+    private readonly options;
+    private closed;
+    constructor({ channel, logger, stamper, ...options }: Configuration<M, S>);
+    publish(message: M): Promise<void>;
+    close(): Promise<void>;
+}
+
+export { type Envelope, GuaranteedChannel, type MessageStamper, TimeStamper };

package/channel/guaranteedChannel.js

@@ -1,5 +1,5 @@
-import { NullLogger } from "../logging";
-import { MessageDeliveryError } from "./channel";
+import { NullLogger } from "../logging/index.js";
+import { MessageDeliveryError } from "./channel.js";
 class TimeStamper {
   generate() {
     return String(Date.now());

package/channel/httpBeaconChannel.cjs

@@ -20,11 +20,11 @@ __export(httpBeaconChannel_exports, {
   HttpBeaconChannel: () => HttpBeaconChannel
 });
 module.exports = __toCommonJS(httpBeaconChannel_exports);
-var import_channel = require("./channel");
-var import_logging = require("../logging");
-var import_error = require("../error");
-var import_constants = require("../constants");
-var import_help = require("../help");
+var import_channel = require('./channel.cjs');
+var import_logging = require('../logging/index.cjs');
+var import_error = require('../error.cjs');
+var import_constants = require('../constants.cjs');
+var import_help = require('../help.cjs');
 class HttpBeaconChannel {
   constructor({ logger = new import_logging.NullLogger(), ...configuration }) {
     this.listeners = [];

package/channel/httpBeaconChannel.d.cts

@@ -0,0 +1,26 @@
+import { DuplexChannel, ChannelListener } from './channel.cjs';
+import { Envelope } from './guaranteedChannel.cjs';
+import { Logger } from '../logging/logger.cjs';
+import { CidAssigner } from '../cid/assigner.cjs';
+
+type Configuration = {
+    appId: string;
+    endpointUrl: string;
+    cidAssigner: CidAssigner;
+    logger?: Logger;
+};
+declare class HttpBeaconChannel implements DuplexChannel<string, Envelope<string, string>> {
+    private readonly configuration;
+    private readonly logger;
+    private readonly listeners;
+    private closed;
+    constructor({ logger, ...configuration }: Configuration);
+    publish({ id: receiptId, message }: Envelope<string, string>): Promise<void>;
+    subscribe(listener: ChannelListener<string>): void;
+    unsubscribe(listener: ChannelListener<string>): void;
+    private notify;
+    close(): Promise<void>;
+    private static isRetryable;
+}
+
+export { type Configuration, HttpBeaconChannel };

package/channel/httpBeaconChannel.js

@@ -1,8 +1,8 @@
-import { MessageDeliveryError } from "./channel";
-import { NullLogger } from "../logging";
-import { formatMessage } from "../error";
-import { CLIENT_LIBRARY } from "../constants";
-import { Help } from "../help";
+import { MessageDeliveryError } from "./channel.js";
+import { NullLogger } from "../logging/index.js";
+import { formatMessage } from "../error.js";
+import { CLIENT_LIBRARY } from "../constants.js";
+import { Help } from "../help.js";
 class HttpBeaconChannel {
   constructor({ logger = new NullLogger(), ...configuration }) {
     this.listeners = [];

package/channel/index.cjs

@@ -26,13 +26,13 @@ __export(channel_exports, {
   SandboxChannel: () => import_sandboxChannel.SandboxChannel
 });
 module.exports = __toCommonJS(channel_exports);
-__reExport(channel_exports, require("./channel"), module.exports);
-var import_encodedChannel = require("./encodedChannel");
-var import_guaranteedChannel = require("./guaranteedChannel");
-var import_queuedChannel = require("./queuedChannel");
-var import_retryChannel = require("./retryChannel");
-var import_sandboxChannel = require("./sandboxChannel");
-var import_httpBeaconChannel = require("./httpBeaconChannel");
+__reExport(channel_exports, require('./channel.cjs'), module.exports);
+var import_encodedChannel = require('./encodedChannel.cjs');
+var import_guaranteedChannel = require('./guaranteedChannel.cjs');
+var import_queuedChannel = require('./queuedChannel.cjs');
+var import_retryChannel = require('./retryChannel.cjs');
+var import_sandboxChannel = require('./sandboxChannel.cjs');
+var import_httpBeaconChannel = require('./httpBeaconChannel.cjs');
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   EncodedChannel,
@@ -41,5 +41,5 @@ var import_httpBeaconChannel = require("./httpBeaconChannel");
   QueuedChannel,
   RetryChannel,
   SandboxChannel,
-  ...require("./channel")
+  ...require('./channel.cjs')
 });

package/channel/index.d.cts

@@ -0,0 +1,12 @@
+export { ChannelListener, Closeable, DuplexChannel, InputChannel, MessageDeliveryError, OutputChannel } from './channel.cjs';
+export { EncodedChannel } from './encodedChannel.cjs';
+export { GuaranteedChannel } from './guaranteedChannel.cjs';
+export { QueuedChannel } from './queuedChannel.cjs';
+export { RetryChannel } from './retryChannel.cjs';
+export { SandboxChannel } from './sandboxChannel.cjs';
+export { HttpBeaconChannel } from './httpBeaconChannel.cjs';
+import '../transformer.cjs';
+import '../logging/logger.cjs';
+import '../queue/queue.cjs';
+import '../retry/policy.cjs';
+import '../cid/assigner.cjs';

package/channel/index.js

@@ -1,10 +1,10 @@
-export * from "./channel";
-import { EncodedChannel } from "./encodedChannel";
-import { GuaranteedChannel } from "./guaranteedChannel";
-import { QueuedChannel } from "./queuedChannel";
-import { RetryChannel } from "./retryChannel";
-import { SandboxChannel } from "./sandboxChannel";
-import { HttpBeaconChannel } from "./httpBeaconChannel";
+export * from "./channel.js";
+import { EncodedChannel } from "./encodedChannel.js";
+import { GuaranteedChannel } from "./guaranteedChannel.js";
+import { QueuedChannel } from "./queuedChannel.js";
+import { RetryChannel } from "./retryChannel.js";
+import { SandboxChannel } from "./sandboxChannel.js";
+import { HttpBeaconChannel } from "./httpBeaconChannel.js";
 export {
   EncodedChannel,
   GuaranteedChannel,

package/channel/queuedChannel.cjs

@@ -20,8 +20,8 @@ __export(queuedChannel_exports, {
   QueuedChannel: () => QueuedChannel
 });
 module.exports = __toCommonJS(queuedChannel_exports);
-var import_channel = require("./channel");
-var import_logging = require("../logging");
+var import_channel = require('./channel.cjs');
+var import_logging = require('../logging/index.cjs');
 class QueuedChannel {
   constructor(channel, queue, logger) {
     this.closed = false;
@@ -57,7 +57,11 @@ class QueuedChannel {
   dequeue() {
     this.logger.debug("Dequeuing message...");
     this.logger.debug(`Queue length: ${Math.max(0, this.queue.length() - 1)}`);
-    this.queue.shift();
+    if (this.queue.length() === 0) {
+      this.logger.debug("Queue unexpectedly empty, possibly due to concurrent modification.");
+    } else {
+      this.queue.shift();
+    }
   }
   requeue() {
     if (this.closed) {

package/channel/queuedChannel.d.cts

@@ -0,0 +1,21 @@
+import { OutputChannel } from './channel.cjs';
+import { Queue } from '../queue/queue.cjs';
+import { Logger } from '../logging/logger.cjs';
+
+declare class QueuedChannel<T> implements OutputChannel<T> {
+    private readonly channel;
+    private readonly queue;
+    private readonly logger;
+    private pending?;
+    private closed;
+    constructor(channel: OutputChannel<T>, queue: Queue<T>, logger?: Logger);
+    flush(): Promise<void>;
+    publish(message: T): Promise<void>;
+    private enqueue;
+    private dequeue;
+    private requeue;
+    private chainNext;
+    close(): Promise<void>;
+}
+
+export { QueuedChannel };

package/channel/queuedChannel.js

@@ -1,5 +1,5 @@
-import { MessageDeliveryError } from "./channel";
-import { NullLogger } from "../logging";
+import { MessageDeliveryError } from "./channel.js";
+import { NullLogger } from "../logging/index.js";
 class QueuedChannel {
   constructor(channel, queue, logger) {
     this.closed = false;
@@ -35,7 +35,11 @@ class QueuedChannel {
   dequeue() {
     this.logger.debug("Dequeuing message...");
     this.logger.debug(`Queue length: ${Math.max(0, this.queue.length() - 1)}`);
-    this.queue.shift();
+    if (this.queue.length() === 0) {
+      this.logger.debug("Queue unexpectedly empty, possibly due to concurrent modification.");
+    } else {
+      this.queue.shift();
+    }
   }
   requeue() {
     if (this.closed) {

package/channel/retryChannel.cjs

@@ -20,8 +20,8 @@ __export(retryChannel_exports, {
   RetryChannel: () => RetryChannel
 });
 module.exports = __toCommonJS(retryChannel_exports);
-var import_channel = require("./channel");
-var import_logging = require("../logging");
+var import_channel = require('./channel.cjs');
+var import_logging = require('../logging/index.cjs');
 class RetryChannel {
   constructor({ channel, retryPolicy, logger }) {
     this.closed = false;

package/channel/retryChannel.d.cts

@@ -0,0 +1,21 @@
+import { OutputChannel } from './channel.cjs';
+import { Logger } from '../logging/logger.cjs';
+import { RetryPolicy } from '../retry/policy.cjs';
+
+type Configuration<T> = {
+    channel: OutputChannel<T>;
+    retryPolicy: RetryPolicy<T>;
+    logger?: Logger;
+};
+declare class RetryChannel<T> implements OutputChannel<T> {
+    private readonly channel;
+    private readonly retryPolicy;
+    private readonly logger;
+    private closed;
+    constructor({ channel, retryPolicy, logger }: Configuration<T>);
+    publish(message: T): Promise<void>;
+    retry(message: T, error: unknown): Promise<void>;
+    close(): Promise<void>;
+}
+
+export { RetryChannel };

package/channel/retryChannel.js

@@ -1,5 +1,5 @@
-import { MessageDeliveryError } from "./channel";
-import { NullLogger } from "../logging";
+import { MessageDeliveryError } from "./channel.js";
+import { NullLogger } from "../logging/index.js";
 class RetryChannel {
   constructor({ channel, retryPolicy, logger }) {
     this.closed = false;

package/channel/sandboxChannel.cjs

@@ -20,7 +20,7 @@ __export(sandboxChannel_exports, {
   SandboxChannel: () => SandboxChannel
 });
 module.exports = __toCommonJS(sandboxChannel_exports);
-var import_channel = require("./channel");
+var import_channel = require('./channel.cjs');
 class SandboxChannel {
   constructor() {
     this.listeners = [];

package/channel/sandboxChannel.d.cts

@@ -0,0 +1,15 @@
+import { DuplexChannel, ChannelListener } from './channel.cjs';
+
+declare class SandboxChannel<I, O> implements DuplexChannel<I, O> {
+    private readonly listeners;
+    readonly messages: O[];
+    private closed;
+    publish(message: O): Promise<void>;
+    notify(message: I): void;
+    subscribe(listener: ChannelListener<I>): void;
+    unsubscribe(listener: ChannelListener<I>): void;
+    close(): Promise<void>;
+    isClosed(): boolean;
+}
+
+export { SandboxChannel };