@oomol-lab/open-flow 0.1.0-beta.90 → 0.1.0-beta.91

package/dist/render/browser/runtime.js

@@ -27043,9 +27043,24 @@ var OpenFlowRenderer = (function(exports) {
 	//#region src/canvas/browser/base/routeLayout.ts
 	var clearance = 16;
 	var portOffset = 24;
+	function componentIndex(sets) {
+		return new Map(sets.flatMap((ids, index) => ids.map((id) => [id, index])));
+	}
 	/** Orthogonal channels around the measured cards, in primary/cross coordinates. */
-	function routeLayout(nodes, edges) {
+	function routeLayout(nodes, edges, options = {}) {
 		const byId = new Map(nodes.map((node) => [node.id, node]));
+		const graph = new ie.Graph();
+		for (const node of nodes) graph.setNode(node.id);
+		for (const edge of edges) graph.setEdge(edge.source, edge.target);
+		const components = componentIndex(ie.alg.components(graph));
+		const cycles = componentIndex(ie.alg.tarjan(graph));
+		const obstacles = nodes.map((node) => ({
+			component: components.get(node.id),
+			left: node.x - clearance,
+			right: node.x + node.width + clearance,
+			top: node.y - clearance,
+			bottom: node.y + node.height + clearance
+		}));
 		const connections = edges.map((edge) => {
 			const source = byId.get(edge.source);
 			const target = byId.get(edge.target);
@@ -27058,11 +27073,15 @@ var OpenFlowRenderer = (function(exports) {
 				y: target.y + (edge.targetOffset?.y ?? target.height / 2)
 			};
 			const offset = output.x < input.x ? Math.min(portOffset, (input.x - output.x) / 2) : portOffset;
+			const feedback = input.x <= output.x && cycles.get(edge.source) === cycles.get(edge.target);
 			return {
 				id: edge.id,
+				component: components.get(edge.source),
 				source: output,
 				target: input,
 				returnSide: input.x <= output.x ? Math.sign(input.y - output.y) : 0,
+				feedback,
+				returnLane: void 0,
 				start: {
 					x: output.x + offset,
 					y: output.y
@@ -27073,12 +27092,23 @@ var OpenFlowRenderer = (function(exports) {
 				}
 			};
 		});
-		const obstacles = nodes.map((node) => ({
-			left: node.x - clearance,
-			right: node.x + node.width + clearance,
-			top: node.y - clearance,
-			bottom: node.y + node.height + clearance
-		}));
+		const feedback = connections.filter((edge) => edge.feedback).toSorted((a, b) => a.source.x - a.target.x - (b.source.x - b.target.x));
+		for (const [index, edge] of feedback.entries()) {
+			const side = edge.source.y <= edge.target.y ? -1 : 1;
+			const span = obstacles.filter((rect) => rect.component === edge.component && rect.right >= edge.end.x && rect.left <= edge.start.x);
+			let lane = side < 0 ? Math.min(...span.map((rect) => rect.top)) : Math.max(...span.map((rect) => rect.bottom));
+			let previousLane;
+			do {
+				previousLane = lane;
+				for (const rect of obstacles) if (rect.right >= edge.end.x && rect.left <= edge.start.x && lane > rect.top && lane < rect.bottom) lane = side < 0 ? rect.top : rect.bottom;
+				for (const other of feedback.slice(0, index)) {
+					if (other.component !== edge.component || other.start.x < edge.end.x || other.end.x > edge.start.x) continue;
+					if (side < 0 && other.returnLane <= lane) lane = other.returnLane - clearance;
+					if (side > 0 && other.returnLane >= lane) lane = other.returnLane + clearance;
+				}
+			} while (lane !== previousLane);
+			edge.returnLane = lane;
+		}
 		const routes = /* @__PURE__ */ new Map();
 		const pending = connections.filter((edge) => {
 			if (edge.start.x > edge.end.x) return true;
@@ -27110,7 +27140,11 @@ var OpenFlowRenderer = (function(exports) {
 		});
 		if (!pending.length) return routes;
 		const xs = [.../* @__PURE__ */ new Set([...obstacles.flatMap((rect) => [rect.left, rect.right]), ...pending.flatMap((edge) => [edge.start.x, edge.end.x])])].toSorted((a, b) => a - b);
-		const ys = [.../* @__PURE__ */ new Set([...obstacles.flatMap((rect) => [rect.top, rect.bottom]), ...pending.flatMap((edge) => [edge.start.y, edge.end.y])])].toSorted((a, b) => a - b);
+		const ys = [.../* @__PURE__ */ new Set([...obstacles.flatMap((rect) => [rect.top, rect.bottom]), ...pending.flatMap((edge) => edge.returnLane == null ? [edge.start.y, edge.end.y] : [
+			edge.start.y,
+			edge.end.y,
+			edge.returnLane
+		])])].toSorted((a, b) => a - b);
 		const xIndex = new Map(xs.map((value, index) => [value, index]));
 		const yIndex = new Map(ys.map((value, index) => [value, index]));
 		const columns = xs.length;
@@ -27160,7 +27194,9 @@ var OpenFlowRenderer = (function(exports) {
 				];
 				for (const [index, next] of moves.entries()) {
 					if (next < 0 || vertex === start && index === 0 || next === end && index === 0) continue;
-					if (edge.returnSide * (ys[Math.floor(next / columns)] - edge.start.y) < -1e-6) continue;
+					if (edge.returnLane != null) {
+						if (index === 0 && ys[y] !== edge.returnLane) continue;
+					} else if (edge.returnSide * (ys[Math.floor(next / columns)] - edge.start.y) < -1e-6) continue;
 					const axis = index < 2 ? 0 : 1;
 					const state = next * 2 + axis;
 					const length = Math.abs(xs[next % columns] - xs[x]) + Math.abs(ys[Math.floor(next / columns)] - ys[y]);
@@ -27175,7 +27211,10 @@ var OpenFlowRenderer = (function(exports) {
 					});
 				}
 			}
-			if (finish < 0) throw new Error("Could not route the compact workflow connection.");
+			if (finish < 0) {
+				if (options.allowBlockedPorts) continue;
+				throw new Error("Could not route the compact workflow connection.");
+			}
 			const points = [];
 			for (let state = finish; state >= 0; state = previous[state]) {
 				const vertex = Math.floor(state / 2);
@@ -33545,7 +33584,8 @@ var OpenFlowRenderer = (function(exports) {
 		constructor(model, editable, language, callbacks, options = {}) {
 			this.canDeleteNodes = true;
 			this.dispose = disposableStore();
-			this.connectionRoutes = this.dispose.add(val(/* @__PURE__ */ new Map()));
+			this.exportRoutes = this.dispose.add(val(/* @__PURE__ */ new Map()));
+			this.layoutRequest = this.dispose.add(val(0));
 			this.ignoredNodeIds = this.dispose.add(val([]));
 			this.ignoreNodes = (nodeIds, ignored) => {
 				if (this.$.editable.value) this.#callbacks.onIgnoreNodes?.(nodeIds, ignored);
@@ -33572,16 +33612,27 @@ var OpenFlowRenderer = (function(exports) {
 			};
 			this.disposed = false;
 			this.layoutMeasurementAttempts = 0;
+			this.initialLayoutPending = false;
 			this.#modelDirection = "horizontal";
 			this.pendingNodeDeletes = /* @__PURE__ */ new Set();
 			this.pendingDisconnects = /* @__PURE__ */ new Map();
 			this.#entries = /* @__PURE__ */ new Map();
 			this.#modelPositions = /* @__PURE__ */ new Map();
 			this.#selectedNodeIds = /* @__PURE__ */ new Set();
+			this.requestLayout = () => {
+				if (this.disposed) return;
+				this.layoutComplete = false;
+				this.layoutMeasurementAttempts = 0;
+				this.initialLayoutPending = true;
+				this.layoutRequest.set(this.layoutRequest.value + 1);
+			};
 			this.completeLayout = (availableWidth) => {
 				if (this.disposed || this.layoutComplete) return true;
 				const nodes = this.allLayoutNodes();
-				if (nodes.length === 0 && !this.$.changingDirection.value) return true;
+				if (nodes.length === 0 && !this.$.changingDirection.value) {
+					this.resolveInitialLayout(void 0);
+					return true;
+				}
 				for (const node of nodes) {
 					const measured = node.$.measured.value;
 					if (!measured?.width || !measured.height) {
@@ -33589,6 +33640,7 @@ var OpenFlowRenderer = (function(exports) {
 						this.layoutMeasurementAttempts = 0;
 						this.layoutComplete = true;
 						this.#restoreDirection();
+						this.resolveInitialLayout(void 0);
 						return true;
 					}
 				}
@@ -33596,6 +33648,10 @@ var OpenFlowRenderer = (function(exports) {
 				this.applyPositions(positions);
 				this.layoutMeasurementAttempts = 0;
 				this.layoutComplete = true;
+				this.resolveInitialLayout({
+					direction: this.$.direction.value,
+					positions
+				});
 				if (this.$.changingDirection.value) this.#saveDirection(positions);
 				else this.#callbacks.onMoveNodes(positions);
 				return "relayout";
@@ -33730,7 +33786,7 @@ var OpenFlowRenderer = (function(exports) {
 			const commentNodes = this.dispose.add(reactiveMap(null, { onDeleted: dispose }));
 			const viewport = this.dispose.add(val(model.viewport, { equal: isSameViewport }));
 			this.rfCommand = this.dispose.add(createRFCommand(nodes));
-			this.layoutComplete = !options.autoLayout;
+			this.layoutComplete = true;
 			this.#runStatus = this.dispose.add(val(model.runStatus == "running" ? FLOW_RUN_STATUS.Running : FLOW_RUN_STATUS.Idle));
 			this.#connections = this.dispose.add(val([]));
 			const edges = this.dispose.add(deriveEdges(this.#connections, nodes));
@@ -33767,8 +33823,14 @@ var OpenFlowRenderer = (function(exports) {
 				nodeMiniMapPhase: this.dispose.add(compute((get) => getNodeMinimap(get(nodes.$).size + get(commentNodes.$).size, get(viewport)?.zoom ?? 1)))
 			};
 			this.#syncModel(model);
+			if (options.autoLayout) this.requestLayout();
 			if (options.defaultDirection != null) this.changeDirection(options.defaultDirection);
 		}
+		resolveInitialLayout(layout) {
+			if (!this.initialLayoutPending) return;
+			this.initialLayoutPending = false;
+			this.#callbacks.onInitialLayout?.(layout);
+		}
 		async #saveDirection(positions) {
 			try {
 				if (!await this.#callbacks.onChangeDirection?.(this.$.direction.value, positions) && !this.disposed) this.#restoreDirection();
@@ -33874,7 +33936,7 @@ var OpenFlowRenderer = (function(exports) {
 				edges
 			}, insets, aspectRatio);
 			this.applyPositions(result.positions);
-			this.connectionRoutes.set(result.routes);
+			this.exportRoutes.set(result.routes);
 			return result.bounds;
 		}
 		doRemoveNodes(nodes) {
@@ -56887,6 +56949,71 @@ var OpenFlowRenderer = (function(exports) {
 		return `${path} L ${end.x} ${end.y}`;
 	}
 	//#endregion
+	//#region src/canvas/browser/graph/Edges/ConnectionRoutes.tsx
+	init_use_value_enhancer();
+	var emptyRoutes = /* @__PURE__ */ new Map();
+	var emptyNodes = [];
+	var emptyEdges = [];
+	var ConnectionRoutesContext = (0, import_react$4.createContext)(emptyRoutes);
+	function inactiveNodes() {
+		return emptyNodes;
+	}
+	function measuredNodes(state) {
+		return [...state.nodeLookup.values()].flatMap((node) => node.hidden || !node.measured.width || !node.measured.height ? [] : [{
+			id: node.id,
+			...layoutAxes(node.internals.positionAbsolute, "vertical"),
+			width: node.measured.height,
+			height: node.measured.width,
+			column: 0,
+			handles: node.internals.handleBounds
+		}]);
+	}
+	function sameNodes(a, b) {
+		return a.length === b.length && a.every((node, index) => shallowPlainObjectEqual(node, b[index]));
+	}
+	/** Share obstacle-aware routes using React Flow's measured cards and actual ports. */
+	function ConnectionRoutesProvider({ direction, routes$, children }) {
+		const planned = useVal(routes$);
+		const active = direction === "vertical" && !planned?.size;
+		const nodes = useStore$1(active ? measuredNodes : inactiveNodes, sameNodes);
+		const edges = useStore$1((state) => active ? state.edges : emptyEdges);
+		const routes = (0, import_react$4.useMemo)(() => {
+			if (planned?.size) return planned;
+			if (direction !== "vertical") return emptyRoutes;
+			const byId = new Map(nodes.map((node) => [node.id, node]));
+			const connections = edges.flatMap((edge) => {
+				const source = byId.get(edge.source);
+				const target = byId.get(edge.target);
+				const output = source?.handles?.source?.find((handle) => edge.sourceHandle == null || handle.id === edge.sourceHandle);
+				const input = target?.handles?.target?.find((handle) => edge.targetHandle == null || handle.id === edge.targetHandle);
+				if (edge.hidden || !source || !target || output?.position !== Position$1.Bottom || input?.position !== Position$1.Top) return [];
+				return [{
+					id: edge.id,
+					source: edge.source,
+					target: edge.target,
+					sourceOffset: {
+						x: output.y + output.height,
+						y: output.x + output.width / 2
+					},
+					targetOffset: {
+						x: input.y,
+						y: input.x + input.width / 2
+					}
+				}];
+			});
+			return new Map([...routeLayout(nodes, connections, { allowBlockedPorts: true })].map(([id, points]) => [id, points.map((point) => layoutAxes(point, "vertical"))]));
+		}, [
+			direction,
+			nodes,
+			edges,
+			planned
+		]);
+		return /* @__PURE__ */ (0, import_jsx_runtime$2.jsx)(ConnectionRoutesContext.Provider, {
+			value: routes,
+			children
+		});
+	}
+	//#endregion
 	//#region src/canvas/browser/graph/Edges/EdgeGradient.tsx
 	function EdgeGradient({ id, sourceX, sourceY, targetX, targetY, sourceColor, targetColor }) {
 		return /* @__PURE__ */ (0, import_jsx_runtime$2.jsx)("defs", { children: /* @__PURE__ */ (0, import_jsx_runtime$2.jsxs)("linearGradient", {
@@ -56914,7 +57041,7 @@ var OpenFlowRenderer = (function(exports) {
 		const error = useVal(edgeStore?.$.error);
 		const canvasStore = useCanvasStore();
 		const scale = useVal(canvasStore.$.scale);
-		const routes = useVal(canvasStore.connectionRoutes);
+		const routes = (0, import_react$4.useContext)(ConnectionRoutesContext);
 		const gap = 3;
 		const targetX = props.targetX + (props.targetPosition == Position$1.Left ? -3 : props.targetPosition == Position$1.Right ? gap : 0);
 		const targetY = props.targetY + (props.targetPosition == Position$1.Top ? -3 : props.targetPosition == Position$1.Bottom ? gap : 0);
@@ -123616,7 +123743,7 @@ var OpenFlowRenderer = (function(exports) {
 	* @returns {Location}
 	*   Accessors for index.
 	*/
-	function location(file) {
+	function location$1(file) {
 		const value = String(file);
 		/**
 		* List, where each index is a line number (0-based), and each value is the
@@ -123736,7 +123863,7 @@ var OpenFlowRenderer = (function(exports) {
 				};
 				if (state.file && state.location) {
 					const document = String(state.file);
-					const loc = location(document);
+					const loc = location$1(document);
 					const start = loc.toPoint(0);
 					const end = loc.toPoint(document.length);
 					result.position = {
@@ -243402,7 +243529,7 @@ ${seriesRules.join("\n")}${tipRules}
 	};
 	var COMPILE_INVALID = /* @__PURE__ */ Symbol.for("zod.compile.invalid");
 	var COMPILE_FALLBACK = /* @__PURE__ */ Symbol.for("zod.compile.fallback");
-	var validate = ((schema, value, _ctx) => {
+	var validate$1 = ((schema, value, _ctx) => {
 		const validator = schema._zod.bag.validator;
 		if (validator !== void 0) {
 			if (validator(value) !== COMPILE_INVALID) return true;
@@ -247436,7 +247563,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			own(this, "spa", value);
 		},
 		validate(data, params) {
-			return validate(this, data, params);
+			return validate$1(this, data, params);
 		},
 		validateAsync(data, params) {
 			return validateAsync$1(this, data, params);
@@ -249685,9 +249812,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 						i18n: props.i18n,
 						children: /* @__PURE__ */ (0, import_jsx_runtime$2.jsx)(TooltipProvider, {
 							delay: 300,
-							children: /* @__PURE__ */ (0, import_jsx_runtime$2.jsx)(ReactFlowProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime$2.jsx)(HandleContextProvider, {
-								Handle: Handle$1,
-								children: /* @__PURE__ */ (0, import_jsx_runtime$2.jsx)(ReactFlowContainerInner, { ...props })
+							children: /* @__PURE__ */ (0, import_jsx_runtime$2.jsx)(ReactFlowProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime$2.jsx)(ConnectionRoutesProvider, {
+								direction: props.direction,
+								routes$: props.connectionRoutes$,
+								children: /* @__PURE__ */ (0, import_jsx_runtime$2.jsx)(HandleContextProvider, {
+									Handle: Handle$1,
+									children: /* @__PURE__ */ (0, import_jsx_runtime$2.jsx)(ReactFlowContainerInner, { ...props })
+								})
 							}) })
 						})
 					})
@@ -249939,7 +250070,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		]);
 		(0, import_react$4.useLayoutEffect)(() => {
 			setLayoutReady(props.layoutMotion !== false || props.onLayoutMeasured == null);
-		}, [props.layoutMotion, props.onLayoutMeasured]);
+		}, [
+			props.layoutMotion,
+			props.onLayoutMeasured,
+			props.layoutRequest
+		]);
 		(0, import_react$4.useEffect)(() => {
 			let active = true;
 			let measurementFrame = 0;
@@ -249986,6 +250121,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			onBeforeFitView,
 			props.layoutMotion,
 			props.onLayoutMeasured,
+			props.layoutRequest,
 			props.direction,
 			rf,
 			updateNodeInternals
@@ -250412,6 +250548,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 	var FlowCanvas = ({ flowCanvasStore, annotationContext, onActivateSelection, onSelectionStart, onSelectionEnd, onInspectSelection, inspectorOpen = false, onRequestAddNode, cornerTools, cornerLeading, topLeftTools, bottomRightTools, toolbar, dark, dottedBackground, fitView, nodesDraggable, layoutMotion, className, addNodeRequest, addItemRequest, onInit, onMove, onMoveEnd, onNodeDragStop, onSelectionChange, isValidConnection, onDropAddItem }) => {
 		const editable = useVal(flowCanvasStore.$.editable);
 		const direction = useVal(flowCanvasStore.$.direction);
+		const layoutRequest = useVal(flowCanvasStore.layoutRequest);
 		const changingDirection = useVal(flowCanvasStore.$.changingDirection);
 		const nodeMiniMapPhase = useVal(flowCanvasStore.$.nodeMiniMapPhase);
 		(0, import_react$4.useEffect)(flowCanvasStore.setupForceDelete, []);
@@ -250445,12 +250582,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 							fitView: fitView ?? !editable,
 							fitViewOptions,
 							layoutMotion,
+							layoutRequest,
 							nodeTypes: NODE_TYPES,
 							edgeTypes: EDGE_TYPES,
 							miniMapExpanded$: flowCanvasStore.$$.miniMapExpanded,
 							interactiveMode$: flowCanvasStore.$$.interactiveMode,
 							nodes$: flowCanvasStore.$.rfNodes,
 							edges$: flowCanvasStore.$.rfEdges,
+							connectionRoutes$: flowCanvasStore.exportRoutes,
 							viewport$: flowCanvasStore.$$.viewport,
 							onRequestAddNode,
 							addNodeRequest,
@@ -261369,6 +261508,136 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		bodyFormat: _enum(["none", "json"]).default("none")
 	}).extend({ kind: literal("connector-proxy") });
 	//#endregion
+	//#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/deep-compare-strict.js
+	function deepCompareStrict(a, b) {
+		const typeofa = typeof a;
+		if (typeofa !== typeof b) return false;
+		if (Array.isArray(a)) {
+			if (!Array.isArray(b)) return false;
+			const length = a.length;
+			if (length !== b.length) return false;
+			for (let i = 0; i < length; i++) if (!deepCompareStrict(a[i], b[i])) return false;
+			return true;
+		}
+		if (typeofa === "object") {
+			if (!a || !b) return a === b;
+			const aKeys = Object.keys(a);
+			const bKeys = Object.keys(b);
+			if (aKeys.length !== bKeys.length) return false;
+			for (const k of aKeys) if (!deepCompareStrict(a[k], b[k])) return false;
+			return true;
+		}
+		return a === b;
+	}
+	//#endregion
+	//#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/pointer.js
+	function encodePointer(p) {
+		return encodeURI(escapePointer(p));
+	}
+	function escapePointer(p) {
+		return p.replace(/~/g, "~0").replace(/\//g, "~1");
+	}
+	//#endregion
+	//#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/dereference.js
+	var schemaArrayKeyword = {
+		prefixItems: true,
+		items: true,
+		allOf: true,
+		anyOf: true,
+		oneOf: true
+	};
+	var schemaMapKeyword = {
+		$defs: true,
+		definitions: true,
+		properties: true,
+		patternProperties: true,
+		dependentSchemas: true
+	};
+	var ignoredKeyword = {
+		id: true,
+		$id: true,
+		$ref: true,
+		$schema: true,
+		$anchor: true,
+		$vocabulary: true,
+		$comment: true,
+		default: true,
+		enum: true,
+		const: true,
+		required: true,
+		type: true,
+		maximum: true,
+		minimum: true,
+		exclusiveMaximum: true,
+		exclusiveMinimum: true,
+		multipleOf: true,
+		maxLength: true,
+		minLength: true,
+		pattern: true,
+		format: true,
+		maxItems: true,
+		minItems: true,
+		uniqueItems: true,
+		maxProperties: true,
+		minProperties: true
+	};
+	var initialBaseURI = typeof self !== "undefined" && self.location && self.location.origin !== "null" ? new URL(self.location.origin + self.location.pathname + location.search) : new URL("https://github.com/cfworker");
+	function dereference(schema, lookup = Object.create(null), baseURI = initialBaseURI, basePointer = "") {
+		if (schema && typeof schema === "object" && !Array.isArray(schema)) {
+			const id = schema.$id || schema.id;
+			if (id) {
+				const url = new URL(id, baseURI.href);
+				if (url.hash.length > 1) lookup[url.href] = schema;
+				else {
+					url.hash = "";
+					if (basePointer === "") baseURI = url;
+					else dereference(schema, lookup, baseURI);
+				}
+			}
+		} else if (schema !== true && schema !== false) return lookup;
+		const schemaURI = baseURI.href + (basePointer ? "#" + basePointer : "");
+		if (lookup[schemaURI] !== void 0) throw new Error(`Duplicate schema URI "${schemaURI}".`);
+		lookup[schemaURI] = schema;
+		if (schema === true || schema === false) return lookup;
+		if (schema.__absolute_uri__ === void 0) Object.defineProperty(schema, "__absolute_uri__", {
+			enumerable: false,
+			value: schemaURI
+		});
+		if (schema.$ref && schema.__absolute_ref__ === void 0) {
+			const url = new URL(schema.$ref, baseURI.href);
+			url.hash = url.hash;
+			Object.defineProperty(schema, "__absolute_ref__", {
+				enumerable: false,
+				value: url.href
+			});
+		}
+		if (schema.$recursiveRef && schema.__absolute_recursive_ref__ === void 0) {
+			const url = new URL(schema.$recursiveRef, baseURI.href);
+			url.hash = url.hash;
+			Object.defineProperty(schema, "__absolute_recursive_ref__", {
+				enumerable: false,
+				value: url.href
+			});
+		}
+		if (schema.$anchor) {
+			const url = new URL("#" + schema.$anchor, baseURI.href);
+			lookup[url.href] = schema;
+		}
+		for (let key in schema) {
+			if (ignoredKeyword[key]) continue;
+			const keyBase = `${basePointer}/${encodePointer(key)}`;
+			const subSchema = schema[key];
+			if (Array.isArray(subSchema)) {
+				if (schemaArrayKeyword[key]) {
+					const length = subSchema.length;
+					for (let i = 0; i < length; i++) dereference(subSchema[i], lookup, baseURI, `${keyBase}/${i}`);
+				}
+			} else if (schemaMapKeyword[key]) for (let subKey in subSchema) dereference(subSchema[subKey], lookup, baseURI, `${keyBase}/${encodePointer(subKey)}`);
+			else dereference(subSchema, lookup, baseURI, keyBase);
+		}
+		return lookup;
+	}
+	//#endregion
 	//#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/format.js
 	var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
 	var DAYS = [
@@ -261469,6 +261738,656 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		}
 	}
 	//#endregion
+	//#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/ucs2-length.js
+	function ucs2length(s) {
+		let result = 0;
+		let length = s.length;
+		let index = 0;
+		let charCode;
+		while (index < length) {
+			result++;
+			charCode = s.charCodeAt(index++);
+			if (charCode >= 55296 && charCode <= 56319 && index < length) {
+				charCode = s.charCodeAt(index);
+				if ((charCode & 64512) == 56320) index++;
+			}
+		}
+		return result;
+	}
+	//#endregion
+	//#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/validate.js
+	function validate(instance, schema, draft = "2019-09", lookup = dereference(schema), shortCircuit = true, recursiveAnchor = null, instanceLocation = "#", schemaLocation = "#", evaluated = Object.create(null)) {
+		if (schema === true) return {
+			valid: true,
+			errors: []
+		};
+		if (schema === false) return {
+			valid: false,
+			errors: [{
+				instanceLocation,
+				keyword: "false",
+				keywordLocation: instanceLocation,
+				error: "False boolean schema."
+			}]
+		};
+		const rawInstanceType = typeof instance;
+		let instanceType;
+		switch (rawInstanceType) {
+			case "boolean":
+			case "number":
+			case "string":
+				instanceType = rawInstanceType;
+				break;
+			case "object":
+				if (instance === null) instanceType = "null";
+				else if (Array.isArray(instance)) instanceType = "array";
+				else instanceType = "object";
+				break;
+			default: throw new Error(`Instances of "${rawInstanceType}" type are not supported.`);
+		}
+		const { $ref, $recursiveRef, $recursiveAnchor, type: $type, const: $const, enum: $enum, required: $required, not: $not, anyOf: $anyOf, allOf: $allOf, oneOf: $oneOf, if: $if, then: $then, else: $else, format: $format, properties: $properties, patternProperties: $patternProperties, additionalProperties: $additionalProperties, unevaluatedProperties: $unevaluatedProperties, minProperties: $minProperties, maxProperties: $maxProperties, propertyNames: $propertyNames, dependentRequired: $dependentRequired, dependentSchemas: $dependentSchemas, dependencies: $dependencies, prefixItems: $prefixItems, items: $items, additionalItems: $additionalItems, unevaluatedItems: $unevaluatedItems, contains: $contains, minContains: $minContains, maxContains: $maxContains, minItems: $minItems, maxItems: $maxItems, uniqueItems: $uniqueItems, minimum: $minimum, maximum: $maximum, exclusiveMinimum: $exclusiveMinimum, exclusiveMaximum: $exclusiveMaximum, multipleOf: $multipleOf, minLength: $minLength, maxLength: $maxLength, pattern: $pattern, __absolute_ref__, __absolute_recursive_ref__ } = schema;
+		const errors = [];
+		if ($recursiveAnchor === true && recursiveAnchor === null) recursiveAnchor = schema;
+		if ($recursiveRef === "#") {
+			const refSchema = recursiveAnchor === null ? lookup[__absolute_recursive_ref__] : recursiveAnchor;
+			const keywordLocation = `${schemaLocation}/$recursiveRef`;
+			const result = validate(instance, recursiveAnchor === null ? schema : recursiveAnchor, draft, lookup, shortCircuit, refSchema, instanceLocation, keywordLocation, evaluated);
+			if (!result.valid) errors.push({
+				instanceLocation,
+				keyword: "$recursiveRef",
+				keywordLocation,
+				error: "A subschema had errors."
+			}, ...result.errors);
+		}
+		if ($ref !== void 0) {
+			const refSchema = lookup[__absolute_ref__ || $ref];
+			if (refSchema === void 0) {
+				let message = `Unresolved $ref "${$ref}".`;
+				if (__absolute_ref__ && __absolute_ref__ !== $ref) message += `  Absolute URI "${__absolute_ref__}".`;
+				message += `\nKnown schemas:\n- ${Object.keys(lookup).join("\n- ")}`;
+				throw new Error(message);
+			}
+			const keywordLocation = `${schemaLocation}/$ref`;
+			const result = validate(instance, refSchema, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, keywordLocation, evaluated);
+			if (!result.valid) errors.push({
+				instanceLocation,
+				keyword: "$ref",
+				keywordLocation,
+				error: "A subschema had errors."
+			}, ...result.errors);
+			if (draft === "4" || draft === "7") return {
+				valid: errors.length === 0,
+				errors
+			};
+		}
+		if (Array.isArray($type)) {
+			let length = $type.length;
+			let valid = false;
+			for (let i = 0; i < length; i++) if (instanceType === $type[i] || $type[i] === "integer" && instanceType === "number" && instance % 1 === 0 && instance === instance) {
+				valid = true;
+				break;
+			}
+			if (!valid) errors.push({
+				instanceLocation,
+				keyword: "type",
+				keywordLocation: `${schemaLocation}/type`,
+				error: `Instance type "${instanceType}" is invalid. Expected "${$type.join("\", \"")}".`
+			});
+		} else if ($type === "integer") {
+			if (instanceType !== "number" || instance % 1 || instance !== instance) errors.push({
+				instanceLocation,
+				keyword: "type",
+				keywordLocation: `${schemaLocation}/type`,
+				error: `Instance type "${instanceType}" is invalid. Expected "${$type}".`
+			});
+		} else if ($type !== void 0 && instanceType !== $type) errors.push({
+			instanceLocation,
+			keyword: "type",
+			keywordLocation: `${schemaLocation}/type`,
+			error: `Instance type "${instanceType}" is invalid. Expected "${$type}".`
+		});
+		if ($const !== void 0) {
+			if (instanceType === "object" || instanceType === "array") {
+				if (!deepCompareStrict(instance, $const)) errors.push({
+					instanceLocation,
+					keyword: "const",
+					keywordLocation: `${schemaLocation}/const`,
+					error: `Instance does not match ${JSON.stringify($const)}.`
+				});
+			} else if (instance !== $const) errors.push({
+				instanceLocation,
+				keyword: "const",
+				keywordLocation: `${schemaLocation}/const`,
+				error: `Instance does not match ${JSON.stringify($const)}.`
+			});
+		}
+		if ($enum !== void 0) {
+			if (instanceType === "object" || instanceType === "array") {
+				if (!$enum.some((value) => deepCompareStrict(instance, value))) errors.push({
+					instanceLocation,
+					keyword: "enum",
+					keywordLocation: `${schemaLocation}/enum`,
+					error: `Instance does not match any of ${JSON.stringify($enum)}.`
+				});
+			} else if (!$enum.some((value) => instance === value)) errors.push({
+				instanceLocation,
+				keyword: "enum",
+				keywordLocation: `${schemaLocation}/enum`,
+				error: `Instance does not match any of ${JSON.stringify($enum)}.`
+			});
+		}
+		if ($not !== void 0) {
+			const keywordLocation = `${schemaLocation}/not`;
+			if (validate(instance, $not, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, keywordLocation).valid) errors.push({
+				instanceLocation,
+				keyword: "not",
+				keywordLocation,
+				error: "Instance matched \"not\" schema."
+			});
+		}
+		let subEvaluateds = [];
+		if ($anyOf !== void 0) {
+			const keywordLocation = `${schemaLocation}/anyOf`;
+			const errorsLength = errors.length;
+			let anyValid = false;
+			for (let i = 0; i < $anyOf.length; i++) {
+				const subSchema = $anyOf[i];
+				const subEvaluated = Object.create(evaluated);
+				const result = validate(instance, subSchema, draft, lookup, shortCircuit, $recursiveAnchor === true ? recursiveAnchor : null, instanceLocation, `${keywordLocation}/${i}`, subEvaluated);
+				errors.push(...result.errors);
+				anyValid = anyValid || result.valid;
+				if (result.valid) subEvaluateds.push(subEvaluated);
+			}
+			if (anyValid) errors.length = errorsLength;
+			else errors.splice(errorsLength, 0, {
+				instanceLocation,
+				keyword: "anyOf",
+				keywordLocation,
+				error: "Instance does not match any subschemas."
+			});
+		}
+		if ($allOf !== void 0) {
+			const keywordLocation = `${schemaLocation}/allOf`;
+			const errorsLength = errors.length;
+			let allValid = true;
+			for (let i = 0; i < $allOf.length; i++) {
+				const subSchema = $allOf[i];
+				const subEvaluated = Object.create(evaluated);
+				const result = validate(instance, subSchema, draft, lookup, shortCircuit, $recursiveAnchor === true ? recursiveAnchor : null, instanceLocation, `${keywordLocation}/${i}`, subEvaluated);
+				errors.push(...result.errors);
+				allValid = allValid && result.valid;
+				if (result.valid) subEvaluateds.push(subEvaluated);
+			}
+			if (allValid) errors.length = errorsLength;
+			else errors.splice(errorsLength, 0, {
+				instanceLocation,
+				keyword: "allOf",
+				keywordLocation,
+				error: `Instance does not match every subschema.`
+			});
+		}
+		if ($oneOf !== void 0) {
+			const keywordLocation = `${schemaLocation}/oneOf`;
+			const errorsLength = errors.length;
+			const matches = $oneOf.filter((subSchema, i) => {
+				const subEvaluated = Object.create(evaluated);
+				const result = validate(instance, subSchema, draft, lookup, shortCircuit, $recursiveAnchor === true ? recursiveAnchor : null, instanceLocation, `${keywordLocation}/${i}`, subEvaluated);
+				errors.push(...result.errors);
+				if (result.valid) subEvaluateds.push(subEvaluated);
+				return result.valid;
+			}).length;
+			if (matches === 1) errors.length = errorsLength;
+			else errors.splice(errorsLength, 0, {
+				instanceLocation,
+				keyword: "oneOf",
+				keywordLocation,
+				error: `Instance does not match exactly one subschema (${matches} matches).`
+			});
+		}
+		if (instanceType === "object" || instanceType === "array") Object.assign(evaluated, ...subEvaluateds);
+		if ($if !== void 0) {
+			const keywordLocation = `${schemaLocation}/if`;
+			if (validate(instance, $if, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, keywordLocation, evaluated).valid) {
+				if ($then !== void 0) {
+					const thenResult = validate(instance, $then, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${schemaLocation}/then`, evaluated);
+					if (!thenResult.valid) errors.push({
+						instanceLocation,
+						keyword: "if",
+						keywordLocation,
+						error: `Instance does not match "then" schema.`
+					}, ...thenResult.errors);
+				}
+			} else if ($else !== void 0) {
+				const elseResult = validate(instance, $else, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${schemaLocation}/else`, evaluated);
+				if (!elseResult.valid) errors.push({
+					instanceLocation,
+					keyword: "if",
+					keywordLocation,
+					error: `Instance does not match "else" schema.`
+				}, ...elseResult.errors);
+			}
+		}
+		if (instanceType === "object") {
+			if ($required !== void 0) {
+				for (const key of $required) if (!(key in instance)) errors.push({
+					instanceLocation,
+					keyword: "required",
+					keywordLocation: `${schemaLocation}/required`,
+					error: `Instance does not have required property "${key}".`
+				});
+			}
+			const keys = Object.keys(instance);
+			if ($minProperties !== void 0 && keys.length < $minProperties) errors.push({
+				instanceLocation,
+				keyword: "minProperties",
+				keywordLocation: `${schemaLocation}/minProperties`,
+				error: `Instance does not have at least ${$minProperties} properties.`
+			});
+			if ($maxProperties !== void 0 && keys.length > $maxProperties) errors.push({
+				instanceLocation,
+				keyword: "maxProperties",
+				keywordLocation: `${schemaLocation}/maxProperties`,
+				error: `Instance does not have at least ${$maxProperties} properties.`
+			});
+			if ($propertyNames !== void 0) {
+				const keywordLocation = `${schemaLocation}/propertyNames`;
+				for (const key in instance) {
+					const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
+					const result = validate(key, $propertyNames, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, keywordLocation);
+					if (!result.valid) errors.push({
+						instanceLocation,
+						keyword: "propertyNames",
+						keywordLocation,
+						error: `Property name "${key}" does not match schema.`
+					}, ...result.errors);
+				}
+			}
+			if ($dependentRequired !== void 0) {
+				const keywordLocation = `${schemaLocation}/dependantRequired`;
+				for (const key in $dependentRequired) if (key in instance) {
+					const required = $dependentRequired[key];
+					for (const dependantKey of required) if (!(dependantKey in instance)) errors.push({
+						instanceLocation,
+						keyword: "dependentRequired",
+						keywordLocation,
+						error: `Instance has "${key}" but does not have "${dependantKey}".`
+					});
+				}
+			}
+			if ($dependentSchemas !== void 0) for (const key in $dependentSchemas) {
+				const keywordLocation = `${schemaLocation}/dependentSchemas`;
+				if (key in instance) {
+					const result = validate(instance, $dependentSchemas[key], draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${keywordLocation}/${encodePointer(key)}`, evaluated);
+					if (!result.valid) errors.push({
+						instanceLocation,
+						keyword: "dependentSchemas",
+						keywordLocation,
+						error: `Instance has "${key}" but does not match dependant schema.`
+					}, ...result.errors);
+				}
+			}
+			if ($dependencies !== void 0) {
+				const keywordLocation = `${schemaLocation}/dependencies`;
+				for (const key in $dependencies) if (key in instance) {
+					const propsOrSchema = $dependencies[key];
+					if (Array.isArray(propsOrSchema)) {
+						for (const dependantKey of propsOrSchema) if (!(dependantKey in instance)) errors.push({
+							instanceLocation,
+							keyword: "dependencies",
+							keywordLocation,
+							error: `Instance has "${key}" but does not have "${dependantKey}".`
+						});
+					} else {
+						const result = validate(instance, propsOrSchema, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${keywordLocation}/${encodePointer(key)}`);
+						if (!result.valid) errors.push({
+							instanceLocation,
+							keyword: "dependencies",
+							keywordLocation,
+							error: `Instance has "${key}" but does not match dependant schema.`
+						}, ...result.errors);
+					}
+				}
+			}
+			const thisEvaluated = Object.create(null);
+			let stop = false;
+			if ($properties !== void 0) {
+				const keywordLocation = `${schemaLocation}/properties`;
+				for (const key in $properties) {
+					if (!(key in instance)) continue;
+					const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
+					const result = validate(instance[key], $properties[key], draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, `${keywordLocation}/${encodePointer(key)}`);
+					if (result.valid) evaluated[key] = thisEvaluated[key] = true;
+					else {
+						stop = shortCircuit;
+						errors.push({
+							instanceLocation,
+							keyword: "properties",
+							keywordLocation,
+							error: `Property "${key}" does not match schema.`
+						}, ...result.errors);
+						if (stop) break;
+					}
+				}
+			}
+			if (!stop && $patternProperties !== void 0) {
+				const keywordLocation = `${schemaLocation}/patternProperties`;
+				for (const pattern in $patternProperties) {
+					const regex = new RegExp(pattern, "u");
+					const subSchema = $patternProperties[pattern];
+					for (const key in instance) {
+						if (!regex.test(key)) continue;
+						const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
+						const result = validate(instance[key], subSchema, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, `${keywordLocation}/${encodePointer(pattern)}`);
+						if (result.valid) evaluated[key] = thisEvaluated[key] = true;
+						else {
+							stop = shortCircuit;
+							errors.push({
+								instanceLocation,
+								keyword: "patternProperties",
+								keywordLocation,
+								error: `Property "${key}" matches pattern "${pattern}" but does not match associated schema.`
+							}, ...result.errors);
+						}
+					}
+				}
+			}
+			if (!stop && $additionalProperties !== void 0) {
+				const keywordLocation = `${schemaLocation}/additionalProperties`;
+				for (const key in instance) {
+					if (thisEvaluated[key]) continue;
+					const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
+					const result = validate(instance[key], $additionalProperties, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, keywordLocation);
+					if (result.valid) evaluated[key] = true;
+					else {
+						stop = shortCircuit;
+						errors.push({
+							instanceLocation,
+							keyword: "additionalProperties",
+							keywordLocation,
+							error: `Property "${key}" does not match additional properties schema.`
+						}, ...result.errors);
+					}
+				}
+			} else if (!stop && $unevaluatedProperties !== void 0) {
+				const keywordLocation = `${schemaLocation}/unevaluatedProperties`;
+				for (const key in instance) if (!evaluated[key]) {
+					const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
+					const result = validate(instance[key], $unevaluatedProperties, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, keywordLocation);
+					if (result.valid) evaluated[key] = true;
+					else errors.push({
+						instanceLocation,
+						keyword: "unevaluatedProperties",
+						keywordLocation,
+						error: `Property "${key}" does not match unevaluated properties schema.`
+					}, ...result.errors);
+				}
+			}
+		} else if (instanceType === "array") {
+			if ($maxItems !== void 0 && instance.length > $maxItems) errors.push({
+				instanceLocation,
+				keyword: "maxItems",
+				keywordLocation: `${schemaLocation}/maxItems`,
+				error: `Array has too many items (${instance.length} > ${$maxItems}).`
+			});
+			if ($minItems !== void 0 && instance.length < $minItems) errors.push({
+				instanceLocation,
+				keyword: "minItems",
+				keywordLocation: `${schemaLocation}/minItems`,
+				error: `Array has too few items (${instance.length} < ${$minItems}).`
+			});
+			const length = instance.length;
+			let i = 0;
+			let stop = false;
+			if ($prefixItems !== void 0) {
+				const keywordLocation = `${schemaLocation}/prefixItems`;
+				const length2 = Math.min($prefixItems.length, length);
+				for (; i < length2; i++) {
+					const result = validate(instance[i], $prefixItems[i], draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, `${keywordLocation}/${i}`);
+					evaluated[i] = true;
+					if (!result.valid) {
+						stop = shortCircuit;
+						errors.push({
+							instanceLocation,
+							keyword: "prefixItems",
+							keywordLocation,
+							error: `Items did not match schema.`
+						}, ...result.errors);
+						if (stop) break;
+					}
+				}
+			}
+			if ($items !== void 0) {
+				const keywordLocation = `${schemaLocation}/items`;
+				if (Array.isArray($items)) {
+					const length2 = Math.min($items.length, length);
+					for (; i < length2; i++) {
+						const result = validate(instance[i], $items[i], draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, `${keywordLocation}/${i}`);
+						evaluated[i] = true;
+						if (!result.valid) {
+							stop = shortCircuit;
+							errors.push({
+								instanceLocation,
+								keyword: "items",
+								keywordLocation,
+								error: `Items did not match schema.`
+							}, ...result.errors);
+							if (stop) break;
+						}
+					}
+				} else for (; i < length; i++) {
+					const result = validate(instance[i], $items, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, keywordLocation);
+					evaluated[i] = true;
+					if (!result.valid) {
+						stop = shortCircuit;
+						errors.push({
+							instanceLocation,
+							keyword: "items",
+							keywordLocation,
+							error: `Items did not match schema.`
+						}, ...result.errors);
+						if (stop) break;
+					}
+				}
+				if (!stop && $additionalItems !== void 0) {
+					const keywordLocation = `${schemaLocation}/additionalItems`;
+					for (; i < length; i++) {
+						const result = validate(instance[i], $additionalItems, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, keywordLocation);
+						evaluated[i] = true;
+						if (!result.valid) {
+							stop = shortCircuit;
+							errors.push({
+								instanceLocation,
+								keyword: "additionalItems",
+								keywordLocation,
+								error: `Items did not match additional items schema.`
+							}, ...result.errors);
+						}
+					}
+				}
+			}
+			if ($contains !== void 0) {
+				if (length === 0 && $minContains === void 0) errors.push({
+					instanceLocation,
+					keyword: "contains",
+					keywordLocation: `${schemaLocation}/contains`,
+					error: `Array is empty. It must contain at least one item matching the schema.`
+				});
+				else if ($minContains !== void 0 && length < $minContains) errors.push({
+					instanceLocation,
+					keyword: "minContains",
+					keywordLocation: `${schemaLocation}/minContains`,
+					error: `Array has less items (${length}) than minContains (${$minContains}).`
+				});
+				else {
+					const keywordLocation = `${schemaLocation}/contains`;
+					const errorsLength = errors.length;
+					let contained = 0;
+					for (let j = 0; j < length; j++) {
+						const result = validate(instance[j], $contains, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${j}`, keywordLocation);
+						if (result.valid) {
+							evaluated[j] = true;
+							contained++;
+						} else errors.push(...result.errors);
+					}
+					if (contained >= ($minContains || 0)) errors.length = errorsLength;
+					if ($minContains === void 0 && $maxContains === void 0 && contained === 0) errors.splice(errorsLength, 0, {
+						instanceLocation,
+						keyword: "contains",
+						keywordLocation,
+						error: `Array does not contain item matching schema.`
+					});
+					else if ($minContains !== void 0 && contained < $minContains) errors.push({
+						instanceLocation,
+						keyword: "minContains",
+						keywordLocation: `${schemaLocation}/minContains`,
+						error: `Array must contain at least ${$minContains} items matching schema. Only ${contained} items were found.`
+					});
+					else if ($maxContains !== void 0 && contained > $maxContains) errors.push({
+						instanceLocation,
+						keyword: "maxContains",
+						keywordLocation: `${schemaLocation}/maxContains`,
+						error: `Array may contain at most ${$maxContains} items matching schema. ${contained} items were found.`
+					});
+				}
+			}
+			if (!stop && $unevaluatedItems !== void 0) {
+				const keywordLocation = `${schemaLocation}/unevaluatedItems`;
+				for (; i < length; i++) {
+					if (evaluated[i]) continue;
+					const result = validate(instance[i], $unevaluatedItems, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, keywordLocation);
+					evaluated[i] = true;
+					if (!result.valid) errors.push({
+						instanceLocation,
+						keyword: "unevaluatedItems",
+						keywordLocation,
+						error: `Items did not match unevaluated items schema.`
+					}, ...result.errors);
+				}
+			}
+			if ($uniqueItems) for (let j = 0; j < length; j++) {
+				const a = instance[j];
+				const ao = typeof a === "object" && a !== null;
+				for (let k = 0; k < length; k++) {
+					if (j === k) continue;
+					const b = instance[k];
+					if (a === b || ao && typeof b === "object" && b !== null && deepCompareStrict(a, b)) {
+						errors.push({
+							instanceLocation,
+							keyword: "uniqueItems",
+							keywordLocation: `${schemaLocation}/uniqueItems`,
+							error: `Duplicate items at indexes ${j} and ${k}.`
+						});
+						j = Number.MAX_SAFE_INTEGER;
+						k = Number.MAX_SAFE_INTEGER;
+					}
+				}
+			}
+		} else if (instanceType === "number") {
+			if (draft === "4") {
+				if ($minimum !== void 0 && ($exclusiveMinimum === true && instance <= $minimum || instance < $minimum)) errors.push({
+					instanceLocation,
+					keyword: "minimum",
+					keywordLocation: `${schemaLocation}/minimum`,
+					error: `${instance} is less than ${$exclusiveMinimum ? "or equal to " : ""} ${$minimum}.`
+				});
+				if ($maximum !== void 0 && ($exclusiveMaximum === true && instance >= $maximum || instance > $maximum)) errors.push({
+					instanceLocation,
+					keyword: "maximum",
+					keywordLocation: `${schemaLocation}/maximum`,
+					error: `${instance} is greater than ${$exclusiveMaximum ? "or equal to " : ""} ${$maximum}.`
+				});
+			} else {
+				if ($minimum !== void 0 && instance < $minimum) errors.push({
+					instanceLocation,
+					keyword: "minimum",
+					keywordLocation: `${schemaLocation}/minimum`,
+					error: `${instance} is less than ${$minimum}.`
+				});
+				if ($maximum !== void 0 && instance > $maximum) errors.push({
+					instanceLocation,
+					keyword: "maximum",
+					keywordLocation: `${schemaLocation}/maximum`,
+					error: `${instance} is greater than ${$maximum}.`
+				});
+				if ($exclusiveMinimum !== void 0 && instance <= $exclusiveMinimum) errors.push({
+					instanceLocation,
+					keyword: "exclusiveMinimum",
+					keywordLocation: `${schemaLocation}/exclusiveMinimum`,
+					error: `${instance} is less than ${$exclusiveMinimum}.`
+				});
+				if ($exclusiveMaximum !== void 0 && instance >= $exclusiveMaximum) errors.push({
+					instanceLocation,
+					keyword: "exclusiveMaximum",
+					keywordLocation: `${schemaLocation}/exclusiveMaximum`,
+					error: `${instance} is greater than or equal to ${$exclusiveMaximum}.`
+				});
+			}
+			if ($multipleOf !== void 0) {
+				const remainder = instance % $multipleOf;
+				if (Math.abs(0 - remainder) >= 1.1920929e-7 && Math.abs($multipleOf - remainder) >= 1.1920929e-7) errors.push({
+					instanceLocation,
+					keyword: "multipleOf",
+					keywordLocation: `${schemaLocation}/multipleOf`,
+					error: `${instance} is not a multiple of ${$multipleOf}.`
+				});
+			}
+		} else if (instanceType === "string") {
+			const length = $minLength === void 0 && $maxLength === void 0 ? 0 : ucs2length(instance);
+			if ($minLength !== void 0 && length < $minLength) errors.push({
+				instanceLocation,
+				keyword: "minLength",
+				keywordLocation: `${schemaLocation}/minLength`,
+				error: `String is too short (${length} < ${$minLength}).`
+			});
+			if ($maxLength !== void 0 && length > $maxLength) errors.push({
+				instanceLocation,
+				keyword: "maxLength",
+				keywordLocation: `${schemaLocation}/maxLength`,
+				error: `String is too long (${length} > ${$maxLength}).`
+			});
+			if ($pattern !== void 0 && !new RegExp($pattern, "u").test(instance)) errors.push({
+				instanceLocation,
+				keyword: "pattern",
+				keywordLocation: `${schemaLocation}/pattern`,
+				error: `String does not match pattern.`
+			});
+			if ($format !== void 0 && format[$format] && !format[$format](instance)) errors.push({
+				instanceLocation,
+				keyword: "format",
+				keywordLocation: `${schemaLocation}/format`,
+				error: `String does not match format "${$format}".`
+			});
+		}
+		return {
+			valid: errors.length === 0,
+			errors
+		};
+	}
+	//#endregion
+	//#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/validator.js
+	var Validator = class {
+		schema;
+		draft;
+		shortCircuit;
+		lookup;
+		constructor(schema, draft = "2019-09", shortCircuit = true) {
+			this.schema = schema;
+			this.draft = draft;
+			this.shortCircuit = shortCircuit;
+			this.lookup = dereference(schema);
+		}
+		validate(instance) {
+			return validate(instance, this.schema, this.draft, this.lookup, this.shortCircuit);
+		}
+		addSchema(schema, id) {
+			if (id) schema = {
+				...schema,
+				$id: id
+			};
+			dereference(schema, this.lookup);
+		}
+	};
+	//#endregion
 	//#region src/json-schema-subset/utils.ts
 	var nextId = 0;
 	function createId() {
@@ -263422,6 +264341,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			if (value1 === null || value2 === null) return false;
 			if (typeof value1 !== "object") return false;
 			if (typeof value1 !== typeof value2) return false;
+			if (extendsContext.isExtendsSchema(value1) || extendsContext.isExtendsSchema(value2)) return extendsContext.equals(value1, value2);
 			if (isCompiledSchema(value1) && isCompiledSchema(value2)) return isCompiledSchemaEquals(value1, value2);
 			return isObjectLikeEquals(value1, value2);
 		}
@@ -264145,10 +265065,17 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		}
 		constructor(id, value, context) {
 			if (!SingleSelectSchema.isMatch(value)) throw new TypeError("Invalid single-select schema.");
-			super(id, value, context);
+			const validator = new Validator(structuredClone(value), "7");
+			super(id, { enum: value.enum.filter((item) => validator.validate(item).valid) }, context);
 		}
 		compareImpl(other) {
-			if (isStringLikeSchema(other)) return [ExpressionSingleResult.ContainedBy];
+			if (this.value.enum.length == 0) return [(other instanceof SingleSelectSchema ? other.value.enum.length == 0 : isCompiledSchema(other) && getKind(other) === CompiledKind.Never) ? ExpressionSingleResult.Equals : ExpressionSingleResult.ContainedBy];
+			if (isStringLikeSchema(other)) {
+				const validator = new Validator(structuredClone(other), "7");
+				const accepted = this.value.enum.filter((item) => validator.validate(item).valid).length;
+				if (accepted == this.value.enum.length) return [ExpressionSingleResult.ContainedBy];
+				return [accepted == 0 ? ExpressionSingleResult.Rejection : ExpressionSingleResult.Intersection];
+			}
 			if (other instanceof SingleSelectSchema) {
 				const f = new Set(this.value.enum);
 				let result = ExpressionSingleResult.Equals;
@@ -267710,9 +268637,8 @@ export function identity(value) { return value }
 			edges
 		};
 	}
-	function layoutNodes(nodeIds, dependencies, dependents) {
+	function orderNodes(nodeIds, dependencies, dependents) {
 		const indegree = new Map([...dependencies].map(([nodeId, sources]) => [nodeId, sources.size]));
-		const depth = /* @__PURE__ */ new Map();
 		const ordered = [];
 		const orderedIds = /* @__PURE__ */ new Set();
 		const ready = [...indegree].filter(([, count]) => count == 0).map(([nodeId]) => nodeId).toSorted();
@@ -267720,23 +268646,14 @@ export function identity(value) { return value }
 			const nodeId = ready[cursor];
 			ordered.push(nodeId);
 			orderedIds.add(nodeId);
-			const nextDepth = (depth.get(nodeId) ?? 0) + 1;
 			for (const targetId of [...dependents.get(nodeId)].toSorted()) {
-				depth.set(targetId, Math.max(depth.get(targetId) ?? 0, nextDepth));
 				const count = indegree.get(targetId) - 1;
 				indegree.set(targetId, count);
 				if (count == 0) ready.push(targetId);
 			}
 		}
-		const cycleDepth = Math.max(0, ...depth.values()) + 1;
-		for (const nodeId of [...nodeIds].filter((candidate) => !orderedIds.has(candidate)).toSorted()) {
-			depth.set(nodeId, cycleDepth);
-			ordered.push(nodeId);
-		}
-		return {
-			depth,
-			ordered
-		};
+		for (const nodeId of [...nodeIds].filter((candidate) => !orderedIds.has(candidate)).toSorted()) ordered.push(nodeId);
+		return ordered;
 	}
 	function designerInputs(nodeId, node, ports, revision) {
 		if (isTriggerNode(node)) return [];
@@ -267933,6 +268850,7 @@ export function identity(value) { return value }
 		const graph = revision == null ? void 0 : revision.graph();
 		if (revision == null || graph == null) return {
 			edges: [],
+			needsLayout: false,
 			nodes: [],
 			viewport: {
 				x: 0,
@@ -267946,7 +268864,7 @@ export function identity(value) { return value }
 		const nodeIds = new Set(entries.map(([nodeId]) => nodeId));
 		const ports = new Map([...definitions].map(([nodeId, node]) => [nodeId, nodePorts(node, revision)]));
 		const edgeProjection = projectEdges(graph, nodeIds);
-		const layout = layoutNodes(nodeIds, edgeProjection.dependencies, edgeProjection.dependents);
+		const ordered = orderNodes(nodeIds, edgeProjection.dependencies, edgeProjection.dependents);
 		const direction = savedDirection(presentation);
 		const positions = savedPositions(presentation);
 		const hiddenNodeContent = savedHiddenNodeContent(presentation);
@@ -267961,33 +268879,21 @@ export function identity(value) { return value }
 			runNodes: projectedRun.nodes,
 			t
 		};
-		const rows = /* @__PURE__ */ new Map();
-		const defaultNodes = layout.ordered.map((nodeId) => {
-			const column = layout.depth.get(nodeId) ?? 0;
-			const row = rows.get(column) ?? 0;
-			rows.set(column, row + 1);
-			return direction === "vertical" ? {
-				id: nodeId,
-				column,
-				x: 80 + row * 400,
-				y: 80 + column * 240,
-				width: 320,
-				height: 160
-			} : {
+		const defaultNodes = ordered.every((nodeId) => positions[nodeId] != null) ? [] : graphLayout(ordered.map((nodeId) => {
+			const { kind } = definitions.get(nodeId);
+			return {
 				id: nodeId,
-				column,
-				x: 80 + column * 500,
-				y: 80 + row * 240,
-				width: 420,
-				height: 240
+				width: direction === "vertical" ? 320 : 420,
+				height: direction === "vertical" ? 160 : 240,
+				branchHandles: kind === "condition" || kind === "approval" || kind === "wait" ? [...ports.get(nodeId).outputs.keys()].map((handle) => "$branch:" + handle) : void 0
 			};
-		});
+		}), edgeProjection.edges, direction).nodes;
 		const automaticPositions = direction === "horizontal" ? wrapLayout(defaultNodes) : Object.fromEntries(defaultNodes.map(({ id, x, y }) => [id, {
 			x,
 			y
 		}]));
 		const nodes = [];
-		for (const nodeId of layout.ordered) {
+		for (const nodeId of ordered) {
 			const position = positions[nodeId] ?? automaticPositions[nodeId];
 			const resolved = definitions.get(nodeId);
 			if (resolved.kind == "trigger") {
@@ -268015,6 +268921,7 @@ export function identity(value) { return value }
 		return {
 			direction,
 			edges: edgeProjection.edges,
+			needsLayout: nodes.length > 0 && nodes.every((node) => positions[node.id] == null),
 			nodes,
 			...projectedRun.status == null ? {} : { runStatus: projectedRun.status },
 			viewport: savedViewport(presentation)