@jskit-ai/assistant-voice 0.1.1 → 0.1.2

package/examples/conversation/node_modules/.vite/deps/@jskit-ai_kernel_client_moduleBootstrap.js

@@ -1,824 +0,0 @@
-Object.freeze([
-	"none",
-	"pending",
-	"committed",
-	"rolledBack",
-	"unknown"
-]);
-function isRecord(value) {
-	return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-Object.freeze(["bundled", "dev_server"]);
-Object.freeze(["capacitor"]);
-Object.freeze({
-	callbackPath: "/auth/login",
-	customScheme: "",
-	appLinkDomains: Object.freeze([])
-});
-Object.freeze({
-	packageName: "",
-	minSdk: 26,
-	targetSdk: 35,
-	versionCode: 1,
-	versionName: "1.0.0"
-});
-//#endregion
-//#region ../../../kernel/shared/capabilities/defineProvider.js
-var ARCHITECTURE_ID_PATTERN = /^[a-z][a-z0-9_.-]*$/u;
-var LOCAL_NAME_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/u;
-function normalizeArchitectureId(value, label) {
-	const normalized = String(value || "").trim().toLowerCase();
-	if (!ARCHITECTURE_ID_PATTERN.test(normalized)) throw new TypeError(`${label} must match ${ARCHITECTURE_ID_PATTERN.toString()}.`);
-	return normalized;
-}
-function normalizeCapabilityMap(value, label) {
-	if (value == null) return Object.freeze({});
-	if (!isRecord(value)) throw new TypeError(`${label} must be an object mapping local names to capability ids.`);
-	const normalized = {};
-	const seenCapabilityIds = /* @__PURE__ */ new Set();
-	for (const [rawLocalName, rawCapabilityId] of Object.entries(value)) {
-		const localName = String(rawLocalName || "").trim();
-		if (!LOCAL_NAME_PATTERN.test(localName)) throw new TypeError(`${label} local name "${localName}" must be a JavaScript identifier.`);
-		const capabilityId = normalizeArchitectureId(rawCapabilityId, `${label}.${localName}`);
-		if (seenCapabilityIds.has(capabilityId)) throw new TypeError(`${label} declares capability "${capabilityId}" more than once.`);
-		seenCapabilityIds.add(capabilityId);
-		normalized[localName] = capabilityId;
-	}
-	return Object.freeze(normalized);
-}
-function assertDistinctLocalNames(maps) {
-	const owners = /* @__PURE__ */ new Map();
-	for (const [kind, entries] of Object.entries(maps)) for (const localName of Object.keys(entries)) {
-		if (owners.has(localName)) throw new TypeError(`Provider local name "${localName}" is declared by both ${owners.get(localName)} and ${kind}.`);
-		owners.set(localName, kind);
-	}
-}
-function normalizeLifecycleMethod(value, label) {
-	if (value == null) return null;
-	if (typeof value !== "function") throw new TypeError(`${label} must be a function when provided.`);
-	return value;
-}
-function defineProvider({ id, requires = {}, optional = {}, provides = {}, setup, boot = null, shutdown = null } = {}) {
-	const providerId = normalizeArchitectureId(id, "Provider id");
-	const normalizedRequires = normalizeCapabilityMap(requires, `${providerId}.requires`);
-	const normalizedOptional = normalizeCapabilityMap(optional, `${providerId}.optional`);
-	const normalizedProvides = normalizeCapabilityMap(provides, `${providerId}.provides`);
-	assertDistinctLocalNames({
-		requires: normalizedRequires,
-		optional: normalizedOptional,
-		provides: normalizedProvides
-	});
-	const setupMethod = normalizeLifecycleMethod(setup, `${providerId}.setup`);
-	if (!setupMethod) throw new TypeError(`${providerId}.setup is required.`);
-	return Object.freeze({
-		id: providerId,
-		requires: normalizedRequires,
-		optional: normalizedOptional,
-		provides: normalizedProvides,
-		setup: setupMethod,
-		boot: normalizeLifecycleMethod(boot, `${providerId}.boot`),
-		shutdown: normalizeLifecycleMethod(shutdown, `${providerId}.shutdown`)
-	});
-}
-//#endregion
-//#region ../../../kernel/shared/capabilities/runtime.js
-function normalizeProviderDefinition(value) {
-	if (!isRecord(value)) throw new TypeError("Capability runtime providers must be provider definitions.");
-	return defineProvider(value);
-}
-function normalizeInputCapabilities(value) {
-	if (value == null) return /* @__PURE__ */ new Map();
-	if (!isRecord(value)) throw new TypeError("Capability runtime inputs must be an object keyed by capability id.");
-	return new Map(Object.entries(value).map(([id, capability]) => [normalizeArchitectureId(id, "Runtime input capability id"), capability]));
-}
-function providerCapabilityIds(provider, field) {
-	return Object.values(provider[field] || {});
-}
-function buildProviderOrder(providers, inputCapabilities) {
-	const normalizedProviders = providers.map(normalizeProviderDefinition);
-	const providersById = /* @__PURE__ */ new Map();
-	const providerByCapability = /* @__PURE__ */ new Map();
-	for (const provider of normalizedProviders) {
-		if (providersById.has(provider.id)) throw new Error(`Provider "${provider.id}" is duplicated.`);
-		providersById.set(provider.id, provider);
-		for (const capabilityId of providerCapabilityIds(provider, "provides")) {
-			if (inputCapabilities.has(capabilityId)) throw new Error(`Capability "${capabilityId}" is supplied both as a runtime input and by ${provider.id}.`);
-			if (providerByCapability.has(capabilityId)) throw new Error(`Capability "${capabilityId}" is provided by both ${providerByCapability.get(capabilityId).id} and ${provider.id}.`);
-			providerByCapability.set(capabilityId, provider);
-		}
-	}
-	for (const provider of normalizedProviders) for (const capabilityId of providerCapabilityIds(provider, "requires")) {
-		if (!inputCapabilities.has(capabilityId) && !providerByCapability.has(capabilityId)) throw new Error(`Provider "${provider.id}" requires missing capability "${capabilityId}".`);
-		if (providerByCapability.get(capabilityId)?.id === provider.id) throw new Error(`Provider "${provider.id}" cannot require capability "${capabilityId}" that it provides.`);
-	}
-	const visited = /* @__PURE__ */ new Set();
-	const visiting = /* @__PURE__ */ new Set();
-	const ordered = [];
-	function visit(provider, lineage = []) {
-		if (visited.has(provider.id)) return;
-		if (visiting.has(provider.id)) throw new Error(`Provider capability cycle detected: ${[...lineage, provider.id].join(" -> ")}.`);
-		visiting.add(provider.id);
-		const dependencyProviders = [...providerCapabilityIds(provider, "requires"), ...providerCapabilityIds(provider, "optional")].map((capabilityId) => providerByCapability.get(capabilityId) || null).filter(Boolean).sort((left, right) => left.id.localeCompare(right.id));
-		for (const dependencyProvider of dependencyProviders) visit(dependencyProvider, [...lineage, provider.id]);
-		visiting.delete(provider.id);
-		visited.add(provider.id);
-		ordered.push(provider);
-	}
-	for (const provider of [...normalizedProviders].sort((left, right) => left.id.localeCompare(right.id))) visit(provider);
-	return Object.freeze(ordered);
-}
-function resolveProviderDependencies(provider, capabilities) {
-	const dependencies = {};
-	for (const [localName, capabilityId] of Object.entries(provider.requires)) {
-		if (!capabilities.has(capabilityId)) throw new Error(`Provider "${provider.id}" requires unavailable capability "${capabilityId}".`);
-		dependencies[localName] = capabilities.get(capabilityId);
-	}
-	for (const [localName, capabilityId] of Object.entries(provider.optional)) dependencies[localName] = capabilities.has(capabilityId) ? capabilities.get(capabilityId) : null;
-	return Object.freeze(dependencies);
-}
-function normalizeProviderOutputs(provider, value) {
-	const expectedNames = Object.keys(provider.provides);
-	if (expectedNames.length === 0) {
-		if (value != null && (!isRecord(value) || Object.keys(value).length > 0)) throw new Error(`Provider "${provider.id}" declares no capabilities but setup() returned outputs.`);
-		return Object.freeze({});
-	}
-	if (!isRecord(value)) throw new Error(`Provider "${provider.id}" setup() must return its declared capability outputs.`);
-	const actualNames = Object.keys(value).sort();
-	const sortedExpectedNames = [...expectedNames].sort();
-	if (actualNames.length !== sortedExpectedNames.length || actualNames.some((name, index) => name !== sortedExpectedNames[index])) throw new Error(`Provider "${provider.id}" setup() outputs must be exactly: ${sortedExpectedNames.join(", ") || "<none>"}.`);
-	return Object.freeze({ ...value });
-}
-function createCapabilityRuntime({ providers = [], inputs = {}, profile = "" } = {}) {
-	const capabilities = normalizeInputCapabilities(inputs);
-	const providerOrder = buildProviderOrder(Array.isArray(providers) ? providers : [], capabilities);
-	const providerStates = /* @__PURE__ */ new Map();
-	const normalizedProfile = String(profile || "").trim();
-	let lifecycleState = "created";
-	async function stopInitializedProviders() {
-		const stopped = [];
-		let firstError = null;
-		for (const provider of [...providerOrder].reverse()) {
-			if (!providerStates.has(provider.id)) continue;
-			if (provider.shutdown) {
-				const state = providerStates.get(provider.id);
-				try {
-					await provider.shutdown(state.dependencies, Object.freeze({
-						outputs: state.outputs,
-						profile: normalizedProfile
-					}));
-				} catch (error) {
-					firstError ||= error;
-				}
-			}
-			stopped.push(provider.id);
-		}
-		if (firstError) throw firstError;
-		return Object.freeze(stopped);
-	}
-	async function start() {
-		if (lifecycleState !== "created") throw new Error(`Capability runtime cannot start from state "${lifecycleState}".`);
-		lifecycleState = "starting";
-		try {
-			for (const provider of providerOrder) {
-				const dependencies = resolveProviderDependencies(provider, capabilities);
-				const outputs = normalizeProviderOutputs(provider, await provider.setup(dependencies, Object.freeze({ profile: normalizedProfile })));
-				for (const [localName, capabilityId] of Object.entries(provider.provides)) capabilities.set(capabilityId, outputs[localName]);
-				providerStates.set(provider.id, Object.freeze({
-					dependencies,
-					outputs
-				}));
-			}
-			for (const provider of providerOrder) if (provider.boot) {
-				const state = providerStates.get(provider.id);
-				await provider.boot(state.dependencies, Object.freeze({
-					outputs: state.outputs,
-					profile: normalizedProfile
-				}));
-			}
-			lifecycleState = "started";
-			return api;
-		} catch (error) {
-			lifecycleState = "failed";
-			try {
-				await stopInitializedProviders();
-			} catch (shutdownError) {
-				throw new AggregateError([error, shutdownError], "Capability runtime startup failed and cleanup also failed.", { cause: error });
-			}
-			throw error;
-		}
-	}
-	async function shutdown() {
-		if (lifecycleState === "stopped") return Object.freeze([]);
-		if (lifecycleState !== "started") throw new Error(`Capability runtime cannot shut down from state "${lifecycleState}".`);
-		lifecycleState = "stopping";
-		try {
-			return await stopInitializedProviders();
-		} finally {
-			lifecycleState = "stopped";
-		}
-	}
-	function diagnostics() {
-		return Object.freeze({
-			profile: normalizedProfile,
-			lifecycleState,
-			providerOrder: Object.freeze(providerOrder.map((provider) => provider.id)),
-			capabilityIds: Object.freeze([...capabilities.keys()].sort())
-		});
-	}
-	const api = Object.freeze({
-		start,
-		shutdown,
-		diagnostics
-	});
-	return api;
-}
-//#endregion
-//#region ../../../kernel/shared/surface/registry.js
-function normalizeSurfaceId(value) {
-	return String(value || "").trim().toLowerCase();
-}
-//#endregion
-//#region ../../../kernel/shared/surface/runtime.js
-function normalizeRoutePath(pathLike = "") {
-	const rawPath = String(pathLike || "").trim();
-	if (!rawPath || rawPath === "/") return "/";
-	const compacted = (rawPath.startsWith("/") ? rawPath : `/${rawPath}`).replace(/\/{2,}/g, "/");
-	if (compacted === "/") return "/";
-	return compacted.replace(/\/+$/, "") || "/";
-}
-function resolveAbsoluteRoutePath(parentAbsolutePath = "/", routePath = "") {
-	const normalizedParentPath = normalizeRoutePath(parentAbsolutePath);
-	const rawRoutePath = String(routePath || "").trim();
-	if (!rawRoutePath) return normalizedParentPath;
-	if (rawRoutePath.startsWith("/")) return normalizeRoutePath(rawRoutePath);
-	if (normalizedParentPath === "/") return normalizeRoutePath(`/${rawRoutePath}`);
-	return normalizeRoutePath(`${normalizedParentPath}/${rawRoutePath}`);
-}
-function readRouteJskitMeta(route) {
-	if (!isRecord(route) || !isRecord(route.meta) || !isRecord(route.meta.jskit)) return {};
-	return route.meta.jskit;
-}
-function resolveRouteExplicitSurface(route) {
-	const metaSurface = readRouteJskitMeta(route).surface;
-	return normalizeSurfaceId(route?.surface || metaSurface);
-}
-function resolveOwnRouteScope(route) {
-	const metaScope = readRouteJskitMeta(route).scope;
-	const normalizedScope = String(route?.scope || metaScope || "").trim().toLowerCase();
-	if (!normalizedScope) return "";
-	return normalizedScope === "global" ? "global" : "surface";
-}
-function resolveRouteSurface(route, inheritedSurfaceId = "", { surfaceRuntime, absolutePath = "/" } = {}) {
-	const explicitSurface = resolveRouteExplicitSurface(route);
-	if (explicitSurface) return explicitSurface;
-	const normalizedInheritedSurface = normalizeSurfaceId(inheritedSurfaceId);
-	if (normalizedInheritedSurface) return normalizedInheritedSurface;
-	const routePath = String(route?.path || "").trim();
-	if (routePath && routePath.startsWith("/")) return surfaceRuntime.resolveSurfaceFromPathname(routePath);
-	if (absolutePath) return surfaceRuntime.resolveSurfaceFromPathname(absolutePath);
-	return surfaceRuntime.DEFAULT_SURFACE_ID;
-}
-function normalizeRoutesBySurfaceBoundaries(routeList = [], { surfaceRuntime } = {}) {
-	const normalizedRoutes = Array.isArray(routeList) ? routeList : [];
-	const hoistedRoutes = [];
-	function cloneRouteWithChildren(route, children) {
-		const nextRoute = { ...route };
-		if (children.length > 0) nextRoute.children = children;
-		else if (Object.prototype.hasOwnProperty.call(nextRoute, "children")) delete nextRoute.children;
-		return nextRoute;
-	}
-	function cloneRouteAsHoisted(route, absolutePath, children) {
-		const nextRoute = cloneRouteWithChildren(route, children);
-		nextRoute.path = absolutePath;
-		return nextRoute;
-	}
-	function visitRoute(route, parentSurfaceId = "", parentAbsolutePath = "/") {
-		if (!isRecord(route)) return null;
-		const absolutePath = resolveAbsoluteRoutePath(parentAbsolutePath, route.path);
-		const explicitSurface = resolveRouteExplicitSurface(route);
-		const normalizedParentSurfaceId = normalizeSurfaceId(parentSurfaceId);
-		const resolvedSurface = resolveRouteSurface(route, normalizedParentSurfaceId, {
-			surfaceRuntime,
-			absolutePath
-		});
-		const surfaceBoundary = Boolean(explicitSurface) && Boolean(normalizedParentSurfaceId) && explicitSurface !== normalizedParentSurfaceId;
-		const children = Array.isArray(route.children) ? route.children : [];
-		const filteredChildren = [];
-		for (const child of children) {
-			const normalizedChild = visitRoute(child, resolvedSurface, absolutePath);
-			if (normalizedChild) filteredChildren.push(normalizedChild);
-		}
-		const routeWithChildren = children.length !== filteredChildren.length || filteredChildren.some((child, index) => child !== children[index]) ? cloneRouteWithChildren(route, filteredChildren) : route;
-		if (!surfaceBoundary) return routeWithChildren;
-		hoistedRoutes.push(cloneRouteAsHoisted(routeWithChildren, absolutePath, filteredChildren));
-		return null;
-	}
-	const keptRoutes = [];
-	for (const route of normalizedRoutes) {
-		const normalizedRoute = visitRoute(route, "", "/");
-		if (normalizedRoute) keptRoutes.push(normalizedRoute);
-	}
-	return [...keptRoutes, ...hoistedRoutes];
-}
-function filterRoutesBySurface(routeList, { surfaceRuntime, surfaceMode } = {}) {
-	if (!surfaceRuntime || typeof surfaceRuntime !== "object") throw new Error("filterRoutesBySurface requires surfaceRuntime.");
-	if (typeof surfaceRuntime.normalizeSurfaceMode !== "function") throw new Error("filterRoutesBySurface requires surfaceRuntime.normalizeSurfaceMode().");
-	if (typeof surfaceRuntime.resolveSurfaceFromPathname !== "function") throw new Error("filterRoutesBySurface requires surfaceRuntime.resolveSurfaceFromPathname().");
-	if (typeof surfaceRuntime.listEnabledSurfaceIds !== "function") throw new Error("filterRoutesBySurface requires surfaceRuntime.listEnabledSurfaceIds().");
-	const normalizedRoutes = normalizeRoutesBySurfaceBoundaries(routeList, { surfaceRuntime });
-	const allMode = String(surfaceRuntime.SURFACE_MODE_ALL || "all").trim().toLowerCase() || "all";
-	const normalizedMode = surfaceRuntime.normalizeSurfaceMode(surfaceMode);
-	const enabledSurfaces = new Set(surfaceRuntime.listEnabledSurfaceIds());
-	function filterRouteNode(route, inheritedSurfaceId = "") {
-		if (!isRecord(route)) return null;
-		const resolvedSurface = resolveRouteSurface(route, inheritedSurfaceId, {
-			surfaceRuntime,
-			absolutePath: String(route.path || "/")
-		});
-		const isGlobalScope = resolveOwnRouteScope(route) === "global";
-		const isEnabledSurfaceRoute = enabledSurfaces.has(resolvedSurface);
-		const ownIncluded = isGlobalScope || isEnabledSurfaceRoute && (normalizedMode === allMode || resolvedSurface === normalizedMode);
-		const children = Array.isArray(route.children) ? route.children : [];
-		const filteredChildren = children.map((child) => filterRouteNode(child, resolvedSurface)).filter(Boolean);
-		if (!ownIncluded && filteredChildren.length < 1) return null;
-		if (children.length < 1) return route;
-		return {
-			...route,
-			children: filteredChildren
-		};
-	}
-	return normalizedRoutes.map((route) => filterRouteNode(route)).filter(Boolean);
-}
-//#endregion
-//#region ../../../kernel/client/componentRegistry.js
-function normalizeComponentId(value) {
-	const id = String(value || "").trim();
-	if (!id) throw new TypeError("Client component id is required.");
-	return id;
-}
-function createClientComponentRegistry() {
-	const components = /* @__PURE__ */ new Map();
-	function register(id, component) {
-		const componentId = normalizeComponentId(id);
-		if (component == null) throw new TypeError(`Client component "${componentId}" is required.`);
-		if (components.has(componentId)) throw new Error(`Client component "${componentId}" is duplicated.`);
-		components.set(componentId, component);
-		return api;
-	}
-	function has(id) {
-		return components.has(normalizeComponentId(id));
-	}
-	function get(id) {
-		const componentId = normalizeComponentId(id);
-		if (!components.has(componentId)) throw new Error(`Client component "${componentId}" is not registered.`);
-		return components.get(componentId);
-	}
-	function ids() {
-		return Object.freeze([...components.keys()].sort());
-	}
-	const api = Object.freeze({
-		register,
-		has,
-		get,
-		ids
-	});
-	return api;
-}
-//#endregion
-//#region ../../../kernel/client/packageMetadataSections.js
-function normalizePackageMetadataUiRoutes(value) {
-	const routeEntries = Array.isArray(value) ? value : [];
-	const normalizedRoutes = [];
-	for (const routeEntry of routeEntries) {
-		if (!isRecord(routeEntry)) continue;
-		try {
-			normalizedRoutes.push(Object.freeze(JSON.parse(JSON.stringify(routeEntry))));
-		} catch {}
-	}
-	return Object.freeze(normalizedRoutes);
-}
-function normalizePackageMetadataClientProviders(value) {
-	const entries = Array.isArray(value) ? value : [];
-	const providers = [];
-	for (const entry of entries) {
-		if (!isRecord(entry)) continue;
-		const exportName = String(entry.export || "").trim();
-		if (!exportName) continue;
-		providers.push(Object.freeze({
-			export: exportName,
-			entrypoint: String(entry.entrypoint || "").trim()
-		}));
-	}
-	return Object.freeze(providers);
-}
-//#endregion
-//#region ../../../kernel/client/logging.js
-function createStructuredLogger(logger = console) {
-	if (isRecord(logger)) return Object.freeze({
-		info: typeof logger.info === "function" ? logger.info.bind(logger) : console.info.bind(console),
-		warn: typeof logger.warn === "function" ? logger.warn.bind(logger) : console.warn.bind(console),
-		error: typeof logger.error === "function" ? logger.error.bind(logger) : console.error.bind(console),
-		debug: typeof logger.debug === "function" ? logger.debug.bind(logger) : () => {}
-	});
-	return Object.freeze({
-		info: console.info.bind(console),
-		warn: console.warn.bind(console),
-		error: console.error.bind(console),
-		debug: () => {}
-	});
-}
-function summarizeRouterRoutes(router) {
-	if (!router || typeof router.getRoutes !== "function") return Object.freeze([]);
-	return Object.freeze(router.getRoutes().map((route) => Object.freeze({
-		name: String(route?.name || "").trim(),
-		path: String(route?.path || "").trim(),
-		metaScope: String(route?.meta?.jskit?.scope || "").trim(),
-		metaSurface: String(route?.meta?.jskit?.surface || "").trim()
-	})));
-}
-//#endregion
-//#region ../../../kernel/client/moduleBootstrap.js
-function normalizePackageId(value) {
-	return String(value || "").trim();
-}
-function toRouteSnapshot(route) {
-	const metaJskit = isRecord(route?.meta?.jskit) ? route.meta.jskit : {};
-	return Object.freeze({
-		id: String(route?.id || "").trim(),
-		name: String(route?.name || "").trim(),
-		path: String(route?.path || "").trim(),
-		scope: String(route?.scope || "").trim(),
-		surface: String(route?.surface || "").trim(),
-		metaScope: String(metaJskit.scope || "").trim(),
-		metaSurface: String(metaJskit.surface || "").trim()
-	});
-}
-function isRouteComponent(value) {
-	if (typeof value === "function") return true;
-	return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function normalizeRoute(route, { packageId, index }) {
-	if (!isRecord(route)) throw new TypeError(`Client route #${index} from ${packageId} must be an object.`);
-	const id = String(route.id || "").trim();
-	const path = String(route.path || "").trim();
-	if (!id) throw new Error(`Client route #${index} from ${packageId} requires id.`);
-	if (!path || !path.startsWith("/") || path.startsWith("//")) throw new Error(`Client route "${id}" from ${packageId} must use an absolute path.`);
-	if (!isRouteComponent(route.component)) throw new Error(`Client route "${id}" from ${packageId} requires component.`);
-	const scope = String(route.scope || "surface").trim().toLowerCase();
-	if (scope !== "global" && scope !== "surface") throw new Error(`Client route "${id}" from ${packageId} has invalid scope "${scope}".`);
-	const surface = String(route.surface || "").trim().toLowerCase();
-	const baseMeta = isRecord(route.meta) ? route.meta : {};
-	const baseMetaJskit = isRecord(baseMeta.jskit) ? baseMeta.jskit : {};
-	return Object.freeze({
-		...route,
-		id,
-		path,
-		scope,
-		...surface ? { surface } : {},
-		meta: {
-			...baseMeta,
-			jskit: {
-				...baseMetaJskit,
-				packageId,
-				routeId: id,
-				scope,
-				...surface ? { surface } : {}
-			}
-		}
-	});
-}
-function normalizeRouteList(routes, { packageId }) {
-	return Object.freeze((Array.isArray(routes) ? routes : []).map((route, index) => normalizeRoute(route, {
-		packageId,
-		index: index + 1
-	})));
-}
-function toVueRouteRecord(route) {
-	const nextMeta = isRecord(route.meta) ? { ...route.meta } : void 0;
-	const routeRecord = {
-		path: route.path,
-		component: route.component,
-		...route.name ? { name: route.name } : {},
-		...route.props !== void 0 ? { props: route.props } : {},
-		...route.redirect !== void 0 ? { redirect: route.redirect } : {},
-		...route.children !== void 0 ? { children: route.children } : {},
-		...nextMeta ? { meta: nextMeta } : {}
-	};
-	return Object.freeze(routeRecord);
-}
-function registerClientModuleRoutes({ packageId, routes = [], router, surfaceRuntime, surfaceMode, seenRoutePaths, seenRouteNames, logger = null, source = "module", packageMetadataRouteDeclarations = null } = {}) {
-	const normalizedPackageId = normalizePackageId(packageId);
-	if (!normalizedPackageId) throw new TypeError("registerClientModuleRoutes requires packageId.");
-	if (!router || typeof router.addRoute !== "function") throw new TypeError("registerClientModuleRoutes requires router.addRoute().");
-	if (!surfaceRuntime || typeof surfaceRuntime !== "object") throw new TypeError("registerClientModuleRoutes requires surfaceRuntime.");
-	const normalizedRoutes = normalizeRouteList(routes, { packageId: normalizedPackageId });
-	assertRoutesDeclaredInPackageMetadata({
-		packageId: normalizedPackageId,
-		source,
-		normalizedRoutes,
-		packageMetadataRouteDeclarations
-	});
-	const activeRoutes = filterRoutesBySurface(normalizedRoutes, {
-		surfaceRuntime,
-		surfaceMode
-	});
-	const log = createStructuredLogger(logger);
-	log.debug({
-		packageId: normalizedPackageId,
-		source,
-		surfaceMode: String(surfaceMode || "").trim(),
-		declaredRoutes: normalizedRoutes.map(toRouteSnapshot),
-		activeRoutes: activeRoutes.map(toRouteSnapshot)
-	}, "Client route registration analysis.");
-	const declaredPaths = normalizedRoutes.map((route) => route.path);
-	const activePaths = activeRoutes.map((route) => route.path);
-	let registeredCount = 0;
-	for (const route of activeRoutes) {
-		const normalizedPath = String(route.path || "").trim();
-		if (seenRoutePaths.has(normalizedPath)) throw new Error(`Client route path "${normalizedPath}" is duplicated (package ${normalizedPackageId}).`);
-		const normalizedName = String(route.name || "").trim();
-		if (normalizedName) {
-			if (seenRouteNames.has(normalizedName)) throw new Error(`Client route name "${normalizedName}" is duplicated (package ${normalizedPackageId}).`);
-			seenRouteNames.add(normalizedName);
-		}
-		seenRoutePaths.add(normalizedPath);
-		router.addRoute(toVueRouteRecord(route));
-		log.debug({
-			packageId: normalizedPackageId,
-			source,
-			route: toRouteSnapshot(route)
-		}, "Added client route to router.");
-		registeredCount += 1;
-	}
-	return Object.freeze({
-		packageId: normalizedPackageId,
-		source,
-		declaredCount: normalizedRoutes.length,
-		registeredCount,
-		declaredPaths: Object.freeze(declaredPaths),
-		activePaths: Object.freeze(activePaths)
-	});
-}
-function resolvePackageMetadataProviders(moduleNamespace, packageId, packageMetadataClientProviders = []) {
-	const providers = [];
-	const seenProviderIds = /* @__PURE__ */ new Set();
-	for (const providerDeclaration of packageMetadataClientProviders) {
-		const exportName = String(providerDeclaration?.export || "").trim();
-		if (!exportName) continue;
-		const providerValue = moduleNamespace?.[exportName];
-		let provider = null;
-		try {
-			provider = defineProvider(providerValue);
-		} catch (error) {
-			throw new TypeError(`Client module ${packageId} packageMetadata provider export "${exportName}" must be a capability provider: ${error.message}`, { cause: error });
-		}
-		const providerId = provider.id;
-		if (seenProviderIds.has(providerId)) continue;
-		seenProviderIds.add(providerId);
-		providers.push(provider);
-	}
-	return providers;
-}
-function resolveModuleProviders(moduleNamespace, packageId, packageMetadataClientProviders = []) {
-	if (!isRecord(moduleNamespace)) return [];
-	return resolvePackageMetadataProviders(moduleNamespace, packageId, packageMetadataClientProviders);
-}
-function buildPackageMetadataRouteDeclarationIndex({ packageId, packageMetadataUiRoutes = [] } = {}) {
-	const normalizedPackageId = normalizePackageId(packageId);
-	const packageMetadataRoutes = normalizePackageMetadataUiRoutes(packageMetadataUiRoutes);
-	const byId = /* @__PURE__ */ new Map();
-	for (const packageMetadataRoute of packageMetadataRoutes) {
-		const routeId = String(packageMetadataRoute.id || "").trim();
-		const routePath = String(packageMetadataRoute.path || "").trim();
-		const routeScope = String(packageMetadataRoute.scope || "surface").trim().toLowerCase();
-		if (!routeId || !routePath) continue;
-		if (byId.has(routeId)) {
-			const existingRoute = byId.get(routeId);
-			if (existingRoute.path !== routePath || existingRoute.scope !== routeScope) throw new Error(`PackageMetadata ui routes for ${normalizedPackageId} define duplicate id "${routeId}" with conflicting declarations.`);
-			continue;
-		}
-		byId.set(routeId, Object.freeze({
-			id: routeId,
-			path: routePath,
-			scope: routeScope
-		}));
-	}
-	return Object.freeze({ byId });
-}
-function assertRoutesDeclaredInPackageMetadata({ packageId, source, normalizedRoutes = [], packageMetadataRouteDeclarations = null } = {}) {
-	if (String(source || "").trim() !== "clientRoutes") return;
-	const byId = packageMetadataRouteDeclarations?.byId instanceof Map ? packageMetadataRouteDeclarations.byId : /* @__PURE__ */ new Map();
-	const normalizedPackageId = normalizePackageId(packageId);
-	for (const route of normalizedRoutes) {
-		const routeId = String(route?.id || "").trim();
-		const routePath = String(route?.path || "").trim();
-		if (String(route?.scope || "surface").trim().toLowerCase() !== "global") continue;
-		const declaredRoute = byId.get(routeId);
-		if (!declaredRoute) throw new Error(`Global client route "${routeId}" from ${normalizedPackageId} (${source}) must be declared in metadata.ui.routes (id "${routeId}", path "${routePath}") with scope:"global" and autoRegister:false.`);
-		if (String(declaredRoute.path || "").trim() !== routePath) throw new Error(`Global client route "${routeId}" from ${normalizedPackageId} (${source}) path "${routePath}" does not match packageMetadata metadata.ui.routes path "${declaredRoute.path}".`);
-		if (String(declaredRoute.scope || "").trim().toLowerCase() !== "global") throw new Error(`Global client route "${routeId}" from ${normalizedPackageId} (${source}) must be declared with scope:"global" in metadata.ui.routes.`);
-	}
-}
-function resolvePackageMetadataClientRoutes({ packageId, packageMetadataUiRoutes = [], routeComponents = {}, logger = null } = {}) {
-	const normalizedPackageId = normalizePackageId(packageId);
-	const packageMetadataRoutes = normalizePackageMetadataUiRoutes(packageMetadataUiRoutes);
-	if (packageMetadataRoutes.length < 1) return Object.freeze([]);
-	if (!isRecord(routeComponents)) throw new TypeError(`Client module ${normalizedPackageId} declares packageMetadata ui routes but does not export a routeComponents map.`);
-	const log = createStructuredLogger(logger);
-	const routes = [];
-	const skippedRoutes = [];
-	for (const packageMetadataRoute of packageMetadataRoutes) {
-		const routeId = String(packageMetadataRoute.id || "").trim();
-		const routePath = String(packageMetadataRoute.path || "").trim();
-		if (!(packageMetadataRoute.autoRegister !== false)) {
-			skippedRoutes.push(Object.freeze({
-				id: routeId,
-				path: routePath,
-				reason: "autoRegister=false"
-			}));
-			continue;
-		}
-		if (!routeId || !routePath) throw new Error(`PackageMetadata ui route from ${normalizedPackageId} requires id and path when autoRegister is enabled.`);
-		const componentKey = String(packageMetadataRoute.componentKey || "").trim();
-		if (!componentKey) throw new Error(`PackageMetadata ui route "${routeId}" from ${normalizedPackageId} requires componentKey when autoRegister is enabled.`);
-		const routeComponent = routeComponents[componentKey];
-		if (!isRouteComponent(routeComponent)) throw new Error(`PackageMetadata ui route "${routeId}" from ${normalizedPackageId} references unknown routeComponents key "${componentKey}".`);
-		const scope = String(packageMetadataRoute.scope || "surface").trim().toLowerCase();
-		const surface = String(packageMetadataRoute.surface || "").trim().toLowerCase();
-		const guard = isRecord(packageMetadataRoute.guard) ? { ...packageMetadataRoute.guard } : {};
-		const baseMeta = isRecord(packageMetadataRoute.meta) ? { ...packageMetadataRoute.meta } : {};
-		const baseMetaJskit = isRecord(baseMeta.jskit) ? { ...baseMeta.jskit } : {};
-		routes.push(Object.freeze({
-			id: routeId,
-			path: routePath,
-			scope,
-			...surface ? { surface } : {},
-			...String(packageMetadataRoute.name || "").trim() ? { name: String(packageMetadataRoute.name || "").trim() } : {},
-			component: routeComponent,
-			meta: {
-				...baseMeta,
-				...Object.keys(guard).length > 0 ? { guard } : {},
-				jskit: {
-					...baseMetaJskit,
-					packageId: normalizedPackageId,
-					routeId,
-					scope,
-					componentKey,
-					source: "packageMetadata.ui.routes",
-					...surface ? { surface } : {}
-				}
-			}
-		}));
-	}
-	log.debug({
-		packageId: normalizedPackageId,
-		packageMetadataRouteCount: packageMetadataRoutes.length,
-		autoRegisterRouteCount: routes.length,
-		skippedRoutes
-	}, "Processed packageMetadata ui routes.");
-	return Object.freeze(routes);
-}
-function normalizeClientModuleEntries(clientModules) {
-	if (!Array.isArray(clientModules)) return [];
-	return clientModules.map((entry) => {
-		const packageId = normalizePackageId(entry?.packageId);
-		const moduleNamespace = isRecord(entry?.module) ? entry.module : null;
-		if (!packageId || !moduleNamespace) return null;
-		return Object.freeze({
-			packageId,
-			module: moduleNamespace,
-			packageMetadataUiRoutes: normalizePackageMetadataUiRoutes(entry?.packageMetadataUiRoutes),
-			packageMetadataClientProviders: normalizePackageMetadataClientProviders(entry?.packageMetadataClientProviders)
-		});
-	}).filter(Boolean).sort((left, right) => left.packageId.localeCompare(right.packageId));
-}
-function createClientRuntime({ profile = "client", providers = [], app, pinia = null, queryClient = null, router, env, logger, surfaceRuntime, surfaceMode } = {}) {
-	const components = createClientComponentRegistry();
-	const runtime = createCapabilityRuntime({
-		profile,
-		providers,
-		inputs: {
-			"client.vue": app || null,
-			"client.router": router || null,
-			"client.pinia": pinia,
-			"client.query": queryClient,
-			"client.env": Object.freeze({ ...isRecord(env) ? env : {} }),
-			"client.surface": surfaceRuntime || null,
-			"client.surface-mode": String(surfaceMode || "").trim(),
-			"client.logger": logger,
-			"client.components": components
-		}
-	});
-	return Object.freeze({
-		runtime,
-		components
-	});
-}
-async function bootClientModules({ clientModules = [], app, pinia = null, queryClient = null, router, surfaceRuntime, surfaceMode, env, logger = console } = {}) {
-	if (!router || typeof router.addRoute !== "function") throw new TypeError("bootClientModules requires router.addRoute().");
-	if (!surfaceRuntime || typeof surfaceRuntime.normalizeSurfaceMode !== "function") throw new TypeError("bootClientModules requires surfaceRuntime.normalizeSurfaceMode().");
-	const log = createStructuredLogger(logger);
-	const moduleEntries = normalizeClientModuleEntries(clientModules);
-	const providers = [];
-	const seenProviderIds = /* @__PURE__ */ new Set();
-	log.debug({
-		surfaceMode: String(surfaceMode || "").trim(),
-		normalizedSurfaceMode: String(surfaceRuntime.normalizeSurfaceMode(surfaceMode) || "").trim(),
-		moduleCount: moduleEntries.length,
-		modules: moduleEntries.map((entry) => entry.packageId)
-	}, "Starting JSKIT client module bootstrap.");
-	for (const entry of moduleEntries) {
-		const moduleProviders = resolveModuleProviders(entry.module, entry.packageId, entry.packageMetadataClientProviders);
-		log.debug({
-			packageId: entry.packageId,
-			providerExports: moduleProviders.map((provider) => provider.id),
-			hasClientRoutes: Array.isArray(entry.module.clientRoutes) && entry.module.clientRoutes.length > 0
-		}, "Discovered client module capabilities.");
-		for (const provider of moduleProviders) {
-			const providerId = provider.id;
-			if (seenProviderIds.has(providerId)) throw new Error(`Client provider id "${providerId}" is duplicated.`);
-			seenProviderIds.add(providerId);
-			providers.push(provider);
-		}
-	}
-	const clientRuntime = createClientRuntime({
-		profile: String(surfaceRuntime.normalizeSurfaceMode(surfaceMode) || "client"),
-		providers,
-		app,
-		pinia,
-		queryClient,
-		router,
-		env,
-		logger: log,
-		surfaceRuntime,
-		surfaceMode
-	});
-	await clientRuntime.runtime.start();
-	const seenRoutePaths = /* @__PURE__ */ new Set();
-	const seenRouteNames = /* @__PURE__ */ new Set();
-	const routeResults = [];
-	const registerRoutesForEntry = (routeList, packageId, source = "module", packageMetadataRouteDeclarations = null) => {
-		if (!routeList || routeList.length === 0) return null;
-		const result = registerClientModuleRoutes({
-			packageId,
-			routes: routeList,
-			router,
-			surfaceRuntime,
-			surfaceMode,
-			seenRoutePaths,
-			seenRouteNames,
-			logger: log,
-			source,
-			packageMetadataRouteDeclarations
-		});
-		log.debug({
-			packageId,
-			source,
-			declaredPaths: result.declaredPaths,
-			activePaths: result.activePaths,
-			registeredCount: result.registeredCount
-		}, "Registered client module routes.");
-		log.debug({
-			packageId,
-			source,
-			routerRoutes: summarizeRouterRoutes(router)
-		}, "Router route table after client route registration.");
-		routeResults.push(result);
-		return result;
-	};
-	for (const entry of moduleEntries) {
-		const packageMetadataRouteDeclarations = buildPackageMetadataRouteDeclarationIndex({
-			packageId: entry.packageId,
-			packageMetadataUiRoutes: entry.packageMetadataUiRoutes
-		});
-		registerRoutesForEntry(resolvePackageMetadataClientRoutes({
-			packageId: entry.packageId,
-			packageMetadataUiRoutes: entry.packageMetadataUiRoutes,
-			routeComponents: entry.module.routeComponents,
-			logger: log
-		}), entry.packageId, "packageMetadata.ui.routes", packageMetadataRouteDeclarations);
-		registerRoutesForEntry(Array.isArray(entry.module.clientRoutes) ? entry.module.clientRoutes : [], entry.packageId, "clientRoutes", packageMetadataRouteDeclarations);
-	}
-	const registeredRouteCount = routeResults.reduce((sum, result) => sum + result.registeredCount, 0);
-	if (moduleEntries.length > 0) {
-		log.debug({
-			modules: moduleEntries.map((entry) => entry.packageId),
-			providerCount: providers.length,
-			routeCount: registeredRouteCount
-		}, "Booted JSKIT client modules.");
-		log.debug({
-			routerRoutes: summarizeRouterRoutes(router),
-			currentPath: typeof window !== "undefined" ? String(window.location?.pathname || "") : ""
-		}, "JSKIT client bootstrap final route table.");
-	}
-	return Object.freeze({
-		runtime: clientRuntime.runtime,
-		components: clientRuntime.components,
-		modules: Object.freeze(moduleEntries.map((entry) => entry.packageId)),
-		providerCount: providers.length,
-		routeResults: Object.freeze(routeResults),
-		routeCount: registeredRouteCount
-	});
-}
-//#endregion
-export { bootClientModules };