@stringsync/splates 0.0.60 → 1.13.3

package/vendor/core/system/ip-provider/darwin-ip-provider.d.ts

@@ -0,0 +1,6 @@
+import type { IpProvider, IpProviderOptions } from "./ip-provider";
+export declare class DarwinIpProvider implements IpProvider {
+    private readonly ps;
+    constructor(opts?: IpProviderOptions);
+    get(): Promise<string>;
+}

package/vendor/core/system/ip-provider/ip-provider.d.ts

@@ -0,0 +1,8 @@
+import type { Ps } from "../ps/ps";
+export interface IpProvider {
+    get(): Promise<string>;
+}
+/** What an ip provider asks about the machine; the real process by default. */
+export interface IpProviderOptions {
+    ps?: Ps;
+}

package/vendor/core/system/ip-provider/linux-ip-provider.d.ts

@@ -0,0 +1,6 @@
+import type { IpProvider, IpProviderOptions } from "./ip-provider";
+export declare class LinuxIpProvider implements IpProvider {
+    private readonly ps;
+    constructor(opts?: IpProviderOptions);
+    get(): Promise<string>;
+}

package/vendor/core/system/ip-provider/platform-ip-provider.d.ts

@@ -0,0 +1,6 @@
+import type { IpProvider, IpProviderOptions } from "./ip-provider";
+export declare class PlatformIpProvider implements IpProvider {
+    private readonly provider;
+    constructor(opts?: IpProviderOptions);
+    get(): Promise<string>;
+}

package/vendor/core/system/ip-provider/sequential-ip-provider.d.ts

@@ -0,0 +1,6 @@
+import type { IpProvider } from "./ip-provider";
+export declare class SequentialIpProvider implements IpProvider {
+    private readonly ipProviders;
+    constructor(ipProviders: IpProvider[]);
+    get(): Promise<string>;
+}

package/vendor/core/system/ip-provider/static-ip-provider.d.ts

@@ -0,0 +1,8 @@
+import type { IpProvider } from "./ip-provider";
+export declare class StaticIpProvider implements IpProvider {
+    private readonly ip;
+    constructor(ip: string);
+    static localhost(): StaticIpProvider;
+    static empty(): StaticIpProvider;
+    get(): Promise<string>;
+}

package/vendor/core/system/ip-provider/win32-ip-provider.d.ts

@@ -0,0 +1,6 @@
+import type { IpProvider, IpProviderOptions } from "./ip-provider";
+export declare class Win32IpProvider implements IpProvider {
+    private readonly ps;
+    constructor(opts?: IpProviderOptions);
+    get(): Promise<string>;
+}

package/vendor/core/system/lock/file-lock.d.ts

@@ -0,0 +1,50 @@
+import { type Logger } from "../../log/index.js";
+import type { Fs } from "../fs/fs";
+import type { Ps } from "../ps/ps";
+import type { Lock } from "./lock";
+export interface FileLockOptions {
+    /** How long a holder on another host may hold the lock before it can be stolen. */
+    stalenessMs?: number;
+    /**
+     * Judge a holder by its pid alone, whatever hostname it was written under,
+     * for hosts whose hostname changes (macOS flips it with the network).
+     */
+    pidOnly?: boolean;
+    /** How often to re-check a lock that is already taken. */
+    pollMs?: number;
+    fs?: Fs;
+    ps?: Ps;
+    log?: Logger;
+}
+/**
+ * A mutex between processes, held by a directory on disk. A holder that died
+ * is detected and its lock stolen, and the directory is removed on signals and
+ * uncaught exceptions.
+ */
+export declare class FileLock implements Lock {
+    readonly path: string;
+    private held;
+    /** The process listeners that remove the lock, while it is held. */
+    private listeners;
+    private readonly stalenessMs;
+    private readonly pollMs;
+    private readonly pidOnly;
+    private readonly fs;
+    private readonly ps;
+    private readonly log;
+    constructor(path: string, opts?: FileLockOptions);
+    acquire(): Promise<void>;
+    release(): Promise<void>;
+    releaseIfOurs(): Promise<void>;
+    private get holderPath();
+    private holder;
+    private isStale;
+    private sameHost;
+    private steal;
+    /**
+     * A crashed holder that never releases wedges every other waiter, so the
+     * removal has to survive signals and uncaught exceptions. It is sync
+     * because exit handlers cannot await.
+     */
+    private registerCleanup;
+}

package/vendor/core/system/lock/lock.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Lock is a mutex seam. `acquire` blocks until the lock is free: there is
+ * deliberately no "busy" return, so callers cannot wander off and do work they
+ * are not holding the lock for.
+ */
+export interface Lock {
+    acquire(): Promise<void>;
+    release(): Promise<void>;
+    /** Releases only if this process is the recorded holder. */
+    releaseIfOurs(): Promise<void>;
+}

package/vendor/core/system/lock/memory-lock.d.ts

@@ -0,0 +1,13 @@
+import type { Lock } from "./lock";
+/**
+ * A mutex between callers inside one process, held by nothing but this object.
+ * Contenders have to share the instance, since there is no path or pid for a
+ * second one to find. Waiters are served in the order they arrived.
+ */
+export declare class MemoryLock implements Lock {
+    private tail;
+    private handOff;
+    acquire(): Promise<void>;
+    release(): Promise<void>;
+    releaseIfOurs(): Promise<void>;
+}

package/vendor/core/system/port-provider/open-port-provider.d.ts

@@ -0,0 +1,38 @@
+import type { PortProvider } from "./port-provider";
+/** The highest port there is; a range naming one past it cannot be served. */
+export declare const MAX_PORT = 65535;
+/** Where the port will be bound, when that is narrower than every interface. */
+export interface PortHost {
+    /**
+     * The address the port is for, such as 127.0.0.1. Set it when that is where
+     * the port will be bound: a port something holds on that one address can
+     * still look open on every interface, so it is probed there as well.
+     */
+    host?: string;
+}
+/** The ports to consider, `to` included; `to` left out means `from` alone. */
+export interface PortRange extends PortHost {
+    from: number;
+    to?: number;
+}
+/** How many ports to consider, counting `from` itself. */
+export interface PortSpan extends PortHost {
+    from: number;
+    span: number;
+}
+/**
+ * Finds an open port by binding one and letting it go again, which is the only
+ * way to ask the machine rather than guess at what it is running.
+ */
+export declare class OpenPortProvider implements PortProvider {
+    private readonly from;
+    private readonly to;
+    private readonly host;
+    constructor({ from, to, host }: PortRange);
+    /** `span` ports from `from` on, which is what a dev server wants. */
+    static span({ from, span, host }: PortSpan): OpenPortProvider;
+    /** Any port at all: 0 comes back, and whatever binds it is what chooses. */
+    static any(): OpenPortProvider;
+    get(): Promise<number>;
+    private open;
+}

package/vendor/core/system/port-provider/port-provider.d.ts

@@ -0,0 +1,14 @@
+/**
+ * PortProvider is the seam that answers which port to listen on. Typically,
+ * this is assigned the variable name `ports`.
+ *
+ * Which ports it will consider is the provider's own business, settled when it
+ * is made, so a caller asks the same way whether it wants one exact port or
+ * whatever is open near a preferred one. The port is worth asking for even
+ * when this process is not the one binding it, which is the case for a
+ * database or any other server started as a subprocess.
+ */
+export interface PortProvider {
+    /** An open port, or a throw when there is none to give. */
+    get(): Promise<number>;
+}

package/vendor/core/system/process-like/process-like.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The parts of `process` that NodePs touches. Hand NodePs a `FakeProcess` to
+ * test with real subprocesses and exit codes, while `exit` kills nothing and
+ * signal handlers stay with the test that set them.
+ */
+export interface ProcessLike {
+    platform: NodeJS.Platform;
+    pid: number;
+    argv: string[];
+    env: NodeJS.ProcessEnv;
+    /** `columns` is set only while stdout is a terminal. */
+    stdout?: {
+        columns?: number;
+    };
+    kill(pid: number, signal: 0): boolean;
+    cwd(): string;
+    chdir(path: string): void;
+    exit(code: number): void;
+    on(event: string, handler: (...args: unknown[]) => void): void;
+    once(event: string, handler: () => void): void;
+    off(event: string, handler: (...args: unknown[]) => void): void;
+}

package/vendor/core/system/ps/file-process.d.ts

@@ -0,0 +1,40 @@
+import type { Child, OutputWatcher, SpawnCaptureResult } from "./ps";
+interface FileOptions {
+    cwd?: string;
+    env: NodeJS.ProcessEnv;
+    timeout?: number;
+    signal?: AbortSignal;
+}
+/** Only the Bun process operations the FIFO-backed path needs. */
+export interface FileProcess {
+    pid: number;
+    exitCode: number | null;
+    signalCode: number | NodeJS.Signals | null;
+    exited: Promise<number>;
+    stdin: Pick<Bun.FileSink, "write" | "flush" | "end"> | number | undefined;
+    kill(signal?: NodeJS.Signals): void;
+    unref(): void;
+}
+/** The runtime boundary, also used to reproduce a lost exit without a race. */
+export interface FileRuntime {
+    spawn(argv: string[], opts: FileOptions & {
+        stdin: "pipe" | "inherit";
+        stdout: number;
+        stderr: number;
+    }): FileProcess;
+    reap(pid: number): number | null;
+}
+/** Starts a child with live output streams that survive a lost Bun exit. */
+export declare function fileStart(argv: string[], opts: FileOptions & {
+    stdin?: "pipe" | "inherit";
+    runtime?: FileRuntime;
+}): Child;
+/** Capture waits for both readers, including their final decoder flush. */
+export declare function fileCapture(argv: string[], opts: FileOptions & {
+    input?: string;
+    watcher?: OutputWatcher;
+    runtime?: FileRuntime;
+}): Promise<SpawnCaptureResult>;
+/** Closing input after a child exits is normal, not a failed command. */
+export declare function ignoreClosedInput(error: unknown): void;
+export {};

package/vendor/core/system/ps/listening.d.ts

@@ -0,0 +1,20 @@
+import type { ListeningEntry } from "./ps";
+/** A listening socket, before its process's working directory is read. */
+export type Listener = Omit<ListeningEntry, "cwd">;
+/**
+ * The listening sockets in what `lsof -nP -iTCP -sTCP:LISTEN -Fpn` printed:
+ * a `p<pid>` line for each process, then an `n<host>:<port>` line for each
+ * of its sockets, among `f<fd>` lines. A socket on both IPv4 and IPv6 is
+ * listed once for each.
+ */
+export declare function parseLsof(stdout: string): Listener[];
+/**
+ * The listening sockets in what `ss -Hltnp` printed, a line each, the local
+ * address fourth and the process last, as `users:(("node",pid=12,fd=20))`.
+ */
+export declare function parseSs(stdout: string): Listener[];
+/**
+ * Each process's working directory in what `lsof -a -d cwd -p <pids> -Fpn`
+ * printed: a `p<pid>` line, then its `n<path>` line.
+ */
+export declare function parseLsofCwds(stdout: string): Map<number, string>;

package/vendor/core/system/ps/node-ps.d.ts

@@ -0,0 +1,39 @@
+import { type Resource } from "../../disposable/index.js";
+import type { ProcessLike } from "../process-like/process-like";
+import type { Child, ListeningEntry, ProcessEntry, Ps, SpawnCaptureResult, SpawnOptions, SpawnResult, StartOptions, TerminalChild, TerminalOptions } from "./ps";
+/** What a `NodePs` speaks to; the running process by default. */
+export interface NodePsOptions {
+    proc?: ProcessLike;
+}
+export declare class NodePs implements Ps {
+    platform: NodeJS.Platform;
+    pid: number;
+    hostname: string;
+    args: string[];
+    self: string[];
+    private readonly proc;
+    constructor(opts?: NodePsOptions);
+    alive(pid: number): boolean;
+    spawn(argv: string[], opts?: SpawnOptions): Promise<SpawnResult>;
+    spawnCapture(argv: string[], opts?: SpawnOptions): Promise<SpawnCaptureResult>;
+    start(argv: string[], opts?: StartOptions): Child;
+    startOnTerminal(argv: string[], opts: TerminalOptions): TerminalChild;
+    processes(): Promise<ProcessEntry[]>;
+    listening(): Promise<ListeningEntry[]>;
+    /**
+     * Node replaces the whole environment when `env` is given, so a command
+     * launched with the caller's two or three variables would have no PATH and
+     * no HOME. Callers mean "and these as well", so that is what this does.
+     *
+     * Always built from `proc.env` rather than left undefined for Node to
+     * inherit, so what a child sees comes through the seam either way.
+     */
+    private options;
+    cwd(): string;
+    env(name: string): string | undefined;
+    columns(): number | undefined;
+    cd(path: string): void;
+    exit(code: number): void;
+    on(signal: string, handler: () => void): Resource;
+    once(event: "exit", handler: () => void): Resource;
+}

package/vendor/core/system/ps/ps.d.ts

@@ -0,0 +1,161 @@
+import type { Resource } from "../../disposable/index.js";
+/**
+ * Ps is the process seam. Typically, this is assigned the variable name `ps`.
+ */
+export interface Ps {
+    platform: NodeJS.Platform;
+    pid: number;
+    hostname: string;
+    /**
+     * What the program was invoked with, past the runtime and the script: the
+     * arguments a cli parses.
+     */
+    args: string[];
+    /**
+     * The runtime and the entry point this program runs as, ahead of `args`:
+     * what starts it again, as a supervisor restarting its child does.
+     */
+    self: string[];
+    /** Whether a pid on *this* host is still running. */
+    alive(pid: number): boolean;
+    spawn(argv: string[], opts?: SpawnOptions): Promise<SpawnResult>;
+    spawnCapture(argv: string[], opts?: SpawnOptions): Promise<SpawnCaptureResult>;
+    /**
+     * Starts `argv` with its stdin, stdout and stderr left open as streams, for
+     * a child spoken to while it runs, as over a protocol on its stdio. A
+     * child blocks on writing once its unread output fills its pipe. One that
+     * cannot start, its program or cwd missing, still returns: its output
+     * streams error, and `exited` rejects with why.
+     */
+    start(argv: string[], opts?: StartOptions): Child;
+    /**
+     * Starts `argv` on a pseudo-terminal of its own, the way a terminal window
+     * runs a shell, as its controlling terminal so ^C and resizes reach the
+     * job in front. POSIX on Bun only, since `Bun.Terminal` is.
+     */
+    startOnTerminal(argv: string[], opts: TerminalOptions): TerminalChild;
+    /**
+     * Every process on this host, as `ps` lists them; none on Windows. For
+     * what runs under a child: its descendants, and its terminal's job.
+     */
+    processes(): Promise<ProcessEntry[]>;
+    /**
+     * Every TCP port a process on this host listens on, as `lsof` lists them
+     * (or `ss`, on Linux without it), with where each process runs; none on
+     * Windows. With `processes`, what a child's tree serves, as an editor
+     * finds the ports to forward.
+     */
+    listening(): Promise<ListeningEntry[]>;
+    /** The working directory, as `cd` last left it. */
+    cwd(): string;
+    env(name: string): string | undefined;
+    /**
+     * How many columns wide the terminal stdout writes to is, for text laid out
+     * to fit it; undefined when stdout is not a terminal, as when piped.
+     */
+    columns(): number | undefined;
+    cd(path: string): void;
+    exit(code: number): void;
+    /** Listens until the returned resource is disposed. */
+    on(signal: string, handler: (...args: unknown[]) => void): Resource;
+    once(event: "exit", handler: () => void): Resource;
+}
+export interface SpawnOptions {
+    /** Added to the current environment, not a replacement for it. */
+    env?: Record<string, string>;
+    /**
+     * Taken out of the environment the child inherits, so it sees them unset
+     * rather than empty. `env` wins over it for a name in both.
+     */
+    unset?: string[];
+    cwd?: string;
+    /**
+     * Written to the child's stdin, which is then closed. Without it the child
+     * shares this process's stdin. Only `spawnCapture` honors it.
+     */
+    stdin?: string;
+    /** Kills the child with SIGTERM once it has run this long. */
+    timeoutMs?: number;
+    /** Kills the child with SIGTERM when it aborts, and rejects the spawn. */
+    signal?: AbortSignal;
+    /**
+     * Sees the output as it arrives, for progress on a long command. The
+     * result still holds all of it. Only `spawnCapture` honors it.
+     */
+    watcher?: OutputWatcher;
+}
+/** What watches a spawned command's output as it comes. */
+export interface OutputWatcher {
+    stdout(chunk: string): void;
+    stderr(chunk: string): void;
+}
+export interface SpawnResult {
+    exitCode: number;
+}
+export interface SpawnCaptureResult extends SpawnResult {
+    stdout: string;
+    stderr: string;
+}
+/** What `start` honors of a spawn's options: none that wait for the end. */
+export type StartOptions = Omit<SpawnOptions, "stdin" | "watcher">;
+/** Where and how big a terminal starts. */
+export interface TerminalOptions extends StartOptions {
+    cols: number;
+    rows: number;
+}
+/** A process `processes` lists. */
+export interface ProcessEntry {
+    pid: number;
+    /** Its parent's pid. */
+    ppid: number;
+    /** Its process group. */
+    pgid: number;
+    /**
+     * The process group in front on its controlling terminal, the job that
+     * keys reach; 0 or less for one without a terminal.
+     */
+    tpgid: number;
+    /** What it runs, its arguments joined by spaces. */
+    command: string;
+}
+/** One TCP socket a process listens on, as `Ps.listening` lists it. */
+export interface ListeningEntry {
+    pid: number;
+    /**
+     * The address it is bound to, as listed: `*` for every IPv4 and IPv6
+     * address, `127.0.0.1`, or an IPv6 one in brackets, as `[::1]`.
+     */
+    host: string;
+    port: number;
+    /** The listening process's working directory, or null when it cannot be read. */
+    cwd: string | null;
+}
+/** A child still running, its stdio open: bytes in, bytes out. */
+export interface Child {
+    /** Its pid; null for one that never started. */
+    pid: number | null;
+    stdin: WritableStream<Uint8Array>;
+    stdout: ReadableStream<Uint8Array>;
+    stderr: ReadableStream<Uint8Array>;
+    /** Its exit code once it is gone, 128 + the signal for one killed. */
+    exited: Promise<number>;
+    /** Sends it `signal`, SIGTERM by default; nothing once it has exited. */
+    kill(signal?: NodeJS.Signals): void;
+}
+/** A child on a terminal: what it writes, and keys typed at it. */
+export interface TerminalChild {
+    /** The pid of the program it runs. */
+    pid: number;
+    /** What the child writes to its terminal; ends once the terminal closes. */
+    output: ReadableStream<Uint8Array>;
+    /** Types `data` at the child, keys and pastes alike. */
+    write(data: string | Uint8Array): void;
+    /** What a window resize does: the child hears of it as SIGWINCH. */
+    resize(cols: number, rows: number): void;
+    /** Its exit code once it is gone, 128 + the signal for one killed. */
+    exited: Promise<number>;
+    /** Sends it `signal`, SIGTERM by default; nothing once it has exited. */
+    kill(signal?: NodeJS.Signals): void;
+    /** Closes the terminal, after which writes and resizes do nothing. */
+    close(): void;
+}

package/vendor/core/system/ps/reap.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Collects a child's exit status from the kernel, for the runtime that can lose
+ * it: call it with the child's pid when its `close` never comes.
+ *
+ * Returns the raw wait status for `decode`, or null while the child runs or
+ * once someone else has reaped it. The whole thing is null where exits are not
+ * lost: Node, and Bun anywhere but macOS.
+ */
+export declare const reap: ((pid: number) => number | null) | null;
+/** A wait status as a shell reports it: the exit code, or 128 + the signal. */
+export declare function decode(status: number): number;
+/** The runtime and kernel race to report an exit; neither may hold up the other. */
+export declare function exitOf(child: {
+    pid: number;
+    exitCode: number | null;
+    signalCode: number | NodeJS.Signals | null;
+    exited: Promise<number>;
+}, kernel: {
+    reap(pid: number): number | null;
+}): Promise<number>;
+/** Shell status for either a normal exit or a signal death. */
+export declare function shellCode(code: number | null, signal: number | NodeJS.Signals | null): number;

package/vendor/core/system/undumpable.d.ts

@@ -0,0 +1,32 @@
+/** What `makeUndumpable` could do on this platform. */
+export type Undumpable = {
+    undumpable: true;
+    how: string;
+} | {
+    undumpable: false;
+    why: string;
+};
+/** Which platform `makeUndumpable` acts for; this process's by default. */
+export interface MakeUndumpableOptions {
+    platform?: NodeJS.Platform;
+}
+/**
+ * Keeps other processes of the same user out of this one's memory, for a
+ * process holding secrets beside programs it does not trust, such as a
+ * daemon keeping API keys while agents run as its own user. Call it once, at
+ * start, before the process holds a secret: it cannot be undone.
+ *
+ * On Linux it clears the process's dumpable flag, so no process but root's
+ * can ptrace it or read `/proc/<pid>/mem` or `/proc/<pid>/environ`, and it
+ * leaves no core dump; it checks the flag took. On macOS it denies debuggers
+ * the right to attach, which stops `lldb` and `ptrace`, though not root; a
+ * Bun signed with the hardened runtime, as released, refuses them already,
+ * and this keeps a locally built or re-signed one the same.
+ * Elsewhere it does nothing and says why. It throws when the call fails
+ * where it should work, since a caller relying on it must not carry on
+ * unguarded.
+ *
+ * Children are not covered: the flag returns with each program they run, so
+ * the programs it spawns can be ptraced as usual.
+ */
+export declare function makeUndumpable(opts?: MakeUndumpableOptions): Promise<Undumpable>;

package/vendor/core/system/walk.d.ts

@@ -0,0 +1,10 @@
+import type { Fs } from "./fs/fs";
+/**
+ * Yields the path of every file under `dir`, recursively. Dotfiles and
+ * `node_modules` are skipped, so what comes back is a project's own source.
+ */
+export interface WalkOptions {
+    /** The filesystem to read; the real one by default. */
+    fs?: Fs;
+}
+export declare function walk(dir: string, opts?: WalkOptions): AsyncGenerator<string>;

package/vendor/core/time/clock/clock.d.ts

@@ -0,0 +1,5 @@
+import type { Duration } from "../duration";
+/** A source of "now", read on demand. Subtract two readings for a duration. */
+export interface Clock {
+    now(): Duration;
+}

package/vendor/core/time/clock/system-clock.d.ts

@@ -0,0 +1,5 @@
+import { Duration } from "../duration";
+import type { Clock } from "./clock";
+export declare class SystemClock implements Clock {
+    now(): Duration;
+}

package/vendor/core/time/debouncer.d.ts

@@ -0,0 +1,25 @@
+import type { Resource } from "../disposable/index.js";
+import type { Duration } from "./duration";
+import type { Timer } from "./timer/timer";
+/**
+ * Runs the last function it was given once the calls stop, waiting `delay`
+ * after each one. A burst of calls does the work once, at the end.
+ *
+ * ```ts
+ * const debouncer = new Debouncer(new SystemTimer(), Duration.ms(300));
+ * input.addEventListener("input", () => debouncer.call(() => search(input.value)));
+ * ```
+ */
+export declare class Debouncer implements Resource {
+    private readonly timer;
+    private readonly delay;
+    private pending;
+    private fn;
+    constructor(timer: Timer, delay: Duration);
+    call(fn: () => void): void;
+    /** Runs whatever is waiting right now, if anything. */
+    flush(): void;
+    /** Drops whatever is waiting, unrun. */
+    cancel(): void;
+    dispose(): void;
+}

package/vendor/core/time/duration.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A length of time, held as milliseconds. Durations are values: every operation
+ * returns a new one, so passing one around cannot change it under the caller.
+ * Taking a `Duration` rather than a bare number also stops the unit question
+ * (seconds? millis?) from being asked at every call site.
+ */
+export declare class Duration {
+    private readonly _ms;
+    private constructor();
+    static zero(): Duration;
+    static ms(ms: number): Duration;
+    static secs(secs: number): Duration;
+    static mins(mins: number): Duration;
+    static hrs(hrs: number): Duration;
+    static days(days: number): Duration;
+    static min(...durations: Duration[]): Duration;
+    static max(...durations: Duration[]): Duration;
+    get ms(): number;
+    get secs(): number;
+    get mins(): number;
+    get hrs(): number;
+    isEqual(other: Duration): boolean;
+    isLessThan(other: Duration): boolean;
+    isGreaterThan(other: Duration): boolean;
+    isLessThanOrEqual(other: Duration): boolean;
+    isGreaterThanOrEqual(other: Duration): boolean;
+    add(other: Duration): Duration;
+    subtract(other: Duration): Duration;
+    multiply(factor: number): Duration;
+    clamp(min: Duration, max: Duration): Duration;
+    negate(): Duration;
+    toString(): string;
+    /**
+     * Precision drops as the number grows, because nobody reading minutes cares
+     * about the milliseconds.
+     */
+    human(): string;
+}

package/vendor/core/time/index.d.ts

@@ -0,0 +1,13 @@
+export type { Clock } from "./clock/clock";
+export { SystemClock } from "./clock/system-clock";
+export { Debouncer } from "./debouncer";
+export { Duration } from "./duration";
+export { sleep } from "./sleep";
+export { Stopwatch } from "./stopwatch";
+export { Throttler } from "./throttler";
+export { timeAgo } from "./time-ago";
+export { timeouts } from "./timeouts";
+export { SystemTimer } from "./timer/system-timer";
+export type { Timer } from "./timer/timer";
+export { SystemWallClock } from "./wall-clock/system-wall-clock";
+export type { WallClock } from "./wall-clock/wall-clock";