@thatopen/services 0.5.0 → 0.7.0

package/dist/built-in/index.d.ts

@@ -941,6 +941,575 @@ export type FileList = InstanceType<typeof _FileList>;
 export declare const FileList: typeof _FileList & {
     uuid: "b0b5e2a2-0b3a-4a6b-8b1c-0b1c4a6b8b1c";
 };
+/** One element mutation inside a revit-flow commit. */
+export interface RevitFlowChange {
+    /** create → element added, update → geometry/data changed, delete → removed. */
+    type: "create" | "update" | "delete" | string;
+    /** Revit UniqueId (GUID). Resolves to a fragments localId via getLocalIdsByGuids. */
+    uniqueId: string;
+}
+/** Per-commit change tallies, mirrored from the add-in's `counts` block. */
+export interface RevitFlowCounts {
+    added: number;
+    modified: number;
+    removed: number;
+}
+/**
+ * A revit-flow commit — one push of changes from the Revit add-in. `id` is a
+ * monotonic integer; `parent` points at the previous commit (null for the
+ * root). The first commit is the baseline: its geometry IS the visible model
+ * file. Later commits carry only their delta geometry, in a HIDDEN .frag whose
+ * id is `deltaId`.
+ */
+export interface RevitFlowCommit {
+    /**
+     * WHAT this commit is. Identity, minted by whoever wrote it, meaningful outside the model it
+     * belongs to — which the old integer was not: that was the platform's storage version, a number
+     * the CDE handed out. An application that does not push through a Revit central has no such
+     * number, and an integer sequence asserts one line of history, which Revit's central enforces and
+     * nothing else has to.
+     */
+    guid: string;
+    /**
+     * The commits this one was built on. Absent on a root.
+     *
+     * A LIST, because a history that can only ever be a line is a different thing from a graph. A
+     * fork was already expressible with a single parent — two commits naming the same one — but a
+     * MERGE means naming both lines, and that needs this. The first entry is the line the commit
+     * continues, which is what lets the panel lay out lanes without guessing which side is the trunk.
+     *
+     * Revit never writes more than one: its central IS a single line and it merges inside itself
+     * rather than in this graph. The list is for the applications that are not Revit.
+     */
+    parents?: string[] | null;
+    /**
+     * WHERE this landed in the CDE, when there is such a place. Data, never identity, and never shown
+     * as the commit's name. Absent for any application with no version counter.
+     */
+    version?: number;
+    /**
+     * Position in this model's history, computed from the parent chain when the commits are read.
+     *
+     * Order questions — "is this commit before the one on screen?" — used to be asked of the integer
+     * id, which meant every application had to produce a sequence to be understood. They are asked of
+     * this instead: derived from the graph, so an application that has no numbers still answers them.
+     */
+    ordinal: number;
+    /**
+     * What the author said this commit was for, in their own words. Absent when nobody said
+     * anything, which is most commits.
+     *
+     * In Revit it comes from the Comment box in its own Synchronize with Central dialog, which
+     * people have been typing into for years while it went nowhere. Free text: never parsed, never
+     * relied on for structure.
+     */
+    message?: string;
+    author: string;
+    source: string;
+    timestamp: string;
+    changes: RevitFlowChange[];
+    counts: RevitFlowCounts;
+    /**
+     * Hidden-file id of this commit's delta .frag (created+modified geometry).
+     * Absent on the baseline/first commit and on geometry-less commits. The
+     * platform's hidden-file API has no queryable name, so the delta is loaded by
+     * this id, never by filename.
+     */
+    deltaId?: string;
+    /**
+     * Platform user id of the committer, recorded by the add-in from its API key. Lets the
+     * UI resolve the author to a real project member (avatar + name) via getProjectData,
+     * instead of deriving initials from the raw Revit username. Absent on history written
+     * before this was recorded, or when the key isn't a readable JWT.
+     */
+    userId?: string;
+    /**
+     * Which loaded model this commit belongs to (the model file's id == the viewer's
+     * modelId). Tagged in by the manager when it reads the history: commit ids are
+     * per-model version numbers, so they repeat across models and can't identify a commit
+     * on their own.
+     */
+    modelId?: string;
+    /** The model's name AS SHOWN IN PROJECT FILES, for the cards and the model filter. */
+    modelName?: string;
+    /**
+     * This commit re-exported the WHOLE model, so the project's visible .frag shows the
+     * model as of here — what anyone opening it from Project Files gets, without the
+     * history panel. True for the initial capture and for the periodic full exports the
+     * team publishes; ordinary commits ship only their delta.
+     */
+    full?: boolean;
+    /**
+     * Interoperability operations this commit materialised. Present only when somebody in
+     * Revit pulled a deferred edit: the commit is the native half of it, and this is the
+     * link back to the operation that asked for it. Ordinary hand-authored commits, which
+     * are nearly all of them, carry no such key at all.
+     */
+    appliedOps?: string[];
+    /**
+     * Set when this entry is NOT a commit but a deferred edit still waiting to be applied.
+     *
+     * Pending operations are surfaced commit-SHAPED rather than as a parallel kind of thing, so
+     * they inherit search, the user and model filters, the change-kind chips and the
+     * filter-by-selection behaviour instead of needing all of it reimplemented. It also means
+     * one of them can be clicked and previewed: a `modify` or `delete` names elements that
+     * already exist, which is exactly what the outline machinery consumes, so you can see what
+     * a change will touch before anybody applies it. A `create` has nothing to show yet, which
+     * is honest rather than missing.
+     *
+     * Everything that treats an entry as history must check this first: it has not happened.
+     */
+    pendingOp?: RevitFlowOp;
+}
+/** Shape of `revitflow_history.json`. */
+export interface RevitFlowHistory {
+    model: string;
+    commits: RevitFlowCommit[];
+}
+/**
+ * One deferred edit waiting to be applied to a model.
+ *
+ * Operations are NOT commits and do not live in the graph: a commit is immutable past, an
+ * operation is optional future. They sit above the model's HEAD until somebody opens the
+ * model in Revit and applies one, at which point they become a commit and stop being
+ * pending. Mirrors the add-in's `revitflow_ops.json`.
+ */
+export interface RevitFlowOp {
+    opId: string;
+    /** Groups the operations one authored action produced across several models. */
+    batchId?: string;
+    /** Hidden-file id of the operation's .frag payload. */
+    fragId?: string;
+    title?: string;
+    /** add | set | remove | mixed. Older queues say modify | create | delete. */
+    verb?: string;
+    author?: string;
+    /**
+     * Platform user id of whoever authored it. Resolved to a real project member exactly as a
+     * commit's is, so the same person does not appear as "Antonio That Open" on their commits
+     * and as their raw OS username on their operations.
+     */
+    userId?: string;
+    createdAt?: string;
+    /** The commit this operation was authored against. */
+    /** The commit this was authored against, by guid. What a proposal actually refers to. */
+    baseCommitGuid?: string;
+    /** The platform version that commit landed in. Data, for reconciling with the CDE. */
+    baseCommit?: number;
+    /** How many elements it targets. */
+    targets?: number;
+    state?: "pending" | "applied" | "discarded" | string;
+    /** The native commit that materialised it, once applied. */
+    appliedInCommit?: number | null;
+    /**
+     * Native ids the operation actually touched or created, written by the add-in when it applied.
+     * A FLAT list: it does not say which source object produced which result, because nothing in
+     * this system ties an element to an element in another application.
+     *
+     * It is what lets an APPLIED proposal be selected and previewed like a commit, with no payload
+     * fetch at all. Note which halves that leaves blind, because they are opposite ends:
+     *
+     *   add     pending → nothing exists yet   ·  applied → these are what it made
+     *   set     pending → its targets          ·  applied → the same targets
+     *   remove  pending → its targets          ·  applied → nothing, they are gone
+     *
+     * So the only case still needing the payload is a PENDING set or remove, whose target ids live
+     * in the operation's .frag rather than in this index.
+     */
+    affectedIds?: string[];
+    /** Tagged in by the manager, exactly as commits are: which model this queue belongs to. */
+    modelId?: string;
+    modelName?: string;
+}
+/** Shape of `revitflow_ops.json`. */
+export interface RevitFlowOpsIndex {
+    schema?: string;
+    ops: RevitFlowOp[];
+}
+/** Dominant change type of a commit, used to color its timeline node. */
+export type DominantChange = "create" | "update" | "delete";
+/** What to do with elements outside the selected commit. */
+export type ContextMode = "default" | "hidden";
+/** The three kinds of change a commit can carry. */
+export type ChangeKind = "create" | "update" | "delete";
+/**
+ * Stable id for a commit across models — which is now just its guid.
+ *
+ * It used to have to be `${model}:${id}`, because the id was a per-model version number and every
+ * model had a commit 3. A guid needs no help being unique, and that is exactly what it was for.
+ */
+export declare const commitKey: (c: {
+    guid?: string;
+    pendingOp?: {
+        opId: string;
+    };
+}) => string;
+/** How the commit is shown in 3D: review colours, or the model as it ended up. */
+export type HighlightMode = "colored" | "plain";
+/** Dominant change type of a commit: delete → create → update. */
+export declare function dominantChange(commit: RevitFlowCommit): DominantChange;
+/**
+ * GitHistoryManager — headless engine for the revit-flow git-history built-in.
+ *
+ * Owns ALL viewer mutation for the change outlines. It does NOT load the model —
+ * the user opens a model from the Project Files panel, and this manager reacts to
+ * that load: it reads the model's hidden `revitflow_history.json` (if any) and
+ * publishes the commit list. Showing a commit outlines its changed elements
+ * (create → green, update → blue, delete → red) via three independently-colored
+ * `OBF.Outliner` groups — a cheap post-process outline that never recolors the
+ * fragment geometry. The Lit panel (`top-git-history`) is intent-only: it calls
+ * these methods and subscribes to the events below.
+ *
+ * Data model, per loaded model (fileId == modelId), all HIDDEN children of it:
+ *   - revitflow_history.json — { model, commits: [{ id, parent, author, source,
+ *       timestamp, changes:[{type,uniqueId}], counts }] }. The first commit is the
+ *       INITIAL full-model capture (its geometry == the visible baseline file).
+ *   - revitflow_frag_<N>.frag — delta fragments for commit N (its created+modified
+ *       geometry), loaded on demand so created elements can be colored.
+ */
+declare class _GitHistoryManager extends OBC.Component {
+    static readonly uuid: "3f9c1a7e-6b2d-4e18-9a5c-7d0e2f4b6c81";
+    enabled: boolean;
+    readonly onCommitsChanged: OBC.Event<RevitFlowCommit[]>;
+    /** {@link commitKey} of the highlighted commit, or null when cleared. */
+    readonly onCommitChanged: OBC.Event<string | null>;
+    readonly onLoadingChanged: OBC.Event<boolean>;
+    readonly onError: OBC.Event<string>;
+    /** The GUID currently selected in the 3D view (null when the selection is cleared). */
+    readonly onSelectedGuidChanged: OBC.Event<string | null>;
+    world?: OBC.World;
+    /**
+     * What happens to elements that are NOT part of the selected commit:
+     *   "default" — left as they are (the change outlines sit on the full model)
+     *   "hidden"  — hidden entirely, isolating the commit's elements
+     *
+     * A dimmed ("ghost") middle ground was dropped: the fragments x-ray writes depth
+     * from the pixels its screen door keeps, so dimmed geometry still occluded the very
+     * elements under review — worse the denser the model in front. Fixing that properly
+     * belongs in the renderer, not here, so this offers the two states that are exact.
+     */
+    contextMode: ContextMode;
+    /**
+     * Which change kinds to outline. All three by default; the panel's filter buttons
+     * narrow it (e.g. only deletions) without reloading anything.
+     */
+    typeFilter: Set<ChangeKind>;
+    /**
+     * How many commits either side of the selected one to keep pre-loaded, so stepping
+     * through the timeline is instant instead of fetching on every click. The window
+     * slides with the selection and everything outside it is disposed, which bounds
+     * memory no matter how long the history gets.
+     */
+    prefetchRadius: number;
+    /**
+     * How a commit is presented in 3D:
+     *   "colored" — outline created/edited/deleted in their colours (the review lens)
+     *   "plain"   — no outlines: the model simply as it stood AFTER the commit, so the
+     *               deleted elements are hidden rather than painted red
+     */
+    highlightMode: HighlightMode;
+    /** @deprecated kept so older callers still compile — maps onto contextMode. */
+    get isolateChanges(): boolean;
+    /** Green — created elements. */
+    readonly COLOR_CREATED = "#22c55e";
+    /** Golden yellow — modified elements. */
+    readonly COLOR_MODIFIED = "#e3b341";
+    /** Red — deleted elements. */
+    readonly COLOR_DELETED = "#ef4444";
+    readonly GROUP_CREATED = "revitflow-created";
+    readonly GROUP_MODIFIED = "revitflow-modified";
+    readonly GROUP_DELETED = "revitflow-deleted";
+    private _client?;
+    private _projectId?;
+    /**
+     * One entry per loaded revit-flow model. Commit ids are per-model version numbers, so
+     * they collide across models — every commit is tagged with its modelId and a commit is
+     * addressed by {@link commitKey}, never by id alone.
+     */
+    private _models;
+    /** Which models the timeline shows. Empty = all of them. */
+    private _selectedModels;
+    /** `${modelId}:${id}` of the commit currently highlighted, or null. */
+    private _currentKey;
+    /** modelIds already probed for a sibling history (avoids re-probing). */
+    private _probed;
+    /** hiddenIds of delta frags this manager has loaded into the viewer. */
+    private _loadedDeltas;
+    /** Ghosted localIds per modelId, so isolate can be cleared/re-applied. */
+    private _contextApplied;
+    /** localIds hidden because the shown commit deleted them (plain mode). */
+    private _hiddenDeleted;
+    /** localIds hidden because a newer visible source supplies the same element. */
+    private _hiddenSuperseded;
+    /** True once the three named Outliner groups have been created. */
+    private _groupsReady;
+    private _loading;
+    private _wired;
+    constructor(components: OBC.Components);
+    get ready(): boolean;
+    get loading(): boolean;
+    /**
+     * Commits of the selected models, newest last, interleaved by time so a multi-model
+     * timeline reads chronologically rather than model-by-model.
+     */
+    get commits(): RevitFlowCommit[];
+    /** True when this entry is a proposal rather than something that happened. */
+    isProposal(commit: RevitFlowCommit | null | undefined): boolean;
+    /**
+     * The entry a proposal/commit links to, in whichever direction applies: a commit points at
+     * the proposal it materialised, a proposal at the commit that did it. Returns null when
+     * there is no counterpart, which is the normal case for hand-authored work.
+     */
+    counterpart(commit: RevitFlowCommit): RevitFlowCommit | null;
+    /**
+     * Deferred edits still waiting to be applied, across the selected models, oldest first.
+     *
+     * Kept separate from {@link commits} on purpose. A commit is something that happened; a
+     * pending operation is something that might. Merging them into one list would force every
+     * consumer to keep asking which kind it was holding.
+     */
+    get pendingOps(): RevitFlowOp[];
+    /** The loaded revit-flow models, for the panel's model filter. */
+    get models(): Array<{
+        modelId: string;
+        name: string;
+        commits: number;
+    }>;
+    get selectedModels(): Set<string>;
+    get currentKey(): string | null;
+    /** Name of the single loaded model, or "" when there are none/several. */
+    get modelName(): string;
+    /** The commit behind {@link currentKey}, or undefined when nothing is highlighted. */
+    private _currentCommit;
+    /** Restrict the timeline to these models (empty set = show all of them). */
+    setSelectedModels(modelIds: Iterable<string>): Promise<void>;
+    /** True when `commit` is its model's baseline (the full-model capture). */
+    isBaseline(commit: RevitFlowCommit): boolean;
+    /** True if `commit` has a hidden delta .frag to load. */
+    hasFrag(commit: RevitFlowCommit): boolean;
+    /**
+     * Wire the platform client and subscribe to model loads. Does NOT load any
+     * geometry: the manager only attaches to models the user opens from the Files
+     * panel. Consumer panels call this once on connect.
+     */
+    init(client: PlatformClient): Promise<void>;
+    /**
+     * Follow the viewer's selection so the element view tracks whatever the user clicks in
+     * 3D — no "trace this" button to press. The Highlighter's events appear asynchronously
+     * (they're registered when the viewer sets it up), so retry briefly until they exist.
+     */
+    private _watchSelection;
+    private _onModelSet;
+    private _onModelDeleted;
+    /**
+     * Probe a loaded model for a sibling visible `revitflow_history.json` in its
+     * folder. If present, adopt it as the active model and publish its commits.
+     * Silent for non-revit models and for our own delta frags — only genuine
+     * fetch/parse failures raise onError.
+     */
+    private _probeModel;
+    /**
+     * Read the model's deferred-edit queue, if it has one.
+     *
+     * Best effort by design: a model that has never been the target of an operation simply has
+     * no queue, and that is the normal case rather than an error. A failure here must never
+     * cost the user their history, which is why it cannot throw out of the probe.
+     */
+    private _readOps;
+    /**
+     * Re-scan every currently-loaded model for a hidden revit-flow history (the
+     * panel's Refresh button). Clears the probe cache so models load-order edge
+     * cases re-resolve.
+     */
+    loadHistory(): Promise<void>;
+    /**
+     * Show `commit`. The baseline geometry is the visible model the user already loaded, so
+     * the baseline view just clears outlines. Any other commit pulls its hidden delta frag
+     * in (so created elements exist) and outlines its changed elements. Fires
+     * onCommitChanged. Takes the commit itself, not an id: ids repeat across models.
+     */
+    showCommit(commit: RevitFlowCommit): Promise<void>;
+    /**
+     * Keep the deltas of the commits around `centerId` loaded and drop the rest, so
+     * stepping through the timeline never stalls and memory stays bounded: moving from
+     * commit 10 to 11 fetches one delta and disposes one, instead of reloading a window.
+     */
+    private _slidePrefetchWindow;
+    /**
+     * Show the model as it stood AT `commit`: the visible baseline is the model at its
+     * INITIAL commit, and everything created later lives in per-commit delta .frags loaded
+     * as separate models. Those deltas stay loaded (the prefetch window keeps neighbours
+     * warm), so stepping BACK has to hide the ones from later commits — otherwise a wall
+     * added in commit 3 was still sitting there while you were looking at commit 2.
+     * Only touches deltas of the commit's own model; other models keep their own state.
+     */
+    private _applyFutureVisibility;
+    /** Which commit a loaded delta belongs to (deltas are keyed by their hidden id). */
+    private _commitOfDelta;
+    /** Make every loaded delta visible again (the model as of its latest commit). */
+    private _showAllDeltas;
+    /** Remove all revit-flow outlines + ghosting and reset the selection. */
+    clear(): Promise<void>;
+    /** Set what happens to non-commit elements; re-applies to the current commit. */
+    setContextMode(mode: ContextMode): Promise<void>;
+    /**
+     * Every commit that touched `uniqueId`, oldest first, with what happened to it there.
+     * The element's life story: created here, edited there, finally deleted.
+     */
+    elementHistory(uniqueId: string): Array<{
+        commit: RevitFlowCommit;
+        type: string;
+    }>;
+    /** Per-author totals across the (optionally date-filtered) history. */
+    userActivity(since?: Date): Array<{
+        author: string;
+        userId?: string;
+        commits: number;
+        added: number;
+        modified: number;
+        removed: number;
+        last: string;
+    }>;
+    /**
+     * The GUID of whatever is currently selected in the viewer, so the element view can
+     * follow the user's selection. Returns null when nothing (or something unresolvable)
+     * is selected.
+     */
+    /** GUIDs of everything currently selected in the viewer (empty when nothing is). */
+    selectedGuids(): Promise<string[]>;
+    selectedGuid(): Promise<string | null>;
+    /**
+     * Select every element the commit touched, in the viewer's own selection — so the
+     * usual tools (properties, isolate, zoom) work on it like any hand-made selection.
+     * Honours the current type filter, so "only deletions" selects only those.
+     * @returns how many elements ended up selected.
+     */
+    selectCommitElements(commit: RevitFlowCommit, zoom?: boolean): Promise<number>;
+    /** Show/hide one kind of change; re-applies to the current commit. */
+    setTypeVisible(kind: ChangeKind, on: boolean): Promise<void>;
+    /** @deprecated use setContextMode. */
+    setIsolateChanges(on: boolean): Promise<void>;
+    /** The shared Outliner component (created on first access by the viewer). */
+    private _outliner;
+    /**
+     * Create the three independently-colored outline groups once. The viewer
+     * owns the Outliner's DEFAULT group (selection) — we only add our own named
+     * groups and never touch "default".
+     */
+    private _ensureGroups;
+    /** Clear our three outline groups only — leaves the viewer's default group. */
+    private _clearOutlines;
+    /**
+     * Resolve each change bucket's GUIDs to localIds across every loaded model
+     * and route them to the matching outline group.
+     */
+    private _outlineCommit;
+    /**
+     * Remove every localId that `_applySupersededVisibility` has hidden from a change map.
+     * Returns a copy: the input maps come from `_buildMap` and are used elsewhere.
+     */
+    private _dropSuperseded;
+    /**
+     * Hide (or restore) the elements a commit deleted. Tracked separately from the context
+     * modes so switching Colored↔Plain doesn't disturb ghosting or the rest of the model.
+     */
+    private _applyDeletedVisibility;
+    /**
+     * Show each element ONCE: from the newest source that supplies it.
+     *
+     * THE BUG THIS EXISTS FOR. The baseline .frag holds the whole model as of the first
+     * commit, and every later commit ships a delta .frag with the geometry it created AND
+     * the geometry it modified. Both stay in the scene. For a CREATED element that is
+     * right — it exists in exactly one place. For a MODIFIED one it is not: the element is
+     * in the baseline at its old shape and in the delta at its new one, and the viewer drew
+     * both. Measured 2026-08-05 on a wall whose height Quim raised: the new wall stood
+     * proud of the old one, with the coincident faces z-fighting into a dotted band.
+     *
+     * The rule is the obvious one once stated: for any element, only the newest VISIBLE
+     * source may draw it. Deltas are walked newest-first, each guid is claimed by the first
+     * source that has it, and every older copy — in an older delta or in the baseline — is
+     * hidden. Deltas newer than the commit being shown are already hidden wholesale by
+     * `_applyFutureVisibility`, so they never get to claim anything.
+     *
+     * Restores before it hides, like `_applyDeletedVisibility`, so stepping backwards
+     * through the timeline brings the old geometry back rather than accumulating hidden
+     * elements until the model is empty.
+     */
+    private _applySupersededVisibility;
+    /** Switch between review colours and the plain post-commit model. */
+    setHighlightMode(mode: HighlightMode): Promise<void>;
+    /**
+     * Make sure the geometry of `deleted` GUIDs is loaded. Anything already resolvable in
+     * a loaded model (the usual case: the element shipped in the baseline) needs nothing;
+     * for the rest, walk back through the history to the commit that CREATED each one and
+     * load that commit's delta, which is the last place its geometry existed.
+     */
+    private _ensureDeletedGeometry;
+    /** GUIDs → { modelId: Set<localId> } across the given models. */
+    private _buildMap;
+    private _mergeMaps;
+    /**
+     * Dim ("ghost") or hide every element that is NOT part of the shown commit, per the
+     * chosen context mode. Best-effort per model: a model that doesn't support the call is
+     * simply left alone — the outlines still convey the change.
+     */
+    private _applyContext;
+    /** Undo whatever the context mode did: drop the ghost overlay and restore visibility. */
+    private _clearContext;
+    /**
+     * Kept for the panel's connect hook. Prefetching is now driven by the SELECTION (see
+     * _slidePrefetchWindow): nothing is downloaded until a commit is opened, and only its
+     * neighbourhood is kept. Warming the newest N up front, as this used to do, spent
+     * bandwidth on commits nobody had asked for and grew without bound.
+     */
+    warmDeltas(): void;
+    /** Load a commit's hidden delta .frag (by its hidden id) into the viewer (modelId == hiddenId). */
+    private _ensureDeltaLoaded;
+    private _setLoading;
+    private _firstWorld;
+}
+/**
+ * GitHistoryManager — headless engine for the revit-flow git-history built-in.
+ *
+ * Owns ALL viewer mutation for the change outlines. It does NOT load the model —
+ * the user opens a model from the Project Files panel, and this manager reacts to
+ * that load: it reads the model's hidden `revitflow_history.json` (if any) and
+ * publishes the commit list. Showing a commit outlines its changed elements
+ * (create → green, update → blue, delete → red) via three independently-colored
+ * `OBF.Outliner` groups — a cheap post-process outline that never recolors the
+ * fragment geometry. The Lit panel (`top-git-history`) is intent-only: it calls
+ * these methods and subscribes to the events below.
+ *
+ * Data model, per loaded model (fileId == modelId), all HIDDEN children of it:
+ *   - revitflow_history.json — { model, commits: [{ id, parent, author, source,
+ *       timestamp, changes:[{type,uniqueId}], counts }] }. The first commit is the
+ *       INITIAL full-model capture (its geometry == the visible baseline file).
+ *   - revitflow_frag_<N>.frag — delta fragments for commit N (its created+modified
+ *       geometry), loaded on demand so created elements can be colored.
+ */
+export type GitHistoryManager = InstanceType<typeof _GitHistoryManager>;
+/**
+ * GitHistoryManager — headless engine for the revit-flow git-history built-in.
+ *
+ * Owns ALL viewer mutation for the change outlines. It does NOT load the model —
+ * the user opens a model from the Project Files panel, and this manager reacts to
+ * that load: it reads the model's hidden `revitflow_history.json` (if any) and
+ * publishes the commit list. Showing a commit outlines its changed elements
+ * (create → green, update → blue, delete → red) via three independently-colored
+ * `OBF.Outliner` groups — a cheap post-process outline that never recolors the
+ * fragment geometry. The Lit panel (`top-git-history`) is intent-only: it calls
+ * these methods and subscribes to the events below.
+ *
+ * Data model, per loaded model (fileId == modelId), all HIDDEN children of it:
+ *   - revitflow_history.json — { model, commits: [{ id, parent, author, source,
+ *       timestamp, changes:[{type,uniqueId}], counts }] }. The first commit is the
+ *       INITIAL full-model capture (its geometry == the visible baseline file).
+ *   - revitflow_frag_<N>.frag — delta fragments for commit N (its created+modified
+ *       geometry), loaded on demand so created elements can be colored.
+ */
+export declare const GitHistoryManager: typeof _GitHistoryManager & {
+    uuid: "3f9c1a7e-6b2d-4e18-9a5c-7d0e2f4b6c81";
+};
 /**
  * A simple test component to validate the built-in component pipeline.
  * Replace this with real components once the infrastructure is verified.

package/dist/cli.js

@@ -4205,8 +4205,8 @@ class BaseXHR extends Polling {
   /**
    * Sends data.
    *
-   * @param {String} data - data to send.
-   * @param {Function} fn - called upon flush.
+   * @param {String} data to send.
+   * @param {Function} called upon flush.
    * @private
    */
   doWrite(data, fn) {
@@ -4959,7 +4959,7 @@ class SocketWithoutUpgrade extends Emitter {
   /**
    * Sends a packet.
    *
-   * @param {String} type - packet type.
+   * @param {String} type: packet type.
    * @param {String} data.
    * @param {Object} options.
    * @param {Function} fn - callback function.
@@ -5194,12 +5194,11 @@ class SocketWithUpgrade extends SocketWithoutUpgrade {
 }
 let Socket$1 = class Socket extends SocketWithUpgrade {
   constructor(uri, opts = {}) {
-    const isOptionsOnly = typeof uri === "object";
-    const o = isOptionsOnly ? { ...uri } : { ...opts };
+    const o = typeof uri === "object" ? uri : opts;
     if (!o.transports || o.transports && typeof o.transports[0] === "string") {
       o.transports = (o.transports || ["polling", "websocket", "webtransport"]).map((transportName) => transports[transportName]).filter((t) => !!t);
     }
-    super(isOptionsOnly ? o : uri, o);
+    super(uri, o);
   }
 };
 function url(uri, path2 = "", loc) {
@@ -5420,13 +5419,12 @@ class Encoder {
 class Decoder extends Emitter {
   /**
    * Decoder constructor
+   *
+   * @param {function} reviver - custom reviver to pass down to JSON.stringify
    */
-  constructor(opts) {
+  constructor(reviver) {
     super();
-    this.opts = Object.assign({
-      reviver: void 0,
-      maxAttachments: 10
-    }, typeof opts === "function" ? { reviver: opts } : opts);
+    this.reviver = reviver;
   }
   /**
    * Decodes an encoded packet string into packet JSON.
@@ -5486,13 +5484,7 @@ class Decoder extends Emitter {
       if (buf != Number(buf) || str.charAt(i) !== "-") {
         throw new Error("Illegal attachments");
       }
-      const n = Number(buf);
-      if (!isInteger(n) || n < 0) {
-        throw new Error("Illegal attachments");
-      } else if (n > this.opts.maxAttachments) {
-        throw new Error("too many attachments");
-      }
-      p.attachments = n;
+      p.attachments = Number(buf);
     }
     if ("/" === str.charAt(i + 1)) {
       const start = i + 1;
@@ -5533,7 +5525,7 @@ class Decoder extends Emitter {
   }
   tryParse(str) {
     try {
-      return JSON.parse(str, this.opts.reviver);
+      return JSON.parse(str, this.reviver);
     } catch (e) {
       return false;
     }
@@ -5595,9 +5587,6 @@ class BinaryReconstructor {
     this.buffers = [];
   }
 }
-const isInteger = Number.isInteger || function(value2) {
-  return typeof value2 === "number" && isFinite(value2) && Math.floor(value2) === value2;
-};
 function isObject(value2) {
   return Object.prototype.toString.call(value2) === "[object Object]";
 }
@@ -8227,7 +8216,7 @@ Dual licenced under the MIT license or GPLv3. See https://raw.github.com/Stuk/js
 JSZip uses the library pako released under the MIT license :
 https://github.com/nodeca/pako/blob/main/LICENSE
 */
-(function(module2, exports) {
+(function(module2, exports$1) {
   !function(e) {
     module2.exports = e();
   }(function() {