@stringsync/splates 0.0.60 → 1.13.3

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

@@ -0,0 +1,79 @@
+import type { StoredTask } from "../board";
+import type { AutoPickSet, Conversation, Conversations, Picked } from "../conversations";
+import type { Journal, Lifted } from "../records";
+import type { Project } from "../server/shared";
+import type { AttachmentInfo } from "./classify";
+import { type AutoPickDecision, type DecideContext } from "./decide";
+import { type JudgeFor } from "./judge";
+import type { AutoPicked } from "./record";
+/** Which task Auto pick starts: a started one by name, or a queued one by number. */
+export type AutoPickTarget = {
+    task: string;
+} | {
+    todo: number;
+};
+/** Which words Auto pick judges: a task's, or those of a new conversation's first message. */
+export type AutoPickWords = AutoPickTarget | {
+    words: string;
+    attachments?: readonly AttachmentInfo[];
+};
+/** How `startAutoPick` starts the conversation, in the tree it runs in. */
+export type AutoPickStart = (agent: string, opts: {
+    model?: string;
+    settings: Record<string, string>;
+    picking: Promise<Picked<string>>;
+}) => Promise<Conversation>;
+/**
+ * Starts a conversation on what Auto pick decides for a task, through
+ * `start`, which knows the tree it runs in. It answers before the judge does,
+ * on what the rules give a task of no sure kind, so the page opens the
+ * thread at once; the agent opens on the decision, which a prompt said
+ * meanwhile waits on. A task whose words the judge read before is decided on
+ * what it said then. Keeps the decision on the task's record, logs it in the
+ * conversation as splates's own line, and, with no judge to ask, asks once
+ * on the Creds page for the key one needs.
+ */
+export declare function startAutoPick({ project, conversations, target, start, slug, judge, now, }: {
+    project: Project;
+    conversations: Conversations;
+    target: AutoPickWords;
+    start: AutoPickStart;
+    /** The judge to ask; the one the project's creds give by default. */
+    judge?: JudgeFor;
+    /** The project's slug, to name it in the spend ledger; none when not given. */
+    slug?: () => Promise<string | null>;
+    now?: () => Date;
+}): Promise<Conversation>;
+/** What a decision for a task in `project` reads besides its classification. */
+export declare function contextOf(project: Project, conversations: Conversations, now: Date, attachments?: readonly AttachmentInfo[]): Promise<DecideContext>;
+/** The record of the task `target` names, failing for none. */
+export declare function recordOf(project: Project, target: AutoPickTarget): Promise<StoredTask>;
+/**
+ * What the judge reads of a task: its subject and text, or for a started
+ * task with no text, as one never queued has, the goal its `SPLATES.md` sets.
+ */
+export declare function wordsOf(project: Project, record: StoredTask): Promise<{
+    subject: string;
+    detail: string;
+}>;
+/**
+ * Keeps `picked` on task `id`'s record and logs it in `conversation`, when
+ * there is one, before its agent opens, asking once for the judge's key
+ * unless it `judged`. Each failure is logged, so neither stops the start.
+ */
+export declare function settle(project: Project, id: number, picked: AutoPicked, { conversation, judged, }: {
+    conversation: Promise<Conversation> | null;
+    judged: boolean;
+}): Promise<void>;
+/**
+ * Logs `picked` in `conversation`, asking once for the judge's key unless it
+ * `judged`; a failure is logged, so it never stops the start.
+ */
+export declare function announce(project: Project, conversation: Promise<Conversation>, picked: AutoPicked, judged: boolean): Promise<void>;
+/** What a conversation keeps of `decision`. */
+export declare function setOf({ pick, rule, kind, depth, clarity, }: AutoPickDecision): AutoPickSet;
+/**
+ * Writes `picked` in `journal` as splates's own line in its conversation,
+ * with, for a pick that moved it up later, what it moved off.
+ */
+export declare function journalPick(journal: Journal, task: string | null, picked: AutoPicked, lifted?: Lifted): Promise<void>;

package/vendor/@stringsync/splates-server/auto-pick/store.d.ts

@@ -0,0 +1,25 @@
+import type { Fs } from "../../../core/system/index.js";
+import { type AutoPickRules } from "./rules";
+/**
+ * The person's Auto pick rules, kept in one file under their home rather than
+ * per project, as the roster is: one mapping for every project on the machine.
+ */
+export declare class AutoPickStore {
+    /** `~/.splates/auto-pick.json`, or a test's own. */
+    readonly path: string;
+    private readonly deps;
+    constructor(
+    /** `~/.splates/auto-pick.json`, or a test's own. */
+    path: string, deps: {
+        fs: Fs;
+    });
+    /** The rules as the file keeps them; the defaults when there is no file. */
+    rules(): Promise<AutoPickRules>;
+    /** Writes `rules` once they check out, refusing them, file untouched, when not. */
+    save(rules: AutoPickRules): Promise<void>;
+    /** Writes the defaults over the person's rules, returning them. */
+    reset(): Promise<AutoPickRules>;
+    /** Deletes the file, so the defaults apply again; none there is fine. */
+    remove(): Promise<void>;
+    private write;
+}

package/vendor/@stringsync/splates-server/auto-pick/system-one.d.ts

@@ -0,0 +1,60 @@
+/**
+ * A decision model: it reads some state and answers yes-or-no questions about
+ * it with the probability of yes. The same shape as scry's `Judge`, so scry's
+ * Jev and Clef fit here too, without splates carrying scry's native
+ * dependencies; a fake in a test is another.
+ */
+export interface Judge {
+    judge(judgment: Judgment, opts?: JudgeOptions): Promise<Verdict>;
+}
+/** How one judgment runs. */
+export interface JudgeOptions {
+    /** Gives up on the judgment when it aborts. */
+    signal?: AbortSignal;
+}
+/** The state once, and every question about it, answered together. */
+export interface Judgment {
+    /** What the questions are about. A question names its parts by backticked path. */
+    state: Record<string, unknown>;
+    /** By id, which is for code and never sent as meaning. */
+    questions: Record<string, Noul>;
+}
+/** A yes-or-no question, answered with the probability of yes. */
+export interface Noul {
+    type: "noul";
+    instructions: string;
+    /** What a yes and a no each mean, when the line between them is subtle. */
+    criteria?: {
+        true: string;
+        false: string;
+    };
+}
+/** What a judge answered: the probability of yes, by question id. */
+export interface Verdict {
+    answers: Map<string, number>;
+    /** The tokens the reply said it used; unsaid when it said none, as Clef may not. */
+    usage?: {
+        input: number;
+        output: number;
+    };
+    /** What the judgment cost, when the judge knows its price, as Jev does. */
+    dollars?: number;
+}
+/**
+ * One request to a URL that speaks the System One API, tried once: a caller
+ * that cannot wait falls back rather than retrying. Its errors name the judge,
+ * never the URL, which can hold an account id.
+ */
+export declare function askSystemOne(name: string, url: string, token: string, body: object, opts: AskOptions): Promise<Verdict>;
+/** How `askSystemOne` sends its request. */
+export interface AskOptions extends JudgeOptions {
+    /** Sends the request; the global `fetch` when not given. */
+    fetch?: typeof fetch;
+}
+/** Where a judge is reached. */
+export interface EndpointOptions {
+    /** The provider's own when not given. */
+    origin?: string;
+    /** Sends the request; the global `fetch` when not given. */
+    fetch?: typeof fetch;
+}

package/vendor/@stringsync/splates-server/auto-pick/trial.d.ts

@@ -0,0 +1,32 @@
+import type { Conversations } from "../conversations";
+import type { Project } from "../server/shared";
+import { type Classification } from "./classify";
+import { type AutoPickDecision } from "./decide";
+import { type JudgeFor } from "./judge";
+import { type AutoPickTarget } from "./start";
+/** What Auto pick would do for a task, as Setup's "Try it on a task" shows it. */
+export interface AutoPickTrial {
+    /** The task's subject, as the judge read it. */
+    subject: string;
+    decision: AutoPickDecision;
+    /** What the judge said of the task; null when it said nothing, and why is in the reasons. */
+    classification: Classification | null;
+    /** Whether that is what the task's record kept from an earlier pick, so no judge was asked. */
+    cached: boolean;
+}
+/**
+ * Decides for a task as an Auto pick start would, on the rules saved now,
+ * but starts nothing and leaves the task's record as it is: a classification
+ * kept on it from an earlier pick of the same words is reused, and one the
+ * judge gives now is not kept.
+ */
+export declare function tryAutoPick({ project, conversations, target, slug, judge, now, }: {
+    project: Project;
+    conversations: Conversations;
+    target: AutoPickTarget;
+    /** The judge to ask; the one the project's creds give by default. */
+    judge?: JudgeFor;
+    /** The project's slug, to name it in the spend ledger; none when not given. */
+    slug?: () => Promise<string | null>;
+    now?: () => Date;
+}): Promise<AutoPickTrial>;

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

@@ -0,0 +1,4 @@
+/** The permanent catch-all lane; ordinary lane numbers start at one. */
+export declare const BACKLOG_LANE = 0;
+/** Refuses operations that would remove the system lane's identity. */
+export declare function protectBacklog(id: number): void;

package/vendor/@stringsync/splates-server/board/blocked-warning.d.ts

@@ -0,0 +1,7 @@
+import type { Task } from "./task";
+/**
+ * The lines warning that `taken` was taken while `blockers` have yet to merge,
+ * or none when nothing blocks it: it may be started, but what it builds on
+ * is not there yet.
+ */
+export declare function blockedWarning(taken: Task, blockers: Task[]): string[];

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

@@ -0,0 +1,8 @@
+export { BACKLOG_LANE } from "./backlog";
+export type { Deferral, DeferralBlocker, DeferredQuestion, OutsideBlocker, TaskBlockerStatus, } from "./deferral";
+export { cleared, deferralBlockers } from "./deferral";
+export type { ElsewhereBlocker, ElsewhereBlockerNow, ElsewhereFollower, ElsewhereOnBoard, ElsewhereOpen, } from "./elsewhere";
+export { elsewhereName, holding } from "./elsewhere";
+export type { LaneRecord, LaneState } from "./lanes";
+export { blockerLabel, cycle, elsewhereMention, followers, isReady, lanes, lanesTaken, MENTION, named, } from "./lanes";
+export type { Task, TaskRecord } from "./task";

package/vendor/@stringsync/splates-server/board/change-lane.d.ts

@@ -0,0 +1,12 @@
+import type { LaneUpdateOptions } from "./lane";
+import type { LaneRecord } from "./lanes";
+import type { Tasks } from "./tasks";
+/**
+ * Makes each change asked of lane `id`: a new name, a new place among
+ * the lanes. Gives back the lane after, and the lanes in order when it
+ * moved.
+ */
+export declare function changeLane(tasks: Tasks, id: number, { name, position }: LaneUpdateOptions): Promise<{
+    record: LaneRecord | undefined;
+    order: LaneRecord[] | undefined;
+}>;

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

@@ -0,0 +1,87 @@
+import type { ElsewhereBlocker, ElsewhereBlockerNow } from "./elsewhere";
+import type { GoneBlocker, TaskRecord } from "./task";
+/**
+ * Why a task's work was set aside and what it waits on, as the agent that
+ * deferred it said: read it to tell the person what stopped the work, and
+ * to start it again from there. Pass it with the board to
+ * `deferralBlockers` for where each blocker stands now.
+ */
+export interface Deferral {
+    /** What the agent found that stops the work, in a sentence or two. */
+    why: string;
+    /** When it was deferred. */
+    at: string;
+    /** The started task deferred, whose worktree went. */
+    task: string;
+    /** The `splates server` conversation it was deferred from; absent for none known. */
+    conversation?: string;
+    /**
+     * The tasks it waits on to merge, with their subjects when it was
+     * deferred, those of another project with its main tree.
+     */
+    tasks: GoneBlocker[];
+    /** Questions for the person, each in the skill's question format. */
+    questions: DeferredQuestion[];
+    /** What it waits on outside splates: a key, an upstream release. */
+    outside: OutsideBlocker[];
+}
+export interface DeferredQuestion {
+    text: string;
+    /** The person's answer; absent while it is open. */
+    answer?: string;
+}
+export interface OutsideBlocker {
+    what: string;
+    /** Set once the person marks it done. */
+    done?: true;
+}
+/** What a deferral names, before it is recorded. */
+export interface DeferralAsk {
+    why: string;
+    blockedBy: number[];
+    /** The tasks of other projects it waits on to merge; none when absent. */
+    blockedElsewhere?: ElsewhereBlocker[];
+    questions: string[];
+    outside: string[];
+}
+/** Where one blocker a deferral named stands now. */
+export type DeferralBlocker = {
+    kind: "task";
+    id: number;
+    subject: string;
+    status: TaskBlockerStatus;
+    /** The other project's main tree and slug, for a task there; absent for one here. */
+    project?: string;
+    slug?: string;
+} | {
+    kind: "question";
+    text: string;
+    status: "open" | "answered";
+    /** What the person answered; absent while it is open. */
+    answer?: string;
+} | {
+    kind: "outside";
+    what: string;
+    status: "open" | "done";
+};
+/**
+ * A task blocker's stage on the board, `working` once taken; `merged` once
+ * it landed; `removed` once it left the board without merging; `unlinked`
+ * when the person let the deferred task stop waiting on it; `unknown` for
+ * one of another project that cannot be read.
+ */
+export type TaskBlockerStatus = "backlog" | "ready" | "queued" | "working" | "merged" | "removed" | "unlinked" | "unknown";
+/** Whether a blocker no longer holds the work back. */
+export declare function cleared(blocker: DeferralBlocker): boolean;
+/**
+ * Each blocker `task`'s deferral named, with where it stands now among the
+ * tasks on the board, `board`, and for one of another project, among
+ * `elsewhere`, its blockers there as `ElsewhereStanding.of` reads them; empty for a
+ * task never deferred.
+ */
+export declare function deferralBlockers(task: TaskRecord, board: readonly TaskRecord[], elsewhere?: readonly ElsewhereBlockerNow[]): DeferralBlocker[];
+/**
+ * Refuses a deferral that says no why or names no blocker, saying how to
+ * name each, so the agent learns it at the moment it defers.
+ */
+export declare function deferralProblem(ask: Partial<DeferralAsk>): string | null;

package/vendor/@stringsync/splates-server/board/elsewhere-links.d.ts

@@ -0,0 +1,26 @@
+import { type ElsewhereBlocker, type ElsewhereBoards } from "./elsewhere";
+import type { Task } from "./task";
+import type { Tasks } from "./tasks";
+/**
+ * Links `tasks` to tasks of other projects that have to merge first, and
+ * notes those that since merged or were removed there: `link` from a
+ * command or the page, `settle` from the queue's sweep.
+ */
+export declare class ElsewhereLinks {
+    private readonly tasks;
+    constructor(tasks: Tasks);
+    /**
+     * Says task `id` comes after exactly the tasks of other projects in
+     * `blockers`: it is not to be started until each merges there. One it
+     * was already blocked by keeps whether it landed or was lost.
+     */
+    link(id: number, blockers: readonly ElsewhereBlocker[]): Promise<Task>;
+    /**
+     * Notes each blocker in another project that has since merged there,
+     * with the commit it landed as, or left without merging, as `boards`
+     * reads them; gives back the tasks that changed.
+     */
+    settle(boards: ElsewhereBoards): Promise<Task[]>;
+}
+/** `blockers` with each task named once, the first kept. */
+export declare function distinct(blockers: readonly ElsewhereBlocker[]): ElsewhereBlocker[];

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

@@ -0,0 +1,119 @@
+import type { TaskRecord, TaskStage } from "./task";
+/**
+ * Where tasks' blockers in other projects stand, read from `boards`: `of`
+ * for one task, as `task show` says it, `onBoard` for a page's whole board.
+ */
+export declare class ElsewhereStanding {
+    private readonly boards;
+    constructor(boards: ElsewhereBoards);
+    /**
+     * `task`'s blockers in other projects, each as it stands now: those
+     * settled as its record says, the rest as that project's board does.
+     */
+    of(task: TaskRecord): Promise<ElsewhereBlockerNow[]>;
+    /**
+     * The blockers in other projects of the tasks among `todos`, as `of`
+     * reads them, and the tasks of other projects that wait on each, for the
+     * board of the project at `root`.
+     */
+    onBoard(todos: readonly TaskRecord[], root: string): Promise<ElsewhereOnBoard>;
+}
+/** Whether `blocker` still holds its task back: open there, or gone without merging. */
+export declare function holding(blocker: ElsewhereBlocker): boolean;
+/** The same blocker: one project's task by its number. */
+export declare function sameBlocker(one: Pick<ElsewhereBlocker, "project" | "id">, other: Pick<ElsewhereBlocker, "project" | "id">): boolean;
+/** How a blocker in another project is written: `webappwiz #404`. */
+export declare function elsewhereName(blocker: Pick<ElsewhereBlocker, "project" | "id"> & {
+    slug?: string;
+}): string;
+/**
+ * `blocker` as `found` says it ended: landed once it merged, lost once
+ * removed, or as it was while still open or unread.
+ */
+export declare function settled(blocker: ElsewhereBlocker, found: ElsewhereTask | null): ElsewhereBlocker;
+/** What `ElsewhereStanding.onBoard` reads, by task number. */
+export interface ElsewhereOnBoard {
+    /** Each task's blockers in other projects, as they stand now. */
+    blockers: Record<number, ElsewhereBlockerNow[]>;
+    /** The tasks of other projects that wait on each task. */
+    following: Record<number, ElsewhereFollower[]>;
+}
+/** A line for each of `blockers`, as `task show` and `queue list` say them. */
+export declare function elsewhereLine(blocker: ElsewhereBlockerNow): string;
+/**
+ * A task of another splates project, `webappwiz #404`, that has to merge
+ * before the task it is kept on starts. Link one with
+ * `ElsewhereLinks.link`; the queue holds the task until `landed` is set.
+ */
+export interface ElsewhereBlocker {
+    /** That project's main tree. */
+    project: string;
+    /** Its number there. */
+    id: number;
+    /** Its subject when linked, for when it is gone. */
+    subject: string;
+    /** The commit it landed as there, once it merged. */
+    landed?: string;
+    /**
+     * Set once it left that board without merging: whether this task still
+     * makes sense is the person's call, made by unlinking it.
+     */
+    lost?: true;
+}
+/**
+ * Where a task of another project stands: the stage it waits in, `working`
+ * once an agent took it, `merged` with the commit it landed as, `removed`
+ * once gone without merging.
+ */
+export type ElsewhereTask = {
+    status: Exclude<TaskStage, "running"> | "working";
+    subject: string;
+    lane: number | null;
+    takenBy: string | null;
+} | {
+    status: "merged";
+    commit: string;
+} | {
+    status: "removed";
+};
+/** What one task's blocker in another project is now, as the page and CLI say it. */
+export interface ElsewhereBlockerNow extends ElsewhereBlocker {
+    /** That project's slug, which `--project` and `?project=` take. */
+    slug: string;
+    /** Where it stands; `unknown` while that project cannot be read. */
+    status: ElsewhereTask["status"] | "unknown";
+}
+/** A task of another project that waits on one of this project's, `blocker`. */
+export interface ElsewhereFollower {
+    /** The number here of the task it waits on. */
+    blocker: number;
+    /** That project's main tree. */
+    project: string;
+    slug: string;
+    id: number;
+    subject: string;
+    stage: TaskStage;
+}
+/** Reads the boards of the other splates projects on this machine. */
+export interface ElsewhereBoards {
+    /** The registered project `slug` names, or null for none. */
+    root(slug: string): Promise<string | null>;
+    /** What the registry names the project at `root` by. */
+    slug(root: string): Promise<string>;
+    /** Task `id` of the project at `root` now, or null when it cannot be read. */
+    find(root: string, id: number): Promise<ElsewhereTask | null>;
+    /** The open tasks of every other project blocked by a task of `root`'s. */
+    following(root: string): Promise<ElsewhereFollower[]>;
+    /** The open tasks of every project but the one at `root`, to pick a blocker from. */
+    openTasks(root: string): Promise<ElsewhereOpen[]>;
+}
+/** An open task of another project, which a task here may wait on. */
+export interface ElsewhereOpen {
+    /** That project's main tree. */
+    project: string;
+    /** Its slug. */
+    slug: string;
+    id: number;
+    subject: string;
+    lane: number | null;
+}

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

@@ -0,0 +1,21 @@
+export { BACKLOG_LANE, protectBacklog } from "./backlog";
+export { blockedWarning } from "./blocked-warning";
+export type { Deferral, DeferralAsk, DeferralBlocker, DeferredQuestion, OutsideBlocker, TaskBlockerStatus, } from "./deferral";
+export { cleared, deferralBlockers, deferralProblem } from "./deferral";
+export type { ElsewhereBlocker, ElsewhereBlockerNow, ElsewhereBoards, ElsewhereFollower, ElsewhereOnBoard, ElsewhereOpen, ElsewhereTask, } from "./elsewhere";
+export { ElsewhereStanding, elsewhereLine, elsewhereName, holding, sameBlocker, } from "./elsewhere";
+export { ElsewhereLinks } from "./elsewhere-links";
+export { laneAdd, laneList, laneQueue, laneRemove, laneShow, laneUpdate, laneUpdated, recordLaneRemove, } from "./lane";
+export type { LaneRecord, LaneState } from "./lanes";
+export { blockerLabel, cycle, elsewhereMention, followers, isReady, lane, lanes, lanesTaken, MENTION, named, } from "./lanes";
+export { lanesFromTags } from "./lanes-from-tags";
+export { BoardRoutes } from "./routes";
+export type { Started, StoredTask } from "./store";
+export { queuedOf, startedOf, TaskStore } from "./store";
+export type { GoneBlocker, LandedBlocker, Task, TaskRecord, TaskStage, } from "./task";
+export { checkSlug, enqueued, tasksNamed, unqueued, wording, } from "./task";
+export { addedFacts, taskAdd, taskRemove, taskUpdate } from "./task-edit";
+export { decodeTask, encodeTask, TASK_FILE } from "./task-file";
+export { recordUpdate } from "./task-journal";
+export { taskList, taskShow } from "./task-list";
+export { Tasks } from "./tasks";

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

@@ -0,0 +1,112 @@
+import {
+  BACKLOG_LANE2,
+  protectBacklog2,
+  ElsewhereStanding2,
+  holding2,
+  sameBlocker2,
+  elsewhereName2,
+  elsewhereLine2,
+  blockedWarning2,
+  cleared2,
+  deferralBlockers2,
+  deferralProblem2,
+  ElsewhereLinks2,
+  lanes2,
+  lanesTaken2,
+  named2,
+  lane2,
+  followers2,
+  isReady2,
+  cycle2,
+  blockerLabel2,
+  MENTION2,
+  elsewhereMention2,
+  laneList2,
+  laneShow2,
+  laneAdd2,
+  laneUpdate2,
+  laneUpdated2,
+  laneQueue2,
+  recordLaneRemove2,
+  laneRemove2,
+  enqueued2,
+  unqueued2,
+  checkSlug2,
+  wording2,
+  tasksNamed2,
+  TASK_FILE2,
+  encodeTask2,
+  decodeTask2,
+  startedOf2,
+  queuedOf2,
+  TaskStore2,
+  Tasks2,
+  lanesFromTags2,
+  taskAdd2,
+  addedFacts2,
+  taskUpdate2,
+  taskRemove2,
+  recordUpdate2,
+  BoardRoutes2,
+  taskList2,
+  taskShow2
+} 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 {
+  BACKLOG_LANE2 as BACKLOG_LANE,
+  BoardRoutes2 as BoardRoutes,
+  ElsewhereLinks2 as ElsewhereLinks,
+  ElsewhereStanding2 as ElsewhereStanding,
+  MENTION2 as MENTION,
+  TASK_FILE2 as TASK_FILE,
+  TaskStore2 as TaskStore,
+  Tasks2 as Tasks,
+  addedFacts2 as addedFacts,
+  blockedWarning2 as blockedWarning,
+  blockerLabel2 as blockerLabel,
+  checkSlug2 as checkSlug,
+  cleared2 as cleared,
+  cycle2 as cycle,
+  decodeTask2 as decodeTask,
+  deferralBlockers2 as deferralBlockers,
+  deferralProblem2 as deferralProblem,
+  elsewhereLine2 as elsewhereLine,
+  elsewhereMention2 as elsewhereMention,
+  elsewhereName2 as elsewhereName,
+  encodeTask2 as encodeTask,
+  enqueued2 as enqueued,
+  followers2 as followers,
+  holding2 as holding,
+  isReady2 as isReady,
+  lane2 as lane,
+  laneAdd2 as laneAdd,
+  laneList2 as laneList,
+  laneQueue2 as laneQueue,
+  laneRemove2 as laneRemove,
+  laneShow2 as laneShow,
+  laneUpdate2 as laneUpdate,
+  laneUpdated2 as laneUpdated,
+  lanes2 as lanes,
+  lanesFromTags2 as lanesFromTags,
+  lanesTaken2 as lanesTaken,
+  named2 as named,
+  protectBacklog2 as protectBacklog,
+  queuedOf2 as queuedOf,
+  recordLaneRemove2 as recordLaneRemove,
+  recordUpdate2 as recordUpdate,
+  sameBlocker2 as sameBlocker,
+  startedOf2 as startedOf,
+  taskAdd2 as taskAdd,
+  taskList2 as taskList,
+  taskRemove2 as taskRemove,
+  taskShow2 as taskShow,
+  taskUpdate2 as taskUpdate,
+  tasksNamed2 as tasksNamed,
+  unqueued2 as unqueued,
+  wording2 as wording
+};

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

@@ -0,0 +1,69 @@
+import { type Logger } from "../../../core/log/index.js";
+import type { Facts, Journal } from "../records";
+import { type LaneRecord } from "./lanes";
+import type { TaskRecord } from "./task";
+import type { Tasks } from "./tasks";
+export interface LaneListOptions {
+    /** Print the lanes as JSON instead of a table. */
+    json?: boolean;
+}
+/** Every lane, with its tasks in order, who is on it, and what blocks it. */
+export declare function laneList({ tasks, log }: {
+    tasks: Tasks;
+    log: Logger;
+}, { json }?: LaneListOptions): Promise<void>;
+export interface LaneShowOptions {
+    /** Print the lane as JSON instead of prose. */
+    json?: boolean;
+}
+/**
+ * One lane in full, step by step: what an agent handed `[SPLATES LANE N]`
+ * reads to know which task is next, and whether it is blocked first. For
+ * null, the untriaged tasks, and how to place them in lanes.
+ */
+export declare function laneShow({ tasks, log }: {
+    tasks: Tasks;
+    log: Logger;
+}, id: number | null, { json }?: LaneShowOptions): Promise<void>;
+/** Starts an empty lane called `name`, after the others. */
+export declare function laneAdd({ tasks, log }: {
+    tasks: Tasks;
+    log: Logger;
+}, name: string): Promise<LaneRecord>;
+export interface LaneUpdateOptions {
+    /** What it is called from now on. */
+    name?: string;
+    /** Where it goes among the lanes, 1 the first; the others close up around it. */
+    position?: number;
+}
+/** Calls a lane by another name, or moves it among the others. */
+export declare function laneUpdate({ tasks, log }: {
+    tasks: Tasks;
+    log: Logger;
+}, id: number, { name, position }?: LaneUpdateOptions): Promise<LaneRecord>;
+/** What a lane update changed, for the event: only the parts it was asked to. */
+export declare function laneUpdated(id: number, record: LaneRecord, { name, position }: LaneUpdateOptions): Facts["lane update"];
+/**
+ * Queues every task waiting in lane `id`, once, journaled as the queue
+ * change it is: the queue starts each once nothing blocks it, and a task put
+ * in the lane later waits to be queued itself. With `queued` false, takes
+ * each of the lane's queued tasks nobody has taken back out. Gives back the
+ * tasks it queued or took out.
+ */
+export declare function laneQueue({ tasks, log, journal }: {
+    tasks: Tasks;
+    log: Logger;
+    journal: Journal;
+}, id: number, queued: boolean): Promise<TaskRecord[]>;
+/** Removes lane `id` through `drop` and journals its name and the tasks it left in no lane. */
+export declare function recordLaneRemove(journal: Journal, tasks: Tasks, id: number, drop: () => Promise<void>): Promise<void>;
+/**
+ * Removes a lane and the tasks in it, each kept to restore as removing it from
+ * its dialog keeps it: the person never wants a lane gone but its tasks left.
+ */
+export declare function laneRemove({ tasks, log }: {
+    tasks: Tasks;
+    log: Logger;
+}, id: number, opts?: {
+    emptyOnly?: boolean;
+}): Promise<void>;