@duckmind/dm-darwin-x64 0.36.5 → 0.36.8

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/instantiate.d.mts

@@ -52,9 +52,11 @@ 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';
@@ -158,9 +160,7 @@ type TInstantiateDeferred<Context extends TProperties, State extends TState, Act
 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>;
 /** 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 {};

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

@@ -65,6 +65,9 @@ import { UncapitalizeInstantiate } from './intrinsics/instantiate.mjs';
 import { UppercaseInstantiate } from './intrinsics/instantiate.mjs';
 import { WithInstantiate } from './with/instantiate.mjs';
 import { RestSpread } from './rest/index.mjs';
+export function State(callstack, visited) {
+    return { callstack, visited };
+}
 export function CanInstantiate(types) {
     return Guard.TakeLeft(types, (left, right) => IsRef(left)
         ? false
@@ -157,5 +160,5 @@ export function InstantiateType(context, state, input) {
 }
 /** Instantiates computed schematics using the given context and type. */
 export function Instantiate(context, type) {
-    return InstantiateType(context, { callstack: [] }, type);
+    return InstantiateType(context, State([], []), type);
 }

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

@@ -3,16 +3,13 @@ import { type TProperties } from '../../types/properties.mjs';
 import { type TObject } from '../../types/object.mjs';
 import { type TEvaluateIntersect } from '../evaluate/evaluate.mjs';
 import { type TInterfaceDeferred } from '../../action/index.mjs';
-import { type TState, type TCanInstantiate } from '../instantiate.mjs';
+import { type TCanInstantiate } from '../instantiate.mjs';
 import { type TInstantiateProperties } from '../instantiate.mjs';
 import { type TInstantiateTypes } from '../instantiate.mjs';
+import { type TState } from '../instantiate.mjs';
 type TInterfaceOperation<Heritage extends TSchema[], Properties extends TProperties, Result extends TSchema = TEvaluateIntersect<[...Heritage, TObject<Properties>]>> = Result;
 export type TInterfaceAction<Heritage extends TSchema[], Properties extends TProperties, Result extends TSchema = TCanInstantiate<Heritage> extends true ? TInterfaceOperation<Heritage, Properties> : TInterfaceDeferred<Heritage, Properties>> = Result;
 export declare function InterfaceAction<Heritage extends TSchema[], Properties extends TProperties>(heritage: [...Heritage], properties: Properties, options: TSchemaOptions): TInterfaceAction<Heritage, Properties>;
-export type TInterfaceInstantiate<Context extends TProperties, State extends TState, Heritage extends TSchema[], Properties extends TProperties, InstantiatedHeritage extends TSchema[] = TInstantiateTypes<Context, {
-    callstack: [];
-}, Heritage>, InstantiatedProperties extends TProperties = TInstantiateProperties<Context, {
-    callstack: [];
-}, Properties>> = TInterfaceAction<InstantiatedHeritage, InstantiatedProperties>;
+export type TInterfaceInstantiate<Context extends TProperties, State extends TState, Heritage extends TSchema[], Properties extends TProperties, InstantiatedHeritage extends TSchema[] = TInstantiateTypes<Context, State, Heritage>, InstantiatedProperties extends TProperties = TInstantiateProperties<Context, State, Properties>> = TInterfaceAction<InstantiatedHeritage, InstantiatedProperties>;
 export declare function InterfaceInstantiate<Context extends TProperties, State extends TState, Heritage extends TSchema[], Properties extends TProperties>(context: Context, state: State, heritage: [...Heritage], properties: Properties, options: TSchemaOptions): TInterfaceInstantiate<Context, State, Heritage, Properties>;
 export {};

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

@@ -9,9 +9,7 @@ type TInstantiateCyclics<Context extends TProperties, CyclicKeys extends string[
     [Key in Extract<keyof Context, CyclicKeys[number]>]: TInstantiateCyclic<Context, Key, Context[Key]>;
 }> = Result;
 type TInstantiateNonCyclics<Context extends TProperties, CyclicKeys extends string[], Result extends TProperties = {
-    [Key in Exclude<keyof Context, CyclicKeys[number]>]: TInstantiateType<Context, {
-        callstack: [];
-    }, Context[Key]>;
+    [Key in Exclude<keyof Context, CyclicKeys[number]>]: TInstantiateType<Context, TState<[], []>, Context[Key]>;
 }> = Result;
 type TInstantiateModule<Context extends TProperties, CyclicCandidates extends string[] = TCyclicCandidates<Context>, InstantiatedCyclics extends TProperties = TInstantiateCyclics<Context, CyclicCandidates>, InstantiatedNonCyclics extends TProperties = TInstantiateNonCyclics<Context, CyclicCandidates>, InstantiatedModule extends TProperties = InstantiatedCyclics & InstantiatedNonCyclics> = {
     [Key in keyof InstantiatedModule]: InstantiatedModule[Key];

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

@@ -2,6 +2,7 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { Memory } from '../../../system/memory/index.mjs';
+import { State } from '../instantiate.mjs';
 // ------------------------------------------------------------------
 // Module: Instantiation Infrastructure
 // ------------------------------------------------------------------
@@ -17,7 +18,7 @@ function InstantiateCyclics(context, cyclicKeys) {
 function InstantiateNonCyclics(context, cyclicKeys) {
     const keys = Guard.Keys(context).filter(key => !cyclicKeys.includes(key));
     return keys.reduce((result, key) => {
-        return { ...result, [key]: InstantiateType(context, { callstack: [] }, context[key]) };
+        return { ...result, [key]: InstantiateType(context, State([], []), context[key]) };
     }, {});
 }
 function InstantiateModule(context, options) {

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

@@ -3,11 +3,10 @@ import { type TProperties } from '../../types/properties.mjs';
 import { type TFunction } from '../../types/function.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
 import { type TParametersDeferred } from '../../action/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 TParametersOperation<Type extends TSchema, Parameters extends TSchema[] = Type extends TFunction ? Type['parameters'] : [], InstantiatedParameters extends TSchema[] = TInstantiateElements<{}, {
-    callstack: [];
-}, Parameters>, Result extends TSchema = TTuple<InstantiatedParameters>> = Result;
+import { type TState } from '../instantiate.mjs';
+type TParametersOperation<Type extends TSchema, Parameters extends TSchema[] = Type extends TFunction ? Type['parameters'] : [], InstantiatedParameters extends TSchema[] = TInstantiateElements<{}, TState<[], []>, Parameters>, Result extends TSchema = TTuple<InstantiatedParameters>> = Result;
 export type TParametersAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TParametersOperation<Type> : TParametersDeferred<Type>> = Result;
 export declare function ParametersAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TParametersAction<Type>;
 export type TParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TParametersAction<InstantiatedType>;

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

@@ -6,9 +6,10 @@ import { Tuple } from '../../types/tuple.mjs';
 import { ParametersDeferred } from '../../action/parameters.mjs';
 import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
 import { InstantiateElements } from '../instantiate.mjs';
+import { State } from '../instantiate.mjs';
 function ParametersOperation(type) {
     const parameters = IsFunction(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/ref/instantiate.d.mts

@@ -1,6 +1,6 @@
 import { type TProperties } from '../../types/properties.mjs';
-import { type TState, type TInstantiateType } from '../instantiate.mjs';
-import { type TCyclicCheck } from '../cyclic/check.mjs';
+import { type TInstantiateType } from '../instantiate.mjs';
 import { type TRef } from '../../types/ref.mjs';
-export type TRefInstantiate<Context extends TProperties, State extends TState, Type extends TRef, Ref extends string> = (Ref extends keyof Context ? TCyclicCheck<[Ref], Context, Context[Ref]> extends true ? Type : TInstantiateType<Context, State, Context[Ref]> : Type);
+import { type TState } from '../instantiate.mjs';
+export type TRefInstantiate<Context extends TProperties, State extends TState, Type extends TRef, Ref extends string> = (Ref extends State['visited'][number] ? Type : Ref extends keyof Context ? TInstantiateType<Context, TState<State['callstack'], [...State['visited'], Ref]>, Context[Ref]> : Type);
 export declare function RefInstantiate<Context extends TProperties, State extends TState, Type extends TRef, Ref extends string>(context: Context, state: State, type: Type, ref: Ref): TRefInstantiate<Context, State, Type, Ref>;

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

@@ -1,10 +1,10 @@
 // deno-fmt-ignore-file
 import { InstantiateType } from '../instantiate.mjs';
-import { CyclicCheck } from '../cyclic/check.mjs';
+import { State } from '../instantiate.mjs';
 export function RefInstantiate(context, state, type, ref) {
-    return (ref in context
-        ? CyclicCheck([ref], context, context[ref])
-            ? type
-            : InstantiateType(context, state, context[ref])
-        : type);
+    return (state.visited.includes(ref)
+        ? type
+        : ref in context
+            ? InstantiateType(context, State(state['callstack'], [...state['visited'], ref]), context[ref])
+            : type);
 }

package/extensions/dm-tasks/node_modules/typebox/build/type/extends/tuple.d.mts

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

package/extensions/dm-tasks/node_modules/typebox/build/type/extends/tuple.mjs

@@ -7,6 +7,7 @@ import { ExtendsLeft } from './extends_left.mjs';
 import { ExtendsRight } from './extends_right.mjs';
 import * as Result from './result.mjs';
 import { InstantiateElements } from '../engine/instantiate.mjs';
+import { State } from '../engine/instantiate.mjs';
 // ----------------------------------------------------------------------------
 // Inference
 // ----------------------------------------------------------------------------
@@ -42,7 +43,7 @@ function Elements(inferred, reversed, leftRest, rightRest) {
     return ElementsRight(inferred, reversed, leftRest, rightRest);
 }
 function ExtendsTupleToTuple(inferred, left, right) {
-    const instantiatedRight = InstantiateElements(inferred, { callstack: [] }, right);
+    const instantiatedRight = InstantiateElements(inferred, State([], []), right);
     const reversed = Reversed(instantiatedRight);
     return Elements(inferred, reversed, ApplyReverse(left, reversed), ApplyReverse(instantiatedRight, reversed));
 }
@@ -53,7 +54,7 @@ function ExtendsTupleToArray(inferred, left, right) {
         : Guard.TakeLeft(left, (head, tail) => Result.Match(ExtendsLeft(inferred, head, right), inferred => ExtendsTupleToArray(inferred, tail, right), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred)));
 }
 export function ExtendsTuple(inferred, left, right) {
-    const instantiatedLeft = InstantiateElements(inferred, { callstack: [] }, left);
+    const instantiatedLeft = InstantiateElements(inferred, State([], []), left);
     return (IsTuple(right) ? ExtendsTupleToTuple(inferred, instantiatedLeft, right.items) :
         IsArray(right) ? ExtendsTupleToArray(inferred, instantiatedLeft, right.items) :
             ExtendsRight(inferred, Tuple(instantiatedLeft), right));

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

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

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

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

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

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

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

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

package/extensions/dm-tasks/node_modules/typebox/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "keywords": [
     "typescript",
     "jsonschema"

package/extensions/dm-tasks/package-lock.json

@@ -1256,9 +1256,9 @@
       "optional": true
     },
     "node_modules/typebox": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/typebox/-/typebox-1.2.2.tgz",
-      "integrity": "sha512-0nqIJFL+baWoAEtwa0l/vfbfXg0+3gEhiWGnHuoIiivXjlk/TpxDddG0WER34CojKNpHi4ZXku8XGEz9H55b5Q==",
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/typebox/-/typebox-1.2.3.tgz",
+      "integrity": "sha512-EdFz/9FGvhQK2NmjZjSLri+nd5oMH+t/46/6lueEPbeHmS9WbWOz5IayPyLw0HHIyOWfo+wPrQGcAEQ+GsXc/w==",
       "license": "MIT"
     },
     "node_modules/typescript": {

package/extensions/dm-tasks/src/index.ts

@@ -16,7 +16,7 @@
 
 import { randomUUID } from "node:crypto";
 import { join, resolve } from "node:path";
-import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { AutoClearManager } from "./auto-clear.js";
 import { ProcessTracker } from "./process-tracker.js";

package/extensions/dm-tasks/src/ui/settings-menu.ts

@@ -6,8 +6,8 @@
  * own settings panel style.
  */
 
-import { getSettingsListTheme } from "@mariozechner/pi-coding-agent";
-import { Container, type SettingItem, SettingsList, Spacer, Text } from "@mariozechner/pi-tui";
+import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
+import { Container, type SettingItem, SettingsList, Spacer, Text } from "@earendil-works/pi-tui";
 import { saveTasksConfig, type TasksConfig } from "../tasks-config.js";
 
 // ── Types ───────────────────────────────────────────────────────────────────

package/extensions/dm-tasks/src/ui/task-widget.ts

@@ -8,7 +8,7 @@
  *   ✳/✽ actively executing task (star spinner with activeForm text)
  */
 
-import { truncateToWidth } from "@mariozechner/pi-tui";
+import { truncateToWidth } from "@earendil-works/pi-tui";
 import type { TaskStore } from "../task-store.js";
 
 // ---- Types ----

package/extensions/dm-ultradex/AGENTS.md

@@ -87,13 +87,13 @@ When continuing work, prioritize these items before expanding scope:
 ## Packaging rules
 
 - Core pi packages must stay aligned with DM package docs.
-- Keep `@mariozechner/pi-ai`, `@mariozechner/pi-coding-agent`, and `@mariozechner/pi-tui` in `peerDependencies` and `devDependencies` as needed for local development.
+- Keep `@earendil-works/pi-ai`, `@earendil-works/pi-coding-agent`, and `@earendil-works/pi-tui` in `peerDependencies` and `devDependencies` as needed for local development.
 - Do not move pi core packages into normal runtime `dependencies` unless DM package docs require it.
 - Keep the published tarball limited to runtime files only.
 
 ## Type safety and architecture
 
-- Use public exports from `@mariozechner/pi-ai` and `@mariozechner/pi-coding-agent`.
+- Use public exports from `@earendil-works/pi-ai` and `@earendil-works/pi-coding-agent`.
 - Prefer small focused modules with explicit exports over large shared files.
 - Keep durable config, runtime status, and UI wiring separate.
 - Normalize config on load and save.

package/extensions/dm-ultradex/account-manager.test.ts

@@ -28,7 +28,7 @@ vi.mock("./usage-client", () => ({
 	fetchCodexUsage: mocks.fetchCodexUsage,
 }));
 
-vi.mock("@mariozechner/pi-ai/oauth", () => ({
+vi.mock("@earendil-works/pi-ai/oauth", () => ({
 	refreshOpenAICodexToken: mocks.refreshOpenAICodexToken,
 }));
 

package/extensions/dm-ultradex/account-manager.ts

@@ -1,7 +1,7 @@
 import {
 	type OAuthCredentials,
 	refreshOpenAICodexToken,
-} from "@mariozechner/pi-ai/oauth";
+} from "@earendil-works/pi-ai/oauth";
 import { loadImportedOpenAICodexAuth } from "./auth";
 import { isAccountAvailable, pickBestAccount } from "./selection";
 import {

package/extensions/dm-ultradex/auth.ts

@@ -1,5 +1,5 @@
 import { promises as fs } from "node:fs";
-import type { OAuthCredentials } from "@mariozechner/pi-ai/oauth";
+import type { OAuthCredentials } from "@earendil-works/pi-ai/oauth";
 import { getAgentAuthPath } from "pi-provider-utils/agent-paths";
 
 const AUTH_FILE = getAgentAuthPath();

package/extensions/dm-ultradex/browser.ts

@@ -1,7 +1,7 @@
 import type {
 	ExtensionAPI,
 	ExtensionCommandContext,
-} from "@mariozechner/pi-coding-agent";
+} from "@earendil-works/pi-coding-agent";
 
 export async function openLoginInBrowser(
 	pi: ExtensionAPI,

package/extensions/dm-ultradex/commands.ts

@@ -1,11 +1,11 @@
 import { promises as fs, constants as fsConstants } from "node:fs";
 import path from "node:path";
-import { loginOpenAICodex } from "@mariozechner/pi-ai/oauth";
+import { loginOpenAICodex } from "@earendil-works/pi-ai/oauth";
 import type {
 	ExtensionAPI,
 	ExtensionCommandContext,
-} from "@mariozechner/pi-coding-agent";
-import { DynamicBorder, rawKeyHint } from "@mariozechner/pi-coding-agent";
+} from "@earendil-works/pi-coding-agent";
+import { DynamicBorder, rawKeyHint } from "@earendil-works/pi-coding-agent";
 import {
 	type AutocompleteItem,
 	Container,
@@ -14,7 +14,7 @@ import {
 	Spacer,
 	truncateToWidth,
 	visibleWidth,
-} from "@mariozechner/pi-tui";
+} from "@earendil-works/pi-tui";
 import { getAgentSettingsPath } from "pi-provider-utils/agent-paths";
 import { normalizeUnknownError } from "pi-provider-utils/streams";
 import type { AccountManager } from "./account-manager";

package/extensions/dm-ultradex/extension.ts

@@ -1,8 +1,8 @@
-import type { Model } from "@mariozechner/pi-ai";
+import type { Model } from "@earendil-works/pi-ai";
 import type {
 	ExtensionAPI,
 	ExtensionContext,
-} from "@mariozechner/pi-coding-agent";
+} from "@earendil-works/pi-coding-agent";
 import { AccountManager } from "./account-manager";
 import { registerCommands } from "./commands";
 import { handleNewSessionSwitch, handleSessionStart } from "./hooks";

package/extensions/dm-ultradex/index.test.ts

@@ -1,4 +1,4 @@
-import { getModels } from "@mariozechner/pi-ai";
+import { mirrorProvider } from "pi-provider-utils/providers";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
 const syncMocks = vi.hoisted(() => ({
@@ -73,9 +73,11 @@ describe("isQuotaErrorMessage", () => {
 
 describe("getOpenAICodexMirror", () => {
 	it("mirrors the openai-codex provider models exactly (metadata)", () => {
-		const sourceModels = getModels("openai-codex");
+		const sourceMirror = mirrorProvider("openai-codex");
+		expect(sourceMirror).toBeTruthy();
+		const sourceModels = sourceMirror?.models ?? [];
 		const expected = {
-			baseUrl: sourceModels[0]?.baseUrl || "https://chatgpt.com/backend-api",
+			baseUrl: sourceMirror?.baseUrl || "https://chatgpt.com/backend-api",
 			models: sourceModels.map((m) => ({
 				id: m.id,
 				name: m.name,

package/extensions/dm-ultradex/node_modules/.package-lock.json

@@ -4,6 +4,15 @@
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
+		"../../pi-mono/packages/ai": {
+			"dev": true
+		},
+		"../../pi-mono/packages/coding-agent": {
+			"dev": true
+		},
+		"../../pi-mono/packages/tui": {
+			"dev": true
+		},
 		"node_modules/pi-provider-utils": {
 			"version": "0.0.0",
 			"resolved": "https://registry.npmjs.org/pi-provider-utils/-/pi-provider-utils-0.0.0.tgz",