@openclaw/lobster 2026.5.20 → 2026.5.22

package/node_modules/typebox/build/type/extends/integer.mjs

@@ -0,0 +1,10 @@
+// deno-fmt-ignore-file
+import { IsInteger } from '../types/integer.mjs';
+import { IsNumber } from '../types/number.mjs';
+import { ExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+export function ExtendsInteger(inferred, left, right) {
+    return (IsInteger(right) ? Result.ExtendsTrue(inferred) :
+        IsNumber(right) ? Result.ExtendsTrue(inferred) :
+            ExtendsRight(inferred, left, right));
+}

package/node_modules/typebox/build/type/extends/intersect.d.mts

@@ -0,0 +1,6 @@
+import { type TProperties } from '../types/properties.mjs';
+import { type TSchema } from '../types/schema.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import { type TEvaluateIntersect } from '../engine/evaluate/index.mjs';
+export type TExtendsIntersect<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, Evaluated extends TSchema = TEvaluateIntersect<Left>> = TExtendsLeft<Inferred, Evaluated, Right>;
+export declare function ExtendsIntersect<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsIntersect<Inferred, Left, Right>;

package/node_modules/typebox/build/type/extends/intersect.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { ExtendsLeft } from './extends_left.mjs';
+// ----------------------------------------------------------------------------
+// ExtendsIntersect
+//
+// This function evaluates the intersection and continues. This is different
+// to IntersectRight which MUST enumerate each type to derive Inferred. Left 
+// side types do not infer so it should be ok to do this.
+//
+// ----------------------------------------------------------------------------
+import { EvaluateIntersect } from '../engine/evaluate/index.mjs';
+export function ExtendsIntersect(inferred, left, right) {
+    const evaluated = EvaluateIntersect(left);
+    return ExtendsLeft(inferred, evaluated, right);
+}

package/node_modules/typebox/build/type/extends/iterator.d.mts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TIterator } from '../types/iterator.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+export type TExtendsIterator<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TIterator<infer Type extends TSchema> ? TExtendsLeft<Inferred, Left, Type> : TExtendsRight<Inferred, TIterator<Left>, Right>);
+export declare function ExtendsIterator<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsIterator<Inferred, Left, Right>;

package/node_modules/typebox/build/type/extends/iterator.mjs

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { Iterator, IsIterator } from '../types/iterator.mjs';
+import { ExtendsRight } from './extends_right.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
+export function ExtendsIterator(inferred, left, right) {
+    return (IsIterator(right)
+        ? ExtendsLeft(inferred, left, right.iteratorItems)
+        : ExtendsRight(inferred, Iterator(left), right));
+}

package/node_modules/typebox/build/type/extends/literal.d.mts

@@ -0,0 +1,18 @@
+import { type TUnreachable } from '../../system/unreachable/unreachable.mjs';
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TLiteral, type TLiteralValue } from '../types/literal.mjs';
+import { type TBigInt } from '../types/bigint.mjs';
+import { type TBoolean } from '../types/boolean.mjs';
+import { type TNumber } from '../types/number.mjs';
+import { type TString } from '../types/string.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+type TExtendsLiteralValue<Inferred extends TProperties, Left extends TLiteralValue, Right extends TLiteralValue> = (Left extends Right ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
+type TExtendsLiteralBigInt<Inferred extends TProperties, Left extends bigint, Right extends TSchema> = (Right extends TLiteral<infer Value extends bigint> ? TExtendsLiteralValue<Inferred, Left, Value> : Right extends TBigInt ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, TLiteral<Left>, Right>);
+type TExtendsLiteralBoolean<Inferred extends TProperties, Left extends boolean, Right extends TSchema> = (Right extends TLiteral<infer Value extends boolean> ? TExtendsLiteralValue<Inferred, Left, Value> : Right extends TBoolean ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, TLiteral<Left>, Right>);
+type TExtendsLiteralNumber<Inferred extends TProperties, Left extends number, Right extends TSchema> = (Right extends TLiteral<infer Value extends number> ? TExtendsLiteralValue<Inferred, Left, Value> : Right extends TNumber ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, TLiteral<Left>, Right>);
+type TExtendsLiteralString<Inferred extends TProperties, Left extends string, Right extends TSchema> = (Right extends TLiteral<infer Value extends string> ? TExtendsLiteralValue<Inferred, Left, Value> : Right extends TString ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, TLiteral<Left>, Right>);
+export type TExtendsLiteral<Inferred extends TProperties, Left extends TLiteral, Right extends TSchema> = (Left extends TLiteral<infer Value extends bigint> ? TExtendsLiteralBigInt<Inferred, Value, Right> : Left extends TLiteral<infer Value extends boolean> ? TExtendsLiteralBoolean<Inferred, Value, Right> : Left extends TLiteral<infer Value extends number> ? TExtendsLiteralNumber<Inferred, Value, Right> : Left extends TLiteral<infer Value extends string> ? TExtendsLiteralString<Inferred, Value, Right> : TUnreachable);
+export declare function ExtendsLiteral<Inferred extends TProperties, Left extends TLiteral, Right extends TSchema>(inferred: TProperties, left: Left, right: Right): TExtendsLiteral<Inferred, Left, Right>;
+export {};

package/node_modules/typebox/build/type/extends/literal.mjs

@@ -0,0 +1,44 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Unreachable } from '../../system/unreachable/unreachable.mjs';
+import { IsLiteral, Literal } from '../types/literal.mjs';
+import { IsBigInt } from '../types/bigint.mjs';
+import { IsBoolean } from '../types/boolean.mjs';
+import { IsNumber } from '../types/number.mjs';
+import { IsString } from '../types/string.mjs';
+import { ExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+function ExtendsLiteralValue(inferred, left, right) {
+    return (left === right
+        ? Result.ExtendsTrue(inferred)
+        : Result.ExtendsFalse());
+}
+function ExtendsLiteralBigInt(inferred, left, right) {
+    return (IsLiteral(right) ? ExtendsLiteralValue(inferred, left, right.const) :
+        IsBigInt(right) ? Result.ExtendsTrue(inferred) :
+            ExtendsRight(inferred, Literal(left), right));
+}
+function ExtendsLiteralBoolean(inferred, left, right) {
+    return (IsLiteral(right) ? ExtendsLiteralValue(inferred, left, right.const) :
+        IsBoolean(right) ? Result.ExtendsTrue(inferred) :
+            ExtendsRight(inferred, Literal(left), right));
+}
+function ExtendsLiteralNumber(inferred, left, right) {
+    return (IsLiteral(right) ? ExtendsLiteralValue(inferred, left, right.const) :
+        IsNumber(right) ? Result.ExtendsTrue(inferred) :
+            ExtendsRight(inferred, Literal(left), right));
+}
+function ExtendsLiteralString(inferred, left, right) {
+    return (IsLiteral(right) ? ExtendsLiteralValue(inferred, left, right.const) :
+        IsString(right) ? Result.ExtendsTrue(inferred) :
+            ExtendsRight(inferred, Literal(left), right));
+}
+export function ExtendsLiteral(inferred, left, right) {
+    return (Guard.IsBigInt(left.const) ? ExtendsLiteralBigInt(inferred, left.const, right) :
+        Guard.IsBoolean(left.const) ? ExtendsLiteralBoolean(inferred, left.const, right) :
+            Guard.IsNumber(left.const) ? ExtendsLiteralNumber(inferred, left.const, right) :
+                Guard.IsString(left.const) ? ExtendsLiteralString(inferred, left.const, right) :
+                    Unreachable() // ExtendsRight(inferred, left, right)
+    );
+}
+// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/extends/never.d.mts

@@ -0,0 +1,8 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TNever } from '../types/never.mjs';
+import { type TInfer } from '../types/infer.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+export type TExtendsNever<Inferred extends TProperties, Left extends TNever, Right extends TSchema> = (Right extends TInfer ? TExtendsRight<Inferred, Left, Right> : Result.TExtendsTrue<Inferred>);
+export declare function ExtendsNever<Inferred extends TProperties, Left extends TNever, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsNever<Inferred, Left, Right>;

package/node_modules/typebox/build/type/extends/never.mjs

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { IsInfer } from '../types/infer.mjs';
+import { ExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+export function ExtendsNever(inferred, left, right) {
+    return (IsInfer(right)
+        ? ExtendsRight(inferred, left, right)
+        : Result.ExtendsTrue(inferred));
+}

package/node_modules/typebox/build/type/extends/null.d.mts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TNull } from '../types/null.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+export type TExtendsNull<Inferred extends TProperties, Left extends TNull, Right extends TSchema> = (Right extends TNull ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, Left, Right>);
+export declare function ExtendsNull<Inferred extends TProperties, Left extends TNull, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsNull<Inferred, Left, Right>;

package/node_modules/typebox/build/type/extends/null.mjs

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { IsNull } from '../types/null.mjs';
+import { ExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+export function ExtendsNull(inferred, left, right) {
+    return (IsNull(right)
+        ? Result.ExtendsTrue(inferred)
+        : ExtendsRight(inferred, left, right));
+}

package/node_modules/typebox/build/type/extends/number.d.mts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TNumber } from '../types/number.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+export type TExtendsNumber<Inferred extends TProperties, Left extends TNumber, Right extends TSchema> = (Right extends TNumber ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, Left, Right>);
+export declare function ExtendsNumber<Inferred extends TProperties, Left extends TNumber, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsNumber<Inferred, Left, Right>;

package/node_modules/typebox/build/type/extends/number.mjs

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { IsNumber } from '../types/number.mjs';
+import { ExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+export function ExtendsNumber(inferred, left, right) {
+    return (IsNumber(right)
+        ? Result.ExtendsTrue(inferred)
+        : ExtendsRight(inferred, left, right));
+}

package/node_modules/typebox/build/type/extends/object.d.mts

@@ -0,0 +1,25 @@
+import { type TUnreachable } from '../../system/unreachable/index.mjs';
+import { Memory } from '../../system/memory/index.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TSchema } from '../types/schema.mjs';
+import { type TOptional } from '../types/_optional.mjs';
+import { type TInfer } from '../types/infer.mjs';
+import { type TNever } from '../types/never.mjs';
+import { type TObject } from '../types/object.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import { type TUnionToTuple } from '../engine/helpers/union.mjs';
+import * as Result from './result.mjs';
+type TExtendsPropertyOptional<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Left extends TOptional<Left> ? Right extends TOptional<Right> ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse : Result.TExtendsTrue<Inferred>);
+type TExtendsProperty<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TInfer<string, TNever> ? Result.TExtendsFalse : TExtendsLeft<Inferred, Left, Right> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsPropertyOptional<Inferred, Left, Right> : Result.TExtendsFalse);
+type TExtractInferredProperties<Keys extends PropertyKey[], Properties extends Record<PropertyKey, Result.TResult>, Result extends TProperties = {}> = (Keys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? Left extends keyof Properties ? Properties[Left] extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtractInferredProperties<Right, Properties, Result & Inferred> : TExtractInferredProperties<Right, Properties, Result> : TUnreachable : Result);
+type TExtendsPropertiesComparer<Inferred extends TProperties, Left extends TProperties, Right extends TProperties, Properties extends Record<PropertyKey, Result.TExtendsTrue | Result.TExtendsFalse> = {
+    [RightKey in keyof Right]: (RightKey extends keyof Left ? TExtendsProperty<{}, Left[RightKey], Right[RightKey]> : Right[RightKey] extends TOptional<Right[RightKey]> ? Right[RightKey] extends TInfer ? Result.TExtendsTrue<Memory.TAssign<Inferred, {
+        [_ in Right[RightKey]['name']]: Right[RightKey]['extends'];
+    }>> : Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
+}, Checked extends boolean = Properties[keyof Right] extends Result.TExtendsTrueLike ? true : false, Extracted extends TProperties = Checked extends true ? TExtractInferredProperties<TUnionToTuple<keyof Properties>, Properties> : {}> = (Checked extends true ? Result.TExtendsTrue<Extracted> : Result.TExtendsFalse);
+type TExtendsProperties<Inferred extends TProperties, Left extends TProperties, Right extends TProperties, Compared extends Result.TResult = TExtendsPropertiesComparer<Inferred, Left, Right>> = (Compared extends Result.TExtendsTrueLike<infer ComparedInferred extends TProperties> ? Result.TExtendsTrue<Memory.TAssign<Inferred, ComparedInferred>> : Result.TExtendsFalse);
+type TExtendsObjectToObject<Inferred extends TProperties, Left extends TProperties, Right extends TProperties> = (TExtendsProperties<Inferred, Left, Right>);
+export type TExtendsObject<Inferred extends TProperties, Left extends TProperties, Right extends TSchema> = (Right extends TObject<infer Properties extends TProperties> ? TExtendsObjectToObject<Inferred, Left, Properties> : TExtendsRight<Inferred, TObject<Left>, Right>);
+export declare function ExtendsObject<Inferred extends TProperties, Left extends TProperties, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsObject<Inferred, Left, Right>;
+export {};

package/node_modules/typebox/build/type/extends/object.mjs

@@ -0,0 +1,87 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Unreachable } from '../../system/unreachable/index.mjs';
+import { Memory } from '../../system/memory/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { IsOptional } from '../types/_optional.mjs';
+import { IsInfer } from '../types/infer.mjs';
+import { IsNever } from '../types/never.mjs';
+import { IsObject, Object } from '../types/object.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
+import { ExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+function ExtendsPropertyOptional(inferred, left, right) {
+    return (IsOptional(left)
+        ? IsOptional(right)
+            ? Result.ExtendsTrue(inferred)
+            : Result.ExtendsFalse()
+        : Result.ExtendsTrue(inferred));
+}
+function ExtendsProperty(inferred, left, right) {
+    return (
+    // Right TInfer<TNever> is TExtendsFalse
+    (IsInfer(right) && IsNever(right.extends))
+        ? Result.ExtendsFalse()
+        : Result.Match(ExtendsLeft(inferred, left, right), inferred => ExtendsPropertyOptional(inferred, left, right), () => Result.ExtendsFalse()));
+}
+function ExtractInferredProperties(keys, properties) {
+    return keys.reduce((result, key) => {
+        return key in properties
+            ? Result.IsExtendsTrueLike(properties[key])
+                // @ts-ignore 5.0.4 cannot see `.inferred`
+                ? { ...result, ...properties[key].inferred }
+                : Unreachable() // result
+            : Unreachable(); // result
+    }, {});
+}
+function ExtendsPropertiesComparer(inferred, left, right) {
+    const properties = {};
+    for (const rightKey of Guard.Keys(right)) {
+        properties[rightKey] = (rightKey in left
+            // We don't consider the exterior Inferred as part of the property check as
+            // we don't want the exterior Context to override the Inferred Context for
+            // the Property Key. This override behavior is observed in the following
+            // case we want the inferred A to shadow the exterior A.
+            //
+            // const A = Type.Script(`{ x: 1, y: 1 }`)
+            // const S = Type.Script({ A }, `{
+            //   [K in keyof A]: A extends { 
+            //     x: infer A, 
+            //     y: infer B 
+            //   } ? [A, B]   <-- inferred 'A' shadows the exterior 'A'
+            //     : never
+            // }`)
+            ? ExtendsProperty({}, left[rightKey], right[rightKey])
+            // If the right key K is not in left, but the right property is optional
+            // then we say this property is permissable. This is because an optional
+            // property on right is the same as property missing in left. If the
+            // right is infer, then we just assign the extend type to inferred.
+            : IsOptional(right[rightKey])
+                ? IsInfer(right[rightKey])
+                    // @ts-ignore 5.0.1 - cannot observe extend in right[rightKey].extends
+                    ? Result.ExtendsTrue(Memory.Assign(inferred, { [right[rightKey].name]: right[rightKey].extends }))
+                    : Result.ExtendsTrue(inferred)
+                : Result.ExtendsFalse());
+    }
+    // Check if all properties are ExtendsTrueLike
+    const checked = Guard.Values(properties).every(result => Result.IsExtendsTrueLike(result));
+    // Extract inferred results from properties, but only if the check is true.
+    const extracted = checked ? ExtractInferredProperties(Guard.Keys(properties), properties) : {};
+    return (checked
+        ? Result.ExtendsTrue(extracted)
+        : Result.ExtendsFalse());
+}
+function ExtendsProperties(inferred, left, right) {
+    const compared = ExtendsPropertiesComparer(inferred, left, right);
+    return (Result.IsExtendsTrueLike(compared)
+        ? Result.ExtendsTrue(Memory.Assign(inferred, compared.inferred))
+        : Result.ExtendsFalse());
+}
+function ExtendsObjectToObject(inferred, left, right) {
+    return ExtendsProperties(inferred, left, right);
+}
+export function ExtendsObject(inferred, left, right) {
+    return (IsObject(right)
+        ? ExtendsObjectToObject(inferred, left, right.properties)
+        : ExtendsRight(inferred, Object(left), right));
+}

package/node_modules/typebox/build/type/extends/parameters.d.mts

@@ -0,0 +1,15 @@
+import { type TInfer } from '../types/infer.mjs';
+import { type TSchema } from '../types/schema.mjs';
+import { type TOptional } from '../types/_optional.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import * as Result from './result.mjs';
+type TParameterCompare<Inferred extends TProperties, Left extends TSchema, LeftRest extends TSchema[], Right extends TSchema, RightRest extends TSchema[], CheckLeft extends TSchema = Right extends TInfer ? Left : Right, CheckRight extends TSchema = Right extends TInfer ? Right : Left, IsLeftOptional extends boolean = Left extends TOptional ? true : false, IsRightOptional extends boolean = Right extends TOptional ? true : false> = ([
+    IsLeftOptional,
+    IsRightOptional
+] extends [false, true] ? Result.TExtendsFalse : TExtendsLeft<Inferred, CheckLeft, CheckRight> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsParameters<Inferred, LeftRest, RightRest> : Result.TExtendsFalse);
+type TParameterRight<Inferred extends TProperties, Left extends TSchema, LeftRest extends TSchema[], RightRest extends TSchema[]> = (RightRest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TParameterCompare<Inferred, Left, LeftRest, Head, Tail> : Left extends TOptional ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
+type TParameterLeft<Inferred extends TProperties, LeftRest extends TSchema[], RightRest extends TSchema[]> = (LeftRest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TParameterRight<Inferred, Head, Tail, RightRest> : Result.TExtendsTrue<Inferred>);
+export type TExtendsParameters<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema[]> = TParameterLeft<Inferred, Left, Right>;
+export declare function ExtendsParameters<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema[]>(inferred: Inferred, left: Left, right: Right): TExtendsParameters<Inferred, Left, Right>;
+export {};

package/node_modules/typebox/build/type/extends/parameters.mjs

@@ -0,0 +1,28 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsInfer } from '../types/infer.mjs';
+import { IsOptional } from '../types/_optional.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
+import * as Result from './result.mjs';
+function ParameterCompare(inferred, left, leftRest, right, rightRest) {
+    // Parameter extends Right on Left, except when infer Right  
+    const checkLeft = IsInfer(right) ? left : right;
+    const checkRight = IsInfer(right) ? right : left;
+    const isLeftOptional = IsOptional(left);
+    const isRightOptional = IsOptional(right);
+    return ((!isLeftOptional && isRightOptional)
+        ? Result.ExtendsFalse() // 'fail: left-required-but-right-is-optional'
+        : Result.Match(ExtendsLeft(inferred, checkLeft, checkRight), inferred => ExtendsParameters(inferred, leftRest, rightRest), () => Result.ExtendsFalse()) // 'fail: left-and-right-did-not-match'
+    );
+}
+function ParameterRight(inferred, left, leftRest, rightRest) {
+    return Guard.TakeLeft(rightRest, (head, tail) => ParameterCompare(inferred, left, leftRest, head, tail), () => IsOptional(left) // 'right-did-not-have-enough-elements'
+        ? Result.ExtendsTrue(inferred) // 'ok: left was optional'
+        : Result.ExtendsFalse()); // 'fail: left was required'
+}
+function ParametersLeft(inferred, left, rightRest) {
+    return Guard.TakeLeft(left, (head, tail) => ParameterRight(inferred, head, tail, rightRest), () => Result.ExtendsTrue(inferred)); // 'ok: no-more-elements-in-left'
+}
+export function ExtendsParameters(inferred, left, right) {
+    return ParametersLeft(inferred, left, right);
+}

package/node_modules/typebox/build/type/extends/promise.d.mts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TPromise } from '../types/promise.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+export type TExtendsPromise<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TPromise<infer Type extends TSchema> ? TExtendsLeft<Inferred, Left, Type> : TExtendsRight<Inferred, TPromise<Left>, Right>);
+export declare function ExtendsPromise<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsPromise<Inferred, Left, Right>;

package/node_modules/typebox/build/type/extends/promise.mjs

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { Promise, IsPromise } from '../types/promise.mjs';
+import { ExtendsRight } from './extends_right.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
+export function ExtendsPromise(inferred, left, right) {
+    return (IsPromise(right)
+        ? ExtendsLeft(inferred, left, right.item)
+        : ExtendsRight(inferred, Promise(left), right));
+}

package/node_modules/typebox/build/type/extends/result.d.mts

@@ -0,0 +1,24 @@
+import { type TProperties } from '../types/properties.mjs';
+export type TResult = TExtendsUnion | TExtendsTrue | TExtendsFalse;
+export interface TExtendsUnion<Inferred extends TProperties = TProperties> {
+    '~kind': 'ExtendsUnion';
+    inferred: Inferred;
+}
+export declare function ExtendsUnion<Inferred extends TProperties>(inferred: TProperties): TExtendsUnion<Inferred>;
+export declare function IsExtendsUnion(value: unknown): value is TExtendsUnion;
+export interface TExtendsTrue<Inferred extends TProperties = TProperties> {
+    '~kind': 'ExtendsTrue';
+    inferred: Inferred;
+}
+export declare function ExtendsTrue<Inferred extends TProperties>(inferred: TProperties): TExtendsTrue<Inferred>;
+export declare function IsExtendsTrue(value: unknown): value is TExtendsTrue;
+export interface TExtendsFalse {
+    type: 'ExtendsFalse';
+}
+export declare function ExtendsFalse(): TExtendsFalse;
+export declare function IsExtendsFalse(value: unknown): value is TExtendsFalse;
+export type TExtendsTrueLike<Inferred extends TProperties = TProperties> = TExtendsUnion<Inferred> | TExtendsTrue<Inferred>;
+export declare function IsExtendsTrueLike(value: unknown): value is TExtendsTrueLike;
+export type MatchTrueLike = (inferred: TProperties) => unknown;
+export type MatchFalse = () => unknown;
+export declare function Match(result: TResult, true_: MatchTrueLike, false_: MatchFalse): unknown;

package/node_modules/typebox/build/type/extends/result.mjs

@@ -0,0 +1,36 @@
+import { Guard } from '../../guard/index.mjs';
+import { Memory } from '../../system/memory/index.mjs';
+export function ExtendsUnion(inferred) {
+    return Memory.Create({ ['~kind']: 'ExtendsUnion' }, { inferred });
+}
+export function IsExtendsUnion(value) {
+    return Guard.IsObject(value) &&
+        Guard.HasPropertyKey(value, '~kind') &&
+        Guard.HasPropertyKey(value, 'inferred') &&
+        Guard.IsEqual(value['~kind'], 'ExtendsUnion') &&
+        Guard.IsObject(value.inferred);
+}
+export function ExtendsTrue(inferred) {
+    return Memory.Create({ ['~kind']: 'ExtendsTrue' }, { inferred });
+}
+export function IsExtendsTrue(value) {
+    return Guard.IsObject(value) &&
+        Guard.HasPropertyKey(value, '~kind') &&
+        Guard.HasPropertyKey(value, 'inferred') &&
+        Guard.IsEqual(value['~kind'], 'ExtendsTrue') &&
+        Guard.IsObject(value.inferred);
+}
+export function ExtendsFalse() {
+    return Memory.Create({ ['~kind']: 'ExtendsFalse' }, {});
+}
+export function IsExtendsFalse(value) {
+    return Guard.IsObject(value) &&
+        Guard.HasPropertyKey(value, '~kind') &&
+        Guard.IsEqual(value['~kind'], 'ExtendsFalse');
+}
+export function IsExtendsTrueLike(value) {
+    return IsExtendsUnion(value) || IsExtendsTrue(value);
+}
+export function Match(result, true_, false_) {
+    return IsExtendsTrueLike(result) ? true_(result.inferred) : false_();
+}

package/node_modules/typebox/build/type/extends/return_type.d.mts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TVoid } from '../types/void.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import * as Result from './result.mjs';
+export type TExtendsReturnType<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TVoid ? Result.TExtendsTrue<Inferred> : TExtendsLeft<Inferred, Left, Right>);
+export declare function ExtendsReturnType<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsReturnType<Inferred, Left, Right>;

package/node_modules/typebox/build/type/extends/return_type.mjs

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { IsVoid } from '../types/void.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
+import * as Result from './result.mjs';
+export function ExtendsReturnType(inferred, left, right) {
+    return (IsVoid(right)
+        ? Result.ExtendsTrue(inferred)
+        : ExtendsLeft(inferred, left, right));
+}

package/node_modules/typebox/build/type/extends/string.d.mts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TString } from '../types/string.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+export type TExtendsString<Inferred extends TProperties, Left extends TString, Right extends TSchema> = (Right extends TString ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, Left, Right>);
+export declare function ExtendsString<Inferred extends TProperties, Left extends TString, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsString<Inferred, Left, Right>;

package/node_modules/typebox/build/type/extends/string.mjs

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { IsString } from '../types/string.mjs';
+import { ExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+export function ExtendsString(inferred, left, right) {
+    return (IsString(right)
+        ? Result.ExtendsTrue(inferred)
+        : ExtendsRight(inferred, left, right));
+}

package/node_modules/typebox/build/type/extends/symbol.d.mts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TSymbol } from '../types/symbol.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+export type TExtendsSymbol<Inferred extends TProperties, Left extends TSymbol, Right extends TSchema> = (Right extends TSymbol ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, Left, Right>);
+export declare function ExtendsSymbol<Inferred extends TProperties, Left extends TSymbol, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsSymbol<Inferred, Left, Right>;

package/node_modules/typebox/build/type/extends/symbol.mjs

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { IsSymbol } from '../types/symbol.mjs';
+import { ExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+export function ExtendsSymbol(inferred, left, right) {
+    return (IsSymbol(right)
+        ? Result.ExtendsTrue(inferred)
+        : ExtendsRight(inferred, left, right));
+}

package/node_modules/typebox/build/type/extends/template_literal.d.mts

@@ -0,0 +1,6 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import { type TTemplateLiteralDecode } from '../engine/template_literal/decode.mjs';
+export type TExtendsTemplateLiteral<Inferred extends TProperties, Left extends string, Right extends TSchema, Decoded extends TSchema = TTemplateLiteralDecode<Left>> = TExtendsLeft<Inferred, Decoded, Right>;
+export declare function ExtendsTemplateLiteral<Inferred extends TProperties, Left extends string, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsTemplateLiteral<Inferred, Left, Right>;

package/node_modules/typebox/build/type/extends/template_literal.mjs

@@ -0,0 +1,7 @@
+// deno-fmt-ignore-file
+import { ExtendsLeft } from './extends_left.mjs';
+import { TemplateLiteralDecode } from '../engine/template_literal/decode.mjs';
+export function ExtendsTemplateLiteral(inferred, left, right) {
+    const decoded = TemplateLiteralDecode(left);
+    return ExtendsLeft(inferred, decoded, right);
+}

package/node_modules/typebox/build/type/extends/tuple.d.mts

@@ -0,0 +1,25 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TArray } from '../types/array.mjs';
+import { type TTuple } from '../types/tuple.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+import { type TInstantiateElements } from '../engine/instantiate.mjs';
+import { type TTryRestInferable, type TTryInferable, type TInferable, type TInferTupleResult, type TInferUnionResult } from './inference.mjs';
+type TReverse<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TReverse<Right, [Left, ...Result]> : Result);
+type TApplyReverse<Types extends TSchema[], Reversed extends boolean> = Reversed extends true ? TReverse<Types> : Types;
+type TReversed<Types extends TSchema[], First extends TSchema | undefined = Types extends [infer Left extends TSchema, ...infer _ extends TSchema[]] ? Left : undefined, Inferable extends TSchema | undefined = First extends TSchema ? TTryRestInferable<First> : undefined, Result extends boolean = Inferable extends TSchema ? true : false> = Result;
+type TElementsCompare<Inferred extends TProperties, Reversed extends boolean, Left extends TSchema, LeftRest extends TSchema[], Right extends TSchema, RightRest extends TSchema[]> = (TExtendsLeft<Inferred, Left, Right> extends Result.TExtendsTrueLike<infer CheckInferred extends TProperties> ? TElements<CheckInferred, Reversed, LeftRest, RightRest> : Result.TExtendsFalse);
+type TElementsLeft<Inferred extends TProperties, Reversed extends boolean, LeftRest extends TSchema[], Right extends TSchema, RightRest extends TSchema[], Inferable extends TInferable | undefined = TTryRestInferable<Right>> = (Inferable extends TInferable ? TInferTupleResult<Inferred, Inferable['name'], TApplyReverse<LeftRest, Reversed>, Inferable['type']> : LeftRest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TElementsCompare<Inferred, Reversed, Head, Tail, Right, RightRest> : Result.TExtendsFalse);
+type TElementsRight<Inferred extends TProperties, Reversed extends boolean, LeftRest extends TSchema[], RightRest extends TSchema[]> = (RightRest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TElementsLeft<Inferred, Reversed, LeftRest, Head, Tail> : LeftRest['length'] extends 0 ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
+type TElements<Inferred extends TProperties, Reversed extends boolean, LeftRest extends TSchema[], RightRest extends TSchema[]> = TElementsRight<Inferred, Reversed, LeftRest, RightRest>;
+type TExtendsTupleToTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema[], InstantiatedRight extends TSchema[] = TInstantiateElements<Inferred, {
+    callstack: [];
+}, Right>, Reversed extends boolean = TReversed<InstantiatedRight>> = TElements<Inferred, Reversed, TApplyReverse<Left, Reversed>, TApplyReverse<InstantiatedRight, Reversed>>;
+type TExtendsTupleToArray<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, Inferrable extends TInferable | undefined = TTryInferable<Right>> = (Inferrable extends TInferable ? TInferUnionResult<Inferred, Inferrable['name'], Left, Inferrable['type']> : Left extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Head, Right> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsTupleToArray<Inferred, Tail, Right> : Result.TExtendsFalse : Result.TExtendsTrue<Inferred>);
+export type TExtendsTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, InstantiatedLeft extends TSchema[] = TInstantiateElements<Inferred, {
+    callstack: [];
+}, Left>> = (Right extends TTuple<infer Types extends TSchema[]> ? TExtendsTupleToTuple<Inferred, InstantiatedLeft, Types> : Right extends TArray<infer Type extends TSchema> ? TExtendsTupleToArray<Inferred, InstantiatedLeft, Type> : TExtendsRight<Inferred, TTuple<InstantiatedLeft>, Right>);
+export declare function ExtendsTuple<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsTuple<Inferred, Left, Right>;
+export {};

package/node_modules/typebox/build/type/extends/tuple.mjs

@@ -0,0 +1,60 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from '../types/schema.mjs';
+import { IsArray } from '../types/array.mjs';
+import { IsTuple, Tuple } from '../types/tuple.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
+import { ExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+import { InstantiateElements } from '../engine/instantiate.mjs';
+// ----------------------------------------------------------------------------
+// Inference
+// ----------------------------------------------------------------------------
+import { TryRestInferable, TryInferable, IsInferable, InferTupleResult, InferUnionResult } from './inference.mjs';
+function Reverse(types) {
+    return [...types].reverse();
+}
+function ApplyReverse(types, reversed) {
+    return (reversed ? Reverse(types) : types);
+}
+function Reversed(types) {
+    const first = types.length > 0 ? types[0] : undefined;
+    const inferrable = IsSchema(first) ? TryRestInferable(first) : undefined;
+    return IsSchema(inferrable);
+}
+function ElementsCompare(inferred, reversed, left, leftRest, right, rightRest) {
+    return Result.Match(ExtendsLeft(inferred, left, right), checkInferred => Elements(checkInferred, reversed, leftRest, rightRest), () => Result.ExtendsFalse()); // 'left-and-right-not-compared'
+}
+function ElementsLeft(inferred, reversed, leftRest, right, rightRest) {
+    const inferable = TryRestInferable(right);
+    return (
+    // Rest Inferrable Right Means we delegate to TInferTupleResult to Generate a Result
+    IsInferable(inferable)
+        ? InferTupleResult(inferred, inferable['name'], ApplyReverse(leftRest, reversed), inferable['type'])
+        : Guard.TakeLeft(leftRest, (head, tail) => ElementsCompare(inferred, reversed, head, tail, right, rightRest), () => Result.ExtendsFalse()));
+}
+function ElementsRight(inferred, reversed, leftRest, rightRest) {
+    return Guard.TakeLeft(rightRest, (head, tail) => ElementsLeft(inferred, reversed, leftRest, head, tail), () => Guard.IsEqual(leftRest.length, 0)
+        ? Result.ExtendsTrue(inferred) // 'Ok: right-empty-and-left-empty'
+        : Result.ExtendsFalse()); // 'Fail: right-empty-and-left-not-empty'
+}
+function Elements(inferred, reversed, leftRest, rightRest) {
+    return ElementsRight(inferred, reversed, leftRest, rightRest);
+}
+function ExtendsTupleToTuple(inferred, left, right) {
+    const instantiatedRight = InstantiateElements(inferred, { callstack: [] }, right);
+    const reversed = Reversed(instantiatedRight);
+    return Elements(inferred, reversed, ApplyReverse(left, reversed), ApplyReverse(instantiatedRight, reversed));
+}
+function ExtendsTupleToArray(inferred, left, right) {
+    const inferrable = TryInferable(right);
+    return (IsInferable(inferrable)
+        ? InferUnionResult(inferred, inferrable['name'], left, inferrable['type'])
+        : Guard.TakeLeft(left, (head, tail) => Result.Match(ExtendsLeft(inferred, head, right), inferred => ExtendsTupleToArray(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred)));
+}
+export function ExtendsTuple(inferred, left, right) {
+    const instantiatedLeft = InstantiateElements(inferred, { callstack: [] }, left);
+    return (IsTuple(right) ? ExtendsTupleToTuple(inferred, instantiatedLeft, right.items) :
+        IsArray(right) ? ExtendsTupleToArray(inferred, instantiatedLeft, right.items) :
+            ExtendsRight(inferred, Tuple(instantiatedLeft), right));
+}

package/node_modules/typebox/build/type/extends/undefined.d.mts

@@ -0,0 +1,8 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TUndefined } from '../types/undefined.mjs';
+import { type TVoid } from '../types/void.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+export type TExtendsUndefined<Inferred extends TProperties, Left extends TUndefined, Right extends TSchema> = (Right extends TVoid ? Result.TExtendsTrue<Inferred> : Right extends TUndefined ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, Left, Right>);
+export declare function ExtendsUndefined<Inferred extends TProperties, Left extends TUndefined, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsUndefined<Inferred, Left, Right>;