@crazx/dsh-client-ui-conversation 0.1.5-alpha.1.zw.3

package/lib/types/client/conversation/assembly.d.ts

@@ -0,0 +1,97 @@
+/** Per-Session target-neutral Conversation assembly. */
+import { Service, type Context } from '@deepseek-ai/cordis';
+import type { ImageAttachmentRef } from '@deepseek-ai/dsh-attachment';
+import type { ISessions, SessionBinding } from '@deepseek-ai/dsh-api-session-controller/client';
+import type { SessionEvent, SessionId } from '@deepseek-ai/dsh-session/types';
+import { type ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
+import type { ConversationViewSnapshotMap } from '../contract/conversation.ts';
+import type { ConversationSnapshot } from '../contract/snapshot.ts';
+import type { ConversationPromptSnapshot, RequestPromptInspection, SystemPromptNode } from '../contract/request-inspection.ts';
+import { type SystemPromptState } from '../contract/system-prompt.ts';
+import { ConversationEventRegistry } from './event-registry.ts';
+import { ConversationViewRegistry } from './view-registry.ts';
+/** Observable faces published for one Session's Conversation assembly. */
+export interface ConversationBinding {
+    readonly snapshot: ObservableSnapshot<ConversationSnapshot>;
+    /**
+     * Add one selected target to the Session's monotonic active set.
+     * @param target - registered or subsequently registered Conversation target.
+     */
+    activate(target: string): void;
+    /**
+     * Resolve one target-owned snapshot source.
+     * The first subscriber activates the target unless shell selection already
+     * activated it; activation lasts for the remaining Session lifetime.
+     * @param target - registered Conversation target.
+     * @returns identity-stable source following the target.
+     */
+    target<Target extends Extract<keyof ConversationViewSnapshotMap, string>>(target: Target): ObservableSnapshot<ConversationViewSnapshotMap[Target] | undefined>;
+}
+/** Root service owning Conversation registries and per-Session bindings. */
+export declare class UiConversation extends Service {
+    private readonly sessions;
+    /** Registry of event matchers and target snapshot builders. */
+    readonly events: ConversationEventRegistry;
+    /** Registry of target View definitions. */
+    readonly views: ConversationViewRegistry;
+    private readonly bindings;
+    private readonly images;
+    /**
+     * @param ctx - owning Client context.
+     * @param sessions - Session Controller object layer.
+     */
+    constructor(ctx: Context, sessions: ISessions);
+    /**
+     * Resolve the Conversation binding for one Controller binding or Session id.
+     * @param source - Session binding or identity.
+     * @returns stable Conversation binding.
+     */
+    binding(source: SessionBinding | SessionId): ConversationBinding;
+    /**
+     * Resolve one session-authorized durable image URL, cached per Session so
+     * every Conversation target shares one read and one browser URL.
+     * @param sessionId - Session authorization and lifetime scope.
+     * @param attachment - Durable image reference from a session event.
+     * @returns browser URL valid until the Session binding is released.
+     */
+    imageUrl(sessionId: SessionId, attachment: ImageAttachmentRef): Promise<string>;
+    /**
+     * Read a cached durable image URL synchronously when one is available.
+     * @param sessionId - Session authorization and lifetime scope.
+     * @param attachment - Durable image reference from a session event.
+     * @returns current preview or canonical URL, if cached.
+     */
+    peekImageUrl(sessionId: SessionId, attachment: ImageAttachmentRef): string | undefined;
+    /**
+     * Adopt an already-displayable URL for one durable reference (see
+     * HistoricalImageCache.seed): the transcript node then renders it without a
+     * byte round-trip.
+     * @param sessionId - Session authorization and lifetime scope.
+     * @param attachment - Durable image reference the URL displays.
+     * @param url - browser URL to adopt.
+     * @returns whether the cache took URL ownership.
+     */
+    seedImageUrl(sessionId: SessionId, attachment: ImageAttachmentRef, url: string): boolean;
+    /**
+     * Interpret a system message or surface replacement for target-owned prompt Definitions.
+     * @param previous - System facts at the preceding relevant loaded event.
+     * @param event - Durable system message or positional replacement.
+     * @returns Immutable prompt interpretation at this event.
+     */
+    inspectSystemPrompt(previous: SystemPromptState | undefined, event: SessionEvent): SystemPromptState;
+    /**
+     * Canonicalize one `request/header` event against the previous prompt state
+     * and the `system/message` node in force.
+     *
+     * A pure interpretation shared by the Chat and Trajectory Definitions, exposed
+     * as a service method because cross-plugin value imports are forbidden in
+     * client bundles.
+     * @param previous - prompt recorded by the preceding loaded header, if any.
+     * @param event - the `request/header` session event to interpret.
+     * @param system - effective prompt after loaded surface replacements, if any.
+     * @returns the canonical prompt snapshot and any model-visible change.
+     */
+    inspectRequestPrompt(previous: ConversationPromptSnapshot | undefined, event: SessionEvent<'request/header'>, system: SystemPromptNode | undefined): RequestPromptInspection;
+    private drop;
+}
+//# sourceMappingURL=assembly.d.ts.map

package/lib/types/client/conversation/definition-registry.d.ts

@@ -0,0 +1,33 @@
+import { type Context } from '@deepseek-ai/cordis';
+/** Shared lifecycle and stable-entry storage for one Conversation Definition registry. */
+export declare abstract class ConversationDefinitionRegistry<Definition> {
+    protected readonly ctx: Context;
+    protected readonly definitions: Map<string, Definition>;
+    private listeners;
+    private cached;
+    /** @param ctx - Context whose effects own contributed Definitions. */
+    constructor(ctx: Context);
+    /**
+     * Return reference-stable Definitions in registration order.
+     * @returns current Definitions.
+     */
+    entries(): readonly Definition[];
+    /**
+     * Observe low-frequency registry changes.
+     * @param listener - synchronous invalidation callback.
+     * @returns unsubscribe callback.
+     */
+    subscribe(listener: () => void): () => void;
+    /**
+     * Register one uniquely keyed Definition for the caller's lifetime.
+     * @param key - registry-local unique key.
+     * @param definition - contributed Definition.
+     * @param duplicateMessage - error raised when the key is already owned.
+     * @param effectName - Cordis effect diagnostic label.
+     * @returns idempotent disposer.
+     */
+    protected registerDefinition(key: string, definition: Definition, duplicateMessage: string, effectName: string): () => void;
+    /** Refresh cached entries and synchronously invalidate subscribers. */
+    protected refresh(): void;
+}
+//# sourceMappingURL=definition-registry.d.ts.map

package/lib/types/client/conversation/event-registry.d.ts

@@ -0,0 +1,24 @@
+import type { ConversationNodeDefinition } from '../contract/conversation.ts';
+import { ConversationDefinitionRegistry } from './definition-registry.ts';
+/** Runtime registry of independently owned Conversation business Definitions. */
+export declare class ConversationEventRegistry extends ConversationDefinitionRegistry<ConversationNodeDefinition> {
+    private fallback;
+    /**
+     * Register a uniquely named business Definition for the caller's lifetime.
+     * @param definition - Definition contribution.
+     * @returns idempotent disposer.
+     */
+    register(definition: ConversationNodeDefinition): () => void;
+    /**
+     * Register the sole fallback used only when no ordinary Definition matches.
+     * @param definition - fallback Definition.
+     * @returns idempotent disposer.
+     */
+    registerFallback(definition: ConversationNodeDefinition): () => void;
+    /**
+     * Return the current unmatched-event fallback.
+     * @returns installed fallback, when present.
+     */
+    fallbackEntry(): ConversationNodeDefinition | undefined;
+}
+//# sourceMappingURL=event-registry.d.ts.map

package/lib/types/client/conversation/historical-images.d.ts

@@ -0,0 +1,51 @@
+/** Session-scoped durable image URL cache shared by Conversation targets. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { ImageAttachmentRef } from '@deepseek-ai/dsh-attachment';
+import type { ISessions } from '@deepseek-ai/dsh-api-session-controller/client';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+/** Resolve durable Conversation images and release their browser URLs with Session scope. */
+export declare class HistoricalImageCache {
+    private readonly sessions;
+    private readonly entries;
+    private readonly generations;
+    private readonly scopeDisposers;
+    private readonly urls;
+    private disposed;
+    /**
+     * @param ctx - Owning ui-conversation fiber.
+     * @param sessions - Session Controller object layer.
+     */
+    constructor(ctx: Context, sessions: ISessions);
+    /**
+     * Resolve and cache one session-authorized image URL.
+     * @param sessionId - Session authorization and lifetime scope.
+     * @param attachment - Durable image reference.
+     * @returns browser URL valid until the Session binding is released.
+     */
+    resolve(sessionId: SessionId, attachment: ImageAttachmentRef): Promise<string>;
+    /**
+     * Return an already-displayable URL without starting a read.
+     * @param sessionId - Session authorization and lifetime scope.
+     * @param attachment - Durable image reference.
+     * @returns current preview or canonical URL when cached.
+     */
+    peek(sessionId: SessionId, attachment: ImageAttachmentRef): string | undefined;
+    /**
+     * Adopt a submission preview while fetching the durable admitted bytes.
+     * The preview is available synchronously, then replaced and revoked when
+     * the canonical attachment read completes.
+     * @param sessionId - Session authorization and lifetime scope.
+     * @param attachment - Durable image reference the URL temporarily displays.
+     * @param url - browser URL to adopt.
+     * @returns whether the cache took ownership.
+     */
+    seed(sessionId: SessionId, attachment: ImageAttachmentRef, url: string): boolean;
+    private key;
+    private loadCanonical;
+    private assertLive;
+    private bindScope;
+    private release;
+    private releaseUrl;
+    private dispose;
+}
+//# sourceMappingURL=historical-images.d.ts.map

package/lib/types/client/conversation/location-index.d.ts

@@ -0,0 +1,85 @@
+import { type AssistantLiveChunkEvent, type SessionEventLike, type SessionEventLikeEntry } from '@deepseek-ai/dsh-api-session-controller/client';
+import type { SessionEvent } from '@deepseek-ai/dsh-session/types';
+import type { ConversationLocation, ConversationLocationData, ConversationTimelineSnapshot } from '../contract/conversation.ts';
+/** One Context's previous and next Location-data publication. */
+export interface ConversationLocationDataChange {
+    readonly owner: string;
+    readonly previous: ConversationLocationData | null;
+    readonly next: ConversationLocationData | null;
+}
+/** Session-owned Turn/Step timeline and event-to-Location index. */
+export declare class ConversationLocationIndex {
+    private coordinates;
+    private locations;
+    private seqsByTurn;
+    private timeline;
+    private readonly turnDataStores;
+    private readonly stepDataStores;
+    private readonly dirtyDataStores;
+    private currentTurn;
+    private currentStep;
+    /**
+     * Return the current reference-stable timeline.
+     * @returns current timeline snapshot.
+     */
+    snapshot(): ConversationTimelineSnapshot;
+    /**
+     * Replace all Definition-owned Location values while preserving reader identities.
+     * @param entries - complete current set of Definition-owned Location values.
+     * @returns whether any published Location data changed.
+     */
+    replaceData(entries: readonly {
+        readonly owner: string;
+        readonly data: ConversationLocationData;
+    }[]): boolean;
+    /**
+     * Apply changed Context publications without rebuilding Turn/Step membership.
+     * @param changes - incremental removals and replacements from published Contexts.
+     * @returns whether any published Location data changed.
+     */
+    applyData(changes: readonly ConversationLocationDataChange[]): boolean;
+    /** Publish committed Location-data changes to their keyed sources. */
+    publishData(): void;
+    /**
+     * Resolve the latest Location for one event.
+     * @param event - event already ingested into this index.
+     * @returns current Location, falling back to session when it has no Turn/Step affinity.
+     */
+    locationOf(event: SessionEventLike): ConversationLocation;
+    /**
+     * Rebuild timeline facts after replace/prepend or a boundary append.
+     * @param entries - complete current window in ascending seq order.
+     * @returns seqs whose resolved Location changed.
+     */
+    rebuild(entries: readonly SessionEventLikeEntry[]): ReadonlySet<number>;
+    /**
+     * Append one Turn/Step boundary while revisiting only the owning Turn.
+     * @param event - contiguous tail boundary event.
+     * @returns seqs whose immutable Location reference changed.
+     */
+    appendBoundary(event: SessionEvent): ReadonlySet<number>;
+    /**
+     * Index one non-boundary tail event without rescanning the window.
+     * @param event - contiguous appended event.
+     */
+    appendNonBoundary(event: SessionEventLike): void;
+    /**
+     * Remove indexed Assistant transients without rebuilding the Turn/Step timeline.
+     * @param events - transient events retired by one Assistant settlement.
+     */
+    removeAssistantTransients(events: readonly AssistantLiveChunkEvent[]): void;
+    /**
+     * Index one durable Assistant settlement inserted before an already visible tail.
+     * @param event - message or attempt settlement with explicit Turn and Step coordinates.
+     */
+    insertAssistantSettlement(event: SessionEvent<'assistant/message'> | SessionEvent<'assistant/attempt'>): void;
+    private indexTurnSeq;
+    private turnData;
+    private stepData;
+    private mutableTurnData;
+    private mutableStepData;
+    private createDataStore;
+    private storeFor;
+    private resolve;
+}
+//# sourceMappingURL=location-index.d.ts.map

package/lib/types/client/conversation/view-registry.d.ts

@@ -0,0 +1,12 @@
+import type { ConversationViewDefinition } from '../contract/conversation.ts';
+import { ConversationDefinitionRegistry } from './definition-registry.ts';
+/** Runtime registry of per-target Conversation snapshot builders. */
+export declare class ConversationViewRegistry extends ConversationDefinitionRegistry<ConversationViewDefinition> {
+    /**
+     * Register a uniquely named view builder factory for the caller's lifetime.
+     * @param definition - target builder contribution.
+     * @returns idempotent disposer.
+     */
+    register(definition: ConversationViewDefinition): () => void;
+}
+//# sourceMappingURL=view-registry.d.ts.map

package/lib/types/client/image-labels.d.ts

@@ -0,0 +1,23 @@
+/** Attachment error and limit copy owned by the conversation input flow. */
+import type { ImageAttachmentLimits } from '@deepseek-ai/dsh-attachment';
+import type { Translate } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ConversationKey } from './locales.ts';
+/**
+ * Byte count as user-facing megabytes (`10MB`, `2.5MB`).
+ * @param bytes - the byte count.
+ * @returns the rounded megabyte text.
+ */
+export declare function imageSizeText(bytes: number): string;
+/**
+ * Product copy for a host attachment rejection (the `details.reason` of
+ * `session/attachment-invalid` or `subagent/attachment-invalid`).
+ * User-solvable reasons name the limit and the way out;
+ * reasons the user cannot act on fold into one send-failed line carrying the
+ * reason code for a bug report.
+ * @param t - the conversation-namespace translate.
+ * @param reason - the wire `details.reason` code.
+ * @param limits - projected limits interpolated into count/size copy, when known.
+ * @returns the banner text.
+ */
+export declare function attachmentErrorText(t: Translate<ConversationKey>, reason: string, limits?: ImageAttachmentLimits): string;
+//# sourceMappingURL=image-labels.d.ts.map

package/lib/types/client/index.d.ts

@@ -0,0 +1,36 @@
+/** Browser Conversation assemble core, React adapter, shell, and input plugin. */
+export { apply, Config, inject } from './apply.ts';
+export type { Config as ConversationConfig } from './apply.ts';
+export { UiConversation } from './conversation/assembly.ts';
+export type { ConversationBinding } from './conversation/assembly.ts';
+export { ConversationController, UnsupportedImageMediaTypeError } from './service.ts';
+export type { IConversation } from './service.ts';
+export type { ConversationContextReader, ConversationLocation, ConversationLocationData, ConversationLocationDataScope, ConversationLocationDataSource, ConversationLocationDataStore, ConversationMatch, ConversationMatchResult, ConversationNodeContext, ConversationNodeDefinition, ConversationPreviousContext, ConversationPublication, ConversationStartMatch, ConversationStepDataMap, ConversationTimelineSnapshot, ConversationTurnDataMap, ConversationViewBuilder, ConversationViewDefinition, ConversationViewNode, ConversationViewSnapshotMap, ConversationViewSnapshotStore, StepLocation, TurnLocation, } from './contract/conversation.ts';
+export { EMPTY_CONVERSATION_SNAPSHOT, conversationPhase } from './contract/snapshot.ts';
+export type { ConversationPhase, ConversationSnapshot, } from './contract/snapshot.ts';
+export type { AssistantBlock, AssistantMessageNode, AssistantProvenanceView, AssistantRequestConfig, AssistantTiming, CommandNode, CompactionSummaryNode, ContextMessageNode, ConversationNode, ModelRetryNode, PartialAssistant, RunningToolCall, SteeringMessageNode, TodoItem, ToolCallBlock, ToolResultNode, TurnErrorNode, TurnMaxTokensNode, UnknownSurfaceNode, UserMessageNode, } from './contract/records.ts';
+export type { ContextProvenanceView, ContextRole, KnownContextForm, } from './contract/context-provenance.ts';
+export type { ConversationPromptSnapshot, RequestInspectionSnapshot, RequestPromptChange, RequestPromptInspection, RequestPromptInspector, RequestView, SystemPromptNode, } from './contract/request-inspection.ts';
+export { inspectRequestPrompt } from './contract/request-inspection.ts';
+export type { SystemPromptState, SystemPromptInspector } from './contract/system-prompt.ts';
+export type { ConversationStoreState, ConversationViewRequest, ViewTab } from './contract/views.ts';
+export { ConversationNodeAssembler } from './conversation/assembler.ts';
+export type { ConversationEventDefinitions, ConversationViewDefinitions, } from './conversation/assembler.ts';
+export { ConversationDefinitionRegistry } from './conversation/definition-registry.ts';
+export { ConversationEventRegistry } from './conversation/event-registry.ts';
+export { ConversationLocationIndex } from './conversation/location-index.ts';
+export type { ConversationLocationDataChange } from './conversation/location-index.ts';
+export { ConversationViewRegistry } from './conversation/view-registry.ts';
+export type { ConversationKey } from './locales.ts';
+export type { ComposerAttachment, ComposerAttachmentsOwnerProps, ComposerAttachmentsProps, ComposerFileAttachment, ComposerImageAttachment, DraftFileUpload, DraftFileUploads, ComposerBarInjected, ComposerBarOwnerProps, ComposerBarProps, ComposerChainProps, ConversationHeaderActionOwnerProps, ConversationHeaderCornerOwnerProps, ConversationHeaderLineageOwnerProps, ConversationInjected, ConversationSessionHeaderInjected, ConversationSessionHeaderSlotProps, ConversationSessionInjected, ConversationSessionSlotProps, ConversationSlotProps, ConversationStore, ConvViewOwnerProps, ConvViewProps, EmptyWorkspaceOwnerProps, HeroAgentPresetOwnerProps, HeroBrandMarkOwnerProps, InputControlOwnerProps, InputZone, MessageImageLoader, MessageImageSource, MessageImagesOwnerProps, RenderMessageImages, UseConversation, UseConversationViews, } from './contract/slots.ts';
+export type { ArbitrateKey, ArbitrateOutcome, BeginCommandRequest, CommandClaim, ConsumeTokenRequest, DraftAttachmentId, InputActions, InputState, InsertReferenceRequest, InsertTextRequest, PickOutcome, ReferenceInsert, SessionInput, SessionInputResolver, SubmitAttachment, SubmitOutcome, TokenSpan, } from './contract/input.ts';
+export type { ComposerBlock, ComposerBlocks } from './contract/composer-blocks.ts';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /** Scope-addressed Conversation actions and per-Session input registry. */
+        conversation: import('./service.ts').IConversation;
+        /** Target-neutral Conversation registries and per-Session assembly. */
+        uiConversation: import('./conversation/assembly.ts').UiConversation;
+    }
+}
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/input/blocks.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Composer blocks: the one way another plugin stops a session's input.
+ *
+ * The composer cannot read the plugins that would know — the dependency runs
+ * ui-model-selection → ui-conversation, never back — so a blocker pushes here and the
+ * bar reads its own session's store. A block carries the localized reason it
+ * exists, because the plugin that raised it owns that copy; the composer only
+ * knows how to render an inert textarea with a placeholder, exactly as it
+ * already does for a session with no workspace.
+ *
+ * This is an affordance, not enforcement: the Host refuses a prompt it cannot
+ * route regardless of what any client disables.
+ */
+import { type SnapshotStore } from '@deepseek-ai/dsh-client-store';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { ComposerBlock, ComposerBlocks } from '../contract/composer-blocks.ts';
+/** The per-session composer-block registry (one instance per plugin fiber). */
+export declare class ComposerBlockRegistry implements ComposerBlocks {
+    private readonly stores;
+    /** @inheritdoc */
+    set(sessionId: SessionId, block: ComposerBlock | undefined): void;
+    /** @inheritdoc */
+    storeFor(sessionId: SessionId): SnapshotStore<ComposerBlock | undefined>;
+    /** @inheritdoc */
+    forget(sessionId: SessionId): void;
+}
+//# sourceMappingURL=blocks.d.ts.map

package/lib/types/client/input/decorations.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Plain-text reference scan (the plain-text-reference decision;
+ * see .agents/notes/archived/architecture/2026-07-25-web-input-machine-and-slash-pipeline.md):
+ * a `/name` or `@name` token whose name is on the trigger's lexicon, and
+ * syntax-recognizable `@dir/` folder tokens. Pure derivation — the editor's
+ * text-ref entity transform consumes these ranges; editing the text out of
+ * match shape simply drops the range next scan.
+ */
+/**
+ * One plain-text reference range (the plain-text-reference decision;
+ * see .agents/notes/archived/architecture/2026-07-25-web-input-machine-and-slash-pipeline.md):
+ * a `/name` or `@name` token
+ * whose name is on the trigger's lexicon. Pure derivation — editing the text
+ * out of match shape simply drops the range next scan.
+ */
+export interface TextRefRange {
+    readonly start: number;
+    readonly end: number;
+    readonly trigger: '/' | '@';
+}
+/**
+ * Scan the draft for plain-text reference tokens against the hot lexicons.
+ * Word-boundary discipline: the trigger must sit at the draft
+ * start or after whitespace ('x/name' never matches); the name must be an
+ * exact lexicon member; a `/name` token must end at whitespace or the draft
+ * end ('/name/x' is a path, '/name。' is prose).
+ * @param draft - draft text.
+ * @param lexicon - per-trigger name lists (a missing trigger scans nothing).
+ * @returns matched ranges in draft order.
+ */
+export declare function scanTextRefs(draft: string, lexicon: ReadonlyMap<'/' | '@', readonly string[]>): TextRefRange[];
+//# sourceMappingURL=decorations.d.ts.map

package/lib/types/client/input/editor/ComposerContentEditable.d.ts

@@ -0,0 +1,16 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+import type { LexicalEditor } from 'lexical';
+/** Host props: the editor binding plus the div passthroughs the bar owns. */
+export interface ComposerContentEditableProps extends HTMLAttributes<HTMLDivElement> {
+    /** The shell-owned editor; null renders the same div unbound and inert. */
+    readonly editor: LexicalEditor | null;
+    /** Whether the user may edit (readOnly/disabled states fold in here). */
+    readonly editable: boolean;
+}
+/**
+ * Render the composer's editable surface.
+ * @param props - editor binding, editability, and div passthroughs.
+ * @returns the resident contenteditable div.
+ */
+export declare function ComposerContentEditable({ editor, editable, ...rest }: ComposerContentEditableProps): ReactNode;
+//# sourceMappingURL=ComposerContentEditable.d.ts.map

package/lib/types/client/input/editor/DecoratorPortals.d.ts

@@ -0,0 +1,14 @@
+import type { ReactNode } from 'react';
+import type { LexicalEditor } from 'lexical';
+/** Portal-loop props. */
+export interface DecoratorPortalsProps {
+    /** The bound editor; null (no-session) renders nothing. */
+    readonly editor: LexicalEditor | null;
+}
+/**
+ * Render every decorator's React face into its editor host element.
+ * @param props - the editor to observe.
+ * @returns the live portal set.
+ */
+export declare function DecoratorPortals({ editor }: DecoratorPortalsProps): ReactNode;
+//# sourceMappingURL=DecoratorPortals.d.ts.map

package/lib/types/client/input/editor/ReferenceChip.d.ts

@@ -0,0 +1,17 @@
+import type { ReactNode } from 'react';
+import type { ReferenceIconKind } from '@deepseek-ai/dsh-client-ui-primitives';
+/** Display inputs of one chip (the node's cached owner projections). */
+export interface ReferenceChipProps {
+    readonly label: string;
+    /** Domain glyph; absent renders the trigger marker instead of an icon. */
+    readonly appearance?: ReferenceIconKind | undefined;
+    /** Owner-resolution failure styling bit. */
+    readonly invalid: boolean;
+}
+/**
+ * Render one inline reference chip.
+ * @param props - label, optional domain glyph, and the invalid bit.
+ * @returns the chip body (icon + truncating label).
+ */
+export declare function ReferenceChip({ label, appearance, invalid }: ReferenceChipProps): ReactNode;
+//# sourceMappingURL=ReferenceChip.d.ts.map

package/lib/types/client/input/editor/chip-node.d.ts

@@ -0,0 +1,110 @@
+/**
+ * ReferenceChipNode: one inline reference as an atomic Lexical decorator.
+ * The node IS the occurrence — NodeKey carries identity, the node carries
+ * the owner's insert-time projections (label/appearance/clipboardText), and
+ * `getTextContent()` answers the clipboard/persistence projection so native
+ * copy and the draft mirror stay correct without expansion code. The detect
+ * projection (trigger scanning and TokenSpan coordinates) counts every chip
+ * as one U+FFFC instead; see projection.ts.
+ */
+import type { JSX } from 'react';
+import type { EditorConfig, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from 'lexical';
+import { DecoratorNode } from 'lexical';
+import type { ReferenceInsert } from '../../contract/input.ts';
+/** JSON form of one chip (Lexical node serialization contract). */
+export type SerializedReferenceChipNode = Spread<{
+    source: string;
+    ref: string;
+    label: string;
+    appearance?: ReferenceInsert['appearance'];
+    clipboardText: string;
+    invalid: boolean;
+}, SerializedLexicalNode>;
+/** One inline reference occurrence as an atomic decorator node. */
+export declare class ReferenceChipNode extends DecoratorNode<JSX.Element> {
+    /** Owning source name (serializer routing key). */
+    __source: string;
+    /** Owner-scoped reference id. */
+    __ref: string;
+    /** Inline display label (insert-time cache). */
+    __label: string;
+    /** Optional domain glyph (insert-time cache). */
+    __appearance: ReferenceInsert['appearance'];
+    /** Clipboard / persistence projection, e.g. `/name` (never the model form). */
+    __clipboardText: string;
+    /** Owner-resolution failure flag: chip renders invalid; serialization must fail. */
+    __invalid: boolean;
+    /** Lexical node registry type tag. */
+    static getType(): string;
+    /**
+     * Clone with identity (Lexical writable-copy contract).
+     * @param node - node to clone.
+     * @returns a copy carrying the same NodeKey.
+     */
+    static clone(node: ReferenceChipNode): ReferenceChipNode;
+    /**
+     * Rebuild one chip from its JSON form.
+     * @param json - serialized chip.
+     * @returns a fresh node (new key).
+     */
+    static importJSON(json: SerializedReferenceChipNode): ReferenceChipNode;
+    /**
+     * @param insert - the owner's reference insertion (display projections included).
+     * @param invalid - owner-resolution failure bit (defaults valid).
+     * @param key - Lexical clone-path key; absent for fresh nodes.
+     */
+    constructor(insert: Omit<ReferenceInsert, 'appearance'> & {
+        appearance?: ReferenceInsert['appearance'];
+    }, invalid?: boolean, key?: NodeKey);
+    /** Serialize to the JSON node form. */
+    exportJSON(): SerializedReferenceChipNode;
+    /**
+     * Mount the chip's host element; the decorator portal renders into it.
+     * @returns an inline, non-editable span carrying the test/e2e anchor.
+     */
+    createDOM(_config: EditorConfig): HTMLElement;
+    /** Host element never changes shape. */
+    updateDOM(): boolean;
+    /** Chips sit in the text line. */
+    isInline(): boolean;
+    /**
+     * No keyboard-selected intermediate state: arrows step across the chip in
+     * one move and Backspace/Delete remove it whole (the placeholder semantics
+     * of the old textarea). `true` would put a NodeSelection between the
+     * keystroke and the caret — a state the plain-text binding's handlers all
+     * ignore, deadlocking arrows, typing, and deletion at the chip edge.
+     */
+    isKeyboardSelectable(): boolean;
+    /** Clipboard / persistence projection (native copy reads this). */
+    getTextContent(): string;
+    /**
+     * Flip the owner-resolution failure bit.
+     * @param invalid - next bit; no-op writes are the caller's concern.
+     */
+    setInvalid(invalid: boolean): void;
+    /** Owner-resolution failure bit. */
+    isInvalid(): boolean;
+    /** Owning source name. */
+    getSource(): string;
+    /** Owner-scoped reference id. */
+    getReference(): string;
+    /** Inline display label. */
+    getLabel(): string;
+    /** Optional domain glyph. */
+    getAppearance(): ReferenceInsert['appearance'];
+    /** React face rendered into the host element by the decorator portal. */
+    decorate(): JSX.Element;
+}
+/**
+ * Mint one chip node from a reference insertion.
+ * @param insert - the owner's reference insertion.
+ * @returns the fresh node.
+ */
+export declare function $createReferenceChipNode(insert: ReferenceInsert): ReferenceChipNode;
+/**
+ * Chip type guard.
+ * @param node - any node or nullish.
+ * @returns whether the node is a ReferenceChipNode.
+ */
+export declare function $isReferenceChipNode(node: LexicalNode | null | undefined): node is ReferenceChipNode;
+//# sourceMappingURL=chip-node.d.ts.map

package/lib/types/client/input/editor/claim-decor.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Claim-token highlight: while a command claim holds, the draft's leading
+ * token renders in the warn color. A TextNode transform keeps the token in
+ * its own styled node (splitting when typing merges text into it), and the
+ * shell nudges the first leaf dirty when the claim flips so entering and
+ * leaving claimed restyles without a text edit.
+ */
+import type { LexicalEditor } from 'lexical';
+/**
+ * Register the claim-token styling transform.
+ * @param editor - the shell-owned editor.
+ * @param activeToken - live claim token accessor; null while unclaimed.
+ * @returns the unregister disposer.
+ */
+export declare function registerClaimDecoration(editor: LexicalEditor, activeToken: () => string | null): () => void;
+/**
+ * Nudge the token seat dirty so the transform restyles after a claim flip
+ * (claims change phase without a text edit; transforms only run on dirty
+ * nodes).
+ * @param editor - the shell-owned editor.
+ */
+export declare function refreshClaimDecoration(editor: LexicalEditor): void;
+//# sourceMappingURL=claim-decor.d.ts.map