@epam/ai-dial-chat-hooks 1.3.0-dev.5 → 1.3.0-dev.55

package/conversation/announcement-message.d.ts

@@ -0,0 +1,61 @@
+/** A link rendered as the call to action of an announcements-popover entry. */
+export interface AnnouncementListItemLink {
+    /** Visible text of the call to action. */
+    label: string;
+    /** Absolute `http`/`https` target the call to action opens. */
+    href: string;
+}
+/** One entry of the announcements popover behind the banner's `+N` pill. */
+export interface AnnouncementListItem {
+    /** Plain-text heading of the entry. */
+    title: string;
+    /** Supporting copy of the entry, sanitized before it is rendered. */
+    description?: string | null;
+    /** Optional call to action shown at the end of the entry. */
+    link?: AnnouncementListItemLink | null;
+}
+/** Structured announcement banner content. */
+export interface AnnouncementContent {
+    title: string | null;
+    description: string | null;
+    html: string | null;
+    /** Entries of the popover the banner opens. */
+    items?: readonly AnnouncementListItem[];
+}
+/** Sanitizes announcement HTML to the allowed inline tag/attribute set. */
+export declare const sanitizeAnnouncementHtml: (html: string) => string;
+/**
+ * Sanitizes the legacy `ANNOUNCEMENT_HTML_MESSAGE` banner, which permits the
+ * block-level markup the inline pass strips. See
+ * `ANNOUNCEMENT_MESSAGE_SANITIZE_OPTIONS` for why the two lists differ.
+ */
+export declare const sanitizeAnnouncementMessageHtml: (html: string) => string;
+/**
+ * Whether the operator configured the structured banner (title and/or
+ * description) rather than only the legacy HTML message. Drives which of the
+ * two banner layouts renders.
+ */
+export declare const hasStructuredAnnouncement: ({ title, description, }: AnnouncementContent) => boolean;
+/** True when the announcement has any renderable content (structured or legacy HTML). */
+export declare const hasAnnouncementContent: (content: AnnouncementContent) => boolean;
+/**
+ * Builds the value persisted under `StorageKey.TextOfClosedAnnouncement` when
+ * the user dismisses the banner. Dismissal is content-keyed: the banner stays
+ * hidden only while the current announcement produces the same signature, so
+ * editing any part of it brings the banner back with no version counter.
+ *
+ * Every piece of content the banner surface renders feeds the signature — the
+ * title, the description, and the popover entries behind the pill, which live
+ * inside the banner and are hidden along with it. Publishing a new entry in
+ * that list therefore invalidates an earlier dismissal on its own, even when
+ * the banner line itself is untouched.
+ *
+ * A legacy-only announcement returns the raw HTML string — byte-identical to
+ * what shipped before the structured fields existed — so dismissals recorded
+ * by older builds keep working without a storage migration. `items` is left
+ * out of the payload entirely when the list is empty for the same reason: a
+ * deployment that never configured the popover keeps matching the signatures
+ * its users already have stored.
+ */
+export declare const buildAnnouncementSignature: (content: AnnouncementContent) => string;
+//# sourceMappingURL=announcement-message.d.ts.map

package/conversation/announcement-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"announcement-message.d.ts","sourceRoot":"","sources":["../../src/conversation/announcement-message.ts"],"names":[],"mappings":"AA+BA,+EAA+E;AAC/E,MAAM,WAAW,wBAAwB;IACvC,0CAA0C;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAC;CACd;AAED,4EAA4E;AAC5E,MAAM,WAAW,oBAAoB;IACnC,uCAAuC;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,qEAAqE;IACrE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,6DAA6D;IAC7D,IAAI,CAAC,EAAE,wBAAwB,GAAG,IAAI,CAAC;CACxC;AAED,8CAA8C;AAC9C,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,+CAA+C;IAC/C,KAAK,CAAC,EAAE,SAAS,oBAAoB,EAAE,CAAC;CACzC;AAQD,2EAA2E;AAC3E,eAAO,MAAM,wBAAwB,GAAI,MAAM,MAAM,KAAG,MACgB,CAAC;AAEzE;;;;GAIG;AACH,eAAO,MAAM,+BAA+B,GAAI,MAAM,MAAM,KAAG,MACY,CAAC;AAK5E;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,GAAI,yBAGvC,mBAAmB,KAAG,OACqB,CAAC;AAE/C,yFAAyF;AACzF,eAAO,MAAM,sBAAsB,GAAI,SAAS,mBAAmB,KAAG,OACN,CAAC;AA2BjE;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,0BAA0B,GACrC,SAAS,mBAAmB,KAC3B,MAgBF,CAAC"}

package/conversation/conversation-transfer/async.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Runs `worker` over `items` with at most `limit` concurrent invocations.
+ * Preserves no particular result order beyond "worker completed"; a worker
+ * that returns `undefined`, or throws, contributes nothing to the result
+ * array (used to skip failed/invalid items without aborting the whole
+ * batch) — a throwing worker is caught here so the other concurrent items
+ * keep being tracked instead of continuing unobserved in the background.
+ */
+export declare const runWithConcurrency: <T, R>(items: T[], limit: number, worker: (item: T) => Promise<R | undefined>) => Promise<R[]>;
+//# sourceMappingURL=async.d.ts.map

package/conversation/conversation-transfer/async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.d.ts","sourceRoot":"","sources":["../../../src/conversation/conversation-transfer/async.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAAU,CAAC,EAAE,CAAC,EAC3C,OAAO,CAAC,EAAE,EACV,OAAO,MAAM,EACb,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,KAC1C,OAAO,CAAC,CAAC,EAAE,CAqBb,CAAC"}

package/conversation/conversation-transfer/attachment-refs.d.ts

@@ -0,0 +1,42 @@
+import { Conversation } from '@epam/ai-dial-chat-shared';
+/**
+ * The reference fields shared by every attachment shape a conversation can
+ * carry — `MessageAttachment` on a message or a stage, and
+ * `AttachmentResource` on a citation's source.
+ */
+export interface AttachmentReference {
+    /** DIAL file id (`files/{bucket}/{path}`), optionally with a trailing `#…` anchor. */
+    url?: string;
+    /** Alternate reference resource, same shape as `url`. */
+    reference_url?: string;
+    /** Display name shown in the UI. */
+    title?: string;
+}
+/**
+ * Splits a DIAL file reference into the resource id and its trailing `#…`
+ * anchor (e.g. the `#page=3` a PDF citation carries). An anchor outside
+ * {@link SAFE_ANCHOR_PATTERN} is reported as absent; the file id is returned
+ * either way, so the attachment itself is still transferred.
+ *
+ * The anchor is display metadata, not part of the stored resource path: the
+ * download endpoint 404s on it, so it has to be stripped before a reference
+ * is resolved to `{bucket, path}` — and restored afterwards, so an imported
+ * citation still opens the page it cited.
+ */
+export declare const splitFileIdAnchor: (url: string) => {
+    fileId: string;
+    anchor: string;
+};
+/** A unique DIAL file reference found in a conversation's messages. */
+export interface AttachmentRef {
+    fileId: string;
+}
+/**
+ * Collects unique attachment references across all messages — message
+ * attachments, stage attachments, and citation source documents — with any
+ * `#…` anchor stripped. The same file can be referenced more than once (by a
+ * later turn, by a stage and the message it belongs to, or by several
+ * citations), so dedupe by file id and process it only once.
+ */
+export declare const collectAttachmentRefs: (conversation: Conversation) => AttachmentRef[];
+//# sourceMappingURL=attachment-refs.d.ts.map

package/conversation/conversation-transfer/attachment-refs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachment-refs.d.ts","sourceRoot":"","sources":["../../../src/conversation/conversation-transfer/attachment-refs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAK9D;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,sFAAsF;IACtF,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,yDAAyD;IACzD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,oCAAoC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAeD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,GAC5B,KAAK,MAAM,KACV;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CASlC,CAAC;AAEF,uEAAuE;AACvE,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;CAChB;AAoCD;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,GAChC,cAAc,YAAY,KACzB,aAAa,EAef,CAAC"}

package/conversation/conversation-transfer/build-upload-path.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Builds the `uploads/<YYYY-MM>/<safe-name>` upload path for a file.
+ * `date` defaults to now (regular attachment upload); conversation import
+ * passes a date fixed for the whole job so all its attachments land in the
+ * same month folder. Does not de-duplicate: a name collision is left for the
+ * upload call to reject (`create-only` mode) — use `createUploadPathAllocator`
+ * when collisions must be resolved with a ` (n)` suffix instead.
+ */
+export declare const buildUploadPath: (fileName: string, date?: Date) => string;
+/** A file name the allocator has handed out, in the forms the caller needs. */
+export interface AllocatedUploadPath {
+    /** Bucket-relative, percent-encoded upload path, e.g. `uploads/2026-08/report%20(1).pdf`. */
+    path: string;
+    /** Decoded name actually reserved, e.g. `report (1).pdf` — pass this as the uploaded `File`'s name. */
+    fileName: string;
+    /** Whether a ` (n)` suffix had to be appended because the requested name was taken. */
+    isRenamed: boolean;
+}
+/** Stateful allocator that hands out collision-free upload paths inside one month folder. */
+export interface UploadPathAllocator {
+    /** Reserves the next free name derived from `fileName` and returns its upload path. */
+    allocate: (fileName: string) => AllocatedUploadPath;
+    /** Records `fileName` as taken — used when the server rejects a name the registry believed free. */
+    markTaken: (fileName: string) => void;
+    /** Returns a previously allocated `fileName` to the free pool — used when its upload failed for a reason other than a collision. */
+    release: (fileName: string) => void;
+}
+/**
+ * Creates an allocator that assigns ` (1)`, ` (2)`, … suffixes to repeated or
+ * pre-existing file names so every allocation lands on a distinct path inside
+ * one `uploads/<YYYY-MM>/` folder. Mutation is deliberately confined to the
+ * private `Set` closed over here — an explicit, contained exception to the
+ * immutable-by-default rule, needed because collision-free naming is
+ * inherently a sequential, stateful decision.
+ */
+export declare const createUploadPathAllocator: (params?: {
+    /** Month folder to allocate into. Defaults to now. */
+    date?: Date;
+    /** Decoded names already present in the destination folder, e.g. from `listFiles`. */
+    existingNames?: Iterable<string>;
+}) => UploadPathAllocator;
+//# sourceMappingURL=build-upload-path.d.ts.map

package/conversation/conversation-transfer/build-upload-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-upload-path.d.ts","sourceRoot":"","sources":["../../../src/conversation/conversation-transfer/build-upload-path.ts"],"names":[],"mappings":"AAmBA;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAC1B,UAAU,MAAM,EAChB,OAAM,IAAiB,KACtB,MAIF,CAAC;AAUF,+EAA+E;AAC/E,MAAM,WAAW,mBAAmB;IAClC,6FAA6F;IAC7F,IAAI,EAAE,MAAM,CAAC;IACb,uGAAuG;IACvG,QAAQ,EAAE,MAAM,CAAC;IACjB,uFAAuF;IACvF,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,6FAA6F;AAC7F,MAAM,WAAW,mBAAmB;IAClC,uFAAuF;IACvF,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,mBAAmB,CAAC;IACpD,oGAAoG;IACpG,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,oIAAoI;IACpI,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;CACrC;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,GAAI,SAAS;IACjD,sDAAsD;IACtD,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,sFAAsF;IACtF,aAAa,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;CAClC,KAAG,mBAgCH,CAAC"}

package/conversation/conversation-transfer/date.d.ts

@@ -0,0 +1,5 @@
+/** Formats a `Date` as `YYYY-MM-DD` using its local-time components. */
+export declare const formatDateYMD: (date: Date) => string;
+/** Formats a `Date` as `YYYY-MM` using its local-time components. */
+export declare const formatDateYM: (date: Date) => string;
+//# sourceMappingURL=date.d.ts.map

package/conversation/conversation-transfer/date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../../src/conversation/conversation-transfer/date.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,eAAO,MAAM,aAAa,GAAI,MAAM,IAAI,KAAG,MAK1C,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,YAAY,GAAI,MAAM,IAAI,KAAG,MAIzC,CAAC"}

package/conversation/conversation-transfer/dial-file-resolve.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Extracts the bucket and decoded relative path from a DIAL file ID
+ * (`files/{bucket}/{path}`). Returns `undefined` if the input does not start
+ * with `files/` or has no path segment after the bucket.
+ */
+export declare const resolveDialFileBucketAndPath: (fileId: string) => {
+    bucket: string;
+    path: string;
+} | undefined;
+//# sourceMappingURL=dial-file-resolve.d.ts.map

package/conversation/conversation-transfer/dial-file-resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dial-file-resolve.d.ts","sourceRoot":"","sources":["../../../src/conversation/conversation-transfer/dial-file-resolve.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,GACvC,QAAQ,MAAM,KACb;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,SAcrC,CAAC"}

package/conversation/conversation-transfer/export-conversation.d.ts

@@ -0,0 +1,10 @@
+import { Conversation, ExportFolder, ExportFormat } from '@epam/ai-dial-chat-shared';
+import { ExportFileNameKind } from './types';
+/** Placeholder app name used in every export file name — this branch has no app display-name config yet. */
+export declare const EXPORT_APP_NAME = "ai_dial";
+/** Returns the conversation with every message-, stage- and citation-level attachment reference removed. */
+export declare const stripConversationAttachments: (conversation: Conversation) => Conversation;
+export declare const buildExportEnvelope: (conversations: Conversation[], folders?: ExportFolder[]) => ExportFormat;
+export declare const serializeExportEnvelope: (envelope: ExportFormat) => Blob;
+export declare const buildExportFileName: (kind: ExportFileNameKind, appName: string, date?: Date) => string;
+//# sourceMappingURL=export-conversation.d.ts.map

package/conversation/conversation-transfer/export-conversation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-conversation.d.ts","sourceRoot":"","sources":["../../../src/conversation/conversation-transfer/export-conversation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,YAAY,EACZ,YAAY,EACZ,YAAY,EAGb,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAE7C,4GAA4G;AAC5G,eAAO,MAAM,eAAe,YAAY,CAAC;AA2CzC,4GAA4G;AAC5G,eAAO,MAAM,4BAA4B,GACvC,cAAc,YAAY,KACzB,YAGD,CAAC;AAEH,eAAO,MAAM,mBAAmB,GAC9B,eAAe,YAAY,EAAE,EAC7B,UAAS,YAAY,EAAO,KAC3B,YAID,CAAC;AAEH,eAAO,MAAM,uBAAuB,GAAI,UAAU,YAAY,KAAG,IACY,CAAC;AAQ9E,eAAO,MAAM,mBAAmB,GAC9B,MAAM,kBAAkB,EACxB,SAAS,MAAM,EACf,OAAM,IAAiB,KACtB,MACyE,CAAC"}

package/conversation/conversation-transfer/import-conversation.d.ts

@@ -0,0 +1,106 @@
+import { Conversation, ExportFormat } from '@epam/ai-dial-chat-shared';
+import { AllocatedUploadPath, UploadPathAllocator } from './build-upload-path';
+/** Thrown when an imported file cannot be parsed as a supported export envelope. */
+export declare class UnsupportedImportFormatError extends Error {
+    constructor(message: string);
+}
+/**
+ * Parses raw file text into a supported export envelope (`version: 5`) with
+ * an array `history` — conversations are returned unmodified.
+ * Throws `UnsupportedImportFormatError` for malformed JSON or any other shape.
+ */
+export declare const parseImportEnvelope: (text: string) => ExportFormat;
+export interface RebasedConversationId {
+    /** The conversation with `id`/`folderId` rebased to `bucket` and a fresh UUID, and `name` sanitized. */
+    conversation: Conversation;
+    /** Bucket-relative path to pass to `saveConversation`. */
+    subPath: string;
+}
+/**
+ * Rebases a conversation's id/folderId to the current user's bucket and
+ * regenerates its trailing UUID segment, so importing it can never collide
+ * with an existing conversation and needs no replace/skip dialog. Folder
+ * path segments between the bucket and the filename are preserved (not
+ * flattened) — the new chat currently displays everything at the root, but
+ * the conversation keeps its original folder location for when the folder
+ * feature ships.
+ *
+ * The filename's title segment is rewritten from the conversation's own
+ * `name` (see `buildImportedFileName`), and `name` is replaced with the same
+ * sanitized value — the invariant the conversation list relies on to render a
+ * row's title identically whether or not it read the body back.
+ */
+export declare const rebaseConversationId: (conversation: Conversation, bucket: string) => RebasedConversationId;
+/**
+ * Derives the queue row's secondary breadcrumb line from a conversation's
+ * source `folderId` (`{bucket}[/<folder>/...]`) — the segments after the
+ * leading bucket, joined with " / ". Returns `undefined` for a root
+ * conversation (no folder segments).
+ */
+export declare const getFolderBreadcrumb: (conversation: Conversation) => string | undefined;
+/**
+ * Formats a list of names for the aggregate success/failure notifications,
+ * each individually quoted and comma-separated (e.g. `"A", "B", "C"`) so the
+ * i18n template only needs to append the trailing verb phrase.
+ */
+export declare const formatQuotedNameList: (names: string[]) => string;
+/** New location — and, when the import renamed it, new display name — for an imported attachment. */
+export interface RewrittenAttachmentTarget {
+    /** New `files/{bucket}/{path}` id to write into `url`/`reference_url`. */
+    url: string;
+    /** New display name — present only when a ` (n)` disambiguation suffix was applied. */
+    title?: string;
+}
+/**
+ * Rewrites every attachment reference a message carries — its own
+ * `custom_content.attachments`, the attachments of each execution stage, and
+ * the source document of each citation — from an old file id to its new
+ * uploaded location, and its `title` when the target carries a renamed one.
+ * References not present in `targetMap` are left untouched (immutable —
+ * returns a new conversation).
+ */
+export declare const rewriteAttachmentUrls: (conversation: Conversation, targetMap: Map<string, RewrittenAttachmentTarget>) => Conversation;
+/**
+ * Removes every attachment reference that still points into another user's
+ * bucket once the import has re-pointed what it could.
+ *
+ * A plain `.json` export carries no attachment bytes, and an archive can miss
+ * some, so those references keep the exporting user's `files/{bucket}/…` ids.
+ * Written back verbatim, they leave the importing user with previews that
+ * fail with 403. Own-bucket references are kept — they are the
+ * user's own files on a re-import — and so are public ones. A file another
+ * user shared with the importing user is dropped too: nothing here can tell
+ * it apart from one they never had access to.
+ *
+ * Returns the conversation (unchanged when nothing was foreign) and the name
+ * of every dropped file, for the skipped-attachment warning.
+ */
+export declare const dropForeignAttachmentRefs: (conversation: Conversation, bucket: string) => {
+    conversation: Conversation;
+    droppedNames: string[];
+};
+/** One attachment reference planned for upload, with its collision-free destination already allocated. */
+export interface PlannedAttachmentUpload {
+    /** Original DIAL file id this attachment is uploaded from — the key `rewriteAttachmentUrls` rewrites. */
+    fileId: string;
+    /** Raw bytes read from the archive. */
+    bytes: Uint8Array;
+    /** Basename a 409 retry re-derives its next attempt from (never the already-suffixed name). */
+    originalFileName: string;
+    /** Destination allocated for the first upload attempt. */
+    allocated: AllocatedUploadPath;
+}
+/**
+ * Resolves a conversation's unique attachment references to archive bytes
+ * and allocates each a collision-free upload destination, in
+ * `collectAttachmentRefs` order — a synchronous pre-pass so suffix
+ * assignment stays deterministic regardless of later upload concurrency.
+ * A reference that cannot be resolved to a `{bucket, path}` pair, or has no
+ * matching bytes in the archive, is reported in `skippedNames` and does not
+ * consume an allocator slot.
+ */
+export declare const planAttachmentUploads: (conversation: Conversation, attachmentBytes: Map<string, Uint8Array>, allocator: UploadPathAllocator) => {
+    plan: PlannedAttachmentUpload[];
+    skippedNames: string[];
+};
+//# sourceMappingURL=import-conversation.d.ts.map

package/conversation/conversation-transfer/import-conversation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-conversation.d.ts","sourceRoot":"","sources":["../../../src/conversation/conversation-transfer/import-conversation.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAEV,YAAY,EAEZ,YAAY,EAGb,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EACV,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,qBAAqB,CAAC;AAG7B,oFAAoF;AACpF,qBAAa,4BAA6B,SAAQ,KAAK;gBACzC,OAAO,EAAE,MAAM;CAI5B;AAOD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,MAAM,MAAM,KAAG,YA2BlD,CAAC;AAgGF,MAAM,WAAW,qBAAqB;IACpC,wGAAwG;IACxG,YAAY,EAAE,YAAY,CAAC;IAC3B,0DAA0D;IAC1D,OAAO,EAAE,MAAM,CAAC;CACjB;AAgBD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,GAC/B,cAAc,YAAY,EAC1B,QAAQ,MAAM,KACb,qBAmDF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAC9B,cAAc,YAAY,KACzB,MAAM,GAAG,SAMX,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,MAAM,EAAE,KAAG,MACV,CAAC;AAE9C,qGAAqG;AACrG,MAAM,WAAW,yBAAyB;IACxC,0EAA0E;IAC1E,GAAG,EAAE,MAAM,CAAC;IACZ,uFAAuF;IACvF,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAoFD;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,GAChC,cAAc,YAAY,EAC1B,WAAW,GAAG,CAAC,MAAM,EAAE,yBAAyB,CAAC,KAChD,YA8BD,CAAC;AAmEH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,yBAAyB,GACpC,cAAc,YAAY,EAC1B,QAAQ,MAAM,KACb;IAAE,YAAY,EAAE,YAAY,CAAC;IAAC,YAAY,EAAE,MAAM,EAAE,CAAA;CAwDtD,CAAC;AAMF,0GAA0G;AAC1G,MAAM,WAAW,uBAAuB;IACtC,yGAAyG;IACzG,MAAM,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,KAAK,EAAE,UAAU,CAAC;IAClB,+FAA+F;IAC/F,gBAAgB,EAAE,MAAM,CAAC;IACzB,0DAA0D;IAC1D,SAAS,EAAE,mBAAmB,CAAC;CAChC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,GAChC,cAAc,YAAY,EAC1B,iBAAiB,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,EACxC,WAAW,mBAAmB,KAC7B;IAAE,IAAI,EAAE,uBAAuB,EAAE,CAAC;IAAC,YAAY,EAAE,MAAM,EAAE,CAAA;CA2B3D,CAAC"}

package/conversation/conversation-transfer/progress.d.ts

@@ -0,0 +1,60 @@
+import { ConversationTransferProgress, ConversationTransferProgressUnits } from '@epam/ai-dial-chat-shared';
+/**
+ * The three stages every transfer job moves through. `Transfer` is the only
+ * one whose work is subdivided, because its unit count is discovered rather
+ * than known at enqueue time.
+ */
+export declare enum ConversationTransferPhase {
+    /** Fetching the conversation, listing conversations, or parsing the import file. */
+    Prepare = "prepare",
+    /** Downloading or uploading the discovered units. */
+    Transfer = "transfer",
+    /** Serializing, building the archive, or saving the conversations. */
+    Finalize = "finalize"
+}
+/** Which weight table a job uses. */
+export declare enum ConversationTransferKind {
+    ExportSingle = "exportSingle",
+    ExportSingleWithAttachments = "exportSingleWithAttachments",
+    ExportAll = "exportAll",
+    Import = "import"
+}
+/** Share of a job's 100 percentage points that each phase is worth. */
+interface PhaseWeights {
+    [ConversationTransferPhase.Prepare]: number;
+    [ConversationTransferPhase.Transfer]: number;
+    [ConversationTransferPhase.Finalize]: number;
+}
+/**
+ * Per-kind phase weights, each summing to 100. Fixed rather than derived from
+ * the unit count so that discovering how many attachments a job has subdivides
+ * work still to do instead of moving the indicator backwards.
+ */
+export declare const TRANSFER_PHASE_WEIGHTS: Record<ConversationTransferKind, PhaseWeights>;
+/** Percentage a fully settled job reports. */
+export declare const TRANSFER_PROGRESS_COMPLETE = 100;
+/** Arguments for {@link computeTransferPercent}. */
+export interface ComputeTransferPercentParams {
+    /** Which weight table applies. */
+    kind: ConversationTransferKind;
+    /** The phase currently advancing. */
+    phase: ConversationTransferPhase;
+    /**
+     * Units settled within `phase`. Omit (or pass `total: 0`) for a phase whose
+     * work is not subdivided; its whole weight is then credited at once.
+     */
+    completed?: number;
+    /** Units `phase` will settle in total. */
+    total?: number;
+}
+/**
+ * Returns the job's completion as an integer 0–100: every earlier phase's
+ * weight in full, plus `phase`'s weight scaled by `completed / total`. A phase
+ * with no units to settle is credited in full, so a conversation with no
+ * attachments never stalls at the start of the transfer phase.
+ */
+export declare const computeTransferPercent: ({ kind, phase, completed, total, }: ComputeTransferPercentParams) => number;
+/** Builds the progress patch for a phase, carrying its unit readout when the phase has units. */
+export declare const buildTransferProgress: (params: ComputeTransferPercentParams, units?: ConversationTransferProgressUnits) => ConversationTransferProgress;
+export {};
+//# sourceMappingURL=progress.d.ts.map

package/conversation/conversation-transfer/progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress.d.ts","sourceRoot":"","sources":["../../../src/conversation/conversation-transfer/progress.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,4BAA4B,EAC5B,iCAAiC,EAClC,MAAM,2BAA2B,CAAC;AAEnC;;;;GAIG;AACH,oBAAY,yBAAyB;IACnC,oFAAoF;IACpF,OAAO,YAAY;IACnB,qDAAqD;IACrD,QAAQ,aAAa;IACrB,sEAAsE;IACtE,QAAQ,aAAa;CACtB;AAED,qCAAqC;AACrC,oBAAY,wBAAwB;IAClC,YAAY,iBAAiB;IAC7B,2BAA2B,gCAAgC;IAC3D,SAAS,cAAc;IACvB,MAAM,WAAW;CAClB;AAED,uEAAuE;AACvE,UAAU,YAAY;IACpB,CAAC,yBAAyB,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC5C,CAAC,yBAAyB,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC7C,CAAC,yBAAyB,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC9C;AAED;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CACzC,wBAAwB,EACxB,YAAY,CAsBb,CAAC;AAEF,8CAA8C;AAC9C,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAkB9C,oDAAoD;AACpD,MAAM,WAAW,4BAA4B;IAC3C,kCAAkC;IAClC,IAAI,EAAE,wBAAwB,CAAC;IAC/B,qCAAqC;IACrC,KAAK,EAAE,yBAAyB,CAAC;IACjC;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0CAA0C;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,GAAI,oCAKpC,4BAA4B,KAAG,MAOjC,CAAC;AAEF,iGAAiG;AACjG,eAAO,MAAM,qBAAqB,GAChC,QAAQ,4BAA4B,EACpC,QAAQ,iCAAiC,KACxC,4BAGD,CAAC"}

package/conversation/conversation-transfer/queue.d.ts

@@ -0,0 +1,54 @@
+import { ConversationTransferErrorCode, ConversationTransferJob, ConversationTransferProgress, ConversationTransferSubject, ConversationTransferWarningCode } from '@epam/ai-dial-chat-shared';
+/** Shared job-queue primitive underlying both `useConversationExport` and `useConversationImport`. */
+export interface ConversationTransferQueue {
+    /** Queued jobs, most recently added last. */
+    jobs: ConversationTransferJob[];
+    /** Adds a new `InProgress` job for `subject`, named `fileName`, at 0% and returns its id. */
+    addJob: (subject: ConversationTransferSubject, fileName: string) => string;
+    /** Merges `patch` into the job identified by `jobId`. */
+    updateJob: (jobId: string, patch: Partial<ConversationTransferJob>) => void;
+    /**
+     * Advances the job's progress. A write whose `percent` is lower than the
+     * stored value is discarded, so out-of-order completions from concurrent
+     * transfers cannot move the indicator backwards, and a write to a job that
+     * has already settled is ignored, so an aborted run unwinding in the
+     * background cannot advance a canceled or failed row.
+     */
+    setJobProgress: (jobId: string, progress: ConversationTransferProgress) => void;
+    /** Marks the job `Success` at 100%. */
+    succeedJob: (jobId: string) => void;
+    /**
+     * Marks the job `Warning` at 100%, recording what was incomplete. The file
+     * was still delivered, so this settles the job exactly as `succeedJob` does
+     * apart from the status and the attached code and optional file names.
+     */
+    warnJob: (jobId: string, warningCode: ConversationTransferWarningCode, warningNames?: string[]) => void;
+    /** Marks the job `Failed`, recording why. Progress freezes where it stopped. */
+    failJob: (jobId: string, errorCode: ConversationTransferErrorCode) => void;
+    /**
+     * Aborts the job's in-flight request(s) and marks it `Canceled`, keeping the
+     * row so the user has a record of what they stopped. The job stays retryable.
+     */
+    cancelJob: (jobId: string) => void;
+    /** Aborts the job's in-flight request (if any) and removes it from `jobs`. */
+    dismissJob: (jobId: string) => void;
+    /** Re-invokes the job's registered run function under a fresh `AbortController`. */
+    retryJob: (jobId: string) => void;
+    /** Aborts every in-flight job and clears the queue. */
+    dismissAll: () => void;
+    /**
+     * Runs `run` under a fresh `AbortController` registered for `jobId`, and
+     * registers the same `run` function to be re-invoked (under a new
+     * controller) on `retryJob`.
+     */
+    startJob: (jobId: string, run: (signal: AbortSignal) => Promise<void>) => Promise<void>;
+}
+/**
+ * Owns the export/import job queue: job list state, per-job
+ * `AbortController` tracking, monotonic progress, retry-function
+ * registration, and unmount cleanup. Shared by `useConversationExport` and
+ * `useConversationImport` so both hooks have identical cancellation,
+ * retry, and dismissal semantics.
+ */
+export declare const useConversationTransferQueue: () => ConversationTransferQueue;
+//# sourceMappingURL=queue.d.ts.map

package/conversation/conversation-transfer/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../../src/conversation/conversation-transfer/queue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,6BAA6B,EAClC,KAAK,uBAAuB,EAE5B,KAAK,4BAA4B,EACjC,KAAK,2BAA2B,EAChC,KAAK,+BAA+B,EAErC,MAAM,2BAA2B,CAAC;AAInC,sGAAsG;AACtG,MAAM,WAAW,yBAAyB;IACxC,6CAA6C;IAC7C,IAAI,EAAE,uBAAuB,EAAE,CAAC;IAChC,6FAA6F;IAC7F,MAAM,EAAE,CAAC,OAAO,EAAE,2BAA2B,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;IAC3E,yDAAyD;IACzD,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,uBAAuB,CAAC,KAAK,IAAI,CAAC;IAC5E;;;;;;OAMG;IACH,cAAc,EAAE,CACd,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,4BAA4B,KACnC,IAAI,CAAC;IACV,uCAAuC;IACvC,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC;;;;OAIG;IACH,OAAO,EAAE,CACP,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,+BAA+B,EAC5C,YAAY,CAAC,EAAE,MAAM,EAAE,KACpB,IAAI,CAAC;IACV,gFAAgF;IAChF,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,6BAA6B,KAAK,IAAI,CAAC;IAC3E;;;OAGG;IACH,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,8EAA8E;IAC9E,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,oFAAoF;IACpF,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,uDAAuD;IACvD,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB;;;;OAIG;IACH,QAAQ,EAAE,CACR,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,KACxC,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,QAAO,yBAkL/C,CAAC"}

package/conversation/conversation-transfer/types.d.ts

@@ -0,0 +1,36 @@
+import { ConversationTransferErrorCode, ConversationTransferWarningCode } from '@epam/ai-dial-chat-shared';
+/** Whether an export includes the conversation's attachments. */
+export declare enum ConversationExportMode {
+    WithAttachments = "withAttachments",
+    WithoutAttachments = "withoutAttachments"
+}
+/** Which export file was produced, used to derive its file name/extension. */
+export declare enum ExportFileNameKind {
+    SingleConversation = "chat_conversation",
+    SingleConversationWithAttachments = "chat_with_attachments",
+    AllConversationsHistory = "chat_conversations_history"
+}
+/** Structured, translation-free error report for a transfer job. */
+export interface ConversationTransferErrorEvent {
+    jobId: string;
+    code: ConversationTransferErrorCode;
+    /** Conversation title(s) relevant to the error, when applicable. */
+    titles?: string[];
+    /** Resolved trace id for the failing request, when the host's `resolveErrorTraceId` supplies one. */
+    traceId?: string;
+}
+export { ConversationTransferErrorCode, ConversationTransferWarningCode };
+/** Structured, translation-free warning report for a transfer job. */
+export interface ConversationTransferWarningEvent {
+    jobId: string;
+    code: ConversationTransferWarningCode;
+    /** Names relevant to the warning (e.g. skipped attachment file names). */
+    names?: string[];
+}
+/** Structured, translation-free success report for a transfer job. */
+export interface ConversationTransferSuccessEvent {
+    jobId: string;
+    /** Conversation title(s) affected, when applicable. */
+    titles?: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/conversation/conversation-transfer/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/conversation/conversation-transfer/types.ts"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,oBAAY,sBAAsB;IAChC,eAAe,oBAAoB;IACnC,kBAAkB,uBAAuB;CAC1C;AAED,OAAO,EACL,6BAA6B,EAC7B,+BAA+B,EAChC,MAAM,2BAA2B,CAAC;AAEnC,8EAA8E;AAC9E,oBAAY,kBAAkB;IAC5B,kBAAkB,sBAAsB;IACxC,iCAAiC,0BAA0B;IAC3D,uBAAuB,+BAA+B;CACvD;AAED,oEAAoE;AACpE,MAAM,WAAW,8BAA8B;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,6BAA6B,CAAC;IACpC,oEAAoE;IACpE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,qGAAqG;IACrG,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAQD,OAAO,EAAE,6BAA6B,EAAE,+BAA+B,EAAE,CAAC;AAE1E,sEAAsE;AACtE,MAAM,WAAW,gCAAgC;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,+BAA+B,CAAC;IACtC,0EAA0E;IAC1E,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,sEAAsE;AACtE,MAAM,WAAW,gCAAgC;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB"}

package/conversation/conversation-transfer/zip-export.d.ts

@@ -0,0 +1,31 @@
+import { ExportFormat } from '@epam/ai-dial-chat-shared';
+/**
+ * Validates an attachment path before it is written into (or read from) a
+ * `.dial` archive. Blocks path traversal and absolute paths by rejecting
+ * empty, `.`, or `..` path segments (so `../../etc/passwd` and `/etc/passwd`
+ * are both rejected). No character allowlist — real-world filenames
+ * routinely contain spaces, parentheses, and non-ASCII characters, and any
+ * character that would be unsafe in the eventual upload URL is already
+ * percent-encoded downstream by `buildUploadPath`.
+ */
+export declare const isValidArchivePath: (path: string) => boolean;
+/** A single attachment already fetched into memory, ready to be written into the archive. */
+export interface ZipAttachmentEntry {
+    /** Relative path under which the attachment is stored, e.g. `reports/q1.pdf`. */
+    path: string;
+    /** Attachment content. */
+    data: Uint8Array;
+}
+export interface BuildDialArchiveResult {
+    /** The built `.dial` archive. */
+    blob: Blob;
+    /** Attachment paths that failed validation and were not written to the archive. */
+    skippedPaths: string[];
+}
+/**
+ * Builds a `.dial` ZIP archive containing the conversation export envelope
+ * plus every valid attachment, laid out under `res/<path>`. Attachments
+ * failing the path allowlist are skipped and reported in `skippedPaths`.
+ */
+export declare const buildDialArchive: (envelope: ExportFormat, attachments: ZipAttachmentEntry[]) => BuildDialArchiveResult;
+//# sourceMappingURL=zip-export.d.ts.map

package/conversation/conversation-transfer/zip-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-export.d.ts","sourceRoot":"","sources":["../../../src/conversation/conversation-transfer/zip-export.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAY9D;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,KAAG,OAI4B,CAAC;AAE/E,6FAA6F;AAC7F,MAAM,WAAW,kBAAkB;IACjC,iFAAiF;IACjF,IAAI,EAAE,MAAM,CAAC;IACb,0BAA0B;IAC1B,IAAI,EAAE,UAAU,CAAC;CAClB;AAED,MAAM,WAAW,sBAAsB;IACrC,iCAAiC;IACjC,IAAI,EAAE,IAAI,CAAC;IACX,mFAAmF;IACnF,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAC3B,UAAU,YAAY,EACtB,aAAa,kBAAkB,EAAE,KAChC,sBAqBF,CAAC"}

package/conversation/conversation-transfer/zip-import.d.ts

@@ -0,0 +1,17 @@
+import { ExportFormat } from '@epam/ai-dial-chat-shared';
+export interface ParsedDialArchive {
+    /** The parsed and validated export envelope. */
+    envelope: ExportFormat;
+    /** Attachment bytes keyed by their bucket-relative path (the `res/<path>` suffix). */
+    attachments: Map<string, Uint8Array>;
+}
+/**
+ * Parses a `.dial`/`.zip` archive produced by either the new-chat export
+ * (`conversation.json` at the archive root) or the old (`development`
+ * branch) export (`conversations/<name>.json`) — the JSON entry name is
+ * detected tolerantly by its archive path, since both old-chat and new-chat
+ * archives write the same `version: 5` envelope. Attachment bytes are
+ * collected from `res/<path>` entries, keyed by their validated relative path.
+ */
+export declare const parseDialArchive: (file: File) => Promise<ParsedDialArchive>;
+//# sourceMappingURL=zip-import.d.ts.map

package/conversation/conversation-transfer/zip-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-import.d.ts","sourceRoot":"","sources":["../../../src/conversation/conversation-transfer/zip-import.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAe9D,MAAM,WAAW,iBAAiB;IAChC,gDAAgD;IAChD,QAAQ,EAAE,YAAY,CAAC;IACvB,sFAAsF;IACtF,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACtC;AAqBD;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAC3B,MAAM,IAAI,KACT,OAAO,CAAC,iBAAiB,CAiC3B,CAAC"}