@tangle-network/agent-app 0.34.0 → 0.36.0

package/dist/intakes/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"sources":["../../src/intakes/context-sufficiency.ts"],"sourcesContent":["/**\n * Pure context-sufficiency floor + conversational-gather scaffold — the\n * product-agnostic core of a CONVERSATIONAL intake. Where the question-graph\n * model (`./model`) runs a one-question-at-a-time interview, this leaf judges\n * whether an agent has gathered ENOUGH context to act, and renders the prompt\n * directive that tells the agent to fold the remaining gaps into its work\n * instead of running a form.\n *\n * Zero dependencies: no drizzle, no env, no react, no I/O, no product reads.\n * A product declares WHICH facts matter (`ContextFactSpec`), and its own\n * adapter resolves those facts + named substrate flags from whatever substrate\n * it owns (`ResolvedContextSignals`); this leaf only does the deterministic\n * combine and the wording. That separation is what makes the framework opt-in\n * and tree-shakeable, and what lets gtm/tax/legal/insurance share one core.\n *\n * Readiness is a two-part floor: SCOPE (every required fact has a value) AND\n * SUBSTRATE (at least one named substrate flag is true). Scope alone is not\n * enough — knowing the goal without any durable thing to act on is still\n * not-ready; substrate alone is not enough either. The product's adapter\n * decides what counts as a fact and what counts as substrate.\n */\n\n/** One fact the product treats as known context once it has a value. */\nexport interface ContextFact {\n  /** Stable key the resolved-signals map is keyed on. */\n  key: string\n  /** Human label shown in the prompt's known/missing lists. */\n  label: string\n  /** When true, this fact must have a value for SCOPE to be met. */\n  required?: boolean\n  /** How the agent should gather this fact conversationally, if missing. */\n  gatherHint?: string\n}\n\n/**\n * The product's declaration of what context matters: the facts that make up\n * scope, plus optional tool hints appended verbatim to the gather prompt (e.g.\n * a product passes the command that extracts a brand from a URL). Pure data —\n * the product supplies labels, hints, and tool lines; the framework never\n * names a product-specific concept itself.\n */\nexport interface ContextFactSpec {\n  facts: ContextFact[]\n  /** Lines appended after the gather directive — e.g. product tool pointers. */\n  toolHints?: string[]\n}\n\n/**\n * What a product's adapter resolves from its own substrate, ready to combine.\n * `facts` carries the resolved VALUE per fact key (undefined/empty = not\n * known); `substrate` carries named boolean flags (e.g.\n * `{ brandConfirmed, configHasContext, coreKnowledgePresent }`) — any one true\n * satisfies the substrate half of the floor.\n */\nexport interface ResolvedContextSignals {\n  facts: Record<string, string | undefined>\n  substrate: Record<string, boolean>\n}\n\n/** A resolved fact that has a value — surfaced to the prompt as known context. */\nexport interface KnownFact {\n  key: string\n  label: string\n  value: string\n}\n\n/** A required fact with no value — surfaced to the prompt as a gap to close. */\nexport interface MissingFact {\n  key: string\n  label: string\n  gatherHint?: string\n}\n\n/** The deterministic verdict over the resolved signals. */\nexport interface ContextSufficiency {\n  /** True when the floor is met: `hasScope && hasSubstrate`. */\n  ready: boolean\n  /** Every REQUIRED fact has a non-empty value. */\n  hasScope: boolean\n  /** At least one named substrate flag is true. */\n  hasSubstrate: boolean\n  /** Facts (required or not) that have a value. */\n  knownFacts: KnownFact[]\n  /** Required facts that have no value yet. */\n  missingFacts: MissingFact[]\n  /** The substrate flags as resolved, passed through for the prompt/caller. */\n  substrate: Record<string, boolean>\n}\n\n/** Trim a fact value to a present string, or undefined when blank/absent. */\nfunction presentValue(value: string | undefined): string | undefined {\n  if (typeof value !== 'string') return undefined\n  const trimmed = value.trim()\n  return trimmed.length > 0 ? trimmed : undefined\n}\n\n/**\n * Combine a fact spec with resolved signals into the readiness verdict. Pure,\n * deterministic, never throws — a missing fact key or an empty substrate map\n * reads as not-ready, not an error, so a fresh scope is honestly not-ready\n * rather than crashing the caller.\n *\n * SCOPE = every `required` fact resolves to a non-empty value.\n * SUBSTRATE = any value in `signals.substrate` is true.\n * READY = SCOPE && SUBSTRATE.\n *\n * `knownFacts` lists every fact (required or optional) that resolved to a\n * value, in spec declaration order; `missingFacts` lists every REQUIRED fact\n * that did not — optional facts never appear as missing because they never gate\n * scope.\n */\nexport function computeContextSufficiency(\n  spec: ContextFactSpec,\n  signals: ResolvedContextSignals,\n): ContextSufficiency {\n  const facts = spec.facts ?? []\n  const resolvedFacts = signals.facts ?? {}\n  const substrate = signals.substrate ?? {}\n\n  const knownFacts: KnownFact[] = []\n  const missingFacts: MissingFact[] = []\n  let hasScope = true\n\n  for (const fact of facts) {\n    const value = presentValue(resolvedFacts[fact.key])\n    if (value !== undefined) {\n      knownFacts.push({ key: fact.key, label: fact.label, value })\n    } else if (fact.required) {\n      hasScope = false\n      missingFacts.push({ key: fact.key, label: fact.label, gatherHint: fact.gatherHint })\n    }\n  }\n\n  const hasSubstrate = Object.values(substrate).some(Boolean)\n\n  return {\n    ready: hasScope && hasSubstrate,\n    hasScope,\n    hasSubstrate,\n    knownFacts,\n    missingFacts,\n    substrate,\n  }\n}\n\n/** The directive that turns gaps into conversational gathering, not a form. */\nconst GATHER_DIRECTIVE =\n  'Do not run an interview. Act on the message first, then fold AT MOST one or two pointed questions into the same turn to close the highest-leverage gap. Never present a form.'\n\n/** What to say when scope is met but no durable substrate exists yet. */\nconst SUBSTRATE_DIRECTIVE =\n  'You have the scope but no durable substrate to act on yet. As you work, persist what you learn — that is what makes this context-ready.'\n\n/**\n * Render the prompt section that mirrors a conversational-gather flow:\n *  - \"### Context you already have\" — the known facts, as `label: value`.\n *  - \"### Context still missing — gather it while you work, not as a form\" —\n *    the missing facts (with their gather hints), the act-first directive, and\n *    any product tool hints appended verbatim.\n *\n * When scope is met but the floor still is not (no substrate flag), it emits\n * the substrate directive instead of a missing-facts list. Returns '' when\n * there is nothing to say (no known facts, no gaps, and ready) so a caller can\n * concatenate it unconditionally. Pure: wording is product-neutral; every\n * product-specific phrase comes from the spec's labels, gather hints, and tool\n * hints.\n */\nexport function buildContextGatherPrompt(\n  spec: ContextFactSpec,\n  sufficiency: ContextSufficiency,\n): string {\n  const lines: string[] = []\n\n  if (sufficiency.knownFacts.length > 0) {\n    lines.push('### Context you already have')\n    lines.push(sufficiency.knownFacts.map((f) => `- ${f.label}: ${f.value}`).join('\\n'))\n  }\n\n  if (sufficiency.missingFacts.length > 0) {\n    if (lines.length > 0) lines.push('')\n    lines.push('### Context still missing — gather it while you work, not as a form')\n    const gaps = sufficiency.missingFacts\n      .map((f) => (f.gatherHint ? `- ${f.label} — ${f.gatherHint}` : `- ${f.label}`))\n      .join('\\n')\n    lines.push(`You do NOT have:\\n${gaps}`)\n    lines.push(GATHER_DIRECTIVE)\n    for (const hint of spec.toolHints ?? []) {\n      const trimmed = hint.trim()\n      if (trimmed) lines.push(trimmed)\n    }\n  } else if (!sufficiency.ready) {\n    if (lines.length > 0) lines.push('')\n    lines.push(SUBSTRATE_DIRECTIVE)\n    for (const hint of spec.toolHints ?? []) {\n      const trimmed = hint.trim()\n      if (trimmed) lines.push(trimmed)\n    }\n  }\n\n  if (lines.length === 0) return ''\n  return `## Project Context & Sufficiency\\n${lines.join('\\n')}`\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA0FA,SAAS,aAAa,OAA+C;AACnE,MAAI,OAAO,UAAU,SAAU,QAAO;AACtC,QAAM,UAAU,MAAM,KAAK;AAC3B,SAAO,QAAQ,SAAS,IAAI,UAAU;AACxC;AAiBO,SAAS,0BACd,MACA,SACoB;AACpB,QAAM,QAAQ,KAAK,SAAS,CAAC;AAC7B,QAAM,gBAAgB,QAAQ,SAAS,CAAC;AACxC,QAAM,YAAY,QAAQ,aAAa,CAAC;AAExC,QAAM,aAA0B,CAAC;AACjC,QAAM,eAA8B,CAAC;AACrC,MAAI,WAAW;AAEf,aAAW,QAAQ,OAAO;AACxB,UAAM,QAAQ,aAAa,cAAc,KAAK,GAAG,CAAC;AAClD,QAAI,UAAU,QAAW;AACvB,iBAAW,KAAK,EAAE,KAAK,KAAK,KAAK,OAAO,KAAK,OAAO,MAAM,CAAC;AAAA,IAC7D,WAAW,KAAK,UAAU;AACxB,iBAAW;AACX,mBAAa,KAAK,EAAE,KAAK,KAAK,KAAK,OAAO,KAAK,OAAO,YAAY,KAAK,WAAW,CAAC;AAAA,IACrF;AAAA,EACF;AAEA,QAAM,eAAe,OAAO,OAAO,SAAS,EAAE,KAAK,OAAO;AAE1D,SAAO;AAAA,IACL,OAAO,YAAY;AAAA,IACnB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAGA,IAAM,mBACJ;AAGF,IAAM,sBACJ;AAgBK,SAAS,yBACd,MACA,aACQ;AACR,QAAM,QAAkB,CAAC;AAEzB,MAAI,YAAY,WAAW,SAAS,GAAG;AACrC,UAAM,KAAK,8BAA8B;AACzC,UAAM,KAAK,YAAY,WAAW,IAAI,CAAC,MAAM,KAAK,EAAE,KAAK,KAAK,EAAE,KAAK,EAAE,EAAE,KAAK,IAAI,CAAC;AAAA,EACrF;AAEA,MAAI,YAAY,aAAa,SAAS,GAAG;AACvC,QAAI,MAAM,SAAS,EAAG,OAAM,KAAK,EAAE;AACnC,UAAM,KAAK,0EAAqE;AAChF,UAAM,OAAO,YAAY,aACtB,IAAI,CAAC,MAAO,EAAE,aAAa,KAAK,EAAE,KAAK,WAAM,EAAE,UAAU,KAAK,KAAK,EAAE,KAAK,EAAG,EAC7E,KAAK,IAAI;AACZ,UAAM,KAAK;AAAA,EAAqB,IAAI,EAAE;AACtC,UAAM,KAAK,gBAAgB;AAC3B,eAAW,QAAQ,KAAK,aAAa,CAAC,GAAG;AACvC,YAAM,UAAU,KAAK,KAAK;AAC1B,UAAI,QAAS,OAAM,KAAK,OAAO;AAAA,IACjC;AAAA,EACF,WAAW,CAAC,YAAY,OAAO;AAC7B,QAAI,MAAM,SAAS,EAAG,OAAM,KAAK,EAAE;AACnC,UAAM,KAAK,mBAAmB;AAC9B,eAAW,QAAQ,KAAK,aAAa,CAAC,GAAG;AACvC,YAAM,UAAU,KAAK,KAAK;AAC1B,UAAI,QAAS,OAAM,KAAK,OAAO;AAAA,IACjC;AAAA,EACF;AAEA,MAAI,MAAM,WAAW,EAAG,QAAO;AAC/B,SAAO;AAAA,EAAqC,MAAM,KAAK,IAAI,CAAC;AAC9D;","names":[]}

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

@@ -1,4 +1,4 @@
-import { I as IntakeAnswerValue, a as IntakeQuestion } from '../model-Cuj7d-xT.js';
+import { I as IntakeAnswerValue, a as IntakeQuestion } from '../model-Bzi5i63l.js';
 import * as react from 'react';
 
 /**

package/dist/intakes-react/lazy.d.ts

@@ -1,7 +1,7 @@
 import * as react from 'react';
 import { IntakeInterview } from './index.js';
 export { IntakeInterviewProps } from './index.js';
-import '../model-Cuj7d-xT.js';
+import '../model-Bzi5i63l.js';
 
 declare const IntakeInterviewLazy: react.LazyExoticComponent<typeof IntakeInterview>;
 

package/dist/{model-Cuj7d-xT.d.ts → model-Bzi5i63l.d.ts}

@@ -113,4 +113,4 @@ declare function intakeProgress(graph: IntakeGraph, answers: IntakeAnswers): {
 /** The questions reachable under the current answers, in traversal order. */
 declare function reachableQuestions(graph: IntakeGraph, answers: IntakeAnswers): IntakeQuestion[];
 
-export { type AnswerRejectionReason as A, type IntakeAnswerValue as I, type IntakeQuestion as a, type IntakeGraph as b, type IntakeAnswers as c, type AnswerValidationResult as d, type IntakeAnswerType as e, type IntakeOption as f, getQuestion as g, hasAnswer as h, intakeProgress as i, isComplete as j, nextQuestion as n, reachableQuestions as r, validateAnswer as v };
+export { type AnswerRejectionReason as A, type IntakeAnswerValue as I, type IntakeQuestion as a, type IntakeGraph as b, type AnswerValidationResult as c, type IntakeAnswerType as d, type IntakeAnswers as e, type IntakeOption as f, getQuestion as g, hasAnswer as h, intakeProgress as i, isComplete as j, nextQuestion as n, reachableQuestions as r, validateAnswer as v };

package/dist/studio/index.d.ts

@@ -0,0 +1,132 @@
+interface StudioIntegrationConnection {
+    status: string;
+    providerId: string;
+    connectorId: string;
+}
+type GenerationType = 'image' | 'video' | 'speech' | 'avatar' | 'transcription';
+type GenerationStatus = 'pending' | 'running' | 'succeeded' | 'failed';
+type MediaModelStatus = 'available' | 'limited' | 'unavailable';
+interface Generation {
+    id: string;
+    type: string;
+    prompt: string;
+    result: string | null;
+    model: string | null;
+    cost: number | null;
+    createdAt: Date | null;
+    metadata: Record<string, unknown> | null;
+}
+interface MediaModelOption {
+    id: string;
+    name: string;
+    provider?: string;
+    type: GenerationType;
+    status: MediaModelStatus;
+    reason?: string;
+}
+interface MediaModelCatalogResponse {
+    defaults: Record<GenerationType, string>;
+    models: Record<GenerationType, MediaModelOption[]>;
+    error?: string;
+}
+interface PublishPackage {
+    caption: string;
+    description: string;
+    mentions: string[];
+    destinations: string[];
+    cadence: string;
+    workflowDraft: boolean;
+    evalContract: {
+        artifactType: string;
+        deterministicChecks: string[];
+    };
+}
+interface PublishDestination {
+    id: string;
+    label: string;
+    providerIds: string[];
+    fields: string;
+}
+declare const GENERATION_TYPES: readonly GenerationType[];
+declare function isGenerationType(value: string): value is GenerationType;
+declare const DESTINATIONS: PublishDestination[];
+declare const CADENCES: string[];
+declare const MIN_IMAGE_COUNT = 1;
+declare const MAX_IMAGE_COUNT = 4;
+declare function relativeTime(date: Date | null): string;
+declare function outputPathFor(type: GenerationType): string;
+declare function generationVaultPath(generation: Generation): string | null;
+declare function buildPublishPackage({ caption, postDescription, mentions, cadence, destinations, }: {
+    caption: string;
+    postDescription: string;
+    mentions: string;
+    cadence: string;
+    destinations: string[];
+}): PublishPackage | null;
+declare function isPublishPackage(value: unknown): value is {
+    caption?: string;
+    description?: string;
+    mentions?: string[];
+    destinations?: string[];
+    cadence?: string;
+};
+declare function isDestinationConnected(destination: PublishDestination, connections: StudioIntegrationConnection[]): boolean;
+declare function selectedModelsWithDefaults(current: Partial<Record<GenerationType, string>>, catalog: MediaModelCatalogResponse): Partial<Record<GenerationType, string>>;
+declare function preferredModelId(type: GenerationType, catalog: MediaModelCatalogResponse | null): string | undefined;
+declare function modelMessage(model: MediaModelOption | undefined, loading: boolean, count: number): string | null;
+interface GenerationRequestFields {
+    workspaceId: string;
+    clientRequestId: string;
+    type: GenerationType;
+    model: string;
+    prompt: string;
+    negativePrompt: string;
+    outputPath: string;
+    publishPackage: PublishPackage | null;
+    image: {
+        size: string;
+        quality: string;
+        count: number;
+    };
+    video: {
+        duration: string;
+        resolution: string;
+        aspectRatio: string;
+        referenceImageUrl: string;
+    };
+    speech: {
+        voice: string;
+    };
+    avatar: {
+        audioUrl: string;
+        imageUrl: string;
+        avatarId: string;
+    };
+    transcription: {
+        audioUrl: string;
+        language: string;
+        responseFormat: string;
+        temperature: string;
+    };
+}
+declare function buildGenerationRequestBody(fields: GenerationRequestFields): Record<string, unknown>;
+declare function generationStatus(generation: Generation): GenerationStatus;
+declare function generationError(generation: Generation): string | null;
+declare function generationMergeKey(generation: Generation): string | null;
+declare function mergeLiveGeneration(current: Generation[], generation: Generation): Generation[];
+declare function mergeLoaderAndLive(loader: Generation[], live: Generation[]): Generation[];
+declare function isLocalGeneration(generation: Generation): boolean;
+declare function latestBatchOf(generations: Generation[]): Generation[];
+declare function userSafeGenerationMessage(message?: string): string;
+declare function optimisticGeneration({ type, prompt, model, clientRequestId, outputIndex, outputCount, }: {
+    type: GenerationType;
+    prompt: string;
+    model?: string;
+    clientRequestId: string;
+    outputIndex?: number;
+    outputCount?: number;
+}): Generation;
+declare function failedOptimisticGeneration(generation: Generation): Generation;
+declare function normalizeImageCount(value: unknown): number;
+
+export { CADENCES, DESTINATIONS, GENERATION_TYPES, type Generation, type GenerationRequestFields, type GenerationStatus, type GenerationType, MAX_IMAGE_COUNT, MIN_IMAGE_COUNT, type MediaModelCatalogResponse, type MediaModelOption, type MediaModelStatus, type PublishDestination, type PublishPackage, type StudioIntegrationConnection, buildGenerationRequestBody, buildPublishPackage, failedOptimisticGeneration, generationError, generationMergeKey, generationStatus, generationVaultPath, isDestinationConnected, isGenerationType, isLocalGeneration, isPublishPackage, latestBatchOf, mergeLiveGeneration, mergeLoaderAndLive, modelMessage, normalizeImageCount, optimisticGeneration, outputPathFor, preferredModelId, relativeTime, selectedModelsWithDefaults, userSafeGenerationMessage };

package/dist/studio/index.js

@@ -0,0 +1,59 @@
+import {
+  CADENCES,
+  DESTINATIONS,
+  GENERATION_TYPES,
+  MAX_IMAGE_COUNT,
+  MIN_IMAGE_COUNT,
+  buildGenerationRequestBody,
+  buildPublishPackage,
+  failedOptimisticGeneration,
+  generationError,
+  generationMergeKey,
+  generationStatus,
+  generationVaultPath,
+  isDestinationConnected,
+  isGenerationType,
+  isLocalGeneration,
+  isPublishPackage,
+  latestBatchOf,
+  mergeLiveGeneration,
+  mergeLoaderAndLive,
+  modelMessage,
+  normalizeImageCount,
+  optimisticGeneration,
+  outputPathFor,
+  preferredModelId,
+  relativeTime,
+  selectedModelsWithDefaults,
+  userSafeGenerationMessage
+} from "../chunk-DTS5TZRN.js";
+export {
+  CADENCES,
+  DESTINATIONS,
+  GENERATION_TYPES,
+  MAX_IMAGE_COUNT,
+  MIN_IMAGE_COUNT,
+  buildGenerationRequestBody,
+  buildPublishPackage,
+  failedOptimisticGeneration,
+  generationError,
+  generationMergeKey,
+  generationStatus,
+  generationVaultPath,
+  isDestinationConnected,
+  isGenerationType,
+  isLocalGeneration,
+  isPublishPackage,
+  latestBatchOf,
+  mergeLiveGeneration,
+  mergeLoaderAndLive,
+  modelMessage,
+  normalizeImageCount,
+  optimisticGeneration,
+  outputPathFor,
+  preferredModelId,
+  relativeTime,
+  selectedModelsWithDefaults,
+  userSafeGenerationMessage
+};
+//# sourceMappingURL=index.js.map

package/dist/studio/index.js.map

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

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

@@ -0,0 +1,193 @@
+import * as react from 'react';
+import { ReactNode, SelectHTMLAttributes } from 'react';
+import { Generation } from '../studio/index.js';
+import { IntegrationConnection } from '@tangle-network/sandbox-ui/integrations';
+import { Image } from 'lucide-react';
+
+type StudioRole = 'owner' | 'admin' | 'editor' | 'viewer';
+interface StudioWorkspaceProps {
+    generations: Generation[];
+    totalCost: number;
+    workspaceId?: string;
+    role: StudioRole;
+    /** Polling endpoint override (default `/api/generations`). */
+    generationsEndpoint?: string;
+    /** Build a vault link, optionally to a specific file. Defaults to `/app/<workspaceId>/vault`. */
+    vaultHref?: (filePath?: string | null) => string;
+    /** Integrations page href for the publish-package "Connect" link. Defaults to `/app/<workspaceId>/integrations`. */
+    integrationsHref?: string;
+}
+/**
+ * The full studio surface: header + composer + result canvas + library drawer,
+ * with the generation orchestrator (merge/poll/revalidate) wired in. The host
+ * route owns the loader (auth, RBAC, the generation query) and the server
+ * endpoints (`/api/generate`, `/api/media-models`, `/api/generations`); this
+ * shell renders that data and drives the live UI. Role gates the composer
+ * (viewers get a read-only library) and the integration-management affordances.
+ */
+declare function StudioWorkspace({ generations, totalCost, workspaceId, role, generationsEndpoint, vaultHref, integrationsHref, }: StudioWorkspaceProps): react.JSX.Element;
+
+/**
+ * The generation orchestrator behind a studio surface: it merges the loader's
+ * rows with in-flight live generations, computes the latest batch for the
+ * canvas, polls running generations until they settle, and revalidates the
+ * route loader when a status changes.
+ *
+ * The merge keeps the canvas, the library, and the polling path looking at the
+ * same full list. Polling hits `generationsEndpoint` (default `/api/generations`,
+ * the convention both apps already serve); pass an override if a product routes
+ * it elsewhere. `onGenerated` is wired to the composer's per-result callback.
+ */
+declare function useStudioGenerations(loaderGenerations: Generation[], options?: {
+    workspaceId?: string;
+    generationsEndpoint?: string;
+}): {
+    mergedGenerations: Generation[];
+    latestBatch: Generation[];
+    onGenerated: (generation: Generation) => void;
+};
+
+declare function ComposerHero({ workspaceId, integrationsHref, canManageIntegrations, onGenerated, }: {
+    workspaceId?: string;
+    integrationsHref?: string;
+    canManageIntegrations: boolean;
+    onGenerated: (generation: Generation) => void;
+}): react.JSX.Element;
+
+declare function Field({ label, htmlFor, className, children, }: {
+    label: string;
+    htmlFor?: string;
+    className?: string;
+    children: ReactNode;
+}): react.JSX.Element;
+declare function ComposerDisclosure({ summary, children }: {
+    summary: ReactNode;
+    children: ReactNode;
+}): react.JSX.Element;
+declare function NativeSelect(props: SelectHTMLAttributes<HTMLSelectElement>): react.JSX.Element;
+
+declare function StudioHeader({ count, onOpenLibrary, canGenerate, }: {
+    count: number;
+    onOpenLibrary: () => void;
+    canGenerate: boolean;
+}): react.JSX.Element;
+
+/**
+ * Right-side overlay sheet built on Radix Dialog — gives focus-trap, scroll-lock,
+ * and Escape-to-close for free. Slide/fade come from the studio-sheet-* classes in
+ * ./studio.css (driven by Radix data-state), not tailwindcss-animate.
+ */
+declare function StudioSheet({ open, onOpenChange, title, children, }: {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: string;
+    children: ReactNode;
+}): react.JSX.Element;
+
+declare function ResultCanvas({ batch, onOpenLibrary, onSelect, }: {
+    batch: Generation[];
+    onOpenLibrary: () => void;
+    onSelect: (generation: Generation) => void;
+}): react.JSX.Element;
+
+declare function LibraryDrawer({ open, onOpenChange, generations, totalCost, typeFilter, onFilterChange, vaultHref, selected, onSelect, }: {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    generations: Generation[];
+    totalCost: number;
+    typeFilter: string | null;
+    onFilterChange: (type: string | null) => void;
+    vaultHref?: (filePath?: string | null) => string;
+    selected: Generation | null;
+    onSelect: (generation: Generation | null) => void;
+}): react.JSX.Element;
+
+declare function GenerationCard({ generation, onSelect, }: {
+    generation: Generation;
+    onSelect: (generation: Generation) => void;
+}): react.JSX.Element;
+declare function GenerationStatusBadge({ generation, inline, }: {
+    generation: Generation;
+    inline?: boolean;
+}): react.JSX.Element | null;
+
+declare function GenerationDetail({ generation, vaultHref, onNavigate, }: {
+    generation: Generation;
+    vaultHref?: (filePath?: string | null) => string;
+    onNavigate?: () => void;
+}): react.JSX.Element;
+
+declare function PublishPackageComposer({ caption, postDescription, mentions, cadence, selectedDestinations, connections, connectionError, connectionsLoading, integrationsHref, canManageIntegrations, onCaptionChange, onDescriptionChange, onMentionsChange, onCadenceChange, onDestinationToggle, }: {
+    caption: string;
+    postDescription: string;
+    mentions: string;
+    cadence: string;
+    selectedDestinations: string[];
+    connections: IntegrationConnection[];
+    connectionError: Error | null;
+    connectionsLoading: boolean;
+    integrationsHref?: string;
+    canManageIntegrations: boolean;
+    onCaptionChange: (value: string) => void;
+    onDescriptionChange: (value: string) => void;
+    onMentionsChange: (value: string) => void;
+    onCadenceChange: (value: string) => void;
+    onDestinationToggle: (destination: string) => void;
+}): react.JSX.Element;
+
+interface TypeConfig {
+    label: string;
+    icon: typeof Image;
+    color: string;
+}
+declare const TYPE_CONFIG: Record<string, TypeConfig>;
+declare function typeConfigFor(type: string): TypeConfig;
+
+declare function ImageComposer({ size, quality, imageCount, onSizeChange, onQualityChange, onImageCountChange, }: {
+    size: string;
+    quality: string;
+    imageCount: number;
+    onSizeChange: (value: string) => void;
+    onQualityChange: (value: string) => void;
+    onImageCountChange: (value: number) => void;
+}): react.JSX.Element;
+
+declare function VideoComposer({ duration, resolution, aspectRatio, referenceImageUrl, onDurationChange, onResolutionChange, onAspectRatioChange, onReferenceImageUrlChange, }: {
+    duration: string;
+    resolution: string;
+    aspectRatio: string;
+    referenceImageUrl: string;
+    onDurationChange: (value: string) => void;
+    onResolutionChange: (value: string) => void;
+    onAspectRatioChange: (value: string) => void;
+    onReferenceImageUrlChange: (value: string) => void;
+}): react.JSX.Element;
+
+declare function SpeechComposer({ voice, onVoiceChange, }: {
+    voice: string;
+    onVoiceChange: (value: string) => void;
+}): react.JSX.Element;
+
+declare function AvatarComposer({ audioUrl, imageUrl, avatarId, onAudioUrlChange, onImageUrlChange, onAvatarIdChange, }: {
+    audioUrl: string;
+    imageUrl: string;
+    avatarId: string;
+    onAudioUrlChange: (value: string) => void;
+    onImageUrlChange: (value: string) => void;
+    onAvatarIdChange: (value: string) => void;
+}): react.JSX.Element;
+
+declare function TranscriptionComposer({ audioUrl, language, onAudioUrlChange, onLanguageChange, }: {
+    audioUrl: string;
+    language: string;
+    onAudioUrlChange: (value: string) => void;
+    onLanguageChange: (value: string) => void;
+}): react.JSX.Element;
+declare function TranscriptionOptions({ responseFormat, temperature, onResponseFormatChange, onTemperatureChange, }: {
+    responseFormat: string;
+    temperature: string;
+    onResponseFormatChange: (value: string) => void;
+    onTemperatureChange: (value: string) => void;
+}): react.JSX.Element;
+
+export { AvatarComposer, ComposerDisclosure, ComposerHero, Field, GenerationCard, GenerationDetail, GenerationStatusBadge, ImageComposer, LibraryDrawer, NativeSelect, PublishPackageComposer, ResultCanvas, SpeechComposer, StudioHeader, type StudioRole, StudioSheet, StudioWorkspace, type StudioWorkspaceProps, TYPE_CONFIG, TranscriptionComposer, TranscriptionOptions, type TypeConfig, VideoComposer, typeConfigFor, useStudioGenerations };