@shd101wyy/yo 0.1.14 → 0.1.16

package/out/types/src/cache.d.ts

@@ -1,3 +1,5 @@
 export declare function getGlobalCacheDir(): string;
 export declare function getGlobalDepsCacheDir(): string;
 export declare function ensureGlobalDepsCacheDir(): string;
+export declare function getGlobalVersionsCacheDir(): string;
+export declare function getVersionCacheDir(version: string): string;

package/out/types/src/codegen/exprs/return.d.ts

@@ -1,7 +1,7 @@
 import { type Expr, type FnCallExpr } from "../../expr";
 import type { FunctionGenerationContext } from "../functions/context";
 import { type CodeGenContext } from "../utils";
-export declare function generatePendingDeferredDrops(indent: string, context: FunctionGenerationContext, expr: Expr, isCompletion?: boolean, skipAlreadyDroppedCheck?: boolean, skipEnvCheck?: boolean): void;
+export declare function generatePendingDeferredDrops(indent: string, context: FunctionGenerationContext, expr: Expr, isCompletion?: boolean, skipAlreadyDroppedCheck?: boolean, skipEnvCheck?: boolean, additionalSkipVarNames?: Set<string>): void;
 export declare function generateConsumedVarDropsForEscape(indent: string, context: FunctionGenerationContext, expr: Expr, skipEnvCheck?: boolean): void;
 export declare function generateReturn(expr: FnCallExpr, indent: string, context: CodeGenContext): string;
 export declare function generateImplicitReturnStatement(expr: Expr, indent: string, context: CodeGenContext): void;

package/out/types/src/codegen/types/generation.d.ts

@@ -4,8 +4,6 @@ export declare function generateTypeDeclarations(context: CodeGenContext): void;
 export declare function generateArrayStructDeclarations(context: CodeGenContext): void;
 export declare function generateSliceStructDeclarations(context: CodeGenContext): void;
 export declare function generateIsoTypeDeclarations(context: CodeGenContext): void;
-export declare function generateArcTypeForwardDeclarations(context: CodeGenContext): void;
-export declare function generateArcTypeDefinitions(context: CodeGenContext): void;
 export declare function generateClosureDeclaration(functionType: FunctionType, cName: string, captureType: StructType | undefined, context: CodeGenContext): void;
 export declare function generateStructDeclaration(structType: StructType, cName: string, context: CodeGenContext): void;
 export declare function generateTupleDeclaration(tupleType: TupleType, cName: string, context: CodeGenContext): void;

package/out/types/src/codegen/utils/index.d.ts

@@ -3,7 +3,7 @@ import { type Environment } from "../../env";
 import { type Expr } from "../../expr";
 import type { FunctionValue, FuncValueId } from "../../function-value";
 import type { TargetInfo } from "../../target";
-import type { ArcType, DynType, EnumType, FunctionType, IsoType, StructType, Type, TypeId } from "../../types/definitions";
+import type { DynType, EnumType, FunctionType, IsoType, StructType, Type, TypeId } from "../../types/definitions";
 import { type TraitValue } from "../../value";
 export interface CodeGenContext {
     types: Record<TypeId, {
@@ -36,13 +36,6 @@ export interface CodeGenContext {
         extractGenerated?: boolean;
         disposeGenerated?: boolean;
     }>;
-    arcTypes?: Map<string, {
-        childTypeCName: string;
-        arcType: ArcType;
-        structGenerated?: boolean;
-        createGenerated?: boolean;
-        disposeGenerated?: boolean;
-    }>;
     spawnedFunctionSignatures: Map<string, {
         parameterTypes: Type[];
         returnType: Type;
@@ -61,6 +54,7 @@ export interface CodeGenContext {
         functionCName: string;
         callTypeId: TypeId;
         callType?: FunctionType;
+        consumedCaptures?: string[];
     }>;
     currentFunctionName: string;
     cIncludes: Set<string>;

package/out/types/src/doc/extractor.d.ts

@@ -17,6 +17,10 @@ export interface DocExtractionResult {
 export interface InlineDocResult {
     docs: Map<string, string>;
 }
+export declare function getDocCommentLookupKey(target: {
+    position: Token["position"];
+    modulePath: string;
+}): string;
 export declare function stripDocLineComment(value: string): string;
 export declare function stripDocBlockComment(value: string): string;
 export declare function extractDocComments(tokens: Token[]): DocExtractionResult;

package/out/types/src/evaluator/builtins/rc-fns.d.ts

@@ -61,11 +61,6 @@ export declare function evaluateYoIsoDispose({ expr, env, context, }: {
     env: Environment;
     context: EvaluatorContext;
 }): Expr;
-export declare function evaluateYoArcDispose({ expr, env, context, }: {
-    expr: FnCallExpr;
-    env: Environment;
-    context: EvaluatorContext;
-}): Expr;
 export declare function evaluateYoDropArrayElement({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

package/out/types/src/evaluator/context.d.ts

@@ -38,6 +38,7 @@ export interface EvaluatorContext {
     isEvaluatingFunctionBodyOrAsyncBlock?: FunctionEvaluationContext | AsyncBlockEvaluationContext | TestBlockEvaluationContext;
     isInsideImplBlock?: boolean;
     capturedVariables?: Map<string, CapturedVariableInfo>;
+    ownConsumedCaptures?: Set<string>;
     isEvaluatingLoopBody?: {
         kind: "while" | "for";
         env: Environment;
@@ -69,6 +70,12 @@ export interface EvaluatorContext {
     isInsideIoAsyncCall?: boolean;
     isInsideGivenHandler?: boolean;
     isEvaluatingGenericImplSpecialization?: boolean;
+    currentlySpecializingFunction?: {
+        originalFuncId: string;
+        specializedFuncId: string;
+        specializedReturnType: Type;
+        originalFunction: FunctionValue;
+    };
     docCommentLookup?: Map<string, string>;
 }
 export interface ArgValues {
@@ -178,9 +185,6 @@ export interface FunctionToCall {
     } | {
         kind: "iso-value";
         result: FnCallExpr;
-    } | {
-        kind: "arc-value";
-        result: FnCallExpr;
     } | {
         kind: "index";
         result: IndexCallResult;

package/out/types/src/evaluator/trait-checking.d.ts

@@ -16,6 +16,8 @@ export declare function checkTypeImplementsSelfConstraints({ targetType, traitTy
 export declare function typeImplementsComptime(type: Type, env: Environment): boolean;
 export declare function findSomeTypeMissingComptimeConstraint(type: Type, env: Environment): SomeType | undefined;
 export declare function typeImplementsRuntime(type: Type, env: Environment): boolean;
+export declare function beginSendDerivation(typeId: string): void;
+export declare function endSendDerivation(typeId: string): void;
 export declare function typeImplementsSend(type: Type | undefined, env: Environment): boolean;
 export declare function typeImplementsDispose(type: Type | undefined, env: Environment): boolean;
 export declare function typeImplementsAcyclic(type: Type | undefined, env: Environment): boolean;

package/out/types/src/evaluator/types/object.d.ts

@@ -1,8 +1,9 @@
 import type { Environment } from "../../env";
 import { type FnCallExpr } from "../../expr";
 import type { EvaluatorContext } from "../context";
-export declare function evaluateObjectType({ expr, env, context, }: {
+export declare function evaluateObjectType({ expr, env, context, isAtomicRc, }: {
     expr: FnCallExpr;
     env: Environment;
     context: EvaluatorContext;
+    isAtomicRc?: boolean;
 }): FnCallExpr;

package/out/types/src/evaluator/types/struct.d.ts

@@ -1,8 +1,9 @@
 import type { Environment } from "../../env";
 import { type FnCallExpr } from "../../expr";
 import type { EvaluatorContext } from "../context";
-export declare function evaluateStructType({ expr, env, context, }: {
+export declare function evaluateStructType({ expr, env, context, isAtomicRc, }: {
     expr: FnCallExpr;
     env: Environment;
     context: EvaluatorContext;
+    isAtomicRc?: boolean;
 }): FnCallExpr;

package/out/types/src/evaluator/types/utils.d.ts

@@ -1,18 +1,18 @@
 import type { Environment } from "../../env";
 import type { Token } from "../../token";
-import type { ArcType, DynType, EnumType, IsoType, SomeType, StructType, TupleType, UnionType } from "../../types/definitions";
+import type { DynType, EnumType, IsoType, SomeType, StructType, TupleType, UnionType } from "../../types/definitions";
 import type { EvaluatorContext } from "../context";
 export declare function addFunctionSignatureToSelfTypeModule({ label, functionSignature, SelfType, env, context, }: {
     label: string;
     functionSignature: string;
-    SelfType: StructType | EnumType | DynType | SomeType | IsoType | ArcType;
+    SelfType: StructType | EnumType | DynType | SomeType | IsoType;
     env: Environment;
     context: EvaluatorContext;
 }): Environment;
 export declare function addFunctionCodeToSelfTypeModule({ label, functionCode, SelfType, env, context, }: {
     label: string;
     functionCode: string;
-    SelfType: StructType | EnumType | DynType | SomeType | IsoType | ArcType;
+    SelfType: StructType | EnumType | DynType | SomeType | IsoType;
     env: Environment;
     context: EvaluatorContext;
 }): Environment;
@@ -54,11 +54,6 @@ export declare function addRcFunctionsToIsoType({ isoType, env, context, }: {
     env: Environment;
     context: EvaluatorContext;
 }): Environment;
-export declare function addRcFunctionsToArcType({ arcType, env, context, }: {
-    arcType: ArcType;
-    env: Environment;
-    context: EvaluatorContext;
-}): Environment;
 export declare function attachTraitToReceiverType(moduleName: string, receiverType: StructType | EnumType | UnionType | TupleType | SomeType, env: Environment, context: EvaluatorContext): Environment;
 export declare function autoDeriveSendForStructType({ structType, env, context, }: {
     structType: StructType;

package/out/types/src/evaluator/values/impl.d.ts

@@ -1,6 +1,6 @@
 import { type Environment } from "../../env";
 import { type Expr, type FnCallExpr } from "../../expr";
-import type { FunctionType, SomeType, TraitType, Type } from "../../types/definitions";
+import type { FunctionType, SomeType, TraitField, TraitType, Type } from "../../types/definitions";
 import { type TraitValue, type UnknownValue, type Value } from "../../value";
 import type { EvaluatorContext } from "../context";
 export type ForallParameter = {
@@ -44,6 +44,13 @@ export declare function findMethodsFromGenericImpls({ concreteType, methodName,
     type: FunctionType;
     value: Value | undefined;
 }[];
+export declare function enumerateMethodNamesFromGenericImpls({ concreteType, env, }: {
+    concreteType: Type;
+    env: Environment;
+}): {
+    name: string;
+    type: FunctionType;
+}[];
 export declare function findAssociatedTypeFromGenericImpls({ concreteType, propertyName, env, }: {
     concreteType: Type;
     propertyName: string;
@@ -62,6 +69,7 @@ export declare function findMethodFromGenericImplForTrait({ concreteType, traitT
     value: Value | undefined;
 } | undefined;
 export declare function clearImplsFromModule(modulePath: string): void;
+export declare function snapshotAllImplTraitFields(): Map<TraitType, TraitField[]>;
 export declare function evaluateModuleValue({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

package/out/types/src/expr.d.ts

@@ -133,6 +133,7 @@ export declare const BuiltinKeywords: {
     type: string[];
     match: string[];
     test: string[];
+    atomic: string[];
     struct: string[];
     object: string[];
     newtype: string[];
@@ -166,7 +167,6 @@ export declare const BuiltinKeywords: {
     unique: string[];
     Ptr: string[];
     Iso: string[];
-    Arc: string[];
     Tuple: string[];
     Array: string[];
     Slice: string[];
@@ -552,7 +552,6 @@ export declare const BuiltinFunctions: {
     __yo_rc_own: string[];
     __yo_iso_extract: string[];
     __yo_iso_dispose: string[];
-    __yo_arc_dispose: string[];
     __yo_gc_collect: string[];
     __yo_dyn_drop: string[];
     __yo_dyn_dup: string[];

package/out/types/src/function-value.d.ts

@@ -46,4 +46,5 @@ export interface ClosureInfo {
     closureType: FnTraitType;
     captureType: Type | undefined;
     effectParamNames?: string[];
+    consumedCaptures?: string[];
 }

package/out/types/src/lsp/completion.d.ts

@@ -0,0 +1,3 @@
+import type { CompletionItem } from "vscode-languageserver";
+import type { LspDocumentManager } from "./document-manager";
+export declare function handleCompletion(uri: string, line: number, character: number, lineText: string, docManager: LspDocumentManager): CompletionItem[];

package/out/types/src/lsp/definition.d.ts

@@ -0,0 +1,3 @@
+import type { Location } from "vscode-languageserver";
+import type { LspDocumentManager } from "./document-manager";
+export declare function handleDefinition(uri: string, line: number, character: number, docManager: LspDocumentManager): Location | null;

package/out/types/src/lsp/diagnostics.d.ts

@@ -0,0 +1,6 @@
+import type { Diagnostic } from "vscode-languageserver";
+import { YoLexerError } from "../error";
+import type { LspDocumentManager } from "./document-manager";
+export declare function getDiagnosticsForUri(uri: string, docManager: LspDocumentManager, documentText?: string): Diagnostic[];
+export declare function errorToDiagnostics(error: Error, documentText?: string): Diagnostic[];
+export declare function lexerErrorToDiagnostic(error: YoLexerError, text: string): Diagnostic;

package/out/types/src/lsp/document-manager.d.ts

@@ -0,0 +1,31 @@
+import type { TextDocuments } from "vscode-languageserver";
+import type { TextDocument } from "vscode-languageserver-textdocument";
+import { ModuleManager } from "../module-manager";
+type ModuleData = NonNullable<ReturnType<ModuleManager["modules"]["get"]>>;
+export declare class LspDocumentManager {
+    private moduleManager;
+    private moduleManagerStdPath;
+    private evaluatedBuildProjects;
+    private lastAnalyzedTextByUri;
+    private analyzeGenerationByUri;
+    private lastGoodModules;
+    constructor(stdPath?: string);
+    getStdPath(): string | null;
+    attachToDocuments(documents: TextDocuments<TextDocument>, onDiagnostics: (uri: string) => void): void;
+    analyzeDocument(document: TextDocument, onDiagnostics: (uri: string) => void): void;
+    getModule(uri: string): {
+        moduleValue: import("../value").ModuleValue;
+        moduleError: Error | undefined;
+        evaluator: import("../evaluator").default;
+    } | undefined;
+    getModuleForCompletion(uri: string): ModuleData | undefined;
+    getLastGoodModule(uri: string): ModuleData | undefined;
+    getModuleManager(): ModuleManager;
+    private ensureStdPathForUri;
+    private findStdPath;
+    private findBuildYoForUri;
+    private ensureBuildImportsResolved;
+    private findDependencyDir;
+    private resolveDepModuleRoot;
+}
+export {};

package/out/types/src/lsp/folding.d.ts

@@ -0,0 +1,3 @@
+import { FoldingRange } from "vscode-languageserver";
+import type { LspDocumentManager } from "./document-manager";
+export declare function handleFoldingRange(uri: string, docManager: LspDocumentManager): FoldingRange[];

package/out/types/src/lsp/hover.d.ts

@@ -0,0 +1,3 @@
+import type { Hover } from "vscode-languageserver";
+import type { LspDocumentManager } from "./document-manager";
+export declare function handleHover(uri: string, line: number, character: number, docManager: LspDocumentManager): Hover | null;

package/out/types/src/lsp/inlay-hints.d.ts

@@ -0,0 +1,3 @@
+import { type InlayHint } from "vscode-languageserver";
+import type { LspDocumentManager } from "./document-manager";
+export declare function handleInlayHint(uri: string, docManager: LspDocumentManager): InlayHint[];

package/out/types/src/lsp/references.d.ts

@@ -0,0 +1,3 @@
+import type { Location } from "vscode-languageserver";
+import type { LspDocumentManager } from "./document-manager";
+export declare function handleReferences(uri: string, line: number, character: number, docManager: LspDocumentManager): Location[] | null;

package/out/types/src/lsp/rename.d.ts

@@ -0,0 +1,16 @@
+import type { RenameParams, WorkspaceEdit } from "vscode-languageserver";
+import type { LspDocumentManager } from "./document-manager";
+export declare function handleRename(params: RenameParams, docManager: LspDocumentManager): WorkspaceEdit | null;
+export declare function handlePrepareRename(uri: string, line: number, character: number, docManager: LspDocumentManager): {
+    range: {
+        start: {
+            line: number;
+            character: number;
+        };
+        end: {
+            line: number;
+            character: number;
+        };
+    };
+    placeholder: string;
+} | null;

package/out/types/src/lsp/server.d.ts

@@ -0,0 +1 @@
+export {};

package/out/types/src/lsp/signature-help.d.ts

@@ -0,0 +1,3 @@
+import { type SignatureHelp } from "vscode-languageserver";
+import type { LspDocumentManager } from "./document-manager";
+export declare function handleSignatureHelp(uri: string, line: number, character: number, docManager: LspDocumentManager): SignatureHelp | null;

package/out/types/src/lsp/symbols.d.ts

@@ -0,0 +1,3 @@
+import { DocumentSymbol } from "vscode-languageserver";
+import type { LspDocumentManager } from "./document-manager";
+export declare function handleDocumentSymbol(uri: string, docManager: LspDocumentManager): DocumentSymbol[];

package/out/types/src/lsp/utils.d.ts

@@ -0,0 +1,11 @@
+import type { Variable } from "../env";
+import { type AtomExpr, type Expr } from "../expr";
+import { type Token } from "../token";
+export declare function findTokenAtPosition(tokens: Token[], line: number, character: number): Token | null;
+export declare function collectExpressionCandidates(exprs: Expr[], targetToken: Token, candidateExprs: AtomExpr[]): void;
+export declare function findBestExpressionMatch(exprs: Expr[], targetToken: Token, targetLine: number): Expr | null;
+export declare function selectBestVariableAtPosition(variables: Variable[], targetToken: Pick<Token, "position" | "modulePath">): Variable | undefined;
+export declare function walkExprs(exprs: Expr[], visitor: (expr: Expr) => void): void;
+export declare function modulePathToUri(modulePath: string): string;
+export declare function uriToModulePath(uri: string): string;
+export declare function modulePathToFsPath(modulePath: string): string;

package/out/types/src/tests/lsp.test.d.ts

@@ -0,0 +1 @@
+export {};

package/out/types/src/tests/version.test.d.ts

@@ -0,0 +1 @@
+export {};

package/out/types/src/types/creators.d.ts

@@ -3,7 +3,7 @@ import type { EvaluatorContext } from "../evaluator/context";
 import type { Expr } from "../expr";
 import type { FunctionValue } from "../function-value";
 import { type Value } from "../value";
-import type { ArcType, ArrayType, ComptimeListType, DynType, EffectsRowType, EnumType, FnTraitType, FunctionForallParameter, FunctionImplicitParameter, FunctionParameter, FunctionParameterExprs, FunctionReturn, FunctionType, FutureTraitType, IsoType, ModuleType, PtrType, SliceType, SomeType, StructType, TraitType, TupleType, Type, TypeApplicationType, TypeField, TypeHierarchyType, UnionType, VoidType } from "./definitions";
+import type { ArrayType, ComptimeListType, DynType, EffectsRowType, EnumType, FnTraitType, FunctionForallParameter, FunctionImplicitParameter, FunctionParameter, FunctionParameterExprs, FunctionReturn, FunctionType, FutureTraitType, IsoType, ModuleType, PtrType, SliceType, SomeType, StructType, TraitType, TupleType, Type, TypeApplicationType, TypeField, TypeHierarchyType, UnionType, VoidType } from "./definitions";
 export declare function createComptimeIntType(): Type;
 export declare function createComptimeFloatType(): Type;
 export declare function createComptimeStringType(): Type;
@@ -40,7 +40,7 @@ export declare function createSliceType(childType: Type): SliceType;
 export declare function createStrType(env: Environment): Type;
 export declare function createVoidType(): VoidType;
 export declare function createTupleType(fields: TypeField[]): TupleType;
-export declare function createStructType(env: Environment, isReferenceSemantics?: boolean, isNewtype?: boolean): StructType;
+export declare function createStructType(env: Environment, isReferenceSemantics?: boolean, isNewtype?: boolean, isAtomicRc?: boolean): StructType;
 export declare function createModuleType(env: Environment): ModuleType;
 export declare function createTraitType(env: Environment): TraitType;
 export declare function createEnumType(env: Environment): EnumType;
@@ -61,7 +61,6 @@ export declare function createFunctionType({ parameters, forallParameters, impli
 }): FunctionType;
 export declare function createPtrType(childType: Type): PtrType;
 export declare function createIsoType(childType: Type, env: Environment): IsoType;
-export declare function createArcType(childType: Type, env: Environment): ArcType;
 export declare function createSomeType(type: TypeHierarchyType, variableName: string, { id, requiredTraits, negativeTraits, recursiveTypeRef, env, context, }: {
     id?: string;
     requiredTraits?: TraitType[];

package/out/types/src/types/definitions.d.ts

@@ -97,6 +97,7 @@ export interface TypeField {
     assignedValue?: Value;
     exprs: FieldExprs;
     isEffectParam?: boolean;
+    docComment?: string;
 }
 export interface TupleType extends Type {
     tag: TypeTag.Tuple;
@@ -132,6 +133,7 @@ export type FunctionImplicitParameter = FunctionParameter & {
 export interface StructType extends Type {
     tag: TypeTag.Struct;
     isReferenceSemantics: boolean;
+    isAtomicRc?: boolean;
     isNewtype: boolean;
     functionValue?: FunctionValue;
     fields: TypeField[];
@@ -145,6 +147,7 @@ export interface ModuleField {
     defaultValue?: Value;
     assignedValue?: Value;
     exprs: FieldExprs;
+    docComment?: string;
 }
 export interface TraitField extends ModuleField {
     unassignedSomeType?: SomeType;
@@ -257,12 +260,6 @@ export interface IsoType extends Type {
     trait: TraitType;
     env: Environment;
 }
-export interface ArcType extends Type {
-    tag: TypeTag.Arc;
-    childType: Type;
-    trait: TraitType;
-    env: Environment;
-}
 export interface DynType extends Type {
     tag: TypeTag.Dyn;
     requiredTraits: {

package/out/types/src/types/guards.d.ts

@@ -1,5 +1,5 @@
 import { FunctionValue } from "../function-value";
-import type { ArcType, ArrayType, ComptimeListType, ConcreteModuleType, DynType, EffectsRowType, EnumType, FnTraitType, FunctionType, FutureTraitType, IsoType, ModuleType, PtrType, SliceType, SomeType, StructType, TraitType, TupleType, Type, TypeApplicationType, TypeHierarchyType, UnionType, VoidType } from "./definitions";
+import type { ArrayType, ComptimeListType, ConcreteModuleType, DynType, EffectsRowType, EnumType, FnTraitType, FunctionType, FutureTraitType, IsoType, ModuleType, PtrType, SliceType, SomeType, StructType, TraitType, TupleType, Type, TypeApplicationType, TypeHierarchyType, UnionType, VoidType } from "./definitions";
 export declare function isPrimitiveType(type: Type): boolean;
 export declare function isUnitType(type?: Type): boolean;
 export declare function isComptimeIntType(type?: Type): boolean;
@@ -30,6 +30,10 @@ export declare function isStructType(type?: Type): type is StructType;
 export declare function isObjectType(type?: Type): type is StructType & {
     isReferenceSemantics: true;
 };
+export declare function isAtomicObjectType(type?: Type): type is StructType & {
+    isReferenceSemantics: true;
+    isAtomicRc: true;
+};
 export declare function isNewtypeType(type?: Type): type is StructType & {
     isNewtype: true;
 };
@@ -45,7 +49,6 @@ export declare function isType0(type?: Type): boolean;
 export declare function isSomeType(type?: Type): type is SomeType;
 export declare function isPtrType(type?: Type): type is PtrType;
 export declare function isIsoType(type?: Type): type is IsoType;
-export declare function isArcType(type?: Type): type is ArcType;
 export declare function isDynType(type?: Type): type is DynType;
 export declare function isTypeApplicationType(type?: Type): type is TypeApplicationType;
 export declare function isRcType(type?: Type): boolean;

package/out/types/src/types/tags.d.ts

@@ -40,7 +40,6 @@ export declare enum TypeTag {
     Trait = "Trait",
     Ptr = "Ptr",
     Iso = "Iso",
-    Arc = "Arc",
     Dyn = "Dyn",
     Expr = "Expr",
     ComptimeList = "ComptimeList",

package/out/types/src/version-cache.d.ts

@@ -0,0 +1,7 @@
+export declare function isVersionCached(version: string): boolean;
+export declare function listCachedVersions(): string[];
+export declare function cleanVersionCache(version?: string): void;
+export declare function ensureCachedVersion(version: string): Promise<string>;
+export declare function downloadVersion(version: string): Promise<string>;
+export declare function fetchRemoteVersions(): Promise<string[]>;
+export declare function findJsRuntime(): string;

package/out/types/src/version.d.ts

@@ -0,0 +1,5 @@
+export declare function getCurrentYoVersion(): string;
+export declare function findYoVersionFile(startDir: string): string | null;
+export declare function parseYoVersion(content: string): string;
+export declare function readYoVersion(startDir: string): string | null;
+export declare function isPinnedVersionCurrent(pinnedVersion: string): boolean;