@nimbus-sh/platform 0.7.1 → 0.8.1

package/dist/wave-writer.d.ts

@@ -0,0 +1,392 @@
+/**
+ * wave-writer.ts — a producer's writes into the session, as W7 waves.
+ *
+ * The one W7 producer: git's network facet (a clone's files, fetch and
+ * pull's objects and refs), npm's install facet (package files), and the
+ * session's own bulk writes (npm bin shims, the clang sysroot). Each write
+ * is a record: a file, a link, a directory, or a removal. The writer buffers
+ * records into a wave and publishes the wave through one writeBatchStream()
+ * call. A wave closes before it would pass W7's owned-path bounds (count and
+ * bytes: files, removals and the directories above them, up to the root) or
+ * its byte budget; a file larger than the budget travels in a wave of its
+ * own, and one streamed from a source is never held whole.
+ *
+ * Pipelining: one wave is in flight while the next one buffers. A wave
+ * starts only once its predecessor has published, so a producer waits only
+ * when it fills a second wave, and a failed wave is the last this writer
+ * sends: the failure names its wave, and every later call rejects with it.
+ * Waves publish in order, so a record written after another is durable only
+ * if that one is: a completion marker written last proves what came before.
+ *
+ * Lost transport (lost-call.ts, the one policy for it): a wave whose call
+ * failed before the session answered (isLostFencedCall), or that nothing
+ * read for LOST_STREAM_STALL_MS before its end, or that stayed unanswered
+ * LOST_STREAM_ANSWER_MS after it, is sent again after a backoff, at most
+ * LOST_CALL_RESEND_BACKOFF_MS.length times. The abandoned attempt's stream
+ * is errored so it reads nothing more, and every attempt carries its fence
+ * (writer, wave, attempt): the session refuses an attempt older than one it
+ * has seen, so a late original never applies over its re-send.
+ * Re-sending is safe: a wave is the same paths and bytes, replacing. A shed
+ * wave never ran; the platform's advice is not to retry an overloaded
+ * object, but these waves are few and backed off, and npm measured the
+ * re-send recover a 119-package install that otherwise lost 31 packages to
+ * one shed. A wave the session answered (ok: false) is its verdict and is
+ * never retried, nor is a wave with a streamed source (its source is spent).
+ *
+ * Fault domains: with `failPerOwner`, a record's `meta` is its owner (an
+ * npm package), and a failed wave whose records all have owners fails those
+ * owners (their later records reject, their buffered ones are not sent)
+ * while the writer goes on for the rest. Otherwise, and for a failed wave
+ * carrying anything unowned (a directory or removal record, the pin, a
+ * record without meta), the failed wave is the last one sent. A write that
+ * supersedes a buffered record (the same path, written again before a cut)
+ * settles it: the wave carrying the later write publishes or fails the
+ * owners of both. An owner is published once every wave that carried its
+ * writes has (`published`).
+ *
+ * Admitting a record costs its own new directories, never a recount of the
+ * wave: the owned set grows as records arrive, and a directory chain walk
+ * stops at the first directory already owned (whose chain is owned).
+ * Records may be written concurrently (an install writes several packages
+ * at once): each is admitted and buffered in call order.
+ *
+ * Several writers may publish into one session at once (a clone's parallel
+ * producers); each is its own stream, and the session takes them
+ * concurrently.
+ */
+/** Paths a wave holds back from W7's bound, for its pinned marker and the marker's directories. */
+export declare const WAVE_PATHS: number;
+export declare const WAVE_PATH_BYTES: number;
+/** Buffered content bytes that close a wave. */
+export declare const WAVE_BYTES: number;
+/**
+ * Which attempt of which wave under which writer epoch a stream is. The
+ * session issued the epoch (openWaveWriter) and refuses, by default, an
+ * attempt under an epoch it does not hold open, or older than one it has
+ * admitted under it: an attempt the writer gave up on never applies after
+ * its re-send, however late it arrives.
+ */
+export interface WaveFence {
+    writer: string;
+    wave: number;
+    attempt: number;
+    /**
+     * A sequenced writer's wave (a process's filesystem client): the number of
+     * its first op, each op after it the next, and the highest cursor the
+     * writer has had answered. The session keeps the writer's cursor with its
+     * commits, so an op a re-send carries again is answered, not applied twice.
+     */
+    seq?: number;
+    ack?: number;
+}
+/** The supervisor surface a writer publishes through. */
+export interface WaveSupervisor {
+    /**
+     * `fence` is absent when the supervisor issued no epoch: the session
+     * fences nothing. `owner`: the delegation the wave is written under, when
+     * it is not the one the binding was made with.
+     */
+    writeBatchStream(stream: ReadableStream<Uint8Array>, fence?: WaveFence, owner?: string): Promise<unknown>;
+    /**
+     * A writer epoch from the session, the only identity it admits fenced
+     * waves under, or null when it fences nothing. Absent on a supervisor
+     * that is the session itself (nothing between them can lose a call).
+     */
+    openWaveWriter?(): Promise<string | null>;
+}
+/** A published file as the session will stat it: what a warm index entry needs. */
+export interface WaveFileReceipt {
+    path: string;
+    ino: number;
+    mode: number;
+    size: number;
+    mtimeMs: number;
+    ctimeMs: number;
+    uid: number;
+    gid: number;
+    dev: number;
+}
+export interface WaveReport {
+    wave: number;
+    files: number;
+    bytes: number;
+    rpcWallMs: number;
+    receipts: WaveFileReceipt[];
+}
+/** What one wave carried, for the caller's own view of the paths it published. */
+export interface WaveCut<Meta> {
+    wave: number;
+    mtimeMs: number;
+    /** Each file and link, with what its caller attached to the record. */
+    files: {
+        path: string;
+        meta: Meta | undefined;
+    }[];
+    directories: string[];
+}
+export interface WaveWriterOptions<Meta = undefined> {
+    supervisor: WaveSupervisor;
+    /**
+     * The directory a wave publishes up to, inclusive: a record's directories
+     * above it are not the writer's. Null publishes every ancestor.
+     */
+    root: string | null;
+    /** An existing worktree: only directories strictly below it are published. */
+    worktreeRoot?: string | null;
+    /** Record paths are relative to it (joined with '/'); omitted, they are VFS paths. */
+    base?: string;
+    /** Wall-clock time (ms) after which no new wave starts. */
+    deadline?: number | null;
+    /** Every inode's mtime; omitted, each wave stamps the time it was cut. */
+    mtimeMs?: number;
+    /** A directory's mode, as the caller knows it; omitted or undefined, 0o755. */
+    directoryMode?: (path: string) => number | undefined;
+    /** Called synchronously as a wave is cut, before it is sent. */
+    onCut?: (cut: WaveCut<Meta>) => void;
+    /** Called once per published wave, in order. */
+    onWave?: (report: WaveReport) => void;
+    /** A record's `meta` names its owner, and a failed wave fails only the owners it carried. */
+    failPerOwner?: boolean;
+    /** The lost-call policy's timings (lost-call.ts); tests shorten them. */
+    retry?: {
+        backoffMs: readonly number[];
+        stallMs: number;
+        answerDeadlineMs: number;
+    };
+    /** Called before each re-send of a lost wave, with its lost-call attributes (lost-call.ts). */
+    onResend?: (lost: Record<string, string | number>) => void;
+}
+export interface WaveStats {
+    waves: number;
+    files: number;
+    bytes: number;
+    rpcWallMs: number;
+    maxRpcWallMs: number;
+    producerWaitMs: number;
+    /** Paths probed by ownership accounting: linear in records, never wave × records. */
+    ownershipVisits: number;
+    maxWavePaths: number;
+    maxWaveBytes: number;
+    /** Waves sent again after their transport was lost. */
+    retries: number;
+    /** Waves encoded whole before they were sent (the rest streamed as encoded). */
+    wholeWaves: number;
+}
+export declare class WaveFailure extends Error {
+    readonly wave: number;
+    constructor(wave: number, cause: unknown);
+}
+export declare class WaveWriter<Meta = undefined> {
+    private readonly options;
+    private readonly records;
+    private readonly directories;
+    private readonly deletes;
+    private bufferedBytes;
+    private symlinks;
+    /** Links in the wave in flight: sent, not yet published. */
+    private inFlightSymlinks;
+    /** Every path the buffered wave publishes; a superset once a buffered record is removed. */
+    private readonly owned;
+    /** The upward-closed part of `owned`: each one's chain, to the root, is owned too. */
+    private readonly ownedDirectories;
+    private ownedPathBytes;
+    private pin;
+    private inFlight;
+    private cutQueue;
+    private sequence;
+    private failure;
+    /** Owners (records' `meta`) whose records a failed wave carried. */
+    private readonly failedOwners;
+    /** With `failPerOwner`: owners with a write in the buffered wave, superseded ones included. */
+    private readonly bufferedOwners;
+    /** With `failPerOwner`: the last wave that carried each owner's writes. */
+    private readonly ownerWaves;
+    /** Waves publish in order: every wave up to this one has settled, this one published. */
+    private lastPublishedWave;
+    private readonly counters;
+    /** The session's epoch for this writer, and when it was opened (null: unfenced). */
+    private epoch;
+    /** Mutations run one at a time, in call order: concurrent writers interleave by record. */
+    private mutations;
+    constructor(options: WaveWriterOptions<Meta>);
+    /** Run `mutate` once every mutation called before it has finished. */
+    private exclusive;
+    /**
+     * A regular file, with its permission bits as given (`mode & 0o7777`). The
+     * writer takes `bytes`; a view sharing its buffer is copied. `meta` rides
+     * with the record, back to the caller as it is cut.
+     */
+    file(path: string, mode: number, bytes: Uint8Array, meta?: Meta): Promise<void>;
+    /** A symbolic link to `target`. */
+    symlink(path: string, target: string, meta?: Meta): Promise<void>;
+    /**
+     * A regular file of `size` bytes read from `chunks` as its wave drains:
+     * the buffered wave is sent first, then this file travels alone, and the
+     * call resolves once its source is consumed.
+     */
+    fileChunks(path: string, mode: number, size: number, chunks: AsyncIterable<Uint8Array>, meta?: Meta): Promise<void>;
+    /** A directory (an empty one, a gitlink): files' directories need no record. */
+    directory(path: string): Promise<void>;
+    /**
+     * Remove what stands at `path`, its subtree included. A buffered record at
+     * the path is dropped; with `directory`, a buffered mkdir of it too.
+     */
+    remove(path: string, directory?: boolean): Promise<void>;
+    /**
+     * A file every wave re-asserts until a wave carrying it publishes (a
+     * clone's ownership marker): parent directories publish independently of
+     * files, so each wave leaves the marker's proof in place. `durable` says
+     * these bytes are already published.
+     */
+    setPin(path: string, text: string, durable?: boolean): void;
+    clearPin(path: string): void;
+    /** The bytes buffered at `path`, if a file or link is. */
+    buffered(path: string): Uint8Array | undefined;
+    /** The buffered file or link at `path`: its kind, size and the caller's `meta`. */
+    bufferedRecord(path: string): {
+        kind: 'file' | 'symlink';
+        size: number;
+        meta: Meta | undefined;
+    } | undefined;
+    isBufferedDirectory(path: string): boolean;
+    isBufferedDelete(path: string): boolean;
+    bufferedPaths(): {
+        files: Iterable<string>;
+        directories: Iterable<string>;
+        deletes: Iterable<string>;
+    };
+    /** Whether a link is buffered or in flight: written, not yet published. */
+    get hasUnpublishedSymlinks(): boolean;
+    /** Every record written before this call is durable; rejects with the first failed wave. */
+    flush(): Promise<void>;
+    /** The wave in flight has settled; nothing new is cut. */
+    settled(): Promise<void>;
+    assertHealthy(): void;
+    /** The failure of the wave that carried `owner`'s records, if one failed. */
+    failureOf(owner: Meta): WaveFailure | undefined;
+    /**
+     * Whether every record written with `owner` (as `meta`, under
+     * `failPerOwner`) is durable: each wave that carried it, or a write
+     * superseding it, published.
+     */
+    published(owner: Meta): boolean;
+    private assertOwnerHealthy;
+    get failed(): WaveFailure | null;
+    stats(): WaveStats;
+    private key;
+    private tally;
+    private hasBuffered;
+    private ownPath;
+    /** collectDirectoryPaths' chain from `path` upward, to the first directory already owned. */
+    private walkChain;
+    /**
+     * Send what is buffered when a removal of `path` is pending in it: a wave
+     * names a path once, and what is made there must land after the removal,
+     * as rm then create does (the directory's permission decides, not the old
+     * file's mode).
+     */
+    private afterRemoval;
+    /** Cut waves until `path` (with its chain) and `bytes` fit beside what is buffered. */
+    private admit;
+    private buffer;
+    private drop;
+    private cutIfFull;
+    /**
+     * Send the buffered wave once the one in flight has published. Cuts are
+     * serialised, so at most one wave is in flight and one buffers.
+     */
+    private cut;
+    private cutNow;
+    /**
+     * How a wave of `bytes` content crosses: an attempt's stream, made anew
+     * for each attempt.
+     *
+     * Across a transport (a supervisor that opens epochs), a wave held in
+     * memory is encoded whole before it is sent, and the transport takes it in
+     * SEND_SLICE_BYTES pieces, never waiting on the encoder. A re-send sends
+     * the same bytes, and the wave's records are let go once it is encoded.
+     * Measured, eight producers into one session, Markflow's file sizes: the
+     * encoder's stream, pulled through the watchdog as the transport read it,
+     * took 1,002 files/s; the wave encoded first, 1,374 (re-chunking that
+     * stream to 64 KiB or 1 MiB gained nothing). A wave with a streamed
+     * source is never held whole, nor is a lone file larger than a wave, and a
+     * session's own writer has no transport to wait on: they stream as the
+     * encoder makes them.
+     */
+    private open;
+    /** Send one wave (sendWaveAttempts) under this writer's epoch. */
+    private sendAttempts;
+    /**
+     * The epoch this writer's waves are fenced under: opened before its first
+     * wave, and again once half of WAVE_EPOCH_TTL_MS has passed, so a wave is
+     * never sent under an epoch about to close. Opened under the lost-call
+     * policy (openWaveEpoch); an open that failed even so is not the writer's
+     * epoch, and the next wave opens again.
+     */
+    private currentEpoch;
+    /** The directories the buffered records publish, shallowest first. */
+    private publishedDirectories;
+    private bufferPin;
+}
+/** An attempt the session never read or never answered: its call did not arrive, or its answer was lost. */
+/** One wave's attempts (sendWaveAttempts). */
+export interface WaveAttempts {
+    supervisor: WaveSupervisor;
+    /** The epoch each attempt is fenced under, asked before each one (null: unfenced). */
+    writer: () => Promise<string | null>;
+    /** A fresh stream of the wave's bytes for each attempt. */
+    open: () => ReadableStream<Uint8Array>;
+    /** A wave with a streamed source is sent once: its source is spent. */
+    streamed: boolean;
+    wave: number;
+    /** A sequenced writer's numbering, on every attempt's fence (WaveFence `seq`, `ack`). */
+    sequence?: {
+        seq: number;
+        ack: number;
+    };
+    /** The delegation the wave is written under (WaveSupervisor.writeBatchStream's `owner`). */
+    owner?: string;
+    /** The lost-call policy's timings (lost-call.ts); tests shorten them. */
+    retry?: {
+        backoffMs: readonly number[];
+        stallMs: number;
+        answerDeadlineMs: number;
+    };
+    /** Told before each re-send, with its lost-call attributes. */
+    resent?: (lost: Record<string, string | number>) => void;
+    /** The timers the watch and the backoff run on: a program's own may be its shims'. */
+    timers?: WaveTimers;
+}
+/** setTimeout and clearTimeout, as a caller captured them. */
+export interface WaveTimers {
+    setTimeout(callback: () => void, ms: number): unknown;
+    clearTimeout(timer: unknown): void;
+}
+/**
+ * Send one wave, again while its transport is lost (see the module's
+ * comment), and answer with what the session answered. The one way every
+ * W7 producer sends: the wave writer, and a process's filesystem client.
+ */
+export declare function sendWaveAttempts(options: WaveAttempts): Promise<unknown>;
+/**
+ * Open a writer epoch (`open`: the supervisor's openWaveWriter, or a
+ * process's openWriter), again while the call is lost or shed, under a
+ * wave's lost-call policy and budget (isLostFencedCall,
+ * LOST_CALL_RESEND_BACKOFF_MS). Re-opening is safe: an open the session
+ * never ran issued nothing, and one whose answer was lost issued an epoch
+ * nothing is sent under, which closes at WAVE_EPOCH_TTL_MS. Anything else
+ * it answered is its verdict. A shed open would otherwise fail every write
+ * the epoch was for, unsent: measured, create-next-app lost 31 of 42
+ * packages to one.
+ */
+export declare function openWaveEpoch(open: () => Promise<string | null>, options?: {
+    retry?: {
+        backoffMs: readonly number[];
+    };
+    resent?: (lost: Record<string, string | number>) => void;
+    timers?: WaveTimers;
+}): Promise<string | null>;
+/** A wave's encoded bytes as each attempt's stream (in SEND_SLICE_BYTES pieces, each a copy). */
+export declare function waveAttemptsOf(bytes: Uint8Array): () => ReadableStream<Uint8Array>;
+export declare function createWaveWriter<Meta = undefined>(options: WaveWriterOptions<Meta>): WaveWriter<Meta>;
+//# sourceMappingURL=wave-writer.d.ts.map

package/dist/wave-writer.d.ts.map

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