@jini-ai/chat 0.5.3 → 0.5.5

package/dist/react/hooks/useComposerHistory.hooks.js

@@ -0,0 +1,90 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { composerHistoryKeyAction, createComposerHistoryState, mergeComposerHistory, normalizeComposerHistory, transitionComposerHistory, } from '../../core/composer-history.js';
+import { browserComposerHistoryStorage } from './composer-history-storage.js';
+const EMPTY_MESSAGES = [];
+export function useComposerHistory({ setRecalledDraft }, { messages = EMPTY_MESSAGES, scope = 'default', storage = browserComposerHistoryStorage, conversationId } = {}) {
+    const browseRef = useRef(createComposerHistoryState({}));
+    const [recent, setRecent] = useState([]);
+    const hydratedPortRef = useRef(null);
+    const [hydratedScope, setHydratedScope] = useState(null);
+    const pendingRef = useRef([]);
+    const conversationRef = useRef(conversationId);
+    const scopeRef = useRef(scope);
+    const seenRef = useRef(new Set(messages.map((message) => message.id)));
+    const writeQueueRef = useRef(Promise.resolve());
+    const current = useMemo(() => messages.filter((message) => message.role === 'user').map((message) => message.content), [messages]);
+    const entries = mergeComposerHistory({ recent, current });
+    useEffect(() => {
+        let cancelled = false;
+        pendingRef.current = [];
+        hydratedPortRef.current = null;
+        setRecent([]);
+        setHydratedScope(null);
+        browseRef.current = createComposerHistoryState({});
+        // Read after this hook's outstanding writes so an injected async store cannot return stale
+        // entries when a scope is revisited. A remounted hook's default storage writes synchronously.
+        void writeQueueRef.current.then(() => storage.read({ scope }, {})).catch(() => []).then((loaded) => {
+            if (cancelled)
+                return;
+            // Bootstrap an empty recent store from the already-sent current transcript. This
+            // makes opening a new chat useful immediately after installing recall; opening an
+            // older transcript later does not reorder an established recent list.
+            const seed = loaded.length > 0 ? loaded : current;
+            setRecent(normalizeComposerHistory({ entries: [...seed, ...pendingRef.current] }));
+            hydratedPortRef.current = storage;
+            setHydratedScope(scope);
+        });
+        return () => { cancelled = true; };
+    }, [scope, storage]);
+    useEffect(() => {
+        const adopted = conversationRef.current == null && conversationId != null && scopeRef.current === scope;
+        conversationRef.current = conversationId;
+        scopeRef.current = scope;
+        if (adopted)
+            return;
+        browseRef.current = createComposerHistoryState({});
+        // A conversation's existing turns are available for navigation, but merely opening old
+        // conversations must not reorder the cross-conversation recent list.
+        seenRef.current = new Set(messages.map((message) => message.id));
+        // messages is deliberately absent: newly appended turns are handled below, not reseeded.
+    }, [conversationId, scope]);
+    useEffect(() => {
+        const added = [];
+        for (const message of messages) {
+            if (!seenRef.current.has(message.id) && message.role === 'user')
+                added.push(message.content);
+            seenRef.current.add(message.id);
+        }
+        if (added.length === 0)
+            return;
+        pendingRef.current.push(...added);
+        pendingRef.current = normalizeComposerHistory({ entries: pendingRef.current });
+        setRecent((previous) => normalizeComposerHistory({ entries: [...previous, ...added] }));
+    }, [messages]);
+    useEffect(() => {
+        if (hydratedScope !== scope || hydratedPortRef.current !== storage)
+            return;
+        // Serialize writes; a slow earlier write must not overwrite a later prompt.
+        writeQueueRef.current = writeQueueRef.current.then(() => storage.write({ scope, entries: recent }, {})).catch(() => { });
+    }, [hydratedScope, recent, scope, storage]);
+    const navigate = useCallback((input, _optional = {}) => {
+        const action = composerHistoryKeyAction(input);
+        if (action === null)
+            return false;
+        const transition = transitionComposerHistory({ state: browseRef.current, action, text: input.text, entries });
+        if (!transition.handled)
+            return false;
+        browseRef.current = transition.state;
+        // Recall is a view, not an edit to the cached working draft. Reload while copying a
+        // recalled entry still restores what the operator was writing before they browsed.
+        setRecalledDraft(transition.text);
+        return true;
+    }, [entries, setRecalledDraft]);
+    const edit = useCallback((_required, _optional = {}) => {
+        // The first edit leaves history. Its text is now the working draft; stored entries and
+        // the original browsing snapshot are never edited in place.
+        browseRef.current = createComposerHistoryState({});
+    }, []);
+    return useMemo(() => ({ navigate, edit }), [navigate, edit]);
+}
+//# sourceMappingURL=useComposerHistory.hooks.js.map

package/dist/react/hooks/useComposerHistoryKeys.hooks.d.ts

@@ -0,0 +1,9 @@
+import { type KeyboardEvent, type RefObject } from 'react';
+import type { UseComposerResult } from './useComposer.js';
+export declare function useComposerHistoryKeys({ composer, textareaRef }: {
+    composer: UseComposerResult;
+    textareaRef: RefObject<HTMLTextAreaElement | null>;
+}, { popupOpen }?: {
+    popupOpen?: boolean;
+}): (event: KeyboardEvent<HTMLTextAreaElement>) => boolean;
+//# sourceMappingURL=useComposerHistoryKeys.hooks.d.ts.map

package/dist/react/hooks/useComposerHistoryKeys.hooks.js

@@ -0,0 +1,90 @@
+import { useLayoutEffect, useReducer, useRef } from 'react';
+/** Measures visual lines as well as newlines, so a wrapped paragraph keeps native arrow motion. */
+function visualLineBounds({ textarea }) {
+    if (textarea.clientWidth === 0)
+        return {};
+    const computed = getComputedStyle(textarea);
+    const mirror = document.createElement('div');
+    for (const property of ['font', 'letter-spacing', 'word-spacing', 'line-height', 'text-indent', 'padding', 'tab-size', 'word-break', 'overflow-wrap', 'direction']) {
+        mirror.style.setProperty(property, computed.getPropertyValue(property));
+    }
+    mirror.style.position = 'fixed';
+    mirror.style.visibility = 'hidden';
+    mirror.style.pointerEvents = 'none';
+    mirror.style.whiteSpace = 'pre-wrap';
+    mirror.style.overflowWrap = 'break-word';
+    mirror.style.boxSizing = 'border-box';
+    mirror.style.width = `${textarea.clientWidth}px`;
+    const text = document.createTextNode(textarea.value);
+    mirror.append(text, document.createTextNode('\u200b'));
+    document.body.append(mirror);
+    try {
+        function lineAt(offset) {
+            const range = document.createRange();
+            range.setStart(text, offset);
+            range.setEnd(text, offset);
+            return range.getBoundingClientRect().top;
+        }
+        const first = lineAt(0);
+        const last = lineAt(text.length);
+        // Both selection endpoints must be on the boundary visual line. Selecting across soft
+        // wraps should stay native just like selecting across explicit newline characters.
+        const start = lineAt(textarea.selectionStart);
+        const end = lineAt(textarea.selectionEnd);
+        return { firstLine: Math.abs(start - first) < 1 && Math.abs(end - first) < 1, lastLine: Math.abs(start - last) < 1 && Math.abs(end - last) < 1 };
+    }
+    finally {
+        mirror.remove();
+    }
+}
+export function useComposerHistoryKeys({ composer, textareaRef }, { popupOpen = false } = {}) {
+    const pendingCaretRef = useRef(null);
+    // A duplicate history entry can equal the current value, so setDraft may bail out.
+    // Still commit the caret request now rather than carrying it into the next real edit.
+    const [, requestCaretCommit] = useReducer((revision) => revision + 1, 0);
+    useLayoutEffect(() => {
+        if (!pendingCaretRef.current)
+            return;
+        const placement = pendingCaretRef.current;
+        pendingCaretRef.current = null;
+        const textarea = textareaRef.current;
+        if (textarea) {
+            const offset = placement === 'start' ? 0 : textarea.value.length;
+            textarea.setSelectionRange(offset, offset);
+        }
+    });
+    return (event) => {
+        if (event.shiftKey || event.ctrlKey || event.altKey || event.metaKey)
+            return false;
+        if (event.defaultPrevented || popupOpen || event.nativeEvent.isComposing || event.nativeEvent.keyCode === 229)
+            return false;
+        if (!['ArrowUp', 'ArrowDown', 'Escape'].includes(event.key))
+            return false;
+        const textarea = event.currentTarget;
+        const handled = composer.history?.navigate({
+            key: event.key,
+            text: textarea.value,
+            selectionStart: textarea.selectionStart,
+            selectionEnd: textarea.selectionEnd,
+            shiftKey: event.shiftKey,
+            ctrlKey: event.ctrlKey,
+            altKey: event.altKey,
+            metaKey: event.metaKey,
+            ...visualLineBounds({ textarea }),
+        }) ?? false;
+        if (handled) {
+            event.preventDefault();
+            // React's controlled value lands on the following commit. Placing the caret before
+            // that commit clamps it to the OLD draft's length and breaks multiline Down gating.
+            // Up stays on the first line of even a multiline recall so repeated Up can browse
+            // older entries. Down/Escape go to the end, including when restoring the draft.
+            pendingCaretRef.current = event.key === 'ArrowUp' ? 'start' : 'end';
+            requestCaretCommit();
+            // Recalling an identical string may not cause a render; the existing value is safe.
+            const offset = pendingCaretRef.current === 'start' ? 0 : textarea.value.length;
+            textarea.setSelectionRange(offset, offset);
+        }
+        return handled;
+    };
+}
+//# sourceMappingURL=useComposerHistoryKeys.hooks.js.map

package/dist/react/hooks/useConversation.d.ts

@@ -1,6 +1,7 @@
+import { type UserTextRedactionOptions } from '../../core/user-text-redaction.js';
 import type { ChatAttachment, ChatMessage } from '../../core/index.js';
 import type { ChatTransport, RunContext } from '../../core/index.js';
-export interface UseConversationOptions {
+export interface UseConversationOptions extends UserTextRedactionOptions {
     transport: ChatTransport;
     initialMessages?: ChatMessage[];
     conversationId?: string | null;
@@ -9,6 +10,8 @@ export interface UseConversationOptions {
     createMessageId?: () => string;
 }
 export interface SendMessageOptions {
+    /** Non-secret signal from a composer that already sanitized the content before this boundary. */
+    secretRedaction?: ChatMessage['secretRedaction'];
     attachments?: ChatAttachment[];
     context?: RunContext;
     agentId?: string;

package/dist/react/hooks/useConversation.js

@@ -1,3 +1,5 @@
+import { redactUserHistory, redactUserMessage } from '../../core/user-text-redaction.js';
+import { preserveAssistantContent, mergeRunEvents } from '../../core/durable-projection.js';
 /**
  * @module useConversation
  *
@@ -22,7 +24,7 @@ function defaultCreateMessageId() {
 }
 export function useConversation(options) {
     const { transport, conversationId = null, agentId, createMessageId = defaultCreateMessageId } = options;
-    const [messages, setMessagesState] = useState(options.initialMessages ?? []);
+    const [messages, setMessagesState] = useState(() => redactUserHistory({ history: options.initialMessages ?? [] }, { ...(options.redactUserText ? { redactUserText: options.redactUserText } : {}) }));
     const [scrollIntent, setScrollIntent] = useState(false);
     const run = useRunStream({ transport });
     // The assistant message id the currently-active run is writing into.
@@ -113,8 +115,9 @@ export function useConversation(options) {
             return {
                 ...m,
                 ...(nextRunId !== undefined ? { runId: nextRunId } : {}),
-                events: run.events,
-                content: assistantContentFromEvents({ events: run.events }),
+                events: mergeRunEvents({ saved: m.events, incoming: run.events }, {}),
+                // Replayed completion prefixes cannot erase a saved interrupted segment.
+                content: preserveAssistantContent({ saved: m.content, incoming: assistantContentFromEvents({ events: run.events }) }, {}),
                 runStatus,
                 ...(isTerminalRunStatus({ status: runStatus }) ? { endedAt: Date.now() } : {}),
             };
@@ -132,13 +135,14 @@ export function useConversation(options) {
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [run.events, run.status, run.runId]);
     const sendMessage = useCallback(async (content, sendOptions = {}) => {
-        const userMessage = {
-            id: createMessageId(),
-            role: 'user',
-            content,
-            createdAt: Date.now(),
-            ...(sendOptions.attachments ? { attachments: sendOptions.attachments } : {}),
-        };
+        const userMessage = redactUserMessage({ message: {
+                id: createMessageId(),
+                role: 'user',
+                content,
+                createdAt: Date.now(),
+                ...(sendOptions.secretRedaction ? { secretRedaction: sendOptions.secretRedaction } : {}),
+                ...(sendOptions.attachments ? { attachments: sendOptions.attachments } : {}),
+            } }, options).message;
         const resolvedAgentId = sendOptions.agentId ?? agentId;
         const assistantMessage = {
             id: createMessageId(),
@@ -150,7 +154,7 @@ export function useConversation(options) {
             startedAt: Date.now(),
         };
         activeAssistantIdRef.current = assistantMessage.id;
-        const history = [...messagesRef.current, userMessage];
+        const history = redactUserHistory({ history: [...messagesRef.current, userMessage] }, options);
         // Functional, never `[...history, assistantMessage]`: `messagesRef` is the last RENDER's
         // snapshot, and a host that sends from an effect (`useChatPane`'s queued-prompt flush) runs in
         // the same commit as the reconciliation effect that just marked the previous turn terminal.
@@ -160,13 +164,14 @@ export function useConversation(options) {
         setMessagesState((prev) => [...prev, userMessage, assistantMessage]);
         setScrollIntent(true);
         await run.start({
+            assistantMessageId: assistantMessage.id,
             history,
             ...(resolvedAgentId !== undefined ? { agentId: resolvedAgentId } : {}),
             conversationId,
             ...(sendOptions.attachments !== undefined ? { attachments: sendOptions.attachments } : {}),
             ...(sendOptions.context !== undefined ? { context: sendOptions.context } : {}),
         });
-    }, [agentId, conversationId, createMessageId, run]);
+    }, [agentId, conversationId, createMessageId, run, options.redactUserText, options.onSecretRedacted]);
     const retry = useCallback(async (assistantMessageId) => {
         const idx = messagesRef.current.findIndex((m) => m.id === assistantMessageId);
         if (idx <= 0)
@@ -174,7 +179,7 @@ export function useConversation(options) {
         const priorUser = messagesRef.current[idx - 1];
         if (!priorUser || priorUser.role !== 'user')
             return;
-        const history = messagesRef.current.slice(0, idx);
+        const history = redactUserHistory({ history: messagesRef.current.slice(0, idx) }, options);
         const resetAssistant = { ...messagesRef.current[idx], content: '', events: [], runStatus: 'queued' };
         activeAssistantIdRef.current = resetAssistant.id;
         // Functional for the same reason as `sendMessage`'s: keep a just-queued terminal update.
@@ -191,12 +196,13 @@ export function useConversation(options) {
         // attachment beside the user turn, the failure reads as the model ignoring it rather than as
         // the client never having sent it.
         await run.start({
+            assistantMessageId: resetAssistant.id,
             history,
             ...(resolvedAgentId !== undefined ? { agentId: resolvedAgentId } : {}),
             conversationId,
             ...(priorUser.attachments !== undefined ? { attachments: priorUser.attachments } : {}),
         });
-    }, [agentId, conversationId, run]);
+    }, [agentId, conversationId, run, options.redactUserText, options.onSecretRedacted]);
     const cancel = useCallback(() => run.cancel(), [run]);
     const acknowledgeScroll = useCallback(() => setScrollIntent(false), []);
     const suppressScroll = useCallback(() => setScrollIntent(false), []);

package/dist/react/hooks/useRunStream.js

@@ -17,6 +17,7 @@
  * comparison can't do this — `start()`'s handlers must exist before the
  * transport's promise resolves with the real id).
  */
+import { mergeRunEvents } from '../../core/durable-projection.js';
 import { useCallback, useEffect, useRef, useState } from 'react';
 function reportRunStreamHostEffectFailure(effectName, error) {
     console.error(`[@jini-ai/chat] useRunStream ${effectName} host effect failed:`, error);
@@ -77,6 +78,15 @@ export function useRunStream({ transport }) {
     const makeHandlers = useCallback((generation) => {
         const isStale = () => generationRef.current !== generation;
         return {
+            onCheckpoint: (message) => {
+                if (isStale())
+                    return;
+                const statuses = { queued: 'streaming', running: 'streaming', succeeded: 'done', failed: 'error', canceled: 'canceled' };
+                setState((prev) => ({ ...prev, runId: message.runId ?? prev.runId,
+                    status: message.runStatus ? statuses[message.runStatus] : prev.status,
+                    events: mergeRunEvents({ saved: prev.events, incoming: message.events ?? [] }, {}),
+                }));
+            },
             onEvent: (ev) => {
                 if (isStale())
                     return;
@@ -93,12 +103,12 @@ export function useRunStream({ transport }) {
             onError: (err) => {
                 if (isStale())
                     return;
-                setState((prev) => ({ ...prev, status: 'error', error: err }));
+                setState((prev) => ({ ...prev, status: 'error', error: err, events: [...prev.events, { kind: 'status', code: 'run_terminal', label: err.message }] }));
             },
             onDone: (finalEvents) => {
                 if (isStale())
                     return;
-                setState((prev) => ({ ...prev, status: prev.status === 'error' ? prev.status : 'done', events: finalEvents }));
+                setState((prev) => ({ ...prev, status: prev.status === 'error' || prev.status === 'canceled' ? prev.status : 'done', events: mergeRunEvents({ saved: prev.events, incoming: finalEvents }, {}) }));
             },
         };
     }, []);

package/dist/react/hooks/useUserTextGuard.d.ts

@@ -0,0 +1,11 @@
+import { type SecretRedactionSignal, type UserTextRedactionOptions } from '../../core/user-text-redaction.js';
+/** Shared notice state for composer and question answers. Effects see only a count, never text. */
+export declare function useUserTextGuard(options: UserTextRedactionOptions, _optional?: Record<string, never>): {
+    secretRedacted: boolean;
+    redact: ({ text }: {
+        text: string;
+    }, _options?: {}) => import("../../core/user-text-redaction.js").UserTextRedaction;
+    redactText: (text: string) => string;
+    notifyRedaction: (signal: SecretRedactionSignal) => void;
+};
+//# sourceMappingURL=useUserTextGuard.d.ts.map

package/dist/react/hooks/useUserTextGuard.js

@@ -0,0 +1,19 @@
+import { useCallback, useState } from 'react';
+import { redactUserText } from '../../core/user-text-redaction.js';
+/** Shared notice state for composer and question answers. Effects see only a count, never text. */
+export function useUserTextGuard(options, _optional = {}) {
+    const [secretRedacted, setSecretRedacted] = useState(false);
+    const notifyRedaction = useCallback((signal) => {
+        setSecretRedacted(true);
+        options.onSecretRedacted?.(signal);
+    }, [options.onSecretRedacted]);
+    const redact = useCallback(({ text }, _options = {}) => {
+        const result = (options.redactUserText ?? redactUserText)({ text }, {});
+        if (result.secretRedacted)
+            notifyRedaction({ secretRedacted: true, count: result.count });
+        return result;
+    }, [options.redactUserText, notifyRedaction]);
+    const redactText = useCallback((text) => redact({ text }, {}).text, [redact]);
+    return { secretRedacted, redact, redactText, notifyRedaction };
+}
+//# sourceMappingURL=useUserTextGuard.js.map

package/dist/react/index.d.ts

@@ -1,25 +1,7 @@
 /**
- * @jini-ai/chat-react — headless hooks + presentational components + slots for
- * a chat/artifact frontend, built on `@jini-ai/chat/core`'s framework-free
- * vocabulary. See ADS-memory/reports/jini-port/recon/r4b-webui-design.md §1/§2/§4 for the
- * spec this package implements, and archived provenance ledger for provenance.
- *
- * This barrel is filled in incrementally as each layer lands (hooks first,
- * then presentational components, then the `<JiniChatProvider>` composition
- * root) — see archived provenance ledger's "Status" section for what's shipped so far.
- *
- * ## Every export here is explicit. Do not reintroduce `export *`.
- *
- * This file used 15 `export * from` statements until 2026-08-05. That made the package's public
- * API *implicit*: whatever any of those modules happened to export was public, so renaming an
- * internal helper shipped a breaking change nobody reviewed, and no one could read this file and
- * say what the package exports. It is also the likeliest reason consumers reach past this barrel
- * into `@jini-ai/chat/core` deep paths — a grab-bag invites bypassing.
- *
- * The expansion was mechanical and provably surface-preserving: 193 symbols before and after,
- * identical in name AND in value-vs-type kind. `features/chat-pane/index.ts` is the style model.
- *
- * When adding an export, add the name here deliberately. That edit IS the API review.
+ * @jini-ai/chat/react — headless hooks, presentational components and slots over framework-free
+ * chat/core vocabulary. Every export is explicit: adding or renaming a name here is a public API
+ * review, so internal module exports cannot silently become public. Do not use export *.
  */
 export type { ChatTransport, FeedbackChange, OnFeedback, ReattachRunOptions, RunContext, RunHandlers, StartRunInput, } from '../core/index.js';
 export { RendererRegistry, } from './artifact-types.js';
@@ -163,4 +145,15 @@ export type { JiniChatProviderProps, JiniChatSlots } from './components/JiniChat
 export { createFrontendSessionBridge } from './agent-bridge/frontend-session-bridge.js';
 export type { FrontendSessionBridge, FrontendSessionBridgeArgs, FrontendSessionBridgeOptions, } from './agent-bridge/frontend-session-bridge.js';
 export { createDomPageDriver, currentAgentPage, type DomPageDriverOptions } from '@jini-ai/agentic/dom';
+export { createBrowserComposerHistoryStorage } from './hooks/composer-history-storage.js';
+export type { ComposerHistoryStoragePort } from '../core/composer-history.js';
+export { SECRET_REDACTED_NOTICE, redactUserText } from '../core/user-text-redaction.js';
+export type { UserTextRedactionOptions } from '../core/user-text-redaction.js';
+export { useUserTextGuard } from './hooks/useUserTextGuard.js';
+export { cacheAttachmentPreviewSource } from './hooks/attachment-preview-cache.js';
+export { readCachedAttachmentBatchId, writeCachedAttachmentBatchId } from './hooks/composer-draft-cache.js';
+export { createAssistantChatsClient } from "./hooks/assistant-chats.js";
+export type { AssistantChatsPort, AssistantChatsClientPorts, AssistantChatsClient, UseAssistantChats } from "./hooks/assistant-chats-contracts.js";
+export { useFabPosition } from "./hooks/fab-position.js";
+export type { FabPositionInput, FabPositionResult } from "./hooks/fab-position.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/react/index.js

@@ -121,4 +121,12 @@ export { JiniChatProvider, useJiniChatSlots, useOnFeedback } from './components/
  */
 export { createFrontendSessionBridge } from './agent-bridge/frontend-session-bridge.js';
 export { createDomPageDriver, currentAgentPage } from '@jini-ai/agentic/dom';
+export { createBrowserComposerHistoryStorage } from './hooks/composer-history-storage.js';
+// ChatPane consumers share the same redaction and draft/preview state owners.
+export { SECRET_REDACTED_NOTICE, redactUserText } from '../core/user-text-redaction.js';
+export { useUserTextGuard } from './hooks/useUserTextGuard.js';
+export { cacheAttachmentPreviewSource } from './hooks/attachment-preview-cache.js';
+export { readCachedAttachmentBatchId, writeCachedAttachmentBatchId } from './hooks/composer-draft-cache.js';
+export { createAssistantChatsClient } from "./hooks/assistant-chats.js";
+export { useFabPosition } from "./hooks/fab-position.js";
 //# sourceMappingURL=index.js.map

package/dist/server/durable-runs/accept.d.ts

@@ -0,0 +1,25 @@
+import type { AcceptedRunRequest, DurableRun, DurableRunStore } from "../../core/durable-runs/ports.js";
+export interface RunAcceptancePorts {
+    readonly store: DurableRunStore;
+    /** Sanitize the host envelope before it is durably accepted. */
+    readonly sanitizeContextRef: (required: {
+        contextRef: string;
+    }, optional: {}) => string;
+    readonly now: () => number;
+    readonly mintRunId: () => string;
+    readonly launch: (required: {
+        run: DurableRun;
+        request: AcceptedRunRequest;
+    }, optional: {}) => Promise<void>;
+    readonly attach: (required: DurableRun, optional: {}) => void;
+}
+export declare function createRunAcceptance(ports: RunAcceptancePorts, _optional?: {}): {
+    accept(required: {
+        principalId: string;
+        workspaceId: string;
+        conversationId: string;
+        messageId: string;
+        request: AcceptedRunRequest;
+    }, _options?: {}): Promise<DurableRun | null>;
+};
+//# sourceMappingURL=accept.d.ts.map

package/dist/server/durable-runs/accept.js

@@ -0,0 +1,21 @@
+export function createRunAcceptance(ports, _optional = {}) {
+    return {
+        async accept(required, _options = {}) {
+            const request = { ...required.request, contextRef: ports.sanitizeContextRef({ contextRef: required.request.contextRef }, {}) };
+            const run = await ports.store.accept({ ...required, request, runId: ports.mintRunId(), now: ports.now() }, {});
+            if (!run)
+                return null;
+            // The stub and accepted input are committed BEFORE dispatch. The daemon uses the stored
+            // attempt id as its idempotency key, so duplicate POSTs cannot start two executors.
+            if (run.message.runStatus === "queued" && run.recoveryCount === 0 && !run.cancelReason) {
+                try {
+                    await ports.launch({ run, request: run.request }, {});
+                }
+                catch { /* The accepted attempt is recoverable even if its response was lost. */ }
+            }
+            ports.attach(run, {});
+            return run;
+        },
+    };
+}
+//# sourceMappingURL=accept.js.map

package/dist/server/durable-runs/entry.d.ts

@@ -0,0 +1,5 @@
+export * from "./accept.js";
+export * from "./recover.js";
+export * from "../../core/durable-runs/continuation.js";
+export type * from "../../core/durable-runs/ports.js";
+//# sourceMappingURL=entry.d.ts.map

package/dist/server/durable-runs/entry.js

@@ -0,0 +1,4 @@
+export * from "./accept.js";
+export * from "./recover.js";
+export * from "../../core/durable-runs/continuation.js";
+//# sourceMappingURL=entry.js.map

package/dist/server/durable-runs/recover.d.ts

@@ -0,0 +1,5 @@
+import type { DurableRecovery, RecoveryPorts } from "../../core/durable-runs/ports.js";
+export { RECOVERY_LIMIT, RECOVERY_WINDOW_MS, RUN_STALENESS_MS, SAVED_WORK_NOTICE, EXHAUSTED_NOTICE } from "../../core/durable-runs/policies.js";
+/** Recovery coordinator behind explicit host ports. One CAS owns both the attempt and its conversation slot. */
+export declare function createDurableRecovery(ports: RecoveryPorts, _optional?: {}): DurableRecovery;
+//# sourceMappingURL=recover.d.ts.map