@stringsync/splates 0.0.60 → 1.13.3

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

@@ -0,0 +1,223 @@
+import type { Fs } from "../../../core/system/index.js";
+/** The plan each task keeps at its worktree root, excluded from git. */
+export declare const PLAN_FILE = "SPLATES.md";
+/** Where tasks keep their plans: each worktree's `SPLATES.md`, read through `fs`. */
+export declare class Plans {
+    private readonly fs;
+    constructor(fs: Fs);
+    /**
+     * The plan in worktree `tree`, or null for none: an agent still on arbor's
+     * skill keeps it as `ARBOR.md`, read when there is no `SPLATES.md`.
+     */
+    read(tree: string): Promise<string | null>;
+    /**
+     * Keeps plans out of git in every worktree of the repository whose shared
+     * `.git` is `gitDir`, leaving the repo's own .gitignore alone.
+     */
+    exclude(gitDir: string): Promise<void>;
+}
+/**
+ * The steps `splates add` once wrote under `## Next`, asking its agent to
+ * plan: a plan that still holds them has no work under way.
+ */
+export declare const STUB_STEPS: string[];
+/**
+ * What an `SPLATES.md` says its task is for: the first line under `## Goal`, or
+ * null when it says nothing yet. One line, since it sits beside other tasks'
+ * in `splates list --files`.
+ */
+export declare function goalLine(text: string): string | null;
+/**
+ * The `## <name>` section of an `SPLATES.md`, heading and all, apart from the
+ * rest of it: null for one it does not have. The task dialog shows
+ * `## Verification` on its own, above the rest.
+ */
+export declare function sectionApart(text: string, name: string): {
+    section: string | null;
+    rest: string;
+};
+/**
+ * What an `SPLATES.md` says came of its task: all of `## Outcome`, as
+ * markdown, or "" when it says nothing. The merge record keeps it, since the
+ * plan goes with the worktree.
+ */
+export declare function outcomeOf(text: string): string;
+/**
+ * What an `SPLATES.md` says done means: all of `## Goal`, as markdown, or ""
+ * when it says nothing yet.
+ */
+export declare function goalOf(text: string): string;
+/**
+ * One `- [ ] 9.` item under `## Blocked`: something only a person can do.
+ * The item's line is its subject; lines indented under it are its body, and
+ * `- (a) ...`, `- [a] ...` or `- a. ...` lines among them are the answers it
+ * offers.
+ */
+export interface Question {
+    /** As the plan numbers it, `9`: the name a reply goes by. */
+    number: string;
+    /** Checked off, which the agent does once it has acted on the reply. */
+    done: boolean;
+    /** The item's own line, without its checkbox, number, size or reply. */
+    text: string;
+    /**
+     * The `(large)` that led its line in plans from when the skill sized
+     * questions, which outcomes still keep; null when it has none.
+     */
+    size: string | null;
+    /**
+     * The markdown indented under it, dedented, choices left out: detail,
+     * code blocks, `![shot](/abs/path.png)` images. Empty when there is none.
+     */
+    body: string;
+    /** Whatever follows ` → `, or null when nobody has answered yet. */
+    reply: string | null;
+    /**
+     * What a person added once the reply was read, oldest first: each an
+     * indented `→ ` line under the question.
+     */
+    followUps: string[];
+    /**
+     * The answers it offers, in order. Empty for a question answered in words
+     * alone. A reply can always add words to its picks, or answer in words
+     * instead.
+     */
+    choices: Choice[];
+    /**
+     * `one` for `- (a)` choices, at most one of which a reply picks; `any` for
+     * `- [a]` choices, where it picks all that apply; `order` for `- a.`
+     * choices, which a reply puts in order, every one of them, as `b, a, c`.
+     * Null without choices.
+     */
+    pick: "one" | "any" | "order" | null;
+}
+/** One answer a question offers: `- (b) Migrate on next login`. */
+export interface Choice {
+    /** The letter it goes by: `b`. */
+    key: string;
+    /** What it says, without the `(chosen)` that may end it. */
+    text: string;
+    /**
+     * The markdown indented under it, dedented: most often the screenshot of
+     * what it would look like. Empty when there is none.
+     */
+    body: string;
+    /**
+     * Why the agent would go with it, or not: a `Why:` line under it, without
+     * the label, kept out of `body`. The page folds
+     * it away until asked. Empty when there is none.
+     */
+    why: string;
+    /**
+     * Marked `(chosen)`: what the agent went with while it waits for the reply,
+     * which picks nothing for the person.
+     */
+    chosen: boolean;
+}
+/** `text` without the size that leads it, and that size, or null. */
+export declare function sized(text: string): {
+    text: string;
+    size: string | null;
+};
+/**
+ * Every numbered item under `## Blocked`, open or checked off, each with the
+ * indented lines under it. The reply is read off the item's own line: an
+ * answer is one line after the arrow, which the agent writes in from the
+ * user's reply in chat.
+ */
+export declare function questions(text: string): Question[];
+/**
+ * The questions under `## Blocked` still waiting on a person: unchecked and
+ * unanswered. One answered and unchecked is a follow-up for the agent.
+ */
+export declare function openQuestions(text: string): Question[];
+/**
+ * Adds what `line` offers to `asked`, saying whether it did: an indented
+ * `- (a) text` picks one, `- [a] text` picks any, and `- a. text` is put in
+ * order, and a line indented past a choice's dash, such as its screenshot,
+ * belongs to that choice. The first choice says which for the question. The
+ * same in a plan and in a conversation, which `asked.ts` reads with this.
+ */
+export declare function offers(asked: Pick<Question, "choices" | "pick">, line: string): boolean;
+/** `asked` with `body` as its own, and each choice's dedented. */
+export declare function settled(asked: Question, body: string[]): Question;
+/** Lines with the indent they all share taken off, blank ends trimmed. */
+export declare function dedent(lines: string[]): string;
+/**
+ * How the person met the agent's picks under `## Blocked`: the questions
+ * asked, those that offered a `(chosen)` choice and were answered with a
+ * choice, and of those, the ones answered with another, and the ones answered
+ * with the agent's choice but with words added, in the reply or a follow-up.
+ * A moot question, or one answered in words alone, is asked but picks nothing.
+ */
+export declare function picks(text: string): {
+    asked: number;
+    picked: number;
+    overturned: number;
+    amended: number;
+};
+/**
+ * One call a plan made, as an outcome keeps it: enough to count how the
+ * agent's recommendations fare by size, and to size it again by its line if
+ * the scheme changes.
+ */
+export interface Decision {
+    /** As the plan numbers it. */
+    number: string;
+    /** The item's line, without its size. */
+    text: string;
+    /** The word its line was sized with, or null for none. */
+    size: string | null;
+    /**
+     * What became of the agent's recommendation: a pick taken as it was,
+     * kept; taken with words added, amended; answered with another choice,
+     * overturned. Null for a question with no pick to meet, or one never
+     * answered with a choice.
+     */
+    ended: "kept" | "amended" | "overturned" | null;
+}
+/** Every question in the plan `text`, in the order numbered. */
+export declare function decisions(text: string): Decision[];
+/** What still stands between a task and trunk, as its plan tells it. */
+export interface Unfinished {
+    /** Each unchecked question under `## Blocked`, by number: `["2", "4"]`. */
+    questions: string[];
+    /** Each unchecked step under `## Next`, as written. */
+    steps: string[];
+}
+/**
+ * The questions and steps a plan leaves unchecked. Nothing in either means the
+ * task is ready to merge: `splates merge` lands it, or its agent's Ready to
+ * merge report asks a person to look first. A task with no plan has nothing
+ * left.
+ */
+export declare function unfinished(text: string): Unfinished;
+/** Whether {@link unfinished} found nothing left. */
+export declare function ready({ questions, steps }: Unfinished): boolean;
+/** What {@link unfinished} found, as a clause: `questions 1, 2 unchecked under ## Blocked`. */
+export declare function whatIsLeft({ questions, steps }: Unfinished): string;
+/**
+ * The plan with a new open question at the end of `## Blocked`, the section
+ * made if missing, numbered after the highest there. Returns the plan and the
+ * number it went by.
+ */
+export declare function withQuestion(text: string, subject: string, body?: string): {
+    plan: string;
+    number: string;
+};
+/**
+ * A question's number however a person typed it: `9`, `9.`, `Q9` and `q9:`
+ * all mean `9`. Null for anything that is not a number at all.
+ */
+export declare function questionNumber(raw: string): string | null;
+export interface PlanOptions {
+    /** The task name the title is expected to match. */
+    task: string;
+}
+/**
+ * Every way a task's `SPLATES.md` departs from the shape the agent skill
+ * prescribes, phrased for the agent that wrote it. Advisory only: a resumable
+ * plan is the point, and a malformed one still beats none, so nothing here
+ * blocks a merge.
+ */
+export declare function checkPlan(text: string, { task }: PlanOptions): string[];

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

@@ -0,0 +1,148 @@
+/** What a chat with an agent takes to mean task `id`. */
+export declare function taskNumberReference(id: number): string;
+/**
+ * What the untriaged lane, the tasks in no lane, goes by where a lane's
+ * number would: `[SPLATES LANE untriaged]`, `splates lane show untriaged`.
+ */
+export declare const UNTRIAGED = "untriaged";
+/**
+ * What opens the conversation a hook starts on task event `name`, about the
+ * queued tasks `numbers` and the started `task`, before the hook's prompt.
+ */
+export declare function eventReference(name: string, numbers: readonly number[], task: string | null): string;
+/**
+ * What opens the conversation an automation starts when its schedule comes
+ * due, named by the automation's number, before its prompt.
+ */
+export declare function scheduleReference(automation: string): string;
+/**
+ * What tells the project's groomer to groom backlog task `id`, which
+ * `splates server` claimed for it: the splates skill says what it means.
+ */
+export declare function groomReference(id: number): string;
+/**
+ * What tells the project's groomer to look for lanes for Untriaged tasks
+ * `ids`, which `splates server` marked as looked at: the splates skill says
+ * what it means.
+ */
+export declare function sortReference(ids: readonly number[]): string;
+/** What a chat with an agent takes to mean "claim `task` and carry on with it". */
+export declare function taskReference(task: string): string;
+/** Where a demo shows a task: just before its change, with it, or on main now. */
+export type DemoPoint = "before" | "after" | "main";
+/**
+ * What asks an agent to set up a demo of `task` at `point`, as the task
+ * dialog's Demo buttons send: the splates skill says what it means.
+ */
+export declare function demoReference(task: string, point: DemoPoint): string;
+/**
+ * What asks an agent to take merged `task` back off its base, as the merged
+ * card's Unmerge sends, with what the person wrote in its dialog after it:
+ * the splates skill says what it means, checking first that it can be undone.
+ */
+export declare function unmergeReference(task: string, note: string): string;
+/**
+ * What a chat with an agent takes to mean "claim `task` and carry on with
+ * it" from an agent that stopped on it without handing it over, whose last
+ * turns are at `transcript`.
+ */
+export declare function handOffReference(task: string, transcript: string): string;
+/**
+ * What opens a project's conversation that carries on from a General one,
+ * whose turns are at `transcript`: it reads them, then works in the project,
+ * where the splates skill has it add a task before changing code.
+ */
+export declare function continuedReference(transcript: string): string;
+/** What a chat with an agent takes to mean "walk the user through setup step `step`". */
+export declare function setupReference(step: string): string;
+/**
+ * Whether `text` is an update splates itself tells the conversation that handed
+ * tasks out: a report, or, in a conversation from before lanes stopped
+ * running, idle, a task done, open, added, to groom or to sort, or lanes
+ * done; never the person's word.
+ */
+export declare function isUpdate(text: string): boolean;
+/**
+ * What tells an agent a run its run evals card asked for is done, the batch
+ * it wrote named, before its condensed report: the splates skill says what it
+ * means.
+ */
+export declare function evalsDoneReference(batch: string): string;
+/**
+ * What asks an agent to bring its `SPLATES.md` up to date and stop, as before a
+ * restart: the splates skill says what it means.
+ */
+export declare const CHECKPOINT = "[SPLATES CHECKPOINT]";
+/**
+ * What asks an agent to carry on from where its `SPLATES.md` says it stopped,
+ * after a checkpoint: the splates skill says what it means.
+ */
+export declare const RESUME = "[SPLATES RESUME]";
+/**
+ * What asks an agent to carry on with a turn a lost connection cut short:
+ * send it from the page's Reconnect button, or once the agent's process is
+ * lost. The splates skill says what it means.
+ */
+export declare const RECONNECT = "[SPLATES RECONNECT]";
+/**
+ * What approves a task's review and asks the agent to merge it, as the Ready
+ * to merge card's Merge button sends: the splates skill says what it means.
+ */
+export declare const MERGE = "[SPLATES MERGE]";
+/**
+ * What tells an agent the person allowed the command its run-command card
+ * asked to run, or turned it down, as that card's Allow and Deny send: the
+ * splates skill says what it means.
+ */
+export declare const RUN_ALLOWED = "[SPLATES RUN ALLOWED]";
+export declare const RUN_DENIED = "[SPLATES RUN DENIED]";
+/**
+ * What tells an agent the person granted its task another round of merge
+ * attempts, as `splates retry` does, from its retry card or the refused
+ * merge's Grant: the page has granted them already, so the agent merges
+ * again. The splates skill says what it means.
+ */
+export declare const RETRIED = "[SPLATES RETRIED]";
+/**
+ * What tells an agent the person gave the reach its grant card asked for,
+ * from the card's Allow: the page has granted it already, so the agent
+ * carries on with the work it was for. The splates skill says what it means.
+ */
+export declare const GRANTED = "[SPLATES GRANTED]";
+/**
+ * What tells an agent the person turned down the reach its grant card
+ * asked for, from the card's Deny, any note after it: nothing was granted,
+ * so the agent carries on without the reach. The splates skill says what it
+ * means.
+ */
+export declare const GRANT_DENIED = "[SPLATES GRANT DENIED]";
+/**
+ * What approves an agent's proposal as it stands and asks it to go ahead,
+ * the answers to any calls it chose nothing for after it, as the Proposed
+ * card's Approve button sends: the splates skill says what it means.
+ */
+export declare const APPROVE = "[SPLATES APPROVE]";
+/**
+ * What asks an agent to make the request after it a queued task rather than do it,
+ * or, alone, to make the person's message before it one, with what it did on
+ * it since, and stop, as the composer's Defer offers: the splates skill says
+ * what it means.
+ */
+export declare const DEFER = "[SPLATES DEFER]";
+/**
+ * What the agent alone is told of a message the person dictated: the page
+ * marks it with a mic, and never shows these words.
+ */
+export declare const DICTATED = "(Dictated by voice: words that sound alike may be swapped, and names in this project misspelled. Read a near miss as the closest name in the project, and ask before acting on a reading that changes what you do.)";
+/** Each `[SPLATES ...]` directive in a text, wherever it stands. */
+export declare const DIRECTIVES: RegExp;
+/**
+ * The directives `text` starts with, in order, and what follows them; none
+ * when it starts with anything else.
+ */
+export declare function leadingDirectives(text: string): {
+    directives: string[];
+    rest: string;
+};
+/** Directive `text` trimmed, in the words splates uses for it today. */
+export declare function directive(text: string): string;

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

@@ -0,0 +1,45 @@
+import type { Question } from "./plan";
+/** What a reply says to one question: the letters it picks, then its words. */
+export interface Answer {
+    picks: string[];
+    words: string;
+}
+/**
+ * The question an answer is for: its number, its line, and the letters it
+ * offers and how they are picked.
+ */
+type Asked = Pick<Question, "number" | "text" | "choices" | "pick">;
+/**
+ * `answers` to `questions` as a reply, quote and reply: each question
+ * answered, its line quoted in bold, its picks under it as a list spelled out
+ * with their text, numbered when in order, and then its words; last, what else
+ * the person says, under a quoted "Anything else?" (alone, bare, when no
+ * question is answered). Unanswered questions are left out, so nothing in the reply
+ * goes by a number or a letter alone.
+ */
+export declare function replyOf(questions: Asked[], answers: (Answer | null)[], more: string): string;
+/** Whether `answer` says nothing: no picks, and no words but spaces. */
+export declare function isEmpty(answer: Answer): boolean;
+/** The answer that takes `asked` as the agent recommends it: its `(chosen)` choices. */
+export declare function takenOf(asked: Question): Answer;
+/** Whether `answer` changes what `asked` recommends: says anything but its `(chosen)` choices. */
+export declare function changes(asked: Question, answer: Answer): boolean;
+/**
+ * What a quote-and-reply reply in `text` says to `asked`, found by its line
+ * rather than its number, or null when it quotes another: what follows its
+ * quote, up to the next question's.
+ */
+export declare function quotedIn(text: string, asked: Asked): Answer | null;
+/**
+ * What the reply in `text` says to `asked`, or null when it has nothing for
+ * it: quoted, as the question cards write it, or a line typed by hand as the
+ * splates skill reads one, `2. b`, `1. a, c`, `2. b: only on phones`, or
+ * `3. after a phone check`, by the number of the report it answers.
+ */
+export declare function answerIn(text: string, asked: Asked): Answer | null;
+/**
+ * What `text`, a reply, says besides its answers to `asked`: what follows
+ * its quoted "Anything else?", else what comes before its first quoted question, or around the lines typed by hand.
+ */
+export declare function besides(text: string, asked: Asked[]): string;
+export {};

package/vendor/@stringsync/splates-server/plans/run-command.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Whether `command`, from a run-command card, may need a suite grant: a
+ * `bin/mono test` (including scopes reaching half the test files), or a
+ * `bin/mono premerge` or `bun run premerge` without `--evals`, which an agent is
+ * refused until the person approves one run. Leading `VAR=value` words are
+ * passed over.
+ */
+export declare function isWholeSuite(command: string): boolean;
+/**
+ * The task a run-command card's `splates retry <task>` asks another round of
+ * merge attempts for, which the page grants itself on Allow, as only the
+ * person may; null for any other command.
+ */
+export declare function retryOf(command: string): string | null;
+/**
+ * The project a run-command card's `splates ship [<project>]` asks to ship,
+ * which the page starts itself on Allow, as only the person may: "" for the
+ * conversation's own project when it names none; null for any other command,
+ * `--plan` and any other flag included.
+ */
+export declare function shipOf(command: string): string | null;

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

@@ -0,0 +1,26 @@
+import type { Fs } from "../../../core/system/index.js";
+import type { Storage } from "../storage";
+/**
+ * Each task's `SPLATES.md` kept in repo state, ``plans/<task>.md``,
+ * through the command's `fs`: on a worker that is the server's disk, so
+ * the plan outlives the checkout it was written in. It is never in a branch,
+ * and so never on trunk.
+ */
+export declare class PlanStore {
+    /** Reads and writes the checkouts' own `SPLATES.md`. */
+    private readonly fs;
+    private readonly plans;
+    private readonly kept;
+    constructor(
+    /** Reads and writes the checkouts' own `SPLATES.md`. */
+    fs: Fs, 
+    /** The project's, holding `plans/`. */
+    storage: Storage);
+    /** Copies the plan in checkout `tree` here; a tree with none changes nothing. */
+    save(task: string, tree: string): Promise<void>;
+    /** Forgets the plan of a task that merged or was removed. */
+    drop(task: string): Promise<void>;
+    /** Writes the kept plan into checkout `tree` when it has none of its own. */
+    restore(task: string, tree: string): Promise<boolean>;
+    private at;
+}

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

@@ -0,0 +1,15 @@
+import type { Message } from "../conversations";
+import type { Needing } from "./needs";
+import type { Question } from "./plan";
+/**
+ * Of `open`, a task's open questions, returns those the person has not yet
+ * answered in `messages`, to tell a conversation still asking from one whose
+ * answers the agent has yet to record.
+ */
+export declare function unanswered(open: Question[], messages: Message[]): Question[];
+/**
+ * Tells whether `row` waits on you, for ⌥⌘M, Needs you and the waiting counts
+ * to stop on: true while its conversation has stopped on you with questions
+ * no reply has answered yet.
+ */
+export declare function waitsOnYou({ conversation, need }: Needing): boolean;

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

@@ -0,0 +1,8 @@
+export { portsLs } from "./list";
+export type { PortLink } from "./routes";
+export { claimedFirst, DevTaskPorts, portOwnersOf } from "./routes";
+export { devSlot } from "./slot";
+export { slotTunnelSetup } from "./slot-tunnel";
+export type { Held, Slot } from "./slots";
+export { freedLine, MACHINE_HOME, SERVER_PID, SLOT, SLOT_POOL, Slots, slotOf, } from "./slots";
+export type { PortOwners } from "./task-ports";

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

@@ -0,0 +1,36 @@
+import {
+  portsLs2,
+  DevTaskPorts2,
+  portOwnersOf2,
+  claimedFirst2,
+  slotTunnelSetup2,
+  SERVER_PID2,
+  SLOT2,
+  MACHINE_HOME2,
+  Slots2,
+  SLOT_POOL2,
+  freedLine2,
+  slotOf2,
+  devSlot2
+} 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 {
+  DevTaskPorts2 as DevTaskPorts,
+  MACHINE_HOME2 as MACHINE_HOME,
+  SERVER_PID2 as SERVER_PID,
+  SLOT2 as SLOT,
+  SLOT_POOL2 as SLOT_POOL,
+  Slots2 as Slots,
+  claimedFirst2 as claimedFirst,
+  devSlot2 as devSlot,
+  freedLine2 as freedLine,
+  portOwnersOf2 as portOwnersOf,
+  portsLs2 as portsLs,
+  slotOf2 as slotOf,
+  slotTunnelSetup2 as slotTunnelSetup
+};

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

@@ -0,0 +1,22 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Ps } from "../../../core/system/index.js";
+/** What `splates ports` is run with. */
+export interface PortsOptions {
+    /** Only this task's; empty for every task's. */
+    task: string;
+    /**
+     * The `splates server` to ask; empty for the one this agent runs under,
+     * else this machine's.
+     */
+    dev: string;
+    json: boolean;
+    log: Logger;
+    ps: Ps;
+    send?: typeof fetch;
+}
+/**
+ * `splates ports`: asks the running `splates server` which ports tasks serve, each
+ * with its link through the saved ports host and its link on this machine,
+ * so an agent can hand the user both.
+ */
+export declare function portsLs(opts: PortsOptions): Promise<void>;

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

@@ -0,0 +1,64 @@
+import type { Logger } from "../../../core/log/index.js";
+import { type Clock } from "../../../core/time/index.js";
+import type { Connection, Served } from "../server/shared";
+import { type Access } from "../tunnel";
+import type { ConnectedWorker } from "../workers";
+import { type PortOwners, type TaskPort } from "./task-ports";
+/** One task port, with where to open it. */
+export interface PortLink extends TaskPort {
+    /** On this machine. */
+    local: string;
+    /** Through the saved base host, behind Access; null with none saved. */
+    remote: string | null;
+}
+/**
+ * The ports each task's processes listen on, read on this machine's worker,
+ * as VS Code finds the ports to forward: each open on this machine's
+ * loopback, and, under a saved base host, served at `<task>-<port>.<base>`
+ * to whoever Cloudflare Access lets in, and never without it. DNS and TLS
+ * for the base are the operator's.
+ */
+export declare class DevTaskPorts implements Claimer {
+    private readonly deps;
+    private looked;
+    private readonly clock;
+    constructor(deps: {
+        /** This machine's worker, which the tasks' agents run on. */
+        worker: () => ConnectedWorker;
+        /** Each served project's worktrees and agents. */
+        owners: () => Promise<PortOwners>;
+        /** `<task>-<port>.<base>` is a task port's; null for none. */
+        base: string | null;
+        /** What lets a request reach a task port, which none does without. */
+        access: Access | null;
+        log: Logger;
+        clock?: Clock;
+    });
+    /** Each port a task serves now, with its links. */
+    links(): Promise<PortLink[]>;
+    /** `GET /api/ports`: `links`, as JSON. */
+    readonly list: () => Promise<Response>;
+    /**
+     * Answers `request` when its host is a task port's, proxying it to the
+     * task's server; null for any other host, which the page's routes answer.
+     */
+    claim(request: Request, server: Bun.Server<Connection>): Promise<Response | undefined> | null;
+    private proxy;
+    /** The ports tasks serve: as last seen while fresh, unless `again`. */
+    private look;
+    /** The ports tasks serve, tied to them by the worker's own processes. */
+    private read;
+    private link;
+}
+/** Every served project's worktrees and agents, those that failed to open left out. */
+export declare function portOwnersOf(served: Map<string, Promise<Served>>): Promise<PortOwners>;
+/** What answers a task port's request before the page's routes do. */
+export interface Claimer {
+    /** Its answer to `request`, or null to leave it to the route. */
+    claim(request: Request, server: Bun.Server<Connection>): Promise<Response | undefined> | null;
+}
+/**
+ * `routes`, each handler asking `claimer` first: Bun matches a route by its
+ * path alone, so a task port's `/` would otherwise reach the page's.
+ */
+export declare function claimedFirst<Routes extends Record<string, unknown>>(routes: Routes, claimer: Claimer): Routes;

package/vendor/@stringsync/splates-server/ports/slot-tunnel.d.ts

@@ -0,0 +1,24 @@
+import type { Logger } from "../../../core/log/index.js";
+import type { Creds } from "../creds";
+import type { SavedTunnel, TunnelRecord } from "../tunnel";
+import type { Slot } from "./slots";
+/**
+ * Makes what carries `<word>.<zone>` to a slot's `splates server`, beside the
+ * tunnel `splates tunnel setup` made, through the API with the same token: the
+ * slot's tunnel, `splates-<word>`, the DNS record routing its host to it, and,
+ * once for every slot, an Access application in front of `*.<zone>` letting
+ * in whom the machine's own lets in. Saves them in the slot's home, so its
+ * `splates server` runs them as a bare one runs the machine's, asking the API
+ * for the tunnel's token at each start rather than keeping it as a cred. What already exists
+ * by name is reused, so running it again is safe.
+ */
+export declare function slotTunnelSetup({ slot, machine, creds, saved, log, fetch, }: {
+    slot: Slot;
+    /** What `splates tunnel setup` saved, whose zone, team and policy slots share. */
+    machine: TunnelRecord;
+    creds: Creds;
+    /** The slot home's tunnel, saved here. */
+    saved: SavedTunnel;
+    log: Logger;
+    fetch?: typeof globalThis.fetch;
+}): Promise<TunnelRecord>;

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

@@ -0,0 +1,28 @@
+import { type Logger } from "../../../core/log/index.js";
+import type { SplatesDeps } from "../server/shared";
+import { type Slot, Slots } from "./slots";
+/** How `splates server --slot` starts its server: with what added. */
+export interface SlotStart {
+    slot: Slot;
+    /** The public host it answers on, as in fox.example.com. */
+    host: string;
+    /** The slot's home, its `SPLATES_HOME`, and the word it serves under. */
+    env: Record<string, string>;
+}
+/**
+ * Readies the slot this checkout holds, claimed now when it holds none: its
+ * tunnel, made on the slot's first claim, and its home, `~/.splates/slots/<word>`,
+ * which keeps its own projects, roster and tunnel apart from the machine's, so
+ * it never drives the agents of the `splates server` serving your projects. Its
+ * home starts out with a throwaway project of its own, made on the first
+ * start, so its page has one to show.
+ */
+export declare function devSlot(ctx: SplatesDeps): Promise<SlotStart>;
+/**
+ * Stops the server this tree's slot last ran, if it still runs, as one does
+ * when its wrapper was killed or it was started again: it holds a port, and
+ * its cloudflared still serves the slot's host from it, so the new server
+ * would answer beside old code. Only this tree ever holds the word, so the
+ * server is this task's own to stop.
+ */
+export declare function stopLeftover(slots: Slots, slot: Slot, log: Pick<Logger, "info">): Promise<void>;