@agimon-ai/po-cloudflare 0.0.2-alpha.0 → 0.0.2-alpha.2

package/dist/apiContracts-CHOiCbS_.js

@@ -0,0 +1,4451 @@
+import { A as Integer, C as Null, G as _Object_, M as Boolean, Q as _Array_, R as Intersect, U as Unknown, V as Unsafe, _ as Union, a as Partial, d as Record, h as Tuple, k as Literal, o as Omit, q as Optional$4, x as Number$1, y as String$1 } from "./build-2gFaVEfG.js";
+import { n as Check } from "./value-Djvc2foV.js";
+//#region ../../core/po-core/src/schemas/pluginProtocol.ts
+/** The address is always exact. A workspace call never resolves to a global service. */
+const PoPluginMountSchema = Union([
+	_Object_({ scope: Literal("global") }, { additionalProperties: false }),
+	_Object_({
+		scope: Literal("workspace"),
+		workspaceId: String$1({ minLength: 1 })
+	}, { additionalProperties: false }),
+	_Object_({
+		scope: Literal("session"),
+		sessionId: String$1({ minLength: 1 })
+	}, { additionalProperties: false })
+]);
+const PoPluginCallSchema = _Object_({
+	mount: PoPluginMountSchema,
+	service: String$1({ minLength: 1 }),
+	method: String$1({ minLength: 1 }),
+	input: Unknown()
+}, { additionalProperties: false });
+function definePoPluginMethod(definition) {
+	if (!definition.service || !definition.method) throw new Error("Plugin service and method must be named.");
+	return definition;
+}
+function poPluginMountKey(mount) {
+	if (!Check(PoPluginMountSchema, mount)) throw new Error("Invalid plugin mount.");
+	switch (mount.scope) {
+		case "global": return "global";
+		case "workspace": return `workspace:${mount.workspaceId}`;
+		case "session": return `session:${mount.sessionId}`;
+	}
+}
+var PoPluginCallError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "PoPluginCallError";
+	}
+};
+/** Transport-neutral dispatch, shared by Chord server services and client capability hosts. */
+function createPoPluginRegistry() {
+	const handlers = /* @__PURE__ */ new Map();
+	let disposed = false;
+	const keyOf = (mount, service, method, direction) => `${poPluginMountKey(mount)}\0${direction}\0${service}\0${method}`;
+	return {
+		register(mount, definition, handler) {
+			if (disposed) throw new Error("Plugin registry is disposed.");
+			if (mount.scope !== definition.scope) throw new Error(`Method '${definition.service}.${definition.method}' requires ${definition.scope} scope.`);
+			const key = keyOf(mount, definition.service, definition.method, definition.direction);
+			if (handlers.has(key)) throw new Error(`Plugin method '${definition.service}.${definition.method}' is already mounted.`);
+			const entry = {
+				definition,
+				handler
+			};
+			handlers.set(key, entry);
+			return () => {
+				if (handlers.get(key) === entry) handlers.delete(key);
+			};
+		},
+		async invoke(value, direction, caller = {}) {
+			if (disposed) throw new Error("Plugin registry is disposed.");
+			if (!Check(PoPluginCallSchema, value)) throw new PoPluginCallError("INVALID_CALL", "Invalid plugin call.");
+			const call = value;
+			const entry = handlers.get(keyOf(call.mount, call.service, call.method, direction));
+			if (!entry) throw new PoPluginCallError("METHOD_NOT_FOUND", `Plugin method '${call.service}.${call.method}' is not mounted at this scope.`);
+			if (!Check(entry.definition.input, call.input)) throw new PoPluginCallError("INVALID_INPUT", `Invalid input for '${call.service}.${call.method}'.`);
+			const output = await entry.handler(call.input, caller);
+			if (!Check(entry.definition.output, output)) throw new PoPluginCallError("INVALID_OUTPUT", `Invalid output from '${call.service}.${call.method}'.`);
+			return output;
+		},
+		dispose() {
+			disposed = true;
+			handlers.clear();
+		}
+	};
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@earendil-works+pi-schema@1.5.0/node_modules/@earendil-works/pi-schema/dist/builders.js
+/** A string, with optional length bounds (in code points), pattern and format. */
+function str(options = {}) {
+	return {
+		type: "string",
+		...options
+	};
+}
+/** A number within optional bounds. */
+function num(options = {}) {
+	return {
+		type: "number",
+		...options
+	};
+}
+/** An integer within optional bounds. */
+function int(options = {}) {
+	return {
+		type: "integer",
+		...options
+	};
+}
+/** A boolean. */
+function bool(options = {}) {
+	return {
+		type: "boolean",
+		...options
+	};
+}
+/** Any value. */
+function unknown(options = {}) {
+	return { ...options };
+}
+/** Exactly `value` (a string, number, boolean or null). */
+function lit(value, options = {}) {
+	return {
+		const: value,
+		...options
+	};
+}
+/** One of the given values. */
+function oneOf(values, options = {}) {
+	return {
+		enum: values,
+		...options
+	};
+}
+/**
+* Any of the given schemas. A union of objects tagged by a `lit()` property (`{ kind: lit("text"), ... }`) is checked
+* by the tag: only the branch it selects runs, and its errors are the ones reported.
+*/
+function union(schemas, options = {}) {
+	return {
+		anyOf: schemas,
+		...options
+	};
+}
+/** An array of `items`, with optional length bounds and unique items. */
+function arr(items, options = {}) {
+	return {
+		type: "array",
+		items,
+		...options
+	};
+}
+/** An object with string keys and values of `value` (a record). */
+function map(value, options = {}) {
+	return {
+		type: "object",
+		additionalProperties: value,
+		...options
+	};
+}
+/** An optional property of obj(): `{ name: opt(str()) }` may omit `name` or set it to undefined. */
+var Optional$3 = class {
+	schema;
+	constructor(schema) {
+		this.schema = schema;
+	}
+};
+/** Marks an obj() property as optional. */
+function opt(schema) {
+	return new Optional$3(schema);
+}
+/**
+* A closed object: the given properties (required unless opt()) and no others. `open: true` allows other
+* properties, as tool schemas from other systems often do.
+*/
+function obj(properties, options = {}) {
+	const { open, ...annotations } = options;
+	const props = {};
+	const required = [];
+	for (const [name, property] of Object.entries(properties)) if (property instanceof Optional$3) props[name] = property.schema;
+	else {
+		props[name] = property;
+		required.push(name);
+	}
+	return {
+		type: "object",
+		properties: props,
+		...required.length > 0 ? { required } : {},
+		...open === true ? {} : { additionalProperties: false },
+		...annotations
+	};
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@earendil-works+pi-schema@1.5.0/node_modules/@earendil-works/pi-schema/dist/resolver.js
+/** The base URI of a root schema without `$id`; relative references resolve against it. */
+const DEFAULT_BASE = "https://json-schema.invalid/root.json";
+/**
+* Resolves references in the root schema and the registered documents. The schema is indexed on the first
+* reference, so a schema without references is never walked for identifiers.
+*/
+var Resolver = class {
+	draft;
+	rootBase;
+	/** Schema object to the base URI it was indexed under. */
+	baseOf = /* @__PURE__ */ new Map();
+	/** URI (with a `#name` fragment) of every `$dynamicAnchor`, to its schema. */
+	dynamicAnchors = /* @__PURE__ */ new Map();
+	root;
+	options;
+	registry = /* @__PURE__ */ new Map();
+	rejectUnresolved;
+	/** The references that named nothing and resolved to `false` (with `unresolvedRefs: "reject"`). */
+	unresolved = /* @__PURE__ */ new Set();
+	resources = /* @__PURE__ */ new Map();
+	anchors = /* @__PURE__ */ new Map();
+	indexed = false;
+	constructor(root, options) {
+		this.draft = options.draft === "7" ? "7" : "2020-12";
+		this.root = root;
+		this.options = options;
+		this.rejectUnresolved = options.unresolvedRefs === "reject";
+		this.rootBase = isSchemaObject$1(root) ? this.baseFor(root, DEFAULT_BASE) : DEFAULT_BASE;
+	}
+	/**
+	* The base URI of `node`, whose parent has `base`: its `$id` changes it, unless draft 7 makes the `$id` inert. Once
+	* the schema is indexed, the indexed base (a resolved reference target already has its own).
+	*/
+	baseFor(node, base) {
+		const indexed = this.baseOf.get(node);
+		if (indexed !== void 0) return indexed;
+		const id = node.$id;
+		if (typeof id !== "string") return base;
+		if (this.draft === "7" && (typeof node.$ref === "string" || id.startsWith("#"))) return base;
+		return documentOf(resolveUri(id, base));
+	}
+	/** Indexes the root schema and the registered documents' URIs (once). */
+	ensureIndexed() {
+		if (this.indexed) return;
+		this.indexed = true;
+		for (const [uri, schema] of Object.entries(this.options.schemas ?? {})) this.registry.set(documentOf(resolveUri(uri, DEFAULT_BASE)), schema);
+		this.resources.set(DEFAULT_BASE, this.root);
+		this.index(this.root, DEFAULT_BASE);
+	}
+	/**
+	* The schema a reference names, with the base URI it compiles under. Throws if it names nothing, or, with
+	* `unresolvedRefs: "reject"`, resolves to `false`, the schema no value passes.
+	*/
+	resolve(ref, base) {
+		this.ensureIndexed();
+		if (!this.rejectUnresolved) return this.find(ref, base);
+		try {
+			return this.find(ref, base);
+		} catch {
+			this.unresolved.add(resolveUri(ref, base));
+			return {
+				node: false,
+				base
+			};
+		}
+	}
+	/** Whether `ref`, from `base`, named nothing and resolved to `false`. */
+	isUnresolved(ref, base) {
+		return this.unresolved.has(resolveUri(ref, base));
+	}
+	find(ref, base) {
+		const uri = resolveUri(ref, base);
+		const doc = documentOf(uri);
+		const fragment = uri.length > doc.length ? decodeURIComponent(uri.slice(doc.length + 1)) : "";
+		const root = this.resources.has(doc) ? this.resources.get(doc) : this.load(doc);
+		if (root === void 0) throw new Error(`Unresolved $ref ${ref} (no schema registered for ${doc})`);
+		if (fragment === "") return {
+			node: root,
+			base: doc
+		};
+		if (fragment.startsWith("/")) return this.pointer(root, doc, fragment);
+		const target = this.anchors.get(`${doc}#${fragment}`);
+		if (target === void 0) throw new Error(`Unresolved $ref ${ref} (no anchor ${fragment} in ${doc})`);
+		return {
+			node: target,
+			base: this.baseOf.get(target) ?? doc
+		};
+	}
+	/** Whether `node` is the root of the schema resource at `base`. */
+	isResource(node, base) {
+		this.ensureIndexed();
+		return this.resources.get(base) === node;
+	}
+	index(node, base) {
+		if (!isSchemaObject$1(node) || this.baseOf.has(node)) return;
+		let b = base;
+		const refOnly = this.draft === "7" && typeof node.$ref === "string";
+		if (!refOnly && typeof node.$id === "string") {
+			if (this.draft === "7" && node.$id.startsWith("#")) this.anchors.set(documentOf(b) + node.$id, node);
+			else {
+				const uri = resolveUri(node.$id, b);
+				b = documentOf(uri);
+				this.resources.set(b, node);
+				if (uri.length > b.length + 1) this.anchors.set(uri, node);
+			}
+		}
+		this.baseOf.set(node, b);
+		if (refOnly) return;
+		if (this.draft !== "7") {
+			if (typeof node.$anchor === "string") this.anchors.set(`${b}#${node.$anchor}`, node);
+			if (typeof node.$dynamicAnchor === "string") {
+				this.anchors.set(`${b}#${node.$dynamicAnchor}`, node);
+				this.dynamicAnchors.set(`${b}#${node.$dynamicAnchor}`, node);
+			}
+		}
+		for (const key of SCHEMA_KEYWORDS) this.index(node[key], b);
+		for (const key of MAP_KEYWORDS) {
+			const map = node[key];
+			if (isSchemaObject$1(map)) for (const k of Object.keys(map)) this.index(map[k], b);
+		}
+		for (const key of ARRAY_KEYWORDS) {
+			const list = node[key];
+			if (Array.isArray(list)) for (const s of list) this.index(s, b);
+		}
+	}
+	load(doc) {
+		const schema = this.registry.get(doc);
+		if (schema === void 0) return void 0;
+		this.resources.set(doc, schema);
+		this.index(schema, doc);
+		return schema;
+	}
+	pointer(root, base, fragment) {
+		let node = root;
+		let b = base;
+		for (const raw of fragment.split("/").slice(1)) {
+			const key = raw.replace(/~1/g, "/").replace(/~0/g, "~");
+			node = typeof node === "object" && node !== null && Object.hasOwn(node, key) ? node[key] : void 0;
+			if (node === void 0) throw new Error(`Unresolved $ref #${fragment} in ${base}`);
+			if (typeof node === "object" && node !== null) b = this.baseOf.get(node) ?? b;
+		}
+		return {
+			node,
+			base: b
+		};
+	}
+};
+const SCHEMA_KEYWORDS = [
+	"additionalProperties",
+	"propertyNames",
+	"contains",
+	"not",
+	"if",
+	"then",
+	"else",
+	"unevaluatedProperties",
+	"unevaluatedItems",
+	"additionalItems",
+	"contentSchema",
+	"items"
+];
+const MAP_KEYWORDS = [
+	"properties",
+	"patternProperties",
+	"$defs",
+	"definitions",
+	"dependentSchemas",
+	"dependencies"
+];
+const ARRAY_KEYWORDS = [
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"prefixItems",
+	"items"
+];
+/** Whether `value` is a schema object (not `true`/`false`, an array or a primitive). */
+function isSchemaObject$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** `ref` resolved against `base`. URNs and other bases a URL parser rejects take fragment-only references. */
+function resolveUri(ref, base) {
+	try {
+		return new URL(ref, base).href;
+	} catch {
+		return ref.startsWith("#") ? documentOf(base) + ref : ref;
+	}
+}
+/** `uri` without its fragment. */
+function documentOf(uri) {
+	const hash = uri.indexOf("#");
+	return hash < 0 ? uri : uri.slice(0, hash);
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@earendil-works+pi-schema@1.5.0/node_modules/@earendil-works/pi-schema/dist/shared.js
+/**
+* The regular expression of a `pattern` source, shared by source. Patterns are ECMAScript regular expressions with
+* the `u` flag; a source that is invalid with it (some older schemas escape characters `u` rejects) compiles
+* without it.
+*/
+function sharedRegex(source) {
+	const hit = regexes.get(source)?.deref();
+	if (hit !== void 0) return hit;
+	let re;
+	try {
+		re = new RegExp(source, "u");
+	} catch {
+		re = new RegExp(source);
+	}
+	regexes.set(source, new WeakRef(re));
+	regexCleanup.register(re, source);
+	return re;
+}
+const regexes = /* @__PURE__ */ new Map();
+const regexCleanup = new FinalizationRegistry((source) => {
+	if (regexes.get(source)?.deref() === void 0) regexes.delete(source);
+});
+//#endregion
+//#region ../../../node_modules/.pnpm/@earendil-works+pi-schema@1.5.0/node_modules/@earendil-works/pi-schema/dist/coerce.js
+/** Coerces values for one compiled schema. */
+var Coercer = class {
+	c;
+	schema;
+	/**
+	* The (schema node, value) pairs pass 2 is converting through a re-entry point, as a stack. Conversion can enter
+	* a node again with the same value only through a `$ref` or by wrapping a single value into an array (also for
+	* schemas that cycle through shared JS objects): a recursive schema that meets a value no branch accepts would
+	* convert it without end. A pair already on the stack (primitives by value, objects by reference) leaves the value
+	* unchanged. Only those two points push, so schemas without references or wraps pay nothing.
+	*/
+	entered = [];
+	/** How often a re-entry was cut short in this coerce() call; results computed across one are not memoized. */
+	cuts = 0;
+	/**
+	* Results of `$ref` targets by (node, value) within one coerce() call: a recursive union whose branches all
+	* convert the same children (and all fail) would convert them once per branch, exponentially in the depth.
+	*/
+	memo = void 0;
+	constructor(compiler, schema) {
+		this.c = compiler;
+		this.schema = schema;
+	}
+	/** `value` coerced: a copy along the changed paths only, or `value` itself when nothing changes. */
+	coerce(value) {
+		const base = this.c.r.rootBase;
+		const withoutNulls = this.dropOptionalNulls(value, this.schema, base);
+		return this.coerceTypes(this.convertOnly(withoutNulls), this.schema, base);
+	}
+	/** Pass 2 alone, as TypeBox's `Value.Convert` (the TypeBox conformance tests run it). */
+	convertOnly(value) {
+		try {
+			return this.convert(this.schema, this.c.r.rootBase, value);
+		} finally {
+			this.memo = void 0;
+			this.cuts = 0;
+		}
+	}
+	/** `node` converted for `value` at a re-entry point: unchanged when that pair is already being converted. */
+	reenter(node, base, value, memoize) {
+		const entered = this.entered;
+		for (let i = 0; i < entered.length; i += 2) if (entered[i] === node && Object.is(entered[i + 1], value)) {
+			this.cuts++;
+			return value;
+		}
+		const memo = memoize ? this.memo?.get(node) : void 0;
+		if (memo?.has(value)) return memo.get(value);
+		const cuts = this.cuts;
+		entered.push(node, value);
+		let result;
+		try {
+			result = this.convert(node, base, value);
+		} finally {
+			entered.length -= 2;
+		}
+		if (memoize && this.cuts === cuts) {
+			this.memo ??= /* @__PURE__ */ new Map();
+			let values = this.memo.get(node);
+			if (values === void 0) {
+				values = /* @__PURE__ */ new Map();
+				this.memo.set(node, values);
+			}
+			values.set(value, result);
+		}
+		return result;
+	}
+	/** Whether `value` passes the schema `node`; undefined when `node` cannot be compiled. */
+	passes(node, base, value) {
+		try {
+			return this.c.check(node, this.baseOf(node, base))(value);
+		} catch {
+			return;
+		}
+	}
+	baseOf(node, base) {
+		return isSchemaObject$1(node) ? this.c.r.baseOf.get(node) ?? base : base;
+	}
+	dropOptionalNulls(value, schema, base) {
+		if (!isSchemaObject$1(schema)) return value;
+		const b = this.baseOf(schema, base);
+		if (Array.isArray(value)) return mapItems(value, (item, i) => {
+			const itemSchema = itemSchemaAt(schema, i);
+			return itemSchema === void 0 ? item : this.dropOptionalNulls(item, itemSchema, b);
+		});
+		if (!isPlainObject$1(value)) return value;
+		const properties = isSchemaObject$1(schema.properties) ? schema.properties : {};
+		const patterns = isSchemaObject$1(schema.patternProperties) ? Object.entries(schema.patternProperties).map(([pattern, item]) => [sharedRegex(pattern), item]) : [];
+		const additional = isSchemaObject$1(schema.additionalProperties) ? schema.additionalProperties : void 0;
+		if (patterns.length === 0 && additional === void 0 && !isSchemaObject$1(schema.properties)) return value;
+		const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+		let out;
+		const set = (key, next) => {
+			if (next === (out ?? value)[key]) return;
+			out ??= { ...value };
+			out[key] = next;
+		};
+		for (const [key, property] of Object.entries(properties)) {
+			if (!Object.hasOwn(value, key)) continue;
+			const isRef = isSchemaObject$1(property) && typeof property.$ref === "string";
+			if (value[key] === null && !required.has(key) && !isRef && this.passes(property, b, null) === false) {
+				out ??= { ...value };
+				delete out[key];
+				continue;
+			}
+			set(key, this.dropOptionalNulls(value[key], property, b));
+		}
+		if (patterns.length > 0 || additional !== void 0) for (const key of Object.keys(value)) {
+			let matched = Object.hasOwn(properties, key);
+			for (const [pattern, item] of patterns) {
+				if (!pattern.test(key)) continue;
+				matched = true;
+				set(key, this.dropOptionalNulls((out ?? value)[key], item, b));
+			}
+			if (!matched && additional !== void 0) set(key, this.dropOptionalNulls(value[key], additional, b));
+		}
+		return out ?? value;
+	}
+	convert(node, base, value) {
+		if (!isSchemaObject$1(node)) return value;
+		const b = this.baseOf(node, base);
+		if (typeof node.$ref === "string") {
+			let target;
+			try {
+				target = this.c.r.resolve(node.$ref, b);
+			} catch {
+				return value;
+			}
+			return isSchemaObject$1(target.node) ? this.reenter(target.node, target.base, value, true) : value;
+		}
+		return this.convertNode(node, b, value);
+	}
+	/** One schema node's conversion: its first keyword among `const`, `enum`, the unions, `allOf` and `type`. */
+	convertNode(node, b, value) {
+		if (Object.hasOwn(node, "const")) return convertLiteral(node.const, value);
+		if (Array.isArray(node.enum)) return this.convertEnum(node, node.enum, b, value);
+		if (Array.isArray(node.anyOf)) return this.convertUnion(node, node.anyOf, b, value);
+		if (Array.isArray(node.oneOf)) return this.convertUnion(node, node.oneOf, b, value);
+		if (Array.isArray(node.allOf)) {
+			let next = value;
+			for (const member of node.allOf) next = this.convert(member, b, next);
+			return this.convertMembers(node, b, next);
+		}
+		switch (node.type) {
+			case "string": return orValue(tryString(value), value);
+			case "number": return orValue(tryNumber(value), value);
+			case "integer": {
+				const result = tryNumber(value);
+				return result === void 0 ? value : Math.trunc(result.value);
+			}
+			case "boolean": return orValue(tryBoolean(value), value);
+			case "null": return orValue(tryNull(value), value);
+			case "array": return this.convertArray(node, b, value);
+			case "object": return this.convertObject(node, b, value);
+			case void 0:
+				if (node.properties !== void 0 || node.patternProperties !== void 0) return this.convertObject(node, b, value);
+				if (node.items !== void 0 || node.prefixItems !== void 0) return this.convertArray(node, b, value);
+				return value;
+			default: return value;
+		}
+	}
+	/** An enum is a union of its values: a member stays, else the first value the input converts to. */
+	convertEnum(node, values, base, value) {
+		if (values.some((member) => member === value)) return value;
+		for (const member of values) {
+			const candidate = convertLiteral(member, value);
+			if (candidate !== value && this.passes(node, base, candidate) === true) return candidate;
+		}
+		return value;
+	}
+	/**
+	* A value one branch accepts stays; else the first branch's conversion that the whole union accepts. Branches are
+	* converted in order and only until one is accepted, so a later recursive branch is not entered needlessly. A node
+	* that also declares members (plain JSON Schema; TypeBox's never do) converts them into each candidate before it is
+	* checked, so a branch is not discarded for a sibling property that is converted after it.
+	*/
+	convertUnion(node, branches, base, value) {
+		if (branches.some((branch) => this.passes(branch, base, value) === true)) return this.convertMembers(node, base, value);
+		for (const branch of branches) {
+			const candidate = this.convertMembers(node, base, this.convert(branch, base, value));
+			if (this.passes(node, base, candidate) === true) return candidate;
+		}
+		return this.convertMembers(node, base, value);
+	}
+	/** The object members of a union or intersection node, when it declares any. */
+	convertMembers(node, base, value) {
+		return node.properties !== void 0 || node.patternProperties !== void 0 || node.additionalProperties !== void 0 ? this.convertObject(node, base, value) : value;
+	}
+	convertArray(node, base, value) {
+		const prefix = Array.isArray(node.items) ? node.items : Array.isArray(node.prefixItems) ? node.prefixItems : void 0;
+		if (prefix !== void 0) {
+			if (!Array.isArray(value)) return value;
+			const rest = Array.isArray(node.items) ? void 0 : node.items;
+			return mapItems(value, (item, i) => {
+				const schema = i < prefix.length ? prefix[i] : rest;
+				return schema === void 0 ? item : this.convert(schema, base, item);
+			});
+		}
+		if (Array.isArray(value)) return node.items === void 0 ? value : mapItems(value, (item) => this.convert(node.items, base, item));
+		const item = node.items;
+		return [isSchemaObject$1(item) ? this.reenter(item, base, value, false) : value];
+	}
+	convertObject(node, base, value) {
+		if (!isPlainObject$1(value)) return value;
+		const properties = isSchemaObject$1(node.properties) ? node.properties : {};
+		const patterns = isSchemaObject$1(node.patternProperties) ? Object.entries(node.patternProperties).map(([pattern, schema]) => [sharedRegex(pattern), schema]) : [];
+		const additional = isSchemaObject$1(node.additionalProperties) ? node.additionalProperties : void 0;
+		let out;
+		for (const key of Object.keys(value)) {
+			if (value[key] === void 0) continue;
+			let next = value[key];
+			let matched = Object.hasOwn(properties, key);
+			if (matched) next = this.convert(properties[key], base, next);
+			for (const [pattern, schema] of patterns) {
+				if (!pattern.test(key)) continue;
+				matched = true;
+				next = this.convert(schema, base, next);
+			}
+			if (!matched && additional !== void 0) next = this.convert(additional, base, next);
+			if (next !== value[key]) {
+				out ??= { ...value };
+				out[key] = next;
+			}
+		}
+		return out ?? value;
+	}
+	coerceTypes(value, schema, base) {
+		if (!isSchemaObject$1(schema)) return value;
+		const b = this.baseOf(schema, base);
+		let next = value;
+		if (Array.isArray(schema.allOf)) for (const member of schema.allOf) next = this.coerceTypes(next, member, b);
+		if (Array.isArray(schema.anyOf)) next = this.coerceUnion(next, schema.anyOf, b);
+		if (Array.isArray(schema.oneOf)) next = this.coerceUnion(next, schema.oneOf, b);
+		const types = typesOf$1(schema);
+		const matchesUnionMember = types.length > 1 && types.some((type) => matchesType(next, type));
+		if (types.length > 0 && !matchesUnionMember) for (const type of types) {
+			const candidate = coercePrimitive(next, type);
+			if (candidate !== next) {
+				next = candidate;
+				break;
+			}
+		}
+		if (types.includes("object") && isPlainObject$1(next)) next = this.coerceProperties(next, schema, b);
+		if (types.includes("array") && Array.isArray(next)) next = this.coerceItems(next, schema, b);
+		return next;
+	}
+	coerceUnion(value, branches, base) {
+		for (const branch of branches) if (this.passes(branch, base, value) === true) return value;
+		for (const branch of branches) {
+			const coerced = this.coerceTypes(value, branch, base);
+			if (this.passes(branch, base, coerced) === true) return coerced;
+		}
+		return value;
+	}
+	coerceProperties(value, schema, base) {
+		const properties = isSchemaObject$1(schema.properties) ? schema.properties : {};
+		const patterns = isSchemaObject$1(schema.patternProperties) ? Object.entries(schema.patternProperties).map(([pattern, item]) => [sharedRegex(pattern), item]) : [];
+		const additional = isSchemaObject$1(schema.additionalProperties) ? schema.additionalProperties : void 0;
+		let out;
+		const set = (key, next) => {
+			if (next === (out ?? value)[key]) return;
+			out ??= { ...value };
+			out[key] = next;
+		};
+		for (const [key, property] of Object.entries(properties)) if (key in value) set(key, this.coerceTypes(value[key], property, base));
+		for (const key of Object.keys(value)) {
+			let matched = Object.hasOwn(properties, key);
+			for (const [pattern, item] of patterns) {
+				if (!pattern.test(key)) continue;
+				matched = true;
+				set(key, this.coerceTypes((out ?? value)[key], item, base));
+			}
+			if (!matched && additional !== void 0) set(key, this.coerceTypes(value[key], additional, base));
+		}
+		return out ?? value;
+	}
+	coerceItems(value, schema, base) {
+		return mapItems(value, (item, i) => {
+			const itemSchema = itemSchemaAt(schema, i);
+			return isSchemaObject$1(itemSchema) ? this.coerceTypes(item, itemSchema, base) : item;
+		});
+	}
+};
+/**
+* The schema of an array's item at `index`: a tuple's (`prefixItems`, or a draft-7 `items` array) for its prefix,
+* `items` after `prefixItems`, or `items` for every item. Undefined when nothing applies.
+*/
+function itemSchemaAt(schema, index) {
+	if (Array.isArray(schema.items)) return schema.items[index];
+	if (Array.isArray(schema.prefixItems) && index < schema.prefixItems.length) return schema.prefixItems[index];
+	return schema.items;
+}
+/** `items` mapped by `map`; the same array when every item maps to itself. */
+function mapItems(items, map) {
+	let out;
+	for (let i = 0; i < items.length; i++) {
+		const next = map(items[i], i);
+		if (next === items[i]) continue;
+		out ??= items.slice();
+		out[i] = next;
+	}
+	return out ?? items;
+}
+function orValue(result, value) {
+	return result === void 0 ? value : result.value;
+}
+/** A literal (`const`, an enum value) taken from a value of another type that converts to exactly it. */
+function convertLiteral(literal, value) {
+	if (literal === value) return value;
+	const result = typeof literal === "string" ? tryString(value) : typeof literal === "number" ? tryNumber(value) : typeof literal === "boolean" ? tryBoolean(value) : void 0;
+	return result !== void 0 && result.value === literal ? result.value : value;
+}
+function tryString(value) {
+	if (typeof value === "bigint" || typeof value === "boolean" || isFiniteNumber(value)) return { value: String(value) };
+	if (value === null) return { value: "null" };
+	if (typeof value === "string") return { value };
+	if (value === void 0) return { value: "" };
+}
+const MAX_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+const MIN_BIGINT = BigInt(Number.MIN_SAFE_INTEGER);
+function tryNumber(value) {
+	if (typeof value === "bigint") return value <= MAX_BIGINT && value >= MIN_BIGINT ? { value: Number(value) } : void 0;
+	if (typeof value === "boolean") return { value: value ? 1 : 0 };
+	if (isFiniteNumber(value)) return { value };
+	if (value === null || value === void 0) return { value: 0 };
+	if (typeof value !== "string") return void 0;
+	const coerced = +value;
+	if (Number.isFinite(coerced)) return { value: coerced };
+	const lowercase = value.toLowerCase();
+	if (lowercase === "false") return { value: 0 };
+	if (lowercase === "true") return { value: 1 };
+	const big = bigIntOfString(value);
+	return big !== void 0 && big <= MAX_BIGINT && big >= MIN_BIGINT ? { value: Number(big) } : void 0;
+}
+/** TypeBox's TryBigInt of a string: `12n`, `12.5` (truncated) or `12`; true and false are not reached from tryNumber. */
+function bigIntOfString(value) {
+	if (/^-?(0|[1-9]\d*)n$/.test(value)) return BigInt(value.slice(0, -1));
+	if (/^-?(0|[1-9]\d*)\.\d+$/.test(value)) return BigInt(value.split(".")[0]);
+	if (/^-?(0|[1-9]\d*)$/.test(value)) return BigInt(value);
+}
+function tryBoolean(value) {
+	if (typeof value === "bigint") return value === 0n ? { value: false } : value === 1n ? { value: true } : void 0;
+	if (typeof value === "boolean") return { value };
+	if (isFiniteNumber(value)) return value === 0 ? { value: false } : value === 1 ? { value: true } : void 0;
+	if (value === null || value === void 0) return { value: false };
+	if (typeof value !== "string") return void 0;
+	const lowercase = value.toLowerCase();
+	if (lowercase === "false" || value === "0") return { value: false };
+	if (lowercase === "true" || value === "1") return { value: true };
+}
+function tryNull(value) {
+	if (typeof value === "bigint") return value === 0n ? { value: null } : void 0;
+	if (typeof value === "boolean") return value === false ? { value: null } : void 0;
+	if (isFiniteNumber(value)) return value === 0 ? { value: null } : void 0;
+	if (value === null || value === void 0) return { value: null };
+	if (typeof value !== "string") return void 0;
+	const lowercase = value.toLowerCase();
+	return lowercase === "undefined" || lowercase === "null" || value === "" || value === "0" ? { value: null } : void 0;
+}
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function typesOf$1(schema) {
+	if (typeof schema.type === "string") return [schema.type];
+	if (Array.isArray(schema.type)) return schema.type.filter((type) => typeof type === "string");
+	return [];
+}
+function matchesType(value, type) {
+	switch (type) {
+		case "number": return typeof value === "number";
+		case "integer": return typeof value === "number" && Number.isInteger(value);
+		case "boolean": return typeof value === "boolean";
+		case "string": return typeof value === "string";
+		case "null": return value === null;
+		case "array": return Array.isArray(value);
+		case "object": return isPlainObject$1(value);
+		default: return false;
+	}
+}
+function coercePrimitive(value, type) {
+	switch (type) {
+		case "number":
+		case "integer":
+			if (value === null) return 0;
+			if (typeof value === "string" && value.trim() !== "") {
+				const parsed = Number(value);
+				if (type === "number" ? Number.isFinite(parsed) : Number.isInteger(parsed)) return parsed;
+			}
+			if (typeof value === "boolean") return value ? 1 : 0;
+			return value;
+		case "boolean":
+			if (value === null) return false;
+			if (value === "true" || value === 1) return true;
+			if (value === "false" || value === 0) return false;
+			return value;
+		case "string":
+			if (value === null) return "";
+			if (typeof value === "number" || typeof value === "boolean") return String(value);
+			return value;
+		case "null": return value === "" || value === 0 || value === false ? null : value;
+		default: return value;
+	}
+}
+function isPlainObject$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@earendil-works+pi-schema@1.5.0/node_modules/@earendil-works/pi-schema/dist/checks.js
+const ALWAYS = () => true;
+const NEVER = () => false;
+const IS_STRING = (v) => typeof v === "string";
+const IS_NUMBER = (v) => typeof v === "number";
+const IS_INTEGER = (v) => Number.isInteger(v);
+const IS_BOOLEAN = (v) => typeof v === "boolean";
+const IS_NULL = (v) => v === null;
+const IS_ARRAY = (v) => Array.isArray(v);
+const IS_BYTES = (v) => v instanceof Uint8Array;
+const IS_OBJECT = (v) => isObject(v);
+/** Whether `v` is a JSON object: not null, an array or bytes. */
+function isObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof Uint8Array);
+}
+/** The check of a `type` name; `bytes` (a Uint8Array) extends JSON Schema for values that never pass through JSON. */
+const TYPE_CHECKS = /* @__PURE__ */ new Map([
+	["string", IS_STRING],
+	["number", IS_NUMBER],
+	["integer", IS_INTEGER],
+	["boolean", IS_BOOLEAN],
+	["null", IS_NULL],
+	["array", IS_ARRAY],
+	["object", IS_OBJECT],
+	["bytes", IS_BYTES]
+]);
+/** Leaf checks that object and array loops run inline by code instead of calling them. */
+const LEAF_CODES = /* @__PURE__ */ new Map([
+	[IS_STRING, 1],
+	[IS_NUMBER, 2],
+	[IS_INTEGER, 3],
+	[IS_BOOLEAN, 4],
+	[IS_NULL, 5],
+	[ALWAYS, 6]
+]);
+function leafOk(code, x) {
+	switch (code) {
+		case 1: return typeof x === "string";
+		case 2: return typeof x === "number";
+		case 3: return Number.isInteger(x);
+		case 4: return typeof x === "boolean";
+		case 5: return x === null;
+		default: return true;
+	}
+}
+/** All of `parts`; two and three parts get closures without a loop. */
+function and(parts) {
+	switch (parts.length) {
+		case 0: return ALWAYS;
+		case 1: return parts[0];
+		case 2: {
+			const [a, b] = parts;
+			return (v) => a(v) && b(v);
+		}
+		case 3: {
+			const [a, b, c] = parts;
+			return (v) => a(v) && b(v) && c(v);
+		}
+		default: return (v) => {
+			for (let i = 0; i < parts.length; i++) if (!parts[i](v)) return false;
+			return true;
+		};
+	}
+}
+/** A check whose implementation is set later: the indirection a recursive reference goes through. */
+function indirect(slot) {
+	return (v) => slot.check(v);
+}
+/** `check` with `uri` pushed onto the dynamic scope while it runs (only for schemas with `$dynamicRef`). */
+function scopedCheck(scope, uri, check) {
+	return (v) => {
+		scope.push(uri);
+		const ok = check(v);
+		scope.pop();
+		return ok;
+	};
+}
+/** Any of the named types. */
+function typeCheck(types) {
+	const checks = types.map((t) => (typeof t === "string" ? TYPE_CHECKS.get(t) : void 0) ?? NEVER);
+	if (checks.length === 1) return checks[0];
+	return (v) => {
+		for (let i = 0; i < checks.length; i++) if (checks[i](v)) return true;
+		return false;
+	};
+}
+/** A Uint8Array within the length bounds. */
+function bytesCheck(min, max) {
+	return (v) => v instanceof Uint8Array && v.length >= min && v.length <= max;
+}
+/** The number of Unicode code points of `s`: JSON Schema string lengths count code points, not UTF-16 units. */
+function codePoints(s) {
+	let n = 0;
+	for (let i = 0; i < s.length; i++, n++) {
+		const c = s.charCodeAt(i);
+		if (c >= 55296 && c <= 56319 && i + 1 < s.length) {
+			const next = s.charCodeAt(i + 1);
+			if (next >= 56320 && next <= 57343) i++;
+		}
+	}
+	return n;
+}
+function lengthOk(s, min, max) {
+	const units = s.length;
+	if (units < min) return false;
+	if (units < 2 * min && codePoints(s) < min) return false;
+	return units <= max || codePoints(s) <= max;
+}
+/** The string keywords: length bounds, pattern and format. */
+function stringCheck(strict, min, max, re, format) {
+	if (re !== void 0 && min === 0 && max === Number.POSITIVE_INFINITY && format === void 0) return strict ? (v) => typeof v === "string" && re.test(v) : (v) => typeof v !== "string" || re.test(v);
+	if (re === void 0 && format === void 0) return strict ? (v) => typeof v === "string" && lengthOk(v, min, max) : (v) => typeof v !== "string" || lengthOk(v, min, max);
+	return (v) => {
+		if (typeof v !== "string") return !strict;
+		return lengthOk(v, min, max) && (re === void 0 || re.test(v)) && (format === void 0 || format(v));
+	};
+}
+/** The number keywords. `mode`: 0 passes other types, 1 requires a number, 2 an integer. */
+function numberCheck(mode, min, max, xmin, xmax, multipleOf) {
+	return (v) => {
+		if (typeof v !== "number") return mode === 0;
+		if (mode === 2 && !Number.isInteger(v)) return false;
+		return v >= min && v <= max && v > xmin && v < xmax && (multipleOf === void 0 || isMultiple(v, multipleOf));
+	};
+}
+/** Whether `v` is a multiple of `d`, exactly for decimals: 0.0075 / 0.0001 is 74.99999999999999 in floating point. */
+function isMultiple(v, d) {
+	const q = v / d;
+	if (Number.isInteger(q)) return true;
+	if (!Number.isFinite(q)) return v % d === 0;
+	const [vc, ve] = decimal(v);
+	const [dc, de] = decimal(d);
+	return ve >= de ? vc * 10n ** BigInt(ve - de) % dc === 0n : vc % (dc * 10n ** BigInt(de - ve)) === 0n;
+}
+function decimal(x) {
+	const [mantissa, exponent = "0"] = Math.abs(x).toString().split("e");
+	const point = mantissa.indexOf(".");
+	const fraction = point < 0 ? 0 : mantissa.length - point - 1;
+	return [BigInt(mantissa.replace(".", "")), Number(exponent) - fraction];
+}
+/** `inner` for objects; other values pass unless `strict`. */
+function guardObject(inner, strict) {
+	return strict ? (v) => isObject(v) && inner(v) : (v) => !isObject(v) || inner(v);
+}
+/** `inner` for arrays; other values pass unless `strict`. */
+function guardArray(inner, strict) {
+	return strict ? (v) => Array.isArray(v) && inner(v) : (v) => !Array.isArray(v) || inner(v);
+}
+/**
+* An object with declared properties: `entries` is `[key, check, flags]` per property. The value's own keys are
+* walked with for...in (whose `o[k]` V8 reads from the enum cache, unlike a load by a name from a list), each found
+* among the declared names; `closed` rejects any other key. A property whose value is `undefined` counts as absent.
+*/
+function declaredObject(entries, requiredCount, closed, guard) {
+	const n = entries.length;
+	return (v) => {
+		if (guard !== 0 && !isObject(v)) return guard === 2;
+		const o = v;
+		let required = 0;
+		for (const k in o) {
+			let i = 0;
+			while (i < n && entries[i] !== k) i += 3;
+			if (i === n) {
+				if (closed) return false;
+				continue;
+			}
+			const x = o[k];
+			if (x === void 0) continue;
+			const f = entries[i + 2];
+			const c = f & 7;
+			if (c !== 0 ? !leafOk(c, x) : !entries[i + 1](x)) return false;
+			if (f & 8) required++;
+		}
+		return required === requiredCount;
+	};
+}
+/** An object with declared properties, required keys not declared, pattern properties and additional properties. */
+function openObject(entries, keys, extraRequired, patterns, additional, guard) {
+	const known = patterns.length > 0 || additional !== void 0 ? new Set(keys) : void 0;
+	return (v) => {
+		if (guard !== 0 && !isObject(v)) return guard === 2;
+		const o = v;
+		for (let i = 0; i < entries.length; i += 3) {
+			const k = entries[i];
+			const x = o[k];
+			const f = entries[i + 2];
+			if (x === void 0 || f & 16 && !Object.hasOwn(o, k)) {
+				if (f & 8) return false;
+				continue;
+			}
+			const c = f & 7;
+			if (c !== 0 ? !leafOk(c, x) : !entries[i + 1](x)) return false;
+		}
+		for (let i = 0; i < extraRequired.length; i++) if (!Object.hasOwn(o, extraRequired[i])) return false;
+		if (known === void 0) return true;
+		for (const k of Object.keys(o)) {
+			let matched = known.has(k);
+			for (let i = 0; i < patterns.length; i++) if (patterns[i][0].test(k)) {
+				matched = true;
+				if (!patterns[i][1](o[k])) return false;
+			}
+			if (!matched && additional !== void 0 && !additional(o[k])) return false;
+		}
+		return true;
+	};
+}
+/** Every property name passes `check` (`v` is an object). */
+function propertyNamesCheck(check) {
+	return (v) => {
+		for (const k in v) if (!check(k)) return false;
+		return true;
+	};
+}
+/** `minProperties` and `maxProperties` (`v` is an object). */
+function propertyCountCheck(min, max) {
+	return (v) => {
+		let n = 0;
+		for (const _ in v) n++;
+		return n >= min && n <= max;
+	};
+}
+/** `dependentRequired` (`v` is an object). */
+function dependentRequiredCheck(entries) {
+	return (v) => {
+		const o = v;
+		for (const [k, list] of entries) if (Object.hasOwn(o, k)) {
+			for (const r of list) if (!Object.hasOwn(o, r)) return false;
+		}
+		return true;
+	};
+}
+/** `dependentSchemas` (`v` is an object). */
+function dependentSchemasCheck(entries) {
+	return (v) => {
+		for (const [k, check] of entries) if (Object.hasOwn(v, k) && !check(v)) return false;
+		return true;
+	};
+}
+/** The common array: guard, length bounds, prefix items and the items after them, in one closure. */
+function listCheck(guard, min, max, prefix, rest) {
+	const n = prefix.length;
+	const code = rest === void 0 ? 0 : LEAF_CODES.get(rest) ?? 0;
+	return (v) => {
+		if (!Array.isArray(v)) return guard === 2;
+		const length = v.length;
+		if (length < min || length > max) return false;
+		const m = length < n ? length : n;
+		for (let i = 0; i < m; i++) if (!prefix[i](v[i])) return false;
+		if (rest === void 0) return true;
+		if (code !== 0) {
+			for (let i = n; i < length; i++) if (!leafOk(code, v[i])) return false;
+			return true;
+		}
+		for (let i = n; i < length; i++) if (!rest(v[i])) return false;
+		return true;
+	};
+}
+/** Prefix items and the items after them (`v` is an array). */
+function itemsCheck(prefix, rest) {
+	return listCheck(0, 0, Number.POSITIVE_INFINITY, prefix, rest);
+}
+/** `minItems` and `maxItems` (`v` is an array). */
+function lengthCheck(min, max) {
+	return (v) => v.length >= min && v.length <= max;
+}
+/** `contains` with its bounds (`v` is an array). */
+function containsCheck(check, min, max) {
+	return (v) => {
+		const list = v;
+		let n = 0;
+		for (let i = 0; i < list.length; i++) if (check(list[i]) && ++n > max) return false;
+		return n >= min;
+	};
+}
+/** `uniqueItems` (`v` is an array). */
+function uniqueCheck(v) {
+	const list = v;
+	for (let i = 1; i < list.length; i++) for (let j = 0; j < i; j++) if (deepEqual$1(list[i], list[j])) return false;
+	return true;
+}
+/** `enum`: up to 8 primitives by a scan, more by a Set, objects and arrays by deep equality. */
+function enumCheck(values) {
+	const primitives = values.filter((x) => typeof x !== "object" || x === null);
+	if (primitives.length === values.length && primitives.length <= 8) return (v) => {
+		for (let i = 0; i < primitives.length; i++) if (primitives[i] === v) return true;
+		return false;
+	};
+	const set = new Set(primitives);
+	const objects = values.filter((x) => typeof x === "object" && x !== null);
+	return (v) => set.has(v) || typeof v === "object" && objects.some((o) => deepEqual$1(v, o));
+}
+/** `const`. */
+function constCheck(value) {
+	if (typeof value !== "object" || value === null) return (v) => v === value;
+	return (v) => deepEqual$1(v, value);
+}
+/** `anyOf`. */
+function anyCheck(checks) {
+	return (v) => {
+		for (let i = 0; i < checks.length; i++) if (checks[i](v)) return true;
+		return false;
+	};
+}
+/** `oneOf`. */
+function oneCheck(checks) {
+	return (v) => {
+		let n = 0;
+		for (let i = 0; i < checks.length; i++) if (checks[i](v) && ++n > 1) return false;
+		return n === 1;
+	};
+}
+/** `not`. */
+function notCheck(check) {
+	return (v) => !check(v);
+}
+/** `if`, `then` and `else`. */
+function ifCheck(cond, then, otherwise) {
+	return (v) => cond(v) ? then(v) : otherwise(v);
+}
+/** A union of objects tagged by a const on `key`: the tag selects the one branch that can match. */
+function taggedCheck(key, tags, checks) {
+	return (v) => {
+		if (!isObject(v)) return false;
+		const tag = v[key];
+		for (let i = 0; i < tags.length; i++) if (tags[i] === tag) return checks[i](v);
+		return false;
+	};
+}
+/** JSON equality: same primitives, arrays with equal items in order, objects with the same keys and equal values. */
+function deepEqual$1(a, b) {
+	if (a === b) return true;
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	const array = Array.isArray(a);
+	if (array !== Array.isArray(b)) return false;
+	if (array) {
+		const x = a;
+		const y = b;
+		if (x.length !== y.length) return false;
+		for (let i = 0; i < x.length; i++) if (!deepEqual$1(x[i], y[i])) return false;
+		return true;
+	}
+	const x = a;
+	const y = b;
+	const keys = Object.keys(x);
+	if (keys.length !== Object.keys(y).length) return false;
+	for (const k of keys) if (!Object.hasOwn(y, k) || !deepEqual$1(x[k], y[k])) return false;
+	return true;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@earendil-works+pi-schema@1.5.0/node_modules/@earendil-works/pi-schema/dist/annotations.js
+/** Empty annotations. */
+function newAnnotations() {
+	return {
+		props: null,
+		allProps: false,
+		items: 0,
+		allItems: false,
+		indexes: null
+	};
+}
+function merge(a, b) {
+	if (b.props !== null) for (const k of b.props) addProp(a, k);
+	a.allProps ||= b.allProps;
+	if (b.items > a.items) a.items = b.items;
+	a.allItems ||= b.allItems;
+	if (b.indexes !== null) for (const i of b.indexes) addIndex(a, i);
+}
+function addProp(a, key) {
+	if (a.props === null) a.props = /* @__PURE__ */ new Set();
+	a.props.add(key);
+}
+function addIndex(a, index) {
+	if (a.indexes === null) a.indexes = /* @__PURE__ */ new Set();
+	a.indexes.add(index);
+}
+const ANNOTATING_TRUE = () => true;
+const ANNOTATING_FALSE = () => false;
+/** The indirection a recursive reference goes through. */
+function indirectAnnotating(slot) {
+	return (v, a) => slot.check(v, a);
+}
+/** A plain check in annotating position: it evaluates nothing that unevaluated* sees. */
+function ignoreAnnotations(check) {
+	return (v) => check(v);
+}
+/** An annotating check run as a plain check, with fresh annotations. */
+function withFreshAnnotations(check) {
+	return (v) => check(v, newAnnotations());
+}
+/** `check` with `uri` pushed onto the dynamic scope while it runs. */
+function scopedAnnotating(scope, uri, check) {
+	return (v, a) => {
+		scope.push(uri);
+		const ok = check(v, a);
+		scope.pop();
+		return ok;
+	};
+}
+/** unevaluated* sees only the annotations of its own schema, never those of its siblings in the parent. */
+function isolateAnnotations(check) {
+	return (v, a) => {
+		const b = newAnnotations();
+		if (!check(v, b)) return false;
+		merge(a, b);
+		return true;
+	};
+}
+/** The non-annotating keywords, then each annotating part in order. */
+function annotateAll(plain, parts) {
+	return (v, a) => {
+		if (!plain(v)) return false;
+		for (let i = 0; i < parts.length; i++) if (!parts[i](v, a)) return false;
+		return true;
+	};
+}
+/** `properties`, `patternProperties` and `additionalProperties`. */
+function annotateObject(props, patterns, additional) {
+	const declared = new Set(props.map(([k]) => k));
+	return (v, a) => {
+		if (!isObject(v)) return true;
+		const seen = [];
+		for (const [k, check] of props) {
+			if (!Object.hasOwn(v, k)) continue;
+			if (!check(v[k])) return false;
+			seen.push(k);
+		}
+		for (const k of Object.keys(v)) {
+			let matched = declared.has(k);
+			for (const [re, check] of patterns) if (re.test(k)) {
+				if (!check(v[k])) return false;
+				matched = true;
+				seen.push(k);
+			}
+			if (!matched && additional !== void 0) {
+				if (!additional(v[k])) return false;
+				seen.push(k);
+			}
+		}
+		for (const k of seen) addProp(a, k);
+		return true;
+	};
+}
+/** `prefixItems`/`items`/`additionalItems` and `contains` with its bounds. */
+function annotateArray(prefix, rest, contains, minContains, maxContains) {
+	return (v, a) => {
+		if (!Array.isArray(v)) return true;
+		const m = Math.min(v.length, prefix.length);
+		for (let i = 0; i < m; i++) if (!prefix[i](v[i])) return false;
+		if (rest !== void 0) {
+			for (let i = prefix.length; i < v.length; i++) if (!rest(v[i])) return false;
+			a.allItems = true;
+		}
+		if (m > a.items) a.items = m;
+		if (contains !== void 0) {
+			let n = 0;
+			for (let i = 0; i < v.length; i++) if (contains(v[i])) {
+				n++;
+				addIndex(a, i);
+			}
+			if (n < minContains || n > maxContains) return false;
+		}
+		return true;
+	};
+}
+/** `anyOf` (or `oneOf` when `exactlyOne`): every passing branch contributes its annotations. */
+function annotateAny(branches, exactlyOne) {
+	return (v, a) => {
+		let n = 0;
+		for (const branch of branches) {
+			const b = newAnnotations();
+			if (branch(v, b)) {
+				n++;
+				merge(a, b);
+			}
+		}
+		return exactlyOne ? n === 1 : n > 0;
+	};
+}
+/** `if`, `then` and `else`: a passing `if` contributes its annotations even without `then`. */
+function annotateIf(cond, then, otherwise) {
+	return (v, a) => {
+		const b = newAnnotations();
+		if (cond(v, b)) {
+			merge(a, b);
+			return then === void 0 || then(v, a);
+		}
+		return otherwise === void 0 || otherwise(v, a);
+	};
+}
+/** One `dependentSchemas` entry. */
+function annotateDependent(key, check) {
+	return (v, a) => !isObject(v) || !Object.hasOwn(v, key) || check(v, a);
+}
+/** `unevaluatedProperties`: every property no other keyword evaluated passes `check`. */
+function unevaluatedProperties(check) {
+	return (v, a) => {
+		if (!isObject(v) || a.allProps) return true;
+		for (const k of Object.keys(v)) if (!(a.props?.has(k) ?? false) && !check(v[k])) return false;
+		a.allProps = true;
+		return true;
+	};
+}
+/** `unevaluatedItems`: every item no other keyword evaluated passes `check`. */
+function unevaluatedItems(check) {
+	return (v, a) => {
+		if (!Array.isArray(v) || a.allItems) return true;
+		for (let i = a.items; i < v.length; i++) if (!(a.indexes?.has(i) ?? false) && !check(v[i])) return false;
+		a.allItems = true;
+		return true;
+	};
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@earendil-works+pi-schema@1.5.0/node_modules/@earendil-works/pi-schema/dist/compiler.js
+/** Thrown when a compile without dynamic scope tracking meets a bookended `$dynamicRef`: compile again with it. */
+const RESTART = Symbol("restart");
+/** One compile of a schema. Its caches and indexes are garbage once the root check is built. */
+var Compiler = class {
+	r;
+	draft;
+	formats;
+	/** Whether checks track the dynamic scope (the schema has a bookended `$dynamicRef`). */
+	dynamic;
+	schema;
+	scope;
+	cache = /* @__PURE__ */ new Map();
+	annotatingCache = /* @__PURE__ */ new Map();
+	constructor(schema, options, dynamic) {
+		this.schema = schema;
+		this.r = new Resolver(schema, options);
+		this.draft = this.r.draft;
+		this.formats = options.formats;
+		this.dynamic = dynamic;
+		this.scope = [];
+	}
+	/** The check of the root schema. */
+	root() {
+		return this.check(this.schema, this.r.rootBase);
+	}
+	/** The check of a schema (cached by schema object; a recursive reference goes through an indirection). */
+	check(node, base) {
+		if (node === true) return ALWAYS;
+		if (node === false) return NEVER;
+		if (!isSchemaObject$1(node)) throw new Error(`A schema must be an object or a boolean, got ${JSON.stringify(node)}`);
+		const cached = this.cache.get(node);
+		if (cached !== void 0) return cached;
+		const bare = this.bareType(node);
+		if (bare !== void 0) return bare;
+		const slot = { check: void 0 };
+		this.cache.set(node, indirect(slot));
+		const check = this.build(node, this.r.baseFor(node, base));
+		slot.check = check;
+		this.cache.set(node, check);
+		return check;
+	}
+	build(node, base) {
+		if (this.draft === "7" && typeof node.$ref === "string") return this.ref(node.$ref, base);
+		if (this.draft !== "7" && (node.unevaluatedProperties !== void 0 || node.unevaluatedItems !== void 0)) return withFreshAnnotations(this.annotating(node, base));
+		const check = this.plain(node, base);
+		return this.dynamic && this.r.isResource(node, base) ? scopedCheck(this.scope, base, check) : check;
+	}
+	/**
+	* The module-level check of a schema that is only a `type` (with annotations), `ALWAYS` for one with no assertion
+	* at all; undefined for every other schema. These are the most common subschemas and cost nothing to share.
+	*/
+	bareType(node) {
+		let type;
+		for (const k in node) if (k === "type") type = node.type;
+		else if (!NEUTRAL_KEYWORDS.has(k)) return void 0;
+		if (type === void 0) return ALWAYS;
+		return typeof type === "string" ? TYPE_CHECKS.get(type) : void 0;
+	}
+	/** Every keyword of `node`, not tracking annotations. */
+	plain(node, base) {
+		const parts = [];
+		const types = node.type === void 0 ? void 0 : Array.isArray(node.type) ? node.type : [node.type];
+		const single = types?.length === 1 ? types[0] : void 0;
+		let typeInGroup = false;
+		if (single === "bytes") {
+			parts.push(bytesCheck(number(node.minLength) ?? 0, number(node.maxLength) ?? Number.POSITIVE_INFINITY));
+			typeInGroup = true;
+		} else {
+			const string = this.stringGroup(node, single === "string");
+			if (string !== void 0) parts.push(string);
+			const numeric = single === "number" || single === "integer";
+			const number = this.numberGroup(node, single === "number" ? 1 : single === "integer" ? 2 : 0);
+			if (number !== void 0) parts.push(number);
+			const object = this.objectGroup(node, base, single === "object");
+			if (object !== void 0) parts.push(object);
+			const array = this.arrayGroup(node, base, single === "array");
+			if (array !== void 0) parts.push(array);
+			typeInGroup = single === "string" && string !== void 0 || numeric && number !== void 0 || single === "object" && object !== void 0 || single === "array" && array !== void 0;
+		}
+		if (types !== void 0 && !typeInGroup) parts.unshift(typeCheck(types));
+		this.inPlace(node, base, parts);
+		return and(parts);
+	}
+	inPlace(node, base, parts) {
+		if (Array.isArray(node.enum)) parts.push(enumCheck(node.enum));
+		if (Object.hasOwn(node, "const")) parts.push(constCheck(node.const));
+		if (Array.isArray(node.allOf)) parts.push(and(node.allOf.map((s) => this.check(s, base))));
+		if (Array.isArray(node.anyOf)) parts.push(this.union(node.anyOf, base, false));
+		if (Array.isArray(node.oneOf)) parts.push(this.union(node.oneOf, base, true));
+		if (node.not !== void 0) parts.push(notCheck(this.check(node.not, base)));
+		if (node.if !== void 0 && (node.then !== void 0 || node.else !== void 0)) {
+			const then = node.then === void 0 ? ALWAYS : this.check(node.then, base);
+			const otherwise = node.else === void 0 ? ALWAYS : this.check(node.else, base);
+			parts.push(ifCheck(this.check(node.if, base), then, otherwise));
+		}
+		if (typeof node.$ref === "string") parts.push(this.ref(node.$ref, base));
+		if (this.draft !== "7" && typeof node.$dynamicRef === "string") parts.push(this.dynamicRef(node.$dynamicRef, base));
+	}
+	union(branches, base, exactlyOne) {
+		const checks = () => branches.map((s) => this.check(s, base));
+		return constUnion(branches, exactlyOne) ?? this.tagged(branches, base) ?? (exactlyOne ? oneCheck(checks()) : anyCheck(checks()));
+	}
+	ref(ref, base) {
+		const target = this.r.resolve(ref, base);
+		const check = this.check(target.node, target.base);
+		return this.dynamic && target.base !== base ? scopedCheck(this.scope, target.base, check) : check;
+	}
+	dynamicRef(ref, base) {
+		const resolved = this.bookended(ref, base);
+		if (resolved === void 0) return this.ref(ref, base);
+		const { initial, name } = resolved;
+		const fallback = this.check(initial.node, initial.base);
+		const lookup = this.dynamicLookup(name, (node, b) => this.check(node, b));
+		const scope = this.scope;
+		return (v) => {
+			for (let i = 0; i < scope.length; i++) {
+				const check = lookup(scope[i]);
+				if (check !== null) return check(v);
+			}
+			return fallback(v);
+		};
+	}
+	/** The initial target and anchor name of a `$dynamicRef` that resolves dynamically, or undefined for a plain ref. */
+	bookended(ref, base) {
+		const initial = this.r.resolve(ref, base);
+		const uri = resolveUri(ref, base);
+		const name = uri.slice(documentOf(uri).length + 1);
+		const anchored = isSchemaObject$1(initial.node) && initial.node.$dynamicAnchor === name;
+		if (name === "" || name.startsWith("/") || !anchored) return void 0;
+		if (!this.dynamic) throw RESTART;
+		return {
+			initial,
+			name
+		};
+	}
+	dynamicLookup(name, compile) {
+		const found = /* @__PURE__ */ new Map();
+		return (uri) => {
+			const key = `${uri}#${name}`;
+			let check = found.get(key);
+			if (check === void 0) {
+				const target = this.r.dynamicAnchors.get(key);
+				check = target === void 0 ? null : compile(target, this.r.baseOf.get(target) ?? uri);
+				found.set(key, check);
+			}
+			return check;
+		};
+	}
+	/** anyOf/oneOf whose branches are all objects with a distinct required const on one key: the tag picks the branch. */
+	tagged(branches, base) {
+		if (branches.length < 2) return void 0;
+		const resolved = [];
+		for (const branch of branches) {
+			if (!isSchemaObject$1(branch)) return void 0;
+			const ref = typeof branch.$ref === "string" && Object.keys(branch).length === 1 ? branch.$ref : void 0;
+			const node = ref === void 0 ? branch : this.r.resolve(ref, this.r.baseFor(branch, base)).node;
+			if (!isSchemaObject$1(node)) return void 0;
+			resolved.push(node);
+		}
+		const first = resolved[0].properties;
+		if (!isSchemaObject$1(first)) return void 0;
+		for (const key of Object.keys(first)) {
+			const tags = resolved.map((s) => tagOf(s, key));
+			if (tags.some((t) => t === void 0) || new Set(tags).size !== tags.length) continue;
+			return taggedCheck(key, tags, branches.map((s) => this.check(s, base)));
+		}
+	}
+	stringGroup(node, strict) {
+		const min = number(node.minLength) ?? 0;
+		const max = number(node.maxLength) ?? Number.POSITIVE_INFINITY;
+		const re = typeof node.pattern === "string" ? sharedRegex(node.pattern) : void 0;
+		const format = this.formats !== void 0 && typeof node.format === "string" && Object.hasOwn(this.formats, node.format) ? this.formats[node.format] : void 0;
+		if (min === 0 && max === Number.POSITIVE_INFINITY && re === void 0 && format === void 0) return void 0;
+		return stringCheck(strict, min, max, re, format);
+	}
+	numberGroup(node, mode) {
+		const min = number(node.minimum);
+		const max = number(node.maximum);
+		const xmin = number(node.exclusiveMinimum);
+		const xmax = number(node.exclusiveMaximum);
+		const multipleOf = number(node.multipleOf);
+		if ([
+			min,
+			max,
+			xmin,
+			xmax,
+			multipleOf
+		].every((x) => x === void 0)) return void 0;
+		const inf = Number.POSITIVE_INFINITY;
+		return numberCheck(mode, min ?? -inf, max ?? inf, xmin ?? -inf, xmax ?? inf, multipleOf);
+	}
+	objectGroup(node, base, strict) {
+		const onlyCore = OBJECT_EXTRAS.every((k) => node[k] === void 0);
+		const core = this.objectCore(node, base, onlyCore ? strict ? 1 : 2 : 0);
+		if (core !== void 0 && onlyCore) return core;
+		const parts = core === void 0 ? [] : [core];
+		if (node.propertyNames !== void 0) parts.push(propertyNamesCheck(this.check(node.propertyNames, base)));
+		const minProperties = number(node.minProperties);
+		const maxProperties = number(node.maxProperties);
+		if (minProperties !== void 0 || maxProperties !== void 0) parts.push(propertyCountCheck(minProperties ?? 0, maxProperties ?? Number.POSITIVE_INFINITY));
+		const dependentRequired = [];
+		const dependentSchemas = [];
+		if (this.draft !== "7") {
+			for (const [k, list] of entries(node.dependentRequired)) if (Array.isArray(list)) dependentRequired.push([k, list]);
+			for (const [k, s] of entries(node.dependentSchemas)) dependentSchemas.push([k, this.check(s, base)]);
+		}
+		for (const [k, d] of entries(node.dependencies)) if (Array.isArray(d)) dependentRequired.push([k, d]);
+		else dependentSchemas.push([k, this.check(d, base)]);
+		if (dependentRequired.length > 0) parts.push(dependentRequiredCheck(dependentRequired));
+		if (dependentSchemas.length > 0) parts.push(dependentSchemasCheck(dependentSchemas));
+		if (parts.length === 0) return strict ? IS_OBJECT : void 0;
+		return guardObject(and(parts), strict);
+	}
+	objectCore(node, base, guard) {
+		const properties = isSchemaObject$1(node.properties) ? node.properties : {};
+		const required = Array.isArray(node.required) ? node.required.filter((k) => typeof k === "string") : [];
+		const patterns = isSchemaObject$1(node.patternProperties) ? node.patternProperties : {};
+		const additional = node.additionalProperties;
+		const keys = Object.keys(properties);
+		const patternKeys = Object.keys(patterns);
+		if (keys.length + required.length + patternKeys.length === 0 && (additional === void 0 || additional === true)) return;
+		const entries = [];
+		for (const k of keys) {
+			const check = this.check(properties[k], base);
+			const flags = (LEAF_CODES.get(check) ?? 0) | (required.includes(k) ? 8 : 0) | (k in Object.prototype ? 16 : 0);
+			entries.push(k, check, flags);
+		}
+		const extraRequired = required.filter((k) => !Object.hasOwn(properties, k));
+		const pats = patternKeys.map((p) => [sharedRegex(p), this.check(patterns[p], base)]);
+		const extra = additional === void 0 || additional === true ? void 0 : this.check(additional, base);
+		if (pats.length === 0 && extraRequired.length === 0 && (extra === void 0 || additional === false)) {
+			const requiredCount = keys.filter((k) => required.includes(k)).length;
+			return declaredObject(entries, requiredCount, additional === false, guard);
+		}
+		return openObject(entries, keys, extraRequired, pats, extra, guard);
+	}
+	arrayGroup(node, base, strict) {
+		let prefix = [];
+		let rest;
+		if (Array.isArray(node.items)) {
+			prefix = node.items;
+			rest = node.additionalItems;
+		} else {
+			if (this.draft !== "7" && Array.isArray(node.prefixItems)) prefix = node.prefixItems;
+			rest = node.items;
+		}
+		const prefixChecks = prefix.map((s) => this.check(s, base));
+		const restCheck = rest === void 0 || rest === true ? void 0 : this.check(rest, base);
+		const minItems = number(node.minItems);
+		const maxItems = number(node.maxItems);
+		if (node.contains === void 0 && node.uniqueItems !== true && (prefixChecks.length > 0 || restCheck !== void 0)) return listCheck(strict ? 1 : 2, minItems ?? 0, maxItems ?? Number.POSITIVE_INFINITY, prefixChecks, restCheck);
+		const parts = [];
+		if (prefixChecks.length > 0 || restCheck !== void 0) parts.push(itemsCheck(prefixChecks, restCheck));
+		if (minItems !== void 0 || maxItems !== void 0) parts.push(lengthCheck(minItems ?? 0, maxItems ?? Number.POSITIVE_INFINITY));
+		if (node.contains !== void 0) {
+			const min = this.draft === "7" ? 1 : number(node.minContains) ?? 1;
+			const max = this.draft === "7" ? Number.POSITIVE_INFINITY : number(node.maxContains) ?? Number.POSITIVE_INFINITY;
+			parts.push(containsCheck(this.check(node.contains, base), min, max));
+		}
+		if (node.uniqueItems === true) parts.push(uniqueCheck);
+		if (parts.length === 0) return strict ? IS_ARRAY : void 0;
+		return guardArray(and(parts), strict);
+	}
+	/** The annotating check of a schema evaluated in place (only below `unevaluatedProperties`/`unevaluatedItems`). */
+	annotating(node, base) {
+		if (node === true) return ANNOTATING_TRUE;
+		if (node === false) return ANNOTATING_FALSE;
+		if (!isSchemaObject$1(node)) throw new Error(`A schema must be an object or a boolean, got ${JSON.stringify(node)}`);
+		const cached = this.annotatingCache.get(node);
+		if (cached !== void 0) return cached;
+		const slot = { check: void 0 };
+		this.annotatingCache.set(node, indirectAnnotating(slot));
+		const check = this.buildAnnotating(node, this.r.baseFor(node, base));
+		slot.check = check;
+		this.annotatingCache.set(node, check);
+		return check;
+	}
+	buildAnnotating(node, base) {
+		const rest = {};
+		let annotates = false;
+		for (const k of Object.keys(node)) if (ANNOTATING.has(k)) annotates = true;
+		else rest[k] = node[k];
+		const plain = this.plain(rest, base);
+		const parts = [];
+		if (annotates) this.annotatingParts(node, base, parts);
+		const all = parts.length === 0 ? ignoreAnnotations(plain) : annotateAll(plain, parts);
+		const own = node.unevaluatedProperties !== void 0 || node.unevaluatedItems !== void 0 ? isolateAnnotations(all) : all;
+		return this.dynamic && this.r.isResource(node, base) ? scopedAnnotating(this.scope, base, own) : own;
+	}
+	annotatingParts(node, base, parts) {
+		if (node.properties !== void 0 || node.patternProperties !== void 0 || node.additionalProperties !== void 0) {
+			const props = entries(node.properties).map(([k, s]) => [k, this.check(s, base)]);
+			const pats = entries(node.patternProperties).map(([p, s]) => [sharedRegex(p), this.check(s, base)]);
+			const extra = node.additionalProperties === void 0 ? void 0 : this.check(node.additionalProperties, base);
+			parts.push(annotateObject(props, pats, extra));
+		}
+		if (node.prefixItems !== void 0 || node.items !== void 0 || node.contains !== void 0) {
+			const prefix = Array.isArray(node.prefixItems) ? node.prefixItems : Array.isArray(node.items) ? node.items : [];
+			const rest = Array.isArray(node.items) ? node.additionalItems : node.items;
+			parts.push(annotateArray(prefix.map((s) => this.check(s, base)), rest === void 0 ? void 0 : this.check(rest, base), node.contains === void 0 ? void 0 : this.check(node.contains, base), number(node.minContains) ?? 1, number(node.maxContains) ?? Number.POSITIVE_INFINITY));
+		}
+		if (Array.isArray(node.allOf)) for (const s of node.allOf) parts.push(this.annotating(s, base));
+		if (Array.isArray(node.anyOf)) parts.push(annotateAny(node.anyOf.map((s) => this.annotating(s, base)), false));
+		if (Array.isArray(node.oneOf)) parts.push(annotateAny(node.oneOf.map((s) => this.annotating(s, base)), true));
+		if (node.if !== void 0) {
+			const then = node.then === void 0 ? void 0 : this.annotating(node.then, base);
+			const otherwise = node.else === void 0 ? void 0 : this.annotating(node.else, base);
+			parts.push(annotateIf(this.annotating(node.if, base), then, otherwise));
+		}
+		if (typeof node.$ref === "string") parts.push(this.annotatingRef(node.$ref, base));
+		if (typeof node.$dynamicRef === "string") parts.push(this.annotatingDynamicRef(node.$dynamicRef, base));
+		for (const [k, s] of entries(node.dependentSchemas)) parts.push(annotateDependent(k, this.annotating(s, base)));
+		if (node.unevaluatedProperties !== void 0) parts.push(unevaluatedProperties(this.check(node.unevaluatedProperties, base)));
+		if (node.unevaluatedItems !== void 0) parts.push(unevaluatedItems(this.check(node.unevaluatedItems, base)));
+	}
+	annotatingRef(ref, base) {
+		const target = this.r.resolve(ref, base);
+		const check = this.annotating(target.node, target.base);
+		return this.dynamic && target.base !== base ? scopedAnnotating(this.scope, target.base, check) : check;
+	}
+	annotatingDynamicRef(ref, base) {
+		const resolved = this.bookended(ref, base);
+		if (resolved === void 0) return this.annotatingRef(ref, base);
+		const { initial, name } = resolved;
+		const fallback = this.annotating(initial.node, initial.base);
+		const lookup = this.dynamicLookup(name, (node, b) => this.annotating(node, b));
+		const scope = this.scope;
+		return (v, a) => {
+			for (let i = 0; i < scope.length; i++) {
+				const check = lookup(scope[i]);
+				if (check !== null) return check(v, a);
+			}
+			return fallback(v, a);
+		};
+	}
+};
+/** Keywords that never affect a check. */
+const NEUTRAL_KEYWORDS = /* @__PURE__ */ new Set([
+	"$schema",
+	"$comment",
+	"title",
+	"description",
+	"default",
+	"examples",
+	"deprecated",
+	"readOnly",
+	"writeOnly",
+	"$defs",
+	"definitions",
+	"contentEncoding",
+	"contentMediaType",
+	"minContains",
+	"maxContains",
+	"$vocabulary"
+]);
+const OBJECT_EXTRAS = [
+	"propertyNames",
+	"minProperties",
+	"maxProperties",
+	"dependentRequired",
+	"dependentSchemas",
+	"dependencies"
+];
+const ANNOTATING = /* @__PURE__ */ new Set([
+	"properties",
+	"patternProperties",
+	"additionalProperties",
+	"prefixItems",
+	"items",
+	"additionalItems",
+	"contains",
+	"minContains",
+	"maxContains",
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"if",
+	"then",
+	"else",
+	"$ref",
+	"$dynamicRef",
+	"dependentSchemas",
+	"unevaluatedProperties",
+	"unevaluatedItems"
+]);
+/** anyOf/oneOf whose branches are all `{ const: primitive }`: an enum (distinct values make oneOf the same). */
+function constUnion(branches, exactlyOne) {
+	const values = [];
+	for (const branch of branches) {
+		if (!isSchemaObject$1(branch) || !Object.hasOwn(branch, "const")) return void 0;
+		for (const k of Object.keys(branch)) if (k !== "const" && !NEUTRAL_KEYWORDS.has(k)) return void 0;
+		if (typeof branch.const === "object" && branch.const !== null) return void 0;
+		if (exactlyOne && values.includes(branch.const)) return void 0;
+		values.push(branch.const);
+	}
+	return enumCheck(values);
+}
+function tagOf(branch, key) {
+	const properties = branch.properties;
+	if (branch.type !== "object" || !Array.isArray(branch.required) || !branch.required.includes(key)) return void 0;
+	const tag = isSchemaObject$1(properties) ? properties[key] : void 0;
+	if (!isSchemaObject$1(tag) || !Object.hasOwn(tag, "const")) return void 0;
+	return typeof tag.const === "object" && tag.const !== null ? void 0 : tag.const;
+}
+function number(value) {
+	return typeof value === "number" ? value : void 0;
+}
+function entries(value) {
+	return isSchemaObject$1(value) ? Object.entries(value) : [];
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@earendil-works+pi-schema@1.5.0/node_modules/@earendil-works/pi-schema/dist/explain.js
+/** Explains failures of one compiled schema. */
+var Explainer = class {
+	c;
+	schema;
+	/**
+	* The errors of `$ref` targets for object values, within one errors() call: a recursive union explains each branch
+	* to pick the one to blame, and every branch would explain the same children again, exponentially in the depth.
+	*/
+	memo = void 0;
+	constructor(compiler, schema) {
+		this.c = compiler;
+		this.schema = schema;
+		compiler.root();
+	}
+	/** The errors of `value`, at least one (`value` failed the check). */
+	errors(value) {
+		const out = [];
+		try {
+			this.walk(this.schema, this.c.r.rootBase, value, "", out);
+		} finally {
+			this.memo = void 0;
+		}
+		if (out.length === 0) out.push({
+			path: "",
+			keyword: "schema",
+			message: "invalid"
+		});
+		return out;
+	}
+	ok(node, base, v) {
+		return this.c.check(node, base)(v);
+	}
+	walk(node, base, v, path, out) {
+		if (node === true) return;
+		if (node === false) {
+			out.push({
+				path,
+				keyword: "false",
+				message: "no value is allowed here"
+			});
+			return;
+		}
+		if (!isSchemaObject$1(node)) return;
+		const b = this.c.r.baseFor(node, base);
+		if (this.ok(node, b, v)) return;
+		const start = out.length;
+		const push = (keyword, message, at = path) => {
+			out.push({
+				path: at,
+				keyword,
+				message
+			});
+		};
+		if (this.c.draft === "7" && typeof node.$ref === "string") {
+			this.walkRef(node.$ref, b, v, path, out);
+			return;
+		}
+		if (node.type !== void 0) {
+			const types = Array.isArray(node.type) ? node.type : [node.type];
+			if (!types.map((t) => (typeof t === "string" ? TYPE_CHECKS.get(t) : void 0) ?? NEVER).some((check) => check(v))) {
+				push("type", `expected ${types.join(" or ")}, got ${typeName(v)}`);
+				return;
+			}
+		}
+		if (Array.isArray(node.enum) && !enumCheck(node.enum)(v)) push("enum", `expected one of ${listValues(node.enum)}`);
+		if (Object.hasOwn(node, "const") && !constCheck(node.const)(v)) push("const", `expected ${JSON.stringify(node.const)}`);
+		if (typeof v === "string" && node.type !== "bytes") this.walkString(node, v, push);
+		if (v instanceof Uint8Array && node.type === "bytes") this.walkBytes(node, v, push);
+		if (typeof v === "number") this.walkNumber(node, v, push);
+		if (isObject(v)) this.walkObject(node, b, v, path, out, push);
+		if (Array.isArray(v)) this.walkArray(node, b, v, path, out, push);
+		if (Array.isArray(node.allOf)) for (const s of node.allOf) this.walk(s, b, v, path, out);
+		if (Array.isArray(node.anyOf)) this.walkUnion(node.anyOf, b, v, path, out, false);
+		if (Array.isArray(node.oneOf)) this.walkUnion(node.oneOf, b, v, path, out, true);
+		if (node.not !== void 0 && this.ok(node.not, b, v)) push("not", "must not match the schema in not");
+		if (node.if !== void 0) {
+			const branch = this.ok(node.if, b, v) ? node.then : node.else;
+			if (branch !== void 0) this.walk(branch, b, v, path, out);
+		}
+		if (typeof node.$ref === "string") this.walkRef(node.$ref, b, v, path, out);
+		if (out.length === start && (node.unevaluatedProperties !== void 0 || node.unevaluatedItems !== void 0)) this.walkUnevaluated(node, b, v, path, out);
+		if (out.length === start && typeof node.$dynamicRef === "string") push("$dynamicRef", "does not match the dynamically referenced schema");
+	}
+	walkRef(ref, base, v, path, out) {
+		const target = this.c.r.resolve(ref, base);
+		if (target.node === false && this.c.r.isUnresolved(ref, base)) {
+			out.push({
+				path,
+				keyword: "$ref",
+				message: `unresolved reference ${ref}`
+			});
+			return;
+		}
+		if (!isSchemaObject$1(target.node) || typeof v !== "object" || v === null) {
+			this.walk(target.node, target.base, v, path, out);
+			return;
+		}
+		this.memo ??= /* @__PURE__ */ new Map();
+		let values = this.memo.get(target.node);
+		const known = values?.get(v);
+		if (known !== void 0 && known.path === path) {
+			out.push(...known.errors);
+			return;
+		}
+		const errors = [];
+		this.walk(target.node, target.base, v, path, errors);
+		if (values === void 0) {
+			values = /* @__PURE__ */ new Map();
+			this.memo.set(target.node, values);
+		}
+		values.set(v, {
+			path,
+			errors
+		});
+		out.push(...errors);
+	}
+	walkString(node, v, push) {
+		const n = codePoints(v);
+		if (typeof node.minLength === "number" && n < node.minLength) push("minLength", `expected at least ${node.minLength} characters`);
+		if (typeof node.maxLength === "number" && n > node.maxLength) push("maxLength", `expected at most ${node.maxLength} characters`);
+		if (typeof node.pattern === "string" && !sharedRegex(node.pattern).test(v)) push("pattern", `expected to match ${node.pattern}`);
+		const formats = this.c.formats;
+		const format = formats !== void 0 && typeof node.format === "string" && Object.hasOwn(formats, node.format) ? formats[node.format] : void 0;
+		if (format !== void 0 && !format(v)) push("format", `expected format ${node.format}`);
+	}
+	walkBytes(node, v, push) {
+		if (typeof node.minLength === "number" && v.length < node.minLength) push("minLength", `expected at least ${node.minLength} bytes`);
+		if (typeof node.maxLength === "number" && v.length > node.maxLength) push("maxLength", `expected at most ${node.maxLength} bytes`);
+	}
+	walkNumber(node, v, push) {
+		if (typeof node.minimum === "number" && v < node.minimum) push("minimum", `expected >= ${node.minimum}`);
+		if (typeof node.maximum === "number" && v > node.maximum) push("maximum", `expected <= ${node.maximum}`);
+		if (typeof node.exclusiveMinimum === "number" && v <= node.exclusiveMinimum) push("exclusiveMinimum", `expected > ${node.exclusiveMinimum}`);
+		if (typeof node.exclusiveMaximum === "number" && v >= node.exclusiveMaximum) push("exclusiveMaximum", `expected < ${node.exclusiveMaximum}`);
+		if (typeof node.multipleOf === "number" && !isMultiple(v, node.multipleOf)) push("multipleOf", `expected a multiple of ${node.multipleOf}`);
+	}
+	walkObject(node, b, v, path, out, push) {
+		const properties = isSchemaObject$1(node.properties) ? node.properties : {};
+		const required = Array.isArray(node.required) ? node.required : [];
+		for (const k of required) if (typeof k === "string" && (!Object.hasOwn(v, k) || v[k] === void 0)) push("required", "missing", pointer(path, k));
+		for (const k of Object.keys(properties)) if (Object.hasOwn(v, k) && v[k] !== void 0) this.walk(properties[k], b, v[k], pointer(path, k), out);
+		const patterns = isSchemaObject$1(node.patternProperties) ? Object.entries(node.patternProperties) : [];
+		for (const k of Object.keys(v)) {
+			let matched = Object.hasOwn(properties, k);
+			for (const [p, s] of patterns) if (sharedRegex(p).test(k)) {
+				matched = true;
+				this.walk(s, b, v[k], pointer(path, k), out);
+			}
+			if (!matched && node.additionalProperties !== void 0) {
+				if (node.additionalProperties === false) push("additionalProperties", "unknown field", pointer(path, k));
+				else this.walk(node.additionalProperties, b, v[k], pointer(path, k), out);
+			}
+			if (node.propertyNames !== void 0 && !this.ok(node.propertyNames, b, k)) push("propertyNames", "invalid property name", pointer(path, k));
+		}
+		const count = Object.keys(v).length;
+		if (typeof node.minProperties === "number" && count < node.minProperties) push("minProperties", `expected at least ${node.minProperties} properties`);
+		if (typeof node.maxProperties === "number" && count > node.maxProperties) push("maxProperties", `expected at most ${node.maxProperties} properties`);
+		const dependencies = {
+			...this.c.draft === "7" || !isSchemaObject$1(node.dependentRequired) ? {} : node.dependentRequired,
+			...isSchemaObject$1(node.dependencies) ? node.dependencies : {}
+		};
+		for (const [k, d] of Object.entries(dependencies)) {
+			if (!Object.hasOwn(v, k)) continue;
+			if (!Array.isArray(d)) this.walk(d, b, v, path, out);
+			else for (const r of d) if (!Object.hasOwn(v, r)) push("dependentRequired", `required when ${k} is present`, pointer(path, r));
+		}
+		if (this.c.draft !== "7" && isSchemaObject$1(node.dependentSchemas)) {
+			for (const [k, s] of Object.entries(node.dependentSchemas)) if (Object.hasOwn(v, k)) this.walk(s, b, v, path, out);
+		}
+	}
+	walkArray(node, b, v, path, out, push) {
+		let prefix = [];
+		let rest;
+		if (Array.isArray(node.items)) {
+			prefix = node.items;
+			rest = node.additionalItems;
+		} else {
+			if (this.c.draft !== "7" && Array.isArray(node.prefixItems)) prefix = node.prefixItems;
+			rest = node.items;
+		}
+		for (let i = 0; i < v.length; i++) {
+			const s = i < prefix.length ? prefix[i] : rest;
+			if (s !== void 0) this.walk(s, b, v[i], `${path}/${i}`, out);
+		}
+		if (typeof node.minItems === "number" && v.length < node.minItems) push("minItems", `expected at least ${node.minItems} items`);
+		if (typeof node.maxItems === "number" && v.length > node.maxItems) push("maxItems", `expected at most ${node.maxItems} items`);
+		if (node.uniqueItems === true && !uniqueCheck(v)) push("uniqueItems", "expected unique items");
+		if (node.contains !== void 0) {
+			const draft7 = this.c.draft === "7";
+			const min = draft7 || typeof node.minContains !== "number" ? 1 : node.minContains;
+			const max = draft7 || typeof node.maxContains !== "number" ? Number.POSITIVE_INFINITY : node.maxContains;
+			if (!containsCheck(this.c.check(node.contains, b), min, max)(v)) push("contains", containsMessage(min, max));
+		}
+	}
+	walkUnion(branches, b, v, path, out, exactlyOne) {
+		const matches = branches.filter((s) => this.ok(s, b, v)).length;
+		if (matches === 1 || !exactlyOne && matches > 0) return;
+		const keyword = exactlyOne ? "oneOf" : "anyOf";
+		if (matches > 1) {
+			out.push({
+				path,
+				keyword,
+				message: "matches more than one alternative"
+			});
+			return;
+		}
+		const tag = this.tagOf(branches, b);
+		if (tag !== void 0 && isObject(v)) {
+			const i = tag.values.indexOf(v[tag.key]);
+			if (i < 0) out.push({
+				path: pointer(path, tag.key),
+				keyword,
+				message: `expected one of ${listValues(tag.values)}`
+			});
+			else this.walk(branches[i], b, v, path, out);
+			return;
+		}
+		let best;
+		for (const s of branches) {
+			const errors = [];
+			this.walk(s, b, v, path, errors);
+			if (errors.length === 0) continue;
+			const declared = isObject(v) ? this.declaredKeys(s, b, v) : 0;
+			if (best === void 0 || declared > best.declared || declared === best.declared && errors[0].path.length > best.errors[0].path.length) best = {
+				errors,
+				declared
+			};
+		}
+		out.push(...best?.errors ?? [{
+			path,
+			keyword,
+			message: "matches no alternative"
+		}]);
+	}
+	/** How many of the keys of `v` the branch `s` (through a `$ref`) declares in `properties`. */
+	declaredKeys(s, b, v) {
+		const node = isSchemaObject$1(s) && typeof s.$ref === "string" ? this.c.r.resolve(s.$ref, b).node : s;
+		const properties = isSchemaObject$1(node) && isSchemaObject$1(node.properties) ? node.properties : {};
+		return Object.keys(v).filter((k) => Object.hasOwn(properties, k)).length;
+	}
+	tagOf(branches, b) {
+		const resolved = branches.map((s) => isSchemaObject$1(s) && typeof s.$ref === "string" ? this.c.r.resolve(s.$ref, b).node : s);
+		const first = resolved[0];
+		if (!isSchemaObject$1(first) || !isSchemaObject$1(first.properties)) return void 0;
+		for (const key of Object.keys(first.properties)) {
+			const values = resolved.map((s) => {
+				const tag = isSchemaObject$1(s) && isSchemaObject$1(s.properties) ? s.properties[key] : void 0;
+				return isSchemaObject$1(tag) ? tag.const : void 0;
+			});
+			if (values.every((x) => x !== void 0 && (typeof x !== "object" || x === null)) && new Set(values).size === values.length) return {
+				key,
+				values
+			};
+		}
+	}
+	walkUnevaluated(node, b, v, path, out) {
+		const { unevaluatedProperties, unevaluatedItems, ...rest } = node;
+		const a = newAnnotations();
+		this.c.annotating(rest, b)(v, a);
+		if (isObject(v) && unevaluatedProperties !== void 0 && !a.allProps) for (const k of Object.keys(v)) {
+			if (a.props?.has(k)) continue;
+			if (unevaluatedProperties === false) out.push({
+				path: pointer(path, k),
+				keyword: "unevaluatedProperties",
+				message: "unknown field"
+			});
+			else this.walk(unevaluatedProperties, b, v[k], pointer(path, k), out);
+		}
+		if (Array.isArray(v) && unevaluatedItems !== void 0 && !a.allItems) for (let i = a.items; i < v.length; i++) {
+			if (a.indexes?.has(i)) continue;
+			if (unevaluatedItems === false) out.push({
+				path: `${path}/${i}`,
+				keyword: "unevaluatedItems",
+				message: "unexpected item"
+			});
+			else this.walk(unevaluatedItems, b, v[i], `${path}/${i}`, out);
+		}
+	}
+};
+const LISTED_VALUES = 20;
+/** `values` as JSON, at most LISTED_VALUES of them, then how many more there are. */
+function listValues(values) {
+	if (values.length <= LISTED_VALUES) return JSON.stringify(values);
+	return `${JSON.stringify(values.slice(0, LISTED_VALUES)).slice(0, -1)}, ... and ${values.length - LISTED_VALUES} more]`;
+}
+function containsMessage(min, max) {
+	if (max === Number.POSITIVE_INFINITY) return `expected at least ${min} matching ${min === 1 ? "item" : "items"}`;
+	if (min === 0) return `expected at most ${max} matching ${max === 1 ? "item" : "items"}`;
+	return `expected between ${min} and ${max} matching items`;
+}
+function pointer(path, key) {
+	return `${path}/${String(key).replace(/~/g, "~0").replace(/\//g, "~1")}`;
+}
+function typeName(v) {
+	if (v === null) return "null";
+	if (Array.isArray(v)) return "array";
+	if (v instanceof Uint8Array) return "bytes";
+	if (typeof v === "number" && Number.isInteger(v)) return "integer";
+	return typeof v;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@earendil-works+pi-schema@1.5.0/node_modules/@earendil-works/pi-schema/dist/validator.js
+function compile(schema, options = NO_OPTIONS) {
+	const check = compileCheck(schema, options);
+	return options.coerce === true ? new CoercingValidator(schema, options, check) : new Validator(schema, options, check);
+}
+const NO_OPTIONS = Object.freeze({});
+/** A compiled schema whose valid values have type `T` (`unknown` unless the schema was built with the builders). */
+var Validator = class {
+	/** Whether `value` is valid. A plain function: it may be passed around without its validator. */
+	check;
+	schema;
+	options;
+	explainer = void 0;
+	constructor(schema, options, check) {
+		this.check = check;
+		this.schema = schema;
+		this.options = options;
+	}
+	/**
+	* Why `value` is invalid: one error per failing keyword, `[]` when it is valid. Built on the first failure and
+	* kept, so a validator whose values always pass never pays for it.
+	*/
+	errors(value) {
+		if (this.check(value)) return [];
+		this.explainer ??= new Explainer(compiler(this.schema, this.options), this.schema);
+		return this.explainer.errors(value);
+	}
+};
+/** A validator compiled with `coerce: true`: it also coerces loosely typed input towards the schema. */
+var CoercingValidator = class extends Validator {
+	coercer = void 0;
+	/**
+	* `value` coerced towards the schema: numeric strings to numbers, `"true"` to `true`, a single value to a one-item
+	* array, an optional `null` dropped, the first union branch the value converts to (the README lists every rule).
+	* Only the changed paths are copied; `value` comes back itself when nothing changes, and is never modified. Values
+	* that cannot be coerced stay as they are. The rules are built on the first call.
+	*/
+	coerce(value) {
+		this.coercer ??= new Coercer(compiler(this.schema, this.options), this.schema);
+		return this.coercer.coerce(value);
+	}
+	/** Coerces `value`, then checks it: the coerced value when it is valid, else its errors. */
+	parse(value) {
+		const coerced = this.coerce(value);
+		return this.check(coerced) ? {
+			ok: true,
+			value: coerced
+		} : {
+			ok: false,
+			errors: this.errors(coerced)
+		};
+	}
+};
+function compileCheck(schema, options) {
+	return compiler(schema, options).root();
+}
+function compiler(schema, options) {
+	const plain = new Compiler(schema, options, false);
+	try {
+		plain.root();
+		return plain;
+	} catch (error) {
+		if (error !== RESTART) throw error;
+		return new Compiler(schema, options, true);
+	}
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@earendil-works+chord@1.5.0_esbuild@0.28.2/node_modules/@earendil-works/chord/dist/errors.js
+/** Error codes callers see (guide table). A refused or aborted reload keeps the code of its cause. */
+const CHORD_ERROR_CODES = [
+	"aborted",
+	"contract_mismatch",
+	"forbidden",
+	"gone",
+	"invalid",
+	"not_in_variant",
+	"not_ready",
+	"released",
+	"superseded",
+	"unavailable",
+	"upgrade_conflict",
+	"upgrade_required"
+];
+const RETRYABLE = /* @__PURE__ */ new Set(["superseded", "upgrade_conflict"]);
+var ChordError = class extends Error {
+	code;
+	reason;
+	retryable;
+	details;
+	constructor(code, message, options) {
+		super(`${code}${options?.reason ? `/${options.reason}` : ""}: ${message}`, { cause: options?.cause });
+		this.name = "ChordError";
+		this.code = code;
+		this.reason = options?.reason;
+		this.retryable = RETRYABLE.has(code);
+		this.details = options?.details;
+	}
+};
+const isChordError = (error, code) => error instanceof ChordError && (code === void 0 || error.code === code);
+/** For factories and methods refusing a principal: `throw forbidden()`. */
+const forbidden = (message = "forbidden") => new ChordError("forbidden", message);
+const invalid = (reason, message, details) => new ChordError("invalid", message, {
+	reason,
+	details
+});
+/** Keeps a ChordError's code; anything else becomes `unavailable` with the original as cause. */
+const asChordError = (error, context) => error instanceof ChordError ? error : new ChordError("unavailable", `${context}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+/** Runs every step, then throws one error, or an AggregateError when several failed. */
+async function runAll(steps, message) {
+	const errors = [];
+	for (const step of steps) try {
+		await step();
+	} catch (error) {
+		errors.push(error);
+	}
+	if (errors.length === 1) throw errors[0];
+	if (errors.length > 1) throw new AggregateError(errors, message);
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@earendil-works+chord@1.5.0_esbuild@0.28.2/node_modules/@earendil-works/chord/dist/schema.js
+const asSchema = (schema) => schema !== null && typeof schema === "object" ? schema : schema === false ? { not: {} } : {};
+/** Canonical JSON: sorted object keys, `undefined` members dropped. */
+function canonicalJson(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+	if (Array.isArray(value)) return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
+	return `{${Object.keys(value).filter((key) => value[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
+}
+/** Non-cryptographic 64-bit hash (two FNV-1a lanes). Contracts are trusted, so collisions are not an attack surface. */
+function hash64(text) {
+	let a = 2166136261;
+	let b = 1523705862;
+	for (let index = 0; index < text.length; index++) {
+		const code = text.charCodeAt(index);
+		a = Math.imul(a ^ code, 16777619);
+		b = Math.imul(b ^ code, 1540483477) ^ b >>> 13;
+	}
+	return (a >>> 0).toString(16).padStart(8, "0") + (b >>> 0).toString(16).padStart(8, "0");
+}
+function deepEqual(a, b) {
+	return a === b || canonicalJson(a) === canonicalJson(b);
+}
+const validators = /* @__PURE__ */ new WeakMap();
+/** The compiled validator of `schema`, compiled once per schema object; `format` is an annotation. */
+function validatorOf(schema) {
+	if (typeof schema === "boolean") return compile(schema);
+	let validator = validators.get(schema);
+	if (validator === void 0) {
+		validator = compile(schema);
+		validators.set(schema, validator);
+	}
+	return validator;
+}
+/** Whether `value` matches `schema`. */
+function isValid(schema, value) {
+	return validatorOf(schema).check(value);
+}
+/** Throws `invalid` (with `reason`) and the first schema errors when `value` does not match. */
+function assertValid(reason, what, schema, value) {
+	const validator = validatorOf(schema);
+	if (validator.check(value)) return;
+	const errors = validator.errors(value).slice(0, 3);
+	const summary = errors.map((error) => `${error.path || "/"} ${error.message}`).join("; ");
+	throw invalid(reason, `${what}: ${summary}`, errors);
+}
+/** Applies defaults, strips unknown fields, validates. Returns a fresh value. */
+function normalize(schema, value, what) {
+	const normalized = cleanFrom(asSchema(schema), withDefaults(asSchema(schema), cloneData(value ?? {})));
+	assertValid("input", what, schema, normalized);
+	return normalized;
+}
+/** A copy of `value` with only what `schema` knows: unknown object fields dropped, recursively (TypeBox's `Clean`). */
+function cleaned(schema, value) {
+	return cleanFrom(asSchema(schema), cloneData(value));
+}
+/** A deep copy of plain data: arrays, plain objects and bytes are copied, any other value is kept. */
+function cloneData(value) {
+	if (Array.isArray(value)) return value.map(cloneData);
+	if (value instanceof Uint8Array) return value.slice();
+	if (value === null || typeof value !== "object") return value;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) return value;
+	const copy = {};
+	for (const [key, item] of Object.entries(value)) copy[key] = cloneData(item);
+	return copy;
+}
+const isPlainObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Uint8Array);
+const isSchemaObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+/** The object an `allOf` of object schemas evaluates to (TypeBox's `Evaluate`), or undefined for any other `allOf`. */
+function mergedAllOf(schema) {
+	if (!Array.isArray(schema.allOf) || !schema.allOf.every((branch) => isSchemaObject(branch.properties))) return void 0;
+	const properties = {};
+	const required = /* @__PURE__ */ new Set();
+	for (const branch of schema.allOf) {
+		Object.assign(properties, branch.properties);
+		for (const key of branch.required ?? []) required.add(key);
+	}
+	return {
+		type: "object",
+		properties,
+		required: [...required],
+		...schema.unevaluatedProperties === void 0 ? {} : { additionalProperties: schema.unevaluatedProperties }
+	};
+}
+/** The pattern and value schema of a record (`patternProperties` with one pattern). */
+function recordOf(schema) {
+	if (!isSchemaObject(schema.patternProperties) || isSchemaObject(schema.properties)) return void 0;
+	const [entry] = Object.entries(schema.patternProperties);
+	return entry === void 0 ? void 0 : [new RegExp(entry[0], "u"), entry[1]];
+}
+/** Whether `additional` (an object's `additionalProperties`) keeps an unknown field holding `value`. */
+const keepsUnknown = (additional, value) => additional === true || isSchemaObject(additional) && isValid(additional, value);
+function cleanFrom(schema, value) {
+	const merged = mergedAllOf(schema);
+	if (merged !== void 0) return cleanFrom(merged, value);
+	if (Array.isArray(schema.anyOf)) {
+		for (const branch of schema.anyOf) {
+			const candidate = cleanFrom(asSchema(branch), cloneData(value));
+			if (isValid(asSchema(branch), candidate)) return candidate;
+		}
+		return value;
+	}
+	if (Array.isArray(value)) {
+		const prefix = Array.isArray(schema.items) ? schema.items : Array.isArray(schema.prefixItems) ? schema.prefixItems : void 0;
+		if (prefix !== void 0) {
+			const length = Math.min(value.length, prefix.length);
+			for (let index = 0; index < length; index++) value[index] = cleanFrom(asSchema(prefix[index]), value[index]);
+			return value.length > length ? value.slice(0, length) : value;
+		}
+		if (isSchemaObject(schema.items)) return value.map((item) => cleanFrom(schema.items, item));
+		return value;
+	}
+	if (!isPlainObject(value)) return value;
+	const record = recordOf(schema);
+	const properties = isSchemaObject(schema.properties) ? schema.properties : void 0;
+	if (properties === void 0 && record === void 0 && !isSchemaObject(schema.additionalProperties)) return value;
+	for (const key of Object.keys(value)) {
+		const matched = (properties !== void 0 && Object.hasOwn(properties, key) ? properties[key] : void 0) ?? (record?.[0].test(key) ? record[1] : void 0);
+		if (matched !== void 0) value[key] = cleanFrom(asSchema(matched), value[key]);
+		else if (keepsUnknown(schema.additionalProperties, value[key])) value[key] = cleanFrom(asSchema(schema.additionalProperties), value[key]);
+		else delete value[key];
+	}
+	return value;
+}
+function withDefaults(schema, value) {
+	const defaulted = value === void 0 && "default" in schema ? cloneData(schema.default) : value;
+	const merged = mergedAllOf(schema);
+	if (merged !== void 0) return withDefaults(merged, defaulted);
+	if (Array.isArray(schema.anyOf)) {
+		for (const branch of schema.anyOf) {
+			const candidate = withDefaults(asSchema(branch), cloneData(defaulted));
+			if (isValid(asSchema(branch), candidate)) return candidate;
+		}
+		return defaulted;
+	}
+	if (Array.isArray(defaulted)) {
+		const prefix = Array.isArray(schema.items) ? schema.items : Array.isArray(schema.prefixItems) ? schema.prefixItems : void 0;
+		if (prefix !== void 0) {
+			for (let index = 0; index < prefix.length; index++) {
+				const item = withDefaults(asSchema(prefix[index]), defaulted[index]);
+				if (index < defaulted.length || item !== void 0) defaulted[index] = item;
+			}
+			return defaulted;
+		}
+		if (isSchemaObject(schema.items)) return defaulted.map((item) => withDefaults(schema.items, item));
+		return defaulted;
+	}
+	if (!isPlainObject(defaulted)) return defaulted;
+	const properties = isSchemaObject(schema.properties) ? schema.properties : void 0;
+	const record = recordOf(schema);
+	if (properties !== void 0) {
+		const required = schema.required ?? [];
+		for (const [key, property] of Object.entries(properties)) {
+			const item = withDefaults(asSchema(property), defaulted[key]);
+			if (item === void 0 && (!required.includes(key) || !("default" in asSchema(property)))) continue;
+			defaulted[key] = item;
+		}
+	} else if (record !== void 0 && isSchemaObject(record[1]) && "default" in record[1]) {
+		for (const key of Object.keys(defaulted)) if (record[0].test(key)) defaulted[key] = withDefaults(record[1], defaulted[key]);
+	}
+	if (!isSchemaObject(schema.additionalProperties)) return defaulted;
+	for (const key of Object.keys(defaulted)) if (!(properties !== void 0 && Object.hasOwn(properties, key)) && !record?.[0].test(key)) defaulted[key] = withDefaults(schema.additionalProperties, defaulted[key]);
+	return defaulted;
+}
+/** Canonical identity of a normalized value: fields equal to their schema default are omitted. */
+function canonicalIdentity(schema, value) {
+	return canonicalJson(stripDefaults(asSchema(schema), value));
+}
+function stripDefaults(schema, value) {
+	if (Array.isArray(value)) {
+		const items = schema.items;
+		if (Array.isArray(items)) return value.map((item, index) => stripDefaults(asSchema(items[index]), item));
+		return value.map((item) => stripDefaults(asSchema(items), item));
+	}
+	if (value === null || typeof value !== "object") return value;
+	const properties = asSchema(schema.properties);
+	const result = {};
+	for (const [key, item] of Object.entries(value)) {
+		const property = asSchema(properties[key]);
+		if ("default" in property && deepEqual(property.default, item)) continue;
+		result[key] = stripDefaults(property, item);
+	}
+	return result;
+}
+const CONSTRAINTS = [
+	"minLength",
+	"maxLength",
+	"pattern",
+	"format",
+	"minimum",
+	"maximum",
+	"exclusiveMinimum",
+	"exclusiveMaximum",
+	"multipleOf",
+	"minItems",
+	"maxItems",
+	"uniqueItems",
+	"minProperties",
+	"maxProperties"
+];
+const typesOf = (schema) => typeof schema.type === "string" ? [schema.type] : Array.isArray(schema.type) ? schema.type : void 0;
+/** Keywords `fits` reasons about. Any other validation keyword in the provider's schema forces exact equality. */
+const KNOWN = /* @__PURE__ */ new Set([
+	...CONSTRAINTS,
+	"type",
+	"properties",
+	"required",
+	"additionalProperties",
+	"patternProperties",
+	"items",
+	"additionalItems",
+	"const",
+	"enum",
+	"anyOf",
+	"parameters",
+	"returnType"
+]);
+/** Annotations: no effect on validity. */
+const ANNOTATIONS = /* @__PURE__ */ new Set([
+	"title",
+	"description",
+	"default",
+	"examples",
+	"$id",
+	"$schema",
+	"$comment",
+	"readOnly",
+	"writeOnly",
+	"deprecated"
+]);
+const withoutAnnotations = (schema) => Object.fromEntries(Object.entries(schema).filter(([key]) => !ANNOTATIONS.has(key)));
+/**
+* Conservative structural subtyping: true only if every value valid under `sub` is valid under `sup`, where object
+* fields missing from `sub` but optional in `sup` count as fine (unknown fields are stripped at the provider, see
+* `RecordImpl.call`). A provider schema using a keyword this function does not model (`not`, `allOf`, `contains`,
+* `$ref`, ...) or an `additionalProperties` schema only fits an identical consumer schema.
+*/
+function fits(subSchema, supSchema) {
+	const sub = withoutAnnotations(asSchema(subSchema));
+	const sup = withoutAnnotations(asSchema(supSchema));
+	if (Object.keys(sup).length === 0) return true;
+	if (deepEqual(sub, sup)) return true;
+	if (Object.keys(sup).some((key) => !KNOWN.has(key))) return false;
+	if (sup.additionalProperties !== void 0 && typeof sup.additionalProperties !== "boolean") return false;
+	if (Array.isArray(sub.anyOf)) return sub.anyOf.every((branch) => fits(branch, sup));
+	if (Array.isArray(sup.anyOf)) return sup.anyOf.some((branch) => fits(sub, branch));
+	if ("const" in sup) return "const" in sub && deepEqual(sub.const, sup.const);
+	if (Array.isArray(sup.enum)) return ("const" in sub ? [sub.const] : Array.isArray(sub.enum) ? sub.enum : void 0)?.every((item) => sup.enum.some((allowed) => deepEqual(allowed, item))) ?? false;
+	for (const key of CONSTRAINTS) if (key in sup && !deepEqual(sub[key], sup[key])) return false;
+	const supTypes = typesOf(sup);
+	const subTypes = typesOf(sub);
+	if (supTypes === void 0 || subTypes === void 0) return false;
+	if (!subTypes.every((type) => supTypes.includes(type) || type === "integer" && supTypes.includes("number"))) return false;
+	if ("const" in sub || Array.isArray(sub.enum)) return true;
+	if (subTypes.includes("object") && !objectFits(sub, sup)) return false;
+	if (subTypes.includes("array") && !arrayFits(sub, sup)) return false;
+	if (subTypes.includes("function")) return functionFits(sub, sup);
+	return true;
+}
+function objectFits(sub, sup) {
+	const subProperties = asSchema(sub.properties);
+	const supProperties = asSchema(sup.properties);
+	const subRequired = new Set(sub.required ?? []);
+	for (const key of sup.required ?? []) if (!subRequired.has(key)) return false;
+	for (const [key, property] of Object.entries(supProperties)) if (key in subProperties) {
+		if (!fits(subProperties[key], property)) return false;
+	} else if (typeof sub.additionalProperties === "object" && !fits(sub.additionalProperties, property)) return false;
+	if (sup.additionalProperties === false) {
+		if (sub.additionalProperties !== false) return false;
+		if (Object.keys(subProperties).some((key) => !(key in supProperties))) return false;
+	}
+	const supPatterns = asSchema(sup.patternProperties);
+	if (Object.keys(supPatterns).length > 0) {
+		const subPatterns = asSchema(sub.patternProperties);
+		if (sub.additionalProperties !== false && Object.keys(subPatterns).length === 0) return false;
+		for (const [pattern, property] of Object.entries(supPatterns)) {
+			const matcher = new RegExp(pattern, "u");
+			for (const [key, subProperty] of Object.entries(subProperties)) if (!(key in supProperties) && matcher.test(key) && !fits(subProperty, property)) return false;
+			if (Object.keys(subPatterns).length > 0 && (!(pattern in subPatterns) || !fits(subPatterns[pattern], property))) return false;
+		}
+		for (const pattern of Object.keys(subPatterns)) if (!(pattern in supPatterns)) return false;
+	}
+	return true;
+}
+function arrayFits(sub, sup) {
+	if (Array.isArray(sup.items)) {
+		if (!Array.isArray(sub.items) || sub.items.length !== sup.items.length) return false;
+		return sub.items.every((item, index) => fits(item, sup.items[index]));
+	}
+	if (Array.isArray(sub.items)) return sub.items.every((item) => fits(item, sup.items));
+	return fits(sub.items, sup.items);
+}
+function functionFits(sub, sup) {
+	const subParameters = sub.parameters ?? [];
+	const supParameters = sup.parameters ?? [];
+	if (subParameters.length > supParameters.length) return false;
+	if (!subParameters.every((parameter, index) => fits(supParameters[index], parameter))) return false;
+	return fits(sub.returnType, sup.returnType);
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@earendil-works+chord@1.5.0_esbuild@0.28.2/node_modules/@earendil-works/chord/dist/contract.js
+const MEMBER = Symbol("chord.member");
+function method(args, result) {
+	return {
+		[MEMBER]: "method",
+		args,
+		result
+	};
+}
+/** A native in-process object identified by `name@version` (local contracts only). */
+const opaque = (id) => {
+	if (!/^[^@\s]+@\d+$/.test(id)) throw new TypeError(`opaque id must be name@version: ${id}`);
+	return {
+		[MEMBER]: "opaque",
+		id
+	};
+};
+/** Objects of the type live on the host named `name` (`hostNamed("server")`). */
+function hostNamed(name) {
+	if (typeof name !== "string" || name === "") throw new TypeError("hostNamed needs a host name");
+	return { name };
+}
+/** The host an object of `placement` with this (normalized) input lives on. Throws `invalid/placement`. */
+function resolveHost(typeName, placement, input) {
+	if ("name" in placement) return placement.name;
+	const value = input !== null && typeof input === "object" ? input[placement.key] : void 0;
+	if (typeof value !== "string" || value === "") throw invalid("placement", `${typeName}: input field ${placement.key} names no host`);
+	return placement.prefix + value;
+}
+/** Whether the host named `hostName` may serve a type of `placement`. */
+const placedOn = (placement, hostName) => "name" in placement ? placement.name === hostName : hostName.startsWith(placement.prefix) && hostName.length > placement.prefix.length;
+const placementText = (placement) => "name" in placement ? placement.name : `${placement.prefix}<${placement.key}>`;
+const SchemaObject = obj({}, { open: true });
+const MemberDescriptionSchema = union([
+	obj({
+		kind: lit("method"),
+		args: opt(SchemaObject),
+		result: opt(SchemaObject)
+	}, { open: true }),
+	obj({
+		kind: lit("state"),
+		schema: SchemaObject
+	}, { open: true }),
+	obj({
+		kind: lit("opaque"),
+		id: str()
+	}, { open: true })
+]);
+const PlacementSchema = union([obj({ name: str({ minLength: 1 }) }), obj({
+	prefix: str({ minLength: 1 }),
+	key: str({ minLength: 1 })
+})]);
+const DescriptionSchema = obj({
+	name: str({ minLength: 1 }),
+	scope: union([lit("remote"), lit("local")]),
+	version: int(),
+	input: SchemaObject,
+	/** Remote types only (required there): where their objects live. */
+	host: opt(PlacementSchema),
+	variants: map(map(MemberDescriptionSchema))
+}, { open: true });
+/** Names a reference uses itself; members may not use them. */
+const RESERVED_MEMBERS = /* @__PURE__ */ new Set([
+	"variant",
+	"status",
+	"ready",
+	"shape",
+	"error",
+	"onShape",
+	"onStatus",
+	"release",
+	"then",
+	"contract"
+]);
+function describeMember(name, member, scope) {
+	if (RESERVED_MEMBERS.has(name)) throw new TypeError(`member name is reserved: ${name}`);
+	const brand = member[MEMBER];
+	if (brand === "method") {
+		const spec = member;
+		return {
+			kind: "method",
+			...spec.args === void 0 ? {} : { args: spec.args },
+			...spec.result === void 0 ? {} : { result: spec.result }
+		};
+	}
+	if (brand === "opaque") {
+		if (scope === "remote") throw new TypeError(`remote contracts cannot expose opaque members: ${name}`);
+		return {
+			kind: "opaque",
+			id: member.id
+		};
+	}
+	return {
+		kind: "state",
+		schema: member
+	};
+}
+function finish(contract) {
+	return {
+		...contract,
+		fingerprint: hash64(canonicalJson(contract.description))
+	};
+}
+function checkHeader(name, version) {
+	if (!name) throw new TypeError("contract name is empty");
+	if (!Number.isInteger(version) || version < 1) throw new TypeError(`contract version must be a positive integer`);
+}
+function remote(name, def) {
+	checkHeader(name, def.version);
+	const placement = def.host;
+	if (placement === void 0 || !isValid(PlacementSchema, placement)) throw new TypeError(`remote contract ${name} needs \`host\`: hostNamed(…) or hostFamily(…)`);
+	const host = "name" in placement ? { name: placement.name } : {
+		prefix: placement.prefix,
+		key: placement.key
+	};
+	const variants = {};
+	if (Object.keys(def.variants).length === 0) throw new TypeError(`remote contract ${name} has no variants`);
+	for (const [kind, variant] of Object.entries(def.variants)) {
+		const members = {};
+		for (const [key, schema] of Object.entries(variant.state ?? {})) members[key] = describeMember(key, schema, "remote");
+		for (const [key, spec] of Object.entries(variant.methods ?? {})) {
+			if (key in members) throw new TypeError(`member ${key} is both state and method in ${name}.${kind}`);
+			members[key] = describeMember(key, spec, "remote");
+			if (members[key].kind !== "method") throw new TypeError(`methods.${key} is not a method()`);
+		}
+		variants[kind] = members;
+	}
+	const description = {
+		name,
+		scope: "remote",
+		version: def.version,
+		input: def.input,
+		host,
+		variants
+	};
+	return finish({
+		scope: "remote",
+		name,
+		version: def.version,
+		input: def.input,
+		def,
+		description
+	});
+}
+function local(name, def) {
+	checkHeader(name, def.version);
+	const members = {};
+	for (const [key, member] of Object.entries(def.members ?? {})) members[key] = describeMember(key, member, "local");
+	const description = {
+		name,
+		scope: "local",
+		version: def.version,
+		input: def.input,
+		variants: { [""]: members }
+	};
+	return finish({
+		scope: "local",
+		name,
+		version: def.version,
+		input: def.input,
+		def,
+		description
+	});
+}
+/**
+* A consumer token received over a link (only its description travels). Has no `def`, so it is only good for binding
+* and validation, never for TypeScript types.
+*/
+function contractFromDescription(description) {
+	const { name, scope, version, input, host } = description;
+	if (typeof name !== "string" || scope !== "remote" && scope !== "local" || !Number.isInteger(version) || scope === "remote" !== (host !== void 0)) throw new ChordError("invalid", "malformed contract token", { reason: "token" });
+	const base = {
+		name,
+		version,
+		input,
+		description,
+		fingerprint: hash64(canonicalJson(description))
+	};
+	return scope === "remote" ? {
+		...base,
+		scope,
+		def: {
+			version,
+			input,
+			host,
+			variants: {}
+		}
+	} : {
+		...base,
+		scope,
+		def: {
+			version,
+			input
+		}
+	};
+}
+/** Returns why `provider` does not cover `consumer`, or undefined when it does. */
+function coverage(provider, consumer) {
+	if (provider.name !== consumer.name || provider.scope !== consumer.scope) return "different type";
+	if (!samePlacement(provider, consumer)) return "host";
+	if (!fits(consumer.input, provider.input)) return "input";
+	for (const [kind, consumerMembers] of Object.entries(consumer.variants)) {
+		const providerMembers = provider.variants[kind];
+		if (providerMembers === void 0) return `variant ${kind} missing`;
+		for (const [name, wanted] of Object.entries(consumerMembers)) {
+			const offered = providerMembers[name];
+			if (offered === void 0 || offered.kind !== wanted.kind) return `${kind}.${name} missing or of another kind`;
+			if (offered.kind === "method" && wanted.kind === "method") {
+				if (wanted.args === void 0 !== (offered.args === void 0)) return `${kind}.${name} arguments`;
+				if (wanted.args !== void 0 && offered.args !== void 0 && !fits(wanted.args, offered.args)) return `${kind}.${name} arguments`;
+				if (wanted.result !== void 0 && (offered.result === void 0 || !fits(offered.result, wanted.result))) return `${kind}.${name} result`;
+			} else if (offered.kind === "state" && wanted.kind === "state") {
+				if (!fits(offered.schema, wanted.schema)) return `${kind}.${name} state`;
+			} else if (offered.kind === "opaque" && wanted.kind === "opaque" && offered.id !== wanted.id) return `${kind}.${name} opaque ${offered.id} != ${wanted.id}`;
+		}
+	}
+}
+const samePlacement = (a, b) => canonicalJson(a.host ?? null) === canonicalJson(b.host ?? null);
+const placementOf = (description) => description.host === void 0 ? "(local)" : placementText(description.host);
+/** How a consumer token binds to a provider: directly or through an `accepts` adapter. Throws contract_mismatch. */
+function bind(provider, accepts, consumer) {
+	if (provider.fingerprint === consumer.fingerprint) return void 0;
+	if (!samePlacement(provider.description, consumer.description)) throw new ChordError("contract_mismatch", `${provider.name} lives on ${placementOf(provider.description)}, the consumer expects ${placementOf(consumer.description)}`);
+	if (provider.version === consumer.version) {
+		const reason = coverage(provider.description, consumer.description);
+		if (reason === void 0) return void 0;
+		throw new ChordError("contract_mismatch", `${provider.name}@${provider.version} does not cover the consumer's description (${reason}); forgotten version bump?`);
+	}
+	const adapter = accepts?.[consumer.version];
+	if (adapter === void 0) throw new ChordError("contract_mismatch", `${provider.name}: provider version ${provider.version}, consumer version ${consumer.version}, no accepts adapter`);
+	return adapter;
+}
+/** Whether `contract`'s method `name` takes no arguments (it is called as `ref.name(ctx)`). */
+function takesNoArgs(contract, name) {
+	for (const members of Object.values(contract.description.variants)) {
+		const member = members[name];
+		if (member?.kind === "method") return member.args === void 0;
+	}
+	return false;
+}
+//#endregion
+//#region ../../core/po-core/src/schemas/protocolContracts.ts
+/** Name of the Po server host; every Po contract places its objects on it. */
+const PO_SERVER_HOST = "server";
+/**
+* Gives a TypeBox schema the pi-schema type Chord reads. A TypeBox schema is JSON Schema, so Chord validates it
+* unchanged and contract fingerprints stay the same; only its static type moves.
+*/
+function chordSchema(schema) {
+	return schema;
+}
+/** `chordSchema` over a variant's state table. */
+function chordStates(schemas) {
+	return schemas;
+}
+/** Chord method specs for a schema table, typed so contracts built from them stay nameable. */
+function chordMethods(schemas) {
+	return Object.fromEntries(Object.entries(schemas).map(([name, { args, result }]) => [name, result !== void 0 ? method(args && chordSchema(args), chordSchema(result)) : args !== void 0 ? method(chordSchema(args)) : method()]));
+}
+//#endregion
+//#region ../../core/po-core/src/schemas/protocolChannelsContract.ts
+const Json$4 = Unsafe({});
+const ChannelFrameSchema = _Object_({
+	type: String$1({ minLength: 1 }),
+	payload: Json$4
+});
+/** Latest payload per extension channel frame type. */
+const PoChannelsStateSchema = Record(String$1(), Json$4);
+/** A session's extension channels as seen by one connection. */
+const PoChannelsContract = remote("po.channels", {
+	version: 1,
+	host: hostNamed(PO_SERVER_HOST),
+	input: chordSchema(_Object_({ sessionId: String$1({ minLength: 1 }) })),
+	variants: { default: {
+		state: chordStates({ latest: PoChannelsStateSchema }),
+		methods: chordMethods({ receive: { args: ChannelFrameSchema } })
+	} }
+});
+//#endregion
+//#region ../../core/po-core/src/constants/contextApi.ts
+/**
+* What one entry in the composition actually is, for a reader who clicked it.
+*
+* The projection prices the composition and stops there: names, owners, and
+* integer counts, small enough to republish whenever the composition changes.
+* The prose and the schema behind a figure are an order of magnitude larger and
+* are wanted one row at a time, so they travel on request instead. This module
+* is the contract both ends of that request share, and it is deliberately free
+* of Node imports so a browser can hold it too.
+*/
+/** Where a host mounts this package's API; the segment after /api/plugins/. */
+const API_BASE_PATH = "context";
+const ITEM_ROUTE = "/item";
+const CURRENT_ROUTE = "/current";
+//#endregion
+//#region ../../core/po-core/src/schemas/httpApiContracts.ts
+const Text$3 = String$1();
+const Optional$2 = Optional$4;
+const Strings$1 = _Array_(Text$3);
+const Flag$2 = Boolean();
+const NumberValue$2 = Number$1();
+const ApiErrorSchema = _Object_({
+	error: Text$3,
+	hash: Optional$2(Text$3)
+});
+const ApiOkSchema = _Object_({ ok: Literal(true) });
+const Json$3 = Unknown({ description: "Value whose schema is supplied by the selected runtime contribution." });
+/** Common JSON response construction; status and payload remain explicit at the declaration. */
+function jsonApiResponses(schema, status = 200) {
+	return {
+		[status]: {
+			description: "Successful response",
+			contentType: "application/json",
+			schema
+		},
+		"400": {
+			description: "Invalid request",
+			schema: ApiErrorSchema
+		},
+		"401": {
+			description: "Authentication required",
+			schema: ApiErrorSchema
+		},
+		"403": {
+			description: "Request is not authorized",
+			schema: ApiErrorSchema
+		},
+		"404": {
+			description: "Resource or capability unavailable",
+			schema: ApiErrorSchema
+		},
+		"409": {
+			description: "Conflicting state",
+			schema: ApiErrorSchema
+		},
+		"422": {
+			description: "Invalid operation",
+			schema: ApiErrorSchema
+		},
+		"500": {
+			description: "Host operation failed",
+			schema: ApiErrorSchema
+		},
+		"502": {
+			description: "Provider failed",
+			schema: ApiErrorSchema
+		},
+		"503": {
+			description: "Service unavailable",
+			schema: ApiErrorSchema
+		}
+	};
+}
+const WebCompositionSchema = _Object_({
+	id: Text$3,
+	scope: Union([
+		Literal("global"),
+		Literal("workspace"),
+		Literal("session")
+	]),
+	revision: NumberValue$2,
+	manifestUrl: Text$3,
+	rawAssetBaseUrl: Text$3,
+	verifiedAssetBaseUrl: Text$3,
+	pluginEntries: _Array_(Tuple([Text$3, Text$3])),
+	assetPaths: Strings$1,
+	stylePaths: Strings$1,
+	channels: Strings$1
+});
+const NativeCompositionSchema = _Object_({
+	id: Text$3,
+	scope: Union([
+		Literal("global"),
+		Literal("workspace"),
+		Literal("session")
+	]),
+	revision: NumberValue$2,
+	manifestUrl: Text$3,
+	rawAssetBaseUrl: Text$3,
+	pluginEntries: _Array_(Tuple([Text$3, Text$3])),
+	uiEntry: Optional$2(Text$3),
+	channels: Strings$1,
+	plugins: Strings$1
+});
+/** A configured template id and the mount whose compositions offer it. */
+const TemplateDecisionSchema = _Object_({
+	id: Optional$2(Text$3),
+	mount: Union([_Object_({ scope: Literal("global") }), _Object_({
+		scope: Literal("workspace"),
+		workspaceId: Text$3
+	})])
+});
+const SessionSummarySchema = _Object_({
+	id: Text$3,
+	workspaceId: Optional$2(Text$3),
+	webComposition: Optional$2(WebCompositionSchema),
+	nativeComposition: Optional$2(NativeCompositionSchema),
+	name: Text$3,
+	cwd: Text$3,
+	createdAt: Text$3,
+	updatedAt: Text$3,
+	phase: Union([
+		Literal("idle"),
+		Literal("turn"),
+		Literal("compaction"),
+		Literal("retry")
+	]),
+	phaseSince: Text$3,
+	attach: Literal("attached"),
+	pendingMessageCount: NumberValue$2,
+	everPrompted: Flag$2,
+	awaitingInput: Flag$2,
+	lastSettledAt: Optional$2(Text$3),
+	git: Optional$2(_Object_({
+		branch: Text$3,
+		dirty: Flag$2
+	})),
+	profile: Optional$2(_Object_({
+		name: Text$3,
+		displayName: Optional$2(Text$3),
+		iconVersion: Optional$2(Text$3)
+	})),
+	parentSessionId: Optional$2(Text$3),
+	sessionProvenance: Optional$2(Text$3),
+	interaction: Optional$2(Union([Literal("interactive"), Literal("unattended")])),
+	/** The line the session's extension published about background work it runs. */
+	activity: Optional$2(_Object_({
+		label: Text$3,
+		attention: Optional$2(Flag$2),
+		since: Optional$2(Text$3)
+	})),
+	/** Tool calls waiting for the person's approval. */
+	pendingApprovalCount: Optional$2(Integer({ minimum: 1 })),
+	pendingSetups: Optional$2(_Array_(_Object_({
+		id: Text$3,
+		name: Text$3,
+		createdAt: Text$3,
+		cwd: Optional$2(Text$3),
+		setupKind: Optional$2(Union([Literal("managed-worktree"), Literal("existing-directory")])),
+		status: Optional$2(Union([
+			Literal("provisioning"),
+			Literal("failed"),
+			Literal("interrupted")
+		])),
+		errorCode: Optional$2(Union([Literal("SESSION_WORKTREE_PROVISION_FAILED"), Literal("SESSION_UNAVAILABLE")]))
+	}))),
+	groups: Optional$2(Strings$1),
+	backgroundWorkActive: Optional$2(Flag$2),
+	/** Present and true for a recorded session the server has not reopened yet. */
+	dormant: Optional$2(Flag$2)
+});
+const WorkspaceSchema = _Object_({
+	kind: Optional$2(Literal("session")),
+	instructions: Optional$2(Text$3),
+	id: Text$3,
+	root: Text$3,
+	name: Optional$2(Text$3),
+	available: Optional$2(Flag$2),
+	sandbox: Optional$2(Text$3),
+	/**
+	* The sandbox's state, live: `starting` while it starts or sessions move in, `running` once the host is linked,
+	* `stopping` while it is switched off, `failed` when a start or a switch failed, `unavailable` when its provider
+	* cannot run it. On a workspace without `sandbox`, `unavailable` means the sandbox provider cannot run it now, so
+	* it cannot be switched on; absent means nothing stands in the way.
+	*/
+	sandboxState: Optional$2(Union([
+		Literal("starting"),
+		Literal("running"),
+		Literal("stopping"),
+		Literal("unavailable"),
+		Literal("failed")
+	])),
+	/** A plain sentence for `failed` or `unavailable`, such as 'Docker is not running.'. */
+	sandboxReason: Optional$2(Text$3)
+});
+const SavedSession = _Object_({
+	id: Text$3,
+	name: Optional$2(Text$3),
+	firstMessage: Text$3,
+	createdAt: Text$3,
+	updatedAt: Text$3
+});
+const query = (name, schema = Text$3, required = false) => ({
+	name,
+	in: "query",
+	required,
+	schema
+});
+const body = (schema) => ({
+	contentType: "application/json",
+	required: true,
+	schema
+});
+const host = (id, path, method, result, extra = {}) => ({
+	id,
+	path,
+	method,
+	scope: "global",
+	authentication: "owner",
+	description: id,
+	responses: jsonApiResponses(result),
+	...extra
+});
+const Principal = _Object_({
+	issuer: Text$3,
+	subject: Text$3
+});
+const ProviderGrant = _Object_({
+	tag: Literal("po/grant/v1"),
+	signature: Text$3,
+	payload: _Object_({
+		issuer: Text$3,
+		subject: Text$3,
+		grantId: Text$3,
+		deviceKeyId: Text$3,
+		networkId: Text$3,
+		workspaceId: Text$3,
+		callingHostId: Text$3,
+		targetHostId: Text$3,
+		operations: Strings$1,
+		constraints: Record(Text$3, Union([
+			Text$3,
+			NumberValue$2,
+			Flag$2,
+			Null()
+		])),
+		issuedAt: NumberValue$2,
+		notBefore: NumberValue$2,
+		expiresAt: NumberValue$2,
+		redelegable: Literal(false),
+		revocationEpoch: Optional$2(NumberValue$2)
+	})
+});
+const ProviderConsent = _Object_({
+	workspaceId: Text$3,
+	providerHostId: Text$3,
+	packageName: Text$3,
+	owner: Principal,
+	grants: _Array_(ProviderGrant, {
+		minItems: 2,
+		maxItems: 2
+	}),
+	createdAt: NumberValue$2,
+	expiresAt: NumberValue$2
+});
+const ConsentCandidate = _Object_({
+	hostId: Text$3,
+	packageName: Text$3,
+	version: Text$3,
+	operations: Strings$1,
+	manifestExpiresAt: NumberValue$2
+});
+const ConsentWorkspaceParameter = {
+	name: "workspaceId",
+	in: "path",
+	required: true,
+	schema: Text$3
+};
+const Binary = String$1({ contentEncoding: "binary" });
+const headlessHttpContracts = [
+	host("health", "/api/health", "GET", _Object_({
+		ok: Literal(true),
+		role: Literal("hub"),
+		protocol: Literal(1),
+		sessions: NumberValue$2
+	}), { authentication: "none" }),
+	host("telemetry.browser", "/api/telemetry/browser", "POST", ApiOkSchema, { body: body(_Object_({
+		v: Literal(1),
+		events: _Array_(_Object_({
+			name: String$1({ pattern: "^web\\.browser\\.[a-z_]{1,40}$" }),
+			duration_ms: Optional$2(NumberValue$2),
+			count: Optional$2(NumberValue$2),
+			level: Optional$2(Literal("warn")),
+			attributes: Optional$2(Record(String$1({ pattern: "^[a-z_]{1,32}$" }), Union([String$1({ maxLength: 256 }), NumberValue$2]), { maxProperties: 12 }))
+		}), { maxItems: 10 })
+	})) }),
+	host("compositions", "/api/compositions", "GET", _Object_({
+		network: Optional$2(_Object_({
+			hostId: Text$3,
+			networkId: Text$3,
+			enrollmentGeneration: Optional$2(NumberValue$2)
+		})),
+		/** The computer's own name, which phones show instead of a tunnel address. */
+		displayName: Optional$2(Text$3),
+		global: Optional$2(WebCompositionSchema),
+		nativeGlobal: Optional$2(NativeCompositionSchema),
+		publicKey: Optional$2(Text$3),
+		shell: Optional$2(_Object_({
+			publicKey: Text$3,
+			revision: NumberValue$2
+		})),
+		template: Optional$2(TemplateDecisionSchema),
+		/** The phone app's `native.template` choice, resolved the same way. */
+		nativeTemplate: Optional$2(TemplateDecisionSchema),
+		workspaces: _Array_(_Object_({
+			id: Text$3,
+			root: Text$3,
+			/** `null` for a sandboxed workspace: its plugins run in its sandbox, the host has none for it. */
+			webComposition: Optional$2(Union([WebCompositionSchema, Null()])),
+			nativeComposition: Optional$2(Union([NativeCompositionSchema, Null()])),
+			providers: Optional$2(_Array_(_Object_({
+				hostId: Text$3,
+				packageName: Text$3,
+				version: Text$3,
+				operations: _Array_(_Object_({
+					scope: Union([
+						Literal("global"),
+						Literal("workspace"),
+						Literal("session")
+					]),
+					names: Strings$1
+				})),
+				provenance: Union([
+					Literal("local"),
+					Literal("own"),
+					Literal("consented")
+				]),
+				status: Union([Literal("available"), Literal("unavailable")]),
+				reason: Optional$2(Union([
+					Literal("manifest-missing"),
+					Literal("manifest-expired"),
+					Literal("roster-stale"),
+					Literal("host-removed"),
+					Literal("consent-expired")
+				])),
+				expiresAt: Optional$2(NumberValue$2)
+			})))
+		}))
+	})),
+	host("network.voters.propose", "/api/network/voters", "POST", Json$3, { body: body(_Object_({
+		change: Union([_Object_({
+			network: Text$3,
+			epoch: NumberValue$2,
+			kind: Literal("add"),
+			added: Text$3,
+			addedKey: Text$3
+		}), _Object_({
+			network: Text$3,
+			epoch: NumberValue$2,
+			kind: Literal("evict"),
+			removed: Text$3
+		})]),
+		authorization: Text$3
+	})) }),
+	host("network.consents.list", "/api/network/workspaces/{workspaceId}/consents", "GET", _Object_({
+		consents: _Array_(ProviderConsent),
+		candidates: _Array_(ConsentCandidate)
+	}), { parameters: [ConsentWorkspaceParameter] }),
+	host("network.consents.approve", "/api/network/workspaces/{workspaceId}/consents", "POST", ProviderConsent, {
+		parameters: [ConsentWorkspaceParameter],
+		body: body(_Object_({
+			providerHostId: Text$3,
+			packageName: Text$3,
+			grants: _Array_(ProviderGrant, {
+				minItems: 2,
+				maxItems: 2
+			})
+		})),
+		responses: jsonApiResponses(ProviderConsent, 201)
+	}),
+	host("network.consents.revoke", "/api/network/workspaces/{workspaceId}/consents/{providerHostId}/{packageName}", "DELETE", Null(), {
+		parameters: [
+			ConsentWorkspaceParameter,
+			{
+				name: "providerHostId",
+				in: "path",
+				required: true,
+				schema: Text$3
+			},
+			{
+				name: "packageName",
+				in: "path",
+				required: true,
+				schema: Text$3
+			}
+		],
+		responses: { "204": { description: "Provider consent revoked" } }
+	}),
+	host("directories", "/api/directories", "GET", _Object_({ directories: Strings$1 }), { parameters: [query("q")] }),
+	host("directories.children", "/api/directories/children", "GET", _Object_({
+		path: Text$3,
+		parent: Optional$2(Text$3),
+		directories: Strings$1
+	}), { parameters: [query("path")] }),
+	host("directories.workspaces", "/api/directories/workspaces", "GET", _Object_({
+		root: Text$3,
+		declarations: _Array_(_Object_({
+			name: Text$3,
+			instructions: Optional$2(Text$3),
+			workspaceId: Optional$2(Text$3)
+		}))
+	}), {
+		parameters: [query("path")],
+		availability: "Host provides declaredWorkspaces"
+	}),
+	host("directories.po", "/api/directories/po", "GET", _Object_({ directories: Strings$1 })),
+	host("sessions.list", "/api/workspaces/{workspaceId}/sessions", "GET", _Object_({ sessions: _Array_(SessionSummarySchema) })),
+	host("sessions.create", "/api/workspaces/{workspaceId}/sessions", "POST", _Object_({ sessionId: Text$3 }), {
+		body: body(_Object_({ name: Optional$2(Text$3) })),
+		responses: jsonApiResponses(_Object_({ sessionId: Text$3 }), 201)
+	}),
+	host("sessions.createGeneral", "/api/sessions", "POST", _Object_({
+		sessionId: Text$3,
+		workspace: Optional$2(WorkspaceSchema),
+		session: Optional$2(SessionSummarySchema)
+	}), {
+		body: body(_Object_({
+			name: Optional$2(Text$3),
+			cwd: Optional$2(String$1({ minLength: 1 }))
+		})),
+		availability: "Host provides createGeneralSession when cwd is omitted; explicit cwd remains supported for compatibility",
+		responses: jsonApiResponses(_Object_({
+			sessionId: Text$3,
+			workspace: Optional$2(WorkspaceSchema),
+			session: Optional$2(SessionSummarySchema)
+		}), 201)
+	}),
+	host("sessions.get", "/api/workspaces/{workspaceId}/sessions/{sessionId}", "GET", SessionSummarySchema),
+	host("sessions.delete", "/api/workspaces/{workspaceId}/sessions/{sessionId}", "DELETE", ApiOkSchema),
+	host("sessions.history", "/api/workspaces/{workspaceId}/sessions/{sessionId}/history", "GET", _Object_({ sessions: _Array_(SavedSession) }), { availability: "Host provides sessionHistory" }),
+	host("sessions.restart", "/api/workspaces/{workspaceId}/sessions/{sessionId}/restart", "POST", ApiOkSchema, { availability: "Host provides restartSession" }),
+	host("sessions.revive", "/api/workspaces/{workspaceId}/sessions/{sessionId}/revive", "POST", ApiOkSchema, { availability: "Host provides reviveSession" }),
+	host("sessions.resume", "/api/workspaces/{workspaceId}/sessions/{sessionId}/resume", "POST", _Object_({ sessionId: Text$3 }), {
+		availability: "Host provides resumeSession",
+		body: body(_Object_({ targetSessionId: String$1({ pattern: "^[A-Za-z0-9_-]+$" }) }))
+	}),
+	host("sessions.file", "/api/workspaces/{workspaceId}/sessions/{sessionId}/file", "GET", Binary, {
+		parameters: [query("path", Text$3, true)],
+		responses: {
+			...jsonApiResponses(Binary),
+			"200": {
+				description: "File bytes, MIME type follows the file extension",
+				contentType: "*/*",
+				schema: Binary
+			}
+		}
+	}),
+	host("workspaces.list", "/api/workspaces", "GET", _Object_({ workspaces: _Array_(WorkspaceSchema) })),
+	host("workspaces.admit", "/api/workspaces", "POST", _Object_({ workspace: WorkspaceSchema }), {
+		body: body(_Object_({
+			root: Optional$2(Text$3),
+			name: Optional$2(Text$3),
+			declaration: Optional$2(Text$3),
+			instructions: Optional$2(Text$3)
+		})),
+		responses: jsonApiResponses(_Object_({ workspace: WorkspaceSchema }), 201)
+	}),
+	host("workspaces.get", "/api/workspaces/{workspaceId}", "GET", _Object_({ workspace: WorkspaceSchema })),
+	host("workspaces.history", "/api/workspaces/{workspaceId}/history", "GET", _Object_({ sessions: _Array_(SavedSession) }), { availability: "Host provides workspaceHistory" }),
+	host("workspaces.resume", "/api/workspaces/{workspaceId}/resume", "POST", _Object_({ sessionId: Text$3 }), {
+		availability: "Host provides resumeWorkspaceSession",
+		body: body(_Object_({ targetSessionId: String$1({ pattern: "^[A-Za-z0-9_-]+$" }) }))
+	}),
+	host("workspaces.removed", "/api/workspaces/{workspaceId}/removed", "GET", _Object_({ sessions: _Array_(Intersect([SavedSession, _Object_({
+		removedAt: Text$3,
+		purgeAt: Text$3
+	})])) }), { availability: "Host provides removedSessions" }),
+	host("workspaces.restoreRemoved", "/api/workspaces/{workspaceId}/removed/{sessionId}/restore", "POST", ApiOkSchema, { availability: "Host provides restoreRemovedSession" }),
+	host("workspaces.setSandbox", "/api/workspaces/{workspaceId}", "PATCH", _Object_({ workspace: WorkspaceSchema }), {
+		availability: "Host provides setWorkspaceSandbox or setWorkspaceInstructions",
+		body: body(Union([_Object_({ sandbox: Union([Text$3, Null()]) }, { additionalProperties: false }), _Object_({ instructions: Text$3 }, { additionalProperties: false })]))
+	}),
+	host("workspaces.remove", "/api/workspaces/{workspaceId}", "DELETE", ApiOkSchema)
+];
+const AuthType = Union([Literal("api_key"), Literal("oauth")]);
+const Provider = _Object_({
+	id: Text$3,
+	name: Text$3,
+	methods: _Array_(_Object_({
+		type: AuthType,
+		label: Text$3
+	})),
+	authenticated: Optional$2(_Object_({
+		type: AuthType,
+		source: Optional$2(Text$3)
+	}))
+});
+const LoginEvent = Union([
+	_Object_({
+		type: Literal("info"),
+		message: Text$3,
+		links: Optional$2(_Array_(_Object_({
+			url: Text$3,
+			label: Optional$2(Text$3)
+		})))
+	}),
+	_Object_({
+		type: Literal("auth_url"),
+		url: Text$3,
+		instructions: Optional$2(Text$3)
+	}),
+	_Object_({
+		type: Literal("device_code"),
+		userCode: Text$3,
+		verificationUri: Text$3,
+		intervalSeconds: Optional$2(NumberValue$2),
+		expiresInSeconds: Optional$2(NumberValue$2)
+	}),
+	_Object_({
+		type: Literal("progress"),
+		message: Text$3
+	})
+]);
+const LoginFlowSchema = _Object_({
+	id: Text$3,
+	providerId: Text$3,
+	providerName: Text$3,
+	type: AuthType,
+	status: Union([
+		Literal("running"),
+		Literal("succeeded"),
+		Literal("failed"),
+		Literal("cancelled")
+	]),
+	events: _Array_(LoginEvent),
+	prompt: Optional$2(_Object_({
+		id: Text$3,
+		type: Union([
+			Literal("text"),
+			Literal("secret"),
+			Literal("select"),
+			Literal("manual_code")
+		]),
+		message: Text$3,
+		placeholder: Optional$2(Text$3),
+		options: Optional$2(_Array_(_Object_({
+			id: Text$3,
+			label: Text$3,
+			description: Optional$2(Text$3)
+		})))
+	})),
+	remote: Optional$2(Flag$2),
+	error: Optional$2(Text$3)
+});
+const Flow = _Object_({ flow: LoginFlowSchema });
+const machineHttpContracts = [
+	host("providers.list", "/providers", "GET", _Object_({ providers: _Array_(Provider) })),
+	host("models.list", "/models", "GET", _Object_({ models: _Array_(_Object_({
+		value: Text$3,
+		label: Text$3,
+		group: Text$3
+	})) })),
+	host("providers.logout", "/providers/{providerId}", "DELETE", ApiOkSchema),
+	host("logins.create", "/logins", "POST", Flow, {
+		body: body(_Object_({
+			providerId: Text$3,
+			type: AuthType
+		})),
+		responses: jsonApiResponses(Flow, 201)
+	}),
+	host("logins.get", "/logins/{flowId}", "GET", Flow),
+	host("logins.cancel", "/logins/{flowId}", "DELETE", Flow),
+	host("logins.answer", "/logins/{flowId}/answer", "POST", Flow, { body: body(_Object_({
+		promptId: Text$3,
+		value: Text$3
+	})) })
+].map((route) => ({
+	...route,
+	basePath: "po"
+}));
+const Source = Union([
+	Literal("extension"),
+	Literal("mcp"),
+	Literal("plugin"),
+	Literal("core")
+]);
+const Detail = Union([
+	_Object_({
+		itemKind: Literal("tool"),
+		name: Text$3,
+		owner: Text$3,
+		source: Source,
+		active: Flag$2,
+		tokens: _Object_({
+			schemaTokens: NumberValue$2,
+			promptTokens: NumberValue$2,
+			totalTokens: NumberValue$2
+		}),
+		description: Optional$2(Text$3),
+		promptSnippet: Optional$2(Text$3),
+		promptGuidelines: Optional$2(Strings$1),
+		parameters: Optional$2(Json$3)
+	}),
+	_Object_({
+		itemKind: Literal("skill"),
+		name: Text$3,
+		owner: Text$3,
+		source: Source,
+		active: Literal(true),
+		tokens: NumberValue$2,
+		description: Text$3,
+		filePath: Optional$2(Text$3),
+		modelInvocable: Flag$2
+	}),
+	_Object_({
+		itemKind: Literal("prompt"),
+		name: Literal("system"),
+		tokens: NumberValue$2,
+		stage: Union([Literal("base"), Literal("effective")]),
+		text: Text$3
+	})
+]);
+const sessionHttpContracts = [
+	{
+		...host("context.current", CURRENT_ROUTE, "GET", _Object_({
+			version: Literal(1),
+			revision: NumberValue$2,
+			selection: _Object_({
+				majorMode: Text$3,
+				domains: Strings$1,
+				profile: Optional$2(Text$3)
+			}),
+			groups: _Array_(_Object_({
+				id: Text$3,
+				label: Text$3,
+				kind: Union([
+					Literal("major"),
+					Literal("minor"),
+					Literal("domain"),
+					Literal("shared"),
+					Literal("core")
+				]),
+				items: _Array_(_Object_({
+					name: Text$3,
+					itemKind: Union([Literal("tool"), Literal("skill")]),
+					source: Source,
+					owner: Text$3,
+					tokens: NumberValue$2,
+					active: Flag$2
+				})),
+				tokens: NumberValue$2,
+				inactiveTokens: NumberValue$2
+			})),
+			totalTokens: NumberValue$2,
+			inactiveTokens: NumberValue$2,
+			systemPrompt: Optional$2(_Object_({
+				tokens: NumberValue$2,
+				stage: Union([Literal("base"), Literal("effective")])
+			})),
+			estimator: Literal("gpt-tokenizer")
+		})),
+		scope: "session",
+		basePath: API_BASE_PATH
+	},
+	{
+		...host("context.item", ITEM_ROUTE, "GET", _Object_({
+			revision: NumberValue$2,
+			item: Detail
+		}), { parameters: [query("kind", Union([
+			Literal("tool"),
+			Literal("skill"),
+			Literal("prompt")
+		]), true), query("name", Text$3, true)] }),
+		scope: "session",
+		basePath: API_BASE_PATH
+	},
+	{
+		...host("files.complete", "/", "GET", _Object_({ files: Strings$1 }), { parameters: [query("q", String$1({ maxLength: 256 }))] }),
+		scope: "session",
+		basePath: "files"
+	}
+];
+//#endregion
+//#region ../../core/po-core/src/schemas/protocolHubContract.ts
+const Text$2 = String$1();
+const Json$2 = Unsafe({});
+/** A live session frame every hub client needs (notification entries and agent dialogs) until it is acknowledged. */
+const HubNoticeSchema = _Object_({
+	id: Text$2,
+	sessionId: Text$2,
+	frame: Record(Text$2, Json$2)
+});
+/** Native UI delivery metadata is HTTP-only; adding it must not refuse existing po.hub@1 clients. */
+const HubSessionSchema = _Object_({
+	...SessionSummarySchema.properties,
+	nativeComposition: Optional$4(Omit(NativeCompositionSchema, ["uiEntry"]))
+});
+/** Instructions are HTTP-only so existing po.hub@1 clients keep the same wire contract. */
+const HubWorkspaceSchema = Omit(WorkspaceSchema, ["instructions"]);
+/** Per shared mount (`global`, `workspace:<id>`), a counter that rises when its plugin composition changes. */
+const HubCompositionsSchema = Record(Text$2, Integer({ minimum: 0 }));
+const HubState = {
+	sessions: Record(Text$2, HubSessionSchema),
+	workspaces: Record(Text$2, HubWorkspaceSchema),
+	pending: _Array_(HubNoticeSchema),
+	compositions: HubCompositionsSchema
+};
+const PoHubStateSchema = _Object_(HubState);
+/** What one connection may see: its sessions, its workspaces, and the notices it has not acknowledged. */
+const PoHubContract = remote("po.hub", {
+	version: 1,
+	host: hostNamed(PO_SERVER_HOST),
+	input: chordSchema(_Object_({})),
+	variants: { default: {
+		state: chordStates(HubState),
+		methods: chordMethods({
+			readHome: {
+				args: _Object_({
+					offset: Optional$4(Integer({ minimum: 0 })),
+					limit: Optional$4(Integer({ minimum: 1 })),
+					source: Optional$4(Text$2),
+					workspaceId: Optional$4(Text$2)
+				}),
+				result: Unsafe({})
+			},
+			invoke: {
+				args: PoPluginCallSchema,
+				result: Json$2
+			},
+			ackNotice: { args: _Object_({ id: Text$2 }) }
+		})
+	} }
+});
+/**
+* Per topic (`global:<name>`, `workspace:<id>:<name>`), a counter the host raises when that data changes, so a
+* client fetches it again instead of polling. A separate contract: a host without it leaves clients on
+* fetch-on-open rather than refusing the whole hub as out of date.
+*/
+const HubRevisionsSchema = Record(Text$2, Integer({ minimum: 0 }));
+const PoHubRevisionsContract = remote("po.hub.revisions", {
+	version: 1,
+	host: hostNamed(PO_SERVER_HOST),
+	input: chordSchema(_Object_({})),
+	variants: { default: {
+		state: chordStates({ revisions: HubRevisionsSchema }),
+		methods: chordMethods({})
+	} }
+});
+//#endregion
+//#region ../../core/po-core/src/schemas/protocolThreadContract.ts
+/** The thread's latest frame: `transcript_state` while its child runs, `transcript_ready` once it has finished. */
+const PoThreadFrameSchema = Union([Null(), Intersect([_Object_({ type: String$1() }), Record(String$1(), Unsafe({}))])]);
+/** One child thread of a session, followed only while someone holds it. */
+const PoThreadContract = remote("po.thread", {
+	version: 1,
+	host: hostNamed(PO_SERVER_HOST),
+	input: chordSchema(_Object_({
+		sessionId: String$1({ minLength: 1 }),
+		threadId: String$1({ minLength: 1 })
+	})),
+	variants: { default: { state: chordStates({ frame: PoThreadFrameSchema }) } }
+});
+//#endregion
+//#region ../../core/po-core/src/schemas/sessionApiContracts.ts
+const Text$1 = String$1();
+const NumberValue$1 = Number$1();
+const Flag$1 = Boolean();
+const Json$1 = Unsafe(Unknown({ description: "Strict JSON application value supplied by the active tool, journal entry, or extension; validated by the Pi codec." }));
+const Optional$1 = Optional$4;
+const Strings = _Array_(Text$1);
+const Model = _Object_({
+	provider: Text$1,
+	id: Text$1
+});
+const Thinking = Union([
+	Literal("off"),
+	Literal("minimal"),
+	Literal("low"),
+	Literal("medium"),
+	Literal("high"),
+	Literal("max"),
+	Literal("xhigh")
+]);
+const Phase = Union([
+	Literal("idle"),
+	Literal("turn"),
+	Literal("compaction"),
+	Literal("retry")
+]);
+const Image = _Object_({
+	type: Literal("image"),
+	data: Text$1,
+	mimeType: Text$1
+});
+const TextPart = _Object_({
+	type: Literal("text"),
+	text: Text$1
+});
+const ThinkingPart = _Object_({
+	type: Literal("thinking"),
+	thinking: Text$1,
+	redacted: Optional$1(Literal(true))
+});
+const Content = Union([Image, TextPart]);
+const Usage = _Object_({
+	input: NumberValue$1,
+	output: NumberValue$1,
+	cacheRead: NumberValue$1,
+	cacheWrite: NumberValue$1,
+	total: NumberValue$1
+});
+const Message = _Object_({
+	text: Text$1,
+	images: Optional$1(_Array_(Image))
+});
+const Lifecycle = _Object_({
+	revision: NumberValue$1,
+	operation: Union([Null(), _Object_({
+		id: Text$1,
+		kind: Union([
+			Literal("run"),
+			Literal("compaction"),
+			Literal("navigation")
+		]),
+		status: Union([Literal("open"), Literal("aborting")])
+	})]),
+	paused: Flag$1,
+	queue: _Array_(_Object_({
+		id: Text$1,
+		text: Text$1,
+		images: Optional$1(_Array_(Image)),
+		delivery: Union([
+			Literal("steer"),
+			Literal("followUp"),
+			Literal("nextRun")
+		]),
+		scheduling: Union([Literal("automatic"), Literal("held")]),
+		disposition: Union([Literal("pending"), Literal("handoff")])
+	}))
+});
+const Frame = Intersect([_Object_({ type: Text$1 }), Record(Text$1, Json$1)], { description: "Discriminated extension presentation frame; selected channel schemas describe package payloads." });
+const ProtocolEvent = _Object_({
+	sequence: NumberValue$1,
+	frame: Frame
+});
+const SessionServiceStateSchema = _Object_({
+	snapshot: _Object_({
+		fastMode: Flag$1,
+		locked: Flag$1,
+		lifecycle: Optional$1(Lifecycle)
+	}),
+	presentation: Optional$1(_Object_({
+		revision: NumberValue$1,
+		dropped: NumberValue$1,
+		resetRevision: Optional$1(NumberValue$1),
+		events: _Array_(ProtocolEvent),
+		projections: _Array_(ProtocolEvent)
+	})),
+	live: Optional$1(_Object_({
+		phase: Phase,
+		message: Optional$1(_Object_({
+			role: Literal("assistant"),
+			content: _Array_(Union([TextPart, ThinkingPart])),
+			model: Text$1,
+			timestamp: NumberValue$1
+		})),
+		tools: Record(Text$1, _Object_({
+			toolCallId: Text$1,
+			toolName: Text$1,
+			args: Json$1,
+			partialResult: Optional$1(_Object_({
+				content: _Array_(Content),
+				details: Optional$1(Json$1)
+			}))
+		}))
+	}))
+});
+/** Argument and result schemas of the `po.session` methods; the Chord contract and the API docs both read them. */
+const SessionMethodSchemas = {
+	readTranscriptPage: {
+		args: _Object_({
+			cursor: Optional$1(Text$1),
+			direction: Optional$1(Union([Literal("older"), Literal("newer")])),
+			limit: Optional$1(NumberValue$1),
+			threadId: Optional$1(Text$1),
+			entryId: Optional$1(Text$1)
+		}),
+		result: _Object_({
+			entries: _Array_(Json$1),
+			startCursor: Union([Text$1, Null()]),
+			endCursor: Union([Text$1, Null()]),
+			olderCursor: Union([Text$1, Null()]),
+			newerCursor: Union([Text$1, Null()]),
+			generation: NumberValue$1,
+			revision: NumberValue$1,
+			context: _Array_(Json$1)
+		})
+	},
+	prompt: { args: Union([Text$1, _Object_({
+		...Message.properties,
+		waitFor: Optional$1(Union([Literal("accepted"), Literal("settled")]))
+	})]) },
+	steer: { args: Union([Text$1, Message]) },
+	abort: {},
+	abortOperation: { args: _Object_({ operationId: Text$1 }) },
+	setModel: { args: Model },
+	setThinking: { args: Thinking },
+	setFastMode: { args: Flag$1 },
+	setAgentLock: { args: Flag$1 },
+	followUp: { args: Message },
+	enqueueAutomatic: {
+		args: Message,
+		result: _Object_({ id: Text$1 })
+	},
+	removeQueued: {
+		args: _Object_({ id: Text$1 }),
+		result: Union([
+			Literal("removed"),
+			Literal("in_flight"),
+			Literal("already_consumed"),
+			Literal("not_found")
+		])
+	},
+	promoteQueued: {
+		args: _Object_({
+			id: Text$1,
+			operationId: Optional$1(Text$1)
+		}),
+		result: Union([
+			Literal("promoted"),
+			Literal("in_flight"),
+			Literal("target_changed"),
+			Literal("not_found")
+		])
+	},
+	resumeQueue: {},
+	clearQueue: { result: _Object_({
+		steering: Strings,
+		followUp: Strings
+	}) },
+	rewind: {
+		args: _Object_({
+			itemId: Text$1,
+			summarize: Optional$1(Flag$1),
+			customInstructions: Optional$1(Text$1),
+			replaceInstructions: Optional$1(Flag$1),
+			label: Optional$1(Text$1)
+		}),
+		result: _Object_({
+			editorText: Optional$1(Text$1),
+			cancelled: Flag$1,
+			aborted: Optional$1(Flag$1),
+			summaryEntry: Optional$1(_Object_({
+				id: Text$1,
+				parentId: Union([Text$1, Null()]),
+				timestamp: Text$1,
+				fromId: Text$1,
+				summary: Text$1,
+				details: Optional$1(Json$1),
+				usage: Optional$1(Usage),
+				fromHook: Optional$1(Flag$1)
+			}))
+		})
+	},
+	extensionUiResponse: { args: Union([
+		_Object_({
+			id: Text$1,
+			value: Text$1
+		}),
+		_Object_({
+			id: Text$1,
+			confirmed: Flag$1
+		}),
+		_Object_({
+			id: Text$1,
+			cancelled: Literal(true)
+		})
+	]) },
+	getState: { result: _Object_({
+		model: Optional$1(Model),
+		thinkingLevel: Thinking,
+		fastMode: Flag$1,
+		agentLocked: Optional$1(Flag$1),
+		isStreaming: Flag$1,
+		isCompacting: Flag$1,
+		steeringMode: Union([Literal("all"), Literal("one-at-a-time")]),
+		followUpMode: Union([Literal("all"), Literal("one-at-a-time")]),
+		sessionId: Text$1,
+		sessionName: Optional$1(Text$1),
+		autoCompactionEnabled: Flag$1,
+		messageCount: NumberValue$1,
+		pendingMessageCount: NumberValue$1,
+		operationId: Optional$1(Text$1),
+		executionStatus: Optional$1(Union([Literal("open"), Literal("aborting")])),
+		queuePaused: Optional$1(Flag$1),
+		queueRevision: Optional$1(NumberValue$1)
+	}) },
+	getSessionStats: { result: _Object_({
+		sessionId: Text$1,
+		totalMessages: NumberValue$1,
+		tokens: Usage,
+		cost: NumberValue$1,
+		contextUsage: Optional$1(_Object_({
+			tokens: Union([NumberValue$1, Null()]),
+			contextWindow: NumberValue$1,
+			percent: Union([NumberValue$1, Null()])
+		}))
+	}) },
+	getCommands: { result: _Array_(_Object_({
+		name: Text$1,
+		description: Optional$1(Text$1),
+		source: Union([
+			Literal("extension"),
+			Literal("prompt"),
+			Literal("skill")
+		]),
+		sourceInfo: Optional$1(_Object_({
+			path: Text$1,
+			source: Text$1,
+			scope: Union([
+				Literal("user"),
+				Literal("project"),
+				Literal("temporary")
+			]),
+			origin: Union([Literal("package"), Literal("top-level")]),
+			baseDir: Optional$1(Text$1)
+		}))
+	})) },
+	getAvailableModels: { result: _Array_(Model) },
+	getAvailableThinkingLevels: { result: _Array_(Thinking) },
+	compact: {
+		args: _Object_({ customInstructions: Optional$1(Text$1) }),
+		result: Json$1
+	},
+	setName: { args: Text$1 },
+	setGroups: { args: _Array_(Text$1) }
+};
+/** The `po.session` methods as Chord specs. */
+const SessionMethods = chordMethods(SessionMethodSchemas);
+const ErrorSchema = _Object_({
+	code: Text$1,
+	message: Text$1
+});
+const documented = (id, service, member, direction, input, description) => ({
+	id,
+	scope: service === "po.hub" ? "global" : "session",
+	service,
+	member,
+	direction,
+	kind: direction === "server-to-client" ? "state" : "method",
+	input,
+	...direction === "server-to-client" ? {} : { errors: ErrorSchema },
+	description
+});
+const sessionSocketContracts = [
+	...Object.entries(SessionMethodSchemas).map(([member, { args, result }]) => ({
+		id: `session.${member}`,
+		scope: "session",
+		service: "po.session",
+		member,
+		direction: "client-to-server",
+		kind: "method",
+		description: `Session ${member}. The Chord call carries the argument; a void result is null.`,
+		input: Tuple(args === void 0 ? [] : [args]),
+		...result === void 0 ? {} : { output: result },
+		errors: ErrorSchema
+	})),
+	documented("session.state", "po.session", "state", "server-to-client", SessionServiceStateSchema, "The `state` member of `po.session`, reconstructed from Chord snapshot and delta frames."),
+	documented("hub.state", "po.hub", "state", "server-to-client", PoHubStateSchema, "Sessions and workspaces this connection may see, and notices it has not acknowledged."),
+	documented("thread.frame", "po.thread", "frame", "server-to-client", PoThreadFrameSchema, "The latest frame of one child thread: transcript_state while it runs, transcript_ready once finished."),
+	documented("channels.latest", "po.channels", "latest", "server-to-client", PoChannelsStateSchema, "The latest payload of each extension channel frame type for one session."),
+	documented("channels.receive", "po.channels", "receive", "client-to-server", Tuple([ChannelFrameSchema]), "Send one extension channel frame to the session.")
+];
+const Schema = Unsafe(Union([Boolean(), Record(String$1(), Unknown())]));
+const Scope = Union([
+	Literal("global"),
+	Literal("workspace"),
+	Literal("session")
+]);
+const Named = String$1({ minLength: 1 });
+const ResponseSchema = _Object_({
+	description: Named,
+	contentType: Optional$4(Named),
+	schema: Optional$4(Schema),
+	events: Optional$4(Record(Named, Schema))
+});
+_Object_({
+	version: Literal(1),
+	protocols: Optional$4(Record(Named, Named)),
+	schemas: Optional$4(Record(Named, Schema)),
+	http: _Array_(_Object_({
+		id: Named,
+		scope: Scope,
+		/** Omit for host-owned absolute routes. */
+		basePath: Optional$4(String$1({ pattern: "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$" })),
+		path: String$1({ pattern: "^/" }),
+		method: Union([
+			Literal("GET"),
+			Literal("POST"),
+			Literal("PUT"),
+			Literal("PATCH"),
+			Literal("DELETE"),
+			Literal("HEAD"),
+			Literal("OPTIONS")
+		]),
+		description: Named,
+		availability: Optional$4(Named),
+		authentication: Union([
+			Literal("none"),
+			Literal("owner"),
+			Literal("device")
+		]),
+		parameters: Optional$4(_Array_(_Object_({
+			name: Named,
+			in: Union([
+				Literal("path"),
+				Literal("query"),
+				Literal("header")
+			]),
+			required: Boolean(),
+			schema: Schema
+		}))),
+		body: Optional$4(_Object_({
+			contentType: Named,
+			contentTypes: Optional$4(_Array_(Named, { minItems: 1 })),
+			required: Boolean(),
+			schema: Schema
+		})),
+		responses: Record(String$1({ pattern: "^(?:[1-5][0-9]{2}|default)$" }), ResponseSchema, { minProperties: 1 })
+	})),
+	sockets: _Array_(_Object_({
+		id: Named,
+		scope: Scope,
+		description: Named,
+		availability: Optional$4(Named),
+		service: Named,
+		member: Named,
+		direction: Union([Literal("client-to-server"), Literal("server-to-client")]),
+		kind: Union([
+			Literal("method"),
+			Literal("state"),
+			Literal("channel")
+		]),
+		input: Schema,
+		output: Optional$4(Schema),
+		errors: Optional$4(Schema)
+	})),
+	/** Explicitly enumerate dynamic values whose shape is supplied at runtime. */
+	dynamic: _Array_(String$1({ minLength: 1 })),
+	gaps: Optional$4(_Array_(Named))
+});
+function defineApiContract(contract) {
+	return contract;
+}
+//#endregion
+//#region ../../core/po-core/src/schemas/remoteApiContracts.ts
+const Text = String$1();
+const NumberValue = Number$1();
+const Optional = Optional$4;
+const Flag = Boolean();
+const JsonObject = Record(Text, Unknown({ description: "WebAuthn ceremony fields supplied and verified by the installed WebAuthn implementation." }));
+const Tunnel = Union([_Object_({ kind: Literal("quick") }), _Object_({
+	kind: Literal("named"),
+	hostname: Text,
+	name: Optional(Text),
+	tokenFile: Optional(Text),
+	configFile: Optional(Text)
+})]);
+const Settings = _Object_({
+	autoCloseEnabled: Flag,
+	autoCloseMinutes: NumberValue,
+	sessionExpiryEnabled: Flag,
+	idleMinutes: NumberValue,
+	absoluteHours: NumberValue,
+	tunnel: Tunnel
+});
+const State = _Object_({
+	status: Union([
+		Literal("off"),
+		Literal("starting"),
+		Literal("on"),
+		Literal("failed")
+	]),
+	publicUrl: Optional(Text),
+	startedAt: Optional(Text),
+	closesAt: Optional(Text),
+	error: Optional(Text),
+	devices: _Array_(_Object_({
+		id: Text,
+		label: Text,
+		userAgent: Text,
+		createdAt: Text,
+		lastSeenAt: Text,
+		self: Flag
+	})),
+	pending: _Array_(_Object_({
+		id: Text,
+		userAgent: Text,
+		edgeIp: Text,
+		createdAt: Text,
+		expiresAt: Text
+	})),
+	trustedDevices: _Array_(_Object_({
+		id: Text,
+		label: Text,
+		platform: Union([Literal("ios"), Literal("android")]),
+		createdAt: Text,
+		lastSeenAt: Text,
+		self: Flag
+	})),
+	settings: Settings
+});
+const StateResponse = _Object_({ state: State });
+const Trust = _Object_({
+	publicKey: Text,
+	fingerprint: Text,
+	revision: NumberValue
+});
+const Begun = _Object_({
+	ceremonyId: Text,
+	options: JsonObject
+});
+const DeviceKeyBegun = _Object_({
+	ceremonyId: Text,
+	challenge: Text,
+	kind: Literal("device-key")
+});
+const ChannelKeys = _Object_({
+	session: Text,
+	protocol: Text,
+	http: Text
+});
+const Finish = _Object_({
+	ceremonyId: Text,
+	response: JsonObject
+});
+const SealedEnvelopeSchema = _Object_({
+	v: Literal(1),
+	n: Text,
+	c: Text
+});
+_Object_({
+	v: Literal(1),
+	method: Text,
+	target: Text,
+	headers: _Array_(Tuple([Text, Text])),
+	body: Optional(Text)
+});
+_Object_({
+	v: Literal(1),
+	status: NumberValue,
+	headers: _Array_(Tuple([Text, Text])),
+	body: Text
+});
+const route = (id, path, method, result, input, extra = {}) => ({
+	id: `remote.${id}`,
+	path: `/api/remote${path}`,
+	method,
+	scope: "global",
+	authentication: "owner",
+	description: `Remote Control ${id}.`,
+	availability: "Global host provides Remote Control. Tunnel routes additionally enforce device, origin and step-up policy.",
+	responses: {
+		...jsonApiResponses(result),
+		"429": {
+			description: "Rate limit exceeded",
+			schema: ApiErrorSchema
+		}
+	},
+	...input ? { body: {
+		contentType: "application/json",
+		required: true,
+		schema: input
+	} } : {},
+	...extra
+});
+const direct = [
+	route("state", "", "GET", StateResponse),
+	route("enable", "/enable", "POST", StateResponse),
+	route("disable", "/disable", "POST", StateResponse, void 0, { responses: {
+		...jsonApiResponses(StateResponse),
+		"202": {
+			description: "Tunnel closing",
+			schema: _Object_({ status: Literal("closing") })
+		}
+	} }),
+	route("codes", "/codes", "POST", _Object_({
+		...Trust.properties,
+		code: Text,
+		manualCode: Text,
+		pairUrl: Text,
+		expiresAt: Text
+	}), void 0, { responses: jsonApiResponses(_Object_({
+		...Trust.properties,
+		code: Text,
+		manualCode: Text,
+		pairUrl: Text,
+		expiresAt: Text
+	}), 201) }),
+	route("approve", "/pairing/{id}/approve", "POST", StateResponse),
+	route("deny", "/pairing/{id}/deny", "POST", StateResponse),
+	route("revoke", "/devices/{id}", "DELETE", StateResponse),
+	route("settings", "/settings", "PUT", _Object_({ settings: Settings }), Partial(Settings)),
+	route("passkeys", "/passkeys", "GET", _Object_({
+		support: Union([_Object_({
+			supported: Literal(true),
+			rpId: Text
+		}), _Object_({
+			supported: Literal(false),
+			reason: Text
+		})]),
+		credentials: _Array_(_Object_({
+			id: Text,
+			label: Text,
+			createdAt: Text,
+			lastUsedAt: Text
+		}))
+	})),
+	route("passkeys.remove", "/passkeys/{id}", "DELETE", ApiOkSchema),
+	route("register.begin", "/passkeys/register/begin", "POST", Begun, void 0, { authentication: "device" }),
+	route("register.finish", "/passkeys/register/finish", "POST", _Object_({ id: Text }), Finish, { authentication: "device" }),
+	route("authenticate.begin", "/passkeys/authenticate/begin", "POST", Begun, void 0, { authentication: "none" }),
+	route("authenticate.finish", "/passkeys/authenticate/finish", "POST", _Object_({
+		ok: Literal(true),
+		hostPublicKey: Text
+	}), Finish, { authentication: "none" }),
+	route("challenge", "/challenge", "POST", Union([Begun, DeviceKeyBegun]), _Object_({ action: Text }), { authentication: "device" }),
+	route("trusted-devices.register", "/trusted-devices", "POST", _Object_({ trustedDeviceId: Text }), _Object_({
+		identityPublicKey: Text,
+		stepUpPublicKey: Text,
+		label: Text,
+		platform: Union([Literal("ios"), Literal("android")]),
+		identityProof: Text,
+		stepUpProof: Text
+	}), {
+		authentication: "device",
+		description: "Registers a native device from a sealed, QR-approved pairing session.",
+		responses: jsonApiResponses(_Object_({ trustedDeviceId: Text }), 201)
+	}),
+	route("trusted-devices.revoke", "/trusted-devices/{id}", "DELETE", StateResponse, void 0, { description: "Revokes a trusted native device. Local callers, or sealed callers with verified step-up." }),
+	route("device-auth.challenge", "/device-auth/challenge", "POST", _Object_({
+		challengeId: Text,
+		challenge: Text,
+		hostPublicKey: Text,
+		attestation: Text
+	}), _Object_({
+		trustedDeviceId: Text,
+		nonce: Text
+	}), { authentication: "none" }),
+	route("device-auth.authenticate", "/device-auth/authenticate", "POST", _Object_({ ok: Literal(true) }), _Object_({
+		challengeId: Text,
+		trustedDeviceId: Text,
+		signature: Text,
+		channels: ChannelKeys
+	}), { authentication: "none" }),
+	route("channel", "/channel", "POST", ApiOkSchema, _Object_({
+		clientPublicKey: Text,
+		scope: Union([
+			Literal("session"),
+			Literal("protocol"),
+			Literal("http")
+		])
+	}), { authentication: "device" }),
+	route("request", "/request", "POST", SealedEnvelopeSchema, SealedEnvelopeSchema, {
+		authentication: "device",
+		description: "Sealed HTTP gateway. Decrypted requests/responses use the SealedHttpRequest and SealedHttpResponse envelopes."
+	}),
+	route("pair", "/pair", "POST", _Object_({
+		requestId: Text,
+		status: Literal("pending")
+	}), _Object_({ code: String$1({ minLength: 1 }) }), {
+		authentication: "none",
+		responses: {
+			...jsonApiResponses(_Object_({
+				requestId: Text,
+				status: Literal("pending")
+			}), 202),
+			"410": {
+				description: "Pairing code is no longer valid",
+				schema: ApiErrorSchema
+			}
+		}
+	}),
+	route("pair.status", "/pair/status", "GET", _Object_({
+		status: Union([
+			Literal("pending"),
+			Literal("approved"),
+			Literal("denied"),
+			Literal("expired"),
+			Literal("consumed")
+		]),
+		bundleTrust: Optional(Trust),
+		hostPublicKey: Optional(Text)
+	}), void 0, {
+		authentication: "none",
+		parameters: [{
+			name: "request",
+			in: "query",
+			required: true,
+			schema: Text
+		}]
+	})
+];
+const remoteHttpContracts = [
+	route("frontend", "/frontend", "POST", ApiOkSchema, _Object_({ origin: Text }), {
+		authentication: "owner",
+		availability: "Internal loopback frontend registration; blocked by the browser proxy.",
+		parameters: [{
+			name: "x-po-web-registration",
+			in: "header",
+			required: true,
+			schema: Text
+		}]
+	}),
+	...direct,
+	...direct.map((operation) => ({
+		...operation,
+		id: `${operation.id}.plugin`,
+		basePath: "remote",
+		path: operation.path.slice(11) || "/",
+		authentication: "owner",
+		availability: "Global Remote Control plugin mount, reached through the authenticated headless listener."
+	})),
+	{
+		id: "remote.pair.page",
+		scope: "global",
+		path: "/pair",
+		method: "GET",
+		authentication: "none",
+		availability: "Remote listener only",
+		description: "Pairing and passkey bootstrap page.",
+		responses: { "200": {
+			description: "Pairing page",
+			contentType: "text/html",
+			schema: Text
+		} }
+	}
+];
+const Asset = _Object_({
+	path: Text,
+	sha256: String$1({ pattern: "^[a-f0-9]{64}$" }),
+	byteLength: Integer({ minimum: 0 }),
+	contentType: Text
+});
+const Signed = _Object_({
+	manifest: _Object_({
+		version: Literal(2),
+		revision: Integer({ minimum: 1 }),
+		builtAt: NumberValue,
+		assets: _Array_(Asset)
+	}),
+	signature: Text,
+	publicKey: Text
+});
+const bundleHttpContracts = [...["/bundle-manifest.json", "/api/web-plugins/{id}/{revision}/manifest"].flatMap((path) => ["GET", "HEAD"].map((method) => ({
+	id: `bundle.${path}.${method}`,
+	scope: "global",
+	path,
+	method,
+	authentication: "owner",
+	availability: "Host publishes a web bundle",
+	description: "Read an immutable signed browser bundle manifest.",
+	responses: method === "HEAD" ? {
+		"200": { description: "Manifest response headers" },
+		"404": { description: "Bundle not published" }
+	} : jsonApiResponses(Signed)
+}))), ...["/bundle-assets/{revision}/{assetPath}", "/api/web-plugins/{id}/{revision}/assets/{assetPath}"].flatMap((path) => ["GET", "HEAD"].map((method) => ({
+	id: `asset.${path}.${method}`,
+	scope: "global",
+	path,
+	method,
+	authentication: "owner",
+	availability: "Host publishes a web bundle",
+	description: "Read an asset from the signed manifest. assetPath may contain multiple path segments.",
+	responses: {
+		"200": {
+			description: "Manifest-listed asset, original MIME type",
+			...method === "GET" ? {
+				contentType: "*/*",
+				schema: String$1({ contentEncoding: "binary" })
+			} : {}
+		},
+		"404": { description: "Asset not published" }
+	}
+})))];
+//#endregion
+//#region ../../core/po-core/src/schemas/transportApiContracts.ts
+/** The Chord release whose link frames this file describes (link protocol 4). */
+const CHORD_WIRE_VERSION = "1.3.0";
+const S = String$1({ minLength: 1 });
+const Json = Unknown({ description: "JSON value; its application shape is defined by the addressed contract member." });
+const Id = Integer({ minimum: 1 });
+const ErrorCode = Union([
+	"aborted",
+	"contract_mismatch",
+	"forbidden",
+	"gone",
+	"invalid",
+	"not_in_variant",
+	"not_ready",
+	"released",
+	"superseded",
+	"unavailable",
+	"upgrade_conflict",
+	"upgrade_required"
+].map((code) => Literal(code)));
+const WireError = _Object_({
+	code: ErrorCode,
+	message: String$1(),
+	reason: Optional$4(String$1())
+});
+const Segment = Union([String$1(), Integer({ minimum: 0 })]);
+const Path = _Array_(Segment);
+const PathRef = Union([Path, Integer({ minimum: 0 })]);
+const NonemptyPathRef = Union([_Array_(Segment, { minItems: 1 }), Integer({ minimum: 0 })]);
+const Index = Integer({ minimum: 0 });
+const ChordWireOpSchema = Union([
+	Tuple([Literal("r"), Json]),
+	Tuple([
+		Literal("s"),
+		NonemptyPathRef,
+		Json
+	]),
+	Tuple([Literal("s"), Json]),
+	Tuple([Literal("d"), NonemptyPathRef]),
+	Tuple([Literal("d")]),
+	Tuple([
+		Literal("a"),
+		NonemptyPathRef,
+		String$1()
+	]),
+	Tuple([Literal("a"), String$1()]),
+	Tuple([
+		Literal("t"),
+		NonemptyPathRef,
+		Index
+	]),
+	Tuple([Literal("t"), Index]),
+	Tuple([
+		Literal("p"),
+		PathRef,
+		Index,
+		Index,
+		_Array_(Json)
+	]),
+	Tuple([
+		Literal("p"),
+		Index,
+		Index,
+		_Array_(Json)
+	]),
+	Tuple([
+		Literal("m"),
+		PathRef,
+		_Array_(Index)
+	]),
+	Tuple([Literal("m"), _Array_(Index)]),
+	Tuple([
+		Literal("#"),
+		Index,
+		Path
+	])
+], { description: "Chord delta tuples. Path dictionary references and omitted paths depend on earlier operations in this subscription; decode with the Chord delta decoder." });
+const Hello = (kind) => _Object_({
+	t: Literal("hello"),
+	protocol: Optional$4(Integer({ minimum: 1 })),
+	name: String$1(),
+	kind,
+	codeVersion: Integer({ minimum: 0 }),
+	acks: Optional$4(Boolean())
+});
+const Ack = _Object_({
+	t: Literal("ack"),
+	n: Integer({ minimum: 1 })
+});
+const Ping = _Object_({
+	t: Literal("ping"),
+	n: Integer()
+});
+const Pong = _Object_({
+	t: Literal("pong"),
+	n: Integer()
+});
+const Bye = _Object_({
+	t: Literal("bye"),
+	reason: Optional$4(String$1())
+});
+/** Frames a client (browser or native app) sends on its link. */
+const ChordClientFrameSchema = Union([
+	Hello(Literal("client")),
+	Ack,
+	_Object_({
+		t: Literal("hold"),
+		id: Id,
+		at: String$1(),
+		token: Json,
+		input: Json,
+		state: Optional$4(Literal(false)),
+		again: Optional$4(Literal(true))
+	}),
+	_Object_({
+		t: Literal("release"),
+		id: Id
+	}),
+	_Object_({
+		t: Literal("call"),
+		id: Id,
+		hold: Id,
+		member: S,
+		args: Optional$4(Json)
+	}),
+	_Object_({
+		t: Literal("cancel"),
+		id: Id
+	}),
+	_Object_({
+		t: Literal("sub"),
+		hold: Id
+	}),
+	_Object_({
+		t: Literal("unsub"),
+		hold: Id
+	}),
+	_Object_({
+		t: Literal("root_end"),
+		rootId: String$1()
+	}),
+	Ping,
+	Pong,
+	Bye
+]);
+/** Frames the Po server sends to a client link. */
+const ChordServerFrameSchema = Union([
+	Hello(String$1()),
+	Ack,
+	_Object_({
+		t: Literal("shape"),
+		id: Id,
+		variant: Optional$4(String$1()),
+		members: _Array_(String$1()),
+		contract: String$1(),
+		state: _Array_(S)
+	}),
+	_Object_({
+		t: Literal("gone"),
+		id: Id,
+		error: WireError
+	}),
+	_Object_({
+		t: Literal("result"),
+		id: Id,
+		value: Optional$4(Json),
+		error: Optional$4(WireError)
+	}),
+	_Object_({
+		t: Literal("state"),
+		hold: Id,
+		m: S,
+		as: Union([
+			Literal("snap"),
+			Literal("reset"),
+			Literal("ops"),
+			Literal("error")
+		]),
+		value: Optional$4(Json),
+		ops: Optional$4(_Array_(ChordWireOpSchema)),
+		error: Optional$4(WireError)
+	}),
+	Ping,
+	Pong,
+	Bye
+]);
+const transportSocketContracts = [
+	{
+		id: "chord.client",
+		scope: "global",
+		service: "$chord",
+		member: "client",
+		direction: "client-to-server",
+		kind: "channel",
+		input: ChordClientFrameSchema,
+		description: `Chord ${CHORD_WIRE_VERSION} link frame, one JSON text message each, sealed for remote delivery. Hold \`po.hub\` ({}) and \`po.session\` ({ sessionId }) at host \`server\`.`
+	},
+	{
+		id: "chord.server",
+		scope: "global",
+		service: "$chord",
+		member: "server",
+		direction: "server-to-client",
+		kind: "channel",
+		input: ChordServerFrameSchema,
+		description: "Chord link frame. Results correlate by call id; state frames by hold id and member."
+	},
+	{
+		id: "plugin.invoke",
+		scope: "global",
+		service: "po.hub",
+		member: "invoke",
+		direction: "client-to-server",
+		kind: "method",
+		input: PoPluginCallSchema,
+		output: Json,
+		errors: WireError,
+		description: "Invoke the selected scoped plugin method. Its declaration supplies input and output shapes."
+	}
+];
+[
+	...headlessHttpContracts,
+	...machineHttpContracts,
+	...sessionHttpContracts,
+	...remoteHttpContracts,
+	...bundleHttpContracts
+], [...sessionSocketContracts, ...transportSocketContracts];
+//#endregion
+export { oneOf as $, resolveHost as A, asChordError as B, coverage as C, placedOn as D, opaque as E, cleaned as F, compile as G, invalid as H, deepEqual as I, int as J, arr as K, normalize as L, assertValid as M, canonicalIdentity as N, placementText as O, canonicalJson as P, obj as Q, CHORD_ERROR_CODES as R, contractFromDescription as S, local as T, isChordError as U, forbidden as V, runAll as W, map as X, lit as Y, num as Z, PO_SERVER_HOST as _, PoThreadContract as a, definePoPluginMethod as at, DescriptionSchema as b, HubNoticeSchema as c, PoHubContract as d, opt as et, PoHubRevisionsContract as f, PoChannelsStateSchema as g, PoChannelsContract as h, SessionServiceStateSchema as i, createPoPluginRegistry as it, takesNoArgs as j, remote as k, HubRevisionsSchema as l, jsonApiResponses as m, SessionMethodSchemas as n, union as nt, PoThreadFrameSchema as o, SessionSummarySchema as p, bool as q, SessionMethods as r, unknown as rt, HubCompositionsSchema as s, defineApiContract as t, str as tt, HubWorkspaceSchema as u, chordSchema as v, hostNamed as w, bind as x, chordStates as y, ChordError as z };