@plitzi/plitzi-builder 0.37.8 → 0.37.10

package/dist/modules/Functions/components/FunctionInspector/components/TimeLimit/TimeLimit.d.ts

@@ -0,0 +1,16 @@
+export type TimeLimitProps = {
+    /** The CPU the task runs with now. */
+    ms: number;
+    /** Whether the task asked for it, or gets the default. */
+    asked: boolean;
+    /** Why it cannot be changed from here right now — the code is still being read, say — or nothing. */
+    disabledReason?: string;
+    /** A new limit, or `undefined` to take it out and run with the default. Written into the task's code. */
+    onChange: (cpuMs: number | undefined) => void;
+};
+/**
+ * How much CPU one run of the task may use before it is stopped: a slider and the usual values, written into the task
+ * as `limits: { cpuMs }` — the code stays the one place it is said, and the panel follows it when it is typed there.
+ */
+declare const TimeLimit: ({ ms, asked, disabledReason, onChange }: TimeLimitProps) => import('react').JSX.Element;
+export default TimeLimit;

package/dist/modules/Functions/components/FunctionInspector/components/TimeLimit/index.d.ts

@@ -0,0 +1,3 @@
+import { default as TimeLimit } from './TimeLimit';
+export * from './TimeLimit';
+export default TimeLimit;

package/dist/modules/Functions/components/FunctionInspector/components/TryField/TryField.d.ts

@@ -0,0 +1,10 @@
+import { FunctionTaskManifest } from '@plitzi/sdk-shared';
+export type TryFieldProps = {
+    name: string;
+    param: FunctionTaskManifest['params'][string];
+    value: unknown;
+    onChange: (name: string, value: unknown) => void;
+};
+/** One param of a task, drawn as its step would draw it: a choice from its options, a switch, or text. */
+declare const TryField: ({ name, param, value, onChange }: TryFieldProps) => import('react').JSX.Element;
+export default TryField;

package/dist/modules/Functions/components/FunctionInspector/components/TryField/index.d.ts

@@ -0,0 +1,3 @@
+import { default as TryField } from './TryField';
+export * from './TryField';
+export default TryField;

package/dist/modules/Functions/components/FunctionInspector/components/TryResult/TryResult.d.ts

@@ -0,0 +1,9 @@
+import { ActionRunReport } from '@plitzi/sdk-shared';
+export type TryResultProps = {
+    report: ActionRunReport;
+    /** The task that was tried: its step in the report is what it answered. */
+    task: string;
+};
+/** What a try answered: how it ended and how long it took, what it logged, and its value — or why it failed. */
+declare const TryResult: ({ report, task }: TryResultProps) => import('react').JSX.Element;
+export default TryResult;

package/dist/modules/Functions/components/FunctionInspector/components/TryResult/index.d.ts

@@ -0,0 +1,3 @@
+import { default as TryResult } from './TryResult';
+export * from './TryResult';
+export default TryResult;

package/dist/modules/Functions/components/FunctionInspector/index.d.ts

@@ -0,0 +1,3 @@
+import { default as FunctionInspector } from './FunctionInspector';
+export * from './FunctionInspector';
+export default FunctionInspector;

package/dist/modules/Functions/components/FunctionsEditor/FunctionsEditor.d.ts

@@ -0,0 +1,20 @@
+import { EditorTarget } from '../../helpers';
+import { Extension } from '@codemirror/state';
+export type FunctionsEditorProps = {
+    file: string;
+    value: string;
+    modified: boolean;
+    theme: 'light' | 'dark';
+    /** The language service's extensions for this file — none until it is ready. Kept stable by the caller. */
+    extensions: Extension[];
+    /** Whether the language service is checking the code as it is typed. */
+    checking: boolean;
+    /** A line to bring into view and put the cursor on: a new `key` asks again, even for the same line. */
+    target?: EditorTarget;
+    onChange: (code: string) => void;
+    /** Where the cursor is when the person moves it: the panel follows it to the task it is in. */
+    onCursor: (file: string, offset: number) => void;
+};
+/** The file being edited, under the path it is at — one editor per file, so each keeps its own undo history. */
+declare const FunctionsEditor: ({ file, value, modified, theme, extensions, checking, target, onChange, onCursor }: FunctionsEditorProps) => import('react').JSX.Element;
+export default FunctionsEditor;

package/dist/modules/Functions/components/FunctionsEditor/index.d.ts

@@ -0,0 +1,3 @@
+import { default as FunctionsEditor } from './FunctionsEditor';
+export * from './FunctionsEditor';
+export default FunctionsEditor;

package/dist/modules/Functions/components/FunctionsGuide/FunctionsGuide.d.ts

@@ -0,0 +1,7 @@
+export type FunctionsGuideProps = {
+    /** Whether the code declares any task yet. */
+    hasTasks: boolean;
+};
+/** The inspector's place with no task in it: how to get one there. */
+declare const FunctionsGuide: ({ hasTasks }: FunctionsGuideProps) => import('react').JSX.Element;
+export default FunctionsGuide;

package/dist/modules/Functions/components/FunctionsGuide/index.d.ts

@@ -0,0 +1,3 @@
+import { default as FunctionsGuide } from './FunctionsGuide';
+export * from './FunctionsGuide';
+export default FunctionsGuide;

package/dist/modules/Functions/components/FunctionsHeader/FunctionsHeader.d.ts

@@ -0,0 +1,17 @@
+import { SaveState } from '../../helpers';
+export type FunctionsHeaderProps = {
+    /** Where the files stand — none for a space with no functions yet. */
+    state?: SaveState;
+    canSave: boolean;
+    isSaving: boolean;
+    /** Whether there are changes to discard. */
+    canDiscard: boolean;
+    /** Whether there is a saved draft to remove. */
+    canRemove: boolean;
+    onSave: () => void;
+    onDiscard: () => void;
+    onRemove: () => void;
+};
+/** The panel's name and what it is for, where the files stand, and saving them — the one thing done most. */
+declare const FunctionsHeader: ({ state, canSave, isSaving, canDiscard, canRemove, onSave, onDiscard, onRemove }: FunctionsHeaderProps) => import('react').JSX.Element;
+export default FunctionsHeader;

package/dist/modules/Functions/components/FunctionsHeader/index.d.ts

@@ -0,0 +1,3 @@
+import { default as FunctionsHeader } from './FunctionsHeader';
+export * from './FunctionsHeader';
+export default FunctionsHeader;

package/dist/modules/Functions/components/FunctionsProblems/FunctionsProblems.d.ts

@@ -1,7 +1,8 @@
 import { FunctionsProblem } from '@plitzi/sdk-shared';
 export type FunctionsProblemsProps = {
     problems: FunctionsProblem[];
-    onSelect: (file: string) => void;
+    /** Where a problem is, to open: its file, and its line when it has one. */
+    onSelect: (file: string, line?: number) => void;
 };
 /** What the last save found wrong, where it is: the build's and the platform's checks, before anything ran. */
 declare const FunctionsProblems: ({ problems, onSelect }: FunctionsProblemsProps) => import('react').JSX.Element;

package/dist/modules/Functions/components/FunctionsSidebar/FunctionsSidebar.d.ts

@@ -0,0 +1,30 @@
+import { NewTask as NewTaskSpec } from '../../editor/source';
+import { ListedRoute, ListedTask } from '../../helpers';
+import { FunctionTimeLimits } from '@plitzi/sdk-shared';
+export type FunctionsSidebarProps = {
+    tasks: ListedTask[];
+    /** What every task gets unless it asks for its own, from `defineFunctions`. */
+    sharedLimits?: FunctionTimeLimits;
+    selectedTask: string;
+    /** Tasks the code builds by calling something: there, but only a save can say what they are. */
+    unreadable: number;
+    /** Whether a new task can be written for you: the code has been read, and it calls `defineFunctions`. */
+    canCreateTask: boolean;
+    routes: ListedRoute[];
+    files: string[];
+    selectedFile: string;
+    /** The files whose text differs from what was last saved. */
+    modified: string[];
+    onSelectTask: (task: string) => void;
+    onCreateTask: (task: NewTaskSpec) => void;
+    onSelectRoute: (route: string) => void;
+    onSelectFile: (file: string) => void;
+    onAddFile: (file: string) => void;
+    onRemoveFile: (file: string) => void;
+};
+/**
+ * What the functions are, as the code declares them right now: the tasks a step can run — a click from the code and
+ * the inspector — the routes they answer at, and the files they are written in.
+ */
+declare const FunctionsSidebar: ({ tasks, sharedLimits, selectedTask, unreadable, canCreateTask, routes, files, selectedFile, modified, onSelectTask, onCreateTask, onSelectRoute, onSelectFile, onAddFile, onRemoveFile }: FunctionsSidebarProps) => import('react').JSX.Element;
+export default FunctionsSidebar;

package/dist/modules/Functions/components/FunctionsSidebar/components/FileItem/FileItem.d.ts

@@ -0,0 +1,14 @@
+export type FileItemProps = {
+    path: string;
+    name: string;
+    depth: number;
+    selected: boolean;
+    modified: boolean;
+    /** `index.ts` is what everything starts from: it is never removed. */
+    removable: boolean;
+    onSelect: (file: string) => void;
+    onRemove: (file: string) => void;
+};
+/** One file in the list: opened with a click, marked while it has unsaved changes, removed from its own button. */
+declare const FileItem: ({ path, name, depth, selected, modified, removable, onSelect, onRemove }: FileItemProps) => import('react').JSX.Element;
+export default FileItem;

package/dist/modules/Functions/components/FunctionsSidebar/components/FileItem/index.d.ts

@@ -0,0 +1,3 @@
+import { default as FileItem } from './FileItem';
+export * from './FileItem';
+export default FileItem;

package/dist/modules/Functions/components/FunctionsSidebar/components/FolderItem/FolderItem.d.ts

@@ -0,0 +1,7 @@
+export type FolderItemProps = {
+    name: string;
+    depth: number;
+};
+/** A folder in the list: its name, once, above the files in it. */
+declare const FolderItem: ({ name, depth }: FolderItemProps) => import('react').JSX.Element;
+export default FolderItem;

package/dist/modules/Functions/components/FunctionsSidebar/components/FolderItem/index.d.ts

@@ -0,0 +1,3 @@
+import { default as FolderItem } from './FolderItem';
+export * from './FolderItem';
+export default FolderItem;

package/dist/modules/Functions/components/FunctionsSidebar/components/NewFile/NewFile.d.ts

@@ -0,0 +1,7 @@
+export type NewFileProps = {
+    onAdd: (file: string) => void;
+    onCancel: () => void;
+};
+/** A new file's name, typed where the list starts: Enter adds it — `lib/feed.ts` makes the folder too — Escape lets it go. */
+declare const NewFile: ({ onAdd, onCancel }: NewFileProps) => import('react').JSX.Element;
+export default NewFile;

package/dist/modules/Functions/components/FunctionsSidebar/components/NewFile/index.d.ts

@@ -0,0 +1,3 @@
+import { default as NewFile } from './NewFile';
+export * from './NewFile';
+export default NewFile;

package/dist/modules/Functions/components/FunctionsSidebar/components/NewTask/NewTask.d.ts

@@ -0,0 +1,13 @@
+import { NewTask as NewTaskSpec } from '../../../../editor/source';
+export type NewTaskProps = {
+    /** The namespace the others use, offered first: a space's tasks usually share one. */
+    namespace: string;
+    onCreate: (task: NewTaskSpec) => void;
+    onCancel: () => void;
+};
+/**
+ * A new task, named where the list is: its namespace and action — what a step calls it, `seismic.feed` — and its title.
+ * Written into `defineFunctions` for you, with a `run` to start from.
+ */
+declare const NewTask: ({ namespace: usual, onCreate, onCancel }: NewTaskProps) => import('react').JSX.Element;
+export default NewTask;

package/dist/modules/Functions/components/FunctionsSidebar/components/NewTask/index.d.ts

@@ -0,0 +1,3 @@
+import { default as NewTask } from './NewTask';
+export * from './NewTask';
+export default NewTask;

package/dist/modules/Functions/components/FunctionsSidebar/components/RouteItem/RouteItem.d.ts

@@ -0,0 +1,9 @@
+export type RouteItemProps = {
+    routeKey: string;
+    method: string;
+    path: string;
+    onSelect: (route: string) => void;
+};
+/** One route: the method and the address it answers at, a click from where it is written. */
+declare const RouteItem: ({ routeKey, method, path, onSelect }: RouteItemProps) => import('react').JSX.Element;
+export default RouteItem;

package/dist/modules/Functions/components/FunctionsSidebar/components/RouteItem/index.d.ts

@@ -0,0 +1,3 @@
+import { default as RouteItem } from './RouteItem';
+export * from './RouteItem';
+export default RouteItem;

package/dist/modules/Functions/components/FunctionsSidebar/components/SidebarSection/SidebarSection.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+export type SidebarSectionProps = {
+    title: string;
+    /** How many there are, beside the title — none for a section that is not a list. */
+    count?: number;
+    /** What its one button does, in words: its tooltip and its accessible name. */
+    actionTitle?: string;
+    onAction?: () => void;
+    children: ReactNode;
+};
+/** One part of the sidebar: its title and how many it holds, the button that adds one, and the list. */
+declare const SidebarSection: ({ title, count, actionTitle, onAction, children }: SidebarSectionProps) => import('react').JSX.Element;
+export default SidebarSection;

package/dist/modules/Functions/components/FunctionsSidebar/components/SidebarSection/index.d.ts

@@ -0,0 +1,3 @@
+import { default as SidebarSection } from './SidebarSection';
+export * from './SidebarSection';
+export default SidebarSection;

package/dist/modules/Functions/components/FunctionsSidebar/components/TaskItem/TaskItem.d.ts

@@ -0,0 +1,16 @@
+export type TaskItemProps = {
+    name: string;
+    title: string;
+    /** The CPU it runs with, and whether it asked for it or gets the default. */
+    cpu: {
+        ms: number;
+        asked: boolean;
+    };
+    selected: boolean;
+    /** Written, but not in the saved draft yet: nothing can run it until it is saved. */
+    unsaved: boolean;
+    onSelect: (task: string) => void;
+};
+/** One task in the list: its title and its step's name, the time it asked for, and whether a save has it yet. */
+declare const TaskItem: ({ name, title, cpu, selected, unsaved, onSelect }: TaskItemProps) => import('react').JSX.Element;
+export default TaskItem;

package/dist/modules/Functions/components/FunctionsSidebar/components/TaskItem/index.d.ts

@@ -0,0 +1,3 @@
+import { default as TaskItem } from './TaskItem';
+export * from './TaskItem';
+export default TaskItem;

package/dist/modules/Functions/components/FunctionsSidebar/index.d.ts

@@ -0,0 +1,3 @@
+import { default as FunctionsSidebar } from './FunctionsSidebar';
+export * from './FunctionsSidebar';
+export default FunctionsSidebar;

package/dist/modules/Functions/components/FunctionsWelcome/FunctionsWelcome.d.ts

@@ -0,0 +1,6 @@
+export type FunctionsWelcomeProps = {
+    onStart: () => void;
+};
+/** A space with no functions yet: what they are for, and one written already to change rather than a blank file. */
+declare const FunctionsWelcome: ({ onStart }: FunctionsWelcomeProps) => import('react').JSX.Element;
+export default FunctionsWelcome;

package/dist/modules/Functions/components/FunctionsWelcome/index.d.ts

@@ -0,0 +1,3 @@
+import { default as FunctionsWelcome } from './FunctionsWelcome';
+export * from './FunctionsWelcome';
+export default FunctionsWelcome;

package/dist/modules/Functions/editor/paths.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Where the worker keeps the space's files. Its own module, with nothing imported: the panel needs these paths, and
+ * `source.ts` beside them brings the TypeScript compiler, which belongs to the worker alone — imported from the panel it
+ * landed in the builder's bundle, and broke rendering the builder on the server.
+ */
+/** The root the worker keeps the space's files under — `/functions/lib/feed.ts` is `lib/feed.ts` to the panel. */
+export declare const FUNCTIONS_ROOT = "/functions/";
+/** Where a file of the space's functions lives in the worker. */
+export declare const workerPathOf: (file: string) => string;

package/dist/modules/Functions/editor/source.d.ts

@@ -0,0 +1,60 @@
+import { FunctionTaskManifest, FunctionTimeLimits } from '@plitzi/sdk-shared';
+import { VirtualTypeScriptEnvironment } from '@typescript/vfs';
+/**
+ * The space's functions as their SOURCE declares them, read while they are written — what the panel lists and edits
+ * before anything is saved. Static: the object literals `defineFunctions` is handed, followed through the constants and
+ * the files they come from; nothing is run. What cannot be read that way (a task built by a function call) is said, not
+ * guessed. Saving still asks the platform, which runs the bundle and is the one that decides.
+ */
+/** Where something is written: the file — as the panel names it, `lib/feed.ts` — and its place in it. */
+/** Where something is written: its file, the line it starts on, and the offsets it spans there. */
+export type SourcePlace = {
+    file: string;
+    line: number;
+    start: number;
+    end: number;
+};
+export type SourceTask = Pick<FunctionTaskManifest, 'namespace' | 'action' | 'title' | 'description' | 'params'> & {
+    limits?: FunctionTimeLimits;
+    at: SourcePlace;
+};
+export type SourceRoute = {
+    key: string;
+    at: SourcePlace;
+};
+export type SourceFunctions = {
+    /** `index.ts` exports `defineFunctions(…)` — without it there is nothing declared to read. */
+    defined: boolean;
+    tasks: SourceTask[];
+    routes: SourceRoute[];
+    hosts: string[];
+    /** What every task and route asks for, unless one asks for its own. */
+    limits?: FunctionTimeLimits;
+    /** Entries that are there but cannot be read without running the code: what to look at, and where. */
+    unreadable: {
+        what: string;
+        at: SourcePlace;
+    }[];
+};
+export declare const describeSource: (env: VirtualTypeScriptEnvironment) => SourceFunctions;
+/** A file of the space's, written again: what a panel puts back in its files. */
+export type SourceEdit = {
+    file: string;
+    code: string;
+};
+/**
+ * The task written at `place`, asking for `limits` — written into its own `limits`, or that taken out when it asks for
+ * nothing. Its other properties, comments and formatting are left as they are: the edit is the one property.
+ */
+export declare const withTaskLimits: (env: VirtualTypeScriptEnvironment, place: SourcePlace, limits: FunctionTimeLimits) => SourceEdit | undefined;
+/** A new task, as `New task` writes it: what it is called, and a `run` that answers with something to see. */
+export type NewTask = {
+    namespace: string;
+    action: string;
+    title: string;
+};
+/**
+ * `index.ts` with a new task at the end of the list `defineFunctions` is handed — a list started for it when there is
+ * none. What it adds is answered too, so the panel can open it where it was written.
+ */
+export declare const withNewTask: (env: VirtualTypeScriptEnvironment, task: NewTask) => SourceEdit | undefined;

package/dist/modules/Functions/editor/source.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/Functions/editor/typescriptWorker.d.ts

@@ -1 +1,27 @@
+import { NewTask, SourcePlace } from './source';
+import { FunctionTimeLimits } from '@plitzi/sdk-shared';
+declare const functionsWorker: {
+    describe: () => import('./source').SourceFunctions;
+    setTaskLimits: (place: SourcePlace, limits: FunctionTimeLimits) => import('./source').SourceEdit | undefined;
+    addTask: (task: NewTask) => import('./source').SourceEdit | undefined;
+    initialize(): Promise<void>;
+    updateFile({ path, code }: {
+        path: string;
+        code: string;
+    }): void;
+    getLints({ path, diagnosticCodesToIgnore, }: {
+        path: string;
+        diagnosticCodesToIgnore: number[];
+    }): import('@codemirror/lint').Diagnostic[];
+    getAutocompletion({ path, context, }: {
+        path: string;
+        context: Pick<import('@codemirror/autocomplete').CompletionContext, "pos" | "explicit">;
+    }): Promise<import('@codemirror/autocomplete').CompletionResult | null> | null;
+    getHover({ path, pos }: {
+        path: string;
+        pos: number;
+    }): import('@valtown/codemirror-ts').HoverInfo | null | undefined;
+    getEnv(): import('@typescript/vfs').VirtualTypeScriptEnvironment;
+};
+export type FunctionsWorker = typeof functionsWorker;
 export {};

package/dist/modules/Functions/editor/useFunctionsTypeScript.d.ts

@@ -1,6 +1,6 @@
+import { NewTask, SourceEdit, SourceFunctions, SourcePlace } from './source';
 import { Extension } from '@codemirror/state';
-/** Where a file of the space's functions lives in the worker — the same root the worker keeps them under. */
-export declare const workerPathOf: (file: string) => string;
+import { FunctionTimeLimits } from '@plitzi/sdk-shared';
 /**
  * The TypeScript worker for one open panel: started from where the host serves it, given every file of the space so
  * their imports of each other resolve, and turned into the editor extensions for the file being edited. Without a
@@ -9,5 +9,8 @@ export declare const workerPathOf: (file: string) => string;
 declare const useFunctionsTypeScript: (workerUrl: string, files: Record<string, string>) => {
     ready: boolean;
     extensionsFor: (file: string) => Extension[];
+    source: SourceFunctions | undefined;
+    setTaskLimits: (place: SourcePlace, limits: FunctionTimeLimits) => Promise<SourceEdit | undefined>;
+    addTask: (task: NewTask) => Promise<SourceEdit | undefined>;
 };
 export default useFunctionsTypeScript;

package/dist/modules/Functions/helpers.d.ts

@@ -1,4 +1,6 @@
-import { FunctionsProblem } from '@plitzi/sdk-shared';
+import { SourceFunctions, SourcePlace, SourceRoute } from './editor/source';
+import { Text } from '@codemirror/state';
+import { FunctionsManifest, FunctionsProblem, FunctionTaskManifest, FunctionTimeLimits } from '@plitzi/sdk-shared';
 /** What a space's functions start as: one file and one task already written, to change rather than to learn from blank. */
 export declare const STARTER_FILES: Record<string, string>;
 /** Where a problem is, as a person reads it: `lib/feed.ts:12:4`. */
@@ -9,3 +11,119 @@ export declare const readParams: (text: string) => {
 } | {
     error: string;
 };
+/** A task's name, as a step addresses it: `seismic.feed`. */
+export declare const taskNameOf: (task: Pick<FunctionTaskManifest, "namespace" | "action">) => string;
+/** What a Try starts from: each param at the value the task declared for it — what a new step would start from. */
+export declare const paramDefaults: (task: FunctionTaskManifest | undefined) => Record<string, unknown>;
+/** A route key, read for showing: its method, and the address it answers at under `prefix`. */
+export declare const routeParts: (route: string, prefix: string) => {
+    method: string;
+    path: string;
+};
+/** How far a file or a folder is indented for each folder it is in, in pixels. */
+export declare const FILE_INDENT_PX = 12;
+/** A new file's name as typed, made a file's: trimmed, and a TypeScript one when it says nothing else. */
+export declare const newFileName: (typed: string) => string;
+/** One row of the file list: a folder, or a file under the folders before it. */
+export type FileRow = {
+    kind: 'folder';
+    path: string;
+    depth: number;
+} | {
+    kind: 'file';
+    path: string;
+    name: string;
+    depth: number;
+};
+/**
+ * The files as a tree reads, top to bottom: each folder once, before what is in it, and every name indented by how
+ * deep it is — `index.ts` first, as the file everything starts from.
+ */
+export declare const fileRows: (files: readonly string[]) => FileRow[];
+/** A param's value as a field shows it: text as it is, a number as its digits, anything else as nothing. */
+export declare const fieldText: (value: unknown) => string;
+/** Whether a key press is "save": ⌘S on a Mac, Ctrl+S elsewhere. */
+export declare const isSaveKey: (event: KeyboardEvent) => boolean;
+/** Where the files stand, in a few words and a tone: what the header shows. */
+export type SaveState = {
+    label: string;
+    tone: 'unsaved' | 'problems' | 'saved';
+};
+/**
+ * Where the files stand: what the last save found wrong, changes not saved yet — in how many files — or saved, which is
+ * what the builder runs. Nothing for a space with no functions.
+ */
+export declare const saveState: (modified: number, problems: number, saved: boolean) => SaveState | undefined;
+/**
+ * The CPU a task may ask for from the panel, in milliseconds: from the default an invocation gets to a second, in steps
+ * a person can tell apart. More than that is asked for in the code, up to what the server allows.
+ */
+export declare const TIME_LIMIT: {
+    readonly min: 100;
+    readonly max: 1000;
+    readonly step: 50;
+    readonly presets: readonly [100, 250, 500, 1000];
+};
+/** A task as the panel lists it: what the source declares right now, where, and whether a save has it yet. */
+export type ListedTask = FunctionTaskManifest & {
+    limits?: FunctionTimeLimits;
+    /** Where it is written — none while the source has not been read, when the saved list is all there is. */
+    at?: SourcePlace;
+    /** In the saved draft too: what Try can run. A task only written so far is run once it is saved. */
+    saved: boolean;
+};
+/**
+ * The tasks to list: what the source declares as it is written — so the list follows the code — or, until the source
+ * has been read, what the last save declared.
+ */
+export declare const listedTasks: (source: SourceFunctions | undefined, manifest: FunctionsManifest | null) => ListedTask[];
+/** A time as the panel says it: milliseconds under a second, seconds from one. */
+export declare const timeLabel: (ms: number) => string;
+/** What a new task is called as a step: lowercase words joined by dashes — `seismic`, `feed-week`. */
+export declare const isTaskWord: (value: string) => boolean;
+/** A step's title from its action, until somebody writes one: `feed-week` reads `Feed week`. */
+export declare const titleFromAction: (action: string) => string;
+/** A route as the panel lists it: its key, and where it is written once the source has been read. */
+export type ListedRoute = Pick<SourceRoute, 'key'> & {
+    at?: SourcePlace;
+};
+/** The routes to list: the source's as written, or — until it has been read — the last save's. */
+export declare const listedRoutes: (source: SourceFunctions | undefined, manifest: FunctionsManifest | null) => ListedRoute[];
+/** The hosts `ctx.fetch` may reach: the source's as written, or the last save's until it has been read. */
+export declare const listedHosts: (source: SourceFunctions | undefined, manifest: FunctionsManifest | null) => string[];
+/** The namespace a new task is offered: the one the tasks already share, the first one's, or none. */
+export declare const usualNamespace: (tasks: readonly ListedTask[]) => string;
+/**
+ * The CPU a task runs with, and whether it chose it: its own `limits.cpuMs`, else the one every task of the space gets
+ * from `defineFunctions`, else the server's default.
+ */
+export declare const cpuOf: (task: ListedTask, shared: FunctionTimeLimits | undefined) => {
+    ms: number;
+    asked: boolean;
+};
+/** What the run button says: running, or whether it saves first. */
+export declare const runLabel: (isRunning: boolean, needsSave: boolean) => string;
+/** A place to bring the editor to: a file's line, asked for again whenever `key` changes. */
+export type EditorTarget = {
+    file: string;
+    line: number;
+    key: number;
+    /** Whether the editor takes the keyboard too — not when the change came from a control the person is still on. */
+    focus: boolean;
+};
+/** Where a line starts and ends in a document, for line numbers that may run past its end. */
+export declare const lineRange: (doc: Text, line: number) => {
+    from: number;
+    to: number;
+};
+/** A task's time limits with its CPU set — or taken out, to run with the default — and the rest as they were. */
+export declare const withCpu: (limits: FunctionTimeLimits | undefined, cpuMs: number | undefined) => FunctionTimeLimits;
+/** Why the panel cannot write a task's limits for you right now, or nothing when it can. */
+export declare const limitsBlockedBy: (ready: boolean, task: ListedTask) => string;
+/** The task written around an offset of a file — the one the cursor is in — or none. */
+export declare const taskAt: (tasks: readonly ListedTask[], file: string, offset: number) => ListedTask | undefined;
+/** The editor filling the space it is given, so CodeMirror scrolls its own lines and keeps its gutter in place. */
+export declare const EDITOR_CLASS_NAME: {
+    root: string;
+    inputContainer: string;
+};

package/dist/modules/History/History.d.ts

@@ -1,7 +1,11 @@
+export type HistoryProps = {
+    /** Closes the dialog the history is read in, once a line has taken the author to its element. */
+    onDismiss: () => void;
+};
 /**
  * The space's change history: every save of its schema and style, by whoever made it — a person, an agent, the
  * autofix — newest first, with the published revisions marked where they fall. Read-only: it answers "what changed,
  * who did it and what exactly", and never writes anything back.
  */
-declare const History: () => import('react').JSX.Element;
+declare const History: ({ onDismiss }: HistoryProps) => import('react').JSX.Element;
 export default History;

package/dist/modules/History/components/ChangeGroup/ChangeGroup.d.ts

@@ -1,10 +1,11 @@
 import { ChangeGroup as Group } from '../../helpers';
 export type ChangeGroupProps = {
     group: Group;
+    onDismiss: () => void;
 };
 /**
  * A row of the timeline: who, from where and when, and what it did — one line per thing. Unfolded, every save it groups
  * on its own, with the fields each one changed.
  */
-declare const ChangeGroup: ({ group }: ChangeGroupProps) => import('react').JSX.Element;
+declare const ChangeGroup: ({ group, onDismiss }: ChangeGroupProps) => import('react').JSX.Element;
 export default ChangeGroup;

package/dist/modules/History/components/ChangeLine/ChangeLine.d.ts

@@ -1,10 +1,12 @@
 import { ChangeLine as Line } from '@plitzi/sdk-shared/history';
 export type ChangeLineProps = {
     line: Line;
+    /** Makes way for the element once it is on screen: the history is read in a dialog over it. */
+    onDismiss: () => void;
 };
 /**
  * One thing a save did. When it is about an element that is still in the space, the line is the way to it — the same
  * way the problems list takes someone to an element.
  */
-declare const ChangeLine: ({ line }: ChangeLineProps) => import('react').JSX.Element;
+declare const ChangeLine: ({ line, onDismiss }: ChangeLineProps) => import('react').JSX.Element;
 export default ChangeLine;

package/dist/modules/History/components/SaveDetail/SaveDetail.d.ts

@@ -1,7 +1,8 @@
 import { ChangeRecord } from '../../helpers';
 export type SaveDetailProps = {
     change: ChangeRecord;
+    onDismiss: () => void;
 };
 /** One save of a row: its number and time in a narrow column, what it did beside it, and the fields each edit changed. */
-declare const SaveDetail: ({ change }: SaveDetailProps) => import('react').JSX.Element;
+declare const SaveDetail: ({ change, onDismiss }: SaveDetailProps) => import('react').JSX.Element;
 export default SaveDetail;