@stringsync/splates 0.0.60 → 1.13.3

package/vendor/@stringsync/splates-server/records/home.d.ts

@@ -0,0 +1,72 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs, Ps } from "../../../core/system/index.js";
+import type { Projects } from "../projects";
+import { SqliteStorage } from "../storage";
+/** Where a project's records are stamped with their format, apart from the files they once were. */
+export interface DatabaseStamp {
+    read(): Promise<number | null>;
+    write(format: number): Promise<void>;
+}
+/** What a `ProjectHome` works with. */
+export interface ProjectHomeOptions {
+    fs: Fs;
+    ps: Ps;
+    log: Logger;
+    /** The registry, which keeps the id the checkout's records are under. */
+    projects: Projects;
+}
+/**
+ * Where one checkout's records live: a SQLite database, `state.db`, in
+ * `<splates home>/projects/<id>`, the id the registry keeps against the
+ * checkout's path. The checkout itself holds none, so a clone of it on
+ * another machine is a cache and the splates home the one directory that
+ * matters. Dispose it to close the database it opened.
+ */
+export declare class ProjectHome {
+    /** The main tree's root. */
+    readonly root: string;
+    private readonly opts;
+    private opened;
+    constructor(
+    /** The main tree's root. */
+    root: string, opts: ProjectHomeOptions);
+    /** The project's directory under the splates home, once it has an id. */
+    dir(): Promise<string>;
+    /** Whether the project has a database yet, without making one. */
+    exists(): Promise<boolean>;
+    /** The project's records, made empty when there are none. */
+    open(): Promise<SqliteStorage>;
+    /**
+     * The format stamp kept in the database, which reads null while there is
+     * none. It opens the database only for the moment it reads or writes,
+     * unless it is open already.
+     */
+    stamp(): DatabaseStamp;
+    /**
+     * Copies every file under `legacy`, a project's old `.git/splates`, into
+     * the database, through a file beside it renamed into place, so a database
+     * made is a whole one, and stamps it `format`. Run again, it starts over.
+     */
+    import(legacy: string, format: number): Promise<void>;
+    /**
+     * Leaves the database aside as `state.db.moved`, as the server moves to
+     * `to` (said as a person would read it), so nothing here treats it as the
+     * records any more and a command run here says where they went. A
+     * database left aside before stays, this one named `.moved-2` and on.
+     */
+    moveAside(to: string): Promise<string>;
+    /**
+     * Where `moveAside` said the records went, while there is no database
+     * here; null otherwise, and once a restore has brought records back.
+     */
+    movedTo(): Promise<string | null>;
+    /** Forgets where the records went, as a restore here does. */
+    clearMoved(): Promise<void>;
+    /**
+     * Leaves the old `.git/splates` aside as `.git/splates.moved`, so a
+     * downgrade can find the records as they were, and so nothing treats it as
+     * the records any more.
+     */
+    leaveAside(legacy: string): Promise<void>;
+    dispose(): void;
+}

package/vendor/@stringsync/splates-server/records/index.d.ts

@@ -0,0 +1,10 @@
+export { OpenBoards } from "./elsewhere";
+export type { Action, Escalated, Event, Facts, GatePhases, JudgedNote, LandedCommit, LandedSince, Lifted, NoteApplied, } from "./events";
+export { isEscalation } from "./events";
+export { FORMAT, Format } from "./format";
+export { ProjectHome } from "./home";
+export { Journal } from "./journal";
+export type { MigrationFailure } from "./migration";
+export { LAST_READ, MIGRATING, MIGRATION_LIMIT, Migration, } from "./migration";
+export type { Repository } from "./repository";
+export { migrateRecords, migrationOf, openRepository, recordsMigration, repository, } from "./repository";

package/vendor/@stringsync/splates-server/records/index.js

@@ -0,0 +1,40 @@
+import {
+  ProjectHome2,
+  OpenBoards2,
+  isEscalation2,
+  FORMAT2,
+  Format2,
+  Journal2,
+  Migration2,
+  MIGRATING2,
+  MIGRATION_LIMIT2,
+  LAST_READ2,
+  repository2,
+  migrationOf2,
+  migrateRecords2,
+  recordsMigration2,
+  openRepository2
+} from "../index-caep3sde.js";
+import"../index-01z7ycdk.js";
+import"../index-e9z7s5hh.js";
+import"../index-kmzdvvt0.js";
+import"../index-t9w5a8ed.js";
+import"../index-0jttnv86.js";
+import"../index-g18nxyn7.js";
+export {
+  FORMAT2 as FORMAT,
+  Format2 as Format,
+  Journal2 as Journal,
+  LAST_READ2 as LAST_READ,
+  MIGRATING2 as MIGRATING,
+  MIGRATION_LIMIT2 as MIGRATION_LIMIT,
+  Migration2 as Migration,
+  OpenBoards2 as OpenBoards,
+  ProjectHome2 as ProjectHome,
+  isEscalation2 as isEscalation,
+  migrateRecords2 as migrateRecords,
+  migrationOf2 as migrationOf,
+  openRepository2 as openRepository,
+  recordsMigration2 as recordsMigration,
+  repository2 as repository
+};

package/vendor/@stringsync/splates-server/records/journal.d.ts

@@ -0,0 +1,65 @@
+import { type Ps } from "../../../core/system/index.js";
+import type { Storage, Watch } from "../storage";
+import { type Action, type Event, type Facts, type FactsOf } from "./events";
+/** How long a log file is kept once it fills, so a live conversation can still show the events in it. */
+export declare const LOG_KEPT_MS: number;
+/** What a `Journal` runs with beyond its storage; the real process by default. */
+export interface JournalOptions {
+    ps?: Ps;
+    /**
+     * The conversation each event is logged in, for what `splates server`
+     * does there itself; `SPLATES_CONVERSATION` by default.
+     */
+    conversation?: string;
+}
+/**
+ * What has been done in this repo, oldest first. Events outlive their tasks:
+ * `merge` and `remove` take the record with them, so this is the only thing
+ * that remembers a task existed at all.
+ *
+ * Each event is appended to `log.jsonl`, never rewritten, so two agents
+ * writing at once both keep theirs. Once it holds `capacity` events it is
+ * rotated into a segment in `log`, and a fresh one starts; segments go once
+ * they are `LOG_KEPT_MS` old.
+ */
+export declare class Journal {
+    /** The project's storage, which the journal is kept at the top of. */
+    private readonly storage;
+    private readonly capacity;
+    private readonly log;
+    private readonly ps;
+    private readonly conversation;
+    constructor(
+    /** The project's storage, which the journal is kept at the top of. */
+    storage: Storage, capacity: number, opts?: JournalOptions);
+    /** This journal, logging each event in `conversation`. */
+    in(conversation: string): Journal;
+    /**
+     * Tells of each change where the journal is kept, its own among them,
+     * until disposed; throws when the storage cannot watch it.
+     */
+    watch(): Watch;
+    record<A extends Action, T>(action: A, task: string | null, run: () => Promise<T>, ...[facts]: FactsOf<A, T>): Promise<T>;
+    /**
+     * Logs a wait as it begins, then `record`s how it ended with `began`
+     * naming that first event, so the page can count it down while it runs.
+     */
+    waiting<A extends "wait" | "task wait" | "creds wait", T>(action: A, task: string | null, facts: Omit<Facts[A], "began">, run: () => Promise<T>): Promise<T>;
+    /**
+     * Logs that `action` is under way, before it ends, returning the event's
+     * id for a later event to name as where it began.
+     */
+    begin<A extends "merge queued" | "merge start">(action: A, task: string | null, facts: Facts[A]): Promise<string>;
+    tail(count: number): Promise<Event[]>;
+    /** Every event still kept, the segments' and the log's, oldest first. */
+    all(): Promise<Event[]>;
+    /**
+     * The events in the log and in the file moved aside last: every event
+     * written since a reader last looked, so long as it looks before the log
+     * fills twice over.
+     */
+    recent(): Promise<Event[]>;
+    private append;
+    /** Moves the full log aside, and drops what was moved aside long ago. */
+    private rotate;
+}

package/vendor/@stringsync/splates-server/records/lease-lock.d.ts

@@ -0,0 +1,29 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs, Lock, Ps } from "../../../core/system/index.js";
+/**
+ * The merge lease: a lock held for as long as its holder's process lives, so
+ * a long test run is never judged stale. Release it, or let it go stale once
+ * the process ends. The pid alone decides, whatever hostname the holder was
+ * written under: every holder runs on this machine, whose name macOS changes
+ * with the network. Nothing removes it when the process dies.
+ */
+export declare class LeaseLock implements Lock {
+    readonly path: string;
+    private readonly deps;
+    private held;
+    constructor(path: string, deps: {
+        fs: Fs;
+        ps: Ps;
+        log: Logger;
+        /** After how long a holder that cannot be read counts as gone. */
+        stalenessMs: number;
+        pollMs?: number;
+    });
+    acquire(): Promise<void>;
+    release(): Promise<void>;
+    releaseIfOurs(): Promise<void>;
+    private get holderPath();
+    private stamp;
+    private holder;
+    private isStale;
+}

package/vendor/@stringsync/splates-server/records/migration.d.ts

@@ -0,0 +1,94 @@
+import { type Logger } from "../../../core/log/index.js";
+import type { Fs, Lock, Ps } from "../../../core/system/index.js";
+import { Duration } from "../../../core/time/index.js";
+import { z } from "zod";
+import type { Format } from "./format";
+/**
+ * Moves one repository's records to this splates's format so a failure leaves
+ * them as they were: backed up first, the steps run in a child that is
+ * killed past the limit, and the backup put back when it fails, with why
+ * kept beside the records. A failure kept for this release refuses each
+ * later try until `retry` asks again, so a server started over and over
+ * never runs a broken step over and over.
+ */
+export declare class Migration {
+    readonly format: Format;
+    private readonly fs;
+    private readonly log;
+    private readonly lock;
+    private readonly release;
+    private readonly child;
+    private readonly limit;
+    private readonly settle;
+    /** Where the failure is kept: beside the records, since a restore replaces them. */
+    readonly failurePath: string;
+    readonly backupPath: string;
+    constructor(format: Format, { fs, log, lock, release, child, limit, settle, }: MigrationOptions);
+    /** The child `splates migrate` this process would run, in `root`. */
+    static childOf(ps: Ps, root: string): (signal: AbortSignal) => Promise<{
+        exitCode: number;
+        stderr: string;
+    }>;
+    /** The failure kept for these records, or null for none. */
+    failure(): Promise<MigrationFailure | null>;
+    /**
+     * Moves the records forward, then checks them as `Format.check` does.
+     * Refuses them as `migration_failed` when a step fails, runs past the
+     * limit, or failed before on this release, unless `retry`.
+     */
+    run({ retry }?: {
+        retry?: boolean;
+    }): Promise<void>;
+    /** Forgets a kept failure, so the next `run` tries again. */
+    forget(): Promise<void>;
+    private migrate;
+    private refuse;
+}
+/**
+ * Set in the environment of the `splates migrate` a `Migration` runs, so that
+ * one runs the steps itself rather than guarding another.
+ */
+export declare const MIGRATING = "SPLATES_MIGRATING";
+/** How long one repository's steps may run before they count as stuck. */
+export declare const MIGRATION_LIMIT: Duration;
+/**
+ * The last published splates that reads each format, by format: where a
+ * person goes back to while a migration from it fails. A format with none
+ * was never published.
+ */
+export declare const LAST_READ: Readonly<Record<number, string>>;
+/** Why a repository's records stayed where they were, as kept beside them. */
+export declare const MigrationFailure: z.ZodObject<{
+    from: z.ZodNumber;
+    to: z.ZodNumber;
+    step: z.ZodNullable<z.ZodString>;
+    error: z.ZodString;
+    release: z.ZodString;
+    fallback: z.ZodNullable<z.ZodString>;
+    at: z.ZodString;
+}, z.core.$strip>;
+export type MigrationFailure = z.infer<typeof MigrationFailure>;
+/** What a `Migration` works with. */
+export interface MigrationOptions {
+    fs: Fs;
+    log: Logger;
+    /** Held around the backup, the steps and any restore. */
+    lock: Lock;
+    /** The splates running, which a failure is kept against. */
+    release: string;
+    /**
+     * Runs the steps in a child, `splates migrate` with `MIGRATING` set,
+     * killed once `signal` aborts; answers with its exit code and what it
+     * said on stderr.
+     */
+    child(signal: AbortSignal): Promise<{
+        exitCode: number;
+        stderr: string;
+    }>;
+    limit?: Duration;
+    /**
+     * Runs once the records are in this splates's format, whether it moved
+     * them or found them so: clears what the steps left behind.
+     */
+    settle?: () => Promise<void>;
+}

package/vendor/@stringsync/splates-server/records/one-task-store.d.ts

@@ -0,0 +1,15 @@
+import type { Migration } from "./format";
+/**
+ * @internal Where, under `.git/splates`, format 1's records stay as they
+ * were, a backup until a later release removes it.
+ */
+export declare const BACKUP = "format-1";
+/**
+ * @internal Format 1 → 2: todos and tasks become one store of numbered tasks under
+ * `tasks/<N>.json`. Each todo is a queued task under its number. Each task
+ * is started under the lowest-numbered todo it took, the rest queued and
+ * held by it, or under a number of its own, off the list, when it took
+ * none. A task's files are in `tasks/<N>/started/`, a todo's in
+ * `tasks/<N>/`.
+ */
+export declare const ONE_TASK_STORE: Migration;

package/vendor/@stringsync/splates-server/records/repository.d.ts

@@ -0,0 +1,137 @@
+import type { Deps, Middleware } from "../../../core/cmd/index.js";
+import { type Fs, type Lock } from "../../../core/system/index.js";
+import { Tasks } from "../board";
+import type { Config } from "../config";
+import { Creds, type SecretStores } from "../creds";
+import { Git } from "../git";
+import { TaskBranches, type TrunkLanding } from "../merge";
+import { Slots } from "../ports";
+import { Projects, type Reach } from "../projects";
+import { type PlacedLock } from "../server/shared";
+import { Outcomes } from "../stats";
+import { type Storage } from "../storage";
+import { WorktreeService } from "../tasks";
+import { Shell } from "../terminal";
+import { Format } from "./format";
+import { ProjectHome } from "./home";
+import { Journal } from "./journal";
+import { Migration } from "./migration";
+/**
+ * Runs the action against the repository `cwd` sits in, or the registered
+ * project `--project` names, and refuses to run it at all when that is not
+ * a repository, its records are in a format this splates does not read, or
+ * the command is run from another project that has not been granted what
+ * it `needs` there.
+ */
+export declare function repository<C extends Deps & {
+    fs: Fs;
+    secrets?: SecretStores;
+    project?: string;
+}>(opts: Omit<RepositoryOptions, "at"> & {
+    needs: Needs;
+}): Middleware<C, C & Repository & Reached>;
+/** What a command works with once there is a repository to work in. */
+export interface Repository {
+    /**
+     * The project's directory under the splates home, `projects/<id>`, shared
+     * by every worktree: its database and the files beside it.
+     */
+    dir: string;
+    /** Closes what the command held open: the project's database. */
+    dispose(): void;
+    /** The project's records, in its database. */
+    storage: Storage;
+    /** What every project on this machine shares, under the splates home. */
+    machine: Storage;
+    /** Reads and writes the command's files. */
+    fs: Fs;
+    config: Config;
+    /** Checked before the command runs, so its records are in this splates's format. */
+    format: Format;
+    git: Git;
+    service: WorktreeService;
+    /** The merge lease, which one merge in the repository holds at a time. */
+    lock: Lock;
+    shell: Shell;
+    journal: Journal;
+    tasks: Tasks;
+    /** How each task on this machine ended, which a merge reads its findings from. */
+    outcomes: Outcomes;
+    /** Every splates project on this machine, which `splates init` joins this one to. */
+    projects: Projects;
+    /** The creds agents ask for, and the stores they are kept in. */
+    creds: Creds;
+    /** The machine's dev slots, which a task gives back as it ends. */
+    slots: Slots;
+    /** Held by a merge's gate, so one premerge runs per project at a time. */
+    premerge: PlacedLock;
+    /** Each task's branch on the central remote, which a task pushes as it goes. */
+    branches: TaskBranches;
+    /** What moves trunk on the central remote once a merge has tested its branch. */
+    trunk: TrunkLanding;
+}
+/** How `repository` treats records in an older format than this splates's. */
+export interface RepositoryOptions {
+    /**
+     * Brings them forward before the action runs. Set by `splates server` alone;
+     * every other command refuses old records until the server has migrated them.
+     */
+    migrates?: boolean;
+    /**
+     * Sets up the records of a repository that has none first, as only
+     * `splates init` does: every other command refuses one.
+     */
+    creates?: boolean;
+    /** Where to look for the repository; the working directory by default. */
+    at?: string;
+}
+/**
+ * What a command needs of the project it runs on, when an agent of another
+ * project runs it: a reach that project must have granted, or `own` for a
+ * command no other project may run there at all.
+ */
+export type Needs = Reach | "own";
+/** What `repository` adds beyond the repository itself. */
+export interface Reached {
+    /**
+     * The main tree of the other project the command is run from, as checked
+     * against what it `needs`; null when run from this one, or from none.
+     */
+    elsewhere: string | null;
+}
+/**
+ * How `format`'s records move forward under the guard `Migration` keeps:
+ * backed up, run in a child `splates migrate` of this splates, and put back
+ * when it fails.
+ */
+export declare function migrationOf(format: Format, { fs, ps, log }: Deps & {
+    fs: Fs;
+}, 
+/** Where the records end up, whose old files are left aside once moved. */
+home?: ProjectHome): Migration;
+/**
+ * What `splates migrate` does in the repository `at` sits in: as the child a
+ * `Migration` runs, the steps themselves; otherwise the guarded migration,
+ * trying again past a failure kept for this release.
+ */
+export declare function migrateRecords(deps: Deps & {
+    fs: Fs;
+}, { at }?: {
+    at?: string;
+}): Promise<number>;
+/**
+ * The guarded migration of the records under `gitDir`, once an old name for
+ * their directory has moved to splates's.
+ */
+export declare function recordsMigration(deps: Deps & {
+    fs: Fs;
+}, gitDir: string): Promise<Migration>;
+/**
+ * What a command works with in the repository `at` sits in, the working
+ * directory by default: what `repository` hands an action, and what `splates
+ * dev` opens each project it serves with. Refuses what `repository` does.
+ */
+export declare function openRepository({ fs, ps, log, secrets, }: Deps & {
+    fs: Fs;
+    secrets?: SecretStores;
+}, { migrates, creates, at }?: RepositoryOptions): Promise<Repository>;

package/vendor/@stringsync/splates-server/records/task-files.d.ts

@@ -0,0 +1,8 @@
+import type { Migration } from "./format";
+/**
+ * @internal Format 2 → 3: each `tasks/<N>.json` becomes `tasks/<N>.md`, its
+ * fields as JSON front matter and its text as the body, so a task reads as
+ * the `SPLATES.md` it grows into. A queued task gains its stage: `ready`
+ * when it has a model named, as grooming leaves one, else `backlog`.
+ */
+export declare const TASK_FILES: Migration;

package/vendor/@stringsync/splates-server/records/task-stages.d.ts

@@ -0,0 +1,7 @@
+import type { Migration } from "./format";
+/**
+ * @internal Format 3 → 4: every task carries its stage the whole way. A
+ * started task's stage becomes `running`, the stage it was in before kept as
+ * `startedFrom`, and only a running task keeps a `status`.
+ */
+export declare const TASK_STAGES: Migration;

package/vendor/@stringsync/splates-server/records/to-sqlite.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from "./format";
+/** The step that moves a project's records out of `.git/splates` into its database. */
+export declare const TO_SQLITE: Migration;

package/vendor/@stringsync/splates-server/replica/aws-sign.d.ts

@@ -0,0 +1,30 @@
+/** What signs a request: an access key, its secret, and a session token when it is temporary. */
+export interface AwsCredentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+}
+/** A request to sign, its body already in the form it is sent. */
+export interface SigningRequest {
+    method: string;
+    url: URL;
+    headers: Record<string, string>;
+    body: string | Uint8Array;
+}
+/**
+ * Signs requests with AWS Signature Version 4, which every S3-compatible
+ * store takes, so splates needs no AWS SDK: `sign` answers the headers to
+ * send, the `Authorization` among them.
+ */
+export declare class AwsSigner {
+    private readonly credentials;
+    private readonly region;
+    private readonly service;
+    constructor(credentials: AwsCredentials, region: string, service: string);
+    /** The request's headers with `host`, `x-amz-date` and `Authorization` added, signed as of `at`. */
+    sign(request: SigningRequest, at: Date): Record<string, string>;
+}
+/** The SHA-256 of `body` as hex, as a signature and S3's `x-amz-content-sha256` take it. */
+export declare function sha256(body: string | Uint8Array): string;
+/** `text` percent-encoded but for unreserved characters, which `encodeURIComponent` leaves `!'()*` of. */
+export declare function encode(text: string): string;

package/vendor/@stringsync/splates-server/replica/dir.d.ts

@@ -0,0 +1,17 @@
+import type { Fs } from "../../../core/system/index.js";
+import { type Replica, type ReplicaObject } from "./replica";
+/**
+ * A replica in a folder, each key a file under it: for tests, and for a
+ * backup on a disk of the machine's own, as a mounted drive.
+ */
+export declare class DirReplica implements Replica {
+    readonly dir: string;
+    private readonly fs;
+    readonly name: string;
+    constructor(dir: string, fs: Fs);
+    put(key: string, bytes: Uint8Array): Promise<void>;
+    get(key: string): Promise<Uint8Array | null>;
+    list(key: string): Promise<ReplicaObject[]>;
+    delete(key: string): Promise<void>;
+    private path;
+}

package/vendor/@stringsync/splates-server/replica/index.d.ts

@@ -0,0 +1,14 @@
+export type { AwsCredentials } from "./aws-sign";
+export { DirReplica } from "./dir";
+export type { ReplicaPlace } from "./place";
+export { openReplica, REPLICA_ACCESS_KEY, REPLICA_SECRET_KEY } from "./place";
+export type { Replica, ReplicaObject } from "./replica";
+export type { ReplicatorOptions } from "./replicator";
+export { Replicator } from "./replicator";
+export type { Restored, RestoreTarget } from "./restore";
+export { restoreFromReplica } from "./restore";
+export type { S3Place, S3ReplicaOptions } from "./s3";
+export { S3Replica } from "./s3";
+export { replicated } from "./shipped";
+export type { ReplicaStatus } from "./status";
+export { statusLines } from "./status";

package/vendor/@stringsync/splates-server/replica/index.js

@@ -0,0 +1,29 @@
+import {
+  DirReplica2,
+  S3Replica2,
+  REPLICA_ACCESS_KEY2,
+  REPLICA_SECRET_KEY2,
+  openReplica2,
+  replicated2,
+  Replicator2,
+  restoreFromReplica2,
+  statusLines2
+} from "../index-5axhdy8c.js";
+import"../index-caep3sde.js";
+import"../index-01z7ycdk.js";
+import"../index-e9z7s5hh.js";
+import"../index-kmzdvvt0.js";
+import"../index-t9w5a8ed.js";
+import"../index-0jttnv86.js";
+import"../index-g18nxyn7.js";
+export {
+  DirReplica2 as DirReplica,
+  REPLICA_ACCESS_KEY2 as REPLICA_ACCESS_KEY,
+  REPLICA_SECRET_KEY2 as REPLICA_SECRET_KEY,
+  Replicator2 as Replicator,
+  S3Replica2 as S3Replica,
+  openReplica2 as openReplica,
+  replicated2 as replicated,
+  restoreFromReplica2 as restoreFromReplica,
+  statusLines2 as statusLines
+};

package/vendor/@stringsync/splates-server/replica/layout.d.ts

@@ -0,0 +1,45 @@
+import type { Replica } from "./replica";
+/**
+ * Where the `Replicator` keeps each kind of thing in a replica, keyed by the
+ * storage key it copies, so a replica restores into any engine: a value
+ * whole at `values/<key>`, a log as chunks of lines at
+ * `logs/<key>/<to>-<hash>.jsonl`, each holding the lines up to line `to`
+ * from the one before, `hash` naming its last line, and `manifest.json`.
+ */
+export declare const MANIFEST = "manifest.json";
+/** What a replica's `manifest.json` says of it. */
+export interface Manifest {
+    version: 1;
+    /** The server whose records these are, which only it replicates into. */
+    origin: string;
+    /** The machine that last caught it up, for a person to read. */
+    host: string;
+    /** When it last held every change, epoch ms; null before it first has. */
+    caughtUpAt: number | null;
+}
+/** One chunk of a log as kept in a replica. */
+export interface Chunk {
+    /** Its key in the replica. */
+    key: string;
+    /** How many of the log's lines it and the chunks before it hold. */
+    to: number;
+    /** The hash of its last line, which tells whether the log still begins with what was shipped. */
+    last: string;
+}
+export declare function valueKey(key: string): string;
+export declare function chunkKey(key: string, to: number, last: string): string;
+/** The short hash a chunk's key names its last line by. */
+export declare function lineHash(line: string): string;
+/**
+ * What a replica's listing holds, as the storage keys it copies: each
+ * value's MD5 and each log's chunks, oldest first.
+ */
+export declare function readListing(keys: {
+    key: string;
+    md5: string;
+}[]): {
+    values: Map<string, string>;
+    logs: Map<string, Chunk[]>;
+};
+/** What `replica` says of itself, or null when it has no manifest yet; throws on one it cannot read. */
+export declare function readManifest(replica: Replica): Promise<Manifest | null>;

package/vendor/@stringsync/splates-server/replica/place.d.ts

@@ -0,0 +1,31 @@
+import type { Fs } from "../../../core/system/index.js";
+import type { Creds } from "../creds";
+import type { Replica } from "./replica";
+import { type S3Place } from "./s3";
+/**
+ * Where a project's `splates.config.ts` sends its replica, by provider: a
+ * bucket of any S3-compatible store, as
+ * `{ provider: "s3", endpoint: "https://nyc3.digitaloceanspaces.com", bucket: "my-splates" }`,
+ * or a folder, as `{ provider: "dir", path: "/Volumes/Backup/splates" }`.
+ */
+export type ReplicaPlace = ({
+    provider: "s3";
+} & S3Place) | {
+    provider: "dir";
+    /** The folder, relative to the checkout's root unless absolute. */
+    path: string;
+};
+/** The creds a bucket's key and secret are kept as, the project's then the device's. */
+export declare const REPLICA_ACCESS_KEY = "REPLICA_ACCESS_KEY";
+export declare const REPLICA_SECRET_KEY = "REPLICA_SECRET_KEY";
+/**
+ * The replica `place` names, for the checkout at `root`. A bucket reads its
+ * key and secret from `creds` at each request, asking for them on the Creds
+ * page when they are not kept yet, so the replica starts once they are
+ * filled without a restart.
+ */
+export declare function openReplica(place: ReplicaPlace, { root, fs, creds, }: {
+    root: string;
+    fs: Fs;
+    creds: Pick<Creds, "credentials" | "request">;
+}): Replica;