@lmzhen/dsh-evolution-ui 0.0.0 → 0.32.0

package/lib/index.js

@@ -0,0 +1,323 @@
+import { apply as apply$1 } from "@lmzhen/dsh-evolution-merge-ui";
+import { HOST_ROUTES, json, methodNotAllowed, readJsonObject, registerHostRoutes } from "@lmzhen/dsh-evolution-core/http-routes";
+import { contentHash, displayBodyOf, elapsedSince, errorText, isLandmark, latestVersionAt, partitionVersions, skillRowCells, textDiffFacts, versionActionKind, versionRowCells } from "@lmzhen/dsh-evolution-core";
+//#region lib/types/panels/history/unit-undoable.js
+/**
+* G3b: undoability is a property of the UNIT, not of one entry.
+*
+* Every entry of a unit shares the same live body, so "is this undoable" must answer the same for all
+* of them; computing it per entry made the body row say `false` (already current) while a support row
+* of the SAME transaction said `true` — two entrances to one unit in one panel.
+*
+* Entries without a unit id keep the per-entry answer (they are their own singleton unit).
+*/
+/** @param members - every entry that shares the unit (content and support chains together).
+* @param liveHash - hash of the live body, or null when the skill is not readable.
+* @returns one flag per unit id; unknown ids fall back to the per-entry rule. */
+function unitUndoableFlags(members, liveHash) {
+	const flags = /* @__PURE__ */ new Map();
+	for (const entry of members) {
+		if (entry.unitId === void 0) continue;
+		if (isLandmark(entry)) continue;
+		const differs = entry.hash !== liveHash;
+		flags.set(entry.unitId, (flags.get(entry.unitId) ?? false) || differs);
+	}
+	return flags;
+}
+/** @param entry - the entry being rendered. @param flags - the unit flags from {@link unitUndoableFlags}.
+* @param liveHash - hash of the live body. @returns the row's `undoable` value. */
+function undoableFor(entry, flags, liveHash) {
+	if (isLandmark(entry)) return void 0;
+	const unit = entry.unitId;
+	if (unit !== void 0) {
+		const flagged = flags.get(unit);
+		if (flagged !== void 0) return flagged;
+	}
+	return entry.hash !== liveHash;
+}
+//#endregion
+//#region lib/types/panels/history/routes.js
+/**
+* The skill-history HTTP surface: six exact Fetch routes over the curator's read/write seam (five
+* reads plus the one write).
+*
+* W6/G4: the carrier is the platform's Host connection data plane — the fence, browser auth and
+* owner-only admission are applied by the platform BEFORE `fetch(request)` runs, so this module has
+* no 403/401 branch. The wire envelope the browser half reads is unchanged.
+*
+* Layering: this module maps a route to a USE CASE and does nothing else. "Which artifact does this
+* version hold" and "how do the two chains split" live in evolution-core; the only write is
+* curator.undo. The panel never writes the skill tree itself.
+* @module @lmzhen/dsh-evolution-ui/panels/history/routes
+*/
+/** Route paths: the ONE declaration lives in core (W1); the client constants are generated from it. */
+const SKILL_HISTORY_ROUTES = HOST_ROUTES.skillHistory;
+/**
+* How much of one version's body the read route hands back. A bound on the ANSWER, not on what the
+* deployment may store: a long skill arrives as its head plus `truncated`, so the reader is told.
+*/
+const MAX_BODY_CHARS = 2e4;
+/**
+* Build the six routes over the curator seam.
+* @param services - the host services the handlers read.
+* @param _audit - the registration audit (read routes record nothing; undo's decision stays the
+*   curator's own — W6 keeps the ledger to the approval surface).
+* @returns the route list for `registerHostRoutes`.
+*/
+function makeSkillHistoryRoutes(services, _audit) {
+	/** Run one handler body with the curator, or answer the family's E-302 sentence when it is absent. */
+	const withCurator = async (run) => {
+		const curator = services.getCurator();
+		if (curator === void 0) return json(200, {
+			ok: false,
+			code: "curator-not-mounted",
+			message: errorText("e-302-curator-service-not-mounted")
+		});
+		return await run(curator);
+	};
+	return [
+		{
+			path: SKILL_HISTORY_ROUTES.skills,
+			methods: ["GET"],
+			requestBody: "buffered",
+			fetch: (request) => {
+				if (request.method !== "GET") return Promise.resolve(methodNotAllowed(["GET"]));
+				return withCurator(async (curator) => {
+					const listed = await curator.skills.list();
+					const withHistory = [];
+					const now = Date.now();
+					for (const skill of listed) {
+						const versions = await curator.skills.listVersions(skill.name);
+						if (versions.length === 0) continue;
+						const lastAt = latestVersionAt(versions);
+						const row = {
+							name: skill.name,
+							versions: versions.length,
+							description: skill.description,
+							managed: skill.managed,
+							protectedBy: skill.protectedBy,
+							protectionUnknown: skill.protectionUnknown,
+							lastAt,
+							age: lastAt === null ? null : elapsedSince(lastAt, now)
+						};
+						withHistory.push({
+							...row,
+							cells: skillRowCells(row)
+						});
+					}
+					return json(200, {
+						ok: true,
+						data: withHistory
+					});
+				});
+			}
+		},
+		{
+			path: SKILL_HISTORY_ROUTES.versions,
+			methods: ["GET"],
+			requestBody: "buffered",
+			fetch: (request) => {
+				if (request.method !== "GET") return Promise.resolve(methodNotAllowed(["GET"]));
+				const name = new URL(request.url).searchParams.get("name")?.trim() ?? "";
+				if (name === "") return Promise.resolve(json(400, {
+					ok: false,
+					code: "bad-request",
+					message: "缺少 name"
+				}));
+				return withCurator(async (curator) => {
+					const groups = partitionVersions(await curator.history(name));
+					const live = await curator.skills.read(name);
+					const liveHash = live === null ? null : contentHash(live);
+					const now = Date.now();
+					const decorate = (entry, index, chain, withDelta) => {
+						const previous = index === 0 ? void 0 : chain[index - 1];
+						return {
+							...entry,
+							actionKind: versionActionKind(entry.action),
+							age: elapsedSince(entry.at, now),
+							...!withDelta || previous === void 0 ? {} : { charsDelta: entry.chars - previous.chars }
+						};
+					};
+					const unitFlags = unitUndoableFlags([...groups.content, ...groups.support], liveHash);
+					return json(200, {
+						ok: true,
+						data: {
+							content: groups.content.map((entry, index) => {
+								const undoable = undoableFor(entry, unitFlags, liveHash);
+								const row = {
+									...decorate(entry, index, groups.content, true),
+									...undoable === void 0 ? {} : { undoable }
+								};
+								return {
+									...row,
+									cells: versionRowCells(row)
+								};
+							}),
+							support: groups.support.map((entry, index) => {
+								const row = decorate(entry, index, groups.support, false);
+								return {
+									...row,
+									cells: versionRowCells(row)
+								};
+							}),
+							liveHash
+						}
+					});
+				});
+			}
+		},
+		{
+			path: SKILL_HISTORY_ROUTES.diff,
+			methods: ["GET"],
+			requestBody: "buffered",
+			fetch: (request) => {
+				if (request.method !== "GET") return Promise.resolve(methodNotAllowed(["GET"]));
+				const params = new URL(request.url).searchParams;
+				const name = params.get("name")?.trim() ?? "";
+				const rawV = params.get("v")?.trim() ?? "";
+				const v = Number.parseInt(rawV, 10);
+				if (name === "" || !/^\d+$/.test(rawV) || !Number.isInteger(v) || v < 1) return Promise.resolve(json(400, {
+					ok: false,
+					code: "bad-request",
+					message: "需要 name 与正整数 v"
+				}));
+				return withCurator(async (curator) => {
+					const groups = partitionVersions(await curator.history(name));
+					const index = groups.content.findIndex((entry) => entry.v === v);
+					if (index === -1) return json(404, {
+						ok: false,
+						code: "not-found",
+						message: "该版本不在「" + name + "」的记录历史里"
+					});
+					const entry = groups.content[index];
+					const previous = (entry === void 0 || entry.beforeHash === void 0 ? void 0 : groups.content.find((candidate) => candidate.hash === entry.beforeHash)) ?? (index === 0 ? void 0 : groups.content[index - 1]);
+					const after = entry === void 0 ? null : await curator.skills.readVersion(name, v);
+					const before = previous === void 0 ? "" : await curator.skills.readVersion(name, previous.v);
+					if (after === null || before === null) return json(404, {
+						ok: false,
+						code: "not-found",
+						message: "该版本的存储内容读不出来"
+					});
+					const facts = textDiffFacts(before, after, "SKILL.md");
+					return json(200, {
+						ok: true,
+						data: {
+							v,
+							against: previous?.v ?? null,
+							...facts
+						}
+					});
+				});
+			}
+		},
+		{
+			path: SKILL_HISTORY_ROUTES.body,
+			methods: ["GET"],
+			requestBody: "buffered",
+			fetch: (request) => {
+				if (request.method !== "GET") return Promise.resolve(methodNotAllowed(["GET"]));
+				const params = new URL(request.url).searchParams;
+				const name = params.get("name")?.trim() ?? "";
+				const rawV = params.get("v")?.trim() ?? "";
+				const v = Number.parseInt(rawV, 10);
+				if (name === "" || !/^\d+$/.test(rawV) || !Number.isInteger(v) || v < 1) return Promise.resolve(json(400, {
+					ok: false,
+					code: "bad-request",
+					message: "需要 name 与正整数 v"
+				}));
+				return withCurator(async (curator) => {
+					const text = await curator.skills.readVersion(name, v);
+					if (text === null) return json(404, {
+						ok: false,
+						code: "not-found",
+						message: "该版本的存储内容读不出来"
+					});
+					const truncated = text.length > MAX_BODY_CHARS;
+					return json(200, {
+						ok: true,
+						data: {
+							v,
+							display: displayBodyOf(truncated ? text.slice(0, MAX_BODY_CHARS) : text),
+							chars: text.length,
+							truncated
+						}
+					});
+				});
+			}
+		},
+		{
+			path: SKILL_HISTORY_ROUTES.undo,
+			methods: ["POST"],
+			requestBody: "buffered",
+			fetch: (request) => {
+				if (request.method !== "POST") return Promise.resolve(methodNotAllowed(["POST"]));
+				return (async () => {
+					const payload = await readJsonObject(request);
+					const name = typeof payload?.name === "string" ? payload.name.trim() : "";
+					if (name === "") return json(400, {
+						ok: false,
+						code: "bad-request",
+						message: "缺少 name"
+					});
+					const raw = payload?.v;
+					if (raw !== void 0 && (typeof raw !== "number" || !Number.isInteger(raw) || raw < 1)) return json(400, {
+						ok: false,
+						code: "bad-request",
+						message: "v 必须是正整数"
+					});
+					const unitId = typeof payload?.unitId === "string" ? payload.unitId.trim() : "";
+					if (raw !== void 0 && unitId !== "") return json(400, {
+						ok: false,
+						code: "bad-request",
+						message: "v 与 unitId 不能同时使用"
+					});
+					return withCurator(async (curator) => {
+						const result = unitId !== "" ? await curator.undoUnit(name, unitId) : raw === void 0 ? await curator.undo(name) : await curator.undo(name, raw);
+						return json(200, result.ok ? {
+							ok: true,
+							data: result
+						} : {
+							ok: false,
+							code: "undo-refused",
+							message: result.message
+						});
+					});
+				})();
+			}
+		},
+		{
+			path: SKILL_HISTORY_ROUTES.health,
+			methods: ["GET"],
+			requestBody: "buffered",
+			fetch: (request) => {
+				if (request.method !== "GET") return Promise.resolve(methodNotAllowed(["GET"]));
+				return Promise.resolve(json(200, {
+					ok: true,
+					data: { surface: "skill-history" }
+				}));
+			}
+		}
+	];
+}
+//#endregion
+//#region lib/types/panels/history/host.js
+/**
+* Mount the routes as ONE owner effect (disposers run on unload and on HMR). A profile whose host has
+* no connection service simply never runs the callback — inert, never pending.
+* @param ctx - the host context; the connection and curator arrive through it.
+*/
+function apply$2(ctx) {
+	registerHostRoutes(ctx, (audit) => makeSkillHistoryRoutes({ getCurator: () => ctx.get("evolutionCurator") }, audit));
+}
+//#endregion
+//#region lib/types/index.js
+const name = "evolution-ui";
+/** No required service: every nested row resolves its own optional seats. */
+const inject = [];
+/** Mount the four panel host halves through their existing owners. */
+function apply(ctx) {
+	apply$1();
+	apply$2(ctx);
+}
+//#endregion
+export { apply, inject, name };

package/lib/types/client/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Browser umbrella: one client bundle registers the four existing panel rows.
+ * @module @lmzhen/dsh-evolution-ui/client
+ */
+import type { Context } from '@deepseek-ai/cordis';
+export declare const inject: string[];
+/** Register every panel through the shared client-kit lifecycle. */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Host umbrella for the evolution UI panels: one row mounts all four existing host halves.
+ * The panel packages stay separate until their client code moves here.
+ * @module @lmzhen/dsh-evolution-ui
+ */
+import type { Context } from '@deepseek-ai/cordis';
+export declare const name = "evolution-ui";
+/** No required service: every nested row resolves its own optional seats. */
+export declare const inject: string[];
+/** Mount the four panel host halves through their existing owners. */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/panels/history/client/Panel.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The panel: one read, one open skill, one open row — and the faces that draw them.
+ *
+ * Everything a PERSON reads is decided elsewhere: what a row says is core's (`skill-row-cells.ts`,
+ * shipped with the row), the words are the dictionary's, the tool face is `chrome.ts` and the reading
+ * face is `document.ts`. What is left here is the STATE — which skill is open, which row is expanded,
+ * which reads are in flight — and the two rules that only a state machine can hold: a read takes a
+ * ticket so a slow reply cannot land on another skill, and a write reports its own result instead of
+ * being erased by the read that follows it.
+ * @module @lmzhen/dsh-evolution-ui/panels/history/client
+ */
+import { type ReactNode } from 'react';
+import { type Copy } from './chrome.ts';
+import { type SkillRow, type VersionBodyRow, type VersionDiffRow, type VersionsPayload } from './api.ts';
+import type { MarkdownWords } from './markdown.ts';
+/** What the panel is handed: the dictionary seat, the renderer's words, and the host's callbacks. */
+export interface PanelFace extends Copy {
+    /** The two words the platform Markdown renderer needs; the dictionary owns them. */
+    readonly markdownWords: MarkdownWords;
+    readonly loadSkills: () => Promise<readonly SkillRow[]>;
+    readonly loadVersions: (name: string) => Promise<VersionsPayload>;
+    readonly loadDiff: (name: string, v: number) => Promise<VersionDiffRow>;
+    readonly loadBody: (name: string, v: number) => Promise<VersionBodyRow>;
+    readonly undo: (name: string, v?: number, unitId?: string) => Promise<string>;
+}
+export declare function SkillHistoryPanel(face: PanelFace): ReactNode;
+//# sourceMappingURL=Panel.d.ts.map

package/lib/types/panels/history/client/api.d.ts

@@ -0,0 +1,142 @@
+import type { RouteFailure } from '@lmzhen/dsh-evolution-client-kit/generated/route-client';
+/** Route paths: the generated mirror of the host's HOST_ROUTES (one declaration in core). */
+export declare const HOST_ROUTES: {
+    readonly skills: "/api/dsh-evolution/skill-history/skills";
+    readonly versions: "/api/dsh-evolution/skill-history/versions";
+    readonly diff: "/api/dsh-evolution/skill-history/versions/diff";
+    readonly body: "/api/dsh-evolution/skill-history/versions/body";
+    readonly undo: "/api/dsh-evolution/skill-history/undo";
+    readonly health: "/api/dsh-evolution/skill-history/health";
+};
+/** One changed region, as the host reports it (the platform diff card's own shape). */
+export interface DiffHunkRow {
+    readonly path: string;
+    readonly oldText: string;
+    readonly newText: string;
+}
+/** One version's diff, as the host computes it. */
+export interface VersionDiffRow {
+    readonly v: number;
+    /** The version this one replaced, or null for the first recorded version. */
+    readonly against: number | null;
+    readonly linesAdded: number;
+    readonly linesRemoved: number;
+    readonly hunks: readonly DiffHunkRow[];
+    readonly truncated: boolean;
+}
+/** Where a cell sits in its row: `aside` is right-aligned and is never truncated. */
+export type CellSlot = 'lead' | 'meta' | 'aside';
+/** The visual register a cell speaks in; the stylesheet maps it to a scale token. */
+export type CellTone = 'primary' | 'secondary' | 'tertiary';
+/** One cell of a row: a locale key with the values its template needs, or a verbatim fact. */
+export type RowCell = {
+    readonly key: string;
+    readonly slot: CellSlot;
+    readonly tone: CellTone;
+    readonly note?: string;
+    readonly copy: string;
+    readonly values?: Readonly<Record<string, string | number>>;
+} | {
+    readonly key: string;
+    readonly slot: CellSlot;
+    readonly tone: CellTone;
+    readonly note?: string;
+    readonly literal: string;
+};
+/** The lines one row shows: a title line, and a meta line under it. */
+export interface RowCells {
+    readonly title: readonly RowCell[];
+    readonly meta: readonly RowCell[];
+}
+/** One recorded version, as the host reports it. */
+export interface VersionRow {
+    readonly v: number;
+    readonly at: string;
+    readonly action: string;
+    readonly hash: string;
+    readonly chars: number;
+    /** Present on body rows: false when this version already IS the live content. */
+    readonly undoable?: boolean;
+    /** Characters this version added to (or removed from) the one before it; absent on the first. */
+    readonly charsDelta?: number;
+    /** Which kind of write produced it (the vocabulary key the panel turns into words). */
+    readonly actionKind: string;
+    /** How long ago the host recorded it, as a bucket plus a count — never a sentence. */
+    readonly age: {
+        readonly unit: string;
+        readonly n: number;
+    };
+    /** What this row says and where each fact sits, decided in core (`skill-row-cells.ts`). */
+    readonly cells: RowCells;
+    /** The one line the optional summarizer wrote, when the deployment turned it on. */
+    readonly summary?: string;
+    /**
+     * Which support file these bytes came from, relative to the skill directory. Absent on body rows,
+     * and absent on every support row recorded before the field existed (the bytes carry no name).
+     */
+    readonly path?: string;
+    /** Present when this row belongs to a cross-skill write unit; undo then restores the whole unit. */
+    readonly unitId?: string;
+}
+/** One skill that has recorded versions, with what the listing already knows about it. */
+export interface SkillRow {
+    readonly name: string;
+    readonly versions: number;
+    readonly description: string;
+    readonly managed: boolean;
+    readonly protectedBy: string | null;
+    readonly protectionUnknown: boolean;
+    /** When this skill's content last changed (either chain), or null when the index is empty. */
+    readonly lastAt: string | null;
+    /** That moment as a bucket plus a count; null exactly when `lastAt` is. */
+    readonly age: {
+        readonly unit: string;
+        readonly n: number;
+    } | null;
+    /** What this row says and where each fact sits, decided in core (`skill-row-cells.ts`). */
+    readonly cells: RowCells;
+}
+/** One version's whole body, as the read route hands it over. */
+export interface VersionBodyRow {
+    readonly v: number;
+    /**
+     * The text a READER sees: the body without its frontmatter block, or its head when `truncated` —
+     * the reader is told rather than silently cut. The exact bytes are the diff route's answer.
+     */
+    readonly display: string;
+    /** How long the stored body is, whatever came back. */
+    readonly chars: number;
+    readonly truncated: boolean;
+}
+/**
+ * The two chains. G4.2 whitelist audit: the payload's `liveHash` is DELETED here — the host route already
+ * compares it (`undoable: entry.hash !== liveHash`, routes.ts) and delivers the verdict per row, so the
+ * "current" marker has one source. A declared field nobody reads is drift waiting to happen.
+ */
+export interface VersionsPayload {
+    readonly content: readonly VersionRow[];
+    readonly support: readonly VersionRow[];
+}
+/** The panel's data face: plain callbacks, no service handle. */
+export interface SkillHistoryApi {
+    readonly skills: () => Promise<readonly SkillRow[]>;
+    readonly versions: (name: string) => Promise<VersionsPayload>;
+    readonly undo: (name: string, v?: number, unitId?: string) => Promise<string>;
+    readonly diff: (name: string, v: number) => Promise<VersionDiffRow>;
+    readonly body: (name: string, v: number) => Promise<VersionBodyRow>;
+}
+/**
+ * A refusal the host reported, carrying its own sentence (the curator's, not ours) and the classified
+ * four-state failure so the panel can render the shared failure block (G5/W7 S6b).
+ */
+export declare class SkillHistoryRefusal extends Error {
+    readonly failure: RouteFailure;
+    constructor(failure: RouteFailure);
+}
+/**
+ * Build the panel's face over one fetch implementation.
+ * @param fetchImpl - the fetch to use; a spec passes a stub.
+ * @returns the three callbacks the component receives through its inject face.
+ */
+export declare function createSkillHistoryApi(fetchImpl?: typeof fetch): SkillHistoryApi;
+//# sourceMappingURL=api.d.ts.map

package/lib/types/panels/history/client/atoms.d.ts

@@ -0,0 +1,73 @@
+/**
+ * The four atoms the panel's tool face is built from (G3, §15.2 L2a atoms).
+ *
+ * Why atoms at all: the row used to be assembled from five different elements that each wrote their
+ * own classes, so "what a control looks like" was spread over the stylesheet and a click target, a
+ * state chip, a refusal and a glyph had no vocabulary at all (W7/W9/W13/W14). Every interactive
+ * element now says what it IS — a control that acts, a control that only reveals more, a state, a
+ * notice — and the stylesheet answers once per kind.
+ *
+ * No words live here: an atom takes the copy its caller already resolved.
+ * @module @lmzhen/dsh-evolution-ui/panels/history/client
+ */
+import { type ReactNode } from 'react';
+/** The register one control speaks in. `primary` is reserved for the click that writes. */
+export type Tone = 'quiet' | 'primary';
+/**
+ * What a control DOES, which is what makes them distinguishable at a glance: one acts, one reveals
+ * more (and shows whether it is open), one chooses between two views of the same thing.
+ */
+export type ControlKind = 'action' | 'toggle' | 'switch';
+/** The glyphs the panel draws. The platform's own arrows are text characters, which render in the
+ * reader's fallback font at whatever weight it has (W7); a drawn path cannot. */
+export type IconName = 'chevron-right' | 'chevron-down' | 'alert';
+/**
+ * One drawn glyph.
+ * @param name - which glyph.
+ * @returns an inline SVG that takes the surrounding colour and type size.
+ */
+export declare function icon(name: IconName): ReactNode;
+/** What every atom takes. */
+interface BaseProps {
+    /** React key, for the callers that build lists. */
+    readonly key?: string;
+    /** The copy, already resolved by the dictionary seat. */
+    readonly children: ReactNode;
+}
+/** One control. `kind` says whether it acts or only reveals; `tone` says whether it writes. */
+export interface ButtonProps extends BaseProps {
+    readonly kind?: ControlKind;
+    readonly tone?: Tone;
+    /** Hover text, when the label alone is ambiguous. */
+    readonly title?: string;
+    /** Whether the thing this control reveals is currently open (`aria-expanded`). */
+    readonly expanded?: boolean;
+    /** Whether this control is the side of a two-way choice that is showing. */
+    readonly pressed?: boolean;
+    readonly onClick: () => void;
+}
+/**
+ * One control.
+ * @param props - what it is, how it speaks, and what it does.
+ * @returns the button element.
+ */
+export declare function button(props: ButtonProps): ReactNode;
+/**
+ * One state, spelled as a chip: never clickable, never in the primary colour (W9).
+ * @param props - the copy.
+ * @returns the chip element.
+ */
+export declare function chip(props: BaseProps): ReactNode;
+/** One notice: a sentence about what just happened, or why nothing did. */
+export interface NoteProps extends BaseProps {
+    /** Whether this is a refusal or a failure, which colours it and adds the glyph (W13). */
+    readonly error?: boolean;
+}
+/**
+ * One notice.
+ * @param props - the copy, and whether it reports a failure.
+ * @returns the note element.
+ */
+export declare function note(props: NoteProps): ReactNode;
+export {};
+//# sourceMappingURL=atoms.d.ts.map

package/lib/types/panels/history/client/chrome.d.ts

@@ -0,0 +1,76 @@
+/**
+ * The TOOL face: the skill list, the version list, and the controls that act on a version.
+ *
+ * This file renders FACTS. What a row says, in which order and in which slot is decided in core
+ * (`skill-row-cells.ts`) and travels with the row, because a browser half cannot import core at
+ * runtime; the words come from the locale dictionary through the `Copy` seat. The renderer's only
+ * judgements are layout: a cell's slot decides its alignment, and the `aside` slot is the one the
+ * browser's ellipsis may never eat (W1).
+ *
+ * The reading face — a version rendered as a document, and the rendered diff — lives in
+ * `document.ts`; the two faces share the scale in `tokens.ts` and nothing else (§15.2 L2b).
+ * @module @lmzhen/dsh-evolution-ui/panels/history/client
+ */
+import { type ReactNode } from 'react';
+import type { SkillRow, VersionRow } from './api.ts';
+/** What a chrome builder needs: the dictionary, and nothing else. */
+export interface Copy {
+    readonly t: (key: string) => string;
+    readonly format: (key: string, values: Record<string, string | number>) => string;
+}
+/** One kind of expansion a row can show. */
+export type OpenKind = 'diff' | 'preview';
+/** The local time an ISO timestamp names, as the operator's own clock shows it. */
+export declare function localTime(at: string): string;
+/** The search field above the list. */
+export declare function searchField(copy: Copy, query: string, onQuery: (value: string) => void): ReactNode;
+/**
+ * One skill in the left column: its name and size, then what it is and when it last changed.
+ * @param copy - the dictionary seat.
+ * @param row - the skill's facts and cells.
+ * @param selected - whether this is the open skill.
+ * @param onOpen - what a click does.
+ * @returns the row.
+ */
+export declare function skillLine(copy: Copy, row: SkillRow, selected: boolean, onOpen: () => void): ReactNode;
+/** What one version row needs from the panel's state machine. */
+export interface VersionRowProps {
+    readonly copy: Copy;
+    readonly row: VersionRow;
+    /** Whether this row is the one waiting for a confirmation click. */
+    readonly confirming: boolean;
+    /** Which expansion this row currently shows, if any. */
+    readonly open: OpenKind | undefined;
+    /** The expanded content, already built by the caller. */
+    readonly expanded: ReactNode;
+    readonly onRestore: () => void;
+    readonly onCancel: () => void;
+    readonly onToggle: (kind: OpenKind) => void;
+}
+/**
+ * One version row: what happened, when, how big — then the controls, then whatever is expanded.
+ *
+ * The write is the only control that can change anything, and it is the only one that ever takes the
+ * primary tone; a toggle that merely reveals more is borderless and carries a drawn chevron, so the
+ * two kinds cannot be mistaken for each other (W7/W14).
+ * @param props - the row, the copy, and the panel's callbacks.
+ * @returns the row.
+ */
+export declare function versionRow(props: VersionRowProps): ReactNode;
+/**
+ * One group's heading, and the note that explains the group.
+ * @param title - the group's name, already resolved.
+ * @param noteText - the group's note, when it has one.
+ * @returns the heading and the note, for the caller to place in its own section.
+ */
+export declare function groupHeading(title: string, noteText: string | undefined): ReactNode[];
+/** What the list shows when it has nothing to show.
+ * S5-07: the sites that render it as a SIBLING in an array must pass a key - a keyless sibling made
+ * React warn on every render of the default view (measured: one warning per render, captured by spy).
+ */
+export declare function emptyState(text: string, key?: string): ReactNode;
+/** One notice about what just happened. */
+export declare function notice(text: string | undefined, error: boolean): ReactNode;
+/** The pane's heading and its one control. */
+export declare function panelHead(copy: Copy, onRefresh: () => void): ReactNode;
+//# sourceMappingURL=chrome.d.ts.map