@jointhedots/gear 1.1.13 → 1.1.15

package/esm/builder/build-target.js

@@ -66,7 +66,8 @@ export class BuildTarget {
         const start = Date.now();
         await task.execute();
         const elapsed = (Date.now() - start) / 1000;
-        this.log.info(`⏱ ${name} completed in ${elapsed.toFixed(2)}s`);
+        if (elapsed > 1.0)
+            this.log.info(`⏱ ${name} completed in ${elapsed.toFixed(2)}s`);
     }
     async build() {
         const buildStartTime = Date.now();

package/esm/builder/helpers/emit-esmodules.js

@@ -9,7 +9,7 @@ import { PackageRootDir, resolve_normalized_suffixed_path } from "../../utils/fi
 import { Library } from "../../model/workspace.js";
 import { computeNameHashID } from "../../utils/normalized-name.js";
 import { BuildTask } from "./task.js";
-const VirtualOutDir = Path.normalize('X:/');
+const VirtualOutDir = process.platform === 'win32' ? 'X:\\' : '/_/';
 function getEsbuildLogLevel(mode) {
     switch (mode) {
         case "verbose":

package/esm/builder/helpers/emit-typescript-definition.js

@@ -1,7 +1,9 @@
-import * as Glob from 'glob';
+import Fs from 'fs';
 import Os from 'os';
 import Path from 'path';
 import Ts from 'typescript';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
 import { BuildTask } from "./task.js";
 import { BuildTarget } from "../build-target.js";
 import { Library } from "../../model/workspace.js";
@@ -33,15 +35,6 @@ function getError(diagnostics) {
     error.name = 'EmitterError';
     return error;
 }
-function getFilenames(baseDir, files) {
-    return files.map(function (filename) {
-        const resolvedFilename = Path.resolve(filename);
-        if (resolvedFilename.indexOf(baseDir) === 0) {
-            return resolvedFilename;
-        }
-        return Path.resolve(baseDir, filename);
-    });
-}
 function processTree(sourceFile, replacer) {
     let code = '';
     let cursorPosition = 0;
@@ -67,19 +60,6 @@ function processTree(sourceFile, replacer) {
     code += sourceFile.text.slice(cursorPosition);
     return code;
 }
-function getTSConfig(baseDir, tsconfig) {
-    const { config, error } = Ts.parseConfigFileTextToJson("tsconfig.json", tsconfig);
-    if (error)
-        throw getError([error]);
-    const configParsed = Ts.parseJsonConfigFileContent(config, Ts.sys, baseDir);
-    if (configParsed.errors && configParsed.errors.length) {
-        throw getError(configParsed.errors);
-    }
-    return [
-        configParsed.fileNames,
-        configParsed.options
-    ];
-}
 function isNodeKindImportType(value) {
     return value && value.kind === Ts.SyntaxKind.ImportType;
 }
@@ -97,212 +77,144 @@ function isNodeKindExportDeclaration(value) {
 }
 class TypescriptProject {
     baseDir;
-    files;
     compilerOptions;
-    host;
-    program;
-    filenames;
+    dtsDir;
     constructor(baseDir, tsconfig, outDir) {
         this.baseDir = Path.resolve(baseDir);
-        const [files, compilerOptions] = getTSConfig(baseDir, tsconfig);
-        compilerOptions.declaration = true;
-        compilerOptions.emitDeclarationOnly = true;
-        compilerOptions.noEmit = false;
-        compilerOptions.target = compilerOptions.target || Ts.ScriptTarget.Latest;
-        compilerOptions.moduleResolution = compilerOptions.moduleResolution || Ts.ModuleResolutionKind.Bundler;
+        const { config, error } = Ts.parseConfigFileTextToJson("tsconfig.json", tsconfig);
+        if (error)
+            throw getError([error]);
+        const configParsed = Ts.parseJsonConfigFileContent(config, Ts.sys, baseDir);
+        if (configParsed.errors?.length)
+            throw getError(configParsed.errors);
+        const compilerOptions = configParsed.options;
         compilerOptions.outDir = compilerOptions.outDir || outDir;
-        this.files = files;
         this.compilerOptions = compilerOptions;
-        this.filenames = getFilenames(this.baseDir, files);
-        this.host = Ts.createCompilerHost(compilerOptions);
-        this.program = Ts.createProgram(this.filenames, compilerOptions, this.host);
+        // Create a temp directory for tsgo to emit .d.ts into
+        this.dtsDir = Fs.mkdtempSync(Path.join(Os.tmpdir(), 'gear-dts-'));
     }
-    getSourceFiles() {
-        return this.program.getSourceFiles();
-    }
-    emit(sourceFile, writeFile) {
-        return this.program.emit(sourceFile, writeFile);
-    }
-    getSemanticDiagnostics(sourceFile) {
-        return this.program.getSemanticDiagnostics(sourceFile);
+    /** Run tsgo to emit .d.ts files into dtsDir. Returns stderr output. */
+    async emitWithTsgo() {
+        const tsgoPath = Path.resolve('node_modules/.bin/tsgo');
+        const args = [
+            '-p', Path.join(this.baseDir, 'tsconfig.json'),
+            '--declaration',
+            '--emitDeclarationOnly',
+            '--skipLibCheck',
+            '--outDir', this.dtsDir,
+        ];
+        try {
+            await promisify(execFile)(tsgoPath, args, {
+                cwd: this.baseDir,
+                timeout: 120_000,
+                shell: true,
+            });
+        }
+        catch (e) {
+            // tsgo may exit non-zero on type errors but still emit .d.ts files
+        }
     }
-    getSyntacticDiagnostics(sourceFile) {
-        return this.program.getSyntacticDiagnostics(sourceFile);
+    /** Recursively collect all .d.ts files emitted by tsgo */
+    getEmittedDtsFiles() {
+        const results = [];
+        function walk(dir) {
+            for (const entry of Fs.readdirSync(dir, { withFileTypes: true })) {
+                const full = Path.join(dir, entry.name);
+                if (entry.isDirectory())
+                    walk(full);
+                else if (isDtsFilename(entry.name))
+                    results.push(full);
+            }
+        }
+        if (Fs.existsSync(this.dtsDir))
+            walk(this.dtsDir);
+        return results;
     }
-    getDeclarationDiagnostics(sourceFile) {
-        return this.program.getDeclarationDiagnostics(sourceFile);
+    /** Clean up temp directory */
+    cleanup() {
+        try {
+            Fs.rmSync(this.dtsDir, { recursive: true, force: true });
+        }
+        catch { }
     }
 }
 export function createTypescriptProject(baseDir, tsconfig, outDir) {
     return new TypescriptProject(baseDir, tsconfig, outDir);
 }
 export function generateTypescriptDefinition(options) {
-    const project = options.project;
-    const diagnostics = [];
+    const { project, prefix } = options;
     const baseDir = project.baseDir;
-    const outDir = project.compilerOptions.outDir;
-    const excludesMap = {};
-    options.exclude = options.exclude || ['node_modules/**/*'];
-    options.exclude.forEach(function (filename) {
-        Glob.sync(filename, { cwd: baseDir }).forEach(function (globFileName) {
-            excludesMap[normalizeFileName(Path.resolve(baseDir, globFileName))] = true;
-        });
-    });
-    // Compute baseUrl prefix to strip from module paths
     const normalizedBaseDir = normalizeFileName(Path.resolve(baseDir)) + "/";
-    let baseUrlPrefix = '';
-    if (project.compilerOptions.baseUrl) {
-        const absoluteBaseUrl = Path.resolve(baseDir, project.compilerOptions.baseUrl);
-        const normalizedBaseUrl = normalizeFileName(absoluteBaseUrl);
-        baseUrlPrefix = normalizedBaseUrl.slice(normalizedBaseDir.length);
-        if (baseUrlPrefix && !baseUrlPrefix.endsWith('/')) {
-            baseUrlPrefix += '/';
-        }
-    }
-    function stripBaseUrlPrefix(modulePath) {
-        if (baseUrlPrefix && modulePath.startsWith(baseUrlPrefix)) {
-            return modulePath.slice(baseUrlPrefix.length);
-        }
-        return modulePath;
-    }
-    let outputContent = '';
+    const normalizedDtsDir = normalizeFileName(Path.resolve(project.dtsDir)) + "/";
+    const resolveCache = new Map();
+    const outputParts = [];
     if (options.externs) {
         options.externs.forEach(function (path) {
-            outputContent += `/// <reference path="${path}" />` + eol;
+            outputParts.push(`/// <reference path="${path}" />` + eol);
         });
     }
     if (options.types) {
         options.types.forEach(function (type) {
-            outputContent += `/// <reference types="${type}" />` + eol;
+            outputParts.push(`/// <reference types="${type}" />` + eol);
         });
     }
-    // Filter source files
-    const sourcesMap = {};
-    const internalsMap = {};
-    project.getSourceFiles().some(function (sourceFile) {
-        const { fileName } = sourceFile;
-        if (fileName.indexOf(normalizedBaseDir) !== 0)
-            return;
-        if (excludesMap[fileName])
-            return;
-        const shortName = fileName.slice(normalizedBaseDir.length);
-        const shortNameNoExt = shortName.slice(0, -Path.extname(fileName).length);
-        const strippedShortName = stripBaseUrlPrefix(shortName);
-        const strippedShortNameNoExt = stripBaseUrlPrefix(shortNameNoExt);
-        const moduleId = `${options.prefix}/${strippedShortNameNoExt}`;
-        internalsMap[shortName] = moduleId;
-        internalsMap[shortNameNoExt] = moduleId;
-        internalsMap[strippedShortName] = moduleId;
-        internalsMap[strippedShortNameNoExt] = moduleId;
-        sourcesMap[fileName] = true;
-    });
-    // Build reverse map from internal paths to export names
-    // e.g., "src/Inputs" -> "./Inputs" means internal path "src/Inputs" exports as "prefix/Inputs"
-    // Store as [internalPrefix, exportName] pairs for prefix matching
+    // Process each emitted .d.ts file as internal: module
+    const dtsFiles = project.getEmittedDtsFiles();
+    for (const dtsPath of dtsFiles) {
+        const normalizedDts = normalizeFileName(Path.resolve(dtsPath));
+        if (!normalizedDts.startsWith(normalizedDtsDir))
+            continue;
+        const relativeDts = normalizedDts.slice(normalizedDtsDir.length);
+        const relativeSource = relativeDts.replace(/\.d\.ts$/, '');
+        const data = Fs.readFileSync(dtsPath, 'utf-8');
+        const declFile = Ts.createSourceFile(dtsPath, data, Ts.ScriptTarget.Latest, true);
+        writeDeclaration(declFile, relativeSource);
+    }
+    // Emit public re-export modules
     if (options.exports) {
         for (const entry of Object.values(options.exports)) {
-            const fileName = entry.source;
-            if (fileName.indexOf(normalizedBaseDir) !== 0)
-                continue;
-            if (excludesMap[fileName])
-                continue;
-            const shortName = fileName.slice(normalizedBaseDir.length);
-            const shortNameNoExt = shortName.slice(0, -Path.extname(fileName).length);
-            const strippedShortName = stripBaseUrlPrefix(shortName);
-            const strippedShortNameNoExt = stripBaseUrlPrefix(shortNameNoExt);
-            const moduleId = entry.id;
-            internalsMap[shortName] = moduleId;
-            internalsMap[shortNameNoExt] = moduleId;
-            internalsMap[strippedShortName] = moduleId;
-            internalsMap[strippedShortNameNoExt] = moduleId;
-            sourcesMap[fileName] = true;
+            const internalId = resolveInternalModuleImport(entry.source);
+            if (internalId) {
+                outputParts.push(`declare module '${entry.id}' {${eol}`);
+                outputParts.push(`${indent}export * from '${internalId}';${eol}`);
+                outputParts.push(`}${eol}${eol}`);
+            }
         }
     }
-    // Unified module ID normalization: strip extensions, baseUrl prefix, and remap to exports
-    function normalizeModuleId(moduleId) {
-        // Strip .ts, .tsx, .js, .jsx, .d.ts extensions
-        moduleId = moduleId.replace(/\.(d\.ts|ts|tsx|js|jsx)$/, '');
-        // Strip baseUrl prefix
-        moduleId = stripBaseUrlPrefix(moduleId);
-        // Apply resolved prefix
-        const remapped = internalsMap[moduleId] ||
-            internalsMap[moduleId + "/index"] ||
-            internalsMap[moduleId + "/index.ts"];
-        return remapped || moduleId;
-    }
-    // Generate source files
-    project.getSourceFiles().some(function (sourceFile) {
-        if (!sourcesMap[sourceFile.fileName])
-            return;
-        // Source file is already a declaration file so should does not need to be pre-processed by the emitter
-        if (isDtsFilename(sourceFile.fileName)) {
-            writeDeclaration(sourceFile, sourceFile.fileName);
-            return;
-        }
-        const emitOutput = project.emit(sourceFile, (filename, data) => writeFile(filename, data, sourceFile.fileName));
-        if (emitOutput.emitSkipped || emitOutput.diagnostics.length > 0) {
-            diagnostics.push(...emitOutput.diagnostics);
-            diagnostics.push(...project.getSemanticDiagnostics(sourceFile));
-            diagnostics.push(...project.getSyntacticDiagnostics(sourceFile));
-            diagnostics.push(...project.getDeclarationDiagnostics(sourceFile));
+    function resolveInternalModuleImport(moduleId, importDir = "") {
+        if (moduleId.charAt(0) === '.') {
+            return prefix + normalizeFileName(Path.join(importDir, moduleId));
         }
-    });
-    function isExternalModule(moduleId) {
-        if (!internalsMap[moduleId]) {
-            return true;
+        if (resolveCache.has(moduleId))
+            return resolveCache.get(moduleId);
+        const containingFile = Path.resolve(baseDir, importDir, '__resolve.ts');
+        const result = Ts.resolveModuleName(moduleId, containingFile, project.compilerOptions, Ts.sys);
+        if (result.resolvedModule && !result.resolvedModule.isExternalLibraryImport) {
+            const resolved = normalizeFileName(result.resolvedModule.resolvedFileName);
+            if (resolved.startsWith(normalizedBaseDir)) {
+                const value = prefix + resolved.slice(normalizedBaseDir.length).replace(/\.(d\.ts|tsx?|jsx?)$/, '');
+                resolveCache.set(moduleId, value);
+                return value;
+            }
         }
-        return false;
-    }
-    function writeFile(filename, data, sourceFilePath) {
-        if (isDtsFilename(filename)) {
-            const declFile = Ts.createSourceFile(filename, data, project.compilerOptions.target, true);
-            writeDeclaration(declFile, sourceFilePath);
+        // Check if moduleId is already an internal path relative to baseDir
+        const absolute = normalizeFileName(Path.resolve(baseDir, importDir, moduleId));
+        if (absolute.startsWith(normalizedBaseDir)) {
+            const value = prefix + absolute.slice(normalizedBaseDir.length);
+            resolveCache.set(moduleId, value);
+            return value;
         }
+        resolveCache.set(moduleId, null);
+        return null;
     }
-    function writeDeclaration(declarationFile, sourceFilePath) {
-        // Compute rawSourceModuleId based on the source file path that produced the declaration
-        const resolvedSourcePath = Path.resolve(sourceFilePath);
-        const sourceExt = Path.extname(resolvedSourcePath);
-        const rawSourceModuleId = normalizeFileName(resolvedSourcePath.slice(baseDir.length + 1, -sourceExt.length));
-        // Normalize and remap the module ID
-        const moduleDeclId = normalizeModuleId(rawSourceModuleId);
-        outputContent += `declare module '${moduleDeclId}' {${eol}${indent}`;
-        function resolveModuleImport(moduleId) {
-            // Resolve module id
-            let resolved;
-            if (moduleId.charAt(0) === '.') {
-                resolved = normalizeFileName(Path.join(Path.dirname(rawSourceModuleId), moduleId));
-            }
-            else {
-                // Try to resolve using TypeScript's module resolution (handles tsconfig paths)
-                const resolveResult = Ts.resolveModuleName(moduleId, declarationFile.fileName, project.compilerOptions, project.host);
-                if (resolveResult.resolvedModule) {
-                    const resolvedFileName = normalizeFileName(resolveResult.resolvedModule.resolvedFileName);
-                    if (excludesMap[resolvedFileName])
-                        return moduleId;
-                    // Check if resolved file is within our project (internal module)
-                    if (resolvedFileName.startsWith(normalizedBaseDir)) {
-                        // Convert absolute path to relative module id
-                        resolved = resolvedFileName.slice(normalizedBaseDir.length);
-                    }
-                    else {
-                        // External module - return as-is
-                        return moduleId;
-                    }
-                }
-                else {
-                    resolved = moduleId;
-                    if (isExternalModule(resolved))
-                        return resolved;
-                }
-            }
-            // Normalize: strip extensions, baseUrl prefix, and remap to exports
-            return normalizeModuleId(resolved);
-        }
+    function writeDeclaration(declarationFile, rawSourceModuleId) {
+        const moduleDeclId = resolveInternalModuleImport(rawSourceModuleId);
+        const moduleDir = Path.dirname(rawSourceModuleId);
+        outputParts.push(`declare module '${moduleDeclId}' {${eol}${indent}`);
         const content = processTree(declarationFile, function (node) {
             if (isNodeKindExternalModuleReference(node)) {
                 const expression = node.expression;
-                const resolved = resolveModuleImport(expression.text);
+                const resolved = resolveInternalModuleImport(expression.text, moduleDir) ?? expression.text;
                 return ` require('${resolved}')`;
             }
             else if (isNodeKindImportDeclaration(node) && !node.importClause) {
@@ -313,8 +225,8 @@ export function generateTypescriptDefinition(options) {
             }
             else if (isNodeKindStringLiteral(node) && node.parent &&
                 (isNodeKindExportDeclaration(node.parent) || isNodeKindImportDeclaration(node.parent) || isNodeKindImportType(node.parent?.parent))) {
-                const resolved = resolveModuleImport(node.text);
-                if (resolved) {
+                const resolved = resolveInternalModuleImport(node.text, moduleDir);
+                if (resolved != null) {
                     return ` '${resolved}'`;
                 }
             }
@@ -322,38 +234,13 @@ export function generateTypescriptDefinition(options) {
         const chunks = content.replaceAll("\r", "").split("\n").map(c => c.trimEnd());
         while (chunks.length > 0 && chunks[chunks.length - 1] === "")
             chunks.pop();
-        outputContent += chunks.join(eol + indent) + eol;
-        outputContent += '}' + eol + eol;
+        outputParts.push(chunks.join(eol + indent) + eol);
+        outputParts.push('}' + eol + eol);
     }
     return {
-        dts: outputContent,
-        diagnostics,
+        dts: outputParts.join(''),
     };
 }
-export function logDiagnostics(log, diagnostics) {
-    if (diagnostics && diagnostics.length > 0) {
-        for (const diagnostic of diagnostics) {
-            const text = typeof diagnostic.messageText === 'string'
-                ? diagnostic.messageText
-                : diagnostic.messageText.messageText;
-            const message = {
-                id: `TS${diagnostic.code}`,
-                text,
-                detail: diagnostic,
-            };
-            if (diagnostic.file && diagnostic.start !== undefined) {
-                const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-                message.location = {
-                    file: diagnostic.file.fileName,
-                    line: line + 1,
-                    column: character,
-                    length: diagnostic.length ?? 0,
-                };
-            }
-            log.put('error', message);
-        }
-    }
-}
 export class TypescriptDefinitionTask extends BuildTask {
     library;
     constructor(target, library) {
@@ -367,14 +254,15 @@ export class TypescriptDefinitionTask extends BuildTask {
             const configText = file.read.text(Path.join(lib.path, "./tsconfig.json"))
                 || file.read.text("./tsconfig.json");
             const project = createTypescriptProject(lib.path, configText, storage.getBaseDirFS());
-            const { dts, diagnostics } = generateTypescriptDefinition({
+            await project.emitWithTsgo();
+            const { dts } = generateTypescriptDefinition({
                 project,
-                prefix: lib.name,
+                prefix: lib.name + ":",
                 exclude: ["node_modules/**/*"],
                 exports: create_export_map(lib, lib.bundle),
             });
             file.write.text(storage.getBaseDirFS() + "/types.d.ts", dts);
-            logDiagnostics(this.log, diagnostics);
+            project.cleanup();
         }
         catch (e) {
             this.log.error("no 'type.d.ts' will be generated for the package:" + e.message);

package/esm/model/helpers/discover-workspace.js

@@ -7,6 +7,7 @@ import { create_bundle_manifest } from "./create-manifests.js";
 import { Bundle, Library, Workspace } from "../workspace.js";
 import { file, make_canonical_path, make_normalized_dirname, make_normalized_path, make_relative_path } from "../../utils/file.js";
 import { findConfigFile, is_config_filename, readConfigFile, readSingletonConfigFile } from "./config-loader.js";
+import { read_lockfile } from "./lockfile.js";
 const exclude_dirs = ["node_modules", ".git"];
 function is_ignored_dir(ws, path) {
     const normalized_path = make_normalized_path(path);
@@ -252,7 +253,7 @@ function show_constants(ws) {
     }
 }
 export async function discover_workspace(ws) {
-    let package_lock = null;
+    let lockfile = null;
     for (let path = ws.path;;) {
         const package_json = await readJsonFile(path + "/package.json");
         if (package_json) {
@@ -267,30 +268,20 @@ export async function discover_workspace(ws) {
                 };
             }
         }
-        const package_lock_path = path + "/package-lock.json";
-        if (!package_lock && Fs.existsSync(package_lock_path)) {
-            package_lock = await readJsonFile(package_lock_path);
+        if (!lockfile) {
+            lockfile = await read_lockfile(path);
         }
         const next_path = make_normalized_dirname(path);
         if (next_path === path)
             break;
         path = next_path;
     }
-    if (!package_lock) {
-        throw new Error(`Package lock not found for '${ws.name}'`);
-    }
-    for (const location in package_lock.packages) {
-        let pkg = package_lock.packages[location];
-        if (location.startsWith("node_modules/")) {
-            if (pkg.link) {
-                pkg = package_lock.packages[pkg.resolved];
-            }
-            const name = location.replace(/^.*node_modules\//, "");
-            ws.resolved_versions[name] = pkg.version;
-        }
+    if (!lockfile) {
+        throw new Error(`Lock file not found for '${ws.name}'`);
     }
+    ws.resolved_versions = lockfile.resolved_versions;
     await discover_workspace_libraries(ws);
-    for (const location in package_lock.packages) {
+    for (const location of lockfile.installed_locations) {
         await discover_library(ws, location, true);
     }
     for (const bun of ws.bundles) {

package/esm/model/helpers/lockfile.js

@@ -0,0 +1,108 @@
+import Fs from "node:fs";
+import Fsp from "node:fs/promises";
+import YAML from "yaml";
+import { readJsonFile } from "../storage.js";
+export async function read_lockfile(dir) {
+    const npm_path = dir + "/package-lock.json";
+    if (Fs.existsSync(npm_path)) {
+        return parse_npm_lockfile(await readJsonFile(npm_path));
+    }
+    const pnpm_path = dir + "/pnpm-lock.yaml";
+    if (Fs.existsSync(pnpm_path)) {
+        return parse_pnpm_lockfile(YAML.parse(await Fsp.readFile(pnpm_path, "utf-8")));
+    }
+    const yarn_path = dir + "/yarn.lock";
+    if (Fs.existsSync(yarn_path)) {
+        return parse_yarn_lockfile(await Fsp.readFile(yarn_path, "utf-8"));
+    }
+    return null;
+}
+function parse_npm_lockfile(lock) {
+    const resolved_versions = {};
+    const installed_locations = [];
+    for (const location in lock.packages) {
+        if (!location)
+            continue;
+        installed_locations.push(location);
+        if (location.startsWith("node_modules/")) {
+            let pkg = lock.packages[location];
+            if (pkg.link) {
+                pkg = lock.packages[pkg.resolved];
+            }
+            const name = location.replace(/^.*node_modules\//, "");
+            if (pkg?.version) {
+                resolved_versions[name] = pkg.version;
+            }
+        }
+    }
+    return { resolved_versions, installed_locations };
+}
+function parse_pnpm_lockfile(lock) {
+    const resolved_versions = {};
+    const locations = new Set();
+    if (lock.packages) {
+        for (const key in lock.packages) {
+            const clean = key.startsWith("/") ? key.slice(1) : key;
+            const atIdx = clean.lastIndexOf("@");
+            if (atIdx > 0) {
+                const name = clean.slice(0, atIdx);
+                const version = clean.slice(atIdx + 1).split("(")[0];
+                if (name && version) {
+                    resolved_versions[name] = version;
+                    locations.add("node_modules/" + name);
+                }
+            }
+        }
+    }
+    if (lock.importers) {
+        for (const key in lock.importers) {
+            if (key !== ".")
+                locations.add(key);
+        }
+    }
+    return { resolved_versions, installed_locations: [...locations] };
+}
+function parse_yarn_lockfile(text) {
+    const resolved_versions = {};
+    const locations = new Set();
+    if (text.includes("__metadata:")) {
+        const lock = YAML.parse(text);
+        for (const key in lock) {
+            if (key === "__metadata")
+                continue;
+            if (lock[key]?.version) {
+                const name = extract_package_name(key.split(",")[0].trim());
+                if (name) {
+                    resolved_versions[name] = lock[key].version;
+                    locations.add("node_modules/" + name);
+                }
+            }
+        }
+    }
+    else {
+        parse_yarn_classic(text, resolved_versions, locations);
+    }
+    return { resolved_versions, installed_locations: [...locations] };
+}
+function extract_package_name(entry) {
+    entry = entry.replace(/^"|"$/g, "");
+    // @scope/name@version or name@version
+    const at = entry.startsWith("@") ? entry.indexOf("@", 1) : entry.indexOf("@");
+    return at > 0 ? entry.slice(0, at) : null;
+}
+function parse_yarn_classic(text, resolved_versions, locations) {
+    let current_name = null;
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (!line.startsWith(" ") && !line.startsWith("#") && trimmed.endsWith(":")) {
+            current_name = extract_package_name(trimmed.slice(0, -1).split(",")[0].trim());
+        }
+        else if (current_name && trimmed.startsWith("version ")) {
+            const version = trimmed.slice(8).replace(/^"|"$/g, "");
+            resolved_versions[current_name] = version;
+            locations.add("node_modules/" + current_name);
+            current_name = null;
+        }
+    }
+}
+//# sourceMappingURL=lockfile.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@jointhedots/gear",
-   "version": "1.1.13",
+   "version": "1.1.15",
    "type": "module",
    "bin": {
       "jointhedots-gear": "esm/cli.js"
@@ -33,19 +33,17 @@
       "@aws-sdk/client-s3": "^3.968.0",
       "@jspm/core": "^2.1.0",
       "@tailwindcss/postcss": "~4.1.3",
-      "@types/semver": "~7.7.1",
+      "@typescript/native-preview": "^7.0.0-dev.20260310.1",
       "dotenv": "~17.2.3",
       "esbuild": "~0.27.2",
       "esbuild-sass-plugin": "~3.6.0",
       "express": "~5.2.1",
-      "glob": "~13.0.0",
       "mime": "~4.1.0",
       "node-watch": "~0.7.4",
       "postcss": "~8.5.6",
       "sass": "~1.97.2",
       "semver": "~7.7.3",
       "sharp": "~0.34.5",
-      "source-map-support": "~0.5.21",
       "toml": "^3.0.0",
       "typescript": "~5.9.3",
       "yaml": "^2.8.2",
@@ -55,6 +53,7 @@
       "@polycuber/script.cli": "~1.0.5",
       "@types/chrome": "~0.1.33",
       "@types/node": "~22.7.4",
+      "@types/semver": "~7.7.1",
       "@types/web-app-manifest": "~1.0.9",
       "@types/yargs": "~17.0.35"
    },