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

@workclaw/openclaw-workclaw 1.0.202 → 1.0.331

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 (534) hide show

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

@@ -0,0 +1,86 @@
+import { CloneType } from "../clone/type.js";
+import { IsUndefined } from "../guard/value.js";
+import { IsConstructor, IsFunction, IsIntersect, IsUnion, IsTuple, IsArray, IsAsyncIterator, IsIterator, IsPromise, IsObject, IsRecord, IsArgument, IsReadonly, IsOptional } from "../guard/kind.js";
+import { Object as Object$1 } from "../object/object.js";
+import { RecordKey, RecordValue, Record } from "../record/record.js";
+import { Unknown } from "../unknown/unknown.js";
+import { ReadonlyOptional } from "../readonly-optional/readonly-optional.js";
+import { Readonly } from "../readonly/readonly.js";
+import { Optional } from "../optional/optional.js";
+function FromConstructor(args, type) {
+  type.parameters = FromTypes(args, type.parameters);
+  type.returns = FromType(args, type.returns);
+  return type;
+}
+function FromFunction(args, type) {
+  type.parameters = FromTypes(args, type.parameters);
+  type.returns = FromType(args, type.returns);
+  return type;
+}
+function FromIntersect(args, type) {
+  type.allOf = FromTypes(args, type.allOf);
+  return type;
+}
+function FromUnion(args, type) {
+  type.anyOf = FromTypes(args, type.anyOf);
+  return type;
+}
+function FromTuple(args, type) {
+  if (IsUndefined(type.items))
+    return type;
+  type.items = FromTypes(args, type.items);
+  return type;
+}
+function FromArray(args, type) {
+  type.items = FromType(args, type.items);
+  return type;
+}
+function FromAsyncIterator(args, type) {
+  type.items = FromType(args, type.items);
+  return type;
+}
+function FromIterator(args, type) {
+  type.items = FromType(args, type.items);
+  return type;
+}
+function FromPromise(args, type) {
+  type.item = FromType(args, type.item);
+  return type;
+}
+function FromObject(args, type) {
+  const mappedProperties = FromProperties(args, type.properties);
+  return { ...type, ...Object$1(mappedProperties) };
+}
+function FromRecord(args, type) {
+  const mappedKey = FromType(args, RecordKey(type));
+  const mappedValue = FromType(args, RecordValue(type));
+  const result = Record(mappedKey, mappedValue);
+  return { ...type, ...result };
+}
+function FromArgument(args, argument) {
+  return argument.index in args ? args[argument.index] : Unknown();
+}
+function FromProperty(args, type) {
+  const isReadonly = IsReadonly(type);
+  const isOptional = IsOptional(type);
+  const mapped = FromType(args, type);
+  return isReadonly && isOptional ? ReadonlyOptional(mapped) : isReadonly && !isOptional ? Readonly(mapped) : !isReadonly && isOptional ? Optional(mapped) : mapped;
+}
+function FromProperties(args, properties) {
+  return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
+    return { ...result, [key]: FromProperty(args, properties[key]) };
+  }, {});
+}
+function FromTypes(args, types) {
+  return types.map((type) => FromType(args, type));
+}
+function FromType(args, type) {
+  return IsConstructor(type) ? FromConstructor(args, type) : IsFunction(type) ? FromFunction(args, type) : IsIntersect(type) ? FromIntersect(args, type) : IsUnion(type) ? FromUnion(args, type) : IsTuple(type) ? FromTuple(args, type) : IsArray(type) ? FromArray(args, type) : IsAsyncIterator(type) ? FromAsyncIterator(args, type) : IsIterator(type) ? FromIterator(args, type) : IsPromise(type) ? FromPromise(args, type) : IsObject(type) ? FromObject(args, type) : IsRecord(type) ? FromRecord(args, type) : IsArgument(type) ? FromArgument(args, type) : type;
+}
+function Instantiate(type, args) {
+  return FromType(args, CloneType(type));
+}
+export {
+  FromTypes,
+  Instantiate
+};

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

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

@@ -0,0 +1,11 @@
+import { CreateType } from "../create/type.js";
+import { IsObject, IsSchema } from "../guard/kind.js";
+import { Kind } from "../symbols/symbols.js";
+function IntersectCreate(T, options = {}) {
+  const allObjects = T.every((schema) => IsObject(schema));
+  const clonedUnevaluatedProperties = IsSchema(options.unevaluatedProperties) ? { unevaluatedProperties: options.unevaluatedProperties } : {};
+  return CreateType(options.unevaluatedProperties === false || IsSchema(options.unevaluatedProperties) || allObjects ? { ...clonedUnevaluatedProperties, [Kind]: "Intersect", type: "object", allOf: T } : { ...clonedUnevaluatedProperties, [Kind]: "Intersect", allOf: T }, options);
+}
+export {
+  IntersectCreate
+};

@@ -0,0 +1,31 @@
+import { CreateType } from "../create/type.js";
+import { IntersectCreate } from "./intersect-create.js";
+import { IsTransform, IsOptional } from "../guard/kind.js";
+import { Never } from "../never/never.js";
+import { Optional } from "../optional/optional.js";
+import { Discard } from "../discard/discard.js";
+import { OptionalKind } from "../symbols/symbols.js";
+function IsIntersectOptional(types) {
+  return types.every((left) => IsOptional(left));
+}
+function RemoveOptionalFromType(type) {
+  return Discard(type, [OptionalKind]);
+}
+function RemoveOptionalFromRest(types) {
+  return types.map((left) => IsOptional(left) ? RemoveOptionalFromType(left) : left);
+}
+function ResolveIntersect(types, options) {
+  return IsIntersectOptional(types) ? Optional(IntersectCreate(RemoveOptionalFromRest(types), options)) : IntersectCreate(RemoveOptionalFromRest(types), options);
+}
+function IntersectEvaluated(types, options = {}) {
+  if (types.length === 1)
+    return CreateType(types[0], options);
+  if (types.length === 0)
+    return Never(options);
+  if (types.some((schema) => IsTransform(schema)))
+    throw new Error("Cannot intersect transform types");
+  return ResolveIntersect(types, options);
+}
+export {
+  IntersectEvaluated
+};

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

@@ -0,0 +1,16 @@
+import { CreateType } from "../create/type.js";
+import { IntersectCreate } from "./intersect-create.js";
+import { IsTransform } from "../guard/kind.js";
+import { Never } from "../never/never.js";
+function Intersect(types, options) {
+  if (types.length === 1)
+    return CreateType(types[0], options);
+  if (types.length === 0)
+    return Never(options);
+  if (types.some((schema) => IsTransform(schema)))
+    throw new Error("Cannot intersect transform types");
+  return IntersectCreate(types, options);
+}
+export {
+  Intersect
+};

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

@@ -0,0 +1,7 @@
+import { Intrinsic } from "./intrinsic.js";
+function Capitalize(T, options = {}) {
+  return Intrinsic(T, "Capitalize", options);
+}
+export {
+  Capitalize
+};

@@ -0,0 +1,25 @@
+import { Intrinsic } from "./intrinsic.js";
+import { Clone } from "../clone/value.js";
+import { MappedResult } from "../mapped/mapped-result.js";
+import { Literal } from "../literal/literal.js";
+function MappedIntrinsicPropertyKey(K, M, options) {
+  return {
+    [K]: Intrinsic(Literal(K), M, Clone(options))
+  };
+}
+function MappedIntrinsicPropertyKeys(K, M, options) {
+  const result = K.reduce((Acc, L) => {
+    return { ...Acc, ...MappedIntrinsicPropertyKey(L, M, options) };
+  }, {});
+  return result;
+}
+function MappedIntrinsicProperties(T, M, options) {
+  return MappedIntrinsicPropertyKeys(T["keys"], M, options);
+}
+function IntrinsicFromMappedKey(T, M, options) {
+  const P = MappedIntrinsicProperties(T, M, options);
+  return MappedResult(P);
+}
+export {
+  IntrinsicFromMappedKey
+};

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

@@ -0,0 +1,55 @@
+import { CreateType } from "../create/type.js";
+import { IntrinsicFromMappedKey } from "./intrinsic-from-mapped-key.js";
+import { IsMappedKey, IsTemplateLiteral, IsUnion, IsLiteral } from "../guard/kind.js";
+import { Union } from "../union/union.js";
+import { Literal } from "../literal/literal.js";
+import { TemplateLiteralParseExact } from "../template-literal/parse.js";
+import { IsTemplateLiteralExpressionFinite } from "../template-literal/finite.js";
+import { TemplateLiteralExpressionGenerate } from "../template-literal/generate.js";
+import { TemplateLiteral } from "../template-literal/template-literal.js";
+function ApplyUncapitalize(value) {
+  const [first, rest] = [value.slice(0, 1), value.slice(1)];
+  return [first.toLowerCase(), rest].join("");
+}
+function ApplyCapitalize(value) {
+  const [first, rest] = [value.slice(0, 1), value.slice(1)];
+  return [first.toUpperCase(), rest].join("");
+}
+function ApplyUppercase(value) {
+  return value.toUpperCase();
+}
+function ApplyLowercase(value) {
+  return value.toLowerCase();
+}
+function FromTemplateLiteral(schema, mode, options) {
+  const expression = TemplateLiteralParseExact(schema.pattern);
+  const finite = IsTemplateLiteralExpressionFinite(expression);
+  if (!finite)
+    return { ...schema, pattern: FromLiteralValue(schema.pattern, mode) };
+  const strings = [...TemplateLiteralExpressionGenerate(expression)];
+  const literals = strings.map((value) => Literal(value));
+  const mapped = FromRest(literals, mode);
+  const union = Union(mapped);
+  return TemplateLiteral([union], options);
+}
+function FromLiteralValue(value, mode) {
+  return typeof value === "string" ? mode === "Uncapitalize" ? ApplyUncapitalize(value) : mode === "Capitalize" ? ApplyCapitalize(value) : mode === "Uppercase" ? ApplyUppercase(value) : mode === "Lowercase" ? ApplyLowercase(value) : value : value.toString();
+}
+function FromRest(T, M) {
+  return T.map((L) => Intrinsic(L, M));
+}
+function Intrinsic(schema, mode, options = {}) {
+  return (
+    // Intrinsic-Mapped-Inference
+    IsMappedKey(schema) ? IntrinsicFromMappedKey(schema, mode, options) : (
+      // Standard-Inference
+      IsTemplateLiteral(schema) ? FromTemplateLiteral(schema, mode, options) : IsUnion(schema) ? Union(FromRest(schema.anyOf, mode), options) : IsLiteral(schema) ? Literal(FromLiteralValue(schema.const, mode), options) : (
+        // Default Type
+        CreateType(schema, options)
+      )
+    )
+  );
+}
+export {
+  Intrinsic
+};

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

@@ -0,0 +1,7 @@
+import { Intrinsic } from "./intrinsic.js";
+function Lowercase(T, options = {}) {
+  return Intrinsic(T, "Lowercase", options);
+}
+export {
+  Lowercase
+};

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

@@ -0,0 +1,7 @@
+import { Intrinsic } from "./intrinsic.js";
+function Uncapitalize(T, options = {}) {
+  return Intrinsic(T, "Uncapitalize", options);
+}
+export {
+  Uncapitalize
+};

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

@@ -0,0 +1,7 @@
+import { Intrinsic } from "./intrinsic.js";
+function Uppercase(T, options = {}) {
+  return Intrinsic(T, "Uppercase", options);
+}
+export {
+  Uppercase
+};

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

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

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

@@ -0,0 +1,36 @@
+import { IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsRecord } from "../guard/kind.js";
+import { SetUnionMany, SetIntersectMany } from "../sets/set.js";
+function FromRest(types) {
+  const result = [];
+  for (const L of types)
+    result.push(KeyOfPropertyKeys(L));
+  return result;
+}
+function FromIntersect(types) {
+  const propertyKeysArray = FromRest(types);
+  const propertyKeys = SetUnionMany(propertyKeysArray);
+  return propertyKeys;
+}
+function FromUnion(types) {
+  const propertyKeysArray = FromRest(types);
+  const propertyKeys = SetIntersectMany(propertyKeysArray);
+  return propertyKeys;
+}
+function FromTuple(types) {
+  return types.map((_, indexer) => indexer.toString());
+}
+function FromArray(_) {
+  return ["[number]"];
+}
+function FromProperties(T) {
+  return globalThis.Object.getOwnPropertyNames(T);
+}
+function FromPatternProperties(patternProperties) {
+  return [];
+}
+function KeyOfPropertyKeys(type) {
+  return IsIntersect(type) ? FromIntersect(type.allOf) : IsUnion(type) ? FromUnion(type.anyOf) : IsTuple(type) ? FromTuple(type.items ?? []) : IsArray(type) ? FromArray(type.items) : IsObject(type) ? FromProperties(type.properties) : IsRecord(type) ? FromPatternProperties(type.patternProperties) : [];
+}
+export {
+  KeyOfPropertyKeys
+};

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

@@ -0,0 +1,31 @@
+import { CreateType } from "../create/type.js";
+import { KeyOfPropertyKeys } from "./keyof-property-keys.js";
+import { KeyOfFromMappedResult } from "./keyof-from-mapped-result.js";
+import { IsComputed, IsRef, IsMappedResult } from "../guard/kind.js";
+import { Computed } from "../computed/computed.js";
+import { Ref } from "../ref/ref.js";
+import { UnionEvaluated } from "../union/union-evaluated.js";
+import { Number } from "../number/number.js";
+import { Literal } from "../literal/literal.js";
+function FromComputed(target, parameters) {
+  return Computed("KeyOf", [Computed(target, parameters)]);
+}
+function FromRef($ref) {
+  return Computed("KeyOf", [Ref($ref)]);
+}
+function KeyOfFromType(type, options) {
+  const propertyKeys = KeyOfPropertyKeys(type);
+  const propertyKeyTypes = KeyOfPropertyKeysToRest(propertyKeys);
+  const result = UnionEvaluated(propertyKeyTypes);
+  return CreateType(result, options);
+}
+function KeyOfPropertyKeysToRest(propertyKeys) {
+  return propertyKeys.map((L) => L === "[number]" ? Number() : Literal(L));
+}
+function KeyOf(type, options) {
+  return IsComputed(type) ? FromComputed(type.target, type.parameters) : IsRef(type) ? FromRef(type.$ref) : IsMappedResult(type) ? KeyOfFromMappedResult(type, options) : KeyOfFromType(type, options);
+}
+export {
+  KeyOf,
+  KeyOfPropertyKeysToRest
+};

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

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

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

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

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

@@ -0,0 +1,76 @@
+import { MappedResult } from "./mapped-result.js";
+import { IsSchema, IsOptional, IsReadonly, IsMappedResult, IsMappedKey, IsConstructor, IsFunction, IsAsyncIterator, IsIterator, IsIntersect, IsUnion, IsTuple, IsObject, IsArray, IsPromise } from "../guard/kind.js";
+import { IndexPropertyKeys } from "../indexed/indexed-property-keys.js";
+import { Kind, OptionalKind, ReadonlyKind } from "../symbols/symbols.js";
+import { Object as Object$1 } from "../object/object.js";
+import { Optional } from "../optional/optional.js";
+import { Discard } from "../discard/discard.js";
+import { Readonly } from "../readonly/readonly.js";
+import { Constructor } from "../constructor/constructor.js";
+import { Function } from "../function/function.js";
+import { AsyncIterator } from "../async-iterator/async-iterator.js";
+import { Iterator } from "../iterator/iterator.js";
+import { Intersect } from "../intersect/intersect.js";
+import { Union } from "../union/union.js";
+import { Tuple } from "../tuple/tuple.js";
+import { Array } from "../array/array.js";
+import { Promise as Promise$1 } from "../promise/promise.js";
+import { SetIncludes } from "../sets/set.js";
+import { Literal } from "../literal/literal.js";
+function FromMappedResult(K, P) {
+  return K in P ? FromSchemaType(K, P[K]) : MappedResult(P);
+}
+function MappedKeyToKnownMappedResultProperties(K) {
+  return { [K]: Literal(K) };
+}
+function MappedKeyToUnknownMappedResultProperties(P) {
+  const Acc = {};
+  for (const L of P)
+    Acc[L] = Literal(L);
+  return Acc;
+}
+function MappedKeyToMappedResultProperties(K, P) {
+  return SetIncludes(P, K) ? MappedKeyToKnownMappedResultProperties(K) : MappedKeyToUnknownMappedResultProperties(P);
+}
+function FromMappedKey(K, P) {
+  const R = MappedKeyToMappedResultProperties(K, P);
+  return FromMappedResult(K, R);
+}
+function FromRest(K, T) {
+  return T.map((L) => FromSchemaType(K, L));
+}
+function FromProperties(K, T) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(T))
+    Acc[K2] = FromSchemaType(K, T[K2]);
+  return Acc;
+}
+function FromSchemaType(K, T) {
+  const options = { ...T };
+  return (
+    // unevaluated modifier types
+    IsOptional(T) ? Optional(FromSchemaType(K, Discard(T, [OptionalKind]))) : IsReadonly(T) ? Readonly(FromSchemaType(K, Discard(T, [ReadonlyKind]))) : (
+      // unevaluated mapped types
+      IsMappedResult(T) ? FromMappedResult(K, T.properties) : IsMappedKey(T) ? FromMappedKey(K, T.keys) : (
+        // unevaluated types
+        IsConstructor(T) ? Constructor(FromRest(K, T.parameters), FromSchemaType(K, T.returns), options) : IsFunction(T) ? Function(FromRest(K, T.parameters), FromSchemaType(K, T.returns), options) : IsAsyncIterator(T) ? AsyncIterator(FromSchemaType(K, T.items), options) : IsIterator(T) ? Iterator(FromSchemaType(K, T.items), options) : IsIntersect(T) ? Intersect(FromRest(K, T.allOf), options) : IsUnion(T) ? Union(FromRest(K, T.anyOf), options) : IsTuple(T) ? Tuple(FromRest(K, T.items ?? []), options) : IsObject(T) ? Object$1(FromProperties(K, T.properties), options) : IsArray(T) ? Array(FromSchemaType(K, T.items), options) : IsPromise(T) ? Promise$1(FromSchemaType(K, T.item), options) : T
+      )
+    )
+  );
+}
+function MappedFunctionReturnType(K, T) {
+  const Acc = {};
+  for (const L of K)
+    Acc[L] = FromSchemaType(L, T);
+  return Acc;
+}
+function Mapped(key, map, options) {
+  const K = IsSchema(key) ? IndexPropertyKeys(key) : key;
+  const RT = map({ [Kind]: "MappedKey", keys: K });
+  const R = MappedFunctionReturnType(K, RT);
+  return Object$1(R, options);
+}
+export {
+  Mapped,
+  MappedFunctionReturnType
+};

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

@@ -0,0 +1,122 @@
+import { IsOptional, IsReadonly, IsTransform, IsArray, IsAsyncIterator, IsComputed, IsConstructor, IsFunction, IsIntersect, IsIterator, IsObject, IsRecord, IsTuple, IsUnion, IsRef } from "../guard/kind.js";
+import { Never } from "../never/never.js";
+import { CreateType } from "../create/type.js";
+import { Discard } from "../discard/discard.js";
+import { OptionalKind, ReadonlyKind, TransformKind } from "../symbols/symbols.js";
+import { Array } from "../array/array.js";
+import { AsyncIterator } from "../async-iterator/async-iterator.js";
+import { Constructor } from "../constructor/constructor.js";
+import { Function } from "../function/function.js";
+import { Intersect } from "../intersect/intersect.js";
+import { Iterator } from "../iterator/iterator.js";
+import { Object as Object$1 } from "../object/object.js";
+import { RecordValue, RecordPattern } from "../record/record.js";
+import { CloneType } from "../clone/type.js";
+import { Tuple } from "../tuple/tuple.js";
+import { Union } from "../union/union.js";
+import { Awaited } from "../awaited/awaited.js";
+import { Index } from "../indexed/indexed.js";
+import { KeyOf } from "../keyof/keyof.js";
+import { Partial } from "../partial/partial.js";
+import { Omit } from "../omit/omit.js";
+import { Pick } from "../pick/pick.js";
+import { Required } from "../required/required.js";
+function DereferenceParameters(moduleProperties, types) {
+  return types.map((type) => {
+    return IsRef(type) ? Dereference(moduleProperties, type.$ref) : FromType(moduleProperties, type);
+  });
+}
+function Dereference(moduleProperties, ref) {
+  return ref in moduleProperties ? IsRef(moduleProperties[ref]) ? Dereference(moduleProperties, moduleProperties[ref].$ref) : FromType(moduleProperties, moduleProperties[ref]) : Never();
+}
+function FromAwaited(parameters) {
+  return Awaited(parameters[0]);
+}
+function FromIndex(parameters) {
+  return Index(parameters[0], parameters[1]);
+}
+function FromKeyOf(parameters) {
+  return KeyOf(parameters[0]);
+}
+function FromPartial(parameters) {
+  return Partial(parameters[0]);
+}
+function FromOmit(parameters) {
+  return Omit(parameters[0], parameters[1]);
+}
+function FromPick(parameters) {
+  return Pick(parameters[0], parameters[1]);
+}
+function FromRequired(parameters) {
+  return Required(parameters[0]);
+}
+function FromComputed(moduleProperties, target, parameters) {
+  const dereferenced = DereferenceParameters(moduleProperties, parameters);
+  return target === "Awaited" ? FromAwaited(dereferenced) : target === "Index" ? FromIndex(dereferenced) : target === "KeyOf" ? FromKeyOf(dereferenced) : target === "Partial" ? FromPartial(dereferenced) : target === "Omit" ? FromOmit(dereferenced) : target === "Pick" ? FromPick(dereferenced) : target === "Required" ? FromRequired(dereferenced) : Never();
+}
+function FromArray(moduleProperties, type) {
+  return Array(FromType(moduleProperties, type));
+}
+function FromAsyncIterator(moduleProperties, type) {
+  return AsyncIterator(FromType(moduleProperties, type));
+}
+function FromConstructor(moduleProperties, parameters, instanceType) {
+  return Constructor(FromTypes(moduleProperties, parameters), FromType(moduleProperties, instanceType));
+}
+function FromFunction(moduleProperties, parameters, returnType) {
+  return Function(FromTypes(moduleProperties, parameters), FromType(moduleProperties, returnType));
+}
+function FromIntersect(moduleProperties, types) {
+  return Intersect(FromTypes(moduleProperties, types));
+}
+function FromIterator(moduleProperties, type) {
+  return Iterator(FromType(moduleProperties, type));
+}
+function FromObject(moduleProperties, properties) {
+  return Object$1(globalThis.Object.keys(properties).reduce((result, key) => {
+    return { ...result, [key]: FromType(moduleProperties, properties[key]) };
+  }, {}));
+}
+function FromRecord(moduleProperties, type) {
+  const [value, pattern] = [FromType(moduleProperties, RecordValue(type)), RecordPattern(type)];
+  const result = CloneType(type);
+  result.patternProperties[pattern] = value;
+  return result;
+}
+function FromTransform(moduleProperties, transform) {
+  return IsRef(transform) ? { ...Dereference(moduleProperties, transform.$ref), [TransformKind]: transform[TransformKind] } : transform;
+}
+function FromTuple(moduleProperties, types) {
+  return Tuple(FromTypes(moduleProperties, types));
+}
+function FromUnion(moduleProperties, types) {
+  return Union(FromTypes(moduleProperties, types));
+}
+function FromTypes(moduleProperties, types) {
+  return types.map((type) => FromType(moduleProperties, type));
+}
+function FromType(moduleProperties, type) {
+  return (
+    // Modifiers
+    IsOptional(type) ? CreateType(FromType(moduleProperties, Discard(type, [OptionalKind])), type) : IsReadonly(type) ? CreateType(FromType(moduleProperties, Discard(type, [ReadonlyKind])), type) : (
+      // Transform
+      IsTransform(type) ? CreateType(FromTransform(moduleProperties, type), type) : (
+        // Types
+        IsArray(type) ? CreateType(FromArray(moduleProperties, type.items), type) : IsAsyncIterator(type) ? CreateType(FromAsyncIterator(moduleProperties, type.items), type) : IsComputed(type) ? CreateType(FromComputed(moduleProperties, type.target, type.parameters)) : IsConstructor(type) ? CreateType(FromConstructor(moduleProperties, type.parameters, type.returns), type) : IsFunction(type) ? CreateType(FromFunction(moduleProperties, type.parameters, type.returns), type) : IsIntersect(type) ? CreateType(FromIntersect(moduleProperties, type.allOf), type) : IsIterator(type) ? CreateType(FromIterator(moduleProperties, type.items), type) : IsObject(type) ? CreateType(FromObject(moduleProperties, type.properties), type) : IsRecord(type) ? CreateType(FromRecord(moduleProperties, type)) : IsTuple(type) ? CreateType(FromTuple(moduleProperties, type.items || []), type) : IsUnion(type) ? CreateType(FromUnion(moduleProperties, type.anyOf), type) : type
+      )
+    )
+  );
+}
+function ComputeType(moduleProperties, key) {
+  return key in moduleProperties ? FromType(moduleProperties, moduleProperties[key]) : Never();
+}
+function ComputeModuleProperties(moduleProperties) {
+  return globalThis.Object.getOwnPropertyNames(moduleProperties).reduce((result, key) => {
+    return { ...result, [key]: ComputeType(moduleProperties, key) };
+  }, {});
+}
+export {
+  ComputeModuleProperties,
+  ComputeType,
+  FromType
+};

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

@@ -0,0 +1,28 @@
+import { ComputeModuleProperties } from "./compute.js";
+import { CreateType } from "../create/type.js";
+import { Kind } from "../symbols/symbols.js";
+class TModule {
+  constructor($defs) {
+    const computed = ComputeModuleProperties($defs);
+    const identified = this.WithIdentifiers(computed);
+    this.$defs = identified;
+  }
+  /** `[Json]` Imports a Type by Key. */
+  Import(key, options) {
+    const $defs = { ...this.$defs, [key]: CreateType(this.$defs[key], options) };
+    return CreateType({ [Kind]: "Import", $defs, $ref: key });
+  }
+  // prettier-ignore
+  WithIdentifiers($defs) {
+    return globalThis.Object.getOwnPropertyNames($defs).reduce((result, key) => {
+      return { ...result, [key]: { ...$defs[key], $id: key } };
+    }, {});
+  }
+}
+function Module(properties) {
+  return new TModule(properties);
+}
+export {
+  Module,
+  TModule
+};

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

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

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

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