@stringsync/splates 0.0.61 → 1.13.3

package/vendor/@stringsync/splates-server/server/pulse.d.ts

@@ -0,0 +1,8 @@
+import { Duration } from "../../../core/time/index.js";
+/**
+ * How often `splates server` says a stream it serves is still there, so the page
+ * can tell one that went quiet, as across a sleep, from one with no news.
+ */
+export declare const PULSE: Duration;
+/** The event it says so with, one the page's handlers for news never hear. */
+export declare const PULSE_EVENT: Uint8Array<ArrayBuffer>;

package/vendor/@stringsync/splates-server/server/release.d.ts

@@ -0,0 +1,41 @@
+import type { Ps } from "../../../core/system/index.js";
+/** The version of splates running now, as `ship` stamped it. */
+export declare const RUNNING: string;
+/** Where npm says which version of splates is the latest. */
+export declare const REGISTRY = "https://registry.npmjs.org/@stringsync%2fsplates/latest";
+/** A newer splates than the one serving, published since it started. */
+export interface Release {
+    running: string;
+    newest: string;
+}
+/**
+ * Commits to splates's own source since `splates server` started from a checkout of
+ * it, which a restart picks up.
+ */
+export interface Behind {
+    /** The last commit to the source as the server started. */
+    running: string;
+    /** The last commit to it now. */
+    newest: string;
+}
+/**
+ * The directories splates runs from in a checkout: its own, and the webappwiz
+ * library it imports, whose commits change what the server runs just as much.
+ */
+export declare const SOURCE: string[];
+/**
+ * The last commit to `source`, or null when splates does not run from a
+ * checkout, as from npm, or git cannot say. Never throws, like `newest`.
+ */
+export declare function sourceCommit(ps: Ps, source?: string[]): Promise<string | null>;
+/**
+ * The latest version of splates on npm, or null when the registry cannot say:
+ * offline, slow, or answering with something else. A check that fails has
+ * nothing to tell the person at the page, so it never throws.
+ */
+export declare function newest(registry?: string): Promise<string | null>;
+/**
+ * Whether `version` is past `than`, by major, minor and patch. A prerelease is
+ * never newer: only what `@latest` installs is worth a restart.
+ */
+export declare function isNewer(version: string, than: string): boolean;

package/vendor/@stringsync/splates-server/server/replicas.d.ts

@@ -0,0 +1,23 @@
+import type { Logger } from "../../../core/log/index.js";
+import { Replicator } from "../replica";
+import type { Project } from "./project";
+/**
+ * The replicators of this server's projects, one per root: a project
+ * replicates from the server's start whether or not a page ever opens it,
+ * and opening it later finds the one already running, since two writing
+ * one replica would refuse each other.
+ */
+export declare class Replicas {
+    private readonly log;
+    private readonly running;
+    constructor(log: Logger);
+    /**
+     * Starts copying the project's records into the replica its config names,
+     * unless that is under way, and returns it, or null when it names none. A
+     * replica it cannot reach yet is tried again on its own, so nothing waits
+     * on it.
+     */
+    of(project: Project): Replicator | null;
+    /** What changed in the last seconds goes before the server does, unless a store is slow. */
+    disposeAsync(): Promise<void>;
+}

package/vendor/@stringsync/splates-server/server/restart.d.ts

@@ -0,0 +1,177 @@
+import type { AsyncResource } from "../../../core/disposable/index.js";
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs, Ps } from "../../../core/system/index.js";
+import type { Projects } from "../projects";
+import type { Storage } from "../storage";
+import type { Terminals } from "../terminal";
+import type { WorkerMachine } from "../workers";
+import { type Project, type Served } from "./project";
+import type { ServerChoice } from "./servers";
+import type { Versions } from "./versions";
+/** The projects `splates server` serves, as its restarts reach them. */
+export interface ServedProjects {
+    /** Each project opened so far, by root. */
+    readonly served: Map<string, Promise<Served>>;
+    /** The project at `root`, opened on first asking. */
+    servedAt(root: string): Promise<Served>;
+    /** The project `slug` names, or the focused one for none. */
+    projectNamed(slug: string): Promise<Served>;
+}
+/** What `Restarts` works with: the machine, and what `splates server` holds. */
+export interface RestartsHome {
+    fs: Fs;
+    ps: Ps;
+    log: Logger;
+    /** The machine's storage, where a restart says which projects to reopen. */
+    storage: Storage;
+    /** The registry of splates projects. */
+    projects: Projects;
+    served: ServedProjects;
+    terminals: Terminals;
+    /** Where agents and shells run, whose process table says what a restart would kill. */
+    machine: Pick<WorkerMachine, "processes">;
+    /** Stops the whole server, before a restart ends the process. */
+    server: AsyncResource;
+    /** Hands every agent and shell on a worker to the next run, which takes them back; called before the server stops. */
+    handOver(): Promise<void>;
+}
+/** What `Restarts` takes from `dev`'s options. */
+export interface RestartsOptions {
+    exit: ((code: number) => void) | null;
+    open: (root: string) => Promise<Project>;
+    /** Every `splates server` on this machine the page can switch to. */
+    servers: () => Promise<ServerChoice[]>;
+    /** How long a restart or shutdown waits on checkpoints, and again on stopping, before going on without them; the default is five minutes. */
+    deadlineMs?: number;
+}
+/**
+ * How `splates server` restarts: the checkpoint a restart waits on, the restart
+ * itself, and how this run began. Its handlers are properties, so `dev` hands them to its routes
+ * as they are.
+ */
+export declare class Restarts {
+    private readonly home;
+    private readonly versions;
+    private readonly opts;
+    /**
+     * The restart to follow the checkpoint under way, once every agent has
+     * answered, and whether the next run resumes them, or whether it shuts
+     * down instead, for the next start to resume them; null for none.
+     */
+    private restarting;
+    /**
+     * Whether the restart under way goes onto the newest splates, as
+     * `splates update` asks, even before a check of npm has found it.
+     */
+    private updating;
+    /**
+     * How this run began, when a checkpoint's restart started it: its agents
+     * `resuming`, told to carry on, until each has.
+     */
+    private restarted;
+    /**
+     * Whether `reopenStopped` has read how this run began, before which a
+     * checkpoint left in the logs may yet be one to resume.
+     */
+    private began;
+    /** This run of `splates server`, so a page can tell it has restarted. */
+    private readonly run;
+    /**
+     * Written by a checkpoint's restart, beside the registry, with the other
+     * projects whose agents it stopped, so the next run opens them at once
+     * and resumes them.
+     */
+    private readonly reopen;
+    private readonly peeked;
+    /**
+     * How many agents wait in each project read for its tasks alone, as last
+     * counted, and the count under way: reading every task of a project takes
+     * a few hundred milliseconds, so a listing answers with the last count and
+     * leaves the next behind it, for the listing after.
+     */
+    private readonly counted;
+    /**
+     * The restart under way once its checkpoint is answered, until it has
+     * written what the next run reopens and handed over; disposing waits on
+     * it, so nothing is written after the server is gone.
+     */
+    private leaving;
+    private disposed;
+    constructor(home: RestartsHome, versions: Versions, opts: RestartsOptions);
+    /**
+     * Opens the projects a restart stopped agents in, and once they are
+     * served, tells each agent done with the checkpoint to carry on.
+     */
+    reopenStopped(): Promise<void>;
+    readonly listProjects: () => Promise<Response>;
+    /**
+     * Asks every live conversation in each project `projects` names, by slug,
+     * for a checkpoint, then restarts, or shuts down when `after` says to,
+     * once all of them have answered, stopping other projects' agents as they
+     * are; the next run tells each to carry on. With `update`, as `splates
+     * update` asks, it restarts onto the newest splates.
+     */
+    readonly checkpointProjects: (request: Request) => Promise<Response>;
+    /**
+     * Restarts `splates server` now, or with `shutdown` exits for good, without a
+     * checkpoint: an agent at work stops mid-turn, and a command it would
+     * kill dies with it. The next run starts as if started afresh.
+     */
+    readonly powerNow: (request: Request) => Promise<Response>;
+    /**
+     * Restarts `splates server` now, refused while an agent is at work that a
+     * restart would stop (one on a worker carries on through it), or a
+     * command it would kill runs: a job in front in a shell, or one an idle
+     * agent left running.
+     */
+    readonly restartIdle: () => Promise<Response>;
+    readonly forgetProject: (request: Request) => Promise<Response>;
+    /** Each project opened so far, but those that failed to open. */
+    private opened;
+    /**
+     * What a restart would kill: each command an idle agent left running,
+     * unless the agent runs on a worker, which keeps its commands as it keeps
+     * it; the page's shells run there too, and stay. An agent at work that a
+     * restart would stop holds one off on its own.
+     */
+    private holding;
+    private checkpointable;
+    private live;
+    private conversationsIn;
+    private waitingIn;
+    private countWaiting;
+    /**
+     * Restarts `splates server` once each checkpoint `asked` has been answered,
+     * unless dismissed meanwhile, or with `shutdown`, exits for good, the
+     * next start reopening and resuming as a restart would. Without
+     * `reopens`, the next run starts as if started afresh, as for a restart
+     * with every agent idle.
+     */
+    private restartAfter;
+    /**
+     * Writes what the next run reopens and hands over, as a restart leaves;
+     * says whether to go on and exit, which a dispose meanwhile stops.
+     */
+    private leave;
+    /** Stops any restart not yet begun, and waits out the one under way. */
+    disposeAsync(): Promise<void>;
+    /**
+     * Forgets each checkpoint ended with no run under way to restart or
+     * resume it: left by a run that stopped without saying to resume, as when
+     * killed mid-checkpoint, or in a project opened after the resume. Kept,
+     * it would hold Power on a checkpoint nothing ever ends.
+     */
+    private forgetStale;
+    /**
+     * Each conversation a restart's checkpoint has asked, in every project:
+     * a pause and a budget stop are not its own to resume or forget.
+     */
+    private checkpointed;
+    /**
+     * Tells each agent done with the checkpoint to carry on, which ends its
+     * checkpoint once said, and forgets the checkpoint of those it missed.
+     * One whose agent fails to come back has its checkpoint forgotten too,
+     * left failed for the person to open.
+     */
+    private carryOn;
+}

package/vendor/@stringsync/splates-server/server/runtime-deps.d.ts

@@ -0,0 +1,19 @@
+import type { Deps } from "../../../core/cmd/index.js";
+import type { Fs } from "../../../core/system/index.js";
+import type { SecretStores } from "../creds";
+import type { Assets } from "./assets";
+/** Everything `splates` is run with, before the repository middleware adds to it. */
+export interface SplatesDeps extends Deps {
+    fs: Fs;
+    /**
+     * The registered project a leading `--project <slug>` names, which repo
+     * commands run on instead of the one the working directory is in.
+     */
+    project?: string;
+    /** The built page `dev` serves as its preview. */
+    assets: Assets;
+    /** Where creds are kept; the system's stores by default. */
+    secrets?: SecretStores;
+    /** How `splates tunnel setup` reaches Cloudflare's API; the global one by default. */
+    fetch?: typeof fetch;
+}

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

@@ -0,0 +1,19 @@
+import { type AsyncResource } from "../../../core/disposable/index.js";
+import type { DevOptions } from "./options";
+import { type DevMachine } from "./project";
+export type { DevOptions } from "./options";
+export { DEFAULT_PORT, devPorts, PORT_SPAN } from "./ports";
+/**
+ * Serves the splates page, which shows what `task list`, `list` and `show`
+ * print and stays current as the repo changes, for a person to add, edit,
+ * reorder and remove queued tasks. Given `conversations`, it also talks to
+ * agents. Pass `hosts` and `access` to let in hosts other than this machine
+ * once Cloudflare Access verified who is asking.
+ */
+export declare function dev(deps: DevMachine, { ports, hosts, access, tunnel, conversations: converse, general: generalOption, shell, transcriber, newest, running, checkEvery, // how often to ask npm for a newer splates
+source, sourceEvery, // so a commit in a checkout shows within seconds
+unbuilt, slot, servers, exit, deadlineMs, sensors, workerSocket, workers: givenWorkers, worker, coordinator, portsHost, pusher, open: givenOpen, }?: DevOptions): Promise<DevServer>;
+/** A running server, and the one thing a caller ever wants to do with it. */
+export interface DevServer extends AsyncResource {
+    port: number;
+}

package/vendor/@stringsync/splates-server/server/servers.d.ts

@@ -0,0 +1,31 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs, Ps } from "../../../core/system/index.js";
+import { type SecretStores } from "../creds";
+import { type Slot } from "../ports";
+/**
+ * A `splates server` the page can switch to: the machine's own, reached at
+ * the host `splates tunnel setup` made, on its box once it moved there, or a
+ * slot's on this machine.
+ */
+export interface ServerChoice {
+    /** The slot it serves under; null for the machine's own. */
+    slot: Slot | null;
+    /** Its page, as in https://fox.example.com. */
+    url: string;
+    /** The checkout that holds the slot; null for the machine's own. */
+    tree: string | null;
+    /** Whether it is the one serving this page. */
+    here: boolean;
+}
+/**
+ * Every `splates server` this machine has a host for: its own, then each slot a
+ * checkout that still exists holds, in the pool's order, whether or not it
+ * runs. Read from the machine's home, which a slot's server is told of, since
+ * its own `SPLATES_HOME` is the slot's.
+ */
+export declare function devServers({ fs, ps, log, secrets, }: {
+    fs: Fs;
+    ps: Ps;
+    log: Logger;
+    secrets?: SecretStores;
+}): Promise<ServerChoice[]>;

package/vendor/@stringsync/splates-server/server/serving.d.ts

@@ -0,0 +1,28 @@
+import type { Ps } from "../../../core/system/index.js";
+import { z } from "zod";
+import type { Storage } from "../storage";
+/** What `server.json` holds: the `splates server` serving on this machine. */
+declare const ServingFile: z.ZodObject<{
+    url: z.ZodString;
+    pid: z.ZodNumber;
+    release: z.ZodString;
+}, z.core.$strip>;
+/** The `splates server` on this machine, as one serving says it. */
+export type ServingServer = Omit<z.infer<typeof ServingFile>, "pid">;
+/**
+ * Where the `splates server` on this machine says it listens, in the
+ * machine's storage, so a command such as `splates update` finds it: written
+ * once it listens, and taken back as it stops.
+ */
+export declare class Serving {
+    private readonly ps;
+    private readonly document;
+    constructor(machine: Storage, ps: Ps);
+    /** Says this process serves at `url`, running `release`. */
+    say(url: string, release: string): Promise<void>;
+    /** Takes back what `say` wrote, unless another server has written since. */
+    forget(): Promise<void>;
+    /** The server that said it serves, while its process lives; null for none. */
+    running(): Promise<ServingServer | null>;
+}
+export {};

package/vendor/@stringsync/splates-server/server/shared.d.ts

@@ -0,0 +1,14 @@
+export type { EventSink, StreamWatcher } from "./http";
+export { body, eventStream, fileResponse, HostGate, hostname, json, LOOPBACK, MEDIA_TYPES, refuse, uploads, } from "./http";
+export { DEFAULT_PORT } from "./ports";
+export { BESIDE_GATE_NICE, CHECKED_COMMIT, GATE_DEADLINE, GATE_PHASES, PREMERGE_HELD, PREMERGE_HOLD_MS, PREMERGE_TIMEOUT_MS, premergeLockOfProject, projectRootOf, RECENT_FAILED_FILES, } from "./premerge";
+export type { DevMachine, Handler, Project, Served } from "./project";
+export type { ProjectWatch } from "./project-watch";
+export type { Behind, Release } from "./release";
+export { RUNNING } from "./release";
+export type { SplatesDeps } from "./runtime-deps";
+export { installedVersion, projectSkills } from "./skills";
+export type { Connection } from "./sockets";
+export { CONNECTIONS } from "./sockets";
+export { RESTART, SERVING } from "./supervise";
+export type { PlacedAcquireOptions, PlacedLock } from "./ticketed-lock";

package/vendor/@stringsync/splates-server/server/skills.d.ts

@@ -0,0 +1,16 @@
+import type { Logger } from "../../../core/log/index.js";
+import { ProjectSkills } from "../../../core/skills/index.js";
+import type { Fs, Ps } from "../../../core/system/index.js";
+/**
+ * The repository splates's skill comes from: each release is a tag in it, and
+ * the skill its `skills/splates/SKILL.md`, which `bunx skills add` finds.
+ */
+export declare const SOURCE = "stringsync/splates";
+/** The skills a project at `root` has, installing splates's from `SOURCE`. */
+export declare function projectSkills(root: string, deps: {
+    fs: Fs;
+    ps: Ps;
+    log: Logger;
+}): ProjectSkills;
+/** The installed splates skill's version, or null when absent or unreadable. */
+export declare function installedVersion(fs: Fs, root: string): Promise<string | null>;

package/vendor/@stringsync/splates-server/server/sockets.d.ts

@@ -0,0 +1,13 @@
+/**
+ * What one WebSocket the server upgraded does, handed over as the socket's
+ * data on the upgrade, since Bun takes one handler for every socket: a
+ * terminal's shell, a dictation's transcription.
+ */
+export interface Connection {
+    open(socket: Bun.ServerWebSocket<Connection>): void;
+    message(socket: Bun.ServerWebSocket<Connection>, message: string | Buffer<ArrayBuffer>): void;
+    /** The socket closed, from either end. */
+    closed(socket: Bun.ServerWebSocket<Connection>): void;
+}
+/** The server's one handler, which leaves each socket to its own connection. */
+export declare const CONNECTIONS: Bun.WebSocketHandler<Connection>;

package/vendor/@stringsync/splates-server/server/start-settings.d.ts

@@ -0,0 +1,15 @@
+import { type Offered, Roster, type RosterAgent } from "../models";
+import { SavedPortsHost, SavedTunnel } from "../tunnel";
+import type { SplatesDeps } from "./runtime-deps";
+/** The roster saved for this machine. */
+export declare function rosterOf({ ps, fs }: SplatesDeps): Roster;
+/** The base host saved for task ports. */
+export declare function savedPortsHostOf({ ps, fs }: SplatesDeps): SavedPortsHost;
+/** The tunnel saved for this machine. */
+export declare function savedTunnelOf({ ps, fs, fetch, secrets, }: SplatesDeps): SavedTunnel;
+/**
+ * The roster's agents, seeded with the defaults when there is none, with Kimi
+ * added once when it is installed here, and with the default models agents
+ * offer that the roster lacks.
+ */
+export declare function seeded(roster: Roster, offered?: Offered, machine?: Pick<SplatesDeps, "fs" | "ps">): Promise<RosterAgent[]>;

package/vendor/@stringsync/splates-server/server/start.d.ts

@@ -0,0 +1,21 @@
+import type { SplatesDeps } from "./runtime-deps";
+import { type DevServer } from "./server";
+/**
+ * Runs `splates server` with its flags: the page for every registered
+ * project, wherever it is started, reached through the tunnel and Access
+ * the flags name, or else the ones saved for this machine. Answers the
+ * server in the child it runs as, and nothing in the supervisor, which exits.
+ */
+export declare function serveDev(ctx: SplatesDeps, opts: DevFlags): Promise<DevServer | undefined>;
+/** The flags `splates server` takes, as `serveDev` reads them. */
+export interface DevFlags {
+    port: number;
+    "allow-hosts": string;
+    "access-team": string;
+    "access-aud": string;
+    tunnel: string;
+    "tunnel-name": string;
+    "ports-host": string;
+    keepalive: boolean;
+    slot: boolean;
+}

package/vendor/@stringsync/splates-server/server/suite-grant.d.ts

@@ -0,0 +1,26 @@
+import type { Fs, Ps } from "../../../core/system/index.js";
+/**
+ * How long the person's approval of a whole-suite run stands before it is
+ * used: long enough for the agent to finish its turn and start the run.
+ */
+export declare const SUITE_GRANT_MS: number;
+/**
+ * The person's approvals of an agent running the whole test suite outside a
+ * merge's gate, one file a conversation under the machine's splates home,
+ * each holding when it stops standing. Each lets one run start.
+ */
+export declare class SuiteGrants {
+    #private;
+    constructor({ fs, ps, now, }: {
+        fs: Fs;
+        ps: Ps;
+        now?: () => number;
+    });
+    /** Lets `conversation` run the whole suite once, within `SUITE_GRANT_MS`. */
+    grant(conversation: string): Promise<void>;
+    /**
+     * Whether `conversation` had an approval standing, which this uses up: two
+     * runs that ask at once never both have it.
+     */
+    take(conversation: string): Promise<boolean>;
+}

package/vendor/@stringsync/splates-server/server/supervise.d.ts

@@ -0,0 +1,81 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs, Ps } from "../../../core/system/index.js";
+import { type Clock, type Timer } from "../../../core/time/index.js";
+/** What a server exits with to be started again as it was. */
+export declare const RESTART = 75;
+/** What a server exits with to be started again on the newest splates. */
+export declare const UPDATE = 76;
+/**
+ * Set in the server's environment, so the `splates server` it runs serves rather
+ * than supervising another.
+ */
+export declare const SERVING = "SPLATES_DEV_SERVING";
+/**
+ * Set in the server's environment when its page failed to build: the page
+ * then says it may be out of date.
+ */
+export declare const UNBUILT = "SPLATES_DEV_UNBUILT";
+/**
+ * Runs `splates server` as a child of this process, sharing its terminal, and
+ * starts another each time the child exits to restart: as this one was
+ * started, or on the newest splates when it asks to update. Ctrl-C cancels the
+ * child or build; a second press or two seconds without exiting force-stops
+ * this command and its descendants. A SIGTERM or SIGHUP to this one
+ * stops the child with a SIGTERM and ends this, since the child would
+ * otherwise outlive it, listening on its port. A `worker` runs beside it as a second child,
+ * told this process's pid so it ends once this is gone. Both stop, ending
+ * this with 0, once the `checkout` it runs from is deleted. A child that
+ * crashes, ending any other way than with 0, Ctrl-C, a stop or a refusal no
+ * start can change (`usage`, `no_secret_store`), which ends this at once, is started
+ * again after a pause that doubles with each crash that came quickly, until
+ * so many come in a row that it would only crash again. With `awake`, the
+ * platform's own command keeps the machine from sleeping while this runs,
+ * as `awakeCommand` names it.
+ * Answers with the exit code to end on.
+ */
+export declare function supervise(ps: Ps, { build, env, cwd, worker, checkout, awake, log, timer, clock, }?: SuperviseOptions): Promise<number>;
+/** What `supervise` starts the server with, beyond the process it runs in. */
+export interface SuperviseOptions {
+    /**
+     * Builds the page, run before each start of the same splates, as from a
+     * checkout, whose page `bun install` built last and the commits since may
+     * have changed, packages they added included; null for one installed from
+     * npm, whose page shipped built.
+     */
+    build?: {
+        argv: string[];
+        cwd: string;
+    } | null;
+    /** Added to the server's environment, as a slot's home is. */
+    env?: Record<string, string>;
+    /** Where the server runs, the working directory by default. */
+    cwd?: string;
+    /**
+     * The arguments of a worker to run beside the server, as `["worker",
+     * "run"]`: started again whenever it ends, on the newest splates once the
+     * server updates, and stopped with this. Null for none.
+     */
+    worker?: string[] | null;
+    /**
+     * The checkout this runs from, looked at while it serves: once it is gone,
+     * as a task's worktree is when the task merges, the server and its worker
+     * stop, since nothing of theirs is left to start again. Null for splates
+     * installed from npm.
+     */
+    checkout?: {
+        path: string;
+        fs: Pick<Fs, "exists">;
+    } | null;
+    /** Whether to keep the machine awake while this runs, as `awakeCommand` does. */
+    awake?: boolean;
+    /** Where a crashed server is told of; null to tell no one. */
+    log?: Logger | null;
+    timer?: Timer;
+    clock?: Clock;
+}
+/**
+ * What keeps this machine from sleeping until the process `pid` ends, on
+ * `platform`: `caffeinate` on macOS, and on Linux a systemd inhibitor lock
+ * held by a `tail` that waits on the pid. Null where there is none.
+ */
+export declare function awakeCommand(platform: NodeJS.Platform, pid: number): string[] | null;

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

@@ -0,0 +1,80 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Fs, Lock, Ps } from "../../../core/system/index.js";
+/**
+ * A lock whose waiters are told their place in line as they wait: 1 is next
+ * for the lock once its holder lets go. A waiter that stops wanting it
+ * aborts `signal`, and its `acquire` rejects with the signal's reason unless
+ * it already holds the lock.
+ */
+export interface PlacedLock extends Lock {
+    acquire(onPlace?: (place: number) => void | Promise<void>, signal?: AbortSignal, opts?: PlacedAcquireOptions): Promise<void>;
+    /**
+     * Starts over the time a holder may keep the lock, where the lock caps
+     * it: a holder that begins another bounded step of work calls it, with
+     * the step's bound as `holdMs` when it is longer than the lock's own.
+     */
+    renew?(holdMs?: number): void;
+}
+export interface PlacedAcquireOptions {
+    /**
+     * Waits ahead of every waiter that did not ask to, behind those that did
+     * and the one already next, as a merge does once it has resolved a
+     * conflict, so its resolution does not go stale behind the whole line.
+     */
+    ahead?: boolean;
+}
+/**
+ * Serves `inner`, a lock with no order of its own, to its waiters across
+ * processes first come, first served, each told its place in line as it
+ * waits. Wrap a `FileLock` in one, with a `dir` for its tickets beside the
+ * lock, and take and release it as the lock itself.
+ */
+export declare class TicketedLock implements PlacedLock {
+    private readonly inner;
+    private readonly dir;
+    private readonly fs;
+    private readonly ps;
+    private readonly log;
+    private readonly pollMs;
+    private readonly stalenessMs;
+    /** Tells one waiter's tickets apart within a process, as tests make several. */
+    private issued;
+    constructor(inner: Lock, dir: string, opts: TicketedLockOptions);
+    /**
+     * Waits for every ticket ahead to go, telling `onPlace` this waiter's
+     * place each time it changes, then takes `inner`. The ticket stays while
+     * `inner` is taken, so a later waiter keeps its place behind this one,
+     * and goes once the lock is had. Aborting `signal` gives the place up:
+     * the ticket goes and the call rejects with the signal's reason, unless
+     * the lock was had already.
+     */
+    acquire(onPlace?: (place: number) => void | Promise<void>, signal?: AbortSignal, opts?: PlacedAcquireOptions): Promise<void>;
+    release(): Promise<void>;
+    releaseIfOurs(): Promise<void>;
+    /**
+     * Leaves a ticket named so that names sort in the order they were issued:
+     * the time, then the process, then a count within it. One `ahead` starts
+     * with `AHEAD`, which sorts before every digit.
+     */
+    private issue;
+    private holder;
+    /** Whether `name`'s waiter is past the line, asking `inner` for the lock. */
+    private isNext;
+    /**
+     * How many live tickets were issued before `ticket`, dropping the dead
+     * ones it meets. One `AHEAD` counts a plain ticket marked `next` too,
+     * whose waiter is asking `inner` and no longer looks at the line.
+     */
+    private ahead;
+    /** Why a ticket's waiter is taken to be gone; null for one still waiting. */
+    private isStale;
+}
+export interface TicketedLockOptions {
+    fs: Fs;
+    ps: Ps;
+    log: Logger;
+    /** How often a waiter looks at the line again. */
+    pollMs?: number;
+    /** How long a ticket that cannot be read may wait before it is dropped. */
+    stalenessMs?: number;
+}

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

@@ -0,0 +1,8 @@
+import type { Middleware } from "../../../core/cmd/index.js";
+import type { SplatesDeps } from "./runtime-deps";
+/**
+ * Lets `update` run on records in an older format: put it before
+ * `repository`, and it moves them to this splates's format, or has the older
+ * `splates server` serving them restart onto this splates and move them.
+ */
+export declare function recordsFirst<C extends SplatesDeps>(): Middleware<C, C>;