dsh-webui-studio 0.1.0 → 0.2.0

package/lib/host/backend.js

@@ -1,15 +1,14 @@
+import { fileURLToPath } from 'node:url';
 import { StudioAgentController } from './agent.js';
-import { StudioBuildError, StudioBuildRunner } from './build.js';
-import { StudioPreviewSupervisor } from './preview.js';
+import { analyzeAutomaticPatch, writeAutomaticPatch } from './automatic-patch.js';
+import { StudioBuildRunner } from './build.js';
+import { readElementsStyles, saveElementsSource } from './element-source.js';
+import { dshPackageModules, StudioPreviewSupervisor } from './preview.js';
 import { applyProjectPatch, listProjectFiles, readProjectFile, writeProjectFile } from './project-files.js';
 import { inspectReadiness, StudioPackRunner } from './readiness.js';
-import { assertDraftPackageIdentity } from './runtime-profile.js';
-function failure(rpcId, code, message, details = {}) {
-    return { type: 'server-response', rpcId, result: { ok: false, error: { code, message, details } } };
-}
-function success(rpcId, value) {
-    return { type: 'server-response', rpcId, result: { ok: true, value } };
-}
+import { assertDraftPackageIdentity, installDraftDependencies } from './runtime-profile.js';
+import { StudioSourceResolver } from './source-resolution.js';
+const HARMONY_BIN_ENTRY = fileURLToPath(import.meta.resolve('dsh-harmony/bin'));
 function objectPayload(payload) {
     if (typeof payload !== 'object' || payload === null)
         throw new Error('request payload must be an object');
@@ -21,16 +20,104 @@ function draftId(payload) {
         throw new Error('draftId is required');
     return id;
 }
+function optionalStringList(value, field) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.some(item => typeof item !== 'string' || item.length === 0)) {
+        throw new Error(`${field} must be an array of non-empty strings`);
+    }
+    return value;
+}
+function automaticPatchRequest(payload) {
+    const input = objectPayload(payload);
+    if (!Array.isArray(input.targets) || input.targets.length === 0) {
+        throw new Error('automatic Patch targets must be a non-empty array');
+    }
+    const targets = input.targets.map((value, index) => {
+        if (typeof value !== 'object' || value === null)
+            throw new Error(`automatic Patch target ${index} must be an object`);
+        const target = value;
+        if (typeof target.package !== 'string' || target.package === '' || typeof target.file !== 'string' || target.file === '') {
+            throw new Error(`automatic Patch target ${index} requires package and file`);
+        }
+        return { package: target.package, file: target.file };
+    });
+    if (input.kind === 'replace-string') {
+        if (typeof input.text !== 'string' || typeof input.replacement !== 'string' || typeof input.clientFile !== 'string'
+            || typeof input.selector !== 'string' || typeof input.elementId !== 'string' || typeof input.elementLabel !== 'string'
+            || typeof input.boundary !== 'object' || input.boundary === null || !Array.isArray(input.boundary.path)) {
+            throw new Error('automatic content Patch requires text, replacement, client source, boundary, selector, and element identity');
+        }
+        const boundary = input.boundary;
+        if (typeof boundary.surfaceId !== 'string' || !boundary.path.every(item => typeof item === 'string')) {
+            throw new Error('automatic content Patch boundary is invalid');
+        }
+        if (input.targetSelector !== undefined && (typeof input.targetSelector !== 'string' || input.targetSelector === '')) {
+            throw new Error('automatic content Patch target selector is invalid');
+        }
+        if (input.elementSourceFile !== undefined && (typeof input.elementSourceFile !== 'string' || input.elementSourceFile === '')) {
+            throw new Error('automatic content Patch Element source is invalid');
+        }
+        return {
+            kind: input.kind, targets, text: input.text, replacement: input.replacement, clientFile: input.clientFile,
+            boundary: { surfaceId: boundary.surfaceId, path: boundary.path },
+            ...(input.targetSelector === undefined ? {} : { targetSelector: input.targetSelector }),
+            selector: input.selector, elementId: input.elementId, elementLabel: input.elementLabel,
+            ...(input.elementSourceFile === undefined ? {} : { elementSourceFile: input.elementSourceFile }),
+        };
+    }
+    if (input.kind !== 'css-style' || typeof input.component !== 'string' || typeof input.clientFile !== 'string'
+        || typeof input.selector !== 'string' || typeof input.elementId !== 'string' || typeof input.elementLabel !== 'string'
+        || typeof input.boundary !== 'object' || input.boundary === null || !Array.isArray(input.boundary.path)
+        || !Array.isArray(input.variables))
+        throw new Error('automatic CSS Patch requires component, client source, boundary, selector, element identity, and variables');
+    const boundary = input.boundary;
+    if (typeof boundary.surfaceId !== 'string' || !boundary.path.every(item => typeof item === 'string')) {
+        throw new Error('automatic CSS Patch boundary is invalid');
+    }
+    if (input.targetSelector !== undefined && (typeof input.targetSelector !== 'string' || input.targetSelector === '')) {
+        throw new Error('automatic CSS Patch target selector is invalid');
+    }
+    return {
+        kind: input.kind,
+        targets,
+        component: input.component,
+        clientFile: input.clientFile,
+        boundary: { surfaceId: boundary.surfaceId, path: boundary.path },
+        ...(input.targetSelector === undefined ? {} : { targetSelector: input.targetSelector }),
+        selector: input.selector,
+        elementId: input.elementId,
+        elementLabel: input.elementLabel,
+        variables: input.variables,
+    };
+}
+function elementStyleSources(payload) {
+    const value = objectPayload(payload).styles;
+    if (!Array.isArray(value))
+        throw new Error('styles must be an array');
+    return value.map((entry, index) => {
+        if (typeof entry !== 'object' || entry === null)
+            throw new Error(`styles[${index}] must be an object`);
+        const input = entry;
+        if (typeof input.elementId !== 'string' || !Array.isArray(input.rules))
+            throw new Error(`styles[${index}] requires elementId and rules`);
+        return { elementId: input.elementId, rules: input.rules };
+    });
+}
 class StudioDraftController {
     record;
+    commands;
+    kind = 'draft';
     projectState;
     previewState = { connected: false, mode: 'browse' };
     builds;
     packs;
     agent;
+    automaticPatchWrites = Promise.resolve();
     preview;
     constructor(record, profileDir, parentOrigin, commands, harmonyBinEntry, agents, subprocess) {
         this.record = record;
+        this.commands = commands;
         this.preview = new StudioPreviewSupervisor(record, profileDir, parentOrigin, commands, harmonyBinEntry);
         this.builds = new StudioBuildRunner(subprocess);
         this.packs = new StudioPackRunner(subprocess);
@@ -51,7 +138,7 @@ class StudioDraftController {
         return this.view();
     }
     async stop() {
-        await this.agent.dispose();
+        await this.agent.leave();
         await this.builds.cancel();
         await this.preview.stop();
         this.projectState = undefined;
@@ -59,7 +146,7 @@ class StudioDraftController {
         return this.view();
     }
     async dispose() {
-        await this.agent.dispose();
+        await this.agent.leave();
         await this.builds.dispose();
         await this.packs.dispose();
         await this.preview.dispose();
@@ -80,6 +167,42 @@ class StudioDraftController {
     selection() {
         return this.previewState.selection;
     }
+    async context() {
+        const selection = this.selection();
+        const refs = new Map();
+        for (const patch of selection?.react?.patches ?? []) {
+            const key = `${patch.target.package}\0${patch.target.file}`;
+            refs.set(key, patch.target);
+        }
+        const source = selection?.react?.source?.resolved;
+        if (source?.package !== undefined) {
+            const key = `${source.package}\0${source.file}`;
+            refs.set(key, { package: source.package, file: source.file });
+        }
+        const allTargetRefs = [...refs.values()];
+        const targetRefs = allTargetRefs.slice(0, 8);
+        const inspections = await Promise.all(targetRefs.map(ref => this.inspectHarmony(ref)));
+        const inspectedHarmony = inspections.length === 0 ? null : {
+            patches: [...new Map(inspections.flatMap(item => item.patches).map(patch => [patch.key, patch])).values()],
+            targets: [...new Map(inspections.flatMap(item => item.targets).map(target => [`${target.package}\0${target.file}`, target])).values()],
+        };
+        const harmony = inspectedHarmony !== null && Buffer.byteLength(JSON.stringify(inspectedHarmony)) <= 256 * 1024
+            ? inspectedHarmony : null;
+        const readiness = await this.readiness();
+        return {
+            target: 'draft',
+            readOnly: false,
+            selection: selection ?? null,
+            project: this.project(),
+            preview: this.previewStatus(),
+            projectFiles: await listProjectFiles(this.record.root),
+            profile: await this.harmonyProfile(),
+            harmony,
+            targetRefs,
+            targetRefsTruncated: targetRefs.length < allTargetRefs.length,
+            readiness: { findings: readiness.findings },
+        };
+    }
     updatePreview(update) {
         const next = { ...this.previewState, ...update };
         if (next.selection === null)
@@ -101,9 +224,18 @@ class StudioDraftController {
     async inspectHarmony(input) {
         return (await this.preview.inspect(input)).harmony;
     }
+    harmonyProfile() {
+        return this.preview.profile();
+    }
+    profile() {
+        return this.preview.profile();
+    }
+    updateProfile(input) {
+        return this.preview.updateProfile(input);
+    }
     async readiness() {
         const inspection = await this.preview.inspect();
-        return inspectReadiness(this.record.root, this.record.name, inspection.harmony, `${this.record.runtimeHome}/profiles/web`, inspection.dependencies);
+        return inspectReadiness(this.record.root, this.record.name, inspection.harmony, `${this.record.runtimeHome}/profiles/web`);
     }
     async pack() {
         const report = await this.readiness();
@@ -116,6 +248,33 @@ class StudioDraftController {
     async applyPatch(path, before, after) {
         return applyProjectPatch(this.record.root, path, before, after);
     }
+    draftElements() {
+        const elements = this.previewStatus().registry?.elements.filter(item => item.owner === this.record.name) ?? [];
+        if (elements.length === 0)
+            throw new Error('No Elements are registered by the active Draft');
+        return elements;
+    }
+    async readElementStyles() {
+        return readElementsStyles(this.record.root, this.draftElements());
+    }
+    async saveElementSource(styles) {
+        return saveElementsSource(this.record.root, this.draftElements(), styles);
+    }
+    async analyzeAutomaticPatch(request) {
+        const sources = await Promise.all(request.targets.map(target => this.preview.readPatchTarget(target.package, target.file)));
+        return analyzeAutomaticPatch(request, sources, this.record.name);
+    }
+    async createAutomaticPatch(request) {
+        const run = this.automaticPatchWrites.then(async () => {
+            const plan = await this.analyzeAutomaticPatch(request);
+            const result = await writeAutomaticPatch(this.record.root, plan);
+            if (plan.client !== undefined)
+                await installDraftDependencies(this.record, this.commands);
+            return result;
+        });
+        this.automaticPatchWrites = run.then(() => undefined, () => undefined);
+        return run;
+    }
     async build(signal) {
         const current = this.project();
         if (current.state !== 'active')
@@ -131,8 +290,118 @@ class StudioDraftController {
     createAgent(agentPreset) {
         return this.agent.create(agentPreset);
     }
-    async disposeAgent() {
-        await this.agent.dispose();
+    attachAgent(sessionId) {
+        return this.agent.attach(sessionId);
+    }
+    async leaveAgent() {
+        await this.agent.leave();
+        return this.view();
+    }
+}
+class StudioCurrentInstanceController {
+    harmony;
+    previewUrl;
+    bridgeCapability;
+    kind = 'current-instance';
+    previewState = { connected: false, mode: 'browse' };
+    agent;
+    sources;
+    constructor(harmony, agents, previewUrl, bridgeCapability) {
+        this.harmony = harmony;
+        this.previewUrl = previewUrl;
+        this.bridgeCapability = bridgeCapability;
+        this.agent = new StudioAgentController(agents, this);
+        const profileDir = harmony.profile().dir;
+        this.sources = new StudioSourceResolver(undefined, profileDir, [dshPackageModules(HARMONY_BIN_ENTRY)]);
+    }
+    view() {
+        const agent = this.agent.snapshot();
+        return {
+            previewUrl: this.previewUrl,
+            bridgeCapability: this.bridgeCapability,
+            ...(agent === undefined ? {} : { agent }),
+        };
+    }
+    project() {
+        const profile = this.harmony.profile();
+        return {
+            name: 'current-webui',
+            root: profile.dir,
+            state: 'active',
+            graphRev: this.previewState.graphRev ?? String(profile.revision),
+        };
+    }
+    selection() {
+        return this.previewState.selection;
+    }
+    previewStatus() {
+        return this.previewState;
+    }
+    updatePreview(update) {
+        const next = { ...this.previewState, ...update };
+        if (next.selection === null)
+            delete next.selection;
+        if (next.registry === null)
+            delete next.registry;
+        this.previewState = next;
+        return this.previewState;
+    }
+    resolveSource(source) {
+        return this.sources.resolve(source);
+    }
+    harmonyProfile() {
+        return Promise.resolve(this.harmony.profile());
+    }
+    inspectHarmony(input) {
+        return Promise.resolve(this.harmony.inspect(input));
+    }
+    readDependencySource(packageName, file) {
+        return this.sources.readDependency(packageName, file);
+    }
+    async context() {
+        const selection = this.selection();
+        const refs = new Map();
+        for (const patch of selection?.react?.patches ?? []) {
+            refs.set(`${patch.target.package}\0${patch.target.file}`, patch.target);
+        }
+        const source = selection?.react?.source?.resolved;
+        if (source?.package !== undefined)
+            refs.set(`${source.package}\0${source.file}`, { package: source.package, file: source.file });
+        const allTargetRefs = [...refs.values()];
+        const targetRefs = allTargetRefs.slice(0, 8);
+        const inspections = await Promise.all(targetRefs.map(ref => this.inspectHarmony(ref)));
+        const inspectedHarmony = inspections.length === 0 ? null : {
+            patches: [...new Map(inspections.flatMap(item => item.patches).map(patch => [patch.key, patch])).values()],
+            targets: [...new Map(inspections.flatMap(item => item.targets).map(target => [`${target.package}\0${target.file}`, target])).values()],
+        };
+        const harmony = inspectedHarmony !== null && Buffer.byteLength(JSON.stringify(inspectedHarmony)) <= 256 * 1024
+            ? inspectedHarmony : null;
+        return {
+            target: 'current-instance',
+            readOnly: true,
+            selection: selection ?? null,
+            project: this.project(),
+            preview: this.previewStatus(),
+            projectFiles: [],
+            profile: this.harmony.profile(),
+            harmony,
+            targetRefs,
+            targetRefsTruncated: targetRefs.length < allTargetRefs.length,
+            readiness: { findings: [] },
+        };
+    }
+    createAgent(agentPreset) {
+        return this.agent.create(agentPreset);
+    }
+    attachAgent(sessionId) {
+        return this.agent.attach(sessionId);
+    }
+    async leaveAgent() {
+        await this.agent.leave();
+        return this.view();
+    }
+    dispose() {
+        return this.agent.leave();
     }
 }
 /** Stable-Host control plane for persistent, isolated Draft Preview runtimes. */
@@ -146,7 +415,8 @@ export class StudioBackend {
     parentOrigin;
     controllers = new Map();
     controllerCreations = new Map();
-    constructor(harmony, agents, subprocess, registry, workspace, commands, parentOrigin) {
+    current;
+    constructor(harmony, agents, subprocess, registry, workspace, commands, parentOrigin, currentBridgeCapability = 'current-instance') {
         this.harmony = harmony;
         this.agents = agents;
         this.subprocess = subprocess;
@@ -154,109 +424,189 @@ export class StudioBackend {
         this.workspace = workspace;
         this.commands = commands;
         this.parentOrigin = parentOrigin;
+        this.current = new StudioCurrentInstanceController(harmony, agents, `${parentOrigin}/#dsh-studio-preview=${encodeURIComponent(currentBridgeCapability)}`, currentBridgeCapability);
     }
-    async call(message) {
-        const { method, payload, rpcId } = message;
-        try {
-            if (method === 'studio.drafts.list')
-                return success(rpcId, await this.list());
-            if (method === 'studio.drafts.create')
-                return success(rpcId, await this.create(payload));
-            if (method === 'studio.workspace.get') {
-                const records = await this.registry.list();
-                return success(rpcId, await this.workspace.read(records.map(record => record.id)));
-            }
-            if (method === 'studio.workspace.update') {
-                const records = await this.registry.list();
-                return success(rpcId, await this.workspace.write(objectPayload(payload), records.map(record => record.id)));
-            }
-            const controller = await this.controller(draftId(payload));
-            if (method === 'studio.drafts.rename') {
-                const label = objectPayload(payload).label;
-                if (typeof label !== 'string')
-                    throw new Error('Draft name is required');
-                const record = await this.registry.rename(controller.record.id, label);
-                controller.record = record;
-                return success(rpcId, controller.view());
-            }
-            if (method === 'studio.drafts.export') {
-                const record = await this.registry.export(controller.record.id);
-                controller.record = record;
-                return success(rpcId, controller.view());
-            }
-            if (method === 'studio.drafts.start')
-                return success(rpcId, await controller.start());
-            if (method === 'studio.drafts.stop')
-                return success(rpcId, await controller.stop());
-            if (method === 'studio.project.state')
-                return success(rpcId, await controller.refreshProject());
-            if (method === 'studio.project.activate') {
-                const graphRev = objectPayload(payload).graphRev;
-                if (typeof graphRev !== 'string')
-                    throw new Error('graphRev is required');
-                return success(rpcId, await controller.activate(graphRev));
-            }
-            if (method === 'studio.project.files')
-                return success(rpcId, await listProjectFiles(controller.record.root));
-            if (method === 'studio.project.readFile') {
-                const path = objectPayload(payload).path;
-                if (typeof path !== 'string')
-                    throw new Error('path is required');
-                return success(rpcId, { path, content: await controller.readFile(path) });
-            }
-            if (method === 'studio.project.writeFile') {
-                const { path, content } = objectPayload(payload);
-                if (typeof path !== 'string' || typeof content !== 'string')
-                    throw new Error('path and content are required');
-                await writeProjectFile(controller.record.root, path, content);
-                return success(rpcId, { path, saved: true });
-            }
-            if (method === 'studio.project.build')
-                return success(rpcId, await controller.build(new AbortController().signal));
-            if (method === 'studio.project.cancelBuild')
-                return success(rpcId, { canceled: await controller.cancelBuild() });
-            if (method === 'studio.readiness.inspect')
-                return success(rpcId, await controller.readiness());
-            if (method === 'studio.readiness.pack')
-                return success(rpcId, await controller.pack());
-            if (method === 'studio.harmony.inspect') {
-                const input = objectPayload(payload);
-                return success(rpcId, await controller.inspectHarmony({
-                    ...(typeof input.package === 'string' ? { package: input.package } : {}),
-                    ...(typeof input.file === 'string' ? { file: input.file } : {}),
-                }));
-            }
-            if (method === 'studio.preview.status')
-                return success(rpcId, controller.previewStatus());
-            if (method === 'studio.preview.update')
-                return success(rpcId, controller.updatePreview(this.previewStatus(payload)));
-            if (method === 'studio.preview.resolveSource') {
-                const source = objectPayload(payload).source;
-                if (typeof source?.file !== 'string')
-                    throw new Error('source is required');
-                return success(rpcId, await controller.resolveSource(source));
-            }
-            if (method === 'studio.agent.create') {
-                const preset = objectPayload(payload).agentPreset;
-                if (preset !== undefined && typeof preset !== 'string')
-                    throw new Error('agentPreset must be a string');
-                return success(rpcId, await controller.createAgent(preset));
-            }
-            if (method === 'studio.agent.dispose') {
-                await controller.disposeAgent();
-                return success(rpcId, { disposed: true });
-            }
-            return failure(rpcId, 'studio-method-forbidden', `method ${method} is not exposed by Studio`);
+    currentGet() {
+        return this.current.view();
+    }
+    currentPreviewStatus() {
+        return this.current.previewStatus();
+    }
+    currentProjectState() {
+        return this.current.project();
+    }
+    currentContext() {
+        return this.current.context();
+    }
+    currentHarmonyProfile() {
+        return this.current.harmonyProfile();
+    }
+    currentHarmonyInspect(input) {
+        return this.current.inspectHarmony(input);
+    }
+    currentReadDependencySource(input) {
+        return this.current.readDependencySource(input.package, input.file);
+    }
+    currentPreviewUpdate(input) {
+        return this.current.updatePreview(this.parsePreviewStatus(input));
+    }
+    currentResolveSource(input) {
+        if (typeof input.source?.file !== 'string')
+            throw new Error('source is required');
+        return this.current.resolveSource(input.source);
+    }
+    currentAgentCreate(input) {
+        if (input.agentPreset !== undefined && typeof input.agentPreset !== 'string')
+            throw new Error('agentPreset must be a string');
+        return this.current.createAgent(input.agentPreset);
+    }
+    currentAgentAttach(input) {
+        if (typeof input.sessionId !== 'string' || input.sessionId.trim() === '')
+            throw new Error('sessionId is required');
+        if ([...this.controllers.values()].some(controller => controller.view().agent?.sessionId === input.sessionId)) {
+            throw new Error('the selected session is already attached to a Draft');
         }
-        catch (error) {
-            const code = error instanceof StudioBuildError ? error.code : 'studio-request-failed';
-            const details = error instanceof StudioBuildError ? error.output : undefined;
-            return failure(rpcId, code, error instanceof Error ? error.message : String(error), details);
+        return this.current.attachAgent(input.sessionId);
+    }
+    currentAgentLeave() {
+        return this.current.leaveAgent();
+    }
+    draftsList() {
+        return this.list();
+    }
+    draftsCreate(input) {
+        return this.create(input);
+    }
+    async workspaceGet() {
+        const records = await this.registry.list();
+        return this.workspace.read(records.map(record => record.id));
+    }
+    async workspaceUpdate(input) {
+        const records = await this.registry.list();
+        return this.workspace.write(input, records.map(record => record.id));
+    }
+    async harmonyProfile(input) {
+        return (await this.controller(draftId(input))).profile();
+    }
+    async harmonyInspect(input) {
+        const controller = await this.controller(draftId(input));
+        return controller.inspectHarmony({
+            ...(input.package === undefined ? {} : { package: input.package }),
+            ...(input.file === undefined ? {} : { file: input.file }),
+        });
+    }
+    async harmonyUpdateProfile(input) {
+        const controller = await this.controller(draftId(input));
+        const order = optionalStringList(input.order, 'order');
+        const patchOrder = optionalStringList(input.patchOrder, 'patchOrder');
+        const disabled = optionalStringList(input.disabled, 'disabled');
+        return controller.updateProfile({
+            ...(order === undefined ? {} : { order }),
+            ...(patchOrder === undefined ? {} : { patchOrder }),
+            ...(disabled === undefined ? {} : { disabled }),
+        });
+    }
+    async draftsRename(input) {
+        const controller = await this.controller(draftId(input));
+        if (typeof input.label !== 'string')
+            throw new Error('Draft name is required');
+        controller.record = await this.registry.rename(controller.record.id, input.label);
+        return controller.view();
+    }
+    async draftsExport(input) {
+        const controller = await this.controller(draftId(input));
+        controller.record = await this.registry.export(controller.record.id);
+        return controller.view();
+    }
+    async draftsStart(input) {
+        return (await this.controller(draftId(input))).start();
+    }
+    async draftsStop(input) {
+        return (await this.controller(draftId(input))).stop();
+    }
+    async projectState(input) {
+        return (await this.controller(draftId(input))).refreshProject();
+    }
+    async projectActivate(input) {
+        if (typeof input.graphRev !== 'string')
+            throw new Error('graphRev is required');
+        return (await this.controller(draftId(input))).activate(input.graphRev);
+    }
+    async projectFiles(input) {
+        const controller = await this.controller(draftId(input));
+        return listProjectFiles(controller.record.root);
+    }
+    async projectReadFile(input) {
+        if (typeof input.path !== 'string')
+            throw new Error('path is required');
+        const controller = await this.controller(draftId(input));
+        return { path: input.path, content: await controller.readFile(input.path) };
+    }
+    async projectWriteFile(input) {
+        if (typeof input.path !== 'string' || typeof input.content !== 'string')
+            throw new Error('path and content are required');
+        const controller = await this.controller(draftId(input));
+        await writeProjectFile(controller.record.root, input.path, input.content);
+        return { path: input.path, saved: true };
+    }
+    async elementsStyles(input) {
+        return (await this.controller(draftId(input))).readElementStyles();
+    }
+    async elementsSaveSource(input) {
+        return (await this.controller(draftId(input))).saveElementSource(elementStyleSources(input));
+    }
+    async patchesAnalyzeAutomatic(input) {
+        return (await this.controller(draftId(input))).analyzeAutomaticPatch(automaticPatchRequest(input));
+    }
+    async patchesCreateAutomatic(input) {
+        return (await this.controller(draftId(input))).createAutomaticPatch(automaticPatchRequest(input));
+    }
+    async projectBuild(input, signal) {
+        return (await this.controller(draftId(input))).build(signal);
+    }
+    async projectCancelBuild(input) {
+        return { canceled: await (await this.controller(draftId(input))).cancelBuild() };
+    }
+    async readinessInspect(input) {
+        return (await this.controller(draftId(input))).readiness();
+    }
+    async readinessPack(input) {
+        return (await this.controller(draftId(input))).pack();
+    }
+    async previewStatus(input) {
+        return (await this.controller(draftId(input))).previewStatus();
+    }
+    async previewUpdate(input) {
+        return (await this.controller(draftId(input))).updatePreview(this.parsePreviewStatus(input));
+    }
+    async previewResolveSource(input) {
+        if (typeof input.source?.file !== 'string')
+            throw new Error('source is required');
+        return (await this.controller(draftId(input))).resolveSource(input.source);
+    }
+    async agentCreate(input) {
+        if (input.agentPreset !== undefined && typeof input.agentPreset !== 'string')
+            throw new Error('agentPreset must be a string');
+        return (await this.controller(draftId(input))).createAgent(input.agentPreset);
+    }
+    async agentAttach(input) {
+        const controller = await this.controller(draftId(input));
+        if (typeof input.sessionId !== 'string' || input.sessionId.trim() === '')
+            throw new Error('sessionId is required');
+        if (this.current.view().agent?.sessionId === input.sessionId) {
+            throw new Error('the selected session is already attached to the current instance');
         }
+        const other = [...this.controllers.entries()].find(([id, candidate]) => (id !== controller.record.id && candidate.view().agent?.sessionId === input.sessionId));
+        if (other !== undefined)
+            throw new Error('the selected session is already attached to another Draft');
+        return controller.attachAgent(input.sessionId);
+    }
+    async agentLeave(input) {
+        return (await this.controller(draftId(input))).leaveAgent();
     }
     async dispose() {
         await Promise.all([...this.controllerCreations.values()].map(creation => creation.catch(() => undefined)));
-        await Promise.all([...this.controllers.values()].map(controller => controller.dispose()));
+        await Promise.all([this.current.dispose(), ...[...this.controllers.values()].map(controller => controller.dispose())]);
         this.controllers.clear();
         this.controllerCreations.clear();
     }
@@ -272,6 +622,7 @@ export class StudioBackend {
         if ((candidate.profileMode !== 'main-home' && candidate.profileMode !== 'custom')
             || typeof candidate.source !== 'object' || candidate.source === null
             || (candidate.source.kind !== 'new' && candidate.source.kind !== 'existing')
+            || (candidate.profileDirectory !== undefined && typeof candidate.profileDirectory !== 'string')
             || (candidate.destinationDirectory !== undefined && typeof candidate.destinationDirectory !== 'string')) {
             throw new Error('Draft source and profileMode are invalid');
         }
@@ -296,11 +647,11 @@ export class StudioBackend {
         }
     }
     makeController(record) {
-        const controller = new StudioDraftController(record, this.harmony.profileDir, this.parentOrigin, this.commands, this.harmony.binEntry, this.agents, this.subprocess);
+        const controller = new StudioDraftController(record, this.harmony.profile().dir, this.parentOrigin, this.commands, HARMONY_BIN_ENTRY, this.agents, this.subprocess);
         this.controllers.set(record.id, controller);
         return controller;
     }
-    previewStatus(payload) {
+    parsePreviewStatus(payload) {
         const candidate = objectPayload(payload);
         if (typeof candidate.connected !== 'boolean' || (candidate.mode !== 'browse' && candidate.mode !== 'inspect')
             || (candidate.graphRev !== undefined && typeof candidate.graphRev !== 'string')) {