@artenx/dshb 0.1.18 → 0.1.20

package/lib/{workspace-instruction-context-DytAmaPY.js → lib-gdtU_WKT.js}

@@ -1,4 +1,3 @@
-import { sharedSessionInstructionSnapshotStore, sharedWorkspaceInstructionStore } from "./core/workspace-instructions.js";
 import { createRequire } from "node:module";
 import { Context, Service } from "@deepseek-ai/cordis";
 //#region ../../node_modules/@deepseek-ai/dsh-typert-protocol/lib/index.js
@@ -817,6 +816,155 @@ function assertNever(value, context) {
 	const rendered = JSON.stringify(value) ?? String(value);
 	throw new Error(`unreachable variant${context ? ` in ${context}` : ""}: ${rendered}`);
 }
+/** Whether a realm-owned intrinsic prototype has a native constructor matching this engine's representation. */
+function hasIntrinsicConstructor(prototype, name) {
+	const constructor = Object.getOwnPropertyDescriptor(prototype, "constructor")?.value;
+	if (typeof constructor !== "function") return false;
+	try {
+		return constructor.name === name && constructor.prototype === prototype && Function.prototype.toString.call(constructor) === Function.prototype.toString.call(name === "Array" ? Array : Object);
+	} catch {
+		return false;
+	}
+}
+/** Whether a candidate is one realm's intrinsic `Object.prototype`. */
+function isIntrinsicObjectPrototype(value) {
+	return Object.getPrototypeOf(value) === null && hasIntrinsicConstructor(value, "Object");
+}
+/** Whether an array uses one realm's intrinsic `Array.prototype`, not a subclass or forged prototype. */
+function hasPlainArrayPrototype(value) {
+	const prototype = Object.getPrototypeOf(value);
+	if (!Array.isArray(prototype) || !hasIntrinsicConstructor(prototype, "Array")) return false;
+	const objectPrototype = Object.getPrototypeOf(prototype);
+	return typeof objectPrototype === "object" && objectPrototype !== null && isIntrinsicObjectPrototype(objectPrototype);
+}
+/** Whether an object is a plain or null-prototype record from any JavaScript realm. */
+function hasPlainObjectPrototype(value) {
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || typeof prototype === "object" && isIntrinsicObjectPrototype(prototype);
+}
+/** Return every JSON-visible object key, or reject own data JSON would discard. */
+function enumerableStringKeys(value) {
+	const keys = Reflect.ownKeys(value);
+	if (keys.some((key) => typeof key !== "string" || !Object.prototype.propertyIsEnumerable.call(value, key))) return void 0;
+	return keys;
+}
+/** Validate lossless JSON iteratively, optionally materializing a detached snapshot. */
+function walkJsonValue(value, detach) {
+	const ancestors = /* @__PURE__ */ new Set();
+	let root;
+	const assign = (destination, item) => {
+		if (destination === void 0) return;
+		if (destination.kind === "root") root = item;
+		else if (destination.kind === "array") destination.target[destination.index] = item;
+		else Object.defineProperty(destination.target, destination.key, {
+			value: item,
+			enumerable: true,
+			configurable: true,
+			writable: true
+		});
+	};
+	const tasks = [{
+		kind: "visit",
+		value,
+		...detach ? { destination: { kind: "root" } } : {}
+	}];
+	for (let task = tasks.pop(); task !== void 0; task = tasks.pop()) {
+		if (task.kind === "leave") {
+			ancestors.delete(task.source);
+			continue;
+		}
+		if (task.kind === "array-item") {
+			if (!Object.prototype.hasOwnProperty.call(task.source, task.index)) return void 0;
+			tasks.push({
+				kind: "visit",
+				value: task.source[task.index],
+				...task.target === void 0 ? {} : { destination: {
+					kind: "array",
+					target: task.target,
+					index: task.index
+				} }
+			});
+			continue;
+		}
+		if (task.kind === "object-property") {
+			tasks.push({
+				kind: "visit",
+				value: task.source[task.key],
+				...task.target === void 0 ? {} : { destination: {
+					kind: "object",
+					target: task.target,
+					key: task.key
+				} }
+			});
+			continue;
+		}
+		const current = task.value;
+		if (current === null) {
+			assign(task.destination, null);
+			continue;
+		}
+		if (typeof current === "boolean" || typeof current === "string") {
+			assign(task.destination, current);
+			continue;
+		}
+		if (typeof current === "number") {
+			if (!Number.isFinite(current) || Object.is(current, -0)) return void 0;
+			assign(task.destination, current);
+			continue;
+		}
+		if (typeof current !== "object") return void 0;
+		if (ancestors.has(current)) return void 0;
+		if (Array.isArray(current)) {
+			if (!hasPlainArrayPrototype(current)) return void 0;
+			const length = current.length;
+			if (Reflect.ownKeys(current).length !== length + 1) return void 0;
+			const target = detach ? [] : void 0;
+			if (target !== void 0) assign(task.destination, target);
+			ancestors.add(current);
+			tasks.push({
+				kind: "leave",
+				source: current
+			});
+			for (let index = length - 1; index >= 0; index--) tasks.push({
+				kind: "array-item",
+				source: current,
+				index,
+				...target === void 0 ? {} : { target }
+			});
+			continue;
+		}
+		if (!hasPlainObjectPrototype(current)) return void 0;
+		const keys = enumerableStringKeys(current);
+		if (keys === void 0) return void 0;
+		const target = detach ? {} : void 0;
+		if (target !== void 0) assign(task.destination, target);
+		ancestors.add(current);
+		tasks.push({
+			kind: "leave",
+			source: current
+		});
+		for (let index = keys.length - 1; index >= 0; index--) {
+			const key = keys[index];
+			/* v8 ignore next -- the loop is bounded by the captured key count. */
+			if (key === void 0) return void 0;
+			tasks.push({
+				kind: "object-property",
+				source: current,
+				key,
+				...target === void 0 ? {} : { target }
+			});
+		}
+	}
+	return detach ? root : true;
+}
+/**
+* Validate and detach lossless JSON in one read per property.
+* @param value - candidate value to validate and detach.
+* @returns the detached snapshot, or `undefined` when the value is not losslessly JSON-serializable.
+*/
+function snapshotJsonValue(value) {
+	return walkJsonValue(value, true);
+}
 /**
 * Deep-freeze an object graph in place while leaving live AbortSignal objects mutable.
 * @param value - value to freeze.
@@ -895,6 +1043,14 @@ function randomUUID() {
 function brandString(value) {
 	return value;
 }
+/**
+* Apply a compile-time number brand without changing the value.
+* @param value - number admitted by the domain that owns the target brand.
+* @returns the same number with the requested compile-time brand.
+*/
+function brandNumber(value) {
+	return value;
+}
 //#endregion
 //#region ../../node_modules/@deepseek-ai/cosmokit/lib/index.js
 /** Return true when a value is `null` or `undefined`. */
@@ -2988,105 +3144,6 @@ function detachDirectoryEntry(entry) {
 	};
 }
 //#endregion
-//#region src/core/workspace-instruction-context.ts
-const SYSTEM_REMINDER_OPEN = "<system-reminder>";
-const SYSTEM_REMINDER_CLOSE = "</system-reminder>";
-const INSTRUCTION_INTRO = "The following project instructions are managed by the user for this DSH workspace. Follow them as persistent workspace guidance. They take precedence over repository-provided workspace guidance. System, developer, and direct user instructions take precedence over these project instructions.";
-function escapeInstructionFrameBody(body) {
-	return body.replaceAll(SYSTEM_REMINDER_CLOSE, "<\\/system-reminder>");
-}
-function renderInstructionMessageText(workspaceTitle, text) {
-	const escaped = escapeInstructionFrameBody(text);
-	return `${SYSTEM_REMINDER_OPEN}\n${INSTRUCTION_INTRO}\n\nInstructions for workspace: ${workspaceTitle}\n\n${escaped}\n${SYSTEM_REMINDER_CLOSE}`;
-}
-function createInstructionMessage(workspaceId, workspaceTitle, snapshot) {
-	return createUserMessage({
-		content: [{
-			type: "text",
-			text: renderInstructionMessageText(workspaceTitle, snapshot.text)
-		}],
-		source: {
-			kind: "dshb-workspace-instructions",
-			form: "instructions",
-			workspaceId,
-			revision: snapshot.workspaceRevision,
-			digest: snapshot.digest,
-			snapshot: true
-		}
-	});
-}
-function hasDirectUserMessage(messages) {
-	return messages.some((m) => m.role === "user" && m.source.kind === "user");
-}
-function hasOwnInstructionMessage(agent) {
-	const nodes = agent.session.surface?.nodes;
-	if (!nodes) return false;
-	for (const seq of nodes) {
-		const event = agent.session.eventAt?.(seq);
-		if (event?.type === "user/message" && event.data.source.kind === "dshb-workspace-instructions") return true;
-	}
-	return false;
-}
-async function resolveSnapshotForSession(agent, messages, workspaceStore = sharedWorkspaceInstructionStore(), snapshotStore = sharedSessionInstructionSnapshotStore(), registry) {
-	const sessionId = agent.session.id;
-	const existing = snapshotStore.get(sessionId);
-	if (existing) return existing;
-	if (!(hasDirectUserMessage(messages) && !hasOwnInstructionMessage(agent))) return void 0;
-	let workspaceId;
-	const cwd = agent.session.header.cwd;
-	if (registry && cwd) try {
-		const ws = await registry.resolveByPath(cwd);
-		if (ws) {
-			workspaceId = ws.id;
-			ws.title;
-		}
-	} catch {}
-	const record = workspaceId ? workspaceStore.get(workspaceId) : void 0;
-	if (!record || record.text.length === 0) return snapshotStore.createIfAbsent(sessionId, {
-		kind: "empty",
-		workspaceId
-	});
-	return snapshotStore.createIfAbsent(sessionId, {
-		kind: "workspace",
-		record,
-		workspaceId
-	});
-}
-function registerWorkspaceInstructionInjector(ctx) {
-	if (typeof ctx.on !== "function") return;
-	const workspaceStore = sharedWorkspaceInstructionStore();
-	const snapshotStore = sharedSessionInstructionSnapshotStore();
-	ctx.on("agent/pre-step", async ({ agent, messages, signal }, next) => {
-		const decision = await next();
-		if (decision.kind === "reject") return decision;
-		signal.throwIfAborted();
-		const agentLike = agent;
-		const messagesLike = messages;
-		const registry = ctx.get("workspaceRegistry");
-		let snapshot = snapshotStore.get(agentLike.session.id);
-		if (!snapshot) snapshot = await resolveSnapshotForSession(agentLike, messagesLike, workspaceStore, snapshotStore, registry);
-		signal.throwIfAborted();
-		if (!snapshot || snapshot.text.length === 0) return decision;
-		if (hasOwnInstructionMessage(agentLike)) return decision;
-		const workspaceId = snapshot.workspaceId;
-		if (!workspaceId) return decision;
-		const message = createInstructionMessage(workspaceId, (registry?.get(workspaceId))?.title ?? "Unknown", snapshot);
-		const lastClaimedIndex = decision.messages.findLastIndex((m) => messages.includes(m));
-		const entered = decision.messages.toSpliced(lastClaimedIndex + 1, 0, message);
-		return {
-			...decision,
-			messages: entered
-		};
-	});
-	try {
-		ctx.on?.("session/deleted", (sessionId) => {
-			snapshotStore.remove(sessionId);
-		});
-	} catch {}
-}
-const name = "dshb-workspace-instruction-injector";
-const inject = ["workspaceRegistry"];
-//#endregion
-export { registerWorkspaceInstructionInjector as a, name as i, escapeInstructionFrameBody as n, renderInstructionMessageText as o, inject as r, resolveSnapshotForSession as s, createInstructionMessage as t };
+export { snapshotJsonValue as a, deepFreeze as i, brandNumber as n, brandString as r, createUserMessage as t };
 
-//# sourceMappingURL=workspace-instruction-context-DytAmaPY.js.map
+//# sourceMappingURL=lib-gdtU_WKT.js.map