@flighthq/clock 0.1.0

package/dist/addClockChild.d.ts

@@ -0,0 +1,4 @@
+import type { Clock } from '@flighthq/types';
+export declare function addClockChild(parent: Clock, child: Clock): void;
+export declare function removeClockChild(parent: Clock, child: Clock): void;
+//# sourceMappingURL=addClockChild.d.ts.map

package/dist/addClockChild.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addClockChild.d.ts","sourceRoot":"","sources":["../src/addClockChild.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAI7C,wBAAgB,aAAa,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAK/D;AAID,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAKlE"}

package/dist/addClockChild.js

@@ -0,0 +1,20 @@
+// Attaches `child` under `parent`, detaching it from any previous parent first (reparent-safe). After
+// this, advancing `parent` cascades into `child`. A no-op if `child` is already parented here.
+export function addClockChild(parent, child) {
+    if (child.parent === parent)
+        return;
+    if (child.parent !== null)
+        removeClockChild(child.parent, child);
+    child.parent = parent;
+    parent.children.push(child);
+}
+// Detaches `child` from `parent`, making it a root clock again. A no-op if `child` is not a child of
+// `parent`.
+export function removeClockChild(parent, child) {
+    const index = parent.children.indexOf(child);
+    if (index === -1)
+        return;
+    parent.children.splice(index, 1);
+    child.parent = null;
+}
+//# sourceMappingURL=addClockChild.js.map

package/dist/addClockChild.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"addClockChild.js","sourceRoot":"","sources":["../src/addClockChild.ts"],"names":[],"mappings":"AAEA,sGAAsG;AACtG,+FAA+F;AAC/F,MAAM,UAAU,aAAa,CAAC,MAAa,EAAE,KAAY;IACvD,IAAI,KAAK,CAAC,MAAM,KAAK,MAAM;QAAE,OAAO;IACpC,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI;QAAE,gBAAgB,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACjE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC;IACtB,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC9B,CAAC;AAED,qGAAqG;AACrG,YAAY;AACZ,MAAM,UAAU,gBAAgB,CAAC,MAAa,EAAE,KAAY;IAC1D,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAC7C,IAAI,KAAK,KAAK,CAAC,CAAC;QAAE,OAAO;IACzB,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IACjC,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC;AACtB,CAAC"}

package/dist/advanceClock.d.ts

@@ -0,0 +1,3 @@
+import type { Clock } from '@flighthq/types';
+export declare function advanceClock(clock: Clock, deltaSeconds: number): void;
+//# sourceMappingURL=advanceClock.d.ts.map

package/dist/advanceClock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advanceClock.d.ts","sourceRoot":"","sources":["../src/advanceClock.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAQ7C,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CASrE"}

package/dist/advanceClock.js

@@ -0,0 +1,19 @@
+import { emitSignal } from '@flighthq/signals';
+// Advances a clock tree by one step. `deltaSeconds` is the real elapsed seconds for a root clock (the
+// value the frame loop supplies); the cascade feeds each child its parent's already-scaled delta. Each
+// clock's scaled delta is `paused ? 0 : deltaSeconds * scale`; that becomes its deltaTime, accumulates
+// into elapsed, emits its (opt-in) onTick, and drives its children — so scale and pause compose down the
+// whole subtree in one pass. Pre-order: a clock's onTick fires before its children advance. Call once per
+// frame on the root: advanceClock(root, dtSeconds).
+export function advanceClock(clock, deltaSeconds) {
+    const scaledDelta = clock.paused ? 0 : deltaSeconds * clock.scale;
+    clock.deltaTime = scaledDelta;
+    clock.elapsed += scaledDelta;
+    if (clock.onTick !== null)
+        emitSignal(clock.onTick, scaledDelta);
+    const children = clock.children;
+    for (let i = 0; i < children.length; i++) {
+        advanceClock(children[i], scaledDelta);
+    }
+}
+//# sourceMappingURL=advanceClock.js.map

package/dist/advanceClock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"advanceClock.js","sourceRoot":"","sources":["../src/advanceClock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAG/C,sGAAsG;AACtG,uGAAuG;AACvG,uGAAuG;AACvG,yGAAyG;AACzG,0GAA0G;AAC1G,oDAAoD;AACpD,MAAM,UAAU,YAAY,CAAC,KAAY,EAAE,YAAoB;IAC7D,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,YAAY,GAAG,KAAK,CAAC,KAAK,CAAC;IAClE,KAAK,CAAC,SAAS,GAAG,WAAW,CAAC;IAC9B,KAAK,CAAC,OAAO,IAAI,WAAW,CAAC;IAC7B,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI;QAAE,UAAU,CAAC,KAAK,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACjE,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;IAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACzC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC;IACzC,CAAC;AACH,CAAC"}

package/dist/createClock.d.ts

@@ -0,0 +1,4 @@
+import type { Clock, ClockOptions } from '@flighthq/types';
+export declare function createChildClock(parent: Clock, options?: Readonly<ClockOptions>): Clock;
+export declare function createClock(options?: Readonly<ClockOptions>): Clock;
+//# sourceMappingURL=createClock.d.ts.map

package/dist/createClock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createClock.d.ts","sourceRoot":"","sources":["../src/createClock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAM3D,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,KAAK,CAIvF;AAID,wBAAgB,WAAW,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,KAAK,CAUnE"}

package/dist/createClock.js

@@ -0,0 +1,22 @@
+import { addClockChild } from './addClockChild';
+// Allocates a child clock and attaches it to `parent` in one step. Equivalent to createClock followed by
+// addClockChild; the child inherits `parent`'s scale and pause state through the advanceClock cascade.
+export function createChildClock(parent, options) {
+    const child = createClock(options);
+    addClockChild(parent, child);
+    return child;
+}
+// Allocates a root clock (no parent). Defaults to realtime and running; pass options to start scaled or
+// paused. Drive it each frame with advanceClock(clock, dtSeconds).
+export function createClock(options) {
+    return {
+        scale: options?.scale ?? 1,
+        paused: options?.paused ?? false,
+        deltaTime: 0,
+        elapsed: 0,
+        parent: null,
+        children: [],
+        onTick: null,
+    };
+}
+//# sourceMappingURL=createClock.js.map

package/dist/createClock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createClock.js","sourceRoot":"","sources":["../src/createClock.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,yGAAyG;AACzG,uGAAuG;AACvG,MAAM,UAAU,gBAAgB,CAAC,MAAa,EAAE,OAAgC;IAC9E,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;IACnC,aAAa,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC7B,OAAO,KAAK,CAAC;AACf,CAAC;AAED,wGAAwG;AACxG,mEAAmE;AACnE,MAAM,UAAU,WAAW,CAAC,OAAgC;IAC1D,OAAO;QACL,KAAK,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;QAC1B,MAAM,EAAE,OAAO,EAAE,MAAM,IAAI,KAAK;QAChC,SAAS,EAAE,CAAC;QACZ,OAAO,EAAE,CAAC;QACV,MAAM,EAAE,IAAI;QACZ,QAAQ,EAAE,EAAE;QACZ,MAAM,EAAE,IAAI;KACb,CAAC;AACJ,CAAC"}

package/dist/disposeClock.d.ts

@@ -0,0 +1,3 @@
+import type { Clock } from '@flighthq/types';
+export declare function disposeClock(clock: Clock): void;
+//# sourceMappingURL=disposeClock.d.ts.map

package/dist/disposeClock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disposeClock.d.ts","sourceRoot":"","sources":["../src/disposeClock.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAQ7C,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAQ/C"}

package/dist/disposeClock.js

@@ -0,0 +1,18 @@
+import { clearSignal } from '@flighthq/signals';
+import { removeClockChild } from './addClockChild';
+// Detaches a clock from its parent, releases its children, and drops any onTick listeners so nothing
+// keeps the subtree — or the clock's subscribers — reachable through it: the parent no longer references
+// this clock, each child becomes a root, and the onTick slot list is cleared. The clock is then plain
+// GC-managed memory (there is no GPU or native resource to free — that would be destroy*).
+export function disposeClock(clock) {
+    if (clock.parent !== null)
+        removeClockChild(clock.parent, clock);
+    const children = clock.children;
+    for (let i = 0; i < children.length; i++) {
+        children[i].parent = null;
+    }
+    children.length = 0;
+    if (clock.onTick !== null)
+        clearSignal(clock.onTick);
+}
+//# sourceMappingURL=disposeClock.js.map

package/dist/disposeClock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"disposeClock.js","sourceRoot":"","sources":["../src/disposeClock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEnD,qGAAqG;AACrG,yGAAyG;AACzG,sGAAsG;AACtG,2FAA2F;AAC3F,MAAM,UAAU,YAAY,CAAC,KAAY;IACvC,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI;QAAE,gBAAgB,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACjE,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;IAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACzC,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC;IAC5B,CAAC;IACD,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;IACpB,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI;QAAE,WAAW,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;AACvD,CAAC"}

package/dist/enableClockSignals.d.ts

@@ -0,0 +1,3 @@
+import type { Clock, Signal } from '@flighthq/types';
+export declare function enableClockSignals(clock: Clock): Signal<(deltaTime: number) => void>;
+//# sourceMappingURL=enableClockSignals.d.ts.map

package/dist/enableClockSignals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enableClockSignals.d.ts","sourceRoot":"","sources":["../src/enableClockSignals.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAMrD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC,CAKpF"}

package/dist/enableClockSignals.js

@@ -0,0 +1,12 @@
+import { createSignal } from '@flighthq/signals';
+// Opts the clock into the onTick signal, allocating it on first call and returning it (idempotent — a
+// second call returns the same signal). onTick emits the clock's scaled deltaTime on every advance, so it
+// plugs straight into signals' rate helpers, e.g. connectSignalAtFrameRate(clock.onTick, 30, slot). Bare
+// clocks that never call this keep onTick null and pay no signal allocation or dispatch cost.
+export function enableClockSignals(clock) {
+    if (clock.onTick === null) {
+        clock.onTick = createSignal();
+    }
+    return clock.onTick;
+}
+//# sourceMappingURL=enableClockSignals.js.map

package/dist/enableClockSignals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enableClockSignals.js","sourceRoot":"","sources":["../src/enableClockSignals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGjD,sGAAsG;AACtG,0GAA0G;AAC1G,yGAAyG;AACzG,8FAA8F;AAC9F,MAAM,UAAU,kBAAkB,CAAC,KAAY;IAC7C,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI,EAAE,CAAC;QAC1B,KAAK,CAAC,MAAM,GAAG,YAAY,EAA+B,CAAC;IAC7D,CAAC;IACD,OAAO,KAAK,CAAC,MAAM,CAAC;AACtB,CAAC"}

package/dist/getClockEffectiveScale.d.ts

@@ -0,0 +1,3 @@
+import type { Clock } from '@flighthq/types';
+export declare function getClockEffectiveScale(clock: Readonly<Clock>): number;
+//# sourceMappingURL=getClockEffectiveScale.d.ts.map

package/dist/getClockEffectiveScale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getClockEffectiveScale.d.ts","sourceRoot":"","sources":["../src/getClockEffectiveScale.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAK7C,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,GAAG,MAAM,CAQrE"}

package/dist/getClockEffectiveScale.js

@@ -0,0 +1,13 @@
+// The clock's realtime rate accounting for the hierarchy: the product of its own scale and every
+// ancestor's scale. A root clock's effective scale is just its own. This is what `deltaTime` divided by
+// the loop's real delta would equal (when nothing in the chain is paused).
+export function getClockEffectiveScale(clock) {
+    let scale = clock.scale;
+    let current = clock.parent;
+    while (current !== null) {
+        scale *= current.scale;
+        current = current.parent;
+    }
+    return scale;
+}
+//# sourceMappingURL=getClockEffectiveScale.js.map

package/dist/getClockEffectiveScale.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getClockEffectiveScale.js","sourceRoot":"","sources":["../src/getClockEffectiveScale.ts"],"names":[],"mappings":"AAEA,iGAAiG;AACjG,wGAAwG;AACxG,2EAA2E;AAC3E,MAAM,UAAU,sBAAsB,CAAC,KAAsB;IAC3D,IAAI,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;IACxB,IAAI,OAAO,GAA2B,KAAK,CAAC,MAAM,CAAC;IACnD,OAAO,OAAO,KAAK,IAAI,EAAE,CAAC;QACxB,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC;QACvB,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAC3B,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/getClockParent.d.ts

@@ -0,0 +1,3 @@
+import type { Clock } from '@flighthq/types';
+export declare function getClockParent(clock: Readonly<Clock>): Clock | null;
+//# sourceMappingURL=getClockParent.d.ts.map

package/dist/getClockParent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getClockParent.d.ts","sourceRoot":"","sources":["../src/getClockParent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAI7C,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,GAAG,KAAK,GAAG,IAAI,CAEnE"}

package/dist/getClockParent.js

@@ -0,0 +1,6 @@
+// The clock's parent, or null if it is a root. Convenience accessor for the `parent` field; hierarchy is
+// changed through addClockChild / removeClockChild, not by assigning this.
+export function getClockParent(clock) {
+    return clock.parent;
+}
+//# sourceMappingURL=getClockParent.js.map

package/dist/getClockParent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getClockParent.js","sourceRoot":"","sources":["../src/getClockParent.ts"],"names":[],"mappings":"AAEA,yGAAyG;AACzG,2EAA2E;AAC3E,MAAM,UAAU,cAAc,CAAC,KAAsB;IACnD,OAAO,KAAK,CAAC,MAAM,CAAC;AACtB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export * from './addClockChild';
+export * from './advanceClock';
+export * from './createClock';
+export * from './disposeClock';
+export * from './enableClockSignals';
+export * from './getClockEffectiveScale';
+export * from './getClockParent';
+export * from './isClockEffectivelyPaused';
+export * from './pauseClock';
+export * from './resetClock';
+export * from './setClockScale';
+//# 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,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,12 @@
+export * from './addClockChild';
+export * from './advanceClock';
+export * from './createClock';
+export * from './disposeClock';
+export * from './enableClockSignals';
+export * from './getClockEffectiveScale';
+export * from './getClockParent';
+export * from './isClockEffectivelyPaused';
+export * from './pauseClock';
+export * from './resetClock';
+export * from './setClockScale';
+//# 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,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC"}

package/dist/isClockEffectivelyPaused.d.ts

@@ -0,0 +1,3 @@
+import type { Clock } from '@flighthq/types';
+export declare function isClockEffectivelyPaused(clock: Readonly<Clock>): boolean;
+//# sourceMappingURL=isClockEffectivelyPaused.d.ts.map

package/dist/isClockEffectivelyPaused.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isClockEffectivelyPaused.d.ts","sourceRoot":"","sources":["../src/isClockEffectivelyPaused.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAI7C,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,GAAG,OAAO,CAOxE"}

package/dist/isClockEffectivelyPaused.js

@@ -0,0 +1,12 @@
+// Whether this clock receives a zero delta on the next advance: true if the clock itself or any ancestor
+// is paused. A clock can be locally running yet effectively paused because a parent is paused.
+export function isClockEffectivelyPaused(clock) {
+    let current = clock;
+    while (current !== null) {
+        if (current.paused)
+            return true;
+        current = current.parent;
+    }
+    return false;
+}
+//# sourceMappingURL=isClockEffectivelyPaused.js.map

package/dist/isClockEffectivelyPaused.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isClockEffectivelyPaused.js","sourceRoot":"","sources":["../src/isClockEffectivelyPaused.ts"],"names":[],"mappings":"AAEA,yGAAyG;AACzG,+FAA+F;AAC/F,MAAM,UAAU,wBAAwB,CAAC,KAAsB;IAC7D,IAAI,OAAO,GAA2B,KAAK,CAAC;IAC5C,OAAO,OAAO,KAAK,IAAI,EAAE,CAAC;QACxB,IAAI,OAAO,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC;QAChC,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAC3B,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/pauseClock.d.ts

@@ -0,0 +1,4 @@
+import type { Clock } from '@flighthq/types';
+export declare function pauseClock(clock: Clock): void;
+export declare function resumeClock(clock: Clock): void;
+//# sourceMappingURL=pauseClock.d.ts.map

package/dist/pauseClock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pauseClock.d.ts","sourceRoot":"","sources":["../src/pauseClock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAI7C,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAE7C;AAID,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAE9C"}

package/dist/pauseClock.js

@@ -0,0 +1,11 @@
+// Pauses the clock: it and its whole subtree receive a zero delta on subsequent advances, so elapsed
+// freezes until resumed. Local state — a child paused this way stays paused even if its parent resumes.
+export function pauseClock(clock) {
+    clock.paused = true;
+}
+// Resumes a locally-paused clock. The clock still receives a zero delta while any ancestor remains
+// paused (see isClockEffectivelyPaused).
+export function resumeClock(clock) {
+    clock.paused = false;
+}
+//# sourceMappingURL=pauseClock.js.map

package/dist/pauseClock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pauseClock.js","sourceRoot":"","sources":["../src/pauseClock.ts"],"names":[],"mappings":"AAEA,qGAAqG;AACrG,wGAAwG;AACxG,MAAM,UAAU,UAAU,CAAC,KAAY;IACrC,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC;AACtB,CAAC;AAED,mGAAmG;AACnG,yCAAyC;AACzC,MAAM,UAAU,WAAW,CAAC,KAAY;IACtC,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC;AACvB,CAAC"}

package/dist/resetClock.d.ts

@@ -0,0 +1,3 @@
+import type { Clock } from '@flighthq/types';
+export declare function resetClock(clock: Clock): void;
+//# sourceMappingURL=resetClock.d.ts.map

package/dist/resetClock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resetClock.d.ts","sourceRoot":"","sources":["../src/resetClock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAI7C,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAG7C"}

package/dist/resetClock.js

@@ -0,0 +1,7 @@
+// Clears the clock's accumulated time back to the start: elapsed and deltaTime become 0. Does not touch
+// scale, pause, or the hierarchy, and does not reset children (each child owns its own elapsed).
+export function resetClock(clock) {
+    clock.elapsed = 0;
+    clock.deltaTime = 0;
+}
+//# sourceMappingURL=resetClock.js.map

package/dist/resetClock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resetClock.js","sourceRoot":"","sources":["../src/resetClock.ts"],"names":[],"mappings":"AAEA,wGAAwG;AACxG,iGAAiG;AACjG,MAAM,UAAU,UAAU,CAAC,KAAY;IACrC,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC;IAClB,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC;AACtB,CAAC"}

package/dist/setClockScale.d.ts

@@ -0,0 +1,3 @@
+import type { Clock } from '@flighthq/types';
+export declare function setClockScale(clock: Clock, scale: number): void;
+//# sourceMappingURL=setClockScale.d.ts.map

package/dist/setClockScale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setClockScale.d.ts","sourceRoot":"","sources":["../src/setClockScale.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAI7C,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAE/D"}

package/dist/setClockScale.js

@@ -0,0 +1,6 @@
+// Sets the clock's local time scale (1 = realtime, 0.5 = half speed, 2 = double, 0 = frozen without the
+// paused flag). Composes with ancestors on the next advance — see getClockEffectiveScale.
+export function setClockScale(clock, scale) {
+    clock.scale = scale;
+}
+//# sourceMappingURL=setClockScale.js.map

package/dist/setClockScale.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setClockScale.js","sourceRoot":"","sources":["../src/setClockScale.ts"],"names":[],"mappings":"AAEA,wGAAwG;AACxG,0FAA0F;AAC1F,MAAM,UAAU,aAAa,CAAC,KAAY,EAAE,KAAa;IACvD,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC;AACtB,CAAC"}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@flighthq/clock",
+  "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/signals": "0.1.0",
+    "@flighthq/types": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  },
+  "description": "Hierarchical, pausable, scalable time primitive for time-driven systems",
+  "sideEffects": false
+}

package/src/addClockChild.test.ts

@@ -0,0 +1,49 @@
+import { addClockChild, removeClockChild } from './addClockChild';
+import { createClock } from './createClock';
+
+describe('addClockChild', () => {
+  it('attaches a child and sets its parent', () => {
+    const parent = createClock();
+    const child = createClock();
+    addClockChild(parent, child);
+    expect(child.parent).toBe(parent);
+    expect(parent.children).toEqual([child]);
+  });
+
+  it('is a no-op when the child is already parented here', () => {
+    const parent = createClock();
+    const child = createClock();
+    addClockChild(parent, child);
+    addClockChild(parent, child);
+    expect(parent.children).toEqual([child]);
+  });
+
+  it('reparents, detaching from the previous parent first', () => {
+    const a = createClock();
+    const b = createClock();
+    const child = createClock();
+    addClockChild(a, child);
+    addClockChild(b, child);
+    expect(a.children).toEqual([]);
+    expect(b.children).toEqual([child]);
+    expect(child.parent).toBe(b);
+  });
+});
+
+describe('removeClockChild', () => {
+  it('detaches a child and clears its parent', () => {
+    const parent = createClock();
+    const child = createClock();
+    addClockChild(parent, child);
+    removeClockChild(parent, child);
+    expect(parent.children).toEqual([]);
+    expect(child.parent).toBeNull();
+  });
+
+  it('is a no-op when the child is not parented here', () => {
+    const parent = createClock();
+    const child = createClock();
+    expect(() => removeClockChild(parent, child)).not.toThrow();
+    expect(parent.children).toEqual([]);
+  });
+});

package/src/advanceClock.test.ts

@@ -0,0 +1,64 @@
+import { connectSignal } from '@flighthq/signals';
+
+import { advanceClock } from './advanceClock';
+import { createChildClock, createClock } from './createClock';
+import { enableClockSignals } from './enableClockSignals';
+
+describe('advanceClock', () => {
+  it('sets deltaTime to the real delta and accumulates elapsed on a realtime root', () => {
+    const clock = createClock();
+    advanceClock(clock, 0.5);
+    expect(clock.deltaTime).toBe(0.5);
+    expect(clock.elapsed).toBe(0.5);
+    advanceClock(clock, 0.25);
+    expect(clock.deltaTime).toBe(0.25);
+    expect(clock.elapsed).toBe(0.75);
+  });
+
+  it('applies the local scale', () => {
+    const clock = createClock({ scale: 2 });
+    advanceClock(clock, 1);
+    expect(clock.deltaTime).toBe(2);
+    expect(clock.elapsed).toBe(2);
+  });
+
+  it('feeds a zero delta while paused, freezing elapsed', () => {
+    const clock = createClock({ paused: true });
+    advanceClock(clock, 1);
+    expect(clock.deltaTime).toBe(0);
+    expect(clock.elapsed).toBe(0);
+  });
+
+  it('composes scale down the hierarchy — a child rate is the product of the chain', () => {
+    const parent = createClock({ scale: 2 });
+    const child = createChildClock(parent, { scale: 0.5 });
+    advanceClock(parent, 1);
+    expect(parent.deltaTime).toBe(2);
+    expect(child.deltaTime).toBe(1); // 1 * 2 * 0.5
+    expect(child.elapsed).toBe(1);
+  });
+
+  it('freezes a subtree when an ancestor is paused even if the child is running', () => {
+    const parent = createClock({ paused: true });
+    const child = createChildClock(parent);
+    advanceClock(parent, 1);
+    expect(parent.deltaTime).toBe(0);
+    expect(child.deltaTime).toBe(0);
+    expect(child.elapsed).toBe(0);
+  });
+
+  it('emits onTick with the scaled delta when signals are enabled', () => {
+    const clock = createClock({ scale: 2 });
+    const received: number[] = [];
+    const onTick = enableClockSignals(clock);
+    connectSignal(onTick, (deltaTime) => received.push(deltaTime));
+    advanceClock(clock, 0.5);
+    expect(received).toEqual([1]); // 0.5 * 2
+  });
+
+  it('does not emit or throw when signals are not enabled', () => {
+    const clock = createClock();
+    expect(() => advanceClock(clock, 1)).not.toThrow();
+    expect(clock.onTick).toBeNull();
+  });
+});

package/src/createClock.test.ts

@@ -0,0 +1,36 @@
+import { createChildClock, createClock } from './createClock';
+
+describe('createChildClock', () => {
+  it('creates a clock attached to the parent', () => {
+    const parent = createClock();
+    const child = createChildClock(parent);
+    expect(child.parent).toBe(parent);
+    expect(parent.children).toContain(child);
+  });
+
+  it('applies options to the child', () => {
+    const parent = createClock();
+    const child = createChildClock(parent, { scale: 0.5, paused: true });
+    expect(child.scale).toBe(0.5);
+    expect(child.paused).toBe(true);
+  });
+});
+
+describe('createClock', () => {
+  it('defaults to realtime, running, zeroed, rootless, and signal-free', () => {
+    const clock = createClock();
+    expect(clock.scale).toBe(1);
+    expect(clock.paused).toBe(false);
+    expect(clock.deltaTime).toBe(0);
+    expect(clock.elapsed).toBe(0);
+    expect(clock.parent).toBeNull();
+    expect(clock.children).toEqual([]);
+    expect(clock.onTick).toBeNull();
+  });
+
+  it('applies scale and paused options', () => {
+    const clock = createClock({ scale: 3, paused: true });
+    expect(clock.scale).toBe(3);
+    expect(clock.paused).toBe(true);
+  });
+});

package/src/disposeClock.test.ts

@@ -0,0 +1,40 @@
+import { connectSignal, hasSignalSlots } from '@flighthq/signals';
+
+import { addClockChild } from './addClockChild';
+import { createClock } from './createClock';
+import { disposeClock } from './disposeClock';
+import { enableClockSignals } from './enableClockSignals';
+
+describe('disposeClock', () => {
+  it('detaches the clock from its parent', () => {
+    const parent = createClock();
+    const clock = createClock();
+    addClockChild(parent, clock);
+    disposeClock(clock);
+    expect(parent.children).toEqual([]);
+    expect(clock.parent).toBeNull();
+  });
+
+  it('releases its children, making each a root', () => {
+    const clock = createClock();
+    const child = createClock();
+    addClockChild(clock, child);
+    disposeClock(clock);
+    expect(clock.children).toEqual([]);
+    expect(child.parent).toBeNull();
+  });
+
+  it('clears onTick listeners', () => {
+    const clock = createClock();
+    const onTick = enableClockSignals(clock);
+    connectSignal(onTick, () => {});
+    expect(hasSignalSlots(onTick)).toBe(true);
+    disposeClock(clock);
+    expect(hasSignalSlots(onTick)).toBe(false);
+  });
+
+  it('is safe on a rootless, childless, signal-free clock', () => {
+    const clock = createClock();
+    expect(() => disposeClock(clock)).not.toThrow();
+  });
+});

package/src/enableClockSignals.test.ts

@@ -0,0 +1,18 @@
+import { createClock } from './createClock';
+import { enableClockSignals } from './enableClockSignals';
+
+describe('enableClockSignals', () => {
+  it('allocates the onTick signal and returns it', () => {
+    const clock = createClock();
+    const onTick = enableClockSignals(clock);
+    expect(clock.onTick).toBe(onTick);
+    expect(onTick).not.toBeNull();
+  });
+
+  it('is idempotent — a second call returns the same signal', () => {
+    const clock = createClock();
+    const first = enableClockSignals(clock);
+    const second = enableClockSignals(clock);
+    expect(second).toBe(first);
+  });
+});

package/src/getClockEffectiveScale.test.ts

@@ -0,0 +1,15 @@
+import { createChildClock, createClock } from './createClock';
+import { getClockEffectiveScale } from './getClockEffectiveScale';
+
+describe('getClockEffectiveScale', () => {
+  it('returns the local scale for a root', () => {
+    expect(getClockEffectiveScale(createClock({ scale: 2 }))).toBe(2);
+  });
+
+  it('multiplies through the ancestor chain', () => {
+    const a = createClock({ scale: 2 });
+    const b = createChildClock(a, { scale: 0.5 });
+    const c = createChildClock(b, { scale: 3 });
+    expect(getClockEffectiveScale(c)).toBe(3); // 2 * 0.5 * 3
+  });
+});

package/src/getClockParent.test.ts

@@ -0,0 +1,14 @@
+import { createChildClock, createClock } from './createClock';
+import { getClockParent } from './getClockParent';
+
+describe('getClockParent', () => {
+  it('returns null for a root clock', () => {
+    expect(getClockParent(createClock())).toBeNull();
+  });
+
+  it('returns the parent for a child clock', () => {
+    const parent = createClock();
+    const child = createChildClock(parent);
+    expect(getClockParent(child)).toBe(parent);
+  });
+});

package/src/isClockEffectivelyPaused.test.ts

@@ -0,0 +1,19 @@
+import { createChildClock, createClock } from './createClock';
+import { isClockEffectivelyPaused } from './isClockEffectivelyPaused';
+
+describe('isClockEffectivelyPaused', () => {
+  it('is false for a running root', () => {
+    expect(isClockEffectivelyPaused(createClock())).toBe(false);
+  });
+
+  it('is true when the clock itself is paused', () => {
+    expect(isClockEffectivelyPaused(createClock({ paused: true }))).toBe(true);
+  });
+
+  it('is true when an ancestor is paused even if the clock is running', () => {
+    const parent = createClock({ paused: true });
+    const child = createChildClock(parent);
+    expect(child.paused).toBe(false);
+    expect(isClockEffectivelyPaused(child)).toBe(true);
+  });
+});

package/src/pauseClock.test.ts

@@ -0,0 +1,18 @@
+import { createClock } from './createClock';
+import { pauseClock, resumeClock } from './pauseClock';
+
+describe('pauseClock', () => {
+  it('sets paused to true', () => {
+    const clock = createClock();
+    pauseClock(clock);
+    expect(clock.paused).toBe(true);
+  });
+});
+
+describe('resumeClock', () => {
+  it('sets paused to false', () => {
+    const clock = createClock({ paused: true });
+    resumeClock(clock);
+    expect(clock.paused).toBe(false);
+  });
+});

package/src/resetClock.test.ts

@@ -0,0 +1,15 @@
+import { advanceClock } from './advanceClock';
+import { createClock } from './createClock';
+import { resetClock } from './resetClock';
+
+describe('resetClock', () => {
+  it('clears elapsed and deltaTime without touching scale or pause', () => {
+    const clock = createClock({ scale: 2 });
+    advanceClock(clock, 1);
+    resetClock(clock);
+    expect(clock.elapsed).toBe(0);
+    expect(clock.deltaTime).toBe(0);
+    expect(clock.scale).toBe(2);
+    expect(clock.paused).toBe(false);
+  });
+});

package/src/setClockScale.test.ts

@@ -0,0 +1,10 @@
+import { createClock } from './createClock';
+import { setClockScale } from './setClockScale';
+
+describe('setClockScale', () => {
+  it('updates the local scale', () => {
+    const clock = createClock();
+    setClockScale(clock, 0.25);
+    expect(clock.scale).toBe(0.25);
+  });
+});