tachlon 0.0.1 → 0.1.0

package/dist-lib/types/errors.d.ts

@@ -0,0 +1,33 @@
+import { PRODUCT_NAME } from "./product.ts";
+/** Every cause `mount` names, with the sentence that says what to do. */
+declare const FIXES: {
+    readonly DATA_INVALID: "Correct the fields `message` lists and call `mount` again; `validate(data)` checks plain task data against the same rules without mounting.";
+    readonly ENGINE_FETCH: "Serve the engine file (`app_bg.wasm`, the file the chart's script names with `new URL`) from the address the page asks for, with status 200; the `message` has the status.";
+    readonly ENGINE_NOT_WASM: "The address answers with something other than the engine. Serve the file `app_bg.wasm` itself, as `application/wasm`, and make a single-page fallback route skip `.wasm` files.";
+    readonly ENGINE_LOAD_FAILED: "The file is the engine, but it did not start. Rebuild so `app.js` and `app_bg.wasm` come from the same build, and read the browser console and the error in `cause` for the underlying error.";
+    readonly ENGINE_CSP: "Add `'wasm-unsafe-eval'` to the page's `script-src` (or `default-src`) in its Content-Security-Policy, so the browser may compile the engine.";
+    readonly GPU_NONE: "The browser has neither WebGPU nor WebGL2 here. Try a current Chrome, Edge, Firefox or Safari with hardware acceleration on; a headless or remote desktop session often has none.";
+    readonly FILE_UNREADABLE: "The browser could not read the `File` given as `schedule`: it was moved, deleted or is locked. Pick the file again and call `mount` again.";
+};
+export type Cause = keyof typeof FIXES;
+/** A stable name for a cause: the product name in capitals, an underscore and the cause, like `<NAME>_ENGINE_FETCH`. */
+export type ErrorCode = `${Uppercase<typeof PRODUCT_NAME>}_${Cause}`;
+/** Where the codes are explained: a heading in `docs/WASM_API.md`, the page that lists every code with its `fix`. */
+export declare const ERROR_DOCS = "docs/WASM_API.md#mount-error-codes";
+/** The code for a cause. */
+export declare function codeFor(cause: Cause): ErrorCode;
+/** The sentence that says what to do about `code`. */
+export declare function fixFor(code: ErrorCode): string;
+/** What a probe of the engine's address found: the status (`null` when the request itself threw) and the first bytes of the answer. */
+export interface EngineProbe {
+    status: number | null;
+    head: Uint8Array;
+}
+/** The code and the one line for a failed engine load, from the probe and from what `init` threw. A pure function of both. */
+export declare function engineFailure(probe: EngineProbe, thrown: unknown): {
+    code: ErrorCode;
+    message: string;
+};
+/** `GPU_NONE` when the browser has neither a WebGPU adapter (`gpu`) nor WebGL2 (`webgl2`, asked only when `gpu` is false), else `undefined`. */
+export declare function graphicsCode(gpu: boolean, webgl2: () => boolean): ErrorCode | undefined;
+export {};

package/dist-lib/types/events.d.ts

@@ -0,0 +1,80 @@
+import type { Status } from "./api.js";
+import type { PickerProject } from "./open-schedule.js";
+import type { ViewState } from "./view-state.js";
+/** What each event carries. */
+export interface GanttEvents {
+    /** The selected task changed to `task` (a row or a bar was clicked, or a key moved the selection). Clearing the selection fires nothing. */
+    select: {
+        task: number;
+    };
+    /** The schedule changed by an edit, an undo or a redo; `revision` is `Status.revision` after it. */
+    edit: {
+        revision: number;
+    };
+    /** A bar drag was released and moved `task`, whose early start is now `start` (minutes from the origin Monday). */
+    move: {
+        task: number;
+        start: number;
+    };
+    /** A file was opened in place; `epoch` is `Status.epoch` after it. */
+    open: {
+        epoch: number;
+    };
+    /** The first frame was drawn. A handler added later is still called, once. */
+    load: Record<string, never>;
+    /** The view state a toolbar shows (`Gantt.state()`) changed: a filter, the lookahead window, the row or task count, the zoom level, the selection, the move report. At most once a frame. */
+    change: ViewState;
+    /**
+     * A file could not be opened, a frame failed, or WebGPU failed and the chart started again on WebGL2 in its root (`backend`, once, with
+     * the reason); `message` is the line a person sees. `fatal`: the chart has stopped (a panic, frames that keep failing, or a switch to
+     * WebGL2 that could not start), and only a reload of the page brings it back; the host decides whether to do that.
+     */
+    error: {
+        source: ErrorSource;
+        message: string;
+        fatal: boolean;
+        projects?: readonly PickerProject[];
+    };
+    /** The chart's find key (Ctrl+F, Cmd+F) was pressed while focus was in it: a host puts focus in its find box. With a handler the browser's own find does not open. */
+    find: Record<string, never>;
+    /** The chart's status key (`s`) was pressed while focus was in it: a host shows or hides its status line. */
+    "toggle-status": Record<string, never>;
+    /** The chart's open key (Ctrl+O, Cmd+O) was pressed while focus was in it: a host shows its file chooser. With no handler the key is left to the browser. */
+    "choose-file": Record<string, never>;
+    /** The chart's keys key (`?`) was pressed while focus was in it: a host shows or hides its list of keys. */
+    "toggle-keys": Record<string, never>;
+}
+/** What an `error` event is about. */
+export type ErrorSource = "open" | "frame" | "backend";
+/** The events a key of the chart asks for: the host acts on them. */
+export type KeyRequest = "find" | "toggle-status" | "choose-file" | "toggle-keys";
+export type GanttEventName = keyof GanttEvents;
+export type GanttHandler<K extends GanttEventName> = (detail: GanttEvents[K]) => void;
+/**
+ * `Gantt.on`: call `handler` when the chart `select`s a task, `edit`s the schedule, `move`s a bar by a drag, `open`s a file, `load`s (its
+ * first frame), its view state `change`s or it reports an `error`, and when its find key asks for the host's `find` box or its status
+ * key asks to `toggle-status`. Each fires once per change, read from the loop's `Status`, never per frame. Returns the function
+ * that removes the handler. The detail of each is `GanttEvents`.
+ */
+export type On = <K extends GanttEventName>(name: K, handler: GanttHandler<K>) => () => void;
+/** The member `Gantt` takes from here. */
+export interface HasOn {
+    on: On;
+}
+export interface Events {
+    /** Call `handler` for each `name` event. Returns the function that removes it. */
+    on: On;
+    /** Fire the events `s` shows against the status before it. */
+    watch(s: Status): void;
+    /** Fire `error`; `fatal` when the chart has stopped. */
+    fail(source: ErrorSource, message: string, fatal?: boolean, projects?: readonly PickerProject[]): void;
+    /**
+     * A new app drives the chart (the switch to WebGL2): the next status is compared with nothing, so its counters fire no event, and its
+     * view state fires one `change`, since the new start's view is not the one the last `change` carried.
+     */
+    restart(): void;
+    /** Fire a key's event. True when a handler heard it, so the key is taken from the browser. */
+    request(name: KeyRequest): boolean;
+}
+/** `view` turns a frame's `Status` into the view state; it returns the same object while nothing the state carries moved. */
+export declare function createEvents(view: (s: Status) => ViewState): Events;

package/dist-lib/types/filter-names.d.ts

@@ -0,0 +1,5 @@
+import type { Status } from "./api.js";
+/** The row filter that is on, one at a time. `"status"` and `"code"` carry their values in `statusFilter` and `codeFilter`. */
+export type RowFilterName = "off" | "critical" | "longestPath" | "nearCritical" | "slipped" | "floatLost" | "joinedCritical" | "leftCritical" | "moved" | "status" | "code";
+/** The public name of a status filter name. */
+export declare const publicFilterName: (name: Status["filter"]) => RowFilterName;

package/dist-lib/types/index.d.ts

@@ -0,0 +1,92 @@
+import { type ChecksReport, type ExportResult, type LoadResult, type LoadSource } from "./document.js";
+import { type OpenOptions } from "./open-schedule.js";
+import { type Commands } from "./commands.js";
+import { type HasOn } from "./events.js";
+import { type FilterInputs, type ViewState } from "./view-state.js";
+import { PRODUCT_NAME } from "./product.js";
+import type { PlainLink, PlainTask } from "./adapters/plain.js";
+export { fromBryntum, fromDhtmlx, fromTasks, PlainDataError, validate } from "./adapters/index.js";
+export type { BryntumResult, DhtmlxOptions, DhtmlxResult, PlainIssue, PlainLink, PlainOptions, PlainResult, PlainTask, PlainValidation, ScheduleDocument } from "./adapters/index.js";
+/** What `mount` takes: a `schedule`, or `tasks` and `links` as `fromTasks` reads them. */
+export interface MountOptions {
+    /** A schedule file to read (XER or MS Project XML, every project of it, or a `.gantt` document), or the demo or the stress fixture at `n` tasks. */
+    schedule?: File | {
+        demo: number;
+    } | {
+        stress: number;
+    };
+    /** Plain tasks to draw when there is no `schedule`, and the links between them (`fromTasks`). */
+    tasks?: PlainTask[];
+    links?: PlainLink[];
+    /** The licence key; the root's `data-<product>-license` reads `"licensed"` or `"trial"`. A local page is always licensed; a chart that reads `"trial"` shows a small "Unlicensed" mark and works as before. */
+    licenseKey?: string;
+    /** Draw with WebGL2 and never try WebGPU. Without it a WebGPU failure switches the chart to WebGL2 in its root, and `on("error")` says so. */
+    forceWebgl?: boolean;
+    /** Where to fetch the engine file (`app_bg.wasm`) from, a URL or an address read against the page's own. Without it the chart loads the file beside its script (`dist-lib/app_bg.wasm`). When `preloadEngine` already started the load, its `wasmUrl` is the one used. */
+    wasmUrl?: string | URL;
+}
+/** What `mount` returns: the chart, as a host page may drive it. */
+export interface Gantt extends HasOn {
+    /**
+     * Replace the schedule with `file`. Resolves when the attempt has ended; a file that cannot be opened is an `error` event (source `"open"`), not a throw.
+     * `expectedNotes` are the beginnings of import notes the host knows its own file will report (a generated sample): a line that
+     * starts with one is left out of `ViewState.importNotes`. `window.gantt.unsupported` still holds every line the reader reported.
+     * A file with several projects stops at their list, which the `error` event carries as `projects`; `project` (an id from that list, or `"all"`) opens it.
+     */
+    open(file: File, options?: OpenOptions): Promise<void>;
+    /**
+     * Download the open schedule as a schedule document (gzipped JSON), named after the opened file with `.gantt`, `untitled.gantt`
+     * for a sample. Never writes over the opened file. Resolves once the download has started; it does not wait for the file to be
+     * written. It clears the unsaved mark beside the file name, as of the schedule when the save began. The write runs on the main thread.
+     */
+    save(): Promise<void>;
+    /** Download the visible list as `<name>.csv` (`untitled.csv` for a sample), the rows and columns Ctrl+C copies, as the hosted file menu's "Export the list as CSV". */
+    exportCsv(): void;
+    /** Download a picture of the first printed page as `<name>.png` (`untitled.png` for a sample): 2112 by 1632 pixels, drawn from `App.print_pages` without the chart's canvas. Resolves once the download has started. */
+    exportImage(): Promise<void>;
+    /**
+     * Replace the schedule with a document (the JSON `toDocument` returns) or a file (XER, MS Project XML, or a gzipped document). Resolves
+     * `{ ok: true }`, or `{ ok: false, error }` with the schedule as it was: a bad source is a result, never a throw. Unsaved edits are
+     * replaced without asking.
+     */
+    load(source: LoadSource): Promise<LoadResult>;
+    /** The open schedule as a document, the JSON that `save` writes (gzipped) and `load({ document })` reads. Reads the session and changes nothing. */
+    toDocument(): unknown;
+    /** The open schedule as a P6 XER file: `bytes` and `leftOut`, one line for each thing the file cannot carry. Throws when a date cannot be written. */
+    exportXer(): ExportResult;
+    /** The open schedule as an MS Project XML file, as `exportXer` returns it. */
+    exportMspdi(): ExportResult;
+    /** The schedule-quality counts of the open schedule, as the Checks panel lists them: no pass or fail, just the counts. Reads the session and changes nothing; ask it when the panel opens, not every frame. */
+    checks(): ChecksReport;
+    /** The backend that is drawing: `"WebGL2"` once a WebGPU failure has switched the chart. */
+    backend(): "WebGPU" | "WebGL2";
+    /** The view state a toolbar shows: the filters, the lookahead window, the row and task counts, the zoom level, the selection, the move report and the backend. `on("change")` fires when it changes. */
+    state(): ViewState;
+    /** What the filter controls offer: the activity codes, whether tasks have activity IDs, whether the baseline holds float. Read it again after an `open`, an `edit`, or a `change` whose `baseline` moved. */
+    filterInputs(): FilterInputs;
+    /** Whether a cell is being edited or a bar or link is being pressed or dragged: the edit commands refuse then (`"busy"`). It has no event; ask it when a command needs to. */
+    busy(): boolean;
+    /**
+     * Take the chart down: stop the frame loop, remove what it put on `window`, `document` and the media queries, disconnect its observers,
+     * free the WASM app (which lets the GPU device go) and empty the root. Safe to call twice. Every other method throws once it has run
+     * (`open` and `save` reject), and a call already waiting on the app, such as an `open` that has not resolved, is not waited for.
+     */
+    destroy(): void;
+    commands: Commands;
+}
+export type { Commands, ScrollTarget } from "./commands.js";
+export type { GanttEvents } from "./events.js";
+export type { OpenOptions, PickerProject } from "./open-schedule.js";
+export type { CompareResult, EditRefusal, EditResult, LinkResult, Refusal, RowResult } from "./edit-result.js";
+export type { Filter, PlainFilter } from "./set-filter.js";
+export type { CodeValue, FilterInputs, RowFilterName, StatusKind, ViewState, ZoomLevel } from "./view-state.js";
+export { MountError, preloadEngine } from "./mount-load.js";
+export { PRODUCT_NAME };
+/**
+ * Start the chart in `root`: the page gives a `div` with the class `gantt` and a box with a height, and the chart
+ * puts its own elements inside it, with ids of their own, so a page may hold several charts; its stylesheets come
+ * with this module. Rejects with a `MountError` (a `code`, a `fix` and `docs` when the cause is known) when the engine cannot load, the schedule cannot be read or the first frame cannot be set up; any
+ * other failure is a bug and is thrown as it is. A WebGPU failure, at the start or in a later frame, starts the
+ * chart again on WebGL2 in the same root with the same schedule (`webgl-switch.ts`); the page is never reloaded.
+ */
+export declare function mount(root: HTMLDivElement, options: MountOptions): Promise<Gantt>;

package/dist-lib/types/mount-load.d.ts

@@ -0,0 +1,30 @@
+import { type ErrorCode } from "./errors.js";
+import type { MountOptions } from "./index.js";
+/** Why `mount` could not start the chart: `stage` is where it failed, and `message` is one line for a person. */
+export declare class MountError extends Error {
+    readonly stage: "engine" | "schedule" | "render";
+    /** A stable name for the cause when there is one (`errors.ts` lists them); `fix` says what to do about it and `docs` where it is explained. */
+    readonly code?: ErrorCode;
+    readonly fix?: string;
+    readonly docs?: string;
+    constructor(stage: "engine" | "schedule" | "render", message: string, options?: ErrorOptions & {
+        code?: ErrorCode;
+    });
+}
+/** The render `MountError` for a failed start. In a browser with no WebGPU adapter and no WebGL2 it is `GPU_NONE`, whatever the engine's own message says; the probes run only on this failure path. */
+export declare function renderError(message: string, cause: unknown): Promise<MountError>;
+/** A host page's inline script may start `WebAssembly.compileStreaming` on the engine's response and keep the promise here, so the compile does not wait for this module to load (gs#1354). */
+declare global {
+    interface Window {
+        __engineModule?: Promise<WebAssembly.Module>;
+    }
+}
+/** Start loading the engine, or join the load already started: a host page calls it first thing, so the file downloads and compiles while the page reads its data (gs#1336). Settles with no value when the engine has loaded. */
+export declare function preloadEngine(options?: Pick<MountOptions, "wasmUrl">): Promise<void>;
+/** What a chart starts on: the schedule `mount` was given (`undefined` for its `tasks` and `links`), or the document of the one it held when it switched to WebGL2. */
+export type StartSource = MountOptions["schedule"] | {
+    document: unknown;
+} | {
+    tasks: MountOptions["tasks"];
+    links: MountOptions["links"];
+};

package/dist-lib/types/open-schedule.d.ts

@@ -0,0 +1,81 @@
+/** The largest file the page reads. A larger one gets a message and is not read at all. */
+export declare const MAX_OPEN_BYTES: number;
+/**
+ * Where the time of one open went, in milliseconds on `performance.now()`. The phases are back to back and do
+ * not overlap, so `read + paint + copy + parse + build + compute + swap + firstFrame` is `total` (up to the
+ * rounding of the clock). `parse`, `build` and `compute` are `LoadedSchedule.timings()`; the rest are the page's.
+ * A value that is not a finite number, or is negative, is an invalid measurement: it is kept as it is (NaN stays
+ * NaN, a negative stays negative), never turned into 0, and `measure.mjs` rejects the open that holds it.
+ */
+export interface OpenTimings {
+    /** The change or drop event to `file.arrayBuffer()` resolved. */
+    read: number;
+    /** The wait that lets "Opening…" paint before the parse, which does not yield: one frame and a task. */
+    paint: number;
+    /**
+     * The call to `parse_bytes` minus its three Rust phases: the copy of the bytes into linear memory, building the
+     * result, and the clock calls around the phases. It is a remainder, so it would absorb a wrong Rust phase; the
+     * check that does not is `rustSpan` against the phases. Not clamped: a negative `copy` is an invalid measurement.
+     */
+    copy: number;
+    /** Detect the format, read the file, map it into the engine schedule (Rust). */
+    parse: number;
+    /** The display data, the outline and the engine schedule (Rust). */
+    build: number;
+    /** The solve, the row order and the in-progress date check (Rust). */
+    compute: number;
+    /** `parse_bytes` returned to `App.open` returned, with the reads of the result in between. */
+    swap: number;
+    /** `App.open` returned to the first frame submitted after it (the first increment of `Status.frames`); not the display's vblank. */
+    firstFrame: number;
+    /** The event to the first frame. */
+    total: number;
+    /**
+     * Rust's first to last clock read of `load_bytes`: the same reads that bound the three phases, so it equals
+     * `parse + build + compute` up to float rounding however long the process was paused between two reads (gs#248).
+     * It is not a phase and not part of `total`, and `measure.mjs` rejects an open where it differs by 3 ms or more.
+     */
+    rustSpan: number;
+}
+/** What the page records about a successful open. */
+export interface OpenedFile {
+    name: string;
+    bytes: number;
+    /** "xer" or "mspdi", chosen by the file's content, never its name. */
+    format: string;
+    /** Tasks in the schedule, summary rows included. */
+    tasks: number;
+    /**
+     * Only for a file with several projects: the milliseconds the first pass took (the read and the parse that
+     * stopped at the project list). The open that counts starts when the person chooses.
+     */
+    probeMs?: number;
+    /**
+     * Set at the first frame after the swap, on this same object, so it is missing for the moment between the swap
+     * and that frame (and for good if a newer open replaces this one first).
+     */
+    timings?: OpenTimings;
+}
+/** One row of the project list a multi-project XER file carries on its `ChooseProject` error. */
+export interface PickerProject {
+    /** The P6 `proj_id`, as the text `parse_bytes` takes for `selection`. */
+    id: string;
+    name: string;
+    activities: number;
+}
+/** The projects of a `ChooseProject` error, or null for any other thrown value. */
+export declare function chooseProjects(err: unknown): PickerProject[] | null;
+/** What `Gantt.open` takes: the notes the host expects, and the project of a file with several (`"all"` for every one). */
+export interface OpenOptions {
+    expectedNotes?: readonly string[];
+    project?: string;
+}
+export interface OpenControls {
+    /**
+     * Open `file`: the size limit, the messages, the project list and the `open` event. Resolves when that open has ended (a file
+     * with several projects ends it at the project list, which the `error` event carries); a failure is an `error` event, never thrown.
+     */
+    openFile(file: File, options?: OpenOptions): Promise<void>;
+    /** Call once per frame, after `App.frame()`, with `Status.frames`; it completes the timings of the last open at the first new frame. */
+    frame(frames: number): void;
+}

package/dist-lib/types/product.d.ts

@@ -0,0 +1,2 @@
+/** The product's name, as a person sees it in the tab, the toolbar and the hosted page. */
+export declare const PRODUCT_NAME = "Tachlon";

package/dist-lib/types/react.d.ts

@@ -0,0 +1,32 @@
+import { type CSSProperties, type JSX } from "react";
+import { type GanttEvents, type MountOptions } from "./index.js";
+/** The prop that takes each event of `Gantt.on`. */
+declare const EVENTS: {
+    readonly select: "onSelect";
+    readonly edit: "onEdit";
+    readonly move: "onMove";
+    readonly open: "onOpen";
+    readonly load: "onLoad";
+    readonly change: "onChange";
+    readonly error: "onError";
+    readonly find: "onFind";
+    readonly "toggle-status": "onToggleStatus";
+    readonly "choose-file": "onChooseFile";
+    readonly "toggle-keys": "onToggleKeys";
+};
+/**
+ * The mount options, one prop each, and a callback for each event: `onSelect({ task })`, `onMove({ task, start })` and the rest of `GanttEvents`.
+ * A handler is called with the latest function the component was given. A handler for `find` or `choose-file` takes that key from the browser,
+ * as `Gantt.on` does, so give one only when the app answers the key. The chart mounts again when `schedule`, `tasks`, `links`, `licenseKey` or
+ * `forceWebgl` changes (compared by reference, as a hook's dependencies are), so keep `tasks` and `links` stable between renders.
+ * `className` and `style` are the chart's root, where the theme tokens go; the root has no size of its own, so give it one. The page imports
+ * the chart's stylesheet. A start that fails is thrown while rendering, for an error boundary.
+ */
+export type GanttProps = MountOptions & {
+    className?: string;
+    style?: CSSProperties;
+} & {
+    [K in keyof GanttEvents as (typeof EVENTS)[K]]?: (detail: GanttEvents[K]) => void;
+};
+export declare function Gantt(props: GanttProps): JSX.Element;
+export {};

package/dist-lib/types/set-filter.d.ts

@@ -0,0 +1,20 @@
+import { type RowFilterName } from "./filter-names.js";
+import type { CodeValue, StatusKind } from "./view-state.js";
+/** The row filters that take no value. */
+export type PlainFilter = Exclude<RowFilterName, "status" | "code">;
+/**
+ * What `Commands.setFilter` takes. A row filter replaces the one that is on; `"off"` turns the row filter off. `{ status }` and
+ * `{ code }` are the row filters that take a value. `{ lookahead }` sets the window (a day `YYYY-MM-DD` and 1 to 520 weeks) or,
+ * with null, removes it; the window combines with the row filter and leaves it as it is. `setFilter(state().filter)` does not
+ * type-check for `"status"` and `"code"` by design: those two need their value (`{ status }`, `{ code }`).
+ */
+export type Filter = PlainFilter | {
+    status: StatusKind;
+} | {
+    code: CodeValue;
+} | {
+    lookahead: {
+        start: string;
+        weeks: number;
+    } | null;
+};

package/dist-lib/types/view-state.d.ts

@@ -0,0 +1,95 @@
+import type { Status } from "./api.js";
+import { type RowFilterName } from "./filter-names.js";
+export type { RowFilterName } from "./filter-names.js";
+/** The time axis's unit at the current zoom. */
+export type ZoomLevel = "hour" | "day" | "week" | "month" | "year";
+/** The task states the Status filter keeps. */
+export type StatusKind = "in-progress" | "not-started" | "complete";
+/** An activity code type and one of its values, as `filterInputs().activityCodes` lists them. */
+export interface CodeValue {
+    type: string;
+    value: string;
+}
+/** What `Gantt.state()` returns and the `change` event carries. Frozen: a host reads it, the chart never changes it. */
+export interface ViewState {
+    /** The row filter that is on, `"off"` for none. */
+    filter: RowFilterName;
+    /** The Status filter's state while `filter` is `"status"`, else null. */
+    statusFilter: StatusKind | null;
+    /** The activity code filter while `filter` is `"code"`, else null. */
+    codeFilter: CodeValue | null;
+    /** The lookahead window, which combines with the row filter. While `on` is false, `start` and `weeks` are what turning it on would use. */
+    lookahead: {
+        on: boolean;
+        start: string;
+        weeks: number;
+    };
+    /** The rows the filters and the collapsed summaries leave. */
+    rowCount: number;
+    /** The activities (leaf tasks) the row filter and the lookahead window keep, or null while neither is on. */
+    activityCount: number | null;
+    /** The live tasks of the schedule, rows or not. */
+    taskCount: number;
+    /** The time axis's unit at this zoom. */
+    zoomLevel: ZoomLevel;
+    /** The selected task with the counts of its driving predecessors and driven successors, or null. */
+    selection: {
+        task: number;
+        backCount: number;
+        forwardCount: number;
+    } | null;
+    /**
+     * The last edit's report of what it moved, or null: `others` is the number of tasks besides the edited one whose early start or
+     * finish changed, `finishDays` the calendar days the project finish moved (negative when earlier). `id` tells one report from the
+     * next and means nothing else. A host words the report itself; the chart's own sentence is not part of the API.
+     */
+    moved: {
+        id: number;
+        others: number;
+        finishDays: number;
+    } | null;
+    /** The data date, the day written `YYYY-MM-DD` (a file's time of day is not in it), or null with none. `commands.setDataDate` takes the same form. */
+    dataDate: string | null;
+    /** The data date's instant as the toolbar shows it, `YYYY-MM-DD HH:MM` (`2024-01-10 08:00`), or null with none. */
+    dataDateTime: string | null;
+    /**
+     * The baseline, or null with none: `rows` is the number of tasks it holds, `dataDate` the data date's day when it was set (`YYYY-MM-DD`),
+     * null if there was none, `dayText` that same day as the chart writes it (`14 Oct`, the form of the Baseline button's title), null if
+     * there was none, `slipped` the tasks whose early finish is now later than the baseline's, and `added` the live tasks it has no entry for
+     * (inserted since it was set), which "Add new" gives their current dates.
+     */
+    baseline: {
+        rows: number;
+        dataDate: string | null;
+        dayText: string | null;
+        slipped: number;
+        added: number;
+    } | null;
+    /** The backend that is drawing. */
+    backend: "WebGPU" | "WebGL2";
+    /** The name of the file opened in place (`one-project.xer`), or null for a sample or a schedule loaded with `load({ document })`. A mount with a File and `load({ file })` give that file's name. */
+    fileName: string | null;
+    /** True after an edit, undo or redo since the last open or save: the mark beside the file name. */
+    unsaved: boolean;
+    /** The import notes the panel lists: always what it shows (after a mount, an open, a load and a restart on WebGL2), the reader's lines without the ones `expectedNotes` names. Frozen. */
+    importNotes: readonly string[];
+}
+/** What the chart knows of the open file; the reader compares these with the last state it built. */
+export interface OpenFacts {
+    fileName: string | null;
+    unsaved: boolean;
+    importNotes: readonly string[];
+}
+/** What `Gantt.filterInputs()` returns: what the filter controls offer. It changes with an open (`open`), an edit (`edit`) and a baseline set, cleared or added to, which fires no `edit`: a `change` whose `baseline` is a new object. */
+export interface FilterInputs {
+    /** The activity code types the tasks carry, each with its values, by name: `[type, values]`. Empty for a file with none. */
+    activityCodes: [string, string[]][];
+    /** Whether any task has an activity ID (the table then shows the ID column). */
+    hasCodes: boolean;
+    /** Whether the baseline holds float, which the `"floatLost"` filter compares with: false with no baseline or one read from a file. */
+    baselineHasFloat: boolean;
+}
+export interface ViewStateReader {
+    /** The view state `s` shows: the object `read` returned last when nothing it carries moved, else a new frozen one. */
+    read(s: Status): ViewState;
+}

package/package.json

@@ -1,9 +1,65 @@
 {
   "name": "tachlon",
-  "version": "0.0.1",
-  "description": "Tachlon: a fast, beautiful Gantt scheduling component by Inner Stack Labs. Name reserved; coming soon.",
-  "homepage": "https://tachlon.com",
-  "author": "Inner Stack Labs",
+  "version": "0.1.0",
   "license": "UNLICENSED",
-  "files": ["README.md"]
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/innerstacklabs/gantt.git",
+    "directory": "packages/gantt"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "bin": {
+    "tachlon": "./dist-lib/cli/main.js"
+  },
+  "files": [
+    "dist-lib"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist-lib/types/index.d.ts",
+      "default": "./dist-lib/tachlon.js"
+    },
+    "./react": {
+      "types": "./dist-lib/types/react.d.ts",
+      "default": "./dist-lib/react.js"
+    },
+    "./gantt.css": "./dist-lib/gantt.css",
+    "./schema.json": "./dist-lib/schema.json"
+  },
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "packageManager": "pnpm@11.25.0",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "build:lib": "vite build --config vite.lib.config.ts && node ../../scripts/emit-types.ts . && node ../../scripts/emit-engine-size.ts . && tsc -p tsconfig.cli.json",
+    "docs:api": "api-extractor run && api-documenter markdown -i dist-docs/model -o dist-docs/pages",
+    "docs:book": "node ../../scripts/emit-types.ts . && pnpm docs:api",
+    "docs:check": "node ../../scripts/test-api-docs-check.ts && pnpm docs:api && node ../../scripts/api-docs-check.ts dist-docs/model/package.api.json",
+    "preview": "vite preview",
+    "typecheck": "tsc --noEmit && oxlint .",
+    "test:e2e": "playwright test"
+  },
+  "devDependencies": {
+    "@microsoft/api-documenter": "7.30.20",
+    "@microsoft/api-extractor": "7.60.1",
+    "@playwright/test": "1.64.1",
+    "@types/node": "22.20.5",
+    "@types/react": "19.3.0",
+    "@types/react-dom": "19.3.0",
+    "oxlint": "1.91.0",
+    "react": "19.3.1",
+    "react-dom": "19.3.1",
+    "typescript": "7.0.2",
+    "vite": "8.3.4"
+  }
 }