@stringsync/splates 0.0.60 → 1.13.3

package/vendor/@stringsync/splates-server/conversations/entry.d.ts

@@ -0,0 +1,286 @@
+import type * as acp from "@agentclientprotocol/sdk";
+import type { AsyncTaskUpdate, Flag, ProcessHandle } from "../agents";
+import type { ArtifactChange } from "../artifacts";
+import type { ObservedTurn } from "../models";
+import type { Ask, Attached, AutoPickSet, Checkpoint, Decision, Device, Image, Limit, Setting } from "./state";
+/**
+ * A line of a conversation's log: what was said, in the order it was. Each
+ * carries the `seq` of the agent's frame being handled when it was written;
+ * missing before the first frame, and from older logs.
+ */
+export type Entry = Said & {
+    seq?: number;
+};
+type Said = {
+    kind: "start";
+    id: string;
+    agent: string;
+    task: string | null;
+    /** Where it runs; missing from logs written before resuming. */
+    cwd?: string;
+    /** Projectless, in its own scratch workspace; missing for a project's conversation. */
+    scratch?: true;
+    /** The task's base; missing from logs written before parts nested. */
+    base?: string | null;
+    /** Who added the task; missing from logs written before tasks remembered it. */
+    caller?: string | null;
+    createdAt: string;
+    /** Missing from logs written before assignments were kept apart. */
+    assigned?: boolean;
+    /** The lane orchestrator that handed it its task; missing for one nobody did. */
+    startedBy?: string;
+    /** The project's splates skill version; missing when it had none, or before it was kept. */
+    skill?: string;
+    /** Whether the server's queue or a hook started it; missing for one neither did. */
+    automatic?: boolean;
+    /** What `automatic` was written as before it was renamed. */
+    capped?: boolean;
+    /** The queued task it was held for; missing for one held for none. */
+    heldForTask?: number;
+    /** Read from `queued` in logs written before it was renamed. */
+    queued?: number;
+    /** The persistent agent's role it was started for; missing for an ordinary one. */
+    persistent?: string;
+    /** The automation that started it, by its id; missing for one none did. */
+    automation?: string;
+    /** The ship whose adoption task it runs, by its id; missing for any other. */
+    ship?: string;
+} | {
+    kind: "session";
+    session: string;
+    cwd?: string;
+} | {
+    kind: "model-request";
+    model: string;
+}
+/** The person set a model or effort after Auto pick chose it, by the setting's id and what it was set to. */
+ | {
+    kind: "override";
+    setting: string;
+    aspect: "model" | "effort";
+    value: string;
+    at: string;
+}
+/**
+ * What Auto pick set it to: at its start, or `lifted` when it moved it up
+ * for what the person said later.
+ */
+ | {
+    kind: "auto-pick";
+    pick: AutoPickSet;
+    lifted?: true;
+    at: string;
+}
+/** The person switched Auto pick on or off for the conversation. */
+ | {
+    kind: "auto-pick-switch";
+    on: boolean;
+    at: string;
+}
+/** Whether note pointers are held back from it, chosen as its first message was routed. */
+ | {
+    kind: "notes-holdout";
+    holdout: boolean;
+    experiment?: {
+        version: string;
+        at: string;
+    };
+}
+/** Settings to set once the session opens, by id, as Auto pick chose them. */
+ | {
+    kind: "picks-request";
+    picks: Record<string, string>;
+}
+/** Auto picked another agent than the one it started on, before any session opened. */
+ | {
+    kind: "agent";
+    agent: string;
+}
+/** The queue started the task it was held for, so it is held no more. */
+ | {
+    kind: "held-for-task";
+    heldForTask: null;
+}
+/** Read from `queued` in logs written before it was renamed. */
+ | {
+    kind: "queued";
+    queued: null;
+}
+/** Moved into a task's worktree, or back to the main tree. */
+ | {
+    kind: "task";
+    task: string | null;
+    cwd: string;
+    /** The task's base; missing from logs written before parts nested. */
+    base?: string | null;
+    /** Who added the task; missing from logs written before tasks remembered it. */
+    caller?: string | null;
+}
+/** What the session offered and had set, kept so the next one can start alike. */
+ | {
+    kind: "settings";
+    settings: Setting[];
+}
+/** `at` is missing from logs written before older archived ones were deleted. */
+ | {
+    kind: "archive";
+    archived: boolean;
+    at?: string;
+    /** The conversation whose archiving took this one with it. */
+    with?: string;
+    /** Archived resting, as a persistent agent's run that ended with its role still on. */
+    rest?: true;
+} | {
+    kind: "rename";
+    name: string | null;
+} | {
+    kind: "unread";
+    unread: boolean;
+} | {
+    kind: "read";
+    read: number;
+} | {
+    kind: "pin";
+    pinned: boolean;
+} | {
+    kind: "parent";
+    parent: {
+        id: string | null;
+    };
+}
+/** `at` is missing from logs written before the page showed how long things took. */
+ | {
+    kind: "prompt";
+    text: string;
+    at?: string;
+    queued?: true;
+    steered?: true;
+    /** The conversation that said it with `splates tell`. */
+    told?: string;
+    /** Said into the mic; missing from logs written before the page said. */
+    dictated?: true;
+    /** The page's id for it; missing for an agent's word, or from older logs. */
+    id?: string;
+    /** Where the person said it on the page; missing for an agent's word, or from older logs. */
+    from?: Device;
+    /** Missing from logs written before the page sent images. */
+    images?: Image[];
+    /** Missing from logs written before the page sent other files. */
+    files?: Attached[];
+}
+/** Every queued prompt went out. */
+ | {
+    kind: "sent";
+    count?: number;
+    at?: string;
+}
+/** The person stopped the agent's turn. */
+ | {
+    kind: "stopped";
+    at: string;
+}
+/** The agent's turn ended early, its connection lost or its process gone. */
+ | {
+    kind: "interrupted";
+    at: string;
+}
+/** A turn started or ended, so one a dead process left running shows as cut short. */
+ | {
+    kind: "turn";
+    running: boolean;
+    at?: string;
+} | {
+    kind: "observed-turn";
+    turn: ObservedTurn;
+}
+/** The `index`th queued prompt was taken back. */
+ | {
+    kind: "unqueue";
+    index: number;
+}
+/** Where a checkpoint stands, and what comes after it. */
+ | {
+    kind: "checkpoint";
+    checkpoint: Checkpoint | null;
+    /** Why a worker budget hard stop asked it; absent for any other. */
+    budget?: string;
+} | {
+    kind: "update";
+    update: acp.SessionUpdate;
+    at?: string;
+    /** When the last of the chunks joined into this one came. */
+    until?: string;
+}
+/** The tokens a turn used, as the agent said when it ended. */
+ | {
+    kind: "usage";
+    usage: acp.Usage;
+}
+/** The plan's windows, as asked of an agent that does not send them. */
+ | {
+    kind: "limits";
+    limits: Limit[];
+}
+/** What a finished command did to git that it should not have. */
+ | {
+    kind: "flags";
+    tool: string;
+    flags: Flag[];
+}
+/** How the person answered the agent asking permission for a tool call. */
+ | {
+    kind: "decision";
+    tool: string;
+    decision: Decision;
+}
+/** An artifact added, removed, or its bytes deleted. */
+ | {
+    kind: "artifact";
+    change: ArtifactChange;
+}
+/**
+ * The agent's session is open on a process a worker runs, which a
+ * server started again takes back by `handle`, until `end`.
+ */
+ | {
+    kind: "launched";
+    handle: ProcessHandle;
+    /** Whether the agent takes a prompt into its running turn. */
+    steers: boolean;
+    /** Whether the agent takes images in a prompt. */
+    sees: boolean;
+    /** Whether the agent says on its session list when a turn ends; missing from older logs. */
+    follows?: boolean;
+    /** The `LOG_FORMAT` that wrote the log; missing from logs before it was stamped, which are format 1. */
+    format?: number;
+}
+/** A request this side sent the agent, by the id it went out with. */
+ | {
+    kind: "request";
+    id: number;
+    method: string;
+}
+/** What the agent asks the person, by the request id `rpc` to answer on, when known; null once answered. */
+ | {
+    kind: "ask";
+    rpc: acp.JsonRpcId | null;
+    ask: Ask;
+} | {
+    kind: "ask";
+    ask: null;
+}
+/** Word of a command the agent left running in the background. */
+ | {
+    kind: "background";
+    update: AsyncTaskUpdate;
+    at?: string;
+} | {
+    kind: "end";
+    error: string | null;
+    /**
+     * The server went down while it started, before its agent heard
+     * what was queued: the next run starts it again to say it.
+     */
+    unsaid?: true;
+};
+export {};

package/vendor/@stringsync/splates-server/conversations/events.d.ts

@@ -0,0 +1,36 @@
+import type { Resource } from "../../../core/disposable/index.js";
+import type { Logger } from "../../../core/log/index.js";
+import { type Timer } from "../../../core/time/index.js";
+import type { Journal } from "../records";
+import type { Conversations } from "./conversations";
+/**
+ * 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 JournalEvents implements Resource {
+    #private;
+    private readonly journal;
+    private readonly conversations;
+    private readonly log;
+    private constructor();
+    /**
+     * Hands each conversation in `conversations` its events, then follows
+     * the journal for more.
+     */
+    static follow({ journal, conversations, log, timer, }: {
+        journal: Journal;
+        conversations: Conversations;
+        log: Logger;
+        timer?: Timer;
+    }): Promise<JournalEvents>;
+    /**
+     * 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/vendor/@stringsync/splates-server/conversations/files.d.ts

@@ -0,0 +1,62 @@
+import type * as acp from "@agentclientprotocol/sdk";
+import type { Storage } from "../storage";
+import type { ProjectRoster } from "./host";
+import type { Message, Sent, Upload } from "./state";
+/**
+ * The files the person sent in a conversation, kept beside its log in a
+ * collection named for it, and how what they said goes to the agent.
+ */
+export declare class ConversationFiles {
+    /**
+     * Where the conversations are kept, each log `<id>.jsonl`, which an
+     * agent opens what it is handed from as files on this machine.
+     */
+    private readonly storage;
+    private readonly id;
+    private readonly files;
+    private readonly projects;
+    private readonly home;
+    constructor(
+    /**
+     * Where the conversations are kept, each log `<id>.jsonl`, which an
+     * agent opens what it is handed from as files on this machine.
+     */
+    storage: Storage, id: string, { projects, home, }?: {
+        /** The splates projects on this machine, for `#slug`; null for none. */
+        projects?: ProjectRoster | null;
+        /** The main tree of the project the conversation is in; null for none. */
+        home?: string | null;
+    });
+    /**
+     * Saves each file beside the log, named for what is in it, so the page
+     * reads it by name rather than with every change to the conversation.
+     * An image goes to the agent as itself when it `sees` images; anything
+     * else, as a link to where it is kept, which every agent takes.
+     */
+    keep(files: Upload[], sees: boolean): Promise<Sent[]>;
+    /** The file `name` the person sent in `messages`, or null when they sent none by that name. */
+    attachment(name: string, messages: Message[]): Promise<{
+        bytes: Uint8Array;
+        mimeType: string;
+    } | null>;
+    /**
+     * What `messages` say, as one prompt: their images, links to their other
+     * files, then their words, with a line on where each project they name
+     * sits, and one on reading them as speech
+     * when any was dictated.
+     */
+    content(messages: Message[], sees?: boolean): Promise<acp.ContentBlock[]>;
+    /**
+     * Writes the end of `messages` beside the log for the agent that takes its
+     * task on next, and answers where (see `transcriptOf`).
+     */
+    keepTranscript(messages: Message[]): Promise<string>;
+    /** Deletes every file kept, for good. */
+    remove(): Promise<void>;
+    /** Where an agent on this machine opens the file kept under `name`. */
+    private opened;
+    /** The bytes kept under `name`, throwing when there are none. */
+    private bytesOf;
+    /** Adds project locations and conversation log references for the agent. */
+    private namedIn;
+}

package/vendor/@stringsync/splates-server/conversations/given.d.ts

@@ -0,0 +1,18 @@
+import type { WorktreeService } from "../tasks";
+/**
+ * The conversation a command is about: `given` from `--conversation`, for an
+ * agent outside `splates server`, else the one `splates server` started this agent in
+ * ($SPLATES_CONVERSATION). Refuses `usage` when neither names one of this
+ * repository's.
+ */
+export declare function conversationOf(service: WorktreeService, given: string): Promise<string>;
+/**
+ * Refuses `splates <command>` to the project's groomer, which organizes
+ * tasks and never does them: outright, as for `add`, `merge` or `queue
+ * add`; or, given the queued task it changes, only once another task took
+ * that, since whoever starts a task wins it.
+ */
+export declare function refuseGroomer(service: Pick<WorktreeService, "callerRole">, command: string, task?: {
+    id: number;
+    takenBy: string | null;
+}): Promise<void>;

package/vendor/@stringsync/splates-server/conversations/heard.d.ts

@@ -0,0 +1,8 @@
+import type { ConversationHost, Lift } from "./host";
+import type { Message } from "./state";
+/**
+ * Lets Auto pick look again at what the person says in `messages`, in a
+ * conversation it started, before the agent reads them; one that fails
+ * moves nothing.
+ */
+export declare function lifted(lift: Lift | null | undefined, host: ConversationHost, messages: readonly Message[]): Promise<void>;

package/vendor/@stringsync/splates-server/conversations/host.d.ts

@@ -0,0 +1,176 @@
+import type { Events } from "../../../core/events/index.js";
+import type { IdProvider } from "../../../core/id/index.js";
+import type { Fs, Lock } from "../../../core/system/index.js";
+import type { Timer, WallClock } from "../../../core/time/index.js";
+import type { Agent, Launch, Launcher, SessionServers, Watch } from "../agents";
+import type { ArtifactLimits, ArtifactRoom } from "../artifacts";
+import type { Reach } from "../projects";
+import type { Storage } from "../storage";
+import type { Grant, WorkerMachine } from "../workers";
+import type { ConversationLog } from "./log";
+import type { AutoPickSet, ConversationState, Message, QueueSpot } from "./state";
+/**
+ * What a conversation's parts, its connection, its turns and its background
+ * commands, share of it: its state and log, and the few things they do to
+ * the whole. `Conversation` implements it.
+ */
+export interface ConversationHost {
+    readonly state: ConversationState;
+    readonly log: ConversationLog;
+    readonly events: Events<ConversationEvents>;
+    /** What runs it; null when its agent is no longer known. */
+    get agent(): Agent | null;
+    /** Where it runs; null for a log too old to say. */
+    readonly cwd: string | null;
+    /** Under way while the agent starts or comes back, for a prompt to wait on. */
+    readonly opening: Promise<void> | null;
+    now(): string;
+    set(next: Partial<ConversationState>): void;
+    changed(): void;
+    /** A turn ended, with `error` for one that failed. */
+    ended(error: string | null): void;
+    /** Ends the agent's process, with `error` for one that failed. */
+    close(error: string | null): Promise<void>;
+    /** Brings a stopped conversation back: a new process, the same session or a new one. */
+    resume(): Promise<void>;
+    /** Back on the list, stopped until the next prompt. */
+    unarchive(): Promise<void>;
+    /** Marks it `unread` or not. */
+    flag(unread: boolean): void;
+    /** Sets `settings`, by id, as Auto pick moves it up to `pick`. */
+    lift(settings: Record<string, string>, pick: AutoPickSet): Promise<void>;
+}
+/**
+ * Auto pick's second look at `said`, what the person says next in
+ * `conversation`, before its agent reads it: it may move the conversation
+ * up with `lift`.
+ */
+export type Lift = (conversation: ConversationHost, said: readonly Message[]) => Promise<void>;
+export type ConversationEvents = {
+    changed: undefined;
+    chosen: string;
+};
+/** What every conversation in a repo is made with. */
+export interface ConversationDeps {
+    fs: Fs;
+    /** Kimi Code's home (`~/.kimi-code`), whose session logs supply its tokens. */
+    kimiHome?: string;
+    /**
+     * Where every conversation of the repo is kept: its log as `<id>.jsonl`,
+     * the files the person sent in it as the collection `<id>`.
+     */
+    storage: Storage;
+    /**
+     * Where those sit on this machine, for an agent to open: its artifacts,
+     * which are not on storage yet, among them.
+     */
+    dir: string;
+    /** What names the files artifacts are kept in. */
+    ids: IdProvider;
+    /** How many bytes of artifacts it may keep (`artifacts.ts`). */
+    artifacts: ArtifactLimits;
+    /** What makes room for an add across the project; none refuses one past it. */
+    room?: ArtifactRoom;
+    timer: Timer;
+    clock: WallClock;
+    /** What starts each agent, and takes one back after a restart. */
+    launcher: Launcher;
+    /**
+     * Where each agent waits for a place on a worker before it starts, and
+     * starts there: one another agent started for a free one, one the person
+     * started for any worker up. With none, every one starts at once on
+     * `launcher`.
+     */
+    placer?: ConversationPlacer;
+    /** Where the agent runs, which its background commands' output is read from. */
+    machine: WorkerMachine;
+    /**
+     * Hold it while an agent's process starts, until it is done
+     * opening its session, so agents start one at a time.
+     */
+    starting: Lock;
+    /** Where `splates server` answers, for the agent's CLI to tell it things. */
+    url: string | null;
+    /** What watches the agent's commands; null to leave them be. */
+    watch: Watch | null;
+    /** The main tree, where a conversation carries on once its worktree is gone. */
+    root: string | null;
+    /** The splates projects on this machine, for `#slug`; null for none. */
+    projects: ProjectRoster | null;
+    /** The MCP servers each session is offered, beyond the agent's own; null for none. */
+    servers: SessionServers | null;
+    /** What looks again at what the person says in a conversation Auto pick started; null for nothing. */
+    lift?: Lift | null;
+}
+/** A project's way into the machine's queue for places on workers (`Scheduler`). */
+export interface ConversationPlacer {
+    /**
+     * A place for the agent of conversation `id`, once its turn comes;
+     * aborting `signal` takes it out of the queue, rejecting.
+     */
+    take(request: PlaceRequest, signal: AbortSignal): Promise<Placement>;
+    /**
+     * Counts an agent already running on `worker` against its worker, and
+     * reaches it there; throws for a worker this server no longer knows.
+     */
+    hold(request: PlaceRequest, worker: string): Hold;
+    /** Where the agent of conversation `id` waits; null for one not waiting. */
+    spot(id: string): QueueSpot | null;
+    /**
+     * `changed` as the queue or the places held change; `drain` with a
+     * worker's id once it starts draining.
+     */
+    readonly events: Events<{
+        changed: undefined;
+        drain: string;
+    }>;
+}
+/**
+ * What asks for a place: conversation `id`'s agent, of `task`, by the
+ * agent's id, which a worker must hold the key of. An automatic one, which
+ * splates started on its own, waits while starts are paused; one the person
+ * started goes on any worker up.
+ */
+export interface PlaceRequest {
+    id: string;
+    task: string | null;
+    agent: string;
+    automatic: boolean;
+}
+/** A place on a worker, and how to start an agent there. */
+export interface Placement extends Grant {
+    launch: Launch;
+}
+/** A place on a worker an agent already runs on, and how to take it back. */
+export interface Hold extends Grant {
+    /**
+     * Takes back the process `handle` names on the worker, as
+     * `Launcher.resume` does, once that worker joins.
+     */
+    resume: Launcher["resume"];
+}
+/** The splates projects on this machine, as `Projects` lists them. */
+export interface ProjectRoster {
+    /** Each project, flagged `gone` when its repository is no longer there. */
+    list(): Promise<(ProjectRef & {
+        gone: boolean;
+    })[]>;
+    /** What the project at `from` may do in the one at `to`. */
+    reach(from: string, to: string): Promise<Reach>;
+}
+/** A splates project a prompt can name as `#slug`. */
+export interface ProjectRef {
+    slug: string;
+    /** Its main tree's root. */
+    root: string;
+}
+/**
+ * `changed`, `ended` (a turn ended, however it did, or the agent failed to
+ * start) and `removed` each carry a conversation's id.
+ */
+export type ConversationsEvents = {
+    settings: undefined;
+    changed: string;
+    ended: string;
+    removed: string;
+};

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

@@ -0,0 +1,22 @@
+export type { Agent, AgentProcess, Launch, Launcher, Session, } from "../agents";
+export { fold, heard, launch } from "../agents";
+export type { Artifact, ArtifactGone, ArtifactVersion, } from "../artifacts";
+export type { Picked } from "./conversation";
+export { Conversation } from "./conversation";
+export { ARCHIVED_KEPT, Conversations } from "./conversations";
+export { JournalEvents } from "./events";
+export { conversationOf, refuseGroomer } from "./given";
+export type { ConversationDeps, ConversationEvents, ConversationHost, ConversationPlacer, ConversationsEvents, Lift, PlaceRequest, ProjectRef, } from "./host";
+export { listing } from "./listing";
+export type { Entry, Live } from "./log";
+export { ConversationLog, LOG_FORMAT } from "./log";
+export { messageOf, paused, said, textOf } from "./messages";
+export { GROOMER_ROLE, grooms, lanesOf, namedForTask, nameOf, openingOf, realName, } from "./name";
+export type { ConversationsOptions } from "./options";
+export { conversationReference } from "./reference";
+export { ConversationRoutes } from "./routes";
+export type { Said } from "./search";
+export type { After, Answer, Ask, Asked, Attached, AutoPickMark, AutoPickSet, Background, Backgrounded, BackgroundState, Checkpoint, Command, Compaction, ConversationState, Decision, Device, Edit, Field, Image, Limit, Message, Part, QueueSpot, Setting, Status, Step, Taking, Tool, Upload, Usage, } from "./state";
+export { blank, DEVICES, FROM_HEADER, IDLE_STOP, listed, runOn, SERVER_TOLD, switched, unused, } from "./state";
+export type { ConversationsHeard } from "./stream";
+export { treeOf } from "./tree";

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

@@ -0,0 +1,80 @@
+import {
+  fold2,
+  heard2,
+  said2,
+  textOf2,
+  paused2,
+  messageOf2,
+  nameOf2,
+  realName2,
+  namedForTask2,
+  GROOMER_ROLE2,
+  grooms2,
+  lanesOf2,
+  openingOf2,
+  conversationReference2,
+  unused2,
+  switched2,
+  IDLE_STOP2,
+  SERVER_TOLD2,
+  DEVICES2,
+  FROM_HEADER2,
+  blank2,
+  listed2,
+  runOn2,
+  launch2,
+  LOG_FORMAT2,
+  ConversationLog2,
+  Conversation2,
+  ARCHIVED_KEPT2,
+  Conversations2,
+  JournalEvents2,
+  conversationOf2,
+  refuseGroomer2,
+  listing2,
+  treeOf2,
+  ConversationRoutes2
+} 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 {
+  ARCHIVED_KEPT2 as ARCHIVED_KEPT,
+  Conversation2 as Conversation,
+  ConversationLog2 as ConversationLog,
+  ConversationRoutes2 as ConversationRoutes,
+  Conversations2 as Conversations,
+  DEVICES2 as DEVICES,
+  FROM_HEADER2 as FROM_HEADER,
+  GROOMER_ROLE2 as GROOMER_ROLE,
+  IDLE_STOP2 as IDLE_STOP,
+  JournalEvents2 as JournalEvents,
+  LOG_FORMAT2 as LOG_FORMAT,
+  SERVER_TOLD2 as SERVER_TOLD,
+  blank2 as blank,
+  conversationOf2 as conversationOf,
+  conversationReference2 as conversationReference,
+  fold2 as fold,
+  grooms2 as grooms,
+  heard2 as heard,
+  lanesOf2 as lanesOf,
+  launch2 as launch,
+  listed2 as listed,
+  listing2 as listing,
+  messageOf2 as messageOf,
+  nameOf2 as nameOf,
+  namedForTask2 as namedForTask,
+  openingOf2 as openingOf,
+  paused2 as paused,
+  realName2 as realName,
+  refuseGroomer2 as refuseGroomer,
+  runOn2 as runOn,
+  said2 as said,
+  switched2 as switched,
+  textOf2 as textOf,
+  treeOf2 as treeOf,
+  unused2 as unused
+};