@athenaintel/react 0.28.1 → 0.32.0

package/dist/chat/use-statewire-approval-request.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-statewire-approval-request.cjs","sources":["../../src/chat/use-statewire-approval-request.ts"],"sourcesContent":["import type { StatewireThread } from '@assistant-ui/react-statewire';\nimport {\n  useStatewireRuns,\n  useStatewireSendCommand,\n  useStatewireState,\n} from '@assistant-ui/react-statewire';\nimport {\n  type AbandonedInputRequest,\n  asHitlApproval,\n  findAbandonedInterrupt,\n  HITL_PENDING_RESUME_GRACE_MS,\n  type HitlApprovalPayload,\n  interruptMirrorPayload,\n  isApprovalCardInterrupt,\n  type PendingActionRequest,\n  pendingActionRequests,\n  readAbandonedInputRequests,\n  readInterruptMirror,\n  readQueuedLaneDecisions,\n  useApprovalResumeLock,\n} from '@athenaintel/agent-runtime';\nimport { useCallback, useMemo } from 'react';\nimport { useAthenaRunLive } from './use-athena-run-live';\n\ndeclare module '@assistant-ui/core' {\n  namespace Assistant {\n    interface Commands {\n      /**\n       * Decide per-dispatch subagent lanes while the parent run is still\n       * streaming (`DeepAgentThread.run_lane_input`). Keys are the lanes'\n       * langgraph interrupt ids; the host matches them against the lanes its\n       * mirrored interrupt currently parks, answers at once when the run is\n       * already parked, and otherwise holds them until it parks — stale or\n       * unknown ids are ignored, never carried to a later interrupt.\n       */\n      runLaneInput: {\n        readonly type: 'run/lane-input';\n        readonly laneDecisions: Readonly<Record<string, StatewireThread.InputResponse>>;\n      };\n      /**\n       * Re-send the lane decisions the host still holds queued as their\n       * approver's resume of the parked request (`DeepAgentThread.run_lane_replay`).\n       * The host resumes under the meta the approver's `run/lane-input`\n       * recorded and refuses any other caller — every attached client reads\n       * the same queue, and only the one that queued it may turn it into a\n       * resume. Carries no decisions: the host replays what it recorded.\n       */\n      runLaneReplay: {\n        readonly type: 'run/lane-replay';\n        readonly requestId: string;\n      };\n    }\n  }\n}\n\nconst NO_QUEUED_LANE_DECISIONS: Readonly<Record<string, unknown>> = Object.freeze({});\n\n/** Selects which pending interrupt an approval surface answers. */\nexport type StatewireInterruptPredicate = (\n  request: StatewireThread.InputRequestState,\n) => request is StatewireThread.CustomInputRequest;\n\nexport interface UseStatewireApprovalRequestOptions {\n  /**\n   * Which pending interrupt to answer. Defaults to `isApprovalCardInterrupt`\n   * (client-tool parks excluded — the client-tool bridge owns those, and a\n   * generic resume would corrupt the parked tool call).\n   */\n  interruptPredicate?: StatewireInterruptPredicate;\n  /**\n   * How long a sent decision keeps the actions locked when no resume run ever\n   * starts. Defaults to {@link HITL_PENDING_RESUME_GRACE_MS}.\n   */\n  pendingResumeGraceMs?: number;\n  /**\n   * The host refused the `run/input` (or the transport lost it): the\n   * optimistic fold rolls back, the request is on screen again with its\n   * actions re-enabled, and this is the surface's one chance to say why.\n   */\n  onResumeRejected?: (error: unknown, requestId: string) => void;\n  /** See {@link UseApprovalResumeLockOptions.onResumeRetry}. */\n  onResumeRetry?: (error: unknown, requestId: string, attempt: number) => void;\n}\n\nexport interface StatewireApprovalRequest<TValue> {\n  /** The pending interrupt this surface answers, if any. */\n  request: StatewireThread.CustomInputRequest | undefined;\n  requestId: string | undefined;\n  /** The payload narrowed to the Athena HITL approval shape, or `null`. */\n  hitl: HitlApprovalPayload | null;\n  /** Every gated call the approval covers, in decision order (empty for non-HITL parks). */\n  actionRequests: PendingActionRequest[];\n  /** An interrupt a non-resume dispatch dropped — the \"approval was cancelled\" notice. */\n  abandonedInterrupt: AbandonedInputRequest | undefined;\n  /**\n   * The mirrored interrupt's HITL payload while the run is still live and no\n   * input request is answerable: per-dispatch `task` lanes parked on their\n   * gates while sibling lanes stream. `null` once the run parks (the same\n   * lanes are then `hitl` / `actionRequests`) and when nothing is parked.\n   */\n  liveHitl: HitlApprovalPayload | null;\n  /** Every gated call `liveHitl` covers (empty when it is `null`). */\n  liveActionRequests: PendingActionRequest[];\n  /**\n   * The decisions the host already holds from a `run/lane-input`, keyed by\n   * langgraph interrupt id, to be answered when the run parks — a queued lane\n   * reads as decided on every attached client, not just the one that sent it.\n   */\n  queuedLaneDecisions: Readonly<Record<string, unknown>>;\n  /** True after a resume until the request identity changes (or recovery fires). */\n  pending: boolean;\n  /**\n   * Answer the request with `{ type: 'run/input', requestId, response: { type: 'resume', value } }`.\n   * Returns the dispatch promise (settles when the host accepts, rejects when\n   * it refuses), or `undefined` when the lock dropped the send.\n   */\n  resume: (value: TValue) => Promise<unknown> | undefined;\n  /**\n   * Decide per-dispatch lanes by langgraph interrupt id. With a pending\n   * request this is the native `lane_decisions` resume through the lock;\n   * without one (the run is still streaming siblings) it is `run/lane-input`,\n   * which the host queues and answers on the park. Returns the dispatch\n   * promise, or `undefined` when the lock dropped a resume.\n   */\n  sendLaneDecisions: (\n    lanes: Readonly<Record<string, StatewireThread.InputResponse>>,\n  ) => Promise<unknown> | undefined;\n  /**\n   * Ask the host to resume the parked `requestId` with the lane decisions it\n   * still holds queued, as their approver (`run/lane-replay`). For the card\n   * that queued them, after the host's own answerer has stayed silent past\n   * its budget; the host refuses every other caller. Settles when the host\n   * accepts, rejects when it refuses.\n   */\n  replayQueuedLanes: (requestId: string) => Promise<unknown>;\n}\n\n/**\n * The headless half of every statewire approval surface: selects the pending\n * interrupt from the runs projection, narrows its payload, reads the\n * host-published abandoned interrupts, and wires the shared optimistic resume\n * lock to the thread's `run/input` command. `StatewireApprovalCard` renders\n * over it; hosts with their own decision UI (per-lane subagent cards) build\n * on it directly so the selection and lock semantics cannot drift.\n *\n * Requires a statewire aui scope (throws outside one, like every\n * `useStatewire*` hook) — gate the mount with `hasStatewireThreadExtras`.\n */\nexport function useStatewireApprovalRequest<\n  TValue extends StatewireThread.InputResponse = Record<string, string>,\n>(options: UseStatewireApprovalRequestOptions = {}): StatewireApprovalRequest<TValue> {\n  const {\n    interruptPredicate = isApprovalCardInterrupt,\n    pendingResumeGraceMs = HITL_PENDING_RESUME_GRACE_MS,\n    onResumeRejected,\n    onResumeRetry,\n  } = options;\n  const sendCommand = useStatewireSendCommand();\n  // The runs projection is memoized by the lib, so this derivation is\n  // reference-stable between state updates.\n  const request = useStatewireRuns().inputRequests?.find(interruptPredicate);\n  const requestId = request?.id;\n\n  // The host publishes the interrupts a non-resume dispatch dropped. Select\n  // the raw array reference (pre-stream-safe) and derive inline; a `.find`\n  // selector would return a fresh object every update.\n  const abandoned = useStatewireState(readAbandonedInputRequests);\n  const abandonedInterrupt = findAbandonedInterrupt(abandoned);\n\n  const hitl = asHitlApproval(request?.payload);\n  const actionRequests = useMemo(() => pendingActionRequests(hitl), [hitl]);\n\n  const isRunning = useAthenaRunLive();\n  // The host mirrors the interrupt into state as soon as a lane parks — while\n  // the run manager still reports `running` (siblings streaming) and has no\n  // request to answer. Raw reference selectors; derive inline.\n  const mirror = useStatewireState(readInterruptMirror);\n  const liveHitl =\n    request === undefined && isRunning ? asHitlApproval(interruptMirrorPayload(mirror)) : null;\n  const liveActionRequests = useMemo(() => pendingActionRequests(liveHitl), [liveHitl]);\n  const queuedLaneDecisions =\n    useStatewireState(readQueuedLaneDecisions) ?? NO_QUEUED_LANE_DECISIONS;\n\n  const { pending, resume } = useApprovalResumeLock<TValue>({\n    requestId,\n    isRunning,\n    pendingResumeGraceMs,\n    onResumeRejected,\n    onResumeRetry,\n    // The dispatch promise is handed to the lock: a refusal releases it and\n    // reaches `onResumeRejected`.\n    sendResume: (id, value) =>\n      sendCommand({\n        type: 'run/input',\n        requestId: id,\n        response: { type: 'resume', value },\n      }),\n  });\n\n  const sendLaneDecisions = useCallback(\n    (lanes: Readonly<Record<string, StatewireThread.InputResponse>>) =>\n      requestId !== undefined\n        ? resume({ lane_decisions: lanes } as unknown as TValue)\n        : sendCommand({ type: 'run/lane-input', laneDecisions: lanes }),\n    [requestId, resume, sendCommand],\n  );\n\n  const replayQueuedLanes = useCallback(\n    (id: string) => sendCommand({ type: 'run/lane-replay', requestId: id }),\n    [sendCommand],\n  );\n\n  return {\n    request,\n    requestId,\n    hitl,\n    actionRequests,\n    liveHitl,\n    liveActionRequests,\n    queuedLaneDecisions,\n    abandonedInterrupt,\n    pending,\n    resume,\n    sendLaneDecisions,\n    replayQueuedLanes,\n  };\n}\n"],"names":["isApprovalCardInterrupt","HITL_PENDING_RESUME_GRACE_MS","useStatewireSendCommand","useStatewireRuns","useStatewireState","readAbandonedInputRequests","findAbandonedInterrupt","asHitlApproval","useMemo","pendingActionRequests","useAthenaRunLive","readInterruptMirror","interruptMirrorPayload","readQueuedLaneDecisions","useApprovalResumeLock","useCallback"],"mappings":";;;;;;AAuDA,MAAM,2BAA8D,OAAO,OAAO,EAAE;AA6F7E,SAAS,4BAEd,UAA8C,IAAsC;;AACpF,QAAM;AAAA,IACJ,qBAAqBA,WAAAA;AAAAA,IACrB,uBAAuBC,WAAAA;AAAAA,IACvB;AAAA,IACA;AAAA,EAAA,IACE;AACJ,QAAM,cAAcC,eAAAA,wBAAA;AAGpB,QAAM,WAAUC,oBAAAA,iBAAA,EAAmB,kBAAnBA,mBAAkC,KAAK;AACvD,QAAM,YAAY,mCAAS;AAK3B,QAAM,YAAYC,eAAAA,kBAAkBC,qCAA0B;AAC9D,QAAM,qBAAqBC,WAAAA,uBAAuB,SAAS;AAE3D,QAAM,OAAOC,WAAAA,eAAe,mCAAS,OAAO;AAC5C,QAAM,iBAAiBC,MAAAA,QAAQ,MAAMC,WAAAA,sBAAsB,IAAI,GAAG,CAAC,IAAI,CAAC;AAExE,QAAM,YAAYC,iBAAAA,iBAAA;AAIlB,QAAM,SAASN,eAAAA,kBAAkBO,8BAAmB;AACpD,QAAM,WACJ,YAAY,UAAa,YAAYJ,WAAAA,eAAeK,WAAAA,uBAAuB,MAAM,CAAC,IAAI;AACxF,QAAM,qBAAqBJ,MAAAA,QAAQ,MAAMC,WAAAA,sBAAsB,QAAQ,GAAG,CAAC,QAAQ,CAAC;AACpF,QAAM,sBACJL,eAAAA,kBAAkBS,WAAAA,uBAAuB,KAAK;AAEhD,QAAM,EAAE,SAAS,OAAA,IAAWC,iCAA8B;AAAA,IACxD;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA;AAAA,IAGA,YAAY,CAAC,IAAI,UACf,YAAY;AAAA,MACV,MAAM;AAAA,MACN,WAAW;AAAA,MACX,UAAU,EAAE,MAAM,UAAU,MAAA;AAAA,IAAM,CACnC;AAAA,EAAA,CACJ;AAED,QAAM,oBAAoBC,MAAAA;AAAAA,IACxB,CAAC,UACC,cAAc,SACV,OAAO,EAAE,gBAAgB,MAAA,CAA4B,IACrD,YAAY,EAAE,MAAM,kBAAkB,eAAe,OAAO;AAAA,IAClE,CAAC,WAAW,QAAQ,WAAW;AAAA,EAAA;AAGjC,QAAM,oBAAoBA,MAAAA;AAAAA,IACxB,CAAC,OAAe,YAAY,EAAE,MAAM,mBAAmB,WAAW,IAAI;AAAA,IACtE,CAAC,WAAW;AAAA,EAAA;AAGd,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;;"}
+{"version":3,"file":"use-statewire-approval-request.cjs","sources":["../../src/chat/use-statewire-approval-request.ts"],"sourcesContent":["import type { StatewireThread } from '@assistant-ui/react-statewire';\nimport {\n  useStatewireRuns,\n  useStatewireSendCommand,\n  useStatewireState,\n} from '@assistant-ui/react-statewire';\nimport {\n  type AbandonedInputRequest,\n  asHitlApproval,\n  findAbandonedInterrupt,\n  HITL_PENDING_RESUME_GRACE_MS,\n  type HitlApprovalPayload,\n  interruptMirrorPayload,\n  isApprovalCardInterrupt,\n  laneInterruptIds,\n  type PendingActionRequest,\n  pendingActionRequests,\n  readAbandonedInputRequests,\n  readInterruptMirror,\n  readQueuedLaneDecisions,\n  useApprovalResumeLock,\n} from '@athenaintel/agent-runtime';\nimport { useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from 'react';\nimport { useAthenaRunLive } from './use-athena-run-live';\n\ndeclare module '@assistant-ui/core' {\n  namespace Assistant {\n    interface Commands {\n      /**\n       * Decide per-dispatch subagent lanes while the parent run is still\n       * streaming (`DeepAgentThread.run_lane_input`). Keys are the lanes'\n       * langgraph interrupt ids; the host matches them against the lanes its\n       * mirrored interrupt currently parks, answers at once when the run is\n       * already parked, and otherwise holds them until it parks — stale or\n       * unknown ids are ignored, never carried to a later interrupt.\n       */\n      runLaneInput: {\n        readonly type: 'run/lane-input';\n        readonly laneDecisions: Readonly<Record<string, StatewireThread.InputResponse>>;\n      };\n      /**\n       * Re-send the lane decisions the host still holds queued as their\n       * approver's resume of the parked request (`DeepAgentThread.run_lane_replay`).\n       * The host resumes under the meta the approver's `run/lane-input`\n       * recorded and refuses any other caller — every attached client reads\n       * the same queue, and only the one that queued it may turn it into a\n       * resume. Carries no decisions: the host replays what it recorded.\n       */\n      runLaneReplay: {\n        readonly type: 'run/lane-replay';\n        readonly requestId: string;\n      };\n    }\n  }\n}\n\nconst NO_QUEUED_LANE_DECISIONS: Readonly<Record<string, unknown>> = Object.freeze({});\nconst NO_ACTION_REQUESTS: PendingActionRequest[] = [];\n\n/**\n * Lane ids of the parked requests this client resumed, keyed by request id\n * and shared by every hook instance on the page (approval card,\n * waiting-on-you banner, host editors) so all of them treat a lingering\n * mirror the same way. Request ids are unique per parked interrupt, so an\n * instance only ever consults the record of the request it saw parked: two\n * chats mounted side by side cannot suppress or clear each other's. A record\n * is retired once the host drops that request's mirror (the resume run\n * started), the surface sees a different request park, or it unmounts.\n */\nconst answeredRequests = new Map<string, readonly string[]>();\nconst answeredListeners = new Set<() => void>();\nlet answeredVersion = 0;\nfunction notifyAnswered(): void {\n  answeredVersion += 1;\n  for (const listener of answeredListeners) listener();\n}\nfunction recordAnswered(requestId: string, laneIds: readonly string[]): void {\n  answeredRequests.set(requestId, laneIds);\n  notifyAnswered();\n}\nfunction forgetAnswered(requestId: string): void {\n  if (answeredRequests.delete(requestId)) notifyAnswered();\n}\nfunction subscribeAnswered(listener: () => void): () => void {\n  answeredListeners.add(listener);\n  return () => {\n    answeredListeners.delete(listener);\n  };\n}\nconst readAnsweredVersion = (): number => answeredVersion;\n\n/**\n * The lanes a resume of the parked request settles: every lane of the request\n * (a resume answers the whole park — lanes already queued through\n * `run/lane-input` ride along) plus any lane named in the `lane_decisions` map.\n */\nfunction answeredLaneIds(value: unknown, actionRequests: readonly PendingActionRequest[]): string[] {\n  const ids = laneInterruptIds(actionRequests) ?? [];\n  if (typeof value === 'object' && value !== null && 'lane_decisions' in value) {\n    const lanes = (value as { lane_decisions: unknown }).lane_decisions;\n    if (typeof lanes === 'object' && lanes !== null) {\n      for (const id of Object.keys(lanes)) if (!ids.includes(id)) ids.push(id);\n    }\n  }\n  return ids;\n}\n\n/**\n * Whether the host's mirror still shows an interrupt this client already\n * answered. After `run/input` the host drops the parked request at once but\n * keeps `__interrupt__` until the resume run starts and clears it (seconds on\n * a cold checkpoint); without this check the card would re-offer the SAME\n * approval from the mirror, buttons live, and then fold it away again.\n */\nfunction mirrorAlreadyAnswered(\n  answeredLanes: readonly string[] | undefined,\n  liveActionRequests: readonly PendingActionRequest[],\n): boolean {\n  if (answeredLanes === undefined) return false;\n  const ids = laneInterruptIds(liveActionRequests);\n  if (ids === null) return false;\n  return ids.every((id) => answeredLanes.includes(id));\n}\n\n/** Selects which pending interrupt an approval surface answers. */\nexport type StatewireInterruptPredicate = (\n  request: StatewireThread.InputRequestState,\n) => request is StatewireThread.CustomInputRequest;\n\nexport interface UseStatewireApprovalRequestOptions {\n  /**\n   * Which pending interrupt to answer. Defaults to `isApprovalCardInterrupt`\n   * (client-tool parks excluded — the client-tool bridge owns those, and a\n   * generic resume would corrupt the parked tool call).\n   */\n  interruptPredicate?: StatewireInterruptPredicate;\n  /**\n   * How long a sent decision keeps the actions locked when no resume run ever\n   * starts. Defaults to {@link HITL_PENDING_RESUME_GRACE_MS}.\n   */\n  pendingResumeGraceMs?: number;\n  /**\n   * The host refused the `run/input` (or the transport lost it): the\n   * optimistic fold rolls back, the request is on screen again with its\n   * actions re-enabled, and this is the surface's one chance to say why.\n   */\n  onResumeRejected?: (error: unknown, requestId: string) => void;\n  /** See {@link UseApprovalResumeLockOptions.onResumeRetry}. */\n  onResumeRetry?: (error: unknown, requestId: string, attempt: number) => void;\n}\n\nexport interface StatewireApprovalRequest<TValue> {\n  /** The pending interrupt this surface answers, if any. */\n  request: StatewireThread.CustomInputRequest | undefined;\n  requestId: string | undefined;\n  /** The payload narrowed to the Athena HITL approval shape, or `null`. */\n  hitl: HitlApprovalPayload | null;\n  /** Every gated call the approval covers, in decision order (empty for non-HITL parks). */\n  actionRequests: PendingActionRequest[];\n  /** An interrupt a non-resume dispatch dropped — the \"approval was cancelled\" notice. */\n  abandonedInterrupt: AbandonedInputRequest | undefined;\n  /**\n   * The mirrored interrupt's HITL payload while the run is still live and no\n   * input request is answerable: per-dispatch `task` lanes parked on their\n   * gates while sibling lanes stream. `null` once the run parks (the same\n   * lanes are then `hitl` / `actionRequests`) and when nothing is parked.\n   */\n  liveHitl: HitlApprovalPayload | null;\n  /** Every gated call `liveHitl` covers (empty when it is `null`). */\n  liveActionRequests: PendingActionRequest[];\n  /**\n   * The decisions the host already holds from a `run/lane-input`, keyed by\n   * langgraph interrupt id, to be answered when the run parks — a queued lane\n   * reads as decided on every attached client, not just the one that sent it.\n   */\n  queuedLaneDecisions: Readonly<Record<string, unknown>>;\n  /** True after a resume until the request identity changes (or recovery fires). */\n  pending: boolean;\n  /**\n   * Answer the request with `{ type: 'run/input', requestId, response: { type: 'resume', value } }`.\n   * Returns the dispatch promise (settles when the host accepts, rejects when\n   * it refuses), or `undefined` when the lock dropped the send.\n   */\n  resume: (value: TValue) => Promise<unknown> | undefined;\n  /**\n   * Decide per-dispatch lanes by langgraph interrupt id. With a pending\n   * request this is the native `lane_decisions` resume through the lock;\n   * without one (the run is still streaming siblings) it is `run/lane-input`,\n   * which the host queues and answers on the park. Returns the dispatch\n   * promise, or `undefined` when the lock dropped a resume.\n   */\n  sendLaneDecisions: (\n    lanes: Readonly<Record<string, StatewireThread.InputResponse>>,\n  ) => Promise<unknown> | undefined;\n  /**\n   * Ask the host to resume the parked `requestId` with the lane decisions it\n   * still holds queued, as their approver (`run/lane-replay`). For the card\n   * that queued them, after the host's own answerer has stayed silent past\n   * its budget; the host refuses every other caller. Settles when the host\n   * accepts, rejects when it refuses.\n   */\n  replayQueuedLanes: (requestId: string) => Promise<unknown>;\n}\n\n/**\n * The headless half of every statewire approval surface: selects the pending\n * interrupt from the runs projection, narrows its payload, reads the\n * host-published abandoned interrupts, and wires the shared optimistic resume\n * lock to the thread's `run/input` command. `StatewireApprovalCard` renders\n * over it; hosts with their own decision UI (per-lane subagent cards) build\n * on it directly so the selection and lock semantics cannot drift.\n *\n * Requires a statewire aui scope (throws outside one, like every\n * `useStatewire*` hook) — gate the mount with `hasStatewireThreadExtras`.\n */\nexport function useStatewireApprovalRequest<\n  TValue extends StatewireThread.InputResponse = Record<string, string>,\n>(options: UseStatewireApprovalRequestOptions = {}): StatewireApprovalRequest<TValue> {\n  const {\n    interruptPredicate = isApprovalCardInterrupt,\n    pendingResumeGraceMs = HITL_PENDING_RESUME_GRACE_MS,\n    onResumeRejected,\n    onResumeRetry,\n  } = options;\n  const sendCommand = useStatewireSendCommand();\n  // The runs projection is memoized by the lib, so this derivation is\n  // reference-stable between state updates.\n  const request = useStatewireRuns().inputRequests?.find(interruptPredicate);\n  const requestId = request?.id;\n\n  // The host publishes the interrupts a non-resume dispatch dropped. Select\n  // the raw array reference (pre-stream-safe) and derive inline; a `.find`\n  // selector would return a fresh object every update.\n  const abandoned = useStatewireState(readAbandonedInputRequests);\n  const abandonedInterrupt = findAbandonedInterrupt(abandoned);\n\n  const hitl = asHitlApproval(request?.payload);\n  const actionRequests = useMemo(() => pendingActionRequests(hitl), [hitl]);\n\n  const isRunning = useAthenaRunLive();\n  // The host mirrors the interrupt into state as soon as a lane parks — while\n  // the run manager still reports `running` (siblings streaming) and has no\n  // request to answer. Raw reference selectors; derive inline.\n  const mirror = useStatewireState(readInterruptMirror);\n  const mirrorHitl =\n    request === undefined && isRunning ? asHitlApproval(interruptMirrorPayload(mirror)) : null;\n  const mirrorActionRequests = useMemo(() => pendingActionRequests(mirrorHitl), [mirrorHitl]);\n\n  // The request this surface last saw parked: the only record it may read\n  // or retire (the mirror it watches is the one that request's resume clears).\n  const lastRequestIdRef = useRef<string>(undefined);\n  if (requestId !== undefined) lastRequestIdRef.current = requestId;\n  useSyncExternalStore(subscribeAnswered, readAnsweredVersion, readAnsweredVersion);\n  const answeredLanes =\n    lastRequestIdRef.current === undefined ? undefined : answeredRequests.get(lastRequestIdRef.current);\n  const mirrorCleared = interruptMirrorPayload(mirror) === undefined;\n  useEffect(() => {\n    if (requestId === undefined) return;\n    return () => {\n      // A different request parks next (or this one unparks for good): the\n      // record of this one is stale once it is not the one on screen.\n      if (lastRequestIdRef.current !== requestId) forgetAnswered(requestId);\n    };\n  }, [requestId]);\n  useEffect(() => {\n    if (mirrorCleared && lastRequestIdRef.current !== undefined) forgetAnswered(lastRequestIdRef.current);\n  }, [mirrorCleared]);\n  useEffect(\n    () => () => {\n      if (lastRequestIdRef.current !== undefined) forgetAnswered(lastRequestIdRef.current);\n    },\n    [],\n  );\n  const liveHitl = mirrorAlreadyAnswered(answeredLanes, mirrorActionRequests) ? null : mirrorHitl;\n  const liveActionRequests = liveHitl === mirrorHitl ? mirrorActionRequests : NO_ACTION_REQUESTS;\n  const queuedLaneDecisions =\n    useStatewireState(readQueuedLaneDecisions) ?? NO_QUEUED_LANE_DECISIONS;\n\n  const { pending, resume: resumeLocked } = useApprovalResumeLock<TValue>({\n    requestId,\n    isRunning,\n    pendingResumeGraceMs,\n    onResumeRejected,\n    onResumeRetry,\n    // The dispatch promise is handed to the lock: a refusal releases it and\n    // reaches `onResumeRejected`.\n    sendResume: (id, value) =>\n      sendCommand({\n        type: 'run/input',\n        requestId: id,\n        response: { type: 'resume', value },\n      }),\n  });\n\n  const resume = useCallback(\n    (value: TValue) => {\n      if (requestId !== undefined) {\n        recordAnswered(requestId, answeredLaneIds(value, actionRequests));\n      }\n      return resumeLocked(value);\n    },\n    [requestId, actionRequests, resumeLocked],\n  );\n\n  const sendLaneDecisions = useCallback(\n    (lanes: Readonly<Record<string, StatewireThread.InputResponse>>) =>\n      requestId !== undefined\n        ? resume({ lane_decisions: lanes } as unknown as TValue)\n        : sendCommand({ type: 'run/lane-input', laneDecisions: lanes }),\n    [requestId, resume, sendCommand],\n  );\n\n  const replayQueuedLanes = useCallback(\n    (id: string) => sendCommand({ type: 'run/lane-replay', requestId: id }),\n    [sendCommand],\n  );\n\n  return {\n    request,\n    requestId,\n    hitl,\n    actionRequests,\n    liveHitl,\n    liveActionRequests,\n    queuedLaneDecisions,\n    abandonedInterrupt,\n    pending,\n    resume,\n    sendLaneDecisions,\n    replayQueuedLanes,\n  };\n}\n"],"names":["laneInterruptIds","isApprovalCardInterrupt","HITL_PENDING_RESUME_GRACE_MS","useStatewireSendCommand","useStatewireRuns","useStatewireState","readAbandonedInputRequests","findAbandonedInterrupt","asHitlApproval","useMemo","pendingActionRequests","useAthenaRunLive","readInterruptMirror","interruptMirrorPayload","useRef","useSyncExternalStore","useEffect","readQueuedLaneDecisions","useApprovalResumeLock","useCallback"],"mappings":"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"}

package/dist/chat/use-statewire-approval-request.js

@@ -1,8 +1,46 @@
 import { useStatewireSendCommand, useStatewireRuns, useStatewireState } from "@assistant-ui/react-statewire";
-import { useMemo, useCallback } from "react";
+import { useMemo, useRef, useSyncExternalStore, useEffect, useCallback } from "react";
 import { useAthenaRunLive } from "./use-athena-run-live.js";
-import { isApprovalCardInterrupt, HITL_PENDING_RESUME_GRACE_MS, readAbandonedInputRequests, findAbandonedInterrupt, asHitlApproval, pendingActionRequests, readInterruptMirror, interruptMirrorPayload, readQueuedLaneDecisions, useApprovalResumeLock } from "../packages/agent-runtime/src/interrupts.js";
+import { isApprovalCardInterrupt, HITL_PENDING_RESUME_GRACE_MS, readAbandonedInputRequests, findAbandonedInterrupt, asHitlApproval, pendingActionRequests, readInterruptMirror, interruptMirrorPayload, readQueuedLaneDecisions, useApprovalResumeLock, laneInterruptIds } from "../agent-runtime/src/interrupts.js";
 const NO_QUEUED_LANE_DECISIONS = Object.freeze({});
+const NO_ACTION_REQUESTS = [];
+const answeredRequests = /* @__PURE__ */ new Map();
+const answeredListeners = /* @__PURE__ */ new Set();
+let answeredVersion = 0;
+function notifyAnswered() {
+  answeredVersion += 1;
+  for (const listener of answeredListeners) listener();
+}
+function recordAnswered(requestId, laneIds) {
+  answeredRequests.set(requestId, laneIds);
+  notifyAnswered();
+}
+function forgetAnswered(requestId) {
+  if (answeredRequests.delete(requestId)) notifyAnswered();
+}
+function subscribeAnswered(listener) {
+  answeredListeners.add(listener);
+  return () => {
+    answeredListeners.delete(listener);
+  };
+}
+const readAnsweredVersion = () => answeredVersion;
+function answeredLaneIds(value, actionRequests) {
+  const ids = laneInterruptIds(actionRequests) ?? [];
+  if (typeof value === "object" && value !== null && "lane_decisions" in value) {
+    const lanes = value.lane_decisions;
+    if (typeof lanes === "object" && lanes !== null) {
+      for (const id of Object.keys(lanes)) if (!ids.includes(id)) ids.push(id);
+    }
+  }
+  return ids;
+}
+function mirrorAlreadyAnswered(answeredLanes, liveActionRequests) {
+  if (answeredLanes === void 0) return false;
+  const ids = laneInterruptIds(liveActionRequests);
+  if (ids === null) return false;
+  return ids.every((id) => answeredLanes.includes(id));
+}
 function useStatewireApprovalRequest(options = {}) {
   var _a;
   const {
@@ -20,10 +58,32 @@ function useStatewireApprovalRequest(options = {}) {
   const actionRequests = useMemo(() => pendingActionRequests(hitl), [hitl]);
   const isRunning = useAthenaRunLive();
   const mirror = useStatewireState(readInterruptMirror);
-  const liveHitl = request === void 0 && isRunning ? asHitlApproval(interruptMirrorPayload(mirror)) : null;
-  const liveActionRequests = useMemo(() => pendingActionRequests(liveHitl), [liveHitl]);
+  const mirrorHitl = request === void 0 && isRunning ? asHitlApproval(interruptMirrorPayload(mirror)) : null;
+  const mirrorActionRequests = useMemo(() => pendingActionRequests(mirrorHitl), [mirrorHitl]);
+  const lastRequestIdRef = useRef(void 0);
+  if (requestId !== void 0) lastRequestIdRef.current = requestId;
+  useSyncExternalStore(subscribeAnswered, readAnsweredVersion, readAnsweredVersion);
+  const answeredLanes = lastRequestIdRef.current === void 0 ? void 0 : answeredRequests.get(lastRequestIdRef.current);
+  const mirrorCleared = interruptMirrorPayload(mirror) === void 0;
+  useEffect(() => {
+    if (requestId === void 0) return;
+    return () => {
+      if (lastRequestIdRef.current !== requestId) forgetAnswered(requestId);
+    };
+  }, [requestId]);
+  useEffect(() => {
+    if (mirrorCleared && lastRequestIdRef.current !== void 0) forgetAnswered(lastRequestIdRef.current);
+  }, [mirrorCleared]);
+  useEffect(
+    () => () => {
+      if (lastRequestIdRef.current !== void 0) forgetAnswered(lastRequestIdRef.current);
+    },
+    []
+  );
+  const liveHitl = mirrorAlreadyAnswered(answeredLanes, mirrorActionRequests) ? null : mirrorHitl;
+  const liveActionRequests = liveHitl === mirrorHitl ? mirrorActionRequests : NO_ACTION_REQUESTS;
   const queuedLaneDecisions = useStatewireState(readQueuedLaneDecisions) ?? NO_QUEUED_LANE_DECISIONS;
-  const { pending, resume } = useApprovalResumeLock({
+  const { pending, resume: resumeLocked } = useApprovalResumeLock({
     requestId,
     isRunning,
     pendingResumeGraceMs,
@@ -37,6 +97,15 @@ function useStatewireApprovalRequest(options = {}) {
       response: { type: "resume", value }
     })
   });
+  const resume = useCallback(
+    (value) => {
+      if (requestId !== void 0) {
+        recordAnswered(requestId, answeredLaneIds(value, actionRequests));
+      }
+      return resumeLocked(value);
+    },
+    [requestId, actionRequests, resumeLocked]
+  );
   const sendLaneDecisions = useCallback(
     (lanes) => requestId !== void 0 ? resume({ lane_decisions: lanes }) : sendCommand({ type: "run/lane-input", laneDecisions: lanes }),
     [requestId, resume, sendCommand]

package/dist/chat/use-statewire-approval-request.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-statewire-approval-request.js","sources":["../../src/chat/use-statewire-approval-request.ts"],"sourcesContent":["import type { StatewireThread } from '@assistant-ui/react-statewire';\nimport {\n  useStatewireRuns,\n  useStatewireSendCommand,\n  useStatewireState,\n} from '@assistant-ui/react-statewire';\nimport {\n  type AbandonedInputRequest,\n  asHitlApproval,\n  findAbandonedInterrupt,\n  HITL_PENDING_RESUME_GRACE_MS,\n  type HitlApprovalPayload,\n  interruptMirrorPayload,\n  isApprovalCardInterrupt,\n  type PendingActionRequest,\n  pendingActionRequests,\n  readAbandonedInputRequests,\n  readInterruptMirror,\n  readQueuedLaneDecisions,\n  useApprovalResumeLock,\n} from '@athenaintel/agent-runtime';\nimport { useCallback, useMemo } from 'react';\nimport { useAthenaRunLive } from './use-athena-run-live';\n\ndeclare module '@assistant-ui/core' {\n  namespace Assistant {\n    interface Commands {\n      /**\n       * Decide per-dispatch subagent lanes while the parent run is still\n       * streaming (`DeepAgentThread.run_lane_input`). Keys are the lanes'\n       * langgraph interrupt ids; the host matches them against the lanes its\n       * mirrored interrupt currently parks, answers at once when the run is\n       * already parked, and otherwise holds them until it parks — stale or\n       * unknown ids are ignored, never carried to a later interrupt.\n       */\n      runLaneInput: {\n        readonly type: 'run/lane-input';\n        readonly laneDecisions: Readonly<Record<string, StatewireThread.InputResponse>>;\n      };\n      /**\n       * Re-send the lane decisions the host still holds queued as their\n       * approver's resume of the parked request (`DeepAgentThread.run_lane_replay`).\n       * The host resumes under the meta the approver's `run/lane-input`\n       * recorded and refuses any other caller — every attached client reads\n       * the same queue, and only the one that queued it may turn it into a\n       * resume. Carries no decisions: the host replays what it recorded.\n       */\n      runLaneReplay: {\n        readonly type: 'run/lane-replay';\n        readonly requestId: string;\n      };\n    }\n  }\n}\n\nconst NO_QUEUED_LANE_DECISIONS: Readonly<Record<string, unknown>> = Object.freeze({});\n\n/** Selects which pending interrupt an approval surface answers. */\nexport type StatewireInterruptPredicate = (\n  request: StatewireThread.InputRequestState,\n) => request is StatewireThread.CustomInputRequest;\n\nexport interface UseStatewireApprovalRequestOptions {\n  /**\n   * Which pending interrupt to answer. Defaults to `isApprovalCardInterrupt`\n   * (client-tool parks excluded — the client-tool bridge owns those, and a\n   * generic resume would corrupt the parked tool call).\n   */\n  interruptPredicate?: StatewireInterruptPredicate;\n  /**\n   * How long a sent decision keeps the actions locked when no resume run ever\n   * starts. Defaults to {@link HITL_PENDING_RESUME_GRACE_MS}.\n   */\n  pendingResumeGraceMs?: number;\n  /**\n   * The host refused the `run/input` (or the transport lost it): the\n   * optimistic fold rolls back, the request is on screen again with its\n   * actions re-enabled, and this is the surface's one chance to say why.\n   */\n  onResumeRejected?: (error: unknown, requestId: string) => void;\n  /** See {@link UseApprovalResumeLockOptions.onResumeRetry}. */\n  onResumeRetry?: (error: unknown, requestId: string, attempt: number) => void;\n}\n\nexport interface StatewireApprovalRequest<TValue> {\n  /** The pending interrupt this surface answers, if any. */\n  request: StatewireThread.CustomInputRequest | undefined;\n  requestId: string | undefined;\n  /** The payload narrowed to the Athena HITL approval shape, or `null`. */\n  hitl: HitlApprovalPayload | null;\n  /** Every gated call the approval covers, in decision order (empty for non-HITL parks). */\n  actionRequests: PendingActionRequest[];\n  /** An interrupt a non-resume dispatch dropped — the \"approval was cancelled\" notice. */\n  abandonedInterrupt: AbandonedInputRequest | undefined;\n  /**\n   * The mirrored interrupt's HITL payload while the run is still live and no\n   * input request is answerable: per-dispatch `task` lanes parked on their\n   * gates while sibling lanes stream. `null` once the run parks (the same\n   * lanes are then `hitl` / `actionRequests`) and when nothing is parked.\n   */\n  liveHitl: HitlApprovalPayload | null;\n  /** Every gated call `liveHitl` covers (empty when it is `null`). */\n  liveActionRequests: PendingActionRequest[];\n  /**\n   * The decisions the host already holds from a `run/lane-input`, keyed by\n   * langgraph interrupt id, to be answered when the run parks — a queued lane\n   * reads as decided on every attached client, not just the one that sent it.\n   */\n  queuedLaneDecisions: Readonly<Record<string, unknown>>;\n  /** True after a resume until the request identity changes (or recovery fires). */\n  pending: boolean;\n  /**\n   * Answer the request with `{ type: 'run/input', requestId, response: { type: 'resume', value } }`.\n   * Returns the dispatch promise (settles when the host accepts, rejects when\n   * it refuses), or `undefined` when the lock dropped the send.\n   */\n  resume: (value: TValue) => Promise<unknown> | undefined;\n  /**\n   * Decide per-dispatch lanes by langgraph interrupt id. With a pending\n   * request this is the native `lane_decisions` resume through the lock;\n   * without one (the run is still streaming siblings) it is `run/lane-input`,\n   * which the host queues and answers on the park. Returns the dispatch\n   * promise, or `undefined` when the lock dropped a resume.\n   */\n  sendLaneDecisions: (\n    lanes: Readonly<Record<string, StatewireThread.InputResponse>>,\n  ) => Promise<unknown> | undefined;\n  /**\n   * Ask the host to resume the parked `requestId` with the lane decisions it\n   * still holds queued, as their approver (`run/lane-replay`). For the card\n   * that queued them, after the host's own answerer has stayed silent past\n   * its budget; the host refuses every other caller. Settles when the host\n   * accepts, rejects when it refuses.\n   */\n  replayQueuedLanes: (requestId: string) => Promise<unknown>;\n}\n\n/**\n * The headless half of every statewire approval surface: selects the pending\n * interrupt from the runs projection, narrows its payload, reads the\n * host-published abandoned interrupts, and wires the shared optimistic resume\n * lock to the thread's `run/input` command. `StatewireApprovalCard` renders\n * over it; hosts with their own decision UI (per-lane subagent cards) build\n * on it directly so the selection and lock semantics cannot drift.\n *\n * Requires a statewire aui scope (throws outside one, like every\n * `useStatewire*` hook) — gate the mount with `hasStatewireThreadExtras`.\n */\nexport function useStatewireApprovalRequest<\n  TValue extends StatewireThread.InputResponse = Record<string, string>,\n>(options: UseStatewireApprovalRequestOptions = {}): StatewireApprovalRequest<TValue> {\n  const {\n    interruptPredicate = isApprovalCardInterrupt,\n    pendingResumeGraceMs = HITL_PENDING_RESUME_GRACE_MS,\n    onResumeRejected,\n    onResumeRetry,\n  } = options;\n  const sendCommand = useStatewireSendCommand();\n  // The runs projection is memoized by the lib, so this derivation is\n  // reference-stable between state updates.\n  const request = useStatewireRuns().inputRequests?.find(interruptPredicate);\n  const requestId = request?.id;\n\n  // The host publishes the interrupts a non-resume dispatch dropped. Select\n  // the raw array reference (pre-stream-safe) and derive inline; a `.find`\n  // selector would return a fresh object every update.\n  const abandoned = useStatewireState(readAbandonedInputRequests);\n  const abandonedInterrupt = findAbandonedInterrupt(abandoned);\n\n  const hitl = asHitlApproval(request?.payload);\n  const actionRequests = useMemo(() => pendingActionRequests(hitl), [hitl]);\n\n  const isRunning = useAthenaRunLive();\n  // The host mirrors the interrupt into state as soon as a lane parks — while\n  // the run manager still reports `running` (siblings streaming) and has no\n  // request to answer. Raw reference selectors; derive inline.\n  const mirror = useStatewireState(readInterruptMirror);\n  const liveHitl =\n    request === undefined && isRunning ? asHitlApproval(interruptMirrorPayload(mirror)) : null;\n  const liveActionRequests = useMemo(() => pendingActionRequests(liveHitl), [liveHitl]);\n  const queuedLaneDecisions =\n    useStatewireState(readQueuedLaneDecisions) ?? NO_QUEUED_LANE_DECISIONS;\n\n  const { pending, resume } = useApprovalResumeLock<TValue>({\n    requestId,\n    isRunning,\n    pendingResumeGraceMs,\n    onResumeRejected,\n    onResumeRetry,\n    // The dispatch promise is handed to the lock: a refusal releases it and\n    // reaches `onResumeRejected`.\n    sendResume: (id, value) =>\n      sendCommand({\n        type: 'run/input',\n        requestId: id,\n        response: { type: 'resume', value },\n      }),\n  });\n\n  const sendLaneDecisions = useCallback(\n    (lanes: Readonly<Record<string, StatewireThread.InputResponse>>) =>\n      requestId !== undefined\n        ? resume({ lane_decisions: lanes } as unknown as TValue)\n        : sendCommand({ type: 'run/lane-input', laneDecisions: lanes }),\n    [requestId, resume, sendCommand],\n  );\n\n  const replayQueuedLanes = useCallback(\n    (id: string) => sendCommand({ type: 'run/lane-replay', requestId: id }),\n    [sendCommand],\n  );\n\n  return {\n    request,\n    requestId,\n    hitl,\n    actionRequests,\n    liveHitl,\n    liveActionRequests,\n    queuedLaneDecisions,\n    abandonedInterrupt,\n    pending,\n    resume,\n    sendLaneDecisions,\n    replayQueuedLanes,\n  };\n}\n"],"names":[],"mappings":";;;;AAuDA,MAAM,2BAA8D,OAAO,OAAO,EAAE;AA6F7E,SAAS,4BAEd,UAA8C,IAAsC;;AACpF,QAAM;AAAA,IACJ,qBAAqB;AAAA,IACrB,uBAAuB;AAAA,IACvB;AAAA,IACA;AAAA,EAAA,IACE;AACJ,QAAM,cAAc,wBAAA;AAGpB,QAAM,WAAU,sBAAA,EAAmB,kBAAnB,mBAAkC,KAAK;AACvD,QAAM,YAAY,mCAAS;AAK3B,QAAM,YAAY,kBAAkB,0BAA0B;AAC9D,QAAM,qBAAqB,uBAAuB,SAAS;AAE3D,QAAM,OAAO,eAAe,mCAAS,OAAO;AAC5C,QAAM,iBAAiB,QAAQ,MAAM,sBAAsB,IAAI,GAAG,CAAC,IAAI,CAAC;AAExE,QAAM,YAAY,iBAAA;AAIlB,QAAM,SAAS,kBAAkB,mBAAmB;AACpD,QAAM,WACJ,YAAY,UAAa,YAAY,eAAe,uBAAuB,MAAM,CAAC,IAAI;AACxF,QAAM,qBAAqB,QAAQ,MAAM,sBAAsB,QAAQ,GAAG,CAAC,QAAQ,CAAC;AACpF,QAAM,sBACJ,kBAAkB,uBAAuB,KAAK;AAEhD,QAAM,EAAE,SAAS,OAAA,IAAW,sBAA8B;AAAA,IACxD;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA;AAAA,IAGA,YAAY,CAAC,IAAI,UACf,YAAY;AAAA,MACV,MAAM;AAAA,MACN,WAAW;AAAA,MACX,UAAU,EAAE,MAAM,UAAU,MAAA;AAAA,IAAM,CACnC;AAAA,EAAA,CACJ;AAED,QAAM,oBAAoB;AAAA,IACxB,CAAC,UACC,cAAc,SACV,OAAO,EAAE,gBAAgB,MAAA,CAA4B,IACrD,YAAY,EAAE,MAAM,kBAAkB,eAAe,OAAO;AAAA,IAClE,CAAC,WAAW,QAAQ,WAAW;AAAA,EAAA;AAGjC,QAAM,oBAAoB;AAAA,IACxB,CAAC,OAAe,YAAY,EAAE,MAAM,mBAAmB,WAAW,IAAI;AAAA,IACtE,CAAC,WAAW;AAAA,EAAA;AAGd,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;"}
+{"version":3,"file":"use-statewire-approval-request.js","sources":["../../src/chat/use-statewire-approval-request.ts"],"sourcesContent":["import type { StatewireThread } from '@assistant-ui/react-statewire';\nimport {\n  useStatewireRuns,\n  useStatewireSendCommand,\n  useStatewireState,\n} from '@assistant-ui/react-statewire';\nimport {\n  type AbandonedInputRequest,\n  asHitlApproval,\n  findAbandonedInterrupt,\n  HITL_PENDING_RESUME_GRACE_MS,\n  type HitlApprovalPayload,\n  interruptMirrorPayload,\n  isApprovalCardInterrupt,\n  laneInterruptIds,\n  type PendingActionRequest,\n  pendingActionRequests,\n  readAbandonedInputRequests,\n  readInterruptMirror,\n  readQueuedLaneDecisions,\n  useApprovalResumeLock,\n} from '@athenaintel/agent-runtime';\nimport { useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from 'react';\nimport { useAthenaRunLive } from './use-athena-run-live';\n\ndeclare module '@assistant-ui/core' {\n  namespace Assistant {\n    interface Commands {\n      /**\n       * Decide per-dispatch subagent lanes while the parent run is still\n       * streaming (`DeepAgentThread.run_lane_input`). Keys are the lanes'\n       * langgraph interrupt ids; the host matches them against the lanes its\n       * mirrored interrupt currently parks, answers at once when the run is\n       * already parked, and otherwise holds them until it parks — stale or\n       * unknown ids are ignored, never carried to a later interrupt.\n       */\n      runLaneInput: {\n        readonly type: 'run/lane-input';\n        readonly laneDecisions: Readonly<Record<string, StatewireThread.InputResponse>>;\n      };\n      /**\n       * Re-send the lane decisions the host still holds queued as their\n       * approver's resume of the parked request (`DeepAgentThread.run_lane_replay`).\n       * The host resumes under the meta the approver's `run/lane-input`\n       * recorded and refuses any other caller — every attached client reads\n       * the same queue, and only the one that queued it may turn it into a\n       * resume. Carries no decisions: the host replays what it recorded.\n       */\n      runLaneReplay: {\n        readonly type: 'run/lane-replay';\n        readonly requestId: string;\n      };\n    }\n  }\n}\n\nconst NO_QUEUED_LANE_DECISIONS: Readonly<Record<string, unknown>> = Object.freeze({});\nconst NO_ACTION_REQUESTS: PendingActionRequest[] = [];\n\n/**\n * Lane ids of the parked requests this client resumed, keyed by request id\n * and shared by every hook instance on the page (approval card,\n * waiting-on-you banner, host editors) so all of them treat a lingering\n * mirror the same way. Request ids are unique per parked interrupt, so an\n * instance only ever consults the record of the request it saw parked: two\n * chats mounted side by side cannot suppress or clear each other's. A record\n * is retired once the host drops that request's mirror (the resume run\n * started), the surface sees a different request park, or it unmounts.\n */\nconst answeredRequests = new Map<string, readonly string[]>();\nconst answeredListeners = new Set<() => void>();\nlet answeredVersion = 0;\nfunction notifyAnswered(): void {\n  answeredVersion += 1;\n  for (const listener of answeredListeners) listener();\n}\nfunction recordAnswered(requestId: string, laneIds: readonly string[]): void {\n  answeredRequests.set(requestId, laneIds);\n  notifyAnswered();\n}\nfunction forgetAnswered(requestId: string): void {\n  if (answeredRequests.delete(requestId)) notifyAnswered();\n}\nfunction subscribeAnswered(listener: () => void): () => void {\n  answeredListeners.add(listener);\n  return () => {\n    answeredListeners.delete(listener);\n  };\n}\nconst readAnsweredVersion = (): number => answeredVersion;\n\n/**\n * The lanes a resume of the parked request settles: every lane of the request\n * (a resume answers the whole park — lanes already queued through\n * `run/lane-input` ride along) plus any lane named in the `lane_decisions` map.\n */\nfunction answeredLaneIds(value: unknown, actionRequests: readonly PendingActionRequest[]): string[] {\n  const ids = laneInterruptIds(actionRequests) ?? [];\n  if (typeof value === 'object' && value !== null && 'lane_decisions' in value) {\n    const lanes = (value as { lane_decisions: unknown }).lane_decisions;\n    if (typeof lanes === 'object' && lanes !== null) {\n      for (const id of Object.keys(lanes)) if (!ids.includes(id)) ids.push(id);\n    }\n  }\n  return ids;\n}\n\n/**\n * Whether the host's mirror still shows an interrupt this client already\n * answered. After `run/input` the host drops the parked request at once but\n * keeps `__interrupt__` until the resume run starts and clears it (seconds on\n * a cold checkpoint); without this check the card would re-offer the SAME\n * approval from the mirror, buttons live, and then fold it away again.\n */\nfunction mirrorAlreadyAnswered(\n  answeredLanes: readonly string[] | undefined,\n  liveActionRequests: readonly PendingActionRequest[],\n): boolean {\n  if (answeredLanes === undefined) return false;\n  const ids = laneInterruptIds(liveActionRequests);\n  if (ids === null) return false;\n  return ids.every((id) => answeredLanes.includes(id));\n}\n\n/** Selects which pending interrupt an approval surface answers. */\nexport type StatewireInterruptPredicate = (\n  request: StatewireThread.InputRequestState,\n) => request is StatewireThread.CustomInputRequest;\n\nexport interface UseStatewireApprovalRequestOptions {\n  /**\n   * Which pending interrupt to answer. Defaults to `isApprovalCardInterrupt`\n   * (client-tool parks excluded — the client-tool bridge owns those, and a\n   * generic resume would corrupt the parked tool call).\n   */\n  interruptPredicate?: StatewireInterruptPredicate;\n  /**\n   * How long a sent decision keeps the actions locked when no resume run ever\n   * starts. Defaults to {@link HITL_PENDING_RESUME_GRACE_MS}.\n   */\n  pendingResumeGraceMs?: number;\n  /**\n   * The host refused the `run/input` (or the transport lost it): the\n   * optimistic fold rolls back, the request is on screen again with its\n   * actions re-enabled, and this is the surface's one chance to say why.\n   */\n  onResumeRejected?: (error: unknown, requestId: string) => void;\n  /** See {@link UseApprovalResumeLockOptions.onResumeRetry}. */\n  onResumeRetry?: (error: unknown, requestId: string, attempt: number) => void;\n}\n\nexport interface StatewireApprovalRequest<TValue> {\n  /** The pending interrupt this surface answers, if any. */\n  request: StatewireThread.CustomInputRequest | undefined;\n  requestId: string | undefined;\n  /** The payload narrowed to the Athena HITL approval shape, or `null`. */\n  hitl: HitlApprovalPayload | null;\n  /** Every gated call the approval covers, in decision order (empty for non-HITL parks). */\n  actionRequests: PendingActionRequest[];\n  /** An interrupt a non-resume dispatch dropped — the \"approval was cancelled\" notice. */\n  abandonedInterrupt: AbandonedInputRequest | undefined;\n  /**\n   * The mirrored interrupt's HITL payload while the run is still live and no\n   * input request is answerable: per-dispatch `task` lanes parked on their\n   * gates while sibling lanes stream. `null` once the run parks (the same\n   * lanes are then `hitl` / `actionRequests`) and when nothing is parked.\n   */\n  liveHitl: HitlApprovalPayload | null;\n  /** Every gated call `liveHitl` covers (empty when it is `null`). */\n  liveActionRequests: PendingActionRequest[];\n  /**\n   * The decisions the host already holds from a `run/lane-input`, keyed by\n   * langgraph interrupt id, to be answered when the run parks — a queued lane\n   * reads as decided on every attached client, not just the one that sent it.\n   */\n  queuedLaneDecisions: Readonly<Record<string, unknown>>;\n  /** True after a resume until the request identity changes (or recovery fires). */\n  pending: boolean;\n  /**\n   * Answer the request with `{ type: 'run/input', requestId, response: { type: 'resume', value } }`.\n   * Returns the dispatch promise (settles when the host accepts, rejects when\n   * it refuses), or `undefined` when the lock dropped the send.\n   */\n  resume: (value: TValue) => Promise<unknown> | undefined;\n  /**\n   * Decide per-dispatch lanes by langgraph interrupt id. With a pending\n   * request this is the native `lane_decisions` resume through the lock;\n   * without one (the run is still streaming siblings) it is `run/lane-input`,\n   * which the host queues and answers on the park. Returns the dispatch\n   * promise, or `undefined` when the lock dropped a resume.\n   */\n  sendLaneDecisions: (\n    lanes: Readonly<Record<string, StatewireThread.InputResponse>>,\n  ) => Promise<unknown> | undefined;\n  /**\n   * Ask the host to resume the parked `requestId` with the lane decisions it\n   * still holds queued, as their approver (`run/lane-replay`). For the card\n   * that queued them, after the host's own answerer has stayed silent past\n   * its budget; the host refuses every other caller. Settles when the host\n   * accepts, rejects when it refuses.\n   */\n  replayQueuedLanes: (requestId: string) => Promise<unknown>;\n}\n\n/**\n * The headless half of every statewire approval surface: selects the pending\n * interrupt from the runs projection, narrows its payload, reads the\n * host-published abandoned interrupts, and wires the shared optimistic resume\n * lock to the thread's `run/input` command. `StatewireApprovalCard` renders\n * over it; hosts with their own decision UI (per-lane subagent cards) build\n * on it directly so the selection and lock semantics cannot drift.\n *\n * Requires a statewire aui scope (throws outside one, like every\n * `useStatewire*` hook) — gate the mount with `hasStatewireThreadExtras`.\n */\nexport function useStatewireApprovalRequest<\n  TValue extends StatewireThread.InputResponse = Record<string, string>,\n>(options: UseStatewireApprovalRequestOptions = {}): StatewireApprovalRequest<TValue> {\n  const {\n    interruptPredicate = isApprovalCardInterrupt,\n    pendingResumeGraceMs = HITL_PENDING_RESUME_GRACE_MS,\n    onResumeRejected,\n    onResumeRetry,\n  } = options;\n  const sendCommand = useStatewireSendCommand();\n  // The runs projection is memoized by the lib, so this derivation is\n  // reference-stable between state updates.\n  const request = useStatewireRuns().inputRequests?.find(interruptPredicate);\n  const requestId = request?.id;\n\n  // The host publishes the interrupts a non-resume dispatch dropped. Select\n  // the raw array reference (pre-stream-safe) and derive inline; a `.find`\n  // selector would return a fresh object every update.\n  const abandoned = useStatewireState(readAbandonedInputRequests);\n  const abandonedInterrupt = findAbandonedInterrupt(abandoned);\n\n  const hitl = asHitlApproval(request?.payload);\n  const actionRequests = useMemo(() => pendingActionRequests(hitl), [hitl]);\n\n  const isRunning = useAthenaRunLive();\n  // The host mirrors the interrupt into state as soon as a lane parks — while\n  // the run manager still reports `running` (siblings streaming) and has no\n  // request to answer. Raw reference selectors; derive inline.\n  const mirror = useStatewireState(readInterruptMirror);\n  const mirrorHitl =\n    request === undefined && isRunning ? asHitlApproval(interruptMirrorPayload(mirror)) : null;\n  const mirrorActionRequests = useMemo(() => pendingActionRequests(mirrorHitl), [mirrorHitl]);\n\n  // The request this surface last saw parked: the only record it may read\n  // or retire (the mirror it watches is the one that request's resume clears).\n  const lastRequestIdRef = useRef<string>(undefined);\n  if (requestId !== undefined) lastRequestIdRef.current = requestId;\n  useSyncExternalStore(subscribeAnswered, readAnsweredVersion, readAnsweredVersion);\n  const answeredLanes =\n    lastRequestIdRef.current === undefined ? undefined : answeredRequests.get(lastRequestIdRef.current);\n  const mirrorCleared = interruptMirrorPayload(mirror) === undefined;\n  useEffect(() => {\n    if (requestId === undefined) return;\n    return () => {\n      // A different request parks next (or this one unparks for good): the\n      // record of this one is stale once it is not the one on screen.\n      if (lastRequestIdRef.current !== requestId) forgetAnswered(requestId);\n    };\n  }, [requestId]);\n  useEffect(() => {\n    if (mirrorCleared && lastRequestIdRef.current !== undefined) forgetAnswered(lastRequestIdRef.current);\n  }, [mirrorCleared]);\n  useEffect(\n    () => () => {\n      if (lastRequestIdRef.current !== undefined) forgetAnswered(lastRequestIdRef.current);\n    },\n    [],\n  );\n  const liveHitl = mirrorAlreadyAnswered(answeredLanes, mirrorActionRequests) ? null : mirrorHitl;\n  const liveActionRequests = liveHitl === mirrorHitl ? mirrorActionRequests : NO_ACTION_REQUESTS;\n  const queuedLaneDecisions =\n    useStatewireState(readQueuedLaneDecisions) ?? NO_QUEUED_LANE_DECISIONS;\n\n  const { pending, resume: resumeLocked } = useApprovalResumeLock<TValue>({\n    requestId,\n    isRunning,\n    pendingResumeGraceMs,\n    onResumeRejected,\n    onResumeRetry,\n    // The dispatch promise is handed to the lock: a refusal releases it and\n    // reaches `onResumeRejected`.\n    sendResume: (id, value) =>\n      sendCommand({\n        type: 'run/input',\n        requestId: id,\n        response: { type: 'resume', value },\n      }),\n  });\n\n  const resume = useCallback(\n    (value: TValue) => {\n      if (requestId !== undefined) {\n        recordAnswered(requestId, answeredLaneIds(value, actionRequests));\n      }\n      return resumeLocked(value);\n    },\n    [requestId, actionRequests, resumeLocked],\n  );\n\n  const sendLaneDecisions = useCallback(\n    (lanes: Readonly<Record<string, StatewireThread.InputResponse>>) =>\n      requestId !== undefined\n        ? resume({ lane_decisions: lanes } as unknown as TValue)\n        : sendCommand({ type: 'run/lane-input', laneDecisions: lanes }),\n    [requestId, resume, sendCommand],\n  );\n\n  const replayQueuedLanes = useCallback(\n    (id: string) => sendCommand({ type: 'run/lane-replay', requestId: id }),\n    [sendCommand],\n  );\n\n  return {\n    request,\n    requestId,\n    hitl,\n    actionRequests,\n    liveHitl,\n    liveActionRequests,\n    queuedLaneDecisions,\n    abandonedInterrupt,\n    pending,\n    resume,\n    sendLaneDecisions,\n    replayQueuedLanes,\n  };\n}\n"],"names":[],"mappings":";;;;AAwDA,MAAM,2BAA8D,OAAO,OAAO,EAAE;AACpF,MAAM,qBAA6C,CAAA;AAYnD,MAAM,uCAAuB,IAAA;AAC7B,MAAM,wCAAwB,IAAA;AAC9B,IAAI,kBAAkB;AACtB,SAAS,iBAAuB;AAC9B,qBAAmB;AACnB,aAAW,YAAY,kBAAmB,UAAA;AAC5C;AACA,SAAS,eAAe,WAAmB,SAAkC;AAC3E,mBAAiB,IAAI,WAAW,OAAO;AACvC,iBAAA;AACF;AACA,SAAS,eAAe,WAAyB;AAC/C,MAAI,iBAAiB,OAAO,SAAS,EAAG,gBAAA;AAC1C;AACA,SAAS,kBAAkB,UAAkC;AAC3D,oBAAkB,IAAI,QAAQ;AAC9B,SAAO,MAAM;AACX,sBAAkB,OAAO,QAAQ;AAAA,EACnC;AACF;AACA,MAAM,sBAAsB,MAAc;AAO1C,SAAS,gBAAgB,OAAgB,gBAA2D;AAClG,QAAM,MAAM,iBAAiB,cAAc,KAAK,CAAA;AAChD,MAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,oBAAoB,OAAO;AAC5E,UAAM,QAAS,MAAsC;AACrD,QAAI,OAAO,UAAU,YAAY,UAAU,MAAM;AAC/C,iBAAW,MAAM,OAAO,KAAK,KAAK,EAAG,KAAI,CAAC,IAAI,SAAS,EAAE,EAAG,KAAI,KAAK,EAAE;AAAA,IACzE;AAAA,EACF;AACA,SAAO;AACT;AASA,SAAS,sBACP,eACA,oBACS;AACT,MAAI,kBAAkB,OAAW,QAAO;AACxC,QAAM,MAAM,iBAAiB,kBAAkB;AAC/C,MAAI,QAAQ,KAAM,QAAO;AACzB,SAAO,IAAI,MAAM,CAAC,OAAO,cAAc,SAAS,EAAE,CAAC;AACrD;AA6FO,SAAS,4BAEd,UAA8C,IAAsC;;AACpF,QAAM;AAAA,IACJ,qBAAqB;AAAA,IACrB,uBAAuB;AAAA,IACvB;AAAA,IACA;AAAA,EAAA,IACE;AACJ,QAAM,cAAc,wBAAA;AAGpB,QAAM,WAAU,sBAAA,EAAmB,kBAAnB,mBAAkC,KAAK;AACvD,QAAM,YAAY,mCAAS;AAK3B,QAAM,YAAY,kBAAkB,0BAA0B;AAC9D,QAAM,qBAAqB,uBAAuB,SAAS;AAE3D,QAAM,OAAO,eAAe,mCAAS,OAAO;AAC5C,QAAM,iBAAiB,QAAQ,MAAM,sBAAsB,IAAI,GAAG,CAAC,IAAI,CAAC;AAExE,QAAM,YAAY,iBAAA;AAIlB,QAAM,SAAS,kBAAkB,mBAAmB;AACpD,QAAM,aACJ,YAAY,UAAa,YAAY,eAAe,uBAAuB,MAAM,CAAC,IAAI;AACxF,QAAM,uBAAuB,QAAQ,MAAM,sBAAsB,UAAU,GAAG,CAAC,UAAU,CAAC;AAI1F,QAAM,mBAAmB,OAAe,MAAS;AACjD,MAAI,cAAc,OAAW,kBAAiB,UAAU;AACxD,uBAAqB,mBAAmB,qBAAqB,mBAAmB;AAChF,QAAM,gBACJ,iBAAiB,YAAY,SAAY,SAAY,iBAAiB,IAAI,iBAAiB,OAAO;AACpG,QAAM,gBAAgB,uBAAuB,MAAM,MAAM;AACzD,YAAU,MAAM;AACd,QAAI,cAAc,OAAW;AAC7B,WAAO,MAAM;AAGX,UAAI,iBAAiB,YAAY,UAAW,gBAAe,SAAS;AAAA,IACtE;AAAA,EACF,GAAG,CAAC,SAAS,CAAC;AACd,YAAU,MAAM;AACd,QAAI,iBAAiB,iBAAiB,YAAY,OAAW,gBAAe,iBAAiB,OAAO;AAAA,EACtG,GAAG,CAAC,aAAa,CAAC;AAClB;AAAA,IACE,MAAM,MAAM;AACV,UAAI,iBAAiB,YAAY,OAAW,gBAAe,iBAAiB,OAAO;AAAA,IACrF;AAAA,IACA,CAAA;AAAA,EAAC;AAEH,QAAM,WAAW,sBAAsB,eAAe,oBAAoB,IAAI,OAAO;AACrF,QAAM,qBAAqB,aAAa,aAAa,uBAAuB;AAC5E,QAAM,sBACJ,kBAAkB,uBAAuB,KAAK;AAEhD,QAAM,EAAE,SAAS,QAAQ,aAAA,IAAiB,sBAA8B;AAAA,IACtE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA;AAAA,IAGA,YAAY,CAAC,IAAI,UACf,YAAY;AAAA,MACV,MAAM;AAAA,MACN,WAAW;AAAA,MACX,UAAU,EAAE,MAAM,UAAU,MAAA;AAAA,IAAM,CACnC;AAAA,EAAA,CACJ;AAED,QAAM,SAAS;AAAA,IACb,CAAC,UAAkB;AACjB,UAAI,cAAc,QAAW;AAC3B,uBAAe,WAAW,gBAAgB,OAAO,cAAc,CAAC;AAAA,MAClE;AACA,aAAO,aAAa,KAAK;AAAA,IAC3B;AAAA,IACA,CAAC,WAAW,gBAAgB,YAAY;AAAA,EAAA;AAG1C,QAAM,oBAAoB;AAAA,IACxB,CAAC,UACC,cAAc,SACV,OAAO,EAAE,gBAAgB,MAAA,CAA4B,IACrD,YAAY,EAAE,MAAM,kBAAkB,eAAe,OAAO;AAAA,IAClE,CAAC,WAAW,QAAQ,WAAW;AAAA,EAAA;AAGjC,QAAM,oBAAoB;AAAA,IACxB,CAAC,OAAe,YAAY,EAAE,MAAM,mBAAmB,WAAW,IAAI;AAAA,IACtE,CAAC,WAAW;AAAA,EAAA;AAGd,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;"}

package/dist/chat-ui/composer/composer-message.cjs

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("@tiptap/core");
+const model = require("@tiptap/pm/model");
+const markdownStorage = require("../markdown-storage.cjs");
+const composerMarkdown = require("../../agent-runtime/src/composer-markdown.cjs");
+function serializeComposerMessage(editor) {
+  const storage = markdownStorage.getMarkdownStorage(editor);
+  const serializer = storage.serializer;
+  if (!isTiptapMarkdownSerializer(serializer)) {
+    return storage.getMarkdown();
+  }
+  return verbatimTextSerializer(serializer).serialize(editor.state.doc);
+}
+const isRecord = (value) => typeof value === "object" && value !== null;
+function isTiptapMarkdownSerializer(value) {
+  if (!isRecord(value) || typeof Reflect.get(value, "serialize") !== "function") return false;
+  const nodes = Reflect.get(value, "nodes");
+  return isRecord(nodes) && typeof nodes.text === "function";
+}
+const writeTextVerbatim = (state, node) => {
+  state.text(node.text ?? "", false);
+};
+function writeLineBreak(draftLineBreak) {
+  return (state, node, parent, index) => {
+    if (state.inTable) {
+      draftLineBreak(state, node, parent, index);
+      return;
+    }
+    for (let next = index + 1; next < parent.childCount; next++) {
+      if (parent.child(next).type !== node.type) {
+        state.write("\n");
+        return;
+      }
+    }
+  };
+}
+function verbatimTextSerializer(serializer) {
+  const nodes = serializer.nodes;
+  const draftLineBreak = nodes.hardBreak;
+  return Object.create(serializer, {
+    nodes: {
+      value: {
+        ...nodes,
+        text: writeTextVerbatim,
+        ...draftLineBreak && { hardBreak: writeLineBreak(draftLineBreak) }
+      }
+    }
+  });
+}
+function escapeBareUnderscores(text) {
+  let escaped = "";
+  let backslashes = 0;
+  for (const character of text) {
+    if (character === "_" && backslashes % 2 === 0) escaped += "\\";
+    escaped += character;
+    backslashes = character === "\\" ? backslashes + 1 : 0;
+  }
+  return escaped;
+}
+const CHARACTER_REFERENCE_AMPERSAND = /&(?=(?:[A-Za-z][A-Za-z0-9]*|#[0-9]+|#[xX][0-9A-Fa-f]+);)/g;
+function escapeCharacterReferences(text) {
+  return text.replace(CHARACTER_REFERENCE_AMPERSAND, "&amp;");
+}
+function writeTextForDraft(draftText) {
+  return (state, node, parent, index) => {
+    if (state.inAutolink) {
+      state.text(node.text ?? "", false);
+      return;
+    }
+    const typed = node.text ?? "";
+    const referencesKept = escapeCharacterReferences(typed);
+    const textNode = referencesKept === typed ? node : node.type.schema.text(referencesKept, node.marks);
+    const escapeText = state.esc;
+    state.esc = (text, startOfLine) => escapeBareUnderscores(escapeText.call(state, text, startOfLine));
+    try {
+      draftText(state, textNode, parent, index);
+    } finally {
+      state.esc = escapeText;
+    }
+  };
+}
+function draftTextSerializer(serializer) {
+  const nodes = serializer.nodes;
+  const draftText = nodes.text;
+  if (!draftText) return serializer;
+  return Object.create(serializer, {
+    nodes: { value: { ...nodes, text: writeTextForDraft(draftText) } }
+  });
+}
+const LINE_START_REFERENCES = { " ": "&#32;", "	": "&#9;" };
+const STAND_IN_CANDIDATES = [
+  " ",
+  " ",
+  " ",
+  " ",
+  " ",
+  " ",
+  " ",
+  " ",
+  " ",
+  " ",
+  " ",
+  " ",
+  " ",
+  "　"
+];
+function standInsFor(doc) {
+  const held = JSON.stringify(doc.toJSON());
+  const [space, tab] = STAND_IN_CANDIDATES.filter((candidate) => !held.includes(candidate));
+  return space !== void 0 && tab !== void 0 ? { " ": space, "	": tab } : null;
+}
+const isLineStartWhitespace = (character) => character === " " || character === "	";
+function withLineStandIns({
+  textblock,
+  standIns
+}) {
+  const { schema } = textblock.type;
+  const lineBreak = schema.linebreakReplacement;
+  const isBlank = (child) => child.isText ? !/\S/.test(child.text ?? "") : child.type === lineBreak;
+  let blank = true;
+  textblock.forEach((child) => {
+    blank && (blank = isBlank(child));
+  });
+  if (blank) return { node: textblock, replaced: 0 };
+  const children = [];
+  let replaced = 0;
+  let atLineStart = true;
+  textblock.forEach((child) => {
+    const lineStart = atLineStart;
+    atLineStart = child.type === lineBreak;
+    const text = child.isText ? child.text ?? "" : "";
+    const first = text.charAt(0);
+    if (lineStart && isLineStartWhitespace(first) && !child.marks.some((mark) => mark.type.spec.code)) {
+      replaced += 1;
+      children.push(schema.text(standIns[first] + text.slice(1), child.marks));
+    } else {
+      children.push(child);
+    }
+  });
+  return replaced > 0 ? { node: textblock.copy(model.Fragment.from(children)), replaced } : { node: textblock, replaced: 0 };
+}
+function withLeadingWhitespaceStandIns({
+  doc,
+  standIns
+}) {
+  let replaced = 0;
+  const map = (node) => {
+    if (node.isTextblock) {
+      if (node.type.spec.code) return node;
+      const lines = withLineStandIns({ textblock: node, standIns });
+      replaced += lines.replaced;
+      return lines.node;
+    }
+    if (node.isLeaf) return node;
+    const children = [];
+    let changed = false;
+    node.forEach((child) => {
+      const mapped2 = map(child);
+      changed || (changed = mapped2 !== child);
+      children.push(mapped2);
+    });
+    return changed ? node.copy(model.Fragment.from(children)) : node;
+  };
+  const mapped = map(doc);
+  return { doc: mapped, replaced };
+}
+function serializeComposerDraft(editor) {
+  const storage = markdownStorage.getMarkdownStorage(editor);
+  const serializer = storage.serializer;
+  if (!isTiptapMarkdownSerializer(serializer)) return storage.getMarkdown();
+  const draft = draftTextSerializer(serializer);
+  const source = editor.state.doc;
+  const standIns = standInsFor(source);
+  if (standIns === null) return draft.serialize(source);
+  const lines = withLeadingWhitespaceStandIns({ doc: source, standIns });
+  if (lines.replaced === 0) return draft.serialize(source);
+  const written = draft.serialize(lines.doc);
+  const references = /* @__PURE__ */ new Map([
+    [standIns[" "], LINE_START_REFERENCES[" "]],
+    [standIns["	"], LINE_START_REFERENCES["	"]]
+  ]);
+  const characters = Array.from(written);
+  const standInCount = characters.filter((character) => references.has(character)).length;
+  if (standInCount !== lines.replaced) return draft.serialize(source);
+  return characters.map((character) => references.get(character) ?? character).join("");
+}
+const LINE_START_WHITESPACE_REFERENCES = new Set(
+  Object.values(LINE_START_REFERENCES)
+);
+const KEPT_WHITESPACE_TOKEN = "athena_kept_whitespace";
+const COLLAPSIBLE_WHITESPACE = /[ \t]{2,}|\t/g;
+const keptWhitespace = (whitespace) => `<athena-whitespace style="white-space: pre-wrap">${whitespace}</athena-whitespace>`;
+const draftWhitespaceParsers = /* @__PURE__ */ new WeakSet();
+function keepDraftWhitespace(markdownit) {
+  if (draftWhitespaceParsers.has(markdownit)) return;
+  draftWhitespaceParsers.add(markdownit);
+  markdownit.core.ruler.before("text_join", "athena_kept_whitespace", (state) => {
+    for (const block of state.tokens) {
+      const inline = block.children ?? [];
+      inline.forEach((token, index) => {
+        var _a;
+        if (token.type !== "text_special" || token.info !== "entity") return;
+        if (!LINE_START_WHITESPACE_REFERENCES.has(token.markup)) return;
+        token.type = KEPT_WHITESPACE_TOKEN;
+        const next = inline[index + 1];
+        if ((next == null ? void 0 : next.type) !== "text") return;
+        const run = ((_a = /^[ \t]*/.exec(next.content)) == null ? void 0 : _a[0]) ?? "";
+        token.content += run;
+        next.content = next.content.slice(run.length);
+      });
+    }
+  });
+  const { rules } = markdownit.renderer;
+  rules[KEPT_WHITESPACE_TOKEN] = (tokens, index) => {
+    var _a;
+    return keptWhitespace(((_a = tokens[index]) == null ? void 0 : _a.content) ?? "");
+  };
+  for (const name of ["text", "code_inline"]) {
+    const render = rules[name];
+    if (!render) continue;
+    rules[name] = (...args) => render(...args).replace(COLLAPSIBLE_WHITESPACE, keptWhitespace);
+  }
+}
+const ComposerDraftWhitespace = core.Extension.create({
+  name: "athenaComposerDraftWhitespace",
+  addStorage() {
+    return { markdown: { parse: { setup: keepDraftWhitespace } } };
+  }
+});
+function captureComposerSend(editor) {
+  return {
+    text: serializeComposerMessage(editor).trim(),
+    draftMarkdown: composerMarkdown.trimComposerDraft(serializeComposerDraft(editor))
+  };
+}
+const REMEMBERED_SENDS = 50;
+const RETURNED_SEND_WINDOW_MS = 6e4;
+const sends = /* @__PURE__ */ new Map();
+const sendKey = ({ threadId, text }) => JSON.stringify([threadId, text]);
+const isFresh = (send, now) => now - send.sentAt <= RETURNED_SEND_WINDOW_MS;
+function rememberComposerSend({
+  threadId,
+  text,
+  draftMarkdown,
+  now = Date.now()
+}) {
+  const key = sendKey({ threadId, text });
+  const remembered = sends.get(key);
+  sends.delete(key);
+  const collides = remembered !== void 0 && isFresh(remembered, now) && remembered.draft !== draftMarkdown;
+  sends.set(key, { draft: collides ? null : draftMarkdown, sentAt: now });
+  while (sends.size > REMEMBERED_SENDS) {
+    const oldest = sends.keys().next();
+    if (oldest.done) break;
+    sends.delete(oldest.value);
+  }
+}
+function draftForReturnedSend({
+  threadId,
+  text,
+  now = Date.now()
+}) {
+  const remembered = sends.get(sendKey({ threadId, text }));
+  return remembered !== void 0 && isFresh(remembered, now) ? remembered.draft : null;
+}
+function prepareComposerSend({
+  threadId,
+  text,
+  draftMarkdown
+}) {
+  rememberComposerSend({ threadId, text, draftMarkdown });
+  composerMarkdown.stageComposerMarkdown({ threadId, text, markdown: draftMarkdown });
+}
+exports.ComposerDraftWhitespace = ComposerDraftWhitespace;
+exports.RETURNED_SEND_WINDOW_MS = RETURNED_SEND_WINDOW_MS;
+exports.captureComposerSend = captureComposerSend;
+exports.draftForReturnedSend = draftForReturnedSend;
+exports.escapeCharacterReferences = escapeCharacterReferences;
+exports.prepareComposerSend = prepareComposerSend;
+exports.rememberComposerSend = rememberComposerSend;
+exports.serializeComposerDraft = serializeComposerDraft;
+exports.serializeComposerMessage = serializeComposerMessage;
+//# sourceMappingURL=composer-message.cjs.map

package/dist/chat-ui/composer/composer-message.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"composer-message.cjs","sources":["../../../src/chat-ui/composer/composer-message.ts"],"sourcesContent":["import { stageComposerMarkdown, trimComposerDraft } from \"@athenaintel/agent-runtime\";\nimport { type Editor, Extension } from \"@tiptap/core\";\nimport { Fragment, type Node as ProseMirrorNode } from \"@tiptap/pm/model\";\nimport { getMarkdownStorage } from \"../markdown-storage\";\n\n/**\n * The composer's draft as it is sent: its Markdown with every plain-text run\n * written exactly as it was typed. The Olympus chat composer sends the same\n * way (`olympus/src/components/textbox/composer-message-markdown.ts`).\n *\n * `getMarkdown()` escapes plain text for Markdown: prosemirror-markdown's\n * `esc()` puts a backslash before `` ` * \\ ~ [ ] _ `` (and before `#`, `-`,\n * `+`, `>` and `1.` at the start of a line), and tiptap-markdown's text\n * serializer turns `<` and `>` into `&lt;` and `&gt;`. That is right for a\n * draft, which is parsed back, but the sent text is what the model reads, and\n * it reads it literally: `C:\\Users` arrived as `C:\\\\Users`, `arr[0]` as\n * `arr\\[0\\]` and `List<T>` as `List&lt;T&gt;`. A line break typed with\n * Shift+Enter is Markdown's hard break, `\\` before the newline, in the draft;\n * it goes out as the newline alone.\n *\n * Only the plain-text runs and line breaks change. Formatting still\n * serializes as Markdown (bold, italic, strike, inline code, code blocks,\n * lists, headings, links, tables), mention chips still write their `[@Name](url)`\n * links, and code spans and blocks were never escaped.\n */\nexport function serializeComposerMessage(editor: Editor): string {\n  const storage = getMarkdownStorage(editor);\n  const serializer: unknown = storage.serializer;\n  if (!isTiptapMarkdownSerializer(serializer)) {\n    // A tiptap-markdown upgrade that reshaped its serializer: keep sending (the\n    // escaped draft) rather than fail the send. The tests pin the verbatim\n    // output, so such an upgrade fails CI before it ships.\n    return storage.getMarkdown();\n  }\n  return verbatimTextSerializer(serializer).serialize(editor.state.doc);\n}\n\n/** What prosemirror-markdown's serializer state offers a node serializer, as far as text goes. */\ninterface MarkdownSerializerState {\n  /** Writes `text`, escaping it for Markdown unless `escapeMarkdown` is `false`. */\n  text(text: string, escapeMarkdown?: boolean): void;\n  /** The escape `text()` applies to each line (prosemirror-markdown 1.13's `esc()`). */\n  esc(text: string, startOfLine?: boolean): string;\n  /** Writes `content` as is, after the enclosing blocks' line prefix when a line starts. */\n  write(content?: string): void;\n  /** True while a table serializer writes a table. */\n  readonly inTable?: boolean;\n  /**\n   * True while prosemirror-markdown writes a link whose text is its URL as an\n   * autolink (`<https://…>`), where Markdown reads no backslash escapes.\n   */\n  readonly inAutolink?: boolean;\n}\n\ntype MarkdownNodeSerializer = (\n  state: MarkdownSerializerState,\n  node: ProseMirrorNode,\n  parent: ProseMirrorNode,\n  index: number,\n) => void;\n\n/**\n * The slice of tiptap-markdown 0.9.0's `MarkdownSerializer` this module uses.\n * `nodes` is a getter mapping every schema node type to its Markdown spec's\n * `serialize`, and `serialize(doc)` builds the serializer state from\n * `this.nodes` and `this.marks`, so an object whose prototype is the editor's\n * serializer and whose own `nodes` replaces `text` and `hardBreak` serializes\n * everything else exactly as `getMarkdown()` does.\n */\ninterface TiptapMarkdownSerializer {\n  readonly nodes: Readonly<Record<string, MarkdownNodeSerializer | undefined>>;\n  serialize(content: ProseMirrorNode): string;\n}\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null;\n\nfunction isTiptapMarkdownSerializer(value: unknown): value is TiptapMarkdownSerializer {\n  if (!isRecord(value) || typeof Reflect.get(value, \"serialize\") !== \"function\") return false;\n  const nodes: unknown = Reflect.get(value, \"nodes\");\n  return isRecord(nodes) && typeof nodes.text === \"function\";\n}\n\nconst writeTextVerbatim: MarkdownNodeSerializer = (state, node) => {\n  state.text(node.text ?? \"\", false);\n};\n\n/**\n * A hard break as a plain newline. The draft's serializer (tiptap-markdown's\n * `hard-break.js`) keeps the rest: it writes nothing for a break with only\n * breaks after it, and inside a table, where a cell holds one line, it writes\n * a `<br>` tag.\n */\nfunction writeLineBreak(draftLineBreak: MarkdownNodeSerializer): MarkdownNodeSerializer {\n  return (state, node, parent, index) => {\n    if (state.inTable) {\n      draftLineBreak(state, node, parent, index);\n      return;\n    }\n    for (let next = index + 1; next < parent.childCount; next++) {\n      if (parent.child(next).type !== node.type) {\n        state.write(\"\\n\");\n        return;\n      }\n    }\n  };\n}\n\nfunction verbatimTextSerializer(serializer: TiptapMarkdownSerializer): TiptapMarkdownSerializer {\n  const nodes = serializer.nodes;\n  const draftLineBreak = nodes.hardBreak;\n  return Object.create(serializer, {\n    nodes: {\n      value: {\n        ...nodes,\n        text: writeTextVerbatim,\n        ...(draftLineBreak && { hardBreak: writeLineBreak(draftLineBreak) }),\n      },\n    },\n  });\n}\n\n/**\n * `text` with every underscore that is not already escaped escaped:\n * prosemirror-markdown's `esc()` leaves an underscore between two word\n * characters bare, and an underscore after an odd run of backslashes is one it\n * escaped itself.\n */\nfunction escapeBareUnderscores(text: string): string {\n  let escaped = \"\";\n  let backslashes = 0;\n  for (const character of text) {\n    if (character === \"_\" && backslashes % 2 === 0) escaped += \"\\\\\";\n    escaped += character;\n    backslashes = character === \"\\\\\" ? backslashes + 1 : 0;\n  }\n  return escaped;\n}\n\n/**\n * An `&` that starts a character reference (`&lt;`, `&copy;`, `&#60;`,\n * `&#x3C;`): Markdown decodes those, so typed `&lt;` read back as `<`.\n */\nconst CHARACTER_REFERENCE_AMPERSAND = /&(?=(?:[A-Za-z][A-Za-z0-9]*|#[0-9]+|#[xX][0-9A-Fa-f]+);)/g;\n\n/** `text` with every `&` that starts a character reference written `&amp;`, which reads back as `&`. */\nexport function escapeCharacterReferences(text: string): string {\n  return text.replace(CHARACTER_REFERENCE_AMPERSAND, \"&amp;\");\n}\n\n/**\n * The draft's text serializer with every underscore escaped. `esc()` leaves an\n * underscore between word characters bare, so `obj.__init__` was written\n * `obj.\\__init_\\_` and read back as `obj._` + italic `init` + `_` (markdown-it\n * opens emphasis on the inner pair). Every underscore in a text node is typed\n * text (emphasis is a mark, written with `*`), so escaping all of them keeps\n * the round trip exact. Code is written raw and never reaches `esc()`. A typed\n * character reference keeps its `&` too (`&amp;lt;`), so `&lt;` reads back as\n * typed instead of as `<`; tiptap-markdown turns `<` and `>` into `&lt;` and\n * `&gt;` only after that.\n *\n * The text of an autolink (`<https://…>`, a link whose text is its URL) is\n * written raw. Markdown reads no escapes there, so `getMarkdown()`'s own\n * escaping (tiptap-markdown escapes it like any text) read a URL with `~`, `*`\n * or `[` back as another address, and an escaped underscore would too.\n */\nfunction writeTextForDraft(draftText: MarkdownNodeSerializer): MarkdownNodeSerializer {\n  return (state, node, parent, index) => {\n    if (state.inAutolink) {\n      state.text(node.text ?? \"\", false);\n      return;\n    }\n    const typed: string = node.text ?? \"\";\n    const referencesKept: string = escapeCharacterReferences(typed);\n    const textNode: ProseMirrorNode =\n      referencesKept === typed ? node : node.type.schema.text(referencesKept, node.marks);\n    const escapeText = state.esc;\n    state.esc = (text, startOfLine) =>\n      escapeBareUnderscores(escapeText.call(state, text, startOfLine));\n    try {\n      draftText(state, textNode, parent, index);\n    } finally {\n      state.esc = escapeText;\n    }\n  };\n}\n\nfunction draftTextSerializer(serializer: TiptapMarkdownSerializer): TiptapMarkdownSerializer {\n  const nodes = serializer.nodes;\n  const draftText = nodes.text;\n  if (!draftText) return serializer;\n  return Object.create(serializer, {\n    nodes: { value: { ...nodes, text: writeTextForDraft(draftText) } },\n  });\n}\n\n/**\n * What a line's first space or tab is written as in the draft. Agent-runtime's\n * `isComposerMarkdownOfText` and agora's `is_composer_markdown_of_text` decode\n * the same two references.\n */\nconst LINE_START_REFERENCES = { \" \": \"&#32;\", \"\\t\": \"&#9;\" } as const;\n\ntype LineStartWhitespace = keyof typeof LINE_START_REFERENCES;\n\n/** The characters standing in for a line's first space and tab while one draft is written. */\ntype LineStartStandIns = Readonly<Record<LineStartWhitespace, string>>;\n\n/**\n * Characters that can stand in for a line's first space or tab while the draft\n * is written: each is whitespace to the serializer (`\\s`), which moves it out\n * of bold and italic like a space, as the sent text does, and none is a space\n * or tab itself. A draft uses two its document does not already hold.\n */\nconst STAND_IN_CANDIDATES: readonly string[] = [\n  \" \",\n  \" \",\n  \" \",\n  \" \",\n  \" \",\n  \" \",\n  \" \",\n  \" \",\n  \" \",\n  \" \",\n  \" \",\n  \" \",\n  \" \",\n  \"　\",\n];\n\n/** Two stand-ins `doc` holds nowhere (text or attributes); `null` in the unlikely case it holds them all. */\nfunction standInsFor(doc: ProseMirrorNode): LineStartStandIns | null {\n  const held: string = JSON.stringify(doc.toJSON());\n  const [space, tab] = STAND_IN_CANDIDATES.filter((candidate) => !held.includes(candidate));\n  return space !== undefined && tab !== undefined ? { \" \": space, \"\\t\": tab } : null;\n}\n\nconst isLineStartWhitespace = (character: string): character is LineStartWhitespace =>\n  character === \" \" || character === \"\\t\";\n\n/**\n * `textblock` with the first space or tab of each of its lines replaced by its\n * stand-in, and how many it replaced. A line is the textblock's start or what\n * follows a line break; its whitespace is in the text there (not in code,\n * which Markdown keeps as written). A block of nothing but whitespace is left\n * as it is: Markdown reads it as a blank line, as before, and a composer\n * holding only spaces stays empty to every `trim()`.\n */\nfunction withLineStandIns({\n  textblock,\n  standIns,\n}: {\n  textblock: ProseMirrorNode;\n  standIns: LineStartStandIns;\n}): {\n  node: ProseMirrorNode;\n  replaced: number;\n} {\n  const { schema } = textblock.type;\n  const lineBreak = schema.linebreakReplacement;\n  const isBlank = (child: ProseMirrorNode): boolean =>\n    child.isText ? !/\\S/.test(child.text ?? \"\") : child.type === lineBreak;\n  let blank = true;\n  textblock.forEach((child) => {\n    blank &&= isBlank(child);\n  });\n  if (blank) return { node: textblock, replaced: 0 };\n\n  const children: ProseMirrorNode[] = [];\n  let replaced = 0;\n  let atLineStart = true;\n  textblock.forEach((child) => {\n    const lineStart: boolean = atLineStart;\n    atLineStart = child.type === lineBreak;\n    const text: string = child.isText ? (child.text ?? \"\") : \"\";\n    const first: string = text.charAt(0);\n    if (\n      lineStart &&\n      isLineStartWhitespace(first) &&\n      !child.marks.some((mark) => mark.type.spec.code)\n    ) {\n      replaced += 1;\n      children.push(schema.text(standIns[first] + text.slice(1), child.marks));\n    } else {\n      children.push(child);\n    }\n  });\n  return replaced > 0\n    ? { node: textblock.copy(Fragment.from(children)), replaced }\n    : { node: textblock, replaced: 0 };\n}\n\n/**\n * `doc` with the first space or tab of every line in its text replaced by its\n * stand-in, and how many it replaced (see {@link serializeComposerDraft}).\n */\nfunction withLeadingWhitespaceStandIns({\n  doc,\n  standIns,\n}: {\n  doc: ProseMirrorNode;\n  standIns: LineStartStandIns;\n}): {\n  doc: ProseMirrorNode;\n  replaced: number;\n} {\n  let replaced = 0;\n  const map = (node: ProseMirrorNode): ProseMirrorNode => {\n    if (node.isTextblock) {\n      if (node.type.spec.code) return node;\n      const lines = withLineStandIns({ textblock: node, standIns });\n      replaced += lines.replaced;\n      return lines.node;\n    }\n    if (node.isLeaf) return node;\n    const children: ProseMirrorNode[] = [];\n    let changed = false;\n    node.forEach((child) => {\n      const mapped = map(child);\n      changed ||= mapped !== child;\n      children.push(mapped);\n    });\n    return changed ? node.copy(Fragment.from(children)) : node;\n  };\n  const mapped = map(doc);\n  return { doc: mapped, replaced };\n}\n\n/**\n * The composer's draft: Markdown that reads back into the same document, as\n * the Olympus chat composer writes it\n * (`olympus/src/components/textbox/composer-message-markdown.ts`).\n * `getMarkdown()`, except that every underscore in plain text is escaped, a\n * typed character reference keeps its `&`, and an autolink's URL is written\n * raw (see {@link writeTextForDraft}), and the first space or tab of a line is\n * written as a character reference. The composer mirrors its draft into the\n * composer runtime, remembers a send's draft and attaches it to the message\n * (`metadata.composer_markdown`) in this form.\n *\n * Markdown drops the whitespace a line starts with (four spaces or a tab even\n * start a code block), so pasted code came back without its indentation. The\n * first space or tab of each line is written `&#32;` / `&#9;` instead, which\n * Markdown reads back as that character in the line's text; the rest of the\n * run is no longer at the line's start, and the composer's parser keeps it\n * ({@link ComposerDraftWhitespace}). The draft is written with a stand-in for\n * each, a character the document holds nowhere else ({@link standInsFor}),\n * that becomes the reference afterwards; should the serializer ever write a\n * different number of them, the draft is written without them.\n */\nexport function serializeComposerDraft(editor: Editor): string {\n  const storage = getMarkdownStorage(editor);\n  const serializer: unknown = storage.serializer;\n  if (!isTiptapMarkdownSerializer(serializer)) return storage.getMarkdown();\n  const draft = draftTextSerializer(serializer);\n  const source: ProseMirrorNode = editor.state.doc;\n  const standIns = standInsFor(source);\n  if (standIns === null) return draft.serialize(source);\n  const lines = withLeadingWhitespaceStandIns({ doc: source, standIns });\n  if (lines.replaced === 0) return draft.serialize(source);\n  const written: string = draft.serialize(lines.doc);\n  const references = new Map<string, string>([\n    [standIns[\" \"], LINE_START_REFERENCES[\" \"]],\n    [standIns[\"\\t\"], LINE_START_REFERENCES[\"\\t\"]],\n  ]);\n  const characters: string[] = Array.from(written);\n  const standInCount: number = characters.filter((character) => references.has(character)).length;\n  if (standInCount !== lines.replaced) return draft.serialize(source);\n  return characters.map((character) => references.get(character) ?? character).join(\"\");\n}\n\n/** The slice of a markdown-it token {@link keepDraftWhitespace} reads and rewrites. */\ninterface MarkdownItToken {\n  type: string;\n  info: string;\n  markup: string;\n  content: string;\n  children: MarkdownItToken[] | null;\n}\n\ntype MarkdownItRenderRule = (tokens: MarkdownItToken[], index: number, ...rest: unknown[]) => string;\n\n/** The slice of markdown-it (the instance tiptap-markdown parses with) {@link keepDraftWhitespace} configures. */\ninterface MarkdownIt {\n  core: {\n    ruler: {\n      before(\n        beforeName: string,\n        ruleName: string,\n        rule: (state: { tokens: MarkdownItToken[] }) => void,\n      ): void;\n    };\n  };\n  renderer: { rules: Record<string, MarkdownItRenderRule | undefined> };\n}\n\nconst LINE_START_WHITESPACE_REFERENCES: ReadonlySet<string> = new Set(\n  Object.values(LINE_START_REFERENCES),\n);\n\nconst KEPT_WHITESPACE_TOKEN = \"athena_kept_whitespace\";\n\n/** Whitespace ProseMirror's parser would collapse into one space: a run of two or more, or a tab. */\nconst COLLAPSIBLE_WHITESPACE = /[ \\t]{2,}|\\t/g;\n\n/**\n * `whitespace` in an element ProseMirror's parser keeps the whitespace of\n * (`white-space: pre-wrap` is what it reads as \"preserve\"). No node or mark\n * parses the tag, so its text joins the text around it.\n */\nconst keptWhitespace = (whitespace: string): string =>\n  `<athena-whitespace style=\"white-space: pre-wrap\">${whitespace}</athena-whitespace>`;\n\nconst draftWhitespaceParsers = new WeakSet<MarkdownIt>();\n\n/**\n * Markdown read into the composer keeps the spaces and tabs in its text, as\n * the Olympus chat composer's parser does (`ComposerVerbatimTextPaste`).\n * markdown-it keeps a run of spaces inside a line, but ProseMirror's DOM parser\n * collapsed it to one space, and a tab to a space. The draft writes a line's\n * first space or tab as `&#32;` / `&#9;` ({@link serializeComposerDraft});\n * that reference and the whitespace after it, every other run and every tab\n * are rendered in an element that keeps them. Any other single space stays as\n * Markdown reads it, so a task list's space after its checkbox still goes.\n */\nfunction keepDraftWhitespace(markdownit: MarkdownIt): void {\n  if (draftWhitespaceParsers.has(markdownit)) return;\n  draftWhitespaceParsers.add(markdownit);\n  // Before `text_join`, which folds references back into the text around them.\n  markdownit.core.ruler.before(\"text_join\", \"athena_kept_whitespace\", (state) => {\n    for (const block of state.tokens) {\n      const inline: MarkdownItToken[] = block.children ?? [];\n      inline.forEach((token, index) => {\n        if (token.type !== \"text_special\" || token.info !== \"entity\") return;\n        if (!LINE_START_WHITESPACE_REFERENCES.has(token.markup)) return;\n        token.type = KEPT_WHITESPACE_TOKEN;\n        const next: MarkdownItToken | undefined = inline[index + 1];\n        if (next?.type !== \"text\") return;\n        const run: string = /^[ \\t]*/.exec(next.content)?.[0] ?? \"\";\n        token.content += run;\n        next.content = next.content.slice(run.length);\n      });\n    }\n  });\n  const { rules } = markdownit.renderer;\n  rules[KEPT_WHITESPACE_TOKEN] = (tokens, index) => keptWhitespace(tokens[index]?.content ?? \"\");\n  for (const name of [\"text\", \"code_inline\"]) {\n    const render: MarkdownItRenderRule | undefined = rules[name];\n    if (!render) continue;\n    rules[name] = (...args) => render(...args).replace(COLLAPSIBLE_WHITESPACE, keptWhitespace);\n  }\n}\n\n/**\n * The composer's own Markdown reading: a draft restored into it (a returned\n * send, {@link draftForReturnedSend}) keeps its whitespace\n * ({@link keepDraftWhitespace}). The message bubbles read with the chat\n * schema alone.\n */\nexport const ComposerDraftWhitespace = Extension.create({\n  name: \"athenaComposerDraftWhitespace\",\n  addStorage() {\n    return { markdown: { parse: { setup: keepDraftWhitespace } } };\n  },\n});\n\n/** What one send captured: the text it delivers and the draft Markdown that text came from. */\nexport interface ComposerSend {\n  /** Plain text exactly as typed, formatting as Markdown: what the model reads. */\n  readonly text: string;\n  /** The same document as a draft ({@link serializeComposerDraft}). */\n  readonly draftMarkdown: string;\n}\n\n/**\n * The editor's draft as one send would deliver it, both forms trimmed (the\n * draft as agent-runtime's `trimComposerDraft` trims it, so the `&#32;` a\n * first line starts with goes with the space the text loses).\n */\nexport function captureComposerSend(editor: Editor): ComposerSend {\n  return {\n    text: serializeComposerMessage(editor).trim(),\n    draftMarkdown: trimComposerDraft(serializeComposerDraft(editor)),\n  };\n}\n\n/** How many sends {@link rememberComposerSend} keeps the draft of. */\nconst REMEMBERED_SENDS = 50;\n\n/**\n * How long a send's draft stays restorable. Statewire hands a refused send\n * back while it reconnects, soon after the send; past this window a matching\n * text is a host's own write (`useAppendToComposer`), parsed as Markdown.\n */\nexport const RETURNED_SEND_WINDOW_MS = 60_000;\n\ninterface RememberedSend {\n  /** `null` once two different drafts sent the same text in the thread. */\n  readonly draft: string | null;\n  readonly sentAt: number;\n}\n\n/**\n * A sent text in a thread → the draft Markdown it was serialized from, newest\n * last. The draft is withheld once two different drafts sent the same text in\n * that thread within the window: literal `**strong**` and bold `strong` both\n * send `**strong**`, and the text alone cannot say which message is which.\n */\nconst sends = new Map<string, RememberedSend>();\n\nconst sendKey = ({ threadId, text }: { threadId: string; text: string }): string =>\n  JSON.stringify([threadId, text]);\n\nconst isFresh = (send: RememberedSend, now: number): boolean =>\n  now - send.sentAt <= RETURNED_SEND_WINDOW_MS;\n\n/**\n * Remember the draft behind a sent text, so a send that comes back to the\n * composer (statewire puts a send it refuses during a reconnect back into an\n * empty composer) is restored from the draft it was sent from rather than\n * parsed from its verbatim text, where Markdown would read a backslash before\n * punctuation, a tag-like `<x>` or `2*3*4` differently.\n */\nexport function rememberComposerSend({\n  threadId,\n  text,\n  draftMarkdown,\n  now = Date.now(),\n}: {\n  threadId: string;\n  text: string;\n  draftMarkdown: string;\n  /** Test seam: the time of the send. */\n  now?: number;\n}): void {\n  const key = sendKey({ threadId, text });\n  const remembered = sends.get(key);\n  sends.delete(key);\n  const collides =\n    remembered !== undefined && isFresh(remembered, now) && remembered.draft !== draftMarkdown;\n  sends.set(key, { draft: collides ? null : draftMarkdown, sentAt: now });\n  while (sends.size > REMEMBERED_SENDS) {\n    const oldest = sends.keys().next();\n    if (oldest.done) break;\n    sends.delete(oldest.value);\n  }\n}\n\n/**\n * The draft to load for a text that came back to an empty composer: the draft\n * this composer sent it from within {@link RETURNED_SEND_WINDOW_MS}, when that\n * is the only draft that sent this text in the thread; else `null`, and the\n * text is parsed as Markdown (a host's prefill, a send from before a reload).\n */\nexport function draftForReturnedSend({\n  threadId,\n  text,\n  now = Date.now(),\n}: {\n  threadId: string;\n  text: string;\n  /** Test seam: the time the text came back. */\n  now?: number;\n}): string | null {\n  const remembered = sends.get(sendKey({ threadId, text }));\n  return remembered !== undefined && isFresh(remembered, now) ? remembered.draft : null;\n}\n\n/** Test seam: forget every remembered send. */\nexport function resetRememberedComposerSends(): void {\n  sends.clear();\n}\n\n/**\n * Get a send ready right before the composer runtime sends its `text`:\n * remember its draft, so a send statewire hands back is restored from it\n * ({@link rememberComposerSend}), and stage the draft as the message's composer\n * markdown (`metadata.composer_markdown`, only when it differs from the text),\n * which the runtime's `getMessageMetadata` (agent-runtime's\n * `withStagedComposerMarkdown`) puts on the submission that follows, as the\n * Olympus composer does.\n */\nexport function prepareComposerSend({\n  threadId,\n  text,\n  draftMarkdown,\n}: {\n  threadId: string;\n} & ComposerSend): void {\n  rememberComposerSend({ threadId, text, draftMarkdown });\n  stageComposerMarkdown({ threadId, text, markdown: draftMarkdown });\n}\n"],"names":["getMarkdownStorage","Fragment","mapped","Extension","trimComposerDraft","stageComposerMarkdown"],"mappings":"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"}