@cueframe/kernel 0.1.0 → 0.1.2

package/dist/_members/authoring/capabilities.d.ts

@@ -1,29 +1,11 @@
-/**
- * Capability interfaces — what consumers inject into the Director.
- * Required capabilities must always be provided.
- * Optional capabilities determine which tools are available.
- */
 import type { TimelineWord } from '../composition/index.js';
 import type { BrandKit } from '../composition/brand-kit.js';
 import type { CompositionOps, CompositionOpsState } from '../composition/ops/index.js';
-/**
- * The agent operates on the v2 wire-shape composition. `CompositionOps` is
- * the v2 op surface (addClip, addOverlay, addAudioClip, addMarker,
- * cutAndRipple, ripple, etc.) and `CompositionOpsState` carries
- * `composition: Composition` plus selection state.
- */
 import type { PoolItemData, PlayerStateData, FontResult, LottieResult, SubjectFaceInfo } from './types.js';
-/** Read/write composition state. Both zustand and headless stores implement this. */
 export interface CompositionStore extends CompositionOps {
     getState(): CompositionOpsState;
-    /**
-     * Gesture/agent transaction: every mutation inside `fn` commits as ONE
-     * history entry and one store flush (the desktop store's semantics). A
-     * store with no history (headless/bench) implements it as `fn()`.
-     */
     batch(fn: () => void): void;
 }
-/** Access to transcript word timings. */
 export interface TranscriptProvider {
     getTimelineWords(): TimelineWord[];
     getWordTimings(startTime: number, endTime: number): string;
@@ -35,70 +17,21 @@ export interface PlayerControls {
     getPlayerState(): PlayerStateData;
     setPlaybackRate(rate: number): void;
 }
-/**
- * An error the AGENT can fix, in this turn, from the message alone — an invalid composition,
- * an exhausted capture budget. It is NOT an infrastructure failure.
- *
- * The distinction is load-bearing, and conflating the two cost a real compose:
- *  - retrying it is pointless (it will fail identically three times), and
- *  - it must NOT blind the run — the agent is supposed to read it and fix the composition.
- *
- * Everything that is NOT this is infrastructure (render backend down, R2 unreachable, timeout):
- * retry it, and if it stays broken the author has LOST ITS EYES — see `FrameCapture.isBlind`.
- */
 export declare class AgentFixableCaptureError extends Error {
     readonly agentFixable = true;
     constructor(message: string);
 }
 export interface FrameCapture {
-    /**
-     * Capture stills at the given frames.
-     *
-     * `size` is the pixel box to render into. Absent means the implementation's
-     * default — on the desktop a 480x270 thumbnail, chosen so a routine look costs
-     * ~170 vision tokens rather than ~1840. Pass one only when the question needs
-     * it (typography, legibility, whether a graphic is truncated): a caller that
-     * always asks for full size pays 11x on every look.
-     */
     captureFrames(frames: number[], size?: {
         width: number;
         height: number;
     }): Promise<string[]>;
-    /**
-     * True once an INFRASTRUCTURE capture failure has exhausted its retries — the author is
-     * BLIND and every subsequent edit is a guess.
-     *
-     * A blind run is a FAILED run, not a quiet degrade. On 2026-07-13 `capture_frames` died on
-     * every call of a live compose, nothing noticed, the author authored an entire composition
-     * without ever seeing a pixel of it, and the candidate still scored 6.14 and was reported as
-     * a normal below-threshold result. Capability loss must be DECLARED, never inferred.
-     *
-     * Optional so existing consumers (desktop) compile unchanged; absent ⇒ never blind.
-     */
     isBlind?(): boolean;
-    /**
-     * Compute COGS accrued by this capture set so far, in USD.
-     *
-     * In-loop captures are real Modal seconds that the compose run causes but
-     * nobody was counting: they execute under the PLATFORM identity, so
-     * `isBillableCaller` is false and they are neither billed to the customer nor
-     * added to the run's cost. That made the measured base LLM-only and pushed
-     * the gap into the markup, where it could not be audited.
-     *
-     * Optional so existing consumers compile unchanged; absent ⇒ contributes 0.
-     */
     computeCostUsd?(): number;
 }
-/** Score the CURRENT working composition against the CueFrame rubric. Renders the
- *  meaningful beats, runs the vision judge, returns a compact per-criterion verdict
- *  string (composite + per-criterion score/critique, weakest criterion first). The
- *  author's objective check — distinct from `capture_frames`, which only returns pixels. */
 export interface CompositionVerifier {
     verify(): Promise<string>;
 }
-/** apply_motion_preset args — the P2 motion pass's structural lane for static
- *  cards: the agent picks the preset + timing; the shell generation, component
- *  mint, and clip-source swap are code (the consumer's capability). */
 export interface MotionPresetArgs {
     clipId: string;
     preset: string;
@@ -106,10 +39,6 @@ export interface MotionPresetArgs {
     exitMs?: number;
     staggerMs?: number;
 }
-/** Apply a vetted motion preset to a STATIC card clip: wrap the approved markup
- *  in a frame-driven shell, mint it as a component, swap the clip source in
- *  place. Returns a one-line summary the agent reads. Throws on an unknown
- *  clip/preset or a non-card clip (the tool framework surfaces it). */
 export interface MotionPresetApplier {
     apply(args: MotionPresetArgs): Promise<string>;
 }
@@ -160,7 +89,6 @@ export interface Transpiler {
         code?: string;
         error?: string;
     }>;
-    /** Allowed global names in the sandbox (e.g., 'Write', 'FadeIn', 'Graph'). Injected, not imported. */
     sandboxScopeNames: string[];
 }
 export interface ScreenshotProvider {
@@ -171,11 +99,9 @@ export interface ScreenshotProvider {
         maxTiles?: number;
     }): Promise<string[]>;
 }
-/** AI-powered design review (uses a separate LLM call with visual inspection). */
 export interface DesignReviewProvider {
     runDesignReview(contextJson: string, task: string, onProgress: (event: any) => void): Promise<string>;
 }
-/** Desktop-only: cross-scope navigation (delegate tool). */
 export interface NavigationProvider {
     navigate(scope: string, params?: Record<string, string>): void;
 }
@@ -185,58 +111,27 @@ export interface Logger {
     error(msg: string, data?: Record<string, unknown>): void;
     debug(msg: string, data?: Record<string, unknown>): void;
 }
-/** Pool items provider — for tools that need to list/query pool items. */
 export interface PoolProvider {
     getPoolItems(): PoolItemData[];
 }
-/**
- * Subject provider — surfaces the source clip's detected-face roster
- * (`face-0..N` + active-speaker share) into get_context, so the agent authors
- * `{ kind: "face", faceId }` crop intents against REAL faces rather than
- * guessing. Backed by the cached detect_subjects roster (source-level).
- */
 export interface SubjectProvider {
     getFaces(): SubjectFaceInfo[];
-    /**
-     * The detected face GEOMETRY over time + the output frame — everything needed
-     * to decide whether a `shotScale` punch-in is EARNED (is the face actually
-     * small? is there room around it? can the source afford the crop?). Null when
-     * detection did not run, in which case `set_crop_intents` cannot check a
-     * punch-in and says so rather than waving it through.
-     *
-     * The roster above answers "who is there"; this answers "how are they framed".
-     */
     getFraming?(): SubjectFramingInfo | null;
 }
-/** Per-second face geometry + the output frame, as the punch-in warrant needs it. */
 export interface SubjectFramingInfo {
     srcW: number;
     srcH: number;
     outW: number;
     outH: number;
-    /** One entry per source second: `{faceId → {heightFrac, cx, cy}}`, source-normalized. */
     perSecond: Array<Record<string, {
         heightFrac: number;
         cx: number;
         cy: number;
     }>>;
 }
-/**
- * Skill provider — loads on-demand craft skill bodies for the `load_skill` tool
- * (progressive disclosure). The LOADER is OSS; the CONTENT location is per
- * platform (cloud: bundled markdown in the worker image; desktop: plugin), so
- * the body is fetched through this capability rather than read here.
- */
 export interface SkillProvider {
-    /** Full markdown body for a skill name, or null if the name is unknown. */
     loadSkill(name: string): Promise<string | null>;
 }
-/**
- * Compose PLANNER output channel — `submit_compose_plan` delivers the raw plan
- * args here. Present only in planning-phase runs. The arg is `unknown` on
- * purpose: this package stays decoupled from the ComposePlan shape; the worker
- * re-validates with the canonical `@cueframe/composition` ComposePlan.
- */
 export interface PlanSink {
     submit(plan: unknown): void;
 }
@@ -246,7 +141,6 @@ export interface DirectorCapabilities {
     player?: PlayerControls;
     capture?: FrameCapture;
     verify?: CompositionVerifier;
-    /** P2 motion pass: preset motion shells for static card clips. */
     motionPreset?: MotionPresetApplier;
     media?: MediaProvider;
     templates?: TemplateProvider;
@@ -259,48 +153,9 @@ export interface DirectorCapabilities {
     pool?: PoolProvider;
     subjects?: SubjectProvider;
     skills?: SkillProvider;
-    /** Compose planning-phase only: receives the submit_compose_plan output. */
     planSink?: PlanSink;
     logger?: Logger;
 }
-/**
- * Alias for DirectorCapabilities — used by the new Agent class.
- * Same shape for now; Phase 3 may diverge as handlers migrate to typed capabilities.
- */
 export type AgentCapabilities = DirectorCapabilities;
-/**
- * The IN-PROCESS tools whose availability depends on an OPTIONAL capability,
- * mapped to the capability that backs them.
- *
- * This is a closed map over `COMPOSE_ROLE_TOOLS` (tools/composeRoleTools.ts) —
- * the ONLY in-process tool vocabulary left. Until 2026-08-08 the exclusion list
- * carried ~18 further names (`seek`, `search_lottie`, `search_stock_media`,
- * `undo`, `move_content`, `load_skill`, …) inherited from the deleted 81-verb
- * desktop registry. None of them had been buildable since that registry was
- * removed, so every one was a gate on a tool that could not exist: exclusion
- * logic that reads as policy and enforces nothing. That is the failure mode the
- * one-vocabulary merge exists to end, so the map is now DERIVED FROM and gated
- * against the in-process table (see tools/__tests__/composeRoleTools.test.ts).
- *
- * Not every optional capability belongs here. The two deliberate exclusions:
- *
- *  - `planSink` backs submit/amend_compose_plan, which stay ALWAYS-AVAILABLE on
- *    purpose: they are the planner's only output channel, and hiding them
- *    outside the planning phase would turn "you are not in the planning phase" —
- *    a message the model can act on — into a silently missing tool.
- *  - `transpile` is a CONDITIONAL dependency of `update_overlay`: needed only on
- *    the branch that passes new `sourceCode`/`jsxSource` (composeRoleTools.ts
- *    ~326), never for the timing/param tuning that is the motion pass's actual
- *    use. Gating the whole tool on it would delete the motion pass's only
- *    mutation from every consumer that cannot transpile. That branch refuses
- *    in-handler ('Transpiler not available') instead.
- *
- * The rule the gate enforces: a capability belongs here only when its ABSENCE
- * makes the tool useless for EVERY call, not for one argument shape.
- */
 export declare const CAPABILITY_GATED_TOOLS: Readonly<Record<string, keyof DirectorCapabilities>>;
-/**
- * Tool names to EXCLUDE based on missing capabilities.
- * The Agent filters these out of the LLM's tool set.
- */
 export declare function getExcludedTools(capabilities: DirectorCapabilities): Set<string>;

package/dist/_members/authoring/composer/scopes.d.ts

@@ -1,22 +1,3 @@
-/**
- * Composer-agent scopes.
- *
- * EDITOR_TOOLS is the editor agent's subset of the /v1 tool surface
- * (@cueframe/mcp curation — the SSOT for names/schemas/descriptions). The
- * agent gets these via `buildCuratedToolSet(executor, { allowedNames:
- * EDITOR_TOOLS })`, which builds from `[...INTERNAL_LOOP_TOOLS,
- * ...CURATED_TOOLS]` — so every entry here must be a curated OR internal-loop
- * tool name. There are NO hand-written tool implementations behind this list.
- * Adding a capability to the editor chat = adding that name here.
- *
- * An internal-loop name (get_context, search_library, analyze_transcript,
- * wait_job) is deliberately NOT on the public MCP server; being buildable here
- * is not publication there. See internalLoopTools.ts.
- *
- * Deliberately excluded in v1: `compose`/`create_brief`/`resume` (the chat
- * agent delegating to the cloud Director is a product decision to make
- * explicitly, not a default), and the destructive project/webhook ops.
- */
 export interface ComposerScope {
     name: string;
     tools: readonly string[];

package/dist/_members/authoring/context/brand.d.ts

@@ -1,8 +1,4 @@
 import type { BrandKit } from '../../composition/brand-kit.js';
-/**
- * Extract brand kit data into a context-friendly format.
- * Returns undefined if no brand kit is active.
- */
 export declare function buildBrandKitData(activeBrandKit: BrandKit | null | undefined): {
     customFonts?: string[] | undefined;
     bgMusic?: string | undefined;

package/dist/_members/authoring/context/brandTokens.d.ts

@@ -1,6 +1,2 @@
-/**
- * Re-export brand token resolver from tools.
- * The canonical implementation lives in tools/brandTokens.ts — no duplication.
- */
 export { resolveOverlayParams } from '../tools/brandTokens.js';
 export type { TemplateMeta, ResolveContext } from '../tools/brandTokens.js';

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

@@ -2,7 +2,6 @@ import type { DirectorCapabilities } from '../capabilities.js';
 import type { DirectorContext } from '../types.js';
 export type { DirectorContext };
 export interface BuildContextOptions {
-    /** Maximum total characters for the serialized context. */
     maxChars?: number;
 }
 export declare function buildDirectorContext(capabilities: DirectorCapabilities, opts?: BuildContextOptions): DirectorContext;

package/dist/_members/authoring/context/timeline.d.ts

@@ -1,15 +1,6 @@
 import type { TimelineClip } from '../../composition/validators/index.js';
 import type { ClipData, OverlayData } from '../types.js';
-/**
- * Project v2 wire-shape video-track clips into the legacy ClipData shape.
- * Skips non-media clips (the agent's ClipData has no representation for
- * component/effect sources).
- */
 export declare function buildClipData(clips: TimelineClip[]): ClipData[];
-/**
- * Project v2 overlay-track clips into the legacy context overlay shape.
- * Each overlay has a primitiveId + params bag on its source.
- */
 export declare function buildOverlayData(overlays: TimelineClip[]): {
     id: string;
     template: string;
@@ -23,11 +14,5 @@ export declare function buildOverlayData(overlays: TimelineClip[]): {
     transition: "fade" | "slide" | "wipe" | "none" | undefined;
     sequenceGroup: string | undefined;
 }[];
-/** Compute the timeline duration from clips and overlays (v2 wire-shape). */
 export declare function computeTimelineDuration(clips: TimelineClip[], overlays: TimelineClip[]): number;
-/**
- * Re-export for tests / sub-builders that previously imported `OverlayData`
- * from `@cueframe/core` — keep the type alias here so they don't have to
- * walk back to the core module.
- */
 export type { OverlayData };

package/dist/_members/authoring/context/transcript.d.ts

@@ -1,23 +1,12 @@
 import type { TimelineClip } from '../../composition/validators/index.js';
 import type { TimelineWord } from '../../composition/index.js';
 import type { PoolItemData } from '../types.js';
-/**
- * Sanitize user-provided strings before embedding in LLM context.
- */
 export declare function sanitize(s: string, maxLen?: number): string;
 export interface TranscriptResult {
     transcript: string | undefined;
     transcriptTruncated: boolean;
     transcriptHasTimings: boolean;
 }
-/**
- * Build the transcript section of the agent context.
- *
- * Note: in v2 there are no `deletedRanges` — cuts are baked into clip splits.
- * The `deletedRanges` parameter is kept for back-compat (always empty in v2)
- * but the strikethrough rendering it triggers is effectively dead code on the
- * v2 path.
- */
 export declare function buildTranscript(words: TimelineWord[], overlays: TimelineClip[], deletedRanges: Array<{
     start: number;
     end: number;

package/dist/_members/authoring/context/types.d.ts

@@ -1,5 +1 @@
-/**
- * Re-export types needed by the context sub-builders.
- * Avoids each sub-builder importing from scattered locations.
- */
 export type { TimelineClip } from '../../composition/validators/index.js';

package/dist/_members/authoring/decomposer.d.ts

@@ -1,17 +1,5 @@
-/**
- * Decomposer — breaks complex tasks into sequential phases.
- *
- * Deterministic pre-filter: simple tasks skip decomposition entirely.
- * Complex tasks get LLM decomposition into timeline_edit and artifact phases.
- */
 import type { LanguageModel } from 'ai';
 import type { Phase } from './types.js';
-/**
- * Deterministic pre-filter: trivial tasks get a single phase, no decomposition needed.
- * Returns true if the task is complex enough to warrant LLM decomposition.
- */
 export declare function shouldDecompose(task: string, hasTranscript: boolean): boolean;
-/** Create a single-phase plan for simple tasks. No evaluation, no decomposition. */
 export declare function singlePhase(task: string): Phase[];
-/** LLM decomposes a complex task into multiple phases. */
 export declare function decompose(model: LanguageModel, task: string, context: string): Promise<Phase[]>;

package/dist/_members/authoring/evaluate.d.ts

@@ -1,37 +1,11 @@
-/**
- * Criteria-based evaluator for the Agent quality loop.
- *
- * Unlike the rubric-based evaluator (evaluator.ts) which uses weighted numeric
- * scores, this evaluator works with plain-language criteria — each criterion
- * gets a pass/fail verdict with optional feedback.
- *
- * Three evaluation modes (auto-detected):
- * - Vision: frames provided → multimodal evaluation with image content
- * - State: compositionState provided → evaluate against composition JSON
- * - Text: artifact provided → evaluate the text directly
- */
 import type { LanguageModel } from 'ai';
 import type { CriteriaResult } from './types.js';
 export interface EvaluateOptions {
-    /** Language model for evaluation. */
     model: LanguageModel;
-    /** The original task / prompt that was being fulfilled. */
     task: string;
-    /** Plain-language criteria. Keys = names, values = descriptions. */
     criteria: Record<string, string>;
-    /** Composition state JSON (for state-based evaluation). */
     compositionState?: string;
-    /** Text artifact (for text-based evaluation). */
     artifact?: string;
-    /** Base64 frame captures (for vision-based evaluation). */
     frames?: string[];
 }
-/**
- * Evaluate work against plain-language criteria.
- *
- * Auto-detects evaluation mode:
- * - frames present → vision evaluation
- * - compositionState present (no frames) → state evaluation
- * - artifact present (no state, no frames) → text evaluation
- */
 export declare function evaluate(options: EvaluateOptions): Promise<CriteriaResult>;

package/dist/_members/authoring/evaluator.d.ts

@@ -1,22 +1,6 @@
-/**
- * Evaluator — skeptical QA reviewer for Director output.
- *
- * Two modes:
- * - evaluateArtifact: generateText for text artifacts (blog posts, show notes)
- * - evaluateTimeline: generateText with vision for timeline edits (composition state + frame captures)
- *
- * Anti-leniency: calibrated scoring rubrics prevent the model from being generous.
- */
 import type { LanguageModel } from 'ai';
 import type { EvaluatorRubric, EvaluationResult } from './types.js';
 export declare const TIMELINE_RUBRIC: EvaluatorRubric;
 export declare const ARTIFACT_RUBRIC: EvaluatorRubric;
-/**
- * Evaluate a text artifact (blog post, show notes, description).
- */
 export declare function evaluateArtifact(model: LanguageModel, artifact: string, task: string, rubric: EvaluatorRubric, verificationCriteria: string[]): Promise<EvaluationResult>;
-/**
- * Evaluate a timeline edit phase.
- * Uses vision (base64 frame captures) when available.
- */
 export declare function evaluateTimeline(model: LanguageModel, task: string, rubric: EvaluatorRubric, verificationCriteria: string[], compositionContext: string, capturedFrames?: string[]): Promise<EvaluationResult>;

package/dist/_members/authoring/models/modelFactory.d.ts

@@ -1,9 +1,3 @@
-/**
- * Shared model factory for the AI SDK.
- *
- * Single source of truth for building LanguageModel instances from settings.
- * Pure function — no store access, no platform imports. Caller passes settings.
- */
 import type { LanguageModel } from 'ai';
 export interface ModelConfig {
     model: LanguageModel;
@@ -14,94 +8,23 @@ export interface LlmSettings {
     provider: 'anthropic' | 'openai' | 'ollama' | 'gateway';
     apiKey?: string;
     modelId?: string;
-    /** Cheaper/faster model for decomposer, evaluator, and other non-creative LLM calls. */
     fastModelId?: string;
     baseUrl?: string;
     gatewayUrl?: string;
     gatewayKey?: string;
-    /**
-     * Per-HTTP-REQUEST timeout (ms). A hung gateway/model call otherwise dangles
-     * until the caller's outermost deadline — on the compose path that is the
-     * Temporal activity timeout (~12 min), which burned an entire plan try on
-     * one stuck request (staging compose v17555bj…, 2026-07-14: planner try 1
-     * hung at 43s in, killed only by the activity timeout). Applied at the fetch
-     * seam so it bounds EVERY request the model makes, whatever loop drives it.
-     */
     requestTimeoutMs?: number;
 }
-/** Compose a per-request timeout onto a fetch impl. Honors the caller's own
- *  abort signal; whichever fires first wins. The bound is enforced by a RACE,
- *  not just the signal — a transport wedged hard enough to ignore its abort
- *  signal still cannot dangle past the cap (the exact 2026-07-14 failure:
- *  one stuck request rode the ~12-min Temporal activity timeout). */
 export declare function withRequestTimeout(inner: typeof fetch, ms: number): typeof fetch;
-/**
- * Per-call metadata attached to every outgoing LLM request through the
- * `gateway` provider so Langfuse can group traces by user / session /
- * feature. Only the `gateway` case applies it; other providers ignore
- * it (Anthropic / OpenAI direct have no LiteLLM callback layer).
- */
 export interface LangfuseMetadata {
-    /** Trace name — e.g. "director_decompose", "clips_chat_respond". */
     traceName: string;
-    /** Observation (child span) name — defaults to "llm_call". */
     generationName?: string;
-    /** Session anchor — workflowId / threadId / mediaItemId etc. */
     sessionId?: string;
-    /** End-user — auth subject. Sent as both `user` and `trace_user_id`. */
     userId?: string;
-    /** Feature / sub-component tags — e.g. ["director", "decomposer"]. */
     tags?: string[];
-    /** Prompt version for eval work — reserved; unused in v1. */
     version?: string;
-    /**
-     * Stable Langfuse trace id for this run. Defaults to a fresh UUID per
-     * model build, so each operation is its own trace. Pass an explicit id
-     * to group several model builds (e.g. a generator + its evaluator) under
-     * one trace. Without it, LiteLLM groups every request sharing `sessionId`
-     * (often the orgId) into one trace — collapsing unrelated calls and making
-     * per-feature cost attribution impossible.
-     */
     traceId?: string;
-    /**
-     * Ask LiteLLM not to retain the request/response CONTENT for this call
-     * (`turn_off_message_logging`): the trace still exists with its name, model,
-     * tokens and cost — so spend attribution keeps working — but prompts and
-     * completions are not stored. The desktop stamps this whenever the user has
-     * NOT opted into attributed tracing (consent governs content, not just
-     * identity — spec 2026-08-24-desktop-director-tracing §6.1).
-     */
     redactContent?: boolean;
 }
-/**
- * Build a fetch that splices Langfuse metadata into every outgoing
- * Anthropic request body. LiteLLM's `/anthropic/v1/messages` pass-through
- * route reads top-level `metadata.{trace_name,session_id,trace_user_id,tags}`
- * (Anthropic-native shape, LiteLLM extends it) and forwards the unknown
- * keys to the Langfuse success_callback before stripping them on the
- * outbound request to Anthropic.
- *
- * 2026-04-25: a LiteLLM rolling release on `main-stable` started
- * ignoring our prior wrapper (`litellm_metadata.trace_name`), dropping
- * every trace under the default name `litellm-pass_through_endpoint`
- * with empty session/user/tags. Per LiteLLM Langfuse-integration
- * discussion, the working form is the top-level `metadata` field. We
- * write both shapes belt-and-suspenders so older versions that read
- * `litellm_metadata` still work too.
- */
 export declare function makeLangfuseFetch(meta: LangfuseMetadata): typeof fetch;
-/**
- * Build a LanguageModel from explicit settings.
- * Throws if required credentials are missing.
- *
- * Optional `langfuse` parameter: when set on the `gateway` provider,
- * the returned model injects LiteLLM trace metadata into every
- * outgoing request via a fetch override. Ignored for non-gateway
- * providers.
- */
 export declare function buildModel(settings: LlmSettings, langfuse?: LangfuseMetadata): ModelConfig;
-/**
- * Build a cheaper/faster model for non-creative LLM calls (decomposer, evaluator).
- * Falls back to Haiku if no fastModelId is specified.
- */
 export declare function buildFastModel(settings: LlmSettings, langfuse?: LangfuseMetadata): ModelConfig;

package/dist/_members/authoring/motion/applyMotionPreset.d.ts

@@ -1,26 +1,14 @@
-/** The two author-fixable failure classes, matching the error registry codes. */
 export type MotionPresetErrorCode = "motion_preset_unknown" | "motion_preset_target_invalid";
-/** Fail-loud carrier for the applyMotionPreset guards. `code` is a registered
- *  ErrorCode the op route re-throws as an `ApiError` (422) or folds into a
- *  `dry_run` verdict. `opIndex` is stamped by the route (it knows the batch
- *  position); the pure guard leaves it undefined. */
 export declare class MotionPresetError extends Error {
     readonly code: MotionPresetErrorCode;
     opIndex?: number | undefined;
     constructor(code: MotionPresetErrorCode, message: string, opIndex?: number | undefined);
 }
-/** The minimal wire-composition shape the guard reads (tracks → clip contents). */
 export interface MotionPresetComposition {
     tracks?: Array<{
         contents?: unknown[];
     } | null | undefined>;
 }
-/**
- * Validate an `applyMotionPreset` op against the current composition and return
- * the target card's markup (the input to `generateMotionShell`). Throws
- * `MotionPresetError` on an unknown preset, a missing clip, or a non-card clip.
- * Pure — no state, no side effects.
- */
 export declare function resolveMotionPresetCard(composition: MotionPresetComposition, input: {
     clipId: string;
     preset: string;

package/dist/_members/authoring/motion/materializeMotionPresetOps.d.ts

@@ -13,24 +13,17 @@ export type ApplyMotionPresetOp = {
 export declare const isMotionPresetOp: (op: unknown) => op is ApplyMotionPresetOp;
 export declare const hasMotionPresetOp: (ops: readonly unknown[]) => boolean;
 export interface MaterializedMotionShell {
-    /** Deterministic id (`motion-shell-<clipId>`) — idempotent re-apply target. */
     componentId: string;
     clipId: string;
     preset: MotionPresetName;
     tsxSource: string;
     jsSource: string;
-    /** The source card's depth — the sink MUST carry it onto the replacement
-     *  source (whole-source replace drops it otherwise). */
     zPlane?: string;
 }
 export interface MaterializeMotionPresetDeps {
-    /** Per-lane transpile. Throws on a non-compiling shell; the caller maps the
-     *  failure to its lane's `component_does_not_compile` surface. */
     transpile: (componentId: string, tsxSource: string) => Promise<{
         jsSource: string;
     }>;
-    /** Per-lane materialization target; returns the op that replaces the
-     *  motion-preset op in the batch (same index). */
     sink: (shell: MaterializedMotionShell) => Promise<unknown> | unknown;
 }
 export declare function materializeMotionPresetOpsCore(composition: MotionPresetComposition, ops: readonly unknown[], opts: {

package/dist/_members/authoring/motion/shell.d.ts

@@ -2,29 +2,9 @@ export declare const MOTION_PRESETS: readonly ["fade-up", "slide-in-left", "slid
 export type MotionPresetName = (typeof MOTION_PRESETS)[number];
 export interface MotionShellOptions {
     preset: MotionPresetName;
-    /** Entrance duration; motion-flow's confident-move band. Default 300. */
     enterMs?: number;
-    /** Exit duration; the exit COMPLETES at the clip's end. Default 300. */
     exitMs?: number;
-    /** stagger-reveal only: per-child reveal offset. Default 120. */
     staggerMs?: number;
-    /**
-     * The card's token layer, baked onto the shell root as `--cf-<k>` CSS vars —
-     * the CardOverlay `cssLayoutVars` semantics the markup was authored against.
-     * Without this the swap card→component silently unpaints every `var(--cf-*)`
-     * the card uses (the render's custom lane applies no token vars). `$brand:`
-     * refs are DROPPED (same miss policy as `cssLayoutVars` with no kit): the
-     * sandbox has no brand kit to resolve against, and the card html's own
-     * `var(--cf-x, fallback)` fallback applies.
-     */
     tokens?: Record<string, string>;
 }
-/**
- * The wrapper FILLS its container (`inset: 0`) and never reads the injected
- * `params.region`: the render floor stamps an element-band region into EVERY
- * custom overlay's params (OverlayContent → resolveOverlayRegion), and a shell
- * that honored it collapsed full-frame interlude cards into the top ~80%x35%
- * caption-clear band. Placement stays on the CLIP's own channels (region →
- * RegionBox, position → PositionedWrapper) — exactly like the unshelled card.
- */
 export declare function generateMotionShell(cardHtml: string, opts: MotionShellOptions): string;

package/dist/_members/authoring/pipelineTrace.d.ts

@@ -1,19 +1,4 @@
-/**
- * Lightweight pipeline tracing for director requests.
- *
- * Records named spans with start/end times. At the end of a request,
- * logs a summary table showing where wall-clock time was spent.
- *
- * Usage:
- *   const trace = new PipelineTrace();
- *   trace.start('warmup');
- *   await warmUp();
- *   trace.end('warmup');
- *   ...
- *   trace.summary(); // logs the table
- */
 import type { Logger } from './capabilities.js';
-/** Lightweight pipeline trace contract for consumers. */
 export interface PipelineTraceInterface {
     start(name: string): void;
     end(name: string): void;
@@ -27,12 +12,8 @@ export declare class PipelineTrace {
     private toolCallCount;
     private readonly log;
     constructor(logger?: Logger);
-    /** Begin a named span. */
     start(name: string): void;
-    /** End a named span. No-op if the span was never started. */
     end(name: string): void;
-    /** Record a tool call (increments the counter for the summary). */
     recordToolCall(): void;
-    /** Log a summary table of all recorded spans. */
     summary(): void;
 }