@workclaw/openclaw-workclaw 1.0.30 → 1.0.33

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/date/date.js

@@ -0,0 +1,8 @@
+import { CreateType } from "../create/type.js";
+import { Kind } from "../symbols/symbols.js";
+function Date(options) {
+  return CreateType({ [Kind]: "Date", type: "Date" }, options);
+}
+export {
+  Date
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/discard/discard.js

@@ -0,0 +1,10 @@
+function DiscardKey(value, key) {
+  const { [key]: _, ...rest } = value;
+  return rest;
+}
+function Discard(value, keys) {
+  return keys.reduce((acc, key) => DiscardKey(acc, key), value);
+}
+export {
+  Discard
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/enum/enum.js

@@ -0,0 +1,15 @@
+import { IsUndefined } from "../guard/value.js";
+import { Literal } from "../literal/literal.js";
+import { Union } from "../union/union.js";
+import { Hint } from "../symbols/symbols.js";
+function Enum(item, options) {
+  if (IsUndefined(item))
+    throw new Error("Enum undefined or empty");
+  const values1 = globalThis.Object.getOwnPropertyNames(item).filter((key) => isNaN(key)).map((key) => item[key]);
+  const values2 = [...new Set(values1)];
+  const anyOf = values2.map((value) => Literal(value));
+  return Union(anyOf, { ...options, [Hint]: "Enum" });
+}
+export {
+  Enum
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/error/error.js

@@ -0,0 +1,8 @@
+class TypeBoxError extends Error {
+  constructor(message) {
+    super(message);
+  }
+}
+export {
+  TypeBoxError
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-mapped-result.js

@@ -0,0 +1,18 @@
+import { Exclude } from "./exclude.js";
+import { MappedResult } from "../mapped/mapped-result.js";
+function FromProperties(P, U) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+    Acc[K2] = Exclude(P[K2], U);
+  return Acc;
+}
+function FromMappedResult(R, T) {
+  return FromProperties(R.properties, T);
+}
+function ExcludeFromMappedResult(R, T) {
+  const P = FromMappedResult(R, T);
+  return MappedResult(P);
+}
+export {
+  ExcludeFromMappedResult
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-template-literal.js

@@ -0,0 +1,8 @@
+import { Exclude } from "./exclude.js";
+import { TemplateLiteralToUnion } from "../template-literal/union.js";
+function ExcludeFromTemplateLiteral(L, R) {
+  return Exclude(TemplateLiteralToUnion(L), R);
+}
+export {
+  ExcludeFromTemplateLiteral
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/exclude/exclude.js

@@ -0,0 +1,21 @@
+import { CreateType } from "../create/type.js";
+import { ExcludeFromMappedResult } from "./exclude-from-mapped-result.js";
+import { ExcludeFromTemplateLiteral } from "./exclude-from-template-literal.js";
+import { IsTemplateLiteral, IsMappedResult, IsUnion } from "../guard/kind.js";
+import { ExtendsCheck, ExtendsResult } from "../extends/extends-check.js";
+import { Never } from "../never/never.js";
+import { Union } from "../union/union.js";
+function ExcludeRest(L, R) {
+  const excluded = L.filter((inner) => ExtendsCheck(inner, R) === ExtendsResult.False);
+  return excluded.length === 1 ? excluded[0] : Union(excluded);
+}
+function Exclude(L, R, options = {}) {
+  if (IsTemplateLiteral(L))
+    return CreateType(ExcludeFromTemplateLiteral(L, R), options);
+  if (IsMappedResult(L))
+    return CreateType(ExcludeFromMappedResult(L, R), options);
+  return CreateType(IsUnion(L) ? ExcludeRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? Never() : L, options);
+}
+export {
+  Exclude
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/extends/extends-check.js

@@ -0,0 +1,265 @@
+import { Kind, Hint } from "../symbols/symbols.js";
+import { TemplateLiteralToUnion } from "../template-literal/union.js";
+import { String } from "../string/string.js";
+import { Unknown } from "../unknown/unknown.js";
+import { Number } from "../number/number.js";
+import { PatternNumberExact, PatternStringExact } from "../patterns/patterns.js";
+import { Function } from "../function/function.js";
+import { Any } from "../any/any.js";
+import { TypeBoxError } from "../error/error.js";
+import { IsTemplateLiteral, IsRegExp, IsNot, IsAny, IsArray, IsBigInt, IsBoolean, IsAsyncIterator, IsConstructor, IsDate, IsFunction, IsInteger, IsIntersect, IsIterator, IsLiteral, IsNever, IsNull, IsNumber, IsObject, IsRecord, IsString, IsSymbol, IsTuple, IsPromise, IsUint8Array, IsUndefined, IsUnion, IsUnknown, IsVoid, IsOptional, IsLiteralString, IsLiteralNumber, IsLiteralBoolean } from "../guard/type.js";
+import { IsUndefined as IsUndefined$1, IsString as IsString$1, IsNumber as IsNumber$1 } from "../guard/value.js";
+class ExtendsResolverError extends TypeBoxError {
+}
+var ExtendsResult;
+(function(ExtendsResult2) {
+  ExtendsResult2[ExtendsResult2["Union"] = 0] = "Union";
+  ExtendsResult2[ExtendsResult2["True"] = 1] = "True";
+  ExtendsResult2[ExtendsResult2["False"] = 2] = "False";
+})(ExtendsResult || (ExtendsResult = {}));
+function IntoBooleanResult(result) {
+  return result === ExtendsResult.False ? result : ExtendsResult.True;
+}
+function Throw(message) {
+  throw new ExtendsResolverError(message);
+}
+function IsStructuralRight(right) {
+  return IsNever(right) || IsIntersect(right) || IsUnion(right) || IsUnknown(right) || IsAny(right);
+}
+function StructuralRight(left, right) {
+  return IsNever(right) ? FromNeverRight() : IsIntersect(right) ? FromIntersectRight(left, right) : IsUnion(right) ? FromUnionRight(left, right) : IsUnknown(right) ? FromUnknownRight() : IsAny(right) ? FromAnyRight() : Throw("StructuralRight");
+}
+function FromAnyRight(left, right) {
+  return ExtendsResult.True;
+}
+function FromAny(left, right) {
+  return IsIntersect(right) ? FromIntersectRight(left, right) : IsUnion(right) && right.anyOf.some((schema) => IsAny(schema) || IsUnknown(schema)) ? ExtendsResult.True : IsUnion(right) ? ExtendsResult.Union : IsUnknown(right) ? ExtendsResult.True : IsAny(right) ? ExtendsResult.True : ExtendsResult.Union;
+}
+function FromArrayRight(left, right) {
+  return IsUnknown(left) ? ExtendsResult.False : IsAny(left) ? ExtendsResult.Union : IsNever(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromArray(left, right) {
+  return IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : !IsArray(right) ? ExtendsResult.False : IntoBooleanResult(Visit(left.items, right.items));
+}
+function FromAsyncIterator(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : !IsAsyncIterator(right) ? ExtendsResult.False : IntoBooleanResult(Visit(left.items, right.items));
+}
+function FromBigInt(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsBigInt(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromBooleanRight(left, right) {
+  return IsLiteralBoolean(left) ? ExtendsResult.True : IsBoolean(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromBoolean(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsBoolean(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromConstructor(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : !IsConstructor(right) ? ExtendsResult.False : left.parameters.length > right.parameters.length ? ExtendsResult.False : !left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === ExtendsResult.True) ? ExtendsResult.False : IntoBooleanResult(Visit(left.returns, right.returns));
+}
+function FromDate(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsDate(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromFunction(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : !IsFunction(right) ? ExtendsResult.False : left.parameters.length > right.parameters.length ? ExtendsResult.False : !left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === ExtendsResult.True) ? ExtendsResult.False : IntoBooleanResult(Visit(left.returns, right.returns));
+}
+function FromIntegerRight(left, right) {
+  return IsLiteral(left) && IsNumber$1(left.const) ? ExtendsResult.True : IsNumber(left) || IsInteger(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromInteger(left, right) {
+  return IsInteger(right) || IsNumber(right) ? ExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : ExtendsResult.False;
+}
+function FromIntersectRight(left, right) {
+  return right.allOf.every((schema) => Visit(left, schema) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromIntersect(left, right) {
+  return left.allOf.some((schema) => Visit(schema, right) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromIterator(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : !IsIterator(right) ? ExtendsResult.False : IntoBooleanResult(Visit(left.items, right.items));
+}
+function FromLiteral(left, right) {
+  return IsLiteral(right) && right.const === left.const ? ExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsString(right) ? FromStringRight(left) : IsNumber(right) ? FromNumberRight(left) : IsInteger(right) ? FromIntegerRight(left) : IsBoolean(right) ? FromBooleanRight(left) : ExtendsResult.False;
+}
+function FromNeverRight(left, right) {
+  return ExtendsResult.False;
+}
+function FromNever(left, right) {
+  return ExtendsResult.True;
+}
+function UnwrapTNot(schema) {
+  let [current, depth] = [schema, 0];
+  while (true) {
+    if (!IsNot(current))
+      break;
+    current = current.not;
+    depth += 1;
+  }
+  return depth % 2 === 0 ? current : Unknown();
+}
+function FromNot(left, right) {
+  return IsNot(left) ? Visit(UnwrapTNot(left), right) : IsNot(right) ? Visit(left, UnwrapTNot(right)) : Throw("Invalid fallthrough for Not");
+}
+function FromNull(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsNull(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromNumberRight(left, right) {
+  return IsLiteralNumber(left) ? ExtendsResult.True : IsNumber(left) || IsInteger(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromNumber(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsInteger(right) || IsNumber(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function IsObjectPropertyCount(schema, count) {
+  return Object.getOwnPropertyNames(schema.properties).length === count;
+}
+function IsObjectStringLike(schema) {
+  return IsObjectArrayLike(schema);
+}
+function IsObjectSymbolLike(schema) {
+  return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "description" in schema.properties && IsUnion(schema.properties.description) && schema.properties.description.anyOf.length === 2 && (IsString(schema.properties.description.anyOf[0]) && IsUndefined(schema.properties.description.anyOf[1]) || IsString(schema.properties.description.anyOf[1]) && IsUndefined(schema.properties.description.anyOf[0]));
+}
+function IsObjectNumberLike(schema) {
+  return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectBooleanLike(schema) {
+  return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectBigIntLike(schema) {
+  return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectDateLike(schema) {
+  return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectUint8ArrayLike(schema) {
+  return IsObjectArrayLike(schema);
+}
+function IsObjectFunctionLike(schema) {
+  const length = Number();
+  return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit(schema.properties["length"], length)) === ExtendsResult.True;
+}
+function IsObjectConstructorLike(schema) {
+  return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectArrayLike(schema) {
+  const length = Number();
+  return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit(schema.properties["length"], length)) === ExtendsResult.True;
+}
+function IsObjectPromiseLike(schema) {
+  const then = Function([Any()], Any());
+  return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "then" in schema.properties && IntoBooleanResult(Visit(schema.properties["then"], then)) === ExtendsResult.True;
+}
+function Property(left, right) {
+  return Visit(left, right) === ExtendsResult.False ? ExtendsResult.False : IsOptional(left) && !IsOptional(right) ? ExtendsResult.False : ExtendsResult.True;
+}
+function FromObjectRight(left, right) {
+  return IsUnknown(left) ? ExtendsResult.False : IsAny(left) ? ExtendsResult.Union : IsNever(left) || IsLiteralString(left) && IsObjectStringLike(right) || IsLiteralNumber(left) && IsObjectNumberLike(right) || IsLiteralBoolean(left) && IsObjectBooleanLike(right) || IsSymbol(left) && IsObjectSymbolLike(right) || IsBigInt(left) && IsObjectBigIntLike(right) || IsString(left) && IsObjectStringLike(right) || IsSymbol(left) && IsObjectSymbolLike(right) || IsNumber(left) && IsObjectNumberLike(right) || IsInteger(left) && IsObjectNumberLike(right) || IsBoolean(left) && IsObjectBooleanLike(right) || IsUint8Array(left) && IsObjectUint8ArrayLike(right) || IsDate(left) && IsObjectDateLike(right) || IsConstructor(left) && IsObjectConstructorLike(right) || IsFunction(left) && IsObjectFunctionLike(right) ? ExtendsResult.True : IsRecord(left) && IsString(RecordKey(left)) ? (() => {
+    return right[Hint] === "Record" ? ExtendsResult.True : ExtendsResult.False;
+  })() : IsRecord(left) && IsNumber(RecordKey(left)) ? (() => {
+    return IsObjectPropertyCount(right, 0) ? ExtendsResult.True : ExtendsResult.False;
+  })() : ExtendsResult.False;
+}
+function FromObject(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : !IsObject(right) ? ExtendsResult.False : (() => {
+    for (const key of Object.getOwnPropertyNames(right.properties)) {
+      if (!(key in left.properties) && !IsOptional(right.properties[key])) {
+        return ExtendsResult.False;
+      }
+      if (IsOptional(right.properties[key])) {
+        return ExtendsResult.True;
+      }
+      if (Property(left.properties[key], right.properties[key]) === ExtendsResult.False) {
+        return ExtendsResult.False;
+      }
+    }
+    return ExtendsResult.True;
+  })();
+}
+function FromPromise(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) && IsObjectPromiseLike(right) ? ExtendsResult.True : !IsPromise(right) ? ExtendsResult.False : IntoBooleanResult(Visit(left.item, right.item));
+}
+function RecordKey(schema) {
+  return PatternNumberExact in schema.patternProperties ? Number() : PatternStringExact in schema.patternProperties ? String() : Throw("Unknown record key pattern");
+}
+function RecordValue(schema) {
+  return PatternNumberExact in schema.patternProperties ? schema.patternProperties[PatternNumberExact] : PatternStringExact in schema.patternProperties ? schema.patternProperties[PatternStringExact] : Throw("Unable to get record value schema");
+}
+function FromRecordRight(left, right) {
+  const [Key, Value] = [RecordKey(right), RecordValue(right)];
+  return IsLiteralString(left) && IsNumber(Key) && IntoBooleanResult(Visit(left, Value)) === ExtendsResult.True ? ExtendsResult.True : IsUint8Array(left) && IsNumber(Key) ? Visit(left, Value) : IsString(left) && IsNumber(Key) ? Visit(left, Value) : IsArray(left) && IsNumber(Key) ? Visit(left, Value) : IsObject(left) ? (() => {
+    for (const key of Object.getOwnPropertyNames(left.properties)) {
+      if (Property(Value, left.properties[key]) === ExtendsResult.False) {
+        return ExtendsResult.False;
+      }
+    }
+    return ExtendsResult.True;
+  })() : ExtendsResult.False;
+}
+function FromRecord(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : !IsRecord(right) ? ExtendsResult.False : Visit(RecordValue(left), RecordValue(right));
+}
+function FromRegExp(left, right) {
+  const L = IsRegExp(left) ? String() : left;
+  const R = IsRegExp(right) ? String() : right;
+  return Visit(L, R);
+}
+function FromStringRight(left, right) {
+  return IsLiteral(left) && IsString$1(left.const) ? ExtendsResult.True : IsString(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromString(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsString(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromSymbol(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsSymbol(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromTemplateLiteral(left, right) {
+  return IsTemplateLiteral(left) ? Visit(TemplateLiteralToUnion(left), right) : IsTemplateLiteral(right) ? Visit(left, TemplateLiteralToUnion(right)) : Throw("Invalid fallthrough for TemplateLiteral");
+}
+function IsArrayOfTuple(left, right) {
+  return IsArray(right) && left.items !== void 0 && left.items.every((schema) => Visit(schema, right.items) === ExtendsResult.True);
+}
+function FromTupleRight(left, right) {
+  return IsNever(left) ? ExtendsResult.True : IsUnknown(left) ? ExtendsResult.False : IsAny(left) ? ExtendsResult.Union : ExtendsResult.False;
+}
+function FromTuple(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True : IsArray(right) && IsArrayOfTuple(left, right) ? ExtendsResult.True : !IsTuple(right) ? ExtendsResult.False : IsUndefined$1(left.items) && !IsUndefined$1(right.items) || !IsUndefined$1(left.items) && IsUndefined$1(right.items) ? ExtendsResult.False : IsUndefined$1(left.items) && !IsUndefined$1(right.items) ? ExtendsResult.True : left.items.every((schema, index) => Visit(schema, right.items[index]) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUint8Array(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsUint8Array(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUndefined(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsVoid(right) ? FromVoidRight(left) : IsUndefined(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUnionRight(left, right) {
+  return right.anyOf.some((schema) => Visit(left, schema) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUnion(left, right) {
+  return left.anyOf.every((schema) => Visit(schema, right) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUnknownRight(left, right) {
+  return ExtendsResult.True;
+}
+function FromUnknown(left, right) {
+  return IsNever(right) ? FromNeverRight() : IsIntersect(right) ? FromIntersectRight(left, right) : IsUnion(right) ? FromUnionRight(left, right) : IsAny(right) ? FromAnyRight() : IsString(right) ? FromStringRight(left) : IsNumber(right) ? FromNumberRight(left) : IsInteger(right) ? FromIntegerRight(left) : IsBoolean(right) ? FromBooleanRight(left) : IsArray(right) ? FromArrayRight(left) : IsTuple(right) ? FromTupleRight(left) : IsObject(right) ? FromObjectRight(left, right) : IsUnknown(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromVoidRight(left, right) {
+  return IsUndefined(left) ? ExtendsResult.True : IsUndefined(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromVoid(left, right) {
+  return IsIntersect(right) ? FromIntersectRight(left, right) : IsUnion(right) ? FromUnionRight(left, right) : IsUnknown(right) ? FromUnknownRight() : IsAny(right) ? FromAnyRight() : IsObject(right) ? FromObjectRight(left, right) : IsVoid(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function Visit(left, right) {
+  return (
+    // resolvable
+    IsTemplateLiteral(left) || IsTemplateLiteral(right) ? FromTemplateLiteral(left, right) : IsRegExp(left) || IsRegExp(right) ? FromRegExp(left, right) : IsNot(left) || IsNot(right) ? FromNot(left, right) : (
+      // standard
+      IsAny(left) ? FromAny(left, right) : IsArray(left) ? FromArray(left, right) : IsBigInt(left) ? FromBigInt(left, right) : IsBoolean(left) ? FromBoolean(left, right) : IsAsyncIterator(left) ? FromAsyncIterator(left, right) : IsConstructor(left) ? FromConstructor(left, right) : IsDate(left) ? FromDate(left, right) : IsFunction(left) ? FromFunction(left, right) : IsInteger(left) ? FromInteger(left, right) : IsIntersect(left) ? FromIntersect(left, right) : IsIterator(left) ? FromIterator(left, right) : IsLiteral(left) ? FromLiteral(left, right) : IsNever(left) ? FromNever() : IsNull(left) ? FromNull(left, right) : IsNumber(left) ? FromNumber(left, right) : IsObject(left) ? FromObject(left, right) : IsRecord(left) ? FromRecord(left, right) : IsString(left) ? FromString(left, right) : IsSymbol(left) ? FromSymbol(left, right) : IsTuple(left) ? FromTuple(left, right) : IsPromise(left) ? FromPromise(left, right) : IsUint8Array(left) ? FromUint8Array(left, right) : IsUndefined(left) ? FromUndefined(left, right) : IsUnion(left) ? FromUnion(left, right) : IsUnknown(left) ? FromUnknown(left, right) : IsVoid(left) ? FromVoid(left, right) : Throw(`Unknown left type operand '${left[Kind]}'`)
+    )
+  );
+}
+function ExtendsCheck(left, right) {
+  return Visit(left, right);
+}
+export {
+  ExtendsCheck,
+  ExtendsResolverError,
+  ExtendsResult
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-key.js

@@ -0,0 +1,24 @@
+import { Extends } from "./extends.js";
+import { Clone } from "../clone/value.js";
+import { MappedResult } from "../mapped/mapped-result.js";
+import { Literal } from "../literal/literal.js";
+function FromPropertyKey(K, U, L, R, options) {
+  return {
+    [K]: Extends(Literal(K), U, L, R, Clone(options))
+  };
+}
+function FromPropertyKeys(K, U, L, R, options) {
+  return K.reduce((Acc, LK) => {
+    return { ...Acc, ...FromPropertyKey(LK, U, L, R, options) };
+  }, {});
+}
+function FromMappedKey(K, U, L, R, options) {
+  return FromPropertyKeys(K.keys, U, L, R, options);
+}
+function ExtendsFromMappedKey(T, U, L, R, options) {
+  const P = FromMappedKey(T, U, L, R, options);
+  return MappedResult(P);
+}
+export {
+  ExtendsFromMappedKey
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-result.js

@@ -0,0 +1,19 @@
+import { Extends } from "./extends.js";
+import { Clone } from "../clone/value.js";
+import { MappedResult } from "../mapped/mapped-result.js";
+function FromProperties(P, Right, True, False, options) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+    Acc[K2] = Extends(P[K2], Right, True, False, Clone(options));
+  return Acc;
+}
+function FromMappedResult(Left, Right, True, False, options) {
+  return FromProperties(Left.properties, Right, True, False, options);
+}
+function ExtendsFromMappedResult(Left, Right, True, False, options) {
+  const P = FromMappedResult(Left, Right, True, False, options);
+  return MappedResult(P);
+}
+export {
+  ExtendsFromMappedResult
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/extends/extends.js

@@ -0,0 +1,16 @@
+import { CreateType } from "../create/type.js";
+import { ExtendsCheck, ExtendsResult } from "./extends-check.js";
+import { ExtendsFromMappedKey } from "./extends-from-mapped-key.js";
+import { ExtendsFromMappedResult } from "./extends-from-mapped-result.js";
+import { IsMappedResult, IsMappedKey } from "../guard/kind.js";
+import { Union } from "../union/union.js";
+function ExtendsResolve(left, right, trueType, falseType) {
+  const R = ExtendsCheck(left, right);
+  return R === ExtendsResult.Union ? Union([trueType, falseType]) : R === ExtendsResult.True ? trueType : falseType;
+}
+function Extends(L, R, T, F, options) {
+  return IsMappedResult(L) ? ExtendsFromMappedResult(L, R, T, F, options) : IsMappedKey(L) ? CreateType(ExtendsFromMappedKey(L, R, T, F, options)) : CreateType(ExtendsResolve(L, R, T, F), options);
+}
+export {
+  Extends
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-mapped-result.js

@@ -0,0 +1,18 @@
+import { Extract } from "./extract.js";
+import { MappedResult } from "../mapped/mapped-result.js";
+function FromProperties(P, T) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+    Acc[K2] = Extract(P[K2], T);
+  return Acc;
+}
+function FromMappedResult(R, T) {
+  return FromProperties(R.properties, T);
+}
+function ExtractFromMappedResult(R, T) {
+  const P = FromMappedResult(R, T);
+  return MappedResult(P);
+}
+export {
+  ExtractFromMappedResult
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-template-literal.js

@@ -0,0 +1,8 @@
+import { Extract } from "./extract.js";
+import { TemplateLiteralToUnion } from "../template-literal/union.js";
+function ExtractFromTemplateLiteral(L, R) {
+  return Extract(TemplateLiteralToUnion(L), R);
+}
+export {
+  ExtractFromTemplateLiteral
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/extract/extract.js

@@ -0,0 +1,21 @@
+import { CreateType } from "../create/type.js";
+import { ExtractFromMappedResult } from "./extract-from-mapped-result.js";
+import { ExtractFromTemplateLiteral } from "./extract-from-template-literal.js";
+import { IsTemplateLiteral, IsMappedResult, IsUnion } from "../guard/kind.js";
+import { ExtendsCheck, ExtendsResult } from "../extends/extends-check.js";
+import { Never } from "../never/never.js";
+import { Union } from "../union/union.js";
+function ExtractRest(L, R) {
+  const extracted = L.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False);
+  return extracted.length === 1 ? extracted[0] : Union(extracted);
+}
+function Extract(L, R, options) {
+  if (IsTemplateLiteral(L))
+    return CreateType(ExtractFromTemplateLiteral(L, R), options);
+  if (IsMappedResult(L))
+    return CreateType(ExtractFromMappedResult(L, R), options);
+  return CreateType(IsUnion(L) ? ExtractRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never(), options);
+}
+export {
+  Extract
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/function/function.js

@@ -0,0 +1,8 @@
+import { CreateType } from "../create/type.js";
+import { Kind } from "../symbols/symbols.js";
+function Function(parameters, returns, options) {
+  return CreateType({ [Kind]: "Function", type: "Function", parameters, returns }, options);
+}
+export {
+  Function
+};