@deepseek-insight/dsi 0.5.9 → 0.5.11

package/build/server/chunks/entries/endpoints/api/workspace/git-status/_server.ts.js-CGSk5JWn.js

@@ -0,0 +1,80 @@
+import { s as statusFor, m as mapRpcFailure } from '../../../../../chunks/dsh-connection.js-DlwhJZaV.js';
+import { g as gitGateEnabled, i as isInsideRoot, a as gitStatus, G as GitUnavailableError } from '../../../../../chunks/git-probe.js-nfLEa58f.js';
+import { j as json } from '../../../../../chunks/utils.js-CAdNO8Tu.js';
+import '../../../../../chunks/config.js-D2vQdial.js';
+import '../../../../../chunks/insight-config.js-BwcV3Bct.js';
+import '../../../../../chunks/settings-document.js-BIwLIxnE.js';
+import 'node:fs';
+import 'node:path';
+import 'node:os';
+import 'yaml';
+import '../../../../../chunks/dsh-events.js-BtDxaV6Q.js';
+import '../../../../../chunks/permission-state.js-yvwUSnug.js';
+import 'node:child_process';
+import '../../../../../chunks/shared.js-HQ0rfhm4.js';
+import '../../../../../chunks/uneval.js-BJ9Qq2SF.js';
+
+//#region src/routes/api/workspace/git-status/+server.ts
+/**
+* api-workspace — GET /api/workspace/git-status?sessionId=…&root=…&repo=…
+*
+* Working-tree changes for ONE repo root, grouped view source (Git Eye ADR
+* 2026-09-12, D5): the DSI server runs a READ-ONLY git status, gated exactly
+* like git-map (ADR D2). The repo must BE the explorer's workspace root or
+* live inside it — realpath containment, refused 403 outside-workspace.
+* A missing git binary is a VISIBLE failure ({ ok:false, code:
+* 'git-unavailable' }), never a blank pane.
+*/
+var GET = async ({ url }) => {
+	const sessionId = url.searchParams.get("sessionId");
+	const root = url.searchParams.get("root");
+	const repo = url.searchParams.get("repo");
+	if (sessionId === null || sessionId.trim().length === 0 || root === null || root.trim().length === 0 || repo === null || repo.trim().length === 0) return json({
+		ok: false,
+		error: {
+			code: "bad-params",
+			message: "sessionId, root and repo are required"
+		}
+	}, { status: 400 });
+	let enabled;
+	try {
+		enabled = await gitGateEnabled(sessionId);
+	} catch (err) {
+		return json(mapRpcFailure(err), { status: statusFor(err) });
+	}
+	if (!enabled) return json({
+		ok: true,
+		enabled: false
+	});
+	if (!await isInsideRoot(root, repo)) return json({
+		ok: false,
+		error: {
+			code: "outside-workspace",
+			message: "the repo path is not inside the workspace root"
+		}
+	}, { status: 403 });
+	try {
+		const status = await gitStatus(repo);
+		return json({
+			ok: true,
+			enabled: true,
+			...status
+		});
+	} catch (err) {
+		if (err instanceof GitUnavailableError) return json({
+			ok: false,
+			code: "git-unavailable",
+			message: err.message
+		});
+		return json({
+			ok: false,
+			error: {
+				code: "status-failed",
+				message: err instanceof Error ? err.message : "status failed"
+			}
+		}, { status: statusFor(err) });
+	}
+};
+
+export { GET };
+//# sourceMappingURL=_server.ts.js-CGSk5JWn.js.map

package/build/server/chunks/entries/hooks.server.js-B7FsvqtT.js

@@ -0,0 +1,307 @@
+import { U as UI_LOCALES } from '../chunks/config.js-D2vQdial.js';
+import { r as readSettingsDocument } from '../chunks/settings-document.js-BIwLIxnE.js';
+import { g as getServerAsyncLocalStorage, i as isExcludedByRouteStrategy, s as serverAsyncLocalStorage, a as getStrategyForUrl, b as shouldRedirect, d as deLocalizeUrl, o as overwriteServerAsyncLocalStorage } from '../chunks/runtime.js-BPLc5RLR.js';
+import { parse } from 'yaml';
+import 'node:fs';
+import 'node:path';
+import 'node:os';
+
+//#region src/lib/paraglide/server.js
+/**
+* Server middleware that handles locale-based routing and request processing.
+*
+* Configure `disableAsyncLocalStorage` when generating Paraglide with
+* `paraglideVitePlugin()` or `compile()`, not when calling
+* `paraglideMiddleware()`. Keep AsyncLocalStorage enabled by default and
+* only disable it for runtimes that lack `AsyncLocalStorage` support and
+* guarantee request isolation.
+*
+* This middleware performs several key functions:
+*
+* 1. Determines the locale for the incoming request using configured strategies
+* 2. Handles URL localization and redirects (only for document requests)
+* 3. Maintains locale state using AsyncLocalStorage to prevent request interference
+*
+* When URL strategy is used:
+*
+* - The locale is extracted from the URL for all request types
+* - If URL doesn't match the determined locale, redirects to localized URL (only for document requests)
+* - De-localizes URLs before passing to server (e.g., `/fr/about` → `/about`)
+*
+* @see https://paraglidejs.com/middleware
+*
+* @template T - The return type of the resolve function
+*
+* @param {Request} request - The incoming request object
+* @param {(args: { request: Request, locale: import("./runtime.js").Locale }) => T | Promise<T>} resolve - Function to handle the request. The callback receives:
+*   - `request`: A modified request with a delocalized URL when the URL strategy is used (e.g., `/fr/about` → `/about`).
+*      If your framework handles URL localization itself (e.g., TanStack Router's `rewrite` option), use the original
+*      request instead to avoid redirect loops.
+*   - `locale`: The determined locale for this request.
+* @param {{
+*   effectiveRequestUrl?: string | URL | ((request: Request) => string | URL),
+*   onRedirect?: (response: Response) => void
+* }} [options] - Options to control middleware behavior. `effectiveRequestUrl` sets the effective request URL used for route matching, URL-based locale detection, redirects, and `getUrlOrigin()`.
+* @returns {Promise<Response>}
+*
+* @example
+* ```typescript
+* // Basic usage in metaframeworks like NextJS, SvelteKit, Astro, Nuxt, etc.
+* export const handle = async ({ event, resolve }) => {
+*   return paraglideMiddleware(event.request, ({ request, locale }) => {
+*     // let the framework further resolve the request
+*     return resolve(request);
+*   });
+* };
+* ```
+*
+* @example
+* ```typescript
+* // Usage in a framework like Express JS or Hono
+* app.use(async (req, res, next) => {
+*   const result = await paraglideMiddleware(req, ({ request, locale }) => {
+*     // If a redirect happens this won't be called
+*     return next(request);
+*   });
+* });
+* ```
+*
+* @example
+* ```typescript
+* // Usage with frameworks that handle URL localization/delocalization themselves
+* //
+* // Some frameworks like TanStack Router handle URL localization and delocalization
+* // themselves via their own rewrite APIs (e.g., `rewrite.input`/`rewrite.output`).
+* //
+* // When the framework handles this, the middleware's URL delocalization is not needed.
+* // Using the modified `request` from the callback would cause a redirect loop because
+* // both the middleware and the framework would attempt to delocalize the URL.
+* //
+* // Solution: Pass the original request to the handler instead of the modified one.
+* // The middleware still handles locale detection, cookies, and AsyncLocalStorage context.
+* //
+* // ❌ WRONG - causes redirect loop when framework handles URL rewriting:
+* // paraglideMiddleware(req, ({ request }) => handler.fetch(request))
+* //
+* // ✅ CORRECT - use original request when framework handles URL localization:
+* // paraglideMiddleware(req, () => handler.fetch(req))
+*
+* * *
+* export default {
+*   fetch(req: Request): Promise<Response> {
+*     // TanStack Router handles URL rewriting via deLocalizeUrl/localizeUrl
+*     // so we pass the original `req` instead of the modified `request`
+*     return paraglideMiddleware(req, () => handler.fetch(req))
+*   },
+* }
+* ```
+*/
+async function paraglideMiddleware(request, resolve, options) {
+	let requestAsyncLocalStorage = serverAsyncLocalStorage;
+	requestAsyncLocalStorage = getServerAsyncLocalStorage();
+	if (!requestAsyncLocalStorage) {
+		const { AsyncLocalStorage } = await import('async_hooks');
+		requestAsyncLocalStorage = getServerAsyncLocalStorage();
+		if (!requestAsyncLocalStorage) {
+			requestAsyncLocalStorage = new AsyncLocalStorage();
+			overwriteServerAsyncLocalStorage(requestAsyncLocalStorage);
+		}
+	}
+	if (!requestAsyncLocalStorage) {
+		requestAsyncLocalStorage = createMockAsyncLocalStorage();
+		overwriteServerAsyncLocalStorage(requestAsyncLocalStorage);
+	}
+	const url = resolveMiddlewareUrl(request, options?.effectiveRequestUrl);
+	const origin = url.origin;
+	if (isExcludedByRouteStrategy(url.href)) {
+		const locale = "en";
+		const newRequest = cloneRequestWithFallback(request, url);
+		/** @type {Set<string>} */
+		const messageCalls = /* @__PURE__ */ new Set();
+		return await requestAsyncLocalStorage?.run({
+			locale,
+			origin,
+			messageCalls
+		}, () => resolve({
+			locale,
+			request: newRequest
+		}));
+	}
+	const strategy = getStrategyForUrl(url.href);
+	const decision = await shouldRedirect({
+		request,
+		effectiveRequestUrl: url
+	});
+	const locale = decision.locale;
+	if (request.headers.get("Sec-Fetch-Dest") === "document" && decision.shouldRedirect && decision.redirectUrl) {
+		/** @type {Record<string, string>} */
+		const headers = {};
+		if (strategy.includes("preferredLanguage")) headers["Vary"] = "Accept-Language";
+		const response = new Response(null, {
+			status: 307,
+			headers: {
+				Location: decision.redirectUrl.href,
+				...headers
+			}
+		});
+		return response;
+	}
+	let newRequest;
+	if (strategy.includes("url")) newRequest = cloneRequestWithFallback(request, deLocalizeUrl(url));
+	else newRequest = cloneRequestWithFallback(request, url);
+	/** @type {Set<string>} */
+	const messageCalls = /* @__PURE__ */ new Set();
+	return await requestAsyncLocalStorage?.run({
+		locale,
+		origin,
+		messageCalls
+	}, () => resolve({
+		locale,
+		request: newRequest
+	}));
+}
+/**
+* @param {Request} request
+* @param {string | URL | ((request: Request) => string | URL) | undefined} effectiveRequestUrl
+* @returns {URL}
+*/
+function resolveMiddlewareUrl(request, effectiveRequestUrl) {
+	if (effectiveRequestUrl instanceof URL) return new URL(effectiveRequestUrl, request.url);
+	return new URL(request.url);
+}
+/**
+* Some metaframeworks (NextJS) require a new Request object.
+* https://github.com/opral/inlang-paraglide-js/issues/411
+*
+* However, some frameworks (TanStack Start 1.143+) use custom Request
+* implementations that cannot be cloned with `new Request(request)`.
+* https://github.com/opral/paraglide-js/issues/573
+*
+* Effective request URL overrides behind proxies:
+* https://github.com/opral/paraglide-js/issues/652
+*
+* @param {Request} request
+* @param {string | URL} [url]
+* @returns {Request}
+*/
+function cloneRequestWithFallback(request, url = request.url) {
+	const targetUrl = typeof url === "string" ? url : url.href;
+	if (targetUrl === request.url) try {
+		return new Request(request.clone());
+	} catch {
+		try {
+			return new Request(request);
+		} catch {
+			return request;
+		}
+	}
+	try {
+		return new Request(targetUrl, request.clone());
+	} catch {
+		try {
+			return new Request(targetUrl, request);
+		} catch {
+			return request;
+		}
+	}
+}
+/**
+* Creates a mock AsyncLocalStorage implementation for environments where
+* native AsyncLocalStorage is not available or disabled.
+*
+* This mock implementation mimics the behavior of the native AsyncLocalStorage
+* but doesn't require the async_hooks module. It's used as a fallback when
+* the runtime does not expose AsyncLocalStorage or when it has been disabled.
+*
+* @returns {import("./runtime.js").ParaglideAsyncLocalStorage}
+*/
+function createMockAsyncLocalStorage() {
+	/** @type {any} */
+	let currentStore = void 0;
+	return {
+		getStore() {
+			return currentStore;
+		},
+		async run(store, callback) {
+			currentStore = store;
+			try {
+				return await callback();
+			} finally {
+				currentStore = void 0;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/lib/server/locale.ts
+/**
+* The operator's `ui.locale` default from ~/.dsi/settings.yaml — the raw
+* value (NOT gated): an absent section/missing file returns undefined so
+* the resolver treats yaml as silent and falls through. configPath is the
+* test seam (same shape as readSettingsDocument's own).
+*/
+function readOperatorYamlLocale(configPath) {
+	try {
+		const { text, missing } = readSettingsDocument("dsi", configPath);
+		if (missing) return void 0;
+		const doc = parse(text);
+		if (doc && typeof doc === "object" && "ui" in doc) return doc.ui?.locale;
+		return;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/hooks.server.ts
+/**
+* SSR locale middleware — Three Tongues W1 task 1.4 (ADR 2026-09-12 D2/D3).
+*
+* paraglideMiddleware resolves the request locale with the compiled
+* strategy order (cookie → preferredLanguage → baseLocale). The ADR's
+* operator default (ui.locale in settings.yaml) slots BETWEEN cookie and
+* header: when the request carries no dsi.locale cookie, we inject the
+* yaml default as a cookie on the request before the middleware runs —
+* so paraglide's cookie strategy reads it and the order becomes exactly
+* cookie → yaml → Accept-Language → en.
+*
+* The resolved locale lands in the page via the %paraglide.locale%
+* placeholder in src/app.html (first paint, no flash).
+*
+* The root layout's config-fetch contract (+layout.ts) is untouched:
+* this handle hook composes BEFORE Kit's own plumbing and changes no
+* fetch behavior.
+*/
+/** The request's dsi.locale cookie value, if it names a fleet locale. */
+function validCookieLocale(request) {
+	const raw = request.headers.get("cookie")?.split(";").map((c) => c.trim()).find((c) => c.startsWith("dsi.locale="))?.slice(11);
+	return raw !== void 0 && UI_LOCALES.includes(raw) ? raw : void 0;
+}
+var handle = async ({ event, resolve }) => {
+	const yamlLocale = readOperatorYamlLocale();
+	let request = event.request;
+	if (yamlLocale !== void 0 && validCookieLocale(request) === void 0) {
+		const headers = new Headers(request.headers);
+		const kept = (headers.get("cookie") ?? "").split(";").map((c) => c.trim()).filter((c) => c.length > 0 && !c.startsWith("dsi.locale="));
+		kept.push("dsi.locale=" + encodeURIComponent(String(yamlLocale)));
+		headers.set("cookie", kept.join("; "));
+		event.cookies.set("dsi.locale", String(yamlLocale), {
+			path: "/",
+			httpOnly: false,
+			secure: event.url.protocol === "https:"
+		});
+		request = new Request(request.url, {
+			method: request.method,
+			headers,
+			body: request.body,
+			duplex: "half"
+		});
+		event.request = request;
+	}
+	return paraglideMiddleware(request, ({ request: localizedRequest, locale }) => {
+		event.request = localizedRequest;
+		return resolve(event, { transformPageChunk: ({ html }) => html.replace("%paraglide.locale%", locale) });
+	});
+};
+
+export { handle };
+//# sourceMappingURL=hooks.server.js-B7FsvqtT.js.map

package/build/server/chunks/entries/pages/_error.svelte.js-BVjBiEZD.js

@@ -0,0 +1,183 @@
+import { V as head, W as escape_html, y as derived } from '../../chunks/server.js-11-pxAWV.js';
+import { c as getLocale } from '../../chunks/runtime.js-BPLc5RLR.js';
+import { t, p as page } from '../../chunks/state.js-BB7-MsQ0.js';
+import '../../chunks/uneval.js-BJ9Qq2SF.js';
+import '../../chunks/internal.js-CRfRCfoU.js';
+import '../../chunks/shared.js-HQ0rfhm4.js';
+import '../../chunks/exports.js-DH_tjtdv.js';
+import '../../chunks/config.js-D2vQdial.js';
+import '../../chunks/utils.js-CAdNO8Tu.js';
+
+//#region src/lib/paraglide/messages/backtoworkspace2.js
+/** @typedef {import('../runtime.js').LocalizedString} LocalizedString */
+/** @typedef {{}} Backtoworkspace2Inputs */
+var en_backtoworkspace2 = () => {
+	return `← Back to the workspace`;
+};
+var zh_backtoworkspace2 = () => {
+	return `← 返回工作区`;
+};
+var id_backtoworkspace2 = () => {
+	return `← Kembali ke workspace`;
+};
+/**
+* | output |
+* | --- |
+* | "← Back to the workspace" |
+*
+* @param {Backtoworkspace2Inputs} inputs
+* @param {{ locale?: "en" | "zh" | "id" }} options
+* @returns {LocalizedString}
+*/
+var backtoworkspace2 = ((inputs = {}, options = {}) => {
+	const locale = options.locale ?? getLocale();
+	if (locale === "zh") return zh_backtoworkspace2();
+	if (locale === "id") return id_backtoworkspace2();
+	return en_backtoworkspace2();
+});
+//#endregion
+//#region src/lib/paraglide/messages/dshunreachable1.js
+/** @typedef {import('../runtime.js').LocalizedString} LocalizedString */
+/** @typedef {{}} Dshunreachable1Inputs */
+var en_dshunreachable1 = () => {
+	return `DSH host unreachable`;
+};
+var zh_dshunreachable1 = () => {
+	return `DSH 主机不可达`;
+};
+var id_dshunreachable1 = () => {
+	return `Host DSH tidak dapat dijangkau`;
+};
+/**
+* | output |
+* | --- |
+* | "DSH host unreachable" |
+*
+* @param {Dshunreachable1Inputs} inputs
+* @param {{ locale?: "en" | "zh" | "id" }} options
+* @returns {LocalizedString}
+*/
+var dshunreachable1 = ((inputs = {}, options = {}) => {
+	const locale = options.locale ?? getLocale();
+	if (locale === "zh") return zh_dshunreachable1();
+	if (locale === "id") return id_dshunreachable1();
+	return en_dshunreachable1();
+});
+//#endregion
+//#region src/lib/paraglide/messages/reapednote1.js
+/** @typedef {import('../runtime.js').LocalizedString} LocalizedString */
+/** @typedef {{}} Reapednote1Inputs */
+var en_reapednote1 = () => {
+	return `It may have been reaped, or the link predates this host's ledger.`;
+};
+var zh_reapednote1 = () => {
+	return `它可能已被回收，或链接早于此主机的账本。`;
+};
+var id_reapednote1 = () => {
+	return `Mungkin sudah dihapus, atau tautannya lebih tua dari ledger host ini.`;
+};
+/**
+* | output |
+* | --- |
+* | "It may have been reaped, or the link predates this host's ledger." |
+*
+* @param {Reapednote1Inputs} inputs
+* @param {{ locale?: "en" | "zh" | "id" }} options
+* @returns {LocalizedString}
+*/
+var reapednote1 = ((inputs = {}, options = {}) => {
+	const locale = options.locale ?? getLocale();
+	if (locale === "zh") return zh_reapednote1();
+	if (locale === "id") return id_reapednote1();
+	return en_reapednote1();
+});
+//#endregion
+//#region src/lib/paraglide/messages/sessionnotfound2.js
+/** @typedef {import('../runtime.js').LocalizedString} LocalizedString */
+/** @typedef {{}} Sessionnotfound2Inputs */
+var en_sessionnotfound2 = () => {
+	return `Session not found`;
+};
+var zh_sessionnotfound2 = () => {
+	return `会话未找到`;
+};
+var id_sessionnotfound2 = () => {
+	return `Sesi tidak ditemukan`;
+};
+/**
+* | output |
+* | --- |
+* | "Session not found" |
+*
+* @param {Sessionnotfound2Inputs} inputs
+* @param {{ locale?: "en" | "zh" | "id" }} options
+* @returns {LocalizedString}
+*/
+var sessionnotfound2 = ((inputs = {}, options = {}) => {
+	const locale = options.locale ?? getLocale();
+	if (locale === "zh") return zh_sessionnotfound2();
+	if (locale === "id") return id_sessionnotfound2();
+	return en_sessionnotfound2();
+});
+//#endregion
+//#region src/lib/paraglide/messages/unexpectederror1.js
+/** @typedef {import('../runtime.js').LocalizedString} LocalizedString */
+/** @typedef {{}} Unexpectederror1Inputs */
+var en_unexpectederror1 = () => {
+	return `Unexpected error`;
+};
+var zh_unexpectederror1 = () => {
+	return `意外错误`;
+};
+var id_unexpectederror1 = () => {
+	return `Kesalahan tak terduga`;
+};
+/**
+* | output |
+* | --- |
+* | "Unexpected error" |
+*
+* @param {Unexpectederror1Inputs} inputs
+* @param {{ locale?: "en" | "zh" | "id" }} options
+* @returns {LocalizedString}
+*/
+var unexpectederror1 = ((inputs = {}, options = {}) => {
+	const locale = options.locale ?? getLocale();
+	if (locale === "zh") return zh_unexpectederror1();
+	if (locale === "id") return id_unexpectederror1();
+	return en_unexpectederror1();
+});
+//#endregion
+//#region src/routes/+error.svelte
+function _error($$renderer, $$props) {
+	$$renderer.component(($$renderer) => {
+		/**
+		* App-wide error boundary (the Root-is-the-Floor ADR, 2026-09-02):
+		* 404 (session absent — and any retired address), 503 (host down),
+		* 409 (sub-agent ownership). The way back is `/` itself: a bare
+		* arrival restores the persisted desk, so "back" costs nothing.
+		*/
+		const status = derived(() => page.status);
+		const message = derived(() => page.error?.message ?? "Something went wrong.");
+		head("1j96wlh", $$renderer, ($$renderer) => {
+			$$renderer.title(($$renderer) => {
+				$$renderer.push(`<title>${escape_html(status())} — deepseek-insight</title>`);
+			});
+		});
+		$$renderer.push(`<main data-svelte="ErrorPage" class="mx-auto flex max-w-3xl flex-col items-center gap-4 px-4 py-16 text-center"><p class="text-5xl font-semibold text-slate-300" data-testid="error-status">${escape_html(status())}</p> `);
+		if (status() === 404) {
+			$$renderer.push("<!--[0-->");
+			$$renderer.push(`<h1 class="text-xl font-semibold">${escape_html(t(sessionnotfound2))}</h1> <p class="text-sm text-slate-500" data-testid="error-message">${escape_html(message())}</p> <p class="text-xs text-slate-400">${escape_html(t(reapednote1))}</p>`);
+		} else if (status() === 503) {
+			$$renderer.push("<!--[1-->");
+			$$renderer.push(`<h1 class="text-xl font-semibold">${escape_html(t(dshunreachable1))}</h1> <p class="text-sm text-slate-500" data-testid="error-message">${escape_html(message())}</p>`);
+		} else {
+			$$renderer.push("<!--[-1-->");
+			$$renderer.push(`<h1 class="text-xl font-semibold">${escape_html(t(unexpectederror1))}</h1> <p class="text-sm text-slate-500" data-testid="error-message">${escape_html(message())}</p>`);
+		}
+		$$renderer.push(`<!--]--> <a href="/" class="mt-2 rounded-md border border-slate-300 px-3 py-1.5 text-sm text-slate-600 hover:bg-slate-100" data-testid="error-back-home">${escape_html(t(backtoworkspace2))}</a></main>`);
+	});
+}
+
+export { _error as default };
+//# sourceMappingURL=_error.svelte.js-BVjBiEZD.js.map

package/build/server/chunks/entries/pages/{_page.server.ts.js-BGXwU4Ay.js → _page.server.ts.js-CNU4x-f1.js}

@@ -1,7 +1,8 @@
-import { g as getDshConnection, D as DshRpcError, i as isSubagentRejection } from '../../chunks/dsh-connection.js-D52KwDXm.js';
+import { g as getDshConnection, D as DshRpcError, i as isSubagentRejection } from '../../chunks/dsh-connection.js-DlwhJZaV.js';
 import { h as historyToEvents, e as eventsToEntries } from '../../chunks/dsh-events.js-BtDxaV6Q.js';
-import { p as permissionFromProjection, i as imageLimitsFromProjection, f as filterKnobEvents } from '../../chunks/image-limits.js-BMPZ55kJ.js';
-import { v as error } from '../../chunks/utils.js-tOWCe9Wk.js';
+import { p as permissionFromProjection, f as filterKnobEvents } from '../../chunks/permission-state.js-yvwUSnug.js';
+import { i as imageLimitsFromProjection } from '../../chunks/image-limits.js-CUdJ0f7r.js';
+import { v as error } from '../../chunks/utils.js-CAdNO8Tu.js';
 
 //#region src/routes/+page.server.ts
 /**
@@ -82,4 +83,4 @@ var _page_server_ts = /*#__PURE__*/Object.freeze({
 });
 
 export { _page_server_ts as _ };
-//# sourceMappingURL=_page.server.ts.js-BGXwU4Ay.js.map
+//# sourceMappingURL=_page.server.ts.js-CNU4x-f1.js.map