@resonatehq/sdk 0.11.2 → 0.11.4

package/README.md

@@ -2,7 +2,7 @@
 
 # Resonate TypeScript SDK
 
-[![cicd](https://github.com/resonatehq/resonate-sdk-ts/actions/workflows/cicd.yaml/badge.svg)](https://github.com/resonatehq/resonate-sdk-ts/actions/workflows/cicd.yaml)
+[![ci](https://github.com/resonatehq/resonate-sdk-ts/actions/workflows/ci.yml/badge.svg)](https://github.com/resonatehq/resonate-sdk-ts/actions/workflows/ci.yml)
 [![codecov](https://codecov.io/gh/resonatehq/resonate-sdk-ts/branch/main/graph/badge.svg)](https://codecov.io/gh/resonatehq/resonate-sdk-ts)
 [![dst](https://github.com/resonatehq/resonate-sdk-ts/actions/workflows/dst.yml/badge.svg)](https://github.com/resonatehq/resonate-sdk-ts/actions/workflows/dst.yml)
 [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)

package/dist/{async → src/async}/context.d.ts

@@ -267,4 +267,3 @@ export declare function run(ctx: AsyncContext, func: AnyFunc, args: any[]): Prom
  */
 export declare function runWithRetry(makeCtx: (attempt: number) => AsyncContext, func: AnyFunc, args: any[], policy: RetryPolicy, nonRetryableErrors: Array<new (...args: any[]) => Error>, clock: Clock, timeoutAt: number): Promise<Outcome>;
 export {};
-//# sourceMappingURL=context.d.ts.map

package/dist/{async → src/async}/context.js

@@ -595,4 +595,3 @@ export async function runWithRetry(makeCtx, func, args, policy, nonRetryableErro
         await delay(retryIn);
     }
 }
-//# sourceMappingURL=context.js.map

package/dist/{async → src/async}/core.d.ts

@@ -58,4 +58,3 @@ export declare class Core {
     private fulfillTask;
     onMessage(msg: Message): Promise<Status | undefined>;
 }
-//# sourceMappingURL=core.d.ts.map

package/dist/{async → src/async}/core.js

@@ -236,4 +236,3 @@ function isValidData(data) {
     }
     return true;
 }
-//# sourceMappingURL=core.js.map

package/dist/{async → src/async}/index.d.ts

@@ -2,4 +2,3 @@ export { Constant, Exponential, Linear, Never, type RetryPolicy } from "../retri
 export { type AnyFunc, type Context, type DetachedHandle, DurablePromise, type Info } from "./context.js";
 export { Core, type Done, type Status, type Suspended } from "./core.js";
 export { Resonate, type ResonateFunc, type ResonateHandle, type ResonateSchedule, } from "./resonate.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/{async → src/async}/index.js

@@ -14,4 +14,3 @@ export { DurablePromise } from "./context.js";
 // long-running `Resonate` class with its network recv loop and heartbeat.
 export { Core } from "./core.js";
 export { Resonate, } from "./resonate.js";
-//# sourceMappingURL=index.js.map

package/dist/{async → src/async}/resonate.d.ts

@@ -95,4 +95,3 @@ export declare class Resonate {
     private subscribe;
     private notify;
 }
-//# sourceMappingURL=resonate.d.ts.map

package/dist/{async → src/async}/resonate.js

@@ -384,4 +384,3 @@ export class Resonate {
         }
     }
 }
-//# sourceMappingURL=resonate.js.map

package/dist/{clock.d.ts → src/clock.d.ts}

@@ -8,4 +8,3 @@ export declare class StepClock {
     time: number;
     now(): number;
 }
-//# sourceMappingURL=clock.d.ts.map

package/dist/{clock.js → src/clock.js}

@@ -9,4 +9,3 @@ export class StepClock {
         return this.time++;
     }
 }
-//# sourceMappingURL=clock.js.map

package/dist/{codec.d.ts → src/codec.d.ts}

@@ -8,4 +8,3 @@ export declare class Codec {
     decode(value: Value | undefined): any | undefined;
     decodePromise(promise: PromiseRecord): PromiseRecord;
 }
-//# sourceMappingURL=codec.d.ts.map

package/dist/{codec.js → src/codec.js}

@@ -112,4 +112,3 @@ export class Codec {
         };
     }
 }
-//# sourceMappingURL=codec.js.map

package/dist/{computation.d.ts → src/computation.d.ts}

@@ -37,4 +37,3 @@ export declare class Computation {
     private processGenerator;
     private processFunction;
 }
-//# sourceMappingURL=computation.d.ts.map

package/dist/{computation.js → src/computation.js}

@@ -153,4 +153,3 @@ function isValidData(data) {
     }
     return true;
 }
-//# sourceMappingURL=computation.js.map

package/dist/{context.d.ts → src/context.d.ts}

@@ -278,4 +278,3 @@ export declare class InnerContext implements Context {
     }): PromiseCreateReq;
     seqid(): string;
 }
-//# sourceMappingURL=context.d.ts.map

package/dist/{context.js → src/context.js}

@@ -451,4 +451,3 @@ export class InnerContext {
         return `${this.id}.${this.seq}`;
     }
 }
-//# sourceMappingURL=context.js.map

package/dist/{core.d.ts → src/core.d.ts}

@@ -42,4 +42,3 @@ export declare class Core {
     private fulfillTask;
     onMessage(msg: Message): Promise<Status | undefined>;
 }
-//# sourceMappingURL=core.d.ts.map

package/dist/{core.js → src/core.js}

@@ -143,4 +143,3 @@ export class Core {
         return this.executeUntilBlocked(res.data.task, rootPromise, res.data.preload);
     }
 }
-//# sourceMappingURL=core.js.map

package/dist/{coroutine.d.ts → src/coroutine.d.ts}

@@ -34,4 +34,3 @@ export declare class Coroutine<T> {
     private settle;
     private completedPromise;
 }
-//# sourceMappingURL=coroutine.d.ts.map

package/dist/{coroutine.js → src/coroutine.js}

@@ -256,4 +256,3 @@ export class Coroutine {
         };
     }
 }
-//# sourceMappingURL=coroutine.js.map

package/dist/{decorator.d.ts → src/decorator.d.ts}

@@ -66,4 +66,3 @@ export declare class Decorator<TRet> {
     private toLiteral;
     private safeGeneratorNext;
 }
-//# sourceMappingURL=decorator.d.ts.map

package/dist/{decorator.js → src/decorator.js}

@@ -147,4 +147,3 @@ export class Decorator {
         }
     }
 }
-//# sourceMappingURL=decorator.js.map

package/dist/{encryptor.d.ts → src/encryptor.d.ts}

@@ -7,4 +7,3 @@ export declare class NoopEncryptor implements Encryptor {
     encrypt(plaintext: Value): Value;
     decrypt(ciphertext: Value): Value;
 }
-//# sourceMappingURL=encryptor.d.ts.map

package/dist/{encryptor.js → src/encryptor.js}

@@ -6,4 +6,3 @@ export class NoopEncryptor {
         return ciphertext;
     }
 }
-//# sourceMappingURL=encryptor.js.map

package/dist/{exceptions.d.ts → src/exceptions.d.ts}

@@ -36,4 +36,3 @@ declare const _default: {
     SERVER_ERROR: (m: any, r?: boolean, e?: ResonateServerError) => ResonateError;
 };
 export default _default;
-//# sourceMappingURL=exceptions.d.ts.map

package/dist/{exceptions.js → src/exceptions.js}

@@ -86,4 +86,3 @@ export default {
         return new ResonateError("99", "Server", m, { retriable: r, serverError: e });
     },
 };
-//# sourceMappingURL=exceptions.js.map

package/dist/{heartbeat.d.ts → src/heartbeat.d.ts}

@@ -21,4 +21,3 @@ export declare class NoopHeartbeat implements Heartbeat {
     start(): void;
     stop(): void;
 }
-//# sourceMappingURL=heartbeat.d.ts.map

package/dist/{heartbeat.js → src/heartbeat.js}

@@ -47,4 +47,3 @@ export class NoopHeartbeat {
     start() { }
     stop() { }
 }
-//# sourceMappingURL=heartbeat.js.map

package/dist/{index.d.ts → src/index.d.ts}

@@ -17,4 +17,3 @@ export { Resonate, type ResonateFunc, type ResonateHandle } from "./resonate.js"
 export { Constant, Exponential, Linear, Never, type RetryPolicy } from "./retries.js";
 export { awaitThenResumeOrSuspend, blockIsSole, dedupIsSole, type Event, exclusiveLifecycle, isWellFormed, rootSpawn, rpcHasCallee, runHasCallee, spawnIsFirst, type Trace, TraceCollector, terminalIsLast, uniqueSpawn, uniqueTerminal, } from "./trace.js";
 export type { Effects, Func } from "./types.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/{index.js → src/index.js}

@@ -13,4 +13,3 @@ export { Registry } from "./registry.js";
 export { Resonate } from "./resonate.js";
 export { Constant, Exponential, Linear, Never } from "./retries.js";
 export { awaitThenResumeOrSuspend, blockIsSole, dedupIsSole, exclusiveLifecycle, isWellFormed, rootSpawn, rpcHasCallee, runHasCallee, spawnIsFirst, TraceCollector, terminalIsLast, uniqueSpawn, uniqueTerminal, } from "./trace.js";
-//# sourceMappingURL=index.js.map

package/dist/{logger.d.ts → src/logger.d.ts}

@@ -30,4 +30,3 @@ export declare class ConsoleLogger implements Logger {
     private shouldLog;
     private emit;
 }
-//# sourceMappingURL=logger.d.ts.map

package/dist/{logger.js → src/logger.js}

@@ -51,4 +51,3 @@ export class ConsoleLogger {
         writer(JSON.stringify(entry));
     }
 }
-//# sourceMappingURL=logger.js.map

package/dist/{network → src/network}/http.d.ts

@@ -63,4 +63,3 @@ export declare class PollMessageSource implements HttpAdapter {
     stop(): Promise<void>;
     onReceive(callback: (msg: Message) => void): void;
 }
-//# sourceMappingURL=http.d.ts.map

package/dist/{network → src/network}/http.js

@@ -253,4 +253,3 @@ export class PollMessageSource {
         this.callbacks.push(callback);
     }
 }
-//# sourceMappingURL=http.js.map

package/dist/{network → src/network}/local.d.ts

@@ -185,4 +185,3 @@ export declare class LocalNetwork implements Network {
     recv(callback: (msg: Message) => void): void;
     private dispatchMessages;
 }
-//# sourceMappingURL=local.d.ts.map

package/dist/{network → src/network}/local.js

@@ -768,6 +768,15 @@ export class Server {
         return { response: this.response("schedule.get", 200, { schedule: this.toScheduleRecord(schedule) }), changes: [] };
     }
     scheduleCreate(now, req) {
+        // Mirror the server's create-time validation: every fired promise needs a
+        // routing target, so a schedule whose promiseTags lack resonate:target is
+        // rejected up front (same status and message as the real server).
+        if (!req.data.promiseTags || !("resonate:target" in req.data.promiseTags)) {
+            return {
+                response: this.response("schedule.create", 400, "promiseTags must include a resonate:target tag"),
+                changes: [],
+            };
+        }
         const existingSchedule = this.schedules.get(req.data.id);
         if (existingSchedule) {
             return {
@@ -1346,4 +1355,3 @@ export class LocalNetwork {
         }
     }
 }
-//# sourceMappingURL=local.js.map

package/dist/{network → src/network}/nats.d.ts

@@ -56,4 +56,3 @@ export declare class NatsNetwork implements Network {
     recv(callback: (msg: Message) => void): void;
     private onMsg;
 }
-//# sourceMappingURL=nats.d.ts.map

package/dist/{network → src/network}/nats.js

@@ -269,4 +269,3 @@ export class NatsNetwork {
         }
     }
 }
-//# sourceMappingURL=nats.js.map

package/dist/{network → src/network}/network.d.ts

@@ -14,4 +14,3 @@ export interface Network {
     send: Send;
     recv: Recv;
 }
-//# sourceMappingURL=network.d.ts.map

package/dist/src/network/network.js

@@ -0,0 +1 @@
+export {};

package/dist/src/network/postgres.d.ts

@@ -0,0 +1,49 @@
+import type { Logger } from "../logger.js";
+import type { Network } from "./network.js";
+import type { Message, Request, Response } from "./types.js";
+export interface PostgresNetworkConfig {
+    /** Postgres connection string (e.g. postgres://user:pass@host:5432/db). */
+    connectionString: string;
+    /** Worker group; a task targets the group (anycast). Default "default". */
+    group?: string;
+    /** This process's id; a callback/listener targets it (unicast). Defaults to a random id. */
+    pid?: string;
+    /** Fallback poll interval (ms) so timers still fire if a NOTIFY is missed. */
+    tickMs?: number;
+    logger?: Logger;
+}
+export declare class PostgresNetwork implements Network {
+    readonly unicast: string;
+    readonly anycast: string;
+    private readonly connectionString;
+    private readonly group;
+    private readonly pid;
+    private readonly tickMs;
+    private readonly logger?;
+    private poolPromise?;
+    private listenClient?;
+    private callbacks;
+    private timer?;
+    private draining;
+    private redrain;
+    private stopped;
+    constructor(cfg: PostgresNetworkConfig);
+    match(target: string): string;
+    private pg;
+    private getPool;
+    init(): Promise<void>;
+    stop(): Promise<void>;
+    send: <K extends Request["kind"]>(req: Extract<Request, {
+        kind: K;
+    }>) => Promise<Extract<Response, {
+        kind: K;
+    }>>;
+    recv(callback: (msg: Message) => void): void;
+    private deliver;
+    /** Fire due timers, then dequeue this node's outbox rows, delivering each. */
+    private drain;
+    /** Dequeue rows addressed to `address` in batches until the backlog is empty. */
+    private dequeue;
+    /** Fallback tick so timers and missed NOTIFYs still advance the pump. */
+    private scheduleNext;
+}

package/dist/src/network/postgres.js

@@ -0,0 +1,155 @@
+export class PostgresNetwork {
+    unicast;
+    anycast;
+    connectionString;
+    group;
+    pid;
+    tickMs;
+    logger;
+    // `pg` is loaded lazily (optional peer dependency); the pool is memoized so
+    // send() works even before init() resolves (the SDK does not await init()).
+    poolPromise;
+    listenClient;
+    callbacks = [];
+    timer;
+    draining = false;
+    redrain = false;
+    stopped = false;
+    constructor(cfg) {
+        this.connectionString = cfg.connectionString;
+        this.group = cfg.group ?? "default";
+        this.pid = cfg.pid ?? crypto.randomUUID().replace(/-/g, "");
+        this.tickMs = cfg.tickMs ?? 250;
+        this.logger = cfg.logger;
+        // A task targets the group (anycast); a callback/listener targets this
+        // specific process (unicast). The poll:// scheme mirrors the poll
+        // adapter's addressing and is what the schema accepts for listeners.
+        this.unicast = `poll://uni@${this.group}/${this.pid}`;
+        this.anycast = `poll://any@${this.group}`;
+    }
+    match(target) {
+        return `poll://any@${target}`;
+    }
+    async pg() {
+        const m = (await import("pg"));
+        const PoolCtor = (m.Pool ?? m.default?.Pool);
+        const ClientCtor = (m.Client ?? m.default?.Client);
+        return { Pool: PoolCtor, Client: ClientCtor };
+    }
+    getPool() {
+        if (!this.poolPromise) {
+            this.poolPromise = this.pg().then((pg) => new pg.Pool({ connectionString: this.connectionString, max: 8 }));
+        }
+        return this.poolPromise;
+    }
+    async init() {
+        const pool = await this.getPool();
+        // A dedicated connection held open for LISTEN; node-postgres surfaces
+        // notifications as 'notification' events. The schema NOTIFYs on a channel
+        // derived from each row's address, so listen on this node's addresses.
+        const pg = await this.pg();
+        this.listenClient = new pg.Client({ connectionString: this.connectionString });
+        await this.listenClient.connect();
+        this.listenClient.on("notification", () => void this.drain());
+        this.listenClient.on("error", (err) => this.logger?.warn({ component: "network", error: err.message }, "postgres listen error"));
+        for (const address of [this.unicast, this.anycast]) {
+            const { rows } = await pool.query("SELECT resonate.outbox_channel($1) AS channel", [address]);
+            await this.listenClient.query(`LISTEN "${rows[0].channel}"`);
+        }
+        this.scheduleNext();
+        await this.drain();
+        this.logger?.info({ component: "network", group: this.group, pid: this.pid }, "postgres network initialized");
+    }
+    async stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        try {
+            await this.listenClient?.end();
+        }
+        catch {
+            /* already closed */
+        }
+        try {
+            await (await this.poolPromise)?.end();
+        }
+        catch {
+            /* already closed */
+        }
+    }
+    send = async (req) => {
+        const pool = await this.getPool();
+        const { rows } = await pool.query("SELECT resonate.resonate_rpc($1::jsonb) AS res", [JSON.stringify(req)]);
+        return rows[0].res;
+    };
+    recv(callback) {
+        this.callbacks.push(callback);
+    }
+    // --- runtime pump ---------------------------------------------------------
+    deliver(msg) {
+        for (const cb of this.callbacks)
+            cb(msg);
+    }
+    /** Fire due timers, then dequeue this node's outbox rows, delivering each. */
+    async drain() {
+        if (this.stopped)
+            return;
+        if (this.draining) {
+            this.redrain = true; // coalesce concurrent wakes into one pass
+            return;
+        }
+        this.draining = true;
+        try {
+            const pool = await this.getPool();
+            // No-arg overload: timers fire on database time (clock_timestamp), so
+            // every node shares one time authority regardless of local clock skew,
+            // and concurrent calls from multiple nodes are safe (advisory locks,
+            // idempotent handlers).
+            await pool.query("SELECT resonate.process_timeouts()");
+            // Addressed, destructive dequeue (FOR UPDATE SKIP LOCKED): this node
+            // only consumes rows addressed to it, and same-group nodes split the
+            // anycast stream. Delivery is at-least-once: if we crash after
+            // dequeuing an execute row but before the task is claimed, the task
+            // stays pending and the server re-emits it on the task retry timeout
+            // (stale duplicates fail acquire with a 409, which the SDK tolerates).
+            // Execute rows target the task's target address (anycast by default);
+            // unblock rows target the listener's address (this node's unicast).
+            for (const address of [this.anycast, this.unicast]) {
+                await this.dequeue(pool, "SELECT task_id, version FROM resonate.dequeue_execute($1, $2)", address, (r) => this.deliver({ kind: "execute", head: {}, data: { task: { id: r.task_id, version: r.version } } }));
+            }
+            await this.dequeue(pool, "SELECT promise FROM resonate.dequeue_unblock($1, $2)", this.unicast, (r) => this.deliver({ kind: "unblock", head: {}, data: { promise: r.promise } }));
+        }
+        catch (err) {
+            if (!this.stopped) {
+                this.logger?.warn({ component: "network", error: err.message }, "postgres drain error");
+            }
+        }
+        finally {
+            this.draining = false;
+            if (this.redrain) {
+                this.redrain = false;
+                void this.drain();
+            }
+            this.scheduleNext();
+        }
+    }
+    /** Dequeue rows addressed to `address` in batches until the backlog is empty. */
+    async dequeue(pool, sql, address, deliver) {
+        const limit = 100;
+        while (true) {
+            const { rows } = await pool.query(sql, [address, limit]);
+            for (const r of rows)
+                deliver(r);
+            if (rows.length < limit)
+                return;
+        }
+    }
+    /** Fallback tick so timers and missed NOTIFYs still advance the pump. */
+    scheduleNext() {
+        if (this.stopped)
+            return;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = setTimeout(() => void this.drain(), this.tickMs);
+    }
+}

package/dist/{network → src/network}/types.d.ts

@@ -1277,4 +1277,3 @@ export declare function isScheduleRecord(val: unknown): val is ScheduleRecord;
 export declare function isExecuteMsg(val: unknown): val is ExecuteMsg;
 export declare function isUnblockMsg(val: unknown): val is UnblockMsg;
 export declare function isMessage(val: unknown): val is Message;
-//# sourceMappingURL=types.d.ts.map

package/dist/{network → src/network}/types.js

@@ -917,4 +917,3 @@ export function isUnblockMsg(val) {
 export function isMessage(val) {
     return isExecuteMsg(val) || isUnblockMsg(val);
 }
-//# sourceMappingURL=types.js.map

package/dist/{options.d.ts → src/options.d.ts}

@@ -42,4 +42,3 @@ export declare class Options {
         nonRetryableErrors?: Array<new (...args: any[]) => Error>;
     });
 }
-//# sourceMappingURL=options.d.ts.map

package/dist/{options.js → src/options.js}

@@ -31,4 +31,3 @@ export class Options {
         this.nonRetryableErrors = nonRetryableErrors;
     }
 }
-//# sourceMappingURL=options.js.map

package/dist/{platform.d.ts → src/platform.d.ts}

@@ -1,4 +1,3 @@
 export declare function randomUUID(): string;
 export declare function delay(ms: number): Promise<void>;
 export declare function getEnv(name: string): string | undefined;
-//# sourceMappingURL=platform.d.ts.map

package/dist/{platform.js → src/platform.js}

@@ -21,4 +21,3 @@ export function getEnv(name) {
         return undefined;
     return process.env[name];
 }
-//# sourceMappingURL=platform.js.map

package/dist/{promises.d.ts → src/promises.d.ts}

@@ -51,4 +51,3 @@ export declare class Promises {
         promise: PromiseRecord;
     }>;
 }
-//# sourceMappingURL=promises.d.ts.map

package/dist/{promises.js → src/promises.js}

@@ -119,4 +119,3 @@ export class Promises {
         return { promise: res.data.promise };
     }
 }
-//# sourceMappingURL=promises.js.map

package/dist/{registry.d.ts → src/registry.d.ts}

@@ -11,4 +11,3 @@ export declare class Registry {
     get(func: string | Func, version?: number): RegistryItem | undefined;
     private latest;
 }
-//# sourceMappingURL=registry.d.ts.map

package/dist/{registry.js → src/registry.js}

@@ -33,4 +33,3 @@ export class Registry {
         return Math.max(...(Object.keys(registry ?? {}).map(Number) || [1]));
     }
 }
-//# sourceMappingURL=registry.js.map

package/dist/{resonate.d.ts → src/resonate.d.ts}

@@ -165,4 +165,3 @@ export declare class Resonate {
     private subscribe;
     private notify;
 }
-//# sourceMappingURL=resonate.d.ts.map

package/dist/{resonate.js → src/resonate.js}

@@ -483,4 +483,3 @@ export class Resonate {
         }
     }
 }
-//# sourceMappingURL=resonate.js.map

package/dist/{retries.d.ts → src/retries.d.ts}

@@ -74,4 +74,3 @@ export declare class Never implements RetryPolicy {
         data: {};
     };
 }
-//# sourceMappingURL=retries.d.ts.map

package/dist/{retries.js → src/retries.js}

@@ -95,4 +95,3 @@ export class Never {
         };
     }
 }
-//# sourceMappingURL=retries.js.map

package/dist/{schedules.d.ts → src/schedules.d.ts}

@@ -19,4 +19,3 @@ export declare class Schedules {
     }): Promise<ScheduleRecord>;
     delete(id: string): Promise<undefined>;
 }
-//# sourceMappingURL=schedules.d.ts.map

package/dist/{schedules.js → src/schedules.js}

@@ -62,4 +62,3 @@ export class Schedules {
         return undefined;
     }
 }
-//# sourceMappingURL=schedules.js.map

package/dist/{trace.d.ts → src/trace.d.ts}

@@ -87,4 +87,3 @@ export declare function isWellFormed(t: Trace): boolean;
  * still be well-formed, only the await→resume/suspend pairing is dropped.
  */
 export declare function isWellFormedLifecycle(t: Trace): boolean;
-//# sourceMappingURL=trace.d.ts.map

package/dist/{trace.js → src/trace.js}

@@ -243,4 +243,3 @@ export function isWellFormedLifecycle(t) {
         rpcHasCallee(t) &&
         rootSpawn(t));
 }
-//# sourceMappingURL=trace.js.map

package/dist/{types.d.ts → src/types.d.ts}

@@ -18,4 +18,3 @@ export type Effects = {
     promiseCreate: (req: PromiseCreateReq, func?: string) => Promise<PromiseRecord>;
     promiseSettle: (req: PromiseSettleReq, func?: string) => Promise<PromiseRecord>;
 };
-//# sourceMappingURL=types.d.ts.map

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/{util.d.ts → src/util.d.ts}

@@ -25,4 +25,3 @@ export declare function buildEffects(send: Send, codec: Codec, fence: {
     id: string;
     version: number;
 }, preload?: PromiseRecord[]): Effects;
-//# sourceMappingURL=util.d.ts.map

package/dist/{util.js → src/util.js}

@@ -202,4 +202,3 @@ export function buildEffects(send, codec, fence, preload = []) {
         },
     };
 }
-//# sourceMappingURL=util.js.map