@workclaw/openclaw-workclaw 1.0.202 → 1.0.332

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

@@ -0,0 +1,176 @@
+import { IsObject as IsObject$1, IsString as IsString$1, IsBoolean as IsBoolean$1, IsNumber as IsNumber$1 } from "./value.js";
+import { TransformKind, Kind, OptionalKind, ReadonlyKind } from "../symbols/symbols.js";
+function IsReadonly(value) {
+  return IsObject$1(value) && value[ReadonlyKind] === "Readonly";
+}
+function IsOptional(value) {
+  return IsObject$1(value) && value[OptionalKind] === "Optional";
+}
+function IsAny(value) {
+  return IsKindOf(value, "Any");
+}
+function IsArgument(value) {
+  return IsKindOf(value, "Argument");
+}
+function IsArray(value) {
+  return IsKindOf(value, "Array");
+}
+function IsAsyncIterator(value) {
+  return IsKindOf(value, "AsyncIterator");
+}
+function IsBigInt(value) {
+  return IsKindOf(value, "BigInt");
+}
+function IsBoolean(value) {
+  return IsKindOf(value, "Boolean");
+}
+function IsComputed(value) {
+  return IsKindOf(value, "Computed");
+}
+function IsConstructor(value) {
+  return IsKindOf(value, "Constructor");
+}
+function IsDate(value) {
+  return IsKindOf(value, "Date");
+}
+function IsFunction(value) {
+  return IsKindOf(value, "Function");
+}
+function IsInteger(value) {
+  return IsKindOf(value, "Integer");
+}
+function IsIntersect(value) {
+  return IsKindOf(value, "Intersect");
+}
+function IsIterator(value) {
+  return IsKindOf(value, "Iterator");
+}
+function IsKindOf(value, kind) {
+  return IsObject$1(value) && Kind in value && value[Kind] === kind;
+}
+function IsLiteralValue(value) {
+  return IsBoolean$1(value) || IsNumber$1(value) || IsString$1(value);
+}
+function IsLiteral(value) {
+  return IsKindOf(value, "Literal");
+}
+function IsMappedKey(value) {
+  return IsKindOf(value, "MappedKey");
+}
+function IsMappedResult(value) {
+  return IsKindOf(value, "MappedResult");
+}
+function IsNever(value) {
+  return IsKindOf(value, "Never");
+}
+function IsNot(value) {
+  return IsKindOf(value, "Not");
+}
+function IsNull(value) {
+  return IsKindOf(value, "Null");
+}
+function IsNumber(value) {
+  return IsKindOf(value, "Number");
+}
+function IsObject(value) {
+  return IsKindOf(value, "Object");
+}
+function IsPromise(value) {
+  return IsKindOf(value, "Promise");
+}
+function IsRecord(value) {
+  return IsKindOf(value, "Record");
+}
+function IsRef(value) {
+  return IsKindOf(value, "Ref");
+}
+function IsRegExp(value) {
+  return IsKindOf(value, "RegExp");
+}
+function IsString(value) {
+  return IsKindOf(value, "String");
+}
+function IsSymbol(value) {
+  return IsKindOf(value, "Symbol");
+}
+function IsTemplateLiteral(value) {
+  return IsKindOf(value, "TemplateLiteral");
+}
+function IsThis(value) {
+  return IsKindOf(value, "This");
+}
+function IsTransform(value) {
+  return IsObject$1(value) && TransformKind in value;
+}
+function IsTuple(value) {
+  return IsKindOf(value, "Tuple");
+}
+function IsUndefined(value) {
+  return IsKindOf(value, "Undefined");
+}
+function IsUnion(value) {
+  return IsKindOf(value, "Union");
+}
+function IsUint8Array(value) {
+  return IsKindOf(value, "Uint8Array");
+}
+function IsUnknown(value) {
+  return IsKindOf(value, "Unknown");
+}
+function IsUnsafe(value) {
+  return IsKindOf(value, "Unsafe");
+}
+function IsVoid(value) {
+  return IsKindOf(value, "Void");
+}
+function IsKind(value) {
+  return IsObject$1(value) && Kind in value && IsString$1(value[Kind]);
+}
+function IsSchema(value) {
+  return IsAny(value) || IsArgument(value) || IsArray(value) || IsBoolean(value) || IsBigInt(value) || IsAsyncIterator(value) || IsComputed(value) || IsConstructor(value) || IsDate(value) || IsFunction(value) || IsInteger(value) || IsIntersect(value) || IsIterator(value) || IsLiteral(value) || IsMappedKey(value) || IsMappedResult(value) || IsNever(value) || IsNot(value) || IsNull(value) || IsNumber(value) || IsObject(value) || IsPromise(value) || IsRecord(value) || IsRef(value) || IsRegExp(value) || IsString(value) || IsSymbol(value) || IsTemplateLiteral(value) || IsThis(value) || IsTuple(value) || IsUndefined(value) || IsUnion(value) || IsUint8Array(value) || IsUnknown(value) || IsUnsafe(value) || IsVoid(value) || IsKind(value);
+}
+export {
+  IsAny,
+  IsArgument,
+  IsArray,
+  IsAsyncIterator,
+  IsBigInt,
+  IsBoolean,
+  IsComputed,
+  IsConstructor,
+  IsDate,
+  IsFunction,
+  IsInteger,
+  IsIntersect,
+  IsIterator,
+  IsKind,
+  IsKindOf,
+  IsLiteral,
+  IsLiteralValue,
+  IsMappedKey,
+  IsMappedResult,
+  IsNever,
+  IsNot,
+  IsNull,
+  IsNumber,
+  IsObject,
+  IsOptional,
+  IsPromise,
+  IsReadonly,
+  IsRecord,
+  IsRef,
+  IsRegExp,
+  IsSchema,
+  IsString,
+  IsSymbol,
+  IsTemplateLiteral,
+  IsThis,
+  IsTransform,
+  IsTuple,
+  IsUint8Array,
+  IsUndefined,
+  IsUnion,
+  IsUnknown,
+  IsUnsafe,
+  IsVoid
+};

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

@@ -0,0 +1,272 @@
+import { IsString as IsString$1, IsArray as IsArray$1, IsObject as IsObject$1, IsNumber as IsNumber$1, IsUndefined as IsUndefined$1, IsBoolean as IsBoolean$1, IsBigInt as IsBigInt$1 } from "./value.js";
+import { Kind, TransformKind, OptionalKind } from "../symbols/symbols.js";
+const KnownTypes = [
+  "Argument",
+  "Any",
+  "Array",
+  "AsyncIterator",
+  "BigInt",
+  "Boolean",
+  "Computed",
+  "Constructor",
+  "Date",
+  "Enum",
+  "Function",
+  "Integer",
+  "Intersect",
+  "Iterator",
+  "Literal",
+  "MappedKey",
+  "MappedResult",
+  "Not",
+  "Null",
+  "Number",
+  "Object",
+  "Promise",
+  "Record",
+  "Ref",
+  "RegExp",
+  "String",
+  "Symbol",
+  "TemplateLiteral",
+  "This",
+  "Tuple",
+  "Undefined",
+  "Union",
+  "Uint8Array",
+  "Unknown",
+  "Void"
+];
+function IsPattern(value) {
+  try {
+    new RegExp(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function IsControlCharacterFree(value) {
+  if (!IsString$1(value))
+    return false;
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code >= 7 && code <= 13 || code === 27 || code === 127) {
+      return false;
+    }
+  }
+  return true;
+}
+function IsAdditionalProperties(value) {
+  return IsOptionalBoolean(value) || IsSchema(value);
+}
+function IsOptionalBigInt(value) {
+  return IsUndefined$1(value) || IsBigInt$1(value);
+}
+function IsOptionalNumber(value) {
+  return IsUndefined$1(value) || IsNumber$1(value);
+}
+function IsOptionalBoolean(value) {
+  return IsUndefined$1(value) || IsBoolean$1(value);
+}
+function IsOptionalString(value) {
+  return IsUndefined$1(value) || IsString$1(value);
+}
+function IsOptionalPattern(value) {
+  return IsUndefined$1(value) || IsString$1(value) && IsControlCharacterFree(value) && IsPattern(value);
+}
+function IsOptionalFormat(value) {
+  return IsUndefined$1(value) || IsString$1(value) && IsControlCharacterFree(value);
+}
+function IsOptionalSchema(value) {
+  return IsUndefined$1(value) || IsSchema(value);
+}
+function IsOptional(value) {
+  return IsObject$1(value) && value[OptionalKind] === "Optional";
+}
+function IsAny(value) {
+  return IsKindOf(value, "Any") && IsOptionalString(value.$id);
+}
+function IsArgument(value) {
+  return IsKindOf(value, "Argument") && IsNumber$1(value.index);
+}
+function IsArray(value) {
+  return IsKindOf(value, "Array") && value.type === "array" && IsOptionalString(value.$id) && IsSchema(value.items) && IsOptionalNumber(value.minItems) && IsOptionalNumber(value.maxItems) && IsOptionalBoolean(value.uniqueItems) && IsOptionalSchema(value.contains) && IsOptionalNumber(value.minContains) && IsOptionalNumber(value.maxContains);
+}
+function IsAsyncIterator(value) {
+  return IsKindOf(value, "AsyncIterator") && value.type === "AsyncIterator" && IsOptionalString(value.$id) && IsSchema(value.items);
+}
+function IsBigInt(value) {
+  return IsKindOf(value, "BigInt") && value.type === "bigint" && IsOptionalString(value.$id) && IsOptionalBigInt(value.exclusiveMaximum) && IsOptionalBigInt(value.exclusiveMinimum) && IsOptionalBigInt(value.maximum) && IsOptionalBigInt(value.minimum) && IsOptionalBigInt(value.multipleOf);
+}
+function IsBoolean(value) {
+  return IsKindOf(value, "Boolean") && value.type === "boolean" && IsOptionalString(value.$id);
+}
+function IsComputed(value) {
+  return IsKindOf(value, "Computed") && IsString$1(value.target) && IsArray$1(value.parameters) && value.parameters.every((schema) => IsSchema(schema));
+}
+function IsConstructor(value) {
+  return IsKindOf(value, "Constructor") && value.type === "Constructor" && IsOptionalString(value.$id) && IsArray$1(value.parameters) && value.parameters.every((schema) => IsSchema(schema)) && IsSchema(value.returns);
+}
+function IsDate(value) {
+  return IsKindOf(value, "Date") && value.type === "Date" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximumTimestamp) && IsOptionalNumber(value.exclusiveMinimumTimestamp) && IsOptionalNumber(value.maximumTimestamp) && IsOptionalNumber(value.minimumTimestamp) && IsOptionalNumber(value.multipleOfTimestamp);
+}
+function IsFunction(value) {
+  return IsKindOf(value, "Function") && value.type === "Function" && IsOptionalString(value.$id) && IsArray$1(value.parameters) && value.parameters.every((schema) => IsSchema(schema)) && IsSchema(value.returns);
+}
+function IsInteger(value) {
+  return IsKindOf(value, "Integer") && value.type === "integer" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
+}
+function IsProperties(value) {
+  return IsObject$1(value) && Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema(schema));
+}
+function IsIntersect(value) {
+  return IsKindOf(value, "Intersect") && (IsString$1(value.type) && value.type !== "object" ? false : true) && IsArray$1(value.allOf) && value.allOf.every((schema) => IsSchema(schema) && !IsTransform(schema)) && IsOptionalString(value.type) && (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) && IsOptionalString(value.$id);
+}
+function IsIterator(value) {
+  return IsKindOf(value, "Iterator") && value.type === "Iterator" && IsOptionalString(value.$id) && IsSchema(value.items);
+}
+function IsKindOf(value, kind) {
+  return IsObject$1(value) && Kind in value && value[Kind] === kind;
+}
+function IsLiteralString(value) {
+  return IsLiteral(value) && IsString$1(value.const);
+}
+function IsLiteralNumber(value) {
+  return IsLiteral(value) && IsNumber$1(value.const);
+}
+function IsLiteralBoolean(value) {
+  return IsLiteral(value) && IsBoolean$1(value.const);
+}
+function IsLiteral(value) {
+  return IsKindOf(value, "Literal") && IsOptionalString(value.$id) && IsLiteralValue(value.const);
+}
+function IsLiteralValue(value) {
+  return IsBoolean$1(value) || IsNumber$1(value) || IsString$1(value);
+}
+function IsMappedKey(value) {
+  return IsKindOf(value, "MappedKey") && IsArray$1(value.keys) && value.keys.every((key) => IsNumber$1(key) || IsString$1(key));
+}
+function IsMappedResult(value) {
+  return IsKindOf(value, "MappedResult") && IsProperties(value.properties);
+}
+function IsNever(value) {
+  return IsKindOf(value, "Never") && IsObject$1(value.not) && Object.getOwnPropertyNames(value.not).length === 0;
+}
+function IsNot(value) {
+  return IsKindOf(value, "Not") && IsSchema(value.not);
+}
+function IsNull(value) {
+  return IsKindOf(value, "Null") && value.type === "null" && IsOptionalString(value.$id);
+}
+function IsNumber(value) {
+  return IsKindOf(value, "Number") && value.type === "number" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
+}
+function IsObject(value) {
+  return IsKindOf(value, "Object") && value.type === "object" && IsOptionalString(value.$id) && IsProperties(value.properties) && IsAdditionalProperties(value.additionalProperties) && IsOptionalNumber(value.minProperties) && IsOptionalNumber(value.maxProperties);
+}
+function IsPromise(value) {
+  return IsKindOf(value, "Promise") && value.type === "Promise" && IsOptionalString(value.$id) && IsSchema(value.item);
+}
+function IsRecord(value) {
+  return IsKindOf(value, "Record") && value.type === "object" && IsOptionalString(value.$id) && IsAdditionalProperties(value.additionalProperties) && IsObject$1(value.patternProperties) && ((schema) => {
+    const keys = Object.getOwnPropertyNames(schema.patternProperties);
+    return keys.length === 1 && IsPattern(keys[0]) && IsObject$1(schema.patternProperties) && IsSchema(schema.patternProperties[keys[0]]);
+  })(value);
+}
+function IsRef(value) {
+  return IsKindOf(value, "Ref") && IsOptionalString(value.$id) && IsString$1(value.$ref);
+}
+function IsRegExp(value) {
+  return IsKindOf(value, "RegExp") && IsOptionalString(value.$id) && IsString$1(value.source) && IsString$1(value.flags) && IsOptionalNumber(value.maxLength) && IsOptionalNumber(value.minLength);
+}
+function IsString(value) {
+  return IsKindOf(value, "String") && value.type === "string" && IsOptionalString(value.$id) && IsOptionalNumber(value.minLength) && IsOptionalNumber(value.maxLength) && IsOptionalPattern(value.pattern) && IsOptionalFormat(value.format);
+}
+function IsSymbol(value) {
+  return IsKindOf(value, "Symbol") && value.type === "symbol" && IsOptionalString(value.$id);
+}
+function IsTemplateLiteral(value) {
+  return IsKindOf(value, "TemplateLiteral") && value.type === "string" && IsString$1(value.pattern) && value.pattern[0] === "^" && value.pattern[value.pattern.length - 1] === "$";
+}
+function IsThis(value) {
+  return IsKindOf(value, "This") && IsOptionalString(value.$id) && IsString$1(value.$ref);
+}
+function IsTransform(value) {
+  return IsObject$1(value) && TransformKind in value;
+}
+function IsTuple(value) {
+  return IsKindOf(value, "Tuple") && value.type === "array" && IsOptionalString(value.$id) && IsNumber$1(value.minItems) && IsNumber$1(value.maxItems) && value.minItems === value.maxItems && // empty
+  (IsUndefined$1(value.items) && IsUndefined$1(value.additionalItems) && value.minItems === 0 || IsArray$1(value.items) && value.items.every((schema) => IsSchema(schema)));
+}
+function IsUndefined(value) {
+  return IsKindOf(value, "Undefined") && value.type === "undefined" && IsOptionalString(value.$id);
+}
+function IsUnion(value) {
+  return IsKindOf(value, "Union") && IsOptionalString(value.$id) && IsObject$1(value) && IsArray$1(value.anyOf) && value.anyOf.every((schema) => IsSchema(schema));
+}
+function IsUint8Array(value) {
+  return IsKindOf(value, "Uint8Array") && value.type === "Uint8Array" && IsOptionalString(value.$id) && IsOptionalNumber(value.minByteLength) && IsOptionalNumber(value.maxByteLength);
+}
+function IsUnknown(value) {
+  return IsKindOf(value, "Unknown") && IsOptionalString(value.$id);
+}
+function IsUnsafe(value) {
+  return IsKindOf(value, "Unsafe");
+}
+function IsVoid(value) {
+  return IsKindOf(value, "Void") && value.type === "void" && IsOptionalString(value.$id);
+}
+function IsKind(value) {
+  return IsObject$1(value) && Kind in value && IsString$1(value[Kind]) && !KnownTypes.includes(value[Kind]);
+}
+function IsSchema(value) {
+  return IsObject$1(value) && (IsAny(value) || IsArgument(value) || IsArray(value) || IsBoolean(value) || IsBigInt(value) || IsAsyncIterator(value) || IsComputed(value) || IsConstructor(value) || IsDate(value) || IsFunction(value) || IsInteger(value) || IsIntersect(value) || IsIterator(value) || IsLiteral(value) || IsMappedKey(value) || IsMappedResult(value) || IsNever(value) || IsNot(value) || IsNull(value) || IsNumber(value) || IsObject(value) || IsPromise(value) || IsRecord(value) || IsRef(value) || IsRegExp(value) || IsString(value) || IsSymbol(value) || IsTemplateLiteral(value) || IsThis(value) || IsTuple(value) || IsUndefined(value) || IsUnion(value) || IsUint8Array(value) || IsUnknown(value) || IsUnsafe(value) || IsVoid(value) || IsKind(value));
+}
+export {
+  IsAny,
+  IsArgument,
+  IsArray,
+  IsAsyncIterator,
+  IsBigInt,
+  IsBoolean,
+  IsComputed,
+  IsConstructor,
+  IsDate,
+  IsFunction,
+  IsInteger,
+  IsIntersect,
+  IsIterator,
+  IsKind,
+  IsKindOf,
+  IsLiteral,
+  IsLiteralBoolean,
+  IsLiteralNumber,
+  IsLiteralString,
+  IsLiteralValue,
+  IsMappedKey,
+  IsMappedResult,
+  IsNever,
+  IsNot,
+  IsNull,
+  IsNumber,
+  IsObject,
+  IsOptional,
+  IsPromise,
+  IsProperties,
+  IsRecord,
+  IsRef,
+  IsRegExp,
+  IsSchema,
+  IsString,
+  IsSymbol,
+  IsTemplateLiteral,
+  IsThis,
+  IsTransform,
+  IsTuple,
+  IsUint8Array,
+  IsUndefined,
+  IsUnion,
+  IsUnknown,
+  IsUnsafe,
+  IsVoid
+};

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

@@ -0,0 +1,62 @@
+function IsAsyncIterator(value) {
+  return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;
+}
+function IsArray(value) {
+  return Array.isArray(value);
+}
+function IsBigInt(value) {
+  return typeof value === "bigint";
+}
+function IsBoolean(value) {
+  return typeof value === "boolean";
+}
+function IsDate(value) {
+  return value instanceof globalThis.Date;
+}
+function IsFunction(value) {
+  return typeof value === "function";
+}
+function IsIterator(value) {
+  return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.iterator in value;
+}
+function IsNull(value) {
+  return value === null;
+}
+function IsNumber(value) {
+  return typeof value === "number";
+}
+function IsObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function IsRegExp(value) {
+  return value instanceof globalThis.RegExp;
+}
+function IsString(value) {
+  return typeof value === "string";
+}
+function IsSymbol(value) {
+  return typeof value === "symbol";
+}
+function IsUint8Array(value) {
+  return value instanceof globalThis.Uint8Array;
+}
+function IsUndefined(value) {
+  return value === void 0;
+}
+export {
+  IsArray,
+  IsAsyncIterator,
+  IsBigInt,
+  IsBoolean,
+  IsDate,
+  IsFunction,
+  IsIterator,
+  IsNull,
+  IsNumber,
+  IsObject,
+  IsRegExp,
+  IsString,
+  IsSymbol,
+  IsUint8Array,
+  IsUndefined
+};

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

@@ -0,0 +1,21 @@
+import { Index } from "./indexed.js";
+import { Clone } from "../clone/value.js";
+import { MappedResult } from "../mapped/mapped-result.js";
+function MappedIndexPropertyKey(type, key, options) {
+  return { [key]: Index(type, [key], Clone(options)) };
+}
+function MappedIndexPropertyKeys(type, propertyKeys, options) {
+  return propertyKeys.reduce((result, left) => {
+    return { ...result, ...MappedIndexPropertyKey(type, left, options) };
+  }, {});
+}
+function MappedIndexProperties(type, mappedKey, options) {
+  return MappedIndexPropertyKeys(type, mappedKey.keys, options);
+}
+function IndexFromMappedKey(type, mappedKey, options) {
+  const properties = MappedIndexProperties(type, mappedKey, options);
+  return MappedResult(properties);
+}
+export {
+  IndexFromMappedKey
+};

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

@@ -0,0 +1,20 @@
+import { IndexPropertyKeys } from "./indexed-property-keys.js";
+import { MappedResult } from "../mapped/mapped-result.js";
+import { Index } from "./indexed.js";
+function FromProperties(type, properties, options) {
+  const result = {};
+  for (const K2 of Object.getOwnPropertyNames(properties)) {
+    result[K2] = Index(type, IndexPropertyKeys(properties[K2]), options);
+  }
+  return result;
+}
+function FromMappedResult(type, mappedResult, options) {
+  return FromProperties(type, mappedResult.properties, options);
+}
+function IndexFromMappedResult(type, mappedResult, options) {
+  const properties = FromMappedResult(type, mappedResult, options);
+  return MappedResult(properties);
+}
+export {
+  IndexFromMappedResult
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-property-keys.js

@@ -0,0 +1,21 @@
+import { IsTemplateLiteral, IsUnion, IsLiteral, IsNumber, IsInteger } from "../guard/kind.js";
+import { TemplateLiteralGenerate } from "../template-literal/generate.js";
+function FromTemplateLiteral(templateLiteral) {
+  const keys = TemplateLiteralGenerate(templateLiteral);
+  return keys.map((key) => key.toString());
+}
+function FromUnion(types) {
+  const result = [];
+  for (const type of types)
+    result.push(...IndexPropertyKeys(type));
+  return result;
+}
+function FromLiteral(literalValue) {
+  return [literalValue.toString()];
+}
+function IndexPropertyKeys(type) {
+  return [...new Set(IsTemplateLiteral(type) ? FromTemplateLiteral(type) : IsUnion(type) ? FromUnion(type.anyOf) : IsLiteral(type) ? FromLiteral(type.const) : IsNumber(type) ? ["[number]"] : IsInteger(type) ? ["[number]"] : [])];
+}
+export {
+  IndexPropertyKeys
+};

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

@@ -0,0 +1,61 @@
+import { CreateType } from "../create/type.js";
+import { IndexPropertyKeys } from "./indexed-property-keys.js";
+import { IndexFromMappedKey } from "./indexed-from-mapped-key.js";
+import { IndexFromMappedResult } from "./indexed-from-mapped-result.js";
+import { IsRef, IsSchema, IsMappedResult, IsMappedKey, IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsNever } from "../guard/kind.js";
+import { TypeBoxError } from "../error/error.js";
+import { Computed } from "../computed/computed.js";
+import { UnionEvaluated } from "../union/union-evaluated.js";
+import { Never } from "../never/never.js";
+import { IntersectEvaluated } from "../intersect/intersect-evaluated.js";
+function FromRest(types, key) {
+  return types.map((type) => IndexFromPropertyKey(type, key));
+}
+function FromIntersectRest(types) {
+  return types.filter((type) => !IsNever(type));
+}
+function FromIntersect(types, key) {
+  return IntersectEvaluated(FromIntersectRest(FromRest(types, key)));
+}
+function FromUnionRest(types) {
+  return types.some((L) => IsNever(L)) ? [] : types;
+}
+function FromUnion(types, key) {
+  return UnionEvaluated(FromUnionRest(FromRest(types, key)));
+}
+function FromTuple(types, key) {
+  return key in types ? types[key] : key === "[number]" ? UnionEvaluated(types) : Never();
+}
+function FromArray(type, key) {
+  return key === "[number]" ? type : Never();
+}
+function FromProperty(properties, propertyKey) {
+  return propertyKey in properties ? properties[propertyKey] : Never();
+}
+function IndexFromPropertyKey(type, propertyKey) {
+  return IsIntersect(type) ? FromIntersect(type.allOf, propertyKey) : IsUnion(type) ? FromUnion(type.anyOf, propertyKey) : IsTuple(type) ? FromTuple(type.items ?? [], propertyKey) : IsArray(type) ? FromArray(type.items, propertyKey) : IsObject(type) ? FromProperty(type.properties, propertyKey) : Never();
+}
+function IndexFromPropertyKeys(type, propertyKeys) {
+  return propertyKeys.map((propertyKey) => IndexFromPropertyKey(type, propertyKey));
+}
+function FromSchema(type, propertyKeys) {
+  return UnionEvaluated(IndexFromPropertyKeys(type, propertyKeys));
+}
+function Index(type, key, options) {
+  if (IsRef(type) || IsRef(key)) {
+    const error = `Index types using Ref parameters require both Type and Key to be of TSchema`;
+    if (!IsSchema(type) || !IsSchema(key))
+      throw new TypeBoxError(error);
+    return Computed("Index", [type, key]);
+  }
+  if (IsMappedResult(key))
+    return IndexFromMappedResult(type, key, options);
+  if (IsMappedKey(key))
+    return IndexFromMappedKey(type, key, options);
+  return CreateType(IsSchema(key) ? FromSchema(type, IndexPropertyKeys(key)) : FromSchema(type, key), options);
+}
+export {
+  Index,
+  IndexFromPropertyKey,
+  IndexFromPropertyKeys
+};

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

@@ -0,0 +1,9 @@
+import { CreateType } from "../create/type.js";
+import { IsConstructor } from "../guard/kind.js";
+import { Never } from "../never/never.js";
+function InstanceType(schema, options) {
+  return IsConstructor(schema) ? CreateType(schema.returns, options) : Never(options);
+}
+export {
+  InstanceType
+};