@tangle-network/agent-app 0.45.54 → 0.45.56

package/dist/stories/assistant/fixtures.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Assistant-story fixtures: a fully-stubbed `AssistantClient` (no network — the
+ * panel's hooks fetch models/threads on mount, and the dock's real
+ * `useAssistantChat` streams through it), a controlled `AssistantChat` handle
+ * for the panel stories (the same fake the panel's own tests build), and the
+ * transcript/proposal data those stories render.
+ *
+ * The shared `src/stories/fixtures/` chat fixtures model web-react's
+ * `ChatUiMessage`; the assistant transcript consumes the FLAT wire
+ * `ChatMessage[]` shape (user/assistant/tool/status rows the reducer emits), so
+ * this area keeps its own fixtures rather than bending the shared ones.
+ */
+import { type AssistantClient, type AssistantThreadSummary } from '../../assistant';
+import { type AssistantState } from '../../assistant/reducer';
+import type { AssistantStreamEvent, ChatMessage, PendingProposal, UsageInfo } from '../../assistant/types';
+import type { AssistantChat } from '../../assistant/useAssistantChat';
+import type { ComposerFile } from '../../web-react';
+declare const STORY_USER_ID = "u-story";
+/** Past conversations for the history view, newest activity first. */
+export declare const threadSummaries: AssistantThreadSummary[];
+/** A settled two-turn conversation: tool chips with args + outcomes, a status
+ *  line, and enough prose to judge bubble spacing. */
+export declare const populatedMessages: ChatMessage[];
+/** A settled confirmed action: the proposal flow ended in the quiet status
+ *  line ("Created workflow …") rather than an assistant-labeled turn. */
+export declare const confirmedMessages: ChatMessage[];
+/** A turn mid-stream: preamble text, a running tool chip, and an open (still
+ *  empty) bubble the deltas are accumulating into. */
+export declare const streamingMessages: ChatMessage[];
+export declare const streamingReasoning = "The user wants a scheduled post. A cron trigger plus the Slack send step covers it \u2014 checking the workspace connections before proposing anything mutating.";
+/** The turn-level metrics a settled turn leaves behind. */
+export declare const settledUsage: UsageInfo;
+export declare const workflowYaml = "name: launch-poster-monday\ntrigger:\n  type: schedule\n  cron: \"0 9 * * MON\"\nsteps:\n  - id: render\n    uses: canvas/export\n    with:\n      page: page-1\n      format: png\n      dpi: 144\n  - id: post\n    uses: slack/send-message\n    with:\n      channel: \"#launch\"\n      text: \"This week's poster: {{ steps.render.outputs.url }}\"\n";
+/** A workflow-authoring proposal awaiting confirmation, with one unconnected
+ *  requirement (the connect affordance renders) and one satisfied. */
+export declare const workflowProposal: PendingProposal;
+/** A create-key proposal — the scalar-fields card (no body preview). */
+export declare const apiKeyProposal: PendingProposal;
+/** Twenty messages of ordinary back-and-forth — long enough that the transcript
+ *  scrolls, so spacing and typography evaluate under real rhythm. */
+export declare const longHistoryMessages: ChatMessage[];
+export interface StubClientOptions {
+    /** Replace the scripted turn (e.g. an erroring stream). */
+    streamEvents?: (req: {
+        message: string;
+    }) => AssistantStreamEvent[];
+}
+/** Shared instance for stories that don't customize the transport. The model
+ *  catalog is cached per client (WeakMap in `useAssistantModels`), so sharing
+ *  one avoids a refetch on every story mount. */
+export declare const stubClient: AssistantClient;
+/**
+ * A minimal `AssistantChat` over a controlled state slice — the same fake the
+ * panel's tests build, with `console.log` callbacks instead of spies. The
+ * panel reads `state` and binds the handlers; the transport is never involved.
+ */
+export declare function makeFakeChat(over?: Partial<AssistantState>): AssistantChat;
+export { STORY_USER_ID };
+/**
+ * A story-level stand-in for the host attachment pipeline (web-react's
+ * `useComposerAttachments` + an upload route): each picked/dropped file stages
+ * as an 'uploading' chip and flips to 'ready' after a beat, so stories exercise
+ * the composer's chip lifecycle with no network. `onSend` clears the staged
+ * set — wire it to the panel/dock `onComposerSend`.
+ */
+export declare function useStubAttachments(): {
+    attachments: {
+        onAttach: (files: FileList) => void;
+        pendingFiles: ComposerFile[];
+        onRemoveFile: (id: string) => void;
+    };
+    onSend: () => void;
+};

package/dist/stories/chat/fixtures.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Chat-story fixtures: a long, realistic `ChatUiMessage` thread for spacing and
+ * density evaluation, plus the individual edge-state messages (proposal
+ * awaiting approval, errored tool call, streaming in progress) exported on
+ * their own so stories can render a single state in isolation.
+ *
+ * NOTE: this duplicates what the shared `src/stories/fixtures/chat.ts` barrel
+ * is meant to provide. The shared fixtures directory did not exist in the
+ * working tree when these stories were written, so — per house rules — the
+ * chat area carries its own copy. If the shared fixtures return, this file can
+ * be swapped for barrel imports without touching the stories.
+ *
+ * Types come from the package source (`../../web-react`) — the same types the
+ * chat components consume — so a drift in `ChatUiMessage` fails typecheck here.
+ */
+import type { CatalogModel, ChatToolCallInfo, ChatUiMessage } from '../../web-react';
+/** The catalogue the thread prices against. Every fixture message runs Opus. */
+export declare const chatCatalogModels: CatalogModel[];
+/** A completed sandbox command, args + result captured for the expanded row. */
+export declare const doneShellToolCall: ChatToolCallInfo;
+/**
+ * A proposal the human has not ruled on yet: `pendingApprovalOf` keys on
+ * `result.status === 'queued_for_approval'` + a proposalId, so the row becomes
+ * the Approve/Reject decision card when the story passes `approval` handlers.
+ */
+export declare const proposalToolCall: ChatToolCallInfo;
+/** A tool call whose run failed — the row renders the error state + message. */
+export declare const erroredToolCall: ChatToolCallInfo;
+/** A tool call still executing — no `result` yet, the row shows the spinner. */
+export declare const runningToolCall: ChatToolCallInfo;
+/**
+ * A settled `schedule_followup` — NOT a decision and not a failure, so it
+ * renders as the quiet follow-up row (its own visual kind).
+ */
+export declare const scheduledFollowupToolCall: ChatToolCallInfo;
+/** Assistant turn whose proposal is still awaiting human approval. */
+export declare const proposalAwaitingApprovalMessage: ChatUiMessage;
+/** Assistant turn whose only tool call failed. */
+export declare const erroredToolCallMessage: ChatUiMessage;
+/**
+ * A turn still streaming: partial answer text, a tool call in flight, and no
+ * completion metrics yet (no `completionTokens`/`durationMs` — producers only
+ * stamp those when the turn settles).
+ */
+export declare const streamingAssistantMessage: ChatUiMessage;
+/**
+ * ~16 messages covering every rendered state: plain exchanges, reasoning,
+ * per-message metrics, interleaved `segments`, a proposal awaiting approval,
+ * an errored tool call, and a trailing in-flight turn. Long enough that the
+ * thread scrolls, so spacing/typography stories evaluate real rhythm.
+ */
+export declare const chatThread: ChatUiMessage[];
+/** Three turns — the smallest thread that still shows bubble/answer rhythm. */
+export declare const shortThread: ChatUiMessage[];
+/**
+ * Six representative turns (user bubble, assistant + approval card, errored
+ * tool, long user message, segmented assistant) for side-by-side density
+ * comparisons — compact enough to judge rhythm within one viewport.
+ */
+export declare const densityThread: ChatUiMessage[];
+/** The segmented `usage_report` turn on its own (custom-renderer demos). */
+export declare const usageReportMessage: ChatUiMessage[];
+/**
+ * A workflow-authoring session: both assistant turns carry `reasoning`, the
+ * first emits four consecutive settled tool calls (past the collapse threshold,
+ * so they fold into one "Worked through 4 steps" disclosure), the second
+ * interleaves text and tools via `segments` (under the threshold, so the cards
+ * render inline, chronologically).
+ */
+export declare const reasoningToolThread: ChatUiMessage[];

package/dist/stories/chat/markdown.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A tiny dependency-free `renderMarkdown` for the chat stories — the same
+ * injection point a real consumer wires its markdown library into. Handles the
+ * subset the fixtures actually use: paragraphs, `>` blockquotes, ordered
+ * lists, `**bold**`, and `inline code`. Anything richer is the consumer's job.
+ */
+import type { ReactNode } from 'react';
+/** The `renderMarkdown` prop: blocks split on blank lines; a block that is all
+ *  `>` lines becomes a blockquote, all `N.` lines an ordered list, anything
+ *  else a pre-wrapped paragraph. */
+export declare function renderMarkdown(content: string): ReactNode;

package/dist/stories/chat/run-drill-in.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Story-only wiring for the tool row's "Open full transcript" action. In
+ * production the host serves a persisted `ToolRunRecord` per `toolCallId`
+ * (fail-closed: only ids its own loop created) and mounts `RunDrillIn` itself;
+ * the stories have no server, so they synthesize the record from the call's
+ * own args/result. That keeps the demo functional — the button opens the real
+ * panel over the transcript — instead of dead-ending on a console.log.
+ */
+import { type ReactNode } from 'react';
+import { type ChatToolCallInfo } from '../../web-react';
+/**
+ * Wrap a ChatMessages story so `onToolCallClick` opens the real `RunDrillIn`
+ * panel (and still logs, for parity with the other story hosts). The panel is
+ * `fixed` against the canvas's right edge, exactly as `ChatControls/RunDrillIn
+ * → Over transcript` mounts it.
+ */
+export declare function WithRunDrillIn({ children, }: {
+    children: (onToolCallClick: (call: ChatToolCallInfo) => void) => ReactNode;
+}): import("react").JSX.Element;

package/dist/stories/chat-controls/fixtures.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Chat-controls story fixtures — area-local because the shared
+ * `src/stories/fixtures/` barrel is absent from this checkout (the storybook
+ * scaffolding was never committed; see the chat-controls handoff note). The
+ * catalog list mirrors the documented shared `catalogModels` fixture
+ * 1:1 so a later dedupe pass is a pure import swap.
+ *
+ * Everything here is typed against package source (`../../web-react` and the
+ * leaf modules the components themselves import from), so a drift in any of
+ * these shapes fails typecheck in this file.
+ */
+import { type ReactNode } from 'react';
+import type { Decorator } from '@storybook/react';
+import type { AgentActivityPage, CatalogModel, ChatAttachmentPart, ChatEmptyDoor, ChatInteraction, ComposerFile, SubmitInteractionAnswer, ToolRunRecord, WorkProductCardProps } from '../../web-react';
+import type { StepAgentActivity } from '../../missions/agent-activity';
+import type { FlowTrace } from '../../trace';
+import type { ChatPlan } from '../../plans';
+import type { WorkProductPersistedPart } from '../../work-product/types';
+import type { ProductSeatOffer } from '../../platform/billing';
+/** Same five-model catalogue the playground ships (`makeModels`). */
+export declare const catalogModels: CatalogModel[];
+export declare const DEFAULT_MODEL_ID: string;
+/** A model with `supportsReasoning: false` — the effort picker hides for it. */
+export declare const NON_REASONING_MODEL_ID = "deepseek/deepseek-chat";
+/** The exact pending-file pair the playground's ComposerRoute ships. */
+export declare const pendingComposerFiles: ComposerFile[];
+/** Adds an errored chip so the destructive tone is covered too. */
+export declare const pendingComposerFilesWithError: ComposerFile[];
+export declare const fileAttachmentParts: ChatAttachmentPart[];
+export declare const imageAttachmentParts: ChatAttachmentPart[];
+export declare const mixedAttachmentParts: ChatAttachmentPart[];
+/** Serves real bytes for every attachment URL — thumbnails render. */
+export declare const fetchAttachmentOk: (url: string) => Promise<Response>;
+/** 404s every URL — thumbnails flip to the error tile, chips error on click. */
+export declare const fetchAttachmentMissing: () => Promise<Response>;
+/** Never settles — thumbnails hold the loading skeleton. */
+export declare const fetchAttachmentHangs: () => Promise<Response>;
+export declare const resolveAttachmentUrl: (part: ChatAttachmentPart) => string;
+export declare const emptyStateDoors: ChatEmptyDoor[];
+export declare const completedToolRun: ToolRunRecord;
+export declare const erroredToolRun: ToolRunRecord;
+export declare const runningToolRun: ToolRunRecord;
+/** One part per `WorkProductStatus` — every pill tone the card can render. */
+export declare const workProductParts: WorkProductPersistedPart[];
+export declare const openWorkProduct: WorkProductCardProps['onOpen'];
+/** The plan-approval ask, waiting on the human. */
+export declare const pendingPlanInteraction: ChatInteraction;
+/** Long enough (>320px) that the body collapses behind "Show full plan". */
+export declare const longPlanInteraction: ChatInteraction;
+export declare const approvedPlanInteraction: ChatInteraction;
+export declare const declinedPlanInteraction: ChatInteraction;
+export declare const expiredPlanInteraction: ChatInteraction;
+/** Single-select ask with per-option descriptions. */
+export declare const selectQuestionInteraction: ChatInteraction;
+/** Multi-select with a granted write-in row (`allowCustom`). */
+export declare const channelsQuestionInteraction: ChatInteraction;
+/** Free-text ask with a length cap. */
+export declare const freeTextQuestionInteraction: ChatInteraction;
+/** One of each open input kind: boolean, number, secret. */
+export declare const credentialsQuestionInteraction: ChatInteraction;
+export declare const answeredQuestionInteraction: ChatInteraction;
+export declare const expiredQuestionInteraction: ChatInteraction;
+export declare const okSubmitAnswer: SubmitInteractionAnswer;
+export declare const logResolved: (id: string, status: string, answers?: unknown) => void;
+export declare const okLateAnswer: (message: string) => boolean;
+export declare const okReRequest: (interaction: ChatInteraction) => boolean;
+export declare const pendingDurablePlan: ChatPlan;
+export declare const approvedDurablePlan: ChatPlan;
+export declare const rejectedDurablePlan: ChatPlan;
+export declare const withdrawnDurablePlan: ChatPlan;
+/** Seat offer with a discounted first month — the `offer` prop's render path. */
+export declare const seatOffer: ProductSeatOffer;
+export declare const activityLaneRuns: StepAgentActivity[];
+/** Cursor-paged data port: first page carries `nextCursor`, the second ends. */
+export declare const fetchActivityPopulated: (cursor?: string) => Promise<AgentActivityPage>;
+export declare const fetchActivityEmpty: () => Promise<AgentActivityPage>;
+export declare const fetchActivityError: () => Promise<AgentActivityPage>;
+/** Never settles — the refresh spinner holds. */
+export declare const fetchActivityHangs: () => Promise<AgentActivityPage>;
+export declare const posterFlowTrace: FlowTrace;
+export declare const failedFlowTrace: FlowTrace;
+/**
+ * Clicks the first button inside its subtree on mount — the trick that renders
+ * a popover-driven control (ModelPicker, EffortPicker, the lane's "timeline"
+ * toggle) in its OPEN state for a static story. Programmatic `click()` fires
+ * no `mousedown`, so `usePopover`'s outside-click closer does not immediately
+ * re-close it.
+ */
+export declare function AutoClick({ children, selector }: {
+    children: ReactNode;
+    selector?: string;
+}): import("react").JSX.Element;
+/**
+ * Real positive-Y headroom for upward-opening popovers. ModelPicker,
+ * EffortPicker, and AgentSessionControls' menus are inline-absolute
+ * `bottom-full` popovers: opened near the canvas top they extend into
+ * negative-Y space, which the iframe cannot scroll to — the popover reads as
+ * clipped no matter the layout. (The old `pt-[NNNpx]` wrappers only pushed
+ * the trigger down a fixed amount; the popover still overflowed whenever the
+ * canvas was shorter than the pad plus the popover.)
+ *
+ * This decorator anchors the story to the BOTTOM of a 520px-tall block
+ * (`flex items-end`), so the popover opens into canvas space above the
+ * trigger. 520px covers the tallest popover (ModelPicker ~470px; the gear
+ * menu ~260px and EffortPicker ~210px fit with room to spare). Works under
+ * both `centered` and `padded` layouts.
+ *
+ *   decorators: [withPopoverHeadroom]
+ */
+export declare const withPopoverHeadroom: Decorator;
+/**
+ * Minimal line-based markdown renderer for the plan/question cards'
+ * `renderMarkdown` slot — just enough structure (headings, lists, quotes) for
+ * the card stories to show formatted copy instead of the pre-wrap fallback.
+ */
+export declare function renderStoryMarkdown(markdown: string): ReactNode;

package/dist/stories/design-canvas/fixtures.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Local fixtures + harness helpers for the design-canvas stories.
+ *
+ * `makeLaunchPosterScene` mirrors the shared `../fixtures/canvas.ts` fixture
+ * (kept local so these stories are self-contained); the multi-page and empty
+ * scenes are additions covering the editor's page strip, layers states, and
+ * empty-state doors.
+ */
+import type { SceneDocument, ScenePage } from '../../design-canvas';
+import type { SceneOperation } from '../../design-canvas';
+/** Single-page poster scene — populated enough that every editor surface
+ *  (layers, toolbar, rulers, guides) renders with real content. Text elements
+ *  reference Inter, loaded in `.storybook/preview-head.html`. */
+export declare function makeLaunchPosterScene(): SceneDocument;
+/** One blank 1080×1080 page — drives the branded empty state (three doors). */
+export declare function makeEmptyScene(): SceneDocument;
+/**
+ * Three pages with distinct aspect ratios so the pages strip shows real
+ * variety. Page 2 carries the layers-showcase set: a group with children,
+ * a hidden element, a locked element, a slot-bound element, and one element
+ * of every remaining kind (image/video included — their media never loads in
+ * Storybook, which exercises the placeholder/broken treatments). One
+ * data-URL art card (`el-hero-art`) gives the page a designed focal point
+ * amid the intentional placeholders.
+ */
+export declare function makeMultiPageScene(): SceneDocument;
+/** The layers-showcase page on its own (panel stories). */
+export declare function makeLayersShowcasePage(): ScenePage;
+/**
+ * Read the live theme from the document element so the Konva canvas (which
+ * cannot resolve CSS vars) paints with the active palette. Tracks the global
+ * Storybook theme toolbar, which mutates `data-theme` / `.dark` on
+ * `document.documentElement`. Stories never set the theme themselves.
+ */
+export declare function useIsDark(): boolean;
+/**
+ * Host-side persistence for editor stories, mirroring the playground canvas
+ * route: ops are reduced into local document state with the engine's real
+ * `applySceneOperations`, so the editor rebases onto a coherent post-apply
+ * document on every save (and a rejected op would surface, not echo stale).
+ */
+export declare function useLocalSceneDocument(initial: SceneDocument): {
+    document: SceneDocument;
+    rev: number;
+    onApplyOperations: (operations: SceneOperation[]) => Promise<{
+        rev: number;
+        document: SceneDocument;
+    }>;
+};
+/**
+ * Deterministic offline thumbnail for PagesStrip stories: an SVG data URL
+ * painting the page background plus simplified element fills. The real
+ * Konva-based renderer is exercised through the full editor stories.
+ */
+export declare function renderFakeThumbnail(page: ScenePage): Promise<string | null>;
+/** Never resolves — drives the PagesStrip placeholder (loading) treatment. */
+export declare function renderPendingThumbnail(): Promise<string | null>;

package/dist/stories/fixtures/canvas.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Canvas fixture: a multi-element `SceneDocument` populated enough that the
+ * editor surface — layers panel, toolbar, rulers, guides — renders with real
+ * content rather than an empty shell. Text elements reference Inter, loaded in
+ * `.storybook/preview-head.html` (Konva measures against real loaded fonts).
+ */
+import type { SceneDocument } from '../../design-canvas';
+export declare function makeLaunchPosterScene(): SceneDocument;
+/** Prebuilt instance for stories that don't need isolation. */
+export declare const launchPosterScene: SceneDocument;

package/dist/stories/fixtures/catalog.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Model-catalog fixtures: the catalogue the chat surfaces price per-message
+ * cost against and the composer model picker lists. Same shapes the playground
+ * ships, typed against the package's own `CatalogModel`.
+ */
+import type { CatalogModel } from '../../web-react';
+export declare const catalogModels: CatalogModel[];

package/dist/stories/fixtures/chat.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Chat fixtures: a long, realistic `ChatUiMessage` thread for story spacing
+ * evaluation, plus the individual edge-state messages (proposal awaiting
+ * approval, errored tool call, streaming in progress) exported on their own
+ * so stories can render a single state in isolation.
+ *
+ * Types come from the package source (`../../web-react`) — the same types the
+ * chat components consume — so a drift in `ChatUiMessage` fails typecheck here.
+ */
+import type { ChatToolCallInfo, ChatUiMessage } from '../../web-react';
+/** A completed sandbox command, args + result captured for the expanded card. */
+export declare const doneShellToolCall: ChatToolCallInfo;
+/**
+ * A proposal the human has not ruled on yet: `pendingApprovalOf` keys on
+ * `result.status === 'queued_for_approval'` + a proposalId, so the chip renders
+ * the Approve/Reject affordance when the story passes `approval` handlers.
+ */
+export declare const proposalToolCall: ChatToolCallInfo;
+/** A tool call whose run failed — the chip renders the error state + message. */
+export declare const erroredToolCall: ChatToolCallInfo;
+/** A tool call still executing — no `result` yet, chip shows the spinner. */
+export declare const runningToolCall: ChatToolCallInfo;
+/** Assistant turn whose proposal is still awaiting human approval. */
+export declare const proposalAwaitingApprovalMessage: ChatUiMessage;
+/** Assistant turn whose only tool call failed. */
+export declare const erroredToolCallMessage: ChatUiMessage;
+/**
+ * A turn still streaming: partial answer text, a tool call in flight, and no
+ * completion metrics yet (no `completionTokens`/`durationMs` — producers only
+ * stamp those when the turn settles).
+ */
+export declare const streamingAssistantMessage: ChatUiMessage;
+/**
+ * ~16 messages covering every rendered state: plain exchanges, reasoning,
+ * per-message metrics, interleaved `segments`, a proposal awaiting approval,
+ * an errored tool call, and a trailing in-flight turn. Long enough that the
+ * thread scrolls, so spacing/typography stories evaluate real rhythm.
+ */
+export declare const chatThread: ChatUiMessage[];

package/dist/stories/fixtures/index.d.ts

@@ -0,0 +1,4 @@
+export * from './chat';
+export * from './catalog';
+export * from './canvas';
+export * from './sequences';

package/dist/stories/fixtures/sequences.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Sequences fixtures: a video + caption `SequenceTimeline` for the timeline
+ * editor, and a dependency-free `VideoFrameProvider` that paints deterministic
+ * solid frames — no media decode, no network — so the preview monitor renders
+ * something real in stories.
+ */
+import type { SequenceTimeline } from '../../sequences';
+import type { VideoFrameProvider } from '../../sequences-react';
+export declare function makePlaygroundReelTimeline(): SequenceTimeline;
+/** Prebuilt instance for stories that don't need isolation. */
+export declare const playgroundReelTimeline: SequenceTimeline;
+/**
+ * Simplest valid `VideoFrameProvider`: paints a deterministic solid color into
+ * the preview rect. `drawFrame` never touches network or <video>/<img>. The
+ * color cycles by second so scrubbing is visibly distinct.
+ */
+export declare function makeSolidFrameProvider(): VideoFrameProvider;

package/dist/stories/panels/fixtures.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Fixtures for the panels area (teams / intakes / work-product). Local to this
+ * area: the shared `src/stories/fixtures` barrel covers chat, catalog, canvas,
+ * and sequences — none of which these surfaces consume.
+ *
+ * Shapes mirror the API seams: `MemberView` / `InvitationView` are what
+ * `teams/members-api` and `teams/invitations-api` return, `IntakeView` is what
+ * `intakes/api` returns, and `WorkProductRecord` is the durable review row.
+ */
+import type { IntakeAnswers } from '../../intakes/model';
+import type { IntakeView } from '../../intakes-react';
+import type { InviteAcceptDetails, InvitationView, MemberView } from '../../teams-react';
+import type { ProfileBacktestSummary, WorkProductRecord } from '../../work-product/types';
+/** A realistic workspace roster: an explicit owner, an inherited org owner
+ *  (not editable here), one of each assignable role, and a pending invite. */
+export declare const MEMBERS: MemberView[];
+/** Every lifecycle status × every email-delivery status a history list shows. */
+export declare const INVITATIONS: InvitationView[];
+/** The valid, signed-out invite — the landing state of `/invite/:token`. */
+export declare const INVITE_SIGNED_OUT: InviteAcceptDetails;
+/** Signed in as the invited address — the accept action is live. */
+export declare const INVITE_READY: InviteAcceptDetails;
+/** Signed in as someone else — the switch-account branch. */
+export declare const INVITE_EMAIL_MISMATCH: InviteAcceptDetails;
+/** Right address, unverified — the resend-verification branch. */
+export declare const INVITE_NEEDS_VERIFICATION: InviteAcceptDetails;
+/** Derive a view from the graph the same way `intakes/api` does — the server
+ *  re-derives next question + progress after every persisted answer. */
+export declare function intakeViewFor(answers: IntakeAnswers, completed?: boolean): IntakeView;
+/** Answer snapshots at each step of the flow, for the static step stories. */
+export declare const INTAKE_STEPS: {
+    /** Nothing answered — the text question, progress 0/3. */
+    start: {};
+    /** Name answered — the single-select question, progress 1/3. */
+    role: {
+        name: string;
+    };
+    /** Role answered — the boolean question (optional multi-select skipped), 2/3. */
+    briefings: {
+        name: string;
+        role: string;
+    };
+    /** All required answered — nextQuestion is null, the Finish action shows. */
+    ready: {
+        name: string;
+        role: string;
+        stack: string[];
+        briefings: true;
+    };
+};
+/** Bodies behind `history[].artifactPath`, for the version-compare seam. */
+export declare const VERSION_BODIES: Record<string, string>;
+/** A ready-for-review legal redline: baseline diff, span/model evidence,
+ *  one exception per severity, mixed-verdict checks, and a 3-version history. */
+export declare const REDLINE_RECORD: WorkProductRecord;
+/** The trust-gate-passing backtest summary for the redline record's profile. */
+export declare const BACKTEST_PASS: ProfileBacktestSummary;
+/** An accumulating draft: artifact null, every list empty — the "nothing to
+ *  review yet" pane (artifact tab renders its empty copy). */
+export declare const DRAFT_RECORD: WorkProductRecord;
+/** A tax-style fields package: no markdown body — the artifact is a structured
+ *  field map (rendered as JSON) and lineage anchors to form-line ids. */
+export declare const FIELDS_RECORD: WorkProductRecord;

package/dist/stories/sequences/fixtures.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Sequences-area story fixtures. Self-contained on purpose: the shared
+ * `src/stories/fixtures/` barrel was absent from the working tree when these
+ * stories were written, so this file mirrors its `makePlaygroundReelTimeline`
+ * and `makeSolidFrameProvider` byte-for-byte behavior (same shapes, same
+ * solid-color provider — no media decode, no network) and adds the
+ * multi-track, empty, and lookup variants the sequence stories need. If the
+ * shared fixtures return, the reel/provider below can be re-pointed at them.
+ */
+import type { SequenceApplyResult, SequenceClip, SequenceOperation, SequenceTimeline, SequenceTrack } from '../../sequences';
+import type { VideoFrameProvider } from '../../sequences-react';
+export declare function makePlaygroundReelTimeline(): SequenceTimeline;
+export declare function makeStudioCutTimeline(): SequenceTimeline;
+export declare function makeEmptyTimeline(): SequenceTimeline;
+export declare function makeAudioClip(): SequenceClip;
+export declare function trackOf(timeline: SequenceTimeline, trackId: string): SequenceTrack;
+export declare function clipsOf(timeline: SequenceTimeline, trackId: string): SequenceClip[];
+export declare function clipOf(timeline: SequenceTimeline, clipId: string): SequenceClip;
+/**
+ * Simplest valid `VideoFrameProvider`: paints a deterministic solid color into
+ * the preview rect. `drawFrame` never touches network or <video>/<img>. The
+ * color cycles by second so scrubbing is visibly distinct.
+ */
+export declare function makeSolidFrameProvider(): VideoFrameProvider;
+/**
+ * Host `onApplyOperations` stand-in: logs the operations and echoes an
+ * index-aligned `SequenceApplyResult[]` so the editor's optimistic-id
+ * reconciliation has a well-formed reply for any edit (playground pattern).
+ */
+export declare function makeEchoApply(timeline: SequenceTimeline): (operations: SequenceOperation[]) => Promise<SequenceApplyResult[]>;

package/dist/stories/studio/fixtures.d.ts

@@ -0,0 +1,22 @@
+import type { IntegrationConnection } from '@tangle-network/sandbox-ui/integrations';
+import type { Generation } from '../../studio';
+export declare const teaserA: Generation;
+export declare const storyboardGeneration: Generation;
+export declare const videoGeneration: Generation;
+export declare const avatarGeneration: Generation;
+export declare const speechGeneration: Generation;
+export declare const transcriptionGeneration: Generation;
+export declare const queuedGeneration: Generation;
+export declare const runningGeneration: Generation;
+export declare const failedGeneration: Generation;
+export declare const storageFailedGeneration: Generation;
+export declare const publishPackageGeneration: Generation;
+/** The four-image batch a single "Images: 4" run produces. */
+export declare const teaserBatch: Generation[];
+/** Populated library: the newest batch first, every type and status represented. */
+export declare const libraryGenerations: Generation[];
+export declare const libraryTotalCost = 1.87;
+/** Mirrors StudioWorkspace's default vaultHref (see generation-detail.test.tsx). */
+export declare const demoVaultHref: (filePath?: string | null) => string;
+/** Connected destinations for the publish-package composer (instagram + X). */
+export declare const demoConnections: IntegrationConnection[];

package/dist/stream/index.d.ts

@@ -1,56 +1,10 @@
-import { J as JsonRecord } from '../stream-normalizer-DKRxyVlZ.js';
-export { M as MISSING_TOOL_TERMINAL_ERROR, b as MISSING_TOOL_TERMINAL_REASON, S as StreamEvent, c as asRecord, d as asString, a as attachmentPartKey, e as collapseRedundantTextParts, f as draftAssistantParts, g as encodeEvent, h as finalizeAssistantParts, i as finalizePendingInteractionParts, j as getPartKey, m as mergePersistedPart, n as normalizePersistedPart, k as normalizeTime, l as normalizeToolEvent, r as resolveToolId, o as resolveToolName, t as terminalizeDanglingAssistantToolUpdates, p as terminalizeDanglingToolPart, q as terminalizeDanglingToolParts } from '../stream-normalizer-DKRxyVlZ.js';
-export { B as BufferedTurnEvent, a as BufferedTurnOptions, b as BufferedTurnTap, D as D1LikeForTurns, c as DEFAULT_RUNNING_TURN_LEASE_MS, d as DEFAULT_RUNNING_TURN_RENEW_INTERVAL_MS, P as PumpBufferedTurnOptions, R as ReplayTurnEventsOptions, e as TURN_EVENTS_MIGRATION_SQL, f as TURN_STATUS_SCOPE_MIGRATION_SQL, T as TurnEventStore, g as TurnEventStoreOptions, h as TurnStatus, i as coalesceChatStreamEvents, j as coalesceDeltas, k as createBufferedTurnTap, l as createD1TurnEventStore, m as createMemoryTurnEventStore, p as pumpBufferedTurn, r as replayTurnEvents, s as stampReplaySeq } from '../turn-buffer-COMQUwO2.js';
-import '../contract-OxG_jVMx.js';
-import '@tangle-network/agent-interface';
-
-/** Define the structure of a chat message stored for a specific conversation turn */
-interface PersistedChatMessageForTurn {
-    id: string;
-    role: 'user' | 'assistant' | 'system' | 'tool';
-    content: string;
-    parts: Array<Record<string, unknown>> | null;
-}
-/** Represent a chat turn with resolved user message insertion and prior message context */
-interface ResolvedChatTurn {
-    turnIndex: number;
-    shouldInsertUserMessage: boolean;
-    priorMessages: PersistedChatMessageForTurn[];
-    userParts: JsonRecord[];
-    /** The id of the user row this turn REUSES (retry dedup), when one was
-     *  found. Absent on the insert path, where no row exists yet.
-     *
-     *  The reused row is deliberately EXCLUDED from `priorMessages` (it is this
-     *  turn's own user message, not prior context), so this field is the only
-     *  way a caller can name it. */
-    reusedUserMessageId?: string;
-}
-/** Normalize and validate a client turn ID string ensuring it meets format and length requirements */
-declare function normalizeClientTurnId(value: unknown): string | undefined;
-/** Build an array of text parts with optional turn ID for user input */
-declare function buildUserTextParts(text: string, turnId: string | undefined): JsonRecord[];
-/** Resolve whether a message contains any part with the specified turn ID */
-declare function messageHasTurnId(message: PersistedChatMessageForTurn, turnId: string): boolean;
-/** Resolve a chat turn by determining message reuse and constructing user message parts */
-declare function resolveChatTurn(input: {
-    existingMessages: PersistedChatMessageForTurn[];
-    userContent: string;
-    turnId?: string;
-    /** True when the thread has a turn still RUNNING in the turn-event buffer
-     *  (`turnStore.listRunning(threadId)`).
-     *
-     *  Without incremental persistence the trailing row of a thread mid-turn is
-     *  always the user row, so the content fallback below could assume it. With
-     *  incremental persistence the assistant row lands seconds into the turn, so
-     *  a retry of that same turn finds an ASSISTANT row trailing and would
-     *  insert a duplicate user row.
-     *
-     *  This flag is the discriminator that keeps both cases right, and it needs
-     *  no new state: an assistant row trailing a turn that is still running is
-     *  that turn's in-flight draft (walk past it — this is a retry), whereas an
-     *  assistant row trailing a SETTLED turn is a completed answer (stop — the
-     *  user genuinely repeated a message and deserves a new turn). */
-    hasRunningTurn?: boolean;
-}): ResolvedChatTurn;
-
-export { JsonRecord, type PersistedChatMessageForTurn, type ResolvedChatTurn, buildUserTextParts, messageHasTurnId, normalizeClientTurnId, resolveChatTurn };
+/**
+ * Chat-stream mechanism — provider-agnostic normalization of an agent SSE/event
+ * stream into the `StreamEvent` shape a web client consumes, plus turn-identity
+ * resolution (mapping a client-supplied turn id onto persisted messages for
+ * idempotent replay). Pure mechanism, zero domain — every agent app's chat
+ * route hand-rolls this otherwise.
+ */
+export * from './stream-normalizer';
+export * from './turn-identity';
+export * from './turn-buffer';