@tangle-network/agent-app 0.26.0 → 0.28.0

package/dist/runtime/index.d.ts

@@ -1,13 +1,44 @@
+export { C as CatalogModel, M as ModelCatalog, R as RouterModel, _ as __resetCatalogCache, b as buildCatalog, f as fetchModelCatalog, n as normalizeModelId } from '../model-catalog-BEAEVDaa.js';
+export { C as CreateTangleRouterModelConfigOptions, D as DEFAULT_TANGLE_BILLING_ENFORCEMENT_ENV_VAR, a as DEFAULT_TANGLE_ROUTER_BASE_URL, R as ResolveModelOptions, b as ResolveUserTangleExecutionKeyForUserOptions, c as ResolveUserTangleExecutionKeyOptions, d as ResolvedTangleExecutionKey, T as TangleBillingEnforcementOptions, e as TangleExecutionEnvironment, f as TangleExecutionKeyError, g as TangleExecutionKeyErrorCode, h as TangleExecutionKeyHttpError, i as TangleExecutionKeySource, j as TangleModelConfig, k as createTangleRouterModelConfig, l as isTangleBillingEnforcementDisabled, m as isTangleExecutionKeyError, r as resolveTangleExecutionEnvironment, n as resolveTangleModelConfig, o as resolveUserTangleExecutionKey, p as resolveUserTangleExecutionKeyForUser, t as tangleExecutionKeyHttpError } from '../model-CKzniMMr.js';
 import * as _tangle_network_agent_runtime from '@tangle-network/agent-runtime';
 import { ToolLoopMessage, ToolLoopResult, StreamToolLoopYield, ToolLoopCall } from '@tangle-network/agent-runtime';
 export { RunToolLoopOptions as AppToolLoopOptions, ToolLoopAssistantToolCall as LoopAssistantToolCall, ToolLoopMessage as LoopMessage, ToolLoopCall as LoopToolCall, StreamToolLoopOptions as StreamAppToolLoopOptions, StreamToolLoopYield as StreamLoopYield, ToolLoopEvent, ToolLoopResult, ToolLoopStopReason, runToolLoop as runAppToolLoop, streamToolLoop as streamAppToolLoop } from '@tangle-network/agent-runtime';
-export { C as CatalogModel, M as ModelCatalog, R as RouterModel, _ as __resetCatalogCache, b as buildCatalog, f as fetchModelCatalog, n as normalizeModelId } from '../model-catalog-BEAEVDaa.js';
-export { C as CreateTangleRouterModelConfigOptions, D as DEFAULT_TANGLE_BILLING_ENFORCEMENT_ENV_VAR, a as DEFAULT_TANGLE_ROUTER_BASE_URL, R as ResolveModelOptions, b as ResolveUserTangleExecutionKeyForUserOptions, c as ResolveUserTangleExecutionKeyOptions, d as ResolvedTangleExecutionKey, T as TangleBillingEnforcementOptions, e as TangleExecutionEnvironment, f as TangleExecutionKeyError, g as TangleExecutionKeyErrorCode, h as TangleExecutionKeyHttpError, i as TangleExecutionKeySource, j as TangleModelConfig, k as createTangleRouterModelConfig, l as isTangleBillingEnforcementDisabled, m as isTangleExecutionKeyError, r as resolveTangleExecutionEnvironment, n as resolveTangleModelConfig, o as resolveUserTangleExecutionKey, p as resolveUserTangleExecutionKeyForUser, t as tangleExecutionKeyHttpError } from '../model-CKzniMMr.js';
 import { b as AppToolContext, e as AppToolProducedEvent, f as AppToolTaxonomy, c as AppToolHandlers, d as AppToolOutcome } from '../types-2rOJo8Hc.js';
 import { CertifiedProfile } from '@tangle-network/agent-runtime/intelligence';
 import { A as AppToolMcpServer } from '../mcp-BShTlESm.js';
 import '../auth-BlS9GWfL.js';
 
+/**
+ * Events the app's OpenAI-compat stream adapter ({@link toLoopEvents}) yields.
+ *
+ * This is the app's own `Raw` event type for the streaming loop — the canonical
+ * `streamToolLoop<Raw>` is generic over it. It widens the substrate's
+ * tool-loop event with `reasoning` (DeepSeek/router `reasoning_content` /
+ * `thinking` deltas, rendered as thinking sections) and `usage` (per-message
+ * token accounting) — neither belongs in the substrate's loop contract, so they
+ * stay here. The adapter maps each into the `streamTurn` seam; `text` and
+ * `tool_call` drive the loop, `reasoning` / `usage` pass through to the UI.
+ */
+type LoopEvent = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'reasoning';
+    text: string;
+} | {
+    type: 'tool_call';
+    call: _tangle_network_agent_runtime.ToolLoopCall;
+} | {
+    type: 'usage';
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+    };
+} | {
+    type: 'other';
+    event: unknown;
+};
+
 /**
  * OpenAI-compatible stream → `LoopEvent` adapter, for NON-sandbox copilots.
  *
@@ -356,35 +387,4 @@ interface SurfaceMergeBase {
  */
 declare function mergeSurfaceOverlay<TBase extends SurfaceMergeBase>(base: TBase, overlay: SurfaceOverlay): TBase & SurfaceMergeBase;
 
-/**
- * Events the app's OpenAI-compat stream adapter ({@link toLoopEvents}) yields.
- *
- * This is the app's own `Raw` event type for the streaming loop — the canonical
- * `streamToolLoop<Raw>` is generic over it. It widens the substrate's
- * tool-loop event with `reasoning` (DeepSeek/router `reasoning_content` /
- * `thinking` deltas, rendered as thinking sections) and `usage` (per-message
- * token accounting) — neither belongs in the substrate's loop contract, so they
- * stay here. The adapter maps each into the `streamTurn` seam; `text` and
- * `tool_call` drive the loop, `reasoning` / `usage` pass through to the UI.
- */
-type LoopEvent = {
-    type: 'text';
-    text: string;
-} | {
-    type: 'reasoning';
-    text: string;
-} | {
-    type: 'tool_call';
-    call: _tangle_network_agent_runtime.ToolLoopCall;
-} | {
-    type: 'usage';
-    usage: {
-        promptTokens: number;
-        completionTokens: number;
-    };
-} | {
-    type: 'other';
-    event: unknown;
-};
-
 export { type AgentRuntime, type AgentRuntimeModelConfig, type AgentTurnOptions, type AnySurfaceKind, type CertifiedDelivery, type CertifiedDeliveryConfig, type CreateAgentRuntimeOptions, type LoopEvent, type OpenAICompatStreamTurnOptions, type OpenAIStreamChunk, type ResolvedAgentProfile, type SurfaceKindDefinition, type SurfaceMcpServer, type SurfaceMergeBase, type SurfaceOverlay, type SurfacePermissionValue, type SurfaceRegistry, createAgentRuntime, createCertifiedDelivery, createOpenAICompatStreamTurn, createSurfaceRegistry, defineSurfaceKind, mergeSurfaceOverlay, toLoopEvents };

package/dist/runtime/index.js

@@ -12,7 +12,7 @@ import {
   runToolLoop,
   streamToolLoop,
   toLoopEvents
-} from "../chunk-LUE4HO5C.js";
+} from "../chunk-4IQMTTNE.js";
 import {
   DEFAULT_TANGLE_BILLING_ENFORCEMENT_ENV_VAR,
   DEFAULT_TANGLE_ROUTER_BASE_URL,

package/dist/sequences/index.d.ts

@@ -1,6 +1,6 @@
 import { j as SequenceMediaKind, o as SequenceTimeline, r as TimelineInterval, m as SequenceStore } from '../store-gckrNq-g.js';
 export { M as MIN_SEQUENCE_CLIP_FRAMES, N as NewSequenceClip, a as NewSequenceDecision, b as NewSequenceTrack, S as SequenceClip, c as SequenceClipMedia, d as SequenceClipPatch, e as SequenceDecision, f as SequenceExportFormat, g as SequenceExportRecord, h as SequenceExportStatus, i as SequenceFrameSnapshot, k as SequenceMeta, l as SequenceStatus, n as SequenceStoreScope, p as SequenceTrack, q as SequenceTrackKind, T as TimelineClipBounds, s as assertClipFitsSequence, t as chooseCaptionPlacement, u as clampClipDuration, v as clampClipStart, w as formatSeconds, x as formatTimecode, y as framesToSeconds, z as secondsToFrames, A as snapshotFrame, B as trackIntervals } from '../store-gckrNq-g.js';
-export { A as AddCaptionOperation, C as CaptionTargetResolution, a as CreateTrackOperation, D as DeleteClipOperation, E as ExtendSequenceOperation, M as MoveClipOperation, P as PlaceClipOperation, Q as QueueExportOperation, S as SEQUENCE_OPERATION_TYPES, b as SequenceApplyResult, c as SequenceOperation, d as SequenceOperationContext, e as SequenceOperationType, f as SequencePlan, g as SetClipDisabledOperation, h as SetClipTextOperation, i as SplitClipOperation, T as TrimClipOperation, j as applySequenceOperation, k as applySequenceOperations, l as assertSequenceMediaUrl, m as captionTrackNameForLanguage, n as lastClipEndFrame, p as parseSequenceOperations, r as resolveCaptionPlacement, o as resolveCaptionTarget, q as resolvePlaceClipTrack, v as validateAddCaption, s as validateCreateTrack, t as validateDeleteClip, u as validateExtendSequence, w as validateMoveClip, x as validatePlaceClip, y as validateQueueExport, z as validateSequenceOperation, B as validateSequenceOperations, F as validateSetClipDisabled, G as validateSetClipText, H as validateSplitClip, I as validateTrimClip } from '../apply-Cp8c3K9D.js';
+export { A as AddCaptionOperation, C as CaptionTargetResolution, a as CreateTrackOperation, D as DeleteClipOperation, E as ExtendSequenceOperation, M as MoveClipOperation, P as PlaceClipOperation, Q as QueueExportOperation, S as SEQUENCE_OPERATION_TYPES, b as SequenceApplyResult, c as SequenceOperation, d as SequenceOperationContext, e as SequenceOperationType, f as SequencePlan, g as SetClipDisabledOperation, h as SetClipTextOperation, i as SplitClipOperation, T as TrimClipOperation, j as applySequenceOperation, k as applySequenceOperations, l as assertSequenceMediaUrl, m as captionTrackNameForLanguage, n as lastClipEndFrame, p as parseSequenceOperations, r as resolveCaptionPlacement, o as resolveCaptionTarget, q as resolvePlaceClipTrack, v as validateAddCaption, s as validateCreateTrack, t as validateDeleteClip, u as validateExtendSequence, w as validateMoveClip, x as validatePlaceClip, y as validateQueueExport, z as validateSequenceOperation, B as validateSequenceOperations, F as validateSetClipDisabled, G as validateSetClipText, H as validateSplitClip, I as validateTrimClip } from '../apply-Gk4raT2j.js';
 import { c as ToolHeaderNames } from '../auth-BlS9GWfL.js';
 import { A as AppToolMcpServer } from '../mcp-BShTlESm.js';
 import { b as AppToolContext } from '../types-2rOJo8Hc.js';

package/dist/sequences/index.js

@@ -41,7 +41,7 @@ import {
   validateSetClipText,
   validateSplitClip,
   validateTrimClip
-} from "../chunk-6UOE5CTA.js";
+} from "../chunk-JT6HHO5P.js";
 import {
   MIN_SEQUENCE_CLIP_FRAMES,
   assertClipFitsSequence,
@@ -55,6 +55,7 @@ import {
   snapshotFrame,
   trackIntervals
 } from "../chunk-ZYBWGSAZ.js";
+import "../chunk-HFC4BTWJ.js";
 import "../chunk-A76ZHWNF.js";
 export {
   DEFAULT_SEQUENCES_MCP_DESCRIPTION,

package/dist/sequences-react/index.d.ts

@@ -1,4 +1,4 @@
-import { c as SequenceOperation, b as SequenceApplyResult } from '../apply-Cp8c3K9D.js';
+import { c as SequenceOperation, b as SequenceApplyResult } from '../apply-Gk4raT2j.js';
 import { o as SequenceTimeline, S as SequenceClip, p as SequenceTrack } from '../store-gckrNq-g.js';
 import * as react from 'react';
 import react__default from 'react';
@@ -543,6 +543,9 @@ interface TimelineClipChipProps {
     sequenceDurationFrames: number;
     selected: boolean;
     canWrite: boolean;
+    /** Roving-tabindex: exactly one chip per editor carries tabIndex 0 so the
+     *  clip set is a single Tab stop; arrows move focus across the others. */
+    tabbable: boolean;
     frameProvider: VideoFrameProvider;
     /** Snap a candidate move (both clip edges considered); editor closes over
      *  the engine's snap points. */
@@ -564,6 +567,12 @@ interface TimelineClipChipProps {
     };
     onSnapPointChange(point: SnapPoint | null): void;
     onSelect(clipId: string, additive: boolean): void;
+    /** Keyboard delete of the focused clip (one command on the stack), routed
+     *  through the same locked-track guard as the transport Delete key. */
+    onRequestDelete(clipId: string): void;
+    /** Move keyboard focus to the previous/next clip in DOM order (roving
+     *  tabindex); the editor owns the ordered chip set. */
+    onFocusStep(clipId: string, direction: -1 | 1): void;
     onCommitMove(input: ClipMoveCommit): void;
     onCommitTrim(input: ClipTrimCommit): void;
     onCommitText(input: {
@@ -580,6 +589,9 @@ interface TimelineTrackRowProps {
     zoom: number;
     sequenceDurationFrames: number;
     selectedClipIds: ReadonlySet<string>;
+    /** The single clip that carries tabIndex 0 (roving tabindex); null seeds the
+     *  first chip in the editor as the lone Tab stop. */
+    tabbableClipId: string | null;
     canWrite: boolean;
     frameProvider: VideoFrameProvider;
     snapMove(candidate: {
@@ -599,6 +611,8 @@ interface TimelineTrackRowProps {
     };
     onSnapPointChange(point: SnapPoint | null): void;
     onSelectClip(clipId: string, additive: boolean): void;
+    onRequestDeleteClip(clipId: string): void;
+    onFocusStepClip(clipId: string, direction: -1 | 1): void;
     onCommitMove(input: ClipMoveCommit): void;
     onCommitTrim(input: ClipTrimCommit): void;
     onCommitText(input: {

package/dist/sequences-react/index.js

@@ -47,7 +47,7 @@ import {
   trimClipCommand,
   trimEndDrag,
   trimStartDrag
-} from "../chunk-RJ2ZHK5D.js";
+} from "../chunk-S6WS2B32.js";
 import "../chunk-ZYBWGSAZ.js";
 
 // src/sequences-react/media/transcription.ts
@@ -182,7 +182,7 @@ function createWhisperTranscriptionProvider(opts) {
 
 // src/sequences-react/lazy.tsx
 import React from "react";
-var SequenceTimelineEditorLazy = React.lazy(() => import("../TimelineEditor-JDG54OBP.js"));
+var SequenceTimelineEditorLazy = React.lazy(() => import("../TimelineEditor-Z7C6BFP5.js"));
 export {
   COMMAND_HISTORY_LIMIT,
   DEFAULT_MAX_MEDIA_ELEMENTS,

package/dist/{store-CUStmtdH.d.ts → store-CFyxgTlD.d.ts}

@@ -1,4 +1,4 @@
-import { c as SceneDocument } from './model-BHLN208Z.js';
+import { c as SceneDocument } from './model-BBwyOuWG.js';
 
 /**
  * Storage contract for design-canvas documents. Unlike sequences (row per

package/dist/theme/index.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Typed mirror of tokens.css for runtime/JS theming. The canonical source is
+ * tokens.css (`import '@tangle-network/agent-app/styles'`); this module is for
+ * apps that compute theme variables in JS, or read color values where CSS
+ * custom properties cannot reach — notably Konva canvas render code, which
+ * paints to a bitmap and cannot resolve `var(--…)`.
+ *
+ * Values are shadcn-style HSL channel triples ("H S% L%"); wrap with `color()`.
+ */
+interface AgentAppTheme {
+    background: string;
+    foreground: string;
+    card: string;
+    cardForeground: string;
+    popover: string;
+    popoverForeground: string;
+    primary: string;
+    primaryForeground: string;
+    secondary: string;
+    secondaryForeground: string;
+    muted: string;
+    mutedForeground: string;
+    accent: string;
+    accentForeground: string;
+    destructive: string;
+    destructiveForeground: string;
+    border: string;
+    input: string;
+    ring: string;
+    success: string;
+    successForeground: string;
+    warning: string;
+    warningForeground: string;
+    /** Full CSS color (not a triple) — the canvas/scene backdrop. */
+    canvasBackdrop: string;
+    /** Konva render palette — full hex colors the bitmap canvas paints with
+     *  (it cannot resolve `var(--…)`). NOT emitted by themeToCssVars. */
+    canvasRender: CanvasRenderPalette;
+}
+/**
+ * Colors the Konva design-canvas paints directly. Konva renders to a bitmap
+ * and cannot read CSS custom properties, so these are full hex strings sourced
+ * from the active theme and threaded through the canvas components.
+ */
+interface CanvasRenderPalette {
+    /** Grid line color (GridLayer). */
+    grid: string;
+    /** Grid-snap guide line (SnapGuidesOverlay, kind 'grid'). */
+    snapGrid: string;
+    /** Saved ruler-guide snap line (kind 'guide'). */
+    snapGuide: string;
+    /** Page edge/center snap line (kinds 'page-edge'/'page-center'). */
+    snapPage: string;
+    /** Element edge/center snap line (kinds 'element-edge'/'element-center'). */
+    snapElement: string;
+    /** Transformer border + anchor stroke (SelectionLayer). */
+    selectionStroke: string;
+    /** Transformer anchor fill (SelectionLayer). */
+    selectionAnchorFill: string;
+    /** Video placeholder fill (ElementNode VideoNode). */
+    placeholderFill: string;
+    /** Video placeholder stroke (ElementNode VideoNode). */
+    placeholderStroke: string;
+    /** Broken/loading image placeholder fill (ElementNode ImageNode). */
+    brokenFill: string;
+    /** Broken/loading image placeholder stroke (ElementNode ImageNode). */
+    brokenStroke: string;
+}
+declare const lightTheme: AgentAppTheme;
+declare const darkTheme: AgentAppTheme;
+/** Wrap a channel triple in `hsl()`; pass through values already in a color form. */
+declare function themeColor(value: string): string;
+/**
+ * Map a theme to the full CSS-variable set (shadcn triples + canvas/sequences
+ * aliases + canvas surface). Apply at runtime to scope a theme without loading
+ * tokens.css: `Object.assign(el.style, themeToCssVars(darkTheme))`.
+ */
+declare function themeToCssVars(theme: AgentAppTheme): Record<string, string>;
+
+export { type AgentAppTheme, type CanvasRenderPalette, darkTheme, lightTheme, themeColor, themeToCssVars };

package/dist/theme/index.js

@@ -0,0 +1,14 @@
+import "../chunk-UAKFCMWK.js";
+import {
+  darkTheme,
+  lightTheme,
+  themeColor,
+  themeToCssVars
+} from "../chunk-Y2SZVW35.js";
+export {
+  darkTheme,
+  lightTheme,
+  themeColor,
+  themeToCssVars
+};
+//# sourceMappingURL=index.js.map

package/dist/theme/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/theme/tailwind-preset.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Tailwind preset mapping the shadcn semantic color names used by web-react
+ * (bg-card, text-muted-foreground, border-border, …) onto the CSS variables in
+ * tokens.css — so a consuming app themes every agent-app surface from one source.
+ *
+ *   // tailwind.config.{js,ts}
+ *   import agentAppPreset from '@tangle-network/agent-app/tailwind-preset'
+ *   export default { presets: [agentAppPreset], content: [...] }
+ *
+ * Pair with `import '@tangle-network/agent-app/styles'` for the variable values.
+ * design-canvas/sequences need no preset — they consume vars via arbitrary
+ * values (bg-[var(--bg-input)]), which Tailwind supports without color config.
+ */
+declare const agentAppPreset: {
+    darkMode: [string, string];
+    theme: {
+        extend: {
+            colors: {
+                background: string;
+                foreground: string;
+                border: string;
+                input: string;
+                ring: string;
+                success: {
+                    DEFAULT: string;
+                    foreground: string;
+                };
+                warning: {
+                    DEFAULT: string;
+                    foreground: string;
+                };
+                card: {
+                    DEFAULT: string;
+                    foreground: string;
+                };
+                popover: {
+                    DEFAULT: string;
+                    foreground: string;
+                };
+                primary: {
+                    DEFAULT: string;
+                    foreground: string;
+                };
+                secondary: {
+                    DEFAULT: string;
+                    foreground: string;
+                };
+                muted: {
+                    DEFAULT: string;
+                    foreground: string;
+                };
+                accent: {
+                    DEFAULT: string;
+                    foreground: string;
+                };
+                destructive: {
+                    DEFAULT: string;
+                    foreground: string;
+                };
+            };
+        };
+    };
+};
+
+export { agentAppPreset as default };

package/dist/theme/tailwind-preset.js

@@ -0,0 +1,33 @@
+// src/theme/tailwind-preset.ts
+var withForeground = (name) => ({
+  DEFAULT: `hsl(var(--${name}))`,
+  foreground: `hsl(var(--${name}-foreground))`
+});
+var agentAppPreset = {
+  darkMode: ["class", '[data-theme="dark"]'],
+  theme: {
+    extend: {
+      colors: {
+        background: "hsl(var(--background))",
+        foreground: "hsl(var(--foreground))",
+        border: "hsl(var(--border))",
+        input: "hsl(var(--input))",
+        ring: "hsl(var(--ring))",
+        success: withForeground("success"),
+        warning: withForeground("warning"),
+        card: withForeground("card"),
+        popover: withForeground("popover"),
+        primary: withForeground("primary"),
+        secondary: withForeground("secondary"),
+        muted: withForeground("muted"),
+        accent: withForeground("accent"),
+        destructive: withForeground("destructive")
+      }
+    }
+  }
+};
+var tailwind_preset_default = agentAppPreset;
+export {
+  tailwind_preset_default as default
+};
+//# sourceMappingURL=tailwind-preset.js.map

package/dist/theme/tailwind-preset.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/theme/tailwind-preset.ts"],"sourcesContent":["/**\n * Tailwind preset mapping the shadcn semantic color names used by web-react\n * (bg-card, text-muted-foreground, border-border, …) onto the CSS variables in\n * tokens.css — so a consuming app themes every agent-app surface from one source.\n *\n *   // tailwind.config.{js,ts}\n *   import agentAppPreset from '@tangle-network/agent-app/tailwind-preset'\n *   export default { presets: [agentAppPreset], content: [...] }\n *\n * Pair with `import '@tangle-network/agent-app/styles'` for the variable values.\n * design-canvas/sequences need no preset — they consume vars via arbitrary\n * values (bg-[var(--bg-input)]), which Tailwind supports without color config.\n */\n\nconst withForeground = (name: string) => ({\n  DEFAULT: `hsl(var(--${name}))`,\n  foreground: `hsl(var(--${name}-foreground))`,\n})\n\nconst agentAppPreset = {\n  darkMode: ['class', '[data-theme=\"dark\"]'] as [string, string],\n  theme: {\n    extend: {\n      colors: {\n        background: 'hsl(var(--background))',\n        foreground: 'hsl(var(--foreground))',\n        border: 'hsl(var(--border))',\n        input: 'hsl(var(--input))',\n        ring: 'hsl(var(--ring))',\n        success: withForeground('success'),\n        warning: withForeground('warning'),\n        card: withForeground('card'),\n        popover: withForeground('popover'),\n        primary: withForeground('primary'),\n        secondary: withForeground('secondary'),\n        muted: withForeground('muted'),\n        accent: withForeground('accent'),\n        destructive: withForeground('destructive'),\n      },\n    },\n  },\n}\n\nexport default agentAppPreset\n"],"mappings":";AAcA,IAAM,iBAAiB,CAAC,UAAkB;AAAA,EACxC,SAAS,aAAa,IAAI;AAAA,EAC1B,YAAY,aAAa,IAAI;AAC/B;AAEA,IAAM,iBAAiB;AAAA,EACrB,UAAU,CAAC,SAAS,qBAAqB;AAAA,EACzC,OAAO;AAAA,IACL,QAAQ;AAAA,MACN,QAAQ;AAAA,QACN,YAAY;AAAA,QACZ,YAAY;AAAA,QACZ,QAAQ;AAAA,QACR,OAAO;AAAA,QACP,MAAM;AAAA,QACN,SAAS,eAAe,SAAS;AAAA,QACjC,SAAS,eAAe,SAAS;AAAA,QACjC,MAAM,eAAe,MAAM;AAAA,QAC3B,SAAS,eAAe,SAAS;AAAA,QACjC,SAAS,eAAe,SAAS;AAAA,QACjC,WAAW,eAAe,WAAW;AAAA,QACrC,OAAO,eAAe,OAAO;AAAA,QAC7B,QAAQ,eAAe,QAAQ;AAAA,QAC/B,aAAa,eAAe,aAAa;AAAA,MAC3C;AAAA,IACF;AAAA,EACF;AACF;AAEA,IAAO,0BAAQ;","names":[]}

package/dist/theme/tokens.css

@@ -0,0 +1,95 @@
+/**
+ * agent-app design tokens — the single source of truth for theming every React
+ * surface (design-canvas-react, sequences-react, web-react).
+ *
+ * Import once at your app root:  import '@tangle-network/agent-app/styles'
+ * Dark mode: set `data-theme="dark"` (or class `dark`) on a parent element.
+ *
+ * Two vocabularies resolve to ONE set of channel triples:
+ *   - shadcn semantic names (--card, --foreground, --muted-foreground, …) —
+ *     consumed by web-react via Tailwind classes (bg-card, text-foreground).
+ *     Wire them with the Tailwind preset: import '@tangle-network/agent-app/tailwind-preset'.
+ *   - canvas/sequences alias names (--bg-input, --text-primary, …) — full
+ *     colors consumed directly via Tailwind arbitrary values (bg-[var(--bg-input)]).
+ *     These need no Tailwind config; tokens.css alone is enough.
+ *
+ * The aliases reference the triples, so redefining only the triples in the dark
+ * scope re-themes both vocabularies through the cascade.
+ */
+
+:root {
+  /* shadcn channel triples — "H S% L%", consumed as hsl(var(--name)) */
+  --background: 0 0% 100%;
+  --foreground: 222 47% 11%;
+  --card: 0 0% 100%;
+  --card-foreground: 222 47% 11%;
+  --popover: 0 0% 100%;
+  --popover-foreground: 222 47% 11%;
+  --primary: 221 83% 47%;
+  --primary-foreground: 0 0% 100%;
+  --secondary: 210 40% 96%;
+  --secondary-foreground: 222 47% 30%;
+  --muted: 210 40% 96%;
+  /* 44% L (was 47%) so muted text clears WCAG AA even on subtly tinted surfaces
+     (e.g. the failed tool card's 5%-red wash); ~4.7:1 on white. */
+  --muted-foreground: 215 16% 44%;
+  --accent: 210 40% 96%;
+  --accent-foreground: 222 47% 11%;
+  --destructive: 0 72% 45%;
+  --destructive-foreground: 0 0% 100%;
+  --border: 214 32% 91%;
+  --input: 214 32% 91%;
+  --ring: 221 83% 53%;
+  /* note: --primary below is darkened from 53% → 47% L so the brand blue clears
+     WCAG AA (4.5:1) when used AS TEXT on a light surface; --ring stays at the
+     brighter 53% (a 2px focus ring only needs 3:1 non-text contrast). */
+  /* status colors — dark enough on light surfaces to clear AA as text (used by
+     chips, dots, and solid buttons via the Tailwind preset's success/warning). */
+  --success: 142 72% 29%;
+  --success-foreground: 0 0% 100%;
+  --warning: 38 92% 32%;
+  --warning-foreground: 38 92% 12%;
+
+  /* canvas/sequences aliases — full colors, resolve to the triples above */
+  --bg-input: hsl(var(--card));
+  --text-primary: hsl(var(--foreground));
+  --text-secondary: hsl(var(--secondary-foreground));
+  --text-muted: hsl(var(--muted-foreground));
+  --text-danger: hsl(var(--destructive));
+  --text-warning: hsl(var(--warning));
+  --border-default: hsl(var(--border));
+  --brand-primary: hsl(var(--primary));
+
+  /* canvas-only surfaces (not part of the shadcn vocabulary). Name matches the
+     `--canvas-backdrop` the design-canvas Workspace references (with a #1a1a1a fallback). */
+  --canvas-backdrop: hsl(220 13% 91%);
+}
+
+[data-theme='dark'],
+.dark {
+  --background: 222 47% 7%;
+  --foreground: 210 40% 98%;
+  --card: 222 47% 11%;
+  --card-foreground: 210 40% 98%;
+  --popover: 222 47% 11%;
+  --popover-foreground: 210 40% 98%;
+  --primary: 217 91% 72%;
+  --primary-foreground: 222 47% 11%;
+  --secondary: 217 33% 17%;
+  --secondary-foreground: 210 40% 90%;
+  --muted: 217 33% 17%;
+  --muted-foreground: 215 20% 65%;
+  --accent: 217 33% 17%;
+  --accent-foreground: 210 40% 98%;
+  --destructive: 0 78% 67%;
+  --destructive-foreground: 0 0% 12%;
+  --border: 217 33% 20%;
+  --input: 217 33% 20%;
+  --ring: 217 91% 60%;
+  --success: 142 60% 50%;
+  --success-foreground: 142 80% 12%;
+  --warning: 38 95% 58%;
+  --warning-foreground: 38 92% 12%;
+
+  --canvas-backdrop: hsl(0 0% 10%);
+}

package/dist/trace/index.d.ts

@@ -1,3 +1,4 @@
+import { a as FlowTrace, F as FlowSpan } from '../flow-types-Cb_AblZs.js';
 import { S as StepAgentActivity } from '../agent-activity-C8ZG0F0M.js';
 
 /**
@@ -154,23 +155,6 @@ interface TimedEvent {
     t: number;
     event: Record<string, unknown>;
 }
-interface FlowSpan {
-    kind: 'pipeline' | 'model' | 'tool';
-    name: string;
-    startMs: number;
-    endMs: number;
-    approx?: boolean;
-    meta?: Record<string, unknown>;
-}
-interface FlowTrace {
-    spans: FlowSpan[];
-    totalMs: number;
-    promptTokens: number;
-    completionTokens: number;
-    /** Computed when per-token pricing is supplied. */
-    costUsd?: number;
-    toolCalls: number;
-}
 /** Parse stored turn-event lines (JSON strings with `_t`) into TimedEvents. */
 declare function timedEventsFromLines(lines: string[]): TimedEvent[];
 /**
@@ -204,4 +188,4 @@ declare function renderHistogram(values: number[], opts?: {
     format?: (v: number) => string;
 }): string;
 
-export { type DistributionSummary, type FlowSpan, type FlowTrace, type LoopTraceEventLike, type MissionFlowStep, type MissionTraceContext, type StepSpanContext, type TimedEvent, buildFlowTrace, childSpanContext, composeMissionFlowTrace, createMissionTraceContext, delegationActivityToFlowSpans, loopTraceEventsToFlowSpans, renderHistogram, renderWaterfall, stepActivityFlowTrace, summarize, timedEventsFromLines, traceEnv };
+export { type DistributionSummary, FlowSpan, FlowTrace, type LoopTraceEventLike, type MissionFlowStep, type MissionTraceContext, type StepSpanContext, type TimedEvent, buildFlowTrace, childSpanContext, composeMissionFlowTrace, createMissionTraceContext, delegationActivityToFlowSpans, loopTraceEventsToFlowSpans, renderHistogram, renderWaterfall, stepActivityFlowTrace, summarize, timedEventsFromLines, traceEnv };

package/dist/trace/index.js

@@ -7,13 +7,13 @@ import {
   summarize,
   timedEventsFromLines,
   traceEnv
-} from "../chunk-5RT6KY4G.js";
+} from "../chunk-GQRL6VNU.js";
 import {
   composeMissionFlowTrace,
   delegationActivityToFlowSpans,
   loopTraceEventsToFlowSpans,
   stepActivityFlowTrace
-} from "../chunk-AFDROJ64.js";
+} from "../chunk-2QI7XV2T.js";
 export {
   buildFlowTrace,
   childSpanContext,

package/dist/web/index.d.ts

@@ -33,7 +33,18 @@ interface RateLimitResult {
     resetAt: number;
 }
 /** KV-backed sliding-window rate limit. Stores recent timestamps per key,
- *  prunes the window, allows until `limit` is hit. */
+ *  prunes the window, allows until `limit` is hit.
+ *
+ *  Read-modify-write is best-effort, NOT atomic: KV has no compare-and-swap, so
+ *  two requests racing on the same key can each read the same pre-state and both
+ *  write — a concurrent burst can momentarily admit up to one extra request per
+ *  racing writer. This is acceptable for coarse abuse limiting; it is NOT a hard
+ *  quota gate.
+ *
+ *  Fail-CLOSED on unreadable state: corrupt/non-array KV (a poisoned or
+ *  truncated value) is treated as a full window, so a tampered key cannot reset
+ *  the count and bypass the limiter. A bare `JSON.parse` here would throw and
+ *  abort the request handler, silently disabling the limit (fail-open). */
 declare function checkRateLimit(kv: KvLike, key: string, limit: number, windowSeconds: number): Promise<RateLimitResult>;
 interface CookieOptions {
     name: string;
@@ -68,5 +79,17 @@ interface SecurityHeaderOptions {
  *  referrer-policy, XSS) + optional product disclaimer/retention. The security
  *  set is generic; the disclaimer/retention are the product's. */
 declare function addSecurityHeaders(response: Response, opts?: SecurityHeaderOptions): Response;
+/**
+ * Canonical media-reference boundary shared by every surface that persists a
+ * media url (sequences clips, design-canvas image/video src). The ONE rule:
+ * remote `http(s)` or a rooted `/api/` path are allowed; everything else is
+ * rejected, with a named reason for known-bad local/inline schemes so the
+ * thrown message is actionable for an LLM planner. The url is trimmed before
+ * the scheme check so leading whitespace cannot smuggle a rejected scheme past
+ * a naive `startsWith`.
+ *
+ * @param what - noun for the error message (e.g. 'media url', 'src').
+ */
+declare function assertMediaUrl(url: string, what?: string): void;
 
-export { type CookieOptions, type JsonObject, type KvLike, type RateLimitResult, type RequestContext, type SecurityHeaderOptions, addSecurityHeaders, checkRateLimit, clearCookieHeader, extractRequestContext, parseJsonObjectBody, readCookieValue, requireString, serializeCookie };
+export { type CookieOptions, type JsonObject, type KvLike, type RateLimitResult, type RequestContext, type SecurityHeaderOptions, addSecurityHeaders, assertMediaUrl, checkRateLimit, clearCookieHeader, extractRequestContext, parseJsonObjectBody, readCookieValue, requireString, serializeCookie };

package/dist/web/index.js

@@ -1,5 +1,6 @@
 import {
   addSecurityHeaders,
+  assertMediaUrl,
   checkRateLimit,
   clearCookieHeader,
   extractRequestContext,
@@ -7,9 +8,10 @@ import {
   readCookieValue,
   requireString,
   serializeCookie
-} from "../chunk-SCG5JJ4C.js";
+} from "../chunk-HFC4BTWJ.js";
 export {
   addSecurityHeaders,
+  assertMediaUrl,
   checkRateLimit,
   clearCookieHeader,
   extractRequestContext,