@openclaw/slack 2026.7.1-beta.2 → 2026.7.1-beta.4

package/node_modules/typebox/build/type/script/parser.mjs

@@ -31,23 +31,22 @@ export const KeywordNever = (input) => If(Token.Const('never', input), ([_0, inp
 export const KeywordSymbol = (input) => If(Token.Const('symbol', input), ([_0, input]) => [S.KeywordSymbolMapping(_0), input]);
 export const KeywordVoid = (input) => If(Token.Const('void', input), ([_0, input]) => [S.KeywordVoidMapping(_0), input]);
 export const KeywordThis = (input) => If(Token.Const('this', input), ([_0, input]) => [S.KeywordThisMapping(_0), input]);
-export const Keyword = (input) => If(If(KeywordString(input), ([_0, input]) => [_0, input], () => If(KeywordNumber(input), ([_0, input]) => [_0, input], () => If(KeywordBoolean(input), ([_0, input]) => [_0, input], () => If(KeywordUndefined(input), ([_0, input]) => [_0, input], () => If(KeywordNull(input), ([_0, input]) => [_0, input], () => If(KeywordInteger(input), ([_0, input]) => [_0, input], () => If(KeywordBigInt(input), ([_0, input]) => [_0, input], () => If(KeywordUnknown(input), ([_0, input]) => [_0, input], () => If(KeywordAny(input), ([_0, input]) => [_0, input], () => If(KeywordObject(input), ([_0, input]) => [_0, input], () => If(KeywordNever(input), ([_0, input]) => [_0, input], () => If(KeywordSymbol(input), ([_0, input]) => [_0, input], () => If(KeywordVoid(input), ([_0, input]) => [_0, input], () => If(KeywordThis(input), ([_0, input]) => [_0, input], () => [])))))))))))))), ([_0, input]) => [S.KeywordMapping(_0), input]);
 export const TemplateInterpolate = (input) => If(If(Token.Const('${', input), ([_0, input]) => If(Type(input), ([_1, input]) => If(Token.Const('}', input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [S.TemplateInterpolateMapping(_0), input]);
 export const TemplateSpan = (input) => If(Token.Until(['${', '`'], input), ([_0, input]) => [S.TemplateSpanMapping(_0), input]);
 export const TemplateBody = (input) => If(If(If(TemplateSpan(input), ([_0, input]) => If(TemplateInterpolate(input), ([_1, input]) => If(TemplateBody(input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [_0, input], () => If(If(TemplateSpan(input), ([_0, input]) => [[_0], input]), ([_0, input]) => [_0, input], () => If(If(TemplateSpan(input), ([_0, input]) => [[_0], input]), ([_0, input]) => [_0, input], () => []))), ([_0, input]) => [S.TemplateBodyMapping(_0), input]);
 export const TemplateLiteralTypes = (input) => If(If(Token.Const('`', input), ([_0, input]) => If(TemplateBody(input), ([_1, input]) => If(Token.Const('`', input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [S.TemplateLiteralTypesMapping(_0), input]);
 export const TemplateLiteral = (input) => If(TemplateLiteralTypes(input), ([_0, input]) => [S.TemplateLiteralMapping(_0), input]);
+export const Dependent = (input) => If(If(If(Token.Const('if', input), ([_0, input]) => If(Type(input), ([_1, input]) => If(Token.Const('then', input), ([_2, input]) => If(Type(input), ([_3, input]) => If(Token.Const('else', input), ([_4, input]) => If(Type(input), ([_5, input]) => [[_0, _1, _2, _3, _4, _5], input])))))), ([_0, input]) => [_0, input], () => If(If(Token.Const('if', input), ([_0, input]) => If(Type(input), ([_1, input]) => If(Token.Const('then', input), ([_2, input]) => If(Type(input), ([_3, input]) => [[_0, _1, _2, _3], input])))), ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.DependentMapping(_0), input]);
 export const LiteralBigInt = (input) => If(Token.BigInt(input), ([_0, input]) => [S.LiteralBigIntMapping(_0), input]);
 export const LiteralBoolean = (input) => If(If(Token.Const('true', input), ([_0, input]) => [_0, input], () => If(Token.Const('false', input), ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.LiteralBooleanMapping(_0), input]);
 export const LiteralNumber = (input) => If(Token.Number(input), ([_0, input]) => [S.LiteralNumberMapping(_0), input]);
 export const LiteralString = (input) => If(Token.String(['\'', '\"'], input), ([_0, input]) => [S.LiteralStringMapping(_0), input]);
-export const Literal = (input) => If(If(LiteralBigInt(input), ([_0, input]) => [_0, input], () => If(LiteralBoolean(input), ([_0, input]) => [_0, input], () => If(LiteralNumber(input), ([_0, input]) => [_0, input], () => If(LiteralString(input), ([_0, input]) => [_0, input], () => [])))), ([_0, input]) => [S.LiteralMapping(_0), input]);
 export const KeyOf = (input) => If(If(If(Token.Const('keyof', input), ([_0, input]) => [[_0], input]), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.KeyOfMapping(_0), input]);
 export const IndexArray_0 = (input, result = []) => If(If(If(Token.Const('[', input), ([_0, input]) => If(Type(input), ([_1, input]) => If(Token.Const(']', input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [_0, input], () => If(If(Token.Const('[', input), ([_0, input]) => If(Token.Const(']', input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [_0, input], () => [])), ([_0, input]) => IndexArray_0(input, [...result, _0]), () => [result, input]);
 export const IndexArray = (input) => If(IndexArray_0(input), ([_0, input]) => [S.IndexArrayMapping(_0), input]);
 export const Extends = (input) => If(If(If(Token.Const('extends', input), ([_0, input]) => If(Type(input), ([_1, input]) => If(Token.Const('?', input), ([_2, input]) => If(Type(input), ([_3, input]) => If(Token.Const(':', input), ([_4, input]) => If(Type(input), ([_5, input]) => [[_0, _1, _2, _3, _4, _5], input])))))), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.ExtendsMapping(_0), input]);
-export const Base = (input) => If(If(If(Token.Const('(', input), ([_0, input]) => If(Type(input), ([_1, input]) => If(Token.Const(')', input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [_0, input], () => If(Keyword(input), ([_0, input]) => [_0, input], () => If(_Object_(input), ([_0, input]) => [_0, input], () => If(Tuple(input), ([_0, input]) => [_0, input], () => If(TemplateLiteral(input), ([_0, input]) => [_0, input], () => If(Literal(input), ([_0, input]) => [_0, input], () => If(Constructor(input), ([_0, input]) => [_0, input], () => If(_Function_(input), ([_0, input]) => [_0, input], () => If(Mapped(input), ([_0, input]) => [_0, input], () => If(Options(input), ([_0, input]) => [_0, input], () => If(GenericCall(input), ([_0, input]) => [_0, input], () => If(Reference(input), ([_0, input]) => [_0, input], () => [])))))))))))), ([_0, input]) => [S.BaseMapping(_0), input]);
-export const With = (input) => If(If(If(Token.Const('with', input), ([_0, input]) => If(JsonObject(input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.WithMapping(_0), input]);
+export const Base = (input) => If(If(If(Token.Const('(', input), ([_0, input]) => If(Type(input), ([_1, input]) => If(Token.Const(')', input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [_0, input], () => If(KeywordString(input), ([_0, input]) => [_0, input], () => If(KeywordNumber(input), ([_0, input]) => [_0, input], () => If(KeywordBoolean(input), ([_0, input]) => [_0, input], () => If(KeywordUndefined(input), ([_0, input]) => [_0, input], () => If(KeywordNull(input), ([_0, input]) => [_0, input], () => If(KeywordInteger(input), ([_0, input]) => [_0, input], () => If(KeywordBigInt(input), ([_0, input]) => [_0, input], () => If(KeywordUnknown(input), ([_0, input]) => [_0, input], () => If(KeywordAny(input), ([_0, input]) => [_0, input], () => If(KeywordObject(input), ([_0, input]) => [_0, input], () => If(KeywordNever(input), ([_0, input]) => [_0, input], () => If(KeywordSymbol(input), ([_0, input]) => [_0, input], () => If(KeywordVoid(input), ([_0, input]) => [_0, input], () => If(KeywordThis(input), ([_0, input]) => [_0, input], () => If(LiteralBigInt(input), ([_0, input]) => [_0, input], () => If(LiteralBoolean(input), ([_0, input]) => [_0, input], () => If(LiteralNumber(input), ([_0, input]) => [_0, input], () => If(LiteralString(input), ([_0, input]) => [_0, input], () => If(TemplateLiteral(input), ([_0, input]) => [_0, input], () => If(Dependent(input), ([_0, input]) => [_0, input], () => If(_Object_(input), ([_0, input]) => [_0, input], () => If(_Tuple_(input), ([_0, input]) => [_0, input], () => If(_Constructor_(input), ([_0, input]) => [_0, input], () => If(_Function_(input), ([_0, input]) => [_0, input], () => If(_Mapped_(input), ([_0, input]) => [_0, input], () => If(GenericCall(input), ([_0, input]) => [_0, input], () => If(Reference(input), ([_0, input]) => [_0, input], () => [])))))))))))))))))))))))))))), ([_0, input]) => [S.BaseMapping(_0), input]);
+export const With = (input) => If(If(If(Token.Const('with', input), ([_0, input]) => If(WithObject(input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.WithMapping(_0), input]);
 export const Factor = (input) => If(If(KeyOf(input), ([_0, input]) => If(Base(input), ([_1, input]) => If(IndexArray(input), ([_2, input]) => If(Extends(input), ([_3, input]) => If(With(input), ([_4, input]) => [[_0, _1, _2, _3, _4], input]))))), ([_0, input]) => [S.FactorMapping(_0), input]);
 export const ExprTermTail = (input) => If(If(If(Token.Const('&', input), ([_0, input]) => If(Factor(input), ([_1, input]) => If(ExprTermTail(input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.ExprTermTailMapping(_0), input]);
 export const ExprTerm = (input) => If(If(Factor(input), ([_0, input]) => If(ExprTermTail(input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [S.ExprTermMapping(_0), input]);
@@ -79,7 +78,7 @@ export const ElementBase = (input) => If(If(ElementNamed(input), ([_0, input]) =
 export const Element = (input) => If(If(If(Token.Const('...', input), ([_0, input]) => If(ElementBase(input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [_0, input], () => If(If(ElementBase(input), ([_0, input]) => [[_0], input]), ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.ElementMapping(_0), input]);
 export const ElementList_0 = (input, result = []) => If(If(Element(input), ([_0, input]) => If(Token.Const(',', input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => ElementList_0(input, [...result, _0]), () => [result, input]);
 export const ElementList = (input) => If(If(ElementList_0(input), ([_0, input]) => If(If(If(Element(input), ([_0, input]) => [[_0], input]), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [S.ElementListMapping(_0), input]);
-export const Tuple = (input) => If(If(Token.Const('[', input), ([_0, input]) => If(ElementList(input), ([_1, input]) => If(Token.Const(']', input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [S.TupleMapping(_0), input]);
+export const _Tuple_ = (input) => If(If(Token.Const('[', input), ([_0, input]) => If(ElementList(input), ([_1, input]) => If(Token.Const(']', input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [S._Tuple_Mapping(_0), input]);
 export const ParameterReadonlyOptional = (input) => If(If(Token.Ident(input), ([_0, input]) => If(Token.Const('?', input), ([_1, input]) => If(Token.Const(':', input), ([_2, input]) => If(Token.Const('readonly', input), ([_3, input]) => If(Type(input), ([_4, input]) => [[_0, _1, _2, _3, _4], input]))))), ([_0, input]) => [S.ParameterReadonlyOptionalMapping(_0), input]);
 export const ParameterReadonly = (input) => If(If(Token.Ident(input), ([_0, input]) => If(Token.Const(':', input), ([_1, input]) => If(Token.Const('readonly', input), ([_2, input]) => If(Type(input), ([_3, input]) => [[_0, _1, _2, _3], input])))), ([_0, input]) => [S.ParameterReadonlyMapping(_0), input]);
 export const ParameterOptional = (input) => If(If(Token.Ident(input), ([_0, input]) => If(Token.Const('?', input), ([_1, input]) => If(Token.Const(':', input), ([_2, input]) => If(Type(input), ([_3, input]) => [[_0, _1, _2, _3], input])))), ([_0, input]) => [S.ParameterOptionalMapping(_0), input]);
@@ -89,31 +88,32 @@ export const Parameter = (input) => If(If(If(Token.Const('...', input), ([_0, in
 export const ParameterList_0 = (input, result = []) => If(If(Parameter(input), ([_0, input]) => If(Token.Const(',', input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => ParameterList_0(input, [...result, _0]), () => [result, input]);
 export const ParameterList = (input) => If(If(ParameterList_0(input), ([_0, input]) => If(If(If(Parameter(input), ([_0, input]) => [[_0], input]), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [S.ParameterListMapping(_0), input]);
 export const _Function_ = (input) => If(If(Token.Const('(', input), ([_0, input]) => If(ParameterList(input), ([_1, input]) => If(Token.Const(')', input), ([_2, input]) => If(Token.Const('=>', input), ([_3, input]) => If(Type(input), ([_4, input]) => [[_0, _1, _2, _3, _4], input]))))), ([_0, input]) => [S._Function_Mapping(_0), input]);
-export const Constructor = (input) => If(If(Token.Const('new', input), ([_0, input]) => If(Token.Const('(', input), ([_1, input]) => If(ParameterList(input), ([_2, input]) => If(Token.Const(')', input), ([_3, input]) => If(Token.Const('=>', input), ([_4, input]) => If(Type(input), ([_5, input]) => [[_0, _1, _2, _3, _4, _5], input])))))), ([_0, input]) => [S.ConstructorMapping(_0), input]);
+export const _Constructor_ = (input) => If(If(Token.Const('new', input), ([_0, input]) => If(Token.Const('(', input), ([_1, input]) => If(ParameterList(input), ([_2, input]) => If(Token.Const(')', input), ([_3, input]) => If(Token.Const('=>', input), ([_4, input]) => If(Type(input), ([_5, input]) => [[_0, _1, _2, _3, _4, _5], input])))))), ([_0, input]) => [S._Constructor_Mapping(_0), input]);
 export const MappedReadonly = (input) => If(If(If(Token.Const('+', input), ([_0, input]) => If(Token.Const('readonly', input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [_0, input], () => If(If(Token.Const('-', input), ([_0, input]) => If(Token.Const('readonly', input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [_0, input], () => If(If(Token.Const('readonly', input), ([_0, input]) => [[_0], input]), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])))), ([_0, input]) => [S.MappedReadonlyMapping(_0), input]);
 export const MappedOptional = (input) => If(If(If(Token.Const('+', input), ([_0, input]) => If(Token.Const('?', input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [_0, input], () => If(If(Token.Const('-', input), ([_0, input]) => If(Token.Const('?', input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [_0, input], () => If(If(Token.Const('?', input), ([_0, input]) => [[_0], input]), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])))), ([_0, input]) => [S.MappedOptionalMapping(_0), input]);
 export const MappedAs = (input) => If(If(If(Token.Const('as', input), ([_0, input]) => If(Type(input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.MappedAsMapping(_0), input]);
-export const Mapped = (input) => If(If(Token.Const('{', input), ([_0, input]) => If(MappedReadonly(input), ([_1, input]) => If(Token.Const('[', input), ([_2, input]) => If(Token.Ident(input), ([_3, input]) => If(Token.Const('in', input), ([_4, input]) => If(Type(input), ([_5, input]) => If(MappedAs(input), ([_6, input]) => If(Token.Const(']', input), ([_7, input]) => If(MappedOptional(input), ([_8, input]) => If(Token.Const(':', input), ([_9, input]) => If(Type(input), ([_10, input]) => If(OptionalSemiColon(input), ([_11, input]) => If(Token.Const('}', input), ([_12, input]) => [[_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12], input]))))))))))))), ([_0, input]) => [S.MappedMapping(_0), input]);
+export const _Mapped_ = (input) => If(If(Token.Const('{', input), ([_0, input]) => If(MappedReadonly(input), ([_1, input]) => If(Token.Const('[', input), ([_2, input]) => If(Token.Ident(input), ([_3, input]) => If(Token.Const('in', input), ([_4, input]) => If(Type(input), ([_5, input]) => If(MappedAs(input), ([_6, input]) => If(Token.Const(']', input), ([_7, input]) => If(MappedOptional(input), ([_8, input]) => If(Token.Const(':', input), ([_9, input]) => If(Type(input), ([_10, input]) => If(OptionalSemiColon(input), ([_11, input]) => If(Token.Const('}', input), ([_12, input]) => [[_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12], input]))))))))))))), ([_0, input]) => [S._Mapped_Mapping(_0), input]);
 export const Reference = (input) => If(Token.Ident(input), ([_0, input]) => [S.ReferenceMapping(_0), input]);
-export const Options = (input) => If(If(Token.Const('Options', input), ([_0, input]) => If(Token.Const('<', input), ([_1, input]) => If(Type(input), ([_2, input]) => If(Token.Const(',', input), ([_3, input]) => If(JsonObject(input), ([_4, input]) => If(Token.Const('>', input), ([_5, input]) => [[_0, _1, _2, _3, _4, _5], input])))))), ([_0, input]) => [S.OptionsMapping(_0), input]);
-export const JsonNumber = (input) => If(Token.Number(input), ([_0, input]) => [S.JsonNumberMapping(_0), input]);
-export const JsonBoolean = (input) => If(If(Token.Const('true', input), ([_0, input]) => [_0, input], () => If(Token.Const('false', input), ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.JsonBooleanMapping(_0), input]);
-export const JsonString = (input) => If(Token.String(['\"', '\''], input), ([_0, input]) => [S.JsonStringMapping(_0), input]);
-export const JsonNull = (input) => If(Token.Const('null', input), ([_0, input]) => [S.JsonNullMapping(_0), input]);
-export const JsonProperty = (input) => If(If(PropertyKey(input), ([_0, input]) => If(Token.Const(':', input), ([_1, input]) => If(Json(input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [S.JsonPropertyMapping(_0), input]);
-export const JsonPropertyList_0 = (input, result = []) => If(If(JsonProperty(input), ([_0, input]) => If(PropertyDelimiter(input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => JsonPropertyList_0(input, [...result, _0]), () => [result, input]);
-export const JsonPropertyList = (input) => If(If(JsonPropertyList_0(input), ([_0, input]) => If(If(If(JsonProperty(input), ([_0, input]) => [[_0], input]), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [S.JsonPropertyListMapping(_0), input]);
-export const JsonObject = (input) => If(If(Token.Const('{', input), ([_0, input]) => If(JsonPropertyList(input), ([_1, input]) => If(Token.Const('}', input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [S.JsonObjectMapping(_0), input]);
-export const JsonElementList_0 = (input, result = []) => If(If(Json(input), ([_0, input]) => If(Token.Const(',', input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => JsonElementList_0(input, [...result, _0]), () => [result, input]);
-export const JsonElementList = (input) => If(If(JsonElementList_0(input), ([_0, input]) => If(If(If(Json(input), ([_0, input]) => [[_0], input]), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [S.JsonElementListMapping(_0), input]);
-export const JsonArray = (input) => If(If(Token.Const('[', input), ([_0, input]) => If(JsonElementList(input), ([_1, input]) => If(Token.Const(']', input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [S.JsonArrayMapping(_0), input]);
-export const Json = (input) => If(If(JsonNumber(input), ([_0, input]) => [_0, input], () => If(JsonBoolean(input), ([_0, input]) => [_0, input], () => If(JsonString(input), ([_0, input]) => [_0, input], () => If(JsonNull(input), ([_0, input]) => [_0, input], () => If(JsonObject(input), ([_0, input]) => [_0, input], () => If(JsonArray(input), ([_0, input]) => [_0, input], () => [])))))), ([_0, input]) => [S.JsonMapping(_0), input]);
+export const WithBigInt = (input) => If(Token.BigInt(input), ([_0, input]) => [S.WithBigIntMapping(_0), input]);
+export const WithNumber = (input) => If(Token.Number(input), ([_0, input]) => [S.WithNumberMapping(_0), input]);
+export const WithBoolean = (input) => If(If(Token.Const('true', input), ([_0, input]) => [_0, input], () => If(Token.Const('false', input), ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.WithBooleanMapping(_0), input]);
+export const WithString = (input) => If(Token.String(['\"', '\''], input), ([_0, input]) => [S.WithStringMapping(_0), input]);
+export const WithNull = (input) => If(Token.Const('null', input), ([_0, input]) => [S.WithNullMapping(_0), input]);
+export const WithUndefined = (input) => If(Token.Const('undefined', input), ([_0, input]) => [S.WithUndefinedMapping(_0), input]);
+export const WithProperty = (input) => If(If(PropertyKey(input), ([_0, input]) => If(Token.Const(':', input), ([_1, input]) => If(WithValue(input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [S.WithPropertyMapping(_0), input]);
+export const WithPropertyList_0 = (input, result = []) => If(If(WithProperty(input), ([_0, input]) => If(PropertyDelimiter(input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => WithPropertyList_0(input, [...result, _0]), () => [result, input]);
+export const WithPropertyList = (input) => If(If(WithPropertyList_0(input), ([_0, input]) => If(If(If(WithProperty(input), ([_0, input]) => [[_0], input]), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [S.WithPropertyListMapping(_0), input]);
+export const WithObject = (input) => If(If(Token.Const('{', input), ([_0, input]) => If(WithPropertyList(input), ([_1, input]) => If(Token.Const('}', input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [S.WithObjectMapping(_0), input]);
+export const WithElementList_0 = (input, result = []) => If(If(WithValue(input), ([_0, input]) => If(Token.Const(',', input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => WithElementList_0(input, [...result, _0]), () => [result, input]);
+export const WithElementList = (input) => If(If(WithElementList_0(input), ([_0, input]) => If(If(If(WithValue(input), ([_0, input]) => [[_0], input]), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [S.WithElementListMapping(_0), input]);
+export const WithArray = (input) => If(If(Token.Const('[', input), ([_0, input]) => If(WithElementList(input), ([_1, input]) => If(Token.Const(']', input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [S.WithArrayMapping(_0), input]);
+export const WithValue = (input) => If(If(WithBigInt(input), ([_0, input]) => [_0, input], () => If(WithNumber(input), ([_0, input]) => [_0, input], () => If(WithBoolean(input), ([_0, input]) => [_0, input], () => If(WithString(input), ([_0, input]) => [_0, input], () => If(WithNull(input), ([_0, input]) => [_0, input], () => If(WithUndefined(input), ([_0, input]) => [_0, input], () => If(WithObject(input), ([_0, input]) => [_0, input], () => If(WithArray(input), ([_0, input]) => [_0, input], () => [])))))))), ([_0, input]) => [S.WithValueMapping(_0), input]);
 export const PatternBigInt = (input) => If(Token.Const('-?(?:0|[1-9][0-9]*)n', input), ([_0, input]) => [S.PatternBigIntMapping(_0), input]);
 export const PatternString = (input) => If(Token.Const('.*', input), ([_0, input]) => [S.PatternStringMapping(_0), input]);
-export const PatternNumber = (input) => If(Token.Const('-?(?:0|[1-9][0-9]*)(?:.[0-9]+)?', input), ([_0, input]) => [S.PatternNumberMapping(_0), input]);
+export const PatternNumber = (input) => If(Token.Const('-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?', input), ([_0, input]) => [S.PatternNumberMapping(_0), input]);
 export const PatternInteger = (input) => If(Token.Const('-?(?:0|[1-9][0-9]*)', input), ([_0, input]) => [S.PatternIntegerMapping(_0), input]);
 export const PatternNever = (input) => If(Token.Const('(?!)', input), ([_0, input]) => [S.PatternNeverMapping(_0), input]);
-export const PatternText = (input) => If(Token.Until_1(['-?(?:0|[1-9][0-9]*)n', '.*', '-?(?:0|[1-9][0-9]*)(?:.[0-9]+)?', '-?(?:0|[1-9][0-9]*)', '(?!)', '(', ')', '$', '|'], input), ([_0, input]) => [S.PatternTextMapping(_0), input]);
+export const PatternText = (input) => If(Token.Until_1(['-?(?:0|[1-9][0-9]*)n', '.*', '-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?', '-?(?:0|[1-9][0-9]*)', '(?!)', '(', ')', '$', '|'], input), ([_0, input]) => [S.PatternTextMapping(_0), input]);
 export const PatternBase = (input) => If(If(PatternBigInt(input), ([_0, input]) => [_0, input], () => If(PatternString(input), ([_0, input]) => [_0, input], () => If(PatternNumber(input), ([_0, input]) => [_0, input], () => If(PatternInteger(input), ([_0, input]) => [_0, input], () => If(PatternNever(input), ([_0, input]) => [_0, input], () => If(PatternGroup(input), ([_0, input]) => [_0, input], () => If(PatternText(input), ([_0, input]) => [_0, input], () => []))))))), ([_0, input]) => [S.PatternBaseMapping(_0), input]);
 export const PatternGroup = (input) => If(If(Token.Const('(', input), ([_0, input]) => If(PatternBody(input), ([_1, input]) => If(Token.Const(')', input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [S.PatternGroupMapping(_0), input]);
 export const PatternUnion = (input) => If(If(If(PatternTerm(input), ([_0, input]) => If(Token.Const('|', input), ([_1, input]) => If(PatternUnion(input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [_0, input], () => If(If(PatternTerm(input), ([_0, input]) => [[_0], input]), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => []))), ([_0, input]) => [S.PatternUnionMapping(_0), input]);

package/node_modules/typebox/build/type/script/script.d.mts

@@ -1,12 +1,11 @@
 import type { TArrayOptions, TIntersectOptions, TNumberOptions, TObjectOptions, TStringOptions, TTupleOptions } from '../../type/index.mjs';
-import { type TInstantiateType } from '../engine/instantiate.mjs';
 import { type TNever, type TSchema, type TProperties } from '../types/index.mjs';
+import { type TInstantiateType } from '../engine/instantiate.mjs';
+import { type TState } from '../engine/instantiate.mjs';
 import * as Parser from './parser.mjs';
 export type TScriptOptions = TArrayOptions | TIntersectOptions | TNumberOptions | TObjectOptions | TStringOptions | TTupleOptions;
 /** Parses a string-based TypeScript type expression into a TypeBox type. */
-export type TScript<Context extends TProperties, Input extends string> = (Parser.TScript<Input> extends [infer Type extends TSchema, string] ? TInstantiateType<Context, {
-    callstack: [];
-}, Type> : TNever);
+export type TScript<Context extends TProperties, Input extends string> = (Parser.TScript<Input> extends [infer Type extends TSchema, string] ? TInstantiateType<Context, TState<[], []>, Type> : TNever);
 /** Parses a type from a TypeScript type expression */
 export declare function Script<Script extends string>(input: Script): TScript<{}, Script>;
 /** Parses a type from a TypeScript type expression */

package/node_modules/typebox/build/type/script/script.mjs

@@ -3,8 +3,9 @@
 import { Arguments } from '../../system/arguments/index.mjs';
 import { Memory } from '../../system/memory/index.mjs';
 import { Guard } from '../../guard/index.mjs';
-import { InstantiateType } from '../engine/instantiate.mjs';
 import { Never } from '../types/index.mjs';
+import { InstantiateType } from '../engine/instantiate.mjs';
+import { State } from '../engine/instantiate.mjs';
 import * as Parser from './parser.mjs';
 /** Parses a type from a TypeScript type expression */
 export function Script(...args) {
@@ -15,7 +16,7 @@ export function Script(...args) {
     });
     const result = Parser.Script(input);
     const parsed = Guard.IsArray(result) && Guard.IsEqual(result.length, 2)
-        ? InstantiateType(context, { callstack: [] }, result[0])
+        ? InstantiateType(context, State([], []), result[0])
         : Never();
     return Memory.Update(parsed, {}, options);
 }

package/node_modules/typebox/build/type/script/token/internal/guard.d.mts

@@ -1 +1 @@
-export { IsArray, IsEqual, IsString, TakeLeft } from '../../../../guard/guard.mjs';
+export { IsArray, IsEqual, IsString, ShiftLeft } from '../../../../guard/guard.mjs';

package/node_modules/typebox/build/type/script/token/internal/guard.mjs

@@ -1,5 +1,5 @@
 // deno-coverage-ignore-start - parsebox tested
-export { IsArray, IsEqual, IsString, TakeLeft } from '../../../../guard/guard.mjs';
+export { IsArray, IsEqual, IsString, ShiftLeft } from '../../../../guard/guard.mjs';
 // ------------------------------------------------------------------
 // Internal Guards to ensure Token is portable.
 // ------------------------------------------------------------------

package/node_modules/typebox/build/type/script/token/internal/take.mjs

@@ -12,7 +12,7 @@ export function Take(variants, input) {
     // ----------------------------------------------------------------
     // Symmetric
     // ----------------------------------------------------------------
-    // return Guard.TakeLeft(variants, (valueLeft, valueRight) => 
+    // return Guard.ShiftLeft(variants, (valueLeft, valueRight) => 
     //   Match(TakeVariant(valueLeft, input), (take, rest) => 
     //     [take, rest],
     //     () => Take(valueRight, input)),

package/node_modules/typebox/build/type/script/token/until.mjs

@@ -1,13 +1,13 @@
 // deno-coverage-ignore-start - parsebox tested
 // deno-fmt-ignore-file
 import { Match } from './internal/match.mjs';
-import { IsEqual, TakeLeft } from './internal/guard.mjs';
+import { IsEqual, ShiftLeft } from './internal/guard.mjs';
 function TakeOne(input) {
     const result = IsEqual(input, '') ? [] : [input.slice(0, 1), input.slice(1)];
     return result;
 }
 function IsInputMatchSentinal(end, input) {
-    return TakeLeft(end, (left, right) => input.startsWith(left)
+    return ShiftLeft(end, (left, right) => input.startsWith(left)
         ? true
         : IsInputMatchSentinal(right, input), () => false);
 }

package/node_modules/typebox/build/type/types/_codec.d.mts

@@ -1,30 +1,30 @@
-import { type StaticDirection, type StaticType } from './static.mjs';
+import { type StaticDirection, type StaticDecode, type StaticType } from './static.mjs';
 import { type TSchema } from './schema.mjs';
 import { type TProperties } from './properties.mjs';
 export type StaticCodec<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Decoded extends unknown> = (Direction extends 'Decode' ? Decoded : StaticType<Stack, Direction, Context, This, Omit<Type, '~codec'>>);
-export type TDecodeCallback<Type extends TSchema, Decoded = unknown> = (input: StaticType<[], 'Decode', {}, {}, Type>) => Decoded;
-export type TEncodeCallback<Type extends TSchema, Decoded = unknown> = (input: Decoded) => StaticType<[], 'Decode', {}, {}, Type>;
+export type TDecodeCallback<Encoded extends unknown, Decoded = unknown> = (input: Encoded) => Decoded;
+export type TEncodeCallback<Encoded extends unknown, Decoded = unknown> = (input: Decoded) => Encoded;
 export type TCodec<Type extends TSchema = TSchema, Decoded extends unknown = unknown> = Type & {
     '~codec': {
-        encode: TDecodeCallback<Type, Decoded>;
-        decode: TEncodeCallback<Type, Decoded>;
+        encode: TDecodeCallback<unknown, Decoded>;
+        decode: TEncodeCallback<unknown, Decoded>;
     };
 };
-export declare class EncodeBuilder<Type extends TSchema, Decoded extends unknown> {
+export declare class EncodeBuilder<Type extends TSchema, Encoded extends unknown, Decoded extends unknown> {
     private readonly type;
     private readonly decode;
     constructor(type: Type, decode: globalThis.Function);
-    Encode<Callback extends TEncodeCallback<Type, Decoded>>(callback: Callback): TCodec<Type, Decoded>;
+    Encode(callback: TEncodeCallback<Encoded, Decoded>): TCodec<Type, Decoded>;
 }
-export declare class DecodeBuilder<Type extends TSchema> {
+export declare class DecodeBuilder<Type extends TSchema, Encoded extends unknown> {
     private readonly type;
     constructor(type: Type);
-    Decode<Callback extends TDecodeCallback<Type>>(callback: Callback): EncodeBuilder<Type, ReturnType<Callback>>;
+    Decode<Callback extends TDecodeCallback<Encoded, unknown>>(callback: Callback): EncodeBuilder<Type, Encoded, ReturnType<Callback>>;
 }
 /** Creates a bi-directional Codec. Codec functions are called on Value.Decode and Value.Encode. */
-export declare function Codec<Type extends TSchema>(type: Type): DecodeBuilder<Type>;
+export declare function Codec<Type extends TSchema>(type: Type): DecodeBuilder<Type, StaticDecode<Type>>;
 /** Createsa  uni-directional Codec with Decode only. The Decode function is called on Value.Decode */
-export declare function Decode<Type extends TSchema, Callback extends TDecodeCallback<Type>>(type: Type, callback: Callback): TCodec<Type, ReturnType<Callback>>;
+export declare function Decode<Type extends TSchema, Callback extends TDecodeCallback<StaticDecode<Type>, unknown>>(type: Type, callback: Callback): TCodec<Type, ReturnType<Callback>>;
 /** Creates a uni-directional Codec with Encode only. The Encode function is called on Value.Encode */
-export declare function Encode<Type extends TSchema, Callback extends TEncodeCallback<Type, unknown>>(type: Type, callback: Callback): TCodec<Type, unknown>;
+export declare function Encode<Type extends TSchema>(type: Type, callback: TEncodeCallback<StaticDecode<Type>, unknown>): TCodec<Type, unknown>;
 export declare function IsCodec(value: unknown): value is TCodec;

package/node_modules/typebox/build/type/types/_codec.mjs

@@ -1,4 +1,3 @@
-// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../system/index.mjs';
 import { Guard } from '../../guard/index.mjs';

package/node_modules/typebox/build/type/types/_immutable.d.mts

@@ -1,16 +1,9 @@
 import { type TSchema } from './schema.mjs';
-/** Removes Immutable from the given type. */
-export type TImmutableRemove<Type extends TSchema, Result extends TSchema = Type extends TImmutable<infer Type extends TSchema> ? Type : Type> = Result;
-/** Removes Immutable from the given type. */
-export declare function ImmutableRemove<Type extends TSchema>(type: Type): TImmutableRemove<Type>;
-/** Adds Immutable to the given type. */
-export type TImmutableAdd<Type extends TSchema = TSchema> = ('~immutable' extends keyof Type ? Type : TImmutable<Type>);
-/** Adds Immutable to the given type. */
-export declare function ImmutableAdd<Type extends TSchema>(type: Type): TImmutableAdd<Type>;
+import { type TAddImmutable } from '../action/_add_immutable.mjs';
 export type TImmutable<Type extends TSchema = TSchema> = (Type & {
     '~immutable': true;
 });
 /** Applies an Immutable modifier to the given type. */
-export declare function Immutable<Type extends TSchema>(type: Type): TImmutableAdd<Type>;
+export declare function Immutable<Type extends TSchema>(type: Type): TAddImmutable<Type>;
 /** Returns true if the given value is a TImmutable */
 export declare function IsImmutable(value: unknown): value is TImmutable<TSchema>;

package/node_modules/typebox/build/type/types/_immutable.mjs

@@ -1,21 +1,13 @@
 // deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
 import { Guard } from '../../guard/index.mjs';
 import { IsSchema } from './schema.mjs';
-/** Removes Immutable from the given type. */
-export function ImmutableRemove(type) {
-    return Memory.Discard(type, ['~immutable']);
-}
-/** Adds Immutable to the given type. */
-export function ImmutableAdd(type) {
-    return Memory.Update(type, { '~immutable': true }, {});
-}
+import { AddImmutable } from '../action/_add_immutable.mjs';
 // ------------------------------------------------------------------
 // Factory
 // ------------------------------------------------------------------
 /** Applies an Immutable modifier to the given type. */
 export function Immutable(type) {
-    return ImmutableAdd(type);
+    return AddImmutable(type);
 }
 // ------------------------------------------------------------------
 // Guard

package/node_modules/typebox/build/type/types/_optional.d.mts

@@ -1,16 +1,9 @@
 import { type TSchema } from './schema.mjs';
-/** Removes Optional from the given type. */
-export type TOptionalRemove<Type extends TSchema, Result extends TSchema = Type extends TOptional<infer Type extends TSchema> ? Type : Type> = Result;
-/** Removes Optional from the given type. */
-export declare function OptionalRemove<Type extends TSchema>(type: Type): TOptionalRemove<Type>;
-/** Adds Optional to the given type. */
-export type TOptionalAdd<Type extends TSchema = TSchema, Result extends TSchema = '~optional' extends keyof Type ? Type : TOptional<Type>> = Result;
-/** Adds Optional to the given type. */
-export declare function OptionalAdd<Type extends TSchema>(type: Type): TOptionalAdd<Type>;
+import { type TAddOptional } from '../action/_add_optional.mjs';
 export type TOptional<Type extends TSchema = TSchema> = (Type & {
     '~optional': true;
 });
 /** Applies an Optional modifier to the given type. */
-export declare function Optional<Type extends TSchema>(type: Type): TOptionalAdd<Type>;
+export declare function Optional<Type extends TSchema>(type: Type): TAddOptional<Type>;
 /** Returns true if the given value is TOptional */
 export declare function IsOptional(value: unknown): value is TOptional<TSchema>;

package/node_modules/typebox/build/type/types/_optional.mjs

@@ -1,22 +1,13 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
-import { Memory } from '../../system/memory/index.mjs';
 import { IsSchema } from './schema.mjs';
-/** Removes Optional from the given type. */
-export function OptionalRemove(type) {
-    const result = Memory.Discard(type, ['~optional']);
-    return result;
-}
-/** Adds Optional to the given type. */
-export function OptionalAdd(type) {
-    return Memory.Update(type, { '~optional': true }, {});
-}
+import { AddOptional } from '../action/_add_optional.mjs';
 // ------------------------------------------------------------------
 // Factory
 // ------------------------------------------------------------------
 /** Applies an Optional modifier to the given type. */
 export function Optional(type) {
-    return OptionalAdd(type);
+    return AddOptional(type);
 }
 // ------------------------------------------------------------------
 // Guard

package/node_modules/typebox/build/type/types/_readonly.d.mts

@@ -1,16 +1,9 @@
 import { type TSchema } from './schema.mjs';
-/** Removes a Readonly property modifier from the given type. */
-export type TReadonlyRemove<Type extends TSchema, Result extends TSchema = Type extends TReadonly<infer Type extends TSchema> ? Type : Type> = Result;
-/** Removes a Readonly property modifier from the given type. */
-export declare function ReadonlyRemove<Type extends TSchema>(type: Type): TReadonlyRemove<Type>;
-/** Adds a Readonly property modifier to the given type. */
-export type TReadonlyAdd<Type extends TSchema = TSchema> = ('~readonly' extends keyof Type ? Type : TReadonly<Type>);
-/** Adds a Readonly property modifier to the given type. */
-export declare function ReadonlyAdd<Type extends TSchema>(type: Type): TReadonlyAdd<Type>;
+import { type TAddReadonly } from '../action/_add_readonly.mjs';
 export type TReadonly<Type extends TSchema = TSchema> = (Type & {
     '~readonly': true;
 });
 /** Applies an Readonly property modifier to the given type. */
-export declare function Readonly<Type extends TSchema>(type: Type): TReadonlyAdd<Type>;
+export declare function Readonly<Type extends TSchema>(type: Type): TAddReadonly<Type>;
 /** Returns true if the given value is a TReadonly */
 export declare function IsReadonly(value: unknown): value is TReadonly<TSchema>;

package/node_modules/typebox/build/type/types/_readonly.mjs

@@ -1,21 +1,13 @@
 // deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
 import { Guard } from '../../guard/index.mjs';
 import { IsSchema } from './schema.mjs';
-/** Removes a Readonly property modifier from the given type. */
-export function ReadonlyRemove(type) {
-    return Memory.Discard(type, ['~readonly']);
-}
-/** Adds a Readonly property modifier to the given type. */
-export function ReadonlyAdd(type) {
-    return Memory.Update(type, { '~readonly': true }, {});
-}
+import { AddReadonly } from '../action/_add_readonly.mjs';
 // ------------------------------------------------------------------
 // Factory
 // ------------------------------------------------------------------
 /** Applies an Readonly property modifier to the given type. */
 export function Readonly(type) {
-    return ReadonlyAdd(type);
+    return AddReadonly(type);
 }
 // ------------------------------------------------------------------
 // Guard

package/node_modules/typebox/build/type/types/_refine.d.mts

@@ -6,20 +6,18 @@ export type TRefineAdd<Type extends TSchema = TSchema> = ('~refine' extends keyo
 export declare function RefineAdd<Type extends TSchema>(type: Type, refinement: TRefinement<Type>): TRefineAdd<Type>;
 /** Represents a type with embedded Refine check. */
 export type TRefine<Type extends TSchema = TSchema> = (Type & {
-    '~refine': TRefinement<Type>[];
+    '~refine': TRefinement<unknown>[];
 });
-export type TRefineCheckCallback<Type extends TSchema = TSchema> = (value: Static<Type>) => boolean;
-export type TRefineErrorCallback<Type extends TSchema = TSchema> = (value: Static<Type>) => string;
-export interface TRefinement<Type extends TSchema = TSchema> {
-    check: TRefineCheckCallback<Type>;
-    error: TRefineErrorCallback<Type>;
+export type TRefineCheckCallback<Value extends unknown = unknown> = (value: Value) => boolean;
+export type TRefineErrorCallback<Value extends unknown = unknown> = (value: Value) => string;
+export interface TRefinement<Value extends unknown = unknown> {
+    check: TRefineCheckCallback<Value>;
+    error: TRefineErrorCallback<Value>;
 }
 /** Refines a type with an explicit check */
-export declare function Refine<Type extends TSchema>(type: Type, check: TRefineCheckCallback<Type>, error: TRefineErrorCallback<Type>): TRefineAdd<Type>;
+export declare function Refine<Type extends TSchema, Value = Static<Type>>(type: Type, check: TRefineCheckCallback<Value>, error: TRefineErrorCallback<Value>): TRefineAdd<Type>;
 /** Refines a type with an explicit check */
-export declare function Refine<Type extends TSchema>(type: Type, check: TRefineCheckCallback<Type>): TRefineAdd<Type>;
-/** @deprecated Use the error callback signature to generate error message. This overload will be removed in the next version  */
-export declare function Refine<Type extends TSchema>(type: Type, check: TRefineCheckCallback<Type>, message: string): TRefineAdd<Type>;
+export declare function Refine<Type extends TSchema, Value = Static<Type>>(type: Type, check: TRefineCheckCallback<Value>): TRefineAdd<Type>;
 /** Returns true if the given value is a TRefinement. */
 export declare function IsRefinement(value: unknown): value is TRefinement;
 /** Returns true if the given value is a TRefine. */

package/node_modules/typebox/build/type/types/_refine.mjs

@@ -10,11 +10,10 @@ export function RefineAdd(type, refinement) {
 }
 /** Refines a type with an explicit check */
 export function Refine(...args) {
-    const [type, check, error_or_message] = Arguments.Match(args, {
+    const [type, check, error] = Arguments.Match(args, {
         3: (type, check, error) => [type, check, error],
         2: (type, check) => [type, check, () => 'Refine Error'],
     });
-    const error = Guard.IsString(error_or_message) ? () => error_or_message : error_or_message;
     return RefineAdd(type, { check, error });
 }
 // ------------------------------------------------------------------

package/node_modules/typebox/build/type/types/call.d.mts

@@ -1,16 +1,16 @@
 import { type TSchema } from './schema.mjs';
 import { type TCallInstantiate } from '../engine/call/instantiate.mjs';
+import { type TState } from '../engine/instantiate.mjs';
 /** Represents a deferred generic Call */
 export interface TCall<Target extends TSchema = TSchema, Arguments extends TSchema[] = TSchema[]> extends TSchema {
     '~kind': 'Call';
+    type: 'call';
     target: Target;
     arguments: Arguments;
 }
 export type TCallConstruct<Target extends TSchema, Arguments extends TSchema[], Result extends TSchema = TCall<Target, Arguments>> = Result;
 export declare function CallConstruct<Target extends TSchema, Arguments extends TSchema[]>(target: Target, arguments_: [...Arguments]): TCallConstruct<Target, Arguments>;
 /** Creates a Call type. */
-export declare function Call<Target extends TSchema, Arguments extends TSchema[]>(target: Target, arguments_: [...Arguments]): TCallInstantiate<{}, {
-    callstack: [];
-}, Target, Arguments>;
+export declare function Call<Target extends TSchema, Arguments extends TSchema[]>(target: Target, arguments_: [...Arguments]): TCallInstantiate<{}, TState<[], []>, Target, Arguments>;
 /** Returns true if the given type is a TCall. */
 export declare function IsCall(value: unknown): value is TCall;

package/node_modules/typebox/build/type/types/call.mjs

@@ -3,15 +3,16 @@
 import { Memory } from '../../system/memory/index.mjs';
 import { IsKind } from './schema.mjs';
 import { CallInstantiate } from '../engine/call/instantiate.mjs';
+import { State } from '../engine/instantiate.mjs';
 export function CallConstruct(target, arguments_) {
-    return Memory.Create({ ['~kind']: 'Call' }, { target, arguments: arguments_ }, {});
+    return Memory.Create({ ['~kind']: 'Call' }, { type: 'call', target, arguments: arguments_ }, {});
 }
 // ------------------------------------------------------------------
 // Factory
 // ------------------------------------------------------------------
 /** Creates a Call type. */
 export function Call(target, arguments_) {
-    return CallInstantiate({}, { callstack: [] }, target, arguments_);
+    return CallInstantiate({}, State([], []), target, arguments_);
 }
 // ------------------------------------------------------------------
 // Guard

package/node_modules/typebox/build/type/types/deferred.d.mts

@@ -2,6 +2,7 @@ import { type TSchema, type TSchemaOptions } from './schema.mjs';
 /** Represents a deferred action. */
 export interface TDeferred<Action extends string = string, Types extends TSchema[] = TSchema[]> extends TSchema {
     '~kind': 'Deferred';
+    type: 'deferred';
     action: Action;
     parameters: Types;
     options: TSchemaOptions;

package/node_modules/typebox/build/type/types/deferred.mjs

@@ -5,7 +5,7 @@ import { IsKind } from './schema.mjs';
 // ------------------------------------------------------------------
 /** Creates a Deferred action. */
 export function Deferred(action, parameters, options) {
-    return Memory.Create({ '~kind': 'Deferred' }, { action, parameters, options }, {});
+    return Memory.Create({ '~kind': 'Deferred' }, { type: 'deferred', action, parameters, options }, {});
 }
 // ------------------------------------------------------------------
 // Guard

package/node_modules/typebox/build/type/types/dependent.d.mts

@@ -0,0 +1,17 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+import { type TProperties } from './properties.mjs';
+export type StaticDependent<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, If extends TSchema, Then extends TSchema, Else extends TSchema, StaticIf extends unknown = StaticType<Stack, Direction, Context, This, If>, StaticThen extends unknown = StaticType<Stack, Direction, Context, This, Then>, StaticElse extends unknown = StaticType<Stack, Direction, Context, This, Else>, Result extends unknown = (StaticIf & StaticThen) | Exclude<StaticElse, StaticIf>> = Result;
+/** Represents a Dependent Type */
+export interface TDependent<If extends TSchema = TSchema, Then extends TSchema = TSchema, Else extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Dependent';
+    if: If;
+    then: Then;
+    else: Else;
+}
+/** Creates a Dependent type */
+export declare function Dependent<If extends TSchema, Then extends TSchema, Else extends TSchema>(if_: If, then_: Then, else_: Else, options?: TSchemaOptions): TDependent<If, Then, Else>;
+/** Returns true if the given value is TDependent. */
+export declare function IsDependent(value: unknown): value is TDependent;
+/** Extracts options from a IsDependent. */
+export declare function DependentOptions(type: TDependent): TSchemaOptions;

package/node_modules/typebox/build/type/types/dependent.mjs

@@ -0,0 +1,24 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Dependent type */
+export function Dependent(if_, then_, else_, options = {}) {
+    return Memory.Create({ '~kind': 'Dependent' }, { if: if_, then: then_, else: else_ }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TDependent. */
+export function IsDependent(value) {
+    return IsKind(value, 'Dependent');
+}
+// ------------------------------------------------------------------
+// Options
+// ------------------------------------------------------------------
+/** Extracts options from a IsDependent. */
+export function DependentOptions(type) {
+    return Memory.Discard(type, ['~kind', 'if', 'then', 'else']);
+}

package/node_modules/typebox/build/type/types/enum.d.mts

@@ -2,7 +2,9 @@ import { type TSchema, type TSchemaOptions } from './schema.mjs';
 import { type TTypeScriptEnumLike } from '../engine/enum/typescript_enum_to_enum_values.mjs';
 import { type TTypeScriptEnumToEnumValues } from '../engine/enum/typescript_enum_to_enum_values.mjs';
 export type StaticEnum<Values extends TEnumValue[]> = (Values[number]);
-export type TEnumValue = string | number | null;
+export type TEnumValue = string | number;
+/** Returns true if the given value is a EnumValue */
+export declare function IsEnumValue(value: unknown): value is TEnumValue;
 /** Represents an Enum type. */
 export interface TEnum<Values extends TEnumValue[] = TEnumValue[]> extends TSchema {
     '~kind': 'Enum';

package/node_modules/typebox/build/type/types/enum.mjs

@@ -1,8 +1,13 @@
 // deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
 import { Memory } from '../../system/memory/index.mjs';
 import { IsKind } from './schema.mjs';
 import { IsTypeScriptEnumLike } from '../engine/enum/typescript_enum_to_enum_values.mjs';
 import { TypeScriptEnumToEnumValues } from '../engine/enum/typescript_enum_to_enum_values.mjs';
+/** Returns true if the given value is a EnumValue */
+export function IsEnumValue(value) {
+    return Guard.IsString(value) || Guard.IsNumber(value);
+}
 /** Creates an Enum type. */
 export function Enum(value, options) {
     const values = IsTypeScriptEnumLike(value) ? TypeScriptEnumToEnumValues(value) : value;