@stringsync/splates 0.0.45 → 0.0.47

package/dev/conversation-address.d.ts

@@ -1,47 +0,0 @@
-import type { ConversationState, Setting } from "../conversations.js";
-import type { Needing } from "../needs.js";
-import type { AgentChoice } from "./conversation-feed.js";
-/** What `#conversations/task/<name>` opens: a task whose agent runs outside the page. */
-export declare const TASK = "task/";
-/** What opens `row`: its conversation's id, or its external agent's task. */
-export declare function openedBy(row: Needing): string;
-/** What `#conversations/archived` opens: every archived conversation. */
-export declare const ARCHIVED = "archived";
-/**
- * In place of an id in the address: the screen that starts a conversation,
- * with the agent after it, as `new/codex`, else the agent last used, and
- * after that the task whose tree it starts in, as `new/codex/fix-upload`,
- * else the main tree.
- */
-export declare const NEW = "new";
-/**
- * The conversation a `#conversations/<id>` address names, `ARCHIVED` for the
- * archived ones, or null.
- */
-export declare function conversationIn(hash: string): string | null;
-/**
- * After a conversation's id in the address, as `<id>/terminal`: its terminal
- * on a page of its own, as one of the main tree's is.
- */
-export declare const TERMINAL = "/terminal";
-/** The address of `conversation`'s terminal on a page of its own. */
-export declare function terminalAddress(conversation: string): string;
-/**
- * The conversation whose terminal `open` shows on a page of its own, or null.
- * No id has a `/`, unlike the addresses of a task, a new conversation, or a
- * main-tree terminal.
- */
-export declare function terminalOf(open: string | null): string | null;
-/** Whether `open` is the screen that starts a conversation, with any agent. */
-export declare function startsOne(open: string | null): boolean;
-/**
- * The agent a new conversation starts with: the one `open` names, else the
- * newest conversation's the person picked, else the newest's, else the first.
- */
-export declare function agentFor(open: string | null, agents: AgentChoice[], conversations: ConversationState[]): string;
-/** The user's saved defaults, independent of live session settings. */
-export declare function settingsFor(agent: string, agents: AgentChoice[], _conversations: ConversationState[]): Setting[];
-/** The task a new conversation starts in, from `open`; null for the main tree. */
-export declare function taskFor(open: string | null): string | null;
-/** The model a new conversation starts on, `?model=` in `open`, or null. */
-export declare function modelFor(open: string | null): string | null;

package/dev/conversation-feed.d.ts

@@ -1,166 +0,0 @@
-import type { Resource } from "webappwiz/disposable";
-import { type Eventful } from "webappwiz/events";
-import { type IdProvider } from "webappwiz/id";
-import { Duration, type Timer, type WallClock } from "webappwiz/time";
-import type { Attached, ConversationState, Image, Limit, Message, Setting } from "../conversations.js";
-/** How long a message goes unanswered before the page says it is still sending. */
-export declare const STILL_SENDING: Duration;
-export type ConversationFeedEvents = {
-    changed: undefined;
-};
-/** A message on its way: its words, and its files read from the page's own copies. */
-export interface Sending {
-    /**
-     * The page's id for it, sent with it for the server to keep on its own
-     * copy, which is how the page knows that copy when it comes back.
-     */
-    id: string;
-    text: string;
-    images: Image[];
-    files: Attached[];
-    /** Whether it waits for the running turn's end, as the server will record it. */
-    queued: boolean;
-    /** What the person wrote and attached, to send again or take back. */
-    typed: string;
-    attached: File[];
-    /** Whether the person said it into the mic. */
-    dictated: boolean;
-    /** When it was sent, as epoch ms, to tell when it has gone unanswered for `STILL_SENDING`. */
-    at: number;
-}
-/** A message the server refused, with why: shown until sent again or taken back. */
-export interface Unsent {
-    message: Sending;
-    why: string;
-}
-/**
- * The page's copy of every conversation, each replaced whole as the server
- * streams it. `available` stays false when the server holds no
- * conversations. The phone still keeps its Inbox as home.
- */
-export declare class ConversationFeed implements Eventful<ConversationFeedEvents>, Resource {
-    readonly timer: Timer;
-    readonly wall: WallClock;
-    private readonly ids;
-    private readonly dispatcher;
-    readonly events: import("webappwiz/events").Events<ConversationFeedEvents>;
-    /** Whether the first listing is still on its way. */
-    loading: boolean;
-    available: boolean;
-    agents: AgentChoice[];
-    /** Newest first, each with the messages on their way (see `send`) as said. */
-    conversations: ConversationState[];
-    /** Each conversation's messages on their way, by id, in the order sent. */
-    readonly sending: Map<string, Sending[]>;
-    /** Each conversation's refused messages, in the order refused, replaced whole as they change. */
-    readonly unsent: Map<string, readonly Unsent[]>;
-    /** As the server last said, without what is on its way. */
-    private recorded;
-    /**
-     * How many changes `put` and `drop` have made, and the count at each
-     * conversation's last, so a listing knows what moved while it was on its
-     * way.
-     */
-    private changes;
-    private readonly changedAt;
-    private stream;
-    /**
-     * `timer` and `wall` are what the thread waits and reads the date by;
-     * `ids` names each message on its way.
-     */
-    constructor(timer?: Timer, wall?: WallClock, ids?: IdProvider);
-    start(): void;
-    dispose(): void;
-    /** Puts `state` in place of what the page had of it, or first when new. */
-    put(state: ConversationState): void;
-    /** Drops conversation `id`, deleted as an older archived one. */
-    drop(id: string): void;
-    /**
-     * Shows `text` and `files` as said in conversation `id` before its server
-     * records them, which waits on the way there and, while the agent starts
-     * or resumes, until it is up, so the thread does not sit as it was
-     * meanwhile. Said while a turn runs, or behind another on its way, it shows
-     * as queued, as the server records it unless the agent takes it into the
-     * turn, when its echo moves it into the thread. Each goes once the server
-     * has recorded a message with its id, whatever else it records meanwhile,
-     * or `refused` keeps it as unsent. The files show from the page's own, as the server
-     * has yet to keep them. `typed` is the text as the person wrote it, before
-     * the notes on its images were added.
-     */
-    send(id: string, text: string, files?: File[], typed?: string, dictated?: boolean): Sending;
-    /**
-     * Where a message said now to conversation `id` would go, as the server
-     * last said it will take one. Every place a message is put asks here, so
-     * what decides it stays in one spot.
-     */
-    private placed;
-    /**
-     * How many of conversation `id`'s queued messages are still on their way,
-     * the last ones: the server has nothing of them to take back yet.
-     */
-    unrecorded(id: string): number;
-    /**
-     * Keeps `message`, which `send` showed in conversation `id`, as unsent at
-     * the thread's foot, since the server refused it with `error`.
-     */
-    refused(id: string, message: Sending, error: unknown): void;
-    /**
-     * Settles `message`, which `send` showed in conversation `id`, by the
-     * server's answer `state` to it: when that holds the message, the server
-     * has it, so the page takes `state` in at once if the stream has yet to
-     * bring it, and gives up any unsent copy of it.
-     */
-    answered(id: string, message: Sending, state: ConversationState): void;
-    /** Stops showing `message`, unsent in conversation `id`, to send again or edit. */
-    take(id: string, message: Sending): void;
-    /**
-     * When a message of conversation `id` next passes `STILL_SENDING`
-     * unanswered, as epoch ms; null when none will.
-     */
-    nextSlow(id: string): number | null;
-    /** Shows what is on its way afresh, as the clock now reads. */
-    recheck(): void;
-    /** Takes `message` off conversation `id`'s on their way; false when it was not. */
-    private withdraw;
-    private show;
-    private load;
-    /**
-     * Reads every conversation afresh after the stream opens, `reconnect` when it
-     * had before. Messages sent before it dropped that the listing still lacks are given up as unsent:
-     * their requests may have died with the connection, and none would say so.
-     */
-    private reopened;
-    /**
-     * Has the server ask the agents that do not send their limits for them,
-     * then reads the agents afresh, so the page shows what they said.
-     */
-    refreshLimits(): Promise<void>;
-    /** Reads every conversation afresh; false when they are off. */
-    private list;
-}
-/** An agent a conversation can be started with. */
-export interface AgentChoice {
-    id: string;
-    name: string;
-    /** The models the roster lists for it, by the ids its Model setting takes. */
-    models?: {
-        id: string;
-        name: string;
-    }[];
-    /**
-     * What its sessions last offered, from any project, each where it was
-     * left; none until it has had one on this machine.
-     */
-    settings: Setting[];
-    /**
-     * The plan's windows of use, as it last said in any project; none until
-     * it has, and never from an agent that does not say.
-     */
-    limits: Limit[];
-}
-/** What to call agent `id`: its name, or its id once it is off the roster. */
-export declare function agentName(agents: AgentChoice[], id: string): string;
-/** `message` as the thread shows it, from the page's own copies of its files. */
-export declare function messageOf(message: Sending, now?: number): Message;
-/** The images an agent that takes images is sent as such, as the server keeps them. */
-export declare const SEEN: string[];

package/dev/live-stream.d.ts

@@ -1,29 +0,0 @@
-import type { Resource } from "webappwiz/disposable";
-import { type Timer } from "webappwiz/time";
-/** What a stream's events go to, each named event by its name. */
-export interface StreamHandlers {
-    message: (event: MessageEvent<string>) => void;
-    /**
-     * On each open, `again` once it has opened before, when what moved while
-     * it was away was never said.
-     */
-    open?: (again: boolean) => void;
-    error?: () => void;
-    named?: Record<string, (event: MessageEvent<string>) => void>;
-}
-/**
- * An `EventSource` that opens again once it has heard nothing, not even the
- * server's pulse, for two pulses. Across a sleep a stream can sit open with
- * no error and no news, and the page would miss every change until a reload;
- * `open` runs again on each new one, to read afresh what moved meanwhile.
- */
-export declare class LiveStream implements Resource {
-    private readonly url;
-    private readonly handlers;
-    private source;
-    private opened;
-    private readonly silence;
-    constructor(url: string, handlers: StreamHandlers, timer?: Timer);
-    dispose(): void;
-    private open;
-}

package/dev/worker.d.ts

@@ -1,33 +0,0 @@
-/**
- * The page's service worker, which exists only to show notifications: a
- * phone's browser shows one only through a worker's registration, and hears
- * of one the server pushes while the page is frozen only through a worker.
- * It caches nothing, since the page is only of use live.
- *
- * Clicking a notification focuses a window on the row's project and tells it
- * which row to open, or, with none on that project, opens one at the row's
- * address.
- */
-/** What a notification carries for its click, as `Notifier.show` and a push set it. */
-export interface Opening {
-    /** The row's key, which the page looks up among its rows. */
-    key: string;
-    /** The page's address with the row open, for when no window is. */
-    url: string;
-}
-/** What the server pushes for a notice, as `Pushes` sends it. */
-export interface Pushed {
-    title: string;
-    body: string;
-    /** The row's key, which tags its notification and opens it. */
-    key: string;
-    /** The row's address, from the page's own: its `?project=` and hash. */
-    url: string;
-    /** Whether to show it even while a window of the page is in front. */
-    inFront: boolean;
-}
-/** The message a window gets when one of its notifications is clicked. */
-export interface Opened {
-    type: "splates:open";
-    key: string;
-}

package/dev-access.d.ts

@@ -1,61 +0,0 @@
-import { type WallClock } from "webappwiz/time";
-/**
- * The Cloudflare Access application in front of `splates server`: the team it
- * belongs to, as the issuer its tokens name, and its AUD tag. The one place
- * both live, so whatever exposes the page beyond this machine can ask whether
- * Access stands in front of it.
- */
-export interface AccessConfig {
-    /** The team's own origin, `https://<team>.cloudflareaccess.com`. */
-    issuer: string;
-    /** The application's AUD tag, which each of its tokens names. */
-    aud: string;
-}
-/**
- * The Access application `--access-team` and `--access-aud` name, or null
- * when neither is given. The team is its name, its domain or its URL alike.
- */
-export declare function accessConfig(team: string, aud: string): AccessConfig | null;
-/** Who a verified token says is asking. */
-export interface Identity {
-    email: string | null;
-    sub: string;
-}
-/** A request's token, verified or refused with why. */
-export type Verified = {
-    identity: Identity;
-    refused?: undefined;
-} | {
-    identity?: undefined;
-    refused: string;
-};
-/** The header Access sets on each request it lets through to the origin. */
-export declare const ACCESS_HEADER = "cf-access-jwt-assertion";
-/** The cookie a browser carries it in, which an upgrade may have alone. */
-export declare const ACCESS_COOKIE = "CF_Authorization";
-/**
- * Checks the token Cloudflare Access hands each request against the team's
- * signing keys, so a request that merely claims to come through Access, as
- * any process on this machine could, gets nowhere.
- */
-export declare class Access {
-    readonly config: AccessConfig;
-    private keys;
-    private fetching;
-    private fetchedAt;
-    private readonly fetch;
-    private readonly clock;
-    constructor(config: AccessConfig, opts?: AccessOptions);
-    /** Where the team publishes the keys its tokens are signed with. */
-    get certs(): string;
-    /** Who `request` comes from, by the token in its header or its cookie. */
-    verify(request: Request): Promise<Verified>;
-    private check;
-    private key;
-    private refetch;
-}
-/** What an `Access` reaches the world through, swapped in tests. */
-export interface AccessOptions {
-    fetch?: typeof fetch;
-    clock?: WallClock;
-}

package/dev-artifacts.d.ts

@@ -1,22 +0,0 @@
-import type { Conversation } from "./conversation.js";
-/**
- * The version of an artifact that `request` names, `/api/conversations/<id>/
- * artifacts/<name>/<version>`, from `conversation`: 404 `not_found` for a
- * name or version its record lacks, and 404 `gone` for one whose bytes were
- * deleted, so the page shows a placeholder for it.
- */
-export declare function artifactResponse(request: Request, conversation: Conversation): Promise<Response>;
-/**
- * Deletes the bytes of the version that `request` names, `/api/conversations/
- * <id>/artifacts/<name>/<version>`, from `conversation`, keeping its record
- * so the page shows a placeholder.
- */
-export declare function deleteVersion(request: Request, conversation: Conversation): Promise<Response>;
-/**
- * The agent's own `splates artifact add`: a form with the artifact's `name`, its
- * `mimeType`, and its bytes as `file`. The conversation's own store keeps it,
- * so the page hears of it as it would of any change.
- */
-export declare function addVersion(request: Request, conversation: Conversation): Promise<Response>;
-/** The agent's own `splates artifact remove`, `/api/conversations/<id>/artifacts/<name>`. */
-export declare function removeNamed(request: Request, conversation: Conversation): Promise<Response>;

package/dev-budgets.d.ts

@@ -1,18 +0,0 @@
-import type { Project } from "./dev-project.js";
-/**
- * The routes a project's Budget page reads and changes its scry budgets
- * through, each answering with the report `scry budgets` prints. Spread one
- * into a project's routes.
- */
-export declare class BudgetRoutes {
-    #private;
-    constructor(project: Project);
-    readonly listBudgets: () => Promise<Response>;
-    /** Sets a role's spend, or with none, gives it back to the configs. */
-    readonly setBudget: (request: Request) => Promise<Response>;
-    readonly raiseBudget: (request: Request) => Promise<Response>;
-    /** Stops a role asking anything for a while, like `1d`. */
-    readonly pauseBudget: (request: Request) => Promise<Response>;
-    readonly resumeBudget: (request: Request) => Promise<Response>;
-    readonly endRaise: (request: Request) => Promise<Response>;
-}

package/dev-conversation-events.d.ts

@@ -1,39 +0,0 @@
-import type { Resource } from "webappwiz/disposable";
-import type { Logger } from "webappwiz/log";
-import type { Fs } from "webappwiz/system";
-import { type Timer } from "webappwiz/time";
-import type { Conversations } from "./conversations.js";
-import type { Journal } from "./journal.js";
-/**
- * Hands each conversation the events its agent's splates commands logged: all
- * of them as the server opens the project, then each new one as the journal
- * takes it, so the page shows it in that conversation's thread at once. An
- * event no conversation ran, an external agent's or the page's own, goes
- * nowhere.
- */
-export declare class ConversationEvents implements Resource {
-    #private;
-    private readonly journal;
-    private readonly conversations;
-    private readonly log;
-    private constructor();
-    /**
-     * Hands each conversation in `conversations` its events, then follows
-     * `splatesDir`, where the journal writes, for more.
-     */
-    static follow({ journal, conversations, fs, splatesDir, log, timer, }: {
-        journal: Journal;
-        conversations: Conversations;
-        fs: Fs;
-        splatesDir: string;
-        log: Logger;
-        timer?: Timer;
-    }): Promise<ConversationEvents>;
-    /**
-     * Hands out what the journal took since the last look, for when it may
-     * have changed; settles once it has.
-     */
-    changed(): Promise<void>;
-    dispose(): void;
-    private take;
-}

package/dev-conversation-routes.d.ts

@@ -1,90 +0,0 @@
-import { type Conversations } from "./conversations.js";
-import type { Project } from "./dev-project.js";
-import { Everywhere } from "./everywhere.js";
-/**
- * How a project's page talks to agents: starting, prompting and steering its
- * conversations, and hearing each change to them as it streams. Each handler
- * is a property, so `serveProject` spreads them into the project's routes;
- * what they work on stays private, out of the spread.
- */
-export declare class ConversationRoutes {
-    #private;
-    constructor(project: Project, conversations: Conversations | null, everywhere?: Everywhere | null);
-    held(): Conversations;
-    /**
-     * Asks every conversation at work for a checkpoint, or only those `only`
-     * names by id, without waiting on the agents, passing over the idle ones,
-     * whose turn has ended already: one whose task is merging
-     * gets to finish the merge first. While one is still asked, the
-     * checkpoint under way stands, and nothing is asked again. Answers with
-     * what settles as each asked answers.
-     */
-    readonly checkpoint: (only?: string[]) => Promise<Promise<void>[]>;
-    /** Asks the agents that do not send their limits for them, now and then. */
-    readonly refreshLimits: () => Promise<Response>;
-    readonly listConversations: () => Promise<Response>;
-    /** The tree a terminal opens in: `?task=`'s worktree, or the main tree. */
-    readonly terminalTree: (request: Request) => Promise<string>;
-    readonly startConversation: (request: Request) => Promise<Response>;
-    /**
-     * The sessions the agents hold in `?task=`'s tree that no conversation
-     * does, such as ones started in their CLI, to bring in.
-     */
-    readonly listSessions: (request: Request) => Promise<Response>;
-    /** Brings in a session an agent holds, as a conversation in `task`'s tree. */
-    readonly bringSession: (request: Request) => Promise<Response>;
-    readonly moveConversation: (request: Request) => Promise<Response>;
-    readonly promptConversation: (request: Request) => Promise<Response>;
-    readonly conversationAttachment: (request: Request) => Promise<Response>;
-    readonly conversationArtifact: (request: Request) => Promise<Response>;
-    readonly answerConversation: (request: Request) => Promise<Response>;
-    readonly cancelConversation: (request: Request) => Promise<Response>;
-    /**
-     * Checkpoints a running agent for the person and leaves it stopped,
-     * answering without waiting on the agent; one whose task is merging gets
-     * to finish the merge first.
-     */
-    readonly pauseConversation: (request: Request) => Promise<Response>;
-    /** What a background command prints, as it prints it, until it ends. */
-    readonly backgroundOutput: (request: Request) => Promise<Response>;
-    readonly stopBackground: (request: Request) => Promise<Response>;
-    readonly unqueueConversation: (request: Request) => Promise<Response>;
-    readonly sendQueuedNow: (request: Request) => Promise<Response>;
-    readonly chooseSetting: (request: Request) => Promise<Response>;
-    readonly renameConversation: (request: Request) => Promise<Response>;
-    readonly markUnread: (request: Request) => Promise<Response>;
-    readonly pinConversation: (request: Request) => Promise<Response>;
-    readonly reparentConversation: (request: Request) => Promise<Response>;
-    readonly archiveConversation: (request: Request) => Promise<Response>;
-    /**
-     * Says `text` in a conversation as the person would, for the conversation
-     * that handed it its task, as `splates tell` does: the one way in to one
-     * that answers to it, and how a lane's orchestrator wakes or stops one it
-     * started. With `stop`, the running turn stops first.
-     */
-    readonly tellConversation: (request: Request) => Promise<Response>;
-    readonly addArtifact: (request: Request) => Promise<Response>;
-    readonly removeArtifact: (request: Request) => Promise<Response>;
-    readonly deleteArtifactVersion: (request: Request) => Promise<Response>;
-    /**
-     * The person's way out of a handed-out agent: stops its turn and its
-     * process, and tells the conversation that handed it out, which decides
-     * what becomes of the task. Its next word from that one resumes it.
-     */
-    readonly terminateConversation: (request: Request) => Promise<Response>;
-    readonly conversationEvents: () => Promise<Response>;
-    disposeAsync(): Promise<void>;
-    /** Where a conversation for `task` runs: its worktree, or the main tree. */
-    /**
-     * `task`'s name, worktree, the branch it was cut from, and the
-     * conversation whose agent added it.
-     */
-    private treeFor;
-    /**
-     * Whether a task landing on `base` is a part of `task`, or a part of one
-     * of its parts, following each base back while it is a task's branch.
-     */
-    private isPartOf;
-    /** The conversation a `/api/conversations/<id>` path names. */
-    private conversationAt;
-}

package/dev-creds.d.ts

@@ -1,17 +0,0 @@
-import type { Project } from "./dev-project.js";
-import type { ProjectWatch } from "./dev-project-watch.js";
-/**
- * How a project's Creds page fills, replaces and removes creds, and turns
- * requests down. A value only ever comes in: no route answers with one.
- * Each handler is a property, so `serveProject` spreads them into the
- * project's routes.
- */
-export declare class CredRoutes {
-    #private;
-    constructor(project: Project, watch: ProjectWatch);
-    /** What each store keeps, by name, and what the stores are called. */
-    readonly listCreds: () => Promise<Response>;
-    readonly saveCred: (request: Request) => Promise<Response>;
-    readonly removeCred: (request: Request) => Promise<Response>;
-    readonly dismissCred: (request: Request) => Promise<Response>;
-}

package/dev-dictation-connection.d.ts

@@ -1,18 +0,0 @@
-import { type Transcriber } from "webappwiz/dictate";
-import type { Connection } from "./dev-sockets.js";
-/**
- * One dictation's socket, relaying the page's audio to a transcription and
- * its text back. A socket that closes takes its transcription with it: the
- * text heard so far is already in the composer.
- */
-export declare class DictationConnection implements Connection {
-    /** Null when the project has no key, which the Creds page now asks for. */
-    private readonly transcriber;
-    private relay;
-    constructor(
-    /** Null when the project has no key, which the Creds page now asks for. */
-    transcriber: Promise<Transcriber | null>);
-    open(socket: Bun.ServerWebSocket<Connection>): void;
-    message(_socket: Bun.ServerWebSocket<Connection>, message: string | Buffer<ArrayBuffer>): void;
-    closed(): void;
-}

package/dev-dictation.d.ts

@@ -1,17 +0,0 @@
-import { type HostGate } from "./dev-http.js";
-import type { Served } from "./dev-project.js";
-import type { Connection } from "./dev-sockets.js";
-/** How a dictation finds the project its request names. */
-export interface DictationProjects {
-    projectFor(request: Request): Promise<Served>;
-}
-/**
- * The composer's dictations, each over a WebSocket: the page streams the
- * mic's audio up, and the text comes back as it is heard.
- */
-export declare class Dictations {
-    private readonly gate;
-    private readonly projects;
-    constructor(gate: HostGate, projects: DictationProjects);
-    readonly open: (request: Request, server: Bun.Server<Connection>) => Promise<Response | undefined>;
-}

package/dev-http.d.ts

@@ -1,76 +0,0 @@
-import type { Resource } from "webappwiz/disposable";
-import type { Logger } from "webappwiz/log";
-import type { Attachment } from "./attachments.js";
-import type { Access, Identity } from "./dev-access.js";
-import { type Reason } from "./exit.js";
-/**
- * Which requests `splates server` answers at all: those to a host it may be
- * reached by, and writes only from its own page. Given `access`, a host
- * `hosts` lets in answers only to a request Cloudflare Access verified, and
- * such a request may use conversations and terminals too; without it,
- * those answer only to this machine's own names, so a tunnel still reaches
- * no further than the todos.
- */
-export declare class HostGate {
-    private readonly log;
-    readonly access: Access | null;
-    private readonly allowed;
-    constructor(hosts: string[], log: Logger, access?: Access | null);
-    readonly guarded: <Answered extends Response | undefined>(handle: (request: Request) => Promise<Answered>) => (request: Request) => Promise<Answered | Response>;
-    /**
-     * Who Cloudflare Access says `request` comes from, or null when it comes
-     * to this machine's own names or no Access stands in front.
-     */
-    readonly identity: (request: Request) => Promise<Identity | null>;
-    readonly local: <Answered extends Response | undefined>(handle: (request: Request) => Promise<Answered>) => (request: Request) => Promise<Answered | Response>;
-}
-/** The one address the server binds: this machine, and nothing else. */
-export declare const LOOPBACK = "127.0.0.1";
-/** Names this machine answers to, which a page opened on it always may use. */
-export declare const LOCAL_HOSTS: string[];
-/** A phone photo or a short screen recording fits; a long video does not. */
-export declare const MAX_BODY_BYTES: number;
-/**
- * The images and recordings a todo or a task may hold, by extension, and how
- * each is served; `dev/media.tsx` shows the same ones inline.
- */
-export declare const MEDIA_TYPES: Record<string, string>;
-/** How a refusal from the core reads over HTTP. */
-export declare const STATUS: Partial<Record<Reason, number>>;
-/** An open server-sent event stream, as the server writes to it. */
-export type EventSink = ReadableStreamDefaultController<Uint8Array>;
-/** What a stream's owner does as pages join and leave it. */
-export interface StreamWatcher {
-    /** Called once a page's stream has joined the set. */
-    opened(): void;
-    /** Called once a page's stream has left the set. */
-    closed(): void;
-}
-/**
- * A server-sent event stream, in `listeners` while its page holds it open,
- * pulsing so the page can tell it went quiet, and telling `watcher` as it
- * joins and leaves.
- */
-export declare function eventStream(listeners: Set<EventSink>, watcher?: StreamWatcher): Response;
-/** The JSON a write sends, as an object. */
-export declare function body(request: Request): Promise<Record<string, unknown>>;
-/** The files a form carries under `file`, as bytes, each with its type. */
-export declare function uploads(form: FormData): Promise<(Attachment & {
-    mimeType: string;
-})[]>;
-/**
- * `bytes`, served as `type`, or to download when it is not an image or a
- * recording, in the part `request` asks for: Safari plays a video only from a
- * server that hands out its parts.
- */
-export declare function fileResponse(request: Request, bytes: Uint8Array, type: string | undefined, headers: Record<string, string>): Response;
-/** The host a Host header names, without its port. */
-export declare function hostname(host: string): string;
-/** `text` as JSON, or null when it is not. */
-export declare function json(text: string): unknown;
-export declare function refuse(status: number, reason: string, message: string): Response;
-/**
- * Says to `stream`'s page, every pulse, that it is still there, so a page
- * whose stream went quiet, as across a sleep, opens it again.
- */
-export declare function pulsing(stream: EventSink): Resource;

package/dev-open.d.ts

@@ -1,15 +0,0 @@
-/** A file to open, and the tree its editor window should hold. */
-export interface InTree {
-    tree: string;
-    file: string;
-}
-/**
- * Where `path` opens: inside the task worktree under `worktrees` it is in,
- * or, once that worktree is gone, at the same place in the main tree `root`,
- * or inside `root` itself. Null for a path in neither, which the page may not
- * open.
- */
-export declare function inTree(path: string, { root, worktrees }: {
-    root: string;
-    worktrees: string;
-}, exists: (path: string) => Promise<boolean>): Promise<InTree | null>;