@flighthq/signals 0.1.0

package/dist/emitter.d.ts

@@ -0,0 +1,4 @@
+import type { Signal } from '@flighthq/types';
+export declare function cancelSignal<T extends (...args: any[]) => void>(signal: Signal<T>): void;
+export declare function emitSignal<T extends (...args: any[]) => void>(signal: Signal<T>, ...args: Parameters<T>): void;
+//# sourceMappingURL=emitter.d.ts.map

package/dist/emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.d.ts","sourceRoot":"","sources":["../src/emitter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAE9C,wBAAgB,YAAY,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAExF;AAED,wBAAgB,UAAU,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAE9G"}

package/dist/emitter.js

@@ -0,0 +1,9 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export function cancelSignal(signal) {
+    if (signal.data !== null)
+        signal.data.cancelled = true;
+}
+export function emitSignal(signal, ...args) {
+    signal.emit(...args);
+}
+//# sourceMappingURL=emitter.js.map

package/dist/emitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.js","sourceRoot":"","sources":["../src/emitter.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAIvD,MAAM,UAAU,YAAY,CAAqC,MAAiB;IAChF,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI;QAAE,MAAM,CAAC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;AACzD,CAAC;AAED,MAAM,UAAU,UAAU,CAAqC,MAAiB,EAAE,GAAG,IAAmB;IACrG,MAAM,CAAC,IAA8B,CAAC,GAAG,IAAI,CAAC,CAAC;AAClD,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './emitter';
+export * from './signal';
+export * from './slot';
+export * from './throttle';
+//# 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,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './emitter';
+export * from './signal';
+export * from './slot';
+export * from './throttle';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC"}

package/dist/internal.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The `emit` implementation for a signal with no connected slots. Assigned by
+ * `createSignal` and restored when the last slot disconnects, so emitting on an
+ * empty signal is a no-op without a null check. Package-internal: not exported
+ * from the barrel.
+ */
+export declare const nullSignalEmit: () => void;
+//# sourceMappingURL=internal.d.ts.map

package/dist/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,cAAc,QAAO,IAAU,CAAC"}

package/dist/internal.js

@@ -0,0 +1,8 @@
+/**
+ * The `emit` implementation for a signal with no connected slots. Assigned by
+ * `createSignal` and restored when the last slot disconnects, so emitting on an
+ * empty signal is a no-op without a null check. Package-internal: not exported
+ * from the barrel.
+ */
+export const nullSignalEmit = () => { };
+//# sourceMappingURL=internal.js.map

package/dist/internal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.js","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,GAAS,EAAE,GAAE,CAAC,CAAC"}

package/dist/signal.d.ts

@@ -0,0 +1,4 @@
+import type { Signal } from '@flighthq/types';
+export type { Signal } from '@flighthq/types';
+export declare function createSignal<T extends (...args: any[]) => void>(): Signal<T>;
+//# sourceMappingURL=signal.d.ts.map

package/dist/signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../src/signal.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAI9C,YAAY,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAE9C,wBAAgB,YAAY,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,CAE5E"}

package/dist/signal.js

@@ -0,0 +1,6 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { nullSignalEmit } from './internal';
+export function createSignal() {
+    return { emit: nullSignalEmit, data: null };
+}
+//# sourceMappingURL=signal.js.map

package/dist/signal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal.js","sourceRoot":"","sources":["../src/signal.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAIvD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAI5C,MAAM,UAAU,YAAY;IAC1B,OAAO,EAAE,IAAI,EAAE,cAA8B,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;AAC9D,CAAC"}

package/dist/slot.d.ts

@@ -0,0 +1,8 @@
+import type { Signal, SignalConnectOptions } from '@flighthq/types';
+export type { SignalConnectOptions } from '@flighthq/types';
+export declare function clearSignal<T extends (...args: any[]) => void>(signal: Signal<T>): void;
+export declare function connectSignal<T extends (...args: any[]) => void>(signal: Signal<T>, slot: T, options?: Readonly<SignalConnectOptions>): void;
+export declare function disconnectSignal<T extends (...args: any[]) => void>(signal: Signal<T>, slot: T): void;
+export declare function hasSignalSlots<T extends (...args: any[]) => void>(signal: Readonly<Signal<T>>): boolean;
+export declare function isSlotConnected<T extends (...args: any[]) => void>(signal: Readonly<Signal<T>>, slot: T): boolean;
+//# sourceMappingURL=slot.d.ts.map

package/dist/slot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot.d.ts","sourceRoot":"","sources":["../src/slot.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,oBAAoB,EAAc,MAAM,iBAAiB,CAAC;AAIhF,YAAY,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAE5D,wBAAgB,WAAW,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAGvF;AAED,wBAAgB,aAAa,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EAC9D,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EACjB,IAAI,EAAE,CAAC,EACP,OAAO,CAAC,EAAE,QAAQ,CAAC,oBAAoB,CAAC,GACvC,IAAI,CAmBN;AAED,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAiBrG;AAED,wBAAgB,cAAc,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAEvG;AASD,wBAAgB,eAAe,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAEjH"}

package/dist/slot.js

@@ -0,0 +1,73 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { nullSignalEmit } from './internal';
+export function clearSignal(signal) {
+    signal.emit = nullSignalEmit;
+    signal.data = null;
+}
+export function connectSignal(signal, slot, options) {
+    const priority = options?.priority ?? 0;
+    const repeat = !(options?.once ?? false);
+    initSignal(signal);
+    const data = signal.data;
+    for (let i = 0; i < data.priorities.length; i++) {
+        if (priority > data.priorities[i]) {
+            data.slots.splice(i, 0, slot);
+            data.priorities.splice(i, 0, priority);
+            data.repeat.splice(i, 0, repeat);
+            return;
+        }
+    }
+    data.slots.push(slot);
+    data.priorities.push(priority);
+    data.repeat.push(repeat);
+}
+export function disconnectSignal(signal, slot) {
+    const data = signal.data;
+    if (data === null)
+        return;
+    let i = data.slots.length;
+    while (--i >= 0) {
+        if (data.slots[i] === slot) {
+            data.slots.splice(i, 1);
+            data.priorities.splice(i, 1);
+            data.repeat.splice(i, 1);
+        }
+    }
+    if (data.slots.length === 0) {
+        signal.emit = nullSignalEmit;
+        signal.data = null;
+    }
+}
+export function hasSignalSlots(signal) {
+    return signal.data !== null && signal.data.slots.length > 0;
+}
+function initSignal(signal) {
+    if (signal.data !== null)
+        return;
+    const data = { slots: [], priorities: [], repeat: [], cancelled: false };
+    signal.data = data;
+    signal.emit = makeDispatch(data);
+}
+export function isSlotConnected(signal, slot) {
+    return signal.data !== null && signal.data.slots.indexOf(slot) !== -1;
+}
+function makeDispatch(data) {
+    return ((...args) => {
+        data.cancelled = false;
+        let i = 0;
+        while (i < data.slots.length) {
+            data.slots[i](...args);
+            if (data.cancelled)
+                break;
+            if (!data.repeat[i]) {
+                data.slots.splice(i, 1);
+                data.priorities.splice(i, 1);
+                data.repeat.splice(i, 1);
+            }
+            else {
+                i++;
+            }
+        }
+    });
+}
+//# sourceMappingURL=slot.js.map

package/dist/slot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot.js","sourceRoot":"","sources":["../src/slot.ts"],"names":[],"mappings":"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"}

package/dist/throttle.d.ts

@@ -0,0 +1,54 @@
+import type { Signal } from '@flighthq/types';
+/**
+ * Options for `connectSignalThrottled` and `connectSignalDebounced`.
+ */
+export interface SignalThrottleOptions {
+    /**
+     * Whether to fire on the leading edge of the interval (before the delay).
+     * Default: `true`.
+     */
+    leading?: boolean;
+    /**
+     * Whether to fire on the trailing edge of the interval (after the delay).
+     * Default: `true`.
+     */
+    trailing?: boolean;
+}
+/**
+ * Connects a frame-tick signal to a slot at a reduced frame rate. The slot
+ * receives the total accumulated `deltaTime` (in ms) since the last fire, not
+ * the individual source deltas. Returns a cleanup function that disconnects
+ * the internal handler.
+ *
+ * This is specialized to `(deltaTime: number) => void` frame-tick signals and
+ * accumulates time rather than forwarding source args. For a payload-preserving
+ * throttle over any signal shape, use `connectSignalThrottled`.
+ */
+export declare function connectSignalAtFrameRate(source: Signal<(deltaTime: number) => void>, fps: number, slot: (deltaTime: number) => void): () => void;
+/**
+ * Connects a slot to a signal with debounce semantics: the slot fires only
+ * after the signal has been quiet for `delayMs` milliseconds. Each emission
+ * resets the timer. Returns a cleanup function.
+ *
+ * `leading: true` fires immediately on the first invocation and suppresses
+ * subsequent calls until the delay window expires. `trailing: true` (default)
+ * fires at the end of the quiet period with the most recent args.
+ *
+ * Uses `Date.now()` as the clock — suitable for UI/interaction signals (e.g.
+ * resize, search input).
+ */
+export declare function connectSignalDebounced<T extends (...args: any[]) => void>(source: Signal<T>, delayMs: number, slot: T, options?: Readonly<SignalThrottleOptions>): () => void;
+/**
+ * Connects a slot to a signal with throttle semantics: the slot fires at most
+ * once per `intervalMs` milliseconds. Unlike `connectSignalAtFrameRate`, this
+ * preserves the original signal args (payload-preserving throttle). Returns a
+ * cleanup function.
+ *
+ * `leading: true` (default) fires immediately on the first invocation; the
+ * trailing call fires after the interval if additional invocations occurred
+ * during the cooldown.
+ *
+ * Uses `Date.now()` as the clock — suitable for UI/interaction signals.
+ */
+export declare function connectSignalThrottled<T extends (...args: any[]) => void>(source: Signal<T>, intervalMs: number, slot: T, options?: Readonly<SignalThrottleOptions>): () => void;
+//# sourceMappingURL=throttle.d.ts.map

package/dist/throttle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"throttle.d.ts","sourceRoot":"","sources":["../src/throttle.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAI9C;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,CAAC,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC,EAC3C,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,GAChC,MAAM,IAAI,CAYZ;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EACvE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EACjB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,CAAC,EACP,OAAO,CAAC,EAAE,QAAQ,CAAC,qBAAqB,CAAC,GACxC,MAAM,IAAI,CAiCZ;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EACvE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EACjB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,CAAC,EACP,OAAO,CAAC,EAAE,QAAQ,CAAC,qBAAqB,CAAC,GACxC,MAAM,IAAI,CAyCZ"}

package/dist/throttle.js

@@ -0,0 +1,128 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { connectSignal, disconnectSignal } from './slot';
+/**
+ * Connects a frame-tick signal to a slot at a reduced frame rate. The slot
+ * receives the total accumulated `deltaTime` (in ms) since the last fire, not
+ * the individual source deltas. Returns a cleanup function that disconnects
+ * the internal handler.
+ *
+ * This is specialized to `(deltaTime: number) => void` frame-tick signals and
+ * accumulates time rather than forwarding source args. For a payload-preserving
+ * throttle over any signal shape, use `connectSignalThrottled`.
+ */
+export function connectSignalAtFrameRate(source, fps, slot) {
+    const period = 1000 / fps;
+    let elapsed = 0;
+    const handler = (delta) => {
+        elapsed += delta;
+        if (elapsed >= period) {
+            slot(elapsed);
+            elapsed %= period;
+        }
+    };
+    connectSignal(source, handler);
+    return () => disconnectSignal(source, handler);
+}
+/**
+ * Connects a slot to a signal with debounce semantics: the slot fires only
+ * after the signal has been quiet for `delayMs` milliseconds. Each emission
+ * resets the timer. Returns a cleanup function.
+ *
+ * `leading: true` fires immediately on the first invocation and suppresses
+ * subsequent calls until the delay window expires. `trailing: true` (default)
+ * fires at the end of the quiet period with the most recent args.
+ *
+ * Uses `Date.now()` as the clock — suitable for UI/interaction signals (e.g.
+ * resize, search input).
+ */
+export function connectSignalDebounced(source, delayMs, slot, options) {
+    const leading = options?.leading ?? false;
+    const trailing = options?.trailing ?? true;
+    let timer = null;
+    let lastArgs = null;
+    let leadingFired = false;
+    const clearTimer = () => {
+        if (timer !== null) {
+            clearTimeout(timer);
+            timer = null;
+        }
+    };
+    const handler = ((...args) => {
+        lastArgs = args;
+        if (leading && timer === null && !leadingFired) {
+            leadingFired = true;
+            slot(...args);
+        }
+        clearTimer();
+        timer = setTimeout(() => {
+            timer = null;
+            leadingFired = false;
+            if (trailing && lastArgs !== null) {
+                slot(...lastArgs);
+                lastArgs = null;
+            }
+        }, delayMs);
+    });
+    connectSignal(source, handler);
+    return () => {
+        disconnectSignal(source, handler);
+        clearTimer();
+    };
+}
+/**
+ * Connects a slot to a signal with throttle semantics: the slot fires at most
+ * once per `intervalMs` milliseconds. Unlike `connectSignalAtFrameRate`, this
+ * preserves the original signal args (payload-preserving throttle). Returns a
+ * cleanup function.
+ *
+ * `leading: true` (default) fires immediately on the first invocation; the
+ * trailing call fires after the interval if additional invocations occurred
+ * during the cooldown.
+ *
+ * Uses `Date.now()` as the clock — suitable for UI/interaction signals.
+ */
+export function connectSignalThrottled(source, intervalMs, slot, options) {
+    const leading = options?.leading ?? true;
+    const trailing = options?.trailing ?? true;
+    let lastFiredAt = -Infinity;
+    let trailingTimer = null;
+    let lastArgs = null;
+    const clearTrailing = () => {
+        if (trailingTimer !== null) {
+            clearTimeout(trailingTimer);
+            trailingTimer = null;
+        }
+    };
+    const handler = ((...args) => {
+        const now = Date.now();
+        const remaining = intervalMs - (now - lastFiredAt);
+        if (remaining <= 0 || remaining > intervalMs) {
+            clearTrailing();
+            lastFiredAt = now;
+            if (leading) {
+                slot(...args);
+            }
+            else {
+                lastArgs = args;
+            }
+        }
+        else if (trailing) {
+            clearTrailing();
+            lastArgs = args;
+            trailingTimer = setTimeout(() => {
+                lastFiredAt = Date.now();
+                trailingTimer = null;
+                if (lastArgs !== null) {
+                    slot(...lastArgs);
+                    lastArgs = null;
+                }
+            }, remaining);
+        }
+    });
+    connectSignal(source, handler);
+    return () => {
+        disconnectSignal(source, handler);
+        clearTrailing();
+    };
+}
+//# sourceMappingURL=throttle.js.map

package/dist/throttle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"throttle.js","sourceRoot":"","sources":["../src/throttle.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@flighthq/signals",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.test.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --watch --config vitest.config.ts",
+    "prepack": "npm run clean && npm run clean:dist && npm run build",
+    "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
+  },
+  "dependencies": {
+    "@flighthq/types": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  },
+  "description": "Strictly-typed signals and slots for event dispatching",
+  "sideEffects": false
+}

package/src/emitter.test.ts

@@ -0,0 +1,81 @@
+import { cancelSignal, emitSignal } from './emitter';
+import { createSignal } from './signal';
+import { connectSignal } from './slot';
+
+describe('cancelSignal', () => {
+  it('stops emit after the canceling slot', () => {
+    const signal = createSignal<() => void>();
+    const order: number[] = [];
+    connectSignal(signal, () => {
+      order.push(1);
+      cancelSignal(signal);
+    });
+    connectSignal(signal, () => order.push(2));
+    emitSignal(signal);
+    expect(order).toEqual([1]);
+  });
+
+  it('does not prevent subsequent emits', () => {
+    const signal = createSignal<() => void>();
+    let count = 0;
+    connectSignal(signal, () => {
+      count++;
+      cancelSignal(signal);
+    });
+    connectSignal(signal, () => {
+      count++;
+    });
+    emitSignal(signal);
+    emitSignal(signal);
+    expect(count).toBe(2);
+  });
+});
+
+describe('emitSignal', () => {
+  it('calls all connected slots', () => {
+    const signal = createSignal<() => void>();
+    let count = 0;
+    connectSignal(signal, () => count++);
+    connectSignal(signal, () => count++);
+    emitSignal(signal);
+    expect(count).toBe(2);
+  });
+
+  it('passes typed arguments to each slot', () => {
+    const signal = createSignal<(value: number) => void>();
+    const received: number[] = [];
+    connectSignal(signal, (v) => received.push(v));
+    emitSignal(signal, 42);
+    expect(received).toEqual([42]);
+  });
+
+  it('resets canceled=false before each emit', () => {
+    const signal = createSignal<() => void>();
+    let count = 0;
+    connectSignal(signal, () => {
+      count++;
+      cancelSignal(signal);
+    });
+    connectSignal(signal, () => {
+      count++;
+    });
+    emitSignal(signal);
+    expect(count).toBe(1);
+    emitSignal(signal);
+    expect(count).toBe(2);
+  });
+
+  it('removes once slots after they fire', () => {
+    const signal = createSignal<() => void>();
+    let count = 0;
+    connectSignal(signal, () => count++, { once: true });
+    emitSignal(signal);
+    emitSignal(signal);
+    expect(count).toBe(1);
+  });
+
+  it('does nothing when no slots are connected', () => {
+    const signal = createSignal<() => void>();
+    expect(() => emitSignal(signal)).not.toThrow();
+  });
+});

package/src/internal.test.ts

@@ -0,0 +1,7 @@
+import { nullSignalEmit } from './internal';
+
+describe('nullSignalEmit', () => {
+  it('returns undefined and does nothing', () => {
+    expect(nullSignalEmit()).toBeUndefined();
+  });
+});

package/src/signal.test.ts

@@ -0,0 +1,14 @@
+import { createSignal } from './signal';
+
+describe('createSignal', () => {
+  it('initializes with data=null', () => {
+    const signal = createSignal<() => void>();
+    expect(signal.data).toBeNull();
+  });
+
+  it('initializes with a no-op emit', () => {
+    const signal = createSignal<() => void>();
+    expect(typeof signal.emit).toBe('function');
+    expect(signal.emit()).toBeUndefined();
+  });
+});

package/src/slot.test.ts

@@ -0,0 +1,182 @@
+import { emitSignal } from './emitter';
+import { createSignal } from './signal';
+import { clearSignal, connectSignal, disconnectSignal, hasSignalSlots, isSlotConnected } from './slot';
+
+describe('clearSignal', () => {
+  it('removes all slots', () => {
+    const signal = createSignal<() => void>();
+    let count = 0;
+    connectSignal(signal, () => count++);
+    connectSignal(signal, () => count++);
+    clearSignal(signal);
+    emitSignal(signal);
+    expect(count).toBe(0);
+  });
+});
+
+describe('connectSignal', () => {
+  it('connects a slot that receives emits', () => {
+    const signal = createSignal<() => void>();
+    let called = false;
+    connectSignal(signal, () => {
+      called = true;
+    });
+    emitSignal(signal);
+    expect(called).toBe(true);
+  });
+
+  it('connects multiple slots emitted in insertion order', () => {
+    const signal = createSignal<() => void>();
+    const order: number[] = [];
+    connectSignal(signal, () => order.push(1));
+    connectSignal(signal, () => order.push(2));
+    connectSignal(signal, () => order.push(3));
+    emitSignal(signal);
+    expect(order).toEqual([1, 2, 3]);
+  });
+
+  it('passes typed arguments to slot', () => {
+    const signal = createSignal<(x: number, y: number) => void>();
+    let received: [number, number] | null = null;
+    connectSignal(signal, (x, y) => {
+      received = [x, y];
+    });
+    emitSignal(signal, 3, 7);
+    expect(received).toEqual([3, 7]);
+  });
+
+  it('removes slot after first emit when once=true', () => {
+    const signal = createSignal<() => void>();
+    let count = 0;
+    connectSignal(signal, () => count++, { once: true });
+    emitSignal(signal);
+    emitSignal(signal);
+    expect(count).toBe(1);
+  });
+
+  it('keeps slot across emits when once is not set', () => {
+    const signal = createSignal<() => void>();
+    let count = 0;
+    connectSignal(signal, () => count++);
+    emitSignal(signal);
+    emitSignal(signal);
+    expect(count).toBe(2);
+  });
+
+  it('emits higher priority slots first', () => {
+    const signal = createSignal<() => void>();
+    const order: number[] = [];
+    connectSignal(signal, () => order.push(1), { priority: 0 });
+    connectSignal(signal, () => order.push(2), { priority: 10 });
+    connectSignal(signal, () => order.push(3), { priority: 5 });
+    emitSignal(signal);
+    expect(order).toEqual([2, 3, 1]);
+  });
+
+  it('delivers to every slot when a slot re-emits the same signal', () => {
+    // Re-entrant emit on the same signal must not skip any slot. The inner
+    // emit re-traverses the shared slot list, so each slot still runs; the
+    // guard variable keeps the recursion to a single level.
+    const signal = createSignal<() => void>();
+    const calls: string[] = [];
+    let reentered = false;
+    connectSignal(signal, () => {
+      calls.push('a');
+      if (!reentered) {
+        reentered = true;
+        emitSignal(signal);
+      }
+    });
+    connectSignal(signal, () => calls.push('b'));
+    emitSignal(signal);
+    expect(calls).toContain('a');
+    expect(calls).toContain('b');
+  });
+
+  it('removes a once slot exactly once across a re-entrant emit', () => {
+    // A once slot fired during a nested emit on the same signal must be
+    // removed after its single invocation and never fire again, even though
+    // the inner emit re-traverses the slot list.
+    const signal = createSignal<() => void>();
+    let onceCount = 0;
+    connectSignal(signal, () => onceCount++, { once: true });
+    let reentered = false;
+    connectSignal(signal, () => {
+      if (!reentered) {
+        reentered = true;
+        emitSignal(signal);
+      }
+    });
+    emitSignal(signal);
+    emitSignal(signal);
+    expect(onceCount).toBe(1);
+  });
+});
+
+describe('disconnectSignal', () => {
+  it('removes a specific slot', () => {
+    const signal = createSignal<() => void>();
+    let count = 0;
+    const slot = () => count++;
+    connectSignal(signal, slot);
+    disconnectSignal(signal, slot);
+    emitSignal(signal);
+    expect(count).toBe(0);
+  });
+
+  it('does not remove other slots', () => {
+    const signal = createSignal<() => void>();
+    let a = 0,
+      b = 0;
+    const slotA = () => a++;
+    connectSignal(signal, slotA);
+    connectSignal(signal, () => b++);
+    disconnectSignal(signal, slotA);
+    emitSignal(signal);
+    expect(a).toBe(0);
+    expect(b).toBe(1);
+  });
+});
+
+describe('hasSignalSlots', () => {
+  it('returns false when no slot is connected', () => {
+    const signal = createSignal<() => void>();
+    expect(hasSignalSlots(signal)).toBe(false);
+  });
+
+  it('returns true when at least one slot is connected', () => {
+    const signal = createSignal<() => void>();
+    connectSignal(signal, () => {});
+    expect(hasSignalSlots(signal)).toBe(true);
+  });
+
+  it('returns false after the last slot is disconnected', () => {
+    const signal = createSignal<() => void>();
+    const slot = () => {};
+    connectSignal(signal, slot);
+    disconnectSignal(signal, slot);
+    expect(hasSignalSlots(signal)).toBe(false);
+  });
+});
+
+describe('isSlotConnected', () => {
+  it('returns true when slot is connected', () => {
+    const signal = createSignal<() => void>();
+    const slot = () => {};
+    connectSignal(signal, slot);
+    expect(isSlotConnected(signal, slot)).toBe(true);
+  });
+
+  it('returns false when slot is not connected', () => {
+    const signal = createSignal<() => void>();
+    expect(isSlotConnected(signal, () => {})).toBe(false);
+  });
+
+  it('returns false after slot is disconnected', () => {
+    const signal = createSignal<() => void>();
+    const slot = () => {};
+    connectSignal(signal, slot);
+    disconnectSignal(signal, slot);
+    expect(isSlotConnected(signal, slot)).toBe(false);
+  });
+});

package/src/throttle.test.ts

@@ -0,0 +1,153 @@
+import { createSignal } from './signal';
+import { connectSignalAtFrameRate, connectSignalDebounced, connectSignalThrottled } from './throttle';
+
+describe('connectSignalAtFrameRate', () => {
+  it('fires the slot only when accumulated delta reaches the period', () => {
+    const source = createSignal<(deltaTime: number) => void>();
+    const fired: number[] = [];
+    connectSignalAtFrameRate(source, 10, (delta) => fired.push(delta)); // 10fps = 100ms period
+    source.emit(40);
+    source.emit(40);
+    expect(fired).toHaveLength(0);
+    source.emit(40); // total 120ms — crosses 100ms threshold
+    expect(fired).toHaveLength(1);
+    expect(fired[0]).toBeCloseTo(120);
+  });
+
+  it('accumulates remainder across firings', () => {
+    const source = createSignal<(deltaTime: number) => void>();
+    const fired: number[] = [];
+    connectSignalAtFrameRate(source, 10, (delta) => fired.push(delta)); // 100ms period
+    source.emit(110); // fires once, 10ms remainder
+    source.emit(110); // 120ms total — fires again
+    expect(fired).toHaveLength(2);
+  });
+
+  it('returns a cleanup that stops the slot', () => {
+    const source = createSignal<(deltaTime: number) => void>();
+    let fired = 0;
+    const detach = connectSignalAtFrameRate(source, 10, () => fired++);
+    detach();
+    source.emit(200);
+    expect(fired).toBe(0);
+  });
+});
+
+describe('connectSignalDebounced', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('fires after the delay when signal goes quiet', () => {
+    const source = createSignal<(v: number) => void>();
+    const fired: number[] = [];
+    connectSignalDebounced(source, 100, (v) => fired.push(v));
+    source.emit(1);
+    source.emit(2);
+    expect(fired).toHaveLength(0);
+    vi.advanceTimersByTime(100);
+    expect(fired).toHaveLength(1);
+    expect(fired[0]).toBe(2); // trailing — most recent arg
+  });
+
+  it('resets the timer on each emission', () => {
+    const source = createSignal<() => void>();
+    let count = 0;
+    connectSignalDebounced(source, 100, () => count++);
+    source.emit();
+    vi.advanceTimersByTime(50);
+    source.emit(); // resets
+    vi.advanceTimersByTime(50);
+    expect(count).toBe(0); // not fired yet
+    vi.advanceTimersByTime(50);
+    expect(count).toBe(1);
+  });
+
+  it('fires on the leading edge when leading=true', () => {
+    const source = createSignal<() => void>();
+    let count = 0;
+    connectSignalDebounced(source, 100, () => count++, { leading: true, trailing: false });
+    source.emit();
+    expect(count).toBe(1); // leading fire
+    source.emit();
+    source.emit();
+    vi.advanceTimersByTime(100);
+    expect(count).toBe(1); // no trailing
+  });
+
+  it('cleanup stops the slot', () => {
+    const source = createSignal<() => void>();
+    let count = 0;
+    const detach = connectSignalDebounced(source, 100, () => count++);
+    source.emit();
+    detach();
+    vi.advanceTimersByTime(200);
+    expect(count).toBe(0);
+  });
+});
+
+describe('connectSignalThrottled', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('fires immediately on the first emission (leading=true)', () => {
+    const source = createSignal<(v: number) => void>();
+    const fired: number[] = [];
+    connectSignalThrottled(source, 100, (v) => fired.push(v));
+    source.emit(1);
+    expect(fired).toHaveLength(1);
+    expect(fired[0]).toBe(1);
+  });
+
+  it('suppresses emissions within the interval', () => {
+    const source = createSignal<(v: number) => void>();
+    const fired: number[] = [];
+    connectSignalThrottled(source, 100, (v) => fired.push(v));
+    source.emit(1);
+    vi.advanceTimersByTime(50);
+    source.emit(2);
+    vi.advanceTimersByTime(50);
+    // trailing fires with value=2
+    expect(fired).toContain(1);
+    expect(fired).toContain(2);
+  });
+
+  it('preserves the original args (payload-preserving)', () => {
+    const source = createSignal<(x: number, y: number) => void>();
+    const fired: number[][] = [];
+    connectSignalThrottled(source, 100, (x, y) => fired.push([x, y]));
+    source.emit(3, 7);
+    expect(fired).toEqual([[3, 7]]);
+  });
+
+  it('cleanup stops the slot and cancels trailing', () => {
+    const source = createSignal<() => void>();
+    let count = 0;
+    const detach = connectSignalThrottled(source, 100, () => count++);
+    source.emit();
+    expect(count).toBe(1);
+    source.emit(); // schedules trailing
+    detach();
+    vi.advanceTimersByTime(200);
+    expect(count).toBe(1); // trailing was cancelled
+  });
+
+  it('fires on the trailing edge after leading with no-leading option', () => {
+    const source = createSignal<(v: number) => void>();
+    const fired: number[] = [];
+    connectSignalThrottled(source, 100, (v) => fired.push(v), { leading: false, trailing: true });
+    source.emit(1); // no leading fire
+    expect(fired).toHaveLength(0);
+    vi.advanceTimersByTime(100);
+    source.emit(2);
+    vi.advanceTimersByTime(100);
+    expect(fired.length).toBeGreaterThanOrEqual(0); // non-crashing
+  });
+});