@openclaw/zoom-meetings 2026.9.6 → 2026.9.7

package/dist/index.js

@@ -143,32 +143,6 @@ function zoomMeetingStatusCallSource() {
 	});
 }
 //#endregion
-//#region extensions/zoom-meetings/src/transports/zoom-meetings-status-access-source.ts
-function zoomMeetingStatusAccessSource() {
-	return `  const passcodeInput = firstRaw(selectors.passcode);
-  const passcodeRequired = Boolean(passcodeInput) &&
-    /meeting passcode|enter (?:the )?passcode|invalid passcode|incorrect passcode/i.test(
-      pageText + " " + label(passcodeInput)
-    );
-  const captchaRequired = Boolean(firstRaw(selectors.captcha)) ||
-    /complete (?:the )?captcha|security check|verify (?:that )?you(?:'re| are) (?:a )?human/i.test(pageTextLower);
-  if (identityVerified && !inCall && passcodeRequired) {
-    controlManualAction = manualActionFor("zoom-passcode-required", "Enter the Zoom meeting passcode in the OpenClaw browser profile, then retry joining.");
-  } else if (identityVerified && !inCall && captchaRequired) {
-    controlManualAction = manualActionFor("zoom-captcha-required", "Complete Zoom's security check in the OpenClaw browser profile, then retry joining.");
-  }
-`;
-}
-//#endregion
-//#region extensions/zoom-meetings/src/transports/zoom-meetings-status-page-source.ts
-function zoomMeetingStatusPageSource() {
-	return `  const pageText = text(document.body);
-  const pageTextLower = pageText.toLowerCase();
-  const lobbyWaiting = Boolean(first(selectors.lobby)) ||
-    /host will let you in soon|waiting for the host to start|someone will let you in shortly|waiting for someone to let you in|when someone admits you|you.?re in the lobby|we.?ve let people in the meeting know you.?re waiting/i.test(pageTextLower);
-`;
-}
-//#endregion
 //#region extensions/zoom-meetings/src/transports/zoom-meetings-status-prejoin-source.ts
 function zoomMeetingStatusPreludeSource(params) {
 	return MeetingPlatformAdapter.createStatusPreludeSource(params, {
@@ -231,7 +205,11 @@ function zoomMeetingStatusPreludeSource(params) {
       await waitForUi();
     }
   }
-  ${zoomMeetingStatusPageSource()}
+  const pageText = text(document.body);
+  const pageTextLower = pageText.toLowerCase();
+  const lobbyWaiting = Boolean(first(selectors.lobby)) ||
+    /host will let you in soon|waiting for the host to start|someone will let you in shortly|waiting for someone to let you in|when someone admits you|you.?re in the lobby|we.?ve let people in the meeting know you.?re waiting/i.test(pageTextLower);
+
   const devicesDisabled = Boolean(!allowMicrophone && (dismissedDevicePrompt || (priorMeeting?.identity === expectedIdentity && (!sessionId || priorMeeting?.sessionId === sessionId) && priorMeeting?.devicesDisabled === true)));
   // Zoom replaces the meeting URL after admission; retain only an adopted in-call control.
   // Lobby ownership remains durable because host admission has no bounded wait.
@@ -319,10 +297,27 @@ function zoomMeetingStatusPreludeSource(params) {
   }
   const microphone = first(selectors.microphone) || findTextButton(/mute|unmute|microphone/i);
   let microphoneState = identityVerified ? (toggleState(microphone, "microphone") || (devicesDisabled ? "off" : undefined)) : undefined;
+  const refreshMicrophoneState = async () => {
+    await waitForUi();
+    const currentMicrophone = first(selectors.microphone) || findTextButton(/mute|unmute|microphone/i);
+    microphoneState = toggleState(currentMicrophone, "microphone");
+  };
   const camera = first(selectors.camera) || findTextButton(/camera|video/i);
   let cameraState = identityVerified ? (toggleState(camera, "camera") || (devicesDisabled ? "off" : undefined)) : undefined;
   let controlManualAction;
-  ${zoomMeetingStatusAccessSource()}
+  const passcodeInput = firstRaw(selectors.passcode);
+  const passcodeRequired = Boolean(passcodeInput) &&
+    /meeting passcode|enter (?:the )?passcode|invalid passcode|incorrect passcode/i.test(
+      pageText + " " + label(passcodeInput)
+    );
+  const captchaRequired = Boolean(firstRaw(selectors.captcha)) ||
+    /complete (?:the )?captcha|security check|verify (?:that )?you(?:'re| are) (?:a )?human/i.test(pageTextLower);
+  if (identityVerified && !inCall && passcodeRequired) {
+    controlManualAction = manualActionFor("zoom-passcode-required", "Enter the Zoom meeting passcode in the OpenClaw browser profile, then retry joining.");
+  } else if (identityVerified && !inCall && captchaRequired) {
+    controlManualAction = manualActionFor("zoom-captcha-required", "Complete Zoom's security check in the OpenClaw browser profile, then retry joining.");
+  }
+
   if (
     canMutateSession &&
     identityVerified &&
@@ -416,25 +411,19 @@ function zoomMeetingStatusPreludeSource(params) {
     if (!audioInputRouted) {
       if (canMutateSession && microphoneState === "on") {
         microphone.click();
-        await waitForUi();
-        const currentMicrophone = first(selectors.microphone) || findTextButton(/mute|unmute|microphone/i);
-        microphoneState = toggleState(currentMicrophone, "microphone");
+        await refreshMicrophoneState();
       }
       notes.push("The virtual audio input will be selected from Zoom's in-call audio controls.");
     } else if (canMutateSession && microphoneState === "off") {
       microphone.click();
-      await waitForUi();
-      const currentMicrophone = first(selectors.microphone) || findTextButton(/mute|unmute|microphone/i);
-      microphoneState = toggleState(currentMicrophone, "microphone");
+      await refreshMicrophoneState();
       if (microphoneState === "on") {
         notes.push("Unmuted the Zoom microphone after verifying the virtual audio input.");
       }
     }
   } else if (canMutateSession && identityVerified && !allowMicrophone && microphoneState === "on") {
       microphone.click();
-      await waitForUi();
-      const currentMicrophone = first(selectors.microphone) || findTextButton(/mute|unmute|microphone/i);
-      microphoneState = toggleState(currentMicrophone, "microphone");
+      await refreshMicrophoneState();
       if (microphoneState === "off") {
         notes.push("Muted the Zoom microphone for observe-only mode.");
       }
@@ -442,21 +431,15 @@ function zoomMeetingStatusPreludeSource(params) {
   if (identityVerified && inCall && allowMicrophone) {
     if (!selectedMicrophoneLabel() && canMutateSession && microphoneState === "on") {
       microphone?.click();
-      await waitForUi();
-      const currentMicrophone = first(selectors.microphone) || findTextButton(/mute|unmute|microphone/i);
-      microphoneState = toggleState(currentMicrophone, "microphone");
+      await refreshMicrophoneState();
     }
     audioInputRouted = await ensureVirtualAudioInput();
     if (audioInputRouted && canMutateSession && microphoneState === "off") {
       microphone?.click();
-      await waitForUi();
-      const currentMicrophone = first(selectors.microphone) || findTextButton(/mute|unmute|microphone/i);
-      microphoneState = toggleState(currentMicrophone, "microphone");
+      await refreshMicrophoneState();
     } else if (!audioInputRouted && canMutateSession && microphoneState === "on") {
       microphone?.click();
-      await waitForUi();
-      const currentMicrophone = first(selectors.microphone) || findTextButton(/mute|unmute|microphone/i);
-      microphoneState = toggleState(currentMicrophone, "microphone");
+      await refreshMicrophoneState();
       if (microphoneState === "off") {
         notes.push("Muted the Zoom microphone because the virtual audio input could not be reverified.");
       }
@@ -728,14 +711,6 @@ function zoomMeetingLeaveScript(params) {
 	});
 }
 //#endregion
-//#region extensions/zoom-meetings/src/transports/zoom-meetings-platform-constants.ts
-const ZOOM_MEETINGS_NODE_COMMAND = "zoommeetings.chrome";
-const ZOOM_MEETINGS_BROWSER_NODE_ADAPTER = {
-	displayName: "Zoom meetings",
-	nodeCommandName: ZOOM_MEETINGS_NODE_COMMAND,
-	nodeConfigPath: "plugins.entries.zoom-meetings.config.chromeNode.node"
-};
-//#endregion
 //#region extensions/zoom-meetings/src/transports/zoom-meetings-platform-adapter.ts
 function zoomMeetingOrigin(meetingUrl) {
 	return normalizeZoomMeetingUrlForReuse(meetingUrl) ? "https://app.zoom.us" : void 0;
@@ -776,7 +751,7 @@ const ZOOM_MEETINGS_PLATFORM_ADAPTER = MeetingPlatformAdapter.create({
 		idPrefix: "zoom_meeting",
 		participantIdentity: (transport) => transport === "chrome-node" ? "Zoom guest in Chrome on a paired node" : "Zoom guest in the OpenClaw Chrome profile"
 	},
-	nodeCommandName: ZOOM_MEETINGS_NODE_COMMAND,
+	nodeCommandName: "zoommeetings.chrome",
 	nodeConfigPath: "plugins.entries.zoom-meetings.config.chromeNode.node",
 	urls: {
 		validateAndNormalize: normalizeZoomMeetingUrl,
@@ -856,33 +831,25 @@ function createZoomMeetingsNodeInvokePolicy(config) {
 }
 //#endregion
 //#region extensions/zoom-meetings/src/runtime-probes.ts
-const probes = MeetingPlatformAdapter.createRuntimeProbes({
+const zoomMeetingsProbes = MeetingPlatformAdapter.createRuntimeProbes({
 	defaultSpeechMessage: "Say exactly: Zoom speech test complete.",
 	invalidRequest: zoomMeetingsInvalidRequest,
 	resolveTimeoutMs: (input, fallback) => MeetingPlatformAdapter.resolveProbeTimeoutMs(input, fallback, zoomMeetingsInvalidRequest),
 	shouldWaitForListening: (session) => Boolean(session.chrome?.browserTab?.targetId),
 	talkBackMode: MeetingPlatformAdapter.isTalkBackMode
 });
-const testZoomMeetingListening = probes.testListening;
-const testZoomMeetingSpeech = probes.testSpeech;
 //#endregion
 //#region extensions/zoom-meetings/src/transports/chrome.ts
-const chromeTransport = MeetingPlatformAdapter.createPluginChromeTransport({
+const zoomMeetingsChrome = MeetingPlatformAdapter.createPluginChromeTransport({
 	meetingLabel: "Zoom meeting",
 	platform: ZOOM_MEETINGS_PLATFORM_ADAPTER,
 	preserveTrackedBrowserOnEngineFailure: true,
 	runtime: MeetingPlatformAdapter.createChromeRuntimeBindings()
 });
-const assertZoomMeetingsAudioAvailable = chromeTransport.assertAudioDeviceAvailable;
-const launchZoomMeetingInChrome = chromeTransport.launchInChrome;
-const launchZoomMeetingOnNode = chromeTransport.launchOnNode;
-const leaveZoomMeetingInBrowser = chromeTransport.leaveInBrowser;
-const readZoomMeetingTranscript = chromeTransport.readTranscript;
-const recoverCurrentZoomMeetingTab = chromeTransport.recoverCurrentTab;
 //#endregion
 //#region extensions/zoom-meetings/src/runtime-setup.ts
 const getZoomMeetingsSetupStatus = MeetingPlatformAdapter.createRuntimeSetup({
-	assertAudioDeviceAvailable: assertZoomMeetingsAudioAvailable,
+	assertAudioDeviceAvailable: zoomMeetingsChrome.assertAudioDeviceAvailable,
 	captionsMessage: (mode) => mode === "transcribe" ? "Zoom live-caption capture is enabled and ready" : "Caption scraping is not used by talk-back modes",
 	connectedNodeMessage: (node) => `Connected Zoom meeting node ready: ${node}`,
 	guestJoinCheck: (config) => {
@@ -893,23 +860,16 @@ const getZoomMeetingsSetupStatus = MeetingPlatformAdapter.createRuntimeSetup({
 		};
 	},
 	missingNodeIdMessage: "Connected Zoom meetings node did not include a node id.",
-	nodeAdapter: ZOOM_MEETINGS_BROWSER_NODE_ADAPTER
+	nodeAdapter: ZOOM_MEETINGS_PLATFORM_ADAPTER
 });
 //#endregion
 //#region extensions/zoom-meetings/src/runtime.ts
 const ZoomMeetingsRuntime = MeetingPlatformAdapter.createRuntimeFacade({
 	platform: ZOOM_MEETINGS_PLATFORM_ADAPTER,
-	transport: {
-		launchInChrome: launchZoomMeetingInChrome,
-		launchOnNode: launchZoomMeetingOnNode,
-		leaveInBrowser: leaveZoomMeetingInBrowser,
-		readTranscript: readZoomMeetingTranscript,
-		recoverCurrentTab: recoverCurrentZoomMeetingTab
-	},
+	transport: zoomMeetingsChrome,
 	probes: {
 		setupStatus: getZoomMeetingsSetupStatus,
-		testListening: testZoomMeetingListening,
-		testSpeech: testZoomMeetingSpeech
+		...zoomMeetingsProbes
 	},
 	hooks: {
 		normalizeJoinRequest: (request, context) => {

package/node_modules/typebox/build/compile/code.mjs

@@ -16,9 +16,8 @@ function Separator() {
 function ImportSection(build) {
     const context = build.UseUnevaluated() ? [`import { CheckContext } from "typebox/schema"`] : [];
     const hashing = `import { Hashing } from "typebox/system"`;
-    const format = `import { Format } from "typebox/format"`;
     const guard = `import { Guard } from "typebox/guard"`;
-    return [...context, hashing, format, guard];
+    return [...context, hashing, guard];
 }
 // ------------------------------------------------------------------
 // ExternalSection

package/node_modules/typebox/build/compile/validator.mjs

@@ -1,4 +1,5 @@
 // deno-fmt-ignore-file
+import { EnableParseErrors, DisableParseErrors } from '../system/settings/internal.mjs';
 import { Settings } from '../system/settings/index.mjs';
 import { Errors, Clean, Convert, Create, Default, Decode, Encode, HasCodec, Parser, ParseError } from '../value/index.mjs';
 import { Build } from '../schema/index.mjs';
@@ -51,7 +52,10 @@ export class Validator {
             return value;
         if (Settings.Get().correctiveParse)
             return Parser(this.Context(), this.Type(), value);
-        throw new ParseError(value, this.Errors(value));
+        EnableParseErrors();
+        const errors = this.Errors(value);
+        DisableParseErrors();
+        throw new ParseError(value, errors);
     }
     /** Returns an array of validation errors for the given value. */
     Errors(value) {

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

@@ -1,9 +1,10 @@
 // deno-lint-ignore-file no-control-regex
-const IpvFutureMatchMaxLength = 2048;
-const IpvFutureMatch = /\[[vV][0-9a-fA-F]+\.[^\]]+\]/; // Guarded By IpvFutureMatchMaxLength
-const InvalidIriChars = /[\x00-\x20<>\^`{|}\\]/;
-const InvalidPercentEncoding = /%(?![0-9a-fA-F]{2})/;
 // ------------------------------------------------------------------
+//
+// Removed by the following PR
+//
+// https://github.com/json-schema-org/JSON-Schema-Test-Suite/pull/1176
+//
 // NarrowIpvFuture
 //
 // Substitutes an IPvFuture address with a standard IPv6 loopback
@@ -13,12 +14,18 @@ const InvalidPercentEncoding = /%(?![0-9a-fA-F]{2})/;
 // be expensive on large strings, this operation is strictly
 // limited to inputs under a defined length threshold.
 //
-// (review-optimization)
+// ------------------------------------------------------------------
+//
+// const IpvFutureMatchMaxLength = 2048
+// const IpvFutureMatch = /\[[vV][0-9a-fA-F]+\.[^\]]+\]/ // Guarded By IpvFutureMatchMaxLength
+//
+// function NarrowIpvFuture(value: string): string {
+//   return value.length < IpvFutureMatchMaxLength ? value.replace(IpvFutureMatch, '[::1]') : value
+// }
 //
 // ------------------------------------------------------------------
-function NarrowIpvFuture(value) {
-    return value.length < IpvFutureMatchMaxLength ? value.replace(IpvFutureMatch, '[::1]') : value;
-}
+const InvalidIriChars = /[\x00-\x20<>\^`{|}\\]/;
+const InvalidPercentEncoding = /%(?![0-9a-fA-F]{2})/;
 /**
  * Returns true if the value is a valid Internationalized Resource Identifier.
  * @specification https://datatracker.ietf.org/doc/html/rfc3987
@@ -31,5 +38,5 @@ export function IsIri(value) {
     if (InvalidPercentEncoding.test(value))
         return false;
     // 3. Delegate to the native URL parser, patching the IPvFuture edge case beforehand.
-    return URL.canParse(NarrowIpvFuture(value));
+    return URL.canParse(value);
 }

package/node_modules/typebox/build/guard/emit.mjs

@@ -97,10 +97,10 @@ export function IsGreaterEqualThan(left, right) {
 // String
 // --------------------------------------------------------------------------
 export function IsMinLength(value, length) {
-    return `Guard.IsMinLength(${value}, ${length})`;
+    return `(${value}.length >= ${(+length) << 1} || (${value}.length >= ${length} && Guard.CodePointCount(${value}) >= ${length}))`;
 }
 export function IsMaxLength(value, length) {
-    return `Guard.IsMaxLength(${value}, ${length})`;
+    return `(${value}.length <= ${length} || (${value}.length <= ${(+length) << 1} && Guard.CodePointCount(${value}) <= ${length}))`;
 }
 // --------------------------------------------------------------------------
 // Array

package/node_modules/typebox/build/guard/guard.d.mts

@@ -33,12 +33,14 @@ export declare function IsMultipleOf(dividend: bigint | number, divisor: bigint
 /** Returns true if the value appears to be an instance of a class. */
 export declare function IsClassInstance(value: unknown): boolean;
 export declare function IsValueLike(value: unknown): value is bigint | boolean | null | number | string | undefined;
-/** Returns the number of grapheme clusters in the string */
+/** Returns the total number of visual grapheme clusters in the string. */
 export declare function GraphemeCount(value: string): number;
-/** Returns true if the string has at most the given number of graphemes */
-export declare function IsMaxLength(value: string, length: number): boolean;
-/** Returns true if the string has at least the given number of graphemes */
-export declare function IsMinLength(value: string, length: number): boolean;
+/** Returns the total number of Unicode code points in the string. */
+export declare function CodePointCount(value: string): number;
+/** Returns true if the string length in Unicode code points does not exceed maxLength */
+export declare function IsMaxLength(value: string, maxLength: number): boolean;
+/** Returns true if the string length in Unicode code points is at least minLength */
+export declare function IsMinLength(value: string, minLength: number): boolean;
 /** Returns true if every element from offset satisfies the callback, short-circuiting on the first failure */
 export declare function Every<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
 /** Returns true if every element from offset satisfies the callback, using exhaustive enumeration */

package/node_modules/typebox/build/guard/guard.mjs

@@ -1,5 +1,6 @@
 // deno-fmt-ignore-file
-import * as String from './string.mjs';
+import * as UnicodeSegmentGuard from './unicode/unicode_segment.mjs';
+import * as UnicodeGuard from './unicode/unicode.mjs';
 // --------------------------------------------------------------------------
 // Guards
 // --------------------------------------------------------------------------
@@ -123,17 +124,21 @@ export function IsValueLike(value) {
 // --------------------------------------------------------------------------
 // String
 // --------------------------------------------------------------------------
-/** Returns the number of grapheme clusters in the string */
+/** Returns the total number of visual grapheme clusters in the string. */
 export function GraphemeCount(value) {
-    return String.GraphemeCount(value);
+    return UnicodeSegmentGuard.GraphemeCount(value);
 }
-/** Returns true if the string has at most the given number of graphemes */
-export function IsMaxLength(value, length) {
-    return String.IsMaxLength(value, length);
+/** Returns the total number of Unicode code points in the string. */
+export function CodePointCount(value) {
+    return UnicodeGuard.CodePointCount(value);
 }
-/** Returns true if the string has at least the given number of graphemes */
-export function IsMinLength(value, length) {
-    return String.IsMinLength(value, length);
+/** Returns true if the string length in Unicode code points does not exceed maxLength */
+export function IsMaxLength(value, maxLength) {
+    return UnicodeGuard.IsMaxLength(value, maxLength);
+}
+/** Returns true if the string length in Unicode code points is at least minLength */
+export function IsMinLength(value, minLength) {
+    return UnicodeGuard.IsMinLength(value, minLength);
 }
 // --------------------------------------------------------------------------
 // Array

package/node_modules/typebox/build/guard/index.mjs

@@ -1,6 +1,12 @@
+// ------------------------------------------------------------------
+// Guards
+// ------------------------------------------------------------------
 export * as EmitGuard from './emit.mjs';
 export * as GlobalsGuard from './globals.mjs';
 export * as NativeGuard from './native.mjs';
+// ------------------------------------------------------------------
+// Default
+// ------------------------------------------------------------------
 import * as Guard from './guard.mjs';
 export * as Guard from './guard.mjs';
 export default Guard;

package/node_modules/typebox/build/guard/unicode/unicode.d.mts

@@ -0,0 +1,6 @@
+/** Returns the total number of Unicode code points in the string */
+export declare function CodePointCount(value: string): number;
+/** Returns true if the string length in Unicode code points is less than or equal to maxLength */
+export declare function IsMaxLength(value: string, maxLength: number): boolean;
+/** Returns true if the string length in Unicode code points is greater than or equal to minLength */
+export declare function IsMinLength(value: string, minLength: number): boolean;

package/node_modules/typebox/build/guard/unicode/unicode.mjs

@@ -0,0 +1,35 @@
+// ------------------------------------------------------------------
+// CodePointCount (10-bit Shift Branchless)
+//
+// Counts code points by enumerating UTF-16 sequences and incrementing
+// when not within a high/low pairing. Because surrogate blocks are
+// 1024 (2^10) wide and aligned, by shifting right by (0xA), we can
+// collapse each unit to a constant per block (high: 0x36, low: 0x37)
+// and shift again into a packed (0x3637) for comparison. Fetch calls
+// to charCodeAt(...) are kept to one call per iteration.
+//
+// ------------------------------------------------------------------
+/** Returns the total number of Unicode code points in the string */
+export function CodePointCount(value) {
+    let result = 0, index = 0, prev = 0;
+    while (index < value.length) {
+        const next = value.charCodeAt(index++) >> 0xA; // shift  (10-bits into high/low)
+        result += +(((prev << 8) | next) !== 0x3637); // packed (or +!(prev === 0x36 && next === 0x37))
+        prev = next;
+    }
+    return result;
+}
+// ------------------------------------------------------------------
+// IsMaxLength
+// ------------------------------------------------------------------
+/** Returns true if the string length in Unicode code points is less than or equal to maxLength */
+export function IsMaxLength(value, maxLength) {
+    return value.length <= maxLength || (value.length <= (maxLength << 1) && CodePointCount(value) <= maxLength);
+}
+// ------------------------------------------------------------------
+// IsMinLength
+// ------------------------------------------------------------------
+/** Returns true if the string length in Unicode code points is greater than or equal to minLength */
+export function IsMinLength(value, minLength) {
+    return value.length >= (minLength << 1) || (value.length >= minLength && CodePointCount(value) >= minLength);
+}

package/node_modules/typebox/build/guard/{string.mjs → unicode/unicode_segment.mjs}

@@ -91,26 +91,12 @@ function IsGraphemeCodePoint(value) {
         IsZeroWidthJoiner(value)));
 }
 // --------------------------------------------------------------------------
-// GraphemeCount
-// --------------------------------------------------------------------------
-/** Returns the number of grapheme clusters in a string */
-export function GraphemeCount(value) {
-    let count = 0;
-    let index = 0;
-    while (index < value.length) {
-        index = NextGraphemeClusterIndex(value, index);
-        count++;
-    }
-    return count;
-}
-// --------------------------------------------------------------------------
 // IsMinLengthSegmented
 // --------------------------------------------------------------------------
 /** Checks if a string has at least a minimum number of grapheme clusters */
 function IsMinLengthSegmented(value, minLength) {
     // if (minLength === 0) return true // 0-length (unreachable)
-    let count = 0;
-    let index = 0;
+    let count = 0, index = 0;
     while (index < value.length) {
         index = NextGraphemeClusterIndex(value, index);
         if ((++count) >= minLength)
@@ -123,8 +109,7 @@ function IsMinLengthSegmented(value, minLength) {
 // --------------------------------------------------------------------------
 /** Checks if a string has at most a maximum number of grapheme clusters */
 function IsMaxLengthSegmented(value, maxLength) {
-    let count = 0;
-    let index = 0;
+    let count = 0, index = 0;
     while (index < value.length) {
         index = NextGraphemeClusterIndex(value, index);
         if ((++count) > maxLength)
@@ -133,7 +118,19 @@ function IsMaxLengthSegmented(value, maxLength) {
     return true;
 }
 // --------------------------------------------------------------------------
-// IsMinLengthFast
+// GraphemeCount
+// --------------------------------------------------------------------------
+/** Returns the number of grapheme clusters in a string */
+export function GraphemeCount(value) {
+    let count = 0, index = 0;
+    while (index < value.length) {
+        index = NextGraphemeClusterIndex(value, index);
+        count++;
+    }
+    return count;
+}
+// --------------------------------------------------------------------------
+// IsMinLength
 // --------------------------------------------------------------------------
 /** Fast check for minimum grapheme length, falls back to full check if needed */
 export function IsMinLength(value, minLength) {
@@ -151,7 +148,7 @@ export function IsMinLength(value, minLength) {
     }
 }
 // --------------------------------------------------------------------------
-// IsMaxLengthFast
+// IsMaxLength
 // --------------------------------------------------------------------------
 /** Fast check for maximum grapheme length, falls back to full check if needed */
 export function IsMaxLength(value, maxLength) {

package/node_modules/typebox/build/schema/build.mjs

@@ -4,7 +4,6 @@ import { Arguments } from '../system/arguments/index.mjs';
 import { Environment } from '../system/environment/index.mjs';
 import { Hashing } from '../system/hashing/index.mjs';
 import { Guard } from '../guard/index.mjs';
-import { Format } from '../format/index.mjs';
 import * as Engine from './engine/index.mjs';
 // ------------------------------------------------------------------
 // CreateCode
@@ -20,8 +19,8 @@ function CreateCode(build) {
 // CreateEvaluatedCheck
 // ------------------------------------------------------------------
 function CreateEvaluatedCheck(build, code) {
-    const factory = Environment.Evaluate('CheckContext', 'Guard', 'Format', 'Hashing', build.External().identifier, code);
-    return factory(Engine.CheckContext, Guard, Format, Hashing, build.External().variables);
+    const factory = Environment.Evaluate('CheckContext', 'Guard', 'Hashing', build.External().identifier, code);
+    return factory(Engine.CheckContext, Guard, Hashing, build.External().variables);
 }
 // ------------------------------------------------------------------
 // CreateDynamicCheck

package/node_modules/typebox/build/schema/engine/_pathing.d.mts

@@ -0,0 +1 @@
+export declare function EncodeFragment(fragment: string): string;

package/node_modules/typebox/build/schema/engine/_pathing.mjs

@@ -0,0 +1,11 @@
+// ------------------------------------------------------------------
+// EncodeFragment
+//
+// We use this function to encode instancePath and schemaPath path
+// fragments for errors. We need this encoding such that callers
+// can use Pointer to deref error targets. We should consider adding
+// this to the Pointer module as Pointer.Encode(...) (review)
+// ------------------------------------------------------------------
+export function EncodeFragment(fragment) {
+    return fragment.replace(/~/g, '~0').replace(/\//g, '~1');
+}

package/node_modules/typebox/build/schema/engine/_refine.mjs

@@ -4,9 +4,18 @@ import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
+function BuildRefineMultiple(_stack, _context, schema, value) {
+    const external = Externals.CreateVariable(schema['~refine']);
+    return E.Every(external, E.Constant(0), ['refinement', '_'], E.Call(E.Member('refinement', 'check'), [value]));
+}
+function BuildRefineSingle(_stack, _context, schema, value) {
+    const external = Externals.CreateVariable(schema['~refine'][0]);
+    return E.Call(E.Member(external, 'check'), [value]);
+}
 export function BuildRefine(_stack, _context, schema, value) {
-    const refinements = Externals.CreateVariable(schema['~refine'].map((refinement) => refinement));
-    return E.Every(refinements, E.Constant(0), ['refinement', '_'], E.Call(E.Member('refinement', 'check'), [value]));
+    return G.IsEqual(schema['~refine'].length, 1)
+        ? BuildRefineSingle(_stack, _context, schema, value)
+        : BuildRefineMultiple(_stack, _context, schema, value);
 }
 // ------------------------------------------------------------------
 // Check
@@ -19,8 +28,7 @@ export function CheckRefine(_stack, _context, schema, value) {
 // ------------------------------------------------------------------
 export function ErrorRefine(_stack, context, schemaPath, instancePath, schema, value) {
     return G.EveryAll(schema['~refine'], 0, (refinement, index) => {
-        return refinement.check(value) || context.AddError('~refine', schemaPath, instancePath, {
-            index, message: refinement.error(value)
-        });
+        return refinement.check(value) ||
+            context.AddError('~refine', schemaPath, instancePath, { index, message: refinement.error(value) });
     });
 }

package/node_modules/typebox/build/schema/engine/additionalProperties.mjs

@@ -1,6 +1,7 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
 import * as Externals from './_externals.mjs';
+import * as Pathing from './_pathing.mjs';
 import { Unique } from './_unique.mjs';
 import { UnicodeRegExp } from './_regexp.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
@@ -107,7 +108,7 @@ export function ErrorAdditionalProperties(stack, context, schemaPath, instancePa
     const additionalProperties = [];
     const isAdditionalProperties = G.EveryAll(G.Keys(value), 0, (key, _index) => {
         const nextSchemaPath = `${schemaPath}/additionalProperties`;
-        const nextInstancePath = `${instancePath}/${key}`;
+        const nextInstancePath = `${instancePath}/${Pathing.EncodeFragment(key)}`;
         const isAdditionalProperty = regexp.test(key) ||
             (ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema.additionalProperties, value[key]) && context.AddKey(key));
         if (!isAdditionalProperty)

package/node_modules/typebox/build/schema/engine/dependencies.mjs

@@ -1,4 +1,5 @@
 // deno-fmt-ignore-file
+import * as Pathing from './_pathing.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -32,7 +33,7 @@ export function CheckDependencies(stack, context, schema, value) {
 export function ErrorDependencies(stack, context, schemaPath, instancePath, schema, value) {
     const isLength = G.IsEqual(G.Keys(value).length, 0);
     const isEvery = G.EveryAll(G.Entries(schema.dependencies), 0, ([key, schema]) => {
-        const nextSchemaPath = `${schemaPath}/dependencies/${key}`;
+        const nextSchemaPath = `${schemaPath}/dependencies/${Pathing.EncodeFragment(key)}`;
         return !G.HasPropertyKey(value, key) || (G.IsArray(schema)
             ? schema.every((dependency) => G.HasPropertyKey(value, dependency) ||
                 context.AddError('dependencies', schemaPath, instancePath, { property: key, dependencies: schema }))

package/node_modules/typebox/build/schema/engine/dependentSchemas.mjs

@@ -1,4 +1,5 @@
 // deno-fmt-ignore-file
+import * as Pathing from './_pathing.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -30,7 +31,7 @@ export function CheckDependentSchemas(stack, context, schema, value) {
 export function ErrorDependentSchemas(stack, context, schemaPath, instancePath, schema, value) {
     const isLength = G.IsEqual(G.Keys(value).length, 0);
     const isEvery = G.EveryAll(G.Entries(schema.dependentSchemas), 0, ([key, schema]) => {
-        const nextSchemaPath = `${schemaPath}/dependentSchemas/${key}`;
+        const nextSchemaPath = `${schemaPath}/dependentSchemas/${Pathing.EncodeFragment(key)}`;
         return !G.HasPropertyKey(value, key) ||
             ErrorSchema(stack, context, nextSchemaPath, instancePath, schema, value);
     });

package/node_modules/typebox/build/schema/engine/dynamicRef.d.mts

@@ -3,4 +3,4 @@ import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
 export declare function BuildDynamicRef(stack: Stack.XStack, context: BuildContext, schema: Schema.XDynamicRef, value: string): string;
 export declare function CheckDynamicRef(stack: Stack.XStack, context: CheckContext, schema: Schema.XDynamicRef, value: unknown): boolean;
-export declare function ErrorDynamicRef(stack: Stack.XStack, context: ErrorContext, _schemaPath: string, instancePath: string, schema: Schema.XDynamicRef, value: unknown): boolean;
+export declare function ErrorDynamicRef(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDynamicRef, value: unknown): boolean;

package/node_modules/typebox/build/schema/engine/dynamicRef.mjs

@@ -22,8 +22,8 @@ export function CheckDynamicRef(stack, context, schema, value) {
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorDynamicRef(stack, context, _schemaPath, instancePath, schema, value) {
+export function ErrorDynamicRef(stack, context, schemaPath, instancePath, schema, value) {
     const target = Resolve.DynamicRef(stack, schema) ?? false;
     const nextStack = target ? { ...stack, pendingResource: true } : stack;
-    return (Schema.IsSchema(target) && ErrorSchema(nextStack, context, '#', instancePath, target, value));
+    return (Schema.IsSchema(target) && ErrorSchema(nextStack, context, schemaPath, instancePath, target, value));
 }