@zephytiju/prism-main-editor 0.1.0

package/dist/blocks/EvidenceTableView.d.ts

@@ -0,0 +1,25 @@
+import type { MainEditorLocale } from "../locales/index.js";
+import type { EvidenceTableBlock as EvidenceTableBlockModel } from "../types.js";
+export interface EvidenceTableViewProps {
+    readonly block: EvidenceTableBlockModel;
+    readonly locale: MainEditorLocale;
+}
+/**
+ * Embedded block — Evidence Table (D10): the block row HOSTS the real
+ * published table component `@zephytiju/prism-evidence-table` (0.1.0). The
+ * hosted component provides its own card chrome — kind tag EVIDENCE TABLE,
+ * SRC FILE chip, VIEW ▾ variant dropdown, ↗ open arrow — and renders the
+ * previewed saved view's IEvidenceSource-shaped rows (source / observation /
+ * confidence / audit locator) with row separators and per-row audit drill
+ * links. Its variant state lives on the "evidence-table.selected-view"
+ * channel (file-level selection). Being a table does NOT make a block
+ * embedded — only file-preview blocks are (D10).
+ *
+ * The editor contributes NO synthetic table rendering — only the hosting
+ * configuration from the block model (sourceFileRef, savedViews, optional
+ * controlled selection / layout / columns) plus the locale and the
+ * translation of the ↗ arrow's open intent into the editor's
+ * "main-editor.open-view-requested" channel.
+ */
+export declare function EvidenceTableView({ block, locale }: EvidenceTableViewProps): import("react").JSX.Element;
+//# sourceMappingURL=EvidenceTableView.d.ts.map

package/dist/blocks/EvidenceTableView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EvidenceTableView.d.ts","sourceRoot":"","sources":["../../src/blocks/EvidenceTableView.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EACV,kBAAkB,IAAI,uBAAuB,EAE9C,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,KAAK,EAAE,uBAAuB,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,sBAAsB,+BAoB1E"}

package/dist/blocks/EvidenceTableView.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box } from "@mantine/core";
+import { emitPrismEvent } from "@zephytiju/prism-react";
+import { EvidenceTable } from "@zephytiju/prism-evidence-table";
+/**
+ * Embedded block — Evidence Table (D10): the block row HOSTS the real
+ * published table component `@zephytiju/prism-evidence-table` (0.1.0). The
+ * hosted component provides its own card chrome — kind tag EVIDENCE TABLE,
+ * SRC FILE chip, VIEW ▾ variant dropdown, ↗ open arrow — and renders the
+ * previewed saved view's IEvidenceSource-shaped rows (source / observation /
+ * confidence / audit locator) with row separators and per-row audit drill
+ * links. Its variant state lives on the "evidence-table.selected-view"
+ * channel (file-level selection). Being a table does NOT make a block
+ * embedded — only file-preview blocks are (D10).
+ *
+ * The editor contributes NO synthetic table rendering — only the hosting
+ * configuration from the block model (sourceFileRef, savedViews, optional
+ * controlled selection / layout / columns) plus the locale and the
+ * translation of the ↗ arrow's open intent into the editor's
+ * "main-editor.open-view-requested" channel.
+ */
+export function EvidenceTableView({ block, locale }) {
+    return (_jsx(Box, { "data-testid": `main-editor-block-${block.id}`, children: _jsx(EvidenceTable, { sourceFileRef: block.sourceFileRef, savedViews: block.savedViews, selectedViewId: block.selectedViewId, layout: block.layout, columns: block.columns, locale: locale, onOpenView: (intent) => {
+                const request = {
+                    sourceFileRef: intent.sourceFileRef,
+                    viewId: intent.viewId,
+                };
+                emitPrismEvent("main-editor.open-view-requested", request);
+            } }) }));
+}

package/dist/blocks/GeovisionEmbedView.d.ts

@@ -0,0 +1,28 @@
+import type { MainEditorLocale } from "../locales/index.js";
+import type { GeovisionEmbedBlock as GeovisionEmbedBlockModel } from "../types.js";
+export interface GeovisionEmbedViewProps {
+    readonly block: GeovisionEmbedBlockModel;
+    readonly locale: MainEditorLocale;
+}
+/**
+ * Embedded block — Geovision Embed (D10): the block row HOSTS the real
+ * published chrome component `@zephytiju/prism-geovision-embed-block`
+ * (0.2.0). The hosted block provides the full D10 card chrome — kind tag
+ * GEOVISION, SRC FILE chip, VIEW ▾ variant dropdown fed by the render
+ * package's describeViews(sourceFileRef) through the host Lattice transport,
+ * and the ↗ open arrow — and itself hosts the real render dispatcher
+ * (`@zephytiju/prism-geovision-embed`) in its body slot, rendering exactly
+ * the ONE variant the current viewId (`${fileRef}#${previewKind}`) selects.
+ * The variant state is owned by the block through its
+ * "geovision-embed.selected-view" channel (file-level selection — every
+ * embed of the same source file re-previews the picked variant).
+ *
+ * The editor contributes NO synthetic preview — only the hosting
+ * configuration from the block model (sourceFileRef, optional explicit views
+ * / controlled selection / engine passthrough) plus the locale and the
+ * translation of the ↗ arrow's open intent into the editor's
+ * "main-editor.open-view-requested" channel, so hosts keep ONE open-intent
+ * contract for every embedded block.
+ */
+export declare function GeovisionEmbedView({ block, locale }: GeovisionEmbedViewProps): import("react").JSX.Element;
+//# sourceMappingURL=GeovisionEmbedView.d.ts.map

package/dist/blocks/GeovisionEmbedView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeovisionEmbedView.d.ts","sourceRoot":"","sources":["../../src/blocks/GeovisionEmbedView.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EACV,mBAAmB,IAAI,wBAAwB,EAEhD,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,KAAK,EAAE,wBAAwB,CAAC;IACzC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,uBAAuB,+BAmB5E"}

package/dist/blocks/GeovisionEmbedView.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box } from "@mantine/core";
+import { emitPrismEvent } from "@zephytiju/prism-react";
+import { GeovisionEmbedBlock } from "@zephytiju/prism-geovision-embed-block";
+/**
+ * Embedded block — Geovision Embed (D10): the block row HOSTS the real
+ * published chrome component `@zephytiju/prism-geovision-embed-block`
+ * (0.2.0). The hosted block provides the full D10 card chrome — kind tag
+ * GEOVISION, SRC FILE chip, VIEW ▾ variant dropdown fed by the render
+ * package's describeViews(sourceFileRef) through the host Lattice transport,
+ * and the ↗ open arrow — and itself hosts the real render dispatcher
+ * (`@zephytiju/prism-geovision-embed`) in its body slot, rendering exactly
+ * the ONE variant the current viewId (`${fileRef}#${previewKind}`) selects.
+ * The variant state is owned by the block through its
+ * "geovision-embed.selected-view" channel (file-level selection — every
+ * embed of the same source file re-previews the picked variant).
+ *
+ * The editor contributes NO synthetic preview — only the hosting
+ * configuration from the block model (sourceFileRef, optional explicit views
+ * / controlled selection / engine passthrough) plus the locale and the
+ * translation of the ↗ arrow's open intent into the editor's
+ * "main-editor.open-view-requested" channel, so hosts keep ONE open-intent
+ * contract for every embedded block.
+ */
+export function GeovisionEmbedView({ block, locale }) {
+    return (_jsx(Box, { "data-testid": `main-editor-block-${block.id}`, children: _jsx(GeovisionEmbedBlock, { sourceFileRef: block.sourceFileRef, views: block.views, selectedViewId: block.selectedViewId, engine: block.engine, locale: locale, onOpenView: (intent) => {
+                const request = {
+                    sourceFileRef: intent.sourceFileRef,
+                    viewId: intent.viewId,
+                };
+                emitPrismEvent("main-editor.open-view-requested", request);
+            } }) }));
+}

package/dist/blocks/InsertMenu.d.ts

@@ -0,0 +1,22 @@
+import type { MainEditorLocale } from "../locales/index.js";
+import type { MainEditorBlockKind } from "../types.js";
+/** Label resolver: block kind → localized menu label. */
+export type KindLabelFn = (kind: MainEditorBlockKind) => string;
+export interface InsertMenuProps {
+    readonly buttonTestId: string;
+    readonly kinds: readonly MainEditorBlockKind[];
+    readonly kindLabel: KindLabelFn;
+    readonly afterBlockId: string | null;
+    readonly locale: MainEditorLocale;
+    readonly compact?: boolean;
+}
+/**
+ * The block gutter's insert control (D3/D10): the circular + button that
+ * opens the block-kind menu. Picking a kind emits
+ * "main-editor.insert-block-requested" (an IDossierDoc ACTION the host
+ * applies — blocks are added at app runtime, never composition mutations)
+ * and inserts AFTER afterBlockId (null = top of the stack). Also used
+ * compact at the end-of-stack affordance.
+ */
+export declare function InsertMenu({ buttonTestId, kinds, kindLabel, afterBlockId, locale, compact, }: InsertMenuProps): import("react").JSX.Element;
+//# sourceMappingURL=InsertMenu.d.ts.map

package/dist/blocks/InsertMenu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InsertMenu.d.ts","sourceRoot":"","sources":["../../src/blocks/InsertMenu.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EACV,mBAAmB,EAEpB,MAAM,aAAa,CAAC;AAIrB,yDAAyD;AACzD,MAAM,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,mBAAmB,KAAK,MAAM,CAAC;AAEhE,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC/C,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;IAChC,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,EACzB,YAAY,EACZ,KAAK,EACL,SAAS,EACT,YAAY,EACZ,MAAM,EACN,OAAO,GACR,EAAE,eAAe,+BAyFjB"}

package/dist/blocks/InsertMenu.js

@@ -0,0 +1,59 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box } from "@mantine/core";
+import { emitPrismEvent } from "@zephytiju/prism-react";
+import { stringsForLocale } from "../locales/index.js";
+import { ACCENT, BORDER, CARD, LINE } from "../tokens.js";
+import { menuHeaderStyle, menuOptionStyle } from "./menuStyles.js";
+/**
+ * The block gutter's insert control (D3/D10): the circular + button that
+ * opens the block-kind menu. Picking a kind emits
+ * "main-editor.insert-block-requested" (an IDossierDoc ACTION the host
+ * applies — blocks are added at app runtime, never composition mutations)
+ * and inserts AFTER afterBlockId (null = top of the stack). Also used
+ * compact at the end-of-stack affordance.
+ */
+export function InsertMenu({ buttonTestId, kinds, kindLabel, afterBlockId, locale, compact, }) {
+    const strings = stringsForLocale(locale);
+    const [open, setOpen] = useState(false);
+    return (_jsxs(Box, { style: { position: "relative", flexShrink: 0 }, children: [_jsx("button", { type: "button", style: {
+                    width: 30,
+                    height: 30,
+                    borderRadius: 15,
+                    background: CARD,
+                    border: `1px solid ${ACCENT}`,
+                    fontSize: compact ? 16 : 18,
+                    fontWeight: 500,
+                    color: ACCENT,
+                    display: "inline-flex",
+                    alignItems: "center",
+                    justifyContent: "center",
+                    cursor: "pointer",
+                    lineHeight: 1,
+                }, title: strings.insertMenuTitle, "data-testid": buttonTestId, onClick: () => {
+                    setOpen((value) => !value);
+                }, children: "+" }), open ? (_jsxs(_Fragment, { children: [_jsx("div", { style: { position: "fixed", inset: 0, zIndex: 8 }, onClick: () => {
+                            setOpen(false);
+                        } }), _jsxs(Box, { component: "ul", w: 228, py: 4, style: {
+                            position: "absolute",
+                            top: 34,
+                            left: 0,
+                            background: CARD,
+                            border: `1px solid ${LINE}`,
+                            borderRadius: 6,
+                            boxShadow: "0 8px 24px rgba(0,0,0,.55)",
+                            zIndex: 9,
+                            listStyle: "none",
+                            margin: 0,
+                        }, "data-testid": `${buttonTestId}-menu`, role: "menu", children: [_jsx("li", { style: menuHeaderStyle, children: strings.insertMenuTitle }), kinds.map((kind) => (_jsx("li", { children: _jsxs("button", { type: "button", role: "menuitem", style: menuOptionStyle, "data-testid": `${buttonTestId}-option-${kind}`, onClick: () => {
+                                        const request = { afterBlockId, kind };
+                                        emitPrismEvent("main-editor.insert-block-requested", request);
+                                        setOpen(false);
+                                    }, children: [_jsx("span", { style: {
+                                                width: 5,
+                                                height: 5,
+                                                borderRadius: "50%",
+                                                background: BORDER,
+                                                flexShrink: 0,
+                                            } }), kindLabel(kind)] }) }, kind)))] })] })) : null] }));
+}

package/dist/blocks/InsertRail.d.ts

@@ -0,0 +1,28 @@
+import type { MainEditorLocale } from "../locales/index.js";
+import type { MainEditorBlockKind } from "../types.js";
+import type { KindLabelFn } from "./InsertMenu.js";
+export interface InsertRailProps {
+    readonly blockId: string;
+    readonly kinds: readonly MainEditorBlockKind[];
+    readonly kindLabel: KindLabelFn;
+    readonly canMoveUp: boolean;
+    readonly canMoveDown: boolean;
+    readonly locale: MainEditorLocale;
+    readonly showInsert: boolean;
+    /**
+     * D11: the gutter renders ONLY while its row is hovered (or focused within,
+     * keeping keyboard access) — the 120ms opacity fade is driven by the row's
+     * hover/focus state, never an always-visible rail.
+     */
+    readonly revealed: boolean;
+}
+/**
+ * The left rail (block gutter) of one block row (D3/D11): the + insert control
+ * opening the block-kind menu, the ⠿ drag/reorder handle with its click-open
+ * block popover, and the dashed guide line filling the remaining width. The
+ * whole gutter fades in on row hover (opacity transition ~120ms) and out when
+ * the pointer leaves — it is invisible in the resting document. Clicks never
+ * propagate to the block surface behind it.
+ */
+export declare function InsertRail({ blockId, kinds, kindLabel, canMoveUp, canMoveDown, locale, showInsert, revealed, }: InsertRailProps): import("react").JSX.Element;
+//# sourceMappingURL=InsertRail.d.ts.map

package/dist/blocks/InsertRail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InsertRail.d.ts","sourceRoot":"","sources":["../../src/blocks/InsertRail.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAIvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC/C,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,EACzB,OAAO,EACP,KAAK,EACL,SAAS,EACT,SAAS,EACT,WAAW,EACX,MAAM,EACN,UAAU,EACV,QAAQ,GACT,EAAE,eAAe,+BA8CjB"}

package/dist/blocks/InsertRail.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box } from "@mantine/core";
+import { BORDER } from "../tokens.js";
+import { DragMenu } from "./DragMenu.js";
+import { InsertMenu } from "./InsertMenu.js";
+/**
+ * The left rail (block gutter) of one block row (D3/D11): the + insert control
+ * opening the block-kind menu, the ⠿ drag/reorder handle with its click-open
+ * block popover, and the dashed guide line filling the remaining width. The
+ * whole gutter fades in on row hover (opacity transition ~120ms) and out when
+ * the pointer leaves — it is invisible in the resting document. Clicks never
+ * propagate to the block surface behind it.
+ */
+export function InsertRail({ blockId, kinds, kindLabel, canMoveUp, canMoveDown, locale, showInsert, revealed, }) {
+    return (_jsx(Box, { w: 72, style: { display: "flex", alignItems: "center", gap: 6, paddingTop: 8, flexShrink: 0 }, onClick: (event) => {
+            event.stopPropagation();
+        }, children: _jsxs(Box, { style: {
+                display: "flex",
+                alignItems: "center",
+                gap: 6,
+                flex: 1,
+                opacity: revealed ? 1 : 0,
+                transition: "opacity .12s ease",
+            }, "data-testid": `main-editor-gutter-${blockId}`, children: [showInsert ? (_jsx(InsertMenu, { buttonTestId: `main-editor-insert-${blockId}`, kinds: kinds, kindLabel: kindLabel, afterBlockId: blockId, locale: locale })) : null, _jsx(DragMenu, { blockId: blockId, canMoveUp: canMoveUp, canMoveDown: canMoveDown, locale: locale }), _jsx("span", { style: {
+                        flex: 1,
+                        borderTop: `1px dashed ${BORDER}`,
+                        marginTop: 2,
+                    }, "aria-hidden": "true" })] }) }));
+}

package/dist/blocks/NarrativeBlockView.d.ts

@@ -0,0 +1,22 @@
+import type { NarrativeBlock as NarrativeBlockModel } from "../types.js";
+export interface NarrativeBlockViewProps {
+    readonly block: NarrativeBlockModel;
+    /**
+     * D11: in the editor variant the heading and paragraph are editable text
+     * surfaces — selecting inside them opens the floating selection toolbar.
+     */
+    readonly editable?: boolean;
+}
+/**
+ * Normal document block — narrative (D10): a plain document element with NO
+ * outlining box, no card background, no kind pill. Source links are ordinary
+ * inline hyperlinks embedded inside the paragraph text — accent-colored,
+ * underlined, preceded by the ↗ glyph — never standalone link blocks.
+ *
+ * D11: when editable, the heading and paragraph carry the
+ * data-main-editor-editable attribute the selection toolbar anchors to; the
+ * DOM is the editing surface (style mutations apply in place), the channel
+ * projection stays authoritative for content.
+ */
+export declare function NarrativeBlockView({ block, editable }: NarrativeBlockViewProps): import("react").JSX.Element;
+//# sourceMappingURL=NarrativeBlockView.d.ts.map

package/dist/blocks/NarrativeBlockView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NarrativeBlockView.d.ts","sourceRoot":"","sources":["../../src/blocks/NarrativeBlockView.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,IAAI,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEzE,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAAC;IACpC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,KAAK,EAAE,QAAgB,EAAE,EAAE,uBAAuB,+BA6EtF"}

package/dist/blocks/NarrativeBlockView.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Stack, Text } from "@mantine/core";
+/**
+ * Normal document block — narrative (D10): a plain document element with NO
+ * outlining box, no card background, no kind pill. Source links are ordinary
+ * inline hyperlinks embedded inside the paragraph text — accent-colored,
+ * underlined, preceded by the ↗ glyph — never standalone link blocks.
+ *
+ * D11: when editable, the heading and paragraph carry the
+ * data-main-editor-editable attribute the selection toolbar anchors to; the
+ * DOM is the editing surface (style mutations apply in place), the channel
+ * projection stays authoritative for content.
+ */
+export function NarrativeBlockView({ block, editable = false }) {
+    const editableDataProps = editable
+        ? {
+            contentEditable: true,
+            suppressContentEditableWarning: true,
+            spellCheck: false,
+            "data-main-editor-editable": block.id,
+        }
+        : {};
+    return (_jsxs(Stack, { gap: 10, "data-testid": `main-editor-block-${block.id}`, children: [block.heading ? (_jsx(Text, { fz: 16, fw: 600, c: "text", style: {
+                    lineHeight: 1.4,
+                    letterSpacing: "0.01em",
+                    ...(editable ? { cursor: "text", outline: "none" } : {}),
+                }, "data-testid": `main-editor-narrative-heading-${block.id}`, ...editableDataProps, children: block.heading })) : null, _jsx(Text, { fz: 12, style: {
+                    lineHeight: 1.6,
+                    color: "var(--mantine-color-muted-filled)",
+                    ...(editable ? { cursor: "text", outline: "none" } : {}),
+                }, "data-testid": `main-editor-narrative-paragraph-${block.id}`, ...editableDataProps, children: block.spans.map((span, index) => span.kind === "text" ? (_jsx("span", { children: span.text }, index)) : (_jsxs("span", { children: [_jsxs("span", { "aria-hidden": "true", style: {
+                                fontFamily: "var(--mantine-font-family-monospace)",
+                                fontSize: 11,
+                                fontWeight: 500,
+                                color: "var(--mantine-color-accent-filled)",
+                            }, children: ["\u2197", " "] }), _jsx("a", { href: "#", onClick: (event) => {
+                                event.preventDefault();
+                            }, style: {
+                                color: "var(--mantine-color-accent-filled)",
+                                textDecoration: "underline",
+                                textUnderlineOffset: 3,
+                                textDecorationThickness: 1,
+                            }, "data-testid": `main-editor-source-link-${span.fileRef}`, "data-file-ref": span.fileRef, children: span.text })] }, index))) })] }));
+}

package/dist/blocks/NativeTableView.d.ts

@@ -0,0 +1,12 @@
+import type { NativeTableBlock as NativeTableBlockModel } from "../types.js";
+export interface NativeTableViewProps {
+    readonly block: NativeTableBlockModel;
+}
+/**
+ * Normal document block — dossier-native table (D10): renders exactly like a
+ * Feishu native table — a plain document element with row rules and NO card
+ * chrome, kind pill, or outlining box. Being a table does not make a block
+ * embedded; only file-preview blocks are embedded.
+ */
+export declare function NativeTableView({ block }: NativeTableViewProps): import("react").JSX.Element;
+//# sourceMappingURL=NativeTableView.d.ts.map

package/dist/blocks/NativeTableView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeTableView.d.ts","sourceRoot":"","sources":["../../src/blocks/NativeTableView.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,IAAI,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAG7E,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,KAAK,EAAE,qBAAqB,CAAC;CACvC;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,EAAE,KAAK,EAAE,EAAE,oBAAoB,+BA0D9D"}

package/dist/blocks/NativeTableView.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box } from "@mantine/core";
+import { BORDER, MONO, MUTED } from "../tokens.js";
+/**
+ * Normal document block — dossier-native table (D10): renders exactly like a
+ * Feishu native table — a plain document element with row rules and NO card
+ * chrome, kind pill, or outlining box. Being a table does not make a block
+ * embedded; only file-preview blocks are embedded.
+ */
+export function NativeTableView({ block }) {
+    return (_jsxs(Box, { "data-testid": `main-editor-block-${block.id}`, children: [_jsx(Box, { style: {
+                    display: "grid",
+                    gridTemplateColumns: `repeat(${String(block.columns.length)}, minmax(0, 1fr))`,
+                    columnGap: 16,
+                    padding: "0 2px 8px 2px",
+                }, "data-testid": `main-editor-native-header-${block.id}`, children: block.columns.map((column, index) => (_jsx("span", { style: {
+                        fontFamily: MONO,
+                        fontSize: 7,
+                        fontWeight: 500,
+                        color: MUTED,
+                        letterSpacing: "0.05em",
+                    }, children: column }, column + String(index)))) }), block.rows.map((row, rowIndex) => (_jsx(Box, { style: {
+                    display: "grid",
+                    gridTemplateColumns: `repeat(${String(block.columns.length)}, minmax(0, 1fr))`,
+                    columnGap: 16,
+                    padding: "9px 2px",
+                    borderTop: `1px solid ${BORDER}`,
+                }, "data-testid": `main-editor-native-row-${block.id}-${String(rowIndex)}`, children: row.map((cell, cellIndex) => (_jsx("span", { style: {
+                        fontFamily: MONO,
+                        fontSize: 8,
+                        color: cellIndex === 0 ? "var(--mantine-color-text-filled)" : MUTED,
+                        whiteSpace: "nowrap",
+                        overflow: "hidden",
+                        textOverflow: "ellipsis",
+                    }, children: cell }, String(cellIndex)))) }, `${row[0] ?? ""}-${String(rowIndex)}`)))] }));
+}

package/dist/blocks/SavedViewDropdown.d.ts

@@ -0,0 +1,17 @@
+import type { MainEditorLocale } from "../locales/index.js";
+import type { EmbeddedSourceFile } from "../types.js";
+export interface SavedViewDropdownProps {
+    readonly blockId: string;
+    readonly sourceFile: EmbeddedSourceFile;
+    readonly locale: MainEditorLocale;
+}
+/**
+ * The source-file variant dropdown on top of an embedded (file-preview)
+ * block (D10): because the dropdown previews SAVED VIEWS of the source file,
+ * picking one publishes "main-editor.selected-view" and every block bound to
+ * that channel (here or in a peer host) re-derives its previewed view — D6
+ * state passing. The current selection derives from the same channel,
+ * falling back to the file's default view.
+ */
+export declare function SavedViewDropdown({ blockId, sourceFile, locale }: SavedViewDropdownProps): import("react").JSX.Element;
+//# sourceMappingURL=SavedViewDropdown.d.ts.map

package/dist/blocks/SavedViewDropdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SavedViewDropdown.d.ts","sourceRoot":"","sources":["../../src/blocks/SavedViewDropdown.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,kBAAkB,EAA0B,MAAM,aAAa,CAAC;AAI9E,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;CACnC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,sBAAsB,+BA8HxF"}

package/dist/blocks/SavedViewDropdown.js

@@ -0,0 +1,85 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box } from "@mantine/core";
+import { usePrismStateSetter, usePrismStateValue } from "@zephytiju/prism-react";
+import { formatMessage, stringsForLocale } from "../locales/index.js";
+import { ACCENT, BORDER, CARD, LINE, MONO, MUTED, TEXT } from "../tokens.js";
+import { menuHeaderStyle } from "./menuStyles.js";
+/**
+ * The source-file variant dropdown on top of an embedded (file-preview)
+ * block (D10): because the dropdown previews SAVED VIEWS of the source file,
+ * picking one publishes "main-editor.selected-view" and every block bound to
+ * that channel (here or in a peer host) re-derives its previewed view — D6
+ * state passing. The current selection derives from the same channel,
+ * falling back to the file's default view.
+ */
+export function SavedViewDropdown({ blockId, sourceFile, locale }) {
+    const strings = stringsForLocale(locale);
+    const [menuOpen, setMenuOpen] = useState(false);
+    // The dropdown owns the selected-view binding: setter-only publish, value
+    // consumed to derive the current view (EntityCard's selected-entity pattern).
+    const selectedView = usePrismStateValue("main-editor.selected-view");
+    const publishSelectedView = usePrismStateSetter("main-editor.selected-view");
+    const currentViewId = selectedView?.blockId === blockId ? selectedView.viewId : sourceFile.defaultViewId;
+    const currentView = sourceFile.savedViews.find((view) => view.id === currentViewId) ??
+        sourceFile.savedViews[0];
+    const currentLabel = currentView?.label ?? "";
+    return (_jsxs(Box, { style: { position: "relative", flexShrink: 0 }, children: [_jsxs("button", { type: "button", style: {
+                    height: 22,
+                    padding: "0 10px",
+                    borderRadius: 11,
+                    background: CARD,
+                    border: `1px solid ${BORDER}`,
+                    fontFamily: MONO,
+                    fontSize: 7,
+                    fontWeight: 500,
+                    color: ACCENT,
+                    display: "inline-flex",
+                    alignItems: "center",
+                    gap: 7,
+                    cursor: "pointer",
+                    userSelect: "none",
+                    whiteSpace: "nowrap",
+                }, "data-testid": `main-editor-view-select-${blockId}`, "aria-haspopup": "listbox", "aria-expanded": menuOpen, onClick: () => {
+                    setMenuOpen((open) => !open);
+                }, children: [formatMessage(strings.viewSelector, { variant: currentLabel }), _jsx("span", { style: { color: MUTED }, "aria-hidden": "true", children: "\u25BE" })] }), menuOpen ? (_jsxs(_Fragment, { children: [_jsx("div", { style: { position: "fixed", inset: 0, zIndex: 8 }, onClick: () => {
+                            setMenuOpen(false);
+                        }, "data-testid": `main-editor-view-menu-overlay-${blockId}` }), _jsxs(Box, { component: "ul", w: 264, py: 4, style: {
+                            position: "absolute",
+                            top: 26,
+                            right: 0,
+                            background: CARD,
+                            border: `1px solid ${LINE}`,
+                            borderRadius: 6,
+                            boxShadow: "0 8px 24px rgba(0,0,0,.55)",
+                            zIndex: 9,
+                            listStyle: "none",
+                            margin: 0,
+                        }, "data-testid": `main-editor-view-menu-${blockId}`, role: "listbox", children: [_jsx("li", { style: menuHeaderStyle, children: formatMessage(strings.savedViewsTitle, { file: sourceFile.name }) }), sourceFile.savedViews.map((view) => {
+                                const active = view.id === currentViewId;
+                                return (_jsx("li", { children: _jsxs("button", { type: "button", role: "option", "aria-selected": active, style: {
+                                            width: "100%",
+                                            height: 26,
+                                            display: "flex",
+                                            alignItems: "center",
+                                            gap: 8,
+                                            padding: "0 12px",
+                                            fontFamily: MONO,
+                                            fontSize: 8,
+                                            color: active ? ACCENT : TEXT,
+                                            background: "transparent",
+                                            border: "none",
+                                            cursor: "pointer",
+                                            textAlign: "left",
+                                        }, "data-testid": `main-editor-view-option-${blockId}-${view.id}`, onClick: () => {
+                                            publishSelectedView({ blockId, viewId: view.id });
+                                            setMenuOpen(false);
+                                        }, children: [_jsx("span", { style: {
+                                                    width: 5,
+                                                    height: 5,
+                                                    borderRadius: "50%",
+                                                    background: active ? ACCENT : BORDER,
+                                                    flexShrink: 0,
+                                                } }), view.label] }) }, view.id));
+                            })] })] })) : null] }));
+}

package/dist/blocks/SelectionToolbar.d.ts

@@ -0,0 +1,25 @@
+import type { RefObject } from "react";
+import type { MainEditorLocale } from "../locales/index.js";
+export interface SelectionToolbarProps {
+    readonly locale: MainEditorLocale;
+    /**
+     * The editor surface this toolbar serves (selections inside OTHER instances
+     * or hosts never open it — each instance's toolbar checks its own bounds).
+     */
+    readonly containerRef: RefObject<HTMLElement | null>;
+}
+/**
+ * The D11 text-selection toolbar: selecting text inside the editor's editable
+ * text surfaces (narrative heading/paragraph, analyst-judgment body) opens a
+ * floating toolbar at the selection. The style actions (bold / italic /
+ * underline / strikethrough) apply text-style mutations to the selection via
+ * document.execCommand — the DOM is the editing surface while the channel
+ * projection stays authoritative for content. The 💬 action wraps the
+ * selected range in a token-only highlight mark and emits
+ * "main-editor.comment-requested" {blockId, quote}, anchoring a new thread to
+ * that text range (the host creates the thread; the aligned comments rail
+ * stacks it under its block). The toolbar dismisses whenever the selection
+ * collapses (or scrolls away).
+ */
+export declare function SelectionToolbar({ locale, containerRef }: SelectionToolbarProps): import("react").JSX.Element | null;
+//# sourceMappingURL=SelectionToolbar.d.ts.map

package/dist/blocks/SelectionToolbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectionToolbar.d.ts","sourceRoot":"","sources":["../../src/blocks/SelectionToolbar.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAA+D,SAAS,EAAE,MAAM,OAAO,CAAC;AAIpG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAI5D,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC;;;OAGG;IACH,QAAQ,CAAC,YAAY,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;CACtD;AAaD;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,qBAAqB,sCA2M/E"}