dsh-zen-remote 1.1.13 → 1.1.14

package/lib/client.js

@@ -1534,84 +1534,2759 @@ function MobileHeaderActions({ sessionId, useSessions, t }) {
     const openInfoCard = () => { window.dispatchEvent(new CustomEvent(nav_store_ts_1.SESSION_INFO_EVENT)); };
     return ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)("button", { type: "button", "data-mobile-nav": "header-back", "aria-label": t('backToList'), title: t('backToList'), onClick: () => window.dispatchEvent(new CustomEvent(nav_store_ts_1.GO_HOME_EVENT)), children: (0, jsx_runtime_1.jsx)(dsh_client_ui_primitives_1.IconChevronLeftOutline14, { size: 20 }) }), tabs.length > 1 && active !== undefined && ((0, jsx_runtime_1.jsxs)("button", { type: "button", "data-mobile-nav": "header-viewrow", "aria-label": t('switchView'), onClick: () => tabs.find((tab) => !tab.active)?.el.click(), children: [(0, jsx_runtime_1.jsx)("span", { "data-mobile-nav": "header-viewrow-label", children: active.label }), (0, jsx_runtime_1.jsx)("span", { "data-mobile-nav": "header-viewrow-dots", "aria-hidden": "true", children: tabs.map((tab, index) => ((0, jsx_runtime_1.jsx)("i", { "data-active": tab.active ? '' : undefined }, index))) })] })), hasActivity && ((0, jsx_runtime_1.jsxs)("div", { "data-mobile-nav": "header-activity", children: [(0, jsx_runtime_1.jsx)(ActivityPill, { kind: "subagent", count: subagents.length, state: subagentState, label: t('infoSubagents', { count: subagents.length }), trigger: SUBAGENT_TRIGGER, onFallback: openInfoCard, Icon: IconSubagentOutline14 }), (0, jsx_runtime_1.jsx)(ActivityPill, { kind: "job", count: jobs.length, state: jobState, label: t('infoJobs', { count: jobs.length }), trigger: JOBS_TRIGGER, onFallback: openInfoCard, Icon: IconTaskOutline14 })] }))] }));
 }
+const BETTER_ROOT = '[data-dsh-better-sidebar]';
+const BETTER_TOGGLE = '[data-dsh-better-sidebar] button[class$="_toggleButton"]';
+const OFFICIAL_PANEL = '[data-sidebar-right-panel]';
+const OFFICIAL_EXPAND = '[data-sidebar-right-expand]';
+const OFFICIAL_COLLAPSE = '[data-sidebar-right-toggle]';
+/** Synchronous read of which sidebar backend this host offers. */
+function readSidebarTarget() {
+    if (document.querySelector(BETTER_ROOT) !== null)
+        return 'better';
+    if (document.querySelector(OFFICIAL_PANEL) !== null)
+        return 'official';
+    return null;
+}
+/**
+ * Toggle whichever sidebar `target` names, by clicking the official/plugin
+ * control through its stable marker. The official pair is open-only in the
+ * corner (`ExpandButton` unmounts once shown) and close-only inside the
+ * panel (`data-sidebar-right-toggle` rides the panel's own strip), so the
+ * open state is read off the panel's `data-sidebar-right-open` attribute and
+ * the matching control is clicked. Synthetic `.click()` fires both React
+ * handlers through `display: none` (the tablist precedent this plugin
+ * already relies on for the view switch).
+ */
+function toggleSidebarTarget(target) {
+    if (target === 'better') {
+        document.querySelector(BETTER_TOGGLE)?.click();
+        return;
+    }
+    if (target === 'official') {
+        const shown = document.querySelector(`${OFFICIAL_PANEL}[data-sidebar-right-open]`) !== null;
+        const control = shown
+            ? document.querySelector(OFFICIAL_COLLAPSE)
+            : document.querySelector(OFFICIAL_EXPAND);
+        control?.click();
+    }
+}
+/** Live mirror of {@link readSidebarTarget} — same observer pattern as the
+ * old workbench presence gate it replaces (plugins load after us; the right
+ * panel mounts with the frame). */
+function useSidebarTarget() {
+    const [target, setTarget] = (0, react_1.useState)(readSidebarTarget);
+    (0, react_1.useEffect)(() => {
+        const check = () => setTarget(readSidebarTarget());
+        const observer = new MutationObserver(check);
+        observer.observe(document.body, { childList: true, subtree: true });
+        check();
+        return () => observer.disconnect();
+    }, []);
+    return target;
+}
+/**
+ * Session header, right lane: the session-info entry (S4 owns the actual
+ * sheet — this fires a hook event for it to pick up) and the sidebar entry.
+ * The sidebar button routes per {@link SidebarTarget}: better-sidebar's own
+ * toggle (no public "open the panel" API — BetterSidebarService.openTab only
+ * auto-expands for a content open, not a bare type-only open, so it clicks
+ * the plugin's real toggle through its root marker `[data-dsh-better-
+ * sidebar]` plus the `_toggleButton` class suffix, verified live 2026-08-17),
+ * the official right sidebar's controls, or nothing when neither exists.
+ */
+function MobileHeaderUtilities({ t }) {
+    // Better-sidebar phone close button (S3.1 follow-up, 2026-08-17): the
+    // panel's own top-right toggle cluster is hidden below 768px
+    // (styles/compat.css.ts) because it duplicates the workbench button
+    // below — but that cluster is also the panel's ONLY close control, so
+    // hiding it blindly leaves an open panel with no way out. This button is
+    // appended straight to document.body, mirroring the existing
+    // preview-full-toggle pattern in MobileNavOverlay.tsx (raw DOM, not a
+    // React portal — react-dom is not among this plugin's platform-module
+    // imports, see AGENTS.md "client import purity"): never inside the
+    // panel's own subtree (the third party's React re-renders would wipe
+    // it) and never under any transformed/backdrop-filter ancestor (the S4
+    // info-card WebKit lesson in AGENTS.md — position:fixed would re-anchor
+    // to that ancestor instead of the viewport). It clicks the SAME hidden
+    // official toggle the workbench button below uses. Visibility is pure
+    // CSS (styles/compat.css.ts: `body:has([data-dsh-better-sidebar]
+    // [class$="_panel"])` — the panel's class ends in "_panel" only while
+    // open, "_panelHidden" is appended once closed), so this effect only
+    // has to guarantee the node exists — no MutationObserver needed to
+    // track open/closed state. Icon paths copied verbatim from
+    // IconCloseOutline16 (primitives) for the same reason IconInfoOutline16
+    // above is hand-built: this button lives outside the React tree, so it
+    // cannot render a primitives component directly.
+    (0, react_1.useEffect)(() => {
+        const button = document.createElement('button');
+        button.type = 'button';
+        button.dataset.mobileNav = 'better-sidebar-close';
+        button.setAttribute('aria-label', t('workbenchClose'));
+        button.title = t('workbenchClose');
+        // Bottom-center labeled pill (real-device follow-up, 2026-08-17): the
+        // icon markup is a static trusted string (safe as innerHTML), but the
+        // locale label is untrusted-shaped text — built as a real text node via
+        // textContent, not string-concatenated into the same innerHTML, so a
+        // translation can never be parsed as markup.
+        button.innerHTML = '<svg viewBox="0 0 16 16" fill="none" aria-hidden="true">'
+            + '<path d="M14.1168 13.197L13.197 14.1167L1.8833 2.80303L2.80309 1.88324L14.1168 13.197Z" fill="currentColor"/>'
+            + '<path d="M13.197 1.88326L14.1168 2.80305L2.80309 14.1168L1.8833 13.197L13.197 1.88326Z" fill="currentColor"/>'
+            + '</svg>';
+        const label = document.createElement('span');
+        label.textContent = t('workbenchClose');
+        button.appendChild(label);
+        const onClick = () => {
+            document.querySelector('[data-dsh-better-sidebar] button[class$="_toggleButton"]')?.click();
+        };
+        button.addEventListener('click', onClick);
+        document.body.appendChild(button);
+        return () => {
+            button.removeEventListener('click', onClick);
+            button.remove();
+        };
+    }, [t]);
+    // Sidebar routing (2026-09-11): better-sidebar installed → its toggle (the
+    // original design); else the official right sidebar (DSH 0.1.5+); else the
+    // button stays hidden — it used to be a dead control without the plugin
+    // (2026-08-17 user question), and the same must hold for a host with no
+    // right sidebar either. The close pill above keeps its own better-sidebar
+    // CSS :has() gate, unchanged.
+    const sidebar = useSidebarTarget();
+    return ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)("button", { type: "button", "data-mobile-nav": "header-info", "aria-label": t('sessionInfo'), title: t('sessionInfo'), onClick: () => window.dispatchEvent(new CustomEvent(nav_store_ts_1.SESSION_INFO_EVENT)), children: (0, jsx_runtime_1.jsx)(IconInfoOutline16, { size: 20 }) }), sidebar !== null && (0, jsx_runtime_1.jsx)("button", { type: "button", "data-mobile-nav": "header-workbench", "data-sidebar-target": sidebar, "aria-label": t(sidebar === 'better' ? 'workbench' : 'sidebar'), title: t(sidebar === 'better' ? 'workbench' : 'sidebar'), onClick: () => { toggleSidebarTarget(sidebar); }, children: (0, jsx_runtime_1.jsx)(dsh_client_ui_primitives_1.IconPanelLeftOutline16, { size: 20 }) })] }));
+}
+};
+__modules["share/fetch-share.js"] = function (require, module, exports) {
+"use strict";
+/**
+ * Share-export fetching (ticket 05, PLAN §5.3): the ONE typed fetch over
+ * GET /_dsh/mobile-nav/share-export, shared by the real share flow
+ * (MobileSessionInfo) and the debug preview (?mobile-nav-share-preview=1)
+ * so query assembly and error handling never fork into two copies.
+ *
+ * Module-shape rules (same reason as rasterize.ts): the share-image check
+ * script imports this file through Node type stripping, which rejects JSX
+ * and runs no browser API — so every import of a JSX-bearing module is
+ * `import type` (fully erased) and browser globals appear only inside
+ * function bodies. The query builder and the error taxonomy below are pure
+ * and pinned there.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShareFetchError = exports.SHARE_TURNS_PRESETS = exports.SHARE_EXPORT_ROUTE = void 0;
+exports.buildShareExportQuery = buildShareExportQuery;
+exports.fetchShareExport = fetchShareExport;
+/** Route the host registers (mirror of src/share-export.ts — the client cannot import host code). */
+exports.SHARE_EXPORT_ROUTE = '/_dsh/mobile-nav/share-export';
+/** Preset turn counts the range sheet offers (PLAN §6: presets, no free input). */
+exports.SHARE_TURNS_PRESETS = [3, 5, 10];
+/** Localizable fetch failure; ticket 05 maps `code` to locales shareErr*. */
+class ShareFetchError extends Error {
+    code;
+    status;
+    constructor(code, status, detail) {
+        super(`share-fetch/${code}${status === undefined ? '' : ` (HTTP ${status})`}: ${detail}`);
+        this.name = 'ShareFetchError';
+        this.code = code;
+        this.status = status;
+    }
+}
+exports.ShareFetchError = ShareFetchError;
+/**
+ * Pure: assemble the route query. The session id arrives in its branded
+ * `session-<uuid>` form (useSessions row / session-scoped slot prop) and is
+ * passed through encodeURIComponent — a bare uuid would 404 (PLAN §2 note).
+ */
+function buildShareExportQuery(session, range) {
+    const params = [`session=${encodeURIComponent(session)}`];
+    params.push(range.kind === 'last' ? `range=last&turns=${range.turns}` : 'range=all');
+    return `${exports.SHARE_EXPORT_ROUTE}?${params.join('&')}`;
+}
+function isShareBlockShape(block) {
+    if (typeof block !== 'object' || block === null)
+        return false;
+    const kind = block.kind;
+    if (kind === 'image')
+        return true;
+    return kind === 'text' && typeof block.text === 'string';
+}
+function isShareTurnShape(turn) {
+    if (typeof turn !== 'object' || turn === null)
+        return false;
+    const { role, seq, blocks } = turn;
+    return (role === 'user' || role === 'assistant')
+        && typeof seq === 'number' && Number.isFinite(seq)
+        && Array.isArray(blocks) && blocks.every(isShareBlockShape);
+}
+/**
+ * Fetch one export and classify every failure.
+ *
+ * Error mapping (the reason a 404 is split in two): this plugin's route
+ * answers 404 + `{error:{code:'session-not-found'}}` for an unknown session,
+ * while a DSH old enough to lack the route answers the web server's own 404
+ * — a different copy (“需要新版 DSH”) than “会话不存在”, decided by whether
+ * our envelope is present.
+ */
+async function fetchShareExport(session, range) {
+    let res;
+    try {
+        res = await fetch(buildShareExportQuery(session, range), { cache: 'no-store' });
+    }
+    catch (err) {
+        throw new ShareFetchError('network', undefined, err instanceof Error ? err.message : String(err));
+    }
+    if (!res.ok) {
+        let envelope;
+        try {
+            envelope = await res.json();
+        }
+        catch {
+            // Not JSON — an old DSH's plain 404 page or a gateway error page.
+            envelope = undefined;
+        }
+        const code = envelope?.error?.code;
+        const detail = typeof envelope?.error?.message === 'string' ? envelope.error.message : `HTTP ${res.status}`;
+        if (res.status === 404 && code === 'session-not-found') {
+            throw new ShareFetchError('session-not-found', res.status, detail);
+        }
+        if (res.status === 404) {
+            throw new ShareFetchError('route-missing', res.status, detail);
+        }
+        if (res.status === 400) {
+            throw new ShareFetchError('bad-request', res.status, detail);
+        }
+        throw new ShareFetchError('server', res.status, detail);
+    }
+    let body;
+    try {
+        body = await res.json();
+    }
+    catch (err) {
+        throw new ShareFetchError('bad-body', res.status, err instanceof Error ? err.message : String(err));
+    }
+    if (body.ok !== true || !Array.isArray(body.turns) || !body.turns.every(isShareTurnShape)) {
+        // Loud over lenient: silently dropping malformed rows would ship a
+        // truncated transcript that LOOKS complete — the worst failure mode for
+        // a share image.
+        throw new ShareFetchError('bad-body', res.status, 'body is not a valid share-export payload');
+    }
+    return {
+        turns: body.turns,
+        createdAt: typeof body.createdAt === 'number' && Number.isFinite(body.createdAt) ? body.createdAt : undefined,
+    };
+}
+};
+__modules["share/share-flow.js"] = function (require, module, exports) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHARE_NAME_MAX = exports.FALLBACK_SHARE_BASE_NAME = void 0;
+exports.sanitizeShareFileName = sanitizeShareFileName;
+exports.shareSliceFileName = shareSliceFileName;
+exports.shareImageFileName = shareImageFileName;
+exports.downloadBlobSequence = downloadBlobSequence;
+exports.deliverShareImages = deliverShareImages;
+exports.deliverShareImage = deliverShareImage;
+/** Basename used when the session title cleans down to nothing. */
+exports.FALLBACK_SHARE_BASE_NAME = 'share-card';
+/**
+ * Max characters (code points, not UTF-16 units) kept from the title. The
+ * `-NN.png` suffix adds 7; 50 + 7 stays far inside every filesystem's 255
+ * byte-name limit even once UTF-8 doubles the CJK characters.
+ */
+exports.SHARE_NAME_MAX = 50;
+/** XML 1.0-invalid control characters (same set rasterize.ts scrubs). */
+const CONTROL_CHARS = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g;
+/**
+ * Bidirectional format characters — LRM/RLM plus the LRE/RLE/PDF/LRO/RLO
+ * family: zero-width, and in a filename they visually reorder the characters
+ * around them (the classic `photo\u202Egpj.png` reads as a .jpg-extension
+ * spoof), so they are stripped like controls rather than kept.
+ */
+const BIDI_CONTROLS = /[\u200E\u200F\u202A-\u202E]/g;
+/** Path separators of every mainstream filesystem — removed, not replaced in place. */
+const PATH_SEPARATORS = /[\\/]/g;
+/** Any whitespace run — collapsed to a single space. */
+const WHITESPACE_RUN = /\s+/g;
+/**
+ * Pure: session title → portable file basename. Path separators, control
+ * characters and bidi format characters are removed (a separator in a
+ * download name lets a hostile title pick the destination directory; a bidi
+ * character visually reorders the name into an extension spoof), whitespace
+ * runs fold to one space, the result is length-capped on code points (no
+ * splitting surrogate pairs) and falls back to {@link FALLBACK_SHARE_BASE_NAME}
+ * when nothing survives.
+ */
+function sanitizeShareFileName(title) {
+    const cleaned = title
+        .replace(CONTROL_CHARS, '')
+        .replace(BIDI_CONTROLS, '')
+        .replace(PATH_SEPARATORS, ' ')
+        .replace(WHITESPACE_RUN, ' ')
+        .trim();
+    if (cleaned === '')
+        return exports.FALLBACK_SHARE_BASE_NAME;
+    const chars = Array.from(cleaned);
+    if (chars.length > exports.SHARE_NAME_MAX) {
+        const capped = chars.slice(0, exports.SHARE_NAME_MAX).join('').trim();
+        return capped === '' ? exports.FALLBACK_SHARE_BASE_NAME : capped;
+    }
+    return cleaned;
+}
+/**
+ * File name of slice {@link index} (0-based): `<base>-NN.png`. Two digits
+ * cover the rasterizer's 24-slice ceiling with room to spare and sort
+ * lexicographically in every receiver's file list. Legacy multi-file fallback
+ * only (ticket 07 stitches first when the browser supports it).
+ */
+function shareSliceFileName(base, index) {
+    return `${base}-${String(index + 1).padStart(2, '0')}.png`;
+}
+/**
+ * File name of the stitched single long image (ticket 07): `<base>.png` — no
+ * slice suffix, the deliverable is one file.
+ */
+function shareImageFileName(base) {
+    return `${base}.png`;
+}
+/** User dismissed the system share panel — not an error, nothing to retry. */
+function isAbortError(err) {
+    return err instanceof Error && err.name === 'AbortError';
+}
+/**
+ * The `<a download>` fallback, as one paced sequence (review 07+08 cleanup —
+ * previously tripled across this module and the debug preview's export):
+ * object URL → programmatic anchor click → delayed revoke per entry, with
+ * consecutive clicks spaced 300ms apart so browsers do not coalesce or block
+ * them. A single entry is simply one click with no pause.
+ */
+async function downloadBlobSequence(entries) {
+    for (const [index, entry] of entries.entries()) {
+        const url = URL.createObjectURL(entry.blob);
+        const anchor = document.createElement('a');
+        anchor.href = url;
+        anchor.download = entry.name;
+        anchor.click();
+        window.setTimeout(() => URL.revokeObjectURL(url), 10_000);
+        if (index < entries.length - 1)
+            await new Promise((resolve) => window.setTimeout(resolve, 300));
+    }
+}
+/** The `<a download>` fallback: one paced click per file. */
+async function downloadFiles(files) {
+    await downloadBlobSequence(files.map((file) => ({ blob: file, name: file.name })));
+}
+/**
+ * Deliver rasterized slices (legacy multi-file fallback): system share panel
+ * when the browser accepts files, downloads otherwise. A share() rejection
+ * that is NOT the user's own cancel — classically NotAllowedError, because
+ * seconds of rasterizing spent the click's transient activation — falls
+ * through to downloads rather than discarding the finished PNGs.
+ */
+async function deliverShareImages(slices, title) {
+    const base = sanitizeShareFileName(title);
+    const files = slices.map((slice, index) => new File([slice.blob], shareSliceFileName(base, index), { type: 'image/png' }));
+    return deliverFiles(files);
+}
+/**
+ * Deliver the stitched single long image (ticket 07): ONE `<base>.png` through
+ * the system share panel, or a single download where the Web Share API is
+ * missing/refusing — never a file sequence.
+ */
+async function deliverShareImage(png, title) {
+    const base = sanitizeShareFileName(title);
+    return deliverFiles([new File([png], shareImageFileName(base), { type: 'image/png' })]);
+}
+/** Shared delivery tail: share panel, else one paced download per file. */
+async function deliverFiles(input) {
+    const files = [...input]; // mutable shallow copy — the navigator.share shape wants File[]
+    const nav = typeof navigator === 'undefined' ? undefined : navigator;
+    if (typeof nav?.canShare === 'function' && typeof nav.share === 'function' && nav.canShare({ files })) {
+        try {
+            await nav.share({ files });
+            return 'shared';
+        }
+        catch (err) {
+            if (isAbortError(err))
+                return 'cancelled';
+            await downloadFiles(files);
+            return 'downloaded';
+        }
+    }
+    await downloadFiles(files);
+    return 'downloaded';
+}
+};
+__modules["share/png-stitch.js"] = function (require, module, exports) {
+"use strict";
+/**
+ * Streaming PNG long-image stitcher (ticket 07, PLAN §4.5).
+ *
+ * The rasterizer still paints slice-by-slice (each slice stays under the iOS
+ * canvas budget), but the DELIVERABLE is one PNG: this module concatenates the
+ * slices' scanlines into a single image — PNG signature + IHDR (whole-image
+ * size, 8-bit RGBA) + IDAT (zlib stream, scanline filter 0) + IEND, CRC32
+ * computed against a self-carried table, compression via the platform's
+ * `CompressionStream('deflate')` whose output already IS the zlib-wrapped
+ * deflate stream the PNG IDAT chunk requires.
+ *
+ * Streaming discipline (the whole point of a custom stitcher): slices are
+ * decoded one at a time (createImageBitmap → offscreen canvas getImageData →
+ * per-row writeRow → release) so the raw pixels of the WHOLE image are never
+ * held; only the compressed output accumulates, as a Blob.
+ *
+ * Module contract (same one share-flow.ts honors): scripts/check-share-image.mjs
+ * imports this file through Node type stripping, which EXECUTES module scope —
+ * so everything here is pure math at module scope, and every browser global
+ * (CompressionStream, createImageBitmap, document, Blob) is touched only
+ * inside function/class bodies. The file is an import-free leaf.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PngStitchWriter = exports.MAX_IDAT_CHUNK_BYTES = exports.IEND_CHUNK = exports.PNG_SIGNATURE = void 0;
+exports.crc32 = crc32;
+exports.pngChunk = pngChunk;
+exports.ihdrData = ihdrData;
+exports.splitIdatBytes = splitIdatBytes;
+exports.supportsPngStitch = supportsPngStitch;
+exports.stitchSliceBlobs = stitchSliceBlobs;
+/* ============================================================================
+ * PURE BYTES — CRC32 + chunk framing (runs in Node for the check script)
+ * ========================================================================== */
+/** Standard CRC-32 table (reflected, polynomial 0xEDB88320). */
+const CRC_TABLE = (() => {
+    const table = new Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++)
+            c = (c & 1) !== 0 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        table[n] = c >>> 0;
+    }
+    return table;
+})();
+/**
+ * CRC-32 (PNG variant: no init/xor toggling beyond the standard reflected
+ * form — init 0xFFFFFFFF, final XOR 0xFFFFFFFF). Known answers pinned by the
+ * check script: crc32('123456789') === 0xCBF43926, crc32('IEND') === 0xAE426082.
+ */
+function crc32(bytes) {
+    let c = 0xffffffff;
+    for (let i = 0; i < bytes.length; i++) {
+        c = (CRC_TABLE[(c ^ bytes[i]) & 0xff] ^ (c >>> 8)) >>> 0;
+    }
+    return (c ^ 0xffffffff) >>> 0;
+}
+/** The 8-byte PNG file signature. */
+exports.PNG_SIGNATURE = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+/** ASCII bytes of a chunk type string (types are always 4 ASCII letters). */
+function ascii(value) {
+    const out = new Uint8Array(value.length);
+    for (let i = 0; i < value.length; i++)
+        out[i] = value.charCodeAt(i) & 0xff;
+    return out;
+}
+function writeU32BE(target, offset, value) {
+    target[offset] = (value >>> 24) & 0xff;
+    target[offset + 1] = (value >>> 16) & 0xff;
+    target[offset + 2] = (value >>> 8) & 0xff;
+    target[offset + 3] = value & 0xff;
+}
+/**
+ * One PNG chunk frame: 4-byte big-endian data length, the type, the data, and
+ * the big-endian CRC32 over TYPE+DATA (never the length field).
+ */
+function pngChunk(type, data) {
+    const typeBytes = ascii(type);
+    if (typeBytes.length !== 4)
+        throw new Error(`png-stitch: chunk type must be 4 ASCII letters, got ${JSON.stringify(type)}`);
+    const out = new Uint8Array(12 + data.length);
+    writeU32BE(out, 0, data.length);
+    out.set(typeBytes, 4);
+    out.set(data, 8);
+    const crcInput = new Uint8Array(4 + data.length);
+    crcInput.set(typeBytes, 0);
+    crcInput.set(data, 4);
+    writeU32BE(out, 8 + data.length, crc32(crcInput));
+    return out;
+}
+/** IHDR payload: width/height big-endian, 8 bits/channel, RGBA (color type 6), deflate, filter 0, no interlace. */
+function ihdrData(width, height) {
+    const data = new Uint8Array(13);
+    writeU32BE(data, 0, width);
+    writeU32BE(data, 4, height);
+    data[8] = 8; // bit depth
+    data[9] = 6; // color type: truecolor + alpha
+    data[10] = 0; // compression: deflate
+    data[11] = 0; // filter: adaptive (per scanline byte)
+    data[12] = 0; // interlace: none
+    return data;
+}
+/** The IEND chunk is a constant: empty payload, CRC 0xAE426082. */
+exports.IEND_CHUNK = pngChunk('IEND', new Uint8Array(0));
+/**
+ * IDAT payload split ceiling (1 MiB): a single IDAT may legally be any size,
+ * but decoders appreciate modest chunks — and splitting keeps the multi-IDAT
+ * path honest since most exports stay under it and emit exactly one.
+ */
+exports.MAX_IDAT_CHUNK_BYTES = 1 << 20;
+/** Split compressed bytes into consecutive IDAT payloads (multi-chunk IDAT is legal and order-significant). */
+function splitIdatBytes(data, maxBytes) {
+    if (!Number.isInteger(maxBytes) || maxBytes <= 0)
+        throw new Error(`png-stitch: invalid IDAT chunk size ${maxBytes}`);
+    if (data.length === 0)
+        return [new Uint8Array(0)];
+    const parts = [];
+    for (let offset = 0; offset < data.length; offset += maxBytes) {
+        parts.push(data.subarray(offset, Math.min(offset + maxBytes, data.length)));
+    }
+    return parts;
+}
+/* ============================================================================
+ * STREAMING WRITER — rows in, Blob out (works in Node 22 too: the check
+ * script produces real PNGs and verifies them with node:zlib)
+ * ========================================================================== */
+/** Scanline filter type 0 (None) — the single filter byte every row carries. */
+const FILTER_NONE = new Uint8Array([0]);
+/**
+ * Row-by-row PNG assembler for one already-known raster size.
+ *
+ * Backpressure: the compressed readable side is drained by a loop started in
+ * the constructor — without a concurrent reader the transform stalls once its
+ * buffers fill and every writeRow would deadlock. Row bytes are NOT copied:
+ * writeRow's awaited write resolves only after the compressor has consumed the
+ * chunk, and the rasterizer feeds disjoint subarrays of an ImageData buffer
+ * that is never mutated after getImageData, so no staging buffer is needed.
+ */
+class PngStitchWriter {
+    width;
+    height;
+    rowsWritten = 0;
+    closed = false;
+    writer;
+    drained;
+    constructor(width, height) {
+        if (!Number.isInteger(width) || width <= 0)
+            throw new Error(`png-stitch: invalid width ${width}`);
+        if (!Number.isInteger(height) || height <= 0)
+            throw new Error(`png-stitch: invalid height ${height}`);
+        this.width = width;
+        this.height = height;
+        const compressor = new CompressionStream('deflate');
+        this.writer = compressor.writable.getWriter();
+        const reader = compressor.readable.getReader();
+        this.drained = (async () => {
+            const chunks = [];
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done === true)
+                    break;
+                if (value !== undefined)
+                    chunks.push(value);
+            }
+            let total = 0;
+            for (const chunk of chunks)
+                total += chunk.length;
+            const out = new Uint8Array(total);
+            let offset = 0;
+            for (const chunk of chunks) {
+                out.set(chunk, offset);
+                offset += chunk.length;
+            }
+            return out;
+        })();
+        // The drain loop starts here and may reject before finish() ever awaits
+        // it (a writeRow error abandons the writer mid-stream) — mark it handled
+        // from birth so the rejection surfaces only through finish(), never as an
+        // unhandled promise rejection. The derived promise resolves; the original
+        // still rejects for the awaiter.
+        void this.drained.catch(() => { });
+    }
+    /** Feed one scanline (`width × 4` RGBA bytes). The bytes must stay untouched until the returned promise resolves. */
+    async writeRow(rgba) {
+        if (this.closed)
+            throw new Error('png-stitch: writer already finished');
+        if (this.rowsWritten >= this.height)
+            throw new Error(`png-stitch: row ${this.rowsWritten} exceeds the declared height ${this.height}`);
+        if (rgba.length !== this.width * 4) {
+            throw new Error(`png-stitch: row is ${rgba.length} bytes, expected ${this.width * 4} (width ${this.width} × RGBA)`);
+        }
+        await this.writer.write(FILTER_NONE);
+        await this.writer.write(rgba);
+        this.rowsWritten += 1;
+    }
+    /** Close the stream and assemble the file. Rejects unless exactly `height` rows were fed. */
+    async finish() {
+        if (this.closed)
+            throw new Error('png-stitch: writer already finished');
+        if (this.rowsWritten !== this.height) {
+            throw new Error(`png-stitch: declared ${this.height} rows but ${this.rowsWritten} were written — IHDR height must equal Σ slice heights`);
+        }
+        this.closed = true;
+        await this.writer.close();
+        const compressed = await this.drained;
+        const parts = [exports.PNG_SIGNATURE, pngChunk('IHDR', ihdrData(this.width, this.height))];
+        for (const payload of splitIdatBytes(compressed, exports.MAX_IDAT_CHUNK_BYTES)) {
+            parts.push(pngChunk('IDAT', payload));
+        }
+        parts.push(exports.IEND_CHUNK);
+        return new Blob(parts);
+    }
+}
+exports.PngStitchWriter = PngStitchWriter;
+/* ============================================================================
+ * BROWSER ORCHESTRATION — slice blobs in, single PNG Blob out
+ * (never executed by the check script; Node has no createImageBitmap)
+ * ========================================================================== */
+/**
+ * Feature probe for the stitch path (ticket 07): CompressionStream gates the
+ * whole mechanism (Safari gained it in 16.4, alongside createImageBitmap and
+ * Blob — the trio is checked anyway because each is independently load-bearing).
+ * Unavailable → the caller falls back to the legacy multi-file delivery.
+ */
+function supportsPngStitch() {
+    return typeof CompressionStream === 'function' && typeof createImageBitmap === 'function' && typeof Blob === 'function';
+}
+/**
+ * Stitch painted slices into one PNG of the shared physical width.
+ *
+ * Per slice: createImageBitmap → draw onto a throwaway canvas → getImageData →
+ * writeRow per scanline → zero the canvas and close the bitmap before the next
+ * slice. getImageData un-premultiplies alpha, which is lossy for translucent
+ * pixels — the share card paints on an opaque background (alpha 255), so the
+ * round-trip is exact here. Every slice must decode at exactly the global
+ * width and its declared height; a mismatch means a painting bug, and the
+ * writer's row accounting would corrupt the file, so it fails loudly instead.
+ */
+async function stitchSliceBlobs(parts, width) {
+    if (parts.length === 0)
+        throw new Error('png-stitch: no slices to stitch');
+    if (!Number.isInteger(width) || width <= 0)
+        throw new Error(`png-stitch: invalid stitch width ${width}`);
+    const totalHeight = parts.reduce((sum, part) => sum + part.height, 0);
+    const writer = new PngStitchWriter(width, totalHeight);
+    for (const part of parts) {
+        const bitmap = await createImageBitmap(part.blob);
+        try {
+            if (bitmap.width !== width) {
+                throw new Error(`png-stitch: slice decoded ${bitmap.width}px wide, expected the global ${width}px — cannot concatenate scanlines`);
+            }
+            if (bitmap.height !== part.height) {
+                throw new Error(`png-stitch: slice decoded ${bitmap.height}px tall, planned ${part.height}px`);
+            }
+            const canvas = document.createElement('canvas');
+            canvas.width = width;
+            canvas.height = part.height;
+            try {
+                const ctx = canvas.getContext('2d', { willReadFrequently: true });
+                if (ctx === null)
+                    throw new Error('png-stitch: 2d context unavailable');
+                ctx.drawImage(bitmap, 0, 0);
+                const image = ctx.getImageData(0, 0, width, part.height);
+                const bytesPerRow = width * 4;
+                for (let y = 0; y < part.height; y++) {
+                    // Zero-copy row view over the ImageData buffer (its data is a
+                    // Uint8ClampedArray; a same-offset Uint8Array view shares the bytes).
+                    const row = new Uint8Array(image.data.buffer, image.data.byteOffset + y * bytesPerRow, bytesPerRow);
+                    await writer.writeRow(row);
+                }
+            }
+            finally {
+                canvas.width = 0;
+                canvas.height = 0;
+            }
+        }
+        finally {
+            bitmap.close();
+        }
+    }
+    return writer.finish();
+}
+};
+__modules["share/share-constants.js"] = function (require, module, exports) {
+"use strict";
+/**
+ * Template constants the share card and its rasterizer MUST agree on
+ * (tickets 03/04; the width-lifting formulas in rasterize.ts invert the
+ * template's own constraints, so a diverging copy would mis-bucket wide
+ * content). Formerly duplicated as literals in share-card.tsx and re-derived
+ * in rasterize.ts with a regex lock in the check script; both sides now
+ * import this single module, and scripts/check-share-image.mjs asserts its
+ * values directly.
+ *
+ * Hard rule for this file: a pure leaf — no imports, no JSX, no DOM, no
+ * module side effects. Node type stripping executes every value import, and
+ * both the check script and the client bundler rely on this module being
+ * loadable anywhere.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USER_BUBBLE_PAD_X = exports.USER_BUBBLE_MAX_RATIO = exports.WIDE_SLICE_WIDTH = exports.BASE_CARD_WIDTH = void 0;
+/** Base logical card width (share-card.tsx default render width). */
+exports.BASE_CARD_WIDTH = 390;
+/** Widened slice width for wide content (PLAN §5.2 “更大逻辑宽 ~780”). */
+exports.WIDE_SLICE_WIDTH = 780;
+/**
+ * User-bubble width cap relative to its row (`maxWidth` in share-card.tsx,
+ * e.g. 0.82 → '82%'). cardWidthForUserBubble inverts this percentage into a
+ * division, so the two sides must be the same number.
+ */
+exports.USER_BUBBLE_MAX_RATIO = 0.82;
+/** Horizontal padding inside the user bubble (its `padding` X component). */
+exports.USER_BUBBLE_PAD_X = 14;
+};
+__modules["share/rasterize.js"] = function (require, module, exports) {
+"use strict";
+/**
+ * Share-card slicing + rasterization (ticket 04, PLAN §5.2).
+ *
+ * Turns a rendered ShareCard DOM tree (ticket 03: fully inline-styled, marked
+ * with data-share-card / -header / -turn / -role / -footer) into a sequence of
+ * PNG blobs: slice by measured turn heights under a per-slice canvas pixel
+ * budget, then paint each slice through
+ * `<svg><foreignObject>` → Image → canvas → PNG export. The SVG document
+ * carries each slice's PHYSICAL target size (intrinsic = canvas), so the image
+ * rasterizes sharp at the canvas's own resolution and the draw is a 1:1 copy.
+ *
+ * File layout, and why it matters:
+ * - The top half is PURE planning math (no DOM, no React). It may import
+ *   ONLY the pure constants module of this directory (share-constants.ts):
+ *   scripts/check-share-image.mjs imports this file through Node type
+ *   stripping, which EXECUTES every value import — JSX or DOM code would
+ *   break the check, and any other module would widen the client bundle.
+ * - The DOM half below only MEASURES and EXECUTES the pure plan's decisions:
+ *   slice grouping, width lifting, scale factors, pixel-ratio fallback and
+ *   truncation are all decided by the pure functions, and the SVG document the
+ *   painter draws is built by a pure serializer — so tests can pin all of it.
+ *
+ * Release policy per slice (PLAN §5.2): each slice is painted, blobbed and its
+ * canvas dropped before the next slice is built — the export never holds more
+ * than one live canvas. Ticket 07 adds the `unified` planning mode whose
+ * single physical width lets png-stitch.ts concatenate the slice PNGs into
+ * one long image.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShareRasterizeError = exports.ULTRA_WIDTH_MARGIN = exports.PIXEL_RATIO_STEPS = exports.MAX_SLICES = exports.SLICE_PIXEL_BUDGET = void 0;
+exports.ratioChain = ratioChain;
+exports.slicePixelCount = slicePixelCount;
+exports.rasterGeometry = rasterGeometry;
+exports.buildSvgDocument = buildSvgDocument;
+exports.cardWidthForContent = cardWidthForContent;
+exports.cardWidthForUserBubble = cardWidthForUserBubble;
+exports.requiredCardWidth = requiredCardWidth;
+exports.bucketTurnWidth = bucketTurnWidth;
+exports.ultraSliceWidth = ultraSliceWidth;
+exports.planShareSlices = planShareSlices;
+exports.unifiedCardWidth = unifiedCardWidth;
+exports.planShareSlicesUnified = planShareSlicesUnified;
+exports.stitchPixelWidth = stitchPixelWidth;
+exports.rasterGeometryStitch = rasterGeometryStitch;
+exports.ensureProbe = ensureProbe;
+exports.rasterizeShareCard = rasterizeShareCard;
+const share_constants_ts_1 = require("./share/share-constants.js");
+/* ============================================================================
+ * PURE PLANNING — no DOM, no React, imports only share-constants.ts
+ * ========================================================================== */
+/** Per-slice physical pixel budget (iOS canvas hard cap 16.7M minus margin). */
+exports.SLICE_PIXEL_BUDGET = 12_000_000;
+/** Slice count ceiling; beyond it the head is dropped and the first slice marked. */
+exports.MAX_SLICES = 24;
+/** Pixel-ratio fallback ladder, walked top-down from min(devicePixelRatio, 2). */
+exports.PIXEL_RATIO_STEPS = [2, 1.5, 1];
+/** Safety px added around computed ultra widths (sub-pixel + rounding slack). */
+exports.ULTRA_WIDTH_MARGIN = 2;
+/** Localizable rasterize failure. `code` drives UI copy, `detail` is diagnostic. */
+class ShareRasterizeError extends Error {
+    code;
+    detail;
+    constructor(code, detail) {
+        super(`share-rasterize/${code}: ${detail}`);
+        this.code = code;
+        this.detail = detail;
+    }
+}
+exports.ShareRasterizeError = ShareRasterizeError;
+/** Descending pixel-ratio candidates for an already-clamped cap; never empty. */
+function ratioChain(cap) {
+    const chain = exports.PIXEL_RATIO_STEPS.filter((step) => step <= cap + 1e-9);
+    return chain.length > 0 ? chain : [1];
+}
+/** Physical pixels a slice occupies once painted (rounding up, canvas-style). */
+function slicePixelCount(outWidth, outHeight, pixelRatio) {
+    return Math.ceil(outWidth * pixelRatio) * Math.ceil(outHeight * pixelRatio);
+}
+/* ---- SVG raster document (pure; the painter only feeds it strings) --------- */
+const XHTML_NS = 'http://www.w3.org/1999/xhtml';
+const SVG_NS = 'http://www.w3.org/2000/svg';
+/** XML 1.0 forbids these; DOM text from transcripts can theoretically carry them. */
+const INVALID_XML_CHARS = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\uFFFE\uFFFF]/g;
+/**
+ * Physical target size for one slice's raster. The svg/foreignObject
+ * width/height attributes MUST be these numbers, never the logical ones: the
+ * browser rasterizes an SVG-as-image at its INTRINSIC size, so logical
+ * attributes make WebKit decode a small bitmap that drawImage then upscales
+ * (blurry on 2x screens) — and an unbounded ultra renderWidth would ask the
+ * decoder for an unbounded bitmap, sailing past the pixel budget before any
+ * canvas is allocated. The logical tree instead rides an inner wrapper scaled
+ * by `transformScale`, so the canvas draw is a 1:1 copy. Sizes are clamped
+ * into `budgetPx` (floor per side when clamping, so the product provably fits
+ * even where the unclamped per-side ceil would not have).
+ */
+function rasterGeometry(renderWidth, logicalHeight, scale, pixelRatio, budgetPx) {
+    let transformScale = scale * pixelRatio;
+    let width = Math.max(1, Math.ceil(renderWidth * transformScale));
+    let height = Math.max(1, Math.ceil(logicalHeight * transformScale));
+    if (width * height > budgetPx) {
+        transformScale *= Math.sqrt(budgetPx / (width * height));
+        width = Math.max(1, Math.floor(renderWidth * transformScale));
+        height = Math.max(1, Math.floor(logicalHeight * transformScale));
+    }
+    return { width, height, transformScale };
+}
+/**
+ * Serialize one slice subtree into a standalone SVG document sized at its
+ * PHYSICAL target: svg + foreignObject carry the physical px, the xhtml
+ * wrapper carries the logical size and a scale() transform, so the image
+ * rasterizes at exactly the resolution the canvas wants (no upscaled copy).
+ * `bodyHtml` is the prepared slice clone's outerHTML — namespace attributes
+ * must already be baked in by the caller (prepareXmlSerialization).
+ */
+function buildSvgDocument(bodyHtml, spec) {
+    const body = bodyHtml.replace(INVALID_XML_CHARS, '');
+    const wrapper = `<div xmlns="${XHTML_NS}" style="width:${spec.renderWidth}px;height:${spec.logicalHeight}px;transform:scale(${spec.transformScale});transform-origin:0 0">${body}</div>`;
+    return `<svg xmlns="${SVG_NS}" width="${spec.width}" height="${spec.height}"><foreignObject width="${spec.width}" height="${spec.height}">${wrapper}</foreignObject></svg>`;
+}
+/**
+ * Card width that fits `contentWidth` of assistant-style rows: the row spans
+ * the card's whole content box, so only the card padding stacks on top.
+ */
+function cardWidthForContent(contentWidth, cardPaddingX) {
+    return Math.ceil(contentWidth) + 2 * Math.ceil(cardPaddingX) + exports.ULTRA_WIDTH_MARGIN;
+}
+/**
+ * Card width that fits `contentWidth` inside a user bubble: the bubble is
+ * capped at {@link USER_BUBBLE_MAX_RATIO} of the row and adds its own padding,
+ * so the percentage constraint inverts into a division.
+ */
+function cardWidthForUserBubble(contentWidth, cardPaddingX) {
+    const inner = Math.ceil(contentWidth) + 2 * share_constants_ts_1.USER_BUBBLE_PAD_X;
+    return Math.ceil(inner / share_constants_ts_1.USER_BUBBLE_MAX_RATIO) + 2 * Math.ceil(cardPaddingX) + exports.ULTRA_WIDTH_MARGIN;
+}
+/** Card width a turn's measured content needs, by turn role. */
+function requiredCardWidth(role, contentWidth, cardPaddingX) {
+    return role === 'user' ? cardWidthForUserBubble(contentWidth, cardPaddingX) : cardWidthForContent(contentWidth, cardPaddingX);
+}
+/** Bucket one turn: base width / widened (~780) / wider-than-wide (scale-to-fit). */
+function bucketTurnWidth(role, contentWidth, cardPaddingX, baseWidth, wideWidth) {
+    const required = requiredCardWidth(role, contentWidth, cardPaddingX);
+    if (required <= baseWidth)
+        return 'base';
+    if (required <= wideWidth)
+        return 'wide';
+    return 'ultra';
+}
+/**
+ * Scale-to-fit geometry for content whose needed card width exceeds the wide
+ * width: render the slice at full natural width, shrink geometrically on
+ * output (pinch-zoom in the image viewer recovers readability — PLAN §5.2).
+ */
+function ultraSliceWidth(role, contentWidth, cardPaddingX, wideWidth) {
+    const renderWidth = requiredCardWidth(role, contentWidth, cardPaddingX);
+    return { renderWidth, scale: Math.min(1, wideWidth / renderWidth) };
+}
+function sameRun(a, b) {
+    return a.renderWidth === b.renderWidth && a.scale === b.scale;
+}
+function packingPixels(p, extras, pixelRatio) {
+    const height = (extras.paddingY + p.children) * p.scale;
+    return slicePixelCount(p.renderWidth * p.scale, height, pixelRatio);
+}
+/**
+ * Greedy first-fit over runs of consecutive turns sharing the same geometry.
+ * A turn is never split; a run never mixes widths (a 390px turn must not ride
+ * a 780px slice — mid-sequence line-length jumps read as a glitch). The first
+ * turn of a run always starts a slice even when it alone busts the budget
+ * (un-splittable); the caller's ratio walk notices and degrades.
+ */
+function greedyPacking(turns, extras, pixelRatio, budgetPx) {
+    const out = [];
+    let i = 0;
+    while (i < turns.length) {
+        let j = i + 1;
+        while (j < turns.length && sameRun(turns[j], turns[i]))
+            j += 1;
+        let cur;
+        let children = 0;
+        for (let k = i; k < j; k++) {
+            const turn = turns[k];
+            const projected = children + (cur === undefined ? 0 : extras.gap) + turn.height;
+            const candidate = cur === undefined
+                ? { from: k, to: k, renderWidth: turn.renderWidth, scale: turn.scale, children: turn.height }
+                : { ...cur, to: k, children: projected };
+            if (cur !== undefined && packingPixels(candidate, extras, pixelRatio) > budgetPx) {
+                out.push(cur);
+                cur = { from: k, to: k, renderWidth: turn.renderWidth, scale: turn.scale, children: turn.height };
+                children = turn.height;
+            }
+            else {
+                cur = candidate;
+                children = projected;
+            }
+        }
+        if (cur !== undefined)
+            out.push(cur);
+        i = j;
+    }
+    return out;
+}
+/**
+ * Ratio ladder + tail-keeping truncation shared by both planners. Order of
+ * levers (PLAN §5.2):
+ * 1. pick the highest pixel ratio whose greedy packing fits both the budget
+ *    on every slice and the {@link PlanOptions.maxSlices} count — the ratio is
+ *    GLOBAL, a property of the whole card's plan, never of one slice;
+ * 2. at the lowest ratio, keep the LAST maxSlices slices and drop the head
+ *    (a share image is of the RECENT conversation — with range=last the user
+ *    explicitly named the newest turns, which head-keeping would discard).
+ */
+function walkRatioAndTruncate(turns, extras, opts) {
+    const lastRatio = opts.ratios.length > 0 ? opts.ratios[opts.ratios.length - 1] : 1;
+    if (turns.length === 0) {
+        return { packing: [], pixelRatio: lastRatio, truncated: false, droppedTurns: 0 };
+    }
+    let packing;
+    let pixelRatio = lastRatio;
+    for (const candidate of opts.ratios) {
+        const p = greedyPacking(turns, extras, candidate, opts.budgetPx);
+        if (p.length <= opts.maxSlices && p.every((s) => packingPixels(s, extras, candidate) <= opts.budgetPx)) {
+            packing = p;
+            pixelRatio = candidate;
+            break;
+        }
+    }
+    let truncated = false;
+    let droppedTurns = 0;
+    if (packing === undefined) {
+        const p = greedyPacking(turns, extras, lastRatio, opts.budgetPx);
+        // Keep the TAIL: the head is the only droppable direction (see doc above).
+        const kept = p.slice(Math.max(0, p.length - opts.maxSlices));
+        const firstKept = kept[0];
+        droppedTurns = firstKept === undefined ? turns.length : firstKept.from;
+        truncated = droppedTurns > 0;
+        packing = kept;
+        pixelRatio = lastRatio;
+    }
+    return { packing, pixelRatio, truncated, droppedTurns };
+}
+/** Reserve the header/note/footer chrome on the first/last packing rows (mutates). */
+function attachChrome(packing, extras, truncated) {
+    const first = packing[0];
+    first.children += extras.headerHeight + extras.gap;
+    if (truncated)
+        first.children += extras.noteHeight + extras.gap;
+    const last = packing[packing.length - 1];
+    last.children += extras.footerHeight + extras.gap;
+}
+/**
+ * Plan the slice sequence (legacy multi-file geometry, ticket 04). Beyond the
+ * shared walk, any slice still over budget (an un-splittable giant turn, or
+ * the header/footer chrome nudging a full slice past the line) is shrunk
+ * uniformly PER SLICE (the `lever`) — geometric scaling keeps completeness,
+ * zoom restores size. Per-slice levers make physical widths diverge, which is
+ * fine for separate files and exactly what the stitched planner removes.
+ *
+ * Deterministic pure function of its inputs.
+ */
+function planShareSlices(turns, extras, opts) {
+    const { packing, pixelRatio, truncated, droppedTurns } = walkRatioAndTruncate(turns, extras, opts);
+    if (packing.length === 0) {
+        return { pixelRatio, slices: [], truncated: false, droppedTurns: 0 };
+    }
+    attachChrome(packing, extras, truncated);
+    const count = packing.length;
+    const slices = packing.map((p, index) => {
+        const height = extras.paddingY + p.children;
+        // Budget lever: the sqrt bound ignores the canvas ceil rounding, so shrink
+        // iteratively (sub-1% deficits converge in one or two steps).
+        let scale = p.scale;
+        if (slicePixelCount(p.renderWidth * scale, height * scale, pixelRatio) > opts.budgetPx) {
+            const bound = Math.sqrt(opts.budgetPx / (p.renderWidth * height)) / pixelRatio;
+            scale = Math.min(p.scale, bound);
+            for (let attempt = 0; attempt < 24 && slicePixelCount(p.renderWidth * scale, height * scale, pixelRatio) > opts.budgetPx; attempt++) {
+                scale *= 0.997;
+            }
+        }
+        const lever = p.scale > 0 ? scale / p.scale : 1;
+        return {
+            from: p.from,
+            to: p.to,
+            renderWidth: p.renderWidth,
+            scale,
+            height,
+            outWidth: p.renderWidth * scale,
+            outHeight: height * scale,
+            lever,
+            first: index === 0,
+            last: index === count - 1,
+            truncated: truncated && index === 0,
+        };
+    });
+    return { pixelRatio, slices, truncated, droppedTurns };
+}
+/* ---- stitch-mode unified planning (ticket 07, PLAN §4.5) -------------------- */
+/**
+ * Global logical width of a stitched export: 390 unless ANY turn needs wide
+ * content, then 780 for the WHOLE card — one long image must not mix widths
+ * (scanlines concatenate only when every slice has the same pixel width; a
+ * mid-image line-length jump would read as a glitch anyway).
+ */
+function unifiedCardWidth(anyTurnNeedsWide) {
+    return anyTurnNeedsWide ? share_constants_ts_1.WIDE_SLICE_WIDTH : share_constants_ts_1.BASE_CARD_WIDTH;
+}
+/**
+ * Plan the slice sequence for a stitched single-PNG export. Same walk and
+ * truncation semantics as {@link planShareSlices}, but the budget lever is
+ * GLOBAL: one multiplier shared by every slice, so every slice's output width
+ * is identical and the PNG stitcher can concatenate scanlines directly. The
+ * inputs must already be normalized to the global width by the caller (the
+ * DOM half measures the card once at {@link unifiedCardWidth}; turns still
+ * wider than that keep their per-turn ultra scale-to-fit, which lands on the
+ * same output width by construction).
+ */
+function planShareSlicesUnified(turns, extras, opts) {
+    const { packing, pixelRatio, truncated, droppedTurns } = walkRatioAndTruncate(turns, extras, opts);
+    if (packing.length === 0) {
+        return { pixelRatio, slices: [], truncated: false, droppedTurns: 0 };
+    }
+    attachChrome(packing, extras, truncated);
+    // GLOBAL lever: when any un-splittable slice busts the budget at the chosen
+    // ratio, the most-shrinking slice governs a single multiplier applied to all
+    // of them — widths stay uniform (the stitch invariant) at the cost of
+    // shrinking well-behaved slices too, which only happens when some single
+    // turn is taller than the whole budget.
+    let lever = 1;
+    const pixelsOf = (p, multiplier) => {
+        const height = (extras.paddingY + p.children) * p.scale * multiplier;
+        return slicePixelCount(p.renderWidth * p.scale * multiplier, height, pixelRatio);
+    };
+    if (packing.some((p) => pixelsOf(p, 1) > opts.budgetPx)) {
+        let bound = 1;
+        for (const p of packing) {
+            const logical = extras.paddingY + p.children;
+            const sliceBound = Math.sqrt(opts.budgetPx / (p.renderWidth * logical)) / pixelRatio;
+            bound = Math.min(bound, sliceBound / p.scale);
+        }
+        lever = Math.min(1, bound);
+        for (let attempt = 0; attempt < 24 && packing.some((p) => pixelsOf(p, lever) > opts.budgetPx); attempt++) {
+            lever *= 0.997;
+        }
+    }
+    const count = packing.length;
+    const slices = packing.map((p, index) => {
+        const height = extras.paddingY + p.children;
+        const scale = p.scale * lever;
+        return {
+            from: p.from,
+            to: p.to,
+            renderWidth: p.renderWidth,
+            scale,
+            height,
+            outWidth: p.renderWidth * scale,
+            outHeight: height * scale,
+            lever,
+            first: index === 0,
+            last: index === count - 1,
+            truncated: truncated && index === 0,
+        };
+    });
+    return { pixelRatio, slices, truncated, droppedTurns };
+}
+/**
+ * Authoritative physical width of a stitched plan — the IHDR width of the
+ * single long image. Every slice's own `outWidth × pixelRatio` must already
+ * agree; the max absorbs the ±ε float noise of ultra scales
+ * (renderWidth × W/renderWidth), so one integer serves the whole card and the
+ * painter FORCES it (rasterGeometryStitch) instead of re-deriving it per slice.
+ */
+function stitchPixelWidth(plan) {
+    if (plan.slices.length === 0)
+        return 0;
+    const widest = plan.slices.reduce((max, s) => Math.max(max, s.outWidth), 0);
+    return Math.ceil(widest * plan.pixelRatio);
+}
+/**
+ * Physical raster geometry of one slice in stitch mode. The width is pinned to
+ * `globalWidth` so every slice's canvas — and the scanlines the stitcher reads
+ * from it — is exactly as wide as the final image; a slice that freshly
+ * measures past the per-slice budget would need a height CLIP (never a width
+ * shrink: that would break concatenation, never aspect distortion), and the
+ * painter rejects that case instead of clipping (see `clamped`). The
+ * planner's global lever is the mechanism that keeps slices in budget; this
+ * clamp is the loud tripwire behind it.
+ */
+function rasterGeometryStitch(renderWidth, logicalHeight, globalWidth, budgetPx) {
+    if (!Number.isInteger(globalWidth) || globalWidth <= 0)
+        throw new Error(`share-rasterize: invalid stitch width ${globalWidth}`);
+    const transformScale = globalWidth / renderWidth;
+    let height = Math.max(1, Math.ceil(logicalHeight * transformScale));
+    let clamped = false;
+    if (globalWidth * height > budgetPx) {
+        height = Math.max(1, Math.floor(budgetPx / globalWidth));
+        clamped = true;
+    }
+    return { width: globalWidth, height, transformScale, clamped };
+}
+/* ============================================================================
+ * DOM EXECUTION — measures only, executes the pure plan
+ * ========================================================================== */
+/** Overflow below this many px is rounding noise, not wide content. */
+const OVERFLOW_EPSILON = 1;
+/** Default truncation copy: counts the dropped head turns. */
+const DEFAULT_TRUNCATED_NOTE = (droppedTurns) => `已省略前 ${droppedTurns} 轮`;
+/**
+ * Offscreen measurement/render host. A shadow root so page stylesheets (which
+ * the later SVG-image render cannot load) do not reach the clones — inside
+ * the shadow tree only inherited properties flow through, and the card
+ * template resets the inheritable ones (font/color/line-height) inline on its
+ * root, making the two contexts agree. position:fixed/-9999px keeps it laid
+ * out (measurement needs real layout) but invisible.
+ */
+function createOffscreenHost() {
+    const host = document.createElement('div');
+    host.setAttribute('data-share-rasterize-host', '');
+    host.style.position = 'fixed';
+    host.style.left = '-9999px';
+    host.style.top = '0';
+    const root = host.attachShadow({ mode: 'open' });
+    document.body.appendChild(host);
+    return { root, dispose: () => { host.remove(); } };
+}
+function cloneCardAt(card, width) {
+    const clone = card.cloneNode(true);
+    clone.style.width = `${width}px`;
+    return clone;
+}
+/**
+ * Natural content width of a turn: the widest descendant box that actually
+ * overflows its own container (`white-space: pre` code/table segments — their
+ * extent is container-independent). Non-overflowing descendants report their
+ * box width, which is a layout result, not a need, so they are skipped.
+ */
+function contentExtent(turn) {
+    let max = 0;
+    for (const el of turn.querySelectorAll('*')) {
+        if (el.scrollWidth > el.clientWidth + OVERFLOW_EPSILON && el.scrollWidth > max) {
+            max = el.scrollWidth;
+        }
+    }
+    return max;
+}
+/**
+ * Clone the card at `width`, measure everything the planner needs, drop the
+ * clone. All reads (offsetHeight/scrollWidth/getComputedStyle) force sync
+ * layout, so the numbers are stable the moment the clone is attached — no
+ * frame timing involved.
+ */
+function measureCardAt(root, card, width) {
+    const clone = cloneCardAt(card, width);
+    root.appendChild(clone);
+    const turns = [];
+    for (const el of Array.from(clone.querySelectorAll('[data-share-turn]'))) {
+        const raw = el.getAttribute('data-share-turn');
+        if (raw === null)
+            continue;
+        const seq = Number(raw);
+        if (!Number.isFinite(seq))
+            continue;
+        turns.push({
+            seq,
+            role: el.getAttribute('data-share-role') === 'user' ? 'user' : 'assistant',
+            height: el.offsetHeight,
+            content: contentExtent(el),
+        });
+    }
+    const computed = getComputedStyle(clone);
+    const header = clone.querySelector('[data-share-header]');
+    const footer = clone.querySelector('[data-share-footer]');
+    const measure = {
+        turns,
+        headerHeight: header?.offsetHeight ?? 0,
+        footerHeight: footer?.offsetHeight ?? 0,
+        gap: parsePx(computed.rowGap),
+        paddingY: parsePx(computed.paddingTop) + parsePx(computed.paddingBottom),
+        paddingX: parsePx(computed.paddingLeft),
+    };
+    clone.remove();
+    return measure;
+}
+function parsePx(value) {
+    const n = Number.parseFloat(value);
+    return Number.isFinite(n) ? n : 0;
+}
+function measureElementHeight(root, el) {
+    root.appendChild(el);
+    const h = el.offsetHeight;
+    el.remove();
+    return h;
+}
+/**
+ * Measure an ultra turn at its planned width, re-deciding up to three times if
+ * the formula missed a constraint the DOM knows better (nested percentage
+ * boxes): widening the card never shrinks `pre` content, so re-measuring
+ * converges. When it still does not fit after the third pass the geometry is
+ * exported anyway (completeness over sharpness) but warned about once — a
+ * silent clip would look like data loss.
+ */
+function measureUltraTurn(root, card, turn, cardPaddingX, targetWidth) {
+    let geo = ultraSliceWidth(turn.role, turn.content, cardPaddingX, targetWidth);
+    let height = turn.height;
+    let scrollWidth = 0;
+    let fits = false;
+    for (let attempt = 0; attempt < 3 && !fits; attempt++) {
+        const clone = cloneCardAt(card, geo.renderWidth);
+        root.appendChild(clone);
+        const el = clone.querySelector(`[data-share-turn="${turn.seq}"]`);
+        const extent = el !== null ? contentExtent(el) : turn.content;
+        height = el?.offsetHeight ?? height;
+        scrollWidth = el?.scrollWidth ?? 0;
+        fits = el === null || scrollWidth <= geo.renderWidth;
+        clone.remove();
+        if (!fits)
+            geo = ultraSliceWidth(turn.role, extent, cardPaddingX, targetWidth);
+    }
+    if (!fits) {
+        console.warn(`[dsh-zen-remote] share-image: ultra turn ${turn.seq} still wider than its slice after 3 re-measures (content ${scrollWidth}px > render width ${geo.renderWidth}px); exporting may clip its right edge`);
+    }
+    return { height, renderWidth: geo.renderWidth, scale: geo.scale };
+}
+/** Theme probes for the truncation note, read off the live card (inline styles). */
+function readNoteTheme(card) {
+    let tertiary = '#81858c';
+    let border = 'rgba(0, 0, 0, 0.1)';
+    let fontFamily = '';
+    try {
+        fontFamily = getComputedStyle(card).fontFamily;
+        const caption = card.querySelector('[data-share-footer] span:last-of-type');
+        if (caption !== null)
+            tertiary = getComputedStyle(caption).color;
+        const rule = card.querySelector('[data-share-footer] > div:first-child');
+        if (rule !== null)
+            border = getComputedStyle(rule).backgroundColor;
+    }
+    catch {
+        // getComputedStyle on a detached card — the defaults above carry the note.
+    }
+    return { tertiary, border, fontFamily };
+}
+/** The「已省略前 X 轮」marker bar — inline-styled like everything the card renders. */
+function buildTruncationNote(text, theme) {
+    const el = document.createElement('div');
+    el.setAttribute('data-share-truncated', '');
+    el.style.display = 'flex';
+    el.style.alignItems = 'center';
+    el.style.gap = '6px';
+    el.style.padding = '8px 12px';
+    el.style.border = `1px dashed ${theme.border}`;
+    el.style.borderRadius = '8px';
+    el.style.fontSize = '12px';
+    el.style.lineHeight = '1.5';
+    el.style.color = theme.tertiary;
+    if (theme.fontFamily !== '')
+        el.style.fontFamily = theme.fontFamily;
+    el.style.overflow = 'visible';
+    el.textContent = text;
+    return el;
+}
+/**
+ * Clone the card and prune it down to exactly one slice's content: the
+ * planned turns, the header only on the first slice, the footer only on the
+ * last, plus the truncation note right under the header of a truncated first
+ * slice. The root's own flex gap/padding keep the layout identical to the
+ * planner's arithmetic (children + inter-child gaps + padding).
+ */
+function buildSliceClone(card, root, slice, seqs, note) {
+    const clone = cloneCardAt(card, slice.renderWidth);
+    for (const el of Array.from(clone.querySelectorAll('[data-share-turn]'))) {
+        const raw = el.getAttribute('data-share-turn');
+        if (raw === null || !seqs.has(Number(raw)))
+            el.remove();
+    }
+    const header = clone.querySelector('[data-share-header]');
+    if (!slice.first)
+        header?.remove();
+    if (slice.truncated && note !== undefined) {
+        const noteNode = note.cloneNode(true);
+        if (header !== null && header.parentElement !== null)
+            header.parentElement.insertBefore(noteNode, header.nextSibling);
+        else
+            clone.insertBefore(noteNode, clone.firstChild);
+    }
+    if (!slice.last)
+        clone.querySelector('[data-share-footer]')?.remove();
+    root.appendChild(clone);
+    return clone;
+}
+/**
+ * Make an HTML subtree survive XML parsing: the foreignObject child needs the
+ * xhtml namespace (HTML serialization never emits it), and inline `<svg>`
+ * glyphs (the image placeholder icon) need theirs — without it they parse as
+ * xhtml-namespace elements named "svg" and silently render as nothing.
+ */
+function prepareXmlSerialization(root) {
+    root.setAttribute('xmlns', XHTML_NS);
+    for (const el of Array.from(root.querySelectorAll('*'))) {
+        if (el.namespaceURI === SVG_NS)
+            el.setAttribute('xmlns', SVG_NS);
+    }
+}
+/**
+ * Describe a source URL for an error surface WITHOUT embedding its content:
+ * the SVG data URL carries the whole card (session transcript), so only the
+ * scheme prefix and total length are kept.
+ */
+function describeImageUrl(url) {
+    if (!url.startsWith('data:'))
+        return url.slice(0, 120);
+    const comma = url.indexOf(',');
+    const prefix = comma === -1 ? url.slice(0, 48) : url.slice(0, comma);
+    return `${prefix} (${url.length} chars, payload omitted)`;
+}
+function loadImage(url) {
+    return new Promise((resolve, reject) => {
+        const img = new Image();
+        img.onload = () => { resolve(img); };
+        img.onerror = () => { reject(new ShareRasterizeError('image-load', describeImageUrl(url))); };
+        img.src = url;
+    });
+}
+function canvasToPng(canvas) {
+    return new Promise((resolve, reject) => {
+        canvas.toBlob((blob) => {
+            if (blob === null)
+                reject(new ShareRasterizeError('canvas', 'toBlob returned null'));
+            else
+                resolve(blob);
+        }, 'image/png');
+    });
+}
+function readBackground(el) {
+    const bg = getComputedStyle(el).backgroundColor;
+    return bg === '' || bg === 'rgba(0, 0, 0, 0)' || bg === 'transparent' ? '#ffffff' : bg;
+}
+/**
+ * Paint one prepared slice clone: serialize → SVG data URL (encodeURIComponent
+ * — transcript text is not ASCII) sized at the slice's PHYSICAL target → Image
+ * whose intrinsic size already IS the canvas size → 1:1 canvas copy → PNG
+ * blob. The canvas is released (zeroed) before returning; only the blob is
+ * kept. Output height is taken from the freshly measured clone, not the
+ * planner's estimate — reflow at slice width is authoritative — and any
+ * resulting budget overshoot is clamped by rasterGeometry (legacy) or
+ * REFUSED with ShareRasterizeError('slice-over-budget') by
+ * rasterGeometryStitch (unified: width pinned to `globalWidth`, a floor'd
+ * height would silently clip the bottom — review 07+08).
+ */
+async function paintSlice(clone, slice, pixelRatio, globalWidth) {
+    const logicalHeight = Math.ceil(clone.offsetHeight);
+    let width;
+    let height;
+    let transformScale;
+    if (globalWidth === undefined) {
+        const geo = rasterGeometry(slice.renderWidth, logicalHeight, slice.scale, pixelRatio, exports.SLICE_PIXEL_BUDGET);
+        width = geo.width;
+        height = geo.height;
+        transformScale = geo.transformScale;
+    }
+    else {
+        const geo = rasterGeometryStitch(slice.renderWidth, logicalHeight, globalWidth, exports.SLICE_PIXEL_BUDGET);
+        if (geo.clamped) {
+            // Review 07+08 (plan B): floor'ing the height would silently cut the
+            // bottom off the slice — data loss the user cannot see. The planner's
+            // global lever should have kept every slice in budget; reaching here
+            // means it did not, and the honest answer is a localized failure, not a
+            // quietly truncated image.
+            const needed = Math.ceil(logicalHeight * geo.transformScale);
+            const detail = `slice ${slice.from}-${slice.to} measured ${needed}px tall at stitch width ${globalWidth}px, but the canvas budget caps it at ${geo.height}px — refusing a silent bottom clip`;
+            console.warn(`[dsh-zen-remote] share-image: ${detail} (the global lever should have prevented this)`);
+            throw new ShareRasterizeError('slice-over-budget', detail);
+        }
+        width = geo.width;
+        height = geo.height;
+        transformScale = geo.transformScale;
+    }
+    prepareXmlSerialization(clone);
+    const svg = buildSvgDocument(clone.outerHTML, {
+        renderWidth: slice.renderWidth,
+        logicalHeight,
+        width,
+        height,
+        transformScale,
+    });
+    const url = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
+    const img = await loadImage(url);
+    const canvas = document.createElement('canvas');
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext('2d');
+    if (ctx === null)
+        throw new ShareRasterizeError('canvas', '2d context unavailable');
+    ctx.fillStyle = readBackground(clone);
+    ctx.fillRect(0, 0, width, height);
+    ctx.imageSmoothingQuality = 'high';
+    // 1:1 copy — the SVG's intrinsic size is the physical target, so nothing is
+    // upscaled here (the old logical-intrinsic + drawImage(target) pair made
+    // WebKit hand back a small bitmap this call had to enlarge: blurry on 2x).
+    ctx.drawImage(img, 0, 0);
+    const blob = await canvasToPng(canvas);
+    canvas.width = 0;
+    canvas.height = 0;
+    return { blob, width, height };
+}
+let probeOutcome = 'unknown';
+const PROBE_SIZE = 40;
+const PROBE_CELLS = ['#e8322c', '#2c55e8', '#28a832', '#e8a028'];
+/**
+ * 2×2 feature probe (PLAN §5.2): before the first export, rasterize a tiny
+ * known card (four solid color cells through the exact foreignObject → Image
+ * → canvas path) and read the pixels back. Old Safari renders foreignObject
+ * images as nothing — exporting then would produce blank PNGs, so the probe
+ * fails loudly once per page load instead. Failure is sticky.
+ */
+async function ensureProbe() {
+    if (probeOutcome === 'ok')
+        return;
+    if (probeOutcome === 'failed') {
+        throw new ShareRasterizeError('probe-failed', 'the SVG foreignObject probe already failed on this page');
+    }
+    const cells = PROBE_CELLS.map((color) => `<div style="width:20px;height:20px;background:${color}"></div>`).join('');
+    const svg = `<svg xmlns="${SVG_NS}" width="${PROBE_SIZE}" height="${PROBE_SIZE}"><foreignObject width="${PROBE_SIZE}" height="${PROBE_SIZE}"><div xmlns="${XHTML_NS}" style="width:${PROBE_SIZE}px;height:${PROBE_SIZE}px;margin:0;display:flex;flex-wrap:wrap">${cells}</div></foreignObject></svg>`;
+    try {
+        const img = await loadImage(`data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`);
+        const canvas = document.createElement('canvas');
+        canvas.width = PROBE_SIZE;
+        canvas.height = PROBE_SIZE;
+        const ctx = canvas.getContext('2d', { willReadFrequently: true });
+        if (ctx === null)
+            throw new Error('2d context unavailable');
+        ctx.drawImage(img, 0, 0);
+        const data = ctx.getImageData(0, 0, PROBE_SIZE, PROBE_SIZE).data;
+        const at = (x, y, channel) => data[(y * PROBE_SIZE + x) * 4 + channel] ?? 0;
+        // Cell centers: red top-left, blue top-right (generous thresholds —
+        // color management may shift values a little, blankness shifts them a lot).
+        const red = at(10, 10, 0) >= 150 && at(10, 10, 1) < 150 && at(10, 10, 2) < 150;
+        const blue = at(30, 10, 2) >= 150 && at(30, 10, 0) < 150 && at(30, 10, 1) < 150;
+        canvas.width = 0;
+        canvas.height = 0;
+        if (!red || !blue)
+            throw new Error('probe canvas came back blank (foreignObject not rendered)');
+        probeOutcome = 'ok';
+    }
+    catch (err) {
+        probeOutcome = 'failed';
+        console.error('[dsh-zen-remote] share-image rasterize probe failed — this browser cannot paint SVG foreignObject content', err);
+        throw new ShareRasterizeError('probe-failed', err instanceof Error ? err.message : String(err));
+    }
+}
+/* ---- pipeline -------------------------------------------------------------- */
+/**
+ * Rasterize a rendered share card into a PNG sequence.
+ *
+ * Pipeline: probe once → measure a clone at base width → bucket turns (pure)
+ * → measure wide/ultra turns at their final widths → plan slices (pure) →
+ * per slice: prune a clone to the slice, measure, serialize into SVG, paint,
+ * release. The returned blobs are owned by the caller (object URLs etc.).
+ *
+ * `unified` (ticket 07) flips both planning decisions the stitch depends on:
+ * one global logical width (re-measured once at 390 or 780 — a card that
+ * lifts ANY turn to wide renders every turn wide) and one global budget
+ * lever, so `stitchWidth` comes back as the single physical width every slice
+ * shares and png-stitch.ts can concatenate the scanlines into one PNG.
+ */
+async function rasterizeShareCard(card, options = {}) {
+    await ensureProbe();
+    const cap = Math.min(2, Math.max(1, options.pixelRatioCap ?? (typeof window === 'undefined' ? 1 : window.devicePixelRatio || 1)));
+    const host = createOffscreenHost();
+    try {
+        const base = measureCardAt(host.root, card, share_constants_ts_1.BASE_CARD_WIDTH);
+        if (base.turns.length === 0) {
+            throw new ShareRasterizeError('empty-card', 'no [data-share-turn] elements found under the card root');
+        }
+        const noteTheme = readNoteTheme(card);
+        const noteFor = (droppedTurns) => buildTruncationNote((options.truncatedNote ?? DEFAULT_TRUNCATED_NOTE)(droppedTurns), noteTheme);
+        const extrasOf = (note) => ({
+            gap: base.gap,
+            paddingY: base.paddingY,
+            headerHeight: base.headerHeight,
+            footerHeight: base.footerHeight,
+            noteHeight: measureElementHeight(host.root, note),
+        });
+        const planOpts = { budgetPx: exports.SLICE_PIXEL_BUDGET, maxSlices: exports.MAX_SLICES, ratios: ratioChain(cap) };
+        let note = noteFor(0);
+        let plan;
+        let stitchWidth;
+        const inputs = [];
+        if (options.unified === true) {
+            // Global width first: any wide-needing turn widens the WHOLE card, then
+            // everything is (re)measured at that one width. Turns still wider than
+            // the global width keep the per-turn ultra scale-to-fit — which lands on
+            // the same output width by construction (renderWidth × W/renderWidth).
+            const needsWide = base.turns.some((turn) => bucketTurnWidth(turn.role, turn.content, base.paddingX, share_constants_ts_1.BASE_CARD_WIDTH, share_constants_ts_1.WIDE_SLICE_WIDTH) !== 'base');
+            const cardWidth = unifiedCardWidth(needsWide);
+            const measure = cardWidth === share_constants_ts_1.BASE_CARD_WIDTH ? base : measureCardAt(host.root, card, cardWidth);
+            for (const turn of measure.turns) {
+                if (requiredCardWidth(turn.role, turn.content, measure.paddingX) <= cardWidth) {
+                    inputs.push({ height: turn.height, renderWidth: cardWidth, scale: 1 });
+                }
+                else {
+                    const ultra = measureUltraTurn(host.root, card, turn, measure.paddingX, cardWidth);
+                    inputs.push({ height: ultra.height, renderWidth: ultra.renderWidth, scale: ultra.scale });
+                }
+            }
+            plan = planShareSlicesUnified(inputs, extrasOf(note), planOpts);
+            if (plan.truncated) {
+                // Re-plan once with the real dropped count baked into the note (its text
+                // length can change the bar's height); droppedTurns itself does not
+                // depend on noteHeight, so this converges in one step.
+                note = noteFor(plan.droppedTurns);
+                plan = planShareSlicesUnified(inputs, extrasOf(note), planOpts);
+            }
+            stitchWidth = stitchPixelWidth(plan);
+        }
+        else {
+            const buckets = base.turns.map((turn) => bucketTurnWidth(turn.role, turn.content, base.paddingX, share_constants_ts_1.BASE_CARD_WIDTH, share_constants_ts_1.WIDE_SLICE_WIDTH));
+            const wideHeights = buckets.includes('wide')
+                ? new Map(measureCardAt(host.root, card, share_constants_ts_1.WIDE_SLICE_WIDTH).turns.map((t) => [t.seq, t.height]))
+                : undefined;
+            for (let i = 0; i < base.turns.length; i++) {
+                const turn = base.turns[i];
+                const bucket = buckets[i];
+                if (bucket === 'base') {
+                    inputs.push({ height: turn.height, renderWidth: share_constants_ts_1.BASE_CARD_WIDTH, scale: 1 });
+                }
+                else if (bucket === 'wide') {
+                    inputs.push({ height: wideHeights?.get(turn.seq) ?? turn.height, renderWidth: share_constants_ts_1.WIDE_SLICE_WIDTH, scale: 1 });
+                }
+                else {
+                    const ultra = measureUltraTurn(host.root, card, turn, base.paddingX, share_constants_ts_1.WIDE_SLICE_WIDTH);
+                    inputs.push({ height: ultra.height, renderWidth: ultra.renderWidth, scale: ultra.scale });
+                }
+            }
+            plan = planShareSlices(inputs, extrasOf(note), planOpts);
+            if (plan.truncated) {
+                note = noteFor(plan.droppedTurns);
+                plan = planShareSlices(inputs, extrasOf(note), planOpts);
+            }
+        }
+        options.onProgress?.(0, plan.slices.length);
+        const slices = [];
+        for (let index = 0; index < plan.slices.length; index++) {
+            const slice = plan.slices[index];
+            const seqSet = new Set(base.turns.slice(slice.from, slice.to + 1).map((t) => t.seq));
+            const clone = buildSliceClone(card, host.root, slice, seqSet, slice.truncated ? note : undefined);
+            const painted = await paintSlice(clone, slice, plan.pixelRatio, stitchWidth);
+            clone.remove();
+            slices.push({
+                index,
+                blob: painted.blob,
+                width: painted.width,
+                height: painted.height,
+                logicalWidth: slice.renderWidth,
+                scale: slice.scale,
+                fromSeq: base.turns[slice.from].seq,
+                toSeq: base.turns[slice.to].seq,
+            });
+            options.onProgress?.(index + 1, plan.slices.length);
+        }
+        return { pixelRatio: plan.pixelRatio, truncated: plan.truncated, droppedTurns: plan.droppedTurns, slices, stitchWidth };
+    }
+    finally {
+        host.dispose();
+    }
+}
+};
+__modules["share/text-layout.js"] = function (require, module, exports) {
+"use strict";
+/**
+ * Pure text → segment fold for share-card text blocks (ticket 03).
+ *
+ * Deliberately NOT a markdown parser: the transcripts the share card renders
+ * are *mostly* markdown, and the readability wins that matter on a phone-size
+ * image are structures recognizable from line shape alone — fenced/indented
+ * code, list items, pipe tables. Everything else stays one pre-wrapped
+ * paragraph, which degrades gracefully (raw text still reads), instead of
+ * half-parsing markup into broken pseudo-HTML.
+ *
+ * No React and no DOM in this file on purpose: the share-image check script
+ * (ticket 04) imports it through Node type stripping, which rejects JSX, so
+ * the fold must live in a JSX-free module.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.segmentShareText = segmentShareText;
+/** ``` / ~~~ fence opener; a language tag after it is allowed and dropped. */
+const FENCE_OPEN = /^ {0,3}(```+|~~~+)/;
+/** A closing fence is the same run of the same character, alone on a line. */
+const FENCE_CLOSE = {
+    '`': /^ {0,3}`{3,}\s*$/,
+    '~': /^ {0,3}~{3,}\s*$/,
+};
+/** 4+ leading spaces or a tab — the classic indented-code threshold. */
+const INDENTED = /^(?: {4,}|\t)/;
+/** `- item` / `* item` / `+ item` / `12. item` / `12) item`. */
+const LIST_ITEM = /^ {0,3}([-*+]|\d{1,3}[.)]) +(.*)$/;
+/** Pipe-table row; must be followed by another pipe row to OPEN a table block
+ * (a single stray `|` line stays an ordinary paragraph). */
+const TABLE_ROW = /^\s*\|.*\|/;
+function isBlank(line) {
+    return line.trim() === '';
+}
+/**
+ * Fold one text block's raw string into display segments, top to bottom.
+ *
+ * Rules, in the order each line is tested:
+ * - ```/~~~ fences switch to verbatim code until the closing fence (or the
+ *   end of the block — an unterminated fence must not swallow nothing);
+ * - a 4-space/tab indent opens verbatim code; a blank line between two
+ *   indented lines stays inside the block (lazy continuation);
+ * - two consecutive pipe rows open a table block, collected while rows last;
+ * - a `-`/`*`/`+`/`N.`/`N)` line opens a list, collected while items last;
+ * - blank lines end the current paragraph; anything else accumulates into the
+ *   current paragraph (rendered pre-wrap, so manual line breaks survive).
+ * @param text - raw text-block content from the share-export route.
+ * @returns the segments in reading order; never contains empty segments.
+ */
+function segmentShareText(text) {
+    const segments = [];
+    const lines = text.replace(/\r\n?/g, '\n').split('\n');
+    let pending = [];
+    const flushPending = () => {
+        if (pending.length > 0) {
+            segments.push({ kind: 'para', text: pending.join('\n') });
+            pending = [];
+        }
+    };
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i] ?? '';
+        const fence = line.match(FENCE_OPEN);
+        if (fence !== null) {
+            flushPending();
+            const close = FENCE_CLOSE[fence[1]?.[0] ?? '`'] ?? FENCE_CLOSE['`'];
+            const body = [];
+            i += 1;
+            while (i < lines.length && !close.test(lines[i] ?? '')) {
+                body.push(lines[i] ?? '');
+                i += 1;
+            }
+            // Skip the closing fence; when the block never closed, this steps past
+            // the end and the loop simply ends.
+            i += 1;
+            if (body.length > 0)
+                segments.push({ kind: 'code', lines: body });
+            continue;
+        }
+        if (INDENTED.test(line)) {
+            flushPending();
+            const body = [line];
+            i += 1;
+            while (i < lines.length) {
+                const next = lines[i] ?? '';
+                if (INDENTED.test(next)) {
+                    body.push(next);
+                    i += 1;
+                    continue;
+                }
+                if (isBlank(next) && INDENTED.test(lines[i + 1] ?? '')) {
+                    body.push('');
+                    i += 1;
+                    continue;
+                }
+                break;
+            }
+            segments.push({ kind: 'code', lines: body });
+            continue;
+        }
+        if (TABLE_ROW.test(line) && TABLE_ROW.test(lines[i + 1] ?? '')) {
+            flushPending();
+            const body = [];
+            while (i < lines.length && TABLE_ROW.test(lines[i] ?? '')) {
+                body.push(lines[i] ?? '');
+                i += 1;
+            }
+            segments.push({ kind: 'table', lines: body });
+            continue;
+        }
+        if (isBlank(line)) {
+            flushPending();
+            i += 1;
+            continue;
+        }
+        const item = line.match(LIST_ITEM);
+        if (item !== null) {
+            flushPending();
+            const items = [];
+            while (i < lines.length) {
+                const m = (lines[i] ?? '').match(LIST_ITEM);
+                if (m === null)
+                    break;
+                items.push({ marker: m[1] ?? '-', text: m[2] ?? '' });
+                i += 1;
+            }
+            segments.push({ kind: 'list', items });
+            continue;
+        }
+        pending.push(line);
+        i += 1;
+    }
+    flushPending();
+    return segments;
+}
+};
+__modules["share/markdown.js"] = function (require, module, exports) {
+"use strict";
+/**
+ * Pure lenient Markdown-subset parser for the share card's assistant text
+ * (ticket 09, PLAN §5.1 v1.2).
+ *
+ * Scope = the constructs assistant transcripts actually use: ATX headings,
+ * paragraphs, ```/~~~ fenced code (with the language tag), 4-space indented
+ * code, blockquotes, ordered/unordered lists (two indent levels, 2-space
+ * multiples), GFM pipe tables with an alignment row, thematic breaks, and
+ * own-line image placeholders; inline bold/italic/strikethrough/code/link with
+ * backslash escapes. Nothing else — no HTML passthrough, no reference links,
+ * no setext headings, no syntax highlighting (PLAN §8 scope discipline).
+ *
+ * Leniency beats strictness ON PURPOSE (PLAN §5.1): a share image that shows
+ * stray asterisks is worse than one that shows plain text. Every marker pair
+ * must CLOSE before it counts — unclosed, empty or implausible markers fall
+ * back to their literal characters, so arbitrary prose round-trips as itself.
+ * The parser is also total: any input yields a tree (empty input yields []).
+ * Totality is enforced, not assumed: recursion (nested quotes, emphasis inside
+ * link text) carries a depth counter and a pathological 5000-deep "> > > …"
+ * degrades to literal paragraphs instead of overflowing the stack; one inline
+ * run longer than {@link INLINE_PLAIN_MAX} skips inline parsing entirely —
+ * every close-scan is then bounded, so no amount of unclosed markers can
+ * regress past linear time.
+ *
+ * Hard rule for this file: no imports, no JSX, no DOM, no module side effects.
+ * scripts/check-share-image.mjs loads it through Node type stripping, which
+ * EXECUTES every value import, and the client bundler inlines it next to
+ * share-card without new externals.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMarkdown = parseMarkdown;
+/* ---- shared character helpers ------------------------------------------------ */
+/** Whitespace test for the opener/closer flanking rules; EOL counts as space. */
+function isWs(ch) {
+    return ch === undefined || ch === ' ' || ch === '\t' || ch === '\n';
+}
+/** CommonMark's escapable set: one ASCII punctuation char after a backslash. */
+const ESCAPABLE = new Set('!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'.split(''));
+/**
+ * Nesting ceiling shared by the block and inline recursion (a quote inside a
+ * quote, emphasis inside link text). Real transcripts never approach it; past
+ * the ceiling the nested content degrades to literal text instead of growing
+ * the native stack — a synthetic 5000-deep "> " chain used to throw.
+ */
+const MAX_DEPTH = 64;
+/**
+ * One inline run longer than this parses as plain text, no markers. Keeps the
+ * close-marker scans bounded: unclosed "*a *a *a …" prose is quadratic in the
+ * classic scan-per-opener shape, and a share-card paragraph this long (4k+
+ * chars with no blank line) has no plausible emphasis anyway.
+ */
+const INLINE_PLAIN_MAX = 4096;
+/* ---- inline parser ----------------------------------------------------------- */
+/**
+ * Parse one inline run into spans. Scans left to right; backslash escapes and
+ * code spans are handled first (their content is literal), then emphasis and
+ * links. Anything that does not close cleanly is emitted as literal text.
+ */
+function parseInline(raw, depth = 0) {
+    // Depth or length guard (see the constants above): degrade to plain text.
+    if (depth >= MAX_DEPTH || raw.length > INLINE_PLAIN_MAX) {
+        return raw === '' ? [] : [{ kind: 'text', text: raw }];
+    }
+    const spans = [];
+    let buf = '';
+    const flush = () => {
+        if (buf !== '') {
+            spans.push({ kind: 'text', text: buf });
+            buf = '';
+        }
+    };
+    const n = raw.length;
+    let i = 0;
+    while (i < n) {
+        const ch = raw[i];
+        if (ch === '\\') {
+            const next = raw[i + 1];
+            if (next !== undefined && ESCAPABLE.has(next)) {
+                buf += next;
+                i += 2;
+            }
+            else {
+                buf += '\\';
+                i += 1;
+            }
+            continue;
+        }
+        if (ch === '`') {
+            const run = tickRun(raw, i);
+            const close = findTickRun(raw, i + run, run);
+            if (close !== -1) {
+                flush();
+                spans.push({ kind: 'code', text: raw.slice(i + run, close) });
+                i = close + run;
+            }
+            else {
+                buf += '`';
+                i += 1;
+            }
+            continue;
+        }
+        if (ch === '*') {
+            const run = starRun(raw, i);
+            // Try the longest marker first (*** = bold(italic)), then **, then *.
+            const lengths = run >= 3 ? [3, 2, 1] : run === 2 ? [2, 1] : [1];
+            let matched = false;
+            for (const len of lengths) {
+                if (matched)
+                    break;
+                // Left-flanking: an opener must be immediately followed by a
+                // non-space character (so "5 * 3" never italicizes).
+                if (isWs(raw[i + len]))
+                    continue;
+                const close = findStarClose(raw, i + len, len);
+                if (close === -1)
+                    continue;
+                const content = raw.slice(i + len, close);
+                if (content.trim() === '')
+                    continue;
+                flush();
+                const inner = parseInline(content, depth + 1);
+                if (len === 3)
+                    spans.push({ kind: 'bold', spans: [{ kind: 'italic', spans: inner }] });
+                else if (len === 2)
+                    spans.push({ kind: 'bold', spans: inner });
+                else
+                    spans.push({ kind: 'italic', spans: inner });
+                i = close + len;
+                matched = true;
+            }
+            if (!matched) {
+                buf += '*';
+                i += 1;
+            }
+            continue;
+        }
+        if (ch === '~' && raw[i + 1] === '~') {
+            const close = findStrikeClose(raw, i + 2);
+            if (close !== -1 && raw.slice(i + 2, close).trim() !== '') {
+                flush();
+                spans.push({ kind: 'strike', spans: parseInline(raw.slice(i + 2, close), depth + 1) });
+                i = close + 2;
+                continue;
+            }
+            // Unclosed ~~ (or a lone ~): literal tilde, one char at a time.
+            buf += '~';
+            i += 1;
+            continue;
+        }
+        if (ch === '[') {
+            const link = tryLink(raw, i, depth);
+            if (link !== undefined) {
+                flush();
+                spans.push(link.span);
+                i = link.end;
+                continue;
+            }
+            buf += '[';
+            i += 1;
+            continue;
+        }
+        buf += ch;
+        i += 1;
+    }
+    flush();
+    return spans;
+}
+/** Length of the backtick run starting at `start`. */
+function tickRun(raw, start) {
+    let n = 0;
+    while (raw[start + n] === '`')
+        n += 1;
+    return n;
+}
+/** Length of the asterisk run starting at `start`. */
+function starRun(raw, start) {
+    let n = 0;
+    while (raw[start + n] === '*')
+        n += 1;
+    return n;
+}
+/**
+ * Find the closing backtick run of EXACT length `len` at/after `from` (a code
+ * span closes only on a matching run, per CommonMark). Escapes do not apply
+ * inside code spans, so every tick is a tick.
+ */
+function findTickRun(raw, from, len) {
+    let j = from;
+    while (j + len <= raw.length) {
+        if (raw[j] !== '`') {
+            j += 1;
+            continue;
+        }
+        let k = 0;
+        while (k < len && raw[j + k] === '`')
+            k += 1;
+        if (k === len && raw[j + len] !== '`')
+            return j;
+        while (raw[j] === '`')
+            j += 1; // inside a longer run: skip it whole
+    }
+    return -1;
+}
+/**
+ * Find a `*` closer of length `len` at/after `from`: the run must match EXACTLY
+ * (a longer run cannot close a shorter marker — `*a **b** c*` must find its
+ * single-star closer past the inner bold pair, not the first half of it), be
+ * preceded by a non-space character (right-flanking), and escaped stars are
+ * skipped. Mirrors findTickRun's exact-length guard.
+ */
+function findStarClose(raw, from, len) {
+    let j = from;
+    while (j + len <= raw.length) {
+        if (raw[j] === '\\') {
+            j += 2;
+            continue;
+        }
+        if (raw[j] === '*') {
+            let k = 0;
+            while (k < len && raw[j + k] === '*')
+                k += 1;
+            if (k === len && raw[j + len] !== '*' && raw[j - 1] !== undefined && !isWs(raw[j - 1]))
+                return j;
+            while (raw[j] === '*')
+                j += 1;
+            continue;
+        }
+        j += 1;
+    }
+    return -1;
+}
+/**
+ * Find a `~~` closer at/after `from`, preceded by a non-space character. The
+ * run must be exactly two tildes — a `~~~` fence-looking run is not a strike
+ * closer (same exact-length rule as findStarClose).
+ */
+function findStrikeClose(raw, from) {
+    let j = from;
+    while (j + 2 <= raw.length) {
+        if (raw[j] === '\\') {
+            j += 2;
+            continue;
+        }
+        if (raw[j] === '~') {
+            if (raw[j + 1] === '~' && raw[j + 2] !== '~' && raw[j - 1] !== undefined && !isWs(raw[j - 1]))
+                return j;
+            // Not a closer (start of a longer run, or wrong flanking): skip the
+            // WHOLE run — advancing one char would let positions 2–3 of a `~~~`
+            // triple pose as an exact `~~` closer.
+            while (raw[j] === '~')
+                j += 1;
+            continue;
+        }
+        j += 1;
+    }
+    return -1;
+}
+/**
+ * Try to read `[text](href)` starting at the `[` at `start`. The destination
+ * must be a bare URL (no whitespace, no parentheses) — that requirement is
+ * what keeps prose like "[see (note)](aside)" from turning into links.
+ * Empty link text displays the URL itself.
+ */
+function tryLink(raw, start, depth) {
+    let j = start + 1;
+    while (j < raw.length && raw[j] !== ']') {
+        j += raw[j] === '\\' ? 2 : 1;
+    }
+    if (j >= raw.length || raw[j + 1] !== '(')
+        return undefined;
+    let k = j + 2;
+    while (k < raw.length && raw[k] !== ')') {
+        k += raw[k] === '\\' ? 2 : 1;
+    }
+    if (k >= raw.length)
+        return undefined;
+    const href = raw.slice(j + 2, k);
+    if (/[\s()]/.test(href))
+        return undefined;
+    const text = raw.slice(start + 1, j);
+    return {
+        span: { kind: 'link', spans: parseInline(text === '' ? href : text, depth + 1), href },
+        end: k + 1,
+    };
+}
+/* ---- block parser ------------------------------------------------------------ */
+/** ```/~~~ fence opener; the info string after it becomes the language tag. */
+const FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})[ \t]*(.*)$/;
+/** 4+ leading spaces or a tab — the indented-code threshold (as text-layout). */
+const INDENTED = /^(?: {4,}|\t)/;
+/** 3+ of one char (- * _) with optional spaces between — a thematic break. */
+const HR = /^ {0,3}([-*_])(?:[ \t]*\1){2,}[ \t]*$/;
+/** ATX heading: 1–6 hashes, then space(s) + text (or nothing). */
+const HEADING = /^ {0,3}(#{1,6})(?:[ \t]+(.*))?$/;
+/** Own-line image: `![alt](src)` with a bare-URL src (alt may be empty). */
+const IMAGE_LINE = /^ {0,3}!\[([^[\]]*)\]\(([^()[\]\s]*)\)[ \t]*$/;
+/** Blockquote prefix; the single space after `>` is consumed with it. */
+const QUOTE_PREFIX = /^ {0,3}>[ \t]?/;
+/**
+ * List item: up to 8 leading spaces (the block loop routes ≥4-space lines at
+ * document level to indented code, so inside a list collection the wider
+ * indents simply land on the nested level), then a bullet or `N.`/`N)` marker
+ * and space-separated content. The space is REQUIRED after the marker, which
+ * is what keeps "3.14" a paragraph.
+ */
+const LIST_ITEM = /^( {0,8})([-*+]|\d{1,9}[.)])(?:[ \t]+(.*))?$/;
+/** One delimiter-row cell: ---, :--, --:, :-: (at least one hyphen). */
+const DELIM_CELL = /^:?-+:?$/;
+/** Split a pipe row into trimmed cells; edge pipes are dropped when empty. */
+function splitCells(line) {
+    let cells = line.split('|');
+    if (cells.length > 1) {
+        if (cells[0].trim() === '')
+            cells = cells.slice(1);
+        if (cells.length > 1 && cells[cells.length - 1].trim() === '')
+            cells = cells.slice(0, -1);
+    }
+    return cells.map((cell) => cell.trim());
+}
+/** Delimiter-row test: has a pipe, and every cell is ---/:--/--:/:-:. */
+function isDelimiterRow(line) {
+    if (!line.includes('|'))
+        return false;
+    const cells = splitCells(line);
+    return cells.length > 0 && cells.every((cell) => cell !== '' && DELIM_CELL.test(cell));
+}
+/** Column alignment from one delimiter cell. */
+function alignOf(cell) {
+    const left = cell.startsWith(':');
+    const right = cell.endsWith(':');
+    if (left && right)
+        return 'center';
+    if (right)
+        return 'right';
+    if (left)
+        return 'left';
+    return null;
+}
+/** Parse a list-item line; undefined when the line is not an item. */
+function matchListItem(line) {
+    const m = line.match(LIST_ITEM);
+    if (m === null)
+        return undefined;
+    const marker = m[2];
+    const ordered = /^\d/.test(marker);
+    return {
+        indent: m[1].length,
+        ordered,
+        number: ordered ? Number.parseInt(marker, 10) : undefined,
+        text: m[3] ?? '',
+    };
+}
+/** Count leading spaces (a tab counts as the 4 that make indented code). */
+function leadingSpaces(line) {
+    if (line.startsWith('\t'))
+        return 4;
+    let n = 0;
+    while (line[n] === ' ')
+        n += 1;
+    return n;
+}
+/** Parse a run of lines into blocks (also the recursion entry for quotes). */
+function parseBlocks(lines, depth = 0) {
+    const blocks = [];
+    let para = [];
+    const flushPara = () => {
+        if (para.length > 0) {
+            blocks.push({ kind: 'para', spans: parseInline(para.join('\n'), depth) });
+            para = [];
+        }
+    };
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line.trim() === '') {
+            flushPara();
+            i += 1;
+            continue;
+        }
+        const fence = line.match(FENCE_OPEN);
+        if (fence !== null) {
+            flushPara();
+            const ch = fence[1][0];
+            const close = ch === '`' ? /^ {0,3}`{3,}[ \t]*$/ : /^ {0,3}~{3,}[ \t]*$/;
+            const body = [];
+            i += 1;
+            while (i < lines.length && !close.test(lines[i])) {
+                body.push(lines[i]);
+                i += 1;
+            }
+            // Past the closing fence; an unterminated fence just ends the block.
+            i += 1;
+            const info = fence[2]?.trim() ?? '';
+            blocks.push({ kind: 'code', lang: info === '' ? undefined : info, lines: body });
+            continue;
+        }
+        // Indented code cannot interrupt a paragraph (CommonMark) — with one open
+        // the line is an ordinary continuation below.
+        if (para.length === 0 && INDENTED.test(line)) {
+            const strip = (s) => s.replace(/^(?: {4}|\t)/, '');
+            const body = [strip(line)];
+            i += 1;
+            while (i < lines.length) {
+                const next = lines[i];
+                if (INDENTED.test(next)) {
+                    body.push(strip(next));
+                    i += 1;
+                    continue;
+                }
+                // A blank line between indented lines stays inside the block (lazy).
+                if (next.trim() === '' && INDENTED.test(lines[i + 1] ?? '')) {
+                    body.push('');
+                    i += 1;
+                    continue;
+                }
+                break;
+            }
+            blocks.push({ kind: 'code', lang: undefined, lines: body });
+            continue;
+        }
+        if (HR.test(line)) {
+            flushPara();
+            blocks.push({ kind: 'hr' });
+            i += 1;
+            continue;
+        }
+        const heading = line.match(HEADING);
+        if (heading !== null) {
+            flushPara();
+            blocks.push({ kind: 'heading', level: heading[1].length, spans: parseInline((heading[2] ?? '').trim(), depth) });
+            i += 1;
+            continue;
+        }
+        const image = line.match(IMAGE_LINE);
+        if (image !== null) {
+            flushPara();
+            blocks.push({ kind: 'image', alt: image[1] ?? '', src: image[2] ?? '' });
+            i += 1;
+            continue;
+        }
+        if (line.includes('|') && isDelimiterRow(lines[i + 1] ?? '')) {
+            flushPara();
+            const headerCells = splitCells(line);
+            const alignCells = splitCells(lines[i + 1]);
+            const align = headerCells.map((_, c) => (c < alignCells.length ? alignOf(alignCells[c]) : null));
+            i += 2;
+            const rows = [];
+            while (i < lines.length) {
+                const row = lines[i];
+                if (row.trim() === '' || !row.includes('|'))
+                    break;
+                rows.push(splitCells(row));
+                i += 1;
+            }
+            blocks.push({
+                kind: 'table',
+                align,
+                header: headerCells.map((cell) => parseInline(cell, depth)),
+                // Rows ride the header's column count: short rows pad, extras drop.
+                rows: rows.map((cells) => headerCells.map((_, c) => parseInline(cells[c] ?? '', depth))),
+            });
+            continue;
+        }
+        if (/^ {0,3}>/.test(line)) {
+            flushPara();
+            const inner = [];
+            while (i < lines.length && /^ {0,3}>/.test(lines[i])) {
+                inner.push(lines[i].replace(QUOTE_PREFIX, ''));
+                i += 1;
+            }
+            // Depth guard (MAX_DEPTH): past the ceiling the quoted lines degrade to
+            // a plain paragraph instead of recursing — a synthetic "> > > …" chain
+            // deep enough used to overflow the native stack.
+            blocks.push(depth + 1 >= MAX_DEPTH
+                ? { kind: 'para', spans: [{ kind: 'text', text: inner.join('\n') }] }
+                : { kind: 'quote', children: parseBlocks(inner, depth + 1) });
+            continue;
+        }
+        {
+            const item = matchListItem(line);
+            // Only 0–3-space indents OPEN a list at block level; deeper indents are
+            // indented code (para closed) or paragraph continuation (para open).
+            // Inside collectList the wider indents land on the nested level.
+            if (item !== undefined && item.indent <= 3) {
+                flushPara();
+                const collected = collectList(lines, i, depth);
+                blocks.push(collected.block);
+                i = collected.next;
+                continue;
+            }
+        }
+        para.push(line);
+        i += 1;
+    }
+    flushPara();
+    return blocks;
+}
 /**
- * Session header, right lane: the session-info entry (S4 owns the actual
- * sheet — this fires a hook event for it to pick up) and the workbench
- * entry, which triggers dsh-better-sidebar's own toggle. There is no public
- * API for "open the panel" (BetterSidebarService.openTab only auto-expands
- * for a content open, not a bare type-only open), so this clicks the
- * plugin's real toggle button through a stable, non-hashed anchor: its root
- * mount marker `[data-dsh-better-sidebar]` plus the `_toggleButton` class
- * suffix (verified live: 2026-08-17). Safe no-op when the plugin, or any
- * other workbench-style plugin sharing that convention, is not installed.
+ * Collect one list block starting at `start` (a list-item line).
+ *
+ * Rules: marker lines with ≥2 leading spaces nest under the last top-level
+ * item (capped at the parser's two levels); a non-marker line indented ≥2
+ * spaces lazily continues the deepest open item; a blank line keeps the list
+ * open only when the next non-blank line is a same-kind item (loose lists);
+ * anything else ends the block.
  */
-function MobileHeaderUtilities({ t }) {
-    // Better-sidebar phone close button (S3.1 follow-up, 2026-08-17): the
-    // panel's own top-right toggle cluster is hidden below 768px
-    // (styles/compat.css.ts) because it duplicates the workbench button
-    // below — but that cluster is also the panel's ONLY close control, so
-    // hiding it blindly leaves an open panel with no way out. This button is
-    // appended straight to document.body, mirroring the existing
-    // preview-full-toggle pattern in MobileNavOverlay.tsx (raw DOM, not a
-    // React portal — react-dom is not among this plugin's platform-module
-    // imports, see AGENTS.md "client import purity"): never inside the
-    // panel's own subtree (the third party's React re-renders would wipe
-    // it) and never under any transformed/backdrop-filter ancestor (the S4
-    // info-card WebKit lesson in AGENTS.md — position:fixed would re-anchor
-    // to that ancestor instead of the viewport). It clicks the SAME hidden
-    // official toggle the workbench button below uses. Visibility is pure
-    // CSS (styles/compat.css.ts: `body:has([data-dsh-better-sidebar]
-    // [class$="_panel"])` — the panel's class ends in "_panel" only while
-    // open, "_panelHidden" is appended once closed), so this effect only
-    // has to guarantee the node exists — no MutationObserver needed to
-    // track open/closed state. Icon paths copied verbatim from
-    // IconCloseOutline16 (primitives) for the same reason IconInfoOutline16
-    // above is hand-built: this button lives outside the React tree, so it
-    // cannot render a primitives component directly.
-    (0, react_1.useEffect)(() => {
-        const button = document.createElement('button');
-        button.type = 'button';
-        button.dataset.mobileNav = 'better-sidebar-close';
-        button.setAttribute('aria-label', t('workbenchClose'));
-        button.title = t('workbenchClose');
-        // Bottom-center labeled pill (real-device follow-up, 2026-08-17): the
-        // icon markup is a static trusted string (safe as innerHTML), but the
-        // locale label is untrusted-shaped text — built as a real text node via
-        // textContent, not string-concatenated into the same innerHTML, so a
-        // translation can never be parsed as markup.
-        button.innerHTML = '<svg viewBox="0 0 16 16" fill="none" aria-hidden="true">'
-            + '<path d="M14.1168 13.197L13.197 14.1167L1.8833 2.80303L2.80309 1.88324L14.1168 13.197Z" fill="currentColor"/>'
-            + '<path d="M13.197 1.88326L14.1168 2.80305L2.80309 14.1168L1.8833 13.197L13.197 1.88326Z" fill="currentColor"/>'
-            + '</svg>';
-        const label = document.createElement('span');
-        label.textContent = t('workbenchClose');
-        button.appendChild(label);
-        const onClick = () => {
-            document.querySelector('[data-dsh-better-sidebar] button[class$="_toggleButton"]')?.click();
-        };
-        button.addEventListener('click', onClick);
-        document.body.appendChild(button);
-        return () => {
-            button.removeEventListener('click', onClick);
-            button.remove();
-        };
-    }, [t]);
-    // Presence gate (2026-08-17 user question): without dsh-better-sidebar
-    // installed the workbench button was a dead control — rendered, clickable,
-    // did nothing. Same live-probe pattern as the home chips: observe until the
-    // plugin's root marker exists, hide the button while it doesn't. The close
-    // pill never had this problem (its CSS :has() gate needs the panel node).
-    const [workbenchPresent, setWorkbenchPresent] = (0, react_1.useState)(() => document.querySelector('[data-dsh-better-sidebar]') !== null);
-    (0, react_1.useEffect)(() => {
-        const check = () => setWorkbenchPresent(document.querySelector('[data-dsh-better-sidebar]') !== null);
-        const observer = new MutationObserver(check);
-        observer.observe(document.body, { childList: true, subtree: true });
-        check();
-        return () => observer.disconnect();
-    }, []);
-    return ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)("button", { type: "button", "data-mobile-nav": "header-info", "aria-label": t('sessionInfo'), title: t('sessionInfo'), onClick: () => window.dispatchEvent(new CustomEvent(nav_store_ts_1.SESSION_INFO_EVENT)), children: (0, jsx_runtime_1.jsx)(IconInfoOutline16, { size: 20 }) }), workbenchPresent && (0, jsx_runtime_1.jsx)("button", { type: "button", "data-mobile-nav": "header-workbench", "aria-label": t('workbench'), title: t('workbench'), onClick: () => {
-                    document.querySelector('[data-dsh-better-sidebar] button[class$="_toggleButton"]')?.click();
-                }, children: (0, jsx_runtime_1.jsx)(dsh_client_ui_primitives_1.IconPanelLeftOutline16, { size: 20 }) })] }));
+function collectList(lines, start, depth) {
+    const ordered = matchListItem(lines[start]).ordered;
+    const items = [];
+    const deepest = () => {
+        const top = items[items.length - 1];
+        if (top === undefined)
+            return undefined;
+        return top.children[top.children.length - 1] ?? top;
+    };
+    let i = start;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line.trim() === '') {
+            let j = i + 1;
+            while (j < lines.length && lines[j].trim() === '')
+                j += 1;
+            const nextItem = j < lines.length ? matchListItem(lines[j]) : undefined;
+            if (nextItem !== undefined && nextItem.ordered === ordered) {
+                i = j;
+                continue;
+            }
+            break;
+        }
+        const m = matchListItem(line);
+        if (m !== undefined) {
+            if (m.ordered !== ordered)
+                break;
+            const raw = { text: [m.text], number: m.number, children: [] };
+            if (m.indent >= 2 && items.length > 0)
+                items[items.length - 1].children.push(raw);
+            else
+                items.push(raw);
+            i += 1;
+            continue;
+        }
+        if (leadingSpaces(line) >= 2) {
+            const target = deepest();
+            if (target !== undefined) {
+                target.text.push(line.trim());
+                i += 1;
+                continue;
+            }
+        }
+        break;
+    }
+    const finish = (raw) => ({
+        spans: parseInline(raw.text.join('\n'), depth),
+        number: raw.number,
+        children: raw.children.map(finish),
+    });
+    return { block: { kind: 'list', ordered, items: items.map(finish) }, next: i };
+}
+/**
+ * Parse a raw text block into the share card's Markdown tree.
+ * @param text - raw text-block content from the share-export route.
+ * @returns blocks in reading order; `[]` for blank input.
+ */
+function parseMarkdown(text) {
+    return parseBlocks(text.replace(/\r\n?/g, '\n').split('\n'));
+}
+};
+__modules["share/share-card.js"] = function (require, module, exports) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SHARE_THEME = void 0;
+exports.readShareTheme = readShareTheme;
+exports.ShareCard = ShareCard;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const text_layout_ts_1 = require("./share/text-layout.js");
+const markdown_ts_1 = require("./share/markdown.js");
+const share_constants_ts_1 = require("./share/share-constants.js");
+/** Light-palette fallback (resolved values from the host theme package). */
+exports.DEFAULT_SHARE_THEME = {
+    text: '#0f1115',
+    textSecondary: '#61666b',
+    textTertiary: '#81858c',
+    cardBg: '#ffffff',
+    codeBg: '#f9fafb',
+    bubbleBg: '#0f1115',
+    bubbleText: '#ffffff',
+    accent: '#4176e6',
+    border: 'rgba(0, 0, 0, 0.1)',
+    fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", sans-serif',
+    monoFamily: '"SF Mono", "JetBrains Mono", "Fira Code", Consolas, Menlo, Courier, monospace',
+};
+/**
+ * Read the host theme once (per render call). A raw value that still contains
+ * `var(` means the engine returned it un-substituted — treated as missing so
+ * the default palette wins over a broken declaration.
+ * @returns concrete theme values for this render.
+ */
+function readShareTheme() {
+    const fallback = exports.DEFAULT_SHARE_THEME;
+    if (typeof document === 'undefined')
+        return fallback;
+    // body first (see file header), then documentElement as a generic fallback.
+    const sources = [getComputedStyle(document.body), getComputedStyle(document.documentElement)];
+    const read = (name) => {
+        for (const computed of sources) {
+            const raw = computed.getPropertyValue(name).trim();
+            if (raw !== '' && !raw.includes('var('))
+                return raw;
+        }
+        return undefined;
+    };
+    return {
+        text: read('--dsw-alias-label-primary') ?? fallback.text,
+        textSecondary: read('--dsw-alias-label-secondary') ?? fallback.textSecondary,
+        textTertiary: read('--dsw-alias-label-tertiary') ?? fallback.textTertiary,
+        cardBg: read('--dsw-alias-bg-base') ?? fallback.cardBg,
+        codeBg: read('--dsw-alias-markdown-code-block') ?? fallback.codeBg,
+        bubbleBg: read('--dsw-alias-brand-primary') ?? fallback.bubbleBg,
+        bubbleText: read('--dsw-alias-label-primary-foreground') ?? fallback.bubbleText,
+        accent: read('--dsw-alias-state-business-primary') ?? fallback.accent,
+        border: read('--dsw-alias-border-l2') ?? fallback.border,
+        fontFamily: read('--dsw-font-family') ?? fallback.fontFamily,
+        monoFamily: read('--ds-font-family-code') ?? fallback.monoFamily,
+    };
+}
+/**
+ * The bubble-width cap as the CSS percentage string the template renders —
+ * `Math.round` guards the float multiply (0.82 × 100), and the value comes
+ * from share-constants.ts so the rasterizer's width formulas invert exactly
+ * this number (see USER_BUBBLE_MAX_RATIO).
+ */
+const USER_BUBBLE_MAX_WIDTH = `${Math.round(share_constants_ts_1.USER_BUBBLE_MAX_RATIO * 100)}%`;
+/** Locale-following short date+time; the share image is dated content. */
+function formatStamp(ms) {
+    const date = new Date(ms);
+    try {
+        return new Intl.DateTimeFormat(undefined, {
+            year: 'numeric',
+            month: 'short',
+            day: 'numeric',
+            hour: '2-digit',
+            minute: '2-digit',
+        }).format(date);
+    }
+    catch {
+        return date.toISOString().slice(0, 16).replace('T', ' ');
+    }
+}
+/**
+ * The share card. A pure template: no hooks, no effects, no context — the
+ * same JSX must render identically inside the page (preview) and inside a
+ * cloned `<foreignObject>` (rasterize).
+ */
+function ShareCard({ title, subtitle, createdAt, turns, width, copy }) {
+    const theme = readShareTheme();
+    const logicalWidth = width ?? share_constants_ts_1.BASE_CARD_WIDTH;
+    // "N 轮" counts user anchors (one exchange = user prompt + its answers),
+    // matching how the host route counts turns for range=last.
+    const turnCount = turns.filter((turn) => turn.role === 'user').length;
+    const stamp = createdAt !== undefined && Number.isFinite(createdAt) ? formatStamp(createdAt) : undefined;
+    const metaParts = [
+        ...(subtitle !== undefined && subtitle !== '' ? [subtitle] : []),
+        ...(stamp !== undefined ? [stamp] : []),
+        copy.turnsLabel(turnCount),
+    ];
+    return ((0, jsx_runtime_1.jsxs)("div", { "data-share-card": "", style: {
+            width: `${logicalWidth}px`,
+            boxSizing: 'border-box',
+            display: 'flex',
+            flexDirection: 'column',
+            gap: '14px',
+            padding: '20px 18px 16px',
+            background: theme.cardBg,
+            color: theme.text,
+            fontFamily: theme.fontFamily,
+            fontSize: '15px',
+            lineHeight: 1.65,
+            // Pin the INHERITABLE typography so the page render (the preview and
+            // the rasterizer's measuring clones live in a shadow root, which still
+            // inherits these from the host cascade) and the SVG-image render (a
+            // fresh context at engine defaults) lay out identically — any unpinned
+            // property is a channel for host-style drift to change text wrapping
+            // between measurement and raster, invalidating the rasterizer's
+            // numbers. Every value below is the CSS initial value.
+            letterSpacing: 'normal',
+            wordBreak: 'normal',
+            overflowWrap: 'normal',
+            hyphens: 'manual',
+            textAlign: 'start',
+            textTransform: 'none',
+            tabSize: 8,
+            fontVariantLigatures: 'normal',
+            // Never hide horizontal content: wide code/tables must stay visible
+            // (and measurable by ticket 04) — see the file header.
+            overflow: 'visible',
+        }, children: [(0, jsx_runtime_1.jsxs)("div", { "data-share-header": "", style: { display: 'flex', flexDirection: 'column', gap: '6px' }, children: [(0, jsx_runtime_1.jsx)("div", { style: { fontSize: '17px', fontWeight: 600, lineHeight: 1.4 }, children: title }), (0, jsx_runtime_1.jsx)("div", { style: { fontSize: '12px', lineHeight: 1.5, color: theme.textSecondary }, children: metaParts.join(' · ') }), (0, jsx_runtime_1.jsx)("div", { style: { height: '1px', marginTop: '6px', background: theme.border } })] }), turns.map((turn) => turn.role === 'user'
+                ? ((0, jsx_runtime_1.jsx)("div", { "data-share-turn": turn.seq, "data-share-role": turn.role, style: { display: 'flex', justifyContent: 'flex-end' }, children: (0, jsx_runtime_1.jsx)("div", { style: {
+                            maxWidth: USER_BUBBLE_MAX_WIDTH,
+                            display: 'flex',
+                            flexDirection: 'column',
+                            gap: '8px',
+                            padding: `9px ${share_constants_ts_1.USER_BUBBLE_PAD_X}px`,
+                            background: theme.bubbleBg,
+                            color: theme.bubbleText,
+                            borderRadius: '16px',
+                            // Sharp corner on the trailing edge = the chat-bubble tail.
+                            borderBottomRightRadius: '4px',
+                            overflow: 'visible',
+                        }, children: (0, jsx_runtime_1.jsx)(ShareBlocks, { blocks: turn.blocks, role: turn.role, theme: theme, copy: copy }) }) }, turn.seq))
+                : ((0, jsx_runtime_1.jsx)("div", { "data-share-turn": turn.seq, "data-share-role": turn.role, style: { display: 'flex', flexDirection: 'column', gap: '8px', overflow: 'visible' }, children: (0, jsx_runtime_1.jsx)(ShareBlocks, { blocks: turn.blocks, role: turn.role, theme: theme, copy: copy }) }, turn.seq))), (0, jsx_runtime_1.jsxs)("div", { "data-share-footer": "", style: { display: 'flex', flexDirection: 'column', gap: '8px' }, children: [(0, jsx_runtime_1.jsx)("div", { style: { height: '1px', background: theme.border } }), (0, jsx_runtime_1.jsxs)("div", { style: { display: 'flex', alignItems: 'center', gap: '6px', fontSize: '11px', lineHeight: 1.4, color: theme.textTertiary }, children: [(0, jsx_runtime_1.jsx)("span", { style: { width: '3px', height: '12px', borderRadius: '2px', background: theme.accent } }), (0, jsx_runtime_1.jsxs)("span", { children: [copy.generatedBy, stamp !== undefined ? ` · ${stamp}` : ''] })] })] })] }));
+}
+/** Render one row's blocks in order (text flows, images become badges). */
+function ShareBlocks({ blocks, role, theme, copy }) {
+    return ((0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: blocks.map((block, index) => block.kind === 'text'
+            ? (role === 'assistant'
+                // Assistant prose is Markdown (ticket 09); user messages stay
+                // plain text — the Chat view renders them the same way.
+                ? (0, jsx_runtime_1.jsx)(ShareMarkdown, { text: block.text, theme: theme, copy: copy }, index)
+                : (0, jsx_runtime_1.jsx)(ShareText, { text: block.text, theme: theme }, index))
+            : (0, jsx_runtime_1.jsx)(ImageBadge, { theme: theme, label: copy.image }, index)) }));
+}
+/** User-message typesetting: the plain-text fold of ticket 03, unchanged. */
+function ShareText({ text, theme }) {
+    const segments = (0, text_layout_ts_1.segmentShareText)(text);
+    if (segments.length === 0)
+        return null;
+    return ((0, jsx_runtime_1.jsx)("div", { style: { display: 'flex', flexDirection: 'column', gap: '8px', overflow: 'visible' }, children: segments.map((segment, index) => ((0, jsx_runtime_1.jsx)(ShareSegment, { segment: segment, theme: theme }, index))) }));
+}
+function ShareSegment({ segment, theme }) {
+    switch (segment.kind) {
+        case 'code':
+        case 'table':
+            // Monospace + `pre` (NOT pre-wrap): the line's natural width wins, the
+            // block may visually overflow the card edge, and ticket 04 measures
+            // that width to widen the slice — wrapping here would destroy the only
+            // signal the width probe has.
+            return ((0, jsx_runtime_1.jsx)("div", { style: {
+                    fontFamily: theme.monoFamily,
+                    fontSize: '12.5px',
+                    lineHeight: 1.6,
+                    whiteSpace: 'pre',
+                    background: theme.codeBg,
+                    borderRadius: '8px',
+                    padding: '10px 12px',
+                    overflow: 'visible',
+                }, children: segment.lines.join('\n') }));
+        case 'list':
+            return ((0, jsx_runtime_1.jsx)("div", { style: { display: 'flex', flexDirection: 'column', gap: '4px' }, children: segment.items.map((item, index) => ((0, jsx_runtime_1.jsxs)("div", { style: { display: 'flex', gap: '8px' }, children: [(0, jsx_runtime_1.jsx)("span", { style: { flexShrink: 0, color: theme.textTertiary }, children: item.marker }), (0, jsx_runtime_1.jsx)("span", { style: { flex: 1, minWidth: 0, whiteSpace: 'pre-wrap', overflow: 'visible' }, children: item.text })] }, index))) }));
+        case 'para':
+        default:
+            return ((0, jsx_runtime_1.jsx)("div", { style: { whiteSpace: 'pre-wrap', overflow: 'visible' }, children: segment.text }));
+    }
+}
+/* ---- markdown rendering (ticket 09, PLAN §5.1 v1.2) -------------------------
+ * Assistant text renders through the pure parser in markdown.ts. Same red
+ * lines as the rest of the card: inline styles only (an SVG-as-image render
+ * loads no stylesheets), and NEVER hide horizontal content — code lines and
+ * table cells keep their natural width so the rasterizer's width probe can
+ * lift the slice (inline emphasis wraps instead, which changes nothing). */
+/** Assistant text block → parsed blocks → self-styled Markdown rendering. */
+function ShareMarkdown({ text, theme, copy }) {
+    const blocks = (0, markdown_ts_1.parseMarkdown)(text);
+    if (blocks.length === 0)
+        return null;
+    return ((0, jsx_runtime_1.jsx)("div", { style: { display: 'flex', flexDirection: 'column', gap: '8px', overflow: 'visible' }, children: blocks.map((block, index) => ((0, jsx_runtime_1.jsx)(MdBlockView, { block: block, theme: theme, copy: copy }, index))) }));
+}
+/** Heading ladder over the card's 15px body; h6 demotes to the secondary tone. */
+function mdHeadingStyle(level, theme) {
+    switch (level) {
+        case 1: return { fontSize: '20px', fontWeight: 700, lineHeight: 1.4 };
+        case 2: return { fontSize: '18px', fontWeight: 700, lineHeight: 1.4 };
+        case 3: return { fontSize: '16.5px', fontWeight: 600, lineHeight: 1.45 };
+        case 4: return { fontSize: '15.5px', fontWeight: 600, lineHeight: 1.5 };
+        case 5: return { fontSize: '15px', fontWeight: 600, lineHeight: 1.5 };
+        default: return { fontSize: '15px', fontWeight: 600, lineHeight: 1.5, color: theme.textSecondary };
+    }
+}
+/** One markdown block. Every branch keeps `overflow: 'visible'` (file header). */
+function MdBlockView({ block, theme, copy }) {
+    switch (block.kind) {
+        case 'heading':
+            return ((0, jsx_runtime_1.jsx)("div", { style: { ...mdHeadingStyle(block.level, theme), overflow: 'visible' }, children: (0, jsx_runtime_1.jsx)(MdSpans, { spans: block.spans, theme: theme }) }));
+        case 'para':
+            return ((0, jsx_runtime_1.jsx)("div", { style: { whiteSpace: 'pre-wrap', overflow: 'visible' }, children: (0, jsx_runtime_1.jsx)(MdSpans, { spans: block.spans, theme: theme }) }));
+        case 'code':
+            return ((0, jsx_runtime_1.jsxs)("div", { style: {
+                    background: theme.codeBg,
+                    borderRadius: '8px',
+                    padding: '10px 12px',
+                    display: 'flex',
+                    flexDirection: 'column',
+                    gap: '6px',
+                    overflow: 'visible',
+                }, children: [block.lang !== undefined ? ((0, jsx_runtime_1.jsx)("div", { style: { fontSize: '11px', lineHeight: 1.4, color: theme.textTertiary }, children: block.lang })) : null, (0, jsx_runtime_1.jsx)("div", { style: {
+                            fontFamily: theme.monoFamily,
+                            fontSize: '12.5px',
+                            lineHeight: 1.6,
+                            whiteSpace: 'pre',
+                            overflow: 'visible',
+                        }, children: block.lines.join('\n') })] }));
+        case 'quote':
+            return ((0, jsx_runtime_1.jsx)("div", { style: {
+                    borderLeft: `3px solid ${theme.border}`,
+                    paddingLeft: '12px',
+                    paddingRight: '2px',
+                    color: theme.textSecondary,
+                    display: 'flex',
+                    flexDirection: 'column',
+                    gap: '6px',
+                    overflow: 'visible',
+                }, children: block.children.map((child, index) => ((0, jsx_runtime_1.jsx)(MdBlockView, { block: child, theme: theme, copy: copy }, index))) }));
+        case 'list':
+            return (0, jsx_runtime_1.jsx)(MdListView, { items: block.items, depth: 0, theme: theme });
+        case 'table':
+            return (0, jsx_runtime_1.jsx)(MdTableView, { block: block, theme: theme });
+        case 'hr':
+            return (0, jsx_runtime_1.jsx)("div", { style: { height: '1px', background: theme.border, overflow: 'visible' } });
+        case 'image':
+            // Markdown image: same placeholder row an image block renders (the
+            // picture lives on the far end of a URL the share image cannot fetch).
+            return (0, jsx_runtime_1.jsx)(ImageBadge, { theme: theme, label: copy.image });
+    }
+}
+/** List rows; one nesting indent under the parent item's content column. */
+function MdListView({ items, depth, theme }) {
+    return ((0, jsx_runtime_1.jsx)("div", { style: { display: 'flex', flexDirection: 'column', gap: '4px', ...(depth > 0 ? { marginLeft: '18px' } : null) }, children: items.map((item, index) => {
+            const ordered = item.number !== undefined;
+            return ((0, jsx_runtime_1.jsxs)("div", { style: { display: 'flex', gap: '8px' }, children: [(0, jsx_runtime_1.jsx)("span", { style: {
+                            flexShrink: 0,
+                            color: theme.textTertiary,
+                            // A fixed marker column keeps 1.–9. dots right-aligned.
+                            minWidth: ordered ? '20px' : undefined,
+                            textAlign: ordered ? 'right' : undefined,
+                        }, children: ordered ? `${item.number}.` : '•' }), (0, jsx_runtime_1.jsxs)("div", { style: { flex: 1, minWidth: 0, display: 'flex', flexDirection: 'column', gap: '4px' }, children: [(0, jsx_runtime_1.jsx)("div", { style: { whiteSpace: 'pre-wrap', overflow: 'visible' }, children: (0, jsx_runtime_1.jsx)(MdSpans, { spans: item.spans, theme: theme }) }), item.children.length > 0 ? (0, jsx_runtime_1.jsx)(MdListView, { items: item.children, depth: depth + 1, theme: theme }) : null] })] }, index));
+        }) }));
+}
+/** Column alignment → CSS text-align ('start' keeps the card's direction). */
+function mdAlignText(align) {
+    if (align === 'center')
+        return 'center';
+    if (align === 'right')
+        return 'right';
+    return 'start';
+}
+/** GFM table as a natural-width grid: nowrap cells, hairline borders. */
+function MdTableView({ block, theme }) {
+    const cellBase = { padding: '6px 10px', border: `1px solid ${theme.border}` };
+    return ((0, jsx_runtime_1.jsxs)("table", { style: { borderCollapse: 'collapse', fontSize: '13px', lineHeight: 1.5, overflow: 'visible' }, children: [(0, jsx_runtime_1.jsx)("thead", { children: (0, jsx_runtime_1.jsx)("tr", { children: block.header.map((cell, index) => ((0, jsx_runtime_1.jsx)("th", { style: {
+                            ...cellBase,
+                            background: theme.codeBg,
+                            fontWeight: 600,
+                            textAlign: mdAlignText(block.align[index] ?? null),
+                            whiteSpace: 'nowrap',
+                            overflow: 'visible',
+                        }, children: (0, jsx_runtime_1.jsx)(MdSpans, { spans: cell, theme: theme }) }, index))) }) }), (0, jsx_runtime_1.jsx)("tbody", { children: block.rows.map((row, rowIndex) => ((0, jsx_runtime_1.jsx)("tr", { children: row.map((cell, colIndex) => ((0, jsx_runtime_1.jsx)("td", { style: {
+                            ...cellBase,
+                            textAlign: mdAlignText(block.align[colIndex] ?? null),
+                            // Natural width, same rationale as code lines above.
+                            whiteSpace: 'nowrap',
+                            overflow: 'visible',
+                        }, children: (0, jsx_runtime_1.jsx)(MdSpans, { spans: cell, theme: theme }) }, colIndex))) }, rowIndex))) })] }));
+}
+/** Render an inline span sequence (raw strings for plain text). */
+function MdSpans({ spans, theme }) {
+    if (spans.length === 0)
+        return null;
+    return ((0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: spans.map((span, index) => ((0, jsx_runtime_1.jsx)(MdSpanView, { span: span, theme: theme }, index))) }));
+}
+/**
+ * One inline span. Plain <span>s with explicit styles, never semantic tags:
+ * the SVG-image render applies its own UA cascade, and only explicit values
+ * lay out identically to the measured page render.
+ */
+function MdSpanView({ span, theme }) {
+    switch (span.kind) {
+        case 'text':
+            return span.text;
+        case 'bold':
+            return (0, jsx_runtime_1.jsx)("span", { style: { fontWeight: 700 }, children: (0, jsx_runtime_1.jsx)(MdSpans, { spans: span.spans, theme: theme }) });
+        case 'italic':
+            return (0, jsx_runtime_1.jsx)("span", { style: { fontStyle: 'italic' }, children: (0, jsx_runtime_1.jsx)(MdSpans, { spans: span.spans, theme: theme }) });
+        case 'strike':
+            return (0, jsx_runtime_1.jsx)("span", { style: { textDecoration: 'line-through' }, children: (0, jsx_runtime_1.jsx)(MdSpans, { spans: span.spans, theme: theme }) });
+        case 'code':
+            return ((0, jsx_runtime_1.jsx)("span", { style: {
+                    fontFamily: theme.monoFamily,
+                    fontSize: '0.92em',
+                    background: theme.codeBg,
+                    borderRadius: '4px',
+                    padding: '1px 5px',
+                }, children: span.text }));
+        case 'link':
+            // Colored text only: the share image is not clickable, and the URL is
+            // deliberately NOT repeated next to the label.
+            return (0, jsx_runtime_1.jsx)("span", { style: { color: theme.accent }, children: (0, jsx_runtime_1.jsx)(MdSpans, { spans: span.spans, theme: theme }) });
+    }
+}
+/** Image attachments stay placeholders in v1 (files live on the host disk). */
+function ImageBadge({ theme, label }) {
+    return ((0, jsx_runtime_1.jsxs)("div", { style: {
+            display: 'flex',
+            alignItems: 'center',
+            gap: '6px',
+            padding: '8px 12px',
+            border: `1px dashed ${theme.border}`,
+            borderRadius: '8px',
+            fontSize: '12px',
+            color: theme.textTertiary,
+            overflow: 'visible',
+        }, children: [(0, jsx_runtime_1.jsxs)("svg", { viewBox: "0 0 16 16", width: "14", height: "14", "aria-hidden": "true", style: { flexShrink: 0 }, children: [(0, jsx_runtime_1.jsx)("rect", { x: "1.5", y: "2.5", width: "13", height: "11", rx: "2", fill: "none", stroke: "currentColor", strokeWidth: "1.2" }), (0, jsx_runtime_1.jsx)("circle", { cx: "5.5", cy: "6.5", r: "1.3", fill: "currentColor" }), (0, jsx_runtime_1.jsx)("path", { d: "M2.5 12 L6.5 8 L9 10.5 L11.5 8 L13.5 10", fill: "none", stroke: "currentColor", strokeWidth: "1.2", strokeLinejoin: "round", strokeLinecap: "round" })] }), (0, jsx_runtime_1.jsx)("span", { children: label })] }));
+}
+};
+__modules["share/share-sheet.js"] = function (require, module, exports) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShareRangeSheet = ShareRangeSheet;
+const jsx_runtime_1 = require("react/jsx-runtime");
+/**
+ * Share-range bottom sheet (ticket 05, PLAN §6): the small picker that opens
+ * from the session-info sheet's 分享图 action — whole conversation or one of
+ * the last-N-turns presets (3/5/10, no free input).
+ *
+ * Mounts INSIDE the info layer's DOM as a DIRECT child of
+ * `[data-mobile-nav="info-layer"]` — a sibling of the info card, never a
+ * child of the card itself (a card-internal mount clipped this sheet's mask
+ * to the card's box, anchored its bottom to the card's scrollable area, and
+ * let taps outside the card reach the info mask underneath — closing both
+ * layers at once and stranding the share layer's history entry; review
+ * 2026-09-10). That placement buys three things for free: the ≥768px
+ * `display:none` of info.css.ts keeps the desktop pixel-identical no-op
+ * (this feature adds no page CSS, PLAN §9.4), the sheet paints in the
+ * header's z:70 promotion while the info sheet is open, and the info layer
+ * (itself a fixed stacking context, inset:0) is the containing block — so
+ * this sheet's own absolute inset:0 overlay is a fullscreen mask and its
+ * bottom anchor is the viewport safe area, exactly like the info card's.
+ * The back stack is the caller's business: the caller pushes one SHARE_LAYER
+ * entry on top of the info layer's, so a back gesture closes exactly this
+ * sheet — one layer per press, same discipline as history-nav.ts demands.
+ *
+ * All-inline styles like everything else in the share feature; theme values
+ * read the host CSS variables with the same fallbacks info.css.ts declares,
+ * and the entry animations reuse base.css.ts's existing keyframes (referenced
+ * from inline `animation`, which adds no stylesheet rules). Reduced-motion is
+ * honored by checking the media query at mount — inline styles cannot carry
+ * a media query themselves.
+ */
+const react_1 = require("react");
+const dsh_client_ui_primitives_1 = require("@deepseek-ai/dsh-client-ui-primitives");
+const fetch_share_ts_1 = require("./share/fetch-share.js");
+/** One-time page-load probe: skip the entry animations when the user asks for less motion. */
+function prefersReducedMotion() {
+    return typeof window !== 'undefined' && typeof window.matchMedia === 'function'
+        && window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+}
+const MASK_STYLE = {
+    position: 'absolute',
+    inset: 0,
+    border: 'none',
+    background: 'var(--dsw-alias-bg-mask-3, rgba(0, 0, 0, .45))',
+};
+const SHEET_STYLE = {
+    position: 'absolute',
+    left: '8px',
+    right: '8px',
+    bottom: 'calc(var(--mnav-sab, 0px) + 8px)',
+    boxSizing: 'border-box',
+    padding: '12px',
+    borderRadius: '16px',
+    background: 'var(--dsw-alias-bg-layer-2, #ffffff)',
+    boxShadow: '0 8px 32px rgba(0, 0, 0, .28)',
+};
+const HEAD_STYLE = {
+    display: 'flex',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+    gap: 8,
+    marginBottom: 10,
+};
+const TITLE_STYLE = {
+    fontSize: 15,
+    fontWeight: 600,
+    color: 'var(--dsw-alias-label-primary, inherit)',
+};
+const CLOSE_STYLE = {
+    display: 'inline-flex',
+    alignItems: 'center',
+    justifyContent: 'center',
+    width: 34,
+    height: 34,
+    flex: 'none',
+    padding: 0,
+    border: 'none',
+    borderRadius: '50%',
+    background: 'transparent',
+    color: 'var(--dsw-alias-label-secondary, inherit)',
+    cursor: 'pointer',
+    touchAction: 'manipulation',
+    WebkitTapHighlightColor: 'transparent',
+};
+const OPTION_BASE = {
+    display: 'flex',
+    alignItems: 'center',
+    gap: 8,
+    width: '100%',
+    minHeight: 48,
+    padding: '0 14px',
+    border: 'none',
+    borderRadius: 12,
+    background: 'transparent',
+    color: 'var(--dsw-alias-label-primary, inherit)',
+    fontFamily: 'inherit',
+    fontSize: 14,
+    textAlign: 'start',
+    cursor: 'pointer',
+    touchAction: 'manipulation',
+    WebkitTapHighlightColor: 'transparent',
+};
+const CONFIRM_STYLE = {
+    width: '100%',
+    minHeight: 48,
+    marginTop: 10,
+    padding: '0 14px',
+    border: 'none',
+    borderRadius: 12,
+    background: 'var(--dsw-alias-brand-primary, #0f1115)',
+    color: 'var(--dsw-alias-label-primary-foreground, #ffffff)',
+    fontFamily: 'inherit',
+    fontSize: 14,
+    fontWeight: 600,
+    cursor: 'pointer',
+    touchAction: 'manipulation',
+    WebkitTapHighlightColor: 'transparent',
+};
+/** The share-range sheet. Rendered only while open (the caller owns the layer stack). */
+function ShareRangeSheet({ busy, onConfirm, onClose, t }) {
+    const [preset, setPreset] = (0, react_1.useState)('all');
+    const [reduced] = (0, react_1.useState)(prefersReducedMotion);
+    const enter = reduced ? undefined : 'dsh-mobile-nav-sheet-up .22s var(--ds-ease-out, ease-in-out)';
+    const fade = reduced ? undefined : 'dsh-mobile-nav-fade .18s var(--ds-ease-out, ease-in-out)';
+    const options = [
+        { key: 'all', label: t('sharePickerAll'), value: 'all' },
+        ...fetch_share_ts_1.SHARE_TURNS_PRESETS.map((count) => ({ key: `last-${count}`, label: t('sharePickerLast', { count }), value: count })),
+    ];
+    return ((0, jsx_runtime_1.jsxs)("div", { "data-mobile-nav": "share-range-layer", style: { position: 'absolute', inset: 0, zIndex: 2 }, children: [(0, jsx_runtime_1.jsx)("div", { "data-mobile-nav": "share-range-mask", role: "button", tabIndex: -1, "aria-label": t('infoClose'), onClick: onClose, style: fade === undefined ? MASK_STYLE : { ...MASK_STYLE, animation: fade } }), (0, jsx_runtime_1.jsxs)("div", { "data-mobile-nav": "share-range-sheet", role: "dialog", "aria-modal": "true", "aria-label": t('sharePickerTitle'), style: enter === undefined ? SHEET_STYLE : { ...SHEET_STYLE, animation: enter }, children: [(0, jsx_runtime_1.jsxs)("div", { style: HEAD_STYLE, children: [(0, jsx_runtime_1.jsx)("span", { style: TITLE_STYLE, children: t('sharePickerTitle') }), (0, jsx_runtime_1.jsx)("button", { type: "button", "aria-label": t('infoClose'), onClick: onClose, style: CLOSE_STYLE, children: (0, jsx_runtime_1.jsx)(dsh_client_ui_primitives_1.IconCloseOutline16, { size: 16 }) })] }), (0, jsx_runtime_1.jsx)("div", { role: "radiogroup", "aria-label": t('sharePickerTitle'), style: { display: 'flex', flexDirection: 'column', gap: 2 }, children: options.map((option) => {
+                            const selected = preset === option.value;
+                            return ((0, jsx_runtime_1.jsxs)("button", { type: "button", role: "radio", "aria-checked": selected, disabled: busy, "data-selected": selected ? '' : undefined, onClick: () => { setPreset(option.value); }, style: {
+                                    ...OPTION_BASE,
+                                    background: selected ? 'var(--dsw-alias-interactive-bg-hover, rgba(0, 0, 0, .06))' : 'transparent',
+                                    fontWeight: selected ? 600 : 400,
+                                }, children: [(0, jsx_runtime_1.jsx)("span", { children: option.label }), selected && ((0, jsx_runtime_1.jsx)("span", { style: { marginLeft: 'auto', display: 'inline-flex', color: 'var(--dsw-alias-label-primary, inherit)' }, children: (0, jsx_runtime_1.jsx)(dsh_client_ui_primitives_1.IconCheckOutline16, { size: 16 }) }))] }, option.key));
+                        }) }), (0, jsx_runtime_1.jsx)("button", { type: "button", disabled: busy, onClick: () => { onConfirm(preset); }, style: { ...CONFIRM_STYLE, opacity: busy ? 0.6 : 1 }, children: busy ? t('sharePickerBusy') : t('sharePickerConfirm') })] })] }));
 }
 };
 __modules["MobileSessionInfo.js"] = function (require, module, exports) {
@@ -1625,8 +4300,20 @@ const store_ts_1 = require("./compat/store.js");
 const types_ts_1 = require("./compat/types.js");
 const nav_store_ts_1 = require("./nav-store.js");
 const history_nav_ts_1 = require("./history-nav.js");
+const fetch_share_ts_1 = require("./share/fetch-share.js");
+const share_flow_ts_1 = require("./share/share-flow.js");
+const png_stitch_ts_1 = require("./share/png-stitch.js");
+const rasterize_ts_1 = require("./share/rasterize.js");
+const share_card_tsx_1 = require("./share/share-card.js");
+const share_sheet_tsx_1 = require("./share/share-sheet.js");
 /** Layer id for the info sheet, so Android back closes it before leaving the session. */
 const INFO_LAYER = 'session-info';
+/**
+ * Layer id for the share-range sheet. Pushed ON TOP of the info layer's own
+ * entry, so one back gesture closes exactly the picker — never both layers
+ * at once (the one-direction rule in history-nav.ts).
+ */
+const SHARE_LAYER = 'session-info-share';
 const MobileSessionHeader_tsx_1 = require("./MobileSessionHeader.js");
 /* ---- StatsLine-identical formatting -------------------------------------
  * Ported (not imported — the source functions are module-private to
@@ -1692,9 +4379,18 @@ function MobileSessionInfo({ sessionId, useSessions, useProjection, forkSession,
     const [open, setOpen] = (0, react_1.useState)(false);
     const [busy, setBusy] = (0, react_1.useState)(false);
     const [error, setError] = (0, react_1.useState)(null);
+    // Degraded-outcome notice (review 07+08): the multi-file delivery SUCCEEDED,
+    // so "操作失败：…" would lie — this row says what the user actually got,
+    // without the error template. Rendered in its own row (below), never through
+    // setError.
+    const [notice, setNotice] = (0, react_1.useState)(null);
+    const [shareOpen, setShareOpen] = (0, react_1.useState)(false);
+    const [shareData, setShareData] = (0, react_1.useState)(null);
+    const shareCardHostRef = (0, react_1.useRef)(null);
     (0, react_1.useEffect)(() => {
         const onOpen = () => {
             setError(null);
+            setNotice(null);
             setOpen(true);
             // Stack a history entry on top of the session's: Android back now
             // closes this sheet first and only then leaves the session.
@@ -1709,6 +4405,109 @@ function MobileSessionInfo({ sessionId, useSessions, useProjection, forkSession,
     const jobCount = useSessions((s) => s.jobsBySession[sessionId]?.length ?? 0);
     const stats = useProjection('sessionStats');
     const usage = useProjection('tokenUsage');
+    /* ---- share-image flow (ticket 05) --------------------------------------
+     * The range sheet renders INSIDE this info layer's DOM — a DIRECT child of
+     * the layer, a sibling of the info card, never inside the card itself (a
+     * card-internal mount clipped the mask to the card's box, anchored the
+     * sheet's bottom to the card's scrollable area, and let outside taps fall
+     * through to the info mask, closing both layers at once and stranding
+     * SHARE_LAYER as a dead history entry; review 2026-09-10): info.css.ts's
+     * ≥768px display:none covers it (this feature adds no page CSS), and the
+     * info layer's own z:70 header promotion carries it. Its history entry
+     * sits above INFO_LAYER's, so back closes the picker alone. These helpers
+     * live before the `if (!open) return null` below because the pipeline
+     * effect may still be settling when the sheet unmounts. */
+    // Rewind rather than flip the flag — same one-direction rule as `close`.
+    const closeShare = () => {
+        if ((0, history_nav_ts_1.hasLayer)(SHARE_LAYER))
+            (0, history_nav_ts_1.popLayer)(SHARE_LAYER);
+        else
+            setShareOpen(false);
+    };
+    // Errors land on the info sheet's existing error row (ticket 05); the
+    // share sheet closes first so the row is not hidden behind its mask.
+    const shareErrorMessage = (err) => {
+        if (err instanceof fetch_share_ts_1.ShareFetchError) {
+            switch (err.code) {
+                case 'route-missing': return t('shareErrRouteMissing');
+                case 'session-not-found': return t('shareErrSessionNotFound');
+                case 'bad-request': return t('shareErrBadRequest');
+                case 'network': return t('shareErrNetwork');
+                case 'server': return t('shareErrServer');
+                case 'bad-body': return t('shareErrBody');
+            }
+        }
+        if (err instanceof rasterize_ts_1.ShareRasterizeError) {
+            if (err.code === 'probe-failed')
+                return t('shareErrProbe');
+            if (err.code === 'slice-over-budget')
+                return t('shareErrSliceBudget');
+            return t('shareErrRender');
+        }
+        return err instanceof Error ? err.message : String(err);
+    };
+    const shareFailed = (err) => {
+        setBusy(false);
+        setShareData(null);
+        closeShare();
+        setError(shareErrorMessage(err));
+    };
+    // Pipeline stage two. Stage one (onShareConfirm below) fetches and commits
+    // the data, which renders the hidden ShareCard; this effect then runs
+    // AFTER that commit, when the card element exists. The state → render →
+    // effect gap is the React-idiomatic bridge over "DOM ready" without
+    // react-dom (not in the client externals whitelist). Ticket 07: when the
+    // browser can stitch (CompressionStream), the slices are planned with the
+    // unified global width/ratio and concatenated into ONE PNG before delivery;
+    // a runtime stitch failure falls back to the legacy per-slice multi-file
+    // delivery, and either degraded form lands on the notice row below (never
+    // the error row — the delivery itself succeeded, review 07+08).
+    (0, react_1.useEffect)(() => {
+        if (shareData === null)
+            return;
+        const card = shareCardHostRef.current?.querySelector('[data-share-card]') ?? null;
+        if (card === null) {
+            shareFailed(new Error(t('shareErrRender')));
+            return;
+        }
+        const stitch = (0, png_stitch_ts_1.supportsPngStitch)();
+        (0, rasterize_ts_1.rasterizeShareCard)(card, {
+            pixelRatioCap: Math.min(window.devicePixelRatio || 1, 2),
+            truncatedNote: (droppedTurns) => t('shareTruncatedNote', { count: droppedTurns }),
+            unified: stitch,
+        })
+            .then(async (result) => {
+            const title = row?.displayTitle ?? '';
+            if (stitch && result.stitchWidth !== undefined) {
+                try {
+                    const png = await (0, png_stitch_ts_1.stitchSliceBlobs)(result.slices, result.stitchWidth);
+                    await (0, share_flow_ts_1.deliverShareImage)(png, title);
+                    return null;
+                }
+                catch (err) {
+                    // Runtime stitch failure (a slice decoded at the wrong size, a
+                    // compressor error, …) — the rasterized slices are finished PNGs
+                    // either way, so deliver them multi-file instead of failing the
+                    // whole export. The original error stays on the console for
+                    // diagnosis; the notice row tells the user what they got (no
+                    // "操作失败" prefix — the delivery succeeded, review 07+08).
+                    console.error('[dsh-zen-remote] share-image: stitch failed — delivering the painted slices as multiple images instead', err);
+                    await (0, share_flow_ts_1.deliverShareImages)(result.slices, title);
+                    return t('shareStitchFailed');
+                }
+            }
+            await (0, share_flow_ts_1.deliverShareImages)(result.slices, title);
+            return t('shareStitchUnsupported');
+        })
+            .then((degraded) => {
+            setBusy(false);
+            setShareData(null);
+            closeShare();
+            setNotice(degraded);
+        })
+            .catch(shareFailed);
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- shareData is the trigger; helpers only touch setters and module functions.
+    }, [shareData]);
     if (!open)
         return null;
     // Rewind rather than flip the flag — see the one-direction rule in
@@ -1767,10 +4566,50 @@ function MobileSessionInfo({ sessionId, useSessions, useProjection, forkSession,
     const onExport = () => {
         void downloadSessionLog(sessionId);
     };
+    const onShare = () => {
+        setError(null);
+        setNotice(null);
+        setShareData(null);
+        setShareOpen(true);
+        (0, history_nav_ts_1.pushLayer)({ id: SHARE_LAYER, close: () => setShareOpen(false) });
+    };
+    // Pipeline stage one: fetch the selected range. Stage two (rasterize +
+    // deliver) lives in the shareData effect above — the hidden card must be
+    // committed to the DOM before the rasterizer can clone it.
+    const onShareConfirm = (choice) => {
+        const range = choice === 'all' ? { kind: 'all' } : { kind: 'last', turns: choice };
+        setBusy(true);
+        setError(null);
+        // Session id straight off the useSessions row (its branded
+        // session-<uuid> form — a bare uuid 404s, PLAN §2), slot prop as backup.
+        (0, fetch_share_ts_1.fetchShareExport)(row?.id ?? sessionId, range)
+            .then((data) => {
+            if (data.turns.length === 0)
+                throw new Error(t('shareErrEmpty'));
+            setShareData(data);
+        })
+            .catch(shareFailed);
+    };
     const cacheHit = usage === undefined ? null : cacheHitPercent(usage);
     const tokensEmpty = usage === undefined || (billedInputTokens(usage) === 0 && usage.outputTokens === 0);
     const cwd = row?.cwd === undefined || row.cwd === '' ? undefined : (0, store_ts_1.workspaceTitleOf)(row.cwd);
     const preset = (0, types_ts_1.agentPresetOf)(row);
+    // Known-empty sessions (stats observed, zero turns) disable the share
+    // button outright; unknown-stats sessions stay enabled and let the fetch's
+    // empty-turns guard speak. Known 口径 gap, accepted for v1: the projection
+    // counts a turn only once one of its steps has CLOSED (the fold increments
+    // on step/end — dsh-session-stats projection.js), so a session whose only
+    // content is a still-streaming turn, or user messages with no assistant
+    // step yet, also reads turns === 0 and is over-disabled here. Wrong
+    // direction but fail-safe: the button is merely greyed (no misleading
+    // error), and every session that passes through still meets the fetch-side
+    // empty-turns guard (shareErrEmpty below), which is exact.
+    const shareEmpty = stats !== undefined && stats.turns === 0;
+    const shareCardCopy = {
+        turnsLabel: (count) => t('shareCardTurns', { count }),
+        generatedBy: t('shareCardGeneratedBy'),
+        image: t('shareCardImage'),
+    };
     const cells = [
         { label: t('infoStatTurns'), value: stats === undefined ? NA : String(stats.turns), sub: undefined },
         { label: t('infoStatSteps'), value: stats === undefined ? NA : String(stats.steps), sub: undefined },
@@ -1808,7 +4647,15 @@ function MobileSessionInfo({ sessionId, useSessions, useProjection, forkSession,
                                         if (!tab.active)
                                             tab.el.click();
                                         close();
-                                    }, children: tab.label }, tab.label))) })), (0, jsx_runtime_1.jsx)("button", { type: "button", "data-mobile-nav": "info-close", "aria-label": t('infoClose'), onClick: close, children: (0, jsx_runtime_1.jsx)(dsh_client_ui_primitives_1.IconCloseOutline16, { size: 16 }) })] }), (0, jsx_runtime_1.jsxs)("div", { "data-mobile-nav": "info-badges", children: [preset !== undefined && (0, jsx_runtime_1.jsx)("span", { "data-mobile-nav": "info-badge", children: preset }), subagentCount > 0 && ((0, jsx_runtime_1.jsx)("span", { "data-mobile-nav": "info-badge", children: t('infoSubagents', { count: subagentCount }) })), jobCount > 0 && ((0, jsx_runtime_1.jsx)("span", { "data-mobile-nav": "info-badge", children: t('infoJobs', { count: jobCount }) })), (0, jsx_runtime_1.jsx)("span", { "data-mobile-nav": "info-badge-cwd", children: cwd ?? t('infoCwdFallback') })] }), (0, jsx_runtime_1.jsx)("div", { "data-mobile-nav": "info-stats", children: cells.map((cell) => ((0, jsx_runtime_1.jsxs)("div", { "data-mobile-nav": "info-stat", children: [(0, jsx_runtime_1.jsx)("span", { "data-mobile-nav": "info-stat-value", children: cell.value }), (0, jsx_runtime_1.jsx)("span", { "data-mobile-nav": "info-stat-label", children: cell.label }), cell.sub !== undefined && (0, jsx_runtime_1.jsx)("span", { "data-mobile-nav": "info-stat-sub", children: cell.sub })] }, cell.label))) }), error !== null && (0, jsx_runtime_1.jsx)("div", { "data-mobile-nav": "info-error", children: t('infoActionError', { message: error }) }), (0, jsx_runtime_1.jsxs)("div", { "data-mobile-nav": "info-actions", children: [(0, jsx_runtime_1.jsxs)("button", { type: "button", "data-mobile-nav": "info-action", disabled: busy, onClick: onExport, children: [(0, jsx_runtime_1.jsx)(dsh_client_ui_primitives_1.IconDownloadOutline16, { size: 16 }), (0, jsx_runtime_1.jsx)("span", { children: t('infoExport') })] }), (0, jsx_runtime_1.jsxs)("button", { type: "button", "data-mobile-nav": "info-action", disabled: busy, onClick: onRename, children: [(0, jsx_runtime_1.jsx)(dsh_client_ui_primitives_1.IconEditOutline16, { size: 16 }), (0, jsx_runtime_1.jsx)("span", { children: t('infoRename') })] }), (0, jsx_runtime_1.jsxs)("button", { type: "button", "data-mobile-nav": "info-action", disabled: busy, onClick: onFork, children: [(0, jsx_runtime_1.jsx)(dsh_client_ui_primitives_1.IconBranchOutline16, { size: 16 }), (0, jsx_runtime_1.jsx)("span", { children: t('infoFork') })] }), (0, jsx_runtime_1.jsxs)("button", { type: "button", "data-mobile-nav": "info-action", "data-mobile-nav-danger": "", disabled: busy, onClick: onArchive, children: [(0, jsx_runtime_1.jsx)(dsh_client_ui_primitives_1.IconArchiveOutline20, { size: 20 }), (0, jsx_runtime_1.jsx)("span", { children: t('infoArchive') })] })] })] })] }));
+                                    }, children: tab.label }, tab.label))) })), (0, jsx_runtime_1.jsx)("button", { type: "button", "data-mobile-nav": "info-close", "aria-label": t('infoClose'), onClick: close, children: (0, jsx_runtime_1.jsx)(dsh_client_ui_primitives_1.IconCloseOutline16, { size: 16 }) })] }), (0, jsx_runtime_1.jsxs)("div", { "data-mobile-nav": "info-badges", children: [preset !== undefined && (0, jsx_runtime_1.jsx)("span", { "data-mobile-nav": "info-badge", children: preset }), subagentCount > 0 && ((0, jsx_runtime_1.jsx)("span", { "data-mobile-nav": "info-badge", children: t('infoSubagents', { count: subagentCount }) })), jobCount > 0 && ((0, jsx_runtime_1.jsx)("span", { "data-mobile-nav": "info-badge", children: t('infoJobs', { count: jobCount }) })), (0, jsx_runtime_1.jsx)("span", { "data-mobile-nav": "info-badge-cwd", children: cwd ?? t('infoCwdFallback') })] }), (0, jsx_runtime_1.jsx)("div", { "data-mobile-nav": "info-stats", children: cells.map((cell) => ((0, jsx_runtime_1.jsxs)("div", { "data-mobile-nav": "info-stat", children: [(0, jsx_runtime_1.jsx)("span", { "data-mobile-nav": "info-stat-value", children: cell.value }), (0, jsx_runtime_1.jsx)("span", { "data-mobile-nav": "info-stat-label", children: cell.label }), cell.sub !== undefined && (0, jsx_runtime_1.jsx)("span", { "data-mobile-nav": "info-stat-sub", children: cell.sub })] }, cell.label))) }), error !== null && (0, jsx_runtime_1.jsx)("div", { "data-mobile-nav": "info-error", children: t('infoActionError', { message: error }) }), notice !== null && ((0, jsx_runtime_1.jsx)("div", { "data-mobile-nav": "info-notice", role: "status", style: {
+                            marginBottom: 8,
+                            padding: '8px 10px',
+                            borderRadius: 10,
+                            background: 'var(--dsw-alias-interactive-bg-hover, rgba(0, 0, 0, .06))',
+                            color: 'var(--dsw-alias-label-secondary, rgba(0, 0, 0, .6))',
+                            fontSize: 12,
+                            lineHeight: 1.4,
+                        }, children: notice })), (0, jsx_runtime_1.jsxs)("div", { "data-mobile-nav": "info-actions", children: [(0, jsx_runtime_1.jsxs)("button", { type: "button", "data-mobile-nav": "info-action", disabled: busy, onClick: onExport, children: [(0, jsx_runtime_1.jsx)(dsh_client_ui_primitives_1.IconDownloadOutline16, { size: 16 }), (0, jsx_runtime_1.jsx)("span", { children: t('infoExport') })] }), (0, jsx_runtime_1.jsxs)("button", { type: "button", "data-mobile-nav": "info-action", disabled: busy, onClick: onRename, children: [(0, jsx_runtime_1.jsx)(dsh_client_ui_primitives_1.IconEditOutline16, { size: 16 }), (0, jsx_runtime_1.jsx)("span", { children: t('infoRename') })] }), (0, jsx_runtime_1.jsxs)("button", { type: "button", "data-mobile-nav": "info-action", disabled: busy, onClick: onFork, children: [(0, jsx_runtime_1.jsx)(dsh_client_ui_primitives_1.IconBranchOutline16, { size: 16 }), (0, jsx_runtime_1.jsx)("span", { children: t('infoFork') })] }), (0, jsx_runtime_1.jsxs)("button", { type: "button", "data-mobile-nav": "info-action", "data-mobile-nav-danger": "", disabled: busy, onClick: onArchive, children: [(0, jsx_runtime_1.jsx)(dsh_client_ui_primitives_1.IconArchiveOutline20, { size: 20 }), (0, jsx_runtime_1.jsx)("span", { children: t('infoArchive') })] }), (0, jsx_runtime_1.jsxs)("button", { type: "button", "data-mobile-nav": "info-action", disabled: busy || shareEmpty, onClick: onShare, children: [(0, jsx_runtime_1.jsx)(dsh_client_ui_primitives_1.IconShareOutline16, { size: 16 }), (0, jsx_runtime_1.jsx)("span", { children: t('shareAction') })] })] }), shareData !== null && ((0, jsx_runtime_1.jsx)("div", { ref: shareCardHostRef, "aria-hidden": "true", style: { position: 'fixed', left: '-9999px', top: 0, pointerEvents: 'none' }, children: (0, jsx_runtime_1.jsx)(share_card_tsx_1.ShareCard, { title: row?.displayTitle ?? t('sessionInfo'), ...(preset !== undefined ? { subtitle: preset } : {}), ...(shareData.createdAt !== undefined ? { createdAt: shareData.createdAt } : {}), turns: shareData.turns, copy: shareCardCopy }) }))] }), shareOpen && ((0, jsx_runtime_1.jsx)(share_sheet_tsx_1.ShareRangeSheet, { busy: busy, onConfirm: onShareConfirm, onClose: closeShare, t: t }))] }));
 }
 };
 __modules["attach-upload.js"] = function (require, module, exports) {
@@ -1957,6 +4804,63 @@ function releaseThumbnailsExcept(keep) {
     }
 }
 };
+__modules["host-attach.js"] = function (require, module, exports) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOST_ATTACH_INPUT = void 0;
+exports.hostAttachPresent = hostAttachPresent;
+exports.useOwnAttachUi = useOwnAttachUi;
+const react_1 = require("react");
+/**
+ * The host composer's own hidden file picker, when the running DSH ships one.
+ *
+ * DSH 0.1.5 grew a native attachment flow (dsh-attachment / dsh-client-file-
+ * upload): the official tool row carries a second `_add` paperclip whose click
+ * drives an `<input type="file" hidden>` that is a DIRECT sibling of the
+ * buttons inside `_tools`. That input is the one structural, locale-free
+ * proof that the host implements composer attachment upload — the button
+ * itself can only be told apart from the "+" command menu by its localized
+ * aria-label, and the capability prop (`addFiles`) lives on the composer
+ * bar's own inject face, which never reaches `conversation.input.left`
+ * registrants. Scoped to `_tools` children so a third-party plugin parking
+ * its own file input somewhere else in the composer cannot be misread as
+ * the official feature; `:not([data-mobile-nav])` keeps OUR picker
+ * (`attach-picker`) out of the match.
+ */
+exports.HOST_ATTACH_INPUT = '[data-slot="conversation.composer.bar"] [class$="_tools"] > input[type="file"]:not([data-mobile-nav])';
+/** Synchronous read: does this host's composer ship its own attach picker? */
+function hostAttachPresent() {
+    return document.querySelector(exports.HOST_ATTACH_INPUT) !== null;
+}
+/**
+ * True while OUR attachment UI should mount (the host has none of its own).
+ *
+ * The rule this encodes (2026-09-11): where the host implements attachment
+ * upload, the phone composer shows exactly ONE attach control — the host's —
+ * and this plugin's S7 button and chips row stand down; on a host without
+ * one (DSH ≤ 0.1.2), both load as they always have.
+ *
+ * `useLayoutEffect`, not `useEffect`: on the composer's very first mount our
+ * slot child renders in the same React pass as the host's tool row, so the
+ * state initializer below reads the DOM BEFORE either exists — the layout
+ * effect re-checks after the commit and before the browser paints, so the
+ * demotion to hidden (or, on an old host, the decision to stay) never
+ * reaches the screen as a flash. The MutationObserver covers the lifetime
+ * after that: the picker's existence only really changes with the page, but
+ * a dynamic host plugin or a reload must not strand a stale verdict.
+ */
+function useOwnAttachUi() {
+    const [own, setOwn] = (0, react_1.useState)(() => !hostAttachPresent());
+    (0, react_1.useLayoutEffect)(() => {
+        const check = () => setOwn(!hostAttachPresent());
+        const observer = new MutationObserver(check);
+        observer.observe(document.body, { childList: true, subtree: true });
+        check();
+        return () => observer.disconnect();
+    }, []);
+    return own;
+}
+};
 __modules["MobileAttachButton.js"] = function (require, module, exports) {
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -1965,6 +4869,7 @@ const jsx_runtime_1 = require("react/jsx-runtime");
 const react_1 = require("react");
 const dsh_client_ui_primitives_1 = require("@deepseek-ai/dsh-client-ui-primitives");
 const attach_upload_ts_1 = require("./attach-upload.js");
+const host_attach_ts_1 = require("./host-attach.js");
 /** Post one file to the host route and return the workspace-relative path it landed on. */
 async function uploadFile(sessionId, file) {
     const response = await fetch((0, attach_upload_ts_1.uploadUrl)(sessionId, file.name), {
@@ -1990,6 +4895,13 @@ async function uploadFile(sessionId, file) {
  * the CLIENT's picker — no `accept` attribute on purpose, so iOS offers the
  * full 相册 / 拍照 / 选取文件 sheet rather than one of them.
  *
+ * DSH 0.1.5 gave the official tool row its own paperclip (the host attachment
+ * flow), which made TWO identical controls on a phone. This button now stands
+ * down entirely while the host ships its own picker (`host-attach.ts` probes
+ * for it) — the official flow uploads into `~/.dsh/attachments` and renders
+ * its own rail, so the composer keeps exactly one attach affordance. On a
+ * host without one (DSH ≤ 0.1.2) everything below loads exactly as before.
+ *
  * Every picked file takes the SAME path: upload to the node half, then append
  * `@.dsh-uploads/name` to the draft through `inputActions.setDraft` (the
  * official write path — no DOM value poking). S7.1 removed the split that used
@@ -2005,12 +4917,17 @@ function MobileAttachButton({ t, sessionId, useInput, inputActions }) {
     const [busy, setBusy] = (0, react_1.useState)(false);
     const [error, setError] = (0, react_1.useState)(null);
     const draft = useInput((state) => state.draft);
+    const ownUi = (0, host_attach_ts_1.useOwnAttachUi)();
     // Uploads are awaited, so the `draft` captured at pick time goes stale — the
     // user can keep typing while a file is in flight. The ref is refreshed on
     // every render (useInput re-renders us on each draft change), so the loop
     // below can rebase onto whatever the composer holds right now.
     const liveDraft = (0, react_1.useRef)(draft);
     liveDraft.current = draft;
+    // The host's own attach button owns this seat now — render nothing (the
+    // hidden picker input goes with it). All hooks stay above this line.
+    if (!ownUi)
+        return null;
     const pick = async (event) => {
         const files = Array.from(event.target.files ?? []);
         // Reset first: picking the same file twice in a row fires no change event
@@ -2056,6 +4973,7 @@ const jsx_runtime_1 = require("react/jsx-runtime");
 const react_1 = require("react");
 const dsh_client_ui_primitives_1 = require("@deepseek-ai/dsh-client-ui-primitives");
 const attach_upload_ts_1 = require("./attach-upload.js");
+const host_attach_ts_1 = require("./host-attach.js");
 /**
  * Attachment preview row (S7.1), in `conversation.input.dock` — the official
  * full-width row above the composer card, which composer.css.ts already lays
@@ -2084,10 +5002,17 @@ const attach_upload_ts_1 = require("./attach-upload.js");
  */
 function MobileAttachChips({ t, useInput, inputActions }) {
     const draft = useInput((state) => state.draft);
-    const attachments = (0, attach_upload_ts_1.mentionsIn)(draft);
+    const ownUi = (0, host_attach_ts_1.useOwnAttachUi)();
     (0, react_1.useEffect)(() => {
         (0, attach_upload_ts_1.releaseThumbnailsExcept)((0, attach_upload_ts_1.mentionsIn)(draft));
     }, [draft]);
+    // Same gate as MobileAttachButton (host-attach.ts): where the host ships
+    // its own attachment flow, our chips row stands down too — the official
+    // rail owns the preview seat. The effect above still runs, so object URLs
+    // from OUR flow get revoked even after the switch.
+    if (!ownUi)
+        return null;
+    const attachments = (0, attach_upload_ts_1.mentionsIn)(draft);
     if (attachments.length === 0)
         return null;
     return ((0, jsx_runtime_1.jsx)("div", { "data-mobile-nav": "attach-chips", children: attachments.map((relPath) => {
@@ -2707,8 +5632,11 @@ exports.LAYOUT_CSS = `/* ---------- mobile-only layout ---------- */
      first-child's last-child, so without this exclusion it silently matched
      this generic selector too — measured 358px (100vw-32px) instead of the
      374px its own left:8px/right:8px margins specify. Same category of bug
-     as the ZuhsRW directory-picker collision below; same fix shape. */
-  [aria-modal="true"]:not(:has(> :first-child > :last-child > button)):not([data-mobile-nav="info-sheet"]) {
+     as the ZuhsRW directory-picker collision below; same fix shape.
+     :not([data-mobile-nav="share-range-sheet"]) (share-image, 2026-09-10):
+     the share range picker rides the same role="dialog" aria-modal bottom
+     -sheet shape and the same margins, so it hit the identical clamp. */
+  [aria-modal="true"]:not(:has(> :first-child > :last-child > button)):not([data-mobile-nav="info-sheet"]):not([data-mobile-nav="share-range-sheet"]) {
     max-width: calc(100vw - 32px) !important;
   }
   /* Nav bar: hide the "Settings" caption (redundant on a full-width sheet)
@@ -4493,6 +7421,11 @@ __modules["styles/header.css.js"] = function (require, module, exports) {
 //         nav.crumbs             breadcrumb chain, last segment = the title
 //         div.headerActions      [data-slot="conversation.session.header.actions"]
 //       div.headerUtilities    [data-slot="conversation.session.header.utilities"]
+//       div.headerCorner       [data-conversation-header-corner]
+//                               [data-slot="conversation.session.header.corner"]
+//                               (DSH 0.1.5: the right sidebar's ExpandButton —
+//                               hidden below, our workbench button routes to
+//                               its controls instead)
 //     div.tabs[role="tablist"]  Chat/Trajectory, only when there is >1 view
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HEADER_CSS = void 0;
@@ -4761,6 +7694,31 @@ exports.HEADER_CSS = `/* ---------- session header five-piece reflow (< 768px) -
   [data-phase] header [data-slot="conversation.session.header.utilities"] > * {
     display: none !important;
   }
+  /* DSH 0.1.5's third titleRow child: the right sidebar's ExpandButton
+     (dsh-client-ui-sidebar-right, slot conversation.session.header.corner
+     inside div.headerCorner). Left alone it auto-placed into an implicit
+     4th grid column at the screen's top-right corner — a second panel-left
+     icon next to our Workbench button, reading as "the hidden official
+     sidebar toggle is back" (reported 2026-09-11). The button itself is the
+     one our workbench control forwards to when better-sidebar is absent
+     (MobileSessionHeader's toggleSidebarTarget), and a display:none button
+     still receives synthetic .click() (the tablist precedent), so hiding it
+     costs nothing.
+     Anchors, in the specificity order they NEED (measured live, 2026-09-11):
+     the corner div must be beaten with (0,3,1) — the utilities un-hide rule
+     above spells header > :first-child > :last-child at exactly that
+     weight, and with 0.1.5's third titleRow child the corner IS that
+     :last-child now, so its flex !important outranks any lighter hide (a
+     single-attribute hide loses at (0,2,1) — both spellings were tried
+     live). Chaining BOTH of the corner's own anchors on one selector — the
+     host's data-conversation-header-corner contract attribute AND the
+     class suffix — reaches the tie, and the later source order here wins
+     it. The slot wrapper rule below needs no help: nothing !important
+     fights it, so its (0,2,1) settles the button. */
+  [data-phase] header [data-conversation-header-corner][class$="_headerCorner"],
+  [data-phase] header [data-slot="conversation.session.header.corner"] {
+    display: none !important;
+  }
   /* Native background-task / subagent entries (rewritten for DSH 0.1.1,
      2026-08-21). Three upstream changes killed the old "park the root as a
      zero-width anchor, hide the trigger, forward the tap" design at once:
@@ -6190,6 +9148,7 @@ exports.zh = {
     'sessionInfo': '会话信息',
     'workbench': '工作台',
     'workbenchClose': '关闭工作台',
+    'sidebar': '侧边栏',
     'switchView': '切换视图',
     'attach': '添加附件',
     'attachBusy': '上传中…',
@@ -6217,6 +9176,28 @@ exports.zh = {
     'infoActionError': '操作失败：{message}',
     'turnFold': '过程 · {count} 步',
     'turnFoldRunning': '进行中 · {count} 步',
+    'shareCardTurns': '{count} 轮对话',
+    'shareCardGeneratedBy': '由 DeepSeek Harness 生成',
+    'shareCardImage': '图片附件',
+    'shareAction': '分享图',
+    'sharePickerTitle': '分享范围',
+    'sharePickerAll': '全部对话',
+    'sharePickerLast': '最近 {count} 轮',
+    'sharePickerConfirm': '生成分享图',
+    'sharePickerBusy': '生成中…',
+    'shareTruncatedNote': '内容过长，已省略前 {count} 轮',
+    'shareErrRouteMissing': '当前 DSH 版本未提供分享图接口，请更新 DSH 后重试',
+    'shareErrSessionNotFound': '会话不存在或已被删除',
+    'shareErrBadRequest': '分享请求无效，请重试',
+    'shareErrNetwork': '网络连接失败，请检查网络后重试',
+    'shareErrServer': '服务暂时不可用，请稍后重试',
+    'shareErrBody': '分享数据异常，请重试',
+    'shareErrProbe': '当前浏览器无法生成分享图',
+    'shareErrRender': '生成分享图失败，请重试',
+    'shareErrSliceBudget': '分享图单段内容超出画布上限，请缩小分享范围后重试',
+    'shareErrEmpty': '会话还没有可分享的内容',
+    'shareStitchUnsupported': '当前浏览器暂不支持合成单张长图，已导出为多张图片',
+    'shareStitchFailed': '合成单张长图失败，已改为多张图片导出',
     'settings': '设置',
     'chipTaskboard': '任务看板',
     'chipSsh': 'SSH',
@@ -6243,6 +9224,7 @@ exports.en = {
     'sessionInfo': 'Session info',
     'workbench': 'Workbench',
     'workbenchClose': 'Close workbench',
+    'sidebar': 'Sidebar',
     'switchView': 'Switch view',
     'attach': 'Add attachment',
     'attachBusy': 'Uploading…',
@@ -6270,6 +9252,28 @@ exports.en = {
     'infoActionError': 'Action failed: {message}',
     'turnFold': 'Process · {count} steps',
     'turnFoldRunning': 'Working · {count} steps',
+    'shareCardTurns': '{count} turns',
+    'shareCardGeneratedBy': 'Made with DeepSeek Harness',
+    'shareCardImage': 'Image attachment',
+    'shareAction': 'Share image',
+    'sharePickerTitle': 'Share range',
+    'sharePickerAll': 'Whole conversation',
+    'sharePickerLast': 'Last {count} turns',
+    'sharePickerConfirm': 'Generate',
+    'sharePickerBusy': 'Generating…',
+    'shareTruncatedNote': 'Long conversation — first {count} turns omitted',
+    'shareErrRouteMissing': 'This DSH version has no share-image endpoint — please update DSH',
+    'shareErrSessionNotFound': 'Session not found or deleted',
+    'shareErrBadRequest': 'Invalid share request — please try again',
+    'shareErrNetwork': 'Network error — check the connection and try again',
+    'shareErrServer': 'Service temporarily unavailable — try again later',
+    'shareErrBody': 'Unexpected share data — please try again',
+    'shareErrProbe': 'This browser cannot render share images',
+    'shareErrRender': 'Failed to generate the share image — please try again',
+    'shareErrSliceBudget': 'One slice of the share image exceeded the canvas limit — try a smaller share range',
+    'shareErrEmpty': 'Nothing to share in this session yet',
+    'shareStitchUnsupported': 'This browser cannot stitch one long image — exported as multiple images instead',
+    'shareStitchFailed': 'Could not stitch one long image — exported as multiple images instead',
     'settings': 'Settings',
     'chipTaskboard': 'Task board',
     'chipSsh': 'SSH',
@@ -8845,24 +11849,29 @@ const INTENT_WINDOW_MS = 1000;
 /**
  * S9 — keep the phone keyboard down until the user asks for it.
  *
- * dsh-client-ui-conversation focuses the composer textarea on every
- * sessionId change (lib/client.js:3423 — el.focus({preventScroll:true}) in a
- * [locked, sessionId] effect). Sensible on desktop; on a phone it pops the
- * software keyboard over half the screen every time a session opens.
+ * dsh-client-ui-conversation focuses the composer's editing host on every
+ * sessionId change (0.1.2: `el.focus({preventScroll:true})` on the textarea;
+ * 0.1.5: the same on the Lexical contenteditable). Sensible on desktop; on a
+ * phone it pops the software keyboard over half the screen every time a
+ * session opens.
  *
- * Rule: focus on the composer textarea survives only when the user asked for
- * it — a tap on the textarea itself or typing on a hardware keyboard.
- * Anything else (session-open autofocus, push-deep-link opens, the refocus
- * side effects of the other composer buttons — slash-command toggle, attach,
- * send) is blurred.
+ * Rule: focus on the composer field survives only when the user asked for
+ * it — a tap on the field itself or typing on a hardware keyboard. Anything
+ * else (session-open autofocus, push-deep-link opens, the refocus side
+ * effects of the other composer buttons — the official attach paperclip's
+ * `keepFocus` mousedown, the slash-command toggle, send) is blurred. That
+ * attach case is not hypothetical: 0.1.5's official paperclip refocuses the
+ * editor on MOUSEDOWN, and while this guard was blind to the contenteditable
+ * (2026-09-11 report) every tap on it popped the keyboard and shoved the
+ * composer up the screen.
  *
  * Two triggers, because one is not enough:
  * - focusin catches the autofocus the moment it happens;
  * - a body MutationObserver re-runs the check after transcript swaps
- *   (opening a session re-renders the flow but may reuse the same textarea,
+ *   (opening a session re-renders the flow but may reuse the same field,
  *   and a focus that landed before this plugin loaded never fired focusin
  *   for us at all).
- * Once focus is user-granted it stays granted until the textarea blurs, so
+ * Once focus is user-granted it stays granted until the field blurs, so
  * the observer never yanks a keyboard the user opened (e.g. while the agent
  * streams and the user pauses typing).
  */
@@ -8873,7 +11882,12 @@ function installKeyboardGuard(ctx) {
         let granted = false;
         let observer = null;
         let frame = 0;
-        const composerTextarea = (node) => node instanceof HTMLElement && node.tagName === 'TEXTAREA' && node.closest(COMPOSER) !== null
+        /** The composer's editing host: the `data-composer-input` contenteditable
+         * DSH 0.1.5 binds Lexical to, or the textarea older hosts rendered (the
+         * attribute also sat on that textarea — both spellings match both hosts,
+         * belt and braces). */
+        const composerField = (node) => node instanceof HTMLElement && node.closest(COMPOSER) !== null
+            && (node.hasAttribute('data-composer-input') || node.tagName === 'TEXTAREA')
             ? node
             : null;
         const onPointerDown = (event) => {
@@ -8881,18 +11895,18 @@ function installKeyboardGuard(ctx) {
             // composer control (slash-command toggle, attach, model menu, send)
             // must not: several of them refocus the input as a side effect, which
             // popped the keyboard on every command-button tap.
-            if (composerTextarea(event.target) !== null) {
+            if (composerField(event.target) !== null) {
                 lastIntent = Date.now();
                 granted = true;
             }
         };
         const onKeyDown = () => {
             lastIntent = Date.now();
-            if (composerTextarea(document.activeElement) !== null)
+            if (composerField(document.activeElement) !== null)
                 granted = true;
         };
         const sweep = () => {
-            const el = composerTextarea(document.activeElement);
+            const el = composerField(document.activeElement);
             if (el === null)
                 return;
             if (granted || Date.now() - lastIntent < INTENT_WINDOW_MS) {
@@ -8902,12 +11916,12 @@ function installKeyboardGuard(ctx) {
             el.blur();
         };
         const onFocusIn = (event) => {
-            if (composerTextarea(event.target) === null)
+            if (composerField(event.target) === null)
                 return;
             sweep();
         };
         const onFocusOut = (event) => {
-            if (composerTextarea(event.target) === null)
+            if (composerField(event.target) === null)
                 return;
             granted = false;
         };
@@ -9146,9 +12160,16 @@ function installKeyboardAvoid(ctx) {
             tuning = loaded.keyboard;
             pad = safetyPad(navigator.userAgent, tuning.safetyPadPx);
         });
-        const composerTextarea = (node) => node instanceof HTMLElement && node.tagName === 'TEXTAREA' && node.closest(COMPOSER) !== null;
+        /** The composer's editing host: the `data-composer-input` contenteditable
+         * DSH 0.1.5 binds Lexical to, or the textarea of older hosts (the
+         * attribute sat on that textarea too). Same recognition as S9's guard —
+         * while this checked TEXTAREA only, the whole focus machinery below was
+         * blind to the 0.1.5 contenteditable and the dumb-keyboard estimate
+         * never ran. */
+        const composerField = (node) => node instanceof HTMLElement && node.closest(COMPOSER) !== null
+            && (node.hasAttribute('data-composer-input') || node.tagName === 'TEXTAREA');
         const sync = () => {
-            const focused = composerTextarea(document.activeElement);
+            const focused = composerField(document.activeElement);
             if (!focused)
                 baseline = viewport.height;
             const geometric = keyboardLift({
@@ -9194,7 +12215,7 @@ function installKeyboardAvoid(ctx) {
                 sync();
             }
             const el = document.activeElement;
-            if (composerTextarea(el) && el instanceof HTMLElement)
+            if (composerField(el) && el instanceof HTMLElement)
                 el.blur();
         };
         /** True when a touch outside the composer means "the reader moved on". */
@@ -9217,7 +12238,7 @@ function installKeyboardAvoid(ctx) {
                 retract();
         };
         const onFocusIn = (event) => {
-            if (!composerTextarea(event.target))
+            if (!composerField(event.target))
                 return;
             // Focus not born from a touch (hardware keyboard, programmatic) raises
             // no on-screen keyboard — never estimate for it.
@@ -9257,7 +12278,7 @@ function installKeyboardAvoid(ctx) {
                 // Keyboard is up (touch focus on a phone) yet the viewport never
                 // reacted: the browser cannot see it. Estimate until blur, and
                 // remember the verdict so the next focus skips the wait.
-                if (!composerTextarea(document.activeElement))
+                if (!composerField(document.activeElement))
                     return;
                 localStorage.setItem(DUMB_KEY, '1');
                 estimate = estimatedLift(window.innerHeight, tuning);
@@ -9266,7 +12287,7 @@ function installKeyboardAvoid(ctx) {
             probeTimer = window.setTimeout(step, PROBE_INTERVAL_MS);
         };
         const onFocusOut = (event) => {
-            if (!composerTextarea(event.target))
+            if (!composerField(event.target))
                 return;
             stopProbe();
             if (estimate === 0)
@@ -9317,6 +12338,288 @@ function installKeyboardAvoid(ctx) {
     }, 'dsh-mobile-nav: composer keyboard avoid');
 }
 };
+__modules["share/share-preview.js"] = function (require, module, exports) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharePreview = SharePreview;
+const jsx_runtime_1 = require("react/jsx-runtime");
+/**
+ * Debug preview for the share-card template (ticket 03) + PNG export entry
+ * (ticket 04, single long image since ticket 07): ?mobile-nav-share-preview=1
+ * renders the card at the top of the page so the layout can be eyeballed at
+ * any viewport, and the caption bar's 导出 PNG button drives the full
+ * slice→rasterize→stitch pipeline, downloading ONE stitched PNG — the
+ * acceptance path before ticket 05 wires the real UI.
+ *
+ * Debug-surface conventions follow debug.ts: the entry only mounts with the
+ * URL param (the slot entry is not even registered without it — zero impact
+ * otherwise, the same exemption ?mobile-nav-inset= enjoys), and its chrome
+ * copy is hardcoded Chinese rather than locale keys, because it never ships
+ * to end users. Only the card's own baked-in strings go through `t`.
+ *
+ * Data comes through fetch-share.ts (ticket 05) — the same typed fetch,
+ * query builder and error taxonomy the real share flow uses; only the error
+ * SURFACE differs (this panel folds any failure back to the fixture and
+ * prints the code, the real UI maps codes to locale copy).
+ */
+const react_1 = require("react");
+const types_ts_1 = require("./compat/types.js");
+const fetch_share_ts_1 = require("./share/fetch-share.js");
+const fetch_share_ts_2 = require("./share/fetch-share.js");
+const png_stitch_ts_1 = require("./share/png-stitch.js");
+const rasterize_ts_1 = require("./share/rasterize.js");
+const share_card_tsx_1 = require("./share/share-card.js");
+const share_flow_ts_1 = require("./share/share-flow.js");
+/* ---- fixture ---------------------------------------------------------------
+ * Exercises every block kind the template knows, and since ticket 09 every
+ * Markdown construct the assistant path renders: headings, inline emphasis /
+ * code / links / escapes, fenced code with a language tag and a deliberately
+ * over-long line (wide-content acceptance), an aligned pipe table, block
+ * quote, ordered + nested unordered lists, thematic break, indented code, a
+ * Markdown image line, and image placeholders. Fixed timestamp so the header
+ * is deterministic between reloads. */
+const FIXTURE_CREATED_AT = Date.UTC(2026, 8, 10, 4, 0); // 2026-09-10 12:00 +08:00
+const FIXTURE_TITLE = '示例会话 · 网关错误率报表';
+const FIXTURE_TURNS = [
+    {
+        role: 'user',
+        seq: 1,
+        blocks: [{ kind: 'text', text: '帮我把这份原始日志清洗成表格，算出每个服务的错误率，再给一个可以复用的脚本。' }],
+    },
+    {
+        role: 'assistant',
+        seq: 2,
+        blocks: [
+            {
+                kind: 'text',
+                text: [
+                    '清洗结果如下（错误率 = 错误 / 请求），口径见 [统计说明](#stats)：',
+                    '',
+                    '## 服务错误率',
+                    '',
+                    '| 服务 | 请求 | 错误 | 错误率 | 备注 |',
+                    '| :--- | ---: | ---: | :---: | --- |',
+                    '| lan-gate | 12040 | 36 | 0.30% | 配对墙拦截计入 |',
+                    '| api-gateway | 98213 | 121 | 0.12% | 5xx 全量 |',
+                    '| web-ui-static | 330912 | 2 | 0.00% | CDN 回源 |',
+                    '',
+                    '复用脚本（长行不裁剪，超出卡片宽是预期行为，切片宽度自适应交给栅格化）：',
+                    '',
+                    '```python',
+                    'def error_rate(total_requests: int, errors: int) -> float:',
+                    '    return errors / total_requests if total_requests else 0.0',
+                    'print(f"{error_rate(98213, 121):.2%}")  # -> 0.12%',
+                    '```',
+                    '',
+                    '### 排版要点',
+                    '',
+                    '行内支持 **粗体**、*斜体*、***粗斜体***、~~删除线~~、`行内代码`、[链接着色](https://example.com/docs) 与转义 \\*字面星号\\*。',
+                    '',
+                    '无序清单（两级缩进）：',
+                    '',
+                    '- 只取近 24 小时的聚合数据',
+                    '  - 请求量不足 1000 的服务不参与排名',
+                    '  - 按错误率降序输出',
+                    '- 长行项目照常参与宽度测量',
+                    '',
+                    '有序步骤：',
+                    '',
+                    '1. 拉取聚合指标',
+                    '2. 计算错误率',
+                    '   1. 过滤零流量服务',
+                    '   2. 保留两位小数',
+                    '3. 输出报表',
+                    '',
+                    '> 引用块：以上口径与 [监控面板](https://example.com/monitor) 一致，',
+                    '> 以 5 分钟粒度聚合，空窗期按 0 处理。',
+                    '',
+                    '---',
+                    '',
+                    '另外附一个历史口径的配置片段（缩进代码）：',
+                    '',
+                    '    window_seconds = 86400',
+                    '    min_requests = 1000',
+                    '',
+                    '架构示意图：',
+                    '',
+                    '![部署架构图](https://example.com/arch.png)',
+                ].join('\n'),
+            },
+        ],
+    },
+    {
+        role: 'user',
+        seq: 3,
+        blocks: [
+            { kind: 'text', text: '很好。再把现在的部署架构画一张图给我。' },
+            { kind: 'image' },
+        ],
+    },
+    {
+        role: 'assistant',
+        seq: 4,
+        blocks: [
+            { kind: 'text', text: '架构图放在这里了（分享图 v1 中图片附件以占位呈现）：' },
+            { kind: 'image' },
+            { kind: 'text', text: '需要我把表格导出成 CSV 的话说一声。' },
+        ],
+    },
+];
+const FIXTURE_STATE = {
+    source: 'fixture',
+    turns: FIXTURE_TURNS,
+    createdAt: FIXTURE_CREATED_AT,
+    error: null,
+};
+/**
+ * Share-card preview panel. Fixed at the top of the overlay layer, scrollable
+ * (long transcripts must be inspectable), all-inline-styled like the card —
+ * this feature adds no page CSS by design (PLAN §9.4).
+ */
+function SharePreview({ useSessions, t }) {
+    const [gone, setGone] = (0, react_1.useState)(false);
+    const [state, setState] = (0, react_1.useState)(FIXTURE_STATE);
+    const [exportBusy, setExportBusy] = (0, react_1.useState)(null);
+    const [exportNote, setExportNote] = (0, react_1.useState)(null);
+    const cardHostRef = (0, react_1.useRef)(null);
+    const currentId = useSessions((s) => s.current);
+    const row = useSessions((s) => (s.current === undefined ? undefined : s.byId[s.current]));
+    // Try the real route whenever a session is open; any failure (route not
+    // mounted on this host, network, bad body) silently reverts to the fixture
+    // — the preview must always render something. The fetch itself is the
+    // production one (fetch-share.ts), so this exercises the exact query and
+    // validation the real share flow sends.
+    (0, react_1.useEffect)(() => {
+        if (currentId === undefined) {
+            setState(FIXTURE_STATE);
+            return;
+        }
+        let cancelled = false;
+        (0, fetch_share_ts_1.fetchShareExport)(currentId, { kind: 'all' })
+            .then((data) => {
+            if (cancelled)
+                return;
+            setState({ source: 'live', turns: data.turns, createdAt: data.createdAt, error: null });
+        })
+            .catch((err) => {
+            if (cancelled)
+                return;
+            // Debug affordance: the typed code (+HTTP status) says WHICH path
+            // failed; the real UI maps these codes to locale copy instead.
+            const detail = err instanceof fetch_share_ts_2.ShareFetchError
+                ? `${err.code}${err.status === undefined ? '' : ` (HTTP ${err.status})`}`
+                : err instanceof Error ? err.message : String(err);
+            setState({ ...FIXTURE_STATE, error: detail });
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [currentId]);
+    if (gone)
+        return null;
+    // Full pipeline on the live card element: probe → measure → plan (unified
+    // when the browser can stitch) → paint → stitch, then a single long-image
+    // download (ticket 07 — the caption notes the final dimensions); browsers
+    // without CompressionStream keep the per-slice downloads.
+    const runExport = async () => {
+        const card = cardHostRef.current?.querySelector('[data-share-card]') ?? null;
+        if (card === null) {
+            setExportNote('导出失败：未找到分享卡元素');
+            return;
+        }
+        setExportBusy('0/?');
+        setExportNote(null);
+        try {
+            const stitch = (0, png_stitch_ts_1.supportsPngStitch)();
+            const result = await (0, rasterize_ts_1.rasterizeShareCard)(card, {
+                pixelRatioCap: Math.min(window.devicePixelRatio || 1, 2),
+                truncatedNote: (droppedTurns) => t('shareTruncatedNote', { count: droppedTurns }),
+                onProgress: (done, total) => setExportBusy(`${done}/${total}`),
+                unified: stitch,
+            });
+            const tail = result.truncated ? `，已省略前 ${result.droppedTurns} 轮` : '';
+            if (stitch && result.stitchWidth !== undefined) {
+                const png = await (0, png_stitch_ts_1.stitchSliceBlobs)(result.slices, result.stitchWidth);
+                const height = result.slices.reduce((sum, slice) => sum + slice.height, 0);
+                await (0, share_flow_ts_1.downloadBlobSequence)([{ blob: png, name: 'share-card.png' }]);
+                setExportNote(`已导出长图 ${result.stitchWidth}×${height}（${result.slices.length} 片拼接，像素比 ${result.pixelRatio}${tail}）`);
+            }
+            else {
+                // The same paced anchor-download sequence the real delivery falls
+                // back to (review 07+08 cleanup — this was a third inline copy).
+                await (0, share_flow_ts_1.downloadBlobSequence)(result.slices.map((slice, index) => ({ blob: slice.blob, name: (0, share_flow_ts_1.shareSliceFileName)('share-card', index) })));
+                setExportNote(`已导出 ${result.slices.length} 张分片（浏览器不支持拼接，像素比 ${result.pixelRatio}${tail}）`);
+            }
+            console.info('[share-preview] rasterized', result);
+        }
+        catch (err) {
+            console.error('[share-preview] PNG export failed', err);
+            setExportNote(`导出失败：${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            setExportBusy(null);
+        }
+    };
+    const copy = {
+        turnsLabel: (count) => t('shareCardTurns', { count }),
+        generatedBy: t('shareCardGeneratedBy'),
+        image: t('shareCardImage'),
+    };
+    const preset = (0, types_ts_1.agentPresetOf)(row);
+    return ((0, jsx_runtime_1.jsxs)("div", { style: PANEL_STYLE, children: [(0, jsx_runtime_1.jsxs)("div", { style: CAPTION_STYLE, children: [(0, jsx_runtime_1.jsxs)("span", { children: ["\u5206\u4EAB\u5361\u9884\u89C8\uFF08?mobile-nav-share-preview=1\uFF09 \u00B7 ", state.source === 'live' ? '会话数据' : 'fixture 数据', state.error !== null ? ` · 拉取失败：${state.error}` : ''] }), (0, jsx_runtime_1.jsx)("button", { type: "button", style: EXPORT_STYLE, disabled: exportBusy !== null, onClick: () => { void runExport(); }, children: exportBusy !== null ? `导出中 ${exportBusy}` : '导出 PNG' }), exportNote !== null
+                        ? (0, jsx_runtime_1.jsx)("span", { style: { overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }, children: exportNote })
+                        : null, (0, jsx_runtime_1.jsx)("button", { type: "button", style: CLOSE_STYLE, onClick: () => setGone(true), children: "\u2715" })] }), (0, jsx_runtime_1.jsx)("div", { ref: cardHostRef, style: { padding: '16px', display: 'flex', justifyContent: 'center', minHeight: '120px' }, children: (0, jsx_runtime_1.jsx)(share_card_tsx_1.ShareCard, { title: state.source === 'live' ? (row?.displayTitle ?? FIXTURE_TITLE) : FIXTURE_TITLE, ...(preset !== undefined ? { subtitle: preset } : {}), ...(state.createdAt !== undefined ? { createdAt: state.createdAt } : {}), turns: state.turns, copy: copy }) })] }));
+}
+/* Debug chrome styles (inline like everything else in this feature). */
+const PANEL_STYLE = {
+    position: 'absolute',
+    top: 0,
+    left: 0,
+    right: 0,
+    maxHeight: '100%',
+    overflow: 'auto',
+    zIndex: 30,
+    // The shell overlay layer is pointer-events:none with pointer-events:auto
+    // restored on children; explicit keeps this panel usable regardless.
+    pointerEvents: 'auto',
+    background: 'rgba(20, 22, 26, 0.08)',
+};
+const CAPTION_STYLE = {
+    position: 'sticky',
+    top: 0,
+    zIndex: 1,
+    display: 'flex',
+    alignItems: 'center',
+    gap: '8px',
+    padding: '6px 12px',
+    background: 'rgba(15, 17, 21, 0.82)',
+    color: '#fff',
+    font: '12px/1.6 ui-monospace, SFMono-Regular, Menlo, monospace',
+};
+const CLOSE_STYLE = {
+    marginLeft: '8px',
+    border: 'none',
+    borderRadius: '6px',
+    background: 'rgba(255, 255, 255, 0.14)',
+    color: '#fff',
+    font: 'inherit',
+    lineHeight: 1,
+    padding: '4px 8px',
+    cursor: 'pointer',
+};
+const EXPORT_STYLE = {
+    marginLeft: 'auto',
+    border: 'none',
+    borderRadius: '6px',
+    background: 'rgba(255, 255, 255, 0.22)',
+    color: '#fff',
+    font: 'inherit',
+    lineHeight: 1,
+    padding: '4px 8px',
+    cursor: 'pointer',
+    whiteSpace: 'nowrap',
+};
+};
 __modules["index.js"] = function (require, module, exports) {
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -9345,6 +12648,7 @@ const native_trigger_overlay_ts_1 = require("./effects/native-trigger-overlay.js
 const welcome_notice_ts_1 = require("./effects/welcome-notice.js");
 const keyboard_guard_ts_1 = require("./effects/keyboard-guard.js");
 const keyboard_avoid_ts_1 = require("./effects/keyboard-avoid.js");
+const share_preview_tsx_1 = require("./share/share-preview.js");
 const locales_ts_1 = require("./locales.js");
 /** Required services (cordis fiber inject — the loader passes all module exports as an object plugin). */
 exports.inject = ['slots', 'layout', 'locale', 'sessionLogDownload', 'sessions', 'workspaces'];
@@ -9562,6 +12866,20 @@ function apply(ctx) {
             toggleSidebar: () => ctx.layout.toggleSidebar(),
         }),
     }, MobileDrawerFooter_tsx_1.MobileDrawerFooter));
+    // Share-card debug preview (ticket 03): renders the share-card template at
+    // the top of the page so its layout is inspectable before the rasterizer
+    // (ticket 04) exists. Registered ONLY with the URL param, so the no-param
+    // path — including desktop — stays bit-for-bit untouched (same debug-param
+    // exemption as ?mobile-nav-inset=, see debug.ts).
+    if (new URLSearchParams(location.search).has('mobile-nav-share-preview')) {
+        ctx.slots.inject('shell.overlay', () => ctx.slots.register({
+            name: 'shell.overlay',
+            id: 'share-preview',
+            // Above the phone home screen (order 20) within the same overlay layer.
+            order: 30,
+            locale: locales_ts_1.NS,
+        }, share_preview_tsx_1.SharePreview));
+    }
 }
 };
 var __cache = {};