@athenaintel/react 0.57.2 → 0.59.0

package/dist/composer/ComposerNamedAgents.cjs

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("react/jsx-runtime");
+const namedAgents = require("../agent-runtime/src/named-agents.cjs");
+const lucideReact = require("lucide-react");
+const require$$0 = require("react");
+const cnfast = require("cnfast");
+const ComposerNamedAgents = ({
+  threadId,
+  onEmptied,
+  className
+}) => {
+  const agents = namedAgents.useDeepAgentNamedAgents(threadId);
+  const listRef = require$$0.useRef(null);
+  if (agents.length === 0) return null;
+  const remove = (agent, index) => {
+    namedAgents.removeDeepAgentNamedAgent({ threadId, ref: agent.ref });
+    requestAnimationFrame(() => {
+      var _a;
+      const buttons = (_a = listRef.current) == null ? void 0 : _a.querySelectorAll(
+        "button[data-named-agent-remove]"
+      );
+      const next = (buttons == null ? void 0 : buttons.length) ? buttons[Math.min(index, buttons.length - 1)] : void 0;
+      if (next) next.focus();
+      else onEmptied == null ? void 0 : onEmptied();
+    });
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: cnfast.cn("aui-composer-named-agents mx-3 mt-2 flex items-start gap-2", className),
+      "data-testid": "athena-named-agents",
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-hidden": "true", className: "py-0.5 text-muted-foreground text-xs", children: "To" }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "ul",
+          {
+            ref: listRef,
+            "aria-label": "Agents this message goes to",
+            className: "flex min-w-0 flex-1 flex-wrap gap-1.5",
+            children: agents.map((agent, index) => /* @__PURE__ */ jsxRuntime.jsx("li", { className: "min-w-0", "data-named-agent": agent.ref, children: /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "inline-flex max-w-full items-center gap-1 rounded-md border border-border bg-muted/60 py-0 pr-0.5 pl-1.5 font-medium text-foreground text-xs", children: [
+              /* @__PURE__ */ jsxRuntime.jsx(lucideReact.BotIcon, { "aria-hidden": "true", className: "size-3 shrink-0 text-muted-foreground" }),
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "max-w-48 truncate", children: agent.name }),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "button",
+                {
+                  type: "button",
+                  className: "inline-flex size-5 shrink-0 items-center justify-center rounded-sm text-muted-foreground transition-colors hover:bg-muted hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+                  "aria-label": `Remove ${agent.name}`,
+                  "data-named-agent-remove": "",
+                  onClick: () => remove(agent, index),
+                  children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.XIcon, { "aria-hidden": "true", className: "size-3" })
+                }
+              )
+            ] }) }, agent.ref))
+          }
+        )
+      ]
+    }
+  );
+};
+exports.ComposerNamedAgents = ComposerNamedAgents;
+//# sourceMappingURL=ComposerNamedAgents.cjs.map

package/dist/composer/ComposerNamedAgents.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComposerNamedAgents.cjs","sources":["../../src/composer/ComposerNamedAgents.tsx"],"sourcesContent":["import {\n  type DeepAgentNamedAgent,\n  removeDeepAgentNamedAgent,\n  useDeepAgentNamedAgents,\n} from '@athenaintel/agent-runtime/named-agents';\nimport { BotIcon, XIcon } from 'lucide-react';\nimport { type FC, useRef } from 'react';\nimport { cn } from '../lib/utils';\n\nexport interface ComposerNamedAgentsProps {\n  /** The conversation whose next message the chips name agents for. */\n  threadId: string;\n  /** The last named agent was removed: where focus goes next (the editor). */\n  onEmptied?: () => void;\n  className?: string;\n}\n\n/**\n * The composer's To line (identity v7 D13), as Olympus's composer shows it: the agents the person\n * named from the `@` menu's Agents section, in the order named, each answering the message in its\n * own turn and each with a labelled remove button. They stay for every message until the person\n * changes them. Renders nothing while none are named. Removing an agent hands focus to the chip that\n * took its place, else the one before it, else back to the editor (`onEmptied`).\n */\nexport const ComposerNamedAgents: FC<ComposerNamedAgentsProps> = ({\n  threadId,\n  onEmptied,\n  className,\n}) => {\n  const agents = useDeepAgentNamedAgents(threadId);\n  const listRef = useRef<HTMLUListElement>(null);\n  if (agents.length === 0) return null;\n\n  const remove = (agent: DeepAgentNamedAgent, index: number): void => {\n    removeDeepAgentNamedAgent({ threadId, ref: agent.ref });\n    // After React has painted the row without the chip (or unmounted it).\n    requestAnimationFrame(() => {\n      const buttons = listRef.current?.querySelectorAll<HTMLButtonElement>(\n        'button[data-named-agent-remove]',\n      );\n      const next = buttons?.length ? buttons[Math.min(index, buttons.length - 1)] : undefined;\n      if (next) next.focus();\n      else onEmptied?.();\n    });\n  };\n\n  return (\n    <div\n      className={cn('aui-composer-named-agents mx-3 mt-2 flex items-start gap-2', className)}\n      data-testid=\"athena-named-agents\"\n    >\n      <span aria-hidden=\"true\" className=\"py-0.5 text-muted-foreground text-xs\">\n        To\n      </span>\n      <ul\n        ref={listRef}\n        aria-label=\"Agents this message goes to\"\n        className=\"flex min-w-0 flex-1 flex-wrap gap-1.5\"\n      >\n        {agents.map((agent, index) => (\n          <li key={agent.ref} className=\"min-w-0\" data-named-agent={agent.ref}>\n            <span className=\"inline-flex max-w-full items-center gap-1 rounded-md border border-border bg-muted/60 py-0 pr-0.5 pl-1.5 font-medium text-foreground text-xs\">\n              <BotIcon aria-hidden=\"true\" className=\"size-3 shrink-0 text-muted-foreground\" />\n              <span className=\"max-w-48 truncate\">{agent.name}</span>\n              <button\n                type=\"button\"\n                className=\"inline-flex size-5 shrink-0 items-center justify-center rounded-sm text-muted-foreground transition-colors hover:bg-muted hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring\"\n                aria-label={`Remove ${agent.name}`}\n                data-named-agent-remove=\"\"\n                onClick={() => remove(agent, index)}\n              >\n                <XIcon aria-hidden=\"true\" className=\"size-3\" />\n              </button>\n            </span>\n          </li>\n        ))}\n      </ul>\n    </div>\n  );\n};\n"],"names":["useDeepAgentNamedAgents","useRef","removeDeepAgentNamedAgent","jsxs","cn","jsx","BotIcon","XIcon"],"mappings":";;;;;;;AAwBO,MAAM,sBAAoD,CAAC;AAAA,EAChE;AAAA,EACA;AAAA,EACA;AACF,MAAM;AACJ,QAAM,SAASA,YAAAA,wBAAwB,QAAQ;AAC/C,QAAM,UAAUC,WAAAA,OAAyB,IAAI;AAC7C,MAAI,OAAO,WAAW,EAAG,QAAO;AAEhC,QAAM,SAAS,CAAC,OAA4B,UAAwB;AAClEC,gBAAAA,0BAA0B,EAAE,UAAU,KAAK,MAAM,KAAK;AAEtD,0BAAsB,MAAM;;AAC1B,YAAM,WAAU,aAAQ,YAAR,mBAAiB;AAAA,QAC/B;AAAA;AAEF,YAAM,QAAO,mCAAS,UAAS,QAAQ,KAAK,IAAI,OAAO,QAAQ,SAAS,CAAC,CAAC,IAAI;AAC9E,UAAI,WAAW,MAAA;AAAA,UACV;AAAA,IACP,CAAC;AAAA,EACH;AAEA,SACEC,2BAAAA;AAAAA,IAAC;AAAA,IAAA;AAAA,MACC,WAAWC,OAAAA,GAAG,8DAA8D,SAAS;AAAA,MACrF,eAAY;AAAA,MAEZ,UAAA;AAAA,QAAAC,+BAAC,QAAA,EAAK,eAAY,QAAO,WAAU,wCAAuC,UAAA,MAE1E;AAAA,QACAA,2BAAAA;AAAAA,UAAC;AAAA,UAAA;AAAA,YACC,KAAK;AAAA,YACL,cAAW;AAAA,YACX,WAAU;AAAA,YAET,UAAA,OAAO,IAAI,CAAC,OAAO,UAClBA,2BAAAA,IAAC,MAAA,EAAmB,WAAU,WAAU,oBAAkB,MAAM,KAC9D,UAAAF,2BAAAA,KAAC,QAAA,EAAK,WAAU,gJACd,UAAA;AAAA,cAAAE,2BAAAA,IAACC,YAAAA,SAAA,EAAQ,eAAY,QAAO,WAAU,yCAAwC;AAAA,cAC9ED,2BAAAA,IAAC,QAAA,EAAK,WAAU,qBAAqB,gBAAM,MAAK;AAAA,cAChDA,2BAAAA;AAAAA,gBAAC;AAAA,gBAAA;AAAA,kBACC,MAAK;AAAA,kBACL,WAAU;AAAA,kBACV,cAAY,UAAU,MAAM,IAAI;AAAA,kBAChC,2BAAwB;AAAA,kBACxB,SAAS,MAAM,OAAO,OAAO,KAAK;AAAA,kBAElC,UAAAA,2BAAAA,IAACE,mBAAA,EAAM,eAAY,QAAO,WAAU,SAAA,CAAS;AAAA,gBAAA;AAAA,cAAA;AAAA,YAC/C,GACF,EAAA,GAbO,MAAM,GAcf,CACD;AAAA,UAAA;AAAA,QAAA;AAAA,MACH;AAAA,IAAA;AAAA,EAAA;AAGN;;"}

package/dist/composer/ComposerNamedAgents.d.ts

@@ -0,0 +1,16 @@
+import { type FC } from 'react';
+export interface ComposerNamedAgentsProps {
+    /** The conversation whose next message the chips name agents for. */
+    threadId: string;
+    /** The last named agent was removed: where focus goes next (the editor). */
+    onEmptied?: () => void;
+    className?: string;
+}
+/**
+ * The composer's To line (identity v7 D13), as Olympus's composer shows it: the agents the person
+ * named from the `@` menu's Agents section, in the order named, each answering the message in its
+ * own turn and each with a labelled remove button. They stay for every message until the person
+ * changes them. Renders nothing while none are named. Removing an agent hands focus to the chip that
+ * took its place, else the one before it, else back to the editor (`onEmptied`).
+ */
+export declare const ComposerNamedAgents: FC<ComposerNamedAgentsProps>;

package/dist/composer/ComposerNamedAgents.js

@@ -0,0 +1,63 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useDeepAgentNamedAgents, removeDeepAgentNamedAgent } from "../agent-runtime/src/named-agents.js";
+import { BotIcon, XIcon } from "lucide-react";
+import { useRef } from "react";
+import { cn } from "cnfast";
+const ComposerNamedAgents = ({
+  threadId,
+  onEmptied,
+  className
+}) => {
+  const agents = useDeepAgentNamedAgents(threadId);
+  const listRef = useRef(null);
+  if (agents.length === 0) return null;
+  const remove = (agent, index) => {
+    removeDeepAgentNamedAgent({ threadId, ref: agent.ref });
+    requestAnimationFrame(() => {
+      var _a;
+      const buttons = (_a = listRef.current) == null ? void 0 : _a.querySelectorAll(
+        "button[data-named-agent-remove]"
+      );
+      const next = (buttons == null ? void 0 : buttons.length) ? buttons[Math.min(index, buttons.length - 1)] : void 0;
+      if (next) next.focus();
+      else onEmptied == null ? void 0 : onEmptied();
+    });
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn("aui-composer-named-agents mx-3 mt-2 flex items-start gap-2", className),
+      "data-testid": "athena-named-agents",
+      children: [
+        /* @__PURE__ */ jsx("span", { "aria-hidden": "true", className: "py-0.5 text-muted-foreground text-xs", children: "To" }),
+        /* @__PURE__ */ jsx(
+          "ul",
+          {
+            ref: listRef,
+            "aria-label": "Agents this message goes to",
+            className: "flex min-w-0 flex-1 flex-wrap gap-1.5",
+            children: agents.map((agent, index) => /* @__PURE__ */ jsx("li", { className: "min-w-0", "data-named-agent": agent.ref, children: /* @__PURE__ */ jsxs("span", { className: "inline-flex max-w-full items-center gap-1 rounded-md border border-border bg-muted/60 py-0 pr-0.5 pl-1.5 font-medium text-foreground text-xs", children: [
+              /* @__PURE__ */ jsx(BotIcon, { "aria-hidden": "true", className: "size-3 shrink-0 text-muted-foreground" }),
+              /* @__PURE__ */ jsx("span", { className: "max-w-48 truncate", children: agent.name }),
+              /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  className: "inline-flex size-5 shrink-0 items-center justify-center rounded-sm text-muted-foreground transition-colors hover:bg-muted hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+                  "aria-label": `Remove ${agent.name}`,
+                  "data-named-agent-remove": "",
+                  onClick: () => remove(agent, index),
+                  children: /* @__PURE__ */ jsx(XIcon, { "aria-hidden": "true", className: "size-3" })
+                }
+              )
+            ] }) }, agent.ref))
+          }
+        )
+      ]
+    }
+  );
+};
+export {
+  ComposerNamedAgents
+};
+//# sourceMappingURL=ComposerNamedAgents.js.map

package/dist/composer/ComposerNamedAgents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComposerNamedAgents.js","sources":["../../src/composer/ComposerNamedAgents.tsx"],"sourcesContent":["import {\n  type DeepAgentNamedAgent,\n  removeDeepAgentNamedAgent,\n  useDeepAgentNamedAgents,\n} from '@athenaintel/agent-runtime/named-agents';\nimport { BotIcon, XIcon } from 'lucide-react';\nimport { type FC, useRef } from 'react';\nimport { cn } from '../lib/utils';\n\nexport interface ComposerNamedAgentsProps {\n  /** The conversation whose next message the chips name agents for. */\n  threadId: string;\n  /** The last named agent was removed: where focus goes next (the editor). */\n  onEmptied?: () => void;\n  className?: string;\n}\n\n/**\n * The composer's To line (identity v7 D13), as Olympus's composer shows it: the agents the person\n * named from the `@` menu's Agents section, in the order named, each answering the message in its\n * own turn and each with a labelled remove button. They stay for every message until the person\n * changes them. Renders nothing while none are named. Removing an agent hands focus to the chip that\n * took its place, else the one before it, else back to the editor (`onEmptied`).\n */\nexport const ComposerNamedAgents: FC<ComposerNamedAgentsProps> = ({\n  threadId,\n  onEmptied,\n  className,\n}) => {\n  const agents = useDeepAgentNamedAgents(threadId);\n  const listRef = useRef<HTMLUListElement>(null);\n  if (agents.length === 0) return null;\n\n  const remove = (agent: DeepAgentNamedAgent, index: number): void => {\n    removeDeepAgentNamedAgent({ threadId, ref: agent.ref });\n    // After React has painted the row without the chip (or unmounted it).\n    requestAnimationFrame(() => {\n      const buttons = listRef.current?.querySelectorAll<HTMLButtonElement>(\n        'button[data-named-agent-remove]',\n      );\n      const next = buttons?.length ? buttons[Math.min(index, buttons.length - 1)] : undefined;\n      if (next) next.focus();\n      else onEmptied?.();\n    });\n  };\n\n  return (\n    <div\n      className={cn('aui-composer-named-agents mx-3 mt-2 flex items-start gap-2', className)}\n      data-testid=\"athena-named-agents\"\n    >\n      <span aria-hidden=\"true\" className=\"py-0.5 text-muted-foreground text-xs\">\n        To\n      </span>\n      <ul\n        ref={listRef}\n        aria-label=\"Agents this message goes to\"\n        className=\"flex min-w-0 flex-1 flex-wrap gap-1.5\"\n      >\n        {agents.map((agent, index) => (\n          <li key={agent.ref} className=\"min-w-0\" data-named-agent={agent.ref}>\n            <span className=\"inline-flex max-w-full items-center gap-1 rounded-md border border-border bg-muted/60 py-0 pr-0.5 pl-1.5 font-medium text-foreground text-xs\">\n              <BotIcon aria-hidden=\"true\" className=\"size-3 shrink-0 text-muted-foreground\" />\n              <span className=\"max-w-48 truncate\">{agent.name}</span>\n              <button\n                type=\"button\"\n                className=\"inline-flex size-5 shrink-0 items-center justify-center rounded-sm text-muted-foreground transition-colors hover:bg-muted hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring\"\n                aria-label={`Remove ${agent.name}`}\n                data-named-agent-remove=\"\"\n                onClick={() => remove(agent, index)}\n              >\n                <XIcon aria-hidden=\"true\" className=\"size-3\" />\n              </button>\n            </span>\n          </li>\n        ))}\n      </ul>\n    </div>\n  );\n};\n"],"names":[],"mappings":";;;;;AAwBO,MAAM,sBAAoD,CAAC;AAAA,EAChE;AAAA,EACA;AAAA,EACA;AACF,MAAM;AACJ,QAAM,SAAS,wBAAwB,QAAQ;AAC/C,QAAM,UAAU,OAAyB,IAAI;AAC7C,MAAI,OAAO,WAAW,EAAG,QAAO;AAEhC,QAAM,SAAS,CAAC,OAA4B,UAAwB;AAClE,8BAA0B,EAAE,UAAU,KAAK,MAAM,KAAK;AAEtD,0BAAsB,MAAM;;AAC1B,YAAM,WAAU,aAAQ,YAAR,mBAAiB;AAAA,QAC/B;AAAA;AAEF,YAAM,QAAO,mCAAS,UAAS,QAAQ,KAAK,IAAI,OAAO,QAAQ,SAAS,CAAC,CAAC,IAAI;AAC9E,UAAI,WAAW,MAAA;AAAA,UACV;AAAA,IACP,CAAC;AAAA,EACH;AAEA,SACE;AAAA,IAAC;AAAA,IAAA;AAAA,MACC,WAAW,GAAG,8DAA8D,SAAS;AAAA,MACrF,eAAY;AAAA,MAEZ,UAAA;AAAA,QAAA,oBAAC,QAAA,EAAK,eAAY,QAAO,WAAU,wCAAuC,UAAA,MAE1E;AAAA,QACA;AAAA,UAAC;AAAA,UAAA;AAAA,YACC,KAAK;AAAA,YACL,cAAW;AAAA,YACX,WAAU;AAAA,YAET,UAAA,OAAO,IAAI,CAAC,OAAO,UAClB,oBAAC,MAAA,EAAmB,WAAU,WAAU,oBAAkB,MAAM,KAC9D,UAAA,qBAAC,QAAA,EAAK,WAAU,gJACd,UAAA;AAAA,cAAA,oBAAC,SAAA,EAAQ,eAAY,QAAO,WAAU,yCAAwC;AAAA,cAC9E,oBAAC,QAAA,EAAK,WAAU,qBAAqB,gBAAM,MAAK;AAAA,cAChD;AAAA,gBAAC;AAAA,gBAAA;AAAA,kBACC,MAAK;AAAA,kBACL,WAAU;AAAA,kBACV,cAAY,UAAU,MAAM,IAAI;AAAA,kBAChC,2BAAwB;AAAA,kBACxB,SAAS,MAAM,OAAO,OAAO,KAAK;AAAA,kBAElC,UAAA,oBAAC,OAAA,EAAM,eAAY,QAAO,WAAU,SAAA,CAAS;AAAA,gBAAA;AAAA,cAAA;AAAA,YAC/C,GACF,EAAA,GAbO,MAAM,GAcf,CACD;AAAA,UAAA;AAAA,QAAA;AAAA,MACH;AAAA,IAAA;AAAA,EAAA;AAGN;"}

package/dist/composer/attached-references.cjs

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const attachable = require("../references/src/attachable.cjs");
+const require$$0 = require("react");
+const EMPTY = Object.freeze([]);
+const pending = /* @__PURE__ */ new Map();
+const listeners = /* @__PURE__ */ new Set();
+let attachedForIdentity = null;
+function notify() {
+  for (const listener of [...listeners]) listener();
+}
+function subscribe(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function setPending(threadId, references) {
+  if (references.length === 0) pending.delete(threadId);
+  else pending.set(threadId, Object.freeze([...references]));
+  notify();
+}
+function attachReferenceToThread({
+  threadId,
+  reference
+}) {
+  if (!threadId) return { attached: false, reason: "no_thread" };
+  const normalized = attachable.normalizeAttachableReference(reference);
+  if (normalized === null) return { attached: false, reason: "invalid_reference" };
+  const key = attachable.attachableReferenceKey(normalized);
+  const current = pending.get(threadId) ?? EMPTY;
+  const index = current.findIndex((entry) => attachable.attachableReferenceKey(entry) === key);
+  if (index >= 0) {
+    setPending(
+      threadId,
+      current.map((entry, position) => position === index ? normalized : entry)
+    );
+    return { attached: true, reference: normalized, duplicate: true };
+  }
+  if (current.length >= attachable.MAX_ATTACHED_REFERENCES) return { attached: false, reason: "too_many" };
+  setPending(threadId, [...current, normalized]);
+  return { attached: true, reference: normalized, duplicate: false };
+}
+function detachReferenceFromThread({
+  threadId,
+  reference
+}) {
+  if (!threadId) return;
+  const current = pending.get(threadId);
+  if (!current) return;
+  const key = attachable.attachableReferenceKey(reference);
+  const kept = current.filter((entry) => attachable.attachableReferenceKey(entry) !== key);
+  if (kept.length !== current.length) setPending(threadId, kept);
+}
+function clearAttachedReferences(threadId) {
+  if (!threadId || !pending.has(threadId)) return;
+  setPending(threadId, EMPTY);
+}
+function readPendingAttachedReferences(threadId) {
+  return (threadId ? pending.get(threadId) : void 0) ?? EMPTY;
+}
+function usePendingAttachedReferences(threadId) {
+  const read = require$$0.useCallback(() => readPendingAttachedReferences(threadId), [threadId]);
+  return require$$0.useSyncExternalStore(subscribe, read, read);
+}
+function forgetAllAttachedReferences() {
+  pending.clear();
+  stagedForSend.clear();
+  sentWithText.clear();
+  notify();
+}
+function keepAttachedReferencesForIdentity(identity) {
+  if (attachedForIdentity !== null && attachedForIdentity !== identity) {
+    forgetAllAttachedReferences();
+  }
+  attachedForIdentity = identity;
+}
+const ATTACHED_REFERENCES_STAGED_TTL_MS = 1e4;
+const stagedForSend = /* @__PURE__ */ new Map();
+function stageAttachedReferencesForSend({
+  threadId,
+  references
+}) {
+  if (!threadId) return;
+  if (references.length === 0) {
+    stagedForSend.delete(threadId);
+    return;
+  }
+  stagedForSend.set(threadId, { references, stagedAt: Date.now() });
+}
+function takeStagedAttachedReferences(threadId) {
+  const staged = stagedForSend.get(threadId);
+  stagedForSend.delete(threadId);
+  if (!staged || Date.now() - staged.stagedAt > ATTACHED_REFERENCES_STAGED_TTL_MS) return EMPTY;
+  return staged.references;
+}
+function withStagedAttachedReferences(threadId, metadata) {
+  const references = takeStagedAttachedReferences(threadId);
+  return references.length === 0 ? metadata : attachable.withAttachedReferences(metadata, references);
+}
+const SENT_TEXTS_KEPT_PER_THREAD = 20;
+const THREADS_WITH_SENT_TEXTS_KEPT = 50;
+const sentWithText = /* @__PURE__ */ new Map();
+function setBounded(map, key, value, limit) {
+  map.delete(key);
+  map.set(key, value);
+  while (map.size > limit) {
+    const oldest = map.keys().next();
+    if (oldest.done) break;
+    map.delete(oldest.value);
+  }
+}
+function stageThreadAttachedReferencesForSend({
+  threadId,
+  text
+}) {
+  const references = readPendingAttachedReferences(threadId);
+  stageAttachedReferencesForSend({ threadId, references });
+  if (!threadId) return references;
+  const texts = sentWithText.get(threadId);
+  if (references.length === 0) {
+    texts == null ? void 0 : texts.delete(text);
+    return references;
+  }
+  const kept = texts ?? /* @__PURE__ */ new Map();
+  setBounded(kept, text, references, SENT_TEXTS_KEPT_PER_THREAD);
+  setBounded(sentWithText, threadId, kept, THREADS_WITH_SENT_TEXTS_KEPT);
+  clearAttachedReferences(threadId);
+  return references;
+}
+function reattach(threadId, references) {
+  for (const reference of references) attachReferenceToThread({ threadId, reference });
+}
+function restoreSentAttachedReferences({
+  threadId,
+  text
+}) {
+  var _a;
+  const references = (_a = sentWithText.get(threadId)) == null ? void 0 : _a.get(text);
+  if (references) reattach(threadId, references);
+}
+function giveBackHeldAttachedReferences(entry) {
+  reattach(entry.threadId, attachable.readAttachedReferences(entry.metadata));
+}
+exports.ATTACHED_REFERENCES_STAGED_TTL_MS = ATTACHED_REFERENCES_STAGED_TTL_MS;
+exports.attachReferenceToThread = attachReferenceToThread;
+exports.clearAttachedReferences = clearAttachedReferences;
+exports.detachReferenceFromThread = detachReferenceFromThread;
+exports.forgetAllAttachedReferences = forgetAllAttachedReferences;
+exports.giveBackHeldAttachedReferences = giveBackHeldAttachedReferences;
+exports.keepAttachedReferencesForIdentity = keepAttachedReferencesForIdentity;
+exports.readPendingAttachedReferences = readPendingAttachedReferences;
+exports.restoreSentAttachedReferences = restoreSentAttachedReferences;
+exports.stageAttachedReferencesForSend = stageAttachedReferencesForSend;
+exports.stageThreadAttachedReferencesForSend = stageThreadAttachedReferencesForSend;
+exports.takeStagedAttachedReferences = takeStagedAttachedReferences;
+exports.usePendingAttachedReferences = usePendingAttachedReferences;
+exports.withStagedAttachedReferences = withStagedAttachedReferences;
+//# sourceMappingURL=attached-references.cjs.map

package/dist/composer/attached-references.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"attached-references.cjs","sources":["../../src/composer/attached-references.ts"],"sourcesContent":["import {\n  type AttachableReference,\n  attachableReferenceKey,\n  MAX_ATTACHED_REFERENCES,\n  normalizeAttachableReference,\n  readAttachedReferences as readMessageAttachedReferences,\n  withAttachedReferences,\n} from '@athenaintel/references/attachable';\nimport { useCallback, useSyncExternalStore } from 'react';\n\n/**\n * What each conversation's next message carries as attached references (`useAttachToChat`), and\n * the hand-off of that list to the message that leaves.\n *\n * - **The pending list.** Per thread, in the order attached, each reference once (by kind and\n *   pointer, an asset's anchor included), at most {@link MAX_ATTACHED_REFERENCES}. The composer\n *   shows it as removable chips (`ComposerAttachedReferences`). It is kept in memory for the page\n *   and dropped when the signed-in identity changes ({@link keepAttachedReferencesForIdentity}):\n *   what one person attached is never sent as someone else's.\n * - **The send.** statewire captures a new message's metadata once, as it journals it\n *   (`getMessageMetadata`), without saying which message it is for. So the composer stages the\n *   list right before `aui.composer.send` ({@link stageAttachedReferencesForSend}) and the runtime's\n *   getter takes it for the message that follows ({@link withStagedAttachedReferences}).\n *   The references then ride the message's own metadata (`attachedReferences`), never its text, so\n *   a send that waits, is retried or is posted again after a reload keeps its own attachments. A\n *   slot nobody takes expires. Both send paths stage them ({@link stageThreadAttachedReferencesForSend}):\n *   `AthenaChat`'s composed send, and `TiptapComposer`'s own through its host's `prepareSend`\n *   (`useAttachedReferencesComposerProps`). A composer whose host doesn't opt in sends none and\n *   never loads this module (the Office pane's budget counts on it).\n * - **The way back.** Sending takes the chips off the composer, and they come back with the send:\n *   a send statewire refuses and hands back ({@link restoreSentAttachedReferences}, by its text),\n *   or a message held in the chat outbox that is cancelled or edited\n *   ({@link giveBackHeldAttachedReferences}, from its metadata).\n *\n * agora reads the list off the message, refuses whatever it can't read, and resolves each one with\n * the person's own permission before the agent is told about it; the client never gates.\n */\n\nconst EMPTY: readonly AttachableReference[] = Object.freeze([]);\n\n// process-local: client-only — the references each thread's composer sends with its next message.\nconst pending = new Map<string, readonly AttachableReference[]>();\nconst listeners = new Set<() => void>();\nlet attachedForIdentity: string | null = null;\n\nfunction notify(): void {\n  for (const listener of [...listeners]) listener();\n}\n\nfunction subscribe(listener: () => void): () => void {\n  listeners.add(listener);\n  return () => {\n    listeners.delete(listener);\n  };\n}\n\nfunction setPending(threadId: string, references: readonly AttachableReference[]): void {\n  if (references.length === 0) pending.delete(threadId);\n  else pending.set(threadId, Object.freeze([...references]));\n  notify();\n}\n\n/** Why a reference was not attached. */\nexport type AttachRefusalReason =\n  /** Not a reference an app may attach (an unknown kind, a malformed id, URL or anchor). */\n  | 'invalid_reference'\n  /** The next message already carries {@link MAX_ATTACHED_REFERENCES}. */\n  | 'too_many'\n  /** No conversation to attach it to (outside `<AthenaProvider>`'s chat). */\n  | 'no_thread';\n\n/** What `attach` did. */\nexport type AttachReferenceResult =\n  | {\n      attached: true;\n      /** The reference as it will be sent (normalized: unknown fields dropped, label cut). */\n      reference: AttachableReference;\n      /** It was attached already; its label is updated and it keeps its place. */\n      duplicate: boolean;\n    }\n  | { attached: false; reason: AttachRefusalReason };\n\n/** Attach `reference` to `threadId`'s next message. */\nexport function attachReferenceToThread({\n  threadId,\n  reference,\n}: {\n  threadId: string | null;\n  reference: unknown;\n}): AttachReferenceResult {\n  if (!threadId) return { attached: false, reason: 'no_thread' };\n  const normalized = normalizeAttachableReference(reference);\n  if (normalized === null) return { attached: false, reason: 'invalid_reference' };\n  const key = attachableReferenceKey(normalized);\n  const current = pending.get(threadId) ?? EMPTY;\n  const index = current.findIndex((entry) => attachableReferenceKey(entry) === key);\n  if (index >= 0) {\n    setPending(\n      threadId,\n      current.map((entry, position) => (position === index ? normalized : entry)),\n    );\n    return { attached: true, reference: normalized, duplicate: true };\n  }\n  if (current.length >= MAX_ATTACHED_REFERENCES) return { attached: false, reason: 'too_many' };\n  setPending(threadId, [...current, normalized]);\n  return { attached: true, reference: normalized, duplicate: false };\n}\n\n/** Take `reference` (matched by kind and pointer) off `threadId`'s next message. */\nexport function detachReferenceFromThread({\n  threadId,\n  reference,\n}: {\n  threadId: string | null;\n  reference: AttachableReference;\n}): void {\n  if (!threadId) return;\n  const current = pending.get(threadId);\n  if (!current) return;\n  const key = attachableReferenceKey(reference);\n  const kept = current.filter((entry) => attachableReferenceKey(entry) !== key);\n  if (kept.length !== current.length) setPending(threadId, kept);\n}\n\n/** Take every reference off `threadId`'s next message. */\nexport function clearAttachedReferences(threadId: string | null): void {\n  if (!threadId || !pending.has(threadId)) return;\n  setPending(threadId, EMPTY);\n}\n\n/** The references `threadId`'s next message carries, in the order attached. */\nexport function readPendingAttachedReferences(threadId: string | null): readonly AttachableReference[] {\n  return (threadId ? pending.get(threadId) : undefined) ?? EMPTY;\n}\n\n/** {@link readPendingAttachedReferences}, re-rendering when the list changes. */\nexport function usePendingAttachedReferences(threadId: string | null): readonly AttachableReference[] {\n  const read = useCallback(() => readPendingAttachedReferences(threadId), [threadId]);\n  return useSyncExternalStore(subscribe, read, read);\n}\n\n/** Forget every pending, staged and sent reference (tests, and a change of identity). */\nexport function forgetAllAttachedReferences(): void {\n  pending.clear();\n  stagedForSend.clear();\n  sentWithText.clear();\n  notify();\n}\n\n/**\n * Keep the pending references only while `identity` (the signed-in person) stays the same: a\n * change forgets every one, so nothing attached under one identity is sent under another.\n */\nexport function keepAttachedReferencesForIdentity(identity: string): void {\n  if (attachedForIdentity !== null && attachedForIdentity !== identity) {\n    forgetAllAttachedReferences();\n  }\n  attachedForIdentity = identity;\n}\n\n// ── The send ────────────────────────────────────────────────────────────────\n\n/** How long staged references wait for the message they were staged for before they expire. */\nexport const ATTACHED_REFERENCES_STAGED_TTL_MS = 10_000;\n\n// process-local: client-only — the references each thread's composer staged for the message it\n// submits next, taken once by the runtime's `getMessageMetadata`.\nconst stagedForSend = new Map<\n  string,\n  { references: readonly AttachableReference[]; stagedAt: number }\n>();\n\n/**\n * Stage `references` for the message `threadId`'s composer submits next. Call right before the send\n * (`aui.composer.send`). A send attaching nothing stages nothing and lets an earlier slot go.\n */\nexport function stageAttachedReferencesForSend({\n  threadId,\n  references,\n}: {\n  threadId: string;\n  references: readonly AttachableReference[];\n}): void {\n  if (!threadId) return;\n  if (references.length === 0) {\n    stagedForSend.delete(threadId);\n    return;\n  }\n  stagedForSend.set(threadId, { references, stagedAt: Date.now() });\n}\n\n/** The references staged for the message `threadId` journals now, taking the slot. */\nexport function takeStagedAttachedReferences(threadId: string): readonly AttachableReference[] {\n  const staged = stagedForSend.get(threadId);\n  stagedForSend.delete(threadId);\n  if (!staged || Date.now() - staged.stagedAt > ATTACHED_REFERENCES_STAGED_TTL_MS) return EMPTY;\n  return staged.references;\n}\n\n/**\n * The metadata a runtime's `getMessageMetadata` adds for the message `threadId` journals now: the\n * references staged for it under `attachedReferences`, taking the slot, over `metadata` (what the\n * rest of the getter produced). `metadata` unchanged when none are staged.\n */\nexport function withStagedAttachedReferences(\n  threadId: string,\n  metadata: Record<string, unknown> | undefined,\n): Record<string, unknown> | undefined {\n  const references = takeStagedAttachedReferences(threadId);\n  return references.length === 0 ? metadata : withAttachedReferences(metadata, references);\n}\n\n/** How many sent texts each thread remembers the references of, and how many threads. */\nconst SENT_TEXTS_KEPT_PER_THREAD = 20;\nconst THREADS_WITH_SENT_TEXTS_KEPT = 50;\n\n// process-local: client-only — the references each recent send carried, by its text, so a send\n// handed back (statewire refused it during a reconnect) brings its chips back.\nconst sentWithText = new Map<string, Map<string, readonly AttachableReference[]>>();\n\nfunction setBounded<K, V>(map: Map<K, V>, key: K, value: V, limit: number): void {\n  map.delete(key);\n  map.set(key, value);\n  while (map.size > limit) {\n    const oldest = map.keys().next();\n    if (oldest.done) break;\n    map.delete(oldest.value);\n  }\n}\n\n/**\n * Right before `threadId`'s composer sends `text`: stage the references pending for it, remember\n * them with the text (so the text coming back brings them back) and take them off the composer.\n * Returns what the message carries, `[]` when nothing was attached.\n */\nexport function stageThreadAttachedReferencesForSend({\n  threadId,\n  text,\n}: {\n  threadId: string;\n  text: string;\n}): readonly AttachableReference[] {\n  const references = readPendingAttachedReferences(threadId);\n  stageAttachedReferencesForSend({ threadId, references });\n  if (!threadId) return references;\n  const texts = sentWithText.get(threadId);\n  if (references.length === 0) {\n    texts?.delete(text);\n    return references;\n  }\n  const kept = texts ?? new Map<string, readonly AttachableReference[]>();\n  setBounded(kept, text, references, SENT_TEXTS_KEPT_PER_THREAD);\n  setBounded(sentWithText, threadId, kept, THREADS_WITH_SENT_TEXTS_KEPT);\n  clearAttachedReferences(threadId);\n  return references;\n}\n\nfunction reattach(threadId: string, references: readonly AttachableReference[]): void {\n  for (const reference of references) attachReferenceToThread({ threadId, reference });\n}\n\n/**\n * Text a send carried came back to `threadId`'s composer (statewire handed a refused send back):\n * the references it carried come back as chips, after any attached since.\n */\nexport function restoreSentAttachedReferences({\n  threadId,\n  text,\n}: {\n  threadId: string;\n  text: string;\n}): void {\n  const references = sentWithText.get(threadId)?.get(text);\n  if (references) reattach(threadId, references);\n}\n\n/**\n * A message held in the chat outbox was given back to the composer (Cancel, Edit): the references\n * its metadata carries come back as chips.\n */\nexport function giveBackHeldAttachedReferences(entry: {\n  threadId: string;\n  metadata?: unknown;\n}): void {\n  reattach(entry.threadId, readMessageAttachedReferences(entry.metadata));\n}\n"],"names":["normalizeAttachableReference","attachableReferenceKey","MAX_ATTACHED_REFERENCES","useCallback","useSyncExternalStore","withAttachedReferences","readMessageAttachedReferences"],"mappings":"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"}

package/dist/composer/attached-references.d.ts

@@ -0,0 +1,86 @@
+import { type AttachableReference } from '../references/src/attachable';
+/** Why a reference was not attached. */
+export type AttachRefusalReason = 
+/** Not a reference an app may attach (an unknown kind, a malformed id, URL or anchor). */
+'invalid_reference'
+/** The next message already carries {@link MAX_ATTACHED_REFERENCES}. */
+ | 'too_many'
+/** No conversation to attach it to (outside `<AthenaProvider>`'s chat). */
+ | 'no_thread';
+/** What `attach` did. */
+export type AttachReferenceResult = {
+    attached: true;
+    /** The reference as it will be sent (normalized: unknown fields dropped, label cut). */
+    reference: AttachableReference;
+    /** It was attached already; its label is updated and it keeps its place. */
+    duplicate: boolean;
+} | {
+    attached: false;
+    reason: AttachRefusalReason;
+};
+/** Attach `reference` to `threadId`'s next message. */
+export declare function attachReferenceToThread({ threadId, reference, }: {
+    threadId: string | null;
+    reference: unknown;
+}): AttachReferenceResult;
+/** Take `reference` (matched by kind and pointer) off `threadId`'s next message. */
+export declare function detachReferenceFromThread({ threadId, reference, }: {
+    threadId: string | null;
+    reference: AttachableReference;
+}): void;
+/** Take every reference off `threadId`'s next message. */
+export declare function clearAttachedReferences(threadId: string | null): void;
+/** The references `threadId`'s next message carries, in the order attached. */
+export declare function readPendingAttachedReferences(threadId: string | null): readonly AttachableReference[];
+/** {@link readPendingAttachedReferences}, re-rendering when the list changes. */
+export declare function usePendingAttachedReferences(threadId: string | null): readonly AttachableReference[];
+/** Forget every pending, staged and sent reference (tests, and a change of identity). */
+export declare function forgetAllAttachedReferences(): void;
+/**
+ * Keep the pending references only while `identity` (the signed-in person) stays the same: a
+ * change forgets every one, so nothing attached under one identity is sent under another.
+ */
+export declare function keepAttachedReferencesForIdentity(identity: string): void;
+/** How long staged references wait for the message they were staged for before they expire. */
+export declare const ATTACHED_REFERENCES_STAGED_TTL_MS = 10000;
+/**
+ * Stage `references` for the message `threadId`'s composer submits next. Call right before the send
+ * (`aui.composer.send`). A send attaching nothing stages nothing and lets an earlier slot go.
+ */
+export declare function stageAttachedReferencesForSend({ threadId, references, }: {
+    threadId: string;
+    references: readonly AttachableReference[];
+}): void;
+/** The references staged for the message `threadId` journals now, taking the slot. */
+export declare function takeStagedAttachedReferences(threadId: string): readonly AttachableReference[];
+/**
+ * The metadata a runtime's `getMessageMetadata` adds for the message `threadId` journals now: the
+ * references staged for it under `attachedReferences`, taking the slot, over `metadata` (what the
+ * rest of the getter produced). `metadata` unchanged when none are staged.
+ */
+export declare function withStagedAttachedReferences(threadId: string, metadata: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
+/**
+ * Right before `threadId`'s composer sends `text`: stage the references pending for it, remember
+ * them with the text (so the text coming back brings them back) and take them off the composer.
+ * Returns what the message carries, `[]` when nothing was attached.
+ */
+export declare function stageThreadAttachedReferencesForSend({ threadId, text, }: {
+    threadId: string;
+    text: string;
+}): readonly AttachableReference[];
+/**
+ * Text a send carried came back to `threadId`'s composer (statewire handed a refused send back):
+ * the references it carried come back as chips, after any attached since.
+ */
+export declare function restoreSentAttachedReferences({ threadId, text, }: {
+    threadId: string;
+    text: string;
+}): void;
+/**
+ * A message held in the chat outbox was given back to the composer (Cancel, Edit): the references
+ * its metadata carries come back as chips.
+ */
+export declare function giveBackHeldAttachedReferences(entry: {
+    threadId: string;
+    metadata?: unknown;
+}): void;

package/dist/composer/attached-references.js

@@ -0,0 +1,159 @@
+import { normalizeAttachableReference, attachableReferenceKey, MAX_ATTACHED_REFERENCES, readAttachedReferences, withAttachedReferences } from "../references/src/attachable.js";
+import { useCallback, useSyncExternalStore } from "react";
+const EMPTY = Object.freeze([]);
+const pending = /* @__PURE__ */ new Map();
+const listeners = /* @__PURE__ */ new Set();
+let attachedForIdentity = null;
+function notify() {
+  for (const listener of [...listeners]) listener();
+}
+function subscribe(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function setPending(threadId, references) {
+  if (references.length === 0) pending.delete(threadId);
+  else pending.set(threadId, Object.freeze([...references]));
+  notify();
+}
+function attachReferenceToThread({
+  threadId,
+  reference
+}) {
+  if (!threadId) return { attached: false, reason: "no_thread" };
+  const normalized = normalizeAttachableReference(reference);
+  if (normalized === null) return { attached: false, reason: "invalid_reference" };
+  const key = attachableReferenceKey(normalized);
+  const current = pending.get(threadId) ?? EMPTY;
+  const index = current.findIndex((entry) => attachableReferenceKey(entry) === key);
+  if (index >= 0) {
+    setPending(
+      threadId,
+      current.map((entry, position) => position === index ? normalized : entry)
+    );
+    return { attached: true, reference: normalized, duplicate: true };
+  }
+  if (current.length >= MAX_ATTACHED_REFERENCES) return { attached: false, reason: "too_many" };
+  setPending(threadId, [...current, normalized]);
+  return { attached: true, reference: normalized, duplicate: false };
+}
+function detachReferenceFromThread({
+  threadId,
+  reference
+}) {
+  if (!threadId) return;
+  const current = pending.get(threadId);
+  if (!current) return;
+  const key = attachableReferenceKey(reference);
+  const kept = current.filter((entry) => attachableReferenceKey(entry) !== key);
+  if (kept.length !== current.length) setPending(threadId, kept);
+}
+function clearAttachedReferences(threadId) {
+  if (!threadId || !pending.has(threadId)) return;
+  setPending(threadId, EMPTY);
+}
+function readPendingAttachedReferences(threadId) {
+  return (threadId ? pending.get(threadId) : void 0) ?? EMPTY;
+}
+function usePendingAttachedReferences(threadId) {
+  const read = useCallback(() => readPendingAttachedReferences(threadId), [threadId]);
+  return useSyncExternalStore(subscribe, read, read);
+}
+function forgetAllAttachedReferences() {
+  pending.clear();
+  stagedForSend.clear();
+  sentWithText.clear();
+  notify();
+}
+function keepAttachedReferencesForIdentity(identity) {
+  if (attachedForIdentity !== null && attachedForIdentity !== identity) {
+    forgetAllAttachedReferences();
+  }
+  attachedForIdentity = identity;
+}
+const ATTACHED_REFERENCES_STAGED_TTL_MS = 1e4;
+const stagedForSend = /* @__PURE__ */ new Map();
+function stageAttachedReferencesForSend({
+  threadId,
+  references
+}) {
+  if (!threadId) return;
+  if (references.length === 0) {
+    stagedForSend.delete(threadId);
+    return;
+  }
+  stagedForSend.set(threadId, { references, stagedAt: Date.now() });
+}
+function takeStagedAttachedReferences(threadId) {
+  const staged = stagedForSend.get(threadId);
+  stagedForSend.delete(threadId);
+  if (!staged || Date.now() - staged.stagedAt > ATTACHED_REFERENCES_STAGED_TTL_MS) return EMPTY;
+  return staged.references;
+}
+function withStagedAttachedReferences(threadId, metadata) {
+  const references = takeStagedAttachedReferences(threadId);
+  return references.length === 0 ? metadata : withAttachedReferences(metadata, references);
+}
+const SENT_TEXTS_KEPT_PER_THREAD = 20;
+const THREADS_WITH_SENT_TEXTS_KEPT = 50;
+const sentWithText = /* @__PURE__ */ new Map();
+function setBounded(map, key, value, limit) {
+  map.delete(key);
+  map.set(key, value);
+  while (map.size > limit) {
+    const oldest = map.keys().next();
+    if (oldest.done) break;
+    map.delete(oldest.value);
+  }
+}
+function stageThreadAttachedReferencesForSend({
+  threadId,
+  text
+}) {
+  const references = readPendingAttachedReferences(threadId);
+  stageAttachedReferencesForSend({ threadId, references });
+  if (!threadId) return references;
+  const texts = sentWithText.get(threadId);
+  if (references.length === 0) {
+    texts == null ? void 0 : texts.delete(text);
+    return references;
+  }
+  const kept = texts ?? /* @__PURE__ */ new Map();
+  setBounded(kept, text, references, SENT_TEXTS_KEPT_PER_THREAD);
+  setBounded(sentWithText, threadId, kept, THREADS_WITH_SENT_TEXTS_KEPT);
+  clearAttachedReferences(threadId);
+  return references;
+}
+function reattach(threadId, references) {
+  for (const reference of references) attachReferenceToThread({ threadId, reference });
+}
+function restoreSentAttachedReferences({
+  threadId,
+  text
+}) {
+  var _a;
+  const references = (_a = sentWithText.get(threadId)) == null ? void 0 : _a.get(text);
+  if (references) reattach(threadId, references);
+}
+function giveBackHeldAttachedReferences(entry) {
+  reattach(entry.threadId, readAttachedReferences(entry.metadata));
+}
+export {
+  ATTACHED_REFERENCES_STAGED_TTL_MS,
+  attachReferenceToThread,
+  clearAttachedReferences,
+  detachReferenceFromThread,
+  forgetAllAttachedReferences,
+  giveBackHeldAttachedReferences,
+  keepAttachedReferencesForIdentity,
+  readPendingAttachedReferences,
+  restoreSentAttachedReferences,
+  stageAttachedReferencesForSend,
+  stageThreadAttachedReferencesForSend,
+  takeStagedAttachedReferences,
+  usePendingAttachedReferences,
+  withStagedAttachedReferences
+};
+//# sourceMappingURL=attached-references.js.map

package/dist/composer/attached-references.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attached-references.js","sources":["../../src/composer/attached-references.ts"],"sourcesContent":["import {\n  type AttachableReference,\n  attachableReferenceKey,\n  MAX_ATTACHED_REFERENCES,\n  normalizeAttachableReference,\n  readAttachedReferences as readMessageAttachedReferences,\n  withAttachedReferences,\n} from '@athenaintel/references/attachable';\nimport { useCallback, useSyncExternalStore } from 'react';\n\n/**\n * What each conversation's next message carries as attached references (`useAttachToChat`), and\n * the hand-off of that list to the message that leaves.\n *\n * - **The pending list.** Per thread, in the order attached, each reference once (by kind and\n *   pointer, an asset's anchor included), at most {@link MAX_ATTACHED_REFERENCES}. The composer\n *   shows it as removable chips (`ComposerAttachedReferences`). It is kept in memory for the page\n *   and dropped when the signed-in identity changes ({@link keepAttachedReferencesForIdentity}):\n *   what one person attached is never sent as someone else's.\n * - **The send.** statewire captures a new message's metadata once, as it journals it\n *   (`getMessageMetadata`), without saying which message it is for. So the composer stages the\n *   list right before `aui.composer.send` ({@link stageAttachedReferencesForSend}) and the runtime's\n *   getter takes it for the message that follows ({@link withStagedAttachedReferences}).\n *   The references then ride the message's own metadata (`attachedReferences`), never its text, so\n *   a send that waits, is retried or is posted again after a reload keeps its own attachments. A\n *   slot nobody takes expires. Both send paths stage them ({@link stageThreadAttachedReferencesForSend}):\n *   `AthenaChat`'s composed send, and `TiptapComposer`'s own through its host's `prepareSend`\n *   (`useAttachedReferencesComposerProps`). A composer whose host doesn't opt in sends none and\n *   never loads this module (the Office pane's budget counts on it).\n * - **The way back.** Sending takes the chips off the composer, and they come back with the send:\n *   a send statewire refuses and hands back ({@link restoreSentAttachedReferences}, by its text),\n *   or a message held in the chat outbox that is cancelled or edited\n *   ({@link giveBackHeldAttachedReferences}, from its metadata).\n *\n * agora reads the list off the message, refuses whatever it can't read, and resolves each one with\n * the person's own permission before the agent is told about it; the client never gates.\n */\n\nconst EMPTY: readonly AttachableReference[] = Object.freeze([]);\n\n// process-local: client-only — the references each thread's composer sends with its next message.\nconst pending = new Map<string, readonly AttachableReference[]>();\nconst listeners = new Set<() => void>();\nlet attachedForIdentity: string | null = null;\n\nfunction notify(): void {\n  for (const listener of [...listeners]) listener();\n}\n\nfunction subscribe(listener: () => void): () => void {\n  listeners.add(listener);\n  return () => {\n    listeners.delete(listener);\n  };\n}\n\nfunction setPending(threadId: string, references: readonly AttachableReference[]): void {\n  if (references.length === 0) pending.delete(threadId);\n  else pending.set(threadId, Object.freeze([...references]));\n  notify();\n}\n\n/** Why a reference was not attached. */\nexport type AttachRefusalReason =\n  /** Not a reference an app may attach (an unknown kind, a malformed id, URL or anchor). */\n  | 'invalid_reference'\n  /** The next message already carries {@link MAX_ATTACHED_REFERENCES}. */\n  | 'too_many'\n  /** No conversation to attach it to (outside `<AthenaProvider>`'s chat). */\n  | 'no_thread';\n\n/** What `attach` did. */\nexport type AttachReferenceResult =\n  | {\n      attached: true;\n      /** The reference as it will be sent (normalized: unknown fields dropped, label cut). */\n      reference: AttachableReference;\n      /** It was attached already; its label is updated and it keeps its place. */\n      duplicate: boolean;\n    }\n  | { attached: false; reason: AttachRefusalReason };\n\n/** Attach `reference` to `threadId`'s next message. */\nexport function attachReferenceToThread({\n  threadId,\n  reference,\n}: {\n  threadId: string | null;\n  reference: unknown;\n}): AttachReferenceResult {\n  if (!threadId) return { attached: false, reason: 'no_thread' };\n  const normalized = normalizeAttachableReference(reference);\n  if (normalized === null) return { attached: false, reason: 'invalid_reference' };\n  const key = attachableReferenceKey(normalized);\n  const current = pending.get(threadId) ?? EMPTY;\n  const index = current.findIndex((entry) => attachableReferenceKey(entry) === key);\n  if (index >= 0) {\n    setPending(\n      threadId,\n      current.map((entry, position) => (position === index ? normalized : entry)),\n    );\n    return { attached: true, reference: normalized, duplicate: true };\n  }\n  if (current.length >= MAX_ATTACHED_REFERENCES) return { attached: false, reason: 'too_many' };\n  setPending(threadId, [...current, normalized]);\n  return { attached: true, reference: normalized, duplicate: false };\n}\n\n/** Take `reference` (matched by kind and pointer) off `threadId`'s next message. */\nexport function detachReferenceFromThread({\n  threadId,\n  reference,\n}: {\n  threadId: string | null;\n  reference: AttachableReference;\n}): void {\n  if (!threadId) return;\n  const current = pending.get(threadId);\n  if (!current) return;\n  const key = attachableReferenceKey(reference);\n  const kept = current.filter((entry) => attachableReferenceKey(entry) !== key);\n  if (kept.length !== current.length) setPending(threadId, kept);\n}\n\n/** Take every reference off `threadId`'s next message. */\nexport function clearAttachedReferences(threadId: string | null): void {\n  if (!threadId || !pending.has(threadId)) return;\n  setPending(threadId, EMPTY);\n}\n\n/** The references `threadId`'s next message carries, in the order attached. */\nexport function readPendingAttachedReferences(threadId: string | null): readonly AttachableReference[] {\n  return (threadId ? pending.get(threadId) : undefined) ?? EMPTY;\n}\n\n/** {@link readPendingAttachedReferences}, re-rendering when the list changes. */\nexport function usePendingAttachedReferences(threadId: string | null): readonly AttachableReference[] {\n  const read = useCallback(() => readPendingAttachedReferences(threadId), [threadId]);\n  return useSyncExternalStore(subscribe, read, read);\n}\n\n/** Forget every pending, staged and sent reference (tests, and a change of identity). */\nexport function forgetAllAttachedReferences(): void {\n  pending.clear();\n  stagedForSend.clear();\n  sentWithText.clear();\n  notify();\n}\n\n/**\n * Keep the pending references only while `identity` (the signed-in person) stays the same: a\n * change forgets every one, so nothing attached under one identity is sent under another.\n */\nexport function keepAttachedReferencesForIdentity(identity: string): void {\n  if (attachedForIdentity !== null && attachedForIdentity !== identity) {\n    forgetAllAttachedReferences();\n  }\n  attachedForIdentity = identity;\n}\n\n// ── The send ────────────────────────────────────────────────────────────────\n\n/** How long staged references wait for the message they were staged for before they expire. */\nexport const ATTACHED_REFERENCES_STAGED_TTL_MS = 10_000;\n\n// process-local: client-only — the references each thread's composer staged for the message it\n// submits next, taken once by the runtime's `getMessageMetadata`.\nconst stagedForSend = new Map<\n  string,\n  { references: readonly AttachableReference[]; stagedAt: number }\n>();\n\n/**\n * Stage `references` for the message `threadId`'s composer submits next. Call right before the send\n * (`aui.composer.send`). A send attaching nothing stages nothing and lets an earlier slot go.\n */\nexport function stageAttachedReferencesForSend({\n  threadId,\n  references,\n}: {\n  threadId: string;\n  references: readonly AttachableReference[];\n}): void {\n  if (!threadId) return;\n  if (references.length === 0) {\n    stagedForSend.delete(threadId);\n    return;\n  }\n  stagedForSend.set(threadId, { references, stagedAt: Date.now() });\n}\n\n/** The references staged for the message `threadId` journals now, taking the slot. */\nexport function takeStagedAttachedReferences(threadId: string): readonly AttachableReference[] {\n  const staged = stagedForSend.get(threadId);\n  stagedForSend.delete(threadId);\n  if (!staged || Date.now() - staged.stagedAt > ATTACHED_REFERENCES_STAGED_TTL_MS) return EMPTY;\n  return staged.references;\n}\n\n/**\n * The metadata a runtime's `getMessageMetadata` adds for the message `threadId` journals now: the\n * references staged for it under `attachedReferences`, taking the slot, over `metadata` (what the\n * rest of the getter produced). `metadata` unchanged when none are staged.\n */\nexport function withStagedAttachedReferences(\n  threadId: string,\n  metadata: Record<string, unknown> | undefined,\n): Record<string, unknown> | undefined {\n  const references = takeStagedAttachedReferences(threadId);\n  return references.length === 0 ? metadata : withAttachedReferences(metadata, references);\n}\n\n/** How many sent texts each thread remembers the references of, and how many threads. */\nconst SENT_TEXTS_KEPT_PER_THREAD = 20;\nconst THREADS_WITH_SENT_TEXTS_KEPT = 50;\n\n// process-local: client-only — the references each recent send carried, by its text, so a send\n// handed back (statewire refused it during a reconnect) brings its chips back.\nconst sentWithText = new Map<string, Map<string, readonly AttachableReference[]>>();\n\nfunction setBounded<K, V>(map: Map<K, V>, key: K, value: V, limit: number): void {\n  map.delete(key);\n  map.set(key, value);\n  while (map.size > limit) {\n    const oldest = map.keys().next();\n    if (oldest.done) break;\n    map.delete(oldest.value);\n  }\n}\n\n/**\n * Right before `threadId`'s composer sends `text`: stage the references pending for it, remember\n * them with the text (so the text coming back brings them back) and take them off the composer.\n * Returns what the message carries, `[]` when nothing was attached.\n */\nexport function stageThreadAttachedReferencesForSend({\n  threadId,\n  text,\n}: {\n  threadId: string;\n  text: string;\n}): readonly AttachableReference[] {\n  const references = readPendingAttachedReferences(threadId);\n  stageAttachedReferencesForSend({ threadId, references });\n  if (!threadId) return references;\n  const texts = sentWithText.get(threadId);\n  if (references.length === 0) {\n    texts?.delete(text);\n    return references;\n  }\n  const kept = texts ?? new Map<string, readonly AttachableReference[]>();\n  setBounded(kept, text, references, SENT_TEXTS_KEPT_PER_THREAD);\n  setBounded(sentWithText, threadId, kept, THREADS_WITH_SENT_TEXTS_KEPT);\n  clearAttachedReferences(threadId);\n  return references;\n}\n\nfunction reattach(threadId: string, references: readonly AttachableReference[]): void {\n  for (const reference of references) attachReferenceToThread({ threadId, reference });\n}\n\n/**\n * Text a send carried came back to `threadId`'s composer (statewire handed a refused send back):\n * the references it carried come back as chips, after any attached since.\n */\nexport function restoreSentAttachedReferences({\n  threadId,\n  text,\n}: {\n  threadId: string;\n  text: string;\n}): void {\n  const references = sentWithText.get(threadId)?.get(text);\n  if (references) reattach(threadId, references);\n}\n\n/**\n * A message held in the chat outbox was given back to the composer (Cancel, Edit): the references\n * its metadata carries come back as chips.\n */\nexport function giveBackHeldAttachedReferences(entry: {\n  threadId: string;\n  metadata?: unknown;\n}): void {\n  reattach(entry.threadId, readMessageAttachedReferences(entry.metadata));\n}\n"],"names":["readMessageAttachedReferences"],"mappings":"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"}