@duckmind/dm-darwin-arm64 0.36.5 → 0.36.9

package/extensions/dm-tasks/node_modules/typebox/build/type/action/_remove_readonly.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { RemoveReadonlyAction } from '../engine/readonly/instantiate_remove.mjs';
+/** Creates a deferred RemoveReadonly action. */
+export function RemoveReadonlyDeferred(type, options = {}) {
+    return Deferred('RemoveReadonly', [type], options);
+}
+/** Applies an RemoveReadonly action to a type. */
+export function RemoveReadonly(type, options = {}) {
+    return RemoveReadonlyAction(type, options);
+}

package/extensions/dm-tasks/node_modules/typebox/build/type/action/conditional.d.mts

@@ -1,13 +1,12 @@
 import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
 import { type TDeferred } from '../types/deferred.mjs';
 import { type TConditionalAction } from '../engine/conditional/instantiate.mjs';
+import { type TState } from '../engine/instantiate.mjs';
 /** Creates a deferred Conditional action. */
 export type TConditionalDeferred<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema> = (TDeferred<'Conditional', [Left, Right, True, False]>);
 /** Creates a deferred Conditional action. */
 export declare function ConditionalDeferred<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema>(left: Left, right: Right, true_: True, false_: False, options?: TSchemaOptions): TConditionalDeferred<Left, Right, True, False>;
 /** Applies a Conditional action to the given types. */
-export type TConditional<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema> = (TConditionalAction<{}, {
-    callstack: [];
-}, Left, Right, True, False>);
+export type TConditional<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema> = (TConditionalAction<{}, TState<[], []>, Left, Right, True, False>);
 /** Applies a Conditional action to the given types. */
 export declare function Conditional<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema>(left: Left, right: Right, true_: True, false_: False, options?: TSchemaOptions): TConditional<Left, Right, True, False>;

package/extensions/dm-tasks/node_modules/typebox/build/type/action/conditional.mjs

@@ -2,11 +2,12 @@
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { ConditionalAction } from '../engine/conditional/instantiate.mjs';
+import { State } from '../engine/instantiate.mjs';
 /** Creates a deferred Conditional action. */
 export function ConditionalDeferred(left, right, true_, false_, options = {}) {
     return Deferred('Conditional', [left, right, true_, false_], options);
 }
 /** Applies a Conditional action to the given types. */
 export function Conditional(left, right, true_, false_, options = {}) {
-    return ConditionalAction({}, { callstack: [] }, left, right, true_, false_, options);
+    return ConditionalAction({}, State([], []), left, right, true_, false_, options);
 }

package/extensions/dm-tasks/node_modules/typebox/build/type/action/index.d.mts

@@ -1,5 +1,9 @@
-export * from './_optional.mjs';
-export * from './_readonly.mjs';
+export * from './_add_immutable.mjs';
+export * from './_add_readonly.mjs';
+export * from './_add_optional.mjs';
+export * from './_remove_immutable.mjs';
+export * from './_remove_readonly.mjs';
+export * from './_remove_optional.mjs';
 export * from './awaited.mjs';
 export * from './capitalize.mjs';
 export * from './conditional.mjs';

package/extensions/dm-tasks/node_modules/typebox/build/type/action/index.mjs

@@ -1,5 +1,9 @@
-export * from './_optional.mjs';
-export * from './_readonly.mjs';
+export * from './_add_immutable.mjs';
+export * from './_add_readonly.mjs';
+export * from './_add_optional.mjs';
+export * from './_remove_immutable.mjs';
+export * from './_remove_readonly.mjs';
+export * from './_remove_optional.mjs';
 export * from './awaited.mjs';
 export * from './capitalize.mjs';
 export * from './conditional.mjs';

package/extensions/dm-tasks/node_modules/typebox/build/type/action/mapped.d.mts

@@ -2,13 +2,12 @@ import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
 import { type TIdentifier } from '../types/identifier.mjs';
 import { type TDeferred } from '../types/deferred.mjs';
 import { type TMappedAction } from '../engine/mapped/instantiate.mjs';
+import { type TState } from '../engine/instantiate.mjs';
 /** Creates a deferred Mapped action. */
 export type TMappedDeferred<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema> = (TDeferred<'Mapped', [Identifier, Type, As, Property]>);
 /** Creates a deferred Mapped action. */
 export declare function MappedDeferred<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(identifier: Identifier, type: Type, as: As, property: Property, options?: TSchemaOptions): TMappedDeferred<Identifier, Type, As, Property>;
 /** Applies a Mapped action using the given types. */
-export type TMapped<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema> = (TMappedAction<{}, {
-    callstack: [];
-}, Identifier, Type, As, Property>);
+export type TMapped<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema> = (TMappedAction<{}, TState<[], []>, Identifier, Type, As, Property>);
 /** Applies a Mapped action using the given types. */
 export declare function Mapped<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(identifier: Identifier, type: Type, as: As, property: Property, options?: TSchemaOptions): TMapped<Identifier, Type, As, Property>;

package/extensions/dm-tasks/node_modules/typebox/build/type/action/mapped.mjs

@@ -2,11 +2,12 @@
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { MappedAction } from '../engine/mapped/instantiate.mjs';
+import { State } from '../engine/instantiate.mjs';
 /** Creates a deferred Mapped action. */
 export function MappedDeferred(identifier, type, as, property, options = {}) {
     return Deferred('Mapped', [identifier, type, as, property], options);
 }
 /** Applies a Mapped action using the given types. */
 export function Mapped(identifier, type, as, property, options = {}) {
-    return MappedAction({}, { callstack: [] }, identifier, type, as, property, options);
+    return MappedAction({}, State([], []), identifier, type, as, property, options);
 }

package/extensions/dm-tasks/node_modules/typebox/build/type/action/module.d.mts

@@ -1,12 +1,13 @@
 import { type TSchemaOptions } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TDeferred } from '../types/deferred.mjs';
-import { type TInstantiate } from '../engine/instantiate.mjs';
+import { type TState } from '../engine/instantiate.mjs';
+import { type TModuleInstantiate } from '../engine/module/instantiate.mjs';
 /** Creates a deferred Module action. */
-export type TModuleDeferred<Context extends TProperties> = (TDeferred<'Module', [Context]>);
+export type TModuleDeferred<Declarations extends TProperties> = (TDeferred<'Module', [Declarations]>);
 /** Creates a deferred Module action. */
-export declare function ModuleDeferred<Context extends TProperties>(context: Context, options?: TSchemaOptions): TModuleDeferred<Context>;
-/** Applies a Module transformation action to the embedded property types. */
-export type TModule<Context extends TProperties> = (TInstantiate<{}, TModuleDeferred<Context>>);
-/** Applies a Module transformation action to the embedded property types. */
-export declare function Module<Context extends TProperties>(context: Context, options?: TSchemaOptions): TModule<Context>;
+export declare function ModuleDeferred<Declarations extends TProperties>(declarations: Declarations, options?: TSchemaOptions): TModuleDeferred<Declarations>;
+/** Creates a Module with the given declarations */
+export type TModule<Declarations extends TProperties> = (TModuleInstantiate<{}, TState<[], []>, Declarations>);
+/** Creates a Module with the given declarations */
+export declare function Module<Declarations extends TProperties>(declarations: Declarations, options?: TSchemaOptions): TModule<Declarations>;

package/extensions/dm-tasks/node_modules/typebox/build/type/action/module.mjs

@@ -1,12 +1,13 @@
 // deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
-import { Instantiate } from '../engine/instantiate.mjs';
+import { State } from '../engine/instantiate.mjs';
+import { ModuleInstantiate } from '../engine/module/instantiate.mjs';
 /** Creates a deferred Module action. */
-export function ModuleDeferred(context, options = {}) {
-    return Deferred('Module', [context], options);
+export function ModuleDeferred(declarations, options = {}) {
+    return Deferred('Module', [declarations], options);
 }
-/** Applies a Module transformation action to the embedded property types. */
-export function Module(context, options = {}) {
-    return Instantiate({}, ModuleDeferred(context, options));
+/** Creates a Module with the given declarations */
+export function Module(declarations, options = {}) {
+    return ModuleInstantiate({}, State([], []), declarations, options);
 }

package/extensions/dm-tasks/node_modules/typebox/build/type/engine/call/instantiate.d.mts

@@ -13,9 +13,7 @@ import { type TResolveTarget } from './resolve_target.mjs';
 import { type TResolveArgumentsContext } from './resolve_arguments.mjs';
 type TPeek<State extends TState, Result extends string = State['callstack'] extends [...infer _ extends string[], infer Top extends string] ? Top : ''> = Result;
 type TIsTailCall<State extends TState, Name extends string, Result extends boolean = TPeek<State> extends Name ? true : false> = Result;
-type TCallDispatch<Context extends TProperties, State extends TState, Target extends TRef, Parameters extends TParameter[], Expression extends TSchema, Arguments extends TSchema[], ArgumentsContext extends TProperties = TResolveArgumentsContext<Context, State, Parameters, Arguments>, ReturnType extends TSchema = TInstantiateType<ArgumentsContext, {
-    callstack: [...State['callstack'], Target['$ref']];
-}, Expression>> = TInstantiateType<Context, State, ReturnType>;
+type TCallDispatch<Context extends TProperties, State extends TState, Target extends TRef, Parameters extends TParameter[], Expression extends TSchema, Arguments extends TSchema[], ArgumentsContext extends TProperties = TResolveArgumentsContext<Context, State, Parameters, Arguments>, ReturnType extends TSchema = TInstantiateType<ArgumentsContext, TState<[...State['callstack'], Target['$ref']], State['visited']>, Expression>> = TInstantiateType<ArgumentsContext, TState<[], []>, ReturnType>;
 type TCallDistributed<Context extends TProperties, State extends TState, Target extends TRef, Parameters extends TParameter[], Expression extends TSchema, DistributedArguments extends TSchema[][], Result extends TSchema[] = []> = (DistributedArguments extends [infer Arguments extends TSchema[], ...infer DistributedArguments extends TSchema[][]] ? TCallDispatch<Context, State, Target, Parameters, Expression, Arguments> extends infer ReturnType extends TSchema ? TCallDistributed<Context, State, Target, Parameters, Expression, DistributedArguments, [...Result, ReturnType]> : never : Result);
 type TCallImmediate<Context extends TProperties, State extends TState, Target extends TRef, Parameters extends TParameter[], Expression extends TSchema, InstantiatedArguments extends TSchema[], DistributedArguments extends TSchema[][] = TDistributeArguments<Parameters, InstantiatedArguments, Expression>, ReturnTypes extends TSchema[] = TCallDistributed<Context, State, Target, Parameters, Expression, DistributedArguments>, Result extends TSchema = ReturnTypes['length'] extends 1 ? ReturnTypes[0] : TEvaluateUnion<ReturnTypes>> = Result;
 export type TCallInstantiate<Context extends TProperties, State extends TState, Target extends TSchema, Arguments extends TSchema[], InstantiatedArguments extends TSchema[] = TInstantiateTypes<Context, State, Arguments>, Resolved extends [string, TSchema] = TResolveTarget<Context, Target, Arguments>, Name extends string = Resolved[0], Type extends TSchema = Resolved[1], Result extends TSchema = (Type extends TGeneric<infer Parameters extends TParameter[], infer Expression extends TSchema> ? TIsTailCall<State, Name> extends true ? TCallConstruct<TRef<Name>, InstantiatedArguments> : TCallImmediate<Context, State, TRef<Name>, Parameters, Expression, InstantiatedArguments> : TCallConstruct<Target, InstantiatedArguments>)> = Result;

package/extensions/dm-tasks/node_modules/typebox/build/type/engine/call/instantiate.mjs

@@ -6,6 +6,7 @@ import { IsGeneric } from '../../types/generic.mjs';
 import { EvaluateUnion } from '../evaluate/index.mjs';
 import { InstantiateType } from '../instantiate.mjs';
 import { InstantiateTypes } from '../instantiate.mjs';
+import { State } from '../instantiate.mjs';
 // ------------------------------------------------------------------
 // Infrastructure
 // ------------------------------------------------------------------
@@ -22,8 +23,8 @@ function IsTailCall(state, name) {
 }
 function CallDispatch(context, state, target, parameters, expression, arguments_) {
     const argumentsContext = ResolveArgumentsContext(context, state, parameters, arguments_);
-    const returnType = InstantiateType(argumentsContext, { callstack: [...state.callstack, target.$ref] }, expression);
-    return InstantiateType(context, state, returnType);
+    const returnType = InstantiateType(argumentsContext, State([...state['callstack'], target['$ref']], state['visited']), expression);
+    return InstantiateType(argumentsContext, State([], []), returnType);
 }
 function CallDistributed(context, state, target, parameters, expression, distributedArguments) {
     return distributedArguments.reduce((result, arguments_) => [...result, CallDispatch(context, state, target, parameters, expression, arguments_)], []);

package/extensions/dm-tasks/node_modules/typebox/build/type/engine/constructor_parameters/instantiate.d.mts

@@ -3,11 +3,10 @@ import { type TProperties } from '../../types/properties.mjs';
 import { type TConstructor } from '../../types/constructor.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
 import { type TConstructorParametersDeferred } from '../../action/constructor_parameters.mjs';
-import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
 import { type TInstantiateElements } from '../instantiate.mjs';
-type TConstructorParametersOperation<Type extends TSchema, Parameters extends TSchema[] = Type extends TConstructor ? Type['parameters'] : [], InstantiatedParameters extends TSchema[] = TInstantiateElements<{}, {
-    callstack: [];
-}, Parameters>, Result extends TSchema = TTuple<InstantiatedParameters>> = Result;
+import { type TState } from '../instantiate.mjs';
+type TConstructorParametersOperation<Type extends TSchema, Parameters extends TSchema[] = Type extends TConstructor ? Type['parameters'] : [], InstantiatedParameters extends TSchema[] = TInstantiateElements<{}, TState<[], []>, Parameters>, Result extends TSchema = TTuple<InstantiatedParameters>> = Result;
 export type TConstructorParametersAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TConstructorParametersOperation<Type> : TConstructorParametersDeferred<Type>> = Result;
 export declare function ConstructorParametersAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TConstructorParametersAction<Type>;
 export type TConstructorParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TConstructorParametersAction<InstantiatedType>;

package/extensions/dm-tasks/node_modules/typebox/build/type/engine/constructor_parameters/instantiate.mjs

@@ -6,9 +6,10 @@ import { Tuple } from '../../types/tuple.mjs';
 import { ConstructorParametersDeferred } from '../../action/constructor_parameters.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
 import { InstantiateElements } from '../instantiate.mjs';
+import { State } from '../instantiate.mjs';
 function ConstructorParametersOperation(type) {
     const parameters = IsConstructor(type) ? type['parameters'] : [];
-    const instantiatedParameters = InstantiateElements({}, { callstack: [] }, parameters);
+    const instantiatedParameters = InstantiateElements({}, State([], []), parameters);
     const result = Tuple(instantiatedParameters);
     return result;
 }

package/extensions/dm-tasks/node_modules/typebox/build/type/engine/cyclic/instantiate.d.mts

@@ -6,12 +6,9 @@ import { type TCyclicDependencies } from '../cyclic/dependencies.mjs';
 import { type TInterfaceDeferred } from '../../action/index.mjs';
 import { type TInstantiateProperties } from '../instantiate.mjs';
 import { type TInstantiateTypes } from '../instantiate.mjs';
+import { type TState } from '../instantiate.mjs';
 import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
-type TCyclicInterface<Context extends TProperties, Heritage extends TSchema[], Properties extends TProperties, InstantiatedHeritage extends TSchema[] = TInstantiateTypes<Context, {
-    callstack: [];
-}, Heritage>, instantiatedProperties extends TProperties = TInstantiateProperties<{}, {
-    callstack: [];
-}, Properties>, EvaluatedInterface extends TSchema = TEvaluateIntersect<[...InstantiatedHeritage, TObject<instantiatedProperties>]>> = EvaluatedInterface;
+type TCyclicInterface<Context extends TProperties, Heritage extends TSchema[], Properties extends TProperties, InstantiatedHeritage extends TSchema[] = TInstantiateTypes<Context, TState<[], []>, Heritage>, instantiatedProperties extends TProperties = TInstantiateProperties<{}, TState<[], []>, Properties>, EvaluatedInterface extends TSchema = TEvaluateIntersect<[...InstantiatedHeritage, TObject<instantiatedProperties>]>> = EvaluatedInterface;
 type TCyclicDefinitions<Context extends TProperties, Dependencies extends string[], Result extends TProperties = {
     [Key in Extract<keyof Context, Dependencies[number]>]: Context[Key] extends TInterfaceDeferred<infer Heritage extends TSchema[], infer Properties extends TProperties> ? TCyclicInterface<Context, Heritage, Properties> : Context[Key];
 }> = Result;

package/extensions/dm-tasks/node_modules/typebox/build/type/engine/cyclic/instantiate.mjs

@@ -7,10 +7,11 @@ import { CyclicDependencies } from '../cyclic/dependencies.mjs';
 import { IsInterfaceDeferred } from '../../action/index.mjs';
 import { InstantiateProperties } from '../instantiate.mjs';
 import { InstantiateTypes } from '../instantiate.mjs';
+import { State } from '../instantiate.mjs';
 import { EvaluateIntersect } from '../evaluate/evaluate.mjs';
 function CyclicInterface(context, heritage, properties) {
-    const instantiatedHeritage = InstantiateTypes(context, { callstack: [] }, heritage);
-    const instantiatedProperties = InstantiateProperties({}, { callstack: [] }, properties);
+    const instantiatedHeritage = InstantiateTypes(context, State([], []), heritage);
+    const instantiatedProperties = InstantiateProperties({}, State([], []), properties);
     const evaluatedInterface = EvaluateIntersect([...instantiatedHeritage, Object(instantiatedProperties)]);
     return evaluatedInterface;
 }

package/extensions/dm-tasks/node_modules/typebox/build/type/engine/evaluate/composite.d.mts

@@ -1,25 +1,29 @@
 import { type TUnreachable } from '../../../system/unreachable/index.mjs';
-import { type TReadonly, type TReadonlyAdd, type TReadonlyRemove } from '../../types/_readonly.mjs';
-import { type TOptional, type TOptionalAdd, type TOptionalRemove } from '../../types/_optional.mjs';
+import { type TReadonly } from '../../types/_readonly.mjs';
+import { type TOptional } from '../../types/_optional.mjs';
 import { type TSchema } from '../../types/schema.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TNever } from '../../types/never.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
+import { type TAddReadonly } from '../../action/_add_readonly.mjs';
+import { type TAddOptional } from '../../action/_add_optional.mjs';
+import { type TRemoveReadonly } from '../../action/_remove_readonly.mjs';
+import { type TRemoveOptional } from '../../action/_remove_optional.mjs';
 import { type TTupleElementsToProperties } from '../tuple/to_object.mjs';
 import { type TEvaluateIntersect } from './evaluate.mjs';
 type TIsReadonlyProperty<Left extends TSchema, Right extends TSchema> = (Left extends TReadonly<Left> ? Right extends TReadonly<Right> ? true : false : false);
 type TIsOptionalProperty<Left extends TSchema, Right extends TSchema> = (Left extends TOptional<Left> ? Right extends TOptional<Right> ? true : false : false);
-type TCompositeProperty<Left extends TSchema, Right extends TSchema, IsReadonly extends boolean = TIsReadonlyProperty<Left, Right>, IsOptional extends boolean = TIsOptionalProperty<Left, Right>, Evaluated extends TSchema = TEvaluateIntersect<[Left, Right]>, Property extends TSchema = TReadonlyRemove<TOptionalRemove<Evaluated>>> = ([
+type TCompositeProperty<Left extends TSchema, Right extends TSchema, IsReadonly extends boolean = TIsReadonlyProperty<Left, Right>, IsOptional extends boolean = TIsOptionalProperty<Left, Right>, Evaluated extends TSchema = TEvaluateIntersect<[Left, Right]>, Property extends TSchema = TRemoveReadonly<TRemoveOptional<Evaluated>>> = ([
     IsReadonly,
     IsOptional
-] extends [true, true] ? TReadonlyAdd<TOptionalAdd<Property>> : [
+] extends [true, true] ? TAddReadonly<TAddOptional<Property>> : [
     IsReadonly,
     IsOptional
-] extends [true, false] ? TReadonlyAdd<Property> : [
+] extends [true, false] ? TAddReadonly<Property> : [
     IsReadonly,
     IsOptional
-] extends [false, true] ? TOptionalAdd<Property> : Property);
+] extends [false, true] ? TAddOptional<Property> : Property);
 type TCompositePropertyKey<Left extends TProperties, Right extends TProperties, Key extends PropertyKey, Result extends TSchema = (Key extends keyof Left ? Key extends keyof Right ? TCompositeProperty<Left[Key], Right[Key]> : Left[Key] : Key extends keyof Right ? Right[Key] : TNever)> = Result;
 type TCompositeProperties<Left extends TProperties, Right extends TProperties, Result extends TProperties = {
     [Key in keyof (Right & Left)]: TCompositePropertyKey<Left, Right, Key>;

package/extensions/dm-tasks/node_modules/typebox/build/type/engine/evaluate/composite.mjs

@@ -2,11 +2,15 @@
 // deno-lint-ignore-file
 import { Unreachable } from '../../../system/unreachable/index.mjs';
 import { Guard } from '../../../guard/index.mjs';
-import { ReadonlyAdd, ReadonlyRemove, IsReadonly } from '../../types/_readonly.mjs';
-import { OptionalAdd, OptionalRemove, IsOptional } from '../../types/_optional.mjs';
+import { IsReadonly } from '../../types/_readonly.mjs';
+import { IsOptional } from '../../types/_optional.mjs';
 import { Object, IsObject } from '../../types/object.mjs';
 import { Never } from '../../types/never.mjs';
 import { IsTuple } from '../../types/tuple.mjs';
+import { AddReadonly } from '../../action/_add_readonly.mjs';
+import { AddOptional } from '../../action/_add_optional.mjs';
+import { RemoveReadonly } from '../../action/_remove_readonly.mjs';
+import { RemoveOptional } from '../../action/_remove_optional.mjs';
 import { TupleElementsToProperties } from '../tuple/to_object.mjs';
 import { EvaluateIntersect } from './evaluate.mjs';
 function IsReadonlyProperty(left, right) {
@@ -20,10 +24,10 @@ function CompositeProperty(left, right) {
     const isOptional = IsOptionalProperty(left, right);
     const evaluated = EvaluateIntersect([left, right]);
     // Modifiers need to be discarded and re-applied
-    const property = ReadonlyRemove(OptionalRemove(evaluated));
-    return (isReadonly && isOptional ? ReadonlyAdd(OptionalAdd(property)) :
-        isReadonly && !isOptional ? ReadonlyAdd(property) :
-            !isReadonly && isOptional ? OptionalAdd(property) :
+    const property = RemoveReadonly(RemoveOptional(evaluated));
+    return (isReadonly && isOptional ? AddReadonly(AddOptional(property)) :
+        isReadonly && !isOptional ? AddReadonly(property) :
+            !isReadonly && isOptional ? AddOptional(property) :
                 property);
 }
 function CompositePropertyKey(left, right, key) {

package/extensions/dm-tasks/node_modules/typebox/build/type/engine/immutable/instantiate_add.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TImmutable } from '../../types/_immutable.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+type TAddImmutableOperation<Type extends TSchema, Result extends TSchema = '~immutable' extends keyof Type ? Type : TImmutable<Type>> = Result;
+export type TAddImmutableAction<Type extends TSchema, Result extends TSchema = TAddImmutableOperation<Type>> = Result;
+export declare function AddImmutableAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TAddImmutableAction<Type>;
+export type TAddImmutableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TAddImmutableAction<InstantiateType>;
+export declare function AddImmutableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TAddImmutableInstantiate<Context, State, Type>;
+export {};

package/extensions/dm-tasks/node_modules/typebox/build/type/engine/immutable/instantiate_add.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { InstantiateType } from '../instantiate.mjs';
+function AddImmutableOperation(type) {
+    return Memory.Update(type, { '~immutable': true }, {});
+}
+export function AddImmutableAction(type, options) {
+    const result = Memory.Update(AddImmutableOperation(type), {}, options);
+    return result;
+}
+export function AddImmutableInstantiate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return AddImmutableAction(instantiatedType, options);
+}

package/extensions/dm-tasks/node_modules/typebox/build/type/engine/immutable/instantiate_remove.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TImmutable } from '../../types/_immutable.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+type TRemoveImmutableOperation<Type extends TSchema, Result extends TSchema = Type extends TImmutable<infer Type extends TSchema> ? Type : Type> = Result;
+export type TRemoveImmutableAction<Type extends TSchema, Result extends TSchema = TRemoveImmutableOperation<Type>> = Result;
+export declare function RemoveImmutableAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TRemoveImmutableAction<Type>;
+export type TRemoveImmutableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TRemoveImmutableAction<InstantiateType>;
+export declare function RemoveImmutableInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TRemoveImmutableInstantiate<Context, State, Type>;
+export {};

package/extensions/dm-tasks/node_modules/typebox/build/type/engine/immutable/instantiate_remove.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { InstantiateType } from '../instantiate.mjs';
+function RemoveImmutableOperation(type) {
+    return Memory.Discard(type, ['~immutable']);
+}
+export function RemoveImmutableAction(type, options) {
+    const result = Memory.Update(RemoveImmutableOperation(type), {}, options);
+    return result;
+}
+export function RemoveImmutableInstantiate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return RemoveImmutableAction(instantiatedType, options);
+}

package/extensions/dm-tasks/node_modules/typebox/build/type/engine/instantiate.d.mts

@@ -1,6 +1,3 @@
-import { type TImmutable } from '../types/_immutable.mjs';
-import { type TOptional, type TOptionalAdd, type TOptionalRemove } from '../types/_optional.mjs';
-import { type TReadonly, type TReadonlyAdd, type TReadonlyRemove } from '../types/_readonly.mjs';
 import { type TSchema } from '../types/schema.mjs';
 import { type TArray } from '../types/array.mjs';
 import { type TAsyncIterator } from '../types/async_iterator.mjs';
@@ -20,8 +17,15 @@ import { type TTuple } from '../types/tuple.mjs';
 import { type TUnion } from '../types/union.mjs';
 import { type TRef } from '../types/ref.mjs';
 import { type TRest } from '../types/rest.mjs';
-import { type TReadonlyAddAction, type TReadonlyRemoveAction } from '../action/_readonly.mjs';
-import { type TOptionalAddAction, type TOptionalRemoveAction } from '../action/_optional.mjs';
+import { type TAddImmutableInstantiate } from './immutable/instantiate_add.mjs';
+import { type TRemoveImmutableInstantiate } from './immutable/instantiate_remove.mjs';
+import { type TAddReadonlyInstantiate } from './readonly/instantiate_add.mjs';
+import { type TRemoveReadonlyInstantiate } from './readonly/instantiate_remove.mjs';
+import { type TAddOptionalInstantiate } from './optional/instantiate_add.mjs';
+import { type TRemoveOptionalInstantiate } from './optional/instantiate_remove.mjs';
+import { type TOptional } from '../types/_optional.mjs';
+import { type TImmutable } from '../types/_immutable.mjs';
+import { type TReadonly } from '../types/_readonly.mjs';
 import { type TAwaitedInstantiate } from './awaited/instantiate.mjs';
 import { type TCallInstantiate } from './call/instantiate.mjs';
 import { type TCapitalizeInstantiate } from './intrinsics/instantiate.mjs';
@@ -52,19 +56,13 @@ import { type TUncapitalizeInstantiate } from './intrinsics/instantiate.mjs';
 import { type TUppercaseInstantiate } from './intrinsics/instantiate.mjs';
 import { type TWithInstantiate } from './with/instantiate.mjs';
 import { type TRestSpread } from './rest/index.mjs';
-export interface TState {
-    callstack: string[];
+export interface TState<CallStack extends string[] = string[], Visited extends string[] = string[]> {
+    callstack: CallStack;
+    visited: Visited;
 }
+export declare function State<CallStack extends string[], Visited extends string[]>(callstack: CallStack, visited: Visited): TState<CallStack, Visited>;
 export type TCanInstantiate<Types extends TSchema[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TRef ? false : TCanInstantiate<Right> : true;
 export declare function CanInstantiate<Types extends TSchema[]>(types: [...Types]): TCanInstantiate<Types>;
-type ModifierAction = 'add' | 'remove' | 'none';
-type TModifierActions<Type extends TSchema, Readonly extends ModifierAction, Optional extends ModifierAction> = (Type extends TReadonlyRemoveAction<infer Type extends TSchema> ? TModifierActions<Type, 'remove', Optional> : Type extends TOptionalRemoveAction<infer Type extends TSchema> ? TModifierActions<Type, Readonly, 'remove'> : Type extends TReadonlyAddAction<infer Type extends TSchema> ? TModifierActions<Type, 'add', Optional> : Type extends TOptionalAddAction<infer Type extends TSchema> ? TModifierActions<Type, Readonly, 'add'> : [
-    Type,
-    Readonly,
-    Optional
-]);
-type TApplyReadonly<Action extends ModifierAction, Type extends TSchema> = (Action extends 'remove' ? TReadonlyRemove<Type> : Action extends 'add' ? TReadonlyAdd<Type> : Type);
-type TApplyOptional<Action extends ModifierAction, Type extends TSchema> = (Action extends 'remove' ? TOptionalRemove<Type> : Action extends 'add' ? TOptionalAdd<Type> : Type);
 export type TInstantiateProperties<Context extends TProperties, State extends TState, Properties extends TProperties, Result extends TProperties = {
     [Key in keyof Properties]: TInstantiateType<Context, State, Properties[Key]>;
 }> = Result;
@@ -76,6 +74,24 @@ export declare function InstantiateTypes<Context extends TProperties, State exte
 type TInstantiateDeferred<Context extends TProperties, State extends TState, Action extends string, Parameters extends TSchema[]> = ([
     Action,
     Parameters
+] extends ['AddImmutable', [infer Type extends TSchema]] ? TAddImmutableInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['RemoveImmutable', [infer Type extends TSchema]] ? TRemoveImmutableInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['AddReadonly', [infer Type extends TSchema]] ? TAddReadonlyInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['RemoveReadonly', [infer Type extends TSchema]] ? TRemoveReadonlyInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['AddOptional', [infer Type extends TSchema]] ? TAddOptionalInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
+] extends ['RemoveOptional', [infer Type extends TSchema]] ? TRemoveOptionalInstantiate<Context, State, Type> : [
+    Action,
+    Parameters
 ] extends ['Awaited', [infer Type extends TSchema]] ? TAwaitedInstantiate<Context, State, Type> : [
     Action,
     Parameters
@@ -115,7 +131,7 @@ type TInstantiateDeferred<Context extends TProperties, State extends TState, Act
 ] extends ['Mapped', [infer Name extends TIdentifier, infer Key extends TSchema, infer As extends TSchema, infer Property extends TSchema]] ? TMappedInstantiate<Context, State, Name, Key, As, Property> : [
     Action,
     Parameters
-] extends ['Module', [infer Properties extends TProperties]] ? TModuleInstantiate<Context, State, Properties> : [
+] extends ['Module', [infer Declarations extends TProperties]] ? TModuleInstantiate<Context, State, Declarations> : [
     Action,
     Parameters
 ] extends ['NonNullable', [infer Type extends TSchema]] ? TNonNullableInstantiate<Context, State, Type> : [
@@ -155,12 +171,13 @@ type TInstantiateDeferred<Context extends TProperties, State extends TState, Act
     Action,
     Parameters
 ] extends ['With', [infer Type extends TSchema, infer Options extends TSchema]] ? TWithInstantiate<Context, State, Type, Options> : TDeferred<Action, Parameters>);
-export type TInstantiateType<Context extends TProperties, State extends TState, Input extends TSchema, Immutable extends boolean = Input extends TImmutable ? true : false, Modifiers extends [TSchema, ModifierAction, ModifierAction] = TModifierActions<Input, Input extends TReadonly<Input> ? 'add' : 'none', Input extends TOptional<Input> ? 'add' : 'none'>, Type extends TSchema = Modifiers[0], Instantiated extends TSchema = (Type extends TRef<infer Ref extends string> ? TRefInstantiate<Context, State, Type, 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 TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TDependent<TInstantiateType<Context, State, If>, TInstantiateType<Context, State, Then>, TInstantiateType<Context, State, Else>> : 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 = Immutable extends true ? TImmutable<Instantiated> : Instantiated, WithModifiers extends TSchema = TApplyReadonly<Modifiers[1], TApplyOptional<Modifiers[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>;
+export type TInstantiateImmediate<Context extends TProperties, State extends TState, Type extends TSchema, Result extends TSchema = (Type extends TRef<infer Ref extends string> ? TRefInstantiate<Context, State, Type, 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 TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TDependent<TInstantiateType<Context, State, If>, TInstantiateType<Context, State, Then>, TInstantiateType<Context, State, Else>> : 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)> = Result;
+export declare function InstantiateImmediate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type): TInstantiateImmediate<Context, State, Type>;
+type TWithModifiers<Type extends TSchema, InstantiatedType extends TSchema, WithImmutable extends TSchema = Type extends TImmutable ? TImmutable<InstantiatedType> : InstantiatedType, WithReadonly extends TSchema = Type extends TReadonly ? TReadonly<WithImmutable> : WithImmutable, WithOptional extends TSchema = Type extends TOptional ? TOptional<WithReadonly> : WithReadonly> = WithOptional;
+export type TInstantiateType<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateImmediate<Context, State, Type>, WithModifiers extends TSchema = Type extends TDeferred ? InstantiatedType : TWithModifiers<Type, InstantiatedType>> = WithModifiers;
+export declare function InstantiateType<Context extends TProperties, State extends TState, Type extends TSchema>(context: TProperties, state: TState, type: 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, {
-    callstack: [];
-}, Type>);
+export type TInstantiate<Context extends TProperties, Type extends TSchema> = (TInstantiateType<Context, TState<[], []>, Type>);
 /** Instantiates computed schematics using the given context and type. */
 export declare function Instantiate<Context extends TProperties, Type extends TSchema>(context: Context, type: Type): TInstantiate<Context, Type>;
 export {};