@septkit/ui 0.0.41 → 0.0.43

package/dist/index.d.ts

@@ -1,15 +1,26 @@
 import { AcceptableValue } from 'reka-ui';
+import { ApplyResult } from '@dialecte/scl/v2019C1';
 import { BoundExtensionMap } from '@dialecte/core';
 import { Component } from 'vue';
 import { ComponentOptionsMixin } from 'vue';
 import { ComponentProvideOptions } from 'vue';
 import { ComputedRef } from 'vue';
 import { DefineComponent } from 'vue';
+import { DiffNode } from '@dialecte/scl/v2019C1';
+import { DiffReport } from '@dialecte/scl/v2019C1';
 import { ExtensionModule } from '@dialecte/core';
+import { GroupDecision } from '@dialecte/scl/v2019C1';
+import { InjectionKey } from 'vue';
+import { LifecycleScenario } from '@dialecte/scl/v2019C1';
+import { LifecycleTarget } from '@dialecte/scl/v2019C1';
+import { LifecycleVerb } from '@dialecte/scl/v2019C1';
 import { MaybeRefOrGetter } from 'vue';
 import { ProjectChannelMessage } from '@dialecte/core';
 import { PublicProps } from 'vue';
+import { Reactive } from 'vue';
 import { Ref } from 'vue';
+import { Scl } from '@dialecte/scl/v2019C1';
+import { ShallowRef } from 'vue';
 
 declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLButtonElement>;
 
@@ -44,19 +55,30 @@ size: "xs" | "sm" | "md" | "lg" | "xl";
 }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
 
 declare const __VLS_component_4: DefineComponent<__VLS_Props_4, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:open": (value: boolean) => any;
+}, string, PublicProps, Readonly<__VLS_Props_4> & Readonly<{
+"onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+size: DialogSize;
+closable: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare const __VLS_component_5: DefineComponent<__VLS_Props_6, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
 select: (node: ExplorerNode) => any;
 contextmenu: (payload: {
 node: ExplorerNode;
 event: MouseEvent;
 }) => any;
-}, string, PublicProps, Readonly<__VLS_Props_4> & Readonly<{
+"update:expanded": (state: ExplorerExpandedState) => any;
+}, string, PublicProps, Readonly<__VLS_Props_6> & Readonly<{
 onSelect?: ((node: ExplorerNode) => any) | undefined;
 onContextmenu?: ((payload: {
 node: ExplorerNode;
 event: MouseEvent;
 }) => any) | undefined;
+"onUpdate:expanded"?: ((state: ExplorerExpandedState) => any) | undefined;
 }>, {
-defaultExpandedItems: string[];
+expanded: ExplorerExpandedState;
 ariaLabel: string;
 }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
 
@@ -69,6 +91,25 @@ declare type __VLS_Props = {
     modifier?: 'wide' | 'block' | 'square' | 'circle';
 };
 
+declare type __VLS_Props_10 = {
+    detail: ElementDetailVM | undefined;
+};
+
+declare type __VLS_Props_11 = MergeSessionParams & {
+    source?: FileMeta;
+    target?: FileMeta;
+};
+
+declare type __VLS_Props_12 = {
+    items: ExplorerNode[];
+    /** Per-node metadata keyed by node id (change, role, groupId, path). */
+    meta: Record<string, MergeNodeMeta>;
+    /** Current decision per group id. */
+    decisions: Record<string, DecisionAction>;
+    /** Node ids to expand by default (the path to every change). */
+    expandedItems?: string[];
+};
+
 declare type __VLS_Props_2 = {
     /** Trigger color */
     color?: 'neutral' | 'primary' | 'secondary' | 'accent' | 'info' | 'success' | 'warning' | 'error';
@@ -99,15 +140,62 @@ declare type __VLS_Props_3 = {
 };
 
 declare type __VLS_Props_4 = {
+    /** Controlled open state (v-model:open). */
+    open: boolean;
+    title?: string;
+    size?: DialogSize;
+    closable?: boolean;
+    /**
+     * Render in place (no teleport) and position `absolute`, so the dialog is
+     * confined to its nearest positioned ancestor instead of the whole viewport.
+     * The container must be `relative` + `overflow-hidden`.
+     */
+    scoped?: boolean;
+};
+
+declare type __VLS_Props_5 = {
+    host?: DialogController;
+};
+
+declare type __VLS_Props_6 = {
     items: ExplorerNode[];
-    defaultExpandedItems?: string[];
+    expanded?: ExplorerExpandedState;
     ariaLabel?: string;
 };
 
+declare type __VLS_Props_7 = {
+    /** Code to render. */
+    code?: string;
+    /** Shiki language id. Defaults to `xml`. */
+    lang?: string;
+    /** Optional per-line diff status, index-aligned with `code` lines. */
+    lineStatuses?: readonly LineStatus[];
+    loading?: boolean;
+    /** Start with word wrap enabled. */
+    wrap?: boolean;
+};
+
+declare type __VLS_Props_8 = {
+    /** Baseline XML. Omit (or empty) for a purely-added element. */
+    before?: string;
+    /** Resulting XML. */
+    after?: string;
+    loading?: boolean;
+};
+
+declare type __VLS_Props_9 = {
+    size?: 'xs' | 'sm' | 'md';
+    disabled?: boolean;
+};
+
 declare type __VLS_PublicProps = {
     modelValue?: AcceptableValue;
 } & __VLS_Props_3;
 
+declare type __VLS_PublicProps_2 = {
+    modelValue: DecisionAction;
+} & __VLS_Props_9;
+
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: {
@@ -141,6 +229,17 @@ declare function __VLS_template_3(): {
 };
 
 declare function __VLS_template_4(): {
+    attrs: Partial<{}>;
+    slots: {
+        header?(_: {}): any;
+        default?(_: {}): any;
+        footer?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+
+declare function __VLS_template_5(): {
     attrs: Partial<{}>;
     slots: Readonly<{
         'node-prefix'(props: {
@@ -175,6 +274,8 @@ declare type __VLS_TemplateResult_3 = ReturnType<typeof __VLS_template_3>;
 
 declare type __VLS_TemplateResult_4 = ReturnType<typeof __VLS_template_4>;
 
+declare type __VLS_TemplateResult_5 = ReturnType<typeof __VLS_template_5>;
+
 declare type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;
@@ -199,14 +300,80 @@ declare type __VLS_WithTemplateSlots_4<T, S> = T & {
     };
 };
 
+declare type __VLS_WithTemplateSlots_5<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+/** The component + props + options currently mounted in the host. */
+export declare type ActiveDialog = {
+    component: Component;
+    props?: Record<string, unknown>;
+    options: DialogOptions;
+};
+
+/**
+ * Shell-agnostic observable used for the active document id — a current `value`
+ * plus `subscribe` (mirrors the shell's `Observable<T>`, whose value is
+ * `T | undefined`). Structural so the UI layer stays decoupled from
+ * `@septkit/shell-lib`.
+ */
+export declare type ActiveDocumentObservable<GenericValue> = {
+    readonly value: GenericValue | undefined;
+    subscribe(listener: (value: GenericValue | undefined) => void): () => void;
+};
+
+/**
+ * Minimal project surface `useActiveDocument` needs: the cross-realm readiness
+ * probe and the document opener. Real core/scl `Project`s satisfy it as-is.
+ */
+export declare type ActiveDocumentProject<GenericDocument> = {
+    getDocumentStatus: (documentId: string) => Promise<{
+        live: boolean;
+        ready: boolean;
+    }>;
+    openDocument: (documentId: string) => GenericDocument;
+};
+
+/**
+ * Consumer hook run INSIDE the merge transaction, right after `tx.lifecycle.apply`.
+ * Receives the `ApplyResult` (the instance roots the write produced) so a caller can
+ * layer domain-specific post-steps (e.g. naming, wiring) onto the same atomic tx for
+ * both preview and commit, keeping this service domain-agnostic.
+ */
+export declare type AfterApply = (tx: MergeTx, ctx: AfterApplyContext) => Promise<void> | void;
+
+/** Context handed to {@link AfterApply}: the target plus what `apply` produced. */
+declare type AfterApplyContext = {
+    target: LifecycleTarget;
+    report: DiffReport;
+    decisions: Map<string, GroupDecision>;
+    result: ApplyResult;
+};
+
 export declare const Button: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 
 export declare const CATEGORY_ELEMENTS: Record<string, string[]>;
 
+/** How an element or attribute changed between the template and the instance. */
+export declare type ChangeStatus = 'added' | 'removed' | 'modified' | 'unchanged';
+
 declare function closeDropdown(): void;
 
+export declare const CodeBlock: DefineComponent<__VLS_Props_7, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_7> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+/**
+ * Collects the ids of every node that has children, for binding to
+ * Explorer's `expanded` v-model to expand the whole tree.
+ */
+export declare function collectExpandableNodeIds(items: ExplorerNode[]): string[];
+
 export declare const Combobox: __VLS_WithTemplateSlots_3<typeof __VLS_component_3, __VLS_TemplateResult_3["slots"]>;
 
+/** Create a standalone dialog host (pure reactive state, no store). */
+export declare function createDialogHost(): DialogController;
+
 /**
  * Build a per-extension reactive document store.
  *
@@ -235,6 +402,29 @@ export declare function createDocumentStore<GenericBaseDocument, GenericAugmente
     clear: () => void;
 };
 
+/** A user's binary choice on a decision group. */
+export declare type DecisionAction = 'accept' | 'skip';
+
+export declare const DecisionToggle: DefineComponent<__VLS_PublicProps_2, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+"update:modelValue": (value: DecisionAction) => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps_2> & Readonly<{
+"onUpdate:modelValue"?: ((value: DecisionAction) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+/** One attribute row in the element-detail panel (write-oriented +/- view). */
+export declare type DetailAttribute = {
+    name: string;
+    status: ChangeStatus;
+    /** The current/instance value — the `-` line, present when modified/removed. */
+    before?: string;
+    /** The final value that will be written — the `+` line, present when added/modified. */
+    after?: string;
+    /** When set, the attribute is user-editable and its value renders as an input. */
+    editable?: EditableMode;
+    /** The engine auto-resolved a placement collision on this field (value = the resolved one). */
+    conflict?: boolean;
+};
+
 /**
  * Message shapes posted on a dialecte project's BroadcastChannel — the public
  * event contract of @dialecte/core. Alias of core's `ProjectChannelMessage`
@@ -242,8 +432,51 @@ export declare function createDocumentStore<GenericBaseDocument, GenericAugmente
  */
 export declare type DialecteChannelMessage = ProjectChannelMessage;
 
+export declare const Dialog: __VLS_WithTemplateSlots_4<typeof __VLS_component_4, __VLS_TemplateResult_4["slots"]>;
+
+export declare type DialogController = {
+    /** Whether the host dialog is open. */
+    readonly open: Ref<boolean>;
+    /** The active dialog payload, or `undefined` when closed/empty. */
+    readonly active: ShallowRef<ActiveDialog | undefined>;
+    /** Open `component` in the host dialog with (type-checked) `props` and `options`. */
+    openDialog: <C extends Component>(component: C, props?: PropsOf<C>, options?: DialogOptions) => void;
+    /** Close the host dialog. */
+    close: () => void;
+};
+
+export declare const DialogHost: DefineComponent<__VLS_Props_5, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_5> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+/** Injection key for the ambient dialog host. */
+export declare const dialogHostKey: InjectionKey<DialogController>;
+
+/** Presentation options for a hosted dialog (passed through the dialog host). */
+export declare type DialogOptions = {
+    /** Size preset. `full` fills the viewport, `fit` shrinks to the content. Default `md`. */
+    size?: DialogSize;
+    /** Optional heading shown in the dialog chrome. */
+    title?: string;
+    /** Whether the user may dismiss it (close button, escape, click-outside). Default `true`. */
+    closable?: boolean;
+    /** Confine the dialog to the host's container (in place, `absolute`) instead of the viewport. */
+    scoped?: boolean;
+};
+
+/** The width/height presets a {@link Dialog} supports. */
+export declare type DialogSize = 'sm' | 'md' | 'lg' | 'xl' | 'full' | 'fit';
+
+/**
+ * Line-level unified diff (LCS). Unchanged lines are shared; a divergent region
+ * emits its removed lines (from `before`) then its added lines (from `after`),
+ * matching the familiar GitHub-style ordering.
+ */
+export declare function diffLines(before: string, after: string): UnifiedDiff;
+
 export declare const Dropdown: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, __VLS_TemplateResult_2["slots"]>;
 
+/** How the UI may edit an attribute (schema-derived classifier). */
+export declare type EditableMode = 'rename' | 'free';
+
 export declare const ELEMENT_TO_COLOR: Record<string, ElementColor>;
 
 export declare const ELEMENT_TO_ICON: Record<string, Component>;
@@ -253,6 +486,30 @@ export declare interface ElementColor {
     background: string;
 }
 
+export declare const ElementDetail: DefineComponent<__VLS_Props_10, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+edit: (attr: string, value: string) => any;
+}, string, PublicProps, Readonly<__VLS_Props_10> & Readonly<{
+onEdit?: ((attr: string, value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+/** View-model for the selected element's detail panel. */
+export declare type ElementDetailVM = {
+    tag: string;
+    title: string;
+    change: ChangeStatus;
+    attributes: DetailAttribute[];
+};
+
+/**
+ * Controlled expand state (v-model:expanded). `scoped` is the exact list of
+ * expanded node ids; `all` expands every node with children and takes
+ * precedence over `scoped` when true.
+ */
+export declare type ExplorerExpandedState = {
+    scoped: string[];
+    all: boolean;
+};
+
 export declare type ExplorerNode = {
     tag: string;
     id: string;
@@ -280,6 +537,33 @@ export declare type ExtendedDocument<GenericDocument, GenericQuery, GenericTrans
 /** Map of named extension modules. */
 export declare type ExtensionsConfig = Record<string, ExtensionModule>;
 
+/** Display metadata for a merged file (source or target), shown in the review header. */
+export declare type FileMeta = {
+    /** Display name (filename, typically without extension). */
+    label: string;
+    /** File-type badge (`Header.fileType` or extension). */
+    type?: string;
+    /** SCL `Header` @version. */
+    version: string;
+    /** SCL `Header` @revision. */
+    revision: string;
+};
+
+/**
+ * Render code to syntax-highlighted HTML using Shiki's VSCode grammars/themes.
+ * The JavaScript RegExp engine is used (not the WASM/oniguruma engine) so the
+ * build stays self-contained with no separate WASM asset to ship.
+ *
+ * When `lineStatuses` is provided, each line node gets a `diff add` / `diff remove`
+ * class so a diff background can be painted on top of the highlighting.
+ */
+export declare function highlightCode(code: string, options?: {
+    lang?: string;
+    lineStatuses?: readonly LineStatus[];
+}): Promise<string>;
+
+export declare type LineStatus = 'added' | 'removed' | 'unchanged';
+
 /**
  * Minimal slice of a `Document` consumed by `useLiveData`: the id it queries
  * and the project channel it listens on. Structural (not `Pick<Document, ...>`)
@@ -290,16 +574,123 @@ export declare type LiveDataDocument = {
     channelName: string;
 };
 
+/**
+ * Per-node metadata the merge tree overlays on an `ExplorerNode` (keyed by node id).
+ * The tree itself is a plain `ExplorerNode[]`; this side map drives change colour, the
+ * decision control, and the spotlight/skip styling.
+ */
+export declare type MergeNodeMeta = {
+    change: ChangeStatus;
+    /** `primary` rows carry the decision control; `companion` rows are read-only side effects. */
+    role: 'primary' | 'companion' | 'plain';
+    /** The decision group this node belongs to (primary + companions share it). */
+    groupId?: string;
+    /** For a satellite companion that lives elsewhere: its real document path (shown as subtitle). */
+    path?: string;
+};
+
+export declare const MergeReview: DefineComponent<__VLS_Props_11, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+close: () => any;
+applied: () => any;
+}, string, PublicProps, Readonly<__VLS_Props_11> & Readonly<{
+onClose?: (() => any) | undefined;
+onApplied?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
+export declare type MergeSessionParams = {
+    targetDocument: Scl.Document;
+    sourceQuery: Scl.Query;
+    verb: LifecycleVerb;
+    /** Operation to perform: place a new instance, or reconcile the existing one. */
+    scenario: LifecycleScenario;
+    /** Source (template) element: a Function (fsd) or Application (asd). */
+    sourceRef: Scl.Ref<'Function'> | Scl.Ref<'Application'>;
+    /** Target parent the instance lives under / is placed into. */
+    anchor: Scl.Ref<Scl.ElementsOf>;
+    /** Optional consumer post-step run inside the merge tx (preview + commit). */
+    afterApply?: AfterApply;
+};
+
+export declare const MergeTree: DefineComponent<__VLS_Props_12, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+select: (node: ExplorerNode) => any;
+"update:decision": (groupId: string, action: DecisionAction) => any;
+}, string, PublicProps, Readonly<__VLS_Props_12> & Readonly<{
+onSelect?: ((node: ExplorerNode) => any) | undefined;
+"onUpdate:decision"?: ((groupId: string, action: DecisionAction) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+/** The transaction handle passed to `prepare`/`transaction` callbacks. */
+declare type MergeTx = Parameters<Parameters<Scl.Document['prepare']>[0]>[0];
+
+/** The props a component accepts (declared props + Vue built-ins like `onXxx` listeners). */
+declare type PropsOf<C extends Component> = C extends new (...args: never[]) => {
+    $props: infer P;
+} ? P : Record<string, never>;
+
+/** Create (or adopt) a dialog host and provide it to descendants. Call once at the root. */
+export declare function provideDialogHost(host?: DialogController): DialogController;
+
 declare type QueryMapOf<GenericExtensions extends ExtensionsConfig> = {
     [ExtensionName in keyof GenericExtensions as GenericExtensions[ExtensionName]['query'] extends object ? ExtensionName : never]: NonNullable<GenericExtensions[ExtensionName]['query']>;
 };
 
-export declare const SclExplorer: __VLS_WithTemplateSlots_4<typeof __VLS_component_4, __VLS_TemplateResult_4["slots"]>;
+export declare const SclExplorer: __VLS_WithTemplateSlots_5<typeof __VLS_component_5, __VLS_TemplateResult_5["slots"]>;
+
+/** Per-node selection payload: what to preview and (if any) the change it carries. */
+declare type StructuralNodeInfo = {
+    previewRef: Scl.Ref<Scl.ElementsOf>;
+    change: ChangeStatus;
+    role: 'primary' | 'companion' | 'plain';
+    groupId?: string;
+    node?: DiffNode;
+};
+
+declare type StructuralTree = {
+    items: ExplorerNode[];
+    /** Per node-id metadata (change, role, groupId) for the explorer decoration. */
+    meta: Record<string, MergeNodeMeta>;
+    /** Selection payload per node id. */
+    index: Record<string, StructuralNodeInfo>;
+    /** Ids on the path to any change — the explorer opens these by default. */
+    expanded: string[];
+};
 
 declare type TransactionMapOf<GenericExtensions extends ExtensionsConfig> = {
     [ExtensionName in keyof GenericExtensions as GenericExtensions[ExtensionName]['transaction'] extends object ? ExtensionName : never]: NonNullable<GenericExtensions[ExtensionName]['transaction']>;
 };
 
+export declare type UnifiedDiff = {
+    /** Every line (removed + added + unchanged), joined for a single highlight pass. */
+    code: string;
+    /** Per-line status, index-aligned with the lines of `code`. */
+    statuses: LineStatus[];
+};
+
+/**
+ * Reactively hydrate the shell's active document — race-safe across realms.
+ *
+ * The active-document id (shell `localStorage` `storage` event) and the
+ * project's document registry (BroadcastChannel) are not ordered across realms,
+ * so in an iframe extension the id can arrive before the document is registered
+ * / its records are readable. `project.getDocumentStatus(id)` reconciles this
+ * realm's store against persisted state first, so hydration never races ahead
+ * of the document. Results from a superseded switch are ignored.
+ *
+ * Cleanup runs automatically when used inside a component/effect scope; the
+ * returned `stop` lets scope-less callers (e.g. an extension bootstrap) tear it
+ * down manually.
+ */
+export declare function useActiveDocument<GenericDocument>(params: {
+    project: ActiveDocumentProject<GenericDocument>;
+    activeDocumentId: ActiveDocumentObservable<string>;
+    hydrate: (doc: GenericDocument) => void;
+    clear: () => void;
+}): {
+    isReady: Ref<boolean>;
+    activeDocumentId: Ref<string | undefined>;
+    stop: () => void;
+};
+
 /**
  * Listen to a dialecte project's BroadcastChannel.
  *
@@ -319,6 +710,9 @@ export declare function useDialecteChannel(channelName: MaybeRefOrGetter<string
     isSupported: Ref<boolean>;
 };
 
+/** Inject the ambient dialog host. Throws if no host was provided. */
+export declare function useDialog(): DialogController;
+
 /**
  * Async data that refetches when its document changes.
  *
@@ -338,6 +732,28 @@ export declare function useLiveData<T>(params: {
     refresh: (delay?: number) => Promise<T | undefined>;
 };
 
+/**
+ * Drives one merge-review session: runs `report`, holds the decision map + selection,
+ * builds an element-scoped merged-XML preview from a single preview-apply, and commits.
+ * The UI panels read the reactive refs and call the setters.
+ */
+export declare function useMergeSession(params: MergeSessionParams): {
+    report: ShallowRef<DiffReport | undefined, DiffReport | undefined>;
+    decisions: Reactive<Map<string, GroupDecision>>;
+    structuralTree: ShallowRef<StructuralTree, StructuralTree>;
+    previewXml: ShallowRef<string | undefined, string | undefined>;
+    previewBeforeXml: ShallowRef<string | undefined, string | undefined>;
+    previewLoading: ShallowRef<boolean, boolean>;
+    load: () => Promise<void>;
+    setDecision: (groupId: string, action: "accept" | "skip") => void;
+    setValue: (groupId: string, attr: string, value: string) => void;
+    decisionOf: (groupId: string) => "accept" | "skip";
+    editedValue: (groupId: string, attr: string) => string | undefined;
+    select: (sel: StructuralNodeInfo | undefined) => void;
+    stagedAttributes: (ref: Scl.Ref<Scl.ElementsOf>) => Promise<Record<string, string | undefined>>;
+    commit: () => Promise<void>;
+};
+
 /**
  * Async data that refetches when anything in the project changes:
  * commits on any document, imports, removals, new documents.
@@ -356,4 +772,6 @@ export declare function useProjectLiveData<T>(params: {
     refresh: (delay?: number) => Promise<T | undefined>;
 };
 
+export declare const XmlDiff: DefineComponent<__VLS_Props_8, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_8> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
+
 export { }

package/dist/index.js

@@ -1,13 +1,30 @@
 import { createDocumentStore as e } from "./dialecte/create-document-store.js";
 import { useDialecteChannel as t } from "./dialecte/composables/use-dialecte-channel.js";
 import { useLiveData as n, useProjectLiveData as r } from "./dialecte/composables/use-live-data.js";
+import { useActiveDocument as i } from "./dialecte/composables/use-active-document.js";
 import "./dialecte/index.js";
-import i from "./button/button.js";
-import a from "./dropdown/dropdown.js";
-import o from "./dropdown/combobox.js";
+import a from "./button/button.js";
+import o from "./dropdown/dropdown.js";
+import s from "./dropdown/combobox.js";
 import "./dropdown/index.js";
-import { CATEGORY_ELEMENTS as s, ELEMENT_TO_COLOR as c } from "./icons/element-color-map.generated.js";
-import { ELEMENT_TO_ICON as l } from "./icons/element-icon-mapper.js";
-import u from "./explorer/explorer.js";
+import c from "./dialog/dialog.js";
+import { createDialogHost as l, dialogHostKey as u, provideDialogHost as d, useDialog as f } from "./dialog/use-dialog-host.js";
+import p from "./dialog/dialog-host.js";
+import "./dialog/index.js";
+import { CATEGORY_ELEMENTS as m, ELEMENT_TO_COLOR as h } from "./icons/element-color-map.generated.js";
+import { ELEMENT_TO_ICON as g } from "./icons/element-icon-mapper.js";
+import { collectExpandableNodeIds as _ } from "./explorer/collect-expandable-node-ids.js";
+import v from "./explorer/explorer.js";
 import "./explorer/index.js";
-export { i as Button, s as CATEGORY_ELEMENTS, o as Combobox, a as Dropdown, c as ELEMENT_TO_COLOR, l as ELEMENT_TO_ICON, u as SclExplorer, e as createDocumentStore, t as useDialecteChannel, n as useLiveData, r as useProjectLiveData };
+import { highlightCode as y } from "./code/highlight.js";
+import b from "./code/code-block.js";
+import { diffLines as x } from "./code/diff.js";
+import S from "./code/xml-diff.js";
+import "./code/index.js";
+import C from "./merge/decision-toggle.js";
+import w from "./merge/element-detail.js";
+import T from "./merge/merge-tree.js";
+import { useMergeSession as E } from "./merge/use-merge-session.js";
+import D from "./merge/merge-review.js";
+import "./merge/index.js";
+export { a as Button, m as CATEGORY_ELEMENTS, b as CodeBlock, s as Combobox, C as DecisionToggle, c as Dialog, p as DialogHost, o as Dropdown, h as ELEMENT_TO_COLOR, g as ELEMENT_TO_ICON, w as ElementDetail, D as MergeReview, T as MergeTree, v as SclExplorer, S as XmlDiff, _ as collectExpandableNodeIds, l as createDialogHost, e as createDocumentStore, u as dialogHostKey, x as diffLines, y as highlightCode, d as provideDialogHost, i as useActiveDocument, t as useDialecteChannel, f as useDialog, n as useLiveData, E as useMergeSession, r as useProjectLiveData };