@weavecode/weave 0.1.2 → 0.1.3

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/jsx/hooks/index.js

@@ -0,0 +1,259 @@
+import { DOM_STASH } from "../constants.js";
+import { buildDataStack, update } from "../dom/render.js";
+//#region src/jsx/hooks/index.ts
+const STASH_SATE = 0;
+const STASH_EFFECT = 1;
+const STASH_CALLBACK = 2;
+const STASH_MEMO = 3;
+const STASH_REF = 4;
+const resolvedPromiseValueMap = /* @__PURE__ */ new WeakMap();
+const isDepsChanged = (prevDeps, deps) => !prevDeps || !deps || prevDeps.length !== deps.length || deps.some((dep, i) => dep !== prevDeps[i]);
+let viewTransitionState = void 0;
+const documentStartViewTransition = (cb) => {
+	if (document?.startViewTransition) return document.startViewTransition(cb);
+	else {
+		cb();
+		return { finished: Promise.resolve() };
+	}
+};
+let updateHook = void 0;
+const viewTransitionHook = (context, node, cb) => {
+	const state = [true, false];
+	let lastVC = node.vC;
+	return documentStartViewTransition(() => {
+		if (lastVC === node.vC) {
+			viewTransitionState = state;
+			cb(context);
+			viewTransitionState = void 0;
+			lastVC = node.vC;
+		}
+	}).finished.then(() => {
+		if (state[1] && lastVC === node.vC) {
+			state[0] = false;
+			viewTransitionState = state;
+			cb(context);
+			viewTransitionState = void 0;
+		}
+	});
+};
+const startViewTransition = (callback) => {
+	updateHook = viewTransitionHook;
+	try {
+		callback();
+	} finally {
+		updateHook = void 0;
+	}
+};
+const useViewTransition = () => {
+	if (!buildDataStack.at(-1)) return [false, () => {}];
+	if (viewTransitionState) viewTransitionState[1] = true;
+	return [!!viewTransitionState?.[0], startViewTransition];
+};
+const pendingStack = [];
+const runCallback = (type, callback) => {
+	let resolve;
+	const promise = new Promise((r) => resolve = r);
+	pendingStack.push([type, promise]);
+	try {
+		const res = callback();
+		if (res instanceof Promise) res.then(resolve, resolve);
+		else resolve();
+	} finally {
+		pendingStack.pop();
+	}
+};
+const startTransition = (callback) => {
+	runCallback(1, callback);
+};
+const startTransitionHook = (callback) => {
+	runCallback(2, callback);
+};
+const useTransition = () => {
+	const buildData = buildDataStack.at(-1);
+	if (!buildData) return [false, () => {}];
+	const [error, setError] = useState();
+	const [state, updateState] = useState();
+	if (error) throw error[0];
+	const startTransitionLocalHook = useCallback((callback) => {
+		startTransitionHook(() => {
+			updateState((state) => !state);
+			let res = callback();
+			if (res instanceof Promise) res = res.catch((e) => {
+				setError([e]);
+			});
+			return res;
+		});
+	}, [state]);
+	const [context] = buildData;
+	return [context[0] === 2, startTransitionLocalHook];
+};
+const useDeferredValue = (value, ...rest) => {
+	const [values, setValues] = useState(rest.length ? [rest[0], rest[0]] : [value, value]);
+	if (Object.is(values[1], value)) return values[1];
+	pendingStack.push([3, Promise.resolve()]);
+	updateHook = async (context, _, cb) => {
+		cb(context);
+		values[0] = value;
+	};
+	setValues([values[0], value]);
+	updateHook = void 0;
+	pendingStack.pop();
+	return values[0];
+};
+const useState = (initialState) => {
+	const resolveInitialState = () => typeof initialState === "function" ? initialState() : initialState;
+	const buildData = buildDataStack.at(-1);
+	if (!buildData) return [resolveInitialState(), () => {}];
+	const [, node] = buildData;
+	const stateArray = node[DOM_STASH][1][STASH_SATE] ||= [];
+	const hookIndex = node[DOM_STASH][0]++;
+	return stateArray[hookIndex] ||= [resolveInitialState(), (newState) => {
+		const localUpdateHook = updateHook;
+		const stateData = stateArray[hookIndex];
+		if (typeof newState === "function") newState = newState(stateData[0]);
+		if (!Object.is(newState, stateData[0])) {
+			stateData[0] = newState;
+			if (pendingStack.length) {
+				const [pendingType, pendingPromise] = pendingStack.at(-1);
+				Promise.all([pendingType === 3 ? node : update([
+					pendingType,
+					false,
+					localUpdateHook
+				], node), pendingPromise]).then(([node]) => {
+					if (!node || !(pendingType === 2 || pendingType === 3)) return;
+					const lastVC = node.vC;
+					const addUpdateTask = () => {
+						setTimeout(() => {
+							if (lastVC !== node.vC) return;
+							update([
+								pendingType === 3 ? 1 : 0,
+								false,
+								localUpdateHook
+							], node);
+						});
+					};
+					requestAnimationFrame(addUpdateTask);
+				});
+			} else update([
+				0,
+				false,
+				localUpdateHook
+			], node);
+		}
+	}];
+};
+const useReducer = (reducer, initialArg, init) => {
+	const handler = useCallback((action) => {
+		setState((state) => reducer(state, action));
+	}, [reducer]);
+	const [state, setState] = useState(() => init ? init(initialArg) : initialArg);
+	return [state, handler];
+};
+const useEffectCommon = (index, effect, deps) => {
+	const buildData = buildDataStack.at(-1);
+	if (!buildData) return;
+	const [, node] = buildData;
+	const effectDepsArray = node[DOM_STASH][1][1] ||= [];
+	const hookIndex = node[DOM_STASH][0]++;
+	const [prevDeps, , prevCleanup] = effectDepsArray[hookIndex] ||= [];
+	if (isDepsChanged(prevDeps, deps)) {
+		if (prevCleanup) prevCleanup();
+		const runner = () => {
+			data[index] = void 0;
+			data[2] = effect();
+		};
+		const data = [
+			deps,
+			void 0,
+			void 0,
+			void 0,
+			void 0
+		];
+		data[index] = runner;
+		effectDepsArray[hookIndex] = data;
+	}
+};
+const useEffect = (effect, deps) => useEffectCommon(3, effect, deps);
+const useLayoutEffect = (effect, deps) => useEffectCommon(1, effect, deps);
+const useInsertionEffect = (effect, deps) => useEffectCommon(4, effect, deps);
+const useCallback = (callback, deps) => {
+	const buildData = buildDataStack.at(-1);
+	if (!buildData) return callback;
+	const [, node] = buildData;
+	const callbackArray = node[DOM_STASH][1][STASH_CALLBACK] ||= [];
+	const hookIndex = node[DOM_STASH][0]++;
+	const prevDeps = callbackArray[hookIndex];
+	if (isDepsChanged(prevDeps?.[1], deps)) callbackArray[hookIndex] = [callback, deps];
+	else callback = callbackArray[hookIndex][0];
+	return callback;
+};
+function useRef(initialValue) {
+	const buildData = buildDataStack.at(-1);
+	if (!buildData) return { current: initialValue };
+	const [, node] = buildData;
+	const refArray = node[DOM_STASH][1][STASH_REF] ||= [];
+	const hookIndex = node[DOM_STASH][0]++;
+	return refArray[hookIndex] ||= { current: initialValue };
+}
+const use = (promise) => {
+	const cachedRes = resolvedPromiseValueMap.get(promise);
+	if (cachedRes) {
+		if (cachedRes.length === 2) throw cachedRes[1];
+		return cachedRes[0];
+	}
+	promise.then((res) => resolvedPromiseValueMap.set(promise, [res]), (e) => resolvedPromiseValueMap.set(promise, [void 0, e]));
+	throw promise;
+};
+const useMemo = (factory, deps) => {
+	const buildData = buildDataStack.at(-1);
+	if (!buildData) return factory();
+	const [, node] = buildData;
+	const memoArray = node[DOM_STASH][1][STASH_MEMO] ||= [];
+	const hookIndex = node[DOM_STASH][0]++;
+	const prevDeps = memoArray[hookIndex];
+	if (isDepsChanged(prevDeps?.[1], deps)) memoArray[hookIndex] = [factory(), deps];
+	return memoArray[hookIndex][0];
+};
+let idCounter = 0;
+const useId = () => useMemo(() => `:r${(idCounter++).toString(32)}:`, []);
+const useDebugValue = (_value, _formatter) => {};
+const createRef = () => {
+	return { current: null };
+};
+const forwardRef = (Component) => {
+	return (props) => {
+		const { ref, ...rest } = props;
+		return Component(rest, ref);
+	};
+};
+const useImperativeHandle = (ref, createHandle, deps) => {
+	useEffect(() => {
+		ref.current = createHandle();
+		return () => {
+			ref.current = null;
+		};
+	}, deps);
+};
+const useSyncExternalStore = (subscribe, getSnapshot, getServerSnapshot) => {
+	const buildData = buildDataStack.at(-1);
+	if (!buildData) {
+		if (!getServerSnapshot) throw new Error("getServerSnapshot is required for server side rendering");
+		return getServerSnapshot();
+	}
+	const snapshot = buildData[0][4] && getServerSnapshot ? getServerSnapshot() : getSnapshot();
+	const [, setVersion] = useState(0);
+	const latestSnapshot = useRef([snapshot, getSnapshot]);
+	latestSnapshot.current = [snapshot, getSnapshot];
+	const unsubscribeRef = useRef(null);
+	useEffect(() => {
+		const update = () => setVersion((version) => version + 1);
+		unsubscribeRef.current?.();
+		unsubscribeRef.current = subscribe(update);
+		const [snapshot, getSnapshot] = latestSnapshot.current;
+		if (!Object.is(snapshot, getSnapshot())) update();
+	}, [subscribe]);
+	useEffect(() => () => unsubscribeRef.current?.(), []);
+	return snapshot;
+};
+//#endregion
+export { STASH_EFFECT, createRef, forwardRef, startTransition, startViewTransition, use, useCallback, useDebugValue, useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore, useTransition, useViewTransition };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/jsx/index.js

@@ -0,0 +1,50 @@
+import { createContext, useContext } from "./context.js";
+import { Children } from "./children.js";
+import { Fragment, cloneElement, isValidElement, jsx, memo, reactAPICompatVersion } from "./base.js";
+import { createRef, forwardRef, startTransition, startViewTransition, use, useCallback, useDebugValue, useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore, useTransition, useViewTransition } from "./hooks/index.js";
+import { useActionState, useOptimistic } from "./dom/hooks/index.js";
+import { Suspense } from "./streaming.js";
+import { ErrorBoundary } from "./components.js";
+//#region src/jsx/index.ts
+/**
+* @module
+* JSX for Hono.
+*/
+var jsx_default = {
+	version: reactAPICompatVersion,
+	memo,
+	Fragment,
+	StrictMode: Fragment,
+	isValidElement,
+	createElement: jsx,
+	cloneElement,
+	ErrorBoundary,
+	createContext,
+	useContext,
+	useState,
+	useEffect,
+	useRef,
+	useCallback,
+	useReducer,
+	useId,
+	useDebugValue,
+	use,
+	startTransition,
+	useTransition,
+	useDeferredValue,
+	startViewTransition,
+	useViewTransition,
+	useMemo,
+	useLayoutEffect,
+	useInsertionEffect,
+	createRef,
+	forwardRef,
+	useImperativeHandle,
+	useSyncExternalStore,
+	useActionState,
+	useOptimistic,
+	Suspense,
+	Children
+};
+//#endregion
+export { Children, ErrorBoundary, Fragment, Fragment as StrictMode, Suspense, cloneElement, createContext, jsx as createElement, jsx, createRef, jsx_default as default, forwardRef, isValidElement, memo, startTransition, startViewTransition, use, useActionState, useCallback, useContext, useDebugValue, useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useOptimistic, useReducer, useRef, useState, useSyncExternalStore, useTransition, useViewTransition, reactAPICompatVersion as version };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/jsx/intrinsic-element/common.js

@@ -0,0 +1,22 @@
+//#region src/jsx/intrinsic-element/common.ts
+const deDupeKeyMap = {
+	title: [],
+	script: ["src"],
+	style: ["data-href"],
+	link: ["href"],
+	meta: [
+		"name",
+		"httpEquiv",
+		"charset",
+		"itemProp"
+	]
+};
+const domRenderers = {};
+const dataPrecedenceAttr = "data-precedence";
+const isStylesheetLinkWithPrecedence = (props) => props.rel === "stylesheet" && "precedence" in props;
+const shouldDeDupeByKey = (tagName, supportSort) => {
+	if (tagName === "link") return supportSort;
+	return deDupeKeyMap[tagName].length > 0;
+};
+//#endregion
+export { dataPrecedenceAttr, deDupeKeyMap, domRenderers, isStylesheetLinkWithPrecedence, shouldDeDupeByKey };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/jsx/intrinsic-element/components.js

@@ -0,0 +1,124 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { raw } from "../../utils/html.js";
+import { PERMALINK } from "../constants.js";
+import { useContext } from "../context.js";
+import { dataPrecedenceAttr, deDupeKeyMap, isStylesheetLinkWithPrecedence, shouldDeDupeByKey } from "./common.js";
+import { toArray } from "../children.js";
+import { JSXNode, getNameSpaceContext, renderChildren } from "../base.js";
+//#region src/jsx/intrinsic-element/components.ts
+var components_exports = /* @__PURE__ */ __exportAll({
+	button: () => button,
+	form: () => form,
+	input: () => input,
+	link: () => link,
+	meta: () => meta,
+	script: () => script,
+	style: () => style,
+	title: () => title
+});
+const metaTagMap = /* @__PURE__ */ new WeakMap();
+const insertIntoHead = (tagName, tag, props, precedence) => ({ buffer, context }) => {
+	if (!buffer) return;
+	const map = metaTagMap.get(context) || {};
+	metaTagMap.set(context, map);
+	const tags = map[tagName] ||= [];
+	let duped = false;
+	const deDupeKeys = deDupeKeyMap[tagName];
+	const deDupeByKey = shouldDeDupeByKey(tagName, precedence !== void 0);
+	if (deDupeByKey) LOOP: for (const [, tagProps] of tags) {
+		if (tagName === "link" && !(tagProps.rel === "stylesheet" && tagProps["data-precedence"] !== void 0)) continue;
+		for (const key of deDupeKeys) if ((tagProps?.[key] ?? null) === props?.[key]) {
+			duped = true;
+			break LOOP;
+		}
+	}
+	if (duped) buffer[0] = buffer[0].replaceAll(tag, "");
+	else if (deDupeByKey || tagName === "link") tags.push([
+		tag,
+		props,
+		precedence
+	]);
+	else tags.unshift([
+		tag,
+		props,
+		precedence
+	]);
+	if (buffer[0].indexOf("</head>") !== -1) {
+		let insertTags;
+		if (tagName === "link" || precedence !== void 0) {
+			const precedences = [];
+			insertTags = tags.map(([tag, , tagPrecedence], index) => {
+				if (tagPrecedence === void 0) return [
+					tag,
+					Number.MAX_SAFE_INTEGER,
+					index
+				];
+				let order = precedences.indexOf(tagPrecedence);
+				if (order === -1) {
+					precedences.push(tagPrecedence);
+					order = precedences.length - 1;
+				}
+				return [
+					tag,
+					order,
+					index
+				];
+			}).sort((a, b) => a[1] - b[1] || a[2] - b[2]).map(([tag]) => tag);
+		} else insertTags = tags.map(([tag]) => tag);
+		insertTags.forEach((tag) => {
+			buffer[0] = buffer[0].replaceAll(tag, "");
+		});
+		buffer[0] = buffer[0].replace(/(?=<\/head>)/, () => insertTags.join(""));
+	}
+};
+const returnWithoutSpecialBehavior = (tag, children, props) => renderChildren([new JSXNode(tag, props, toArray(children ?? []))]);
+const documentMetadataTag = (tag, children, props, sort) => {
+	if ("itemProp" in props) return returnWithoutSpecialBehavior(tag, children, props);
+	let { precedence, blocking, ...restProps } = props;
+	precedence = sort ? precedence ?? "" : void 0;
+	if (sort) restProps[dataPrecedenceAttr] = precedence;
+	const string = new JSXNode(tag, restProps, toArray(children || [])).toString();
+	if (string instanceof Promise) return string.then((resString) => raw(resString, [...resString.callbacks || [], insertIntoHead(tag, resString, restProps, precedence)]));
+	else return raw(string, [insertIntoHead(tag, string, restProps, precedence)]);
+};
+const title = ({ children, ...props }) => {
+	const nameSpaceContext = getNameSpaceContext();
+	if (nameSpaceContext) {
+		const context = useContext(nameSpaceContext);
+		if (context === "svg" || context === "head") return new JSXNode("title", props, toArray(children ?? []));
+	}
+	return documentMetadataTag("title", children, props, false);
+};
+const script = ({ children, ...props }) => {
+	const nameSpaceContext = getNameSpaceContext();
+	if (["src", "async"].some((k) => !props[k]) || nameSpaceContext && useContext(nameSpaceContext) === "head") return returnWithoutSpecialBehavior("script", children, props);
+	return documentMetadataTag("script", children, props, false);
+};
+const style = ({ children, ...props }) => {
+	if (!["href", "precedence"].every((k) => k in props)) return returnWithoutSpecialBehavior("style", children, props);
+	props["data-href"] = props.href;
+	delete props.href;
+	return documentMetadataTag("style", children, props, true);
+};
+const link = ({ children, ...props }) => {
+	if (["onLoad", "onError"].some((k) => k in props) || props.rel === "stylesheet" && (!("precedence" in props) || "disabled" in props)) return returnWithoutSpecialBehavior("link", children, props);
+	return documentMetadataTag("link", children, props, isStylesheetLinkWithPrecedence(props));
+};
+const meta = ({ children, ...props }) => {
+	const nameSpaceContext = getNameSpaceContext();
+	if (nameSpaceContext && useContext(nameSpaceContext) === "head") return returnWithoutSpecialBehavior("meta", children, props);
+	return documentMetadataTag("meta", children, props, false);
+};
+const newJSXNode = (tag, { children, ...props }) => new JSXNode(tag, props, toArray(children ?? []));
+const form = (props) => {
+	if (typeof props.action === "function") props.action = PERMALINK in props.action ? props.action[PERMALINK] : void 0;
+	return newJSXNode("form", props);
+};
+const formActionableElement = (tag, props) => {
+	if (typeof props.formAction === "function") props.formAction = PERMALINK in props.formAction ? props.formAction[PERMALINK] : void 0;
+	return newJSXNode(tag, props);
+};
+const input = (props) => formActionableElement("input", props);
+const button = (props) => formActionableElement("button", props);
+//#endregion
+export { button, components_exports, form, input, link, meta, script, style, title };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/jsx/intrinsic-elements.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/jsx/jsx-dev-runtime.js

@@ -0,0 +1,14 @@
+import { Fragment, jsxFn } from "./base.js";
+//#region src/jsx/jsx-dev-runtime.ts
+function jsxDEV(tag, props, key) {
+	let node;
+	if (!props || !("children" in props)) node = jsxFn(tag, props, []);
+	else {
+		const children = props.children;
+		node = Array.isArray(children) ? jsxFn(tag, props, children) : jsxFn(tag, props, [children]);
+	}
+	node.key = key;
+	return node;
+}
+//#endregion
+export { Fragment, jsxDEV };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/jsx/jsx-runtime.js

@@ -0,0 +1,31 @@
+import { escapeToBuffer, raw, stringBufferToString } from "../utils/html.js";
+import { html } from "../helper/html/index.js";
+import { isValidAttributeName, styleObjectForEach } from "./utils.js";
+import { Fragment } from "./base.js";
+import { jsxDEV } from "./jsx-dev-runtime.js";
+//#region src/jsx/jsx-runtime.ts
+const jsxAttr = (key, v) => {
+	if (!isValidAttributeName(key)) return raw("");
+	const buffer = [`${key}="`];
+	if (key === "style" && typeof v === "object") {
+		let styleStr = "";
+		styleObjectForEach(v, (property, value) => {
+			if (value != null) styleStr += `${styleStr ? ";" : ""}${property}:${value}`;
+		});
+		escapeToBuffer(styleStr, buffer);
+		buffer[0] += "\"";
+	} else if (typeof v === "string") {
+		escapeToBuffer(v, buffer);
+		buffer[0] += "\"";
+	} else if (v === null || v === void 0) return raw("");
+	else if (typeof v === "number" || v.isEscaped) buffer[0] += `${v}"`;
+	else if (v instanceof Promise) buffer.unshift("\"", v);
+	else {
+		escapeToBuffer(v.toString(), buffer);
+		buffer[0] += "\"";
+	}
+	return buffer.length === 1 ? raw(buffer[0]) : stringBufferToString(buffer, void 0);
+};
+const jsxEscape = (value) => value;
+//#endregion
+export { Fragment, jsxDEV as jsx, jsxAttr, jsxEscape, html as jsxTemplate, jsxDEV as jsxs };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/jsx/streaming.js

@@ -0,0 +1,132 @@
+import { HtmlEscapedCallbackPhase, raw, resolveCallback } from "../utils/html.js";
+import { DOM_RENDERER, DOM_STASH } from "./constants.js";
+import { captureRenderContext, createContext, useContext } from "./context.js";
+import { JSXNode, isUntrustedObject, renderChildren, renderUntrustedObject } from "./base.js";
+import { buildDataStack } from "./dom/render.js";
+import { Suspense as Suspense$1 } from "./dom/components.js";
+import { childrenToString } from "./components.js";
+//#region src/jsx/streaming.ts
+/**
+* @module
+* This module enables JSX to supports streaming Response.
+*/
+/**
+* Used to specify nonce for scripts generated by `Suspense` and `ErrorBoundary`.
+*
+* @example
+* ```tsx
+* <StreamingContext.Provider value={{ scriptNonce: 'test-nonce' }}>
+*   <Suspense fallback={<p>Loading...</p>}>
+*     <Content />
+*   </Suspense>
+* </StreamingContext.Provider>
+* ```
+*/
+const StreamingContext = createContext(null);
+let suspenseCounter = 0;
+const serializeBoundaryChild = (child) => typeof child === "string" || Array.isArray(child) ? renderChildren([child]) : child == null || typeof child === "boolean" ? "" : isUntrustedObject(child) ? renderUntrustedObject(child) : child.toString();
+/**
+* @experimental
+* `Suspense` is an experimental feature.
+* The API might be changed.
+*/
+const Suspense = async ({ children, fallback }) => {
+	if (!Array.isArray(children)) children = [children];
+	const nonce = useContext(StreamingContext)?.scriptNonce;
+	let resArray = [];
+	const stackNode = { [DOM_STASH]: [0, []] };
+	const popNodeStack = () => {
+		buildDataStack.pop();
+	};
+	try {
+		stackNode[DOM_STASH][0] = 0;
+		buildDataStack.push([[], stackNode]);
+		resArray = children.map(serializeBoundaryChild);
+	} catch (e) {
+		if (e instanceof Promise) {
+			const resume = captureRenderContext();
+			resArray = [e.then(() => resume(() => {
+				stackNode[DOM_STASH][0] = 0;
+				buildDataStack.push([[], stackNode]);
+				return childrenToString(children).finally(popNodeStack);
+			}))];
+		} else throw e;
+	} finally {
+		popNodeStack();
+	}
+	if (resArray.some((res) => res instanceof Promise)) {
+		const index = suspenseCounter++;
+		const fallbackStr = await (typeof fallback === "string" || Array.isArray(fallback) ? renderChildren([fallback]) : isUntrustedObject(fallback) ? renderUntrustedObject(fallback) : fallback.toString());
+		return raw(`<template id="H:${index}"></template>${fallbackStr}<!--/$-->`, [...fallbackStr.callbacks || [], ({ phase, buffer, context }) => {
+			if (phase === HtmlEscapedCallbackPhase.BeforeStream) return;
+			return Promise.all(resArray).then(async (htmlArray) => {
+				htmlArray = htmlArray.flat();
+				const content = htmlArray.join("");
+				if (buffer) buffer[0] = buffer[0].replace(new RegExp(`<template id="H:${index}"></template>.*?<!--/\\$-->`, "s"), () => content);
+				let html = buffer ? "" : `<template data-hono-target="H:${index}">${content}</template><script${nonce ? ` nonce="${nonce}"` : ""}>
+((d,c,n) => {
+c=d.currentScript.previousSibling
+d=d.getElementById('H:${index}')
+if(!d)return
+do{n=d.nextSibling;n.remove()}while(n.nodeType!=8||n.nodeValue!='/$')
+d.replaceWith(c.content)
+})(document)
+<\/script>`;
+				const callbacks = htmlArray.map((html) => html.callbacks || []).flat();
+				if (!callbacks.length) return html;
+				if (phase === HtmlEscapedCallbackPhase.Stream) html = await resolveCallback(html, HtmlEscapedCallbackPhase.BeforeStream, true, context);
+				return raw(html, callbacks);
+			});
+		}]);
+	} else return raw(resArray.join(""));
+};
+Suspense[DOM_RENDERER] = Suspense$1;
+const textEncoder = new TextEncoder();
+/**
+* @experimental
+* `renderToReadableStream()` is an experimental feature.
+* The API might be changed.
+*/
+const renderToReadableStream = (content, onError = console.trace) => {
+	let cancelled = false;
+	return new ReadableStream({
+		async start(controller) {
+			try {
+				if (content instanceof JSXNode) content = content.toString();
+				const context = typeof content === "object" ? content : {};
+				const resolved = await resolveCallback(content, HtmlEscapedCallbackPhase.BeforeStream, true, context);
+				if (!cancelled) controller.enqueue(textEncoder.encode(resolved));
+				let resolvedCount = 0;
+				const callbacks = [];
+				const then = (promise) => {
+					callbacks.push(promise.catch((err) => {
+						console.log(err);
+						onError(err);
+						return "";
+					}).then(async (res) => {
+						res = await resolveCallback(res, HtmlEscapedCallbackPhase.BeforeStream, true, context);
+						res.callbacks?.map((c) => c({
+							phase: HtmlEscapedCallbackPhase.Stream,
+							context
+						})).filter(Boolean).forEach(then);
+						resolvedCount++;
+						if (!cancelled) controller.enqueue(textEncoder.encode(res));
+					}));
+				};
+				resolved.callbacks?.map((c) => c({
+					phase: HtmlEscapedCallbackPhase.Stream,
+					context
+				})).filter(Boolean).forEach(then);
+				while (resolvedCount !== callbacks.length) await Promise.all(callbacks);
+			} catch (e) {
+				onError(e);
+			}
+			if (!cancelled) controller.close();
+		},
+		cancel() {
+			cancelled = true;
+		}
+	});
+};
+//#endregion
+export { StreamingContext, Suspense, renderToReadableStream };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/jsx/types.js

@@ -0,0 +1 @@
+export {};