@deepseek-insight/dsi 0.5.5

package/build/server/chunks/chunks/env.js-l0sNRNKZ.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=env.js-l0sNRNKZ.js.map

package/build/server/chunks/chunks/exports.js-DMiPee3x.js

@@ -0,0 +1,263 @@
+var internal = new URL("sveltekit-internal://");
+/**
+* @param {string} base
+* @param {string} path
+*/
+function resolve(base, path) {
+	if (path[0] === "/" && path[1] === "/") return path;
+	let url = new URL(base, internal);
+	url = new URL(path, url);
+	return url.protocol === internal.protocol ? url.pathname + url.search + url.hash : url.href;
+}
+/**
+* @param {string} path
+* @param {import('types').TrailingSlash} trailing_slash
+*/
+function normalize_path(path, trailing_slash) {
+	if (path === "/" || trailing_slash === "ignore") return path;
+	if (trailing_slash === "never") return path.endsWith("/") ? path.slice(0, -1) : path;
+	else if (trailing_slash === "always" && !path.endsWith("/")) return path + "/";
+	return path;
+}
+/**
+* Decode pathname excluding %25 to prevent further double decoding of params
+* @param {string} pathname
+*/
+function decode_pathname(pathname) {
+	return pathname.split("%25").map(decodeURI).join("%25");
+}
+/** @param {Record<string, string>} params */
+function decode_params(params) {
+	for (const key in params) params[key] = decodeURIComponent(params[key]);
+	return params;
+}
+/**
+* @param {URL} url
+* @param {() => void} callback
+* @param {(search_param: string) => void} search_params_callback
+* @param {boolean} [allow_hash]
+*/
+function make_trackable(url, callback, search_params_callback, allow_hash = false) {
+	const tracked = new URL(url);
+	Object.defineProperty(tracked, "searchParams", {
+		value: new Proxy(tracked.searchParams, { get(obj, key) {
+			if (key === "get" || key === "getAll" || key === "has") return (param, ...rest) => {
+				search_params_callback(param);
+				return obj[key](param, ...rest);
+			};
+			callback();
+			const value = Reflect.get(obj, key);
+			return typeof value === "function" ? value.bind(obj) : value;
+		} }),
+		enumerable: true,
+		configurable: true
+	});
+	/**
+	* URL properties that could change during the lifetime of the page,
+	* which excludes things like `origin`
+	* @type {(keyof URL)[]}
+	*/
+	const tracked_url_properties = [
+		"href",
+		"pathname",
+		"search",
+		"toString",
+		"toJSON"
+	];
+	if (allow_hash) tracked_url_properties.push("hash");
+	for (const property of tracked_url_properties) Object.defineProperty(tracked, property, {
+		get() {
+			callback();
+			return url[property];
+		},
+		enumerable: true,
+		configurable: true
+	});
+	tracked[Symbol.for("nodejs.util.inspect.custom")] = (_depth, opts, inspect) => {
+		return inspect(url, opts);
+	};
+	tracked.searchParams[Symbol.for("nodejs.util.inspect.custom")] = (_depth, opts, inspect) => {
+		return inspect(url.searchParams, opts);
+	};
+	if (!allow_hash) disable_hash(tracked);
+	return tracked;
+}
+/**
+* Disallow access to `url.hash` on the server and in `load`
+* @param {URL} url
+*/
+function disable_hash(url) {
+	allow_nodejs_console_log(url);
+	Object.defineProperty(url, "hash", { get() {
+		throw new Error("Cannot access event.url.hash. Consider using `page.url.hash` inside a component instead");
+	} });
+}
+/**
+* Disallow access to `url.search` and `url.searchParams` during prerendering
+* @param {URL} url
+*/
+function disable_search(url) {
+	allow_nodejs_console_log(url);
+	for (const property of ["search", "searchParams"]) Object.defineProperty(url, property, { get() {
+		throw new Error(`Cannot access url.${property} on a page with prerendering enabled`);
+	} });
+}
+/**
+* Allow URL to be console logged, bypassing disabled properties.
+* @param {URL} url
+*/
+function allow_nodejs_console_log(url) {
+	url[Symbol.for("nodejs.util.inspect.custom")] = (_depth, opts, inspect) => {
+		return inspect(new URL(url), opts);
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/@sveltejs+kit@2.70.3_@sveltejs+vite-plugin-svelte@7.3.0_svelte@5.56.10_vite@8.2.2_@type_516d88433e8c68d15ca595d506c600a7/node_modules/@sveltejs/kit/src/utils/hash.js
+/**
+* Hash using djb2
+* @param {import('types').StrictBody[]} values
+*/
+function hash(...values) {
+	let hash = 5381;
+	for (const value of values) if (typeof value === "string") {
+		let i = value.length;
+		while (i) hash = hash * 33 ^ value.charCodeAt(--i);
+	} else if (ArrayBuffer.isView(value)) {
+		const buffer = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+		let i = buffer.length;
+		while (i) hash = hash * 33 ^ buffer[--i];
+	} else throw new TypeError("value must be a string or TypedArray");
+	return (hash >>> 0).toString(36);
+}
+//#endregion
+//#region node_modules/.pnpm/@sveltejs+kit@2.70.3_@sveltejs+vite-plugin-svelte@7.3.0_svelte@5.56.10_vite@8.2.2_@type_516d88433e8c68d15ca595d506c600a7/node_modules/@sveltejs/kit/src/utils/routing.js
+/**
+* @param {RegExpMatchArray} match
+* @param {import('types').RouteParam[]} params
+* @param {Record<string, import('@sveltejs/kit').ParamMatcher>} matchers
+*/
+function exec(match, params, matchers) {
+	/** @type {Record<string, string>} */
+	const result = {};
+	const values = match.slice(1);
+	const values_needing_match = values.filter((value) => value !== void 0);
+	let buffered = 0;
+	for (let i = 0; i < params.length; i += 1) {
+		const param = params[i];
+		let value = values[i - buffered];
+		if (param.chained && param.rest && buffered) {
+			value = values.slice(i - buffered, i + 1).filter((s) => s).join("/");
+			buffered = 0;
+		}
+		if (value === void 0) {
+			if (param.rest) value = "";
+			else continue;
+		}
+		if (!param.matcher || matchers[param.matcher](value)) {
+			result[param.name] = value;
+			const next_param = params[i + 1];
+			const next_value = values[i + 1];
+			if (next_param && !next_param.rest && next_param.optional && next_value && param.chained) buffered = 0;
+			if (!next_param && !next_value && Object.keys(result).length === values_needing_match.length) buffered = 0;
+			continue;
+		}
+		if (param.optional && param.chained) {
+			buffered++;
+			continue;
+		}
+		return;
+	}
+	if (buffered) return;
+	return result;
+}
+/**
+* Find the first route that matches the given path
+* @template {{pattern: RegExp, params: import('types').RouteParam[]}} Route
+* @param {string} path - The decoded pathname to match
+* @param {Route[]} routes
+* @param {Record<string, import('@sveltejs/kit').ParamMatcher>} matchers
+* @returns {{ route: Route, params: Record<string, string> } | null}
+*/
+function find_route(path, routes, matchers) {
+	for (const route of routes) {
+		const match = route.pattern.exec(path);
+		if (!match) continue;
+		const matched = exec(match, route.params, matchers);
+		if (matched) return {
+			route,
+			params: decode_params(matched)
+		};
+	}
+	return null;
+}
+//#endregion
+//#region node_modules/.pnpm/@sveltejs+kit@2.70.3_@sveltejs+vite-plugin-svelte@7.3.0_svelte@5.56.10_vite@8.2.2_@type_516d88433e8c68d15ca595d506c600a7/node_modules/@sveltejs/kit/src/utils/exports.js
+/**
+* @param {Set<string>} expected
+*/
+function validator(expected) {
+	/**
+	* @param {any} module
+	* @param {string} [file]
+	*/
+	function validate(module, file) {
+		if (!module) return;
+		for (const key in module) {
+			if (key[0] === "_" || expected.has(key)) continue;
+			const values = [...expected.values()];
+			const hint = hint_for_supported_files(key, file?.slice(file.lastIndexOf("."))) ?? `valid exports are ${values.join(", ")}, or anything with a '_' prefix`;
+			throw new Error(`Invalid export '${key}'${file ? ` in ${file}` : ""} (${hint})`);
+		}
+	}
+	return validate;
+}
+/**
+* @param {string} key
+* @param {string} ext
+* @returns {string | void}
+*/
+function hint_for_supported_files(key, ext = ".js") {
+	const supported_files = [];
+	if (valid_layout_exports.has(key)) supported_files.push(`+layout${ext}`);
+	if (valid_page_exports.has(key)) supported_files.push(`+page${ext}`);
+	if (valid_layout_server_exports.has(key)) supported_files.push(`+layout.server${ext}`);
+	if (valid_page_server_exports.has(key)) supported_files.push(`+page.server${ext}`);
+	if (valid_server_exports.has(key)) supported_files.push(`+server${ext}`);
+	if (supported_files.length > 0) return `'${key}' is a valid export in ${supported_files.slice(0, -1).join(", ")}${supported_files.length > 1 ? " or " : ""}${supported_files.at(-1)}`;
+}
+var valid_layout_exports = /* @__PURE__ */ new Set([
+	"load",
+	"prerender",
+	"csr",
+	"ssr",
+	"trailingSlash",
+	"config"
+]);
+var valid_page_exports = /* @__PURE__ */ new Set([...valid_layout_exports, "entries"]);
+var valid_layout_server_exports = /* @__PURE__ */ new Set([...valid_layout_exports]);
+var valid_page_server_exports = /* @__PURE__ */ new Set([
+	...valid_layout_server_exports,
+	"actions",
+	"entries"
+]);
+var valid_server_exports = /* @__PURE__ */ new Set([
+	"GET",
+	"POST",
+	"PATCH",
+	"PUT",
+	"DELETE",
+	"OPTIONS",
+	"HEAD",
+	"fallback",
+	"prerender",
+	"trailingSlash",
+	"config",
+	"entries"
+]);
+var validate_layout_exports = validator(valid_layout_exports);
+var validate_page_exports = validator(valid_page_exports);
+var validate_layout_server_exports = validator(valid_layout_server_exports);
+var validate_page_server_exports = validator(valid_page_server_exports);
+
+export { disable_search as a, validate_layout_exports as b, validate_page_server_exports as c, decode_pathname as d, validate_page_exports as e, find_route as f, hash as h, make_trackable as m, normalize_path as n, resolve as r, validate_layout_server_exports as v };
+//# sourceMappingURL=exports.js-DMiPee3x.js.map

package/build/server/chunks/chunks/goal-projection.js-0_34t60K.js

@@ -0,0 +1,44 @@
+//#region src/lib/services/conversation/goal-projection.ts
+var PHASES = /* @__PURE__ */ new Set([
+	"active",
+	"paused",
+	"blocked",
+	"complete"
+]);
+/**
+* Validate the projections block's goal value.
+*
+* @param raw - the projection value (projections.values.goal), untyped.
+* @returns undefined when the key is absent (not delivered), null when the
+* host has no current goal (or the value is malformed), else the validated
+* goal — createdAt/updatedAt are host bookkeeping and are dropped; every
+* GoalResultGoal field the UI renders is required and validated.
+*/
+function goalFromProjection(raw) {
+	if (raw === void 0) return void 0;
+	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return null;
+	const value = raw;
+	const g = value.goal;
+	if (g === null || typeof g !== "object" || Array.isArray(g)) return null;
+	const o = g;
+	if (typeof o.id !== "string" || o.id.length === 0) return null;
+	if (typeof o.objective !== "string" || o.objective.length === 0) return null;
+	if (typeof o.phase !== "string" || !PHASES.has(o.phase)) return null;
+	const reason = o.blockedReason;
+	if (!(reason === void 0 || reason !== null && typeof reason === "object" && typeof reason.code === "string" && typeof reason.message === "string")) return null;
+	return {
+		id: o.id,
+		revision: typeof o.revision === "number" ? o.revision : 0,
+		objective: o.objective,
+		phase: o.phase,
+		roundsStarted: typeof value.roundsStarted === "number" ? value.roundsStarted : 0,
+		maxGoalRounds: typeof o.maxGoalRounds === "number" ? o.maxGoalRounds : 0,
+		...reason !== void 0 ? { blockedReason: {
+			code: reason.code,
+			message: reason.message
+		} } : {}
+	};
+}
+
+export { goalFromProjection as g };
+//# sourceMappingURL=goal-projection.js-0_34t60K.js.map

package/build/server/chunks/chunks/image-limits.js-BMPZ55kJ.js

@@ -0,0 +1,186 @@
+//#region src/lib/services/conversation/permission-state.ts
+/** The derived not-a-preset state (read-only label; never a switch target). */
+/** The machine name whose product label is pinned to `Full access`. */
+var FULL_ACCESS_PRESET = "danger-full-access";
+/**
+* The shipped preset table (bundle/base/cordis.patch.yml — the default
+* composition, not the law; see the module header's divergence note).
+*/
+var PRESET_TABLE = {
+	"read-only": {
+		sandbox: "read-only",
+		approval: "ask",
+		label: "Read Only",
+		description: "Read files and run nothing that changes state; every action beyond reading requires approval."
+	},
+	"workspace-write": {
+		sandbox: "workspace-write",
+		approval: "ask",
+		label: "Workspace Write",
+		description: "Write inside the workspace and permitted temporary directories; wider retries require approval."
+	},
+	[FULL_ACCESS_PRESET]: {
+		sandbox: "danger-full-access",
+		approval: "never",
+		label: "Full access",
+		description: "Full file access without approval prompts."
+	}
+};
+/** Label transform (DSH PermissionSelect parity): kebab-case → Title Case,
+*  the pinned product labels, and raw pass-through for unknown names. */
+function presetLabel(name) {
+	if (name === "danger-full-access") return "Full access";
+	if (name === "custom") return "Custom";
+	if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(name)) return name;
+	return name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+/** Description lookup — local table only; unknown presets carry none. */
+function presetDescription(name) {
+	return PRESET_TABLE[name]?.description;
+}
+/** The three knob event types (SILENT_TYPES members — transcript noise,
+*  chip signal). */
+var KNOB_TYPES = /* @__PURE__ */ new Set([
+	"permission/preset",
+	"sandbox/mode",
+	"approval/policy"
+]);
+var EMPTY_KNOBS = {
+	preset: null,
+	sandbox: null,
+	approval: null
+};
+/** One-event knob transition; the SAME reference when the event is not a
+*  knob (the registry's change gate — DSH applyKnobEvent parity). */
+function applyKnobEvent(state, event) {
+	switch (event.type) {
+		case "permission/preset": {
+			const preset = event.data?.preset;
+			if (typeof preset !== "string") return state;
+			return {
+				...state,
+				preset
+			};
+		}
+		case "sandbox/mode": {
+			const mode = event.data?.mode;
+			if (typeof mode !== "string") return state;
+			return {
+				...state,
+				sandbox: mode
+			};
+		}
+		case "approval/policy": {
+			const policy = event.data?.policy;
+			if (typeof policy !== "string") return state;
+			return {
+				...state,
+				approval: policy
+			};
+		}
+		default: return state;
+	}
+}
+/** Filter an event window down to its knob events (poll/payload carrier). */
+function filterKnobEvents(events) {
+	return events.filter((e) => KNOB_TYPES.has(e.type));
+}
+/**
+* Derive the current mode from one folded knob state. Undefined = no
+* basis to resolve (all-null, or a partial triple that matches nothing)
+* — the caller keeps its projections baseline. A KNOWN mismatch of both
+* knobs resolves `custom` exactly when DSH's fold would.
+*/
+function resolvePermission(knobs) {
+	const { preset, sandbox, approval } = knobs;
+	if (preset === null && sandbox === null && approval === null) return void 0;
+	if (preset !== null) {
+		const spec = PRESET_TABLE[preset];
+		if (spec !== void 0 && (sandbox === null || sandbox === spec.sandbox) && (approval === null || approval === spec.approval)) return preset;
+	}
+	if (sandbox !== null && approval !== null) return Object.entries(PRESET_TABLE).find(([name, spec]) => spec.sandbox === sandbox && spec.approval === approval)?.[0] ?? "custom";
+}
+/**
+* Ingest the host's `permissions` projection value (the history tail
+* page's projections block) into the chip's read state. Structural and
+* conservative: a malformed member declines to undefined (the chip
+* hides — never renders a guessed mode). `custom` is filtered from the
+* options (readable as current, never switchable) and labels are sugared
+* through the pinned transform.
+*/
+function permissionFromProjection(raw) {
+	const v = raw;
+	if (v === null || typeof v !== "object" || typeof v.currentValue !== "string" || !Array.isArray(v.options)) return;
+	const options = [];
+	for (const o of v.options) {
+		const opt = o;
+		if (typeof opt?.value !== "string" || opt.value.length === 0) continue;
+		if (opt.value === "custom") continue;
+		const label = typeof opt.name === "string" && opt.name.length > 0 ? opt.name : opt.value;
+		options.push({
+			value: opt.value,
+			label: presetLabel(label),
+			...typeof opt.description === "string" && opt.description.length > 0 ? { description: opt.description } : {}
+		});
+	}
+	if (options.length === 0) return void 0;
+	return {
+		current: v.currentValue,
+		options
+	};
+}
+/** Local read state from the shipped table (fallback when the host ships
+*  no projections block but knob events exist — the shipped trio in
+*  table order, defaulting to the composition default). */
+function localPermission() {
+	return {
+		current: "workspace-write",
+		options: Object.entries(PRESET_TABLE).map(([value, spec]) => ({
+			value,
+			label: spec.label,
+			description: spec.description
+		}))
+	};
+}
+//#endregion
+//#region src/lib/services/conversation/image-limits.ts
+/** DSH documented defaults (fallback when no projection rides the tail). */
+var DEFAULT_IMAGE_LIMITS = {
+	maxImageBytes: 20971520,
+	maxImagesPerMessage: 20,
+	maxMessageImageBytes: 209715200,
+	maxImagePixels: 64e6,
+	maxImageDimension: 8192,
+	mediaTypes: [
+		"image/png",
+		"image/jpeg",
+		"image/webp",
+		"image/gif"
+	]
+};
+function isPositiveInt(value) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+/**
+* Validate the projections block's imageLimits value.
+*
+* @param raw - the projection value (projections.values.imageLimits), untyped.
+* @returns the six-field limits, or null when absent/malformed — the caller
+* then falls back to DEFAULT_IMAGE_LIMITS (BC-A6).
+*/
+function imageLimitsFromProjection(raw) {
+	if (!raw || typeof raw !== "object") return null;
+	const value = raw;
+	if (!isPositiveInt(value.maxImageBytes) || !isPositiveInt(value.maxImagesPerMessage) || !isPositiveInt(value.maxMessageImageBytes) || !isPositiveInt(value.maxImagePixels) || !isPositiveInt(value.maxImageDimension) || !Array.isArray(value.mediaTypes) || value.mediaTypes.length === 0 || !value.mediaTypes.every((t) => typeof t === "string" && t.length > 0)) return null;
+	return {
+		maxImageBytes: value.maxImageBytes,
+		maxImagesPerMessage: value.maxImagesPerMessage,
+		maxMessageImageBytes: value.maxMessageImageBytes,
+		maxImagePixels: value.maxImagePixels,
+		maxImageDimension: value.maxImageDimension,
+		mediaTypes: [...value.mediaTypes]
+	};
+}
+
+export { DEFAULT_IMAGE_LIMITS as D, EMPTY_KNOBS as E, applyKnobEvent as a, presetLabel as b, presetDescription as c, filterKnobEvents as f, imageLimitsFromProjection as i, localPermission as l, permissionFromProjection as p, resolvePermission as r };
+//# sourceMappingURL=image-limits.js-BMPZ55kJ.js.map