commanderclaw 1.1.3

package/dist/plugin/index.mjs

@@ -0,0 +1,4536 @@
+import { createPluginRuntimeStore, emptyPluginConfigSchema } from 'openclaw/plugin-sdk';
+
+/**
+ * WebSocket client for CommanderClaw server
+ * Cross-platform: works in both Node.js and browser/Electron environments
+ */
+function createWebSocket(url, handlers) {
+    if (typeof WebSocket !== "undefined") {
+        const ws = new WebSocket(url);
+        ws.onopen = () => handlers.onOpen();
+        ws.onmessage = (event) => handlers.onMessage(event.data);
+        ws.onerror = () => handlers.onError(new Error("WebSocket error"));
+        ws.onclose = () => handlers.onClose();
+        return ws;
+    }
+    const WS = require("ws");
+    const ws = new WS(url);
+    ws.on("open", handlers.onOpen);
+    ws.on("message", (data) => handlers.onMessage(data.toString()));
+    ws.on("error", (error) => handlers.onError(error));
+    ws.on("close", handlers.onClose);
+    return ws;
+}
+class CommanderClawClient {
+    ws = null;
+    options;
+    nodeId = null;
+    peers = [];
+    commanderId = null;
+    connected = false;
+    reconnectAttempts = 0;
+    messageHandlers = new Map();
+    eventHandlers = new Map();
+    heartbeatInterval = null;
+    connectionPromise = null;
+    constructor(options) {
+        this.options = options;
+    }
+    async connect() {
+        return new Promise((resolve, reject) => {
+            try {
+                this.connectionPromise = { resolve, reject };
+                this.ws = createWebSocket(this.options.url, {
+                    onOpen: () => {
+                        const payload = {
+                            id: this.options.name,
+                            name: this.options.name,
+                            capabilities: this.options.capabilities,
+                            token: this.options.token,
+                        };
+                        this.send("HELLO", payload);
+                    },
+                    onMessage: (data) => {
+                        try {
+                            const msg = JSON.parse(data);
+                            this.handleMessage(msg);
+                        }
+                        catch (error) {
+                            console.error("Failed to parse message:", error);
+                        }
+                    },
+                    onError: (error) => {
+                        if (this.connectionPromise) {
+                            this.connectionPromise.reject(error);
+                            this.connectionPromise = null;
+                        }
+                        this.emit("error", { type: "error", data: error });
+                    },
+                    onClose: () => {
+                        this.handleDisconnect();
+                    },
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    handleMessage(msg) {
+        console.log(`[CommanderClawClient] handleMessage: type=${msg.type}, from=${msg.from}`);
+        switch (msg.type) {
+            case "HELLO_ACK": {
+                const payload = msg.payload;
+                console.log(`[CommanderClawClient] HELLO_ACK received, error=${payload.error}, nodeId=${payload.nodeId}`);
+                if (payload.error) {
+                    if (this.connectionPromise) {
+                        this.connectionPromise.reject(new Error(payload.error));
+                        this.connectionPromise = null;
+                    }
+                    return;
+                }
+                this.nodeId = payload.nodeId;
+                this.peers = payload.peers || [];
+                this.commanderId = payload.commanderId || null;
+                this.connected = true;
+                this.reconnectAttempts = 0;
+                console.log(`[CommanderClawClient] Connected as node ${this.nodeId}, commander=${this.commanderId}, peers=${this.peers.length}`);
+                this.startHeartbeat();
+                this.emit("connected", { type: "connected", data: { nodeId: this.nodeId } });
+                if (this.connectionPromise) {
+                    this.connectionPromise.resolve();
+                    this.connectionPromise = null;
+                }
+                break;
+            }
+            case "HEARTBEAT_ACK":
+                console.log(`[CommanderClawClient] HEARTBEAT_ACK received`);
+                break;
+            case "PEER_UPDATE": {
+                const payload = msg.payload;
+                console.log(`[CommanderClawClient] PEER_UPDATE: event=${payload.event}, node=${payload.node?.id}`);
+                this.updatePeers(payload.event, payload.node);
+                this.emit("peer_update", { type: "peer_update", data: payload });
+                break;
+            }
+            case "TASK_ASSIGN": {
+                console.log(`[CommanderClawClient] TASK_ASSIGN received`, msg.payload);
+                const handler = this.messageHandlers.get("TASK_ASSIGN");
+                if (handler)
+                    handler(msg);
+                this.emit("task_assign", { type: "task_assign", data: msg.payload });
+                break;
+            }
+            case "COMMANDER_APPOINT": {
+                const payload = msg.payload;
+                console.log(`[CommanderClawClient] COMMANDER_APPOINT: commanderId=${payload.commanderId}`);
+                this.commanderId = payload.commanderId;
+                this.emit("commander_change", { type: "commander_change", data: payload });
+                break;
+            }
+            case "CHAT": {
+                console.log(`[CommanderClawClient] CHAT received`, {
+                    from: msg.from,
+                    to: msg.to,
+                    msgType: msg.msgType,
+                    payload: msg.payload,
+                });
+                this.emit("chat", { type: "chat", data: msg });
+                break;
+            }
+            default: {
+                console.log(`[CommanderClawClient] Unknown message type: ${msg.type}`);
+                const handler = this.messageHandlers.get(msg.type);
+                if (handler)
+                    handler(msg);
+            }
+        }
+    }
+    updatePeers(event, node) {
+        switch (event) {
+            case "join":
+                this.peers.push(node);
+                break;
+            case "leave":
+                this.peers = this.peers.filter((p) => p.id !== node.id);
+                if (this.commanderId === node.id) {
+                    this.commanderId = null;
+                }
+                break;
+            case "update":
+                const idx = this.peers.findIndex((p) => p.id === node.id);
+                if (idx >= 0) {
+                    this.peers[idx] = node;
+                }
+                break;
+        }
+    }
+    handleDisconnect() {
+        this.connected = false;
+        this.nodeId = null;
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+        this.emit("disconnected", { type: "disconnected", data: {} });
+        this.attemptReconnect();
+    }
+    startHeartbeat() {
+        this.heartbeatInterval = setInterval(() => {
+            if (this.connected && this.ws) {
+                this.send("HEARTBEAT", { status: "online", load: 0 });
+            }
+        }, 5000);
+    }
+    attemptReconnect() {
+        const reconnect = this.options.reconnect;
+        if (!reconnect?.enabled)
+            return;
+        if (this.reconnectAttempts >= reconnect.maxAttempts) {
+            console.error("Max reconnect attempts reached");
+            return;
+        }
+        this.reconnectAttempts++;
+        console.log(`Reconnecting... attempt ${this.reconnectAttempts}/${reconnect.maxAttempts}`);
+        setTimeout(() => {
+            this.connect().catch((error) => {
+                console.error("Reconnect failed:", error);
+            });
+        }, reconnect.delayMs);
+    }
+    async disconnect() {
+        if (this.ws) {
+            this.send("BYE", { reason: "disconnect" });
+            this.ws.close();
+            this.ws = null;
+        }
+        this.connected = false;
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+    send(type, payload) {
+        if (!this.ws) {
+            console.error(`[CommanderClawClient] send: WebSocket not connected, cannot send ${type}`);
+            return;
+        }
+        const msg = {
+            type,
+            id: crypto.randomUUID(),
+            from: this.nodeId || "unknown",
+            payload,
+            timestamp: Date.now(),
+        };
+        console.log(`[CommanderClawClient] send: type=${type}, from=${msg.from}`, payload);
+        this.ws.send(JSON.stringify(msg));
+    }
+    on(event, handler) {
+        const handlers = this.eventHandlers.get(event) || [];
+        handlers.push(handler);
+        this.eventHandlers.set(event, handlers);
+    }
+    off(event, handler) {
+        const handlers = this.eventHandlers.get(event) || [];
+        const idx = handlers.indexOf(handler);
+        if (idx >= 0) {
+            handlers.splice(idx, 1);
+        }
+    }
+    emit(event, data) {
+        const handlers = this.eventHandlers.get(event) || [];
+        for (const handler of handlers) {
+            try {
+                handler(data);
+            }
+            catch (error) {
+                console.error(`Error in event handler for ${event}:`, error);
+            }
+        }
+    }
+    onMessage(type, handler) {
+        this.messageHandlers.set(type, handler);
+    }
+    isConnected() {
+        return this.connected;
+    }
+    getNodeId() {
+        return this.nodeId;
+    }
+    getPeers() {
+        return [...this.peers];
+    }
+    getCommanderId() {
+        return this.commanderId;
+    }
+    getHttpUrl() {
+        return this.options.url.replace("ws://", "http://").replace("wss://", "https://").replace(/\/ws$/, "");
+    }
+    async fetchApi(path, options = {}) {
+        const url = `${this.getHttpUrl()}${path}`;
+        const headers = {
+            "Content-Type": "application/json",
+            ...options.headers,
+        };
+        if (this.options.token) {
+            headers["Authorization"] = `Bearer ${this.options.token}`;
+        }
+        const response = await fetch(url, {
+            ...options,
+            headers,
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`API error: ${response.status} ${error}`);
+        }
+        return response.json();
+    }
+    async listNodes() {
+        const data = await this.fetchApi("/api/nodes");
+        return data.nodes || [];
+    }
+    async getStatus() {
+        return this.fetchApi("/api/health");
+    }
+    async createTask(input) {
+        return this.fetchApi("/api/tasks", {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+    }
+    async listTasks() {
+        const data = await this.fetchApi("/api/tasks");
+        return data.tasks || [];
+    }
+    async getTask(taskId) {
+        return this.fetchApi(`/api/tasks/${taskId}`);
+    }
+    async abortTask(taskId, reason) {
+        return this.fetchApi(`/api/tasks/${taskId}/abort`, {
+            method: "POST",
+            body: JSON.stringify({ reason }),
+        });
+    }
+    async pauseTask(taskId) {
+        return this.fetchApi(`/api/tasks/${taskId}/pause`, {
+            method: "POST",
+        });
+    }
+    async resumeTask(taskId) {
+        return this.fetchApi(`/api/tasks/${taskId}/resume`, {
+            method: "POST",
+        });
+    }
+    async appointCommander(nodeId) {
+        return this.fetchApi("/api/commander", {
+            method: "POST",
+            body: JSON.stringify({ nodeId }),
+        });
+    }
+    sendTaskUpdate(payload) {
+        this.send("TASK_UPDATE", payload);
+    }
+    sendTaskResult(payload) {
+        this.send("TASK_RESULT", payload);
+    }
+}
+
+/** Returns true if this value is an async iterator */
+function IsAsyncIterator$2(value) {
+    return IsObject$2(value) && !IsArray$2(value) && !IsUint8Array$2(value) && Symbol.asyncIterator in value;
+}
+/** Returns true if this value is an array */
+function IsArray$2(value) {
+    return Array.isArray(value);
+}
+/** Returns true if this value is bigint */
+function IsBigInt$2(value) {
+    return typeof value === 'bigint';
+}
+/** Returns true if this value is a boolean */
+function IsBoolean$2(value) {
+    return typeof value === 'boolean';
+}
+/** Returns true if this value is a Date object */
+function IsDate$2(value) {
+    return value instanceof globalThis.Date;
+}
+/** Returns true if this value is a function */
+function IsFunction$2(value) {
+    return typeof value === 'function';
+}
+/** Returns true if this value is an iterator */
+function IsIterator$2(value) {
+    return IsObject$2(value) && !IsArray$2(value) && !IsUint8Array$2(value) && Symbol.iterator in value;
+}
+/** Returns true if this value is null */
+function IsNull$2(value) {
+    return value === null;
+}
+/** Returns true if this value is number */
+function IsNumber$2(value) {
+    return typeof value === 'number';
+}
+/** Returns true if this value is an object */
+function IsObject$2(value) {
+    return typeof value === 'object' && value !== null;
+}
+/** Returns true if this value is RegExp */
+function IsRegExp$2(value) {
+    return value instanceof globalThis.RegExp;
+}
+/** Returns true if this value is string */
+function IsString$2(value) {
+    return typeof value === 'string';
+}
+/** Returns true if this value is symbol */
+function IsSymbol$2(value) {
+    return typeof value === 'symbol';
+}
+/** Returns true if this value is a Uint8Array */
+function IsUint8Array$2(value) {
+    return value instanceof globalThis.Uint8Array;
+}
+/** Returns true if this value is undefined */
+function IsUndefined$2(value) {
+    return value === undefined;
+}
+
+function ArrayType(value) {
+    return value.map((value) => Visit$2(value));
+}
+function DateType(value) {
+    return new Date(value.getTime());
+}
+function Uint8ArrayType(value) {
+    return new Uint8Array(value);
+}
+function RegExpType(value) {
+    return new RegExp(value.source, value.flags);
+}
+function ObjectType(value) {
+    const result = {};
+    for (const key of Object.getOwnPropertyNames(value)) {
+        result[key] = Visit$2(value[key]);
+    }
+    for (const key of Object.getOwnPropertySymbols(value)) {
+        result[key] = Visit$2(value[key]);
+    }
+    return result;
+}
+// prettier-ignore
+function Visit$2(value) {
+    return (IsArray$2(value) ? ArrayType(value) :
+        IsDate$2(value) ? DateType(value) :
+            IsUint8Array$2(value) ? Uint8ArrayType(value) :
+                IsRegExp$2(value) ? RegExpType(value) :
+                    IsObject$2(value) ? ObjectType(value) :
+                        value);
+}
+/** Clones a value */
+function Clone(value) {
+    return Visit$2(value);
+}
+
+/** Clones a Rest */
+function CloneRest(schemas) {
+    return schemas.map((schema) => CloneType(schema));
+}
+/** Clones a Type */
+function CloneType(schema, options = {}) {
+    return { ...Clone(schema), ...options };
+}
+
+/** The base Error type thrown for all TypeBox exceptions  */
+class TypeBoxError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+
+/** Symbol key applied to transform types */
+const TransformKind = Symbol.for('TypeBox.Transform');
+/** Symbol key applied to readonly types */
+const ReadonlyKind = Symbol.for('TypeBox.Readonly');
+/** Symbol key applied to optional types */
+const OptionalKind = Symbol.for('TypeBox.Optional');
+/** Symbol key applied to types */
+const Hint = Symbol.for('TypeBox.Hint');
+/** Symbol key applied to types */
+const Kind = Symbol.for('TypeBox.Kind');
+
+/** `[Kind-Only]` Returns true if this value has a Readonly symbol */
+function IsReadonly(value) {
+    return IsObject$2(value) && value[ReadonlyKind] === 'Readonly';
+}
+/** `[Kind-Only]` Returns true if this value has a Optional symbol */
+function IsOptional$1(value) {
+    return IsObject$2(value) && value[OptionalKind] === 'Optional';
+}
+/** `[Kind-Only]` Returns true if the given value is TAny */
+function IsAny$1(value) {
+    return IsKindOf$1(value, 'Any');
+}
+/** `[Kind-Only]` Returns true if the given value is TArray */
+function IsArray$1(value) {
+    return IsKindOf$1(value, 'Array');
+}
+/** `[Kind-Only]` Returns true if the given value is TAsyncIterator */
+function IsAsyncIterator$1(value) {
+    return IsKindOf$1(value, 'AsyncIterator');
+}
+/** `[Kind-Only]` Returns true if the given value is TBigInt */
+function IsBigInt$1(value) {
+    return IsKindOf$1(value, 'BigInt');
+}
+/** `[Kind-Only]` Returns true if the given value is TBoolean */
+function IsBoolean$1(value) {
+    return IsKindOf$1(value, 'Boolean');
+}
+/** `[Kind-Only]` Returns true if the given value is TConstructor */
+function IsConstructor$1(value) {
+    return IsKindOf$1(value, 'Constructor');
+}
+/** `[Kind-Only]` Returns true if the given value is TDate */
+function IsDate$1(value) {
+    return IsKindOf$1(value, 'Date');
+}
+/** `[Kind-Only]` Returns true if the given value is TFunction */
+function IsFunction$1(value) {
+    return IsKindOf$1(value, 'Function');
+}
+/** `[Kind-Only]` Returns true if the given value is TInteger */
+function IsInteger$1(value) {
+    return IsKindOf$1(value, 'Integer');
+}
+/** `[Kind-Only]` Returns true if the given value is TIntersect */
+function IsIntersect$1(value) {
+    return IsKindOf$1(value, 'Intersect');
+}
+/** `[Kind-Only]` Returns true if the given value is TIterator */
+function IsIterator$1(value) {
+    return IsKindOf$1(value, 'Iterator');
+}
+/** `[Kind-Only]` Returns true if the given value is a TKind with the given name. */
+function IsKindOf$1(value, kind) {
+    return IsObject$2(value) && Kind in value && value[Kind] === kind;
+}
+/** `[Kind-Only]` Returns true if the given value is TLiteral */
+function IsLiteral$1(value) {
+    return IsKindOf$1(value, 'Literal');
+}
+/** `[Kind-Only]` Returns true if the given value is a TMappedKey */
+function IsMappedKey$1(value) {
+    return IsKindOf$1(value, 'MappedKey');
+}
+/** `[Kind-Only]` Returns true if the given value is TMappedResult */
+function IsMappedResult$1(value) {
+    return IsKindOf$1(value, 'MappedResult');
+}
+/** `[Kind-Only]` Returns true if the given value is TNever */
+function IsNever$1(value) {
+    return IsKindOf$1(value, 'Never');
+}
+/** `[Kind-Only]` Returns true if the given value is TNot */
+function IsNot$1(value) {
+    return IsKindOf$1(value, 'Not');
+}
+/** `[Kind-Only]` Returns true if the given value is TNull */
+function IsNull$1(value) {
+    return IsKindOf$1(value, 'Null');
+}
+/** `[Kind-Only]` Returns true if the given value is TNumber */
+function IsNumber$1(value) {
+    return IsKindOf$1(value, 'Number');
+}
+/** `[Kind-Only]` Returns true if the given value is TObject */
+function IsObject$1(value) {
+    return IsKindOf$1(value, 'Object');
+}
+/** `[Kind-Only]` Returns true if the given value is TPromise */
+function IsPromise$1(value) {
+    return IsKindOf$1(value, 'Promise');
+}
+/** `[Kind-Only]` Returns true if the given value is TRecord */
+function IsRecord$1(value) {
+    return IsKindOf$1(value, 'Record');
+}
+/** `[Kind-Only]` Returns true if the given value is TRef */
+function IsRef$1(value) {
+    return IsKindOf$1(value, 'Ref');
+}
+/** `[Kind-Only]` Returns true if the given value is TRegExp */
+function IsRegExp$1(value) {
+    return IsKindOf$1(value, 'RegExp');
+}
+/** `[Kind-Only]` Returns true if the given value is TString */
+function IsString$1(value) {
+    return IsKindOf$1(value, 'String');
+}
+/** `[Kind-Only]` Returns true if the given value is TSymbol */
+function IsSymbol$1(value) {
+    return IsKindOf$1(value, 'Symbol');
+}
+/** `[Kind-Only]` Returns true if the given value is TTemplateLiteral */
+function IsTemplateLiteral$1(value) {
+    return IsKindOf$1(value, 'TemplateLiteral');
+}
+/** `[Kind-Only]` Returns true if the given value is TThis */
+function IsThis$1(value) {
+    return IsKindOf$1(value, 'This');
+}
+/** `[Kind-Only]` Returns true of this value is TTransform */
+function IsTransform$1(value) {
+    return IsObject$2(value) && TransformKind in value;
+}
+/** `[Kind-Only]` Returns true if the given value is TTuple */
+function IsTuple$1(value) {
+    return IsKindOf$1(value, 'Tuple');
+}
+/** `[Kind-Only]` Returns true if the given value is TUndefined */
+function IsUndefined$1(value) {
+    return IsKindOf$1(value, 'Undefined');
+}
+/** `[Kind-Only]` Returns true if the given value is TUnion */
+function IsUnion$1(value) {
+    return IsKindOf$1(value, 'Union');
+}
+/** `[Kind-Only]` Returns true if the given value is TUint8Array */
+function IsUint8Array$1(value) {
+    return IsKindOf$1(value, 'Uint8Array');
+}
+/** `[Kind-Only]` Returns true if the given value is TUnknown */
+function IsUnknown$1(value) {
+    return IsKindOf$1(value, 'Unknown');
+}
+/** `[Kind-Only]` Returns true if the given value is a raw TUnsafe */
+function IsUnsafe$1(value) {
+    return IsKindOf$1(value, 'Unsafe');
+}
+/** `[Kind-Only]` Returns true if the given value is TVoid */
+function IsVoid$1(value) {
+    return IsKindOf$1(value, 'Void');
+}
+/** `[Kind-Only]` Returns true if the given value is TKind */
+function IsKind$1(value) {
+    return IsObject$2(value) && Kind in value && IsString$2(value[Kind]);
+}
+/** `[Kind-Only]` Returns true if the given value is TSchema */
+function IsSchema$1(value) {
+    // prettier-ignore
+    return (IsAny$1(value) ||
+        IsArray$1(value) ||
+        IsBoolean$1(value) ||
+        IsBigInt$1(value) ||
+        IsAsyncIterator$1(value) ||
+        IsConstructor$1(value) ||
+        IsDate$1(value) ||
+        IsFunction$1(value) ||
+        IsInteger$1(value) ||
+        IsIntersect$1(value) ||
+        IsIterator$1(value) ||
+        IsLiteral$1(value) ||
+        IsMappedKey$1(value) ||
+        IsMappedResult$1(value) ||
+        IsNever$1(value) ||
+        IsNot$1(value) ||
+        IsNull$1(value) ||
+        IsNumber$1(value) ||
+        IsObject$1(value) ||
+        IsPromise$1(value) ||
+        IsRecord$1(value) ||
+        IsRef$1(value) ||
+        IsRegExp$1(value) ||
+        IsString$1(value) ||
+        IsSymbol$1(value) ||
+        IsTemplateLiteral$1(value) ||
+        IsThis$1(value) ||
+        IsTuple$1(value) ||
+        IsUndefined$1(value) ||
+        IsUnion$1(value) ||
+        IsUint8Array$1(value) ||
+        IsUnknown$1(value) ||
+        IsUnsafe$1(value) ||
+        IsVoid$1(value) ||
+        IsKind$1(value));
+}
+
+const KnownTypes = [
+    'Any',
+    'Array',
+    'AsyncIterator',
+    'BigInt',
+    'Boolean',
+    'Constructor',
+    'Date',
+    'Enum',
+    'Function',
+    'Integer',
+    'Intersect',
+    'Iterator',
+    'Literal',
+    'MappedKey',
+    'MappedResult',
+    'Not',
+    'Null',
+    'Number',
+    'Object',
+    'Promise',
+    'Record',
+    'Ref',
+    'RegExp',
+    'String',
+    'Symbol',
+    'TemplateLiteral',
+    'This',
+    'Tuple',
+    'Undefined',
+    'Union',
+    'Uint8Array',
+    'Unknown',
+    'Void',
+];
+function IsPattern(value) {
+    try {
+        new RegExp(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function IsControlCharacterFree(value) {
+    if (!IsString$2(value))
+        return false;
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if ((code >= 7 && code <= 13) || code === 27 || code === 127) {
+            return false;
+        }
+    }
+    return true;
+}
+function IsAdditionalProperties(value) {
+    return IsOptionalBoolean(value) || IsSchema(value);
+}
+function IsOptionalBigInt(value) {
+    return IsUndefined$2(value) || IsBigInt$2(value);
+}
+function IsOptionalNumber(value) {
+    return IsUndefined$2(value) || IsNumber$2(value);
+}
+function IsOptionalBoolean(value) {
+    return IsUndefined$2(value) || IsBoolean$2(value);
+}
+function IsOptionalString(value) {
+    return IsUndefined$2(value) || IsString$2(value);
+}
+function IsOptionalPattern(value) {
+    return IsUndefined$2(value) || (IsString$2(value) && IsControlCharacterFree(value) && IsPattern(value));
+}
+function IsOptionalFormat(value) {
+    return IsUndefined$2(value) || (IsString$2(value) && IsControlCharacterFree(value));
+}
+function IsOptionalSchema(value) {
+    return IsUndefined$2(value) || IsSchema(value);
+}
+/** Returns true if this value has a Optional symbol */
+function IsOptional(value) {
+    return IsObject$2(value) && value[OptionalKind] === 'Optional';
+}
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
+/** Returns true if the given value is TAny */
+function IsAny(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Any') &&
+        IsOptionalString(value.$id));
+}
+/** Returns true if the given value is TArray */
+function IsArray(value) {
+    return (IsKindOf(value, 'Array') &&
+        value.type === 'array' &&
+        IsOptionalString(value.$id) &&
+        IsSchema(value.items) &&
+        IsOptionalNumber(value.minItems) &&
+        IsOptionalNumber(value.maxItems) &&
+        IsOptionalBoolean(value.uniqueItems) &&
+        IsOptionalSchema(value.contains) &&
+        IsOptionalNumber(value.minContains) &&
+        IsOptionalNumber(value.maxContains));
+}
+/** Returns true if the given value is TAsyncIterator */
+function IsAsyncIterator(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'AsyncIterator') &&
+        value.type === 'AsyncIterator' &&
+        IsOptionalString(value.$id) &&
+        IsSchema(value.items));
+}
+/** Returns true if the given value is TBigInt */
+function IsBigInt(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'BigInt') &&
+        value.type === 'bigint' &&
+        IsOptionalString(value.$id) &&
+        IsOptionalBigInt(value.exclusiveMaximum) &&
+        IsOptionalBigInt(value.exclusiveMinimum) &&
+        IsOptionalBigInt(value.maximum) &&
+        IsOptionalBigInt(value.minimum) &&
+        IsOptionalBigInt(value.multipleOf));
+}
+/** Returns true if the given value is TBoolean */
+function IsBoolean(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Boolean') &&
+        value.type === 'boolean' &&
+        IsOptionalString(value.$id));
+}
+/** Returns true if the given value is TConstructor */
+function IsConstructor(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Constructor') &&
+        value.type === 'Constructor' &&
+        IsOptionalString(value.$id) &&
+        IsArray$2(value.parameters) &&
+        value.parameters.every(schema => IsSchema(schema)) &&
+        IsSchema(value.returns));
+}
+/** Returns true if the given value is TDate */
+function IsDate(value) {
+    return (IsKindOf(value, 'Date') &&
+        value.type === 'Date' &&
+        IsOptionalString(value.$id) &&
+        IsOptionalNumber(value.exclusiveMaximumTimestamp) &&
+        IsOptionalNumber(value.exclusiveMinimumTimestamp) &&
+        IsOptionalNumber(value.maximumTimestamp) &&
+        IsOptionalNumber(value.minimumTimestamp) &&
+        IsOptionalNumber(value.multipleOfTimestamp));
+}
+/** Returns true if the given value is TFunction */
+function IsFunction(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Function') &&
+        value.type === 'Function' &&
+        IsOptionalString(value.$id) &&
+        IsArray$2(value.parameters) &&
+        value.parameters.every(schema => IsSchema(schema)) &&
+        IsSchema(value.returns));
+}
+/** Returns true if the given value is TInteger */
+function IsInteger(value) {
+    return (IsKindOf(value, 'Integer') &&
+        value.type === 'integer' &&
+        IsOptionalString(value.$id) &&
+        IsOptionalNumber(value.exclusiveMaximum) &&
+        IsOptionalNumber(value.exclusiveMinimum) &&
+        IsOptionalNumber(value.maximum) &&
+        IsOptionalNumber(value.minimum) &&
+        IsOptionalNumber(value.multipleOf));
+}
+/** Returns true if the given schema is TProperties */
+function IsProperties(value) {
+    // prettier-ignore
+    return (IsObject$2(value) &&
+        Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema(schema)));
+}
+/** Returns true if the given value is TIntersect */
+function IsIntersect(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Intersect') &&
+        (IsString$2(value.type) && value.type !== 'object' ? false : true) &&
+        IsArray$2(value.allOf) &&
+        value.allOf.every(schema => IsSchema(schema) && !IsTransform(schema)) &&
+        IsOptionalString(value.type) &&
+        (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) &&
+        IsOptionalString(value.$id));
+}
+/** Returns true if the given value is TIterator */
+function IsIterator(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Iterator') &&
+        value.type === 'Iterator' &&
+        IsOptionalString(value.$id) &&
+        IsSchema(value.items));
+}
+/** Returns true if the given value is a TKind with the given name. */
+function IsKindOf(value, kind) {
+    return IsObject$2(value) && Kind in value && value[Kind] === kind;
+}
+/** Returns true if the given value is TLiteral<string> */
+function IsLiteralString(value) {
+    return IsLiteral(value) && IsString$2(value.const);
+}
+/** Returns true if the given value is TLiteral<number> */
+function IsLiteralNumber(value) {
+    return IsLiteral(value) && IsNumber$2(value.const);
+}
+/** Returns true if the given value is TLiteral<boolean> */
+function IsLiteralBoolean(value) {
+    return IsLiteral(value) && IsBoolean$2(value.const);
+}
+/** Returns true if the given value is TLiteral */
+function IsLiteral(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Literal') &&
+        IsOptionalString(value.$id) && IsLiteralValue(value.const));
+}
+/** Returns true if the given value is a TLiteralValue */
+function IsLiteralValue(value) {
+    return IsBoolean$2(value) || IsNumber$2(value) || IsString$2(value);
+}
+/** Returns true if the given value is a TMappedKey */
+function IsMappedKey(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'MappedKey') &&
+        IsArray$2(value.keys) &&
+        value.keys.every(key => IsNumber$2(key) || IsString$2(key)));
+}
+/** Returns true if the given value is TMappedResult */
+function IsMappedResult(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'MappedResult') &&
+        IsProperties(value.properties));
+}
+/** Returns true if the given value is TNever */
+function IsNever(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Never') &&
+        IsObject$2(value.not) &&
+        Object.getOwnPropertyNames(value.not).length === 0);
+}
+/** Returns true if the given value is TNot */
+function IsNot(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Not') &&
+        IsSchema(value.not));
+}
+/** Returns true if the given value is TNull */
+function IsNull(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Null') &&
+        value.type === 'null' &&
+        IsOptionalString(value.$id));
+}
+/** Returns true if the given value is TNumber */
+function IsNumber(value) {
+    return (IsKindOf(value, 'Number') &&
+        value.type === 'number' &&
+        IsOptionalString(value.$id) &&
+        IsOptionalNumber(value.exclusiveMaximum) &&
+        IsOptionalNumber(value.exclusiveMinimum) &&
+        IsOptionalNumber(value.maximum) &&
+        IsOptionalNumber(value.minimum) &&
+        IsOptionalNumber(value.multipleOf));
+}
+/** Returns true if the given value is TObject */
+function IsObject(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Object') &&
+        value.type === 'object' &&
+        IsOptionalString(value.$id) &&
+        IsProperties(value.properties) &&
+        IsAdditionalProperties(value.additionalProperties) &&
+        IsOptionalNumber(value.minProperties) &&
+        IsOptionalNumber(value.maxProperties));
+}
+/** Returns true if the given value is TPromise */
+function IsPromise(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Promise') &&
+        value.type === 'Promise' &&
+        IsOptionalString(value.$id) &&
+        IsSchema(value.item));
+}
+/** Returns true if the given value is TRecord */
+function IsRecord(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Record') &&
+        value.type === 'object' &&
+        IsOptionalString(value.$id) &&
+        IsAdditionalProperties(value.additionalProperties) &&
+        IsObject$2(value.patternProperties) &&
+        ((schema) => {
+            const keys = Object.getOwnPropertyNames(schema.patternProperties);
+            return (keys.length === 1 &&
+                IsPattern(keys[0]) &&
+                IsObject$2(schema.patternProperties) &&
+                IsSchema(schema.patternProperties[keys[0]]));
+        })(value));
+}
+/** Returns true if the given value is TRef */
+function IsRef(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Ref') &&
+        IsOptionalString(value.$id) &&
+        IsString$2(value.$ref));
+}
+/** Returns true if the given value is TRegExp */
+function IsRegExp(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'RegExp') &&
+        IsOptionalString(value.$id) &&
+        IsString$2(value.source) &&
+        IsString$2(value.flags) &&
+        IsOptionalNumber(value.maxLength) &&
+        IsOptionalNumber(value.minLength));
+}
+/** Returns true if the given value is TString */
+function IsString(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'String') &&
+        value.type === 'string' &&
+        IsOptionalString(value.$id) &&
+        IsOptionalNumber(value.minLength) &&
+        IsOptionalNumber(value.maxLength) &&
+        IsOptionalPattern(value.pattern) &&
+        IsOptionalFormat(value.format));
+}
+/** Returns true if the given value is TSymbol */
+function IsSymbol(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Symbol') &&
+        value.type === 'symbol' &&
+        IsOptionalString(value.$id));
+}
+/** Returns true if the given value is TTemplateLiteral */
+function IsTemplateLiteral(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'TemplateLiteral') &&
+        value.type === 'string' &&
+        IsString$2(value.pattern) &&
+        value.pattern[0] === '^' &&
+        value.pattern[value.pattern.length - 1] === '$');
+}
+/** Returns true if the given value is TThis */
+function IsThis(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'This') &&
+        IsOptionalString(value.$id) &&
+        IsString$2(value.$ref));
+}
+/** Returns true of this value is TTransform */
+function IsTransform(value) {
+    return IsObject$2(value) && TransformKind in value;
+}
+/** Returns true if the given value is TTuple */
+function IsTuple(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Tuple') &&
+        value.type === 'array' &&
+        IsOptionalString(value.$id) &&
+        IsNumber$2(value.minItems) &&
+        IsNumber$2(value.maxItems) &&
+        value.minItems === value.maxItems &&
+        (( // empty
+        IsUndefined$2(value.items) &&
+            IsUndefined$2(value.additionalItems) &&
+            value.minItems === 0) || (IsArray$2(value.items) &&
+            value.items.every(schema => IsSchema(schema)))));
+}
+/** Returns true if the given value is TUndefined */
+function IsUndefined(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Undefined') &&
+        value.type === 'undefined' &&
+        IsOptionalString(value.$id));
+}
+/** Returns true if the given value is TUnion */
+function IsUnion(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Union') &&
+        IsOptionalString(value.$id) &&
+        IsObject$2(value) &&
+        IsArray$2(value.anyOf) &&
+        value.anyOf.every(schema => IsSchema(schema)));
+}
+/** Returns true if the given value is TUint8Array */
+function IsUint8Array(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Uint8Array') &&
+        value.type === 'Uint8Array' &&
+        IsOptionalString(value.$id) &&
+        IsOptionalNumber(value.minByteLength) &&
+        IsOptionalNumber(value.maxByteLength));
+}
+/** Returns true if the given value is TUnknown */
+function IsUnknown(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Unknown') &&
+        IsOptionalString(value.$id));
+}
+/** Returns true if the given value is a raw TUnsafe */
+function IsUnsafe(value) {
+    return IsKindOf(value, 'Unsafe');
+}
+/** Returns true if the given value is TVoid */
+function IsVoid(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'Void') &&
+        value.type === 'void' &&
+        IsOptionalString(value.$id));
+}
+/** Returns true if the given value is TKind */
+function IsKind(value) {
+    return IsObject$2(value) && Kind in value && IsString$2(value[Kind]) && !KnownTypes.includes(value[Kind]);
+}
+/** Returns true if the given value is TSchema */
+function IsSchema(value) {
+    // prettier-ignore
+    return (IsObject$2(value)) && (IsAny(value) ||
+        IsArray(value) ||
+        IsBoolean(value) ||
+        IsBigInt(value) ||
+        IsAsyncIterator(value) ||
+        IsConstructor(value) ||
+        IsDate(value) ||
+        IsFunction(value) ||
+        IsInteger(value) ||
+        IsIntersect(value) ||
+        IsIterator(value) ||
+        IsLiteral(value) ||
+        IsMappedKey(value) ||
+        IsMappedResult(value) ||
+        IsNever(value) ||
+        IsNot(value) ||
+        IsNull(value) ||
+        IsNumber(value) ||
+        IsObject(value) ||
+        IsPromise(value) ||
+        IsRecord(value) ||
+        IsRef(value) ||
+        IsRegExp(value) ||
+        IsString(value) ||
+        IsSymbol(value) ||
+        IsTemplateLiteral(value) ||
+        IsThis(value) ||
+        IsTuple(value) ||
+        IsUndefined(value) ||
+        IsUnion(value) ||
+        IsUint8Array(value) ||
+        IsUnknown(value) ||
+        IsUnsafe(value) ||
+        IsVoid(value) ||
+        IsKind(value));
+}
+
+const PatternBoolean = '(true|false)';
+const PatternNumber = '(0|[1-9][0-9]*)';
+const PatternString = '(.*)';
+const PatternNever = '(?!.*)';
+const PatternNumberExact = `^${PatternNumber}$`;
+const PatternStringExact = `^${PatternString}$`;
+const PatternNeverExact = `^${PatternNever}$`;
+
+/** Returns true if element right is in the set of left */
+// prettier-ignore
+function SetIncludes(T, S) {
+    return T.includes(S);
+}
+/** Returns a distinct set of elements */
+function SetDistinct(T) {
+    return [...new Set(T)];
+}
+/** Returns the Intersect of the given sets */
+function SetIntersect(T, S) {
+    return T.filter((L) => S.includes(L));
+}
+// prettier-ignore
+function SetIntersectManyResolve(T, Init) {
+    return T.reduce((Acc, L) => {
+        return SetIntersect(Acc, L);
+    }, Init);
+}
+// prettier-ignore
+function SetIntersectMany(T) {
+    return (T.length === 1
+        ? T[0]
+        // Use left to initialize the accumulator for resolve
+        : T.length > 1
+            ? SetIntersectManyResolve(T.slice(1), T[0])
+            : []);
+}
+/** Returns the Union of multiple sets */
+function SetUnionMany(T) {
+    const Acc = [];
+    for (const L of T)
+        Acc.push(...L);
+    return Acc;
+}
+
+/** `[Json]` Creates an Any type */
+function Any(options = {}) {
+    return { ...options, [Kind]: 'Any' };
+}
+
+/** `[Json]` Creates an Array type */
+function Array$1(schema, options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Array',
+        type: 'array',
+        items: CloneType(schema),
+    };
+}
+
+/** `[JavaScript]` Creates a AsyncIterator type */
+function AsyncIterator(items, options = {}) {
+    return {
+        ...options,
+        [Kind]: 'AsyncIterator',
+        type: 'AsyncIterator',
+        items: CloneType(items),
+    };
+}
+
+function DiscardKey(value, key) {
+    const { [key]: _, ...rest } = value;
+    return rest;
+}
+function Discard(value, keys) {
+    return keys.reduce((acc, key) => DiscardKey(acc, key), value);
+}
+
+/** `[Json]` Creates a Never type */
+function Never(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Never',
+        not: {},
+    };
+}
+
+// prettier-ignore
+function MappedResult(properties) {
+    return {
+        [Kind]: 'MappedResult',
+        properties
+    };
+}
+
+/** `[JavaScript]` Creates a Constructor type */
+function Constructor(parameters, returns, options) {
+    return {
+        ...options,
+        [Kind]: 'Constructor',
+        type: 'Constructor',
+        parameters: CloneRest(parameters),
+        returns: CloneType(returns),
+    };
+}
+
+/** `[JavaScript]` Creates a Function type */
+function Function(parameters, returns, options) {
+    return {
+        ...options,
+        [Kind]: 'Function',
+        type: 'Function',
+        parameters: CloneRest(parameters),
+        returns: CloneType(returns),
+    };
+}
+
+function UnionCreate(T, options) {
+    return { ...options, [Kind]: 'Union', anyOf: CloneRest(T) };
+}
+
+// prettier-ignore
+function IsUnionOptional(T) {
+    return T.some(L => IsOptional$1(L));
+}
+// prettier-ignore
+function RemoveOptionalFromRest$1(T) {
+    return T.map(L => IsOptional$1(L) ? RemoveOptionalFromType$1(L) : L);
+}
+// prettier-ignore
+function RemoveOptionalFromType$1(T) {
+    return (Discard(T, [OptionalKind]));
+}
+// prettier-ignore
+function ResolveUnion(T, options) {
+    return (IsUnionOptional(T)
+        ? Optional(UnionCreate(RemoveOptionalFromRest$1(T), options))
+        : UnionCreate(RemoveOptionalFromRest$1(T), options));
+}
+/** `[Json]` Creates an evaluated Union type */
+function UnionEvaluated(T, options = {}) {
+    // prettier-ignore
+    return (T.length === 0 ? Never(options) :
+        T.length === 1 ? CloneType(T[0], options) :
+            ResolveUnion(T, options));
+}
+
+/** `[Json]` Creates a Union type */
+function Union(T, options = {}) {
+    // prettier-ignore
+    return (T.length === 0 ? Never(options) :
+        T.length === 1 ? CloneType(T[0], options) :
+            UnionCreate(T, options));
+}
+
+// ------------------------------------------------------------------
+// TemplateLiteralParserError
+// ------------------------------------------------------------------
+class TemplateLiteralParserError extends TypeBoxError {
+}
+// -------------------------------------------------------------------
+// Unescape
+//
+// Unescape for these control characters specifically. Note that this
+// function is only called on non union group content, and where we
+// still want to allow the user to embed control characters in that
+// content. For review.
+// -------------------------------------------------------------------
+// prettier-ignore
+function Unescape(pattern) {
+    return pattern
+        .replace(/\\\$/g, '$')
+        .replace(/\\\*/g, '*')
+        .replace(/\\\^/g, '^')
+        .replace(/\\\|/g, '|')
+        .replace(/\\\(/g, '(')
+        .replace(/\\\)/g, ')');
+}
+// -------------------------------------------------------------------
+// Control Characters
+// -------------------------------------------------------------------
+function IsNonEscaped(pattern, index, char) {
+    return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
+}
+function IsOpenParen(pattern, index) {
+    return IsNonEscaped(pattern, index, '(');
+}
+function IsCloseParen(pattern, index) {
+    return IsNonEscaped(pattern, index, ')');
+}
+function IsSeparator(pattern, index) {
+    return IsNonEscaped(pattern, index, '|');
+}
+// -------------------------------------------------------------------
+// Control Groups
+// -------------------------------------------------------------------
+function IsGroup(pattern) {
+    if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1)))
+        return false;
+    let count = 0;
+    for (let index = 0; index < pattern.length; index++) {
+        if (IsOpenParen(pattern, index))
+            count += 1;
+        if (IsCloseParen(pattern, index))
+            count -= 1;
+        if (count === 0 && index !== pattern.length - 1)
+            return false;
+    }
+    return true;
+}
+// prettier-ignore
+function InGroup(pattern) {
+    return pattern.slice(1, pattern.length - 1);
+}
+// prettier-ignore
+function IsPrecedenceOr(pattern) {
+    let count = 0;
+    for (let index = 0; index < pattern.length; index++) {
+        if (IsOpenParen(pattern, index))
+            count += 1;
+        if (IsCloseParen(pattern, index))
+            count -= 1;
+        if (IsSeparator(pattern, index) && count === 0)
+            return true;
+    }
+    return false;
+}
+// prettier-ignore
+function IsPrecedenceAnd(pattern) {
+    for (let index = 0; index < pattern.length; index++) {
+        if (IsOpenParen(pattern, index))
+            return true;
+    }
+    return false;
+}
+// prettier-ignore
+function Or(pattern) {
+    let [count, start] = [0, 0];
+    const expressions = [];
+    for (let index = 0; index < pattern.length; index++) {
+        if (IsOpenParen(pattern, index))
+            count += 1;
+        if (IsCloseParen(pattern, index))
+            count -= 1;
+        if (IsSeparator(pattern, index) && count === 0) {
+            const range = pattern.slice(start, index);
+            if (range.length > 0)
+                expressions.push(TemplateLiteralParse(range));
+            start = index + 1;
+        }
+    }
+    const range = pattern.slice(start);
+    if (range.length > 0)
+        expressions.push(TemplateLiteralParse(range));
+    if (expressions.length === 0)
+        return { type: 'const', const: '' };
+    if (expressions.length === 1)
+        return expressions[0];
+    return { type: 'or', expr: expressions };
+}
+// prettier-ignore
+function And(pattern) {
+    function Group(value, index) {
+        if (!IsOpenParen(value, index))
+            throw new TemplateLiteralParserError(`TemplateLiteralParser: Index must point to open parens`);
+        let count = 0;
+        for (let scan = index; scan < value.length; scan++) {
+            if (IsOpenParen(value, scan))
+                count += 1;
+            if (IsCloseParen(value, scan))
+                count -= 1;
+            if (count === 0)
+                return [index, scan];
+        }
+        throw new TemplateLiteralParserError(`TemplateLiteralParser: Unclosed group parens in expression`);
+    }
+    function Range(pattern, index) {
+        for (let scan = index; scan < pattern.length; scan++) {
+            if (IsOpenParen(pattern, scan))
+                return [index, scan];
+        }
+        return [index, pattern.length];
+    }
+    const expressions = [];
+    for (let index = 0; index < pattern.length; index++) {
+        if (IsOpenParen(pattern, index)) {
+            const [start, end] = Group(pattern, index);
+            const range = pattern.slice(start, end + 1);
+            expressions.push(TemplateLiteralParse(range));
+            index = end;
+        }
+        else {
+            const [start, end] = Range(pattern, index);
+            const range = pattern.slice(start, end);
+            if (range.length > 0)
+                expressions.push(TemplateLiteralParse(range));
+            index = end - 1;
+        }
+    }
+    return ((expressions.length === 0) ? { type: 'const', const: '' } :
+        (expressions.length === 1) ? expressions[0] :
+            { type: 'and', expr: expressions });
+}
+// ------------------------------------------------------------------
+// TemplateLiteralParse
+// ------------------------------------------------------------------
+/** Parses a pattern and returns an expression tree */
+function TemplateLiteralParse(pattern) {
+    // prettier-ignore
+    return (IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) :
+        IsPrecedenceOr(pattern) ? Or(pattern) :
+            IsPrecedenceAnd(pattern) ? And(pattern) :
+                { type: 'const', const: Unescape(pattern) });
+}
+// ------------------------------------------------------------------
+// TemplateLiteralParseExact
+// ------------------------------------------------------------------
+/** Parses a pattern and strips forward and trailing ^ and $ */
+function TemplateLiteralParseExact(pattern) {
+    return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
+}
+
+// ------------------------------------------------------------------
+// TemplateLiteralFiniteError
+// ------------------------------------------------------------------
+class TemplateLiteralFiniteError extends TypeBoxError {
+}
+// ------------------------------------------------------------------
+// IsTemplateLiteralFiniteCheck
+// ------------------------------------------------------------------
+// prettier-ignore
+function IsNumberExpression(expression) {
+    return (expression.type === 'or' &&
+        expression.expr.length === 2 &&
+        expression.expr[0].type === 'const' &&
+        expression.expr[0].const === '0' &&
+        expression.expr[1].type === 'const' &&
+        expression.expr[1].const === '[1-9][0-9]*');
+}
+// prettier-ignore
+function IsBooleanExpression(expression) {
+    return (expression.type === 'or' &&
+        expression.expr.length === 2 &&
+        expression.expr[0].type === 'const' &&
+        expression.expr[0].const === 'true' &&
+        expression.expr[1].type === 'const' &&
+        expression.expr[1].const === 'false');
+}
+// prettier-ignore
+function IsStringExpression(expression) {
+    return expression.type === 'const' && expression.const === '.*';
+}
+// ------------------------------------------------------------------
+// IsTemplateLiteralExpressionFinite
+// ------------------------------------------------------------------
+// prettier-ignore
+function IsTemplateLiteralExpressionFinite(expression) {
+    return (IsNumberExpression(expression) || IsStringExpression(expression) ? false :
+        IsBooleanExpression(expression) ? true :
+            (expression.type === 'and') ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) :
+                (expression.type === 'or') ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) :
+                    (expression.type === 'const') ? true :
+                        (() => { throw new TemplateLiteralFiniteError(`Unknown expression type`); })());
+}
+/** Returns true if this TemplateLiteral resolves to a finite set of values */
+function IsTemplateLiteralFinite(schema) {
+    const expression = TemplateLiteralParseExact(schema.pattern);
+    return IsTemplateLiteralExpressionFinite(expression);
+}
+
+// ------------------------------------------------------------------
+// TemplateLiteralGenerateError
+// ------------------------------------------------------------------
+class TemplateLiteralGenerateError extends TypeBoxError {
+}
+// ------------------------------------------------------------------
+// TemplateLiteralExpressionGenerate
+// ------------------------------------------------------------------
+// prettier-ignore
+function* GenerateReduce(buffer) {
+    if (buffer.length === 1)
+        return yield* buffer[0];
+    for (const left of buffer[0]) {
+        for (const right of GenerateReduce(buffer.slice(1))) {
+            yield `${left}${right}`;
+        }
+    }
+}
+// prettier-ignore
+function* GenerateAnd(expression) {
+    return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralExpressionGenerate(expr)]));
+}
+// prettier-ignore
+function* GenerateOr(expression) {
+    for (const expr of expression.expr)
+        yield* TemplateLiteralExpressionGenerate(expr);
+}
+// prettier-ignore
+function* GenerateConst(expression) {
+    return yield expression.const;
+}
+function* TemplateLiteralExpressionGenerate(expression) {
+    return expression.type === 'and'
+        ? yield* GenerateAnd(expression)
+        : expression.type === 'or'
+            ? yield* GenerateOr(expression)
+            : expression.type === 'const'
+                ? yield* GenerateConst(expression)
+                : (() => {
+                    throw new TemplateLiteralGenerateError('Unknown expression');
+                })();
+}
+/** Generates a tuple of strings from the given TemplateLiteral. Returns an empty tuple if infinite. */
+function TemplateLiteralGenerate(schema) {
+    const expression = TemplateLiteralParseExact(schema.pattern);
+    // prettier-ignore
+    return (IsTemplateLiteralExpressionFinite(expression)
+        ? [...TemplateLiteralExpressionGenerate(expression)]
+        : []);
+}
+
+/** `[Json]` Creates a Literal type */
+function Literal(value, options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Literal',
+        const: value,
+        type: typeof value,
+    };
+}
+
+/** `[Json]` Creates a Boolean type */
+function Boolean(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Boolean',
+        type: 'boolean',
+    };
+}
+
+/** `[JavaScript]` Creates a BigInt type */
+function BigInt(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'BigInt',
+        type: 'bigint',
+    };
+}
+
+/** `[Json]` Creates a Number type */
+function Number(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Number',
+        type: 'number',
+    };
+}
+
+/** `[Json]` Creates a String type */
+function String$1(options = {}) {
+    return { ...options, [Kind]: 'String', type: 'string' };
+}
+
+// ------------------------------------------------------------------
+// SyntaxParsers
+// ------------------------------------------------------------------
+// prettier-ignore
+function* FromUnion$8(syntax) {
+    const trim = syntax.trim().replace(/"|'/g, '');
+    return (trim === 'boolean' ? yield Boolean() :
+        trim === 'number' ? yield Number() :
+            trim === 'bigint' ? yield BigInt() :
+                trim === 'string' ? yield String$1() :
+                    yield (() => {
+                        const literals = trim.split('|').map((literal) => Literal(literal.trim()));
+                        return (literals.length === 0 ? Never() :
+                            literals.length === 1 ? literals[0] :
+                                UnionEvaluated(literals));
+                    })());
+}
+// prettier-ignore
+function* FromTerminal(syntax) {
+    if (syntax[1] !== '{') {
+        const L = Literal('$');
+        const R = FromSyntax(syntax.slice(1));
+        return yield* [L, ...R];
+    }
+    for (let i = 2; i < syntax.length; i++) {
+        if (syntax[i] === '}') {
+            const L = FromUnion$8(syntax.slice(2, i));
+            const R = FromSyntax(syntax.slice(i + 1));
+            return yield* [...L, ...R];
+        }
+    }
+    yield Literal(syntax);
+}
+// prettier-ignore
+function* FromSyntax(syntax) {
+    for (let i = 0; i < syntax.length; i++) {
+        if (syntax[i] === '$') {
+            const L = Literal(syntax.slice(0, i));
+            const R = FromTerminal(syntax.slice(i));
+            return yield* [L, ...R];
+        }
+    }
+    yield Literal(syntax);
+}
+/** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
+function TemplateLiteralSyntax(syntax) {
+    return [...FromSyntax(syntax)];
+}
+
+// ------------------------------------------------------------------
+// TemplateLiteralPatternError
+// ------------------------------------------------------------------
+class TemplateLiteralPatternError extends TypeBoxError {
+}
+// ------------------------------------------------------------------
+// TemplateLiteralPattern
+// ------------------------------------------------------------------
+function Escape(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+// prettier-ignore
+function Visit$1(schema, acc) {
+    return (IsTemplateLiteral$1(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) :
+        IsUnion$1(schema) ? `(${schema.anyOf.map((schema) => Visit$1(schema, acc)).join('|')})` :
+            IsNumber$1(schema) ? `${acc}${PatternNumber}` :
+                IsInteger$1(schema) ? `${acc}${PatternNumber}` :
+                    IsBigInt$1(schema) ? `${acc}${PatternNumber}` :
+                        IsString$1(schema) ? `${acc}${PatternString}` :
+                            IsLiteral$1(schema) ? `${acc}${Escape(schema.const.toString())}` :
+                                IsBoolean$1(schema) ? `${acc}${PatternBoolean}` :
+                                    (() => { throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[Kind]}'`); })());
+}
+function TemplateLiteralPattern(kinds) {
+    return `^${kinds.map((schema) => Visit$1(schema, '')).join('')}\$`;
+}
+
+/** Returns a Union from the given TemplateLiteral */
+function TemplateLiteralToUnion(schema) {
+    const R = TemplateLiteralGenerate(schema);
+    const L = R.map((S) => Literal(S));
+    return UnionEvaluated(L);
+}
+
+/** `[Json]` Creates a TemplateLiteral type */
+// prettier-ignore
+function TemplateLiteral(unresolved, options = {}) {
+    const pattern = IsString$2(unresolved)
+        ? TemplateLiteralPattern(TemplateLiteralSyntax(unresolved))
+        : TemplateLiteralPattern(unresolved);
+    return { ...options, [Kind]: 'TemplateLiteral', type: 'string', pattern };
+}
+
+// prettier-ignore
+function FromTemplateLiteral$2(T) {
+    const R = TemplateLiteralGenerate(T);
+    return R.map(S => S.toString());
+}
+// prettier-ignore
+function FromUnion$7(T) {
+    const Acc = [];
+    for (const L of T)
+        Acc.push(...IndexPropertyKeys(L));
+    return Acc;
+}
+// prettier-ignore
+function FromLiteral$1(T) {
+    return ([T.toString()] // TS 5.4 observes TLiteralValue as not having a toString()
+    );
+}
+/** Returns a tuple of PropertyKeys derived from the given TSchema */
+// prettier-ignore
+function IndexPropertyKeys(T) {
+    return [...new Set((IsTemplateLiteral$1(T) ? FromTemplateLiteral$2(T) :
+            IsUnion$1(T) ? FromUnion$7(T.anyOf) :
+                IsLiteral$1(T) ? FromLiteral$1(T.const) :
+                    IsNumber$1(T) ? ['[number]'] :
+                        IsInteger$1(T) ? ['[number]'] :
+                            []))];
+}
+
+// prettier-ignore
+function FromProperties$i(T, P, options) {
+    const Acc = {};
+    for (const K2 of Object.getOwnPropertyNames(P)) {
+        Acc[K2] = Index(T, IndexPropertyKeys(P[K2]), options);
+    }
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult$b(T, R, options) {
+    return FromProperties$i(T, R.properties, options);
+}
+// prettier-ignore
+function IndexFromMappedResult(T, R, options) {
+    const P = FromMappedResult$b(T, R, options);
+    return MappedResult(P);
+}
+
+// prettier-ignore
+function FromRest$7(T, K) {
+    return T.map(L => IndexFromPropertyKey(L, K));
+}
+// prettier-ignore
+function FromIntersectRest(T) {
+    return T.filter(L => !IsNever$1(L));
+}
+// prettier-ignore
+function FromIntersect$6(T, K) {
+    return (IntersectEvaluated(FromIntersectRest(FromRest$7(T, K))));
+}
+// prettier-ignore
+function FromUnionRest(T) {
+    return (T.some(L => IsNever$1(L))
+        ? []
+        : T);
+}
+// prettier-ignore
+function FromUnion$6(T, K) {
+    return (UnionEvaluated(FromUnionRest(FromRest$7(T, K))));
+}
+// prettier-ignore
+function FromTuple$3(T, K) {
+    return (K in T ? T[K] :
+        K === '[number]' ? UnionEvaluated(T) :
+            Never());
+}
+// prettier-ignore
+function FromArray$4(T, K) {
+    return (K === '[number]'
+        ? T
+        : Never());
+}
+// prettier-ignore
+function FromProperty$1(T, K) {
+    return (K in T ? T[K] : Never());
+}
+// prettier-ignore
+function IndexFromPropertyKey(T, K) {
+    return (IsIntersect$1(T) ? FromIntersect$6(T.allOf, K) :
+        IsUnion$1(T) ? FromUnion$6(T.anyOf, K) :
+            IsTuple$1(T) ? FromTuple$3(T.items ?? [], K) :
+                IsArray$1(T) ? FromArray$4(T.items, K) :
+                    IsObject$1(T) ? FromProperty$1(T.properties, K) :
+                        Never());
+}
+// prettier-ignore
+function IndexFromPropertyKeys(T, K) {
+    return K.map(L => IndexFromPropertyKey(T, L));
+}
+// prettier-ignore
+function FromSchema(T, K) {
+    return (UnionEvaluated(IndexFromPropertyKeys(T, K)));
+}
+/** `[Json]` Returns an Indexed property type for the given keys */
+function Index(T, K, options = {}) {
+    // prettier-ignore
+    return (IsMappedResult$1(K) ? CloneType(IndexFromMappedResult(T, K, options)) :
+        IsMappedKey$1(K) ? CloneType(IndexFromMappedKey(T, K, options)) :
+            IsSchema$1(K) ? CloneType(FromSchema(T, IndexPropertyKeys(K)), options) :
+                CloneType(FromSchema(T, K), options));
+}
+
+// prettier-ignore
+function MappedIndexPropertyKey(T, K, options) {
+    return { [K]: Index(T, [K], options) };
+}
+// prettier-ignore
+function MappedIndexPropertyKeys(T, K, options) {
+    return K.reduce((Acc, L) => {
+        return { ...Acc, ...MappedIndexPropertyKey(T, L, options) };
+    }, {});
+}
+// prettier-ignore
+function MappedIndexProperties(T, K, options) {
+    return MappedIndexPropertyKeys(T, K.keys, options);
+}
+// prettier-ignore
+function IndexFromMappedKey(T, K, options) {
+    const P = MappedIndexProperties(T, K, options);
+    return MappedResult(P);
+}
+
+/** `[JavaScript]` Creates an Iterator type */
+function Iterator(items, options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Iterator',
+        type: 'Iterator',
+        items: CloneType(items),
+    };
+}
+
+/** `[Json]` Creates an Object type */
+function _Object(properties, options = {}) {
+    const propertyKeys = globalThis.Object.getOwnPropertyNames(properties);
+    const optionalKeys = propertyKeys.filter((key) => IsOptional$1(properties[key]));
+    const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name));
+    const clonedAdditionalProperties = IsSchema$1(options.additionalProperties) ? { additionalProperties: CloneType(options.additionalProperties) } : {};
+    const clonedProperties = {};
+    for (const key of propertyKeys)
+        clonedProperties[key] = CloneType(properties[key]);
+    return (requiredKeys.length > 0
+        ? { ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys }
+        : { ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties });
+}
+/** `[Json]` Creates an Object type */
+const Object$1 = _Object;
+
+/** `[JavaScript]` Creates a Promise type */
+function Promise$1(item, options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Promise',
+        type: 'Promise',
+        item: CloneType(item),
+    };
+}
+
+function RemoveReadonly(schema) {
+    return Discard(CloneType(schema), [ReadonlyKind]);
+}
+function AddReadonly(schema) {
+    return { ...CloneType(schema), [ReadonlyKind]: 'Readonly' };
+}
+// prettier-ignore
+function ReadonlyWithFlag(schema, F) {
+    return (F === false
+        ? RemoveReadonly(schema)
+        : AddReadonly(schema));
+}
+/** `[Json]` Creates a Readonly property */
+function Readonly(schema, enable) {
+    const F = enable ?? true;
+    return IsMappedResult$1(schema) ? ReadonlyFromMappedResult(schema, F) : ReadonlyWithFlag(schema, F);
+}
+
+// prettier-ignore
+function FromProperties$h(K, F) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+        Acc[K2] = Readonly(K[K2], F);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult$a(R, F) {
+    return FromProperties$h(R.properties, F);
+}
+// prettier-ignore
+function ReadonlyFromMappedResult(R, F) {
+    const P = FromMappedResult$a(R, F);
+    return MappedResult(P);
+}
+
+/** `[Json]` Creates a Tuple type */
+function Tuple(items, options = {}) {
+    // return TupleResolver.Resolve(T)
+    const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
+    // prettier-ignore
+    return (items.length > 0 ?
+        { ...options, [Kind]: 'Tuple', type: 'array', items: CloneRest(items), additionalItems, minItems, maxItems } :
+        { ...options, [Kind]: 'Tuple', type: 'array', minItems, maxItems });
+}
+
+// prettier-ignore
+function FromMappedResult$9(K, P) {
+    return (K in P
+        ? FromSchemaType(K, P[K])
+        : MappedResult(P));
+}
+// prettier-ignore
+function MappedKeyToKnownMappedResultProperties(K) {
+    return { [K]: Literal(K) };
+}
+// prettier-ignore
+function MappedKeyToUnknownMappedResultProperties(P) {
+    const Acc = {};
+    for (const L of P)
+        Acc[L] = Literal(L);
+    return Acc;
+}
+// prettier-ignore
+function MappedKeyToMappedResultProperties(K, P) {
+    return (SetIncludes(P, K)
+        ? MappedKeyToKnownMappedResultProperties(K)
+        : MappedKeyToUnknownMappedResultProperties(P));
+}
+// prettier-ignore
+function FromMappedKey$3(K, P) {
+    const R = MappedKeyToMappedResultProperties(K, P);
+    return FromMappedResult$9(K, R);
+}
+// prettier-ignore
+function FromRest$6(K, T) {
+    return T.map(L => FromSchemaType(K, L));
+}
+// prettier-ignore
+function FromProperties$g(K, T) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(T))
+        Acc[K2] = FromSchemaType(K, T[K2]);
+    return Acc;
+}
+// prettier-ignore
+function FromSchemaType(K, T) {
+    return (
+    // unevaluated modifier types
+    IsOptional$1(T) ? Optional(FromSchemaType(K, Discard(T, [OptionalKind]))) :
+        IsReadonly(T) ? Readonly(FromSchemaType(K, Discard(T, [ReadonlyKind]))) :
+            // unevaluated mapped types
+            IsMappedResult$1(T) ? FromMappedResult$9(K, T.properties) :
+                IsMappedKey$1(T) ? FromMappedKey$3(K, T.keys) :
+                    // unevaluated types
+                    IsConstructor$1(T) ? Constructor(FromRest$6(K, T.parameters), FromSchemaType(K, T.returns)) :
+                        IsFunction$1(T) ? Function(FromRest$6(K, T.parameters), FromSchemaType(K, T.returns)) :
+                            IsAsyncIterator$1(T) ? AsyncIterator(FromSchemaType(K, T.items)) :
+                                IsIterator$1(T) ? Iterator(FromSchemaType(K, T.items)) :
+                                    IsIntersect$1(T) ? Intersect(FromRest$6(K, T.allOf)) :
+                                        IsUnion$1(T) ? Union(FromRest$6(K, T.anyOf)) :
+                                            IsTuple$1(T) ? Tuple(FromRest$6(K, T.items ?? [])) :
+                                                IsObject$1(T) ? Object$1(FromProperties$g(K, T.properties)) :
+                                                    IsArray$1(T) ? Array$1(FromSchemaType(K, T.items)) :
+                                                        IsPromise$1(T) ? Promise$1(FromSchemaType(K, T.item)) :
+                                                            T);
+}
+// prettier-ignore
+function MappedFunctionReturnType(K, T) {
+    const Acc = {};
+    for (const L of K)
+        Acc[L] = FromSchemaType(L, T);
+    return Acc;
+}
+/** `[Json]` Creates a Mapped object type */
+function Mapped(key, map, options = {}) {
+    const K = IsSchema$1(key) ? IndexPropertyKeys(key) : key;
+    const RT = map({ [Kind]: 'MappedKey', keys: K });
+    const R = MappedFunctionReturnType(K, RT);
+    return CloneType(Object$1(R), options);
+}
+
+function RemoveOptional(schema) {
+    return Discard(CloneType(schema), [OptionalKind]);
+}
+function AddOptional(schema) {
+    return { ...CloneType(schema), [OptionalKind]: 'Optional' };
+}
+// prettier-ignore
+function OptionalWithFlag(schema, F) {
+    return (F === false
+        ? RemoveOptional(schema)
+        : AddOptional(schema));
+}
+/** `[Json]` Creates a Optional property */
+function Optional(schema, enable) {
+    const F = enable ?? true;
+    return IsMappedResult$1(schema) ? OptionalFromMappedResult(schema, F) : OptionalWithFlag(schema, F);
+}
+
+// prettier-ignore
+function FromProperties$f(P, F) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Optional(P[K2], F);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult$8(R, F) {
+    return FromProperties$f(R.properties, F);
+}
+// prettier-ignore
+function OptionalFromMappedResult(R, F) {
+    const P = FromMappedResult$8(R, F);
+    return MappedResult(P);
+}
+
+// ------------------------------------------------------------------
+// IntersectCreate
+// ------------------------------------------------------------------
+// prettier-ignore
+function IntersectCreate(T, options) {
+    const allObjects = T.every((schema) => IsObject$1(schema));
+    const clonedUnevaluatedProperties = IsSchema$1(options.unevaluatedProperties)
+        ? { unevaluatedProperties: CloneType(options.unevaluatedProperties) }
+        : {};
+    return ((options.unevaluatedProperties === false || IsSchema$1(options.unevaluatedProperties) || allObjects
+        ? { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: CloneRest(T) }
+        : { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', allOf: CloneRest(T) }));
+}
+
+// prettier-ignore
+function IsIntersectOptional(T) {
+    return T.every(L => IsOptional$1(L));
+}
+// prettier-ignore
+function RemoveOptionalFromType(T) {
+    return (Discard(T, [OptionalKind]));
+}
+// prettier-ignore
+function RemoveOptionalFromRest(T) {
+    return T.map(L => IsOptional$1(L) ? RemoveOptionalFromType(L) : L);
+}
+// prettier-ignore
+function ResolveIntersect(T, options) {
+    return (IsIntersectOptional(T)
+        ? Optional(IntersectCreate(RemoveOptionalFromRest(T), options))
+        : IntersectCreate(RemoveOptionalFromRest(T), options));
+}
+/** `[Json]` Creates an evaluated Intersect type */
+function IntersectEvaluated(T, options = {}) {
+    if (T.length === 0)
+        return Never(options);
+    if (T.length === 1)
+        return CloneType(T[0], options);
+    if (T.some((schema) => IsTransform$1(schema)))
+        throw new Error('Cannot intersect transform types');
+    return ResolveIntersect(T, options);
+}
+
+/** `[Json]` Creates an evaluated Intersect type */
+function Intersect(T, options = {}) {
+    if (T.length === 0)
+        return Never(options);
+    if (T.length === 1)
+        return CloneType(T[0], options);
+    if (T.some((schema) => IsTransform$1(schema)))
+        throw new Error('Cannot intersect transform types');
+    return IntersectCreate(T, options);
+}
+
+// prettier-ignore
+function FromRest$5(T) {
+    return T.map(L => AwaitedResolve(L));
+}
+// prettier-ignore
+function FromIntersect$5(T) {
+    return Intersect(FromRest$5(T));
+}
+// prettier-ignore
+function FromUnion$5(T) {
+    return Union(FromRest$5(T));
+}
+// prettier-ignore
+function FromPromise$2(T) {
+    return AwaitedResolve(T);
+}
+// ----------------------------------------------------------------
+// AwaitedResolve
+// ----------------------------------------------------------------
+// prettier-ignore
+function AwaitedResolve(T) {
+    return (IsIntersect$1(T) ? FromIntersect$5(T.allOf) :
+        IsUnion$1(T) ? FromUnion$5(T.anyOf) :
+            IsPromise$1(T) ? FromPromise$2(T.item) :
+                T);
+}
+/** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
+function Awaited(T, options = {}) {
+    return CloneType(AwaitedResolve(T), options);
+}
+
+// prettier-ignore
+function FromRest$4(T) {
+    const Acc = [];
+    for (const L of T)
+        Acc.push(KeyOfPropertyKeys(L));
+    return Acc;
+}
+// prettier-ignore
+function FromIntersect$4(T) {
+    const C = FromRest$4(T);
+    const R = SetUnionMany(C);
+    return R;
+}
+// prettier-ignore
+function FromUnion$4(T) {
+    const C = FromRest$4(T);
+    const R = SetIntersectMany(C);
+    return R;
+}
+// prettier-ignore
+function FromTuple$2(T) {
+    return T.map((_, I) => I.toString());
+}
+// prettier-ignore
+function FromArray$3(_) {
+    return (['[number]']);
+}
+// prettier-ignore
+function FromProperties$e(T) {
+    return (globalThis.Object.getOwnPropertyNames(T));
+}
+// ------------------------------------------------------------------
+// FromPatternProperties
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromPatternProperties(patternProperties) {
+    return [];
+}
+/** Returns a tuple of PropertyKeys derived from the given TSchema. */
+// prettier-ignore
+function KeyOfPropertyKeys(T) {
+    return (IsIntersect$1(T) ? FromIntersect$4(T.allOf) :
+        IsUnion$1(T) ? FromUnion$4(T.anyOf) :
+            IsTuple$1(T) ? FromTuple$2(T.items ?? []) :
+                IsArray$1(T) ? FromArray$3(T.items) :
+                    IsObject$1(T) ? FromProperties$e(T.properties) :
+                        IsRecord$1(T) ? FromPatternProperties(T.patternProperties) :
+                            []);
+}
+
+// prettier-ignore
+function KeyOfPropertyKeysToRest(T) {
+    return T.map(L => L === '[number]' ? Number() : Literal(L));
+}
+/** `[Json]` Creates a KeyOf type */
+function KeyOf(T, options = {}) {
+    if (IsMappedResult$1(T)) {
+        return KeyOfFromMappedResult(T, options);
+    }
+    else {
+        const K = KeyOfPropertyKeys(T);
+        const S = KeyOfPropertyKeysToRest(K);
+        const U = UnionEvaluated(S);
+        return CloneType(U, options);
+    }
+}
+
+// prettier-ignore
+function FromProperties$d(K, options) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+        Acc[K2] = KeyOf(K[K2], options);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult$7(R, options) {
+    return FromProperties$d(R.properties, options);
+}
+// prettier-ignore
+function KeyOfFromMappedResult(R, options) {
+    const P = FromMappedResult$7(R, options);
+    return MappedResult(P);
+}
+
+// prettier-ignore
+function CompositeKeys(T) {
+    const Acc = [];
+    for (const L of T)
+        Acc.push(...KeyOfPropertyKeys(L));
+    return SetDistinct(Acc);
+}
+// prettier-ignore
+function FilterNever(T) {
+    return T.filter(L => !IsNever$1(L));
+}
+// prettier-ignore
+function CompositeProperty(T, K) {
+    const Acc = [];
+    for (const L of T)
+        Acc.push(...IndexFromPropertyKeys(L, [K]));
+    return FilterNever(Acc);
+}
+// prettier-ignore
+function CompositeProperties(T, K) {
+    const Acc = {};
+    for (const L of K) {
+        Acc[L] = IntersectEvaluated(CompositeProperty(T, L));
+    }
+    return Acc;
+}
+// prettier-ignore
+function Composite(T, options = {}) {
+    const K = CompositeKeys(T);
+    const P = CompositeProperties(T, K);
+    const R = Object$1(P, options);
+    return R;
+}
+
+/** `[JavaScript]` Creates a Date type */
+function Date$1(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Date',
+        type: 'Date',
+    };
+}
+
+/** `[Json]` Creates a Null type */
+function Null(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Null',
+        type: 'null',
+    };
+}
+
+/** `[JavaScript]` Creates a Symbol type */
+function Symbol$1(options) {
+    return { ...options, [Kind]: 'Symbol', type: 'symbol' };
+}
+
+/** `[JavaScript]` Creates a Undefined type */
+function Undefined(options = {}) {
+    return { ...options, [Kind]: 'Undefined', type: 'undefined' };
+}
+
+/** `[JavaScript]` Creates a Uint8Array type */
+function Uint8Array$1(options = {}) {
+    return { ...options, [Kind]: 'Uint8Array', type: 'Uint8Array' };
+}
+
+/** `[Json]` Creates an Unknown type */
+function Unknown(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Unknown',
+    };
+}
+
+// prettier-ignore
+function FromArray$2(T) {
+    return T.map(L => FromValue(L, false));
+}
+// prettier-ignore
+function FromProperties$c(value) {
+    const Acc = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(value))
+        Acc[K] = Readonly(FromValue(value[K], false));
+    return Acc;
+}
+function ConditionalReadonly(T, root) {
+    return (root === true ? T : Readonly(T));
+}
+// prettier-ignore
+function FromValue(value, root) {
+    return (IsAsyncIterator$2(value) ? ConditionalReadonly(Any(), root) :
+        IsIterator$2(value) ? ConditionalReadonly(Any(), root) :
+            IsArray$2(value) ? Readonly(Tuple(FromArray$2(value))) :
+                IsUint8Array$2(value) ? Uint8Array$1() :
+                    IsDate$2(value) ? Date$1() :
+                        IsObject$2(value) ? ConditionalReadonly(Object$1(FromProperties$c(value)), root) :
+                            IsFunction$2(value) ? ConditionalReadonly(Function([], Unknown()), root) :
+                                IsUndefined$2(value) ? Undefined() :
+                                    IsNull$2(value) ? Null() :
+                                        IsSymbol$2(value) ? Symbol$1() :
+                                            IsBigInt$2(value) ? BigInt() :
+                                                IsNumber$2(value) ? Literal(value) :
+                                                    IsBoolean$2(value) ? Literal(value) :
+                                                        IsString$2(value) ? Literal(value) :
+                                                            Object$1({}));
+}
+/** `[JavaScript]` Creates a readonly const type from the given value. */
+function Const(T, options = {}) {
+    return CloneType(FromValue(T, true), options);
+}
+
+/** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
+function ConstructorParameters(schema, options = {}) {
+    return Tuple(CloneRest(schema.parameters), { ...options });
+}
+
+function FromRest$3(schema, references) {
+    return schema.map((schema) => Deref(schema, references));
+}
+// prettier-ignore
+function FromProperties$b(properties, references) {
+    const Acc = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(properties)) {
+        Acc[K] = Deref(properties[K], references);
+    }
+    return Acc;
+}
+// prettier-ignore
+function FromConstructor$1(schema, references) {
+    schema.parameters = FromRest$3(schema.parameters, references);
+    schema.returns = Deref(schema.returns, references);
+    return schema;
+}
+// prettier-ignore
+function FromFunction$1(schema, references) {
+    schema.parameters = FromRest$3(schema.parameters, references);
+    schema.returns = Deref(schema.returns, references);
+    return schema;
+}
+// prettier-ignore
+function FromIntersect$3(schema, references) {
+    schema.allOf = FromRest$3(schema.allOf, references);
+    return schema;
+}
+// prettier-ignore
+function FromUnion$3(schema, references) {
+    schema.anyOf = FromRest$3(schema.anyOf, references);
+    return schema;
+}
+// prettier-ignore
+function FromTuple$1(schema, references) {
+    if (IsUndefined$2(schema.items))
+        return schema;
+    schema.items = FromRest$3(schema.items, references);
+    return schema;
+}
+// prettier-ignore
+function FromArray$1(schema, references) {
+    schema.items = Deref(schema.items, references);
+    return schema;
+}
+// prettier-ignore
+function FromObject$1(schema, references) {
+    schema.properties = FromProperties$b(schema.properties, references);
+    return schema;
+}
+// prettier-ignore
+function FromPromise$1(schema, references) {
+    schema.item = Deref(schema.item, references);
+    return schema;
+}
+// prettier-ignore
+function FromAsyncIterator$1(schema, references) {
+    schema.items = Deref(schema.items, references);
+    return schema;
+}
+// prettier-ignore
+function FromIterator$1(schema, references) {
+    schema.items = Deref(schema.items, references);
+    return schema;
+}
+// prettier-ignore
+function FromRef(schema, references) {
+    const target = references.find(remote => remote.$id === schema.$ref);
+    if (target === undefined)
+        throw Error(`Unable to dereference schema with $id ${schema.$ref}`);
+    const discard = Discard(target, ['$id']);
+    return Deref(discard, references);
+}
+// prettier-ignore
+function DerefResolve(schema, references) {
+    return (IsConstructor$1(schema) ? FromConstructor$1(schema, references) :
+        IsFunction$1(schema) ? FromFunction$1(schema, references) :
+            IsIntersect$1(schema) ? FromIntersect$3(schema, references) :
+                IsUnion$1(schema) ? FromUnion$3(schema, references) :
+                    IsTuple$1(schema) ? FromTuple$1(schema, references) :
+                        IsArray$1(schema) ? FromArray$1(schema, references) :
+                            IsObject$1(schema) ? FromObject$1(schema, references) :
+                                IsPromise$1(schema) ? FromPromise$1(schema, references) :
+                                    IsAsyncIterator$1(schema) ? FromAsyncIterator$1(schema, references) :
+                                        IsIterator$1(schema) ? FromIterator$1(schema, references) :
+                                            IsRef$1(schema) ? FromRef(schema, references) :
+                                                schema);
+}
+// ------------------------------------------------------------------
+// TDeref
+// ------------------------------------------------------------------
+/** `[Json]` Creates a dereferenced type */
+function Deref(schema, references) {
+    return DerefResolve(CloneType(schema), CloneRest(references));
+}
+
+/** `[Json]` Creates a Enum type */
+function Enum(item, options = {}) {
+    if (IsUndefined$2(item))
+        throw new Error('Enum undefined or empty');
+    const values1 = globalThis.Object.getOwnPropertyNames(item)
+        .filter((key) => isNaN(key))
+        .map((key) => item[key]);
+    const values2 = [...new Set(values1)];
+    const anyOf = values2.map((value) => Literal(value));
+    return Union(anyOf, { ...options, [Hint]: 'Enum' });
+}
+
+class ExtendsResolverError extends TypeBoxError {
+}
+var ExtendsResult;
+(function (ExtendsResult) {
+    ExtendsResult[ExtendsResult["Union"] = 0] = "Union";
+    ExtendsResult[ExtendsResult["True"] = 1] = "True";
+    ExtendsResult[ExtendsResult["False"] = 2] = "False";
+})(ExtendsResult || (ExtendsResult = {}));
+// ------------------------------------------------------------------
+// IntoBooleanResult
+// ------------------------------------------------------------------
+// prettier-ignore
+function IntoBooleanResult(result) {
+    return result === ExtendsResult.False ? result : ExtendsResult.True;
+}
+// ------------------------------------------------------------------
+// Throw
+// ------------------------------------------------------------------
+// prettier-ignore
+function Throw(message) {
+    throw new ExtendsResolverError(message);
+}
+// ------------------------------------------------------------------
+// StructuralRight
+// ------------------------------------------------------------------
+// prettier-ignore
+function IsStructuralRight(right) {
+    return (IsNever(right) ||
+        IsIntersect(right) ||
+        IsUnion(right) ||
+        IsUnknown(right) ||
+        IsAny(right));
+}
+// prettier-ignore
+function StructuralRight(left, right) {
+    return (IsNever(right) ? FromNeverRight() :
+        IsIntersect(right) ? FromIntersectRight(left, right) :
+            IsUnion(right) ? FromUnionRight(left, right) :
+                IsUnknown(right) ? FromUnknownRight() :
+                    IsAny(right) ? FromAnyRight() :
+                        Throw('StructuralRight'));
+}
+// ------------------------------------------------------------------
+// Any
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromAnyRight(left, right) {
+    return ExtendsResult.True;
+}
+// prettier-ignore
+function FromAny(left, right) {
+    return (IsIntersect(right) ? FromIntersectRight(left, right) :
+        (IsUnion(right) && right.anyOf.some((schema) => IsAny(schema) || IsUnknown(schema))) ? ExtendsResult.True :
+            IsUnion(right) ? ExtendsResult.Union :
+                IsUnknown(right) ? ExtendsResult.True :
+                    IsAny(right) ? ExtendsResult.True :
+                        ExtendsResult.Union);
+}
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromArrayRight(left, right) {
+    return (IsUnknown(left) ? ExtendsResult.False :
+        IsAny(left) ? ExtendsResult.Union :
+            IsNever(left) ? ExtendsResult.True :
+                ExtendsResult.False);
+}
+// prettier-ignore
+function FromArray(left, right) {
+    return (IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True :
+        IsStructuralRight(right) ? StructuralRight(left, right) :
+            !IsArray(right) ? ExtendsResult.False :
+                IntoBooleanResult(Visit(left.items, right.items)));
+}
+// ------------------------------------------------------------------
+// AsyncIterator
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromAsyncIterator(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        !IsAsyncIterator(right) ? ExtendsResult.False :
+            IntoBooleanResult(Visit(left.items, right.items)));
+}
+// ------------------------------------------------------------------
+// BigInt
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromBigInt(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            IsRecord(right) ? FromRecordRight(left, right) :
+                IsBigInt(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Boolean
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromBooleanRight(left, right) {
+    return (IsLiteralBoolean(left) ? ExtendsResult.True :
+        IsBoolean(left) ? ExtendsResult.True :
+            ExtendsResult.False);
+}
+// prettier-ignore
+function FromBoolean(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            IsRecord(right) ? FromRecordRight(left, right) :
+                IsBoolean(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Constructor
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromConstructor(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            !IsConstructor(right) ? ExtendsResult.False :
+                left.parameters.length > right.parameters.length ? ExtendsResult.False :
+                    (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === ExtendsResult.True)) ? ExtendsResult.False :
+                        IntoBooleanResult(Visit(left.returns, right.returns)));
+}
+// ------------------------------------------------------------------
+// Date
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromDate(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            IsRecord(right) ? FromRecordRight(left, right) :
+                IsDate(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Function
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromFunction(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            !IsFunction(right) ? ExtendsResult.False :
+                left.parameters.length > right.parameters.length ? ExtendsResult.False :
+                    (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === ExtendsResult.True)) ? ExtendsResult.False :
+                        IntoBooleanResult(Visit(left.returns, right.returns)));
+}
+// ------------------------------------------------------------------
+// Integer
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromIntegerRight(left, right) {
+    return (IsLiteral(left) && IsNumber$2(left.const) ? ExtendsResult.True :
+        IsNumber(left) || IsInteger(left) ? ExtendsResult.True :
+            ExtendsResult.False);
+}
+// prettier-ignore
+function FromInteger(left, right) {
+    return (IsInteger(right) || IsNumber(right) ? ExtendsResult.True :
+        IsStructuralRight(right) ? StructuralRight(left, right) :
+            IsObject(right) ? FromObjectRight(left, right) :
+                IsRecord(right) ? FromRecordRight(left, right) :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Intersect
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromIntersectRight(left, right) {
+    return right.allOf.every((schema) => Visit(left, schema) === ExtendsResult.True)
+        ? ExtendsResult.True
+        : ExtendsResult.False;
+}
+// prettier-ignore
+function FromIntersect$2(left, right) {
+    return left.allOf.some((schema) => Visit(schema, right) === ExtendsResult.True)
+        ? ExtendsResult.True
+        : ExtendsResult.False;
+}
+// ------------------------------------------------------------------
+// Iterator
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromIterator(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        !IsIterator(right) ? ExtendsResult.False :
+            IntoBooleanResult(Visit(left.items, right.items)));
+}
+// ------------------------------------------------------------------
+// Literal
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromLiteral(left, right) {
+    return (IsLiteral(right) && right.const === left.const ? ExtendsResult.True :
+        IsStructuralRight(right) ? StructuralRight(left, right) :
+            IsObject(right) ? FromObjectRight(left, right) :
+                IsRecord(right) ? FromRecordRight(left, right) :
+                    IsString(right) ? FromStringRight(left) :
+                        IsNumber(right) ? FromNumberRight(left) :
+                            IsInteger(right) ? FromIntegerRight(left) :
+                                IsBoolean(right) ? FromBooleanRight(left) :
+                                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Never
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromNeverRight(left, right) {
+    return ExtendsResult.False;
+}
+// prettier-ignore
+function FromNever(left, right) {
+    return ExtendsResult.True;
+}
+// ------------------------------------------------------------------
+// Not
+// ------------------------------------------------------------------
+// prettier-ignore
+function UnwrapTNot(schema) {
+    let [current, depth] = [schema, 0];
+    while (true) {
+        if (!IsNot(current))
+            break;
+        current = current.not;
+        depth += 1;
+    }
+    return depth % 2 === 0 ? current : Unknown();
+}
+// prettier-ignore
+function FromNot(left, right) {
+    // TypeScript has no concept of negated types, and attempts to correctly check the negated
+    // type at runtime would put TypeBox at odds with TypeScripts ability to statically infer
+    // the type. Instead we unwrap to either unknown or T and continue evaluating.
+    // prettier-ignore
+    return (IsNot(left) ? Visit(UnwrapTNot(left), right) :
+        IsNot(right) ? Visit(left, UnwrapTNot(right)) :
+            Throw('Invalid fallthrough for Not'));
+}
+// ------------------------------------------------------------------
+// Null
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromNull(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            IsRecord(right) ? FromRecordRight(left, right) :
+                IsNull(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromNumberRight(left, right) {
+    return (IsLiteralNumber(left) ? ExtendsResult.True :
+        IsNumber(left) || IsInteger(left) ? ExtendsResult.True :
+            ExtendsResult.False);
+}
+// prettier-ignore
+function FromNumber(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            IsRecord(right) ? FromRecordRight(left, right) :
+                IsInteger(right) || IsNumber(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+// prettier-ignore
+function IsObjectPropertyCount(schema, count) {
+    return Object.getOwnPropertyNames(schema.properties).length === count;
+}
+// prettier-ignore
+function IsObjectStringLike(schema) {
+    return IsObjectArrayLike(schema);
+}
+// prettier-ignore
+function IsObjectSymbolLike(schema) {
+    return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'description' in schema.properties && IsUnion(schema.properties.description) && schema.properties.description.anyOf.length === 2 && ((IsString(schema.properties.description.anyOf[0]) &&
+        IsUndefined(schema.properties.description.anyOf[1])) || (IsString(schema.properties.description.anyOf[1]) &&
+        IsUndefined(schema.properties.description.anyOf[0]))));
+}
+// prettier-ignore
+function IsObjectNumberLike(schema) {
+    return IsObjectPropertyCount(schema, 0);
+}
+// prettier-ignore
+function IsObjectBooleanLike(schema) {
+    return IsObjectPropertyCount(schema, 0);
+}
+// prettier-ignore
+function IsObjectBigIntLike(schema) {
+    return IsObjectPropertyCount(schema, 0);
+}
+// prettier-ignore
+function IsObjectDateLike(schema) {
+    return IsObjectPropertyCount(schema, 0);
+}
+// prettier-ignore
+function IsObjectUint8ArrayLike(schema) {
+    return IsObjectArrayLike(schema);
+}
+// prettier-ignore
+function IsObjectFunctionLike(schema) {
+    const length = Number();
+    return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'length' in schema.properties && IntoBooleanResult(Visit(schema.properties['length'], length)) === ExtendsResult.True);
+}
+// prettier-ignore
+function IsObjectConstructorLike(schema) {
+    return IsObjectPropertyCount(schema, 0);
+}
+// prettier-ignore
+function IsObjectArrayLike(schema) {
+    const length = Number();
+    return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'length' in schema.properties && IntoBooleanResult(Visit(schema.properties['length'], length)) === ExtendsResult.True);
+}
+// prettier-ignore
+function IsObjectPromiseLike(schema) {
+    const then = Function([Any()], Any());
+    return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'then' in schema.properties && IntoBooleanResult(Visit(schema.properties['then'], then)) === ExtendsResult.True);
+}
+// ------------------------------------------------------------------
+// Property
+// ------------------------------------------------------------------
+// prettier-ignore
+function Property(left, right) {
+    return (Visit(left, right) === ExtendsResult.False ? ExtendsResult.False :
+        IsOptional(left) && !IsOptional(right) ? ExtendsResult.False :
+            ExtendsResult.True);
+}
+// prettier-ignore
+function FromObjectRight(left, right) {
+    return (IsUnknown(left) ? ExtendsResult.False :
+        IsAny(left) ? ExtendsResult.Union : (IsNever(left) ||
+            (IsLiteralString(left) && IsObjectStringLike(right)) ||
+            (IsLiteralNumber(left) && IsObjectNumberLike(right)) ||
+            (IsLiteralBoolean(left) && IsObjectBooleanLike(right)) ||
+            (IsSymbol(left) && IsObjectSymbolLike(right)) ||
+            (IsBigInt(left) && IsObjectBigIntLike(right)) ||
+            (IsString(left) && IsObjectStringLike(right)) ||
+            (IsSymbol(left) && IsObjectSymbolLike(right)) ||
+            (IsNumber(left) && IsObjectNumberLike(right)) ||
+            (IsInteger(left) && IsObjectNumberLike(right)) ||
+            (IsBoolean(left) && IsObjectBooleanLike(right)) ||
+            (IsUint8Array(left) && IsObjectUint8ArrayLike(right)) ||
+            (IsDate(left) && IsObjectDateLike(right)) ||
+            (IsConstructor(left) && IsObjectConstructorLike(right)) ||
+            (IsFunction(left) && IsObjectFunctionLike(right))) ? ExtendsResult.True :
+            (IsRecord(left) && IsString(RecordKey(left))) ? (() => {
+                // When expressing a Record with literal key values, the Record is converted into a Object with
+                // the Hint assigned as `Record`. This is used to invert the extends logic.
+                return right[Hint] === 'Record' ? ExtendsResult.True : ExtendsResult.False;
+            })() :
+                (IsRecord(left) && IsNumber(RecordKey(left))) ? (() => {
+                    return IsObjectPropertyCount(right, 0) ? ExtendsResult.True : ExtendsResult.False;
+                })() :
+                    ExtendsResult.False);
+}
+// prettier-ignore
+function FromObject(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsRecord(right) ? FromRecordRight(left, right) :
+            !IsObject(right) ? ExtendsResult.False :
+                (() => {
+                    for (const key of Object.getOwnPropertyNames(right.properties)) {
+                        if (!(key in left.properties) && !IsOptional(right.properties[key])) {
+                            return ExtendsResult.False;
+                        }
+                        if (IsOptional(right.properties[key])) {
+                            return ExtendsResult.True;
+                        }
+                        if (Property(left.properties[key], right.properties[key]) === ExtendsResult.False) {
+                            return ExtendsResult.False;
+                        }
+                    }
+                    return ExtendsResult.True;
+                })());
+}
+// ------------------------------------------------------------------
+// Promise
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromPromise(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) && IsObjectPromiseLike(right) ? ExtendsResult.True :
+            !IsPromise(right) ? ExtendsResult.False :
+                IntoBooleanResult(Visit(left.item, right.item)));
+}
+// ------------------------------------------------------------------
+// Record
+// ------------------------------------------------------------------
+// prettier-ignore
+function RecordKey(schema) {
+    return (PatternNumberExact in schema.patternProperties ? Number() :
+        PatternStringExact in schema.patternProperties ? String$1() :
+            Throw('Unknown record key pattern'));
+}
+// prettier-ignore
+function RecordValue(schema) {
+    return (PatternNumberExact in schema.patternProperties ? schema.patternProperties[PatternNumberExact] :
+        PatternStringExact in schema.patternProperties ? schema.patternProperties[PatternStringExact] :
+            Throw('Unable to get record value schema'));
+}
+// prettier-ignore
+function FromRecordRight(left, right) {
+    const [Key, Value] = [RecordKey(right), RecordValue(right)];
+    return ((IsLiteralString(left) && IsNumber(Key) && IntoBooleanResult(Visit(left, Value)) === ExtendsResult.True) ? ExtendsResult.True :
+        IsUint8Array(left) && IsNumber(Key) ? Visit(left, Value) :
+            IsString(left) && IsNumber(Key) ? Visit(left, Value) :
+                IsArray(left) && IsNumber(Key) ? Visit(left, Value) :
+                    IsObject(left) ? (() => {
+                        for (const key of Object.getOwnPropertyNames(left.properties)) {
+                            if (Property(Value, left.properties[key]) === ExtendsResult.False) {
+                                return ExtendsResult.False;
+                            }
+                        }
+                        return ExtendsResult.True;
+                    })() :
+                        ExtendsResult.False);
+}
+// prettier-ignore
+function FromRecord(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            !IsRecord(right) ? ExtendsResult.False :
+                Visit(RecordValue(left), RecordValue(right)));
+}
+// ------------------------------------------------------------------
+// RegExp
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromRegExp(left, right) {
+    // Note: RegExp types evaluate as strings, not RegExp objects.
+    // Here we remap either into string and continue evaluating.
+    const L = IsRegExp(left) ? String$1() : left;
+    const R = IsRegExp(right) ? String$1() : right;
+    return Visit(L, R);
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromStringRight(left, right) {
+    return (IsLiteral(left) && IsString$2(left.const) ? ExtendsResult.True :
+        IsString(left) ? ExtendsResult.True :
+            ExtendsResult.False);
+}
+// prettier-ignore
+function FromString(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            IsRecord(right) ? FromRecordRight(left, right) :
+                IsString(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Symbol
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromSymbol(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            IsRecord(right) ? FromRecordRight(left, right) :
+                IsSymbol(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// TemplateLiteral
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromTemplateLiteral$1(left, right) {
+    // TemplateLiteral types are resolved to either unions for finite expressions or string
+    // for infinite expressions. Here we call to TemplateLiteralResolver to resolve for
+    // either type and continue evaluating.
+    return (IsTemplateLiteral(left) ? Visit(TemplateLiteralToUnion(left), right) :
+        IsTemplateLiteral(right) ? Visit(left, TemplateLiteralToUnion(right)) :
+            Throw('Invalid fallthrough for TemplateLiteral'));
+}
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+// prettier-ignore
+function IsArrayOfTuple(left, right) {
+    return (IsArray(right) &&
+        left.items !== undefined &&
+        left.items.every((schema) => Visit(schema, right.items) === ExtendsResult.True));
+}
+// prettier-ignore
+function FromTupleRight(left, right) {
+    return (IsNever(left) ? ExtendsResult.True :
+        IsUnknown(left) ? ExtendsResult.False :
+            IsAny(left) ? ExtendsResult.Union :
+                ExtendsResult.False);
+}
+// prettier-ignore
+function FromTuple(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True :
+            IsArray(right) && IsArrayOfTuple(left, right) ? ExtendsResult.True :
+                !IsTuple(right) ? ExtendsResult.False :
+                    (IsUndefined$2(left.items) && !IsUndefined$2(right.items)) || (!IsUndefined$2(left.items) && IsUndefined$2(right.items)) ? ExtendsResult.False :
+                        (IsUndefined$2(left.items) && !IsUndefined$2(right.items)) ? ExtendsResult.True :
+                            left.items.every((schema, index) => Visit(schema, right.items[index]) === ExtendsResult.True) ? ExtendsResult.True :
+                                ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Uint8Array
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromUint8Array(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            IsRecord(right) ? FromRecordRight(left, right) :
+                IsUint8Array(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Undefined
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromUndefined(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        IsObject(right) ? FromObjectRight(left, right) :
+            IsRecord(right) ? FromRecordRight(left, right) :
+                IsVoid(right) ? FromVoidRight(left) :
+                    IsUndefined(right) ? ExtendsResult.True :
+                        ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromUnionRight(left, right) {
+    return right.anyOf.some((schema) => Visit(left, schema) === ExtendsResult.True)
+        ? ExtendsResult.True
+        : ExtendsResult.False;
+}
+// prettier-ignore
+function FromUnion$2(left, right) {
+    return left.anyOf.every((schema) => Visit(schema, right) === ExtendsResult.True)
+        ? ExtendsResult.True
+        : ExtendsResult.False;
+}
+// ------------------------------------------------------------------
+// Unknown
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromUnknownRight(left, right) {
+    return ExtendsResult.True;
+}
+// prettier-ignore
+function FromUnknown(left, right) {
+    return (IsNever(right) ? FromNeverRight() :
+        IsIntersect(right) ? FromIntersectRight(left, right) :
+            IsUnion(right) ? FromUnionRight(left, right) :
+                IsAny(right) ? FromAnyRight() :
+                    IsString(right) ? FromStringRight(left) :
+                        IsNumber(right) ? FromNumberRight(left) :
+                            IsInteger(right) ? FromIntegerRight(left) :
+                                IsBoolean(right) ? FromBooleanRight(left) :
+                                    IsArray(right) ? FromArrayRight(left) :
+                                        IsTuple(right) ? FromTupleRight(left) :
+                                            IsObject(right) ? FromObjectRight(left, right) :
+                                                IsUnknown(right) ? ExtendsResult.True :
+                                                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Void
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromVoidRight(left, right) {
+    return (IsUndefined(left) ? ExtendsResult.True :
+        IsUndefined(left) ? ExtendsResult.True :
+            ExtendsResult.False);
+}
+// prettier-ignore
+function FromVoid(left, right) {
+    return (IsIntersect(right) ? FromIntersectRight(left, right) :
+        IsUnion(right) ? FromUnionRight(left, right) :
+            IsUnknown(right) ? FromUnknownRight() :
+                IsAny(right) ? FromAnyRight() :
+                    IsObject(right) ? FromObjectRight(left, right) :
+                        IsVoid(right) ? ExtendsResult.True :
+                            ExtendsResult.False);
+}
+// prettier-ignore
+function Visit(left, right) {
+    return (
+    // resolvable
+    (IsTemplateLiteral(left) || IsTemplateLiteral(right)) ? FromTemplateLiteral$1(left, right) :
+        (IsRegExp(left) || IsRegExp(right)) ? FromRegExp(left, right) :
+            (IsNot(left) || IsNot(right)) ? FromNot(left, right) :
+                // standard
+                IsAny(left) ? FromAny(left, right) :
+                    IsArray(left) ? FromArray(left, right) :
+                        IsBigInt(left) ? FromBigInt(left, right) :
+                            IsBoolean(left) ? FromBoolean(left, right) :
+                                IsAsyncIterator(left) ? FromAsyncIterator(left, right) :
+                                    IsConstructor(left) ? FromConstructor(left, right) :
+                                        IsDate(left) ? FromDate(left, right) :
+                                            IsFunction(left) ? FromFunction(left, right) :
+                                                IsInteger(left) ? FromInteger(left, right) :
+                                                    IsIntersect(left) ? FromIntersect$2(left, right) :
+                                                        IsIterator(left) ? FromIterator(left, right) :
+                                                            IsLiteral(left) ? FromLiteral(left, right) :
+                                                                IsNever(left) ? FromNever() :
+                                                                    IsNull(left) ? FromNull(left, right) :
+                                                                        IsNumber(left) ? FromNumber(left, right) :
+                                                                            IsObject(left) ? FromObject(left, right) :
+                                                                                IsRecord(left) ? FromRecord(left, right) :
+                                                                                    IsString(left) ? FromString(left, right) :
+                                                                                        IsSymbol(left) ? FromSymbol(left, right) :
+                                                                                            IsTuple(left) ? FromTuple(left, right) :
+                                                                                                IsPromise(left) ? FromPromise(left, right) :
+                                                                                                    IsUint8Array(left) ? FromUint8Array(left, right) :
+                                                                                                        IsUndefined(left) ? FromUndefined(left, right) :
+                                                                                                            IsUnion(left) ? FromUnion$2(left, right) :
+                                                                                                                IsUnknown(left) ? FromUnknown(left, right) :
+                                                                                                                    IsVoid(left) ? FromVoid(left, right) :
+                                                                                                                        Throw(`Unknown left type operand '${left[Kind]}'`));
+}
+function ExtendsCheck(left, right) {
+    return Visit(left, right);
+}
+
+// prettier-ignore
+function FromProperties$a(P, Right, True, False, options) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Extends(P[K2], Right, True, False, options);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult$6(Left, Right, True, False, options) {
+    return FromProperties$a(Left.properties, Right, True, False, options);
+}
+// prettier-ignore
+function ExtendsFromMappedResult(Left, Right, True, False, options) {
+    const P = FromMappedResult$6(Left, Right, True, False, options);
+    return MappedResult(P);
+}
+
+// prettier-ignore
+function ExtendsResolve(left, right, trueType, falseType) {
+    const R = ExtendsCheck(left, right);
+    return (R === ExtendsResult.Union ? Union([trueType, falseType]) :
+        R === ExtendsResult.True ? trueType :
+            falseType);
+}
+/** `[Json]` Creates a Conditional type */
+function Extends(L, R, T, F, options = {}) {
+    // prettier-ignore
+    return (IsMappedResult$1(L) ? ExtendsFromMappedResult(L, R, T, F, options) :
+        IsMappedKey$1(L) ? CloneType(ExtendsFromMappedKey(L, R, T, F, options)) :
+            CloneType(ExtendsResolve(L, R, T, F), options));
+}
+
+// prettier-ignore
+function FromPropertyKey$2(K, U, L, R, options) {
+    return {
+        [K]: Extends(Literal(K), U, L, R, options)
+    };
+}
+// prettier-ignore
+function FromPropertyKeys$2(K, U, L, R, options) {
+    return K.reduce((Acc, LK) => {
+        return { ...Acc, ...FromPropertyKey$2(LK, U, L, R, options) };
+    }, {});
+}
+// prettier-ignore
+function FromMappedKey$2(K, U, L, R, options) {
+    return FromPropertyKeys$2(K.keys, U, L, R, options);
+}
+// prettier-ignore
+function ExtendsFromMappedKey(T, U, L, R, options) {
+    const P = FromMappedKey$2(T, U, L, R, options);
+    return MappedResult(P);
+}
+
+function ExcludeFromTemplateLiteral(L, R) {
+    return Exclude(TemplateLiteralToUnion(L), R);
+}
+
+function ExcludeRest(L, R) {
+    const excluded = L.filter((inner) => ExtendsCheck(inner, R) === ExtendsResult.False);
+    return excluded.length === 1 ? excluded[0] : Union(excluded);
+}
+/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+function Exclude(L, R, options = {}) {
+    // overloads
+    if (IsTemplateLiteral$1(L))
+        return CloneType(ExcludeFromTemplateLiteral(L, R), options);
+    if (IsMappedResult$1(L))
+        return CloneType(ExcludeFromMappedResult(L, R), options);
+    // prettier-ignore
+    return CloneType(IsUnion$1(L) ? ExcludeRest(L.anyOf, R) :
+        ExtendsCheck(L, R) !== ExtendsResult.False ? Never() : L, options);
+}
+
+// prettier-ignore
+function FromProperties$9(P, U) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Exclude(P[K2], U);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult$5(R, T) {
+    return FromProperties$9(R.properties, T);
+}
+// prettier-ignore
+function ExcludeFromMappedResult(R, T) {
+    const P = FromMappedResult$5(R, T);
+    return MappedResult(P);
+}
+
+function ExtractFromTemplateLiteral(L, R) {
+    return Extract(TemplateLiteralToUnion(L), R);
+}
+
+function ExtractRest(L, R) {
+    const extracted = L.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False);
+    return extracted.length === 1 ? extracted[0] : Union(extracted);
+}
+/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+function Extract(L, R, options = {}) {
+    // overloads
+    if (IsTemplateLiteral$1(L))
+        return CloneType(ExtractFromTemplateLiteral(L, R), options);
+    if (IsMappedResult$1(L))
+        return CloneType(ExtractFromMappedResult(L, R), options);
+    // prettier-ignore
+    return CloneType(IsUnion$1(L) ? ExtractRest(L.anyOf, R) :
+        ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never(), options);
+}
+
+// prettier-ignore
+function FromProperties$8(P, T) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Extract(P[K2], T);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult$4(R, T) {
+    return FromProperties$8(R.properties, T);
+}
+// prettier-ignore
+function ExtractFromMappedResult(R, T) {
+    const P = FromMappedResult$4(R, T);
+    return MappedResult(P);
+}
+
+/** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
+function InstanceType(schema, options = {}) {
+    return CloneType(schema.returns, options);
+}
+
+/** `[Json]` Creates an Integer type */
+function Integer(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Integer',
+        type: 'integer',
+    };
+}
+
+// prettier-ignore
+function MappedIntrinsicPropertyKey(K, M, options) {
+    return {
+        [K]: Intrinsic(Literal(K), M, options)
+    };
+}
+// prettier-ignore
+function MappedIntrinsicPropertyKeys(K, M, options) {
+    return K.reduce((Acc, L) => {
+        return { ...Acc, ...MappedIntrinsicPropertyKey(L, M, options) };
+    }, {});
+}
+// prettier-ignore
+function MappedIntrinsicProperties(T, M, options) {
+    return MappedIntrinsicPropertyKeys(T['keys'], M, options);
+}
+// prettier-ignore
+function IntrinsicFromMappedKey(T, M, options) {
+    const P = MappedIntrinsicProperties(T, M, options);
+    return MappedResult(P);
+}
+
+// ------------------------------------------------------------------
+// Apply
+// ------------------------------------------------------------------
+function ApplyUncapitalize(value) {
+    const [first, rest] = [value.slice(0, 1), value.slice(1)];
+    return [first.toLowerCase(), rest].join('');
+}
+function ApplyCapitalize(value) {
+    const [first, rest] = [value.slice(0, 1), value.slice(1)];
+    return [first.toUpperCase(), rest].join('');
+}
+function ApplyUppercase(value) {
+    return value.toUpperCase();
+}
+function ApplyLowercase(value) {
+    return value.toLowerCase();
+}
+function FromTemplateLiteral(schema, mode, options) {
+    // note: template literals require special runtime handling as they are encoded in string patterns.
+    // This diverges from the mapped type which would otherwise map on the template literal kind.
+    const expression = TemplateLiteralParseExact(schema.pattern);
+    const finite = IsTemplateLiteralExpressionFinite(expression);
+    if (!finite)
+        return { ...schema, pattern: FromLiteralValue(schema.pattern, mode) };
+    const strings = [...TemplateLiteralExpressionGenerate(expression)];
+    const literals = strings.map((value) => Literal(value));
+    const mapped = FromRest$2(literals, mode);
+    const union = Union(mapped);
+    return TemplateLiteral([union], options);
+}
+// prettier-ignore
+function FromLiteralValue(value, mode) {
+    return (typeof value === 'string' ? (mode === 'Uncapitalize' ? ApplyUncapitalize(value) :
+        mode === 'Capitalize' ? ApplyCapitalize(value) :
+            mode === 'Uppercase' ? ApplyUppercase(value) :
+                mode === 'Lowercase' ? ApplyLowercase(value) :
+                    value) : value.toString());
+}
+// prettier-ignore
+function FromRest$2(T, M) {
+    return T.map(L => Intrinsic(L, M));
+}
+/** Applies an intrinsic string manipulation to the given type. */
+function Intrinsic(schema, mode, options = {}) {
+    // prettier-ignore
+    return (
+    // Intrinsic-Mapped-Inference
+    IsMappedKey$1(schema) ? IntrinsicFromMappedKey(schema, mode, options) :
+        // Standard-Inference
+        IsTemplateLiteral$1(schema) ? FromTemplateLiteral(schema, mode, schema) :
+            IsUnion$1(schema) ? Union(FromRest$2(schema.anyOf, mode), options) :
+                IsLiteral$1(schema) ? Literal(FromLiteralValue(schema.const, mode), options) :
+                    schema);
+}
+
+/** `[Json]` Intrinsic function to Capitalize LiteralString types */
+function Capitalize(T, options = {}) {
+    return Intrinsic(T, 'Capitalize', options);
+}
+
+/** `[Json]` Intrinsic function to Lowercase LiteralString types */
+function Lowercase(T, options = {}) {
+    return Intrinsic(T, 'Lowercase', options);
+}
+
+/** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
+function Uncapitalize(T, options = {}) {
+    return Intrinsic(T, 'Uncapitalize', options);
+}
+
+/** `[Json]` Intrinsic function to Uppercase LiteralString types */
+function Uppercase(T, options = {}) {
+    return Intrinsic(T, 'Uppercase', options);
+}
+
+/** `[Json]` Creates a Not type */
+function Not(schema, options) {
+    return {
+        ...options,
+        [Kind]: 'Not',
+        not: CloneType(schema),
+    };
+}
+
+// prettier-ignore
+function FromProperties$7(P, K, options) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Omit(P[K2], K, options);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult$3(R, K, options) {
+    return FromProperties$7(R.properties, K, options);
+}
+// prettier-ignore
+function OmitFromMappedResult(R, K, options) {
+    const P = FromMappedResult$3(R, K, options);
+    return MappedResult(P);
+}
+
+// prettier-ignore
+function FromIntersect$1(T, K) {
+    return T.map((T) => OmitResolve(T, K));
+}
+// prettier-ignore
+function FromUnion$1(T, K) {
+    return T.map((T) => OmitResolve(T, K));
+}
+// ------------------------------------------------------------------
+// FromProperty
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromProperty(T, K) {
+    const { [K]: _, ...R } = T;
+    return R;
+}
+// prettier-ignore
+function FromProperties$6(T, K) {
+    return K.reduce((T, K2) => FromProperty(T, K2), T);
+}
+// ------------------------------------------------------------------
+// OmitResolve
+// ------------------------------------------------------------------
+// prettier-ignore
+function OmitResolve(T, K) {
+    return (IsIntersect$1(T) ? Intersect(FromIntersect$1(T.allOf, K)) :
+        IsUnion$1(T) ? Union(FromUnion$1(T.anyOf, K)) :
+            IsObject$1(T) ? Object$1(FromProperties$6(T.properties, K)) :
+                Object$1({}));
+}
+function Omit(T, K, options = {}) {
+    // mapped
+    if (IsMappedKey$1(K))
+        return OmitFromMappedKey(T, K, options);
+    if (IsMappedResult$1(T))
+        return OmitFromMappedResult(T, K, options);
+    // non-mapped
+    const I = IsSchema$1(K) ? IndexPropertyKeys(K) : K;
+    const D = Discard(T, [TransformKind, '$id', 'required']);
+    const R = CloneType(OmitResolve(T, I), options);
+    return { ...D, ...R };
+}
+
+// prettier-ignore
+function FromPropertyKey$1(T, K, options) {
+    return {
+        [K]: Omit(T, [K], options)
+    };
+}
+// prettier-ignore
+function FromPropertyKeys$1(T, K, options) {
+    return K.reduce((Acc, LK) => {
+        return { ...Acc, ...FromPropertyKey$1(T, LK, options) };
+    }, {});
+}
+// prettier-ignore
+function FromMappedKey$1(T, K, options) {
+    return FromPropertyKeys$1(T, K.keys, options);
+}
+// prettier-ignore
+function OmitFromMappedKey(T, K, options) {
+    const P = FromMappedKey$1(T, K, options);
+    return MappedResult(P);
+}
+
+/** `[JavaScript]` Extracts the Parameters from the given Function type */
+function Parameters(schema, options = {}) {
+    return Tuple(CloneRest(schema.parameters), { ...options });
+}
+
+// prettier-ignore
+function FromRest$1(T) {
+    return T.map(L => PartialResolve(L));
+}
+// prettier-ignore
+function FromProperties$5(T) {
+    const Acc = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(T))
+        Acc[K] = Optional(T[K]);
+    return Acc;
+}
+// ------------------------------------------------------------------
+// PartialResolve
+// ------------------------------------------------------------------
+// prettier-ignore
+function PartialResolve(T) {
+    return (IsIntersect$1(T) ? Intersect(FromRest$1(T.allOf)) :
+        IsUnion$1(T) ? Union(FromRest$1(T.anyOf)) :
+            IsObject$1(T) ? Object$1(FromProperties$5(T.properties)) :
+                Object$1({}));
+}
+/** `[Json]` Constructs a type where all properties are optional */
+function Partial(T, options = {}) {
+    if (IsMappedResult$1(T))
+        return PartialFromMappedResult(T, options);
+    const D = Discard(T, [TransformKind, '$id', 'required']);
+    const R = CloneType(PartialResolve(T), options);
+    return { ...D, ...R };
+}
+
+// prettier-ignore
+function FromProperties$4(K, options) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+        Acc[K2] = Partial(K[K2], options);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult$2(R, options) {
+    return FromProperties$4(R.properties, options);
+}
+// prettier-ignore
+function PartialFromMappedResult(R, options) {
+    const P = FromMappedResult$2(R, options);
+    return MappedResult(P);
+}
+
+// prettier-ignore
+function FromProperties$3(P, K, options) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Pick(P[K2], K, options);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult$1(R, K, options) {
+    return FromProperties$3(R.properties, K, options);
+}
+// prettier-ignore
+function PickFromMappedResult(R, K, options) {
+    const P = FromMappedResult$1(R, K, options);
+    return MappedResult(P);
+}
+
+function FromIntersect(T, K) {
+    return T.map((T) => PickResolve(T, K));
+}
+// prettier-ignore
+function FromUnion(T, K) {
+    return T.map((T) => PickResolve(T, K));
+}
+// prettier-ignore
+function FromProperties$2(T, K) {
+    const Acc = {};
+    for (const K2 of K)
+        if (K2 in T)
+            Acc[K2] = T[K2];
+    return Acc;
+}
+// ------------------------------------------------------------------
+// PickResolve
+// ------------------------------------------------------------------
+// prettier-ignore
+function PickResolve(T, K) {
+    return (IsIntersect$1(T) ? Intersect(FromIntersect(T.allOf, K)) :
+        IsUnion$1(T) ? Union(FromUnion(T.anyOf, K)) :
+            IsObject$1(T) ? Object$1(FromProperties$2(T.properties, K)) :
+                Object$1({}));
+}
+function Pick(T, K, options = {}) {
+    // mapped
+    if (IsMappedKey$1(K))
+        return PickFromMappedKey(T, K, options);
+    if (IsMappedResult$1(T))
+        return PickFromMappedResult(T, K, options);
+    // non-mapped
+    const I = IsSchema$1(K) ? IndexPropertyKeys(K) : K;
+    const D = Discard(T, [TransformKind, '$id', 'required']);
+    const R = CloneType(PickResolve(T, I), options);
+    return { ...D, ...R };
+}
+
+// prettier-ignore
+function FromPropertyKey(T, K, options) {
+    return {
+        [K]: Pick(T, [K], options)
+    };
+}
+// prettier-ignore
+function FromPropertyKeys(T, K, options) {
+    return K.reduce((Acc, LK) => {
+        return { ...Acc, ...FromPropertyKey(T, LK, options) };
+    }, {});
+}
+// prettier-ignore
+function FromMappedKey(T, K, options) {
+    return FromPropertyKeys(T, K.keys, options);
+}
+// prettier-ignore
+function PickFromMappedKey(T, K, options) {
+    const P = FromMappedKey(T, K, options);
+    return MappedResult(P);
+}
+
+/** `[Json]` Creates a Readonly and Optional property */
+function ReadonlyOptional(schema) {
+    return Readonly(Optional(schema));
+}
+
+// ------------------------------------------------------------------
+// RecordCreateFromPattern
+// ------------------------------------------------------------------
+// prettier-ignore
+function RecordCreateFromPattern(pattern, T, options) {
+    return {
+        ...options,
+        [Kind]: 'Record',
+        type: 'object',
+        patternProperties: { [pattern]: CloneType(T) }
+    };
+}
+// ------------------------------------------------------------------
+// RecordCreateFromKeys
+// ------------------------------------------------------------------
+// prettier-ignore
+function RecordCreateFromKeys(K, T, options) {
+    const Acc = {};
+    for (const K2 of K)
+        Acc[K2] = CloneType(T);
+    return Object$1(Acc, { ...options, [Hint]: 'Record' });
+}
+// prettier-ignore
+function FromTemplateLiteralKey(K, T, options) {
+    return (IsTemplateLiteralFinite(K)
+        ? RecordCreateFromKeys(IndexPropertyKeys(K), T, options)
+        : RecordCreateFromPattern(K.pattern, T, options));
+}
+// prettier-ignore
+function FromUnionKey(K, T, options) {
+    return RecordCreateFromKeys(IndexPropertyKeys(Union(K)), T, options);
+}
+// prettier-ignore
+function FromLiteralKey(K, T, options) {
+    return RecordCreateFromKeys([K.toString()], T, options);
+}
+// prettier-ignore
+function FromRegExpKey(K, T, options) {
+    return RecordCreateFromPattern(K.source, T, options);
+}
+// prettier-ignore
+function FromStringKey(K, T, options) {
+    const pattern = IsUndefined$2(K.pattern) ? PatternStringExact : K.pattern;
+    return RecordCreateFromPattern(pattern, T, options);
+}
+// prettier-ignore
+function FromAnyKey(K, T, options) {
+    return RecordCreateFromPattern(PatternStringExact, T, options);
+}
+// prettier-ignore
+function FromNeverKey(K, T, options) {
+    return RecordCreateFromPattern(PatternNeverExact, T, options);
+}
+// prettier-ignore
+function FromIntegerKey(_, T, options) {
+    return RecordCreateFromPattern(PatternNumberExact, T, options);
+}
+// prettier-ignore
+function FromNumberKey(_, T, options) {
+    return RecordCreateFromPattern(PatternNumberExact, T, options);
+}
+// ------------------------------------------------------------------
+// TRecordOrObject
+// ------------------------------------------------------------------
+/** `[Json]` Creates a Record type */
+function Record(K, T, options = {}) {
+    // prettier-ignore
+    return (IsUnion$1(K) ? FromUnionKey(K.anyOf, T, options) :
+        IsTemplateLiteral$1(K) ? FromTemplateLiteralKey(K, T, options) :
+            IsLiteral$1(K) ? FromLiteralKey(K.const, T, options) :
+                IsInteger$1(K) ? FromIntegerKey(K, T, options) :
+                    IsNumber$1(K) ? FromNumberKey(K, T, options) :
+                        IsRegExp$1(K) ? FromRegExpKey(K, T, options) :
+                            IsString$1(K) ? FromStringKey(K, T, options) :
+                                IsAny$1(K) ? FromAnyKey(K, T, options) :
+                                    IsNever$1(K) ? FromNeverKey(K, T, options) :
+                                        Never(options));
+}
+
+// Auto Tracked For Recursive Types without ID's
+let Ordinal = 0;
+/** `[Json]` Creates a Recursive type */
+function Recursive(callback, options = {}) {
+    if (IsUndefined$2(options.$id))
+        options.$id = `T${Ordinal++}`;
+    const thisType = callback({ [Kind]: 'This', $ref: `${options.$id}` });
+    thisType.$id = options.$id;
+    // prettier-ignore
+    return CloneType({ ...options, [Hint]: 'Recursive', ...thisType });
+}
+
+/** `[Json]` Creates a Ref type. */
+function Ref(unresolved, options = {}) {
+    if (IsString$2(unresolved))
+        return { ...options, [Kind]: 'Ref', $ref: unresolved };
+    if (IsUndefined$2(unresolved.$id))
+        throw new Error('Reference target type must specify an $id');
+    return {
+        ...options,
+        [Kind]: 'Ref',
+        $ref: unresolved.$id,
+    };
+}
+
+/** `[JavaScript]` Creates a RegExp type */
+function RegExp$1(unresolved, options = {}) {
+    const expr = IsString$2(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
+    return { ...options, [Kind]: 'RegExp', type: 'RegExp', source: expr.source, flags: expr.flags };
+}
+
+// prettier-ignore
+function FromRest(T) {
+    return T.map(L => RequiredResolve(L));
+}
+// prettier-ignore
+function FromProperties$1(T) {
+    const Acc = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(T))
+        Acc[K] = Discard(T[K], [OptionalKind]);
+    return Acc;
+}
+// ------------------------------------------------------------------
+// RequiredResolve
+// ------------------------------------------------------------------
+// prettier-ignore
+function RequiredResolve(T) {
+    return (IsIntersect$1(T) ? Intersect(FromRest(T.allOf)) :
+        IsUnion$1(T) ? Union(FromRest(T.anyOf)) :
+            IsObject$1(T) ? Object$1(FromProperties$1(T.properties)) :
+                Object$1({}));
+}
+/** `[Json]` Constructs a type where all properties are required */
+function Required(T, options = {}) {
+    if (IsMappedResult$1(T)) {
+        return RequiredFromMappedResult(T, options);
+    }
+    else {
+        const D = Discard(T, [TransformKind, '$id', 'required']);
+        const R = CloneType(RequiredResolve(T), options);
+        return { ...D, ...R };
+    }
+}
+
+// prettier-ignore
+function FromProperties(P, options) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Required(P[K2], options);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult(R, options) {
+    return FromProperties(R.properties, options);
+}
+// prettier-ignore
+function RequiredFromMappedResult(R, options) {
+    const P = FromMappedResult(R, options);
+    return MappedResult(P);
+}
+
+// prettier-ignore
+function RestResolve(T) {
+    return (IsIntersect$1(T) ? CloneRest(T.allOf) :
+        IsUnion$1(T) ? CloneRest(T.anyOf) :
+            IsTuple$1(T) ? CloneRest(T.items ?? []) :
+                []);
+}
+/** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
+function Rest(T) {
+    return CloneRest(RestResolve(T));
+}
+
+/** `[JavaScript]` Extracts the ReturnType from the given Function type */
+function ReturnType(schema, options = {}) {
+    return CloneType(schema.returns, options);
+}
+
+/** `[Json]` Omits compositing symbols from this schema. */
+function Strict(schema) {
+    return JSON.parse(JSON.stringify(schema));
+}
+
+// ------------------------------------------------------------------
+// TransformBuilders
+// ------------------------------------------------------------------
+class TransformDecodeBuilder {
+    constructor(schema) {
+        this.schema = schema;
+    }
+    Decode(decode) {
+        return new TransformEncodeBuilder(this.schema, decode);
+    }
+}
+// prettier-ignore
+class TransformEncodeBuilder {
+    constructor(schema, decode) {
+        this.schema = schema;
+        this.decode = decode;
+    }
+    EncodeTransform(encode, schema) {
+        const Encode = (value) => schema[TransformKind].Encode(encode(value));
+        const Decode = (value) => this.decode(schema[TransformKind].Decode(value));
+        const Codec = { Encode: Encode, Decode: Decode };
+        return { ...schema, [TransformKind]: Codec };
+    }
+    EncodeSchema(encode, schema) {
+        const Codec = { Decode: this.decode, Encode: encode };
+        return { ...schema, [TransformKind]: Codec };
+    }
+    Encode(encode) {
+        const schema = CloneType(this.schema);
+        return (IsTransform$1(schema) ? this.EncodeTransform(encode, schema) : this.EncodeSchema(encode, schema));
+    }
+}
+/** `[Json]` Creates a Transform type */
+function Transform(schema) {
+    return new TransformDecodeBuilder(schema);
+}
+
+/** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
+function Unsafe(options = {}) {
+    return {
+        ...options,
+        [Kind]: options[Kind] ?? 'Unsafe',
+    };
+}
+
+/** `[JavaScript]` Creates a Void type */
+function Void(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Void',
+        type: 'void',
+    };
+}
+
+// ------------------------------------------------------------------
+// Type: Module
+// ------------------------------------------------------------------
+
+var TypeBuilder = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    Any: Any,
+    Array: Array$1,
+    AsyncIterator: AsyncIterator,
+    Awaited: Awaited,
+    BigInt: BigInt,
+    Boolean: Boolean,
+    Capitalize: Capitalize,
+    Composite: Composite,
+    Const: Const,
+    Constructor: Constructor,
+    ConstructorParameters: ConstructorParameters,
+    Date: Date$1,
+    Deref: Deref,
+    Enum: Enum,
+    Exclude: Exclude,
+    Extends: Extends,
+    Extract: Extract,
+    Function: Function,
+    Index: Index,
+    InstanceType: InstanceType,
+    Integer: Integer,
+    Intersect: Intersect,
+    Iterator: Iterator,
+    KeyOf: KeyOf,
+    Literal: Literal,
+    Lowercase: Lowercase,
+    Mapped: Mapped,
+    Never: Never,
+    Not: Not,
+    Null: Null,
+    Number: Number,
+    Object: Object$1,
+    Omit: Omit,
+    Optional: Optional,
+    Parameters: Parameters,
+    Partial: Partial,
+    Pick: Pick,
+    Promise: Promise$1,
+    Readonly: Readonly,
+    ReadonlyOptional: ReadonlyOptional,
+    Record: Record,
+    Recursive: Recursive,
+    Ref: Ref,
+    RegExp: RegExp$1,
+    Required: Required,
+    Rest: Rest,
+    ReturnType: ReturnType,
+    Strict: Strict,
+    String: String$1,
+    Symbol: Symbol$1,
+    TemplateLiteral: TemplateLiteral,
+    Transform: Transform,
+    Tuple: Tuple,
+    Uint8Array: Uint8Array$1,
+    Uncapitalize: Uncapitalize,
+    Undefined: Undefined,
+    Union: Union,
+    Unknown: Unknown,
+    Unsafe: Unsafe,
+    Uppercase: Uppercase,
+    Void: Void
+});
+
+// ------------------------------------------------------------------
+// JsonTypeBuilder
+// ------------------------------------------------------------------
+/** JavaScript Type Builder with Static Resolution for TypeScript */
+const Type = TypeBuilder;
+
+/**
+ * commanderclaw_nodes tool
+ */
+function createNodesTool(getClient) {
+    return {
+        name: "commanderclaw_nodes",
+        description: "List all nodes connected to the CommanderClaw cluster. Use this to see available nodes, their status, roles, and capabilities.",
+        parameters: Type.Object({}),
+        async execute() {
+            const client = getClient();
+            if (!client?.isConnected()) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Not connected to CommanderClaw server. Check plugin configuration.",
+                        },
+                    ],
+                };
+            }
+            try {
+                const nodes = await client.listNodes();
+                const currentNode = client.getNodeId();
+                const commanderId = client.getCommanderId();
+                let text = `## CommanderClaw Cluster Nodes\n\n`;
+                text += `**Total nodes:** ${nodes.length}\n`;
+                text += `**Commander:** ${commanderId || "None elected"}\n`;
+                text += `**Current node:** ${currentNode || "Unknown"}\n\n`;
+                if (nodes.length === 0) {
+                    text += "No nodes connected to the cluster.\n";
+                }
+                else {
+                    for (const node of nodes) {
+                        const isCommander = node.id === commanderId;
+                        const isCurrent = node.id === currentNode;
+                        const marker = isCurrent ? " (you)" : "";
+                        const roleMarker = isCommander ? " 👑 Commander" : "";
+                        text += `### ${node.name || node.id}${marker}${roleMarker}\n`;
+                        text += `- **Status:** ${node.status}\n`;
+                        text += `- **Role:** ${node.role}\n`;
+                        text += `- **Load:** ${node.load}\n`;
+                        if (node.capabilities?.length) {
+                            text += `- **Capabilities:** ${node.capabilities.join(", ")}\n`;
+                        }
+                        text += "\n";
+                    }
+                }
+                return { content: [{ type: "text", text }] };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Failed to list nodes: ${error instanceof Error ? error.message : String(error)}`,
+                        },
+                    ],
+                };
+            }
+        },
+    };
+}
+
+/**
+ * commanderclaw_task tool
+ */
+function createTaskTool(getClient) {
+    return {
+        name: "commanderclaw_task",
+        description: `Create, query, or manage tasks on the CommanderClaw cluster.
+
+Actions:
+- create: Create a new task with a name and optional description, priority, input, and target node
+- list: List all tasks in the cluster
+- get: Get details of a specific task by ID
+- abort: Abort a running task
+- pause: Pause a running task
+- resume: Resume a paused task
+
+Use this to coordinate work across multiple AI agents in the cluster.`,
+        parameters: Type.Object({
+            action: Type.Union([
+                Type.Literal("create"),
+                Type.Literal("list"),
+                Type.Literal("get"),
+                Type.Literal("abort"),
+                Type.Literal("pause"),
+                Type.Literal("resume"),
+            ]),
+            // Create parameters
+            name: Type.Optional(Type.String()),
+            description: Type.Optional(Type.String()),
+            priority: Type.Optional(Type.Union([
+                Type.Literal("low"),
+                Type.Literal("normal"),
+                Type.Literal("high"),
+                Type.Literal("critical"),
+            ])),
+            input: Type.Optional(Type.Any()),
+            targetNodeId: Type.Optional(Type.String()),
+            maxRounds: Type.Optional(Type.Number()),
+            // Get/Abort/Pause/Resume parameters
+            taskId: Type.Optional(Type.String()),
+            reason: Type.Optional(Type.String()),
+        }),
+        async execute(_id, params) {
+            const client = getClient();
+            if (!client?.isConnected()) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Not connected to CommanderClaw server. Check plugin configuration.",
+                        },
+                    ],
+                };
+            }
+            try {
+                switch (params.action) {
+                    case "create": {
+                        if (!params.name || typeof params.name !== "string") {
+                            return {
+                                content: [
+                                    { type: "text", text: "Error: 'name' is required for create action" },
+                                ],
+                            };
+                        }
+                        const task = await client.createTask({
+                            name: params.name,
+                            description: params.description,
+                            priority: params.priority,
+                            input: params.input,
+                            targetNodeId: params.targetNodeId,
+                            maxRounds: params.maxRounds,
+                        });
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Task created successfully:\n\`\`\`json\n${JSON.stringify(task, null, 2)}\n\`\`\``,
+                                },
+                            ],
+                        };
+                    }
+                    case "list": {
+                        const tasks = await client.listTasks();
+                        if (tasks.length === 0) {
+                            return {
+                                content: [{ type: "text", text: "No tasks in the cluster." }],
+                            };
+                        }
+                        let text = `## Tasks (${tasks.length})\n\n`;
+                        for (const task of tasks) {
+                            text += formatTaskSummary(task);
+                        }
+                        return { content: [{ type: "text", text }] };
+                    }
+                    case "get": {
+                        if (!params.taskId || typeof params.taskId !== "string") {
+                            return {
+                                content: [
+                                    { type: "text", text: "Error: 'taskId' is required for get action" },
+                                ],
+                            };
+                        }
+                        const task = await client.getTask(params.taskId);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: formatTaskDetail(task),
+                                },
+                            ],
+                        };
+                    }
+                    case "abort": {
+                        if (!params.taskId || typeof params.taskId !== "string") {
+                            return {
+                                content: [
+                                    { type: "text", text: "Error: 'taskId' is required for abort action" },
+                                ],
+                            };
+                        }
+                        await client.abortTask(params.taskId, params.reason);
+                        return {
+                            content: [
+                                { type: "text", text: `Task ${params.taskId} has been aborted.` },
+                            ],
+                        };
+                    }
+                    case "pause": {
+                        if (!params.taskId || typeof params.taskId !== "string") {
+                            return {
+                                content: [
+                                    { type: "text", text: "Error: 'taskId' is required for pause action" },
+                                ],
+                            };
+                        }
+                        await client.pauseTask(params.taskId);
+                        return {
+                            content: [
+                                { type: "text", text: `Task ${params.taskId} has been paused.` },
+                            ],
+                        };
+                    }
+                    case "resume": {
+                        if (!params.taskId || typeof params.taskId !== "string") {
+                            return {
+                                content: [
+                                    { type: "text", text: "Error: 'taskId' is required for resume action" },
+                                ],
+                            };
+                        }
+                        await client.resumeTask(params.taskId);
+                        return {
+                            content: [
+                                { type: "text", text: `Task ${params.taskId} has been resumed.` },
+                            ],
+                        };
+                    }
+                    default:
+                        return {
+                            content: [
+                                { type: "text", text: `Unknown action: ${params.action}` },
+                            ],
+                        };
+                }
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Failed to execute task action: ${error instanceof Error ? error.message : String(error)}`,
+                        },
+                    ],
+                };
+            }
+        },
+    };
+}
+function formatTaskSummary(task) {
+    const statusEmoji = {
+        pending: "⏳",
+        assigned: "📋",
+        running: "▶️",
+        paused: "⏸️",
+        completed: "✅",
+        failed: "❌",
+        aborted: "🚫",
+    }[task.status] || "❓";
+    let text = `### ${task.name} (${task.id})\n`;
+    text += `- **Status:** ${statusEmoji} ${task.status}\n`;
+    text += `- **Priority:** ${task.priority}\n`;
+    text += `- **Progress:** ${task.progress}%\n`;
+    if (task.assignees?.length) {
+        text += `- **Assignees:** ${task.assignees.join(", ")}\n`;
+    }
+    text += "\n";
+    return text;
+}
+function formatTaskDetail(task) {
+    let text = `## Task: ${task.name}\n\n`;
+    text += `**ID:** ${task.id}\n`;
+    text += `**Status:** ${task.status}\n`;
+    text += `**Priority:** ${task.priority}\n`;
+    text += `**Progress:** ${task.progress}%\n`;
+    text += `**Rounds:** ${task.rounds}/${task.maxRounds}\n\n`;
+    if (task.description) {
+        text += `**Description:**\n${task.description}\n\n`;
+    }
+    if (task.creatorId) {
+        text += `**Creator:** ${task.creatorId}\n`;
+    }
+    if (task.commanderId) {
+        text += `**Commander:** ${task.commanderId}\n`;
+    }
+    if (task.assignees?.length) {
+        text += `**Assignees:** ${task.assignees.join(", ")}\n`;
+    }
+    text += `\n**Created:** ${task.createdAt}\n`;
+    text += `**Updated:** ${task.updatedAt}\n`;
+    if (task.input) {
+        text += `\n**Input:**\n\`\`\`json\n${JSON.stringify(task.input, null, 2)}\n\`\`\`\n`;
+    }
+    if (task.output) {
+        text += `\n**Output:**\n\`\`\`json\n${JSON.stringify(task.output, null, 2)}\n\`\`\`\n`;
+    }
+    if (task.error) {
+        text += `\n**Error:** ${task.error}\n`;
+    }
+    return text;
+}
+
+/**
+ * commanderclaw_status tool
+ */
+function createStatusTool(getClient) {
+    return {
+        name: "commanderclaw_status",
+        description: "Get the current status of the CommanderClaw cluster connection and cluster health. Use this to verify connectivity and check overall cluster status.",
+        parameters: Type.Object({}),
+        async execute() {
+            const client = getClient();
+            if (!client) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "CommanderClaw plugin not initialized. Check plugin configuration.",
+                        },
+                    ],
+                };
+            }
+            const connected = client.isConnected();
+            const nodeId = client.getNodeId();
+            const commanderId = client.getCommanderId();
+            const peers = client.getPeers();
+            let text = `## CommanderClaw Status\n\n`;
+            text += `**Connection:** ${connected ? "✅ Connected" : "❌ Disconnected"}\n`;
+            text += `**Node ID:** ${nodeId || "Not registered"}\n`;
+            text += `**Commander:** ${commanderId || "None elected"}\n`;
+            text += `**Peers:** ${peers.length}\n\n`;
+            if (connected) {
+                try {
+                    const health = await client.getStatus();
+                    text += `### Cluster Health\n`;
+                    text += `- **Status:** ${health.status}\n`;
+                    text += `- **Total nodes:** ${health.nodes}\n`;
+                }
+                catch (error) {
+                    text += `**Health check failed:** ${error instanceof Error ? error.message : String(error)}\n`;
+                }
+            }
+            else {
+                text += `### Troubleshooting\n`;
+                text += `- Check if the CommanderClaw server is running\n`;
+                text += `- Verify the server URL in plugin configuration\n`;
+                text += `- Check if the authentication token is correct\n`;
+            }
+            return { content: [{ type: "text", text }] };
+        },
+    };
+}
+
+/**
+ * commanderclaw_command tool
+ */
+function createCommandTool(getClient) {
+    return {
+        name: "commanderclaw_command",
+        description: `Send King commands to the CommanderClaw cluster.
+
+Commands:
+- appoint: Appoint a specific node as the Commander
+- abort: Abort a task (alias for commanderclaw_task with action=abort)
+- pause: Pause a running task
+- resume: Resume a paused task
+
+Note: Some commands may require King-level permissions.`,
+        parameters: Type.Object({
+            command: Type.Union([
+                Type.Literal("appoint"),
+                Type.Literal("abort"),
+                Type.Literal("pause"),
+                Type.Literal("resume"),
+            ]),
+            nodeId: Type.Optional(Type.String()),
+            taskId: Type.Optional(Type.String()),
+            reason: Type.Optional(Type.String()),
+        }),
+        async execute(_id, params) {
+            const client = getClient();
+            if (!client?.isConnected()) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Not connected to CommanderClaw server. Check plugin configuration.",
+                        },
+                    ],
+                };
+            }
+            try {
+                switch (params.command) {
+                    case "appoint": {
+                        if (!params.nodeId || typeof params.nodeId !== "string") {
+                            return {
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: "Error: 'nodeId' is required for appoint command. Use commanderclaw_nodes to list available nodes.",
+                                    },
+                                ],
+                            };
+                        }
+                        const result = await client.appointCommander(params.nodeId);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Commander appointed successfully.\n- **New Commander:** ${result.commanderId}`,
+                                },
+                            ],
+                        };
+                    }
+                    case "abort": {
+                        if (!params.taskId || typeof params.taskId !== "string") {
+                            return {
+                                content: [
+                                    { type: "text", text: "Error: 'taskId' is required for abort command" },
+                                ],
+                            };
+                        }
+                        await client.abortTask(params.taskId, params.reason);
+                        return {
+                            content: [
+                                { type: "text", text: `Task ${params.taskId} has been aborted.` },
+                            ],
+                        };
+                    }
+                    case "pause": {
+                        if (!params.taskId || typeof params.taskId !== "string") {
+                            return {
+                                content: [
+                                    { type: "text", text: "Error: 'taskId' is required for pause command" },
+                                ],
+                            };
+                        }
+                        await client.pauseTask(params.taskId);
+                        return {
+                            content: [
+                                { type: "text", text: `Task ${params.taskId} has been paused.` },
+                            ],
+                        };
+                    }
+                    case "resume": {
+                        if (!params.taskId || typeof params.taskId !== "string") {
+                            return {
+                                content: [
+                                    { type: "text", text: "Error: 'taskId' is required for resume command" },
+                                ],
+                            };
+                        }
+                        await client.resumeTask(params.taskId);
+                        return {
+                            content: [
+                                { type: "text", text: `Task ${params.taskId} has been resumed.` },
+                            ],
+                        };
+                    }
+                    default:
+                        return {
+                            content: [
+                                { type: "text", text: `Unknown command: ${params.command}` },
+                            ],
+                        };
+                }
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Failed to execute command: ${error instanceof Error ? error.message : String(error)}`,
+                        },
+                    ],
+                };
+            }
+        },
+    };
+}
+
+/**
+ * CommanderClaw Channel Plugin for OpenClaw
+ *
+ * This plugin connects OpenClaw to a CommanderClaw coordination server,
+ * enabling multi-agent task coordination with message bridging.
+ */
+const CHANNEL_ID = "commanderclaw";
+const { setRuntime, getRuntime } = createPluginRuntimeStore("CommanderClaw runtime not initialized");
+let client = null;
+let pluginConfig = null;
+let currentLog = null;
+const DEFAULT_CONFIG = {
+    deviceName: "OpenClaw Agent",
+    autoConnect: true,
+    reconnect: {
+        enabled: true,
+        maxAttempts: 10,
+        delayMs: 5000,
+    },
+};
+async function handleChatMessage(msg) {
+    const log = currentLog;
+    if (!log)
+        return;
+    log.info("handleChatMessage: starting", {
+        from: msg.from,
+        to: msg.to,
+        msgType: msg.msgType,
+    });
+    const rt = getRuntime();
+    if (!rt || !rt.channel) {
+        log.error("handleChatMessage: runtime or channel not initialized");
+        return;
+    }
+    if (!client) {
+        log.error("handleChatMessage: client not initialized");
+        return;
+    }
+    if (!pluginConfig) {
+        log.error("handleChatMessage: pluginConfig not initialized");
+        return;
+    }
+    const content = msg.payload?.content;
+    if (!content) {
+        log.warn("handleChatMessage: no content");
+        return;
+    }
+    log.info("handleChatMessage: processing", {
+        from: msg.from,
+        contentLength: content.length,
+    });
+    try {
+        const nodeId = client.getNodeId() || "unknown";
+        const route = rt.channel.routing.resolveAgentRoute({
+            cfg: pluginConfig,
+            channel: CHANNEL_ID,
+            accountId: "default",
+            peer: {
+                kind: "direct",
+                id: msg.from,
+            },
+        });
+        const ctxPayload = rt.channel.reply.finalizeInboundContext({
+            Body: content,
+            RawBody: content,
+            CommandBody: content,
+            MessageSid: `cc-${Date.now()}`,
+            From: `${CHANNEL_ID}:${msg.from}`,
+            To: `${CHANNEL_ID}:${nodeId}`,
+            SenderId: msg.from,
+            SessionKey: route.sessionKey,
+            AccountId: "default",
+            ChatType: "direct",
+            ConversationLabel: `user:${msg.from}`,
+            Timestamp: Date.now(),
+            Provider: CHANNEL_ID,
+            Surface: CHANNEL_ID,
+            OriginatingChannel: CHANNEL_ID,
+            OriginatingTo: `${CHANNEL_ID}:${nodeId}`,
+            CommandAuthorized: true,
+        });
+        const currentCfg = await rt.config.loadConfig();
+        let accumulatedText = "";
+        await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+            ctx: ctxPayload,
+            cfg: currentCfg,
+            dispatcherOptions: {
+                deliver: async (payload, info) => {
+                    accumulatedText = payload.text;
+                    if (info.kind === "final") {
+                        log.info("handleChatMessage: sending response", {
+                            textLength: accumulatedText.length,
+                        });
+                        client?.send("CHAT", {
+                            content: accumulatedText,
+                        });
+                    }
+                },
+                onError: (err, info) => {
+                    log.error("handleChatMessage: LLM error", {
+                        kind: info.kind,
+                        error: err.message,
+                    });
+                },
+            },
+        });
+        log.info("handleChatMessage: completed");
+    }
+    catch (err) {
+        log.error("handleChatMessage: failed", {
+            error: err instanceof Error ? err.message : String(err),
+            stack: err instanceof Error ? err.stack : undefined,
+        });
+    }
+}
+function initializeClient(config, log) {
+    if (!config.autoConnect) {
+        log.info("CommanderClaw auto-connect disabled");
+        return;
+    }
+    client = new CommanderClawClient({
+        url: config.serverUrl,
+        token: config.token,
+        name: config.deviceName || "OpenClaw Agent",
+        capabilities: ["ai-agent", "task-execution"],
+        reconnect: config.reconnect,
+    });
+    client.on("connected", (event) => {
+        log.info("Connected to CommanderClaw server", {
+            nodeId: event.data?.nodeId,
+        });
+    });
+    client.on("disconnected", () => {
+        log.warn("Disconnected from CommanderClaw server");
+    });
+    client.on("error", (event) => {
+        log.error("CommanderClaw connection error", {
+            error: String(event.data),
+        });
+    });
+    client.on("chat", (event) => {
+        handleChatMessage(event.data);
+    });
+    client.connect().catch((error) => {
+        log.error("Failed to connect to CommanderClaw server", {
+            error: error.message,
+        });
+    });
+    log.info("CommanderClaw client initialized", {
+        url: config.serverUrl,
+        name: config.deviceName,
+    });
+}
+const commanderclawPlugin = {
+    id: CHANNEL_ID,
+    meta: {
+        id: CHANNEL_ID,
+        label: "CommanderClaw",
+        selectionLabel: "CommanderClaw",
+        detailLabel: "CommanderClaw Multi-Agent Coordination",
+        docsPath: "/channels/commanderclaw",
+        blurb: "Connect to CommanderClaw coordination server",
+        order: 100,
+    },
+    capabilities: {
+        chatTypes: ["direct"],
+        media: false,
+        threads: false,
+        reactions: false,
+        edit: false,
+        unsend: false,
+        reply: false,
+        effects: false,
+        blockStreaming: false,
+    },
+    reload: { configPrefixes: [`channels.${CHANNEL_ID}`] },
+    config: {
+        listAccountIds: (_cfg) => ["default"],
+        resolveAccount: (cfg) => ({
+            accountId: "default",
+            enabled: cfg?.channels?.[CHANNEL_ID]?.enabled ?? true,
+            serverUrl: cfg?.channels?.[CHANNEL_ID]?.serverUrl,
+            token: cfg?.channels?.[CHANNEL_ID]?.token,
+            deviceName: cfg?.channels?.[CHANNEL_ID]?.deviceName,
+            autoConnect: cfg?.channels?.[CHANNEL_ID]?.autoConnect,
+            reconnect: cfg?.channels?.[CHANNEL_ID]?.reconnect,
+        }),
+        defaultAccountId: () => "default",
+        setAccountEnabled: ({ cfg, enabled }) => ({
+            ...cfg,
+            channels: {
+                ...cfg?.channels,
+                [CHANNEL_ID]: {
+                    ...cfg?.channels?.[CHANNEL_ID],
+                    enabled,
+                },
+            },
+        }),
+    },
+    security: {
+        resolveDmPolicy: () => ({
+            policy: "open",
+            allowFrom: [],
+            policyPath: `channels.${CHANNEL_ID}.dmPolicy`,
+            allowFromPath: `channels.${CHANNEL_ID}.`,
+        }),
+        collectWarnings: () => [],
+    },
+    messaging: {
+        normalizeTarget: (target) => target?.trim() || undefined,
+        targetResolver: {
+            looksLikeId: (id) => id?.length > 10,
+            hint: "<nodeId>",
+        },
+    },
+    directory: {
+        self: async () => null,
+        listPeers: async () => [],
+        listGroups: async () => [],
+    },
+    outbound: {
+        deliveryMode: "gateway",
+        textChunkLimit: 4000,
+        sendText: async ({ to, text }) => {
+            if (!client) {
+                throw new Error("CommanderClaw client not initialized");
+            }
+            client.send("CHAT", { content: text, to });
+            return { channel: CHANNEL_ID, messageId: `cc-${Date.now()}`, chatId: to };
+        },
+    },
+    gateway: {
+        startAccount: async (ctx) => {
+            const { cfg, log } = ctx;
+            currentLog = log;
+            pluginConfig = cfg;
+            const channelCfg = cfg?.channels?.[CHANNEL_ID] || {};
+            const config = {
+                ...DEFAULT_CONFIG,
+                ...channelCfg,
+            };
+            if (!config.serverUrl) {
+                log?.warn?.("CommanderClaw: serverUrl not configured");
+                return;
+            }
+            log?.info?.(`Starting CommanderClaw channel (server: ${config.serverUrl})`);
+            initializeClient(config, log);
+            return new Promise(() => { });
+        },
+        stopAccount: async (ctx) => {
+            ctx.log?.info?.("CommanderClaw account stopped");
+            if (client) {
+                client.disconnect();
+                client = null;
+            }
+        },
+    },
+};
+const plugin = {
+    id: "commanderclaw",
+    name: "CommanderClaw",
+    description: "Connect to CommanderClaw coordination server",
+    configSchema: emptyPluginConfigSchema(),
+    register(api) {
+        setRuntime(api.runtime);
+        api.registerChannel({ plugin: commanderclawPlugin });
+        api.registerTool(createNodesTool(() => client));
+        api.registerTool(createTaskTool(() => client));
+        api.registerTool(createStatusTool(() => client));
+        api.registerTool(createCommandTool(() => client));
+    },
+};
+
+export { plugin as default };
+//# sourceMappingURL=index.mjs.map