dsh-zen-remote 1.1.13 → 1.1.14

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

@@ -20,6 +20,7 @@ export declare const zh: {
     readonly sessionInfo: "会话信息";
     readonly workbench: "工作台";
     readonly workbenchClose: "关闭工作台";
+    readonly sidebar: "侧边栏";
     readonly switchView: "切换视图";
     readonly attach: "添加附件";
     readonly attachBusy: "上传中…";
@@ -47,6 +48,28 @@ export declare const zh: {
     readonly infoActionError: "操作失败：{message}";
     readonly turnFold: "过程 · {count} 步";
     readonly turnFoldRunning: "进行中 · {count} 步";
+    readonly shareCardTurns: "{count} 轮对话";
+    readonly shareCardGeneratedBy: "由 DeepSeek Harness 生成";
+    readonly shareCardImage: "图片附件";
+    readonly shareAction: "分享图";
+    readonly sharePickerTitle: "分享范围";
+    readonly sharePickerAll: "全部对话";
+    readonly sharePickerLast: "最近 {count} 轮";
+    readonly sharePickerConfirm: "生成分享图";
+    readonly sharePickerBusy: "生成中…";
+    readonly shareTruncatedNote: "内容过长，已省略前 {count} 轮";
+    readonly shareErrRouteMissing: "当前 DSH 版本未提供分享图接口，请更新 DSH 后重试";
+    readonly shareErrSessionNotFound: "会话不存在或已被删除";
+    readonly shareErrBadRequest: "分享请求无效，请重试";
+    readonly shareErrNetwork: "网络连接失败，请检查网络后重试";
+    readonly shareErrServer: "服务暂时不可用，请稍后重试";
+    readonly shareErrBody: "分享数据异常，请重试";
+    readonly shareErrProbe: "当前浏览器无法生成分享图";
+    readonly shareErrRender: "生成分享图失败，请重试";
+    readonly shareErrSliceBudget: "分享图单段内容超出画布上限，请缩小分享范围后重试";
+    readonly shareErrEmpty: "会话还没有可分享的内容";
+    readonly shareStitchUnsupported: "当前浏览器暂不支持合成单张长图，已导出为多张图片";
+    readonly shareStitchFailed: "合成单张长图失败，已改为多张图片导出";
     readonly settings: "设置";
     readonly chipTaskboard: "任务看板";
     readonly chipSsh: "SSH";

package/lib/types/client/locales.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"locales.d.ts","sourceRoot":"","sources":["../../../src/client/locales.ts"],"names":[],"mappings":"AAAA,2DAA2D;AAC3D,eAAO,MAAM,EAAE,cAAc,CAAA;AAE7B,mEAAmE;AACnE,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDL,CAAA;AAEV,wEAAwE;AACxE,eAAO,MAAM,EAAE,EAAE,MAAM,CAAC,YAAY,EAAE,MAAM,CAmD3C,CAAA;AAED,2EAA2E;AAC3E,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,EAAE,CAAA"}
+{"version":3,"file":"locales.d.ts","sourceRoot":"","sources":["../../../src/client/locales.ts"],"names":[],"mappings":"AAAA,2DAA2D;AAC3D,eAAO,MAAM,EAAE,cAAc,CAAA;AAE7B,mEAAmE;AACnE,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0EL,CAAA;AAEV,wEAAwE;AACxE,eAAO,MAAM,EAAE,EAAE,MAAM,CAAC,YAAY,EAAE,MAAM,CA0E3C,CAAA;AAED,2EAA2E;AAC3E,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,EAAE,CAAA"}

package/lib/types/client/share/fetch-share.d.ts

@@ -0,0 +1,77 @@
+/**
+ * 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.
+ */
+import type { ShareTurn } from './share-card.tsx';
+/** Route the host registers (mirror of src/share-export.ts — the client cannot import host code). */
+export declare const SHARE_EXPORT_ROUTE = "/_dsh/mobile-nav/share-export";
+/**
+ * Which slice of the transcript to export — exactly the `range`/`turns` pair
+ * the route validates (src/share-export.ts: `turns` next to `range=all` is a
+ * 400, so it is only ever appended for `range=last`).
+ */
+export type ShareRange = {
+    kind: 'all';
+} | {
+    kind: 'last';
+    turns: number;
+};
+/** Preset turn counts the range sheet offers (PLAN §6: presets, no free input). */
+export declare const SHARE_TURNS_PRESETS: readonly number[];
+/**
+ * Machine-readable fetch failure. `code` picks the localized copy; `status`
+ * is the HTTP status when a response existed (undefined = the request never
+ * completed). Fields are assigned in the constructor body, not declared as
+ * parameter properties — Node type stripping rejects that syntax (same
+ * reason as ShareRasterizeError / ShareExportError).
+ */
+export type ShareFetchErrorCode = 
+/** 404 without the route's JSON envelope: this DSH never mounted the route (too old). */
+'route-missing'
+/** 404 + the route's own session-not-found code: the session is gone. */
+ | 'session-not-found'
+/** 400: malformed query the client should not have built. */
+ | 'bad-request'
+/** Any other non-ok status (route error, gateway 502, …). */
+ | 'server'
+/** fetch() itself threw (offline, connection reset). */
+ | 'network'
+/** 2xx but the body is not the agreed shape. */
+ | 'bad-body';
+/** Localizable fetch failure; ticket 05 maps `code` to locales shareErr*. */
+export declare class ShareFetchError extends Error {
+    readonly code: ShareFetchErrorCode;
+    readonly status: number | undefined;
+    constructor(code: ShareFetchErrorCode, status: number | undefined, detail: string);
+}
+/** A validated export payload (the route's 200 body minus the envelope). */
+export interface ShareExportData {
+    turns: ShareTurn[];
+    createdAt: number | undefined;
+}
+/**
+ * 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).
+ */
+export declare function buildShareExportQuery(session: string, range: ShareRange): string;
+/**
+ * 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.
+ */
+export declare function fetchShareExport(session: string, range: ShareRange): Promise<ShareExportData>;
+//# sourceMappingURL=fetch-share.d.ts.map

package/lib/types/client/share/fetch-share.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-share.d.ts","sourceRoot":"","sources":["../../../../src/client/share/fetch-share.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAEjD,qGAAqG;AACrG,eAAO,MAAM,kBAAkB,kCAAkC,CAAA;AAEjE;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAE1E,mFAAmF;AACnF,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EAAe,CAAA;AAEhE;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB;AAC7B,yFAAyF;AACvF,eAAe;AACjB,yEAAyE;GACvE,mBAAmB;AACrB,6DAA6D;GAC3D,aAAa;AACf,6DAA6D;GAC3D,QAAQ;AACV,wDAAwD;GACtD,SAAS;AACX,gDAAgD;GAC9C,UAAU,CAAA;AAEd,6EAA6E;AAC7E,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAA;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;gBAEvB,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM;CAMlF;AAED,4EAA4E;AAC5E,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,SAAS,EAAE,CAAA;IAClB,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;CAC9B;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM,CAIhF;AAyBD;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,eAAe,CAAC,CA8CnG"}

package/lib/types/client/share/markdown.d.ts

@@ -0,0 +1,97 @@
+/**
+ * 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.
+ */
+/** One inline run. Emphasis nests by recursion; code/link leaves are atomic. */
+export type MdSpan = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'bold';
+    spans: MdSpan[];
+} | {
+    kind: 'italic';
+    spans: MdSpan[];
+} | {
+    kind: 'strike';
+    spans: MdSpan[];
+} | {
+    kind: 'code';
+    text: string;
+} | {
+    kind: 'link';
+    spans: MdSpan[];
+    href: string;
+};
+/** One list item: inline content plus one nested level (the parser's cap). */
+export interface MdListItem {
+    spans: MdSpan[];
+    /** Ordered item number as written (undefined for bullets). */
+    number: number | undefined;
+    children: MdListItem[];
+}
+/** Column alignment from the delimiter row (null = unspecified/left). */
+export type MdAlign = 'left' | 'center' | 'right' | null;
+/** One recognized block. The renderer switches on `kind` only. */
+export type MdBlock = {
+    kind: 'heading';
+    level: number;
+    spans: MdSpan[];
+} | {
+    kind: 'para';
+    spans: MdSpan[];
+} | {
+    kind: 'code';
+    lang: string | undefined;
+    lines: string[];
+} | {
+    kind: 'quote';
+    children: MdBlock[];
+} | {
+    kind: 'list';
+    ordered: boolean;
+    items: MdListItem[];
+} | {
+    kind: 'table';
+    align: MdAlign[];
+    header: MdSpan[][];
+    rows: MdSpan[][][];
+} | {
+    kind: 'hr';
+} | {
+    kind: 'image';
+    alt: string;
+    src: string;
+};
+/**
+ * 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.
+ */
+export declare function parseMarkdown(text: string): MdBlock[];
+//# sourceMappingURL=markdown.d.ts.map

package/lib/types/client/share/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../../../src/client/share/markdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAIH,gFAAgF;AAChF,MAAM,MAAM,MAAM,GACd;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GACnC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GACnC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAInD,8EAA8E;AAC9E,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,8DAA8D;IAC9D,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,QAAQ,EAAE,UAAU,EAAE,CAAA;CACvB;AAED,yEAAyE;AACzE,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,IAAI,CAAA;AAExD,kEAAkE;AAClE,MAAM,MAAM,OAAO,GACf;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GACnD;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GAC3D;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,OAAO,EAAE,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,UAAU,EAAE,CAAA;CAAE,GACvD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAA;CAAE,GAC3E;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,GACd;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAA;AA0hB/C;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,EAAE,CAErD"}

package/lib/types/client/share/png-stitch.d.ts

@@ -0,0 +1,96 @@
+/**
+ * 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.
+ */
+/**
+ * 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.
+ */
+export declare function crc32(bytes: Uint8Array): number;
+/** The 8-byte PNG file signature. */
+export declare const PNG_SIGNATURE: Uint8Array<ArrayBuffer>;
+/**
+ * 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).
+ */
+export declare function pngChunk(type: string, data: Uint8Array): Uint8Array<ArrayBuffer>;
+/** IHDR payload: width/height big-endian, 8 bits/channel, RGBA (color type 6), deflate, filter 0, no interlace. */
+export declare function ihdrData(width: number, height: number): Uint8Array<ArrayBuffer>;
+/** The IEND chunk is a constant: empty payload, CRC 0xAE426082. */
+export declare const IEND_CHUNK: Uint8Array<ArrayBuffer>;
+/**
+ * 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.
+ */
+export declare const MAX_IDAT_CHUNK_BYTES: number;
+/** Split compressed bytes into consecutive IDAT payloads (multi-chunk IDAT is legal and order-significant). */
+export declare function splitIdatBytes(data: Uint8Array<ArrayBuffer>, maxBytes: number): Uint8Array<ArrayBuffer>[];
+/**
+ * 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.
+ */
+export declare class PngStitchWriter {
+    readonly width: number;
+    readonly height: number;
+    private rowsWritten;
+    private closed;
+    private readonly writer;
+    private readonly drained;
+    constructor(width: number, height: number);
+    /** Feed one scanline (`width × 4` RGBA bytes). The bytes must stay untouched until the returned promise resolves. */
+    writeRow(rgba: Uint8Array<ArrayBuffer>): Promise<void>;
+    /** Close the stream and assemble the file. Rejects unless exactly `height` rows were fed. */
+    finish(): Promise<Blob>;
+}
+/**
+ * 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.
+ */
+export declare function supportsPngStitch(): boolean;
+/** One stitched slice: its painted PNG and its physical height. */
+export interface StitchSlicePart {
+    blob: Blob;
+    /** Physical px height of the slice (the count of scanlines it contributes). */
+    height: number;
+}
+/**
+ * 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.
+ */
+export declare function stitchSliceBlobs(parts: readonly StitchSlicePart[], width: number): Promise<Blob>;
+//# sourceMappingURL=png-stitch.d.ts.map

package/lib/types/client/share/png-stitch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"png-stitch.d.ts","sourceRoot":"","sources":["../../../../src/client/share/png-stitch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAiBH;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAM/C;AAED,qCAAqC;AACrC,eAAO,MAAM,aAAa,EAAE,UAAU,CAAC,WAAW,CAAoE,CAAA;AAgBtH;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,UAAU,CAAC,WAAW,CAAC,CAYhF;AAED,mHAAmH;AACnH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,WAAW,CAAC,CAU/E;AAED,mEAAmE;AACnE,eAAO,MAAM,UAAU,EAAE,UAAU,CAAC,WAAW,CAAuC,CAAA;AAEtF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,QAAU,CAAA;AAE3C,+GAA+G;AAC/G,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU,CAAC,WAAW,CAAC,EAAE,CAQzG;AAUD;;;;;;;;;GASG;AACH,qBAAa,eAAe;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,OAAO,CAAC,WAAW,CAAI;IACvB,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2C;IAClE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;gBAE9C,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAiCzC,qHAAqH;IAC/G,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAW5D,6FAA6F;IACvF,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAe9B;AAOD;;;;;GAKG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAED,mEAAmE;AACnE,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,IAAI,CAAA;IACV,+EAA+E;IAC/E,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,SAAS,eAAe,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAsCtG"}

package/lib/types/client/share/rasterize.d.ts

@@ -0,0 +1,317 @@
+/**
+ * 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.
+ */
+/** Per-slice physical pixel budget (iOS canvas hard cap 16.7M minus margin). */
+export declare const SLICE_PIXEL_BUDGET = 12000000;
+/** Slice count ceiling; beyond it the head is dropped and the first slice marked. */
+export declare const MAX_SLICES = 24;
+/** Pixel-ratio fallback ladder, walked top-down from min(devicePixelRatio, 2). */
+export declare const PIXEL_RATIO_STEPS: readonly number[];
+/** Safety px added around computed ultra widths (sub-pixel + rounding slack). */
+export declare const ULTRA_WIDTH_MARGIN = 2;
+/**
+ * Machine-readable failure kinds; ticket 05 maps them to localized copy.
+ * `slice-over-budget` (review 07+08): a unified-mode slice whose freshly
+ * MEASURED height busts the per-slice canvas budget at the global stitch
+ * width — the planner's global lever should have prevented it, and the old
+ * behavior (floor the height, silently clip the bottom) was invisible data
+ * loss, so it fails loudly instead.
+ */
+export type ShareRasterizeErrorCode = 'probe-failed' | 'image-load' | 'canvas' | 'empty-card' | 'slice-over-budget';
+/** Localizable rasterize failure. `code` drives UI copy, `detail` is diagnostic. */
+export declare class ShareRasterizeError extends Error {
+    readonly code: ShareRasterizeErrorCode;
+    readonly detail: string;
+    constructor(code: ShareRasterizeErrorCode, detail: string);
+}
+/** Descending pixel-ratio candidates for an already-clamped cap; never empty. */
+export declare function ratioChain(cap: number): number[];
+/** Physical pixels a slice occupies once painted (rounding up, canvas-style). */
+export declare function slicePixelCount(outWidth: number, outHeight: number, pixelRatio: number): number;
+/** Physical raster geometry of one slice: svg/foreignObject/canvas all take these. */
+export interface RasterGeometry {
+    /** Physical px width (>= 1). */
+    width: number;
+    /** Physical px height (>= 1). */
+    height: number;
+    /** Wrapper transform = scale × pixelRatio (further shrunk when clamped). */
+    transformScale: number;
+}
+/**
+ * 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).
+ */
+export declare function rasterGeometry(renderWidth: number, logicalHeight: number, scale: number, pixelRatio: number, budgetPx: number): RasterGeometry;
+/** Inputs of {@link buildSvgDocument}: logical tree size + physical target. */
+export interface SvgDocumentSpec {
+    /** Logical px width of the slice tree (the wrapper's width). */
+    renderWidth: number;
+    /** Logical px height of the slice tree (the wrapper's height). */
+    logicalHeight: number;
+    /** Physical target width ({@link RasterGeometry.width}). */
+    width: number;
+    /** Physical target height ({@link RasterGeometry.height}). */
+    height: number;
+    /** Wrapper transform ({@link RasterGeometry.transformScale}). */
+    transformScale: number;
+}
+/**
+ * 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).
+ */
+export declare function buildSvgDocument(bodyHtml: string, spec: SvgDocumentSpec): string;
+/**
+ * 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.
+ */
+export declare function cardWidthForContent(contentWidth: number, cardPaddingX: number): number;
+/**
+ * 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.
+ */
+export declare function cardWidthForUserBubble(contentWidth: number, cardPaddingX: number): number;
+/** Card width a turn's measured content needs, by turn role. */
+export declare function requiredCardWidth(role: 'user' | 'assistant', contentWidth: number, cardPaddingX: number): number;
+/** Which slice geometry a turn needs, from its measured natural content width. */
+export type TurnWidthBucket = 'base' | 'wide' | 'ultra';
+/** Bucket one turn: base width / widened (~780) / wider-than-wide (scale-to-fit). */
+export declare function bucketTurnWidth(role: 'user' | 'assistant', contentWidth: number, cardPaddingX: number, baseWidth: number, wideWidth: number): TurnWidthBucket;
+/**
+ * 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).
+ */
+export declare function ultraSliceWidth(role: 'user' | 'assistant', contentWidth: number, cardPaddingX: number, wideWidth: number): {
+    renderWidth: number;
+    scale: number;
+};
+/** One turn's final geometry as the DOM measured it at {@link renderWidth}. */
+export interface PlannedTurnInput {
+    /** Logical px height of the turn at {@link renderWidth}. */
+    height: number;
+    /** Logical px width the turn's slice renders at (base / wide / ultra). */
+    renderWidth: number;
+    /** Geometric output downscale (1 except ultra turns). */
+    scale: number;
+}
+/** Fixed card chrome the planner must reserve height for. */
+export interface PlanExtras {
+    /** Vertical gap between the card root's column children. */
+    gap: number;
+    /** Card root top + bottom padding. */
+    paddingY: number;
+    /** Header strip height (reserved on the first slice). */
+    headerHeight: number;
+    /** Footer strip height (reserved on the last slice). */
+    footerHeight: number;
+    /** Truncation-note bar height (reserved on a truncated last slice). */
+    noteHeight: number;
+}
+export interface PlanOptions {
+    budgetPx: number;
+    maxSlices: number;
+    /** Descending pixel-ratio candidates (see {@link ratioChain}). */
+    ratios: readonly number[];
+}
+/** One planned output image. */
+export interface PlannedSlice {
+    /** Inclusive index of the first turn in this slice. */
+    from: number;
+    /** Inclusive index of the last turn in this slice. */
+    to: number;
+    /** Logical width the slice must be cloned/rendered at. */
+    renderWidth: number;
+    /** Total geometric downscale (ultra fit × budget lever; 1 = native). */
+    scale: number;
+    /** Logical height at {@link renderWidth}, chrome included. */
+    height: number;
+    /** Output logical width (renderWidth × scale). */
+    outWidth: number;
+    /** Output logical height (height × scale). */
+    outHeight: number;
+    /** Extra shrink applied to satisfy the pixel budget (1 = none). */
+    lever: number;
+    /** Carries the header strip (and the note when {@link truncated}). */
+    first: boolean;
+    /** Carries the footer strip. */
+    last: boolean;
+    /** True only on the first slice of a truncated export (marks the dropped head). */
+    truncated: boolean;
+}
+export interface SlicePlan {
+    pixelRatio: number;
+    slices: PlannedSlice[];
+    truncated: boolean;
+    /** Turns dropped from the HEAD by the {@link PlanOptions.maxSlices} ceiling (the tail — the recent turns a share is about — is always kept). */
+    droppedTurns: number;
+}
+/**
+ * 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.
+ */
+export declare function planShareSlices(turns: readonly PlannedTurnInput[], extras: PlanExtras, opts: PlanOptions): SlicePlan;
+/**
+ * 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).
+ */
+export declare function unifiedCardWidth(anyTurnNeedsWide: boolean): number;
+/**
+ * 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).
+ */
+export declare function planShareSlicesUnified(turns: readonly PlannedTurnInput[], extras: PlanExtras, opts: PlanOptions): SlicePlan;
+/**
+ * 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.
+ */
+export declare function stitchPixelWidth(plan: SlicePlan): number;
+/** Stitch-mode raster geometry: the width is the GLOBAL one, never this slice's own arithmetic. */
+export interface StitchRasterGeometry {
+    /** Physical px width — always the caller's global width, byte-for-byte. */
+    width: number;
+    /** Physical px height (>= 1); when `clamped`, the floor'd budget-capped height. */
+    height: number;
+    /** Wrapper transform = globalWidth / renderWidth (ultra fit × lever × ratio all folded in). */
+    transformScale: number;
+    /**
+     * True when the measured height busts the per-slice budget at the global
+     * width (the global lever should have prevented this). The pure function
+     * still returns the floor'd geometry so the check script can pin the
+     * arithmetic — the DOM half REFUSES to paint a clamped slice (a floor'd
+     * height means the bottom of the card is silently cut off: visible data
+     * loss, review 07+08 plan B).
+     */
+    clamped: boolean;
+}
+/**
+ * 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.
+ */
+export declare function rasterGeometryStitch(renderWidth: number, logicalHeight: number, globalWidth: number, budgetPx: number): StitchRasterGeometry;
+export interface RasterizeOptions {
+    /** Upper bound for the pixel ratio; default min(devicePixelRatio, 2). */
+    pixelRatioCap?: number;
+    /** Truncation-note copy, fed the count of dropped head turns (ticket 05 localizes it). */
+    truncatedNote?: (droppedTurns: number) => string;
+    /** Called 0/N once and done/N after each slice. */
+    onProgress?: (done: number, total: number) => void;
+    /**
+     * Stitch mode (ticket 07, PLAN §4.5): plan for a single-PNG stitched export —
+     * one global logical width (390/780), one global pixel ratio and one global
+     * budget lever, so every slice shares the same physical width and
+     * png-stitch.ts can concatenate scanlines. Default false keeps the legacy
+     * per-slice-width multi-file geometry (the fallback path for browsers
+     * without CompressionStream).
+     */
+    unified?: boolean;
+}
+export interface RasterizeResult {
+    pixelRatio: number;
+    truncated: boolean;
+    droppedTurns: number;
+    slices: RasterizedSlice[];
+    /**
+     * Unified mode only: the physical pixel width every slice shares — the IHDR
+     * width of the stitched long image (undefined in legacy mode).
+     */
+    stitchWidth: number | undefined;
+}
+export interface RasterizedSlice {
+    index: number;
+    blob: Blob;
+    /** Physical px size of the PNG. */
+    width: number;
+    height: number;
+    /** Logical slice width (before scaling). */
+    logicalWidth: number;
+    /** Total geometric scale applied on output. */
+    scale: number;
+    /** Transcript seq of the first/last turn in this slice (debug + ordering). */
+    fromSeq: number;
+    toSeq: number;
+}
+/**
+ * 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.
+ */
+export declare function ensureProbe(): Promise<void>;
+/**
+ * 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.
+ */
+export declare function rasterizeShareCard(card: HTMLElement, options?: RasterizeOptions): Promise<RasterizeResult>;
+//# sourceMappingURL=rasterize.d.ts.map

package/lib/types/client/share/rasterize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rasterize.d.ts","sourceRoot":"","sources":["../../../../src/client/share/rasterize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAQH,gFAAgF;AAChF,eAAO,MAAM,kBAAkB,WAAa,CAAA;AAC5C,qFAAqF;AACrF,eAAO,MAAM,UAAU,KAAK,CAAA;AAC5B,kFAAkF;AAClF,eAAO,MAAM,iBAAiB,EAAE,SAAS,MAAM,EAAgB,CAAA;AAC/D,iFAAiF;AACjF,eAAO,MAAM,kBAAkB,IAAI,CAAA;AAEnC;;;;;;;GAOG;AACH,MAAM,MAAM,uBAAuB,GAAG,cAAc,GAAG,YAAY,GAAG,QAAQ,GAAG,YAAY,GAAG,mBAAmB,CAAA;AAEnH,oFAAoF;AACpF,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,QAAQ,CAAC,IAAI,EAAE,uBAAuB,CAAA;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;gBAEX,IAAI,EAAE,uBAAuB,EAAE,MAAM,EAAE,MAAM;CAK1D;AAED,iFAAiF;AACjF,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAGhD;AAED,iFAAiF;AACjF,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAE/F;AASD,sFAAsF;AACtF,MAAM,WAAW,cAAc;IAC7B,gCAAgC;IAChC,KAAK,EAAE,MAAM,CAAA;IACb,iCAAiC;IACjC,MAAM,EAAE,MAAM,CAAA;IACd,4EAA4E;IAC5E,cAAc,EAAE,MAAM,CAAA;CACvB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,CAU9I;AAED,+EAA+E;AAC/E,MAAM,WAAW,eAAe;IAC9B,gEAAgE;IAChE,WAAW,EAAE,MAAM,CAAA;IACnB,kEAAkE;IAClE,aAAa,EAAE,MAAM,CAAA;IACrB,4DAA4D;IAC5D,KAAK,EAAE,MAAM,CAAA;IACb,8DAA8D;IAC9D,MAAM,EAAE,MAAM,CAAA;IACd,iEAAiE;IACjE,cAAc,EAAE,MAAM,CAAA;CACvB;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,GAAG,MAAM,CAIhF;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAEtF;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAGzF;AAED,gEAAgE;AAChE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAEhH;AAED,kFAAkF;AAClF,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;AAEvD,qFAAqF;AACrF,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,eAAe,CAK7J;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAGjK;AAID,+EAA+E;AAC/E,MAAM,WAAW,gBAAgB;IAC/B,4DAA4D;IAC5D,MAAM,EAAE,MAAM,CAAA;IACd,0EAA0E;IAC1E,WAAW,EAAE,MAAM,CAAA;IACnB,yDAAyD;IACzD,KAAK,EAAE,MAAM,CAAA;CACd;AAED,6DAA6D;AAC7D,MAAM,WAAW,UAAU;IACzB,4DAA4D;IAC5D,GAAG,EAAE,MAAM,CAAA;IACX,sCAAsC;IACtC,QAAQ,EAAE,MAAM,CAAA;IAChB,yDAAyD;IACzD,YAAY,EAAE,MAAM,CAAA;IACpB,wDAAwD;IACxD,YAAY,EAAE,MAAM,CAAA;IACpB,uEAAuE;IACvE,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,kEAAkE;IAClE,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAC1B;AAED,gCAAgC;AAChC,MAAM,WAAW,YAAY;IAC3B,uDAAuD;IACvD,IAAI,EAAE,MAAM,CAAA;IACZ,sDAAsD;IACtD,EAAE,EAAE,MAAM,CAAA;IACV,0DAA0D;IAC1D,WAAW,EAAE,MAAM,CAAA;IACnB,wEAAwE;IACxE,KAAK,EAAE,MAAM,CAAA;IACb,8DAA8D;IAC9D,MAAM,EAAE,MAAM,CAAA;IACd,kDAAkD;IAClD,QAAQ,EAAE,MAAM,CAAA;IAChB,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAA;IACjB,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAA;IACb,sEAAsE;IACtE,KAAK,EAAE,OAAO,CAAA;IACd,gCAAgC;IAChC,IAAI,EAAE,OAAO,CAAA;IACb,mFAAmF;IACnF,SAAS,EAAE,OAAO,CAAA;CACnB;AAED,MAAM,WAAW,SAAS;IACxB,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,YAAY,EAAE,CAAA;IACtB,SAAS,EAAE,OAAO,CAAA;IAClB,gJAAgJ;IAChJ,YAAY,EAAE,MAAM,CAAA;CACrB;AAkHD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,gBAAgB,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,WAAW,GAAG,SAAS,CAqCpH;AAID;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,gBAAgB,EAAE,OAAO,GAAG,MAAM,CAElE;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,SAAS,gBAAgB,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,WAAW,GAAG,SAAS,CAkD3H;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAIxD;AAED,mGAAmG;AACnG,MAAM,WAAW,oBAAoB;IACnC,2EAA2E;IAC3E,KAAK,EAAE,MAAM,CAAA;IACb,mFAAmF;IACnF,MAAM,EAAE,MAAM,CAAA;IACd,+FAA+F;IAC/F,cAAc,EAAE,MAAM,CAAA;IACtB;;;;;;;OAOG;IACH,OAAO,EAAE,OAAO,CAAA;CACjB;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,oBAAoB,CAU5I;AAWD,MAAM,WAAW,gBAAgB;IAC/B,yEAAyE;IACzE,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,0FAA0F;IAC1F,aAAa,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,MAAM,CAAA;IAChD,mDAAmD;IACnD,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAClD;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,OAAO,CAAA;IAClB,YAAY,EAAE,MAAM,CAAA;IACpB,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB;;;OAGG;IACH,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;CAChC;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,IAAI,CAAA;IACV,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,4CAA4C;IAC5C,YAAY,EAAE,MAAM,CAAA;IACpB,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAA;IACb,8EAA8E;IAC9E,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd;AAsUD;;;;;;GAMG;AACH,wBAAsB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CA8BjD;AAID;;;;;;;;;;;;;GAaG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,GAAE,gBAAqB,GAAG,OAAO,CAAC,eAAe,CAAC,CAkGpH"}