npm - @workclaw/openclaw-workclaw - Versions diffs - 1.0.202 → 1.0.332 - Mend

@workclaw/openclaw-workclaw 1.0.202 → 1.0.332

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (541) hide show

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

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

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

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

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

@@ -0,0 +1,15 @@
+import { CreateType } from "../create/type.js";
+import { IsOptional } from "../guard/kind.js";
+import { Kind } from "../symbols/symbols.js";
+function RequiredArray(properties) {
+  return globalThis.Object.keys(properties).filter((key) => !IsOptional(properties[key]));
+}
+function _Object(properties, options) {
+  const required = RequiredArray(properties);
+  const schema = required.length > 0 ? { [Kind]: "Object", type: "object", required, properties } : { [Kind]: "Object", type: "object", properties };
+  return CreateType(schema, options);
+}
+var Object$1 = _Object;
+export {
+  Object$1 as Object
+};

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

@@ -0,0 +1,21 @@
+import { Omit } from "./omit.js";
+import { Clone } from "../clone/value.js";
+import { MappedResult } from "../mapped/mapped-result.js";
+function FromPropertyKey(type, key, options) {
+  return { [key]: Omit(type, [key], Clone(options)) };
+}
+function FromPropertyKeys(type, propertyKeys, options) {
+  return propertyKeys.reduce((Acc, LK) => {
+    return { ...Acc, ...FromPropertyKey(type, LK, options) };
+  }, {});
+}
+function FromMappedKey(type, mappedKey, options) {
+  return FromPropertyKeys(type, mappedKey.keys, options);
+}
+function OmitFromMappedKey(type, mappedKey, options) {
+  const properties = FromMappedKey(type, mappedKey, options);
+  return MappedResult(properties);
+}
+export {
+  OmitFromMappedKey
+};

@@ -0,0 +1,19 @@
+import { Omit } from "./omit.js";
+import { Clone } from "../clone/value.js";
+import { MappedResult } from "../mapped/mapped-result.js";
+function FromProperties(properties, propertyKeys, options) {
+  const result = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
+    result[K2] = Omit(properties[K2], propertyKeys, Clone(options));
+  return result;
+}
+function FromMappedResult(mappedResult, propertyKeys, options) {
+  return FromProperties(mappedResult.properties, propertyKeys, options);
+}
+function OmitFromMappedResult(mappedResult, propertyKeys, options) {
+  const properties = FromMappedResult(mappedResult, propertyKeys, options);
+  return MappedResult(properties);
+}
+export {
+  OmitFromMappedResult
+};

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

@@ -0,0 +1,48 @@
+import { CreateType } from "../create/type.js";
+import { Discard } from "../discard/discard.js";
+import { TransformKind } from "../symbols/symbols.js";
+import { OmitFromMappedKey } from "./omit-from-mapped-key.js";
+import { OmitFromMappedResult } from "./omit-from-mapped-result.js";
+import { IsSchema, IsRef, IsMappedResult, IsMappedKey, IsLiteralValue, IsIntersect, IsUnion, IsObject } from "../guard/kind.js";
+import { IsArray } from "../guard/value.js";
+import { IndexPropertyKeys } from "../indexed/indexed-property-keys.js";
+import { Computed } from "../computed/computed.js";
+import { Literal } from "../literal/literal.js";
+import { Union } from "../union/union.js";
+import { Intersect } from "../intersect/intersect.js";
+import { Object as Object$1 } from "../object/object.js";
+function FromIntersect(types, propertyKeys) {
+  return types.map((type) => OmitResolve(type, propertyKeys));
+}
+function FromUnion(types, propertyKeys) {
+  return types.map((type) => OmitResolve(type, propertyKeys));
+}
+function FromProperty(properties, key) {
+  const { [key]: _, ...R } = properties;
+  return R;
+}
+function FromProperties(properties, propertyKeys) {
+  return propertyKeys.reduce((T, K2) => FromProperty(T, K2), properties);
+}
+function FromObject(type, propertyKeys, properties) {
+  const options = Discard(type, [TransformKind, "$id", "required", "properties"]);
+  const mappedProperties = FromProperties(properties, propertyKeys);
+  return Object$1(mappedProperties, options);
+}
+function UnionFromPropertyKeys(propertyKeys) {
+  const result = propertyKeys.reduce((result2, key) => IsLiteralValue(key) ? [...result2, Literal(key)] : result2, []);
+  return Union(result);
+}
+function OmitResolve(type, propertyKeys) {
+  return IsIntersect(type) ? Intersect(FromIntersect(type.allOf, propertyKeys)) : IsUnion(type) ? Union(FromUnion(type.anyOf, propertyKeys)) : IsObject(type) ? FromObject(type, propertyKeys, type.properties) : Object$1({});
+}
+function Omit(type, key, options) {
+  const typeKey = IsArray(key) ? UnionFromPropertyKeys(key) : key;
+  const propertyKeys = IsSchema(key) ? IndexPropertyKeys(key) : key;
+  const isTypeRef = IsRef(type);
+  const isKeyRef = IsRef(key);
+  return IsMappedResult(type) ? OmitFromMappedResult(type, propertyKeys, options) : IsMappedKey(key) ? OmitFromMappedKey(type, key, options) : isTypeRef && isKeyRef ? Computed("Omit", [type, typeKey], options) : !isTypeRef && isKeyRef ? Computed("Omit", [type, typeKey], options) : isTypeRef && !isKeyRef ? Computed("Omit", [type, typeKey], options) : CreateType({ ...OmitResolve(type, propertyKeys), ...options });
+}
+export {
+  Omit
+};

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

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

@@ -0,0 +1,21 @@
+import { CreateType } from "../create/type.js";
+import { OptionalFromMappedResult } from "./optional-from-mapped-result.js";
+import { IsMappedResult } from "../guard/kind.js";
+import { Discard } from "../discard/discard.js";
+import { OptionalKind } from "../symbols/symbols.js";
+function RemoveOptional(schema) {
+  return CreateType(Discard(schema, [OptionalKind]));
+}
+function AddOptional(schema) {
+  return CreateType({ ...schema, [OptionalKind]: "Optional" });
+}
+function OptionalWithFlag(schema, F) {
+  return F === false ? RemoveOptional(schema) : AddOptional(schema);
+}
+function Optional(schema, enable) {
+  const F = enable ?? true;
+  return IsMappedResult(schema) ? OptionalFromMappedResult(schema, F) : OptionalWithFlag(schema, F);
+}
+export {
+  Optional
+};

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

@@ -0,0 +1,9 @@
+import { IsFunction } from "../guard/kind.js";
+import { Tuple } from "../tuple/tuple.js";
+import { Never } from "../never/never.js";
+function Parameters(schema, options) {
+  return IsFunction(schema) ? Tuple(schema.parameters, options) : Never();
+}
+export {
+  Parameters
+};

@@ -0,0 +1,19 @@
+import { Partial } from "./partial.js";
+import { Clone } from "../clone/value.js";
+import { MappedResult } from "../mapped/mapped-result.js";
+function FromProperties(K, options) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+    Acc[K2] = Partial(K[K2], Clone(options));
+  return Acc;
+}
+function FromMappedResult(R, options) {
+  return FromProperties(R.properties, options);
+}
+function PartialFromMappedResult(R, options) {
+  const P = FromMappedResult(R, options);
+  return MappedResult(P);
+}
+export {
+  PartialFromMappedResult
+};

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

@@ -0,0 +1,53 @@
+import { CreateType } from "../create/type.js";
+import { PartialFromMappedResult } from "./partial-from-mapped-result.js";
+import { IsMappedResult, IsComputed, IsRef, IsIntersect, IsUnion, IsObject, IsBigInt, IsBoolean, IsInteger, IsLiteral, IsNull, IsNumber, IsString, IsSymbol, IsUndefined } from "../guard/kind.js";
+import { Intersect } from "../intersect/intersect.js";
+import { Union } from "../union/union.js";
+import { Object as Object$1 } from "../object/object.js";
+import { Computed } from "../computed/computed.js";
+import { Ref } from "../ref/ref.js";
+import { Discard } from "../discard/discard.js";
+import { Optional } from "../optional/optional.js";
+import { TransformKind } from "../symbols/symbols.js";
+function FromComputed(target, parameters) {
+  return Computed("Partial", [Computed(target, parameters)]);
+}
+function FromRef($ref) {
+  return Computed("Partial", [Ref($ref)]);
+}
+function FromProperties(properties) {
+  const partialProperties = {};
+  for (const K of globalThis.Object.getOwnPropertyNames(properties))
+    partialProperties[K] = Optional(properties[K]);
+  return partialProperties;
+}
+function FromObject(type, properties) {
+  const options = Discard(type, [TransformKind, "$id", "required", "properties"]);
+  const mappedProperties = FromProperties(properties);
+  return Object$1(mappedProperties, options);
+}
+function FromRest(types) {
+  return types.map((type) => PartialResolve(type));
+}
+function PartialResolve(type) {
+  return (
+    // Mappable
+    IsComputed(type) ? FromComputed(type.target, type.parameters) : IsRef(type) ? FromRef(type.$ref) : IsIntersect(type) ? Intersect(FromRest(type.allOf)) : IsUnion(type) ? Union(FromRest(type.anyOf)) : IsObject(type) ? FromObject(type, type.properties) : (
+      // Intrinsic
+      IsBigInt(type) ? type : IsBoolean(type) ? type : IsInteger(type) ? type : IsLiteral(type) ? type : IsNull(type) ? type : IsNumber(type) ? type : IsString(type) ? type : IsSymbol(type) ? type : IsUndefined(type) ? type : (
+        // Passthrough
+        Object$1({})
+      )
+    )
+  );
+}
+function Partial(type, options) {
+  if (IsMappedResult(type)) {
+    return PartialFromMappedResult(type, options);
+  } else {
+    return CreateType({ ...PartialResolve(type), ...options });
+  }
+}
+export {
+  Partial
+};

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

@@ -0,0 +1,16 @@
+const PatternBoolean = "(true|false)";
+const PatternNumber = "(0|[1-9][0-9]*)";
+const PatternString = "(.*)";
+const PatternNever = "(?!.*)";
+const PatternNumberExact = `^${PatternNumber}$`;
+const PatternStringExact = `^${PatternString}$`;
+const PatternNeverExact = `^${PatternNever}$`;
+export {
+  PatternBoolean,
+  PatternNever,
+  PatternNeverExact,
+  PatternNumber,
+  PatternNumberExact,
+  PatternString,
+  PatternStringExact
+};

@@ -0,0 +1,23 @@
+import { Pick } from "./pick.js";
+import { Clone } from "../clone/value.js";
+import { MappedResult } from "../mapped/mapped-result.js";
+function FromPropertyKey(type, key, options) {
+  return {
+    [key]: Pick(type, [key], Clone(options))
+  };
+}
+function FromPropertyKeys(type, propertyKeys, options) {
+  return propertyKeys.reduce((result, leftKey) => {
+    return { ...result, ...FromPropertyKey(type, leftKey, options) };
+  }, {});
+}
+function FromMappedKey(type, mappedKey, options) {
+  return FromPropertyKeys(type, mappedKey.keys, options);
+}
+function PickFromMappedKey(type, mappedKey, options) {
+  const properties = FromMappedKey(type, mappedKey, options);
+  return MappedResult(properties);
+}
+export {
+  PickFromMappedKey
+};

@@ -0,0 +1,19 @@
+import { Pick } from "./pick.js";
+import { Clone } from "../clone/value.js";
+import { MappedResult } from "../mapped/mapped-result.js";
+function FromProperties(properties, propertyKeys, options) {
+  const result = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
+    result[K2] = Pick(properties[K2], propertyKeys, Clone(options));
+  return result;
+}
+function FromMappedResult(mappedResult, propertyKeys, options) {
+  return FromProperties(mappedResult.properties, propertyKeys, options);
+}
+function PickFromMappedResult(mappedResult, propertyKeys, options) {
+  const properties = FromMappedResult(mappedResult, propertyKeys, options);
+  return MappedResult(properties);
+}
+export {
+  PickFromMappedResult
+};

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

@@ -0,0 +1,48 @@
+import { CreateType } from "../create/type.js";
+import { Discard } from "../discard/discard.js";
+import { TransformKind } from "../symbols/symbols.js";
+import { IsSchema, IsRef, IsMappedResult, IsMappedKey, IsLiteralValue, IsIntersect, IsUnion, IsObject } from "../guard/kind.js";
+import { IsArray } from "../guard/value.js";
+import { PickFromMappedKey } from "./pick-from-mapped-key.js";
+import { PickFromMappedResult } from "./pick-from-mapped-result.js";
+import { IndexPropertyKeys } from "../indexed/indexed-property-keys.js";
+import { Computed } from "../computed/computed.js";
+import { Literal } from "../literal/literal.js";
+import { Union } from "../union/union.js";
+import { Intersect } from "../intersect/intersect.js";
+import { Object as Object$1 } from "../object/object.js";
+function FromIntersect(types, propertyKeys) {
+  return types.map((type) => PickResolve(type, propertyKeys));
+}
+function FromUnion(types, propertyKeys) {
+  return types.map((type) => PickResolve(type, propertyKeys));
+}
+function FromProperties(properties, propertyKeys) {
+  const result = {};
+  for (const K2 of propertyKeys)
+    if (K2 in properties)
+      result[K2] = properties[K2];
+  return result;
+}
+function FromObject(Type, keys, properties) {
+  const options = Discard(Type, [TransformKind, "$id", "required", "properties"]);
+  const mappedProperties = FromProperties(properties, keys);
+  return Object$1(mappedProperties, options);
+}
+function UnionFromPropertyKeys(propertyKeys) {
+  const result = propertyKeys.reduce((result2, key) => IsLiteralValue(key) ? [...result2, Literal(key)] : result2, []);
+  return Union(result);
+}
+function PickResolve(type, propertyKeys) {
+  return IsIntersect(type) ? Intersect(FromIntersect(type.allOf, propertyKeys)) : IsUnion(type) ? Union(FromUnion(type.anyOf, propertyKeys)) : IsObject(type) ? FromObject(type, propertyKeys, type.properties) : Object$1({});
+}
+function Pick(type, key, options) {
+  const typeKey = IsArray(key) ? UnionFromPropertyKeys(key) : key;
+  const propertyKeys = IsSchema(key) ? IndexPropertyKeys(key) : key;
+  const isTypeRef = IsRef(type);
+  const isKeyRef = IsRef(key);
+  return IsMappedResult(type) ? PickFromMappedResult(type, propertyKeys, options) : IsMappedKey(key) ? PickFromMappedKey(type, key, options) : isTypeRef && isKeyRef ? Computed("Pick", [type, typeKey], options) : !isTypeRef && isKeyRef ? Computed("Pick", [type, typeKey], options) : isTypeRef && !isKeyRef ? Computed("Pick", [type, typeKey], options) : CreateType({ ...PickResolve(type, propertyKeys), ...options });
+}
+export {
+  Pick
+};

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

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

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

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

@@ -0,0 +1,21 @@
+import { CreateType } from "../create/type.js";
+import { ReadonlyFromMappedResult } from "./readonly-from-mapped-result.js";
+import { IsMappedResult } from "../guard/kind.js";
+import { Discard } from "../discard/discard.js";
+import { ReadonlyKind } from "../symbols/symbols.js";
+function RemoveReadonly(schema) {
+  return CreateType(Discard(schema, [ReadonlyKind]));
+}
+function AddReadonly(schema) {
+  return CreateType({ ...schema, [ReadonlyKind]: "Readonly" });
+}
+function ReadonlyWithFlag(schema, F) {
+  return F === false ? RemoveReadonly(schema) : AddReadonly(schema);
+}
+function Readonly(schema, enable) {
+  const F = enable ?? true;
+  return IsMappedResult(schema) ? ReadonlyFromMappedResult(schema, F) : ReadonlyWithFlag(schema, F);
+}
+export {
+  Readonly
+};

@@ -0,0 +1,8 @@
+import { Readonly } from "../readonly/readonly.js";
+import { Optional } from "../optional/optional.js";
+function ReadonlyOptional(schema) {
+  return Readonly(Optional(schema));
+}
+export {
+  ReadonlyOptional
+};

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

@@ -0,0 +1,71 @@
+import { CreateType } from "../create/type.js";
+import { IsUndefined } from "../guard/value.js";
+import { IsUnion, IsTemplateLiteral, IsLiteral, IsBoolean, IsInteger, IsNumber, IsRegExp, IsString, IsAny, IsNever } from "../guard/kind.js";
+import { Never } from "../never/never.js";
+import { IndexPropertyKeys } from "../indexed/indexed-property-keys.js";
+import { Union } from "../union/union.js";
+import { IsTemplateLiteralFinite } from "../template-literal/finite.js";
+import { Object as Object$1 } from "../object/object.js";
+import { PatternStringExact, PatternNumberExact, PatternNeverExact } from "../patterns/patterns.js";
+import { Kind, Hint } from "../symbols/symbols.js";
+import { String } from "../string/string.js";
+import { Number } from "../number/number.js";
+function RecordCreateFromPattern(pattern, T, options) {
+  return CreateType({ [Kind]: "Record", type: "object", patternProperties: { [pattern]: T } }, options);
+}
+function RecordCreateFromKeys(K, T, options) {
+  const result = {};
+  for (const K2 of K)
+    result[K2] = T;
+  return Object$1(result, { ...options, [Hint]: "Record" });
+}
+function FromTemplateLiteralKey(K, T, options) {
+  return IsTemplateLiteralFinite(K) ? RecordCreateFromKeys(IndexPropertyKeys(K), T, options) : RecordCreateFromPattern(K.pattern, T, options);
+}
+function FromUnionKey(key, type, options) {
+  return RecordCreateFromKeys(IndexPropertyKeys(Union(key)), type, options);
+}
+function FromLiteralKey(key, type, options) {
+  return RecordCreateFromKeys([key.toString()], type, options);
+}
+function FromRegExpKey(key, type, options) {
+  return RecordCreateFromPattern(key.source, type, options);
+}
+function FromStringKey(key, type, options) {
+  const pattern = IsUndefined(key.pattern) ? PatternStringExact : key.pattern;
+  return RecordCreateFromPattern(pattern, type, options);
+}
+function FromAnyKey(_, type, options) {
+  return RecordCreateFromPattern(PatternStringExact, type, options);
+}
+function FromNeverKey(_key, type, options) {
+  return RecordCreateFromPattern(PatternNeverExact, type, options);
+}
+function FromBooleanKey(_key, type, options) {
+  return Object$1({ true: type, false: type }, options);
+}
+function FromIntegerKey(_key, type, options) {
+  return RecordCreateFromPattern(PatternNumberExact, type, options);
+}
+function FromNumberKey(_, type, options) {
+  return RecordCreateFromPattern(PatternNumberExact, type, options);
+}
+function Record(key, type, options = {}) {
+  return IsUnion(key) ? FromUnionKey(key.anyOf, type, options) : IsTemplateLiteral(key) ? FromTemplateLiteralKey(key, type, options) : IsLiteral(key) ? FromLiteralKey(key.const, type, options) : IsBoolean(key) ? FromBooleanKey(key, type, options) : IsInteger(key) ? FromIntegerKey(key, type, options) : IsNumber(key) ? FromNumberKey(key, type, options) : IsRegExp(key) ? FromRegExpKey(key, type, options) : IsString(key) ? FromStringKey(key, type, options) : IsAny(key) ? FromAnyKey(key, type, options) : IsNever(key) ? FromNeverKey(key, type, options) : Never(options);
+}
+function RecordPattern(record) {
+  return globalThis.Object.getOwnPropertyNames(record.patternProperties)[0];
+}
+function RecordKey(type) {
+  const pattern = RecordPattern(type);
+  return pattern === PatternStringExact ? String() : pattern === PatternNumberExact ? Number() : String({ pattern });
+}
+function RecordValue(type) {
+  return type.patternProperties[RecordPattern(type)];
+}
+export {
+  Record,
+  RecordKey,
+  RecordPattern,
+  RecordValue
+};

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

@@ -0,0 +1,15 @@
+import { CloneType } from "../clone/type.js";
+import { CreateType } from "../create/type.js";
+import { IsUndefined } from "../guard/value.js";
+import { Kind, Hint } from "../symbols/symbols.js";
+let Ordinal = 0;
+function Recursive(callback, options = {}) {
+  if (IsUndefined(options.$id))
+    options.$id = `T${Ordinal++}`;
+  const thisType = CloneType(callback({ [Kind]: "This", $ref: `${options.$id}` }));
+  thisType.$id = options.$id;
+  return CreateType({ [Hint]: "Recursive", ...thisType }, options);
+}
+export {
+  Recursive
+};

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

@@ -0,0 +1,12 @@
+import { CreateType } from "../create/type.js";
+import { TypeBoxError } from "../error/error.js";
+import { Kind } from "../symbols/symbols.js";
+function Ref(...args) {
+  const [$ref, options] = typeof args[0] === "string" ? [args[0], args[1]] : [args[0].$id, args[1]];
+  if (typeof $ref !== "string")
+    throw new TypeBoxError("Ref: $ref must be a string");
+  return CreateType({ [Kind]: "Ref", $ref }, options);
+}
+export {
+  Ref
+};

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

@@ -0,0 +1,10 @@
+import { CreateType } from "../create/type.js";
+import { IsString } from "../guard/value.js";
+import { Kind } from "../symbols/symbols.js";
+function RegExp(unresolved, options) {
+  const expr = IsString(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
+  return CreateType({ [Kind]: "RegExp", type: "RegExp", source: expr.source, flags: expr.flags }, options);
+}
+export {
+  RegExp
+};

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

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

@@ -0,0 +1,52 @@
+import { CreateType } from "../create/type.js";
+import { RequiredFromMappedResult } from "./required-from-mapped-result.js";
+import { IsMappedResult, IsComputed, IsRef, IsIntersect, IsUnion, IsObject, IsBigInt, IsBoolean, IsInteger, IsLiteral, IsNull, IsNumber, IsString, IsSymbol, IsUndefined } from "../guard/kind.js";
+import { Intersect } from "../intersect/intersect.js";
+import { Union } from "../union/union.js";
+import { Object as Object$1 } from "../object/object.js";
+import { Computed } from "../computed/computed.js";
+import { Ref } from "../ref/ref.js";
+import { Discard } from "../discard/discard.js";
+import { OptionalKind, TransformKind } from "../symbols/symbols.js";
+function FromComputed(target, parameters) {
+  return Computed("Required", [Computed(target, parameters)]);
+}
+function FromRef($ref) {
+  return Computed("Required", [Ref($ref)]);
+}
+function FromProperties(properties) {
+  const requiredProperties = {};
+  for (const K of globalThis.Object.getOwnPropertyNames(properties))
+    requiredProperties[K] = Discard(properties[K], [OptionalKind]);
+  return requiredProperties;
+}
+function FromObject(type, properties) {
+  const options = Discard(type, [TransformKind, "$id", "required", "properties"]);
+  const mappedProperties = FromProperties(properties);
+  return Object$1(mappedProperties, options);
+}
+function FromRest(types) {
+  return types.map((type) => RequiredResolve(type));
+}
+function RequiredResolve(type) {
+  return (
+    // Mappable
+    IsComputed(type) ? FromComputed(type.target, type.parameters) : IsRef(type) ? FromRef(type.$ref) : IsIntersect(type) ? Intersect(FromRest(type.allOf)) : IsUnion(type) ? Union(FromRest(type.anyOf)) : IsObject(type) ? FromObject(type, type.properties) : (
+      // Intrinsic
+      IsBigInt(type) ? type : IsBoolean(type) ? type : IsInteger(type) ? type : IsLiteral(type) ? type : IsNull(type) ? type : IsNumber(type) ? type : IsString(type) ? type : IsSymbol(type) ? type : IsUndefined(type) ? type : (
+        // Passthrough
+        Object$1({})
+      )
+    )
+  );
+}
+function Required(type, options) {
+  if (IsMappedResult(type)) {
+    return RequiredFromMappedResult(type, options);
+  } else {
+    return CreateType({ ...RequiredResolve(type), ...options });
+  }
+}
+export {
+  Required
+};

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

@@ -0,0 +1,10 @@
+import { IsIntersect, IsUnion, IsTuple } from "../guard/kind.js";
+function RestResolve(T) {
+  return IsIntersect(T) ? T.allOf : IsUnion(T) ? T.anyOf : IsTuple(T) ? T.items ?? [] : [];
+}
+function Rest(T) {
+  return RestResolve(T);
+}
+export {
+  Rest
+};

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