@stringsync/splates 0.0.60 → 1.13.3

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

@@ -0,0 +1,301 @@
+import type { Attachment, Attachments } from "../artifacts";
+import type { AutoPicked } from "../auto-pick";
+import type { AgentPick } from "../models";
+import type { Deferral, DeferralAsk } from "./deferral";
+import { type ElsewhereBlocker } from "./elsewhere";
+import type { Tasks } from "./tasks";
+/**
+ * One numbered task on the board: read its words and links, and take,
+ * update, defer or remove it. Get one from `Tasks`.
+ */
+export declare class Task {
+    private readonly tasks;
+    readonly state: TaskRecord;
+    constructor(tasks: Tasks, state: TaskRecord);
+    get id(): number;
+    get subject(): string;
+    get text(): string;
+    get position(): number;
+    get from(): string | null;
+    get takenBy(): string | null;
+    get createdAt(): Date;
+    /** How long it has waited, in milliseconds. */
+    get waited(): number;
+    /**
+     * The tasks blocking it that have yet to merge, leaving out those `task`
+     * has or takes in the same breath, among `together`: what it should not be
+     * started before.
+     */
+    blockers(task: string, together?: number[]): Promise<Task[]>;
+    /** Marks it as the work of `task`, refusing one another task already has. */
+    take(task: string): Promise<Task>;
+    /**
+     * Claims it for groomer conversation `by` to groom, saying whether `by`
+     * now has it: false for one taken, out of the backlog, or `by`'s already,
+     * which had its turn on it. Taking it or marking it ready ends the claim.
+     */
+    groom(by: string): Promise<boolean>;
+    /**
+     * Marks it as looked at for a lane, so no sort looks again; says whether
+     * it did, false for one taken or already in a lane.
+     */
+    sort(): Promise<boolean>;
+    /** Places a groomed task in Backlog if nobody placed or took it meanwhile. */
+    backlog(): Promise<Task>;
+    /**
+     * Puts it back on the list, as when the task that took it is removed;
+     * `unqueue`, out of the queue too.
+     */
+    release({ unqueue }?: {
+        unqueue?: boolean | undefined;
+    }): Promise<Task>;
+    get files(): string[];
+    /** The tasks that have to merge before it starts. */
+    get blockedBy(): number[];
+    /** The tasks of other projects that have to merge before it starts. */
+    get blockedElsewhere(): ElsewhereBlocker[];
+    get lane(): number | null;
+    get attachments(): Attachments;
+    /**
+     * Says what is left to do in other words, with other files, or higher or
+     * lower in the list, keeping its id and history.
+     */
+    update({ subject, slug, text, position, files, keep, blockedBy, blockedElsewhere, lane, assignee, ready, }: TaskChange): Promise<Task>;
+    /**
+     * Records why the work of `task` was set aside and what it waits on,
+     * linking each task it names, and with `detail`, rewrites its detail for
+     * whoever takes it next. Refuses a task named that is not on the board.
+     */
+    defer(ask: DeferralAsk, { task, conversation, detail, }: {
+        task: string;
+        conversation?: string;
+        detail?: string;
+    }): Promise<Task>;
+    /**
+     * Records the person's answer to question `index` of its deferral, adding
+     * it to its detail for whoever takes it next.
+     */
+    answer(index: number, answer: string): Promise<Task>;
+    /** Marks what its deferral waits on outside splates, `index`, as done. */
+    outsideDone(index: number): Promise<Task>;
+    /**
+     * Removes it for good. `landed` is the commit it merged as, written on
+     * each task it blocked; without one, those it blocked are held for the
+     * person.
+     */
+    remove(landed?: string): Promise<void>;
+    /** Removes it, as the person did, keeping it for `Tasks.restore` to put back. */
+    discard(): Promise<void>;
+}
+/** Everything a task holds: its words, place, links and how far it has come. */
+export interface TaskRecord {
+    id: number;
+    /** Owned and started exclusively by this ship step. */
+    ship?: {
+        run: string;
+        step: string;
+        prepared?: boolean;
+    };
+    /** What is left to do, in a line. */
+    subject: string;
+    /** Whatever more there is to say about it, or empty when the line is enough. */
+    text: string;
+    /** Where it stands in the list, 1 at the top: the one to pick up first. */
+    position: number;
+    /** The task it came up in, or null when a person added it from the main tree. */
+    from: string | null;
+    createdAt: string;
+    slug?: string;
+    /** The task working on it now, or null while it waits to be picked up. */
+    takenBy: string | null;
+    /** The files attached to it, by absolute path, to read or show. */
+    files: string[];
+    /** The tasks here that have to merge before this one starts, by number. */
+    blockedBy: number[];
+    /** The lane it runs in, or null for none. */
+    lane: number | null;
+    /** How far it has come: groomed, queued, running, or none of them yet. */
+    stage: TaskStage;
+    /** Whether it was groomed, kept once queued and running, so one let go goes back to ready. */
+    groomed?: true;
+    /** The groomer conversation that claimed it, in the backlog untaken; absent for none. */
+    grooming?: string;
+    /** Set once a groomer has looked for a lane to put it in, so none looks again. */
+    sorted?: true;
+    /** The agent, and model, that should work it, over its lane's; absent for none. */
+    assignee?: AgentPick;
+    /** The other project it was added from; absent for one added here. */
+    origin?: TaskOrigin;
+    /**
+     * Tasks it was blocked by that merged, and the commit each landed as, so
+     * whoever starts it can read what it builds on; absent for none.
+     */
+    blockersLanded?: LandedBlocker[];
+    /**
+     * Tasks it was blocked by that were removed without merging. While any
+     * is here, nothing starts it on its own: whether it still makes sense is
+     * the person's call, made by unlinking each. Absent for none.
+     */
+    blockersLost?: GoneBlocker[];
+    /**
+     * Tasks of other projects that have to merge before this one starts,
+     * kept once they merge, with the commit each landed as; absent for none.
+     */
+    blockedElsewhere?: ElsewhereBlocker[];
+    /** Its last Auto pick, with what the judge said of its words; absent for none. */
+    autoPick?: AutoPicked;
+    /** Who queued it, kept while it is queued or running; absent for one never queued. */
+    queuedBy?: QueuedBy | {
+        by: "ship";
+        project: string;
+    };
+    /** When it was last queued, kept while it is queued or running; absent for one never queued. */
+    queuedAt?: string;
+    /**
+     * The blockers that must be resolved before this task can run again.
+     * Absent when no blocker caused it to leave the queue.
+     */
+    unqueuedFor?: number[];
+    /**
+     * Why its work was last set aside and what it waits on, kept once it is
+     * taken again, so the page can follow it; absent for one never deferred.
+     */
+    deferred?: Deferral;
+}
+/**
+ * `state` put in the queue by `by`, now, with why the queue last let it go
+ * forgotten.
+ */
+export declare function enqueued<T extends TaskRecord>(state: T, by: QueuedBy): T;
+/**
+ * Who queued a task: the person directly, or a lane they queued.
+ */
+export type QueuedBy = {
+    by: "person";
+} | {
+    by: "lane";
+    lane: number;
+};
+/**
+ * `state` taken out of the queue: back in ready when it was groomed, else
+ * the backlog. The queue lets one go itself, saying why in `unqueuedFor`.
+ */
+export declare function unqueued<T extends TaskRecord>(state: T): T & {
+    stage: "ready" | "backlog";
+};
+/**
+ * `state` as it is to be saved: pass whether it has started, which makes it
+ * `running`. A task once ready stays groomed.
+ */
+export declare function staged(state: TaskRecord, running: boolean): TaskRecord;
+/** A task's words, place or files changed: new ones added, some of the old kept. */
+export interface TaskChange {
+    /** A new line; the old one stays when this is absent. */
+    subject?: string;
+    /** A new name for the task that takes it; the old stays when this is absent. */
+    slug?: string;
+    /** New detail, empty for none; the old stays when this is absent. */
+    text?: string;
+    /** Where to move it in the list; it stays put when this is absent. */
+    position?: number;
+    /** Files to add. */
+    files?: Attachment[];
+    /** The paths of the files it has now to keep; absent keeps them all. */
+    keep?: string[];
+    /** Every task blocking it from now on; the old stay when this is absent. */
+    blockedBy?: number[];
+    /** Every task of another project blocking it from now on; the old stay when this is absent. */
+    blockedElsewhere?: ElsewhereBlocker[];
+    /** The lane it runs in, `"new"` for one of its own, null for none; it stays when absent. */
+    lane?: number | "new" | null;
+    /** The agent that should work it, null for none; it stays when absent. */
+    assignee?: AgentPick | null;
+    /** Marks it groomed, moving it from the backlog to ready; absent leaves it as it is. */
+    ready?: boolean;
+}
+/**
+ * Where a task came up, as a list shows it: the task started here, or for one added
+ * from another project, `<project>/<task>`, the project by its directory's
+ * name; null for one a person added from the main tree.
+ */
+export declare function cameFrom({ from, origin }: TaskRecord): string | null;
+/** The other project a task was added from, and the started task there it came up in. */
+export interface TaskOrigin {
+    /** That project's main tree. */
+    project: string;
+    /** The started task it came up in, or null for its main tree. */
+    task: string | null;
+}
+/** What a new task has besides its subject, all of it optional. */
+export interface TaskNew {
+    ship?: {
+        run: string;
+        step: string;
+        prepared?: boolean;
+    };
+    /**
+     * The name the task that takes it starts under, its branch, worktree and
+     * conversation's; absent, the queue names it from its subject.
+     */
+    slug?: string;
+    /** Whatever more there is to say about it. */
+    text?: string;
+    files?: Attachment[];
+    /** Where it goes in the list, pushing those from there down; the bottom by default. */
+    position?: number;
+    /** The tasks blocking it: each has to merge before it starts. */
+    blockedBy?: number[];
+    /** The tasks of other projects blocking it, each to merge there first. */
+    blockedElsewhere?: ElsewhereBlocker[];
+    /** The lane it goes in, `"new"` for one of its own; none by default. */
+    lane?: number | "new" | null;
+    /** The agent that should work it; none by default. */
+    assignee?: AgentPick | null;
+    /** The other project it is added from; none by default. */
+    origin?: TaskOrigin;
+    /**
+     * Whether whoever wrote it groomed it, so it goes in ready; by default it
+     * goes in the backlog, for grooming.
+     */
+    ready?: boolean;
+}
+/** `state` worked by `assignee`, or by nobody in particular for null. */
+export declare function assigned<State extends {
+    assignee?: AgentPick;
+}>(state: State, assignee: AgentPick | null | undefined): State;
+/** Refuses `slug` unless `SLUG` allows it, saying so with `facts`. */
+export declare function checkSlug(slug: string, facts: Record<string, unknown>): void;
+/**
+ * A subject and its detail, trimmed, the subject kept to one line, so the
+ * list shows one line a task: the rest of a longer one leads the detail.
+ */
+export declare function wording(subject: string, text: string): {
+    subject: string;
+    text: string;
+};
+/** `tasks` as an event names them: each by its id and subject. */
+export declare function tasksNamed(tasks: readonly Task[]): {
+    id: number;
+    subject: string;
+}[];
+/** A task that blocked another and has left the list. */
+export interface GoneBlocker {
+    id: number;
+    subject: string;
+    /** The other project's main tree, for a task of another project; absent for one here. */
+    project?: string;
+}
+/** A blocker that merged, as the commit it landed as. */
+export interface LandedBlocker extends GoneBlocker {
+    commit: string;
+}
+/**
+ * Where a task stands: `backlog` until grooming has looked for a duplicate
+ * and linked what it depends on, then `ready`, whether or not it names an
+ * agent, which is picked when it runs otherwise; `queued` once the person
+ * puts it in the queue, from either, for a worker to start; and `running`
+ * while an agent works it in a worktree.
+ */
+export type TaskStage = "backlog" | "ready" | "queued" | "running";
+/** The stages a task waits in before it starts, which it goes back to if let go. */
+export type WaitingStage = Exclude<TaskStage, "running">;

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

@@ -0,0 +1,172 @@
+import { type IdProvider } from "../../../core/id/index.js";
+import { Attachments } from "../artifacts";
+import type { LaneUpdateOptions } from "./lane";
+import { type LaneRecord } from "./lanes";
+import { type TaskStore } from "./store";
+import { Task, type TaskNew, type TaskRecord } from "./task";
+/**
+ * A project's board: add, find, link, place and remove its tasks and
+ * lanes. Open it on the project's `TaskStore`.
+ */
+export declare class Tasks {
+    /**
+     * Where the records are, whose lock is held while numbering a new
+     * task, so two agents never share an id, and while writing one, so a
+     * move renumbering the rest never loses to a write of a position it
+     * just changed.
+     */
+    readonly store: TaskStore;
+    private readonly ids;
+    private readonly laneFiles;
+    constructor(
+    /**
+     * Where the records are, whose lock is held while numbering a new
+     * task, so two agents never share an id, and while writing one, so a
+     * move renumbering the rest never loses to a write of a position it
+     * just changed.
+     */
+    store: TaskStore, opts?: TasksOptions);
+    get dir(): string;
+    /** Where a queued task's files live, beside its record. */
+    attachments(id: number): Attachments;
+    /**
+     * Whether `path` is a file some task holds, one level inside its folder:
+     * never a record, and not a way out of here.
+     */
+    owns(path: string): boolean;
+    add(subject: string, from: string | null, { slug, ship, text, files, position, blockedBy, blockedElsewhere, lane, assignee, origin, ready, }?: TaskNew): Promise<Task>;
+    /** Every task on the board, top of the list first, numbered from 1. */
+    all(): Promise<Task[]>;
+    find(id: number): Promise<Task>;
+    /** The queued tasks `task` has taken; what a merge or remove settles. */
+    takenBy(task: string): Promise<Task[]>;
+    /**
+     * Puts a task at `position`, 1 at the top, past the bottom meaning the
+     * bottom, and numbers the rest around it. Refuses to put one above a task
+     * in its own lane that it comes after, or below one that comes after it.
+     */
+    move(id: number, position: number): Promise<Task>;
+    /**
+     * Says `id` comes after the tasks in `add`, and no longer after those in
+     * `drop`: it is not to be started until they merge. Refuses a link that
+     * would make a loop, naming the tasks in it, and moves a task down below
+     * anything in its own lane it now comes after.
+     */
+    link(id: number, { add, drop }: {
+        add?: number[];
+        drop?: number[];
+    }): Promise<Task>;
+    /**
+     * Puts a task in a lane, or in none for null. `"new"` starts a lane of its
+     * own, called `name`, or after the task without one. With `before`, it goes just above that task; otherwise it goes
+     * below the rest of the lane, or keeps its place when that is in none or
+     * new. Refuses a place above a task in the lane that it comes after, or
+     * below one that comes after it.
+     */
+    arrange(id: number, lane: number | "new" | null, { before, name }?: {
+        before?: number;
+        name?: string;
+    }): Promise<Task>;
+    /** Places an unmatched task in Backlog, preserving concurrent placement or taking. */
+    backlog(id: number): Promise<Task>;
+    /** Every lane, in board order. */
+    lanes(): Promise<LaneRecord[]>;
+    /** The name of every lane there has been, those on the board first. */
+    laneNames(): Promise<LaneRecord[]>;
+    /** Moves every task in lane `from` to the bottom of lane `into`; `from` is gone. */
+    joinLanes(from: number, into: number): Promise<void>;
+    /** Starts an empty lane called `name`, after the others. */
+    addLane(name: string): Promise<LaneRecord>;
+    /** Calls lane `id` by another name. */
+    renameLane(id: number, name: string): Promise<LaneRecord>;
+    /** Puts lane `id` at `position` among the lanes, 1 the first column. */
+    moveLane(id: number, position: number): Promise<LaneRecord[]>;
+    /** Makes each change asked of lane `id`, as `changeLane` says. */
+    changeLane(id: number, change: LaneUpdateOptions): Promise<{
+        record: LaneRecord | undefined;
+        order: LaneRecord[] | undefined;
+    }>;
+    /** Queues every task waiting in lane `id` once, or takes its queued ones out. */
+    queueLane(id: number, queued: boolean): Promise<{
+        lane: LaneRecord;
+        changed: TaskRecord[];
+    }>;
+    /** Removes lane `id`, putting its tasks back in none, untriaged. */
+    dropLane(id: number, opts?: {
+        emptyOnly?: boolean;
+    }): Promise<void>;
+    /** @internal Removes each lane in `ids` that no task is in any more. */
+    endLanes(ids: number[]): Promise<void>;
+    /** Moves tasks saved while splates kept tags into lanes, one lane a tag. */
+    moveTagsToLanes(): Promise<{
+        lane: LaneRecord;
+        tasks: number[];
+    }[]>;
+    /**
+     * @internal Rewrites one task as it stands on disk now, under the lock, so
+     * a change to its words or who has it never undoes a move made meanwhile.
+     */
+    revise(id: number, change: (state: TaskRecord) => TaskRecord): Promise<Task>;
+    /**
+     * @internal Writes one task, keeping what starting it added, which the
+     * list leaves to the task's worktree. Call it under the lock.
+     */
+    save(state: TaskRecord): Promise<Task>;
+    /**
+     * @internal Removes one, moving those below it up to close the gap. What
+     * came after it no longer waits on it, so no task is left naming one that
+     * is gone. A merged blocker keeps the commit it landed as.
+     */
+    delete(id: number, landed?: string): Promise<boolean>;
+    /**
+     * @internal Removes one as `delete` does, keeping it and its files under
+     * `removed/` for `restore` to put back. Only the newest `REMOVED_KEPT` are
+     * kept, the older going for good.
+     */
+    discard(state: TaskRecord): Promise<void>;
+    /**
+     * Puts a task `discard` removed back under its id, where it stood in the
+     * list, untaken: in its lane while that lane is still on the board, after
+     * those it waited on that still are.
+     */
+    restore(id: number): Promise<Task>;
+    /** @internal Runs `run` holding the lock every write goes through. */
+    locked<T>(run: () => Promise<T>): Promise<T>;
+    /**
+     * Settles the list after a link or a lane changed, moving each task below
+     * what it comes after in its lane, and gives back `id` as it ends up.
+     * Call it under the lock.
+     */
+    private settled;
+    /** Refuses `order` when a lane in it puts a task above one it comes after. */
+    private ordered;
+    /** One task as it stands on disk; call it under the lock. */
+    private state;
+    /**
+     * Slots `state` in at `position` among the rest and saves whichever moved.
+     * Call it under the lock.
+     */
+    private place;
+    /**
+     * @internal Every task in list order, with the positions it has on disk. `tagged`
+     * are read though they still have tags, to move them into lanes.
+     */
+    stored(tagged?: number[]): Promise<TaskRecord[]>;
+    /** @internal Saves each task in `order` whose position on disk is not its place there. */
+    renumber(order: TaskRecord[]): Promise<void>;
+    /** The tasks `discard` kept, the oldest removed first. */
+    private removed;
+    /**
+     * One task, or null when it will not parse. One saved with tags is
+     * refused, unless it is one of `tagged`: dropping them unasked would lose
+     * what they grouped.
+     */
+    private read;
+}
+/** How many removed tasks `Tasks.discard` keeps for `restore`. */
+export declare const REMOVED_KEPT = 50;
+/** What `Tasks` is made with. */
+export interface TasksOptions {
+    /** What names stored files apart; random ids by default. */
+    ids?: IdProvider;
+}

package/vendor/@stringsync/splates-server/chunk-files-jkqj87yx.js

@@ -0,0 +1,14 @@
+// web-build/chunk-maps.txt
+var chunk_maps_default = "./chunk-maps-mnjqydx4.txt";
+
+// web-build/chunks.txt
+var chunks_default = "./chunks-3jkzx1q9.txt";
+
+// server/chunk-files.ts
+var chunkFiles = {
+  code: new URL(chunks_default, import.meta.url),
+  maps: new URL(chunk_maps_default, import.meta.url)
+};
+export {
+  chunkFiles
+};