@cueframe/kernel 0.1.1 → 0.1.2

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

@@ -1,17 +1,3 @@
-/**
- * Shared post-processing for AI-generated JSX → sandbox-compatible JS.
- *
- * Both desktop (esbuild-wasm) and server (esbuild native) use this after
- * esbuild.transform(). The sandbox (DynamicOverlay) uses new Function()
- * which can't handle import/export statements — this strips them.
- *
- * The esbuild transform uses the classic JSX transform (React.createElement)
- * so that React is provided by the sandbox scope, not imported.
- */
-/**
- * esbuild transform options for AI-generated JSX.
- * Use these with esbuild.transform(jsxSource, ESBUILD_JSX_OPTIONS).
- */
 export declare const ESBUILD_JSX_OPTIONS: {
     loader: "tsx";
     jsx: "transform";
@@ -19,8 +5,4 @@ export declare const ESBUILD_JSX_OPTIONS: {
     jsxFragment: string;
     target: "es2020";
 };
-/**
- * Post-process esbuild output for the DynamicOverlay sandbox.
- * Strips imports (sandbox injects them), converts export default → exports.default.
- */
 export declare function postProcessForSandbox(code: string): string;

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

@@ -20,9 +20,7 @@ export interface Phase {
     output: 'timeline_edit' | 'artifact' | 'scene_composition';
     description: string;
     verificationCriteria: string[];
-    /** Number of evaluation passes. 0 = skip evaluation, 1 for timeline, 3 for content. */
     evaluationPasses: number;
-    /** Tool names to include for this phase. Empty = all tools available. */
     tools: string[];
     status: 'pending' | 'executing' | 'passed' | 'failed' | 'skipped';
 }
@@ -61,9 +59,7 @@ export interface OverlayData {
 export interface PoolItemData {
     id: string;
     name: string;
-    /** Pool kind (video|audio|image). Optional: headless lanes may omit it. */
     kind?: string;
-    /** Local/presigned URL for the bytes — what view_asset fetches for a still. */
     assetUrl?: string;
     duration: number;
     width: number;
@@ -89,16 +85,13 @@ export interface DirectorContext {
     currentTime: number;
     timelineDuration: number;
     fps: number;
-    /** Canvas format: aspect ratio, optional fps + resolution. Mirrors the wire-shape `Composition.format`. */
     format?: {
         aspectRatio: '16:9' | '9:16' | '1:1' | '4:5';
         fps?: 24 | 30 | 60;
         resolution?: 'hd' | 'fhd' | '4k';
     };
     transcript?: string;
-    /** True when word-level timings were stripped to fit context budget */
     transcriptTruncated?: boolean;
-    /** True when word-level timings are included in the transcript, false when stripped for budget */
     transcriptHasTimings?: boolean;
     clips: ClipData[];
     sceneLabels?: Array<{
@@ -146,21 +139,11 @@ export interface DirectorContext {
         voiceGuidelines: string;
         heroImageUrl?: string;
     };
-    /**
-     * Detected faces in the source clip(s) — the `face-0..N` roster from
-     * source-level subject detection (faces + active-speaker). Lets the agent
-     * author `{ kind: "face", faceId }` crop intents against REAL detected faces
-     * instead of guessing. Empty when detection hasn't run for this clip.
-     */
     faces?: SubjectFaceInfo[];
 }
-/** One detected face surfaced to the agent via get_context. */
 export interface SubjectFaceInfo {
-    /** Stable id within the clip's source window; `face-0` = largest/primary. */
     faceId: string;
-    /** Fraction of the clip this face is the active speaker (0..1), if known. */
     speakingShare?: number;
-    /** Median normalized bbox over the window (0..1) — a placement hint. */
     bbox?: {
         x: number;
         y: number;
@@ -180,24 +163,6 @@ export interface StockMediaResult {
     photographer: string;
     mediaType: 'video' | 'photo';
 }
-/**
- * Stock video candidate returned by `searchStockVideos` / `searchPixabayVideos`.
- *
- * Stricter than `StockMediaResult`:
- *   - `provider` is required (so consumers can render attribution + key by it)
- *   - `externalId` is always a string (Pexels uses numeric IDs, Pixabay
- *     too — normalise here so downstream cache keys / dedupe sets don't
- *     have to coerce)
- *   - `query` echoes the search term that surfaced the candidate (used by
- *     the b-roll enrichment pipeline to attribute hits to suggestions)
- *   - `duration`, `previewUrl` are required (b-roll filter relies on
- *     duration; UI always shows a hover preview)
- *   - `photographerUrl` + `assetUrl` enable Pexels / Pixabay TOS-mandated
- *     backlinks
- *
- * `StockMediaResult` is retained for the photo path where these fields
- * don't apply (no duration, no provider page per asset on the photo APIs we use).
- */
 export interface StockVideoCandidate {
     provider: 'pexels' | 'pixabay';
     externalId: string;
@@ -210,8 +175,6 @@ export interface StockVideoCandidate {
     height: number;
     photographer: string;
     photographerUrl?: string;
-    /** Provider-specific page for this asset (Pexels `url`, Pixabay `pageURL`).
-     *  Used by the UI to satisfy Pexels TOS ("link to the photo page on Pexels"). */
     assetUrl?: string;
 }
 export interface SoundEffectResult {
@@ -223,13 +186,6 @@ export interface SoundEffectResult {
     tags: string[];
     license: string;
 }
-/**
- * Photo candidate returned by the activity-shape variant of
- * `searchStockPhotos` / `searchPixabayPhotos`. Mirrors
- * `StockVideoCandidate` minus `duration` (photos have no duration).
- * Used by the Temporal clip-enrichment activity which persists rows
- * matching `data-models/convex-schemas/src/enrichment.ts` candidateShape.
- */
 export interface StockPhotoCandidate {
     provider: 'pexels' | 'pixabay';
     externalId: string;
@@ -243,13 +199,6 @@ export interface StockPhotoCandidate {
     photographerUrl?: string;
     assetUrl?: string;
 }
-/**
- * Sound-effect candidate returned by `searchSoundEffectsCandidates`.
- * Shaped like `StockVideoCandidate` minus width/height (sfx has no
- * spatial dimensions) and with required `licenseCode` so the call site
- * can filter to CC0 before persistence. `assetUrl` points to the
- * Freesound sound page (TOS-mandated attribution link).
- */
 export interface StockSoundCandidate {
     provider: 'freesound';
     externalId: string;
@@ -263,13 +212,6 @@ export interface StockSoundCandidate {
     assetUrl: string;
     licenseCode: string;
 }
-/**
- * GIF/clip candidate returned by `searchKlipyCandidates` (clips API
- * variant — MP4-backed reaction clips, better suited for overlay than
- * raw GIFs). `duration` is optional because Klipy doesn't always
- * surface it; the enrichment activity's duration filter treats
- * `undefined` as permissive (GIFs loop on playback).
- */
 export interface StockGifCandidate {
     provider: 'klipy';
     externalId: string;
@@ -330,31 +272,18 @@ export interface ToolResult {
     message: string;
     overlayId?: string;
     clipId?: string;
-    /** Tool execution wall-clock, measured around execute() by the hook wrapper
-     *  (instrumentation 2026-07-17 — tool time was invisible in every trace;
-     *  the audit had to reconstruct it from inter-generation gaps). */
     durationMs?: number;
-    /** Serialized argument / result sizes (bytes) — the context-growth ledger
-     *  (fat tool results were +10k-token jumps nobody could attribute). */
     argsBytes?: number;
     resultBytes?: number;
 }
-/** Per-step loop metrics — emitted by the Agent's onStepFinish so hidden
- *  (thinking) output, cache efficiency, and step latency are first-class
- *  telemetry instead of a trace-archaeology exercise (2026-07-17 audit:
- *  94% of output tokens were invisible thinking; nobody had measured). */
 export interface StepMetrics {
     stepIndex: number;
     toolNames: string[];
-    /** Model-visible output: text chars + serialized tool-call arg chars. */
     visibleChars: number;
     outputTokens?: number;
-    /** Uncached prompt tokens this step (the re-billed conversation tail). */
     inputTokens?: number;
     cacheReadTokens?: number;
     cacheWriteTokens?: number;
-    /** reasoning tokens when the provider reports them; else derive
-     *  hidden ≈ outputTokens - visibleChars/4 downstream. */
     reasoningTokens?: number;
     finishReason?: string;
 }
@@ -363,9 +292,7 @@ export interface DirectorResult {
     results: ToolResult[];
     textResponse?: string;
     error?: string;
-    /** CLI session ID — enables session resumption on the next invocation. */
     cliSessionId?: string;
-    /** Token usage from the LLM provider. */
     usage?: {
         inputTokens: number;
         outputTokens: number;
@@ -444,7 +371,6 @@ export type ProgressEvent = {
 };
 export type OnProgressCallback = (event: ProgressEvent) => void;
 export type ApprovalFn = (toolCallId: string, toolName: string, args?: Record<string, unknown>) => Promise<boolean>;
-/** Per-criterion pass/fail with structured feedback. */
 export interface CriteriaResult {
     passed: boolean;
     criteria: Array<{
@@ -454,118 +380,43 @@ export interface CriteriaResult {
     }>;
     bestAttempt: number;
 }
-/** Configuration for the Agent class. */
 export interface AgentConfig {
-    /** Language model to use for generation. */
     model: import('ai').LanguageModel;
-    /** System prompt for the agent. */
     systemPrompt: string;
-    /** Capabilities — without these, the agent has no tools. */
     capabilities?: import('./capabilities.js').AgentCapabilities;
-    /** Lifecycle hooks. */
     hooks?: {
         beforeToolCall?: (name: string, args: Record<string, unknown>) => boolean | Promise<boolean>;
         afterToolCall?: (name: string, result: ToolResult) => void;
-        /** Per-step metrics sink (usage split, visible vs hidden output, cache
-         *  efficiency). Called after each loop step with StepMetrics. */
         onStepMetrics?: (metrics: StepMetrics) => void;
         afterEvaluate?: (criteria: Record<string, string>, result: CriteriaResult) => void;
     };
-    /** Model to use for evaluation. Defaults to model. */
     evaluationModel?: import('ai').LanguageModel;
-    /** Max tool-loop steps per run. Default: 20. */
     maxSteps?: number;
-    /**
-     * Max output tokens per LLM turn. Default: 16000. UNSET before 2026-07-12,
-     * which silently inherited the AI SDK Anthropic default of 4096 — a planner
-     * writing a full ComposePlan tool call (or an author writing a large
-     * apply_composition) got truncated at exactly 4096 tokens and the tool call
-     * was LOST (the verify-rerun planner stall: output stopped mid-answer,
-     * tool_calls=[]).
-     */
     maxOutputTokens?: number;
-    /**
-     * Provider-scoped request options forwarded to every LLM turn (the AI SDK
-     * `providerOptions` passthrough — e.g. `{ anthropic: { thinking: { type:
-     * 'disabled' } } }`). The caller owns the policy; the agent just forwards.
-     * Typed structurally (per-provider JSON object) — the nominal ProviderOptions
-     * export moved across ai@6 minor versions.
-     */
     providerOptions?: Record<string, Record<string, unknown>>;
-    /** Logger. */
     logger?: import('./capabilities.js').Logger;
-    /**
-     * Context-management policy for the tool loop. When set, a `prepareStep`
-     * evicts stale tool-call/result content (accumulating tool-result text +
-     * base64 capture images) between steps so a long, tool-heavy run stays under
-     * the model's context window. Off by default (no pruning).
-     */
     contextManagement?: import('./agent/contextManagement.js').ContextManagementPolicy;
-    /**
-     * Optional tool-set factory (the Subsystem-3 swap seam). When present, the
-     * tool-based run builds its `ToolSet` from this factory instead of the
-     * in-process `buildDirectorTools` — the Director's author LLM then drives the
-     * curated `/v1` MCP tools over the network. Absent (default) → unchanged
-     * in-process path. `packages/authoring` stays free of any `@cueframe/mcp`
-     * dependency: it only knows the structural `ToolSet` (from `ai`).
-     */
     buildToolSet?: (opts: {
         allowedTools: string[];
         onProgress: OnProgressCallback;
     }) => import('ai').ToolSet;
-    /**
-     * The tool names this agent may use — the config-level default `run()` falls
-     * back to.
-     *
-     * REQUIRED alongside `buildToolSet` (unless every `run()` names its own
-     * `tools`): the injected factory speaks a DIFFERENT vocabulary from the
-     * in-process compose-role tool set (tools/composeRoleTools.ts), and
-     * `buildCuratedToolSet` silently skips names it does not recognise — so
-     * inheriting that key list would quietly build whatever happened to overlap.
-     * Absent + no factory ⇒ every in-process compose-role tool.
-     */
     allowedTools?: readonly string[];
-    /**
-     * Tools merged into the built ToolSet VERBATIM — after buildToolSet /
-     * buildDirectorTools and after hook wrapping, so provider-defined tools
-     * (e.g. the Anthropic memory tool, whose serialization the provider owns)
-     * pass through untouched. Keys collide last-wins; callers own uniqueness.
-     */
     extraTools?: import('ai').ToolSet;
-    /**
-     * RESERVE-VERIFY-STEP (P0.2, ledger 2026-07-17): tool names allowed on the
-     * LAST budgeted step. When set, `prepareStep` restricts `activeTools` to this
-     * list on step maxSteps-1, so a MUTATION can never be the loop's unread final
-     * act — the last possible mutation lands at maxSteps-2 and its result (or
-     * error) is read on the reserved step. Motivation: the motion pass's only
-     * mutation errored on step 12/12 and the activity still "succeeded" with zero
-     * motion landed (staging v17b1hsx). Unset (default) → no restriction.
-     */
     finalStepTools?: readonly string[];
 }
-/** Options for Agent.run(). */
 export interface AgentRunOptions {
-    /** Restrict available tools for this run. */
     tools?: string[];
-    /** Plain-language quality criteria. Keys are criterion names, values are descriptions. */
     criteria?: Record<string, string>;
-    /** Weighted rubric with numeric scoring per dimension. */
     rubric?: EvaluatorRubric;
-    /** Verification criteria — each must be met independently. */
     verificationCriteria?: string[];
-    /** Max evaluation attempts. Default 1 (no retry). >1 enables quality loop. */
     maxAttempts?: number;
-    /** Headless mode (generateText, no streaming). */
     headless?: boolean;
-    /** Abort signal for cancellation. */
     abortSignal?: AbortSignal;
 }
-/** Result from Agent.run(). */
 export interface AgentRunResult {
     success: boolean;
     text?: string;
     evaluation?: CriteriaResult;
-    /** Rubric evaluation result (when rubric mode is used). */
     rubricEvaluation?: EvaluationResult;
     attempts: number;
     usage: import('ai').LanguageModelUsage;

package/dist/_members/brand-derivation/constants.d.ts

@@ -1,26 +1,9 @@
-/**
- * Derivation constants — pure data, ZERO side effects, ZERO heavy imports.
- *
- * This module deliberately imports NOTHING (no apca-w3, no culori). Render-side
- * consumers (e.g. @cueframe/primitives) need only the ramp poles / floors and
- * must not drag the contrast MATH (apca-w3 + culori) into their bundle just for
- * two string constants. `contrastSafe.ts` re-exports these so the package root
- * stays the single source of truth; leaf consumers import from
- * `@cueframe/brand-derivation/constants`.
- */
-/** Version of the derivation RULES. Bump when the math changes; downstream stamps
- *  this so re-derivation is explicit, never a silent fleet-wide shift.
- *  v2: Tier-2 derivation expansion — adds surface/card/gridLine/accentMuted fills
- *  and textOnAccent/textOnSurface paired foregrounds. Re-derives the fleet. */
 export declare const DERIVATION_VERSION = 2;
-/** Forward-only APCA floors. The clamp only ever INCREASES legibility. */
 export declare const FLOORS: {
     readonly body: 75;
     readonly nonBody: 60;
     readonly headline: 45;
 };
-/** The two neutral poles. `onDark` (white) is the safe default text color when the
- *  background is unknown; `onLight` (near-black) is the safe plate / dark pole. */
 export declare const NEUTRAL_RAMP: {
     readonly onDark: "#FFFFFF";
     readonly onLight: "#0A0A0A";

package/dist/_members/brand-derivation/contrastSafe.d.ts

@@ -13,33 +13,10 @@ export interface ContrastSafeColors {
     textOnAccent: string;
     textOnSurface: string;
 }
-/** sRGB relative luminance Y∈[0,1] of a hex color, via apca-w3's `sRGBtoY`.
- *  Exported so composition-side legibility (which compares text against a
- *  SAMPLED backdrop luminance, not a second hex) can put text + backdrop on the
- *  same Y scale without re-deriving the transfer curve. */
 export declare function relativeLuminance(hex: string): number;
-/** APCA Lc magnitude between two relative-luminance values (text fg over bg).
- *  This is the primitive the composition FLOOR's worst-tile legibility check
- *  consumes: it samples per-tile backdrop luminance from the rendered frame and
- *  asks "does the caption text clear the floor over the WORST tile?". Polarity-
- *  signed APCA is reduced to a magnitude (the floor wants legibility, not which
- *  way the polarity runs). Keep the APCA math in THIS package — the floor must
- *  not re-implement it (single source of truth, no proxy). */
 export declare function apcaLcFromLuminance(fgY: number, bgY: number): number;
-/** APCA Lc magnitude between two hex colors (fg over bg). Hex-input sibling of
- *  `apcaLcFromLuminance`; the brand cascade and tests use it directly. */
 export declare function apcaLc(fg: string, bg: string): number;
-/** Return `fg` if it clears `floor` over `bg`; else the most legible of {fg, ramp poles} over `bg`
- *  (never lower contrast than the input — forward-only by construction). Exported so the brand
- *  cascade (composition-model) can re-clamp its own derived de-emphasis tokens (e.g. the muted
- *  text mix) back up to a floor without re-implementing the APCA math at the package boundary. */
 export declare function clampToFloor(fg: string, bg: string, floor: number): string;
-/** Derive a contrast-safe palette from a brand seed.
- *  Captions are an UNCONDITIONAL floor: a plate-backed neutral fallback guarantees
- *  `Lc(captionFg, captionScrim) >= FLOORS.body` for any brand background.
- *  `text` / `textMuted` directly on a hostile brand background are best-achievable / forward-only
- *  (the monotone clamp never lowers a brand's own contrast); a tuned solid-background plate for
- *  body text on hostile backgrounds is Phase 1. */
 export declare function deriveContrastSafe(seed: {
     background: string;
     text: string;

package/dist/_members/cloud-import/CloudImportService.d.ts

@@ -1,13 +1,3 @@
-/**
- * Singleton Uppy service for imports (local + cloud).
- *
- * Uses @uppy/aws-s3 for multipart uploads directly to R2 via the
- * upload-signing CF Worker. Replaces the old TUS-based upload path.
- *
- * Owns the Uppy instance lifecycle (headless — no Dashboard plugin).
- * React integration is handled by ImportProvider (single mount at app root).
- * MediaItem pre-creation is handled by MediaItemPreprocessor (Uppy plugin).
- */
 import Uppy from '@uppy/core';
 import { MediaItemPreprocessor } from './MediaItemPreprocessor.js';
 interface CloudImportConfig {
@@ -21,15 +11,10 @@ export interface CloudUploadResult {
 declare class CloudImportService {
     private uppy;
     private config;
-    /** Lazy-init: create Uppy + plugins on first use. */
     init(config: CloudImportConfig): Uppy;
-    /** Get the Uppy instance (must call init() first). */
     getUppy(): Uppy;
-    /** Get the MediaItemPreprocessor plugin. */
     getPreprocessor(): MediaItemPreprocessor;
-    /** Update upload metadata (uploadToken, userId, projectId). */
     setMeta(meta: Record<string, string>): void;
 }
-/** Module-level singleton. */
 export declare const cloudImportService: CloudImportService;
 export {};

package/dist/_members/cloud-import/ImportProvider.d.ts

@@ -1,14 +1,3 @@
-/**
- * ImportProvider — single mount at app root.
- *
- * Initializes the CloudImportService, wires auth callbacks, and provides
- * the useImport() hook to child components. Wraps children in Uppy's
- * UppyContextProvider so headless hooks (useDropzone, useUppyState, etc.)
- * work anywhere in the tree.
- *
- * The import dialog UI is injected via `dialogSlot` to avoid circular
- * dependency between @cueframe/cloud-import and @cueframe/pro.
- */
 import { type ReactNode } from 'react';
 import type Uppy from '@uppy/core';
 import type { CloudUploadResult } from './CloudImportService.js';
@@ -17,30 +6,14 @@ interface ImportContextValue {
     closeModal: () => void;
     isOpen: boolean;
     uppy: Uppy;
-    /**
-     * Can this lane actually take an upload right now?
-     *
-     * A cloud import needs an identity: `getUploadMeta` mints an org-scoped
-     * upload token, so with none the modal opens onto a request that can only
-     * fail. This is DATA because the provider is now a fixture of the tree — it
-     * mounts for the life of the desktop process, signed in or not, so its
-     * PRESENCE stopped being the answer to this question (it was, back when the
-     * whole cloud stack mounted only inside a confirmed auth handshake).
-     */
     available: boolean;
 }
 export interface ImportProviderProps {
     children: ReactNode;
-    /** Whether this lane can take an upload — see `ImportContextValue.available`.
-     *  Required, with no default: the one thing a caller must not forget is the
-     *  fact that decides whether a control is offered at all. */
     available: boolean;
-    /** React element to render the import dialog (e.g. <ImportDialog />) */
     dialogSlot?: ReactNode;
     uploadSigningUrl: string;
-    /** Called before opening the modal — returns upload metadata (token, userId, etc). */
     getUploadMeta?: () => Promise<Record<string, string>>;
-    /** Pre-create a mediaItem — called by the preprocessor plugin before upload starts. */
     createMediaItem?: (file: {
         name: string;
         size: number;
@@ -50,24 +23,6 @@ export interface ImportProviderProps {
     onError?: (error: Error) => void;
 }
 export declare function ImportProvider({ children, available, dialogSlot, uploadSigningUrl, getUploadMeta, createMediaItem, onUploadComplete, onError, }: ImportProviderProps): import("react").JSX.Element;
-/** Hook to access the import modal and Uppy instance. Must be used inside <ImportProvider>. */
 export declare function useImport(): ImportContextValue;
-/**
- * The context WHEN THE LANE CAN BE USED, and `null` otherwise — for surfaces
- * that offer the cloud modal only where it works and fall back where it does
- * not (the pro ImportButton, which drops to the local file picker).
- *
- * It used to answer presence alone, and presence used to be the same fact:
- * the provider mounted only inside a confirmed auth handshake. It mounts for
- * the life of the desktop process now (Task 11 — a provider that appears and
- * disappears re-parents the app), so presence would offer a cloud modal to a
- * signed-out user whose upload-token request can only fail: a control that
- * looks alive and silently does nothing.
- *
- * Still ONE fact, read from the tree rather than mirrored: the alternative —
- * a caller re-deriving `isDesktop && cloudEnabled && signedIn` — is the drift
- * class that crashed the desktop ("useImport must be used within
- * <ImportProvider>") whenever the two copies disagreed.
- */
 export declare function useImportIfAvailable(): ImportContextValue | null;
 export {};

package/dist/_members/cloud-import/MediaItemPreprocessor.d.ts

@@ -1,11 +1,3 @@
-/**
- * Uppy preprocessor plugin that pre-creates a mediaItem in the backend
- * before the upload starts. This guarantees convexMediaItemId is in the
- * upload metadata before the first byte goes out — no race condition.
- *
- * The actual creation function is injected via setCreateFn() so the plugin
- * stays decoupled from Convex/auth concerns.
- */
 import { BasePlugin } from '@uppy/core';
 import type { Uppy, Meta } from '@uppy/core';
 type CreateMediaItemFn = (file: {
@@ -18,7 +10,6 @@ export declare class MediaItemPreprocessor extends BasePlugin<Record<string, nev
     private createFn;
     private preprocessBound;
     constructor(uppy: Uppy, opts?: Record<string, never>);
-    /** Inject the creation function (called from ImportProvider). */
     setCreateFn(fn: CreateMediaItemFn | null): void;
     install(): void;
     uninstall(): void;

package/dist/_members/cloud-import/cloudConfig.d.ts

@@ -1,23 +1,8 @@
-/**
- * Single source of truth for cloud endpoint resolution.
- *
- * One input (convexUrl) → deterministic output (all cloud endpoints).
- * No fallback chains, no env var reading, no defaults.
- */
 export type CloudEnvironment = 'dev' | 'staging' | 'production';
 export interface CloudEndpoints {
     convexUrl: string;
     uploadSigningUrl: string;
 }
 export declare const ENVIRONMENTS: Record<CloudEnvironment, CloudEndpoints>;
-/** Detect environment from a Convex deployment URL.
- *
- * Convex exposes two domains per deployment: queries (`data*`) and HTTP
- * actions (`api*`). Callers pass either form depending on which client
- * they own, so detection has to recognize both:
- *   prod    → api.cueframe.ai     | data.cueframe.ai
- *   staging → api-dev.cueframe.ai | data-dev.cueframe.ai
- */
 export declare function detectEnvironment(convexUrl?: string): CloudEnvironment;
-/** Resolve all cloud endpoints from a Convex URL. */
 export declare function getEndpoints(convexUrl: string): CloudEndpoints;

package/dist/_members/compose/CompositionRenderer.d.ts

@@ -3,10 +3,4 @@ import type { SceneRenderInput } from './sceneToRenderInput.js';
 export interface CompositionRendererProps {
     input: SceneRenderInput;
 }
-/**
- * Renders a complete scene composition.
- *
- * Lays out scenes as Sequences with proper frame offsets (accounting for
- * transition overlaps), applies effects, text, layout, global effects, and audio.
- */
 export declare const CompositionRenderer: React.FC<CompositionRendererProps>;

package/dist/_members/compose/primitiveRegistry.d.ts

@@ -2,86 +2,22 @@ import type { ResolvedBrandKit } from '../composition/projection/index.js';
 import type { PrimitiveMeta as NewPrimitiveMeta } from '../primitives/lib/types.js';
 import { listPrimitivesByCategory, getPrimitiveTextParam, getPrimitiveSubtextParam } from '../composition/primitive-catalog/index.js';
 export { listPrimitivesByCategory, getPrimitiveTextParam, getPrimitiveSubtextParam };
-/** Re-export for consumers that want the canonical PrimitiveMeta shape. */
 export type PrimitiveMeta = NewPrimitiveMeta;
-/**
- * All primitive catalogs merged into a single array.
- *
- * Transitions declare `kind: 'transition'` + `createPresentation(params)`.
- * The render path resolves via `resolveTransitionPresentation(id, params)`
- * and passes the returned presentation to `<TransitionSeries.Transition>`.
- * Agent discovery (list_effect_styles filtered by category) surfaces them
- * as addressable primitives.
- */
 export declare const allCatalogs: PrimitiveMeta[];
 export declare function registerPrimitiveOverride(meta: PrimitiveMeta, owner: string): void;
-/**
- * Clear all registered overrides + release the owner. A shared/pooled process MUST
- * call this between tenants; a per-render process calls it once at bundle init so a
- * reused render context starts clean (idempotent re-render).
- */
 export declare function resetPrimitiveOverrides(): void;
-/**
- * Resolve a primitive by its kebab-case ID.
- * Returns the PrimitiveMeta (component + metadata) or undefined if not found.
- */
 export declare function resolvePrimitive(id: string): PrimitiveMeta | undefined;
-/**
- * List all registered primitive IDs.
- */
 export declare function listPrimitives(): string[];
-/**
- * Resolve a transition presentation factory by id. Returns a concrete
- * Remotion `TransitionPresentation` (typed loosely as `unknown` to avoid
- * pulling `@remotion/transitions` types into every consumer) built from
- * the supplied params.
- *
- * Returns `undefined` if the id is unknown OR if the registered entry is
- * not a transition (defensive — lets callers fall back cleanly).
- */
 export declare function resolveTransitionPresentation(id: string, params?: Record<string, unknown>): unknown | undefined;
-/**
- * Returns true if an id names a registered transition. Used by ingress
- * validators (e.g. public schema) to widen the old enum to any registered
- * transition without losing validation.
- */
 export declare function isRegisteredTransition(id: string): boolean;
-/**
- * Read accessor: returns the primary text string from an overlay, respecting
- * both the canonical location (overlay.params.text) and the legacy
- * primitive-native location (overlay.params[meta.textParam]). Canonical
- * wins when present.
- *
- * Use this in every consumer that needs "the text of an overlay" —
- * Inspector, Timeline, transcript, FCPXML, NLE exports.
- */
 export declare function getPrimitiveText(overlay: {
     template: string;
     params: Record<string, unknown>;
 }): string | undefined;
-/**
- * Read accessor for secondary text. Same fallback pattern as getPrimitiveText.
- */
 export declare function getPrimitiveSubtext(overlay: {
     template: string;
     params: Record<string, unknown>;
 }): string | undefined;
-/**
- * Render-time translator from overlay-canonical params to primitive-native
- * props. Used by OverlayLayer and anything else that spreads overlay.params
- * into the primitive component.
- *
- *   params.text   → props[meta.textParam]    (if primitive has textParam)
- *   params.subtext → props[meta.subtextParam] (if primitive has subtextParam)
- *   "$brand:<path>" refs → resolved against brandKit (if provided)
- *   everything else → passed through
- *
- * Producers MUST write canonical `text` / `subtext`. Writing under the
- * primitive's native prop name (e.g. `content`) is no longer auto-mapped —
- * such payloads fail paramsSchema validation at inflate time with a clear
- * `<primitive-id>: invalid params — text: Required` error so the producer
- * can be corrected.
- */
 export declare function inflatePrimitiveProps(overlay: {
     template: string;
     params: Record<string, unknown>;