@openclaw/lobster 2026.5.20 → 2026.5.22

package/node_modules/typebox/build/value/repair/from_record.mjs

@@ -0,0 +1,33 @@
+// deno-fmt-ignore-file
+import { IsAdditionalProperties } from '../../schema/types/index.mjs';
+import { RecordValue, RecordPattern } from '../../type/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { Create } from '../create/index.mjs';
+import { Check } from '../check/index.mjs';
+import { FromType } from './from_type.mjs';
+export function FromRecord(context, type, value) {
+    if (Check(context, type, value))
+        return value;
+    if (Guard.IsNull(value) || !Guard.IsObject(value) || Guard.IsArray(value))
+        return Create(context, type);
+    const recordKey = new RegExp(RecordPattern(type));
+    const recordValue = RecordValue(type);
+    const evaluatedKeys = new Set();
+    // PatternProperties
+    const result = {};
+    for (const [key, value_] of Guard.Entries(value)) {
+        if (!recordKey.test(key))
+            continue;
+        result[key] = FromType(context, recordValue, value_);
+        evaluatedKeys.add(key);
+    }
+    // AdditionalProperties
+    if (IsAdditionalProperties(type)) {
+        for (const key of Guard.Keys(value)) {
+            if (evaluatedKeys.has(key))
+                continue;
+            result[key] = FromType(context, type.additionalProperties, value[key]);
+        }
+    }
+    return result;
+}

package/node_modules/typebox/build/value/repair/from_ref.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, TRef } from '../../type/index.mjs';
+export declare function FromRef(context: TProperties, type: TRef, value: unknown): unknown;

package/node_modules/typebox/build/value/repair/from_ref.mjs

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { FromType } from './from_type.mjs';
+import { RepairError } from './error.mjs';
+export function FromRef(context, type, value) {
+    return Guard.HasPropertyKey(context, type.$ref)
+        ? FromType(context, context[type.$ref], value)
+        : (() => { throw new RepairError(context, type, value, 'Unable to de-reference target type'); })();
+}

package/node_modules/typebox/build/value/repair/from_template_literal.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, TTemplateLiteral } from '../../type/index.mjs';
+export declare function FromTemplateLiteral(context: TProperties, type: TTemplateLiteral, value: unknown): unknown;

package/node_modules/typebox/build/value/repair/from_template_literal.mjs

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { TemplateLiteralDecode } from '../../type/engine/template_literal/index.mjs';
+import { FromType } from './from_type.mjs';
+export function FromTemplateLiteral(context, type, value) {
+    const decoded = TemplateLiteralDecode(type.pattern);
+    return FromType(context, decoded, value);
+}

package/node_modules/typebox/build/value/repair/from_tuple.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, TTuple } from '../../type/index.mjs';
+export declare function FromTuple(context: TProperties, schema: TTuple, value: unknown): unknown;

package/node_modules/typebox/build/value/repair/from_tuple.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Check } from '../check/index.mjs';
+import { Create } from '../create/index.mjs';
+import { FromType } from './from_type.mjs';
+export function FromTuple(context, schema, value) {
+    if (Check(context, schema, value))
+        return value;
+    if (!Guard.IsArray(value))
+        return Create(context, schema);
+    return schema.items.map((schema, index) => FromType(context, schema, value[index]));
+}

package/node_modules/typebox/build/value/repair/from_type.d.mts

@@ -0,0 +1,2 @@
+import * as T from '../../type/index.mjs';
+export declare function FromType(context: T.TProperties, type: T.TSchema, value: unknown): unknown;

package/node_modules/typebox/build/value/repair/from_type.mjs

@@ -0,0 +1,86 @@
+// deno-fmt-ignore-file
+import { Guard, GlobalsGuard } from '../../guard/index.mjs';
+import * as T from '../../type/index.mjs';
+import { Check } from '../check/index.mjs';
+import { Create } from '../create/index.mjs';
+import { FromArray } from './from_array.mjs';
+import { FromBase } from './from_base.mjs';
+import { FromEnum } from './from_enum.mjs';
+import { FromIntersect } from './from_intersect.mjs';
+import { FromObject } from './from_object.mjs';
+import { FromRecord } from './from_record.mjs';
+import { FromRef } from './from_ref.mjs';
+import { FromTemplateLiteral } from './from_template_literal.mjs';
+import { FromTuple } from './from_tuple.mjs';
+import { FromUnion } from './from_union.mjs';
+import { FromUnknown } from './from_unknown.mjs';
+import { RepairError } from './error.mjs';
+// ------------------------------------------------------------------
+// AssertRepairableValue
+// ------------------------------------------------------------------
+function AssertRepairableValue(context, type, value) {
+    const unsupported = GlobalsGuard.IsDate(value)
+        || GlobalsGuard.IsMap(value)
+        || GlobalsGuard.IsSet(value)
+        || GlobalsGuard.IsTypeArray(value)
+        || Guard.IsConstructor(value)
+        || Guard.IsFunction(value);
+    if (unsupported) {
+        throw new RepairError(context, type, value, 'Value is not repairable');
+    }
+}
+// ------------------------------------------------------------------
+// AssertRepairableType
+// ------------------------------------------------------------------
+function AssertRepairableType(context, type, value) {
+    const unsupported = T.IsAsyncIterator(type)
+        || T.IsIterator(type)
+        || T.IsConstructor(type)
+        || T.IsFunction(type)
+        || T.IsNever(type)
+        || T.IsPromise(type);
+    if (unsupported) {
+        throw new RepairError(context, type, value, 'Type is not repairable');
+    }
+}
+// ------------------------------------------------------------------
+// FinalizeRepair
+//
+// When a type includes the ~refine modifier, a post-repair validation
+// check must be performed to ensure the repaired value satisfies the
+// refine constraint. This logic is implemented as part of FromType to
+// ensure the post-refine validation check is handled outside of
+// sub-schema constraint checking (i.e., at the top level).
+//
+// ------------------------------------------------------------------
+function FinalizeRepair(context, type, repaired) {
+    return T.IsRefine(type)
+        ? Check(context, type, repaired)
+            ? repaired
+            : Create(context, type)
+        : repaired;
+}
+// ------------------------------------------------------------------
+// FromType
+// ------------------------------------------------------------------
+export function FromType(context, type, value) {
+    // Base Repair
+    if (T.IsBase(type)) {
+        const repaired = FromBase(context, type, value);
+        return FinalizeRepair(context, type, repaired);
+    }
+    // Schema Repair
+    AssertRepairableValue(context, type, value);
+    AssertRepairableType(context, type, value);
+    const repaired = (T.IsArray(type) ? FromArray(context, type, value) :
+        T.IsEnum(type) ? FromEnum(context, type, value) :
+            T.IsIntersect(type) ? FromIntersect(context, type, value) :
+                T.IsObject(type) ? FromObject(context, type, value) :
+                    T.IsRecord(type) ? FromRecord(context, type, value) :
+                        T.IsRef(type) ? FromRef(context, type, value) :
+                            T.IsTemplateLiteral(type) ? FromTemplateLiteral(context, type, value) :
+                                T.IsTuple(type) ? FromTuple(context, type, value) :
+                                    T.IsUnion(type) ? FromUnion(context, type, value) :
+                                        FromUnknown(context, type, value));
+    return FinalizeRepair(context, type, repaired);
+}

package/node_modules/typebox/build/value/repair/from_union.d.mts

@@ -0,0 +1,2 @@
+import { type TProperties, type TUnion } from '../../type/index.mjs';
+export declare function FromUnion(context: TProperties, type: TUnion, value: unknown): unknown;

package/node_modules/typebox/build/value/repair/from_union.mjs

@@ -0,0 +1,24 @@
+// deno-fmt-ignore-file
+import { IsDefault } from '../../schema/types/index.mjs';
+import { Union } from '../../type/index.mjs';
+import { Flatten } from '../../type/engine/evaluate/index.mjs';
+import { Check } from '../check/index.mjs';
+import { Clone } from '../clone/index.mjs';
+import { Create } from '../create/index.mjs';
+import { FromType } from './from_type.mjs';
+import { UnionScoreSelect } from '../shared/union_score_select.mjs';
+// ------------------------------------------------------------------
+// RepairUnion
+// ------------------------------------------------------------------
+function RepairUnion(context, type, value) {
+    const union = Union(Flatten(type.anyOf));
+    const schema = UnionScoreSelect(context, union, value);
+    return FromType(context, schema, value);
+}
+export function FromUnion(context, type, value) {
+    if (Check(context, type, value))
+        return Clone(value);
+    if (IsDefault(type))
+        return Create(context, type);
+    return RepairUnion(context, type, value);
+}

package/node_modules/typebox/build/value/repair/from_unknown.d.mts

@@ -0,0 +1,2 @@
+import type { TProperties, TSchema } from '../../type/index.mjs';
+export declare function FromUnknown(context: TProperties, type: TSchema, value: unknown): unknown;

package/node_modules/typebox/build/value/repair/from_unknown.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Check } from '../check/index.mjs';
+import { Create } from '../create/index.mjs';
+import { Convert } from '../convert/index.mjs';
+export function FromUnknown(context, type, value) {
+    if (Check(context, type, value))
+        return value;
+    const converted = Convert(context, type, value);
+    if (Check(context, type, converted))
+        return converted;
+    return Create(context, type);
+}

package/node_modules/typebox/build/value/repair/index.d.mts

@@ -0,0 +1 @@
+export * from './repair.mjs';

package/node_modules/typebox/build/value/repair/index.mjs

@@ -0,0 +1 @@
+export * from './repair.mjs';

package/node_modules/typebox/build/value/repair/repair.d.mts

@@ -0,0 +1,17 @@
+import type { TProperties, TSchema, Static } from '../../type/index.mjs';
+/**
+ * Repairs a value to match the provided type. This function is intended for data migration
+ * scenarios where existing values need to be migrating to an updated type. This function will
+ * repair partially mismatched values by populating missing sub-properties and elements with
+ * default structures derived from the type. If the value already conforms to the type, no
+ * action is performed.
+ */
+export declare function Repair<const Type extends TSchema>(type: Type, value: unknown): Static<Type>;
+/**
+ * Repairs a value to match the provided type. This function is intended for data migration
+ * scenarios where existing values need to be migrating to an updated type. This function will
+ * repair partially mismatched values by populating missing sub-properties and elements with
+ * default structures derived from the type. If the value already conforms to the type, no
+ * action is performed.
+ */
+export declare function Repair<Context extends TProperties, const Type extends TSchema>(context: Context, type: Type, value: unknown): Static<Type, Context>;

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

@@ -0,0 +1,20 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../../system/arguments/index.mjs';
+import { FromType } from './from_type.mjs';
+import { Assert } from '../assert/index.mjs';
+/**
+ * Repairs a value to match the provided type. This function is intended for data migration
+ * scenarios where existing values need to be migrating to an updated type. This function will
+ * repair partially mismatched values by populating missing sub-properties and elements with
+ * default structures derived from the type. If the value already conforms to the type, no
+ * action is performed.
+ */
+export function Repair(...args) {
+    const [context, type, value] = Arguments.Match(args, {
+        3: (context, type, value) => [context, type, value],
+        2: (type, value) => [{}, type, value],
+    });
+    const repaired = FromType(context, type, value);
+    Assert(context, type, repaired);
+    return repaired;
+}

package/node_modules/typebox/build/value/shared/index.d.mts

@@ -0,0 +1,3 @@
+export * from './optional_undefined.mjs';
+export * from './union_priority_sort.mjs';
+export * from './union_score_select.mjs';

package/node_modules/typebox/build/value/shared/index.mjs

@@ -0,0 +1,4 @@
+// deno-fmt-ignore-file
+export * from './optional_undefined.mjs';
+export * from './union_priority_sort.mjs';
+export * from './union_score_select.mjs';

package/node_modules/typebox/build/value/shared/optional_undefined.d.mts

@@ -0,0 +1,2 @@
+import { type TSchema } from '../../type/index.mjs';
+export declare function IsOptionalUndefined(property: TSchema, key: PropertyKey, value: Record<PropertyKey, unknown>): boolean;

package/node_modules/typebox/build/value/shared/optional_undefined.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsOptional } from '../../type/index.mjs';
+// ------------------------------------------------------------------
+// IsOptionalUndefined
+//
+// Indicates whether a key should be excluded from processing when it is 
+// defined as optional in the schema and its corresponding value is undefined. 
+// This case cannot be reliably distinguished from an omitted key, and therefore 
+// introduces ambiguity between a key that is not provided and one that is 
+// explicitly assigned an undefined value.
+// ------------------------------------------------------------------
+export function IsOptionalUndefined(property, key, value) {
+    return IsOptional(property) && Guard.IsUndefined(value[key]);
+}

package/node_modules/typebox/build/value/shared/union_priority_sort.d.mts

@@ -0,0 +1,3 @@
+import { type TSchema } from '../../type/index.mjs';
+/** Deterministically sorts schemas by structural relationship (narrow to broad) */
+export declare function UnionPrioritySort(types: TSchema[], order?: number): TSchema[];

package/node_modules/typebox/build/value/shared/union_priority_sort.mjs

@@ -0,0 +1,36 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Compare } from '../../type/index.mjs';
+// ------------------------------------------------------------------
+// DeterministicCompare
+//
+// Provides a deterministic tie-break for schemas. This is used when
+// schemas are structurally disjoint or mutually inclusive. While
+// JSON serialization incurs a performance overhead, it serves as a
+// reliable mechanism to ensure stable ordering and preserves the
+// alphabetical alignment of named constants.
+//
+// ------------------------------------------------------------------
+function DeterministicCompare(left, right) {
+    return JSON.stringify(left).localeCompare(JSON.stringify(right));
+}
+// ------------------------------------------------------------------
+// UnionPrioritySort
+//
+// Performs a deterministic sort on Union members. By default, this
+// function ensures that narrow (more specific) types precede broader
+// types in the resulting array. The order can be reversed by setting
+// the order property to -1 which will reverse unions from broader
+// to more narrow.
+//
+// ------------------------------------------------------------------
+/** Deterministically sorts schemas by structural relationship (narrow to broad) */
+export function UnionPrioritySort(types, order = 1) {
+    return types.sort((left, right) => {
+        const result = Compare(left, right);
+        return (Guard.IsEqual(result, 'disjoint') ? DeterministicCompare(left, right) :
+            Guard.IsEqual(result, 'right-inside') ? 1 :
+                Guard.IsEqual(result, 'left-inside') ? -1 :
+                    DeterministicCompare(left, right)) * order;
+    });
+}

package/node_modules/typebox/build/value/shared/union_score_select.d.mts

@@ -0,0 +1,3 @@
+import { type TProperties, type TSchema, type TUnion } from '../../type/index.mjs';
+/** Scores Union variants and returns the best match for the given value */
+export declare function UnionScoreSelect(context: TProperties, type: TUnion, value: unknown): TSchema;

package/node_modules/typebox/build/value/shared/union_score_select.mjs

@@ -0,0 +1,51 @@
+// deno-fmt-ignore-file
+import { IsLiteral, IsObject, IsRef } from '../../type/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { Check } from '../check/index.mjs';
+// ------------------------------------------------------------------
+// Deref
+// ------------------------------------------------------------------
+function Deref(context, type, value) {
+    return IsRef(type)
+        ? Guard.HasPropertyKey(context, type.$ref)
+            ? Deref(context, context[type.$ref], value)
+            : (() => { throw new Error('Unable to Deref target'); })()
+        : type;
+}
+// ------------------------------------------------------------------
+// The following will score a schema against a value. For objects,
+// the score is the tally of points awarded for each property of
+// the value. Property points are (1.0 / propertyCount) to prevent
+// large property counts biasing results. Properties that match
+// literal values are maximally awarded as literals are typically
+// used as union discriminator fields.
+// ------------------------------------------------------------------
+function ScoreVariant(context, type, value) {
+    // scoring is only possible for object types.
+    if (!(IsObject(type) && Guard.IsObject(value)))
+        return 0;
+    const keys = Guard.Keys(value);
+    const entries = Guard.Entries(type.properties);
+    return entries.reduce((result, [key, schema]) => {
+        const literal = IsLiteral(schema) && Guard.IsEqual(schema.const, value[key]) ? 100 : 0;
+        const checks = Check(context, schema, value[key]) ? 10 : 0;
+        const exists = keys.includes(key) ? 1 : 0;
+        return result + (literal + checks + exists);
+    }, 0);
+}
+// ------------------------------------------------------------------
+// UnionScoreSelect
+// ------------------------------------------------------------------
+/** Scores Union variants and returns the best match for the given value */
+export function UnionScoreSelect(context, type, value) {
+    const schemas = type.anyOf.map((schema) => Deref(context, schema, value));
+    let [select, best] = [schemas[0], 0];
+    for (const schema of schemas) {
+        const score = ScoreVariant(context, schema, value);
+        if (score > best) {
+            select = schema;
+            best = score;
+        }
+    }
+    return select;
+}

package/node_modules/typebox/build/value/value.d.mts

@@ -0,0 +1,16 @@
+export { Assert } from './assert/index.mjs';
+export { Check } from './check/index.mjs';
+export { Clean } from './clean/index.mjs';
+export { Clone } from './clone/index.mjs';
+export { Decode, Encode, HasCodec } from './codec/index.mjs';
+export { Convert } from './convert/index.mjs';
+export { Create } from './create/index.mjs';
+export { Default } from './default/index.mjs';
+export { Equal } from './equal/index.mjs';
+export { Errors } from './errors/index.mjs';
+export { Hash } from './hash/index.mjs';
+export { Mutate, type TMutable } from './mutate/index.mjs';
+export { Parse } from './parse/index.mjs';
+export { Diff, Patch } from './delta/index.mjs';
+export { Pointer } from './pointer/index.mjs';
+export { Repair } from './repair/index.mjs';

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

@@ -0,0 +1,16 @@
+export { Assert } from './assert/index.mjs';
+export { Check } from './check/index.mjs';
+export { Clean } from './clean/index.mjs';
+export { Clone } from './clone/index.mjs';
+export { Decode, Encode, HasCodec } from './codec/index.mjs';
+export { Convert } from './convert/index.mjs';
+export { Create } from './create/index.mjs';
+export { Default } from './default/index.mjs';
+export { Equal } from './equal/index.mjs';
+export { Errors } from './errors/index.mjs';
+export { Hash } from './hash/index.mjs';
+export { Mutate } from './mutate/index.mjs';
+export { Parse } from './parse/index.mjs';
+export { Diff, Patch } from './delta/index.mjs';
+export { Pointer } from './pointer/index.mjs';
+export { Repair } from './repair/index.mjs';

package/node_modules/typebox/license

@@ -0,0 +1,23 @@
+TypeBox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2026 Haydn Paterson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/node_modules/typebox/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "typebox",
+  "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
+  "version": "1.1.38",
+  "keywords": [
+    "typescript",
+    "jsonschema"
+  ],
+  "license": "MIT",
+  "author": "sinclairzx81",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sinclairzx81/typebox"
+  },
+  "type": "module",
+  "types": "./build/index.d.mts",
+  "module": "./build/index.mjs",
+  "exports": {
+    "./guard": {
+      "import": "./build/guard/index.mjs",
+      "default": "./build/guard/index.mjs"
+    },
+    "./error": {
+      "import": "./build/error/index.mjs",
+      "default": "./build/error/index.mjs"
+    },
+    "./compile": {
+      "import": "./build/compile/index.mjs",
+      "default": "./build/compile/index.mjs"
+    },
+    "./system": {
+      "import": "./build/system/index.mjs",
+      "default": "./build/system/index.mjs"
+    },
+    "./format": {
+      "import": "./build/format/index.mjs",
+      "default": "./build/format/index.mjs"
+    },
+    "./type": {
+      "import": "./build/type/index.mjs",
+      "default": "./build/type/index.mjs"
+    },
+    "./schema": {
+      "import": "./build/schema/index.mjs",
+      "default": "./build/schema/index.mjs"
+    },
+    "./value": {
+      "import": "./build/value/index.mjs",
+      "default": "./build/value/index.mjs"
+    },
+    ".": {
+      "import": "./build/index.mjs",
+      "default": "./build/index.mjs"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "guard": [
+        "./build/guard/index.d.mts"
+      ],
+      "error": [
+        "./build/error/index.d.mts"
+      ],
+      "compile": [
+        "./build/compile/index.d.mts"
+      ],
+      "system": [
+        "./build/system/index.d.mts"
+      ],
+      "format": [
+        "./build/format/index.d.mts"
+      ],
+      "type": [
+        "./build/type/index.d.mts"
+      ],
+      "schema": [
+        "./build/schema/index.d.mts"
+      ],
+      "value": [
+        "./build/value/index.d.mts"
+      ],
+      ".": [
+        "./build/index.d.mts"
+      ]
+    }
+  }
+}