typebox 1.0.35 → 1.0.36

package/build/type/engine/instantiate.d.mts

@@ -1,3 +1,4 @@
+import { type TImmutable } from '../types/_immutable.mjs';
 import { type TOptional, TOptionalAdd, TOptionalRemove } from '../types/_optional.mjs';
 import { type TReadonly, TReadonlyAdd, TReadonlyRemove } from '../types/_readonly.mjs';
 import { type TSchema } from '../types/schema.mjs';
@@ -151,7 +152,7 @@ type TInstantiateDeferred<Context extends TProperties, State extends TState, Act
     Action,
     Parameters
 ] extends ['Uppercase', [infer Type extends TSchema]] ? TUppercaseInstantiate<Context, State, Type> : TDeferred<Action, Parameters>);
-export type TInstantiateType<Context extends TProperties, State extends TState, Input extends TSchema, ModifierState extends [TSchema, ModifierAction, ModifierAction] = TModifierActions<Input, Input extends TReadonly<Input> ? 'add' : 'none', Input extends TOptional<Input> ? 'add' : 'none'>, Type extends TSchema = ModifierState[0], Instantiated extends TSchema = (Type extends TRef<infer Ref extends string> ? TRefInstantiate<Context, State, Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TInstantiateType<Context, State, Type>> : Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TInstantiateType<Context, State, Type>> : Type extends TCall<infer Target extends TSchema, infer Parameters extends TSchema[]> ? TCallInstantiate<Context, State, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, InstanceType>> : Type extends TDeferred<infer Action extends string, infer Types extends TSchema[]> ? TInstantiateDeferred<Context, State, Action, Types> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, ReturnType>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TInstantiateTypes<Context, State, Types>> : Type extends TIterator<infer Type extends TSchema> ? TIterator<TInstantiateType<Context, State, Type>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TInstantiateProperties<Context, State, Properties>> : Type extends TPromise<infer Type extends TSchema> ? TPromise<TInstantiateType<Context, State, Type>> : Type extends TRecord<infer Key extends string, infer Type extends TSchema> ? TRecord<Key, TInstantiateType<Context, State, Type>> : Type extends TRest<infer Type extends TSchema> ? TRest<TInstantiateType<Context, State, Type>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TInstantiateElements<Context, State, Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TInstantiateTypes<Context, State, Types>> : Type)> = TApplyReadonly<ModifierState[1], TApplyOptional<ModifierState[2], Instantiated>>;
+export type TInstantiateType<Context extends TProperties, State extends TState, Input extends TSchema, IsImmutable extends boolean = Input extends TImmutable ? true : false, ModifierState extends [TSchema, ModifierAction, ModifierAction] = TModifierActions<Input, Input extends TReadonly<Input> ? 'add' : 'none', Input extends TOptional<Input> ? 'add' : 'none'>, Type extends TSchema = ModifierState[0], Instantiated extends TSchema = (Type extends TRef<infer Ref extends string> ? TRefInstantiate<Context, State, Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TInstantiateType<Context, State, Type>> : Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TInstantiateType<Context, State, Type>> : Type extends TCall<infer Target extends TSchema, infer Parameters extends TSchema[]> ? TCallInstantiate<Context, State, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, InstanceType>> : Type extends TDeferred<infer Action extends string, infer Types extends TSchema[]> ? TInstantiateDeferred<Context, State, Action, Types> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, ReturnType>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TInstantiateTypes<Context, State, Types>> : Type extends TIterator<infer Type extends TSchema> ? TIterator<TInstantiateType<Context, State, Type>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TInstantiateProperties<Context, State, Properties>> : Type extends TPromise<infer Type extends TSchema> ? TPromise<TInstantiateType<Context, State, Type>> : Type extends TRecord<infer Key extends string, infer Type extends TSchema> ? TRecord<Key, TInstantiateType<Context, State, Type>> : Type extends TRest<infer Type extends TSchema> ? TRest<TInstantiateType<Context, State, Type>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TInstantiateElements<Context, State, Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TInstantiateTypes<Context, State, Types>> : Type), WithImmutable extends TSchema = IsImmutable extends true ? TImmutable<Instantiated> : Instantiated, WithModifiers extends TSchema = TApplyReadonly<ModifierState[1], TApplyOptional<ModifierState[2], WithImmutable>>> = WithModifiers;
 export declare function InstantiateType<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, input: Type): TInstantiateType<Context, State, Type>;
 /** Instantiates computed schematics using the given context and type. */
 export type TInstantiate<Context extends TProperties, Type extends TSchema> = (TInstantiateType<Context, {

package/build/type/engine/instantiate.mjs

@@ -4,6 +4,7 @@ import { Guard } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Modifiers
 // ------------------------------------------------------------------
+import { IsImmutable, Immutable } from '../types/_immutable.mjs';
 import { IsOptional, OptionalAdd, OptionalRemove } from '../types/_optional.mjs';
 import { IsReadonly, ReadonlyAdd, ReadonlyRemove } from '../types/_readonly.mjs';
 // ------------------------------------------------------------------
@@ -139,6 +140,7 @@ function InstantiateDeferred(context, state, action, parameters, options) {
                                                                                                             Deferred(action, parameters, options));
 }
 export function InstantiateType(context, state, input) {
+    const isImmutable = IsImmutable(input);
     const modifierActions = ModifierActions(input, IsReadonly(input) ? 'add' : 'none', IsOptional(input) ? 'add' : 'none');
     const type = modifierActions[0];
     const instantiated = (IsRef(type) ? RefInstantiate(context, state, type.$ref) :
@@ -157,7 +159,9 @@ export function InstantiateType(context, state, input) {
                                                         IsTuple(type) ? Tuple(InstantiateElements(context, state, type.items), TupleOptions(type)) :
                                                             IsUnion(type) ? Union(InstantiateTypes(context, state, type.anyOf), UnionOptions(type)) :
                                                                 type);
-    return ApplyReadonly(modifierActions[1], ApplyOptional(modifierActions[2], instantiated));
+    const withImmutable = isImmutable ? Immutable(instantiated) : instantiated;
+    const withModifiers = ApplyReadonly(modifierActions[1], ApplyOptional(modifierActions[2], withImmutable));
+    return withModifiers;
 }
 /** Instantiates computed schematics using the given context and type. */
 export function Instantiate(context, type) {

package/build/type/extends/array.d.mts

@@ -1,7 +1,20 @@
 import { type TSchema } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TArray } from '../types/array.mjs';
+import { type TImmutable } from '../types/_immutable.mjs';
 import { type TExtendsRight } from './extends-right.mjs';
 import { type TExtendsLeft } from './extends-left.mjs';
-export type TExtendsArray<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TArray<infer Type extends TSchema> ? TExtendsLeft<Inferred, Left, Type> : TExtendsRight<Inferred, TArray<Left>, Right>);
-export declare function ExtendsArray<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsArray<Inferred, Left, Right>;
+import * as Result from './result.mjs';
+type TExtendsImmutable<Left extends TSchema, Right extends TSchema, IsImmutableLeft extends boolean = Left extends TImmutable ? true : false, IsImmutableRight extends boolean = Right extends TImmutable ? true : false, Result extends boolean = [
+    IsImmutableLeft,
+    IsImmutableRight
+] extends [true, true] ? true : [
+    IsImmutableLeft,
+    IsImmutableRight
+] extends [false, true] ? true : [
+    IsImmutableLeft,
+    IsImmutableRight
+] extends [true, false] ? false : true> = Result;
+export type TExtendsArray<Inferred extends TProperties, ArrayLeft extends TSchema, Left extends TSchema, Right extends TSchema> = (Right extends TArray<infer Type extends TSchema> ? TExtendsImmutable<ArrayLeft, Right> extends true ? TExtendsLeft<Inferred, Left, Type> : Result.TExtendsFalse : TExtendsRight<Inferred, ArrayLeft, Right>);
+export declare function ExtendsArray<Inferred extends TProperties, ArrayLeft extends TSchema, Left extends TSchema, Right extends TSchema>(inferred: Inferred, arrayLeft: ArrayLeft, left: Left, right: Right): TExtendsArray<Inferred, ArrayLeft, Left, Right>;
+export {};

package/build/type/extends/array.mjs

@@ -1,9 +1,21 @@
 // deno-fmt-ignore-file
-import { Array, IsArray } from '../types/array.mjs';
+import { IsArray } from '../types/array.mjs';
+import { IsImmutable } from '../types/_immutable.mjs';
 import { ExtendsRight } from './extends-right.mjs';
 import { ExtendsLeft } from './extends-left.mjs';
-export function ExtendsArray(inferred, left, right) {
+import * as Result from './result.mjs';
+function ExtendsImmutable(left, right) {
+    const isImmutableLeft = IsImmutable(left);
+    const isImmutableRight = IsImmutable(right);
+    return (isImmutableLeft && isImmutableRight ? true :
+        !isImmutableLeft && isImmutableRight ? true :
+            isImmutableLeft && !isImmutableRight ? false :
+                true);
+}
+export function ExtendsArray(inferred, arrayLeft, left, right) {
     return (IsArray(right)
-        ? ExtendsLeft(inferred, left, right.items)
-        : ExtendsRight(inferred, Array(left), right));
+        ? ExtendsImmutable(arrayLeft, right)
+            ? ExtendsLeft(inferred, left, right.items)
+            : Result.ExtendsFalse()
+        : ExtendsRight(inferred, arrayLeft, right));
 }

package/build/type/extends/extends-left.d.mts

@@ -51,5 +51,5 @@ import { type TProperties } from '../types/properties.mjs';
 import { type TUnion } from '../types/union.mjs';
 import { type TVoid } from '../types/void.mjs';
 import * as Result from './result.mjs';
-export type TExtendsLeft<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Left extends TAny ? TExtendsAny<Inferred, Left, Right> : Left extends TArray<infer Type extends TSchema> ? TExtendsArray<Inferred, Type, Right> : Left extends TAsyncIterator<infer Type extends TSchema> ? TExtendsAsyncIterator<Inferred, Type, Right> : Left extends TBigInt ? TExtendsBigInt<Inferred, Left, Right> : Left extends TBoolean ? TExtendsBoolean<Inferred, Left, Right> : Left extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TExtendsConstructor<Inferred, Parameters, InstanceType, Right> : Left extends TEnum<infer Values extends TEnumValue[]> ? TExtendsEnum<Inferred, TEnum<Values>, Right> : Left extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TExtendsFunction<Inferred, Parameters, ReturnType, Right> : Left extends TInteger ? TExtendsInteger<Inferred, Left, Right> : Left extends TIntersect<infer Types extends TSchema[]> ? TExtendsIntersect<Inferred, Types, Right> : Left extends TIterator<infer Type extends TSchema> ? TExtendsIterator<Inferred, Type, Right> : Left extends TLiteral ? TExtendsLiteral<Inferred, Left, Right> : Left extends TNever ? TExtendsNever<Inferred, Left, Right> : Left extends TNull ? TExtendsNull<Inferred, Left, Right> : Left extends TNumber ? TExtendsNumber<Inferred, Left, Right> : Left extends TObject<infer Properties extends TProperties> ? TExtendsObject<Inferred, Properties, Right> : Left extends TPromise<infer Type extends TSchema> ? TExtendsPromise<Inferred, Type, Right> : Left extends TString ? TExtendsString<Inferred, Left, Right> : Left extends TSymbol ? TExtendsSymbol<Inferred, Left, Right> : Left extends TTemplateLiteral<infer Pattern extends string> ? TExtendsTemplateLiteral<Inferred, Pattern, Right> : Left extends TTuple<infer Types extends TSchema[]> ? TExtendsTuple<Inferred, Types, Right> : Left extends TUndefined ? TExtendsUndefined<Inferred, Left, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExtendsUnion<Inferred, Types, Right> : Left extends TUnknown ? TExtendsUnknown<Inferred, Left, Right> : Left extends TVoid ? TExtendsVoid<Inferred, Left, Right> : Result.TExtendsFalse);
+export type TExtendsLeft<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Left extends TAny ? TExtendsAny<Inferred, Left, Right> : Left extends TArray<infer Items extends TSchema> ? TExtendsArray<Inferred, Left, Items, Right> : Left extends TAsyncIterator<infer Type extends TSchema> ? TExtendsAsyncIterator<Inferred, Type, Right> : Left extends TBigInt ? TExtendsBigInt<Inferred, Left, Right> : Left extends TBoolean ? TExtendsBoolean<Inferred, Left, Right> : Left extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TExtendsConstructor<Inferred, Parameters, InstanceType, Right> : Left extends TEnum<infer Values extends TEnumValue[]> ? TExtendsEnum<Inferred, TEnum<Values>, Right> : Left extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TExtendsFunction<Inferred, Parameters, ReturnType, Right> : Left extends TInteger ? TExtendsInteger<Inferred, Left, Right> : Left extends TIntersect<infer Types extends TSchema[]> ? TExtendsIntersect<Inferred, Types, Right> : Left extends TIterator<infer Type extends TSchema> ? TExtendsIterator<Inferred, Type, Right> : Left extends TLiteral ? TExtendsLiteral<Inferred, Left, Right> : Left extends TNever ? TExtendsNever<Inferred, Left, Right> : Left extends TNull ? TExtendsNull<Inferred, Left, Right> : Left extends TNumber ? TExtendsNumber<Inferred, Left, Right> : Left extends TObject<infer Properties extends TProperties> ? TExtendsObject<Inferred, Properties, Right> : Left extends TPromise<infer Type extends TSchema> ? TExtendsPromise<Inferred, Type, Right> : Left extends TString ? TExtendsString<Inferred, Left, Right> : Left extends TSymbol ? TExtendsSymbol<Inferred, Left, Right> : Left extends TTemplateLiteral<infer Pattern extends string> ? TExtendsTemplateLiteral<Inferred, Pattern, Right> : Left extends TTuple<infer Types extends TSchema[]> ? TExtendsTuple<Inferred, Types, Right> : Left extends TUndefined ? TExtendsUndefined<Inferred, Left, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExtendsUnion<Inferred, Types, Right> : Left extends TUnknown ? TExtendsUnknown<Inferred, Left, Right> : Left extends TVoid ? TExtendsVoid<Inferred, Left, Right> : Result.TExtendsFalse);
 export declare function ExtendsLeft<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsLeft<Inferred, Left, Right>;

package/build/type/extends/extends-left.mjs

@@ -55,7 +55,7 @@ import { IsVoid } from '../types/void.mjs';
 import * as Result from './result.mjs';
 export function ExtendsLeft(inferred, left, right) {
     return (IsAny(left) ? ExtendsAny(inferred, left, right) :
-        IsArray(left) ? ExtendsArray(inferred, left.items, right) :
+        IsArray(left) ? ExtendsArray(inferred, left, left.items, right) :
             IsAsyncIterator(left) ? ExtendsAsyncIterator(inferred, left.iteratorItems, right) :
                 IsBigInt(left) ? ExtendsBigInt(inferred, left, right) :
                     IsBoolean(left) ? ExtendsBoolean(inferred, left, right) :

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

@@ -1,3 +1,4 @@
+import { 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';
@@ -12,6 +13,6 @@ type TExtendsLiteralBigInt<Inferred extends TProperties, Left extends bigint, Ri
 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> : TExtendsRight<Inferred, 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/build/type/extends/literal.mjs

@@ -1,4 +1,5 @@
 // deno-fmt-ignore-file
+import { Unreachable } from '../../system/unreachable/unreachable.mjs';
 import { Guard } from '../../guard/index.mjs';
 import { IsLiteral, Literal } from '../types/literal.mjs';
 import { IsBigInt } from '../types/bigint.mjs';
@@ -37,5 +38,7 @@ export function ExtendsLiteral(inferred, left, 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) :
-                    ExtendsRight(inferred, left, right));
+                    Unreachable() // ExtendsRight(inferred, left, right)
+    );
 }
+// deno-coverage-ignore-stop

package/build/type/script/mapping.d.mts

@@ -174,6 +174,8 @@ export type TExprTailMapping<Input extends [unknown, unknown, unknown] | []> = (
 export declare function ExprTailMapping(input: [unknown, unknown, unknown] | []): unknown;
 export type TExprMapping<Input extends [unknown, unknown]> = (Input extends [infer Left extends T.TSchema, infer Rest extends unknown[]] ? TExprBinaryMapping<Left, Rest> : []);
 export declare function ExprMapping(input: [unknown, unknown]): unknown;
+export type TExprReadonlyMapping<Input extends [unknown, unknown]> = (Input extends ['readonly', infer Type extends T.TSchema] ? T.TImmutableAdd<Type> : never);
+export declare function ExprReadonlyMapping(input: [unknown, unknown]): unknown;
 export type TExprPipeMapping<Input extends [unknown, unknown]> = (Input extends ['|', infer Type extends T.TSchema] ? Type : never);
 export declare function ExprPipeMapping(input: [unknown, unknown]): unknown;
 export type TGenericTypeMapping<Input extends [unknown, unknown, unknown]> = (Input extends [infer Arguments extends T.TParameter[], '=', infer Type extends T.TSchema] ? T.TGeneric<Arguments, Type> : never);

package/build/type/script/mapping.mjs

@@ -238,6 +238,9 @@ export function ExprMapping(input) {
     const [left, rest] = input;
     return ExprBinaryMapping(left, rest);
 }
+export function ExprReadonlyMapping(input) {
+    return T.ImmutableAdd(input[1]);
+}
 export function ExprPipeMapping(input) {
     return input[1];
 }

package/build/type/script/parser.d.mts

@@ -48,10 +48,11 @@ export type TExprTermTail<Input extends string> = ((Token.TConst<'&', Input> ext
 export type TExprTerm<Input extends string> = (TFactor<Input> extends [infer _0, infer Input extends string] ? (TExprTermTail<Input> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []) extends [infer _0 extends [unknown, unknown], infer Input extends string] ? [S.TExprTermMapping<_0>, Input] : [];
 export type TExprTail<Input extends string> = ((Token.TConst<'|', Input> extends [infer _0, infer Input extends string] ? (TExprTerm<Input> extends [infer _1, infer Input extends string] ? (TExprTail<Input> extends [infer _2, infer Input extends string] ? [[_0, _1, _2], Input] : []) : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : [[], Input] extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends [unknown, unknown, unknown] | [], infer Input extends string] ? [S.TExprTailMapping<_0>, Input] : [];
 export type TExpr<Input extends string> = (TExprTerm<Input> extends [infer _0, infer Input extends string] ? (TExprTail<Input> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []) extends [infer _0 extends [unknown, unknown], infer Input extends string] ? [S.TExprMapping<_0>, Input] : [];
+export type TExprReadonly<Input extends string> = (Token.TConst<'readonly', Input> extends [infer _0, infer Input extends string] ? (TExpr<Input> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []) extends [infer _0 extends [unknown, unknown], infer Input extends string] ? [S.TExprReadonlyMapping<_0>, Input] : [];
 export type TExprPipe<Input extends string> = (Token.TConst<'|', Input> extends [infer _0, infer Input extends string] ? (TExpr<Input> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []) extends [infer _0 extends [unknown, unknown], infer Input extends string] ? [S.TExprPipeMapping<_0>, Input] : [];
 export type TGenericType<Input extends string> = (TGenericParameters<Input> extends [infer _0, infer Input extends string] ? (Token.TConst<'=', Input> extends [infer _1, infer Input extends string] ? (TType<Input> extends [infer _2, infer Input extends string] ? [[_0, _1, _2], Input] : []) : []) : []) extends [infer _0 extends [unknown, unknown, unknown], infer Input extends string] ? [S.TGenericTypeMapping<_0>, Input] : [];
 export type TInferType<Input extends string> = ((Token.TConst<'infer', Input> extends [infer _0, infer Input extends string] ? (Token.TIdent<Input> extends [infer _1, infer Input extends string] ? (Token.TConst<'extends', Input> extends [infer _2, infer Input extends string] ? (TExpr<Input> extends [infer _3, infer Input extends string] ? [[_0, _1, _2, _3], Input] : []) : []) : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : (Token.TConst<'infer', Input> extends [infer _0, infer Input extends string] ? (Token.TIdent<Input> extends [infer _1, infer Input extends string] ? [[_0, _1], Input] : []) : []) extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends [unknown, unknown, unknown, unknown] | [unknown, unknown], infer Input extends string] ? [S.TInferTypeMapping<_0>, Input] : [];
-export type TType<Input extends string> = (TInferType<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TExprPipe<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TExpr<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends unknown, infer Input extends string] ? [S.TTypeMapping<_0>, Input] : [];
+export type TType<Input extends string> = (TInferType<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TExprPipe<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TExprReadonly<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : TExpr<Input> extends [infer _0, infer Input extends string] ? [_0, Input] : []) extends [infer _0 extends unknown, infer Input extends string] ? [S.TTypeMapping<_0>, Input] : [];
 export type TPropertyKeyNumber<Input extends string> = Token.TNumber<Input> extends [infer _0 extends string, infer Input extends string] ? [S.TPropertyKeyNumberMapping<_0>, Input] : [];
 export type TPropertyKeyIdent<Input extends string> = Token.TIdent<Input> extends [infer _0 extends string, infer Input extends string] ? [S.TPropertyKeyIdentMapping<_0>, Input] : [];
 export type TPropertyKeyQuoted<Input extends string> = Token.TString<['\'', '\"'], Input> extends [infer _0 extends string, infer Input extends string] ? [S.TPropertyKeyQuotedMapping<_0>, Input] : [];
@@ -176,6 +177,7 @@ export declare const ExprTermTail: (input: string) => [unknown, string] | [];
 export declare const ExprTerm: (input: string) => [unknown, string] | [];
 export declare const ExprTail: (input: string) => [unknown, string] | [];
 export declare const Expr: (input: string) => [unknown, string] | [];
+export declare const ExprReadonly: (input: string) => [unknown, string] | [];
 export declare const ExprPipe: (input: string) => [unknown, string] | [];
 export declare const GenericType: (input: string) => [unknown, string] | [];
 export declare const InferType: (input: string) => [unknown, string] | [];

package/build/type/script/parser.mjs

@@ -51,10 +51,11 @@ export const ExprTermTail = (input) => If(If(If(Token.Const('&', input), ([_0, i
 export const ExprTerm = (input) => If(If(Factor(input), ([_0, input]) => If(ExprTermTail(input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [S.ExprTermMapping(_0), input]);
 export const ExprTail = (input) => If(If(If(Token.Const('|', input), ([_0, input]) => If(ExprTerm(input), ([_1, input]) => If(ExprTail(input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.ExprTailMapping(_0), input]);
 export const Expr = (input) => If(If(ExprTerm(input), ([_0, input]) => If(ExprTail(input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [S.ExprMapping(_0), input]);
+export const ExprReadonly = (input) => If(If(Token.Const('readonly', input), ([_0, input]) => If(Expr(input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [S.ExprReadonlyMapping(_0), input]);
 export const ExprPipe = (input) => If(If(Token.Const('|', input), ([_0, input]) => If(Expr(input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [S.ExprPipeMapping(_0), input]);
 export const GenericType = (input) => If(If(GenericParameters(input), ([_0, input]) => If(Token.Const('=', input), ([_1, input]) => If(Type(input), ([_2, input]) => [[_0, _1, _2], input]))), ([_0, input]) => [S.GenericTypeMapping(_0), input]);
 export const InferType = (input) => If(If(If(Token.Const('infer', input), ([_0, input]) => If(Token.Ident(input), ([_1, input]) => If(Token.Const('extends', input), ([_2, input]) => If(Expr(input), ([_3, input]) => [[_0, _1, _2, _3], input])))), ([_0, input]) => [_0, input], () => If(If(Token.Const('infer', input), ([_0, input]) => If(Token.Ident(input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [S.InferTypeMapping(_0), input]);
-export const Type = (input) => If(If(InferType(input), ([_0, input]) => [_0, input], () => If(ExprPipe(input), ([_0, input]) => [_0, input], () => If(Expr(input), ([_0, input]) => [_0, input], () => []))), ([_0, input]) => [S.TypeMapping(_0), input]);
+export const Type = (input) => If(If(InferType(input), ([_0, input]) => [_0, input], () => If(ExprPipe(input), ([_0, input]) => [_0, input], () => If(ExprReadonly(input), ([_0, input]) => [_0, input], () => If(Expr(input), ([_0, input]) => [_0, input], () => [])))), ([_0, input]) => [S.TypeMapping(_0), input]);
 export const PropertyKeyNumber = (input) => If(Token.Number(input), ([_0, input]) => [S.PropertyKeyNumberMapping(_0), input]);
 export const PropertyKeyIdent = (input) => If(Token.Ident(input), ([_0, input]) => [S.PropertyKeyIdentMapping(_0), input]);
 export const PropertyKeyQuoted = (input) => If(Token.String(['\'', '\"'], input), ([_0, input]) => [S.PropertyKeyQuotedMapping(_0), input]);

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

@@ -0,0 +1,16 @@
+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>;
+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>;
+/** Returns true if the given value is a TImmutable */
+export declare function IsImmutable(value: unknown): value is TImmutable<TSchema>;

package/build/type/types/_immutable.mjs

@@ -0,0 +1,26 @@
+// 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 }, {});
+}
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Applies an Immutable modifier to the given type. */
+export function Immutable(type) {
+    return ImmutableAdd(type);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TImmutable */
+export function IsImmutable(value) {
+    return IsSchema(value) && Guard.HasPropertyKey(value, '~immutable');
+}

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

@@ -4,11 +4,11 @@ export type TReadonlyRemove<Type extends TSchema, Result extends TSchema = Type
 /** Removes Readaonly from the given type. */
 export declare function ReadonlyRemove<Type extends TSchema>(type: Type): TReadonlyRemove<Type>;
 /** Adds Readonly to the given type. */
-export type TReadonlyAdd<Type extends TSchema = TSchema> = ('readOnly' extends keyof Type ? Type : TReadonly<Type>);
+export type TReadonlyAdd<Type extends TSchema = TSchema> = ('~readonly' extends keyof Type ? Type : TReadonly<Type>);
 /** Adds Readonly to the given type. */
 export declare function ReadonlyAdd<Type extends TSchema>(type: Type): TReadonlyAdd<Type>;
 export type TReadonly<Type extends TSchema = TSchema> = (Type & {
-    readOnly: true;
+    '~readonly': true;
 });
 /** Applies an Readonly modifier to the given type. */
 export declare function Readonly<Type extends TSchema>(type: Type): TReadonlyAdd<Type>;

package/build/type/types/_readonly.mjs

@@ -4,11 +4,11 @@ import { Guard } from '../../guard/index.mjs';
 import { IsSchema } from './schema.mjs';
 /** Removes Readaonly from the given type. */
 export function ReadonlyRemove(type) {
-    return Memory.Discard(type, ['readOnly']);
+    return Memory.Discard(type, ['~readonly']);
 }
 /** Adds Readonly to the given type. */
 export function ReadonlyAdd(type) {
-    return Memory.Update(type, {}, { 'readOnly': true });
+    return Memory.Update(type, { '~readonly': true }, {});
 }
 // ------------------------------------------------------------------
 // Factory
@@ -22,5 +22,5 @@ export function Readonly(type) {
 // ------------------------------------------------------------------
 /** Returns true if the given value is a TReadonly */
 export function IsReadonly(value) {
-    return IsSchema(value) && Guard.HasPropertyKey(value, 'readOnly');
+    return IsSchema(value) && Guard.HasPropertyKey(value, '~readonly');
 }

package/build/type/types/_refine.mjs

@@ -5,7 +5,7 @@ import { IsSchema } from './schema.mjs';
 /** Applies a Refine check to the given type. */
 export function RefineAdd(type, refinement) {
     const refinements = IsRefine(type) ? [...type['~refine'], refinement] : [refinement];
-    return Memory.Update(type, {}, { '~refine': refinements });
+    return Memory.Update(type, { '~refine': refinements }, {});
 }
 /** Applies a Refine check to the given type. */
 export function Refine(type, refine, message = 'error') {

package/build/type/types/array.d.mts

@@ -1,7 +1,8 @@
 import { type StaticType, type StaticDirection } from './static.mjs';
 import { type TSchema, type TArrayOptions } from './schema.mjs';
+import { type TImmutable } from './_immutable.mjs';
 import { type TProperties } from './properties.mjs';
-export type StaticArray<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Result extends unknown[] = StaticType<Stack, Direction, Context, This, Type>[]> = Result;
+export type StaticArray<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Array extends TSchema, Item extends TSchema, Result extends readonly unknown[] = Array extends TImmutable ? readonly StaticType<Stack, Direction, Context, This, Item>[] : StaticType<Stack, Direction, Context, This, Item>[]> = Result;
 /** Represents an Array type. */
 export interface TArray<Type extends TSchema = TSchema> extends TSchema {
     '~kind': 'Array';

package/build/type/types/base.mjs

@@ -21,16 +21,22 @@ export class NotImplemented extends Error {
 /** Base class for creating extension types. */
 export class Base {
     constructor() {
-        Object.defineProperty(this, '~kind', {
+        const configuration = {
             enumerable: Settings.Get().enumerableKind,
             writable: false,
             configurable: false,
+        };
+        globalThis.Object.defineProperty(this, '~kind', {
+            ...configuration,
             value: 'Base'
         });
-        this['~guard'] = {
-            check: (value) => this.Check(value),
-            errors: (value) => this.Errors(value)
-        };
+        globalThis.Object.defineProperty(this, '~guard', {
+            ...configuration,
+            value: {
+                check: (value) => this.Check(value),
+                errors: (value) => this.Errors(value)
+            }
+        });
     }
     /** Checks a value or returns false if invalid */
     Check(value) {

package/build/type/types/index.d.mts

@@ -1,4 +1,5 @@
 export * from './_codec.mjs';
+export * from './_immutable.mjs';
 export * from './_optional.mjs';
 export * from './_readonly.mjs';
 export * from './_refine.mjs';

package/build/type/types/index.mjs

@@ -2,6 +2,7 @@
 // Extensions
 // ------------------------------------------------------------------
 export * from './_codec.mjs';
+export * from './_immutable.mjs';
 export * from './_optional.mjs';
 export * from './_readonly.mjs';
 export * from './_refine.mjs';

package/build/type/types/literal.d.mts

@@ -1,9 +1,18 @@
 import { type TSchema, type TSchemaOptions } from './schema.mjs';
+export declare class InvalidLiteralValue extends Error {
+    readonly cause: {
+        value: unknown;
+    };
+    constructor(value: unknown);
+}
 export type StaticLiteral<Value extends TLiteralValue> = (Value);
+export type TLiteralTypeName<Value extends TLiteralValue> = (Value extends bigint ? 'bigint' : Value extends boolean ? 'boolean' : Value extends number ? 'number' : Value extends string ? 'string' : never);
+export declare function LiteralTypeName<Value extends TLiteralValue>(value: Value): TLiteralTypeName<Value>;
 export type TLiteralValue = string | number | boolean | bigint;
 /** Represents a Literal type. */
 export interface TLiteral<Value extends TLiteralValue = TLiteralValue> extends TSchema {
     '~kind': 'Literal';
+    type: TLiteralTypeName<Value>;
     const: Value;
 }
 /** Creates a Literal type. */

package/build/type/types/literal.mjs

@@ -3,11 +3,32 @@ import { Memory } from '../../system/memory/index.mjs';
 import { Guard } from '../../guard/index.mjs';
 import { IsKind } from './schema.mjs';
 // ------------------------------------------------------------------
+// InvalidLiteralValue
+// ------------------------------------------------------------------
+export class InvalidLiteralValue extends Error {
+    constructor(value) {
+        super(`Invalid Literal value`);
+        Object.defineProperty(this, 'cause', {
+            value: { value },
+            writable: false,
+            configurable: false,
+            enumerable: false
+        });
+    }
+}
+export function LiteralTypeName(value) {
+    return (Guard.IsBigInt(value) ? 'bigint' :
+        Guard.IsBoolean(value) ? 'boolean' :
+            Guard.IsNumber(value) ? 'number' :
+                Guard.IsString(value) ? 'string' :
+                    (() => { throw new InvalidLiteralValue(value); })());
+}
+// ------------------------------------------------------------------
 // Factory
 // ------------------------------------------------------------------
 /** Creates a Literal type. */
 export function Literal(value, options) {
-    return Memory.Create({ '~kind': 'Literal' }, { const: value }, options);
+    return Memory.Create({ '~kind': 'Literal' }, { type: LiteralTypeName(value), const: value }, options);
 }
 // ------------------------------------------------------------------
 // Guards

package/build/type/types/static.d.mts

@@ -36,7 +36,7 @@ export type StaticEvaluate<T> = {
     [K in keyof T]: T[K];
 } & {};
 export type StaticDirection = 'Encode' | 'Decode';
-export type StaticType<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema> = (Type extends TCodec<infer Type extends TSchema, infer Decoded extends unknown> ? StaticCodec<Stack, Direction, Context, This, Type, Decoded> : Type extends TAny ? StaticAny : Type extends TArray<infer Type extends TSchema> ? StaticArray<Stack, Direction, Context, This, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? StaticAsyncIterator<Stack, Direction, Context, This, Type> : Type extends TBigInt ? StaticBigInt : Type extends TBoolean ? StaticBoolean : Type extends TConstructor<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? StaticConstructor<Stack, Direction, Context, This, Parameters, ReturnType> : Type extends TEnum<infer Values extends TEnumValue[]> ? StaticEnum<Values> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? StaticFunction<Stack, Direction, Context, This, Parameters, ReturnType> : Type extends TInteger ? StaticInteger : Type extends TIntersect<infer Types extends TSchema[]> ? StaticIntersect<Stack, Direction, Context, This, Types> : Type extends TIterator<infer Types extends TSchema> ? StaticIterator<Stack, Direction, Context, This, Types> : Type extends TLiteral<infer Value extends TLiteralValue> ? StaticLiteral<Value> : Type extends TNever ? StaticNever : Type extends TNull ? StaticNull : Type extends TNumber ? StaticNumber : Type extends TObject<infer Properties extends TProperties> ? StaticObject<Stack, Direction, Context, This, Properties> : Type extends TPromise<infer Type extends TSchema> ? StaticPromise<Stack, Direction, Context, This, Type> : Type extends TRecord<infer Key extends string, infer Value extends TSchema> ? StaticRecord<Stack, Direction, Context, This, Key, Value> : Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? StaticCyclic<Stack, Direction, Context, This, Defs, Ref> : Type extends TRef<infer Ref extends string> ? StaticRef<Stack, Direction, Context, This, Ref> : Type extends TString ? StaticString : Type extends TSymbol ? StaticSymbol : Type extends TTemplateLiteral<infer Pattern extends string> ? StaticTemplateLiteral<Pattern> : Type extends TThis ? StaticThis<Stack, Direction, Context, This> : Type extends TTuple<infer Types extends TSchema[]> ? StaticTuple<Stack, Direction, Context, This, Types> : Type extends TUndefined ? StaticUndefined : Type extends TUnion<infer Types extends TSchema[]> ? StaticUnion<Stack, Direction, Context, This, Types> : Type extends TUnknown ? StaticUnknown : Type extends TUnsafe<infer Type extends unknown> ? StaticUnsafe<Type> : Type extends TVoid ? StaticVoid : XStatic<Type>);
+export type StaticType<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema> = (Type extends TCodec<infer Type extends TSchema, infer Decoded extends unknown> ? StaticCodec<Stack, Direction, Context, This, Type, Decoded> : Type extends TAny ? StaticAny : Type extends TArray<infer Items extends TSchema> ? StaticArray<Stack, Direction, Context, This, Type, Items> : Type extends TAsyncIterator<infer Type extends TSchema> ? StaticAsyncIterator<Stack, Direction, Context, This, Type> : Type extends TBigInt ? StaticBigInt : Type extends TBoolean ? StaticBoolean : Type extends TConstructor<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? StaticConstructor<Stack, Direction, Context, This, Parameters, ReturnType> : Type extends TEnum<infer Values extends TEnumValue[]> ? StaticEnum<Values> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? StaticFunction<Stack, Direction, Context, This, Parameters, ReturnType> : Type extends TInteger ? StaticInteger : Type extends TIntersect<infer Types extends TSchema[]> ? StaticIntersect<Stack, Direction, Context, This, Types> : Type extends TIterator<infer Types extends TSchema> ? StaticIterator<Stack, Direction, Context, This, Types> : Type extends TLiteral<infer Value extends TLiteralValue> ? StaticLiteral<Value> : Type extends TNever ? StaticNever : Type extends TNull ? StaticNull : Type extends TNumber ? StaticNumber : Type extends TObject<infer Properties extends TProperties> ? StaticObject<Stack, Direction, Context, This, Properties> : Type extends TPromise<infer Type extends TSchema> ? StaticPromise<Stack, Direction, Context, This, Type> : Type extends TRecord<infer Key extends string, infer Value extends TSchema> ? StaticRecord<Stack, Direction, Context, This, Key, Value> : Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? StaticCyclic<Stack, Direction, Context, This, Defs, Ref> : Type extends TRef<infer Ref extends string> ? StaticRef<Stack, Direction, Context, This, Ref> : Type extends TString ? StaticString : Type extends TSymbol ? StaticSymbol : Type extends TTemplateLiteral<infer Pattern extends string> ? StaticTemplateLiteral<Pattern> : Type extends TThis ? StaticThis<Stack, Direction, Context, This> : Type extends TTuple<infer Items extends TSchema[]> ? StaticTuple<Stack, Direction, Context, This, Type, Items> : Type extends TUndefined ? StaticUndefined : Type extends TUnion<infer Types extends TSchema[]> ? StaticUnion<Stack, Direction, Context, This, Types> : Type extends TUnknown ? StaticUnknown : Type extends TUnsafe<infer Type extends unknown> ? StaticUnsafe<Type> : Type extends TVoid ? StaticVoid : XStatic<Type>);
 /** Infers a static type from a TypeBox type using Parse logic. */
 export type StaticParse<Type extends TSchema, Context extends TProperties = {}> = StaticType<[], 'Decode', Context, {}, Type>;
 /** Infers a static type from a TypeBox type using Decode logic. */

package/build/type/types/tuple.d.mts

@@ -3,6 +3,7 @@ import { type TSchema, type TTupleOptions } from './schema.mjs';
 import { type TArray } from './array.mjs';
 import { type TOptional } from './_optional.mjs';
 import { type TProperties } from './properties.mjs';
+import { type TImmutable } from './_immutable.mjs';
 import { type TReadonly } from './_readonly.mjs';
 import { type TRest } from './rest.mjs';
 type StaticLast<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Result extends unknown[]> = (Type extends TRest<infer RestType extends TSchema> ? RestType extends TArray<infer ArrayType extends TSchema> ? [...Result, ...TStaticElement<Stack, Direction, Context, This, ArrayType>[0][]] : [...Result, never] : [...Result, ...TStaticElement<Stack, Direction, Context, This, Type>]);
@@ -19,7 +20,7 @@ type TStaticElement<Stack extends string[], Direction extends StaticDirection, C
     Inferred
 ])> = Result;
 export type TStaticElements<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Types extends TSchema[], Result extends unknown[] = []> = (Types extends [infer Last extends TSchema] ? StaticLast<Stack, Direction, Context, This, Last, Result> : Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TStaticElements<Stack, Direction, Context, This, Right, [...Result, ...TStaticElement<Stack, Direction, Context, This, Left>]> : Result);
-export type StaticTuple<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Types extends TSchema[], Elements extends unknown[] = TStaticElements<Stack, Direction, Context, This, Types>, Result extends unknown[] = Elements> = Result;
+export type StaticTuple<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Tuple extends TSchema, Items extends TSchema[], Elements extends unknown[] = TStaticElements<Stack, Direction, Context, This, Items>, Result extends readonly unknown[] = (Tuple extends TImmutable ? readonly [...Elements] : Elements)> = Result;
 /** Represents a Tuple type. */
 export interface TTuple<Types extends TSchema[] = TSchema[]> extends TSchema {
     '~kind': 'Tuple';

package/build/typebox.d.mts

@@ -26,6 +26,7 @@ export { ReturnType, type TReturnType, type TReturnTypeDeferred } from './type/a
 export { type TUncapitalize, type TUncapitalizeDeferred, Uncapitalize } from './type/action/uncapitalize.mjs';
 export { type TUppercase, type TUppercaseDeferred, Uppercase } from './type/action/uppercase.mjs';
 export { Codec, Decode, DecodeBuilder, Encode, EncodeBuilder, IsCodec, type TCodec } from './type/types/_codec.mjs';
+export { Immutable, IsImmutable, type TImmutable } from './type/types/_immutable.mjs';
 export { IsOptional, Optional, type TOptional } from './type/types/_optional.mjs';
 export { IsReadonly, Readonly, type TReadonly } from './type/types/_readonly.mjs';
 export { IsRefine, Refine, type TRefine, type TRefineCallback, type TRefinement } from './type/types/_refine.mjs';

package/build/typebox.mjs

@@ -41,6 +41,7 @@ export { Uppercase } from './type/action/uppercase.mjs';
 // Extension
 // ------------------------------------------------------------------
 export { Codec, Decode, DecodeBuilder, Encode, EncodeBuilder, IsCodec } from './type/types/_codec.mjs';
+export { Immutable, IsImmutable } from './type/types/_immutable.mjs';
 export { IsOptional, Optional } from './type/types/_optional.mjs';
 export { IsReadonly, Readonly } from './type/types/_readonly.mjs';
 export { IsRefine, Refine } from './type/types/_refine.mjs';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
-  "description": "A Runtime Type System for JavaScript",
-  "version": "1.0.35",
+  "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
+  "version": "1.0.36",
   "keywords": [
     "typescript",
     "jsonschema"

package/readme.md

@@ -2,7 +2,7 @@
 
 <h1>TypeBox</h1>
 
-<p>A Runtime Type System for JavaScript</p>
+<p>Json Schema Type Builder with Static Type Resolution for TypeScript</p>
 
 <img src="typebox.png" />