@adecore/agents-react 0.37.2 → 0.37.3

package/dist/chat/chat-client.d.ts

@@ -16,6 +16,7 @@ export interface ChatSendExtras {
     chats?: string[];
     quoteSource?: ChatQuoteSource;
     attachments?: ChatAttachmentUpload[];
+    references?: string[];
 }
 interface ProviderSink {
     setProviders(providers: ProviderInfo[]): void;

package/dist/chat/chat-client.js

@@ -184,7 +184,8 @@ export class ChatClient {
       skills: extras.skills,
       chats: extras.chats,
       quoteSource: extras.quoteSource,
-      attachments: extras.attachments
+      attachments: extras.attachments,
+      references: extras.references
     });
   }
   /* Marks a message; the list every client of the chat holds comes back as `chat.bookmarks`. */

package/dist/chat/chat-references.d.ts

@@ -1,5 +1,20 @@
+import type { ReferenceToken } from './mentions.js';
 export interface ProjectChat {
     id: string;
     title: string;
 }
-export declare function chatSuggestions(chats: readonly ProjectChat[], query: string, exclude: readonly string[], limit: number): ProjectChat[];
+export type ReferableKind = 'canvas' | 'chat' | 'terminal' | 'note' | 'text' | 'drawing' | 'diagram' | 'browser' | 'device' | 'file' | 'database';
+export interface Referable {
+    id: string;
+    name: string;
+    kind: ReferableKind;
+    detail?: string;
+    group: 'canvas' | 'views';
+}
+export interface Referables {
+    items: readonly Referable[];
+    chatsOnly: boolean;
+}
+export declare function referablesOfChats(chats: readonly ProjectChat[]): Referables;
+export declare function referenceTokens(ids: readonly string[], items: readonly Referable[], spelled?: Readonly<Record<string, string>>): ReferenceToken[];
+export declare function referenceSuggestions(referables: Referables, query: string, exclude: readonly string[], limit: number): Referable[];

package/dist/chat/chat-references.js

@@ -1,5 +1,31 @@
-/* The chats an `@query` offers: never the chat typing it or one already attached. */
-export function chatSuggestions(chats, query, exclude, limit) {
+/* What a host without views offers: its chats, which every machine takes. */
+export function referablesOfChats(chats) {
+  return {
+    items: chats.map(chat => ({
+      id: chat.id,
+      name: chat.title,
+      kind: 'chat',
+      group: 'views'
+    })),
+    chatsOnly: true
+  };
+}
+/*
+ * How each id is spelled in a text: under the name it was picked with where `spelled` knows it, else
+ * under the name it has now. An id with neither has no token.
+ */
+export function referenceTokens(ids, items, spelled = {}) {
+  return [...new Set(ids)].flatMap(id => {
+    const name = spelled[id] ?? items.find(item => item.id === id)?.name;
+    return name === undefined || name === '' ? [] : [{
+      id,
+      name
+    }];
+  });
+}
+/* What a `#query` offers, the canvas first: never an id in `exclude`, and only chats where the machine takes no more. */
+export function referenceSuggestions(referables, query, exclude, limit) {
   const needle = query.toLowerCase();
-  return chats.filter(chat => !exclude.includes(chat.id) && chat.title.toLowerCase().includes(needle)).slice(0, limit);
+  const matches = referables.items.filter(item => item.name !== '' && (!referables.chatsOnly || item.kind === 'chat') && !exclude.includes(item.id) && item.name.toLowerCase().includes(needle));
+  return [...matches.filter(item => item.group === 'canvas'), ...matches.filter(item => item.group === 'views')].slice(0, limit);
 }

package/dist/chat/drafts.d.ts

@@ -7,6 +7,8 @@ export interface ChatDraft {
     attachments: ChatAttachmentUpload[];
     quote: string;
     quoteSource: string | null;
+    references: string[];
+    referenceNames?: Record<string, string>;
 }
 export declare const EMPTY_DRAFT: ChatDraft;
 export declare function isEmptyDraft(draft: ChatDraft): boolean;

package/dist/chat/drafts.js

@@ -10,7 +10,8 @@ export const EMPTY_DRAFT = {
   chats: [],
   attachments: [],
   quote: '',
-  quoteSource: null
+  quoteSource: null,
+  references: []
 };
 const storage = persistedJson(storageKey, raw => raw ? JSON.parse(raw) : {}, {}, () => chatStorageLegacyKeys('drafts'));
 export function isEmptyDraft(draft) {
@@ -58,7 +59,11 @@ export function readDraft(chatId) {
     chats: record.chats ?? [],
     attachments: record.attachments ?? [],
     quote: record.quote ?? '',
-    quoteSource: record.quoteSource ?? null
+    quoteSource: record.quoteSource ?? null,
+    references: record.references ?? [],
+    ...(record.referenceNames === undefined ? {} : {
+      referenceNames: record.referenceNames
+    })
   } : EMPTY_DRAFT;
 }
 export function writeDraft(chatId, draft) {
@@ -78,7 +83,9 @@ export function writeDraft(chatId, draft) {
     quote: draft.quote,
     ...(draft.quoteSource === null ? {} : {
       quoteSource: draft.quoteSource
-    })
+    }),
+    references: draft.references,
+    ...namesOf(draft)
   };
   if (storage.write(drafts)) {
     return;
@@ -92,10 +99,17 @@ export function writeDraft(chatId, draft) {
     quote: draft.quote,
     ...(draft.quoteSource === null ? {} : {
       quoteSource: draft.quoteSource
-    })
+    }),
+    references: draft.references,
+    ...namesOf(draft)
   };
   storage.write(drafts);
 }
+function namesOf(draft) {
+  return draft.referenceNames === undefined ? {} : {
+    referenceNames: draft.referenceNames
+  };
+}
 /* Text handed to a draft from outside the composer goes under what was already typed, never over it. */
 export function joinDraftText(current, added) {
   return current.trim() === '' ? added : `${current.replace(/\s+$/, '')}\n\n${added}`;
@@ -123,7 +137,9 @@ export function takeBackIntoDraft(current, taken) {
       chats: union(taken.chats, current.chats),
       attachments: [...checked.accepted.map(entry => entry.upload), ...current.attachments],
       quote: current.quote,
-      quoteSource: current.quoteSource
+      quoteSource: current.quoteSource,
+      references: union(taken.references, current.references),
+      ...namesOf(current)
     },
     rejected: checked.rejected
   };

package/dist/chat/index.d.ts

@@ -1,7 +1,7 @@
 export { type AccountChoice, useAccountChoice, type NewAccountChoice, useNewAccountChoice } from './account-choice.js';
 export { transportActions, actionsOf, useChatActions } from './actions.js';
 export { type ChatSendExtras, ChatClient } from './chat-client.js';
-export type { ProjectChat } from './chat-references.js';
+export type { ProjectChat, Referable, ReferableKind, Referables } from './chat-references.js';
 export { sendFromComposer, type ComposerSend } from './composer-send.js';
 export { stepEffortFromComposer } from './composer-effort.js';
 export type { EffortStep } from './logic/effort.js';

package/dist/chat/mentions.d.ts

@@ -4,10 +4,25 @@ export declare const MENTION_DRAG_TYPES: readonly ["application/x-adecore-mentio
 export declare function carriesMentions(types: readonly string[]): boolean;
 export declare function droppedMentions(data: Pick<DataTransfer, 'getData'>): string[];
 export declare function writeMentionDrag(data: Pick<DataTransfer, 'setData'>, paths: readonly string[], legacy?: boolean): void;
+export declare const CHIPS_CLIPBOARD_TYPE = "application/x-adecore-chips";
+export interface ClipboardChips {
+    text: string;
+    mentions: string[];
+    skills: string[];
+    references: ReferenceToken[];
+}
+export declare function clipboardChipsOf(text: string, segments: readonly ChipSegment[]): ClipboardChips;
+export declare function hasClipboardChips(chips: ClipboardChips): boolean;
+export declare function writeClipboardChips(data: Pick<DataTransfer, 'setData'>, chips: ClipboardChips): void;
+export declare function readClipboardChips(data: Pick<DataTransfer, 'getData'>): ClipboardChips | null;
 export interface MentionQuery {
     start: number;
     query: string;
 }
+export interface ReferenceToken {
+    id: string;
+    name: string;
+}
 export type ChipSegment = {
     kind: 'text';
     text: string;
@@ -17,22 +32,28 @@ export type ChipSegment = {
 } | {
     kind: 'skill';
     name: string;
+} | {
+    kind: 'reference';
+    id: string;
+    name: string;
 };
+export declare function queryOutsideChips(query: MentionQuery | null, chips: readonly ChipRange[]): MentionQuery | null;
 export declare function findMentionQuery(text: string, caret: number): MentionQuery | null;
 export declare function findSkillQuery(text: string, caret: number): MentionQuery | null;
+export declare function findReferenceQuery(text: string, caret: number): MentionQuery | null;
 export declare function insertToken(text: string, query: MentionQuery, sigil: string, value: string): {
     text: string;
     caret: number;
 };
-export declare function dropQuery(text: string, query: MentionQuery): {
+export declare function insertMention(text: string, query: MentionQuery, path: string): {
     text: string;
     caret: number;
 };
-export declare function insertMention(text: string, query: MentionQuery, path: string): {
+export declare function insertSkill(text: string, query: MentionQuery, name: string): {
     text: string;
     caret: number;
 };
-export declare function insertSkill(text: string, query: MentionQuery, name: string): {
+export declare function insertReference(text: string, query: MentionQuery, name: string): {
     text: string;
     caret: number;
 };
@@ -41,16 +62,10 @@ export interface MentionSearch {
     files: string[];
 }
 export declare const NO_MENTION_SEARCH: MentionSearch;
-export type MentionPick<T> = {
-    kind: 'chat';
-    chat: T;
-} | {
-    kind: 'file';
-    path: string;
-};
-export declare function mentionPick<T>(index: number, chats: readonly T[], search: MentionSearch, query: string): MentionPick<T> | null;
+export declare function mentionPick(index: number, search: MentionSearch, query: string): string | null;
 export declare function presentMentions(text: string, chosen: string[]): string[];
 export declare function presentSkills(text: string, chosen: string[]): string[];
+export declare function presentReferences(text: string, ids: readonly string[], tokens: readonly ReferenceToken[]): string[];
 export declare function chipText(segment: ChipSegment): string;
 export declare function pastedMentions(text: string): string[];
 export interface TextRange {
@@ -58,8 +73,10 @@ export interface TextRange {
     to: number;
 }
 export interface ChipRange extends TextRange {
-    kind: 'mention' | 'skill';
+    kind: 'mention' | 'skill' | 'reference';
     value: string;
 }
-export declare function chipRanges(text: string, mentions: string[], skills?: string[], excluded?: readonly TextRange[]): ChipRange[];
-export declare function tokenizeChips(text: string, mentions: string[], skills?: string[]): ChipSegment[];
+export declare function chipRanges(text: string, mentions: string[], skills?: string[], excluded?: readonly TextRange[], references?: readonly ReferenceToken[]): ChipRange[];
+export declare function tokenizeChips(text: string, mentions: string[], skills?: string[], references?: readonly ReferenceToken[]): ChipSegment[];
+export declare function namedReferenceRanges(text: string, items: readonly ReferenceToken[], referenced?: readonly string[], excluded?: readonly TextRange[]): ChipRange[];
+export declare function tokenizeNamedReferences(text: string, items: readonly ReferenceToken[], referenced?: readonly string[]): ChipSegment[];

package/dist/chat/mentions.js

@@ -19,17 +19,91 @@ export function writeMentionDrag(data, paths, legacy = true) {
     data.setData(LEGACY_MENTION_DRAG_TYPE, text);
   }
 }
+/* Beside the plain text of a copy from a thread or a composer: the chips in it, so a paste makes them chips again. */
+export const CHIPS_CLIPBOARD_TYPE = 'application/x-adecore-chips';
+/* The chips among `segments`, without doubles, for the copy of `text`. */
+export function clipboardChipsOf(text, segments) {
+  const chips = {
+    text,
+    mentions: [],
+    skills: [],
+    references: []
+  };
+  for (const segment of segments) {
+    if (segment.kind === 'mention' && !chips.mentions.includes(segment.path)) {
+      chips.mentions.push(segment.path);
+    } else if (segment.kind === 'skill' && !chips.skills.includes(segment.name)) {
+      chips.skills.push(segment.name);
+    } else if (segment.kind === 'reference' && !chips.references.some(token => token.id === segment.id)) {
+      chips.references.push({
+        id: segment.id,
+        name: segment.name
+      });
+    }
+  }
+  return chips;
+}
+export function hasClipboardChips(chips) {
+  return chips.mentions.length > 0 || chips.skills.length > 0 || chips.references.length > 0;
+}
+export function writeClipboardChips(data, chips) {
+  data.setData('text/plain', chips.text);
+  data.setData(CHIPS_CLIPBOARD_TYPE, JSON.stringify(chips));
+}
+const lines = text => text.replace(/\r\n/g, '\n');
+const isStrings = value => Array.isArray(value) && value.every(entry => typeof entry === 'string');
+/* The chips of a paste, or null when it has none or its plain text is no longer the text they were copied with. */
+export function readClipboardChips(data) {
+  const raw = data.getData(CHIPS_CLIPBOARD_TYPE);
+  if (raw === '') {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== 'object' || parsed === null) {
+    return null;
+  }
+  const {
+    text,
+    mentions,
+    skills,
+    references
+  } = parsed;
+  const tokens = Array.isArray(references) ? references.filter(token => typeof token === 'object' && token !== null && typeof token.id === 'string' && typeof token.name === 'string' && token.name !== '') : [];
+  if (typeof text !== 'string' || lines(text) !== lines(data.getData('text/plain')) || !isStrings(mentions) || !isStrings(skills)) {
+    return null;
+  }
+  return {
+    text: lines(text),
+    mentions,
+    skills,
+    references: tokens.map(({
+      id,
+      name
+    }) => ({
+      id,
+      name
+    }))
+  };
+}
 function isBoundary(char) {
   return char === undefined || /\s/.test(char);
 }
+const TOKEN_END = /[.,;:!?)\]}"'”’]/;
 // A path at the end of a sentence still counts, so "open @a.ts." is a mention of a.ts.
 function isTokenEnd(char) {
-  return isBoundary(char) || /[.,;:!?)]/.test(char);
+  return isBoundary(char) || TOKEN_END.test(char);
 }
+// A path goes on after a dot or a colon (`a.ts`, `C:`), so only the rest ends a file query.
+const PATH_GOES_ON = /[.:]$/;
 /*
  * The `<sigil>word` the caret sits in, if any. The sigil has to open a word (start of text or after
- * whitespace) so an email address never opens the picker, and the word may not have been
- * closed with whitespace yet.
+ * whitespace) so an email address never opens the picker, and the word may not have been closed
+ * with whitespace or the punctuation that ends a token (`#Admin?`) yet.
  */
 function findQuery(text, caret, sigil) {
   const before = text.slice(0, caret);
@@ -41,11 +115,18 @@ function findQuery(text, caret, sigil) {
   if (/\s/.test(query) || !isBoundary(text[caret])) {
     return null;
   }
+  if (query !== '' && isTokenEnd(query.at(-1)) && !(sigil === '@' && PATH_GOES_ON.test(query))) {
+    return null;
+  }
   return {
     start: at,
     query
   };
 }
+/* The query, unless its sigil opens a token that is already a chip, which the picker has nothing to add to. */
+export function queryOutsideChips(query, chips) {
+  return query !== null && chips.some(chip => chip.from === query.start) ? null : query;
+}
 export function findMentionQuery(text, caret) {
   return findQuery(text, caret, '@');
 }
@@ -54,6 +135,14 @@ export function findSkillQuery(text, caret) {
   const found = findQuery(text, caret, '$');
   return found === null || found.query !== '' && !/^[A-Za-z]/.test(found.query) ? null : found;
 }
+/*
+ * The `#word` the caret sits in. It opens only once a letter follows the sigil, so a `# ` heading,
+ * `#123` and a bare `#` stay text. A name with a space is found by its first word.
+ */
+export function findReferenceQuery(text, caret) {
+  const found = findQuery(text, caret, '#');
+  return found === null || !/^\p{L}/u.test(found.query) ? null : found;
+}
 /* Replaces the `<sigil>query` under the caret with the chosen token and a space, and says where the caret goes. */
 export function insertToken(text, query, sigil, value) {
   const end = query.start + 1 + query.query.length;
@@ -63,40 +152,25 @@ export function insertToken(text, query, sigil, value) {
     caret: query.start + token.length
   };
 }
-/* Takes the `<sigil>query` under the caret out, for a pick that lands beside the text instead of in it. */
-export function dropQuery(text, query) {
-  return {
-    text: `${text.slice(0, query.start)}${text.slice(query.start + 1 + query.query.length)}`,
-    caret: query.start
-  };
-}
 export function insertMention(text, query, path) {
   return insertToken(text, query, '@', path);
 }
 export function insertSkill(text, query, name) {
   return insertToken(text, query, '$', name);
 }
+export function insertReference(text, query, name) {
+  return insertToken(text, query, '#', name);
+}
 export const NO_MENTION_SEARCH = {
   query: null,
   files: []
 };
-/* What Enter or Tab takes from the `@` list at `index`. Files still on screen from an older query are never taken. */
-export function mentionPick(index, chats, search, query) {
-  const chat = chats[index];
-  if (chat !== undefined) {
-    return {
-      kind: 'chat',
-      chat
-    };
-  }
+/* The path Enter or Tab takes from the `@` list at `index`. Files still on screen from an older query are never taken. */
+export function mentionPick(index, search, query) {
   if (search.query !== query) {
     return null;
   }
-  const path = search.files[index - chats.length] ?? search.files[0];
-  return path === undefined ? null : {
-    kind: 'file',
-    path
-  };
+  return search.files[index] ?? search.files[0] ?? null;
 }
 function findToken(text, sigil, value, from) {
   const token = `${sigil}${value}`;
@@ -130,6 +204,11 @@ export function presentMentions(text, chosen) {
 export function presentSkills(text, chosen) {
   return present(text, '$', chosen);
 }
+/* The ids among `ids` whose `#name` still sits in the text as a whole token, in text order and without doubles. */
+export function presentReferences(text, ids, tokens) {
+  const wanted = new Set(ids);
+  return chipRanges(text, [], [], [], tokens).map(range => range.value).filter((id, index, found) => wanted.has(id) && found.indexOf(id) === index);
+}
 /* The characters a segment stands for, sigil included; joined, the segments spell the text they were cut from. */
 export function chipText(segment) {
   if (segment.kind === 'mention') {
@@ -138,6 +217,9 @@ export function chipText(segment) {
   if (segment.kind === 'skill') {
     return `$${segment.name}`;
   }
+  if (segment.kind === 'reference') {
+    return `#${segment.name}`;
+  }
   return segment.text;
 }
 /*
@@ -152,29 +234,36 @@ export function pastedMentions(text) {
   return [...new Set(tokens.map(token => token.slice(1)))];
 }
 /*
- * Where the chosen mentions and skills sit in the text, in text order; longer values win when one
- * prefixes another. A token that overlaps an excluded range (a code span, say) is text.
+ * Where the chosen mentions, skills and references sit in the text, in text order; longer values win
+ * when one prefixes another. A token that overlaps an excluded range (a code span, say) is text.
  */
-export function chipRanges(text, mentions, skills = [], excluded = []) {
+export function chipRanges(text, mentions, skills = [], excluded = [], references = []) {
   const tokens = [...[...new Set(mentions)].map(value => ({
     sigil: '@',
     kind: 'mention',
+    spelled: value,
     value
   })), ...[...new Set(skills)].map(value => ({
     sigil: '$',
     kind: 'skill',
+    spelled: value,
     value
-  }))].sort((a, b) => b.value.length - a.value.length);
+  })), ...references.filter(token => token.name !== '').map(token => ({
+    sigil: '#',
+    kind: 'reference',
+    spelled: token.name,
+    value: token.id
+  }))].sort((a, b) => b.spelled.length - a.spelled.length);
   const allowed = (from, to) => !excluded.some(range => from < range.to && to > range.from);
   const ranges = [];
   let cursor = 0;
   while (cursor < text.length) {
     let best = null;
     for (const token of tokens) {
-      const length = token.value.length + 1;
-      let index = findToken(text, token.sigil, token.value, cursor);
+      const length = token.spelled.length + 1;
+      let index = findToken(text, token.sigil, token.spelled, cursor);
       while (index >= 0 && !allowed(index, index + length)) {
-        index = findToken(text, token.sigil, token.value, index + 1);
+        index = findToken(text, token.sigil, token.spelled, index + 1);
       }
       if (index >= 0 && (best === null || index < best.from)) {
         best = {
@@ -193,24 +282,80 @@ export function chipRanges(text, mentions, skills = [], excluded = []) {
   }
   return ranges;
 }
-/* Splits the text so a renderer can draw the mentions and skills as chips. */
-export function tokenizeChips(text, mentions, skills = []) {
+function segmentOf(text, range) {
+  if (range.kind === 'mention') {
+    return {
+      kind: 'mention',
+      path: range.value
+    };
+  }
+  if (range.kind === 'skill') {
+    return {
+      kind: 'skill',
+      name: range.value
+    };
+  }
+  return {
+    kind: 'reference',
+    id: range.value,
+    name: text.slice(range.from + 1, range.to)
+  };
+}
+/* Splits the text so a renderer can draw the mentions, skills and references as chips. */
+export function tokenizeChips(text, mentions, skills = [], references = []) {
+  return segmentsOf(text, chipRanges(text, mentions, skills, [], references));
+}
+// What a `#` may follow in a text nobody typed through the picker: a space, or an opening bracket or quote.
+const REFERENCE_OPENER = /[\s([{"'“‘]/;
+/*
+ * Where a text written without the picker, such as a reply, spells `#Name` for a view, node or chat
+ * by exactly its name. The longest name wins, so a name with a space is found whole. A name more
+ * than one of them carries stays text, unless one of those is in `referenced`, which then wins.
+ */
+export function namedReferenceRanges(text, items, referenced = [], excluded = []) {
+  const byName = new Map();
+  for (const item of items) {
+    if (item.name !== '') {
+      byName.set(item.name, [...(byName.get(item.name) ?? []), item.id]);
+    }
+  }
+  const names = [...byName.keys()].sort((a, b) => b.length - a.length);
+  const preferred = new Set(referenced);
+  const ranges = [];
+  let index = text.indexOf('#');
+  while (index >= 0) {
+    const from = index;
+    const name = from > 0 && !REFERENCE_OPENER.test(text[from - 1]) ? undefined : names.find(candidate => text.startsWith(candidate, from + 1) && isTokenEnd(text[from + 1 + candidate.length]));
+    const to = name === undefined ? from + 1 : from + 1 + name.length;
+    const ids = name === undefined ? [] : byName.get(name);
+    const id = ids.find(candidate => preferred.has(candidate)) ?? (ids.length === 1 ? ids[0] : undefined);
+    if (id !== undefined && !excluded.some(range => from < range.to && to > range.from)) {
+      ranges.push({
+        from,
+        to,
+        kind: 'reference',
+        value: id
+      });
+    }
+    index = text.indexOf('#', to);
+  }
+  return ranges;
+}
+/* `namedReferenceRanges` as segments, for a renderer. */
+export function tokenizeNamedReferences(text, items, referenced = []) {
+  return segmentsOf(text, namedReferenceRanges(text, items, referenced));
+}
+function segmentsOf(text, ranges) {
   const segments = [];
   let cursor = 0;
-  for (const range of chipRanges(text, mentions, skills)) {
+  for (const range of ranges) {
     if (range.from > cursor) {
       segments.push({
         kind: 'text',
         text: text.slice(cursor, range.from)
       });
     }
-    segments.push(range.kind === 'mention' ? {
-      kind: 'mention',
-      path: range.value
-    } : {
-      kind: 'skill',
-      name: range.value
-    });
+    segments.push(segmentOf(text, range));
     cursor = range.to;
   }
   if (cursor < text.length) {

package/dist/chat/stash.d.ts

@@ -15,6 +15,7 @@ export interface StashedPrompt {
     attachments: StashedAttachment[];
     quote?: StashedQuote;
     createdAt: number;
+    references: string[];
 }
 export interface StashedQuote {
     text: string;

package/dist/chat/stash.js

@@ -57,7 +57,8 @@ export function parseStash(raw) {
       chats: strings(entry.chats),
       attachments: attachments(entry.attachments),
       ...stashedQuoteField(entry.quote),
-      createdAt: typeof entry.createdAt === 'number' ? entry.createdAt : 0
+      createdAt: typeof entry.createdAt === 'number' ? entry.createdAt : 0,
+      references: strings(entry.references)
     })).slice(0, STASH_LIMIT);
   } catch {
     return [];
@@ -94,7 +95,8 @@ export function stashedFrom(draft, id, now, chatId) {
       mime: attachment.mime,
       size: uploadBytes(attachment)
     })),
-    createdAt: now
+    createdAt: now,
+    references: [...draft.references]
   };
 }
 /* The limit of `chats` in a send. */