@pgcorp/ui-kit 0.10.0 → 0.10.2

package/dist/src/components/shared/data-display/_internal/SRichMath.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,80 @@
+import { useUiKitLocale as e } from "../../../../composables/useUiKitLocale.js";
+import { validateExactString as t, validateNonEmptyString as n } from "../../../../internal/runtimeContract.js";
+import { computed as r, createBlock as i, createCommentVNode as a, createElementBlock as o, createElementVNode as s, defineComponent as c, onBeforeUnmount as l, onMounted as u, openBlock as d, ref as f, resolveDynamicComponent as p, toDisplayString as m, unref as h, watch as g, withCtx as _ } from "vue";
+import "katex/dist/katex.min.css";
+//#region src/components/shared/data-display/_internal/SRichMath.vue?vue&type=script&setup=true&lang.ts
+var v = {
+	key: 0,
+	class: "s-rich-math__fallback"
+}, y = {
+	key: 1,
+	class: "s-rich-math__assistive",
+	role: "status"
+}, b = {
+	key: 2,
+	class: "s-rich-math__error",
+	role: "alert"
+}, x = /*@__PURE__*/ c({
+	inheritAttrs: !1,
+	__name: "SRichMath",
+	props: {
+		source: {},
+		display: { default: "inline" },
+		label: { default: void 0 }
+	},
+	setup(c) {
+		let x = c, { t: S } = e(), C = f(null), w = f("loading"), T = r(() => n("SRichMath", "source", x.source)), E = r(() => t("SRichMath", "display", x.display, ["inline", "block"])), D = r(() => x.label === void 0 ? T.value : n("SRichMath", "label", x.label)), O = !1, k = 0;
+		async function A() {
+			if (!O) return;
+			let e = C.value;
+			if (!e) throw Error("SRichMath: render surface is unavailable.");
+			let t = k += 1;
+			w.value = "loading", e.replaceChildren();
+			try {
+				let n = await import("katex");
+				if (t !== k || !O) return;
+				n.default.render(T.value, e, {
+					displayMode: E.value === "block",
+					output: "htmlAndMathml",
+					strict: "error",
+					throwOnError: !0,
+					trust: !1,
+					maxExpand: 1e3,
+					maxSize: 20
+				}), e.setAttribute("role", "math"), e.setAttribute("aria-label", D.value), w.value = "ready";
+			} catch {
+				if (t !== k || !O) return;
+				e.replaceChildren(), e.removeAttribute("role"), e.removeAttribute("aria-label"), w.value = "error";
+			}
+		}
+		return u(() => {
+			O = !0, A();
+		}), g(() => [
+			x.source,
+			x.display,
+			x.label
+		], () => {
+			A();
+		}), l(() => {
+			O = !1, k += 1, C.value?.replaceChildren(), C.value?.removeAttribute("role"), C.value?.removeAttribute("aria-label");
+		}), (e, t) => (d(), i(p(E.value === "block" ? "div" : "span"), {
+			class: "s-rich-math",
+			"data-display": E.value,
+			"data-state": w.value
+		}, {
+			default: _(() => [
+				s("span", {
+					ref_key: "surface",
+					ref: C,
+					class: "s-rich-math__surface"
+				}, null, 512),
+				w.value === "loading" ? (d(), o("code", v, m(T.value), 1)) : a("", !0),
+				w.value === "loading" ? (d(), o("span", y, m(h(S)("editor.mathLoading")), 1)) : a("", !0),
+				w.value === "error" ? (d(), o("span", b, [s("span", null, m(h(S)("editor.mathError")), 1), s("code", null, m(T.value), 1)])) : a("", !0)
+			]),
+			_: 1
+		}, 8, ["data-display", "data-state"]));
+	}
+});
+//#endregion
+export { x as default };

package/dist/src/components/shared/data-display/chart.d.ts

@@ -0,0 +1,49 @@
+/** Поддерживаемые семейства графиков. / Supported chart families. */
+export type SChartType = 'line' | 'area' | 'bar' | 'pie' | 'donut';
+/** Семантическая categorical palette без raw CSS values. / Semantic categorical palette without raw CSS values. */
+export type SChartTone = 'series-1' | 'series-2' | 'series-3' | 'series-4' | 'series-5' | 'series-6' | 'series-7' | 'series-8' | 'success' | 'warn' | 'danger';
+/** Одна общая категория Cartesian axis либо radial slice. / One shared Cartesian category or radial slice. */
+export interface SChartCategory {
+    readonly key: string;
+    readonly label: string;
+    /** Используется slice-ом pie/donut; Cartesian series владеет собственным tone. / Used by pie/donut slices; Cartesian series owns its tone. */
+    readonly tone?: SChartTone;
+}
+/** Один data series; values позиционно соответствуют categories. / One data series; values correspond positionally to categories. */
+export interface SChartSeries {
+    readonly key: string;
+    readonly label: string;
+    readonly values: readonly number[];
+    readonly tone?: SChartTone;
+}
+/** Accessible-name contract графика. / Chart accessible-name contract. */
+export type SChartAccessibility = {
+    readonly mode: 'decorative';
+} | {
+    readonly mode: 'label';
+    readonly label: string;
+    readonly description?: string;
+} | {
+    readonly mode: 'labelledby';
+    readonly id: string;
+    readonly describedby?: string;
+};
+/** Домен шкалы без неявных min/max fallbacks. / Scale domain without implicit min/max fallbacks. */
+export type SChartDomain = {
+    readonly mode: 'auto';
+    readonly includeZero?: boolean;
+} | {
+    readonly mode: 'fixed';
+    readonly minimum: number;
+    readonly maximum: number;
+};
+export type SChartSize = 'compact' | 'sm' | 'md' | 'lg';
+export type SChartGrid = 'none' | 'horizontal' | 'vertical' | 'both';
+export type SChartLegend = 'none' | 'top' | 'bottom';
+export type SChartDataLabels = 'none' | 'latest' | 'all';
+export type SChartMarkers = 'none' | 'latest' | 'all';
+export type SChartXLabels = 'none' | 'endpoints' | 'auto' | 'all';
+export type SChartCurve = 'linear' | 'smooth';
+export type SChartBarMode = 'grouped' | 'stacked';
+export type SChartRadialLabel = 'value' | 'percentage' | 'category';
+export type SChartDataTablePresentation = 'assistive' | 'visible' | 'none';

package/dist/src/components/shared/data-display/codeEditor.d.ts

@@ -0,0 +1,49 @@
+/** Serializable half-open document range. */
+export interface SCodeEditorRange {
+    readonly from: number;
+    readonly to: number;
+}
+/** Serializable primary selection. Direction is preserved through anchor/head. */
+export interface SCodeEditorSelectionRange extends SCodeEditorRange {
+    readonly anchor: number;
+    readonly head: number;
+    readonly empty: boolean;
+}
+/** Selection snapshot returned only through an explicit consumer action. */
+export interface SCodeEditorSelectionSnapshot extends SCodeEditorSelectionRange {
+    readonly text: string;
+}
+/** Serializable editor view state without a CodeMirror object or DOM reference. */
+export interface SCodeEditorViewState {
+    readonly selection: SCodeEditorSelectionRange;
+    readonly scrollTop: number;
+    readonly scrollLeft: number;
+}
+/** Serializable imperative surface; CodeMirror objects and DOM nodes never cross the public boundary. */
+export interface SCodeEditorApi {
+    applySelection(position: number): void;
+    revealRange(range: SCodeEditorRange): void;
+    getSelection(): SCodeEditorSelectionSnapshot;
+    captureViewState(): SCodeEditorViewState;
+    applyViewState(viewState: SCodeEditorViewState): void;
+    focus(): void;
+}
+export declare const S_CODE_EDITOR_DIAGNOSTIC_SEVERITIES: readonly ["error", "warning", "info", "hint"];
+export type SCodeEditorDiagnosticSeverity = (typeof S_CODE_EDITOR_DIAGNOSTIC_SEVERITIES)[number];
+export type SCodeEditorDiagnosticId = string | number;
+/** Controlled diagnostic record rendered by SCodeEditor. */
+export interface SCodeEditorDiagnostic<Id extends SCodeEditorDiagnosticId = string> extends SCodeEditorRange {
+    readonly id: Id;
+    readonly severity: SCodeEditorDiagnosticSeverity;
+    readonly message: string;
+    readonly source?: string;
+    readonly code?: string | number;
+}
+/** Validates a half-open range against the current document without clamping. */
+export declare function validateCodeEditorRange(owner: string, coordinate: string, value: unknown, documentLength: number): SCodeEditorRange;
+/** Validates the primary selection and its derived invariants. */
+export declare function validateCodeEditorSelectionRange(owner: string, coordinate: string, value: unknown, documentLength: number): SCodeEditorSelectionRange;
+/** Validates a serializable view-state snapshot against the current document. */
+export declare function validateCodeEditorViewState(owner: string, value: unknown, documentLength: number): SCodeEditorViewState;
+/** Runtime-validates controlled diagnostics and preserves their consumer-owned IDs. */
+export declare function validateCodeEditorDiagnostics(owner: string, value: unknown, documentLength: number): readonly SCodeEditorDiagnostic<SCodeEditorDiagnosticId>[];

package/dist/src/components/shared/data-display/codeEditor.js

@@ -0,0 +1,102 @@
+import { validateBoolean as e, validateBoundedInteger as t, validateExactString as n, validateNonEmptyString as r } from "../../../internal/runtimeContract.js";
+//#region src/components/shared/data-display/codeEditor.ts
+var i = [
+	"error",
+	"warning",
+	"info",
+	"hint"
+], a = /* @__PURE__ */ new Set(["from", "to"]), o = /* @__PURE__ */ new Set([
+	"anchor",
+	"head",
+	"from",
+	"to",
+	"empty"
+]), s = /* @__PURE__ */ new Set([
+	"selection",
+	"scrollTop",
+	"scrollLeft"
+]), c = /* @__PURE__ */ new Set([
+	"id",
+	"severity",
+	"message",
+	"from",
+	"to",
+	"source",
+	"code"
+]);
+function l(e, t, n, r) {
+	if (typeof n != "object" || !n || Array.isArray(n) || Object.getPrototypeOf(n) !== Object.prototype) throw TypeError(`${e}: ${t} должен быть plain object. / ${e}: ${t} must be a plain object.`);
+	let i = n, a = Object.keys(i).filter((e) => !r.has(e));
+	if (a.length > 0) throw TypeError(`${e}.${t}: неизвестные поля ${a.map((e) => JSON.stringify(e)).join(", ")}. / ${e}.${t}: unknown fields ${a.map((e) => JSON.stringify(e)).join(", ")}.`);
+	return i;
+}
+function u(e, t, n) {
+	if (typeof n == "number" && Number.isFinite(n) && n >= 0) return n;
+	throw TypeError(`${e}: ${t} должен быть конечным неотрицательным числом. / ${e}: ${t} must be a finite non-negative number.`);
+}
+function d(e, t, n) {
+	if (typeof n == "string") return r(e, t, n);
+	if (typeof n == "number" && Number.isFinite(n)) return n;
+	throw TypeError(`${e}: ${t} должен быть непустой строкой или конечным числом. / ${e}: ${t} must be a non-empty string or finite number.`);
+}
+function f(e, n, r, i) {
+	let o = t(e, "documentLength", i, {
+		minimum: 0,
+		maximum: 2 ** 53 - 1
+	}), s = l(e, n, r, a), c = t(e, `${n}.from`, s.from, {
+		minimum: 0,
+		maximum: o
+	}), u = t(e, `${n}.to`, s.to, {
+		minimum: c,
+		maximum: o
+	});
+	return Object.freeze({
+		from: c,
+		to: u
+	});
+}
+function p(n, r, i, a) {
+	let s = l(n, r, i, o), c = t(n, `${r}.anchor`, s.anchor, {
+		minimum: 0,
+		maximum: a
+	}), u = t(n, `${r}.head`, s.head, {
+		minimum: 0,
+		maximum: a
+	}), d = Math.min(c, u), f = Math.max(c, u), p = t(n, `${r}.from`, s.from, {
+		minimum: d,
+		maximum: d
+	}), m = t(n, `${r}.to`, s.to, {
+		minimum: f,
+		maximum: f
+	}), h = e(n, `${r}.empty`, s.empty);
+	if (h !== (c === u)) throw TypeError(`${n}: ${r}.empty не соответствует anchor/head. / ${n}: ${r}.empty does not match anchor/head.`);
+	return Object.freeze({
+		anchor: c,
+		head: u,
+		from: p,
+		to: m,
+		empty: h
+	});
+}
+function m(e, t, n) {
+	let r = l(e, "viewState", t, s);
+	return Object.freeze({
+		selection: p(e, "viewState.selection", r.selection, n),
+		scrollTop: u(e, "viewState.scrollTop", r.scrollTop),
+		scrollLeft: u(e, "viewState.scrollLeft", r.scrollLeft)
+	});
+}
+function h(e, t, a) {
+	if (!Array.isArray(t)) throw TypeError(`${e}: diagnostics должен быть массивом. / ${e}: diagnostics must be an array.`);
+	let o = /* @__PURE__ */ new Set();
+	return t.forEach((t, s) => {
+		let u = `diagnostics[${s}]`, p = l(e, u, t, c), m = d(e, `${u}.id`, p.id);
+		if (o.has(m)) throw TypeError(`${e}: ${u}.id дублирует ${JSON.stringify(m)}. / ${e}: ${u}.id duplicates ${JSON.stringify(m)}.`);
+		o.add(m), n(e, `${u}.severity`, p.severity, i), r(e, `${u}.message`, p.message), f(e, u, {
+			from: p.from,
+			to: p.to
+		}, a), p.source !== void 0 && r(e, `${u}.source`, p.source), p.code !== void 0 && d(e, `${u}.code`, p.code);
+	}), t;
+}
+//#endregion
+export { i as S_CODE_EDITOR_DIAGNOSTIC_SEVERITIES, h as validateCodeEditorDiagnostics, f as validateCodeEditorRange, p as validateCodeEditorSelectionRange, m as validateCodeEditorViewState };

package/dist/src/components/shared/data-display/codeWorkspace.d.ts

@@ -0,0 +1,62 @@
+import { CodeEditorCapabilitiesContract, CodeEditorLanguageContract } from '../../../internal/codeEditorContract';
+import { SCodeEditorDiagnostic, SCodeEditorDiagnosticId, SCodeEditorRange, SCodeEditorSelectionRange, SCodeEditorSelectionSnapshot, SCodeEditorViewState } from './codeEditor';
+export type SCodeWorkspaceDocumentKey = string;
+export type SCodeWorkspaceSessionKey = string;
+export type SCodeWorkspaceRevision = string | number;
+/** Controlled document descriptor. Revision changes replace only this editor session and reset its local history. */
+export interface SCodeWorkspaceDocument {
+    readonly key: SCodeWorkspaceDocumentKey;
+    readonly sessionKey: SCodeWorkspaceSessionKey;
+    readonly label: string;
+    readonly value: string;
+    readonly revision: SCodeWorkspaceRevision;
+    readonly language: CodeEditorLanguageContract;
+    readonly capabilities: CodeEditorCapabilitiesContract;
+    readonly diagnostics?: readonly SCodeEditorDiagnostic<SCodeEditorDiagnosticId>[];
+    readonly readOnly?: boolean;
+    readonly disabled?: boolean;
+    readonly invalid?: boolean;
+    readonly closable?: boolean;
+    readonly placeholder?: string;
+    readonly variant?: 'code' | 'sql';
+}
+/** Controlled text change. Revision stays unchanged until the consumer supplies an authoritative replacement. */
+export interface SCodeWorkspaceDocumentChange {
+    readonly key: SCodeWorkspaceDocumentKey;
+    readonly sessionKey: SCodeWorkspaceSessionKey;
+    readonly revision: SCodeWorkspaceRevision;
+    readonly value: string;
+}
+export interface SCodeWorkspaceSelectionChange {
+    readonly key: SCodeWorkspaceDocumentKey;
+    readonly sessionKey: SCodeWorkspaceSessionKey;
+    readonly selection: SCodeEditorSelectionRange;
+}
+export interface SCodeWorkspaceViewStateChange {
+    readonly key: SCodeWorkspaceDocumentKey;
+    readonly sessionKey: SCodeWorkspaceSessionKey;
+    readonly viewState: SCodeEditorViewState;
+}
+export interface SCodeWorkspaceReleaseRequest {
+    readonly key: SCodeWorkspaceDocumentKey;
+    readonly sessionKey: SCodeWorkspaceSessionKey;
+}
+export interface SCodeWorkspaceDocumentState {
+    readonly key: SCodeWorkspaceDocumentKey;
+    readonly sessionKey: SCodeWorkspaceSessionKey;
+    readonly revision: SCodeWorkspaceRevision;
+    readonly selection: SCodeEditorSelectionSnapshot;
+    readonly viewState: SCodeEditorViewState;
+}
+export interface SCodeWorkspaceEditorApi {
+    focusActive(): void;
+    revealRange(key: SCodeWorkspaceDocumentKey, range: SCodeEditorRange): void;
+    captureDocumentState(key: SCodeWorkspaceDocumentKey): SCodeWorkspaceDocumentState;
+    releaseSession(sessionKey: SCodeWorkspaceSessionKey): void;
+}
+/** Validates and freezes the exact controlled document contract without normalizing invalid input. */
+export declare function validateCodeWorkspaceDocument(owner: string, coordinate: string, value: unknown): SCodeWorkspaceDocument;
+/** Validates document/session uniqueness for one workspace inventory. */
+export declare function validateCodeWorkspaceDocuments(owner: string, value: unknown): readonly SCodeWorkspaceDocument[];
+/** Validates controlled selection and rejects missing active documents. */
+export declare function validateCodeWorkspaceActiveKey(owner: string, value: unknown, documents: readonly SCodeWorkspaceDocument[]): SCodeWorkspaceDocumentKey | null;

package/dist/src/components/shared/data-display/codeWorkspace.js

@@ -0,0 +1,84 @@
+import { validateBoolean as e, validateNonEmptyString as t } from "../../../internal/runtimeContract.js";
+import { validateCodeEditorCapabilities as n, validateCodeEditorLanguage as r, validateCodeEditorVariant as i } from "../../../internal/codeEditorContract.js";
+import { validateCodeEditorDiagnostics as a } from "./codeEditor.js";
+//#region src/components/shared/data-display/codeWorkspace.ts
+var o = /* @__PURE__ */ new Set([
+	"key",
+	"sessionKey",
+	"label",
+	"value",
+	"revision",
+	"language",
+	"capabilities",
+	"diagnostics",
+	"readOnly",
+	"disabled",
+	"invalid",
+	"closable",
+	"placeholder",
+	"variant"
+]);
+function s(e, t, n, r) {
+	if (typeof n != "object" || !n || Array.isArray(n) || Object.getPrototypeOf(n) !== Object.prototype) throw TypeError(`${e}: ${t} должен быть plain object. / ${e}: ${t} must be a plain object.`);
+	let i = n, a = Object.keys(i).filter((e) => !r.has(e));
+	if (a.length > 0) throw TypeError(`${e}.${t}: неизвестные поля ${a.map((e) => JSON.stringify(e)).join(", ")}. / ${e}.${t}: unknown fields ${a.map((e) => JSON.stringify(e)).join(", ")}.`);
+	return i;
+}
+function c(e, n, r) {
+	let i = t(e, n, r);
+	if (i !== i.trim()) throw TypeError(`${e}: ${n} не должен содержать окружающие пробелы. / ${e}: ${n} must not contain surrounding whitespace.`);
+	return i;
+}
+function l(e, t, n) {
+	if (typeof n == "string") return c(e, t, n);
+	if (typeof n == "number" && Number.isSafeInteger(n) && n >= 0) return n;
+	throw TypeError(`${e}: ${t} должен быть непустой строкой или неотрицательным safe integer. / ${e}: ${t} must be a non-empty string or non-negative safe integer.`);
+}
+function u(t, n, r, i) {
+	return r === void 0 ? i : e(t, n, r);
+}
+function d(e, n, r) {
+	return r === void 0 ? void 0 : t(e, n, r);
+}
+function f(e, f, p) {
+	let m = s(e, f, p, o);
+	if (typeof m.value != "string") throw TypeError(`${e}: ${f}.value должен быть строкой. / ${e}: ${f}.value must be a string.`);
+	let h = a(e, m.diagnostics ?? [], m.value.length), g = d(e, `${f}.placeholder`, m.placeholder), _ = m.variant === void 0 ? "code" : i(e, m.variant);
+	return Object.freeze({
+		key: c(e, `${f}.key`, m.key),
+		sessionKey: c(e, `${f}.sessionKey`, m.sessionKey),
+		label: t(e, `${f}.label`, m.label),
+		value: m.value,
+		revision: l(e, `${f}.revision`, m.revision),
+		language: r(e, m.language),
+		capabilities: n(e, m.capabilities),
+		diagnostics: h,
+		readOnly: u(e, `${f}.readOnly`, m.readOnly, !1),
+		disabled: u(e, `${f}.disabled`, m.disabled, !1),
+		invalid: u(e, `${f}.invalid`, m.invalid, !1),
+		closable: u(e, `${f}.closable`, m.closable, !0),
+		...g === void 0 ? {} : { placeholder: g },
+		variant: _
+	});
+}
+function p(e, t) {
+	if (!Array.isArray(t)) throw TypeError(`${e}: documents должен быть массивом. / ${e}: documents must be an array.`);
+	let n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set(), i = t.map((t, i) => {
+		let a = f(e, `documents[${i}]`, t);
+		if (n.has(a.key)) throw RangeError(`${e}: duplicate document key ${JSON.stringify(a.key)}.`);
+		if (r.has(a.sessionKey)) throw RangeError(`${e}: duplicate sessionKey ${JSON.stringify(a.sessionKey)}.`);
+		return n.add(a.key), r.add(a.sessionKey), a;
+	});
+	return Object.freeze(i);
+}
+function m(e, t, n) {
+	if (n.length === 0) {
+		if (t === null) return null;
+		throw RangeError(`${e}: activeKey должен быть null для пустого workspace. / ${e}: activeKey must be null for an empty workspace.`);
+	}
+	let r = c(e, "activeKey", t);
+	if (!n.some((e) => e.key === r)) throw RangeError(`${e}: activeKey ${JSON.stringify(r)} отсутствует в documents. / ${e}: activeKey ${JSON.stringify(r)} is absent from documents.`);
+	return r;
+}
+//#endregion
+export { m as validateCodeWorkspaceActiveKey, f as validateCodeWorkspaceDocument, p as validateCodeWorkspaceDocuments };

package/dist/src/components/shared/data-display/diff.d.ts

@@ -0,0 +1,78 @@
+import { CodeEditorLanguageContract } from '../../../internal/codeEditorContract';
+export type SDiffSourceRevision = string | number;
+export type SDiffLanguage = CodeEditorLanguageContract;
+/** Exact text input. UI labels and revisions remain metadata and never participate in line equality. */
+export interface SDiffSource {
+    readonly text: string;
+    readonly label?: string;
+    readonly revision?: SDiffSourceRevision;
+    readonly language?: SDiffLanguage;
+}
+export interface SDiffComputationOptions {
+    readonly contextLines?: number;
+}
+export type SDiffLineBreak = 'lf' | 'crlf' | 'none';
+export type SDiffLineKind = 'unchanged' | 'removed' | 'added';
+export interface SDiffLineSide {
+    readonly lineNumber: number;
+    readonly text: string;
+    readonly lineBreak: SDiffLineBreak;
+}
+/** One semantic line operation. Missing sides are omitted instead of encoded as null. */
+export interface SDiffLine {
+    readonly id: string;
+    readonly kind: SDiffLineKind;
+    readonly before?: SDiffLineSide;
+    readonly after?: SDiffLineSide;
+}
+export interface SDiffHunk {
+    readonly id: string;
+    readonly lineStart: number;
+    readonly lineEnd: number;
+    readonly beforeStart: number;
+    readonly beforeLineCount: number;
+    readonly afterStart: number;
+    readonly afterLineCount: number;
+}
+/** Hidden unchanged interval between hunk windows. Indices use the half-open result.lines domain. */
+export interface SDiffGap {
+    readonly id: string;
+    readonly lineStart: number;
+    readonly lineEnd: number;
+    readonly beforeStart: number;
+    readonly afterStart: number;
+    readonly lineCount: number;
+}
+export interface SDiffSourceSnapshot {
+    readonly lineCount: number;
+    readonly label?: string;
+    readonly revision?: SDiffSourceRevision;
+    readonly language?: SDiffLanguage;
+}
+export interface SDiffSummary {
+    readonly beforeLineCount: number;
+    readonly afterLineCount: number;
+    readonly unchangedLineCount: number;
+    readonly removedLineCount: number;
+    readonly addedLineCount: number;
+    readonly changedLineCount: number;
+}
+/** Serializable, presentation-neutral result shared by synchronous and worker execution paths. */
+export interface SDiffResult {
+    readonly before: SDiffSourceSnapshot;
+    readonly after: SDiffSourceSnapshot;
+    readonly lines: readonly SDiffLine[];
+    readonly hunks: readonly SDiffHunk[];
+    readonly gaps: readonly SDiffGap[];
+    readonly summary: SDiffSummary;
+}
+export declare const S_DIFF_DEFAULT_CONTEXT_LINES = 3;
+export declare const S_DIFF_MAX_CONTEXT_LINES = 100;
+/** Validates an exact source record without coercion or newline normalization. */
+export declare function validateDiffSource(owner: string, coordinate: string, value: unknown): SDiffSource;
+/** Validates computation options and supplies the documented context default. */
+export declare function validateDiffComputationOptions(owner: string, value: unknown): Required<SDiffComputationOptions>;
+/** Validates a worker or persisted result and all cross-record line/count invariants. */
+export declare function validateDiffResult(owner: string, value: unknown): SDiffResult;
+/** Computes the canonical deterministic result on the current thread. Large UI inputs use the worker runtime. */
+export declare function computeDiff(beforeValue: unknown, afterValue: unknown, optionsValue?: unknown): SDiffResult;