@enormora/clock 0.0.1 → 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Christian Rackerseder
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,311 @@
+# @enormora/clock
+
+Explicit time and timer access for TypeScript applications.
+
+`@enormora/clock` provides a small dependency-injection boundary around time-related side effects:
+
+- reading wall time as `Date`, Unix epoch milliseconds, or Unix epoch microseconds
+- reading monotonic time and its Unix epoch origin
+- scheduling and clearing timeouts
+- scheduling and clearing intervals
+- replacing real time with a deterministic clock in tests
+
+It is not a date-time utility library or a general scheduler framework. The package keeps time access explicit so
+application code does not need to call `Date.now()`, `new Date()`, `performance.now()`, `setTimeout`, or `setInterval`
+directly.
+
+## Installation
+
+```sh
+npm install @enormora/clock
+```
+
+The package is ESM-only and requires Node.js `^24.15.0 || ^26.0.0`.
+
+The root export keeps all clocks available from one import. Prefer explicit module subpaths when code only needs one
+clock:
+
+- `@enormora/clock/clock`
+- `@enormora/clock/temporal-clock`
+- `@enormora/clock/deterministic-clock`
+
+## Real Clock
+
+Use `createClock()` at the application boundary and pass the resulting `Clock` into code that needs time.
+
+```ts
+import { createClock } from '@enormora/clock/clock';
+
+const clock = createClock();
+
+console.log(clock.currentUnixEpochMilliseconds);
+console.log(clock.currentUnixEpochMicroseconds);
+console.log(clock.currentDate.toISOString());
+```
+
+The real clock delegates to the runtime:
+
+- `currentDate` returns a new `Date`
+- `currentUnixEpochMilliseconds` uses `Date.now()`
+- `currentUnixEpochMicroseconds` uses `Date.now() * 1000n`
+- `monotonicTimeOriginUnixEpochMicroseconds` uses `performance.timeOrigin`
+- `currentMonotonicMicroseconds` uses `performance.now()`
+- timer functions call `globalThis`
+
+`currentUnixEpochMicroseconds` communicates the unit, not a guaranteed resolution. Date-backed clocks expose
+millisecond-resolution wall time in microseconds.
+
+## Temporal Clock
+
+Use `createTemporalClock()` when the runtime provides `Temporal`.
+
+```ts
+import { createTemporalClock } from '@enormora/clock/temporal-clock';
+
+const clock = createTemporalClock();
+
+console.log(clock.currentUnixEpochMicroseconds);
+```
+
+The Temporal clock implements the same `Clock` interface. It uses `Temporal.Now.instant()` for wall time and
+`performance` for monotonic time. Importing the module works without Temporal, but calling `createTemporalClock()`
+throws when `globalThis.Temporal` is unavailable.
+
+## Dependency Injection
+
+Prefer accepting a `Clock` as an explicit dependency for code that depends on time.
+
+```ts
+import type { Clock } from '@enormora/clock/clock';
+
+type Session = {
+    readonly expiresAtUnixEpochMilliseconds: number;
+};
+
+export function isSessionExpired(clock: Clock, session: Session): boolean {
+    return clock.currentUnixEpochMilliseconds >= session.expiresAtUnixEpochMilliseconds;
+}
+```
+
+Use wall time for calendar time, storage, and user-facing timestamps. Use monotonic values for elapsed time and
+durations.
+
+## Deterministic Clock
+
+Use `createDeterministicClock()` in tests or deterministic environments.
+
+```ts
+import { createDeterministicClock } from '@enormora/clock/deterministic-clock';
+
+const clock = createDeterministicClock({
+    initialUnixEpochMicroseconds: 1_704_067_200_000_000n
+});
+
+console.log(clock.currentDate.toISOString());
+
+clock.advanceByMilliseconds(1000);
+
+console.log(clock.currentUnixEpochMilliseconds);
+```
+
+The deterministic clock implements the same `Clock` interface and adds:
+
+- `setCurrentUnixEpochMicroseconds(nextUnixEpochMicroseconds)`
+- `advanceByMicroseconds(delayInMicroseconds)`
+- `advanceByMilliseconds(delayInMilliseconds)`
+
+Wall time and monotonic time are stored in microseconds. Timers are scheduled against monotonic time, so setting wall
+time does not run or delay timers.
+
+## Testing Timers
+
+The deterministic clock runs scheduled callbacks when monotonic time is advanced far enough.
+
+```ts
+import assert from 'node:assert';
+import { createDeterministicClock } from '@enormora/clock/deterministic-clock';
+
+const clock = createDeterministicClock({
+    initialUnixEpochMicroseconds: 0n
+});
+const calls: string[] = [];
+
+clock.setTimeout(
+    (value) => {
+        calls.push(value);
+    },
+    100,
+    'done'
+);
+
+clock.advanceByMilliseconds(99);
+assert.deepStrictEqual(calls, []);
+
+clock.advanceByMilliseconds(1);
+assert.deepStrictEqual(calls, [ 'done' ]);
+```
+
+Intervals run once for each elapsed interval.
+
+```ts
+import assert from 'node:assert';
+import { createDeterministicClock } from '@enormora/clock/deterministic-clock';
+
+const clock = createDeterministicClock({
+    initialUnixEpochMicroseconds: 0n
+});
+let count = 0;
+
+const intervalIdentifier = clock.setInterval(() => {
+    count += 1;
+}, 100);
+
+clock.advanceByMilliseconds(250);
+assert.strictEqual(count, 2);
+
+clock.clearInterval(intervalIdentifier);
+clock.advanceByMilliseconds(500);
+assert.strictEqual(count, 2);
+```
+
+## Timer Behavior
+
+Timeouts:
+
+- execute once
+- execute only after the clock reaches their scheduled monotonic time
+- execute in scheduled monotonic time order
+- execute in registration order when multiple timeouts share the same scheduled time
+- can use a delay of `0`
+- reject negative and non-finite delays
+
+Intervals:
+
+- execute repeatedly
+- execute once per elapsed interval when time advances
+- stop after `clearInterval`
+- reject `0`, negative, non-finite, and sub-microsecond delays
+
+The deterministic clock rejects intervals that would round down to zero microseconds because they cannot advance safely.
+
+## API
+
+```ts
+declare const timeoutIdentifierBrand: unique symbol;
+declare const intervalIdentifierBrand: unique symbol;
+
+export type TimeoutIdentifier = {
+    readonly [timeoutIdentifierBrand]: 'TimeoutIdentifier';
+};
+
+export type IntervalIdentifier = {
+    readonly [intervalIdentifierBrand]: 'IntervalIdentifier';
+};
+
+export type Clock = {
+    readonly currentDate: Date;
+    readonly currentUnixEpochMilliseconds: number;
+    readonly currentUnixEpochMicroseconds: bigint;
+    readonly monotonicTimeOriginUnixEpochMicroseconds: bigint;
+    readonly currentMonotonicMicroseconds: bigint;
+    readonly setTimeout: <HandlerArguments extends readonly unknown[]>(
+        handler: (...handlerArguments: HandlerArguments) => void,
+        delayInMilliseconds: number,
+        ...handlerArguments: HandlerArguments
+    ) => TimeoutIdentifier;
+    readonly clearTimeout: (timeoutIdentifier: TimeoutIdentifier) => void;
+    readonly setInterval: <HandlerArguments extends readonly unknown[]>(
+        handler: (...handlerArguments: HandlerArguments) => void,
+        delayInMilliseconds: number,
+        ...handlerArguments: HandlerArguments
+    ) => IntervalIdentifier;
+    readonly clearInterval: (intervalIdentifier: IntervalIdentifier) => void;
+};
+```
+
+```ts
+export type DeterministicClock = Clock & {
+    readonly setCurrentUnixEpochMicroseconds: (nextUnixEpochMicroseconds: bigint) => void;
+    readonly advanceByMicroseconds: (delayInMicroseconds: bigint) => void;
+    readonly advanceByMilliseconds: (delayInMilliseconds: number) => void;
+};
+```
+
+```ts
+export function createClock(): Clock;
+```
+
+```ts
+export function createTemporalClock(): Clock;
+```
+
+```ts
+export function createDeterministicClock(options: {
+    readonly initialUnixEpochMicroseconds: bigint;
+}): DeterministicClock;
+```
+
+## Development
+
+Install dependencies:
+
+```sh
+npm clean-install
+```
+
+Compile:
+
+```sh
+just compile
+```
+
+Run lint checks:
+
+```sh
+just lint
+```
+
+Run tests:
+
+```sh
+just test
+```
+
+Run a Packtory dry-run:
+
+```sh
+just packtory-dry-run
+```
+
+## Publishing
+
+Pull requests that should appear in the changelog need exactly one changelog label. Supported labels:
+
+- `breaking`
+- `bug`
+- `feature`
+- `enhancement`
+- `documentation`
+- `upgrade`
+- `refactor`
+- `build`
+
+The package is released through a release pull request:
+
+1. Go to GitHub Actions -> Release -> Run workflow.
+2. The workflow creates or updates a `Prepare release` pull request with the generated `CHANGELOG.md` changes.
+3. Review and merge the release pull request through the normal merge queue.
+4. After the release pull request is merged, the publish workflow publishes to npm, pushes the package tag, and creates
+   the GitHub Release.
+
+The dry-run command validates the package shape without publishing.
+
+```sh
+just packtory-dry-run
+```
+
+Inspect the next release plan:
+
+```sh
+just release-plan
+```

package/clock.d.ts

@@ -0,0 +1,21 @@
+declare const timeoutIdentifierBrand: unique symbol;
+declare const intervalIdentifierBrand: unique symbol;
+export type TimeoutIdentifier = {
+    readonly [timeoutIdentifierBrand]: 'TimeoutIdentifier';
+};
+export type IntervalIdentifier = {
+    readonly [intervalIdentifierBrand]: 'IntervalIdentifier';
+};
+export type Clock = {
+    readonly currentDate: Date;
+    readonly currentUnixEpochMilliseconds: number;
+    readonly currentUnixEpochMicroseconds: bigint;
+    readonly monotonicTimeOriginUnixEpochMicroseconds: bigint;
+    readonly currentMonotonicMicroseconds: bigint;
+    readonly setTimeout: <HandlerArguments extends readonly unknown[]>(handler: (...handlerArguments: HandlerArguments) => void, delayInMilliseconds: number, ...handlerArguments: HandlerArguments) => TimeoutIdentifier;
+    readonly clearTimeout: (timeoutIdentifier: TimeoutIdentifier) => void;
+    readonly setInterval: <HandlerArguments extends readonly unknown[]>(handler: (...handlerArguments: HandlerArguments) => void, delayInMilliseconds: number, ...handlerArguments: HandlerArguments) => IntervalIdentifier;
+    readonly clearInterval: (intervalIdentifier: IntervalIdentifier) => void;
+};
+export {};
+//# sourceMappingURL=clock.d.ts.map

package/clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock.d.ts","sourceRoot":"","sources":["../../../source/clock.ts"],"names":[],"mappings":"AAEA,OAAO,CAAC,MAAM,sBAAsB,EAAE,OAAO,MAAM,CAAC;AACpD,OAAO,CAAC,MAAM,uBAAuB,EAAE,OAAO,MAAM,CAAC;AAErD,MAAM,MAAM,iBAAiB,GAAG;IAC5B,QAAQ,CAAC,CAAC,sBAAsB,CAAC,EAAE,mBAAmB,CAAC;CAC1D,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC7B,QAAQ,CAAC,CAAC,uBAAuB,CAAC,EAAE,oBAAoB,CAAC;CAC5D,CAAC;AAEF,MAAM,MAAM,KAAK,GAAG;IAChB,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAC;IAC3B,QAAQ,CAAC,4BAA4B,EAAE,MAAM,CAAC;IAC9C,QAAQ,CAAC,4BAA4B,EAAE,MAAM,CAAC;IAC9C,QAAQ,CAAC,wCAAwC,EAAE,MAAM,CAAC;IAC1D,QAAQ,CAAC,4BAA4B,EAAE,MAAM,CAAC;IAC9C,QAAQ,CAAC,UAAU,EAAE,CAAC,gBAAgB,SAAS,SAAS,OAAO,EAAE,EAC7D,OAAO,EAAE,CAAC,GAAG,gBAAgB,EAAE,gBAAgB,KAAK,IAAI,EACxD,mBAAmB,EAAE,MAAM,EAC3B,GAAG,gBAAgB,EAAE,gBAAgB,KACpC,iBAAiB,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,CAAC,iBAAiB,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACtE,QAAQ,CAAC,WAAW,EAAE,CAAC,gBAAgB,SAAS,SAAS,OAAO,EAAE,EAC9D,OAAO,EAAE,CAAC,GAAG,gBAAgB,EAAE,gBAAgB,KAAK,IAAI,EACxD,mBAAmB,EAAE,MAAM,EAC3B,GAAG,gBAAgB,EAAE,gBAAgB,KACpC,kBAAkB,CAAC;IACxB,QAAQ,CAAC,aAAa,EAAE,CAAC,kBAAkB,EAAE,kBAAkB,KAAK,IAAI,CAAC;CAC5E,CAAC;AAEF,MAAM,CAA0B,EAS/B,CAAC"}

package/clock.entry-point.d.ts

@@ -0,0 +1,6 @@
+import { type Clock as RuntimeClock, type IntervalIdentifier as RuntimeIntervalIdentifier, type TimeoutIdentifier as RuntimeTimeoutIdentifier } from './clock.ts';
+export type Clock = RuntimeClock;
+export type TimeoutIdentifier = RuntimeTimeoutIdentifier;
+export type IntervalIdentifier = RuntimeIntervalIdentifier;
+export declare function createClock(): RuntimeClock;
+//# sourceMappingURL=clock.entry-point.d.ts.map

package/clock.entry-point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock.entry-point.d.ts","sourceRoot":"","sources":["../../../source/clock.entry-point.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,KAAK,KAAK,IAAI,YAAY,EAC1B,KAAK,kBAAkB,IAAI,yBAAyB,EACpD,KAAK,iBAAiB,IAAI,wBAAwB,EACrD,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,KAAK,GAAG,YAAY,CAAC;AACjC,MAAM,MAAM,iBAAiB,GAAG,wBAAwB,CAAC;AACzD,MAAM,MAAM,kBAAkB,GAAG,yBAAyB,CAAC;AAE3D,wBAAgB,WAAW,IAAI,YAAY,CA+B1C"}

package/clock.entry-point.js

@@ -0,0 +1,26 @@
+import { createClock as createClockFromDependencies } from "./clock.js";
+export function createClock() {
+    return createClockFromDependencies({
+        currentDate() {
+            return new Date();
+        },
+        currentUnixEpochMilliseconds() {
+            return Date.now();
+        },
+        monotonicTimeOriginMilliseconds: globalThis.performance.timeOrigin,
+        currentMonotonicMilliseconds: globalThis.performance.now.bind(globalThis.performance),
+        setTimeout(handler, delayInMilliseconds, ...handlerArguments) {
+            return globalThis.setTimeout(handler, delayInMilliseconds, ...handlerArguments);
+        },
+        clearTimeout(timeoutIdentifier) {
+            globalThis.clearTimeout(timeoutIdentifier);
+        },
+        setInterval(handler, delayInMilliseconds, ...handlerArguments) {
+            return globalThis.setInterval(handler, delayInMilliseconds, ...handlerArguments);
+        },
+        clearInterval(intervalIdentifier) {
+            globalThis.clearInterval(intervalIdentifier);
+        }
+    });
+}
+//# sourceMappingURL=clock.entry-point.js.map

package/clock.entry-point.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock.entry-point.js","sourceRoot":"","sources":["../../../source/clock.entry-point.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,WAAW,IAAI,2BAA2B,EAI7C,MAAM,YAAY,CAAC;AAMpB,MAAM,UAAU,WAAW;IACvB,OAAO,2BAA2B,CAAC;QAC/B,WAAW;YACP,OAAO,IAAI,IAAI,EAAE,CAAC;QACtB,CAAC;QACD,4BAA4B;YACxB,OAAO,IAAI,CAAC,GAAG,EAAE,CAAC;QACtB,CAAC;QACD,+BAA+B,EAAE,UAAU,CAAC,WAAW,CAAC,UAAU;QAClE,4BAA4B,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC;QACrF,UAAU,CAAC,OAAO,EAAE,mBAAmB,EAAE,GAAG,gBAAgB;YACxD,OAAO,UAAU,CAAC,UAAU,CACxB,OAAO,EACP,mBAAmB,EACnB,GAAG,gBAAgB,CACiB,CAAC;QAC7C,CAAC;QACD,YAAY,CAAC,iBAAiB;YAC1B,UAAU,CAAC,YAAY,CAAC,iBAAwE,CAAC,CAAC;QACtG,CAAC;QACD,WAAW,CAAC,OAAO,EAAE,mBAAmB,EAAE,GAAG,gBAAgB;YACzD,OAAO,UAAU,CAAC,WAAW,CACzB,OAAO,EACP,mBAAmB,EACnB,GAAG,gBAAgB,CACkB,CAAC;QAC9C,CAAC;QACD,aAAa,CAAC,kBAAkB;YAC5B,UAAU,CAAC,aAAa,CAAC,kBAA0E,CAAC,CAAC;QACzG,CAAC;KACJ,CAAC,CAAC;AACP,CAAC"}

package/clock.js

@@ -0,0 +1,28 @@
+const microsecondsPerMillisecond = 1000n;
+function millisecondsToMicroseconds(milliseconds) {
+    return BigInt(Math.floor(milliseconds * Number(microsecondsPerMillisecond)));
+}
+export function createClock(dependencies) {
+    return {
+        get currentDate() {
+            return dependencies.currentDate();
+        },
+        get currentUnixEpochMilliseconds() {
+            return dependencies.currentUnixEpochMilliseconds();
+        },
+        get currentUnixEpochMicroseconds() {
+            return millisecondsToMicroseconds(dependencies.currentUnixEpochMilliseconds());
+        },
+        get monotonicTimeOriginUnixEpochMicroseconds() {
+            return millisecondsToMicroseconds(dependencies.monotonicTimeOriginMilliseconds);
+        },
+        get currentMonotonicMicroseconds() {
+            return millisecondsToMicroseconds(dependencies.currentMonotonicMilliseconds());
+        },
+        setTimeout: dependencies.setTimeout,
+        clearTimeout: dependencies.clearTimeout,
+        setInterval: dependencies.setInterval,
+        clearInterval: dependencies.clearInterval
+    };
+}
+//# sourceMappingURL=clock.js.map

package/clock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock.js","sourceRoot":"","sources":["../../../source/clock.ts"],"names":[],"mappings":"AAAA,MAAM,0BAA0B,GAAG,KAAK,CAAC;AA4CzC,SAAS,0BAA0B,CAAC,YAAoB;IACpD,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,GAAG,MAAM,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC;AACjF,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,YAA+B;IACvD,OAAO;QACH,IAAI,WAAW;YACX,OAAO,YAAY,CAAC,WAAW,EAAE,CAAC;QACtC,CAAC;QAED,IAAI,4BAA4B;YAC5B,OAAO,YAAY,CAAC,4BAA4B,EAAE,CAAC;QACvD,CAAC;QAED,IAAI,4BAA4B;YAC5B,OAAO,0BAA0B,CAAC,YAAY,CAAC,4BAA4B,EAAE,CAAC,CAAC;QACnF,CAAC;QAED,IAAI,wCAAwC;YACxC,OAAO,0BAA0B,CAAC,YAAY,CAAC,+BAA+B,CAAC,CAAC;QACpF,CAAC;QAED,IAAI,4BAA4B;YAC5B,OAAO,0BAA0B,CAAC,YAAY,CAAC,4BAA4B,EAAE,CAAC,CAAC;QACnF,CAAC;QAED,UAAU,EAAE,YAAY,CAAC,UAAU;QAEnC,YAAY,EAAE,YAAY,CAAC,YAAY;QAEvC,WAAW,EAAE,YAAY,CAAC,WAAW;QAErC,aAAa,EAAE,YAAY,CAAC,aAAa;KAC5C,CAAC;AACN,CAAC"}

package/deterministic-clock.d.ts

@@ -0,0 +1,11 @@
+import type { Clock } from './clock.ts';
+export type DeterministicClock = Clock & {
+    readonly setCurrentUnixEpochMicroseconds: (nextUnixEpochMicroseconds: bigint) => void;
+    readonly advanceByMicroseconds: (delayInMicroseconds: bigint) => void;
+    readonly advanceByMilliseconds: (delayInMilliseconds: number) => void;
+};
+export type DeterministicClockOptions = {
+    readonly initialUnixEpochMicroseconds: bigint;
+};
+export declare function createDeterministicClock(options: DeterministicClockOptions): DeterministicClock;
+//# sourceMappingURL=deterministic-clock.d.ts.map

package/deterministic-clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deterministic-clock.d.ts","sourceRoot":"","sources":["../../../source/deterministic-clock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGxC,MAAM,MAAM,kBAAkB,GAAG,KAAK,GAAG;IACrC,QAAQ,CAAC,+BAA+B,EAAE,CAAC,yBAAyB,EAAE,MAAM,KAAK,IAAI,CAAC;IACtF,QAAQ,CAAC,qBAAqB,EAAE,CAAC,mBAAmB,EAAE,MAAM,KAAK,IAAI,CAAC;IACtE,QAAQ,CAAC,qBAAqB,EAAE,CAAC,mBAAmB,EAAE,MAAM,KAAK,IAAI,CAAC;CACzE,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACpC,QAAQ,CAAC,4BAA4B,EAAE,MAAM,CAAC;CACjD,CAAC;AA4LF,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,yBAAyB,GAAG,kBAAkB,CAkE/F"}

package/deterministic-clock.js

@@ -0,0 +1,170 @@
+import { validateIntervalDelayInMilliseconds, validateTimeoutDelayInMilliseconds } from "./timer-delay.js";
+const microsecondsPerMillisecond = 1000n;
+const minimumDelayInMicroseconds = 0n;
+function compareMicroseconds(firstMicroseconds, secondMicroseconds) {
+    if (firstMicroseconds < secondMicroseconds) {
+        return -1;
+    }
+    if (firstMicroseconds > secondMicroseconds) {
+        return 1;
+    }
+    return 0;
+}
+function compareTimeoutEntries(firstTimeoutEntry, secondTimeoutEntry) {
+    const [firstTimeoutIdentifier, firstTimeoutRegistration] = firstTimeoutEntry;
+    const [secondTimeoutIdentifier, secondTimeoutRegistration] = secondTimeoutEntry;
+    const timeoutExecutionOrder = compareMicroseconds(firstTimeoutRegistration.executionMonotonicMicroseconds, secondTimeoutRegistration.executionMonotonicMicroseconds);
+    if (timeoutExecutionOrder !== 0) {
+        return timeoutExecutionOrder;
+    }
+    return firstTimeoutIdentifier - secondTimeoutIdentifier;
+}
+function millisecondsToMicroseconds(milliseconds) {
+    return BigInt(Math.floor(milliseconds * Number(microsecondsPerMillisecond)));
+}
+function unixEpochMillisecondsFromMicroseconds(unixEpochMicroseconds) {
+    return Number(unixEpochMicroseconds / microsecondsPerMillisecond);
+}
+function ensureValidDateUnixEpochMicroseconds(unixEpochMicroseconds) {
+    const unixEpochMilliseconds = unixEpochMillisecondsFromMicroseconds(unixEpochMicroseconds);
+    const date = new Date(unixEpochMilliseconds);
+    if (Number.isNaN(date.getTime())) {
+        throw new RangeError('Invalid Unix epoch microseconds, must be representable as a Date');
+    }
+}
+function validateDelayInMicroseconds(delayInMicroseconds) {
+    if (delayInMicroseconds < minimumDelayInMicroseconds) {
+        throw new RangeError(`Invalid delay ${delayInMicroseconds.toString()}, must be greater than or equal to 0`);
+    }
+}
+function createTimeoutController(currentMonotonicMicroseconds) {
+    let nextTimeoutIdentifier = 0;
+    const timeoutRegistrations = new Map();
+    function runDueTimeoutRegistrations() {
+        const dueTimeoutEntries = Array
+            .from(timeoutRegistrations)
+            .filter(function ([, timeoutRegistration]) {
+            return timeoutRegistration.executionMonotonicMicroseconds <= currentMonotonicMicroseconds();
+        })
+            .toSorted(compareTimeoutEntries);
+        dueTimeoutEntries.forEach(function ([timeoutIdentifier, timeoutRegistration]) {
+            timeoutRegistrations.delete(timeoutIdentifier);
+            timeoutRegistration.execute();
+        });
+    }
+    return {
+        runDueTimeoutRegistrations,
+        setTimeout(handler, delayInMilliseconds, ...handlerArguments) {
+            validateTimeoutDelayInMilliseconds(delayInMilliseconds);
+            const timeoutIdentifier = nextTimeoutIdentifier;
+            nextTimeoutIdentifier += 1;
+            const delayInMicroseconds = millisecondsToMicroseconds(delayInMilliseconds);
+            timeoutRegistrations.set(timeoutIdentifier, {
+                execute() {
+                    handler(...handlerArguments);
+                },
+                executionMonotonicMicroseconds: currentMonotonicMicroseconds() + delayInMicroseconds
+            });
+            return timeoutIdentifier;
+        },
+        clearTimeout(timeoutIdentifier) {
+            timeoutRegistrations.delete(timeoutIdentifier);
+        }
+    };
+}
+function createIntervalController(currentMonotonicMicroseconds) {
+    let nextIntervalIdentifier = 0;
+    const intervalRegistrations = new Map();
+    function runDueIntervalRegistrations() {
+        intervalRegistrations.forEach(function (intervalRegistration, intervalIdentifier) {
+            const { delayInMicroseconds, execute } = intervalRegistration;
+            let { nextExecutionMonotonicMicroseconds } = intervalRegistration;
+            while (nextExecutionMonotonicMicroseconds <= currentMonotonicMicroseconds()) {
+                execute();
+                if (!intervalRegistrations.has(intervalIdentifier)) {
+                    return;
+                }
+                nextExecutionMonotonicMicroseconds += delayInMicroseconds;
+                intervalRegistrations.set(intervalIdentifier, {
+                    delayInMicroseconds,
+                    execute,
+                    nextExecutionMonotonicMicroseconds
+                });
+            }
+        });
+    }
+    return {
+        runDueIntervalRegistrations,
+        setInterval(handler, delayInMilliseconds, ...handlerArguments) {
+            validateIntervalDelayInMilliseconds(delayInMilliseconds);
+            const intervalIdentifier = nextIntervalIdentifier;
+            nextIntervalIdentifier += 1;
+            const delayInMicroseconds = millisecondsToMicroseconds(delayInMilliseconds);
+            if (delayInMicroseconds <= minimumDelayInMicroseconds) {
+                throw new RangeError(`Invalid interval delay ${delayInMilliseconds}, must be at least 1 microsecond`);
+            }
+            intervalRegistrations.set(intervalIdentifier, {
+                delayInMicroseconds,
+                execute() {
+                    handler(...handlerArguments);
+                },
+                nextExecutionMonotonicMicroseconds: currentMonotonicMicroseconds() + delayInMicroseconds
+            });
+            return intervalIdentifier;
+        },
+        clearInterval(intervalIdentifier) {
+            intervalRegistrations.delete(intervalIdentifier);
+        }
+    };
+}
+export function createDeterministicClock(options) {
+    const { initialUnixEpochMicroseconds } = options;
+    ensureValidDateUnixEpochMicroseconds(initialUnixEpochMicroseconds);
+    let currentUnixEpochMicroseconds = initialUnixEpochMicroseconds;
+    let currentMonotonicMicroseconds = minimumDelayInMicroseconds;
+    function currentMonotonicMicrosecondsReader() {
+        return currentMonotonicMicroseconds;
+    }
+    const timeoutController = createTimeoutController(currentMonotonicMicrosecondsReader);
+    const intervalController = createIntervalController(currentMonotonicMicrosecondsReader);
+    function advanceClockByMicroseconds(delayInMicroseconds) {
+        validateDelayInMicroseconds(delayInMicroseconds);
+        const nextUnixEpochMicroseconds = currentUnixEpochMicroseconds + delayInMicroseconds;
+        ensureValidDateUnixEpochMicroseconds(nextUnixEpochMicroseconds);
+        currentUnixEpochMicroseconds = nextUnixEpochMicroseconds;
+        currentMonotonicMicroseconds += delayInMicroseconds;
+        intervalController.runDueIntervalRegistrations();
+        timeoutController.runDueTimeoutRegistrations();
+    }
+    return {
+        get currentDate() {
+            return new Date(unixEpochMillisecondsFromMicroseconds(currentUnixEpochMicroseconds));
+        },
+        get currentUnixEpochMilliseconds() {
+            return unixEpochMillisecondsFromMicroseconds(currentUnixEpochMicroseconds);
+        },
+        get currentUnixEpochMicroseconds() {
+            return currentUnixEpochMicroseconds;
+        },
+        get monotonicTimeOriginUnixEpochMicroseconds() {
+            return initialUnixEpochMicroseconds;
+        },
+        get currentMonotonicMicroseconds() {
+            return currentMonotonicMicroseconds;
+        },
+        setCurrentUnixEpochMicroseconds(nextUnixEpochMicroseconds) {
+            ensureValidDateUnixEpochMicroseconds(nextUnixEpochMicroseconds);
+            currentUnixEpochMicroseconds = nextUnixEpochMicroseconds;
+        },
+        advanceByMicroseconds: advanceClockByMicroseconds,
+        advanceByMilliseconds(delayInMilliseconds) {
+            validateTimeoutDelayInMilliseconds(delayInMilliseconds);
+            advanceClockByMicroseconds(millisecondsToMicroseconds(delayInMilliseconds));
+        },
+        setTimeout: timeoutController.setTimeout,
+        clearTimeout: timeoutController.clearTimeout,
+        setInterval: intervalController.setInterval,
+        clearInterval: intervalController.clearInterval
+    };
+}
+//# sourceMappingURL=deterministic-clock.js.map

package/deterministic-clock.js.map

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

package/index.d.ts

@@ -0,0 +1,6 @@
+export { createClock } from './clock.entry-point.ts';
+export type { Clock, IntervalIdentifier, TimeoutIdentifier } from './clock.entry-point.ts';
+export { createTemporalClock } from './temporal-clock.entry-point.ts';
+export { createDeterministicClock } from './deterministic-clock.ts';
+export type { DeterministicClock, DeterministicClockOptions } from './deterministic-clock.ts';
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../source/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,YAAY,EAAE,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3F,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACpE,YAAY,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC"}

package/index.js

@@ -0,0 +1,4 @@
+export { createClock } from "./clock.entry-point.js";
+export { createTemporalClock } from "./temporal-clock.entry-point.js";
+export { createDeterministicClock } from "./deterministic-clock.js";
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../source/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC"}

package/package.json

@@ -1,7 +1,34 @@
 {
-  "name": "@enormora/clock",
-  "version": "0.0.1",
-  "description": "Placeholder claiming the npm package name \"@enormora/clock\" so a trusted publisher can be configured. See https://github.com/npm/cli/issues/8544.",
-  "license": "MIT",
-  "deprecated": "Placeholder published as a workaround so a Trusted Publisher could be configured. See https://github.com/npm/cli/issues/8544."
-}
+    "author": "Christian Rackerseder <git@echooff.de>",
+    "description": "Explicit time and timer access for TypeScript applications",
+    "engines": {
+        "node": "^24.15.0 || ^26.0.0"
+    },
+    "exports": {
+        ".": {
+            "import": "./index.js",
+            "types": "./index.d.ts"
+        },
+        "./clock": {
+            "import": "./clock.entry-point.js",
+            "types": "./clock.entry-point.d.ts"
+        },
+        "./deterministic-clock": {
+            "import": "./deterministic-clock.js",
+            "types": "./deterministic-clock.d.ts"
+        },
+        "./temporal-clock": {
+            "import": "./temporal-clock.entry-point.js",
+            "types": "./temporal-clock.entry-point.d.ts"
+        }
+    },
+    "license": "MIT",
+    "name": "@enormora/clock",
+    "repository": {
+        "type": "git",
+        "url": "git+ssh://git@github.com/enormora/clock.git"
+    },
+    "sideEffects": false,
+    "type": "module",
+    "version": "0.0.2"
+}

package/sbom.cdx.json

@@ -0,0 +1,30 @@
+{
+    "$schema": "http://cyclonedx.org/schema/bom-1.6.schema.json",
+    "bomFormat": "CycloneDX",
+    "specVersion": "1.6",
+    "version": 1,
+    "metadata": {
+        "tools": {
+            "components": [
+                {
+                    "type": "application",
+                    "name": "packtory",
+                    "version": "0.0.114"
+                }
+            ]
+        },
+        "component": {
+            "type": "library",
+            "name": "@enormora/clock",
+            "version": "0.0.2",
+            "bom-ref": "pkg:npm/@enormora/clock@0.0.2",
+            "purl": "pkg:npm/@enormora/clock@0.0.2"
+        }
+    },
+    "components": [],
+    "dependencies": [
+        {
+            "ref": "pkg:npm/@enormora/clock@0.0.2"
+        }
+    ]
+}

package/temporal-clock.entry-point.d.ts

@@ -0,0 +1,3 @@
+import type { Clock } from './clock.ts';
+export declare function createTemporalClock(): Clock;
+//# sourceMappingURL=temporal-clock.entry-point.d.ts.map

package/temporal-clock.entry-point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporal-clock.entry-point.d.ts","sourceRoot":"","sources":["../../../source/temporal-clock.entry-point.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACR,KAAK,EAGR,MAAM,YAAY,CAAC;AA2BpB,wBAAgB,mBAAmB,IAAI,KAAK,CA4B3C"}

package/temporal-clock.entry-point.js

@@ -0,0 +1,29 @@
+import { createTemporalClock as createTemporalClockFromDependencies } from "./temporal-clock.js";
+function readTemporalClockApi() {
+    const temporalClockApi = globalThis.Temporal;
+    if (temporalClockApi === undefined) {
+        throw new ReferenceError('Temporal is not available');
+    }
+    return temporalClockApi;
+}
+export function createTemporalClock() {
+    const temporalClockApi = readTemporalClockApi();
+    return createTemporalClockFromDependencies({
+        currentInstant: temporalClockApi.Now.instant.bind(temporalClockApi.Now),
+        monotonicTimeOriginMilliseconds: globalThis.performance.timeOrigin,
+        currentMonotonicMilliseconds: globalThis.performance.now.bind(globalThis.performance),
+        setTimeout(handler, delayInMilliseconds, ...handlerArguments) {
+            return globalThis.setTimeout(handler, delayInMilliseconds, ...handlerArguments);
+        },
+        clearTimeout(timeoutIdentifier) {
+            globalThis.clearTimeout(timeoutIdentifier);
+        },
+        setInterval(handler, delayInMilliseconds, ...handlerArguments) {
+            return globalThis.setInterval(handler, delayInMilliseconds, ...handlerArguments);
+        },
+        clearInterval(intervalIdentifier) {
+            globalThis.clearInterval(intervalIdentifier);
+        }
+    });
+}
+//# sourceMappingURL=temporal-clock.entry-point.js.map

package/temporal-clock.entry-point.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporal-clock.entry-point.js","sourceRoot":"","sources":["../../../source/temporal-clock.entry-point.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,IAAI,mCAAmC,EAAE,MAAM,qBAAqB,CAAC;AAsBjG,SAAS,oBAAoB;IACzB,MAAM,gBAAgB,GAAI,UAAoC,CAAC,QAAQ,CAAC;IAExE,IAAI,gBAAgB,KAAK,SAAS,EAAE,CAAC;QACjC,MAAM,IAAI,cAAc,CAAC,2BAA2B,CAAC,CAAC;IAC1D,CAAC;IAED,OAAO,gBAAgB,CAAC;AAC5B,CAAC;AAED,MAAM,UAAU,mBAAmB;IAC/B,MAAM,gBAAgB,GAAG,oBAAoB,EAAE,CAAC;IAEhD,OAAO,mCAAmC,CAAC;QACvC,cAAc,EAAE,gBAAgB,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC;QACvE,+BAA+B,EAAE,UAAU,CAAC,WAAW,CAAC,UAAU;QAClE,4BAA4B,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC;QACrF,UAAU,CAAC,OAAO,EAAE,mBAAmB,EAAE,GAAG,gBAAgB;YACxD,OAAO,UAAU,CAAC,UAAU,CACxB,OAAO,EACP,mBAAmB,EACnB,GAAG,gBAAgB,CACiB,CAAC;QAC7C,CAAC;QACD,YAAY,CAAC,iBAAiB;YAC1B,UAAU,CAAC,YAAY,CAAC,iBAAwE,CAAC,CAAC;QACtG,CAAC;QACD,WAAW,CAAC,OAAO,EAAE,mBAAmB,EAAE,GAAG,gBAAgB;YACzD,OAAO,UAAU,CAAC,WAAW,CACzB,OAAO,EACP,mBAAmB,EACnB,GAAG,gBAAgB,CACkB,CAAC;QAC9C,CAAC;QACD,aAAa,CAAC,kBAAkB;YAC5B,UAAU,CAAC,aAAa,CAAC,kBAA0E,CAAC,CAAC;QACzG,CAAC;KACJ,CAAC,CAAC;AACP,CAAC"}

package/temporal-clock.js

@@ -0,0 +1,29 @@
+const microsecondsPerMillisecond = 1000;
+const nanosecondsPerMicrosecond = 1000n;
+function millisecondsToMicroseconds(milliseconds) {
+    return BigInt(Math.floor(milliseconds * microsecondsPerMillisecond));
+}
+export function createTemporalClock(dependencies) {
+    return {
+        get currentDate() {
+            return new Date(dependencies.currentInstant().epochMilliseconds);
+        },
+        get currentUnixEpochMilliseconds() {
+            return dependencies.currentInstant().epochMilliseconds;
+        },
+        get currentUnixEpochMicroseconds() {
+            return dependencies.currentInstant().epochNanoseconds / nanosecondsPerMicrosecond;
+        },
+        get monotonicTimeOriginUnixEpochMicroseconds() {
+            return millisecondsToMicroseconds(dependencies.monotonicTimeOriginMilliseconds);
+        },
+        get currentMonotonicMicroseconds() {
+            return millisecondsToMicroseconds(dependencies.currentMonotonicMilliseconds());
+        },
+        setTimeout: dependencies.setTimeout,
+        clearTimeout: dependencies.clearTimeout,
+        setInterval: dependencies.setInterval,
+        clearInterval: dependencies.clearInterval
+    };
+}
+//# sourceMappingURL=temporal-clock.js.map

package/temporal-clock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporal-clock.js","sourceRoot":"","sources":["../../../source/temporal-clock.ts"],"names":[],"mappings":"AAiBA,MAAM,0BAA0B,GAAG,IAAI,CAAC;AACxC,MAAM,yBAAyB,GAAG,KAAK,CAAC;AAExC,SAAS,0BAA0B,CAAC,YAAoB;IACpD,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,GAAG,0BAA0B,CAAC,CAAC,CAAC;AACzE,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,YAAuC;IACvE,OAAO;QACH,IAAI,WAAW;YACX,OAAO,IAAI,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC,iBAAiB,CAAC,CAAC;QACrE,CAAC;QAED,IAAI,4BAA4B;YAC5B,OAAO,YAAY,CAAC,cAAc,EAAE,CAAC,iBAAiB,CAAC;QAC3D,CAAC;QAED,IAAI,4BAA4B;YAC5B,OAAO,YAAY,CAAC,cAAc,EAAE,CAAC,gBAAgB,GAAG,yBAAyB,CAAC;QACtF,CAAC;QAED,IAAI,wCAAwC;YACxC,OAAO,0BAA0B,CAAC,YAAY,CAAC,+BAA+B,CAAC,CAAC;QACpF,CAAC;QAED,IAAI,4BAA4B;YAC5B,OAAO,0BAA0B,CAAC,YAAY,CAAC,4BAA4B,EAAE,CAAC,CAAC;QACnF,CAAC;QAED,UAAU,EAAE,YAAY,CAAC,UAAU;QAEnC,YAAY,EAAE,YAAY,CAAC,YAAY;QAEvC,WAAW,EAAE,YAAY,CAAC,WAAW;QAErC,aAAa,EAAE,YAAY,CAAC,aAAa;KAC5C,CAAC;AACN,CAAC"}

package/timer-delay.js

@@ -0,0 +1,18 @@
+export function validateFiniteDelayInMilliseconds(delayInMilliseconds) {
+    if (!Number.isFinite(delayInMilliseconds)) {
+        throw new TypeError('Invalid delay, must be a finite number');
+    }
+}
+export function validateTimeoutDelayInMilliseconds(delayInMilliseconds) {
+    validateFiniteDelayInMilliseconds(delayInMilliseconds);
+    if (delayInMilliseconds < 0) {
+        throw new RangeError(`Invalid timeout delay ${delayInMilliseconds}, must be greater than or equal to 0`);
+    }
+}
+export function validateIntervalDelayInMilliseconds(delayInMilliseconds) {
+    validateFiniteDelayInMilliseconds(delayInMilliseconds);
+    if (delayInMilliseconds <= 0) {
+        throw new RangeError(`Invalid interval delay ${delayInMilliseconds}, must be greater than 0`);
+    }
+}
+//# sourceMappingURL=timer-delay.js.map

package/timer-delay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer-delay.js","sourceRoot":"","sources":["../../../source/timer-delay.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,iCAAiC,CAAC,mBAA2B;IACzE,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,CAAC;QACxC,MAAM,IAAI,SAAS,CAAC,wCAAwC,CAAC,CAAC;IAClE,CAAC;AACL,CAAC;AAED,MAAM,UAAU,kCAAkC,CAAC,mBAA2B;IAC1E,iCAAiC,CAAC,mBAAmB,CAAC,CAAC;IAEvD,IAAI,mBAAmB,GAAG,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,UAAU,CAAC,yBAAyB,mBAAmB,sCAAsC,CAAC,CAAC;IAC7G,CAAC;AACL,CAAC;AAED,MAAM,UAAU,mCAAmC,CAAC,mBAA2B;IAC3E,iCAAiC,CAAC,mBAAmB,CAAC,CAAC;IAEvD,IAAI,mBAAmB,IAAI,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,UAAU,CAAC,0BAA0B,mBAAmB,0BAA0B,CAAC,CAAC;IAClG,CAAC;AACL,CAAC"}

package/readme.md

@@ -1,7 +0,0 @@
-# @enormora/clock
-
-This version is a placeholder published only to claim the npm name `@enormora/clock` so a Trusted Publisher
-can subsequently be configured for it. It contains no real package content and is published already
-deprecated.
-
-Workaround context: https://github.com/npm/cli/issues/8544