@yugoo-design/dsh-design-studio-dsh 0.1.2 → 0.2.2

package/lib/authoring-service-WClXJGik.js

@@ -0,0 +1,347 @@
+import { t as markStudioRemote } from "./remote-method-ab_lHwWN.js";
+import { i as readStudioPanelComponents, n as STUDIO_AUTHORING_METHOD_GUIDANCE, r as readStudioAuthoringMaterial } from "./authoring-agent-vc786tS0.js";
+import { STUDIO_AUTHORING_RPC_SCHEMAS } from "./authoring.remote-client.js";
+import { studioPreparedUrl } from "./page-path.js";
+import { t as createDshStudioAuthoringHost } from "./authoring-host-m8-GmXIx.js";
+import { Service } from "@deepseek-ai/cordis";
+import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { PANEL_COMPONENT_CATALOG } from "@yugoo-design/dsh-design-core/dsl";
+//#region src/authoring-tools.ts
+const actions = [
+	"catalog",
+	"list",
+	"read",
+	"copy",
+	"rename",
+	"readFile",
+	"prepareChanges",
+	"saveChanges",
+	"updateMounts",
+	"preview"
+];
+function registerStudioCustomizationTool(ctx, service) {
+	ctx.systemPrompt.section({
+		name: "studio:customization-methods",
+		order: 550,
+		text: `${STUDIO_AUTHORING_METHOD_GUIDANCE} Use studio_customize action read with request {authoring:{}} for the creator index, then request {authoring:{resource,offset}} for an indexed resource, or request {components:{name?,reference?,type?}} for installed component references. Read bound source separately using the existing working-copy id and file list. Packaged methods grant no write, save, publication or installation authority.`
+	});
+	ctx.tools.register(defineTool({
+		name: "studio_customize",
+		description: "Customize reusable Kit/Bundle methods and Panels in the SAME working copies shown in Studio. This edits authoring content, not a Design Project. Before editing, use read request {authoring:{}} for creator methods; for Panel changes discover {components:{}} then exact {components:{name,reference:\"contract\"}} and docs/examples before choosing parameters. catalog.currentKits lists available installed and local Kits for project selection; catalog.kits/bundles inspect installed source pins only, so absence there does not mean a local Kit is unavailable. Use list/read to reopen current local source; copy with kind and an exact kit or bundle {name,version}; readFile for source; rename requires id, expectedRevision and title {zh,en}. Read the current copy before selecting its revision. prepareChanges with id, expectedRevision and complete-file changes to inspect the diff, diagnostics and Panel preview before saving. Preparation never saves. Call saveChanges only when the user explicitly requests saving; pass the same changes, revision and candidate digest, using mode validated for a validated candidate or draft when the user wants to retain incomplete work. Kit mount changes use updateMounts. Saves do not publish, export or change installed content. After a conflict or an uncertain response, read the current working copy before proposing a new save; never blindly retry. request is the existing Studio operation input; it never accepts an agent identity, filesystem root or model configuration.",
+		parameters: {
+			action: {
+				type: "string",
+				required: true,
+				enum: [...actions]
+			},
+			request: {
+				type: "object",
+				required: true,
+				properties: {},
+				additionalProperties: true,
+				description: "Action-specific Studio input. Before authoring, read with {authoring:{}} for creator methods; read a listed resource with {authoring:{resource,offset}} and follow nextOffset. Source read: {id}; readFile: {id,path}. catalog: {query?}; list: {}; copy: {kind:\"bundle\",bundle:{name:\"exact-name\",version:\"exact-version\"}} (or kind:\"kit\",kit:{name,version}). rename: {id,expectedRevision,title:{zh,en}}. prepareChanges: {id,expectedRevision,changes:[{path,content}],bundle?}; saveChanges also sends mode (validated or draft) and the same candidate digest. preview: {id,expectedRevision,bundle?}. Use the current read receipt for expectedRevision; never guess or omit it on writes."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: { content: {
+					type: "string",
+					required: true
+				} }
+			},
+			render: (_args, result) => [{
+				type: "text",
+				text: result.content
+			}]
+		},
+		async execute(args, exec) {
+			const agent = exec.agent;
+			if (!agent) throw new Error("Studio customization requires the actual calling Agent");
+			exec.signal?.throwIfAborted();
+			const input = args.request;
+			let result;
+			switch (args.action) {
+				case "catalog":
+					result = await service.catalog(agent, input);
+					break;
+				case "list":
+					result = await service.list(agent, STUDIO_AUTHORING_RPC_SCHEMAS.list.request.parse(input));
+					break;
+				case "read":
+					if (Object.hasOwn(input, "components")) {
+						if (Object.keys(input).some((key) => key !== "components")) throw new Error("Read component references separately from working-copy source");
+						result = await service.readPanelComponents(agent, input.components);
+					} else if (Object.hasOwn(input, "authoring")) {
+						if (Object.keys(input).some((key) => key !== "authoring")) throw new Error("Read authoring methods separately from working-copy source");
+						result = await service.readAuthoringMaterial(agent, input.authoring);
+					} else result = await service.read(agent, STUDIO_AUTHORING_RPC_SCHEMAS.read.request.parse(input));
+					break;
+				case "copy":
+					result = await service.copy(agent, STUDIO_AUTHORING_RPC_SCHEMAS.copy.request.parse(input));
+					break;
+				case "rename":
+					result = await service.rename(agent, STUDIO_AUTHORING_RPC_SCHEMAS.rename.request.parse(input));
+					break;
+				case "readFile":
+					result = await service.readFile(agent, STUDIO_AUTHORING_RPC_SCHEMAS.readFile.request.parse(input));
+					break;
+				case "prepareChanges":
+					result = await service.prepareChanges(agent, STUDIO_AUTHORING_RPC_SCHEMAS.prepareChanges.request.parse(input));
+					break;
+				case "saveChanges":
+					result = await service.saveChanges(agent, STUDIO_AUTHORING_RPC_SCHEMAS.saveChanges.request.parse(input));
+					break;
+				case "updateMounts":
+					result = await service.updateMounts(agent, STUDIO_AUTHORING_RPC_SCHEMAS.updateMounts.request.parse(input));
+					break;
+				case "preview":
+					result = await service.preview(agent, STUDIO_AUTHORING_RPC_SCHEMAS.preview.request.parse(input));
+					break;
+				default: throw new Error("Unknown Studio customization action");
+			}
+			const candidate = args.action === "prepareChanges" ? STUDIO_AUTHORING_RPC_SCHEMAS.prepareChanges.result.parse(result) : void 0;
+			return { content: JSON.stringify({
+				result,
+				studioUrl: candidate?.authoring?.url ?? `/design-studio/?agentId=${encodeURIComponent(String(agent.id))}`
+			}) };
+		}
+	}));
+}
+//#endregion
+//#region src/authoring-service.ts
+/** Explicit native Service activation over the existing composed Host. */
+/** No model client or extra catalog: project the installed shared Core vocabulary. */
+function readComponents() {
+	return {
+		components: Object.entries(PANEL_COMPONENT_CATALOG).map(([name, entry]) => ({
+			name,
+			...entry,
+			generated: "autoOrder" in entry && entry.autoOrder !== void 0
+		})),
+		contract: "Runtime vocabulary and composition guidance only; not a complete parameter schema or standard A2UI specification."
+	};
+}
+var DshStudioAuthoringService = class extends TypertRemoteService {
+	static inject = [
+		"design",
+		"fs",
+		"agents",
+		"sessions",
+		"sessionQuery",
+		"tools",
+		"systemPrompt"
+	];
+	owner;
+	config;
+	initialization;
+	host;
+	closed = false;
+	accepting = false;
+	disposing;
+	calls = /* @__PURE__ */ new Set();
+	constructor(ctx, config) {
+		super(ctx, "studioAuthoring");
+		this.owner = ctx;
+		this.config = Object.freeze({ ...config });
+		ctx.effect(() => () => this.dispose(), "studio-authoring-service");
+	}
+	async [Service.init]() {
+		if (this.closed) throw new Error("Studio authoring Service is disposed");
+		const pending = createDshStudioAuthoringHost({
+			ctx: this.owner,
+			design: this.owner.design,
+			fs: this.owner.fs,
+			stateRoot: this.config.stateRoot,
+			workspaceRoot: this.config.workspaceRoot,
+			readComponents
+		});
+		this.initialization = pending;
+		const host = await pending;
+		this.host = host;
+		if (this.closed) {
+			await host.dispose();
+			throw new Error("Studio authoring Service closed during initialization");
+		}
+		this.accepting = true;
+		registerStudioCustomizationTool(this.owner, this);
+	}
+	/** Plugin lifetime only; page/request teardown never calls this method. */
+	dispose() {
+		if (this.disposing) return this.disposing;
+		this.closed = true;
+		this.accepting = false;
+		const stop = this.host?.dispose();
+		const settleInitialization = this.initialization?.then((host) => host.dispose(), () => void 0);
+		const calls = [...this.calls].map((call) => call.then(() => void 0, () => void 0));
+		this.disposing = Promise.allSettled([
+			stop,
+			settleInitialization,
+			...calls
+		]).then((results) => {
+			const failures = results.filter((r) => r.status === "rejected").map((r) => r.reason);
+			if (failures.length) throw new AggregateError([...new Set(failures)], "Studio authoring Service cleanup failed");
+		});
+		this.disposing.catch(() => {});
+		return this.disposing;
+	}
+	invoke(agent, operation) {
+		if (this.closed || !this.accepting || !this.host) return Promise.reject(/* @__PURE__ */ new Error("Studio authoring Service is unavailable"));
+		const host = this.host;
+		const result = Promise.resolve().then(() => {
+			if (this.closed || !this.accepting) throw new Error("Studio authoring Service is disposed");
+			return operation(host.forParent(agent));
+		});
+		this.calls.add(result);
+		result.finally(() => this.calls.delete(result)).catch(() => {});
+		return result;
+	}
+	/** Preserve call-time JSON intent before invoke queues its admission check. */
+	request(agent, input, parser, operation) {
+		let captured;
+		try {
+			captured = parser.parse(input);
+		} catch (error) {
+			return Promise.reject(error);
+		}
+		return this.invoke(agent, (parent) => operation(parent, captured));
+	}
+	reference(run) {
+		run.result.catch(() => {});
+		return structuredClone(run.reference);
+	}
+	/** Installed-source inspection plus the same current Kit choices as project selection. */
+	catalog(agent, request) {
+		if (!request || typeof request !== "object" || Array.isArray(request) || Object.keys(request).some((key) => key !== "query") || request.query !== void 0 && (typeof request.query !== "string" || request.query.length > 4096)) return Promise.reject(/* @__PURE__ */ new Error("Studio catalog accepts only an optional search query"));
+		const query = request.query;
+		return this.invoke(agent, async () => {
+			const catalog = this.owner.get("studioManagement");
+			if (!catalog) throw new Error("Studio catalog service is unavailable");
+			const [installed, current] = await Promise.all([catalog.workspace(query ?? ""), this.owner.design.listCurrentKits()]);
+			const search = query?.trim().toLocaleLowerCase() ?? "";
+			return {
+				...installed,
+				currentKits: current.filter((kit) => !search || `${kit.name} ${kit.description ?? ""}`.toLocaleLowerCase().includes(search))
+			};
+		});
+	}
+	list(agent, request) {
+		return this.request(agent, request, STUDIO_AUTHORING_RPC_SCHEMAS.list.request, (p, captured) => p.instances.list(captured));
+	}
+	read(agent, request) {
+		return this.request(agent, request, STUDIO_AUTHORING_RPC_SCHEMAS.read.request, (p, captured) => p.instances.read(captured));
+	}
+	create(agent, request) {
+		return this.request(agent, request, STUDIO_AUTHORING_RPC_SCHEMAS.create.request, (p, captured) => p.instances.create(captured));
+	}
+	importSources(agent, request) {
+		return this.request(agent, request, STUDIO_AUTHORING_RPC_SCHEMAS.importSources.request, (p, captured) => p.instances.importSources(captured));
+	}
+	/** Existing conversation read tool only; not a browser Remote or filesystem port. */
+	readAuthoringMaterial(agent, request) {
+		const captured = structuredClone(request);
+		return this.invoke(agent, () => readStudioAuthoringMaterial(captured));
+	}
+	readPanelComponents(agent, request) {
+		const captured = structuredClone(request);
+		return this.invoke(agent, () => readStudioPanelComponents(captured));
+	}
+	copy(agent, request) {
+		return this.request(agent, request, STUDIO_AUTHORING_RPC_SCHEMAS.copy.request, (p, captured) => p.instances.copy(captured));
+	}
+	editCurrent(agent, request) {
+		return this.request(agent, request, STUDIO_AUTHORING_RPC_SCHEMAS.editCurrent.request, (p, captured) => p.instances.editCurrent(captured));
+	}
+	rename(agent, request) {
+		return this.request(agent, request, STUDIO_AUTHORING_RPC_SCHEMAS.rename.request, (p, captured) => p.instances.rename(captured));
+	}
+	remove(agent, request) {
+		return this.request(agent, request, STUDIO_AUTHORING_RPC_SCHEMAS.remove.request, (p, captured) => p.instances.remove(captured));
+	}
+	readFile(agent, request) {
+		return this.request(agent, request, STUDIO_AUTHORING_RPC_SCHEMAS.readFile.request, (p, captured) => p.instances.readFile(captured));
+	}
+	saveFile(agent, request) {
+		return this.request(agent, request, STUDIO_AUTHORING_RPC_SCHEMAS.saveFile.request, (p, captured) => p.instances.saveFile(captured));
+	}
+	prepareChanges(agent, request) {
+		return this.request(agent, request, STUDIO_AUTHORING_RPC_SCHEMAS.prepareChanges.request, async (p, captured) => {
+			const { locator, prepared } = await p.prepareChanges(captured);
+			const { requestId, digest: _digest, ...studio } = locator;
+			return {
+				...prepared.candidate,
+				authoring: {
+					requestId,
+					studio,
+					url: studioPreparedUrl(String(agent.id), locator)
+				}
+			};
+		});
+	}
+	saveChanges(agent, request) {
+		return this.request(agent, request, STUDIO_AUTHORING_RPC_SCHEMAS.saveChanges.request, (p, captured) => p.instances.saveChanges(captured));
+	}
+	updateMounts(agent, request) {
+		return this.request(agent, request, STUDIO_AUTHORING_RPC_SCHEMAS.updateMounts.request, (p, captured) => p.instances.updateMounts(captured));
+	}
+	preview(agent, request) {
+		return this.request(agent, request, STUDIO_AUTHORING_RPC_SCHEMAS.preview.request, (p, captured) => p.instances.preview(captured));
+	}
+	start(agent, request) {
+		return this.request(agent, request, STUDIO_AUTHORING_RPC_SCHEMAS.start.request, async (p, captured) => this.reference(await p.start(captured)));
+	}
+	resume(agent, request) {
+		return this.request(agent, request, STUDIO_AUTHORING_RPC_SCHEMAS.resume.request, async (p, captured) => this.reference(await p.resume(captured)));
+	}
+	observe(agent, address) {
+		return this.request(agent, address, STUDIO_AUTHORING_RPC_SCHEMAS.observe.request, (p, captured) => p.observe(captured));
+	}
+	cancel(agent, request) {
+		return this.request(agent, request, STUDIO_AUTHORING_RPC_SCHEMAS.cancel.request, (p, captured) => {
+			const { expectedTurn, ...address } = captured;
+			return p.cancel(address, { expectedTurn });
+		});
+	}
+	readPrepared(agent, address) {
+		return this.request(agent, address, STUDIO_AUTHORING_RPC_SCHEMAS.readPrepared.request, async (p, captured) => {
+			const prepared = await p.readPrepared(captured);
+			return prepared === void 0 ? {} : { prepared };
+		});
+	}
+	listReferences(agent) {
+		return this.invoke(agent, (p) => p.listReferences());
+	}
+	exportContentArchive(agent, request) {
+		return this.request(agent, request, STUDIO_AUTHORING_RPC_SCHEMAS.exportContentArchive.request, (p, input) => p.content.exportContentArchive(input));
+	}
+	readArchive(agent, request) {
+		return this.request(agent, request, STUDIO_AUTHORING_RPC_SCHEMAS.readArchive.request, (p, input) => p.content.readArchive(input));
+	}
+};
+const proto = DshStudioAuthoringService.prototype;
+markStudioRemote(proto, "list", proto.list);
+markStudioRemote(proto, "read", proto.read);
+markStudioRemote(proto, "create", proto.create);
+markStudioRemote(proto, "importSources", proto.importSources);
+markStudioRemote(proto, "copy", proto.copy);
+markStudioRemote(proto, "editCurrent", proto.editCurrent);
+markStudioRemote(proto, "rename", proto.rename);
+markStudioRemote(proto, "remove", proto.remove);
+markStudioRemote(proto, "readFile", proto.readFile);
+markStudioRemote(proto, "saveFile", proto.saveFile);
+markStudioRemote(proto, "prepareChanges", proto.prepareChanges);
+markStudioRemote(proto, "saveChanges", proto.saveChanges);
+markStudioRemote(proto, "updateMounts", proto.updateMounts);
+markStudioRemote(proto, "preview", proto.preview);
+markStudioRemote(proto, "start", proto.start);
+markStudioRemote(proto, "resume", proto.resume);
+markStudioRemote(proto, "observe", proto.observe);
+markStudioRemote(proto, "cancel", proto.cancel);
+markStudioRemote(proto, "readPrepared", proto.readPrepared);
+markStudioRemote(proto, "listReferences", proto.listReferences);
+markStudioRemote(proto, "exportContentArchive", proto.exportContentArchive);
+markStudioRemote(proto, "readArchive", proto.readArchive);
+//#endregion
+export { DshStudioAuthoringService as t };

package/lib/authoring-service.d.ts

@@ -0,0 +1,121 @@
+import { r as StudioAuthoringReference, t as StudioAuthoringObservation } from "./authoring-agent.types-0S0xnlDW.js";
+import { r as StudioSessionPrepared } from "./authoring-session.types-C6HosIWU.js";
+import { a as StudioPreparedLocator, i as StudioAuthoringAddress, r as DshStudioAuthoringParent } from "./authoring-host.types-BZt9l0xK.js";
+import { r as StudioPageAuthoringStart } from "./authoring.page-rpc-CYYWsmxc.js";
+import { Context, Service } from "@deepseek-ai/cordis";
+import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { Agent } from "@deepseek-ai/dsh-agent";
+import { StudioInstances } from "@yugoo-design/dsh-design-studio/node";
+//#region src/authoring-service.d.ts
+interface DshStudioAuthoringServiceConfig {
+  /** Explicit private canonical Host directory, outside installed content/projects. */
+  readonly stateRoot: string;
+  /** Explicit isolated Host workspace; never a browser argument. */
+  readonly workspaceRoot: string;
+}
+declare class DshStudioAuthoringService extends TypertRemoteService {
+  static inject: string[];
+  private readonly owner;
+  private readonly config;
+  private initialization?;
+  private host?;
+  private closed;
+  private accepting;
+  private disposing?;
+  private readonly calls;
+  constructor(ctx: Context, config: DshStudioAuthoringServiceConfig);
+  protected [Service.init](): Promise<void>;
+  /** Plugin lifetime only; page/request teardown never calls this method. */
+  dispose(): Promise<void>;
+  private invoke;
+  /** Preserve call-time JSON intent before invoke queues its admission check. */
+  private request;
+  private reference;
+  /** Installed-source inspection plus the same current Kit choices as project selection. */
+  catalog(agent: Agent, request: Record<string, unknown>): Promise<{
+    currentKits: {
+      readonly name: string;
+      readonly version: string;
+      readonly description?: string;
+    }[];
+    query: string;
+    kits: readonly import("@yugoo-design/dsh-design-studio").StudioKitView[];
+    bundles: readonly import("@yugoo-design/dsh-design-studio").StudioBundleView[];
+  }>;
+  list(agent: Agent, request?: Parameters<StudioInstances['list']>[0]): Promise<readonly import("@yugoo-design/dsh-design-studio/node").StudioInstanceDescription[]>;
+  read(agent: Agent, request: {
+    readonly id: string;
+  }): Promise<import("@yugoo-design/dsh-design-studio/node").StudioInstanceDescription>;
+  create(agent: Agent, request: Parameters<StudioInstances['create']>[0]): Promise<import("@yugoo-design/dsh-design-studio/node").StudioInstanceDescription>;
+  importSources(agent: Agent, request: Parameters<StudioInstances['importSources']>[0]): Promise<import("@yugoo-design/dsh-design-studio/node").StudioInstanceDescription>;
+  /** Existing conversation read tool only; not a browser Remote or filesystem port. */
+  readAuthoringMaterial(agent: Agent, request: unknown): Promise<{
+    skills?: {
+      name: string;
+      description: string;
+      method: string;
+    }[] | undefined;
+    nextOffset?: number | undefined;
+    offset: number;
+    content: string;
+    bytes: number;
+    totalBytes: number;
+    resource: string;
+  }>;
+  readPanelComponents(agent: Agent, request: unknown): Promise<unknown>;
+  copy(agent: Agent, request: Parameters<StudioInstances['copy']>[0]): Promise<import("@yugoo-design/dsh-design-studio/node").StudioInstanceDescription>;
+  editCurrent(agent: Agent, request: Parameters<StudioInstances['editCurrent']>[0]): Promise<import("@yugoo-design/dsh-design-studio/node").StudioInstanceDescription>;
+  rename(agent: Agent, request: Parameters<StudioInstances['rename']>[0]): Promise<import("@yugoo-design/dsh-design-studio/node").StudioInstanceDescription>;
+  remove(agent: Agent, request: Parameters<StudioInstances['remove']>[0]): Promise<{
+    readonly id: string;
+    readonly revision: number;
+    readonly trashed: true;
+  }>;
+  readFile(agent: Agent, request: Parameters<StudioInstances['readFile']>[0]): Promise<import("@yugoo-design/dsh-design-studio/node").StudioInstanceReadFile>;
+  saveFile(agent: Agent, request: Parameters<StudioInstances['saveFile']>[0]): Promise<import("@yugoo-design/dsh-design-studio/node").StudioInstanceDescription>;
+  prepareChanges(agent: Agent, request: Parameters<StudioInstances['prepareChanges']>[0]): Promise<{
+    authoring: {
+      requestId: string;
+      studio: {
+        id: string;
+        expectedRevision: number;
+        bundle?: import("@yugoo-design/dsh-design-studio").DesignBundleVersionPin;
+      };
+      url: string;
+    };
+    id: string;
+    baseRevision: number;
+    revision: number;
+    digest: string;
+    diff: readonly import("@yugoo-design/dsh-design-studio").StudioInstanceFileDiff[];
+    valid: boolean;
+    diagnostics: readonly import("@yugoo-design/dsh-design-studio").StudioDiagnostic[];
+    preview?: import("@yugoo-design/dsh-design-studio").StudioPanelPreview;
+  }>;
+  saveChanges(agent: Agent, request: Parameters<StudioInstances['saveChanges']>[0]): Promise<import("@yugoo-design/dsh-design-studio/node").StudioInstanceDescription & {
+    readonly changeReceipt: import("@yugoo-design/dsh-design-studio").StudioInstanceChangeReceipt;
+  }>;
+  updateMounts(agent: Agent, request: Parameters<StudioInstances['updateMounts']>[0]): Promise<import("@yugoo-design/dsh-design-studio/node").StudioInstanceDescription>;
+  preview(agent: Agent, request: Parameters<StudioInstances['preview']>[0]): Promise<import("@yugoo-design/dsh-design-studio").StudioPanelPreviewResult>;
+  start(agent: Agent, request: StudioPageAuthoringStart): Promise<StudioAuthoringReference>;
+  resume(agent: Agent, request: StudioPageAuthoringStart & {
+    readonly previous: StudioAuthoringAddress;
+    readonly explicit: true;
+  }): Promise<StudioAuthoringReference>;
+  observe(agent: Agent, address: StudioAuthoringAddress): Promise<StudioAuthoringObservation>;
+  cancel(agent: Agent, request: StudioAuthoringAddress & {
+    readonly expectedTurn: number | null;
+  }): Promise<StudioAuthoringObservation>;
+  readPrepared(agent: Agent, address: StudioAuthoringAddress | StudioPreparedLocator): Promise<{
+    prepared?: undefined;
+  } | {
+    prepared: StudioSessionPrepared;
+  }>;
+  listReferences(agent: Agent): Promise<readonly StudioAuthoringReference[]>;
+  exportContentArchive(agent: Agent, request: Parameters<DshStudioAuthoringParent['content']['exportContentArchive']>[0]): Promise<string>;
+  readArchive(agent: Agent, request: {
+    source: string;
+  }): Promise<import("@yugoo-design/dsh-design-studio").StudioContentArchive>;
+}
+//#endregion
+export { DshStudioAuthoringService, DshStudioAuthoringService as default, DshStudioAuthoringServiceConfig };

package/lib/authoring-service.js

@@ -0,0 +1,2 @@
+import { t as DshStudioAuthoringService } from "./authoring-service-WClXJGik.js";
+export { DshStudioAuthoringService, DshStudioAuthoringService as default };

package/lib/authoring-session.d.ts

@@ -0,0 +1,5 @@
+import { a as StudioSessionRun, i as StudioSessionResume, n as StudioAuthoringSessionOptions, o as StudioSessionStart, r as StudioSessionPrepared, t as StudioAuthoringSession } from "./authoring-session.types-C6HosIWU.js";
+//#region src/authoring-session.d.ts
+declare function createStudioAuthoringSession(options: StudioAuthoringSessionOptions): StudioAuthoringSession;
+//#endregion
+export { type StudioAuthoringSession, type StudioAuthoringSessionOptions, type StudioSessionPrepared, type StudioSessionResume, type StudioSessionRun, type StudioSessionStart, createStudioAuthoringSession };