toolroll 0.9.103 → 0.9.105

package/dist/flow-changed.d.ts

@@ -1,14 +0,0 @@
-import type { Store } from "./store.js";
-export type FlowChange = {
-    flow: number;
-} | {
-    script: {
-        repo: string;
-        name: string;
-    };
-};
-/**
- * Run `write` (the change itself) and end what it ends, all in one transaction. `write` answers whether it changed
- * anything; when it didn't, nothing else happens. Returns what `write` returned.
- */
-export declare function flowChanged<T>(store: Store, change: FlowChange, by: string, now: Date, write: () => T, changed?: (result: T) => boolean): T;

package/dist/flow-code.d.ts

@@ -1,84 +0,0 @@
-import type { Runner } from "./backend.js";
-import { type FencePolicy, type LaunchFence } from "./agent-fence.js";
-import type { FlowScriptRow, Store } from "./store.js";
-import { projectFile } from "./project-file.js";
-export { projectFile };
-export { LANGUAGE_WORDS, SCRIPT_LANGUAGES, type ScriptLanguage } from "./flows.js";
-/** A step's result on the card: what the script printed, up to what a step passes on (the end, when longer; the whole
- * is in the step's log). */
-export declare const CODE_OUTPUT_CHARS: 12000;
-export type CodeRun = {
-    script: FlowScriptRow;
-    /** Asked right before every spawn attempt (retries too); false refuses it. A browser zone's approval rides here. */
-    beforeSpawn?: () => boolean;
-    /** Where it runs, and the project folder a file script is found in. */
-    cwd: string;
-    root: string;
-    /** JSON on stdin and in $FLOW_INPUT. */
-    input: unknown;
-    env: Record<string, string>;
-    secrets: Record<string, string>;
-    scratch: string;
-    shell: Runner;
-    /** Where it runs from (flowLaunch): its fence, and the launch folder its input and an inline script are written to;
-     * null only where there is nothing to fence (a store with no database file). */
-    launch: FlowLaunch | null;
-};
-/** `printed`: everything it printed (secrets blanked), for a trigger to read items from; `output` is what a card keeps. */
-export type CodeResult = {
-    state: "passed" | "failed";
-    exitCode: number | null;
-    output: string;
-    printed: string;
-    goTo: string | null;
-    log: string;
-    said: string;
-};
-/** What it printed, without key-shaped lines or saved secrets, and the goto line taken off the end. */
-export declare function codeOutput(stdout: string, secrets: Record<string, string>): {
-    output: string;
-    goTo: string | null;
-};
-/** Run one script once, with the card as its input. */
-export declare function runCode(run: CodeRun): Promise<CodeResult>;
-/** A clean folder to run in, made fresh for one run. */
-export declare function cleanFolder(scratch: string, name: string): string;
-/**
- * Cards from what a script printed (a Script trigger): a JSON list of
- * objects, JSON lines, or plain lines (each one a title). An object has a
- * title, and may have details, an email and its own key; otherwise the
- * words themselves are the key, so the same item never makes two cards.
- */
-export declare function cardsFromOutput(stdout: string): {
-    key: string;
-    title: string;
-    description: string | null;
-}[];
-/**
- * Where one flow launch runs (docs/plans/sandbox-parity.md C1): the fence `fenceFor` makes for a flow's setup, script
- * or trigger, around `folder` (a copy of the card's work, bound to its project, or a clean folder), with a launch folder
- * of its own for its input, an inline script and its temp files; writes as the project's writes setting allows (its
- * folder, the copy's Git data, its project's caches); the scratch pool denied around its own folder; and its network
- * open, as flows' scripts have always had it (they reach the services their secrets are for; no approval seals a
- * network for them). `browser` (flow-browser.ts browserStanding, proved by the caller at launch) adds Chromium's one
- * service, as a project check has it; nothing else asks for it. The fence is required: where this machine can't confine it, it runs only when an instance operator
- * allowed unconfined agents, and otherwise nothing runs and the card says why.
- */
-export type FlowLaunch = {
-    folder: string;
-    env: Record<string, string>;
-    fence?: LaunchFence;
-    dispose(): void;
-};
-export declare function flowLaunch(store: Store, options: {
-    repo: string;
-    folder: string;
-    scratch: string;
-    copy: boolean;
-    available?: () => boolean;
-    policy?: FencePolicy;
-    home?: string;
-    browser?: true;
-}): Promise<FlowLaunch | null | {
-    problem: string;
-}>;

package/dist/flow-draft.d.ts

@@ -1,42 +0,0 @@
-import { type CommandRunner } from "./claude-print.js";
-import { type FlowDefinition, type FlowStage } from "./flows.js";
-export declare const DRAFT_CHARS: 12000;
-export type DraftCard = {
-    title: string;
-    description: string | null;
-    note: string | null;
-    outputs: Record<string, string>;
-    source: {
-        label: string;
-    } | null;
-};
-export type DraftRequest = {
-    model: string;
-    prompt: string;
-    timeoutMs: number;
-};
-/** v105: `costUsd` is what the CLI said the draft cost (a plan covers it; a key pays it). */
-export type DraftAnswer = {
-    ok: true;
-    text: string;
-    ms: number;
-    costUsd?: number;
-} | {
-    ok: false;
-    said: string;
-};
-/** Runs one draft; injectable so tests never spend a subscription turn. */
-export type DraftRunner = (request: DraftRequest) => Promise<DraftAnswer>;
-/** What Claude is asked: the zone's instructions, then the card as data — with the last draft and a person's note when it
- * was sent back. `shorten`: the repair turn, with the draft that came back too long and what to cut it to. */
-export declare function draftPrompt(stage: FlowStage, card: DraftCard, definition: FlowDefinition, shorten?: {
-    draft: string;
-    ask: string;
-} | null): string;
-/** A draft as Claude wrote it, kept whole: trimmed, and never holding a key-shaped line. */
-export declare function wholeDraft(text: string): string;
-/** A draft a person edited, as kept: trimmed, whole (one over DRAFT_CHARS is refused where it is written, never cut), and never holding a key-shaped line. */
-export declare function keptDraft(text: string): string;
-/** The production runner: Claude through the sign-in on this computer, with no tools, no MCP servers and no repository. */
-export declare function claudeDraftRunner(runner?: CommandRunner): DraftRunner;
-export declare const DRAFT_TIMEOUT = 180000;

package/dist/flow-engine.d.ts

@@ -1,82 +0,0 @@
-import { type FlowDefinition, type FlowStage } from "./flows.js";
-import type { FlowCardRow, FlowRow, Store } from "./store.js";
-export type FlowAdvance = {
-    moved: number;
-    filed: string[];
-    problems: string[];
-};
-/** The flow's drawing, or null when it can't be read (the card then says so and waits). */
-export declare function flowDefinitionOf(flow: FlowRow): FlowDefinition | null;
-/** Where a card's link opens: the flow's canvas with the card selected. */
-export declare const flowCardHref: (flow: number, card: number) => string;
-/** A reply wait that timed out with nowhere to send the card asks its owner (or the flow's owner) to move it on: the
- * card's waiting words end with this (flows-ui.ts flowCardWaitsOn reads it). */
-export declare const NO_REPLY_MOVE_ON = "Move the card on when you're ready.";
-/** Where a confirmed flow action may point: a flow's canvas, maybe with one card open. */
-export declare const FLOW_HREF: RegExp;
-/** Advance every active card in one project's flows. */
-export declare function advanceFlows(store: Store, repo: string, now: Date, options?: {
-    evidenceRoot?: string;
-}): FlowAdvance;
-export declare function flowGoalCuts(store: Store, taskId: string, goal: string): {
-    label: string;
-    text: string;
-}[];
-/** Why a flow can't be saved as drawn: a build zone in a project its owner, or whoever saves it, may not file work in; null when none. */
-export declare function crossProjectProblem(store: Store, definition: FlowDefinition, flow: {
-    repo: string;
-    owner: string;
-}, editor?: string): string | null;
-export type FlowAct = {
-    ok: true;
-    said: string;
-    card: number;
-} | {
-    ok: false;
-    message: string;
-};
-/** A card's words, checked once for every door: a title, an optional description, and no keys, because cards become agent instructions. */
-export declare function flowCardText(title: unknown, description: unknown): {
-    title: string;
-    description: string | null;
-} | {
-    problem: string;
-};
-/** Add a card to a flow, in its start zone unless a zone is named. */
-export declare function addCardToFlow(store: Store, flow: FlowRow, input: {
-    title: unknown;
-    description: unknown;
-    stage: string | null;
-}, actor: string, now: Date): FlowAct;
-/** Move a card to another zone of its flow by hand; the zone's step runs on the next pass. */
-export declare function moveCardInFlow(store: Store, card: FlowCardRow, to: string, actor: string, now: Date): FlowAct;
-/** Take a card out of its flow; the tasks it filed are left as they are. */
-export declare function cancelFlowCard(store: Store, card: FlowCardRow, actor: string, now: Date): FlowAct;
-export type FlowDecision = {
-    ok: true;
-    said: string;
-} | {
-    ok: false;
-    message: string;
-};
-/** A person's decision on a card waiting in an approval zone. A send back to a build zone whose work has a result becomes a revision of that work. */
-/** The draft a decision is about: the draft zone that sends its cards to this one. */
-export declare function draftFor(definition: FlowDefinition, stage: FlowStage): FlowStage | null;
-/** Back to a build zone with a finished result: a revision of that same work, carrying the note; null when it isn't one. */
-export declare function revisionWithNote(store: Store, card: FlowCardRow, target: FlowStage | undefined, note: string, actor: string, repos: readonly string[], evidenceRoot: string | undefined, now: Date): string | null;
-export declare function decideFlowCard(store: Store, input: {
-    card: number;
-    decision: "approve" | "send-back";
-    note: string | null;
-    actor: string;
-    repos: readonly string[];
-    evidenceRoot?: string;
-    /** The draft as the person left it: approving sends this version on. */
-    draft?: string | null;
-    /** The visit the person saw (a chat button's): a card that moved on since is refused. */
-    entry?: number;
-    /** v92: the subagent (by handle) deciding a zone it staffs; `actor` is then how it reads in history. */
-    subagent?: string;
-    /** Where the decision was made, for its ledger line: "the console", "the command line", "Telegram". */
-    where?: string;
-}, now: Date): FlowDecision;

package/dist/flow-gallery-ui.d.ts

@@ -1,73 +0,0 @@
-import { type GalleryAnswers, type GalleryPreview, type GalleryTemplate, type GalleryTool } from "./flow-gallery.js";
-import { type FlowDefinition, type FlowStage } from "./flows.js";
-import { type Html, type HtmlValue } from "./html.js";
-export declare const GALLERY_CSS: string;
-/** A flow's main path, as a person reads it: from the start, each step's first way on (a sort's first answer, a choose's
- * first option that goes somewhere, else next; a check's failure when passing just ends), never back to a step shown. */
-export declare function mainPath(definition: FlowDefinition): FlowStage[];
-/** A flow's steps in order, joined by arrows. */
-export declare function stepStrip(definition: FlowDefinition): Html;
-/** One row of New flow: name · promise · one line · one outline action (the same shape for templates, kits, recipes and starters). */
-export declare function templateRow(options: {
-    name: string;
-    promise: string;
-    line?: HtmlValue;
-    action?: HtmlValue;
-    attrs?: Html;
-}): Html;
-/** The groups New flow filters by: the template groups, then kits, recipes and starter flows. */
-export declare const NEW_FLOW_GROUPS: ReadonlyArray<readonly [key: string, label: string]>;
-/** The templates as rows, grouped (or one group): each with one "Use this". `repo` carries a chosen project to the template's page. */
-export declare function galleryHtml(input: {
-    repo: string | null;
-    canUse: boolean;
-    connections?: readonly {
-        id: string;
-        state: "connected" | "open" | "taken";
-    }[] | null;
-    group?: string;
-}): Html;
-/**
- * New flow: describe it (the shared composer; the words go to the lead as a chat draft, the project on its bar), then
- * start from a template, filtered by group. Kits, recipes and starter flows arrive as their own rows.
- */
-export declare function newFlowHtml(input: {
-    repo: string | null;
-    projects: readonly {
-        path: string;
-        name: string;
-    }[];
-    canUse: boolean;
-    group: string;
-    connections: readonly {
-        id: string;
-        state: "connected" | "open" | "taken";
-    }[] | null;
-    ask: {
-        value: string;
-        error: string | null;
-    };
-    kits: Html;
-    recipes: Html;
-    starters: Html;
-    said: string | null;
-    problem: string | null;
-}): Html;
-/** A template's page, a reading page: its steps and tools, its questions, what it will do and never do, then Create. */
-export declare function galleryUseHtml(input: {
-    template: GalleryTemplate;
-    projects: readonly {
-        path: string;
-        name: string;
-    }[];
-    repo: string;
-    answers: GalleryAnswers;
-    name: string;
-    preview: GalleryPreview | null;
-    problem: string | null;
-    csrf: string;
-    diagram: FlowDefinition | null;
-    /** The template's tools in this project; `said` is how the last Connect went. */
-    tools?: readonly GalleryTool[];
-    said?: string | null;
-}): Html;

package/dist/flow-gallery.d.ts

@@ -1,147 +0,0 @@
-import { type FlowDefinition, type FlowStepInput } from "./flows.js";
-import type { TriggerInput } from "./contracts/flow.js";
-import type { Store } from "./store.js";
-export declare const GALLERY_GROUPS: readonly [{
-    readonly id: "ship";
-    readonly label: "Ship code";
-}, {
-    readonly id: "health";
-    readonly label: "Keep it healthy";
-}, {
-    readonly id: "users";
-    readonly label: "Hear from users";
-}, {
-    readonly id: "ops";
-    readonly label: "Operations";
-}];
-export type GalleryGroup = (typeof GALLERY_GROUPS)[number]["id"];
-/** What a template may ask, besides the project. */
-export type AskKey = "label" | "branch" | "schedule" | "time" | "command" | "outdated" | "team";
-export type GalleryAsk = {
-    key: AskKey;
-    default: string;
-    label: string;
-    hint?: string;
-};
-/** Weekly upkeep's package managers: what each runs. A script that fails (exits non-zero) when something is out of date. */
-export declare const OUTDATED_COMMANDS: Record<"npm" | "pip" | "cargo", {
-    label: string;
-    command: string;
-}>;
-export type GalleryTemplate = {
-    id: string;
-    /** The flow's name, and the card's title. */
-    name: string;
-    group: GalleryGroup;
-    /** One line: what it promises. */
-    promise: string;
-    /** What it needs to work, in a word or two each. */
-    needs: string[];
-    /** The project tools it puts to work: one-click service ids (ONE_CLICK) or "figma-desktop". */
-    tools?: readonly string[];
-    /** Watches a GitHub repository, so the project must be on GitHub. */
-    github?: boolean;
-    asks: GalleryAsk[];
-    /** Its zones, as steps (laid out for it) or as a drawn flow. */
-    steps?: FlowStepInput[];
-    /** The steps in Toolroll's own repository, when they differ. */
-    ownSteps?: FlowStepInput[];
-    definition?: FlowDefinition;
-    triggers: TriggerInput[];
-    scripts?: {
-        name: string;
-        about: string;
-        body: string;
-        timeoutMinutes?: number;
-    }[];
-    /** What it will do, in order; `{{github}}` is the project's GitHub repository. */
-    does: string[];
-    never: string;
-};
-/** The card's Linear issue key, read from its source as the Linear trigger stored it ("Linear ENG-123"); "none" skips the comment. */
-export declare const LINEAR_KEY = "key=\"$(sed -n 's/.*\"source\":{\"kind\":\"linear\",\"label\":\"Linear \\([A-Z][A-Z0-9]*-[0-9][0-9]*\\)\".*/\\1/p' | head -n 1)\"\nif [ -n \"$key\" ]; then echo \"$key\"; echo \"goto: Found\"; else echo none; echo \"goto: None\"; fi";
-export declare const GALLERY: readonly GalleryTemplate[];
-/** The blank flow, for starting from nothing. */
-export declare const BLANK: GalleryTemplate;
-export declare const galleryTemplateOf: (id: string) => GalleryTemplate | null;
-/** A tool a template uses: where the chosen project stands with it (null with no project), and the zones that use it. */
-export type GalleryTool = {
-    id: string;
-    label: string;
-    state: "connected" | "open" | "taken" | null;
-    zones: string[];
-};
-/** A tool's name ("Mobbin", "Figma (desktop app)"); null for an id that's neither a one-click service nor an app on this computer. */
-export declare const galleryToolLabel: (id: string) => string | null;
-/** The zones that use a tool: a tool step on it, or a research or build step that names it ("With Mobbin, …"). */
-export declare function zonesUsing(definition: FlowDefinition, id: string): string[];
-/** A template's tools, each with its state in a project's connections (connectionsOf), or none without a project. */
-export declare function galleryToolsOf(template: GalleryTemplate, definition: FlowDefinition, connections: readonly {
-    id: string;
-    state: "connected" | "open" | "taken";
-}[] | null): GalleryTool[];
-export type GalleryAnswers = Record<string, string>;
-/** Each question's default for a project: the branch pull requests go to, when that's set up. */
-export declare function galleryDefaults(store: Store, template: GalleryTemplate, repo: string | null): GalleryAnswers;
-/** The optional last step every template offers, and the answer that turns it on. */
-export declare const SEND_RESULT: {
-    readonly key: "send-result";
-    readonly title: "Send me the result";
-    readonly does: "When a card finishes, sends you what was done (its summary, links and screenshots) in your chat apps.";
-};
-/** A template that already sends its result to the person: it isn't offered "Send me the result" again. */
-export declare const sendsAlready: (template: GalleryTemplate) => boolean;
-/** A flow with "Send me the result" before its end: every path into its main Done zone passes through it first.
- * A flow that already has a send zone is left as it is, so nobody gets the result twice. */
-export declare function withSendResult(definition: FlowDefinition): FlowDefinition;
-/** The answers, checked in plain words, with what they fill in. Throws. */
-export declare function checkAnswers(template: GalleryTemplate, given: GalleryAnswers): GalleryAnswers;
-export type GalleryBuilt = {
-    template: GalleryTemplate;
-    repo: string;
-    answers: GalleryAnswers;
-    definition: FlowDefinition;
-    triggers: TriggerInput[];
-    scripts: {
-        name: string;
-        about: string;
-        body: string;
-        timeoutMinutes: number;
-        existing: boolean;
-    }[];
-    does: string[];
-    never: string;
-};
-/** A template made concrete for a project and its answers: its zones, triggers and scripts, checked. Throws in plain words. */
-export declare function buildFromGallery(store: Store, template: GalleryTemplate, repo: string, given: GalleryAnswers): GalleryBuilt;
-/** A template's zones as its defaults draw them, for the gallery's small drawing; no project needed. */
-export declare function galleryDiagram(template: GalleryTemplate): FlowDefinition;
-export type GalleryPreview = {
-    built: GalleryBuilt;
-    startsFrom: string[];
-    steps: string[];
-    tools: GalleryTool[];
-    digest: string;
-};
-/** What using a template will do, in words, before anything is made: its triggers checked as the flow will have them. Throws. */
-export declare function previewGallery(store: Store, template: GalleryTemplate, repo: string, given: GalleryAnswers, actor: string, now: Date): GalleryPreview;
-/** What a preview showed: the template, the project and the answers. Creating checks the person saw these. */
-export declare function galleryDigest(id: string, repo: string, answers: GalleryAnswers): string;
-export type GalleryUsed = {
-    ok: true;
-    flow: number;
-    said: string;
-} | {
-    ok: false;
-    said: string;
-};
-/** Use a template in a project: its scripts, its flow and its triggers, together or not at all. */
-/** Whether a template's triggers bring in items from anyone: making it takes the person's password. */
-export declare function galleryAdmitsAnyone(template: GalleryTemplate): boolean;
-export declare function useGalleryTemplate(store: Store, template: GalleryTemplate, repo: string, given: GalleryAnswers, input: {
-    name?: string | null;
-    by: string;
-    now: Date;
-    dir: string | null;
-    widening?: "proved";
-}): GalleryUsed;

package/dist/flow-insights.d.ts

@@ -1,104 +0,0 @@
-import type { FlowRow, FlowStepRunRow, Store } from "./store.js";
-export type ZoneInsight = {
-    zone: string;
-    title: string;
-    kind: string;
-    /** Cards that arrived in the window, and what happened next. */
-    entered: number;
-    movedOn: number;
-    failed: number;
-    sentBack: number;
-    /** Cards sitting there now. */
-    here: number;
-    /** The middle of how long cards stayed before moving on, in minutes. */
-    typicalMinutes: number | null;
-    lastProblem: {
-        card: number;
-        cardTitle: string;
-        note: string | null;
-        at: string;
-    } | null;
-};
-export type ScriptInsight = {
-    script: string;
-    runs: number;
-    passed: number;
-    failed: number;
-    typicalSeconds: number | null;
-    lastFailure: string | null;
-};
-/**
- * How a sort zone is doing, from what people did after it: a card a person
- * moved to where a different answer leads was sorted wrong; one that moved
- * on from where Jev sent it was sorted right; a not-sure card a person
- * placed says what the answer should have been. Cards nobody has touched
- * since are not counted either way.
- */
-export type SortInsight = {
-    zone: string;
-    title: string;
-    sureAt: number;
-    sorted: number;
-    alone: number;
-    notSure: number;
-    corrected: number;
-    /** How often Jev was right, by how sure it was: [from, to) in whole percents. */
-    bands: {
-        from: number;
-        to: number;
-        right: number;
-        of: number;
-    }[];
-    costUsd: number;
-    suggestion: string | null;
-};
-export type StepRunInsight = {
-    card: number;
-    cardTitle: string;
-    entry: number;
-    zone: string;
-    zoneTitle: string;
-    kind: "check" | "update" | "sort" | "draft" | "request" | "email" | "tool" | "subagent";
-    script: string | null;
-    version: number | null;
-    state: FlowStepRunRow["state"];
-    result: string | null;
-    exitCode: number | null;
-    durationMs: number | null;
-    at: string;
-    hasLog: boolean;
-};
-export type FlowInsights = {
-    flow: number;
-    name: string;
-    days: number;
-    cards: {
-        started: number;
-        finished: number;
-        active: number;
-    };
-    zones: ZoneInsight[];
-    /** The zones that fail or send work back most, worst first. */
-    breaks: {
-        zone: string;
-        title: string;
-        problems: number;
-        of: number;
-    }[];
-    scripts: ScriptInsight[];
-    sorts: SortInsight[];
-    runs: StepRunInsight[];
-    /** A plane review's problems, the ones seen on the most days first: which causes keep coming back. */
-    recurring: RecurringProblem[];
-};
-export type RecurringProblem = {
-    problem: string;
-    title: string;
-    days: number;
-    lastSeen: string;
-    card: number | null;
-};
-/** One flow's insights over the last `days` days. */
-export declare function flowInsights(store: Store, flow: FlowRow, now: Date, days?: number): FlowInsights;
-/** One line for a flow's list entry: where it has had the most trouble lately. */
-export declare function troubleWords(insights: FlowInsights): string | null;

package/dist/flow-items.d.ts

@@ -1,37 +0,0 @@
-/**
- * A research report's items in a flow's message (flow-send.ts): after a report step, each item is listed under the
- * summary, numbered — its title in bold, its why in plain lines, and its link named by its source ("Mobbin", or the
- * site's name). Each screenshot of an item is captioned with the same number, its title and how it plugs in
- * (result-shots.ts), so "2." in the album is item 2 in the text.
- *
- * The message is written in reply-shape.ts's canonical form (`**bold**`, `[label](url)`), which every channel renders
- * in its own format. Its words go through the channel's own cleaner first. Fitted to a channel's limit, each why is
- * shortened evenly first; then the summary, then the titles; past that it is split into parts. Links are never cut.
- */
-import type { FlowSendItem } from "./contracts/flow-send.js";
-/** One item as the message lists it, and kept items read back (src/contracts/flow-send.ts). */
-export type { FlowSendItem };
-export { readFlowItems } from "./contracts/flow-send.js";
-/** A link's source by name: a few known sites as they write themselves, else the site's own name from its address. */
-export declare function itemSource(url: string): string;
-/** A why as plain lines: its own lines, or "the pattern; why it fits us; how it plugs in" one to a line. */
-export declare function whyLines(why: string): string[];
-/** How an item plugs in, in one line: the why's last line when it has several, else the image's caption, else the why. */
-export declare function itemPlug(why: string, imageCaption: string | null): string;
-/** A screenshot's caption: its item's number, title and how it plugs in. */
-export declare function itemCaption(number: number, item: Pick<FlowSendItem, "title" | "plug">): string;
-export type FlowMessage = {
-    head: string;
-    summary: string;
-    items: readonly FlowSendItem[];
-    tail: readonly string[];
-};
-/** The message's own words through a channel's cleaner — head, summary, each title and why, and tail — before it is fitted. */
-export declare function cleanFlowMessage(message: FlowMessage, clean: (text: string) => string): FlowMessage;
-/**
- * The message in canonical form, as parts within `limit` as `measure` counts each once the channel renders it: one
- * whole part when it fits; else every why shortened to the same length; then the summary; then the titles. When the
- * head, links and tail alone are over the limit, the whole message goes in several parts instead, split between
- * blocks (else between lines). Every link stays.
- */
-export declare function fitFlowMessage(message: FlowMessage, limit: number, measure: (shaped: string) => number): string[];

package/dist/flow-live.d.ts

@@ -1,16 +0,0 @@
-import { type LiveRoomOptions, type LiveRooms, type LiveViewer } from "./live-bus.js";
-import type { Store } from "./store.js";
-export type FlowPresence = {
-    name: string;
-    cards: number[];
-    editing: boolean;
-};
-export type FlowViewer = LiveViewer & {
-    card: number | null;
-    editing: boolean;
-};
-/** What changes when anything on the canvas changes: metadata only, kept short and opaque. */
-export declare function flowFingerprint(store: Store, flow: number, now?: Date): string | null;
-export type FlowRooms = LiveRooms<number, FlowViewer>;
-/** Rooms keyed by flow. With a bus, a write reaches every open page at once; without one, only the safety net. */
-export declare function createFlowRooms(fingerprint: (flow: number) => string | null, options?: LiveRoomOptions): FlowRooms;

package/dist/flow-people.d.ts

@@ -1,23 +0,0 @@
-import { type FlowAct } from "./flow-engine.js";
-import type { FlowCardRow, Store } from "./store.js";
-/** Everyone who may take part in a project's flows: approvers who can reach the project. */
-export declare function flowPeople(store: Store, repo: string): string[];
-/** The people a comment @mentions: known names only, each once, in the order written. */
-export declare function mentionsIn(body: string, people: readonly string[]): string[];
-type CardEvent = {
-    key: string;
-    subject: string;
-    body: string;
-    attention?: boolean;
-};
-export declare function notifyPeople(store: Store, card: FlowCardRow, people: Iterable<string>, actor: string | null, event: CardEvent, now: Date): string[];
-/** Who follows a card: its owner and its watchers. */
-export declare function cardFollowers(store: Store, card: FlowCardRow): string[];
-/** Make someone (or no one) a card's owner. The new owner follows it and hears so. */
-export declare function assignFlowCard(store: Store, card: FlowCardRow, owner: string | null, actor: string, now: Date): FlowAct;
-export declare function watchFlowCard(store: Store, card: FlowCardRow, name: string, watching: boolean, now: Date): FlowAct;
-/** A comment on a card: keys refused; the people it @mentions, the owner and watchers hear about it; the author and anyone mentioned follow it from now on. */
-export declare function commentOnFlowCard(store: Store, card: FlowCardRow, author: string, text: unknown, now: Date): FlowAct & {
-    mentions?: string[];
-};
-export {};

package/dist/flow-pull-request.d.ts

@@ -1,14 +0,0 @@
-import type { Runner } from "./backend.js";
-import type { FlowDefinition, FlowStage } from "./flows.js";
-import type { FlowCardRow, FlowRow, Store } from "./store.js";
-export type PullRequestIo = {
-    gh: Runner;
-    evidenceRoot?: string;
-};
-/** Whether a person approved this card at a "Person decides" zone since it was last built; their name when so.
- * The MOST RECENT decision governs (approval policy §1.7): it must be a person's recorded decision, after the card's
- * last build by the current definition AND after the exact build being merged finished (`builtAt`), so editing the
- * flow can't let an older person decision stand behind a newer machine one. */
-export declare function approvedSinceBuild(store: Store, definition: FlowDefinition, card: FlowCardRow, builtAt?: string | null): string | null;
-/** One pass of a Pull request zone for one card. Returns whether it changed anything. */
-export declare function pullRequestStep(store: Store, flow: FlowRow, definition: FlowDefinition, stage: FlowStage, card: FlowCardRow, now: Date, io: PullRequestIo): Promise<boolean>;