@openclaw/lobster 2026.9.6 → 2026.9.7

package/dist/index.js

@@ -1,12 +1,12 @@
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
-import { optionalNonNegativeIntegerSchema, optionalPositiveIntegerSchema } from "openclaw/plugin-sdk/channel-actions";
-import { readNonNegativeIntegerParam, readPositiveIntegerParam } from "openclaw/plugin-sdk/param-readers";
+import { optionalPositiveIntegerSchema } from "openclaw/plugin-sdk/channel-actions";
+import { readPositiveIntegerParam } from "openclaw/plugin-sdk/param-readers";
 import { jsonResult } from "openclaw/plugin-sdk/tool-results";
 import { Type } from "typebox";
 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 { extractErrorCode, 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([
@@ -53,9 +53,6 @@ function normalizeEnvelope(envelope, maxStdoutBytes) {
 	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";
-}
 async function detectWorkflowFile(candidate, cwd) {
 	const trimmed = candidate.trim();
 	if (!trimmed || trimmed.includes("|") || !workflowExts.has(path.extname(trimmed).toLowerCase())) return null;
@@ -64,7 +61,7 @@ async function detectWorkflowFile(candidate, cwd) {
 		if (!(await stat(resolved)).isFile()) throw new Error("Workflow path is not a file");
 		return resolved;
 	} catch (error) {
-		if (/\s/.test(trimmed) && isMissingPathError(error)) return null;
+		if (/\s/.test(trimmed) && extractErrorCode(error) === "ENOENT") return null;
 		throw error;
 	}
 }
@@ -153,257 +150,7 @@ function createEmbeddedLobsterRunner(options) {
 	} };
 }
 //#endregion
-//#region extensions/lobster/src/lobster-taskflow.ts
-function toJsonLike(value, seen = /* @__PURE__ */ new WeakSet()) {
-	if (value === null) return null;
-	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);
-	}
-	seen.delete(value);
-	return jsonObject;
-}
-function buildApprovalWaitState(envelope) {
-	const approval = envelope.requiresApproval;
-	return {
-		kind: "lobster_approval",
-		prompt: approval ? approval.prompt : "",
-		items: approval ? approval.items.map((item) => toJsonLike(item)) : [],
-		...approval?.resumeToken ? { resumeToken: approval.resumeToken } : {},
-		...approval?.approvalId ? { approvalId: approval.approvalId } : {}
-	};
-}
-async function executeManagedLobsterFlow(params, flow) {
-	try {
-		const envelope = await params.runner.run(params.runnerParams);
-		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: await params.taskFlow.fail(flowMutation),
-			error: new Error(envelope.error.message)
-		};
-		return {
-			ok: true,
-			envelope,
-			flow,
-			mutation: envelope.status === "needs_approval" ? await params.taskFlow.setWaiting({
-				...flowMutation,
-				currentStep: params.waitingStep ?? "await_lobster_approval",
-				waitJson: buildApprovalWaitState(envelope)
-			}) : await params.taskFlow.finish(flowMutation)
-		};
-	} catch (error) {
-		const err = error instanceof Error ? error : new Error(String(error));
-		try {
-			return {
-				ok: false,
-				flow,
-				mutation: await params.taskFlow.fail({
-					flowId: flow.flowId,
-					expectedRevision: flow.revision
-				}),
-				error: err
-			};
-		} catch {
-			return {
-				ok: false,
-				flow,
-				error: err
-			};
-		}
-	}
-}
-async function runManagedLobsterFlow(params) {
-	const createFlowParams = {
-		controllerId: params.controllerId,
-		goal: params.goal,
-		currentStep: params.currentStep ?? "run_lobster",
-		...params.stateJson !== void 0 ? { stateJson: params.stateJson } : {}
-	};
-	const flow = await params.taskFlow.tryCreateManaged(createFlowParams);
-	if (!flow) return {
-		ok: false,
-		error: /* @__PURE__ */ new Error("TaskFlow persistence failed.")
-	};
-	return await executeManagedLobsterFlow(params, flow);
-}
-async function resumeManagedLobsterFlow(params) {
-	const saved = await params.taskFlow.get(params.flowId);
-	if (!saved || saved.syncMode !== "managed" || saved.endedAt !== void 0 || saved.cancelRequestedAt !== void 0 || saved.status !== "waiting" && saved.status !== "blocked") return {
-		ok: false,
-		error: /* @__PURE__ */ new Error("TaskFlow has no resumable Lobster checkpoint.")
-	};
-	const wait = saved.waitJson;
-	if (!wait || typeof wait !== "object" || Array.isArray(wait) || wait.kind !== "lobster_approval") return {
-		ok: false,
-		error: /* @__PURE__ */ new Error("TaskFlow is not waiting for Lobster approval.")
-	};
-	const token = typeof wait.resumeToken === "string" ? wait.resumeToken : void 0;
-	const approvalId = typeof wait.approvalId === "string" ? wait.approvalId : void 0;
-	if (!token && !approvalId || params.runnerParams.token !== void 0 && params.runnerParams.token.trim() !== token || params.runnerParams.approvalId !== void 0 && params.runnerParams.approvalId.trim() !== approvalId) return {
-		ok: false,
-		error: /* @__PURE__ */ new Error("Lobster checkpoint does not match the selected TaskFlow.")
-	};
-	const runnerParams = {
-		...params.runnerParams,
-		...params.runnerParams.token || params.runnerParams.approvalId ? {} : token ? { token } : { approvalId }
-	};
-	if (saved.revision !== params.expectedRevision) return {
-		ok: false,
-		error: /* @__PURE__ */ new Error("TaskFlow resume failed: revision_conflict")
-	};
-	const resumed = await params.taskFlow.resume({
-		flowId: params.flowId,
-		expectedRevision: params.expectedRevision,
-		status: "running",
-		currentStep: params.currentStep ?? "resume_lobster"
-	});
-	if (!resumed.applied) return {
-		ok: false,
-		mutation: resumed,
-		error: /* @__PURE__ */ new Error(`TaskFlow resume failed: ${resumed.code}`)
-	};
-	return await executeManagedLobsterFlow({
-		...params,
-		runnerParams
-	}, resumed.flow);
-}
-//#endregion
 //#region extensions/lobster/src/lobster-tool.ts
-function readOptionalTrimmedString(value, fieldName) {
-	if (value === void 0) return;
-	if (typeof value !== "string") throw new Error(`${fieldName} must be a string`);
-	const trimmed = value.trim();
-	return trimmed ? trimmed : void 0;
-}
-function readOptionalNumber(value, fieldName) {
-	return readNonNegativeIntegerParam({ [fieldName]: value }, fieldName, { message: `${fieldName} must be a non-negative integer` });
-}
-function readOptionalBoolean(value, fieldName) {
-	if (value === void 0) return;
-	if (typeof value !== "boolean") throw new Error(`${fieldName} must be a boolean`);
-	return value;
-}
-function parseOptionalFlowStateJson(value) {
-	if (value === void 0) return;
-	if (typeof value !== "string") throw new Error("flowStateJson must be a JSON string");
-	const trimmed = value.trim();
-	if (!trimmed) return;
-	try {
-		return JSON.parse(trimmed);
-	} catch {
-		throw new Error("flowStateJson must be valid JSON");
-	}
-}
-function isEmptyJsonObject(value) {
-	return value !== void 0 && value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
-}
-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");
-	const waitingStep = readOptionalTrimmedString(params.flowWaitingStep, "flowWaitingStep");
-	const token = readOptionalTrimmedString(params.token, "token");
-	const approvalId = readOptionalTrimmedString(params.approvalId, "approvalId");
-	const approve = readOptionalBoolean(params.approve, "approve");
-	const runControllerId = readOptionalTrimmedString(params.flowControllerId, "flowControllerId");
-	const runGoal = readOptionalTrimmedString(params.flowGoal, "flowGoal");
-	const stateJson = parseOptionalFlowStateJson(params.flowStateJson);
-	const stateJsonDisallowed = stateJson !== void 0 && !isEmptyJsonObject(stateJson);
-	if (runControllerId !== void 0 || runGoal !== void 0 || stateJsonDisallowed) throw new Error("resume action does not accept flowControllerId, flowGoal, or flowStateJson");
-	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");
-	const credentialParams = token ? { token: runnerParams.token ?? token } : approvalId ? { approvalId: runnerParams.approvalId ?? approvalId } : null;
-	if (approve === void 0) throw new Error("approve required when using managed TaskFlow resume mode");
-	return {
-		action,
-		flowId,
-		expectedRevision,
-		...currentStep ? { currentStep } : {},
-		...waitingStep ? { waitingStep } : {},
-		runnerParams: {
-			...runnerParams,
-			...credentialParams,
-			action,
-			approve
-		}
-	};
-}
-function resolveManagedFlowToolResult(result) {
-	if (!result.ok) throw result.error;
-	return jsonResult({
-		...result.envelope,
-		flow: result.flow,
-		mutation: result.mutation
-	});
-}
-function requireTaskFlowRuntime(taskFlow, action) {
-	if (!taskFlow) throw new Error(`Managed TaskFlow ${action} mode requires a bound taskFlow runtime`);
-	return taskFlow;
-}
 function createLobsterTool(api, options) {
 	const runner = options?.runner ?? createEmbeddedLobsterRunner();
 	return {
@@ -419,14 +166,7 @@ function createLobsterTool(api, options) {
 			approve: Type.Optional(Type.Boolean()),
 			cwd: Type.Optional(Type.String({ description: "Relative working directory (optional). Must stay within the gateway working directory." })),
 			timeoutMs: optionalPositiveIntegerSchema(),
-			maxStdoutBytes: optionalPositiveIntegerSchema(),
-			flowControllerId: Type.Optional(Type.String()),
-			flowGoal: Type.Optional(Type.String()),
-			flowStateJson: Type.Optional(Type.String()),
-			flowId: Type.Optional(Type.String({ description: "Managed flow to resume. Its saved approval checkpoint is used when token and approvalId are omitted." })),
-			flowExpectedRevision: optionalNonNegativeIntegerSchema(),
-			flowCurrentStep: Type.Optional(Type.String()),
-			flowWaitingStep: Type.Optional(Type.String())
+			maxStdoutBytes: optionalPositiveIntegerSchema()
 		}),
 		async execute(_id, params) {
 			const action = typeof params.action === "string" ? params.action.trim() : "";
@@ -447,29 +187,6 @@ function createLobsterTool(api, options) {
 				timeoutMs,
 				maxStdoutBytes
 			};
-			const taskFlow = options?.taskFlow;
-			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);
@@ -483,13 +200,10 @@ var lobster_default = definePluginEntry({
 	name: "Lobster",
 	description: "Optional local shell helper tools",
 	register(api) {
-		api.registerTool(((ctx) => {
+		api.registerTool((ctx) => {
 			if (ctx.sandboxed) return null;
-			return createLobsterTool(api, { taskFlow: api.runtime && ctx.sessionKey ? {
-				...api.runtime.tasks.async.managedFlows.fromToolContext(ctx),
-				cancel: api.runtime.tasks.managedFlows.fromToolContext(ctx).cancel
-			} : void 0 });
-		}), { optional: true });
+			return createLobsterTool(api);
+		}, { optional: true });
 	}
 });
 //#endregion

package/node_modules/@clawdbot/lobster/node_modules/fast-uri/README.md

@@ -99,6 +99,7 @@ fast-uri supports inserting custom [scheme](https://en.wikipedia.org/wiki/URI_sc
 *	wss \[[RFC 6455](https://www.ietf.org/rfc/rfc6455.txt)\]
 *	urn \[[RFC 2141](https://www.ietf.org/rfc/rfc2141.txt)\]
 *	urn:uuid \[[RFC 4122](https://www.ietf.org/rfc/rfc4122.txt)\]
+*	mailto \[[RFC 6068](https://www.rfc-editor.org/rfc/rfc6068)\]
 
 
 ## Benchmarks

package/node_modules/@clawdbot/lobster/node_modules/fast-uri/SECURITY.md

@@ -15,38 +15,87 @@ Reports based solely on comparing or mixing parsers that follow these different
 standards are out of scope. Applications must use the same parsing and
 normalization rules for both security decisions and subsequent URI use.
 
+A WHATWG comparison may be useful supporting evidence, but a parser difference
+is not by itself a vulnerability. A report remains in scope when it independently
+demonstrates a defect in `fast-uri`'s RFC or documented behavior for a supported
+scheme and a concrete security impact when the application uses `fast-uri`
+consistently. An exploit that requires validating with `fast-uri` and then
+passing the original, unmodified input to a parser with different rules is an
+application parser-confusion issue.
+
 Reports are assessed based on reproducibility, documented supported usage, and
 concrete security impact—not merely on whether they mention WHATWG URL
-behavior. Reports demonstrating a parsing or normalization flaw in a supported
-scheme remain eligible for evaluation.
+behavior.
 
 ## Threat model
 
 `fast-uri`'s threat model extends the
 [Node.js threat model](https://github.com/nodejs/node/blob/main/SECURITY.md#the-nodejs-threat-model).
 
-**Trusted:** Application code, parser options, configuration, and the runtime
-environment.
+**Trusted:** Application code, structured component objects constructed or
+modified by application code and passed directly to `serialize()`, parser
+options, configuration, and the runtime environment.
 
 **Untrusted:** URI and IRI strings passed to the package's public APIs.
 
+## Vulnerability classification
+
+A report is treated as a vulnerability when it demonstrates all of the
+following:
+
+1. Attacker-controlled input reaches a public API through documented,
+   supported usage.
+2. `fast-uri` violates an applicable RFC or its documented API contract.
+3. The defect creates a concrete confidentiality, integrity, or availability
+   impact in a realistic supported use case.
+4. The impact does not depend solely on application misuse, an unsupported
+   scheme, a different parser interpreting the original input, or another
+   package's behavior.
+
+A reproducible bug can still merit a normal issue and fix without meeting the
+security-vulnerability threshold.
+
 ### Examples of vulnerabilities
 
-- RFC 3986 parsing or normalization flaws that bypass security controls
-- Denial of service through malformed input
-- Inconsistent parsing or normalization between `fast-uri` APIs
+- `parse()`, `normalize()`, or `resolve()` changes an attacker-controlled
+  authority within `fast-uri`, and the report demonstrates a host security
+  control being bypassed using that output
+- `equal()` aliases distinct URIs under the rules of a supported scheme, and
+  the report demonstrates an authorization, signature, or cache boundary being
+  bypassed
+- One public API call on a reasonably sized malformed URI causes
+  disproportionate CPU or memory consumption, with reproducible availability
+  impact
+- Parsing or normalization turns component data into a structural delimiter
+  and the report demonstrates a security-control bypass in documented usage
+
+### Denial-of-service reports
+
+A synchronous exception, parse error, or non-idempotent result is not by itself
+a denial-of-service vulnerability. A report must demonstrate disproportionate
+resource consumption in a public API call, or loss of availability in a
+supported deployment despite normal exception handling. An application that
+terminates on an uncaught exception, or repeatedly normalizes until reaching a
+fixpoint, does not establish a package vulnerability by itself.
 
 ### Examples of non-vulnerabilities
 
 The following are **not** considered vulnerabilities in `fast-uri`:
 
-- **Different URL standards:** Differences between RFC 3986 behavior and
-  WHATWG URL behavior, including differences exposed by mixing parsers that
-  implement those standards
-- **Unsupported scheme semantics:** Scheme-specific behavior for schemes that
-  `fast-uri` does not document as supported
+- **Different URL standards:** `fast-uri` returns one host, but an application
+  passes the original input to WHATWG `URL`, `fetch`, or another parser that
+  applies different recovery, whitespace, or legacy-IP rules
+- **Unsupported scheme semantics:** Behavior specific to schemes such as
+  `ftp` or `file`, which `fast-uri` does not document as supported
+- **Correctness without security impact:** Non-idempotent normalization,
+  surprising equality, truncation, re-encoding, or malformed-input handling
+  without a demonstrated security boundary or availability impact
+- **Caller-created resource use:** An application repeatedly parses or
+  normalizes a value, or fails to catch a synchronous exception
+- **Trusted structured input:** Boundary characters supplied in a component
+  object that application code constructs and passes to `serialize()`
 - **Application code vulnerabilities:** Security flaws in code that consumes
-  `fast-uri` output
+  `fast-uri` output contrary to its documented contract
 - **Configuration mistakes:** Security issues caused by incorrect parser
   options or application configuration
 - **Missing security features:** Application-level protections that are not

package/node_modules/@clawdbot/lobster/node_modules/fast-uri/index.js

@@ -89,6 +89,22 @@ function resolve (baseURI, relativeURI, options) {
   return serialize(resolved, schemelessOptions)
 }
 
+/**
+ * Copies a host component together with its parse-time zone identifier (if
+ * any), so downstream recomposition does not re-derive an IPv6 zone from the
+ * ambiguous single-"%" component form. The zone is validated on use by
+ * `recomposeAuthority` rather than blindly trusted.
+ *
+ * @param {import('./types/index').URIComponent} target
+ * @param {import('./types/index').URIComponent} source
+ */
+function copyHost (target, source) {
+  target.host = source.host
+  if (source.ipv6Zone !== undefined) {
+    target.ipv6Zone = source.ipv6Zone
+  }
+}
+
 /**
  * @param {import ('./types/index').URIComponent} base
  * @param {import ('./types/index').URIComponent} relative
@@ -109,7 +125,7 @@ function resolveComponent (base, relative, options, skipNormalization) {
     target.scheme = relative.scheme
     // target.authority = relative.authority;
     target.userinfo = relative.userinfo
-    target.host = relative.host
+    copyHost(target, relative)
     target.port = relative.port
     target.path = removeDotSegments(relative.path || '')
     target.query = relative.query
@@ -117,7 +133,7 @@ function resolveComponent (base, relative, options, skipNormalization) {
     if (relative.userinfo !== undefined || relative.host !== undefined || relative.port !== undefined) {
       // target.authority = relative.authority;
       target.userinfo = relative.userinfo
-      target.host = relative.host
+      copyHost(target, relative)
       target.port = relative.port
       target.path = removeDotSegments(relative.path || '')
       target.query = relative.query
@@ -146,7 +162,7 @@ function resolveComponent (base, relative, options, skipNormalization) {
       }
       // target.authority = base.authority;
       target.userinfo = base.userinfo
-      target.host = base.host
+      copyHost(target, base)
       target.port = base.port
     }
     target.scheme = base.scheme
@@ -178,6 +194,7 @@ function equal (uriA, uriB, options) {
 function serialize (cmpts, opts) {
   const component = {
     host: cmpts.host,
+    ipv6Zone: cmpts.ipv6Zone,
     scheme: cmpts.scheme,
     userinfo: cmpts.userinfo,
     port: cmpts.port,
@@ -506,6 +523,16 @@ function parseWithStatus (uri, opts) {
         malformedIPLiteral = hasIPLiteralBracket && (!bracketedIPLiteral || ipv6result.error === true)
         parsed.host = isIP ? ipv6result.host : ipv6result.host.toLowerCase()
 
+        if (isIP && ipv6result.isIPV6 === true && parsed.host.indexOf('%') !== -1) {
+          // Persist the zone identifier so recomposition never has to re-derive
+          // it from the ambiguous single-"%" component form, which misreads a
+          // zone that begins with "25" as a %25 separator. It is validated on
+          // use during recomposition, so a host reassigned after parse or an
+          // input zone that does not describe the host is ignored. Only zoned
+          // literals are ambiguous; plain IPv6 addresses round-trip without it.
+          parsed.ipv6Zone = parsed.host.slice(parsed.host.indexOf('%') + 1)
+        }
+
         if (malformedIPLiteral) {
           parsed.error = parsed.error || 'URI host is malformed.'
           malformedAuthorityOrPort = true
@@ -537,13 +564,17 @@ function parseWithStatus (uri, opts) {
       malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP)
     }
 
-    if (!schemeHandler || (schemeHandler && !schemeHandler.skipNormalize)) {
-      if (uri.indexOf('%') !== -1) {
-        if (parsed.host !== undefined && !malformedIPLiteral) {
-          const host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true)
-          parsed.host = reescapeHostDelimiters(host, isIP)
-        }
+    if (uri.indexOf('%') !== -1 && parsed.host !== undefined && !malformedIPLiteral) {
+      let host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true)
+      if (!isIP) {
+        // Fold reg-name case after decoding unreserved octets. The second
+        // pass only restores uppercase hex in escapes that remain encoded.
+        host = normalizePercentEncoding(host.toLowerCase())
       }
+      parsed.host = reescapeHostDelimiters(host, isIP)
+    }
+
+    if (!schemeHandler || (schemeHandler && !schemeHandler.skipNormalize)) {
       if (parsed.path) {
         parsed.path = normalizePathEncoding(parsed.path)
       }