@openclaw/firecrawl-plugin 2026.9.5 → 2026.9.7

package/dist/.setup/{firecrawl-client-BPFpIblh.mjs → firecrawl-client-S2gdb9zo.mjs}

@@ -1,11 +1,11 @@
 import { resolveSiteName } from "openclaw/plugin-sdk/provider-web-search";
-import { parseFiniteNumber } from "openclaw/plugin-sdk/number-runtime";
-import { readProviderJsonObjectResponse } from "openclaw/plugin-sdk/provider-http";
+import { asNonNegativeFiniteNumber, asPositiveFiniteNumber, parseDateStringTimestampMs, parseFiniteNumber, resolveIntegerOption } from "openclaw/plugin-sdk/number-runtime";
+import { ProviderHttpError, readProviderJsonObjectResponse } from "openclaw/plugin-sdk/provider-http";
 import { DEFAULT_CACHE_TTL_MINUTES, markdownToText, normalizeCacheKey, readCache, readResponseText, resolveCacheTtlMs, resolvePositiveTimeoutSeconds, withSelfHostedWebToolsEndpoint, withStrictWebToolsEndpoint, writeCache } from "openclaw/plugin-sdk/provider-web-fetch";
 import { normalizeSecretInput } from "openclaw/plugin-sdk/secret-input";
 import { truncateSanitizedExternalContent, wrapExternalContent, wrapWebContent } from "openclaw/plugin-sdk/security-runtime";
 import { SsrFBlockedError, isBlockedHostnameOrIp, isPrivateIpAddress, resolvePinnedHostnameWithPolicy } from "openclaw/plugin-sdk/ssrf-runtime";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { asOptionalObjectRecord, asOptionalRecord, asRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { z } from "zod";
 import { resolveReadOnlyEnvSecretRef } from "openclaw/plugin-sdk/secret-ref-readonly";
 //#region \0rolldown/runtime.js
@@ -24,12 +24,12 @@ const DEFAULT_FIRECRAWL_SCRAPE_TIMEOUT_SECONDS = 60;
 const DEFAULT_FIRECRAWL_MAX_AGE_MS = 1728e5;
 const FIRECRAWL_API_KEY_ENV_VAR = "FIRECRAWL_API_KEY";
 function resolveFirecrawlSearchConfig(cfg) {
-	const pluginWebSearch = (cfg?.plugins?.entries?.firecrawl?.config)?.webSearch;
-	if (pluginWebSearch && typeof pluginWebSearch === "object" && !Array.isArray(pluginWebSearch)) return pluginWebSearch;
+	const pluginConfig = cfg?.plugins?.entries?.firecrawl?.config;
+	return asOptionalRecord(pluginConfig?.webSearch);
 }
 function resolveFirecrawlFetchConfig(cfg) {
-	const pluginWebFetch = (cfg?.plugins?.entries?.firecrawl?.config)?.webFetch;
-	if (pluginWebFetch && typeof pluginWebFetch === "object" && !Array.isArray(pluginWebFetch)) return pluginWebFetch;
+	const pluginConfig = cfg?.plugins?.entries?.firecrawl?.config;
+	return asOptionalRecord(pluginConfig?.webFetch);
 }
 function resolveConfiguredSecret(value, path, cfg) {
 	return resolveReadOnlyEnvSecretRef({
@@ -71,10 +71,7 @@ function resolveFirecrawlOnlyMainContent(cfg, override) {
 	return true;
 }
 function resolveFirecrawlMaxAgeMs(cfg, override) {
-	if (typeof override === "number" && Number.isFinite(override) && override >= 0) return Math.floor(override);
-	const fetch = resolveFirecrawlFetchConfig(cfg);
-	if (typeof fetch?.maxAgeMs === "number" && Number.isFinite(fetch.maxAgeMs) && fetch.maxAgeMs >= 0) return Math.floor(fetch.maxAgeMs);
-	return DEFAULT_FIRECRAWL_MAX_AGE_MS;
+	return Math.floor(asNonNegativeFiniteNumber(override) ?? asNonNegativeFiniteNumber(resolveFirecrawlFetchConfig(cfg)?.maxAgeMs) ?? DEFAULT_FIRECRAWL_MAX_AGE_MS);
 }
 function resolveFirecrawlScrapeTimeoutSeconds(cfg, override) {
 	const fetch = resolveFirecrawlFetchConfig(cfg);
@@ -177,7 +174,7 @@ async function postFirecrawlJson(params, parse) {
 				try {
 					const body = await readResponseText(jsonResponse, { maxBytes: 64e3 });
 					const payload = JSON.parse(body.text);
-					return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : null;
+					return asOptionalRecord(payload) ?? null;
 				} catch {
 					return null;
 				}
@@ -189,7 +186,7 @@ async function postFirecrawlJson(params, parse) {
 				if (errorBody.text) detail = errorBody.text;
 			}
 			const safeDetail = wrapWebContent(truncateSanitizedExternalContent(detail, 1e3).text, "web_fetch");
-			throw new Error(`${params.errorLabel} API error (${response.status}): ${safeDetail}`);
+			throw new ProviderHttpError(`${params.errorLabel} API error (${response.status}): ${safeDetail}`, { status: response.status });
 		}
 		return await parse(response);
 	});
@@ -206,8 +203,13 @@ function normalizeFirecrawlResultUrl(value) {
 		return;
 	}
 }
+function isValidFirecrawlPublishedDate(value) {
+	if (!FIRECRAWL_PUBLISHED_DATE_RE.test(value)) return false;
+	const calendarDate = value.slice(0, 10);
+	const timestamp = parseDateStringTimestampMs(calendarDate);
+	return timestamp !== void 0 && new Date(timestamp).toISOString().startsWith(calendarDate);
+}
 const optionalFirecrawlStringSchema = z.string().optional().catch(void 0);
-const invalidFirecrawlSearchItemSchema = z.unknown().transform(() => null);
 const firecrawlSearchMetadataSchema = z.object({
 	sourceURL: optionalFirecrawlStringSchema,
 	title: optionalFirecrawlStringSchema,
@@ -229,31 +231,25 @@ const firecrawlSearchItemSchema = z.object({
 	published: optionalFirecrawlStringSchema,
 	metadata: firecrawlSearchMetadataSchema
 });
-const firecrawlSearchItemsSchema = z.array(z.union([firecrawlSearchItemSchema, invalidFirecrawlSearchItemSchema])).transform((items) => items.filter((item) => item !== null));
-const firecrawlNestedSearchDataSchema = z.looseObject({
-	results: firecrawlSearchItemsSchema.optional().catch(void 0),
-	data: firecrawlSearchItemsSchema.optional().catch(void 0),
-	web: firecrawlSearchItemsSchema.optional().catch(void 0)
-});
-const firecrawlSearchPayloadSchema = z.looseObject({
-	data: z.union([firecrawlSearchItemsSchema, firecrawlNestedSearchDataSchema]).optional().catch(void 0),
-	results: firecrawlSearchItemsSchema.optional().catch(void 0),
-	web: z.looseObject({ results: firecrawlSearchItemsSchema.optional().catch(void 0) }).optional().catch(void 0)
-});
-function resolveSearchItems(payload) {
-	const parsed = firecrawlSearchPayloadSchema.parse(payload);
-	const nestedData = Array.isArray(parsed.data) ? void 0 : parsed.data;
+function resolveSearchItems(payload, count) {
+	const nestedData = asOptionalRecord(payload.data);
 	const rawItems = [
-		Array.isArray(parsed.data) ? parsed.data : void 0,
-		parsed.results,
+		payload.data,
+		payload.results,
 		nestedData?.results,
 		nestedData?.data,
 		nestedData?.web,
-		parsed.web?.results
-	].find((candidate) => candidate !== void 0);
+		asOptionalRecord(payload.web)?.results
+	].find((candidate) => Array.isArray(candidate));
 	if (!rawItems) return [];
 	const items = [];
-	for (const entry of rawItems.slice(0, FIRECRAWL_SEARCH_MAX_RESULTS)) {
+	let inspectedObjects = 0;
+	for (const rawItem of rawItems) {
+		if (inspectedObjects >= FIRECRAWL_SEARCH_MAX_RESULTS || items.length >= count) break;
+		const record = asOptionalRecord(rawItem);
+		if (!record) continue;
+		inspectedObjects += 1;
+		const entry = firecrawlSearchItemSchema.parse(record);
 		const metadata = entry.metadata;
 		const url = normalizeFirecrawlResultUrl(entry.url || entry.sourceURL || entry.sourceUrl || metadata?.sourceURL || "");
 		if (!url) continue;
@@ -261,7 +257,7 @@ function resolveSearchItems(payload) {
 		const description = entry.description || entry.snippet || entry.summary || void 0;
 		const content = entry.markdown || entry.content || entry.text || void 0;
 		const rawPublished = entry.publishedDate || entry.published || metadata?.publishedTime || metadata?.publishedDate || void 0;
-		const published = rawPublished && FIRECRAWL_PUBLISHED_DATE_RE.test(rawPublished) ? rawPublished : void 0;
+		const published = rawPublished && isValidFirecrawlPublishedDate(rawPublished) ? rawPublished : void 0;
 		items.push({
 			title,
 			url,
@@ -311,7 +307,10 @@ async function runFirecrawlSearch(params) {
 	const providerId = keyless ? "firecrawl-free" : "firecrawl";
 	const apiKey = keyless ? void 0 : resolveFirecrawlApiKey(params.cfg);
 	if (!apiKey && !keyless) throw new Error("web_search (firecrawl) needs a Firecrawl API key. Set FIRECRAWL_API_KEY in the Gateway environment, or configure plugins.entries.firecrawl.config.webSearch.apiKey.");
-	const count = typeof params.count === "number" && Number.isFinite(params.count) ? Math.max(1, Math.min(100, Math.floor(params.count))) : DEFAULT_SEARCH_COUNT;
+	const count = resolveIntegerOption(params.count, DEFAULT_SEARCH_COUNT, {
+		min: 1,
+		max: 100
+	});
 	const timeoutSeconds = resolveFirecrawlSearchTimeoutSeconds(params.timeoutSeconds);
 	const scrapeResults = params.scrapeResults === true;
 	const sources = Array.isArray(params.sources) ? params.sources.filter(Boolean) : [];
@@ -378,21 +377,16 @@ async function runFirecrawlSearch(params) {
 	const result = buildSearchPayload({
 		query: params.query,
 		provider: providerId,
-		items: resolveSearchItems(payload).slice(0, count),
+		items: resolveSearchItems(payload, count),
 		tookMs: Date.now() - start,
 		scrapeResults
 	});
 	writeCache(SEARCH_CACHE, cacheKey, result, cacheTtlMs);
 	return result;
 }
-function resolveScrapeData(payload) {
-	const data = payload.data;
-	if (data && typeof data === "object") return data;
-	return {};
-}
 function parseFirecrawlScrapePayload(params) {
-	const data = resolveScrapeData(params.payload);
-	const metadata = data.metadata && typeof data.metadata === "object" ? data.metadata : void 0;
+	const data = asRecord(params.payload.data);
+	const metadata = asOptionalObjectRecord(data.metadata);
 	const rawStatus = parseFiniteNumber(metadata?.statusCode) ?? parseFiniteNumber(data.statusCode);
 	const status = rawStatus === void 0 ? void 0 : Math.floor(rawStatus);
 	if (status !== void 0 && (status < 200 || status >= 300)) throw new Error(`Firecrawl fetch failed (${status}): target returned an unsuccessful HTTP status.`);
@@ -447,10 +441,7 @@ async function runFirecrawlScrape(params) {
 	const maxAgeMs = resolveFirecrawlMaxAgeMs(params.cfg, params.maxAgeMs);
 	const proxy = params.proxy ?? "auto";
 	const storeInCache = params.storeInCache ?? true;
-	const configuredMaxCharsCap = params.cfg?.tools?.web?.fetch?.maxCharsCap;
-	const maxCharsCap = typeof configuredMaxCharsCap === "number" && Number.isFinite(configuredMaxCharsCap) && configuredMaxCharsCap > 0 ? Math.floor(configuredMaxCharsCap) : DEFAULT_SCRAPE_MAX_CHARS;
-	const requestedMaxChars = typeof params.maxChars === "number" && Number.isFinite(params.maxChars) && params.maxChars > 0 ? Math.floor(params.maxChars) : DEFAULT_SCRAPE_MAX_CHARS;
-	const maxChars = Math.min(requestedMaxChars, maxCharsCap);
+	const maxChars = Math.floor(Math.min(asPositiveFiniteNumber(params.maxChars) ?? DEFAULT_SCRAPE_MAX_CHARS, asPositiveFiniteNumber(params.cfg?.tools?.web?.fetch?.maxCharsCap) ?? DEFAULT_SCRAPE_MAX_CHARS));
 	const endpoint = await resolveEndpoint(baseUrl, "/v2/scrape");
 	return parseFirecrawlScrapePayload({
 		payload: await postFirecrawlJson({

package/dist/.setup/{firecrawl-fetch-provider-BM5uWYri.mjs → firecrawl-fetch-provider-Cq_h8okw.mjs}

@@ -51,7 +51,7 @@ const FIRECRAWL_WEB_FETCH_PROVIDER_SHARED = {
 };
 //#endregion
 //#region extensions/firecrawl/src/firecrawl-fetch-provider.ts
-const loadFirecrawlClientModule = createLazyRuntimeModule(() => import("./firecrawl-client-BPFpIblh.mjs").then((n) => n.t));
+const loadFirecrawlClientModule = createLazyRuntimeModule(() => import("./firecrawl-client-S2gdb9zo.mjs").then((n) => n.t));
 function createFirecrawlWebFetchProvider() {
 	return {
 		...FIRECRAWL_WEB_FETCH_PROVIDER_SHARED,

package/dist/.setup/{firecrawl-search-provider-CdDShG2T.mjs → firecrawl-search-provider-DzEHIoq7.mjs}

@@ -4,7 +4,7 @@ import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createWebSearchProviderContractFields, enablePluginInConfig } from "openclaw/plugin-sdk/provider-web-search-contract";
 //#region extensions/firecrawl/src/firecrawl-search-provider.ts
 const FIRECRAWL_CREDENTIAL_PATH = "plugins.entries.firecrawl.config.webSearch.apiKey";
-const loadFirecrawlClientModule = createLazyRuntimeModule(() => import("./firecrawl-client-BPFpIblh.mjs").then((n) => n.t));
+const loadFirecrawlClientModule = createLazyRuntimeModule(() => import("./firecrawl-client-S2gdb9zo.mjs").then((n) => n.t));
 const GenericFirecrawlSearchSchema = {
 	type: "object",
 	properties: {

package/dist/api.js

@@ -1,4 +1,4 @@
-import { n as runFirecrawlScrape } from "./.setup/firecrawl-client-BPFpIblh.mjs";
+import { n as runFirecrawlScrape } from "./.setup/firecrawl-client-S2gdb9zo.mjs";
 import { readStringValue } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/firecrawl/api.ts
 async function fetchFirecrawlContent(params) {

package/dist/index.js

@@ -1,6 +1,6 @@
-import { n as runFirecrawlScrape, r as runFirecrawlSearch } from "./.setup/firecrawl-client-BPFpIblh.mjs";
-import { t as createFirecrawlWebFetchProvider } from "./.setup/firecrawl-fetch-provider-BM5uWYri.mjs";
-import { n as createFirecrawlWebSearchProvider, t as createFirecrawlFreeWebSearchProvider } from "./.setup/firecrawl-search-provider-CdDShG2T.mjs";
+import { n as runFirecrawlScrape, r as runFirecrawlSearch } from "./.setup/firecrawl-client-S2gdb9zo.mjs";
+import { t as createFirecrawlWebFetchProvider } from "./.setup/firecrawl-fetch-provider-Cq_h8okw.mjs";
+import { n as createFirecrawlWebSearchProvider, t as createFirecrawlFreeWebSearchProvider } from "./.setup/firecrawl-search-provider-DzEHIoq7.mjs";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import { optionalStringEnum } from "openclaw/plugin-sdk/channel-actions";
 import { jsonResult, readNonNegativeIntegerParam, readPositiveIntegerParam, readStringArrayParam, readStringParam } from "openclaw/plugin-sdk/provider-web-search";

package/dist/web-fetch-contract-api.js

@@ -1,3 +1,3 @@
-import { t as createFirecrawlWebFetchProvider } from "./.setup/firecrawl-fetch-provider-BM5uWYri.mjs";
+import { t as createFirecrawlWebFetchProvider } from "./.setup/firecrawl-fetch-provider-Cq_h8okw.mjs";
 import "./web-fetch-provider.js";
 export { createFirecrawlWebFetchProvider };

package/dist/web-fetch-provider.js

@@ -1,2 +1,2 @@
-import { t as createFirecrawlWebFetchProvider } from "./.setup/firecrawl-fetch-provider-BM5uWYri.mjs";
+import { t as createFirecrawlWebFetchProvider } from "./.setup/firecrawl-fetch-provider-Cq_h8okw.mjs";
 export { createFirecrawlWebFetchProvider };

package/dist/web-search-contract-api.js

@@ -1,3 +1,3 @@
-import { n as createFirecrawlWebSearchProvider, t as createFirecrawlFreeWebSearchProvider } from "./.setup/firecrawl-search-provider-CdDShG2T.mjs";
+import { n as createFirecrawlWebSearchProvider, t as createFirecrawlFreeWebSearchProvider } from "./.setup/firecrawl-search-provider-DzEHIoq7.mjs";
 import "./web-search-provider.js";
 export { createFirecrawlFreeWebSearchProvider, createFirecrawlWebSearchProvider };

package/dist/web-search-provider.js

@@ -1,2 +1,2 @@
-import { n as createFirecrawlWebSearchProvider, t as createFirecrawlFreeWebSearchProvider } from "./.setup/firecrawl-search-provider-CdDShG2T.mjs";
+import { n as createFirecrawlWebSearchProvider, t as createFirecrawlFreeWebSearchProvider } from "./.setup/firecrawl-search-provider-DzEHIoq7.mjs";
 export { createFirecrawlFreeWebSearchProvider, createFirecrawlWebSearchProvider };

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 }))