typebox 1.0.35 → 1.0.37

package/build/schema/types/patternProperties.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
-import { IsSchemaLike } from './schema.mjs';
+import { IsSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------
@@ -11,5 +11,5 @@ import { IsSchemaLike } from './schema.mjs';
 export function IsPatternProperties(schema) {
     return Guard.HasPropertyKey(schema, 'patternProperties')
         && Guard.IsObject(schema.patternProperties)
-        && Object.values(schema.patternProperties).every(value => IsSchemaLike(value));
+        && Object.values(schema.patternProperties).every(value => IsSchema(value));
 }

package/build/schema/types/prefixItems.d.mts

@@ -1,8 +1,8 @@
-import { type XSchema, type XSchemaLike } from './schema.mjs';
-export interface XPrefixItems<PrefixItems extends XSchemaLike[] = XSchemaLike[]> {
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XPrefixItems<PrefixItems extends XSchema[] = XSchema[]> {
     prefixItems: PrefixItems;
 }
 /**
  * Returns true if the schema contains a valid prefixItems property
  */
-export declare function IsPrefixItems(schema: XSchema): schema is XPrefixItems;
+export declare function IsPrefixItems(schema: XSchemaObject): schema is XPrefixItems;

package/build/schema/types/prefixItems.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
-import { IsSchemaLike } from './schema.mjs';
+import { IsSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------
@@ -10,5 +10,5 @@ import { IsSchemaLike } from './schema.mjs';
 export function IsPrefixItems(schema) {
     return Guard.HasPropertyKey(schema, 'prefixItems')
         && Guard.IsArray(schema.prefixItems)
-        && schema.prefixItems.every(schema => IsSchemaLike(schema));
+        && schema.prefixItems.every(schema => IsSchema(schema));
 }

package/build/schema/types/properties.d.mts

@@ -1,9 +1,9 @@
-import { type XSchema, type XSchemaLike } from './schema.mjs';
-export interface XProperties<Properties extends Record<PropertyKey, XSchemaLike> = Record<PropertyKey, XSchemaLike>> {
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XProperties<Properties extends Record<PropertyKey, XSchema> = Record<PropertyKey, XSchema>> {
     properties: Properties;
 }
 /**
  * Returns true if the schema contains a valid properties property
  * @specification Json Schema 7
  */
-export declare function IsProperties(schema: XSchema): schema is XProperties;
+export declare function IsProperties(schema: XSchemaObject): schema is XProperties;

package/build/schema/types/properties.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
-import { IsSchemaLike } from './schema.mjs';
+import { IsSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------
@@ -11,5 +11,5 @@ import { IsSchemaLike } from './schema.mjs';
 export function IsProperties(schema) {
     return Guard.HasPropertyKey(schema, 'properties')
         && Guard.IsObject(schema.properties)
-        && Object.values(schema.properties).every(value => IsSchemaLike(value));
+        && Object.values(schema.properties).every(value => IsSchema(value));
 }

package/build/schema/types/propertyNames.d.mts

@@ -1,9 +1,9 @@
-import { type XSchema, type XSchemaLike } from './schema.mjs';
-export interface XPropertyNames<PropertyNames extends XSchemaLike = XSchemaLike> {
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XPropertyNames<PropertyNames extends XSchema = XSchema> {
     propertyNames: PropertyNames;
 }
 /**
  * Returns true if the schema contains a valid propertyNames property
  * @specification Json Schema 7
  */
-export declare function IsPropertyNames(schema: XSchema): schema is XPropertyNames;
+export declare function IsPropertyNames(schema: XSchemaObject): schema is XPropertyNames;

package/build/schema/types/propertyNames.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
-import { IsSchemaLike } from './schema.mjs';
+import { IsSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------
@@ -11,5 +11,5 @@ import { IsSchemaLike } from './schema.mjs';
 export function IsPropertyNames(schema) {
     return Guard.HasPropertyKey(schema, 'propertyNames')
         && (Guard.IsObject(schema.propertyNames)
-            || IsSchemaLike(schema.propertyNames));
+            || IsSchema(schema.propertyNames));
 }

package/build/schema/types/ref.d.mts

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XRef<Ref extends string = string> {
     $ref: Ref;
 }
@@ -6,4 +6,4 @@ export interface XRef<Ref extends string = string> {
  * Returns true if the schema contains a valid $ref property
  * @specification Json Schema 7
  */
-export declare function IsRef(schema: XSchema): schema is XRef;
+export declare function IsRef(schema: XSchemaObject): schema is XRef;

package/build/schema/types/required.d.mts

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XRequired<Required extends string[] = string[]> {
     required: Required;
 }
@@ -6,4 +6,4 @@ export interface XRequired<Required extends string[] = string[]> {
  * Returns true if the schema contains a valid required property
  * @specification Json Schema 7
  */
-export declare function IsRequired(schema: XSchema): schema is XRequired;
+export declare function IsRequired(schema: XSchemaObject): schema is XRequired;

package/build/schema/types/schema.d.mts

@@ -1,9 +1,9 @@
-export type XSchema = object;
+export type XSchemaObject = object;
 /** Returns true if this value is object like */
-export declare function IsSchema(value: unknown): value is XSchema;
+export declare function IsSchemaObject(value: unknown): value is XSchemaObject;
 export type XSchemaBoolean = boolean;
 /** Returns true if this value is a boolean */
 export declare function IsBooleanSchema(value: unknown): value is XSchemaBoolean;
-export type XSchemaLike = XSchema | XSchemaBoolean;
+export type XSchema = XSchemaObject | XSchemaBoolean;
 /** Returns true if this value is schema like */
-export declare function IsSchemaLike(value: unknown): value is XSchemaLike;
+export declare function IsSchema(value: unknown): value is XSchema;

package/build/schema/types/schema.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 /** Returns true if this value is object like */
-export function IsSchema(value) {
+export function IsSchemaObject(value) {
     return Guard.IsObject(value) && !Guard.IsArray(value);
 }
 /** Returns true if this value is a boolean */
@@ -9,6 +9,6 @@ export function IsBooleanSchema(value) {
     return Guard.IsBoolean(value);
 }
 /** Returns true if this value is schema like */
-export function IsSchemaLike(value) {
-    return IsSchema(value) || IsBooleanSchema(value);
+export function IsSchema(value) {
+    return IsSchemaObject(value) || IsBooleanSchema(value);
 }

package/build/schema/types/then.d.mts

@@ -1,9 +1,9 @@
-import { type XSchema, type XSchemaLike } from './schema.mjs';
-export interface XThen<Then extends XSchemaLike = XSchemaLike> {
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XThen<Then extends XSchema = XSchema> {
     then: Then;
 }
 /**
  * Returns true if the schema contains a valid then property
  * @specification Json Schema 7
  */
-export declare function IsThen(schema: XSchema): schema is XThen;
+export declare function IsThen(schema: XSchemaObject): schema is XThen;

package/build/schema/types/then.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
-import { IsSchemaLike } from './schema.mjs';
+import { IsSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------
@@ -10,5 +10,5 @@ import { IsSchemaLike } from './schema.mjs';
  */
 export function IsThen(schema) {
     return Guard.HasPropertyKey(schema, 'then')
-        && IsSchemaLike(schema.then);
+        && IsSchema(schema.then);
 }

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

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XType<Type extends string | string[] = string | string[]> {
     type: Type;
 }
@@ -6,4 +6,4 @@ export interface XType<Type extends string | string[] = string | string[]> {
  * Returns true if the schema contains a valid type property
  * @specification Json Schema 7
  */
-export declare function IsType(schema: XSchema): schema is XType;
+export declare function IsType(schema: XSchemaObject): schema is XType;

package/build/schema/types/unevaluatedItems.d.mts

@@ -1,9 +1,9 @@
-import { type XSchema, type XSchemaLike } from './schema.mjs';
-export interface XUnevaluatedItems<unevaluatedItems extends XSchemaLike = XSchemaLike> {
-    unevaluatedItems: XSchemaLike;
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XUnevaluatedItems<unevaluatedItems extends XSchema = XSchema> {
+    unevaluatedItems: XSchema;
 }
 /**
  * Returns true if the schema contains a valid unevaluatedItems property
  * @specification Json Schema 2019-09
  */
-export declare function IsUnevaluatedItems(schema: XSchema): schema is XUnevaluatedItems;
+export declare function IsUnevaluatedItems(schema: XSchemaObject): schema is XUnevaluatedItems;

package/build/schema/types/unevaluatedItems.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
-import { IsSchemaLike } from './schema.mjs';
+import { IsSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------
@@ -10,5 +10,5 @@ import { IsSchemaLike } from './schema.mjs';
  */
 export function IsUnevaluatedItems(schema) {
     return Guard.HasPropertyKey(schema, 'unevaluatedItems')
-        && IsSchemaLike(schema.unevaluatedItems);
+        && IsSchema(schema.unevaluatedItems);
 }

package/build/schema/types/unevaluatedProperties.d.mts

@@ -1,9 +1,9 @@
-import { type XSchema, type XSchemaLike } from './schema.mjs';
-export interface XUnevaluatedProperties<UnevaluatedProperties extends XSchemaLike = XSchemaLike> {
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XUnevaluatedProperties<UnevaluatedProperties extends XSchema = XSchema> {
     unevaluatedProperties: UnevaluatedProperties;
 }
 /**
  * Returns true if the schema contains a valid unevaluatedProperties property
  * @specification Json Schema 2019-09
  */
-export declare function IsUnevaluatedProperties(schema: XSchema): schema is XUnevaluatedProperties;
+export declare function IsUnevaluatedProperties(schema: XSchemaObject): schema is XUnevaluatedProperties;

package/build/schema/types/unevaluatedProperties.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
-import { IsSchemaLike } from './schema.mjs';
+import { IsSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Guard
 // ------------------------------------------------------------------
@@ -10,5 +10,5 @@ import { IsSchemaLike } from './schema.mjs';
  */
 export function IsUnevaluatedProperties(schema) {
     return Guard.HasPropertyKey(schema, 'unevaluatedProperties')
-        && IsSchemaLike(schema.unevaluatedProperties);
+        && IsSchema(schema.unevaluatedProperties);
 }

package/build/schema/types/uniqueItems.d.mts

@@ -1,4 +1,4 @@
-import { type XSchema } from './schema.mjs';
+import { type XSchemaObject } from './schema.mjs';
 export interface XUniqueItems<UniqueItems extends boolean = boolean> {
     uniqueItems: UniqueItems;
 }
@@ -6,4 +6,4 @@ export interface XUniqueItems<UniqueItems extends boolean = boolean> {
  * Returns true if the schema contains a valid uniqueItems property
  * @specification Json Schema 7
  */
-export declare function IsUniqueItems(schema: XSchema): schema is XUniqueItems;
+export declare function IsUniqueItems(schema: XSchemaObject): schema is XUniqueItems;

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') {