@openclaw/lobster 2026.8.1-beta.2 → 2026.8.1

package/dist/index.js

@@ -7,6 +7,7 @@ import { stat } from "node:fs/promises";
 import path from "node:path";
 import { Readable, Writable } from "node:stream";
 import { toErrorObject } from "openclaw/plugin-sdk/error-runtime";
+import { isPathInside } from "openclaw/plugin-sdk/file-access-runtime";
 //#region extensions/lobster/src/lobster-runner.ts
 const workflowExts = /* @__PURE__ */ new Set([
 	".lobster",
@@ -14,19 +15,13 @@ const workflowExts = /* @__PURE__ */ new Set([
 	".yml",
 	".json"
 ]);
-function normalizeForCwdSandbox(p) {
-	const normalized = path.normalize(p);
-	return process.platform === "win32" ? normalized.toLowerCase() : normalized;
-}
 function resolveLobsterCwd(cwdRaw) {
 	if (typeof cwdRaw !== "string" || !cwdRaw.trim()) return process.cwd();
 	const cwd = cwdRaw.trim();
 	if (path.isAbsolute(cwd)) throw new Error("cwd must be a relative path");
 	const base = process.cwd();
 	const resolved = path.resolve(base, cwd);
-	const rel = path.relative(normalizeForCwdSandbox(base), normalizeForCwdSandbox(resolved));
-	if (rel === "" || rel === ".") return resolved;
-	if (rel.startsWith("..") || path.isAbsolute(rel)) throw new Error("cwd must stay within the gateway working directory");
+	if (!isPathInside(base, resolved)) throw new Error("cwd must stay within the gateway working directory");
 	return resolved;
 }
 function createLimitedSink(maxBytes, label) {
@@ -40,10 +35,10 @@ function createLimitedSink(maxBytes, label) {
 		callback();
 	} });
 }
-function normalizeEnvelope(envelope) {
+function normalizeEnvelope(envelope, maxStdoutBytes) {
 	if (!envelope.ok) throw new Error(envelope.error?.message ?? "lobster runtime failed");
 	if (envelope.status === "needs_input") throw new Error("Lobster input requests are not supported by the OpenClaw Lobster tool yet");
-	return {
+	const normalized = {
 		ok: true,
 		status: envelope.status ?? "ok",
 		output: Array.isArray(envelope.output) ? envelope.output : [],
@@ -55,6 +50,8 @@ function normalizeEnvelope(envelope) {
 			...envelope.requiresApproval.approvalId ? { approvalId: envelope.requiresApproval.approvalId } : {}
 		} : null
 	};
+	if (Buffer.byteLength(JSON.stringify(normalized, null, 2), "utf8") > maxStdoutBytes) throw new Error("lobster runtime result exceeded maxStdoutBytes");
+	return normalized;
 }
 function isMissingPathError(error) {
 	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
@@ -117,6 +114,7 @@ function createEmbeddedLobsterRunner(options) {
 		const runtime = await runtimePromise;
 		return await withTimeout(params.timeoutMs, async (signal) => {
 			const ctx = createEmbeddedToolContext(params, signal);
+			let envelope;
 			if (params.action === "run") {
 				const pipeline = params.pipeline?.trim() ?? "";
 				if (!pipeline) throw new Error("pipeline required");
@@ -129,27 +127,28 @@ function createEmbeddedLobsterRunner(options) {
 					} catch {
 						throw new Error("run --args-json must be valid JSON");
 					}
-					return normalizeEnvelope(await runtime.runToolRequest({
+					envelope = await runtime.runToolRequest({
 						filePath,
 						args,
 						ctx
-					}));
-				}
-				return normalizeEnvelope(await runtime.runToolRequest({
+					});
+				} else envelope = await runtime.runToolRequest({
 					pipeline,
 					ctx
-				}));
+				});
+			} else {
+				const token = params.token?.trim() ?? "";
+				const approvalId = params.approvalId?.trim() ?? "";
+				if (!token && !approvalId) throw new Error("token or approvalId required");
+				if (typeof params.approve !== "boolean") throw new Error("approve required");
+				envelope = await runtime.resumeToolRequest({
+					...token ? { token } : {},
+					...approvalId ? { approvalId } : {},
+					approved: params.approve,
+					ctx
+				});
 			}
-			const token = params.token?.trim() ?? "";
-			const approvalId = params.approvalId?.trim() ?? "";
-			if (!token && !approvalId) throw new Error("token or approvalId required");
-			if (typeof params.approve !== "boolean") throw new Error("approve required");
-			return normalizeEnvelope(await runtime.resumeToolRequest({
-				...token ? { token } : {},
-				...approvalId ? { approvalId } : {},
-				approved: params.approve,
-				ctx
-			}));
+			return normalizeEnvelope(envelope, Math.max(1024, params.maxStdoutBytes));
 		});
 	} };
 }
@@ -157,29 +156,25 @@ function createEmbeddedLobsterRunner(options) {
 //#region extensions/lobster/src/lobster-taskflow.ts
 function toJsonLike(value, seen = /* @__PURE__ */ new WeakSet()) {
 	if (value === null) return null;
-	switch (typeof value) {
-		case "boolean":
-		case "string": return value;
-		case "number": return Number.isFinite(value) ? value : String(value);
-		case "bigint": return value.toString();
-		case "undefined":
-		case "function":
-		case "symbol": return null;
-		case "object": {
-			if (value instanceof Date) return value.toISOString();
-			if (Array.isArray(value)) return value.map((item) => toJsonLike(item, seen));
-			if (seen.has(value)) return "[Circular]";
-			seen.add(value);
-			const jsonObject = {};
-			for (const [key, entry] of Object.entries(value)) {
-				if (entry === void 0 || typeof entry === "function" || typeof entry === "symbol") continue;
-				jsonObject[key] = toJsonLike(entry, seen);
-			}
-			seen.delete(value);
-			return jsonObject;
-		}
+	if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
+	if (typeof value === "bigint") return value.toString();
+	if (typeof value === "boolean" || typeof value === "string") return value;
+	if (typeof value !== "object") return null;
+	if (value instanceof Date) return value.toISOString();
+	if (seen.has(value)) return "[Circular]";
+	seen.add(value);
+	if (Array.isArray(value)) {
+		const jsonArray = value.map((item) => toJsonLike(item, seen));
+		seen.delete(value);
+		return jsonArray;
+	}
+	const jsonObject = {};
+	for (const [key, entry] of Object.entries(value)) {
+		if (entry === void 0 || typeof entry === "function" || typeof entry === "symbol") continue;
+		jsonObject[key] = toJsonLike(entry, seen);
 	}
-	return null;
+	seen.delete(value);
+	return jsonObject;
 }
 function buildApprovalWaitState(envelope) {
 	const approval = envelope.requiresApproval;
@@ -191,40 +186,51 @@ function buildApprovalWaitState(envelope) {
 		...approval?.approvalId ? { approvalId: approval.approvalId } : {}
 	};
 }
-function applyEnvelopeToFlow(params) {
-	const { taskFlow, flow, envelope, waitingStep } = params;
-	const flowMutation = {
-		flowId: flow.flowId,
-		expectedRevision: flow.revision
-	};
-	if (!envelope.ok) return taskFlow.fail(flowMutation);
-	if (envelope.status === "needs_approval") return taskFlow.setWaiting({
-		...flowMutation,
-		currentStep: waitingStep,
-		waitJson: buildApprovalWaitState(envelope)
-	});
-	return taskFlow.finish(flowMutation);
-}
-async function executeManagedLobsterFlow(params, flow, failureFlowId = flow.flowId) {
+async function executeManagedLobsterFlow(params, flow) {
 	try {
 		const envelope = await params.runner.run(params.runnerParams);
-		const mutation = applyEnvelopeToFlow({
-			taskFlow: params.taskFlow,
-			flow,
-			envelope,
-			waitingStep: params.waitingStep ?? "await_lobster_approval"
-		});
+		if (envelope.ok && envelope.status === "cancelled") try {
+			const mutation = await params.taskFlow.cancel({
+				flowId: flow.flowId,
+				cfg: params.config
+			});
+			return mutation.cancelled ? {
+				ok: true,
+				envelope,
+				flow,
+				mutation
+			} : {
+				ok: false,
+				flow,
+				mutation,
+				error: /* @__PURE__ */ new Error(`TaskFlow cancellation failed: ${mutation.reason ?? "unknown"}`)
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				flow,
+				error: error instanceof Error ? error : new Error(String(error))
+			};
+		}
+		const flowMutation = {
+			flowId: flow.flowId,
+			expectedRevision: flow.revision
+		};
 		if (!envelope.ok) return {
 			ok: false,
 			flow,
-			mutation,
+			mutation: params.taskFlow.fail(flowMutation),
 			error: new Error(envelope.error.message)
 		};
 		return {
 			ok: true,
 			envelope,
 			flow,
-			mutation
+			mutation: envelope.status === "needs_approval" ? params.taskFlow.setWaiting({
+				...flowMutation,
+				currentStep: params.waitingStep ?? "await_lobster_approval",
+				waitJson: buildApprovalWaitState(envelope)
+			}) : params.taskFlow.finish(flowMutation)
 		};
 	} catch (error) {
 		const err = error instanceof Error ? error : new Error(String(error));
@@ -233,7 +239,7 @@ async function executeManagedLobsterFlow(params, flow, failureFlowId = flow.flow
 				ok: false,
 				flow,
 				mutation: params.taskFlow.fail({
-					flowId: failureFlowId,
+					flowId: flow.flowId,
 					expectedRevision: flow.revision
 				}),
 				error: err
@@ -273,7 +279,7 @@ async function resumeManagedLobsterFlow(params) {
 		mutation: resumed,
 		error: /* @__PURE__ */ new Error(`TaskFlow resume failed: ${resumed.code}`)
 	};
-	return await executeManagedLobsterFlow(params, resumed.flow, params.flowId);
+	return await executeManagedLobsterFlow(params, resumed.flow);
 }
 //#endregion
 //#region extensions/lobster/src/lobster-tool.ts
@@ -305,28 +311,29 @@ function parseOptionalFlowStateJson(value) {
 function isEmptyJsonObject(value) {
 	return value !== void 0 && value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
 }
-function parseRunFlowParams(params) {
-	const controllerId = readOptionalTrimmedString(params.flowControllerId, "flowControllerId");
-	const goal = readOptionalTrimmedString(params.flowGoal, "flowGoal");
-	const currentStep = readOptionalTrimmedString(params.flowCurrentStep, "flowCurrentStep");
-	const waitingStep = readOptionalTrimmedString(params.flowWaitingStep, "flowWaitingStep");
-	const stateJson = parseOptionalFlowStateJson(params.flowStateJson);
-	const resumeFlowId = readOptionalTrimmedString(params.flowId, "flowId");
-	const resumeRevision = readOptionalNumber(params.flowExpectedRevision, "flowExpectedRevision");
-	const stateJsonSignalsRunMode = stateJson !== void 0 && !isEmptyJsonObject(stateJson);
-	if (resumeFlowId !== void 0 || resumeRevision !== void 0 && resumeRevision !== 0) throw new Error("run action does not accept flowId or flowExpectedRevision");
-	if (!(controllerId !== void 0 || goal !== void 0 || currentStep !== void 0 || waitingStep !== void 0 || stateJsonSignalsRunMode)) return null;
-	if (!controllerId) throw new Error("flowControllerId required when using managed TaskFlow run mode");
-	if (!goal) throw new Error("flowGoal required when using managed TaskFlow run mode");
-	return {
-		controllerId,
-		goal,
-		...currentStep ? { currentStep } : {},
-		...waitingStep ? { waitingStep } : {},
-		...stateJson !== void 0 ? { stateJson } : {}
-	};
-}
-function parseResumeFlowParams(params) {
+function parseManagedFlowParams(action, params, runnerParams) {
+	if (action === "run") {
+		const controllerId = readOptionalTrimmedString(params.flowControllerId, "flowControllerId");
+		const goal = readOptionalTrimmedString(params.flowGoal, "flowGoal");
+		const currentStep = readOptionalTrimmedString(params.flowCurrentStep, "flowCurrentStep");
+		const waitingStep = readOptionalTrimmedString(params.flowWaitingStep, "flowWaitingStep");
+		const stateJson = parseOptionalFlowStateJson(params.flowStateJson);
+		const resumeFlowId = readOptionalTrimmedString(params.flowId, "flowId");
+		const resumeRevision = readOptionalNumber(params.flowExpectedRevision, "flowExpectedRevision");
+		const stateJsonSignalsRunMode = stateJson !== void 0 && !isEmptyJsonObject(stateJson);
+		if (resumeFlowId !== void 0 || resumeRevision !== void 0 && resumeRevision !== 0) throw new Error("run action does not accept flowId or flowExpectedRevision");
+		if (controllerId === void 0 && goal === void 0 && currentStep === void 0 && waitingStep === void 0 && !stateJsonSignalsRunMode) return null;
+		if (!controllerId) throw new Error("flowControllerId required when using managed TaskFlow run mode");
+		if (!goal) throw new Error("flowGoal required when using managed TaskFlow run mode");
+		return {
+			action,
+			controllerId,
+			goal,
+			...currentStep ? { currentStep } : {},
+			...waitingStep ? { waitingStep } : {},
+			...stateJson !== void 0 ? { stateJson } : {}
+		};
+	}
 	const flowId = readOptionalTrimmedString(params.flowId, "flowId");
 	const expectedRevision = readOptionalNumber(params.flowExpectedRevision, "flowExpectedRevision");
 	const currentStep = readOptionalTrimmedString(params.flowCurrentStep, "flowCurrentStep");
@@ -342,13 +349,21 @@ function parseResumeFlowParams(params) {
 	if (!(flowId !== void 0 || expectedRevision !== void 0 && expectedRevision !== 0 || currentStep !== void 0 || waitingStep !== void 0)) return null;
 	if (!flowId) throw new Error("flowId required when using managed TaskFlow resume mode");
 	if (expectedRevision === void 0) throw new Error("flowExpectedRevision required when using managed TaskFlow resume mode");
-	if (!token && !approvalId) throw new Error("token or approvalId required when using managed TaskFlow resume mode");
+	const credentialParams = token ? { token: runnerParams.token ?? token } : approvalId ? { approvalId: runnerParams.approvalId ?? approvalId } : null;
+	if (!credentialParams) throw new Error("token or approvalId required when using managed TaskFlow resume mode");
 	if (approve === void 0) throw new Error("approve required when using managed TaskFlow resume mode");
 	return {
+		action,
 		flowId,
 		expectedRevision,
 		...currentStep ? { currentStep } : {},
-		...waitingStep ? { waitingStep } : {}
+		...waitingStep ? { waitingStep } : {},
+		runnerParams: {
+			...runnerParams,
+			...credentialParams,
+			action,
+			approve
+		}
 	};
 }
 function resolveManagedFlowToolResult(result) {
@@ -407,30 +422,28 @@ function createLobsterTool(api, options) {
 				maxStdoutBytes
 			};
 			const taskFlow = options?.taskFlow;
-			if (action === "run") {
-				const flowParams = parseRunFlowParams(params);
-				if (flowParams) return resolveManagedFlowToolResult(await runManagedLobsterFlow({
-					taskFlow: requireTaskFlowRuntime(taskFlow, "run"),
-					runner,
-					runnerParams,
-					controllerId: flowParams.controllerId,
-					goal: flowParams.goal,
-					...flowParams.stateJson !== void 0 ? { stateJson: flowParams.stateJson } : {},
-					...flowParams.currentStep ? { currentStep: flowParams.currentStep } : {},
-					...flowParams.waitingStep ? { waitingStep: flowParams.waitingStep } : {}
-				}));
-			} else {
-				const flowParams = parseResumeFlowParams(params);
-				if (flowParams) return resolveManagedFlowToolResult(await resumeManagedLobsterFlow({
-					taskFlow: requireTaskFlowRuntime(taskFlow, "resume"),
-					runner,
-					runnerParams,
-					flowId: flowParams.flowId,
-					expectedRevision: flowParams.expectedRevision,
-					...flowParams.currentStep ? { currentStep: flowParams.currentStep } : {},
-					...flowParams.waitingStep ? { waitingStep: flowParams.waitingStep } : {}
-				}));
-			}
+			const flowParams = parseManagedFlowParams(action, params, runnerParams);
+			if (flowParams?.action === "run") return resolveManagedFlowToolResult(await runManagedLobsterFlow({
+				taskFlow: requireTaskFlowRuntime(taskFlow, "run"),
+				config: api.config,
+				runner,
+				runnerParams,
+				controllerId: flowParams.controllerId,
+				goal: flowParams.goal,
+				...flowParams.stateJson !== void 0 ? { stateJson: flowParams.stateJson } : {},
+				...flowParams.currentStep ? { currentStep: flowParams.currentStep } : {},
+				...flowParams.waitingStep ? { waitingStep: flowParams.waitingStep } : {}
+			}));
+			if (flowParams?.action === "resume") return resolveManagedFlowToolResult(await resumeManagedLobsterFlow({
+				taskFlow: requireTaskFlowRuntime(taskFlow, "resume"),
+				config: api.config,
+				runner,
+				runnerParams: flowParams.runnerParams,
+				flowId: flowParams.flowId,
+				expectedRevision: flowParams.expectedRevision,
+				...flowParams.currentStep ? { currentStep: flowParams.currentStep } : {},
+				...flowParams.waitingStep ? { waitingStep: flowParams.waitingStep } : {}
+			}));
 			const envelope = await runner.run(runnerParams);
 			if (!envelope.ok) throw new Error(envelope.error.message);
 			return jsonResult(envelope);

package/node_modules/typebox/build/format/date.d.mts

@@ -1,6 +1,6 @@
 /**
  * Returns true if the value is a ISO8601 Date component string
- * @source ajv-formats
+ * @description https://datatracker.ietf.org/doc/html/rfc3339
  * @example `2020-12-12`
  */
 export declare function IsDate(value: string): boolean;

package/node_modules/typebox/build/format/date.mjs

@@ -5,7 +5,7 @@ function IsLeapYear(year) {
 }
 /**
  * Returns true if the value is a ISO8601 Date component string
- * @source ajv-formats
+ * @description https://datatracker.ietf.org/doc/html/rfc3339
  * @example `2020-12-12`
  */
 export function IsDate(value) {

package/node_modules/typebox/build/format/date_time.d.mts

@@ -1,6 +1,6 @@
 /**
  * Returns true if the value is a ISO8601 DateTime string
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc3339
  * @example `2020-12-12T20:20:40+00:00`
  */
-export declare function IsDateTime(value: string, strictTimeZone?: boolean): boolean;
+export declare function IsDateTime(value: string): boolean;

package/node_modules/typebox/build/format/date_time.mjs

@@ -2,10 +2,10 @@ import { IsDate } from './date.mjs';
 import { IsTime } from './time.mjs';
 /**
  * Returns true if the value is a ISO8601 DateTime string
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc3339
  * @example `2020-12-12T20:20:40+00:00`
  */
-export function IsDateTime(value, strictTimeZone = true) {
+export function IsDateTime(value) {
     const dateTime = value.split(/T/i);
-    return dateTime.length === 2 && IsDate(dateTime[0]) && IsTime(dateTime[1], strictTimeZone);
+    return dateTime.length === 2 && IsDate(dateTime[0]) && IsTime(dateTime[1]);
 }

package/node_modules/typebox/build/format/email.d.mts

@@ -1,5 +1,5 @@
 /**
  * Returns true if the value is an Email
- * @specification ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc5322
  */
 export declare function IsEmail(value: string): boolean;

package/node_modules/typebox/build/format/email.mjs

@@ -1,7 +1,7 @@
-const Email = /^(?!.*\.\.)[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i;
+const Email = /^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[^"\\]|\\.)*")@(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*|\[(?:IPv6:[a-f0-9:]+|(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?:\.(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})\])$/i;
 /**
  * Returns true if the value is an Email
- * @specification ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc5322
  */
 export function IsEmail(value) {
     return Email.test(value);

package/node_modules/typebox/build/format/hostname.mjs

@@ -1,4 +1,4 @@
-import * as Idna from './_idna.mjs';
+import * as Idna from './idna/index.mjs';
 /**
  * Returns true if the value is a valid hostname.
  * @specification https://tools.ietf.org/html/rfc1123
@@ -6,13 +6,5 @@ import * as Idna from './_idna.mjs';
  * @specification https://tools.ietf.org/html/rfc5892
  */
 export function IsHostname(value) {
-    if (value.length === 0 || value.length > 253)
-        return false;
-    if (value.charCodeAt(value.length - 1) === 46)
-        return false;
-    for (const label of value.split('.')) {
-        if (!Idna.IsLabel(label))
-            return false;
-    }
-    return true;
+    return Idna.IsHostname(value);
 }

package/node_modules/typebox/build/format/idn_email.d.mts

@@ -1,5 +1,5 @@
 /**
  * Returns true if the value is an IdnEmail
- * @specification ajv-formats (unicode-extension)
+ * @specification https://datatracker.ietf.org/doc/html/rfc4952
  */
 export declare function IsIdnEmail(value: string): boolean;

package/node_modules/typebox/build/format/idn_email.mjs

@@ -1,8 +1,8 @@
-const IdnEmail = /^(?!.*\.\.)[\p{L}\p{N}!#$%&'*+/=?^_`{|}~-]+(?:\.[\p{L}\p{N}!#$%&'*+/=?^_`{|}~-]+)*@[\p{L}\p{N}](?:[\p{L}\p{N}-]{0,61}[\p{L}\p{N}])?(?:\.[\p{L}\p{N}](?:[\p{L}\p{N}-]{0,61}[\p{L}\p{N}])?)*$/iu;
+const IdnEmail = /^(?:[A-Za-z0-9!#$%&'*+\/=?^_`{|}~\u{0080}-\u{10FFFF}-]+(?:\.[A-Za-z0-9!#$%&'*+\/=?^_`{|}~\u{0080}-\u{10FFFF}-]+)*|"(?:[^"\\]|\\.)*")@[\p{L}\p{N}](?:[\p{L}\p{N}-]{0,62})(?<!-)(?:\.[\p{L}\p{N}](?:[\p{L}\p{N}-]{0,62})(?<!-))*$/iu;
 /**
  * Returns true if the value is an IdnEmail
- * @specification ajv-formats (unicode-extension)
+ * @specification https://datatracker.ietf.org/doc/html/rfc4952
  */
 export function IsIdnEmail(value) {
-    return IdnEmail.test(value);
+    return IdnEmail.test(value.normalize('NFC'));
 }

package/node_modules/typebox/build/format/idn_hostname.d.mts

@@ -3,5 +3,6 @@
  * @specification https://tools.ietf.org/html/rfc3490
  * @specification https://tools.ietf.org/html/rfc5891
  * @specification https://tools.ietf.org/html/rfc5892
+ * @specification https://tools.ietf.org/html/rfc5893
  */
 export declare function IsIdnHostname(value: string): boolean;

package/node_modules/typebox/build/format/idn_hostname.mjs

@@ -1,19 +1,11 @@
-import { IsIdnLabel } from './_idna.mjs';
+import * as Idna from './idna/index.mjs';
 /**
  * Returns true if the value is a valid internationalized (IDN) hostname.
  * @specification https://tools.ietf.org/html/rfc3490
  * @specification https://tools.ietf.org/html/rfc5891
  * @specification https://tools.ietf.org/html/rfc5892
+ * @specification https://tools.ietf.org/html/rfc5893
  */
 export function IsIdnHostname(value) {
-    if (value.length === 0 || value.includes(' '))
-        return false;
-    const canonical = value.normalize('NFC').replace(/[\u002E\u3002\uFF0E\uFF61]/g, '.');
-    if (canonical.length > 253)
-        return false;
-    for (const label of canonical.split('.')) {
-        if (!IsIdnLabel(label))
-            return false;
-    }
-    return true;
+    return Idna.IsIdnHostname(value);
 }

package/node_modules/typebox/build/format/idna/format/bidi.d.mts

@@ -0,0 +1,3 @@
+export declare function HasBidiChars(value: string): boolean;
+export declare function HasRightToLeftCharacters(value: string): boolean;
+export declare function SatisfiesBidiRule(value: string): boolean;

package/node_modules/typebox/build/format/idna/format/bidi.mjs

@@ -0,0 +1,98 @@
+// deno-fmt-ignore-file
+import * as FormatPuny from './puny.mjs';
+import * as Pattern from '../pattern/pattern.mjs';
+// ------------------------------------------------------------------
+// LOCAL REGEX: Allowed Bidi classes per direction (RFC 5893)
+// ------------------------------------------------------------------
+const RE_RTL_ALLOWED = /^(?:R|AL|AN|EN|ES|CS|ET|ON|BN|NSM)$/;
+const RE_LTR_ALLOWED = /^(?:L|EN|ES|CS|ET|ON|BN|NSM)$/;
+const RE_RTL_CLASSES = /^(?:R|AL|AN)$/;
+// ------------------------------------------------------------------
+// HasBidiChars
+//
+// Decodes a punycode label to its Unicode form (if it is one) and
+// checks whether the result is an RTL label per RFC 5893 §1.4.
+// ------------------------------------------------------------------
+export function HasBidiChars(value) {
+    if (FormatPuny.IsAcePrefixed(value)) {
+        try {
+            return HasRightToLeftCharacters(FormatPuny.Decode(value.slice(4).toLowerCase()));
+        }
+        catch {
+            return false;
+        }
+    }
+    return HasRightToLeftCharacters(value);
+}
+// ------------------------------------------------------------------
+// GetBidiClass
+// ------------------------------------------------------------------
+function GetBidiClass(codePoint) {
+    const char = String.fromCodePoint(codePoint);
+    return (Pattern.RE_EUROPEAN_NUMBER.test(char) ? 'EN' :
+        Pattern.RE_ARABIC_INDIC_DIGIT.test(char) ? 'AN' :
+            // Pattern.RE_EUROPEAN_SEPARATOR.test(char) ? 'ES' : // (no-spec-coverage)
+            // Pattern.RE_COMMON_SEPARATOR.test(char) ? 'CS' : // (no-spec-coverage)
+            Pattern.RE_MARK_NONSPACING.test(char) ? 'NSM' :
+                Pattern.RE_SCRIPT_HEBREW.test(char) ? 'R' :
+                    Pattern.RE_SCRIPT_ARABIC_LETTER.test(char) ? 'AL' :
+                        Pattern.RE_LETTER.test(char) ? 'L' :
+                            'ON');
+}
+// ------------------------------------------------------------------
+// HasRightToLeftCharacters
+//
+// Per RFC 5893 §1.4: "An RTL label is a label that contains at least
+// one character of type R, AL, or AN." Used to determine whether a
+// domain name is a "Bidi domain name" (RFC 5893 §1.4), in which case
+// the Bidi Rule applies to every label in the domain.
+// ------------------------------------------------------------------
+export function HasRightToLeftCharacters(value) {
+    for (const ch of value)
+        if (RE_RTL_CLASSES.test(GetBidiClass(ch.codePointAt(0))))
+            return true;
+    return false;
+}
+// ------------------------------------------------------------------
+// SatisfiesBidiRule
+// ------------------------------------------------------------------
+export function SatisfiesBidiRule(value) {
+    let isRtl = false;
+    let allowed = RE_LTR_ALLOWED;
+    let sawEN = false;
+    let sawAN = false;
+    let isFirst = true;
+    // let lastClass: string | null = null // (no-spec-coverage)
+    for (const ch of value) {
+        const bidiClass = GetBidiClass(ch.codePointAt(0));
+        if (isFirst) {
+            // 1. The first character must be a character with Bidi property L, R, or AL.
+            if (bidiClass !== 'L' && bidiClass !== 'R' && bidiClass !== 'AL')
+                return false;
+            isRtl = bidiClass === 'R' || bidiClass === 'AL';
+            allowed = isRtl ? RE_RTL_ALLOWED : RE_LTR_ALLOWED;
+            isFirst = false;
+        }
+        // 2 / 5. Only characters in the allowed set for this direction may appear.
+        if (!allowed.test(bidiClass))
+            return false;
+        if (bidiClass === 'EN')
+            sawEN = true;
+        else if (bidiClass === 'AN')
+            sawAN = true;
+        // if (bidiClass !== 'NSM') lastClass = bidiClass // (no-spec-coverage)
+    }
+    if (isRtl && sawEN && sawAN)
+        return false; // spec coverage path
+    // (no-spec-coverage)
+    // if (isRtl) {
+    //   // 3. The end of the label must be R, AL, EN, or AN (ignoring trailing NSM).
+    //   // if (lastClass !== 'R' && lastClass !== 'AL' && lastClass !== 'EN' && lastClass !== 'AN') return false
+    //   // 4. If an EN is present, no AN may be present, and vice versa.
+    //   if (sawEN && sawAN) return false
+    // } else {
+    //   // 6. The end of the label must be L or EN (ignoring trailing NSM).
+    //   // if (lastClass !== 'L' && lastClass !== 'EN') return false
+    // }
+    return true;
+}

package/node_modules/typebox/build/format/idna/format/puny.d.mts

@@ -0,0 +1,3 @@
+export declare function IsAcePrefixed(value: string): boolean;
+export declare function Decode(value: string): string;
+export declare function Encode(input: string): string;