@cueframe/kernel 0.0.1

package/dist/_members/animate/composition/AnimationGroup.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+interface AnimationGroupProps {
+    children: React.ReactNode;
+    /**
+     * Per-child stagger delay in frames (default: 0 = simultaneous).
+     * Each successive child starts this many frames after the previous.
+     */
+    stagger?: number;
+    /** Delay before the group starts animating (in frames) */
+    delay?: number;
+    /** Duration each child animates for (in frames, default: 30) */
+    durationInFrames?: number;
+    /** Easing function applied to each child's progress (default: smooth) */
+    easing?: (t: number) => number;
+    /** Additional wrapper style */
+    style?: React.CSSProperties;
+}
+/**
+ * Parallel animation container with optional per-child stagger.
+ *
+ * All children animate simultaneously when stagger=0. With stagger > 0,
+ * each child starts progressively later, creating a fan-out effect.
+ *
+ * Usage:
+ *   <AnimationGroup stagger={5} durationInFrames={30}>
+ *     <GrowFromCenter><Circle /></GrowFromCenter>
+ *     <GrowFromCenter><Circle /></GrowFromCenter>
+ *     <GrowFromCenter><Circle /></GrowFromCenter>
+ *   </AnimationGroup>
+ */
+export declare const AnimationGroup: React.FC<AnimationGroupProps>;
+export {};

package/dist/_members/animate/composition/LaggedStart.d.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+interface LaggedStartProps {
+    children: React.ReactNode;
+    /**
+     * Controls timing overlap between children.
+     * 0 = all simultaneous, 1 = fully sequential, 0.3 = sweet spot (Manim default).
+     */
+    lagRatio?: number;
+    /** Total animation duration in frames (default: 60) */
+    durationInFrames?: number;
+    /** Delay before the first child starts (in frames) */
+    delay?: number;
+    /** Easing function applied to each child's progress (default: smooth) */
+    easing?: (t: number) => number;
+    /** Additional wrapper style */
+    style?: React.CSSProperties;
+}
+/**
+ * Staggered cascade animation — children animate in sequence with configurable overlap.
+ *
+ * Each child's start frame = index * lagRatio * totalDuration.
+ * lagRatio of 0.3 means each child starts when the previous is 30% through,
+ * creating the characteristic Manim "lagged start" look.
+ *
+ * Usage:
+ *   <LaggedStart lagRatio={0.3} durationInFrames={90}>
+ *     <FadeIn><div>First</div></FadeIn>
+ *     <FadeIn><div>Second</div></FadeIn>
+ *     <FadeIn><div>Third</div></FadeIn>
+ *   </LaggedStart>
+ */
+export declare const LaggedStart: React.FC<LaggedStartProps>;
+export {};

package/dist/_members/animate/composition/Succession.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+interface SuccessionProps {
+    children: React.ReactNode;
+    /** Duration each child animates for (in frames, default: 30) */
+    durationPerChild?: number;
+    /** Delay before the sequence starts (in frames) */
+    delay?: number;
+    /** Easing function applied to each child's progress (default: smooth) */
+    easing?: (t: number) => number;
+    /** Additional wrapper style */
+    style?: React.CSSProperties;
+}
+/**
+ * Sequential animation — each child waits for the previous to complete before starting.
+ *
+ * Unlike LaggedStart (overlap) or AnimationGroup (parallel), Succession is strictly
+ * sequential: child 0 plays fully, then child 1, then child 2, etc.
+ *
+ * Usage:
+ *   <Succession durationPerChild={30}>
+ *     <FadeIn direction="left"><div>Step 1</div></FadeIn>
+ *     <FadeIn direction="left"><div>Step 2</div></FadeIn>
+ *     <FadeIn direction="left"><div>Step 3</div></FadeIn>
+ *   </Succession>
+ */
+export declare const Succession: React.FC<SuccessionProps>;
+export {};

package/dist/_members/animate/composition/index.d.ts

@@ -0,0 +1,3 @@
+export { LaggedStart } from './LaggedStart.js';
+export { AnimationGroup } from './AnimationGroup.js';
+export { Succession } from './Succession.js';

package/dist/_members/animate/easing/index.d.ts

@@ -0,0 +1,3 @@
+export { smooth } from './smooth.js';
+export { smootherstep } from './smootherstep.js';
+export { rushInto, rushFrom } from './rush.js';

package/dist/_members/animate/easing/rush.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Fast start, gradual arrival. Based on Manim's rush_into.
+ * Useful for elements entering aggressively then settling.
+ *
+ * @param t - Progress value (0 to 1)
+ * @param inflection - Controls curve steepness (default 10)
+ */
+export declare function rushInto(t: number, inflection?: number): number;
+/**
+ * Gradual start, fast arrival. Based on Manim's rush_from.
+ * Useful for elements easing out then snapping to destination.
+ *
+ * @param t - Progress value (0 to 1)
+ * @param inflection - Controls curve steepness (default 10)
+ */
+export declare function rushFrom(t: number, inflection?: number): number;

package/dist/_members/animate/easing/smooth.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Manim's smooth easing — sigmoid curve with zero velocity at both endpoints.
+ * Objects start from rest, accelerate smoothly, and arrive at rest.
+ *
+ * @param t - Progress value (0 to 1)
+ * @param inflection - Controls the steepness of the curve (default 10)
+ */
+export declare function smooth(t: number, inflection?: number): number;

package/dist/_members/animate/easing/smootherstep.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Ken Perlin's smootherstep — zero velocity AND zero acceleration at endpoints.
+ * Even silkier than smooth(). The 6th-degree Hermite interpolation polynomial.
+ *
+ * @param t - Progress value (0 to 1)
+ */
+export declare function smootherstep(t: number): number;

package/dist/_members/animate/index.d.ts

@@ -0,0 +1,25 @@
+export { smooth } from './easing/smooth.js';
+export { smootherstep } from './easing/smootherstep.js';
+export { rushInto, rushFrom } from './easing/rush.js';
+export { Create } from './animations/Create.js';
+export { GrowFromCenter } from './animations/GrowFromCenter.js';
+export { FadeIn } from './animations/FadeIn.js';
+export { Write } from './animations/Write.js';
+export { Indicate } from './animations/Indicate.js';
+export { Wiggle } from './animations/Wiggle.js';
+export { LaggedStart } from './composition/LaggedStart.js';
+export { AnimationGroup } from './composition/AnimationGroup.js';
+export { Succession } from './composition/Succession.js';
+export { Transform } from './animations/Transform.js';
+export { MoveAlongPath } from './animations/MoveAlongPath.js';
+export { GrowArrow } from './animations/GrowArrow.js';
+export { Arrow, makeArrowPath } from './mobjects/Arrow.js';
+export { BrandBox } from './mobjects/BrandBox.js';
+export { Graph } from './mobjects/Graph.js';
+export { DiGraph } from './mobjects/DiGraph.js';
+export { ThreeCanvas } from './three/ThreeCanvas.js';
+export { Box, Sphere, Cylinder, Cone, Torus, TorusKnot, Plane, Circle, Ring, Dodecahedron, Icosahedron, Octahedron, Tetrahedron, Capsule, Extrude, Lathe, Tube, Text, Text3D, Center, Float, Environment, ContactShadows, AccumulativeShadows, RandomizedLight, Lightformer, Stage, Sky, Stars, Sparkles, Cloud, Line, QuadraticBezierLine, CubicBezierLine, CatmullRomLine, MeshDistortMaterial, MeshWobbleMaterial, MeshReflectorMaterial, MeshTransmissionMaterial, Edges, Outlines, GradientTexture, RoundedBox, Billboard, Html, PivotControls, Grid, Backdrop, } from './three/drei.js';
+/** All animate endowments for sandbox injection. */
+export declare const sandboxScope: Record<string, unknown>;
+/** Animate scope names for validation and error messages. */
+export declare const sandboxScopeNames: string[];

package/dist/_members/animate/mobjects/Arrow.d.ts

@@ -0,0 +1,41 @@
+import React from 'react';
+interface ArrowProps {
+    /** Start point [x, y] */
+    from: [number, number];
+    /** End point [x, y] */
+    to: [number, number];
+    /** Stroke color */
+    color?: string;
+    /** Stroke width (default: 2) */
+    strokeWidth?: number;
+    /** Arrowhead size in pixels (default: 12) */
+    tipSize?: number;
+    /** SVG width */
+    width?: number | string;
+    /** SVG height */
+    height?: number | string;
+    /** SVG viewBox */
+    viewBox?: string;
+    /** Draw arrowhead at start too (default: false) */
+    doubleEnded?: boolean;
+    /** Additional SVG style */
+    style?: React.CSSProperties;
+}
+/**
+ * Static SVG arrow between two points with triangular arrowhead.
+ * A "mobject" — wrap in <Create>, <GrowFromCenter>, or <FadeIn> to animate.
+ *
+ * Usage:
+ *   <Arrow from={[100, 300]} to={[500, 300]} color="#fff" />
+ *
+ *   <FadeIn durationInFrames={20}>
+ *     <Arrow from={[100, 200]} to={[400, 200]} color={params.accentColor} />
+ *   </FadeIn>
+ */
+export declare const Arrow: React.FC<ArrowProps>;
+/**
+ * Generate an SVG path string for an arrow line (without arrowhead).
+ * Useful for animating with <Create> or <Transform>.
+ */
+export declare function makeArrowPath(from: [number, number], to: [number, number]): string;
+export {};

package/dist/_members/animate/mobjects/BrandBox.d.ts

@@ -0,0 +1,43 @@
+import React from 'react';
+interface BrandBoxProps {
+    /** Label text displayed inside the box */
+    label?: string;
+    /** Box background color */
+    color?: string;
+    /** Box width in pixels (default: 160) */
+    width?: number;
+    /** Box height in pixels (default: 80) */
+    height?: number;
+    /** Border radius in pixels (default: 12) */
+    borderRadius?: number;
+    /** Label font family */
+    fontFamily?: string;
+    /** Label font size (default: 18) */
+    fontSize?: number | string;
+    /** Label font weight (default: 600) */
+    fontWeight?: number;
+    /** Label text color (default: '#fff') */
+    textColor?: string;
+    /** Border style (default: none) */
+    border?: string;
+    /** Box shadow */
+    shadow?: string;
+    /** Children rendered inside the box (alternative to label) */
+    children?: React.ReactNode;
+    /** Additional wrapper style */
+    style?: React.CSSProperties;
+}
+/**
+ * Rounded rectangle with centered label — a reusable "mobject" for diagrams.
+ * Designed to be wrapped in animation components for entrance effects.
+ *
+ * Usage:
+ *   <BrandBox label="API" color={params.accentColor} />
+ *
+ *   <GrowFromCenter>
+ *     <BrandBox label="Server" color="#1a1a2e" border="2px solid #e94560"
+ *       fontFamily={FONTS.bebasNeue} fontSize={24} />
+ *   </GrowFromCenter>
+ */
+export declare const BrandBox: React.FC<BrandBoxProps>;
+export {};

package/dist/_members/animate/mobjects/DiGraph.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { Graph } from './Graph.js';
+/**
+ * Directed graph — alias for <Graph directed />.
+ * Renders edges with arrowheads to show direction.
+ *
+ * Usage:
+ *   <DiGraph
+ *     nodes={[
+ *       { id: 'client', label: 'Client' },
+ *       { id: 'api', label: 'API' },
+ *       { id: 'db', label: 'DB' },
+ *     ]}
+ *     edges={[
+ *       { source: 'client', target: 'api', label: 'REST' },
+ *       { source: 'api', target: 'db', label: 'SQL' },
+ *     ]}
+ *     nodeColor={params.accentColor}
+ *   />
+ */
+export declare const DiGraph: React.FC<Omit<React.ComponentProps<typeof Graph>, 'directed'>>;

package/dist/_members/animate/mobjects/Graph.d.ts

@@ -0,0 +1,72 @@
+import React from 'react';
+interface GraphNode {
+    id: string;
+    label?: string;
+    color?: string;
+    /** Fixed position override [x, y] — skips force layout for this node */
+    position?: [number, number];
+}
+interface GraphEdge {
+    source: string;
+    target: string;
+    label?: string;
+    color?: string;
+}
+interface GraphProps {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+    /** Whether edges are directed (arrows) or undirected (lines). Default: false */
+    directed?: boolean;
+    /** SVG width */
+    width?: number;
+    /** SVG height */
+    height?: number;
+    /** Node circle radius (default: 24) */
+    nodeRadius?: number;
+    /** Node default color */
+    nodeColor?: string;
+    /** Edge default color */
+    edgeColor?: string;
+    /** Edge stroke width (default: 2) */
+    edgeWidth?: number;
+    /** Label font family */
+    fontFamily?: string;
+    /** Label font size (default: 14) */
+    fontSize?: number;
+    /** Label text color (default: '#fff') */
+    textColor?: string;
+    /** D3 force strength — repulsion between nodes (default: -300) */
+    chargeStrength?: number;
+    /** Staggered entrance animation duration in frames (default: 60) */
+    durationInFrames?: number;
+    /** Delay before animation starts (in frames) */
+    delay?: number;
+    /** Easing function (default: smooth) */
+    easing?: (t: number) => number;
+    /** Additional SVG style */
+    style?: React.CSSProperties;
+}
+/**
+ * Force-directed graph visualization with animated entrance.
+ *
+ * Nodes appear with staggered scale-in, edges draw themselves.
+ * Uses D3-force for layout, SVG for rendering.
+ *
+ * Usage:
+ *   <Graph
+ *     nodes={[
+ *       { id: 'a', label: 'API' },
+ *       { id: 'b', label: 'Gateway' },
+ *       { id: 'c', label: 'DB' },
+ *     ]}
+ *     edges={[
+ *       { source: 'a', target: 'b' },
+ *       { source: 'b', target: 'c' },
+ *     ]}
+ *     directed
+ *     nodeColor={params.accentColor}
+ *     durationInFrames={60}
+ *   />
+ */
+export declare const Graph: React.FC<GraphProps>;
+export {};

package/dist/_members/animate/mobjects/index.d.ts

@@ -0,0 +1,4 @@
+export { Arrow, makeArrowPath } from './Arrow.js';
+export { BrandBox } from './BrandBox.js';
+export { Graph } from './Graph.js';
+export { DiGraph } from './DiGraph.js';

package/dist/_members/animate/three/ThreeCanvas.d.ts

@@ -0,0 +1,36 @@
+import React from 'react';
+interface ThreeCanvasProps {
+    children: React.ReactNode;
+    /** Canvas width in pixels (default: 1920) */
+    width?: number;
+    /** Canvas height in pixels (default: 1080) */
+    height?: number;
+    /** Camera field of view (default: 75) */
+    fov?: number;
+    /** Camera near clipping plane */
+    near?: number;
+    /** Camera far clipping plane */
+    far?: number;
+    /** Camera position [x, y, z] (default: [0, 0, 5]) */
+    cameraPosition?: [number, number, number];
+    /** Additional style for the canvas wrapper */
+    style?: React.CSSProperties;
+}
+/**
+ * Remotion-compatible Three.js canvas — handles frame-perfect 3D rendering.
+ *
+ * Wraps @remotion/three's ThreeCanvas with sensible defaults for
+ * video production (1920x1080, perspective camera).
+ *
+ * Usage:
+ *   <ThreeCanvas>
+ *     <mesh rotation={[0, rotation, 0]}>
+ *       <boxGeometry />
+ *       <meshStandardMaterial color={params.accentColor} />
+ *     </mesh>
+ *     <ambientLight intensity={0.5} />
+ *     <pointLight position={[10, 10, 10]} />
+ *   </ThreeCanvas>
+ */
+export declare const ThreeCanvas: React.FC<ThreeCanvasProps>;
+export {};

package/dist/_members/animate/three/drei.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Whitelisted @react-three/drei components for the AI sandbox.
+ *
+ * Only safe, commonly-needed helpers are exposed.
+ * No controls (OrbitControls etc) — video is non-interactive.
+ * No loaders that access filesystem (useGLTF, useFBX etc).
+ */
+export { Box, Sphere, Cylinder, Cone, Torus, TorusKnot, Plane, Circle, Ring, Dodecahedron, Icosahedron, Octahedron, Tetrahedron, Capsule, Extrude, Lathe, Tube, } from '@react-three/drei';
+export { Text, Text3D } from '@react-three/drei';
+export { Center, Float, Environment, ContactShadows, AccumulativeShadows, RandomizedLight, Lightformer, Stage, Sky, Stars, Sparkles, Cloud, } from '@react-three/drei';
+export { Line, QuadraticBezierLine, CubicBezierLine, CatmullRomLine, } from '@react-three/drei';
+export { MeshDistortMaterial, MeshWobbleMaterial, MeshReflectorMaterial, MeshTransmissionMaterial, Edges, Outlines, GradientTexture, RoundedBox, } from '@react-three/drei';
+export { Billboard, Html, PivotControls, Grid, Backdrop, } from '@react-three/drei';

package/dist/_members/animate/three/index.d.ts

@@ -0,0 +1,2 @@
+export { ThreeCanvas } from './ThreeCanvas.js';
+export { Box, Sphere, Cylinder, Cone, Torus, TorusKnot, Plane, Circle, Ring, Dodecahedron, Icosahedron, Octahedron, Tetrahedron, Capsule, Extrude, Lathe, Tube, Text, Text3D, Center, Float, Environment, ContactShadows, AccumulativeShadows, RandomizedLight, Lightformer, Stage, Sky, Stars, Sparkles, Cloud, Line, QuadraticBezierLine, CubicBezierLine, CatmullRomLine, MeshDistortMaterial, MeshWobbleMaterial, MeshReflectorMaterial, MeshTransmissionMaterial, Edges, Outlines, GradientTexture, RoundedBox, Billboard, Html, PivotControls, Grid, Backdrop, } from './drei.js';

package/dist/_members/authoring/agent/buildTools.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Build an AI SDK ToolSet for the IN-PROCESS compose roles.
+ *
+ * This used to iterate `TOOL_SCHEMAS` — 81 hand-written tools that were the
+ * desktop's private vocabulary. That registry is deleted; the source here is
+ * `COMPOSE_ROLE_TOOLS` (tools/composeRoleTools.ts), the ten verbs the compose
+ * PLANNER and MOTION roles need and which have no `/v1` equivalent. Every other
+ * agent surface builds from the curated manifest via `buildCuratedToolSet`.
+ *
+ * Handles: scope filtering, dedup detection, progress events, approval
+ * callbacks, and image content formatting.
+ */
+import { type ToolSet } from 'ai';
+import type { OnProgressCallback, DirectorContext } from '../types.js';
+import type { AgentCapabilities } from '../capabilities.js';
+export interface BuildToolsParams {
+    /** Agent capabilities — handlers receive this directly. */
+    capabilities: AgentCapabilities;
+    /** Additional tool handler options. */
+    toolOptions?: Record<string, unknown>;
+    /** Pre-built context for get_context tool. */
+    cachedContext?: DirectorContext;
+    /** Progress callback for tool-call / tool-result events. */
+    onProgress: OnProgressCallback;
+    /** Tool names to include. If omitted, every in-process role tool is built. */
+    allowedTools?: string[];
+    /** Tool names requiring user approval before execution. */
+    approvalRequired?: Set<string>;
+    /** Callback to request user approval. */
+    requestApproval?: (toolCallId: string, toolName: string, args?: Record<string, unknown>) => Promise<boolean>;
+}
+/**
+ * Build an AI SDK ToolSet from `COMPOSE_ROLE_TOOLS`.
+ * Each tool wraps `dispatchComposeRoleTool` with dedup, progress, approval, and
+ * image formatting.
+ *
+ * This is the shared generic loop-body every role-scoped factory funnels through
+ * (`buildDirectorTools`, `buildPlannerTools`); logic lives here ONCE.
+ */
+export declare function buildToolsFromSchemas(params: BuildToolsParams): ToolSet;
+/**
+ * The generic full-set factory. The in-process roles (and the Agent swap-seam
+ * fallback) build the whole in-process tool set through this.
+ */
+export declare const buildDirectorTools: typeof buildToolsFromSchemas;
+/**
+ * The compose PLANNER's minimal in-process factory: the SAME shared core, scoped
+ * to `COMPOSE_PLANNER_TOOLS` (get_context, get_word_timings, search_library,
+ * capture_frames, submit_compose_plan). The role owns the tool SCOPE; zero logic
+ * is duplicated. `allowedTools` is fixed here, so callers pass everything else.
+ */
+export declare const buildPlannerTools: (p: Omit<BuildToolsParams, "allowedTools"> & {
+    toolNames?: readonly string[];
+}) => ToolSet;

package/dist/_members/authoring/agent/contextManagement.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Context-management for the tool loop — the seam that keeps a long, tool-heavy
+ * agent run under the model's context window.
+ *
+ * The ONLY ai@6 hook that can rewrite the messages sent to the model between
+ * steps is `prepareStep` (a ToolLoopAgent constructor option). `onStepFinish`
+ * is observe-only; per-tool wrappers can't see cross-step history. So eviction
+ * lives here, as a `prepareStep` built from a per-scope policy.
+ *
+ * The growth this caps (measured on the live compose author): ~197k of
+ * accumulating tool-result content — get_context / search_library /
+ * get_word_timings results, and (once the craftsman captures) base64 image
+ * blocks — none of which ever leave the conversation across the up-to-20 steps
+ * of one generate() call. `pruneMessages` is the SDK's pairing-safe primitive:
+ * `before-last-N-messages` strips OLD tool-call/result content while keeping
+ * tool_use/tool_result pairing intact and the recent N messages whole. It only
+ * rewrites the OLD tail, so the stable system/instruction prefix (where the
+ * Anthropic ephemeral cache breakpoint lives) is untouched and keeps hitting.
+ */
+import { type PrepareStepFunction, type ToolSet } from 'ai';
+export interface ContextManagementPolicy {
+    /**
+     * Keep this many trailing messages' tool content intact; strip tool
+     * calls/results (incl. base64 image blocks) older than that. Clamped to >= 1
+     * (keepRecentToolMessages=0 maps to 'all', which can strip a still-pending
+     * tool call). Default 2 — one beat of lookback for the craftsman's
+     * capture→refine→re-capture loop.
+     */
+    keepRecentToolMessages?: number;
+    /**
+     * RETIRED — reasoning pruning is FORCED ON (before-last-message) whenever
+     * this prepareStep runs; the field is kept only so existing policy literals
+     * typecheck. Why not optional: adaptive-thinking models (claude-sonnet-5+)
+     * attach SIGNED thinking blocks to tool-use turns, and Anthropic rejects a
+     * request whose history keeps a thinking block on an assistant message whose
+     * tool_use we pruned ("`thinking` blocks ... cannot be modified",
+     * invalid_request_error). That half-prune killed every claude-sonnet-5
+     * planner run at step 3 — the loop's first eviction with keep=2 (2026-07-12).
+     * Dropping the WHOLE thinking block from an older turn is allowed; the
+     * latest assistant message's thinking is never touched (before-last-message).
+     */
+    pruneReasoning?: boolean;
+    /**
+     * Evict only IMAGE payloads from old tool results; keep compact TEXT results
+     * (get_context / word timings / apply receipts) for the whole run.
+     *
+     * Why: positional whole-result eviction gave the agent AMNESIA — the planner
+     * re-issued near-identical get_context/capture_frames recon up to 20 steps
+     * and never planned (staging compose v17555bj…, 2026-07-14: both "stalled"
+     * tries were this loop; the designer's ghost clip.remove thrash was the same
+     * disease). The context cost worth capping is the base64 stills (~10k+ tok
+     * each); the text results the model needs to REMEMBER are a few hundred
+     * tokens. So: image parts older than the keep window are replaced with a
+     * one-line stub; text results survive; tool_use/tool_result pairing is
+     * untouched (no thinking-block 400s — nothing structural is removed).
+     */
+    evictImagesOnly?: boolean;
+    /**
+     * Tool names whose results are NEVER evicted — not even image payloads (K3,
+     * e2e 2026-07-17): the designer's style reference (view_style_reference) was
+     * evicted like any working capture, so the agent re-viewed it 3× in a row.
+     * The reference is the GROUND TRUTH being reproduced, not a disposable
+     * capture. Pinning trades bounded context growth (a few exemplar images) for
+     * zero re-view turns; capture_frames / render_frame stills still evict.
+     */
+    pinnedTools?: string[];
+}
+/**
+ * Build the `prepareStep` that evicts stale tool content each step. Pure
+ * function of the messages it is handed (the override is per-step and not
+ * persisted into SDK history), so it is safe to recompute every step.
+ */
+export declare function buildPrepareStep(policy: ContextManagementPolicy): PrepareStepFunction<ToolSet>;

package/dist/_members/authoring/agent/errors.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Error extraction and usage utilities for the agent loop.
+ * Extracted from agentLoop.ts — pure helpers, no loop logic.
+ */
+import { type LanguageModelUsage } from 'ai';
+/**
+ * Extract a clean error message from AI SDK / gateway errors.
+ * Uses typed error classes from the AI SDK instead of regex matching.
+ */
+export declare function extractProviderError(err: unknown): string;
+/** Empty usage for error/abort paths where the SDK doesn't return totalUsage. */
+export declare const ZERO_USAGE: LanguageModelUsage;

package/dist/_members/authoring/agent/index.d.ts

@@ -0,0 +1,2 @@
+export { buildDirectorTools, buildPlannerTools, buildToolsFromSchemas, type BuildToolsParams } from './buildTools.js';
+export { extractProviderError, ZERO_USAGE } from './errors.js';

package/dist/_members/authoring/agent/memoryTool.d.ts

@@ -0,0 +1,8 @@
+import type { ToolSet } from 'ai';
+export interface AgentMemory {
+    /** The memory tool entry to merge into the agent's ToolSet (key `memory`). */
+    tools: ToolSet;
+    /** The store after the run — thread this into the next run's seed. */
+    snapshot(): Record<string, string>;
+}
+export declare function createAgentMemory(seed?: Record<string, string>): AgentMemory;

package/dist/_members/authoring/agent/promptCache.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Moving prompt-cache breakpoint for the tool loop — the AI SDK "dynamic
+ * prompt caching" recipe (ai-sdk.dev/cookbook/node/dynamic-prompt-caching),
+ * applied per step via `prepareStep`.
+ *
+ * Why: the static breakpoint on the system message only caches tools+system.
+ * Anthropic writes cache entries ONLY at explicit breakpoints, and the
+ * server-side continuation caching that happens to cover text tool-results
+ * does NOT cover image blocks — measured on a capture_frames-shaped loop
+ * (scripts/audit-cache-breakpoints.ts), every step re-paid full vision-token
+ * price for ALL accumulated images (~1.2k tokens/image/step, growing
+ * quadratically with step count). Stamping cacheControl on the LAST message
+ * of each step's request makes the whole tail (incl. images) a cached prefix
+ * the next step reads at 0.1x instead of re-paying at 1x.
+ *
+ * The stamp is a per-step request override: `prepareStep` results are not
+ * persisted into SDK history, so markers don't accumulate across steps — each
+ * request carries exactly two breakpoints (system + moving tail), well inside
+ * Anthropic's 4-breakpoint limit.
+ *
+ * Two known limits:
+ * - Do NOT compose with contextManagement eviction: the sliding prune window
+ *   rewrites messages before the prior step's breakpoint, so tail entries are
+ *   written (1.25x) but never read. Agent.executeWithTools gates on this.
+ * - Anthropic's cache-hit lookback is 20 content blocks. Typical steps add
+ *   2-4 blocks, but a burst step (e.g. parallel capture_frames calls, up to
+ *   4 frames each) can exceed 20 — that one step's successor misses the tail
+ *   entry and re-bills the accumulated history once before re-establishing.
+ */
+import type { ModelMessage, PrepareStepFunction, ToolSet } from 'ai';
+/** Stamp cacheControl on the last message (the moving breakpoint). */
+export declare function addCacheControlToLastMessage(messages: ModelMessage[]): ModelMessage[];
+/** `prepareStep` that applies the moving breakpoint (Anthropic models only). */
+export declare const cachePrepareStep: PrepareStepFunction<ToolSet>;