@openclaw/whatsapp 2026.9.6 → 2026.9.7

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

@@ -173,14 +173,14 @@ export function BuildSchema(stack, context, schema, value) {
             constraints.push(BuildContains(current, context, schema, value));
         if (Schema.IsItems(schema))
             constraints.push(BuildItems(current, context, schema, value));
-        if (Schema.IsMaxContains(schema))
-            constraints.push(BuildMaxContains(current, context, schema, value));
-        if (Schema.IsMaxItems(schema))
-            constraints.push(BuildMaxItems(current, context, schema, value));
         if (Schema.IsMinContains(schema))
             constraints.push(BuildMinContains(current, context, schema, value));
+        if (Schema.IsMaxContains(schema))
+            constraints.push(BuildMaxContains(current, context, schema, value));
         if (Schema.IsMinItems(schema))
             constraints.push(BuildMinItems(current, context, schema, value));
+        if (Schema.IsMaxItems(schema))
+            constraints.push(BuildMaxItems(current, context, schema, value));
         if (Schema.IsPrefixItems(schema))
             constraints.push(BuildPrefixItems(current, context, schema, value));
         if (Schema.IsUniqueItems(schema))
@@ -191,10 +191,10 @@ export function BuildSchema(stack, context, schema, value) {
     }
     if (HasStringKeywords(schema)) {
         const constraints = [];
-        if (Schema.IsMaxLength(schema))
-            constraints.push(BuildMaxLength(current, context, schema, value));
         if (Schema.IsMinLength(schema))
             constraints.push(BuildMinLength(current, context, schema, value));
+        if (Schema.IsMaxLength(schema))
+            constraints.push(BuildMaxLength(current, context, schema, value));
         if (Schema.IsFormat(schema))
             constraints.push(BuildFormat(current, context, schema, value));
         if (Schema.IsPattern(schema))
@@ -205,14 +205,14 @@ export function BuildSchema(stack, context, schema, value) {
     }
     if (HasNumberKeywords(schema)) {
         const constraints = [];
-        if (Schema.IsExclusiveMaximum(schema))
-            constraints.push(BuildExclusiveMaximum(current, context, schema, value));
         if (Schema.IsExclusiveMinimum(schema))
             constraints.push(BuildExclusiveMinimum(current, context, schema, value));
-        if (Schema.IsMaximum(schema))
-            constraints.push(BuildMaximum(current, context, schema, value));
+        if (Schema.IsExclusiveMaximum(schema))
+            constraints.push(BuildExclusiveMaximum(current, context, schema, value));
         if (Schema.IsMinimum(schema))
             constraints.push(BuildMinimum(current, context, schema, value));
+        if (Schema.IsMaximum(schema))
+            constraints.push(BuildMaximum(current, context, schema, value));
         if (Schema.IsMultipleOf(schema))
             constraints.push(BuildMultipleOf(current, context, schema, value));
         const reduced = E.ReduceAnd(constraints);
@@ -270,20 +270,20 @@ export function CheckSchema(stack, context, schema, value) {
         (!G.IsArray(value) || ((!Schema.IsAdditionalItems(schema) || CheckAdditionalItems(current, context, schema, value)) &&
             (!Schema.IsContains(schema) || CheckContains(current, context, schema, value)) &&
             (!Schema.IsItems(schema) || CheckItems(current, context, schema, value)) &&
-            (!Schema.IsMaxContains(schema) || CheckMaxContains(current, context, schema, value)) &&
-            (!Schema.IsMaxItems(schema) || CheckMaxItems(current, context, schema, value)) &&
             (!Schema.IsMinContains(schema) || CheckMinContains(current, context, schema, value)) &&
+            (!Schema.IsMaxContains(schema) || CheckMaxContains(current, context, schema, value)) &&
             (!Schema.IsMinItems(schema) || CheckMinItems(current, context, schema, value)) &&
+            (!Schema.IsMaxItems(schema) || CheckMaxItems(current, context, schema, value)) &&
             (!Schema.IsPrefixItems(schema) || CheckPrefixItems(current, context, schema, value)) &&
             (!Schema.IsUniqueItems(schema) || CheckUniqueItems(current, context, schema, value)))) &&
-        (!G.IsString(value) || ((!Schema.IsMaxLength(schema) || CheckMaxLength(current, context, schema, value)) &&
-            (!Schema.IsMinLength(schema) || CheckMinLength(current, context, schema, value)) &&
+        (!G.IsString(value) || ((!Schema.IsMinLength(schema) || CheckMinLength(current, context, schema, value)) &&
+            (!Schema.IsMaxLength(schema) || CheckMaxLength(current, context, schema, value)) &&
             (!Schema.IsFormat(schema) || CheckFormat(current, context, schema, value)) &&
             (!Schema.IsPattern(schema) || CheckPattern(current, context, schema, value)))) &&
-        (!(G.IsNumber(value) || G.IsBigInt(value)) || ((!Schema.IsExclusiveMaximum(schema) || CheckExclusiveMaximum(current, context, schema, value)) &&
-            (!Schema.IsExclusiveMinimum(schema) || CheckExclusiveMinimum(current, context, schema, value)) &&
-            (!Schema.IsMaximum(schema) || CheckMaximum(current, context, schema, value)) &&
+        (!(G.IsNumber(value) || G.IsBigInt(value)) || ((!Schema.IsExclusiveMinimum(schema) || CheckExclusiveMinimum(current, context, schema, value)) &&
+            (!Schema.IsExclusiveMaximum(schema) || CheckExclusiveMaximum(current, context, schema, value)) &&
             (!Schema.IsMinimum(schema) || CheckMinimum(current, context, schema, value)) &&
+            (!Schema.IsMaximum(schema) || CheckMaximum(current, context, schema, value)) &&
             (!Schema.IsMultipleOf(schema) || CheckMultipleOf(current, context, schema, value)))) &&
         (!Schema.IsRef(schema) || CheckRef(current, context, schema, value)) &&
         (!Schema.IsRecursiveRef(schema) || CheckRecursiveRef(current, context, schema, value)) &&
@@ -328,20 +328,20 @@ export function ErrorSchema(stack, context, schemaPath, instancePath, schema, va
         +(!G.IsArray(value) || !!(+(!Schema.IsAdditionalItems(schema) || ErrorAdditionalItems(current, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsContains(schema) || ErrorContains(current, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsItems(schema) || ErrorItems(current, context, schemaPath, instancePath, schema, value)) &
-            +(!Schema.IsMaxContains(schema) || ErrorMaxContains(current, context, schemaPath, instancePath, schema, value)) &
-            +(!Schema.IsMaxItems(schema) || ErrorMaxItems(current, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsMinContains(schema) || ErrorMinContains(current, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsMaxContains(schema) || ErrorMaxContains(current, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsMinItems(schema) || ErrorMinItems(current, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsMaxItems(schema) || ErrorMaxItems(current, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsPrefixItems(schema) || ErrorPrefixItems(current, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsUniqueItems(schema) || ErrorUniqueItems(current, context, schemaPath, instancePath, schema, value)))) &
-        +(!G.IsString(value) || !!(+(!Schema.IsMaxLength(schema) || ErrorMaxLength(current, context, schemaPath, instancePath, schema, value)) &
-            +(!Schema.IsMinLength(schema) || ErrorMinLength(current, context, schemaPath, instancePath, schema, value)) &
+        +(!G.IsString(value) || !!(+(!Schema.IsMinLength(schema) || ErrorMinLength(current, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsMaxLength(schema) || ErrorMaxLength(current, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsFormat(schema) || ErrorFormat(current, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsPattern(schema) || ErrorPattern(current, context, schemaPath, instancePath, schema, value)))) &
-        +(!(G.IsNumber(value) || G.IsBigInt(value)) || !!(+(!Schema.IsExclusiveMaximum(schema) || ErrorExclusiveMaximum(current, context, schemaPath, instancePath, schema, value)) &
-            +(!Schema.IsExclusiveMinimum(schema) || ErrorExclusiveMinimum(current, context, schemaPath, instancePath, schema, value)) &
-            +(!Schema.IsMaximum(schema) || ErrorMaximum(current, context, schemaPath, instancePath, schema, value)) &
+        +(!(G.IsNumber(value) || G.IsBigInt(value)) || !!(+(!Schema.IsExclusiveMinimum(schema) || ErrorExclusiveMinimum(current, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsExclusiveMaximum(schema) || ErrorExclusiveMaximum(current, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsMinimum(schema) || ErrorMinimum(current, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsMaximum(schema) || ErrorMaximum(current, context, schemaPath, instancePath, schema, value)) &
             +(!Schema.IsMultipleOf(schema) || ErrorMultipleOf(current, context, schemaPath, instancePath, schema, value)))) &
         +(!Schema.IsRef(schema) || ErrorRef(current, context, schemaPath, instancePath, schema, value)) &
         +(!Schema.IsRecursiveRef(schema) || ErrorRecursiveRef(current, context, schemaPath, instancePath, schema, value)) &

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

@@ -1,5 +1,6 @@
 // deno-fmt-ignore-file
 // deno-lint-ignore-file
+import { EnableParseErrors, DisableParseErrors } from '../system/settings/internal.mjs';
 import { Arguments } from '../system/arguments/index.mjs';
 import { Check } from './check.mjs';
 import { Errors } from './errors.mjs';
@@ -17,7 +18,9 @@ export class ParseError {
 // ThrowParseError
 // ------------------------------------------------------------------
 export function ThrowParseError(context, schema, value) {
+    EnableParseErrors();
     const result = Errors(context, schema, value);
+    DisableParseErrors();
     throw new ParseError(schema, value, result[1]);
 }
 /** Parses a value against the provided schema */

package/node_modules/typebox/build/schema/pointer/pointer.d.mts

@@ -1,10 +1,5 @@
-/** Returns an array of path indices for the given pointer */
 export declare function Indices(pointer: string): string[];
-/** Returns true if a value exists at the current pointer */
-export declare function Has(value: unknown, pointer: string): unknown;
-/** Gets a value at the pointer, or undefined if not exists */
+export declare function Has(value: unknown, pointer: string): boolean;
 export declare function Get(value: unknown, pointer: string): unknown;
-/** Sets a value at the given pointer. May throw if the target value is not indexable */
 export declare function Set(value: unknown, pointer: string, next: unknown): unknown;
-/** Deletes the value at the given pointer. May throw if the target value is not indexable */
 export declare function Delete(value: unknown, pointer: string): unknown;

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

@@ -1,106 +1,89 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
-// Asserts
+// Throw
 // ------------------------------------------------------------------
-function AssertNotRoot(indices) {
-    if (indices.length === 0)
-        throw Error('Cannot set root');
+function Throw(message) {
+    throw Error(message);
 }
-function AssertCanSet(value) {
-    if (!Guard.IsObject(value))
-        throw Error('Cannot set value');
+function ThrowUnsafePropertyKey() {
+    Throw('Pointer contains unsafe property key');
 }
-function AssertIndex(index) {
-    if (Guard.IsUnsafePropertyKey(index))
-        throw Error('Pointer contains unsafe property key');
-}
-function AssertIndices(indices) {
-    for (const index of indices)
-        AssertIndex(index);
-}
-// ------------------------------------------------------------------
-// Indices
-// ------------------------------------------------------------------
-function IsNumericIndex(index) {
-    return /^(0|[1-9]\d*)$/.test(index);
-}
-function TakeIndexRight(indices) {
-    return [
-        indices.slice(0, indices.length - 1),
-        indices.slice(indices.length - 1)[0]
-    ];
-}
-function HasIndex(index, value) {
-    return Guard.IsObject(value) && Guard.HasPropertyKey(value, index);
-}
-function GetIndex(index, value) {
-    return Guard.IsObject(value) && !Guard.IsUnsafePropertyKey(index) ? value[index] : undefined;
-}
-function GetIndices(indices, value) {
-    return indices.reduce((value, index) => GetIndex(index, value), value);
+function ThrowCannotSetRoot() {
+    Throw('Cannot set value');
 }
 // ------------------------------------------------------------------
 // Indices
 // ------------------------------------------------------------------
-/** Returns an array of path indices for the given pointer */
 export function Indices(pointer) {
-    if (Guard.IsEqual(pointer.length, 0))
-        return [];
-    const indices = pointer.split("/").map(index => index.replace(/~1/g, "/").replace(/~0/g, "~"));
-    return (indices.length > 0 && indices[0] === '') ? indices.slice(1) : indices;
+    const indices = pointer.split('/').map(index => index.replace(/~1/g, '/').replace(/~0/g, '~'));
+    return indices[0] === '' ? indices.slice(1) : indices;
 }
 // ------------------------------------------------------------------
 // Has
 // ------------------------------------------------------------------
-/** Returns true if a value exists at the current pointer */
 export function Has(value, pointer) {
     let current = value;
-    return Indices(pointer).every(index => {
-        if (!HasIndex(index, current))
+    for (const index of Indices(pointer)) {
+        if (!Guard.IsObject(current) || !Guard.HasPropertyKey(current, index))
             return false;
         current = current[index];
-        return true;
-    });
+    }
+    return true;
 }
 // ------------------------------------------------------------------
 // Get
 // ------------------------------------------------------------------
-/** Gets a value at the pointer, or undefined if not exists */
 export function Get(value, pointer) {
-    const indices = Indices(pointer);
-    return GetIndices(indices, value);
+    let current = value;
+    for (const index of Indices(pointer)) {
+        if (!Guard.IsObject(current) || Guard.IsUnsafePropertyKey(index))
+            return undefined;
+        current = current[index];
+    }
+    return current;
+}
+// ------------------------------------------------------------------
+// Get
+// ------------------------------------------------------------------
+function Parent(value, indices, last) {
+    let current = value;
+    for (const index of indices) {
+        if (Guard.IsUnsafePropertyKey(index))
+            ThrowUnsafePropertyKey();
+        current = Guard.IsObject(current) ? current[index] : undefined;
+    }
+    if (Guard.IsUnsafePropertyKey(last))
+        ThrowUnsafePropertyKey();
+    if (!Guard.IsObject(current))
+        ThrowCannotSetRoot();
+    return current;
 }
 // ------------------------------------------------------------------
 // Set
 // ------------------------------------------------------------------
-/** Sets a value at the given pointer. May throw if the target value is not indexable */
 export function Set(value, pointer, next) {
     const indices = Indices(pointer);
-    AssertNotRoot(indices);
-    AssertIndices(indices);
-    const [head, index] = TakeIndexRight(indices);
-    const parent = GetIndices(head, value);
-    AssertCanSet(parent);
-    parent[index] = next;
+    const last = indices.pop();
+    if (Guard.IsUndefined(last))
+        ThrowCannotSetRoot();
+    Parent(value, indices, last)[last] = next;
     return value;
 }
 // ------------------------------------------------------------------
 // Delete
 // ------------------------------------------------------------------
-/** Deletes the value at the given pointer. May throw if the target value is not indexable */
 export function Delete(value, pointer) {
     const indices = Indices(pointer);
-    AssertNotRoot(indices);
-    AssertIndices(indices);
-    const [head, index] = TakeIndexRight(indices);
-    const parent = GetIndices(head, value);
-    AssertCanSet(parent);
-    if (Guard.IsArray(parent) && IsNumericIndex(index)) {
-        parent.splice(+index, 1);
+    const last = indices.pop();
+    if (Guard.IsUndefined(last))
+        ThrowCannotSetRoot();
+    const parent = Parent(value, indices, last);
+    if (Guard.IsArray(parent) && /^(0|[1-9]\d*)$/.test(last)) {
+        parent.splice(Number(last), 1);
     }
     else {
-        delete parent[index];
+        delete parent[last];
     }
     return value;
 }

package/node_modules/typebox/build/system/settings/internal.d.mts

@@ -0,0 +1,2 @@
+export declare function EnableParseErrors(): void;
+export declare function DisableParseErrors(): void;

package/node_modules/typebox/build/system/settings/internal.mjs

@@ -0,0 +1,20 @@
+import { Get } from './settings.mjs';
+// ------------------------------------------------------------------
+// TempMaxErrors
+// ------------------------------------------------------------------
+let TempMaxErrors = 0;
+// ------------------------------------------------------------------
+// [Internal] EnableParseErrors
+// ------------------------------------------------------------------
+export function EnableParseErrors() {
+    const settings = Get();
+    TempMaxErrors = settings.maxErrors;
+    settings.maxErrors = settings.maxParseErrors;
+}
+// ------------------------------------------------------------------
+// [Internal] DisableParseErrors
+// ------------------------------------------------------------------
+export function DisableParseErrors() {
+    const settings = Get();
+    settings.maxErrors = TempMaxErrors;
+}

package/node_modules/typebox/build/system/settings/settings.d.mts

@@ -16,6 +16,17 @@ export interface TSettings {
      * @default 8
      */
     maxErrors: number;
+    /**
+     * Specifies the maximum number of errors to gather for failed Parse operations. TypeBox will
+     * automatically run an error-gathering pass on failed Parses to attach diagnostics to the
+     * thrown exception. This setting controls the number of errors gathered in that pass. Higher
+     * values will reduce throughput on failure cases, so a maximum of 4 is recommended if more
+     * errors are needed. The default setting of 1 will terminate on the first error, while a
+     * setting of 0 will skip error gathering entirely.
+     *
+     * @default 1
+     */
+    maxParseErrors: number;
     /**
      * Specifies the maximum number of instantiations allowed within a top-level generic instantiation
      * context. This setting can be used to bound generic calls to a fixed count, which can be useful if

package/node_modules/typebox/build/system/settings/settings.mjs

@@ -1,8 +1,12 @@
 import { Guard } from '../../guard/index.mjs';
+// -------------------------------------------------------------------
+// State
+// -------------------------------------------------------------------
 // Internal mutable state
 const settings = {
     immutableTypes: false,
     maxErrors: 8,
+    maxParseErrors: 1,
     maxInstantiationCount: 128,
     useAcceleration: true,
     exactOptionalPropertyTypes: false,
@@ -10,10 +14,14 @@ const settings = {
     correctiveParse: false,
     unionPrioritySort: true
 };
+// -------------------------------------------------------------------
+// Reset
+// -------------------------------------------------------------------
 /** Resets system settings to defaults */
 export function Reset() {
     settings.immutableTypes = false;
     settings.maxErrors = 8;
+    settings.maxParseErrors = 1;
     settings.maxInstantiationCount = 128;
     settings.useAcceleration = true;
     settings.exactOptionalPropertyTypes = false;
@@ -21,6 +29,9 @@ export function Reset() {
     settings.correctiveParse = false;
     settings.unionPrioritySort = true;
 }
+// -------------------------------------------------------------------
+// Set
+// -------------------------------------------------------------------
 /** Sets system settings */
 export function Set(options) {
     for (const key of Guard.Keys(options)) {
@@ -30,6 +41,9 @@ export function Set(options) {
         }
     }
 }
+// -------------------------------------------------------------------
+// Get
+// -------------------------------------------------------------------
 /** Gets current system settings */
 export function Get() {
     return settings;

package/node_modules/typebox/build/type/extends/inference.d.mts

@@ -22,7 +22,7 @@ export declare function TryRestInferable<Type extends TSchema>(type: Type): TTry
 export type TTryInferable<Type extends TSchema, Result extends TInferable | undefined = (Type extends TInfer<infer Name extends string, infer Type extends TSchema> ? TInferable<Name, Type> : undefined)> = Result;
 export declare function TryInferable<Type extends TSchema>(type: Type): TTryInferable<Type>;
 type TryInferResults<Rest extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Rest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<{}, Head, Right> extends Result.TExtendsTrueLike ? TryInferResults<Tail, Right, [...Result, Head]> : undefined : Result);
-declare function TryInferResults<Rest extends TSchema[], Right extends TSchema>(rest: [...Rest], right: Right, result?: TSchema[]): TryInferResults<Rest, Right>;
+declare function TryInferResults<Rest extends TSchema[], Right extends TSchema>(rest: [...Rest], right: Right): TryInferResults<Rest, Right>;
 export type TInferTupleResult<Inferred extends TProperties, Name extends string, Left extends TSchema[], Right extends TSchema, Results extends TSchema[] | undefined = TryInferResults<Left, Right>> = (Results extends [...infer Results extends TSchema[]] ? Result.TExtendsTrue<Memory.TAssign<Inferred, {
     [_ in Name]: TTuple<Results>;
 }>> : Result.TExtendsFalse);

package/node_modules/typebox/build/type/extends/inference.mjs

@@ -45,8 +45,21 @@ export function TryInferable(type) {
     return (IsInfer(type) ? Inferrable(type.name, type.extends) :
         undefined);
 }
-function TryInferResults(rest, right, result = []) {
-    return Guard.ShiftLeft(rest, (head, tail) => Result.Match(ExtendsLeft({}, head, right), () => TryInferResults(tail, right, [...result, head]), () => undefined), () => result);
+// function TryInferResults<Rest extends TSchema[], Right extends TSchema>(rest: [...Rest], right: Right, result: TSchema[] = []): TryInferResults<Rest, Right> {
+//   return Guard.ShiftLeft(rest, (head, tail) =>
+//     Result.Match(ExtendsLeft({}, head, right),
+//       () => TryInferResults(tail, right, [...result, head]), // Stack Overflow Here (Large Rest)
+//       () => undefined),
+//     () => result) as never
+// }
+function TryInferResults(rest, right) {
+    const result = [];
+    for (const head of rest) {
+        if (!Result.IsExtendsTrueLike(ExtendsLeft({}, head, right)))
+            return undefined;
+        result.push(head);
+    }
+    return result;
 }
 export function InferTupleResult(inferred, name, left, right) {
     const results = TryInferResults(left, right);

package/node_modules/typebox/build/type/extends/tuple.d.mts

@@ -16,7 +16,8 @@ type TElementsLeft<Inferred extends TProperties, Reversed extends boolean, LeftR
 type TElementsRight<Inferred extends TProperties, Reversed extends boolean, LeftRest extends TSchema[], RightRest extends TSchema[]> = (RightRest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TElementsLeft<Inferred, Reversed, LeftRest, Head, Tail> : LeftRest['length'] extends 0 ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
 type TElements<Inferred extends TProperties, Reversed extends boolean, LeftRest extends TSchema[], RightRest extends TSchema[]> = TElementsRight<Inferred, Reversed, LeftRest, RightRest>;
 type TExtendsTupleToTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema[], InstantiatedRight extends TSchema[] = TInstantiateElements<Inferred, TState<[], []>, Right>, Reversed extends boolean = TReversed<InstantiatedRight>> = TElements<Inferred, Reversed, TApplyReverse<Left, Reversed>, TApplyReverse<InstantiatedRight, Reversed>>;
-type TExtendsTupleToArray<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, Inferrable extends TInferable | undefined = TTryInferable<Right>> = (Inferrable extends TInferable ? TInferUnionResult<Inferred, Inferrable['name'], Left, Inferrable['type']> : Left extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Head, Right> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsTupleToArray<Inferred, Tail, Right> : Result.TExtendsFalse : Result.TExtendsTrue<Inferred>);
+type TExtendsTupleToArrayReduce<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema> = (Left extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Head, Right> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsTupleToArrayReduce<Inferred, Tail, Right> : Result.TExtendsFalse : Result.TExtendsTrue<Inferred>);
+type TExtendsTupleToArray<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, Inferrable extends TInferable | undefined = TTryInferable<Right>> = (Inferrable extends TInferable ? TInferUnionResult<Inferred, Inferrable['name'], Left, Inferrable['type']> : TExtendsTupleToArrayReduce<Inferred, Left, Right>);
 export type TExtendsTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, InstantiatedLeft extends TSchema[] = TInstantiateElements<Inferred, TState<[], []>, Left>> = (Right extends TTuple<infer Types extends TSchema[]> ? TExtendsTupleToTuple<Inferred, InstantiatedLeft, Types> : Right extends TArray<infer Type extends TSchema> ? TExtendsTupleToArray<Inferred, InstantiatedLeft, Type> : TExtendsRight<Inferred, TTuple<InstantiatedLeft>, Right>);
 export declare function ExtendsTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsTuple<Inferred, Left, Right>;
 export {};

package/node_modules/typebox/build/type/extends/tuple.mjs

@@ -47,11 +47,31 @@ function ExtendsTupleToTuple(inferred, left, right) {
     const reversed = Reversed(instantiatedRight);
     return Elements(inferred, reversed, ApplyReverse(left, reversed), ApplyReverse(instantiatedRight, reversed));
 }
+// function ExtendsTupleToArrayReduce<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema>
+//   (inferred: Inferred, left: [...Left], right: Right):
+//     TExtendsTupleToArrayReduce<Inferred, Left, Right> {
+//   return (
+//     Guard.ShiftLeft(left, (head, tail) =>
+//       Result.Match(ExtendsLeft(inferred, head, right), inferred =>
+//         ExtendsTupleToArrayReduce(inferred, tail, right), // Stack Overflow Here (Large Left)
+//         () => Result.ExtendsFalse()),
+//       () => Result.ExtendsTrue(inferred))
+//   ) as never
+// }
+function ExtendsTupleToArrayReduce(inferred, left, right) {
+    for (const head of left) {
+        const result = ExtendsLeft(inferred, head, right);
+        if (!Result.IsExtendsTrueLike(result))
+            return result;
+        inferred = result.inferred; // (review-assign-to-argument)
+    }
+    return Result.ExtendsTrue(inferred);
+}
 function ExtendsTupleToArray(inferred, left, right) {
     const inferrable = TryInferable(right);
     return (IsInferable(inferrable)
         ? InferUnionResult(inferred, inferrable['name'], left, inferrable['type'])
-        : Guard.ShiftLeft(left, (head, tail) => Result.Match(ExtendsLeft(inferred, head, right), inferred => ExtendsTupleToArray(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred)));
+        : ExtendsTupleToArrayReduce(inferred, left, right));
 }
 export function ExtendsTuple(inferred, left, right) {
     const instantiatedLeft = InstantiateElements(inferred, State([], []), left);

package/node_modules/typebox/build/value/parse/parse.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
-import { Settings } from '../../system/system.mjs';
-import { Arguments } from '../../system/arguments/index.mjs';
+import { EnableParseErrors, DisableParseErrors } from '../../system/settings/internal.mjs';
+import { Arguments, Settings } from '../../system/index.mjs';
 import { AssertError } from '../assert/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Errors } from '../errors/index.mjs';
@@ -18,8 +18,11 @@ export class ParseError extends AssertError {
     }
 }
 function Assert(context, type, value) {
+    EnableParseErrors();
+    const errors = Errors(context, type, value);
+    DisableParseErrors();
     if (!Check(context, type, value))
-        throw new ParseError(value, Errors(context, type, value));
+        throw new ParseError(value, errors);
     return value;
 }
 // ------------------------------------------------------------------
@@ -43,5 +46,8 @@ export function Parse(...args) {
         return value;
     if (Settings.Get().correctiveParse)
         return Parser(context, type, value);
-    throw new ParseError(value, Errors(context, type, value));
+    EnableParseErrors();
+    const errors = Errors(context, type, value);
+    DisableParseErrors();
+    throw new ParseError(value, errors);
 }

package/node_modules/typebox/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.3.30",
+  "version": "1.3.34",
   "keywords": [
     "typescript",
     "jsonschema"

package/node_modules/typebox/readme.md

@@ -166,9 +166,11 @@ import Schema from 'typebox/schema'
 
 ### Compile
 
-The compiler accepts both TypeBox types and plain JSON Schema objects. The Compile function will return a new Validator instance which can be used to check and parse values. The example below compiles a Script definition into a validator.
+The compiler accepts TypeBox types as well as plain JSON Schema objects, and returns a Validator instance which can be used to check values. The following compiles a Vector type.
 
 ```typescript
+import Schema from 'typebox/schema'
+
 // Compile
 
 const Vector = Schema.Compile(Type.Script(`{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/whatsapp",
-  "version": "2026.9.6",
+  "version": "2026.9.7",
   "description": "OpenClaw WhatsApp channel plugin for WhatsApp Web chats.",
   "repository": {
     "type": "git",
@@ -8,12 +8,12 @@
   },
   "type": "module",
   "dependencies": {
-    "audio-decode": "2.2.3",
+    "audio-decode": "3.12.0",
     "baileys": "7.0.0-rc14",
-    "typebox": "1.3.30"
+    "typebox": "1.3.34"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.9.6"
+    "openclaw": ">=2026.9.7"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -65,11 +65,11 @@
       "minHostVersion": ">=2026.4.25"
     },
     "compat": {
-      "pluginApi": ">=2026.9.6"
+      "pluginApi": ">=2026.9.7"
     },
     "build": {
       "bundledDist": false,
-      "openclawVersion": "2026.9.6"
+      "openclawVersion": "2026.9.7"
     },
     "release": {
       "publishToClawHub": true,

package/dist/.setup/doctor-BPb-SjdE.mjs

@@ -1,65 +0,0 @@
-import { asObjectRecord, collectChannelAccountScopes } from "openclaw/plugin-sdk/runtime-doctor-migrations";
-//#region extensions/whatsapp/src/doctor.ts
-function resolveLegacyAckScope(ack) {
-	const direct = ack.direct !== false;
-	const group = ack.group ?? "mentions";
-	if (direct) return group === "always" ? "all" : group === "never" ? "direct" : void 0;
-	return group === "always" ? "group-all" : group === "mentions" ? "group-mentions" : group === "never" ? "off" : void 0;
-}
-function resolveDefaultAgentEmoji(cfg) {
-	const entries = asObjectRecord(asObjectRecord(cfg.agents)?.entries);
-	const agents = entries ? Object.values(entries).flatMap((value) => {
-		const entry = asObjectRecord(value);
-		return entry ? [entry] : [];
-	}) : [];
-	const agent = agents.find((entry) => entry.default === true) ?? agents[0];
-	const emoji = asObjectRecord(agent?.identity)?.emoji;
-	return typeof emoji === "string" ? emoji : void 0;
-}
-function normalizeCompatibilityConfig({ cfg }) {
-	const changes = [];
-	const sources = [];
-	for (const scope of collectChannelAccountScopes({
-		cfg,
-		channelId: "whatsapp"
-	})) {
-		const ack = asObjectRecord(scope.account.ackReaction);
-		if (!ack) continue;
-		sources.push({
-			path: `${scope.prefix}.ackReaction`,
-			account: scope.account,
-			...typeof ack.emoji === "string" ? { emoji: ack.emoji } : {},
-			scope: resolveLegacyAckScope(ack),
-			unrepresentableScope: ack.direct !== false && (ack.group ?? "mentions") === "mentions"
-		});
-	}
-	if (sources.length === 0) return {
-		config: cfg,
-		changes
-	};
-	const messages = cfg.messages ??= {};
-	const identityEmoji = resolveDefaultAgentEmoji(cfg) ?? "👀";
-	for (const source of sources) {
-		messages.ackReaction ??= source.emoji ?? identityEmoji;
-		messages.ackReactionScope ??= source.scope;
-		delete source.account.ackReaction;
-		changes.push(`Moved translatable ${source.path} settings to messages ack settings.`);
-	}
-	const finalEmoji = messages.ackReaction.trim();
-	const finalScope = messages.ackReactionScope ?? "group-mentions";
-	const comparableFinalScope = finalScope === "none" ? "off" : finalScope;
-	for (const source of sources) {
-		const sourceEmoji = source.emoji?.trim();
-		if (source.emoji === void 0) changes.push(`${source.path} used a route-dependent agent identity acknowledgement emoji before migration; the final messages.ackReaction is ${JSON.stringify(finalEmoji)}. Review messages.ackReaction.`);
-		else if (sourceEmoji !== finalEmoji) changes.push(`${source.path} requested acknowledgement emoji ${JSON.stringify(sourceEmoji)}, but the final messages.ackReaction is ${JSON.stringify(finalEmoji)}. Review messages.ackReaction.`);
-		if (source.unrepresentableScope) changes.push(`${source.path} migration cannot preserve both direct-message and mentioned-group acknowledgements; the final messages.ackReactionScope is ${JSON.stringify(finalScope)}. Review messages.ackReactionScope.`);
-		else if (source.scope && source.scope !== comparableFinalScope) changes.push(`${source.path} requested acknowledgement scope ${JSON.stringify(source.scope)}, but the final messages.ackReactionScope is ${JSON.stringify(finalScope)}. Review messages.ackReactionScope.`);
-	}
-	return {
-		config: cfg,
-		changes
-	};
-}
-const whatsappDoctor = { normalizeCompatibilityConfig };
-//#endregion
-export { whatsappDoctor as n, normalizeCompatibilityConfig as t };