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

package/lib/authoring-session.js

@@ -0,0 +1,204 @@
+import { t as createStudioAuthoringAgent } from "./authoring-agent-vc786tS0.js";
+import { normalizeStudioInstanceChanges } from "@yugoo-design/dsh-design-studio";
+import { isAbsolute } from "node:path";
+import assert from "node:assert/strict";
+import { createStudioAuthoring } from "@yugoo-design/dsh-design-studio/node";
+//#region src/authoring-session.ts
+/** Trusted live parent -> existing S2 capability -> H2. No storage or model client. */
+const clone = (value) => structuredClone(value);
+const samePin = (a, b) => a?.name === b?.name && a?.version === b?.version;
+const key = (ref) => `${ref.sessionId}:${ref.epoch}`;
+/** Snapshot all caller intent before the first native or source await. */
+function snapshot(request) {
+	const { invocationId, prompt, signal, onPrepared } = request;
+	assert.ok(typeof invocationId === "string" && invocationId.length > 0 && invocationId.length <= 128, "An exact invocation identity is required");
+	assert.ok(typeof prompt === "string" && prompt.trim() && Buffer.byteLength(prompt) <= 131072, "A bounded new authoring prompt is required");
+	assert.ok(onPrepared === void 0 || typeof onPrepared === "function");
+	assert.ok(Array.isArray(request.paths), "Select source paths in this working copy");
+	const normalized = normalizeStudioInstanceChanges({
+		id: request.id,
+		expectedRevision: request.expectedRevision,
+		changes: request.paths.map((path) => ({
+			path,
+			content: ""
+		})),
+		...request.bundle ? { bundle: request.bundle } : {}
+	});
+	return Object.freeze({
+		invocationId,
+		prompt,
+		signal,
+		onPrepared,
+		id: normalized.id,
+		expectedRevision: normalized.expectedRevision,
+		paths: Object.freeze(normalized.changes.map((change) => change.path)),
+		...normalized.bundle ? { bundle: normalized.bundle } : {}
+	});
+}
+function createStudioAuthoringSession(options) {
+	const { ctx, parent, instances, readComponents, workspaceRoot, retainReference } = options;
+	assert.ok(isAbsolute(workspaceRoot), "A trusted isolated workspace is required");
+	assert.equal(typeof retainReference, "function", "The caller must retain native references before dispatch");
+	assert.ok(ctx.agents.get(parent.id) === parent, "The exact native authoring parent is disconnected");
+	const source = {
+		read: instances.read.bind(instances),
+		readFile: instances.readFile.bind(instances),
+		...instances.readMountedBundle ? { readMountedBundle: instances.readMountedBundle.bind(instances) } : {},
+		prepareChanges: instances.prepareChanges.bind(instances)
+	};
+	const native = createStudioAuthoringAgent(ctx), lifetime = new AbortController();
+	const owned = /* @__PURE__ */ new Map();
+	const parentIsLive = () => assert.ok(ctx.agents.get(parent.id) === parent, "The exact native authoring parent is disconnected");
+	const active = () => {
+		lifetime.signal.throwIfAborted();
+		parentIsLive();
+	};
+	parentIsLive();
+	const referenceForParent = (value) => {
+		const ref = clone(value);
+		assert.equal(ref.parentSessionId, String(parent.id), "Authoring reference belongs to another native parent");
+		return ref;
+	};
+	const ownedRun = (value) => {
+		active();
+		const ref = referenceForParent(value), run = owned.get(key(ref));
+		assert.ok(run, "No exact owned authoring run; cold references permit observation only");
+		assert.deepEqual(ref, run.reference, "Authoring reference differs from the exact owned run");
+		return run;
+	};
+	const observe = async (value) => {
+		parentIsLive();
+		const ref = referenceForParent(value), result = await native.observe(ref);
+		parentIsLive();
+		return result;
+	};
+	const readCurrent = (id, signal) => new Promise((resolve, reject) => {
+		signal.throwIfAborted();
+		const abort = () => reject(signal.reason);
+		signal.addEventListener("abort", abort, { once: true });
+		Promise.resolve().then(() => {
+			signal.throwIfAborted();
+			return source.read({ id });
+		}).then((value) => {
+			signal.removeEventListener("abort", abort);
+			resolve(value);
+		}, (error) => {
+			signal.removeEventListener("abort", abort);
+			reject(error);
+		});
+	});
+	const project = (value, scope) => {
+		assert.ok(value && typeof value === "object");
+		const raw = value;
+		assert.deepEqual(raw.scope, scope, "Prepared scope differs from the native binding");
+		const request = normalizeStudioInstanceChanges(raw.request), candidate = raw.candidate;
+		assert.deepEqual(request, raw.request);
+		assert.equal(request.id, scope.id);
+		assert.equal(request.expectedRevision, scope.expectedRevision);
+		assert.ok(samePin(request.bundle, scope.bundle));
+		assert.equal(candidate.id, scope.id);
+		assert.equal(candidate.baseRevision, scope.expectedRevision);
+		assert.equal(candidate.revision, scope.expectedRevision + 1);
+		assert.ok(/^[a-f0-9]{64}$/.test(candidate.digest));
+		return clone({
+			request,
+			candidate
+		});
+	};
+	const begin = async (input, previous) => {
+		active();
+		const request = snapshot(input), prior = previous === void 0 ? void 0 : referenceForParent(previous);
+		const signal = request.signal ? AbortSignal.any([request.signal, lifetime.signal]) : lifetime.signal;
+		signal.throwIfAborted();
+		if (prior) assert.equal(prior.scope.id, request.id, "Resume cannot select another working copy");
+		const record = await readCurrent(request.id, signal);
+		active();
+		signal.throwIfAborted();
+		assert.equal(record.id, request.id);
+		assert.equal(record.revision, request.expectedRevision, "Working copy changed; reopen before authoring");
+		assert.ok(record.recordVersion === 2 && !record.deletedAt && Array.isArray(record.files), "Select a current complete-source working copy");
+		for (const path of request.paths) assert.ok(!record.files.some((file) => file.path === path && !file.editable), "Select an editable source path in this exact working copy");
+		const bundle = record.kind === "bundle" ? record.bundle : request.bundle;
+		assert.ok(record.kind === "bundle" ? bundle && (request.bundle === void 0 || samePin(request.bundle, bundle)) : bundle === void 0 || record.mounts.some((mount) => samePin(mount.bundle, bundle)), "Select the exact Bundle or an explicit mounted Bundle for this Kit");
+		const scope = Object.freeze({
+			id: record.id,
+			expectedRevision: record.revision,
+			allowedPaths: request.paths,
+			...bundle ? { bundle: Object.freeze({ ...bundle }) } : {}
+		});
+		const capability = createStudioAuthoring({
+			scope,
+			instances: source,
+			readComponents
+		});
+		const nativeRequest = {
+			parent,
+			invocationId: request.invocationId,
+			workspaceRoot,
+			scope,
+			prompt: request.prompt,
+			signal,
+			ports: {
+				read: (input) => capability.read(input),
+				prepare: (input) => capability.prepare(input)
+			},
+			onReference: async (value) => {
+				active();
+				assert.deepEqual(value.scope, scope);
+				referenceForParent(value);
+				await retainReference(clone(value));
+				active();
+			},
+			onPrepared: (value) => {
+				active();
+				return request.onPrepared?.(project(value, scope));
+			}
+		};
+		const run = prior ? await native.resume({
+			...nativeRequest,
+			previous: prior,
+			explicit: true
+		}) : await native.start(nativeRequest);
+		try {
+			active();
+			signal.throwIfAborted();
+		} catch (error) {
+			await run.dispose();
+			throw error;
+		}
+		const wrapped = Object.freeze({
+			reference: run.reference,
+			result: run.result,
+			observe: () => observe(run.reference),
+			cancel: (input) => {
+				active();
+				return run.cancel({ expectedTurn: input.expectedTurn });
+			},
+			readPrepared: () => {
+				active();
+				const value = run.readPrepared();
+				return value === void 0 ? void 0 : project(value, scope);
+			}
+		});
+		owned.set(key(run.reference), wrapped);
+		return wrapped;
+	};
+	const dispose = () => {
+		lifetime.abort(/* @__PURE__ */ new Error("Studio authoring session is disposed"));
+		return native.dispose();
+	};
+	ctx.effect(() => dispose);
+	return Object.freeze({
+		start: (request) => begin(request),
+		resume: (request) => {
+			assert.equal(request.explicit, true, "Resume requires explicit authorization and a new prompt");
+			return begin(request, request.previous);
+		},
+		observe,
+		cancel: (ref, input) => ownedRun(ref).cancel(input),
+		readPrepared: (ref) => ownedRun(ref).readPrepared(),
+		dispose
+	});
+}
+//#endregion
+export { createStudioAuthoringSession };

package/lib/authoring-session.types-C6HosIWU.d.ts

@@ -0,0 +1,58 @@
+import { r as StudioAuthoringReference, t as StudioAuthoringObservation } from "./authoring-agent.types-0S0xnlDW.js";
+import { Context } from "@deepseek-ai/cordis";
+import { DesignBundleVersionPin, StudioInstanceCandidate, StudioInstanceChangeRequest } from "@yugoo-design/dsh-design-studio";
+import { Agent } from "@deepseek-ai/dsh-agent";
+import { StudioAuthoringComponentCatalog, StudioAwaitable, StudioInstances } from "@yugoo-design/dsh-design-studio/node";
+//#region src/authoring-session.types.d.ts
+/** A projection of the existing S2/S1 receipt, not another candidate authority. */
+interface StudioSessionPrepared {
+  readonly request: StudioInstanceChangeRequest;
+  readonly candidate: StudioInstanceCandidate;
+}
+interface StudioAuthoringSessionOptions {
+  readonly ctx: Context;
+  readonly parent: Agent;
+  readonly instances: Pick<StudioInstances, 'read' | 'readFile' | 'prepareChanges'> & Partial<Pick<StudioInstances, 'readMountedBundle'>>;
+  readonly readComponents: () => StudioAwaitable<StudioAuthoringComponentCatalog>;
+  /** Host-selected isolated workspace, never a browser-supplied path. */
+  readonly workspaceRoot: string;
+  /** Caller persists the native address before H2 attempts dispatch. */
+  readonly retainReference: (reference: StudioAuthoringReference) => void | Promise<void>;
+}
+interface StudioSessionStart {
+  readonly invocationId: string;
+  readonly id: string;
+  readonly expectedRevision: number;
+  readonly paths: readonly string[];
+  readonly bundle?: DesignBundleVersionPin;
+  readonly prompt: string;
+  readonly signal?: AbortSignal;
+  readonly onPrepared?: (prepared: StudioSessionPrepared) => void | Promise<void>;
+}
+interface StudioSessionResume extends StudioSessionStart {
+  readonly previous: StudioAuthoringReference;
+  readonly explicit: true;
+}
+interface StudioSessionRun {
+  readonly reference: StudioAuthoringReference;
+  /** Native turn outcome, independently of candidate validity or user save. */
+  readonly result: Promise<StudioAuthoringObservation>;
+  observe(): Promise<StudioAuthoringObservation>;
+  cancel(options: {
+    readonly expectedTurn: number | null;
+  }): Promise<StudioAuthoringObservation>;
+  readPrepared(): StudioSessionPrepared | undefined;
+}
+interface StudioAuthoringSession {
+  start(request: StudioSessionStart): Promise<StudioSessionRun>;
+  resume(request: StudioSessionResume): Promise<StudioSessionRun>;
+  observe(reference: StudioAuthoringReference): Promise<StudioAuthoringObservation>;
+  /** Only this session object's exact retained run handle can be cancelled. */
+  cancel(reference: StudioAuthoringReference, options: {
+    readonly expectedTurn: number | null;
+  }): Promise<StudioAuthoringObservation>;
+  readPrepared(reference: StudioAuthoringReference): StudioSessionPrepared | undefined;
+  dispose(): Promise<void>;
+}
+//#endregion
+export { StudioSessionRun as a, StudioSessionResume as i, StudioAuthoringSessionOptions as n, StudioSessionStart as o, StudioSessionPrepared as r, StudioAuthoringSession as t };

package/lib/authoring-sources-BzRuEuub.d.ts

@@ -0,0 +1,17 @@
+import DesignService from "@yugoo-design/dsh-design-core";
+import { StudioInstanceAdapters, StudioInstances } from "@yugoo-design/dsh-design-studio/node";
+import { FileSystem } from "@deepseek-ai/dsh-fs";
+//#region src/authoring-sources.d.ts
+interface DshStudioInstanceSources {
+  readonly design: Pick<DesignService, 'listBundles' | 'resolveBundle' | 'resolveKit'>;
+  readonly fs: FileSystem;
+}
+/** A trusted library source for initial project copies, never a project registry. */
+declare function registerDshStudioCurrentKitSource(design: Pick<DesignService, 'registerCurrentKitSource' | 'listKits'>, instances: Pick<StudioInstances, 'list' | 'editCurrent' | 'loadKit'>): () => void;
+/**
+ * No source discovery, Node source I/O, stateRoot or native session. S2 remains
+ * the compiler, snapshot, composition and save owner, including its list policy.
+ */
+declare function createDshStudioInstanceAdapters({ design, fs }: DshStudioInstanceSources): StudioInstanceAdapters;
+//#endregion
+export { createDshStudioInstanceAdapters as n, registerDshStudioCurrentKitSource as r, DshStudioInstanceSources as t };

package/lib/authoring-sources.d.ts

@@ -0,0 +1,2 @@
+import { n as createDshStudioInstanceAdapters, r as registerDshStudioCurrentKitSource, t as DshStudioInstanceSources } from "./authoring-sources-BzRuEuub.js";
+export { DshStudioInstanceSources, createDshStudioInstanceAdapters, registerDshStudioCurrentKitSource };

package/lib/authoring-sources.js

@@ -0,0 +1,95 @@
+import { n as openInstalledSourceFiles, t as kitFileError } from "./kit-files-DKBlBOG8.js";
+import { DesignKitVersion } from "@yugoo-design/dsh-design-core";
+import { createStudioInstanceAdapters } from "@yugoo-design/dsh-design-studio/node";
+//#region src/authoring-sources.ts
+/** A trusted library source for initial project copies, never a project registry. */
+function registerDshStudioCurrentKitSource(design, instances) {
+	const records = async () => (await instances.list({
+		kind: "kit",
+		includeReadiness: false
+	})).filter((record) => record.kit);
+	return design.registerCurrentKitSource({
+		async load(name) {
+			const matches = (await records()).filter((record) => record.kit.name === name);
+			const selected = matches.find((record) => record.current) ?? matches[0];
+			if (selected) return instances.loadKit({
+				id: selected.id,
+				expectedRevision: selected.revision
+			});
+			const installed = design.listKits().find((kit) => kit.name === name);
+			if (!installed) return void 0;
+			const current = await instances.editCurrent({
+				kind: "kit",
+				kit: {
+					name: installed.name,
+					version: String(installed.version)
+				}
+			});
+			return instances.loadKit({
+				id: current.id,
+				expectedRevision: current.revision
+			});
+		},
+		async list() {
+			return (await records()).map((record) => {
+				const description = [...new Set([
+					record.title?.zh,
+					record.title?.en,
+					record.description
+				].filter(Boolean))].join(" · ");
+				return {
+					name: record.kit.name,
+					version: record.kit.version,
+					...description ? { description } : {}
+				};
+			});
+		}
+	});
+}
+/**
+* No source discovery, Node source I/O, stateRoot or native session. S2 remains
+* the compiler, snapshot, composition and save owner, including its list policy.
+*/
+function createDshStudioInstanceAdapters({ design, fs }) {
+	const unavailable = (message) => kitFileError("studio.source_unavailable", message);
+	const bundle = (pin) => {
+		const content = design.resolveBundle(pin);
+		if (!content) throw unavailable(`Independent Bundle ${pin.name}@${pin.version} is not registered.`);
+		if ((content.skill.catalogName ?? content.skill.name) !== pin.name || String(content.skill.version) !== pin.version) throw kitFileError("studio.source_pin_mismatch", "Resolved Bundle differs from the exact requested pin.");
+		if (typeof content.sourceId !== "string" || !content.sourceId || content.sourceId.length > 4096 || /[\u0000-\u001f\u007f]/u.test(content.sourceId)) throw unavailable("Registered Bundle has no valid trusted sourceId.");
+		if (typeof content.resourceRoot !== "string" || !content.resourceRoot) throw unavailable("Registered Bundle has no resourceRoot.");
+		return {
+			sourceId: content.sourceId,
+			root: content.resourceRoot
+		};
+	};
+	return createStudioInstanceAdapters({
+		async listBundles() {
+			const skills = design.listBundles();
+			if (skills.length > 1024) throw kitFileError("studio.source_limit", "Bundle catalog exceeds 1024 entries.");
+			return skills.map((skill) => ({
+				name: skill.catalogName ?? skill.name,
+				version: String(skill.version)
+			})).filter((pin) => design.resolveBundle(pin) !== void 0).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : a.version < b.version ? -1 : a.version > b.version ? 1 : 0);
+		},
+		async captureBundle(pin) {
+			const { root, sourceId } = bundle(pin);
+			return {
+				sourceId,
+				files: await (await openInstalledSourceFiles(fs, root)).captureTree()
+			};
+		},
+		async captureKit(pin) {
+			const kit = design.resolveKit({
+				kit: pin.name,
+				version: DesignKitVersion(pin.version)
+			});
+			if (!kit) throw unavailable(`Kit ${pin.name}@${pin.version} is not registered.`);
+			if (kit.name !== pin.name || String(kit.version) !== pin.version) throw kitFileError("studio.source_pin_mismatch", "Resolved Kit differs from the exact requested pin.");
+			if (typeof kit.sourceRoot !== "string" || !kit.sourceRoot) throw unavailable("Registered Kit has no sourceRoot.");
+			return { files: await (await openInstalledSourceFiles(fs, kit.sourceRoot, "Kit")).captureTree() };
+		}
+	});
+}
+//#endregion
+export { createDshStudioInstanceAdapters, registerDshStudioCurrentKitSource };

package/lib/authoring-workbench.d.ts

@@ -0,0 +1,15 @@
+import { a as StudioPreparedLocator } from "./authoring-host.types-BZt9l0xK.js";
+import { n as StudioPageAuthoringClient } from "./authoring.page-rpc-CYYWsmxc.js";
+import { InstanceWorkbenchProps } from "@yugoo-design/dsh-design-studio-ui";
+//#region src/authoring-workbench.d.ts
+interface StudioAuthoringWorkbenchProps extends Omit<InstanceWorkbenchProps, 'client' | 'renderSupplement' | 'embedded' | 'initialView' | 'sourceChanges'> {
+  /** Already scoped to the native parent by the page. Identity changes invalidate this open editor. */
+  client: StudioPageAuthoringClient;
+  presentation?: 'content-only' | 'full';
+  preparedLocator?: StudioPreparedLocator;
+  initialPrompt?: string;
+}
+declare const StudioAuthoringPromptContext: import("react").Context<string | undefined>;
+declare function StudioAuthoringWorkbench(props: StudioAuthoringWorkbenchProps): import("react").JSX.Element;
+//#endregion
+export { StudioAuthoringPromptContext, StudioAuthoringWorkbench, StudioAuthoringWorkbenchProps };