dsh-webui-studio 0.1.0 → 0.2.0

package/lib/host/automatic-patch.js

@@ -0,0 +1,433 @@
+import { createHash } from 'node:crypto';
+import { unlink } from 'node:fs/promises';
+import { basename, dirname, extname, join, posix } from 'node:path';
+import ts from 'typescript';
+import { readProjectFile, writeProjectFile } from './project-files.js';
+import { compileElementStyleSelector } from '../bridge/element-style-selector.js';
+function digest(value, length = 12) {
+    return createHash('sha256').update(JSON.stringify(value)).digest('hex').slice(0, length);
+}
+function identifier(value) {
+    const result = value.replace(/[^a-z0-9]+/gi, '-').replace(/^-|-$/g, '').toLowerCase();
+    return result === '' ? 'target' : result.slice(0, 32);
+}
+function excerpt(source, start, end) {
+    const lineStart = source.lastIndexOf('\n', start - 1) + 1;
+    const nextLine = source.indexOf('\n', end);
+    const lineEnd = nextLine === -1 ? source.length : nextLine;
+    const value = source.slice(lineStart, lineEnd).trim();
+    return value.length <= 240 ? value : `${value.slice(0, 237)}...`;
+}
+function match(sourceFile, source, node, applicable, reason) {
+    const start = node.getStart(sourceFile);
+    const location = sourceFile.getLineAndCharacterOfPosition(start);
+    return {
+        line: location.line + 1,
+        column: location.character + 1,
+        excerpt: excerpt(source, start, node.getEnd()),
+        applicable,
+        ...(reason === undefined ? {} : { reason }),
+    };
+}
+function cssVariable(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const variable = value;
+    return typeof variable.id === 'string' && /^[A-Za-z_][A-Za-z0-9_-]*$/.test(variable.id)
+        && typeof variable.label === 'string' && variable.label !== ''
+        && typeof variable.property === 'string' && /^(?:--)?[a-zA-Z][a-zA-Z0-9-]*$/.test(variable.property)
+        && ['color', 'length', 'number', 'enum', 'string'].includes(variable.control ?? '')
+        && (typeof variable.value === 'string' || (typeof variable.value === 'number' && Number.isFinite(variable.value)))
+        && (variable.options === undefined || (Array.isArray(variable.options) && variable.options.length > 0 && variable.options.every(item => typeof item === 'string')))
+        && (variable.constraints === undefined || Object.values(variable.constraints).every(item => typeof item === 'number' && Number.isFinite(item)));
+}
+function validateCssRequest(request) {
+    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(request.component))
+        throw new Error('automatic CSS Patch component name is invalid');
+    if (!/\.(?:[cm]?[jt]sx?)$/.test(request.clientFile))
+        throw new Error('automatic CSS Patch client source must be a JavaScript or TypeScript file');
+    compileElementStyleSelector(request.selector, '[data-dsh-studio-root]');
+    if (request.boundary.surfaceId === '' || request.boundary.path.length === 0 || request.boundary.path.some(item => item === '')) {
+        throw new Error('automatic CSS Patch boundary is invalid');
+    }
+    if (request.targetSelector !== undefined
+        && (request.targetSelector.trim() === '' || request.targetSelector.length > 2_000 || /[{};]/.test(request.targetSelector))) {
+        throw new Error('automatic CSS Patch target selector is invalid');
+    }
+    if (!/^[A-Za-z_][A-Za-z0-9_-]*$/.test(request.elementId))
+        throw new Error('automatic CSS Patch element id is invalid');
+    if (request.elementLabel.trim() === '')
+        throw new Error('automatic CSS Patch element label must not be empty');
+    if (request.variables.length === 0)
+        throw new Error('automatic CSS Patch requires at least one variable');
+    const ids = new Set();
+    const properties = new Set();
+    for (const variable of request.variables) {
+        if (!cssVariable(variable))
+            throw new Error(`automatic CSS Patch variable ${JSON.stringify(variable.id)} is invalid`);
+        if (ids.has(variable.id))
+            throw new Error(`automatic CSS Patch variable ${JSON.stringify(variable.id)} is duplicated`);
+        if (properties.has(variable.property))
+            throw new Error(`automatic CSS Patch property ${JSON.stringify(variable.property)} is duplicated`);
+        ids.add(variable.id);
+        properties.add(variable.property);
+    }
+}
+function validateContentRequest(request) {
+    if (!/\.(?:[cm]?[jt]sx?)$/.test(request.clientFile))
+        throw new Error('automatic content Patch client source must be a JavaScript or TypeScript file');
+    compileElementStyleSelector(request.selector, '[data-dsh-studio-root]');
+    if (request.boundary.surfaceId === '' || request.boundary.path.length === 0 || request.boundary.path.some(item => item === '')) {
+        throw new Error('automatic content Patch boundary is invalid');
+    }
+    if (request.targetSelector !== undefined
+        && (request.targetSelector.trim() === '' || request.targetSelector.length > 2_000 || /[{};]/.test(request.targetSelector))) {
+        throw new Error('automatic content Patch target selector is invalid');
+    }
+    if (!/^[A-Za-z_][A-Za-z0-9_-]*$/.test(request.elementId))
+        throw new Error('automatic content Patch element id is invalid');
+    if (request.elementLabel.trim() === '')
+        throw new Error('automatic content Patch element label must not be empty');
+}
+function analyzeTarget(request, target) {
+    const sourceFile = ts.createSourceFile(target.file, target.source, ts.ScriptTarget.Latest, true);
+    let matches;
+    if (request.kind === 'replace-string') {
+        matches = [];
+        const visit = (node) => {
+            if (ts.isStringLiteral(node) && node.text === request.text)
+                matches.push(match(sourceFile, target.source, node, true));
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+    }
+    else {
+        matches = [];
+        const visit = (node) => {
+            if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === request.component) {
+                matches.push(match(sourceFile, target.source, node, node.initializer !== undefined, node.initializer === undefined ? 'component variable declaration has no initializer' : undefined));
+            }
+            else if (ts.isFunctionDeclaration(node) && node.name?.text === request.component) {
+                matches.push(match(sourceFile, target.source, node, node.body !== undefined, node.body === undefined ? 'component function declaration has no body' : undefined));
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+    }
+    return { package: target.package, file: target.file, version: target.version, matches };
+}
+function patchId(request, target) {
+    return `auto-${request.kind === 'css-style' ? 'css' : 'replace'}-${identifier(target.package)}-${digest({ request, target: { package: target.package, file: target.file, version: target.version } })}`;
+}
+function stringPatch(request, target, id) {
+    return `  {
+    id: ${JSON.stringify(id)},
+    target: { package: ${JSON.stringify(target.package)}, version: ${JSON.stringify(target.version)}, file: ${JSON.stringify(target.file)} },
+    select: ${JSON.stringify(`StringLiteral[text=${JSON.stringify(request.text)}]`)},
+    expect: ${target.matches.length},
+    apply({ node, sourceFile, edit }) {
+      edit.overwrite(node.getStart(sourceFile), node.getEnd(), JSON.stringify(AUTO_CONTENT))
+    },
+  }`;
+}
+function cssPatch(request, target, id, owner) {
+    return `  component({
+    id: ${JSON.stringify(id)},
+    target: { package: ${JSON.stringify(target.package)}, version: ${JSON.stringify(target.version)}, file: ${JSON.stringify(target.file)} },
+    select: { name: ${JSON.stringify(request.component)} },
+    expect: ${target.matches.length},
+    operation: { kind: 'decorate', with: { module: ${JSON.stringify(owner)}, export: AUTO_EXPORT } },
+  })`;
+}
+function cssClientSource(request, owner, id, file, exportName) {
+    const definitions = request.variables.map(variable => `{
+      kind: 'variable', id: ${JSON.stringify(variable.id)}, label: ${JSON.stringify(variable.label)}, control: ${JSON.stringify(variable.control)},
+      ${variable.options === undefined ? '' : `options: ${JSON.stringify(variable.options)},`}
+      ${variable.constraints === undefined ? '' : `constraints: ${JSON.stringify(variable.constraints)},`}
+      defaultSource: { file: ${JSON.stringify(file)}, before: ${JSON.stringify(`  ${JSON.stringify(variable.id)}: /* dsh-studio-default:${id}:${variable.id} */ `)}, after: ${JSON.stringify(',\n')} },
+    }`).join(',\n');
+    const defaults = request.variables.map(variable => `  ${JSON.stringify(variable.id)}: /* dsh-studio-default:${id}:${variable.id} */ ${JSON.stringify(variable.value)},`).join('\n');
+    const properties = JSON.stringify(request.variables.map(item => ({ id: item.id, property: item.property })));
+    const root = `[data-ui-surface=${JSON.stringify(request.boundary.surfaceId)}][data-ui-surface-path=${JSON.stringify(JSON.stringify(request.boundary.path))}]`;
+    const selector = compileElementStyleSelector(request.selector, root);
+    return `import { registerStudioElement } from 'dsh-harmony-react/studio'
+
+const targetSelector = ${request.targetSelector === undefined ? 'undefined' : JSON.stringify(request.targetSelector)}
+const boundarySurface = ${JSON.stringify(request.boundary.surfaceId)}
+const boundaryPath = ${JSON.stringify(JSON.stringify(request.boundary.path))}
+const values = {
+${defaults}
+}
+const declarations = ${properties}
+let styleElement
+let targetObserver
+
+function markTargets() {
+  if (targetSelector === undefined) return
+  for (const element of document.querySelectorAll(targetSelector)) {
+    if (element.hasAttribute('data-ui-surface') || element.hasAttribute('data-ui-surface-path')) continue
+    element.setAttribute('data-ui-surface', boundarySurface)
+    element.setAttribute('data-ui-surface-path', boundaryPath)
+  }
+}
+
+function applyStyles() {
+  if (typeof document === 'undefined') return
+  markTargets()
+  if (styleElement === undefined) {
+    styleElement = document.createElement('style')
+    styleElement.dataset.plugin = ${JSON.stringify(owner)}
+    document.head.append(styleElement)
+  }
+  styleElement.textContent = ''
+  const sheet = styleElement.sheet
+  if (sheet === null) return
+  while (sheet.cssRules.length > 0) sheet.deleteRule(0)
+  const index = sheet.insertRule(${JSON.stringify(`${selector} {}`)}, 0)
+  const rule = sheet.cssRules[index]
+  if (!(rule instanceof CSSStyleRule)) return
+  for (const declaration of declarations) rule.style.setProperty(declaration.property, String(values[declaration.id]))
+}
+
+const bindings = Object.fromEntries(declarations.map(declaration => [declaration.id, {
+  get: () => values[declaration.id],
+  set: value => { values[declaration.id] = value; applyStyles() },
+}]))
+
+registerStudioElement({
+  owner: ${JSON.stringify(owner)},
+  element: {
+    id: ${JSON.stringify(request.elementId)}, label: ${JSON.stringify(request.elementLabel)},
+    boundary: ${JSON.stringify(request.boundary)}, source: { file: ${JSON.stringify(file)} },
+    variables: [{ kind: 'group', id: 'css', label: 'CSS', children: [
+${definitions}
+    ] }],
+  },
+  bindings,
+})
+applyStyles()
+if (targetSelector !== undefined) {
+  targetObserver = new MutationObserver(markTargets)
+  targetObserver.observe(document.documentElement, { childList: true, subtree: true })
+}
+
+export function ${exportName}(Original) {
+  return Original
+}
+`;
+}
+function contentClientSource(request, owner, id, providerFile, file, exportName) {
+    const root = `[data-ui-surface=${JSON.stringify(request.boundary.surfaceId)}][data-ui-surface-path=${JSON.stringify(JSON.stringify(request.boundary.path))}]`;
+    const selector = compileElementStyleSelector(request.selector, root);
+    const variableId = `text_${id.slice('auto-content-'.length)}`;
+    const groupId = `content_${id.slice('auto-content-'.length)}`;
+    const sourceFile = request.elementSourceFile ?? file;
+    return `import { registerStudioElement } from 'dsh-harmony-react/studio'
+
+const targetSelector = ${request.targetSelector === undefined ? 'undefined' : JSON.stringify(request.targetSelector)}
+const boundarySurface = ${JSON.stringify(request.boundary.surfaceId)}
+const boundaryPath = ${JSON.stringify(JSON.stringify(request.boundary.path))}
+let value = ${JSON.stringify(request.replacement)}
+let initialized = false
+const listeners = new Set()
+
+function notify() {
+  for (const listener of listeners) listener()
+}
+
+function markTargets() {
+  if (targetSelector === undefined) return
+  for (const element of document.querySelectorAll(targetSelector)) {
+    if (element.hasAttribute('data-ui-surface') || element.hasAttribute('data-ui-surface-path')) continue
+    element.setAttribute('data-ui-surface', boundarySurface)
+    element.setAttribute('data-ui-surface-path', boundaryPath)
+  }
+}
+
+function syncText() {
+  if (typeof document === 'undefined') return
+  markTargets()
+  const elements = [...document.querySelectorAll(${JSON.stringify(selector)})]
+  if (!initialized && elements[0] !== undefined) {
+    value = elements[0].textContent ?? value
+    initialized = true
+    notify()
+  }
+  for (const element of elements) if (element.textContent !== value) element.textContent = value
+}
+
+registerStudioElement({
+  owner: ${JSON.stringify(owner)},
+  element: {
+    id: ${JSON.stringify(request.elementId)}, label: ${JSON.stringify(request.elementLabel)},
+    boundary: ${JSON.stringify(request.boundary)}, source: { file: ${JSON.stringify(sourceFile)} },
+    variables: [{ kind: 'group', id: ${JSON.stringify(groupId)}, label: 'Content', children: [{
+      kind: 'variable', id: ${JSON.stringify(variableId)}, label: 'Text', control: 'string',
+      defaultSource: { file: ${JSON.stringify(providerFile)}, before: ${JSON.stringify(`const AUTO_CONTENT = /* dsh-studio-default:${id}:text */ `)}, after: ${JSON.stringify(';\n')} },
+    }] }],
+  },
+  bindings: { ${JSON.stringify(variableId)}: {
+    get: () => value,
+    set: next => { value = String(next); initialized = true; syncText(); notify() },
+    subscribe: listener => { listeners.add(listener); return () => listeners.delete(listener) },
+  } },
+})
+syncText()
+const observer = new MutationObserver(syncText)
+observer.observe(document.documentElement, { childList: true, subtree: true, characterData: true })
+
+export const ${exportName} = true
+`;
+}
+function providerSource(request, targets, owner, defaultId) {
+    const applicable = targets.filter(target => target.matches.length > 0 && target.matches.every(item => item.applicable));
+    const patchIds = applicable.map(target => patchId(request, target));
+    const declarations = applicable.map((target, index) => request.kind === 'replace-string'
+        ? stringPatch(request, target, patchIds[index])
+        : cssPatch(request, target, patchIds[index], owner)).join(',\n');
+    const prefix = request.kind === 'css-style'
+        ? `'use strict'\n\nconst { component } = require('dsh-harmony-react')\nconst AUTO_EXPORT = ${JSON.stringify(`DshStudioAuto${digest(request, 10)}`)}\n\n`
+        : `'use strict'\n\nconst AUTO_CONTENT = /* dsh-studio-default:${defaultId}:text */ ${JSON.stringify(request.replacement)};\n\n`;
+    return { patchIds, source: `${prefix}module.exports = [\n${declarations}\n]\n` };
+}
+export function analyzeAutomaticPatch(request, sources, owner) {
+    if (request.kind === 'replace-string' && request.text === '')
+        throw new Error('automatic string Patch text must not be empty');
+    if (request.targets.length === 0)
+        throw new Error('automatic Patch requires at least one target');
+    if (request.targets.length !== sources.length)
+        throw new Error('automatic Patch target sources are incomplete');
+    if (request.kind === 'css-style')
+        validateCssRequest(request);
+    else
+        validateContentRequest(request);
+    const identities = request.targets.map(target => `${target.package}\0${target.file}`);
+    if (new Set(identities).size !== identities.length)
+        throw new Error('automatic Patch targets must be unique');
+    for (let index = 0; index < sources.length; index += 1) {
+        const target = request.targets[index];
+        const source = sources[index];
+        if (source.package !== target.package || source.file !== target.file)
+            throw new Error('automatic Patch source does not match its requested target');
+    }
+    const targets = sources.map(source => analyzeTarget(request, source));
+    const file = `patch.auto-${digest({ request, owner, versions: targets.map(target => target.version) })}.cjs`;
+    const suffix = digest({ request, owner }, 10);
+    const defaultId = `auto-${request.kind === 'css-style' ? 'css' : 'content'}-${suffix}`;
+    const generated = providerSource(request, targets, owner, defaultId);
+    const extension = extname(request.clientFile);
+    const stem = basename(request.clientFile, extension);
+    const generatedFile = posix.join(dirname(request.clientFile).split('\\').join('/'), `${stem}.dsh-studio-auto-${suffix}.js`);
+    const elementId = request.kind === 'replace-string' && request.elementSourceFile !== undefined
+        ? request.elementId : `${request.elementId}-${suffix}`;
+    const client = request.kind === 'css-style'
+        ? {
+            file: generatedFile,
+            source: cssClientSource({ ...request, elementId }, owner, defaultId, generatedFile, `DshStudioAuto${digest(request, 10)}`),
+            export: `DshStudioAuto${digest(request, 10)}`,
+            entryFile: request.clientFile,
+        }
+        : {
+            file: generatedFile,
+            source: contentClientSource({ ...request, elementId }, owner, defaultId, file, generatedFile, `DshStudioContent${digest(request, 10)}`),
+            export: `DshStudioContent${digest(request, 10)}`,
+            entryFile: request.clientFile,
+        };
+    return {
+        request,
+        targets,
+        canApply: generated.patchIds.length > 0,
+        provider: { file, source: generated.source, patchIds: generated.patchIds },
+        client,
+    };
+}
+export async function writeAutomaticPatch(root, plan) {
+    if (!plan.canApply || plan.provider.patchIds.length === 0)
+        throw new Error('automatic Patch has no matches to apply');
+    try {
+        await readProjectFile(root, plan.provider.file);
+        throw new Error(`automatic Patch provider ${JSON.stringify(plan.provider.file)} already exists`);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    const manifestSource = await readProjectFile(root, 'package.json');
+    const manifest = JSON.parse(manifestSource);
+    const current = manifest.dsh?.harmony?.patches;
+    if (!Array.isArray(current) || current.some(value => typeof value !== 'string'))
+        throw new Error('Draft package.json must declare dsh.harmony.patches as an array of file paths');
+    const declaration = `./${plan.provider.file}`;
+    if (current.includes(declaration))
+        throw new Error('automatic Patch provider is already declared');
+    let clientEntrySource;
+    let clientEntryNext;
+    if (plan.client !== undefined) {
+        clientEntrySource = await readProjectFile(root, plan.client.entryFile);
+        if (clientEntrySource.includes('__ModuleLoader__.load')) {
+            throw new Error('automatic Component Patch requires the Draft client source before it is bundled');
+        }
+        const relative = posix.relative(posix.dirname(plan.client.entryFile), plan.client.file);
+        const specifier = relative.startsWith('.') ? relative : `./${relative}`;
+        const reexport = `export { ${plan.client.export} } from ${JSON.stringify(specifier)}`;
+        if (clientEntrySource.includes(reexport))
+            throw new Error('automatic Patch client export is already declared');
+        clientEntryNext = `${clientEntrySource.trimEnd()}\n\n${reexport}\n`;
+    }
+    const nextManifest = {
+        ...manifest,
+        dependencies: plan.client === undefined ? manifest.dependencies : { ...manifest.dependencies, 'dsh-harmony-react': '^0.3.0' },
+        devDependencies: plan.request.kind !== 'css-style' || manifest.devDependencies?.tsdown !== '0.22.14'
+            || manifest.dependencies?.['@tsdown/css'] !== undefined || manifest.devDependencies['@tsdown/css'] !== undefined
+            ? manifest.devDependencies
+            : { ...manifest.devDependencies, '@tsdown/css': manifest.devDependencies.tsdown },
+        dsh: {
+            ...manifest.dsh,
+            ...(plan.client === undefined ? {} : { client: { ...manifest.dsh?.client, immediately: true } }),
+            harmony: { ...manifest.dsh?.harmony, patches: [...current, declaration] },
+        },
+    };
+    const writes = [
+        { file: plan.provider.file, content: plan.provider.source, created: true },
+        ...(plan.client === undefined ? [] : [
+            { file: plan.client.file, content: plan.client.source, created: true },
+            { file: plan.client.entryFile, content: clientEntryNext, original: clientEntrySource, created: false },
+        ]),
+        { file: 'package.json', content: `${JSON.stringify(nextManifest, null, 2)}\n`, original: manifestSource, created: false },
+    ];
+    const written = [];
+    try {
+        for (const write of writes) {
+            if (write.created) {
+                try {
+                    await readProjectFile(root, write.file);
+                    throw new Error(`automatic Patch file ${JSON.stringify(write.file)} already exists`);
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        throw error;
+                }
+            }
+            await writeProjectFile(root, write.file, write.content);
+            written.push(write);
+        }
+    }
+    catch (error) {
+        const rollbackErrors = [];
+        for (const write of written.reverse()) {
+            try {
+                if (write.created)
+                    await unlink(join(root, write.file));
+                else
+                    await writeProjectFile(root, write.file, write.original);
+            }
+            catch (rollbackError) {
+                rollbackErrors.push(rollbackError);
+            }
+        }
+        if (rollbackErrors.length > 0)
+            throw new AggregateError([error, ...rollbackErrors], 'automatic Patch write rollback failed');
+        throw error;
+    }
+    return { ...plan, files: writes.map(item => item.file) };
+}

package/lib/host/backend.d.ts

@@ -1,6 +1,6 @@
 import type { AgentRegistry } from '@deepseek-ai/dsh-agent';
 import type { SubprocessRuntime } from '@deepseek-ai/dsh-subprocess';
-import type { StudioClientRequest, StudioHarmonyService, StudioServerResponse } from '../contracts.js';
+import type { StudioBuildResult, StudioAgentBinding, StudioAgentContext, StudioAutomaticPatchPlan, StudioAutomaticPatchRequest, StudioAutomaticPatchWriteResult, StudioCreateDraftInput, StudioCurrentInstanceView, StudioDraftView, StudioHarmonyInspection, StudioHarmonyProfile, StudioHarmonyProfileUpdateResult, StudioHarmonyService, StudioElementStyleSource, StudioPreviewStatus, StudioPreviewUpdate, StudioProjectFile, StudioProjectState, StudioReadinessReport, StudioSourceLocation, StudioWorkspaceState } from '../contracts.js';
 import type { StudioCommandRunner, StudioDraftRegistry } from './drafts.js';
 import type { StudioWorkspaceStore } from './workspace.js';
 /** Stable-Host control plane for persistent, isolated Draft Preview runtimes. */
@@ -14,12 +14,142 @@ export declare class StudioBackend {
     private readonly parentOrigin;
     private readonly controllers;
     private readonly controllerCreations;
-    constructor(harmony: StudioHarmonyService, agents: AgentRegistry, subprocess: SubprocessRuntime, registry: StudioDraftRegistry, workspace: StudioWorkspaceStore, commands: StudioCommandRunner, parentOrigin: string);
-    call(message: StudioClientRequest): Promise<StudioServerResponse>;
+    private readonly current;
+    constructor(harmony: StudioHarmonyService, agents: AgentRegistry, subprocess: SubprocessRuntime, registry: StudioDraftRegistry, workspace: StudioWorkspaceStore, commands: StudioCommandRunner, parentOrigin: string, currentBridgeCapability?: string);
+    currentGet(): StudioCurrentInstanceView;
+    currentPreviewStatus(): StudioPreviewStatus;
+    currentProjectState(): StudioProjectState;
+    currentContext(): Promise<StudioAgentContext>;
+    currentHarmonyProfile(): Promise<import("dsh-harmony").HarmonyProfileView>;
+    currentHarmonyInspect(input: {
+        package?: string;
+        file?: string;
+    }): Promise<StudioHarmonyInspection>;
+    currentReadDependencySource(input: {
+        package: string;
+        file: string;
+    }): Promise<string>;
+    currentPreviewUpdate(input: StudioPreviewUpdate): StudioPreviewStatus;
+    currentResolveSource(input: {
+        source: StudioSourceLocation;
+    }): Promise<import("../contracts.js").StudioSourceCandidate>;
+    currentAgentCreate(input: {
+        agentPreset?: string;
+    }): Promise<StudioAgentBinding>;
+    currentAgentAttach(input: {
+        sessionId: string;
+    }): Promise<StudioAgentBinding>;
+    currentAgentLeave(): Promise<StudioCurrentInstanceView>;
+    draftsList(): Promise<StudioDraftView[]>;
+    draftsCreate(input: StudioCreateDraftInput): Promise<StudioDraftView>;
+    workspaceGet(): Promise<StudioWorkspaceState>;
+    workspaceUpdate(input: StudioWorkspaceState): Promise<StudioWorkspaceState>;
+    harmonyProfile(input: {
+        draftId: string;
+    }): Promise<StudioHarmonyProfile>;
+    harmonyInspect(input: {
+        draftId: string;
+        package?: string;
+        file?: string;
+    }): Promise<StudioHarmonyInspection>;
+    harmonyUpdateProfile(input: {
+        draftId: string;
+        order?: string[];
+        patchOrder?: string[];
+        disabled?: string[];
+    }): Promise<StudioHarmonyProfileUpdateResult>;
+    draftsRename(input: {
+        draftId: string;
+        label: string;
+    }): Promise<StudioDraftView>;
+    draftsExport(input: {
+        draftId: string;
+    }): Promise<StudioDraftView>;
+    draftsStart(input: {
+        draftId: string;
+    }): Promise<StudioDraftView>;
+    draftsStop(input: {
+        draftId: string;
+    }): Promise<StudioDraftView>;
+    projectState(input: {
+        draftId: string;
+    }): Promise<StudioProjectState>;
+    projectActivate(input: {
+        draftId: string;
+        graphRev: string;
+    }): Promise<StudioProjectState>;
+    projectFiles(input: {
+        draftId: string;
+    }): Promise<StudioProjectFile[]>;
+    projectReadFile(input: {
+        draftId: string;
+        path: string;
+    }): Promise<{
+        path: string;
+        content: string;
+    }>;
+    projectWriteFile(input: {
+        draftId: string;
+        path: string;
+        content: string;
+    }): Promise<{
+        path: string;
+        saved: true;
+    }>;
+    elementsStyles(input: {
+        draftId: string;
+    }): Promise<StudioElementStyleSource[]>;
+    elementsSaveSource(input: {
+        draftId: string;
+        styles: StudioElementStyleSource[];
+    }): Promise<{
+        files: string[];
+    }>;
+    patchesAnalyzeAutomatic(input: StudioAutomaticPatchRequest & {
+        draftId: string;
+    }): Promise<StudioAutomaticPatchPlan>;
+    patchesCreateAutomatic(input: StudioAutomaticPatchRequest & {
+        draftId: string;
+    }): Promise<StudioAutomaticPatchWriteResult>;
+    projectBuild(input: {
+        draftId: string;
+    }, signal: AbortSignal): Promise<StudioBuildResult>;
+    projectCancelBuild(input: {
+        draftId: string;
+    }): Promise<{
+        canceled: boolean;
+    }>;
+    readinessInspect(input: {
+        draftId: string;
+    }): Promise<StudioReadinessReport>;
+    readinessPack(input: {
+        draftId: string;
+    }): Promise<StudioReadinessReport>;
+    previewStatus(input: {
+        draftId: string;
+    }): Promise<StudioPreviewStatus>;
+    previewUpdate(input: StudioPreviewUpdate & {
+        draftId: string;
+    }): Promise<StudioPreviewStatus>;
+    previewResolveSource(input: {
+        draftId: string;
+        source: StudioSourceLocation;
+    }): Promise<import("../contracts.js").StudioSourceCandidate>;
+    agentCreate(input: {
+        draftId: string;
+        agentPreset?: string;
+    }): Promise<StudioAgentBinding>;
+    agentAttach(input: {
+        draftId: string;
+        sessionId: string;
+    }): Promise<StudioAgentBinding>;
+    agentLeave(input: {
+        draftId: string;
+    }): Promise<StudioDraftView>;
     dispose(): Promise<void>;
     private list;
     private create;
     private controller;
     private makeController;
-    private previewStatus;
+    private parsePreviewStatus;
 }