@jointhedots/gear 1.1.18 → 1.2.2

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

@@ -9,7 +9,7 @@ import { file, make_canonical_path, make_normalized_dirname, make_normalized_pat
 import { findConfigFile, is_config_filename, readConfigFile, readSingletonConfigFile } from "./config-loader.js";
 import { read_lockfile } from "./lockfile.js";
 import { LoadLibraryPackager } from "../packager.js";
-import { BundledLibraryPackager, DefaultLibraryPackager } from "../packagers/packager-standard.js";
+import { DefaultLibraryPackager } from "../packagers/packager-standard.js";
 const exclude_dirs = ["node_modules", ".git"];
 function is_ignored_dir(ws, path) {
     const normalized_path = make_normalized_path(path);
@@ -20,26 +20,8 @@ function is_ignored_dir(ws, path) {
     }
     return false;
 }
-export function setup_library_bundle(lib) {
-    const ws = lib.workspace;
-    const manif = make_library_bundle_manifest(lib);
-    let bun = ws.get_bundle(manif.$id);
-    if (!bun) {
-        bun = new Bundle(manif, lib.path, ws, lib);
-        lib.bundle = bun;
-        ws.bundles.push(bun);
-        lib.log.info(`+ 📦 bundle: ${bun.id}`);
-        return bun;
-    }
-    else {
-        throw new Error(`Library '${lib.get_id()}' is associate to a bundle '${bun.id}' that is already associated`);
-    }
-}
 export async function discover_component(lib, fpath) {
-    let bundle = lib.bundle;
-    if (!bundle) {
-        bundle = setup_library_bundle(lib);
-    }
+    const { bundle } = lib;
     if (bundle.components.has(fpath)) {
         return true;
     }
@@ -92,7 +74,7 @@ async function discover_application(lib, fpath) {
         lib.log.error(`invalid application at ${fpath}: ${e?.message}`);
     }
 }
-export async function discover_library_components(lib, path, subdir = false) {
+export async function discover_library_definitions(lib, path, subdir = false) {
     // List names from directory
     const fnames = await Fsp.readdir(path);
     if (subdir && fnames.includes("package.json")) {
@@ -104,8 +86,8 @@ export async function discover_library_components(lib, path, subdir = false) {
         const fstat = await Fsp.stat(fpath);
         if (fstat.isDirectory()) {
             if (!exclude_dirs.includes(fname)) {
-                if (await discover_library(lib.workspace, fpath, lib.installed) === Discovered.None) {
-                    await discover_library_components(lib, fpath, true);
+                if (await discover_bundle(lib, fpath) === Discovered.None) {
+                    await discover_library_definitions(lib, fpath, true);
                 }
             }
         }
@@ -125,133 +107,57 @@ export async function discover_library_components(lib, path, subdir = false) {
         }
     }
 }
-export function collect_declarations_field(lib, key, value) {
-    for (const decl of lib.declarations.values()) {
-        if (typeof decl[key] === typeof value) {
-            if (Array.isArray(value))
-                value.push(...decl[key]);
-            else if (typeof value === "object")
-                Object.assign(value, decl[key]);
-            else
-                value = decl[key];
-        }
-    }
-    return value;
-}
-function make_library_bundle_manifest(lib) {
-    return {
-        $id: makeNormalizedName(collect_declarations_field(lib, "$id", lib.name), NameStyle.OBJECT),
-        type: "bundle",
-        name: lib.name,
-        icon: collect_declarations_field(lib, "icon", ""),
-        title: collect_declarations_field(lib, "title", lib.name),
-        tags: collect_declarations_field(lib, "tags", lib.descriptor?.tags),
-        keywords: collect_declarations_field(lib, "keywords", lib.descriptor?.keywords),
-        description: collect_declarations_field(lib, "description", lib.descriptor?.description),
-        selectors: collect_declarations_field(lib, "selectors", undefined),
-        data: {
-            package: lib.get_id(),
-            alias: collect_declarations_field(lib, "alias", lib.name),
-            namespaces: collect_declarations_field(lib, "namespaces", []),
-            dependencies: collect_declarations_field(lib, "dependencies", []),
-            distribueds: collect_declarations_field(lib, "distribueds", {}),
-        }
-    };
-}
 var Discovered;
 (function (Discovered) {
     Discovered[Discovered["None"] = 0] = "None";
     Discovered[Discovered["Ignored"] = 1] = "Ignored";
     Discovered[Discovered["Registered"] = 2] = "Registered";
 })(Discovered || (Discovered = {}));
-async function discover_library(ws, location, installed) {
+async function discover_library(ws, location) {
     const lib_path = make_canonical_path(ws.path, location);
     if (is_ignored_dir(ws, lib_path))
         return Discovered.Ignored;
+    const has_bundle_manifest = file.exists(findConfigFile(lib_path, "bundle.manifest"));
+    if (has_bundle_manifest) {
+        // discover_bundle
+        return Discovered.Ignored;
+    }
     const package_path = lib_path + "/package.json";
     const has_package_manifest = file.exists(package_path);
-    const has_bundle_manifest = file.exists(findConfigFile(lib_path, "bundle.manifest"));
-    if (!has_package_manifest && !has_bundle_manifest)
+    if (!has_package_manifest)
         return Discovered.None;
-    const lib_not_exists = ws.libraries.reduce((r, lib) => r && lib.path !== lib_path, true);
-    if (!lib_not_exists)
-        return Discovered.Ignored;
-    const lib_desc = await readJsonFile(package_path);
-    if (!lib_desc?.name)
+    const lib_manifest = await readJsonFile(package_path);
+    if (!lib_manifest?.name)
         return Discovered.Ignored;
-    if (has_bundle_manifest || !installed) {
-        const other = ws.get_library(lib_desc.name);
-        if (other) {
-            if (lib_path.includes(other.path)) {
-                ws.log.info(`ignore library build at ${lib_path}`);
-                return Discovered.Ignored;
-            }
-            else {
-                throw new Error(`library '${lib_desc.name}' declared multiple times\n - ${other.path}\n - ${lib_path}`);
-            }
-        }
-        const lib = new Library(lib_desc.name, lib_path, lib_desc, ws, installed);
-        ws.libraries.push(lib);
-        ws.log.info(`+ 📚 library: ${installed ? "⏬" : "🐣"} ${lib.get_id()} (${make_relative_path(ws.path, location)})`);
-        // Setup node search directory
-        const lib_search_path = lib_path + "/node_modules";
-        if (Fs.existsSync(lib_search_path)) {
-            lib.search_directories.push(lib_search_path);
-        }
-        // Load library packager
-        let packager = null;
-        if (has_bundle_manifest) {
-            packager = new BundledLibraryPackager();
+    if (!lib_manifest?.dots)
+        return Discovered.None;
+    const other = ws.get_library(lib_manifest.name);
+    if (other) {
+        if (lib_path.includes(other.path)) {
+            ws.log.info(`ignore library build at ${lib_path}`);
+            return Discovered.Ignored;
         }
         else {
-            const declaration_config = await readSingletonConfigFile(lib_path, "declaration");
-            const packager_ref = declaration_config && declaration_config.data?.packager;
-            if (packager_ref) {
-                packager = await LoadLibraryPackager(packager_ref);
-            }
-            else {
-                packager = new DefaultLibraryPackager();
-            }
+            throw new Error(`library '${lib_manifest.name}' declared multiple times\n - ${other.path}\n - ${lib_path}`);
         }
-        // Discover library with packager
-        await packager.discover_library(lib);
-        return Discovered.Registered;
     }
-    return Discovered.None;
-}
-async function discover_workspace_libraries(ws) {
-    async function walk(dir) {
-        if (await discover_library(ws, dir, false) === Discovered.None) {
-            for (const entry of Fs.readdirSync(dir, { withFileTypes: true })) {
-                if (entry.name === "node_modules")
-                    continue;
-                const fullPath = dir + "/" + entry.name;
-                if (entry.isDirectory()) {
-                    await walk(fullPath);
-                }
-            }
-        }
-    }
-    await walk(ws.path);
-}
-function show_constants(ws) {
-    for (const name in ws.constants) {
-        ws.log.info(`+ 🔖 ${name} = ${ws.constants[name]}`);
-    }
-}
-export async function discover_workspace(ws) {
+    const lib = new Library(lib_manifest.name, lib_path, lib_manifest, ws);
+    ws.libraries.push(lib);
+    ws.log.info(`+ 📚 library: ${lib.get_id()} (${make_relative_path(ws.path, location)})`);
+    // Discover library-level search_directories, lockfile, and constants (walk up to workspace root)
     let lockfile = null;
-    for (let path = ws.path;;) {
+    lib.constants = { ...ws.constants };
+    for (let path = lib.path;;) {
         const package_json = await readJsonFile(path + "/package.json");
         if (package_json) {
             const search_path = path + "/node_modules";
             if (Fs.existsSync(search_path)) {
-                ws.search_directories.push(search_path);
+                lib.search_directories.push(search_path);
             }
             if (package_json.constants) {
-                ws.constants = {
+                lib.constants = {
                     ...package_json.constants,
-                    ...ws.constants,
+                    ...lib.constants,
                 };
             }
         }
@@ -263,20 +169,110 @@ export async function discover_workspace(ws) {
             break;
         path = next_path;
     }
-    if (!lockfile) {
+    // Analyze lock file
+    if (lockfile) {
+        lib.resolved_versions = lockfile.resolved_versions;
+        for (const dep_id in lockfile.resolved_versions) {
+            const dep_path = lib.resolved_versions[dep_id];
+            await discover_bundle(lib, dep_path);
+        }
+    }
+    else {
         throw new Error(`Lock file not found for '${ws.name}'`);
     }
-    ws.resolved_versions = lockfile.resolved_versions;
-    await discover_workspace_libraries(ws);
-    for (const location of lockfile.installed_locations) {
-        await discover_library(ws, location, true);
+    // Load library packager
+    let packager = null;
+    const declaration_config = await readSingletonConfigFile(lib_path, "declaration");
+    const packager_ref = declaration_config && declaration_config.data?.packager;
+    if (packager_ref) {
+        packager = await LoadLibraryPackager(packager_ref);
+    }
+    else {
+        packager = new DefaultLibraryPackager();
+    }
+    // Discover library with packager
+    await packager.discover_library(lib);
+    return Discovered.Registered;
+}
+async function discover_bundle(lib, location) {
+    const bun_path = make_canonical_path(lib.path, location);
+    if (is_ignored_dir(lib.workspace, bun_path))
+        return Discovered.Ignored;
+    const bun_manif_path = findConfigFile(bun_path, "bundle.manifest");
+    if (!bun_manif_path)
+        return Discovered.None;
+    const bun_manif = await readConfigFile(bun_manif_path);
+    if (!bun_manif) {
+        lib.log.error(`bundle manifest invalid at: ${bun_manif_path}`);
+        return Discovered.Ignored;
+    }
+    const other = lib.get_bundle(bun_manif.$id);
+    if (other) {
+        if (bun_path.includes(other.path)) {
+            lib.log.info(`ignore bundle at ${bun_path}`);
+            return Discovered.Ignored;
+        }
+        else {
+            lib.log.error(`bundle '${bun_manif.$id}' declared multiple times\n - ${other.path}\n - ${bun_path}`);
+            return Discovered.Ignored;
+        }
     }
-    for (const bun of ws.bundles) {
-        if (bun.source) {
-            bun.manifest = create_bundle_manifest(bun.source, bun);
+    const bun = new Bundle(bun_manif, lib.path, lib.workspace);
+    lib.bundle = bun;
+    lib.shelve.push(bun);
+    lib.log.info(`+ 📦 bundle: ${bun.id} ⏬`);
+    // Analyze library deployment manifest (supports json/yaml/yml/toml, singleton)
+    if (bun_manif?.data?.components) {
+        for (const pub of bun_manif.data.components) {
+            const fpath = lib.path + "/" + (pub.ref ?? pub.id);
+            await discover_component(lib, fpath);
         }
     }
+    return Discovered.Registered;
+}
+function show_constants(ws) {
+    // Collect all constant keys across libraries
+    const all_keys = new Set();
+    for (const lib of ws.libraries) {
+        for (const key in lib.constants)
+            all_keys.add(key);
+    }
+    for (const name of all_keys) {
+        const lib_values = new Map();
+        for (const lib of ws.libraries) {
+            if (name in lib.constants) {
+                const val = lib.constants[name];
+                const key = String(val);
+                if (!lib_values.has(val))
+                    lib_values.set(val, []);
+                lib_values.get(val).push(lib.name);
+            }
+        }
+        if (lib_values.size === 1) {
+            const [value] = lib_values.keys();
+            ws.log.info(`+ 🔖 ${name} = ${value}`);
+        }
+        else {
+            for (const [value, libs] of lib_values) {
+                ws.log.info(`+ 🔖 ${name} = ${value} (${libs.join(", ")})`);
+            }
+        }
+    }
+}
+export async function discover_workspace(ws) {
+    async function walk(dir) {
+        if (await discover_library(ws, dir) === Discovered.None) {
+            for (const entry of Fs.readdirSync(dir, { withFileTypes: true })) {
+                if (entry.name === "node_modules")
+                    continue;
+                const fullPath = dir + "/" + entry.name;
+                if (entry.isDirectory()) {
+                    await walk(fullPath);
+                }
+            }
+        }
+    }
+    await walk(ws.path);
     show_constants(ws);
     return ws;
 }
-//# sourceMappingURL=discover-workspace.js.map

package/esm/workspace/helpers/lockfile.d.ts

@@ -0,0 +1,5 @@
+export type LockFileInfo = {
+    resolved_versions: Record<string, string>;
+    installed_locations: string[];
+};
+export declare function read_lockfile(dir: string): Promise<LockFileInfo | null>;

package/esm/workspace/helpers/lockfile.js

@@ -105,4 +105,3 @@ function parse_yarn_classic(text, resolved_versions, locations) {
         }
     }
 }
-//# sourceMappingURL=lockfile.js.map

package/esm/workspace/helpers/logger.d.ts

@@ -0,0 +1,65 @@
+export interface Message {
+    id: string;
+    text: string;
+    location?: Location | string;
+    notes?: Note[];
+    /**
+     * Optional user-specified data that is passed through unmodified. You can
+     * use this to stash the original error, for example.
+     */
+    detail?: any;
+}
+export interface Note {
+    title?: string;
+    text: string;
+    location?: Location | string;
+}
+export interface Location {
+    file: string;
+    namespace?: string;
+    /** 1-based */
+    line?: number;
+    /** 0-based, in bytes */
+    column?: number;
+    /** in bytes */
+    length?: number;
+    lineText?: string;
+    suggestion?: string;
+}
+export type LogKind = "error" | "warn" | "info" | "success" | "debug" | "trace";
+export type LogMode = "normal" | "debug" | "verbose";
+export interface LogEntry {
+    kind: LogKind;
+    message: Message;
+    timestamp: number;
+}
+export declare class Log {
+    readonly id: string;
+    private entries;
+    private logger;
+    constructor(id: string, logger: Logger);
+    put(kind: LogKind, message: string | Error | Message): void;
+    error(message: string | Error | Message): void;
+    warn(message: string | Error | Message): void;
+    info(message: string | Error | Message): void;
+    success(message: string | Error | Message): void;
+    debug(message: string | Error | Message): void;
+    trace(message: string | Error | Message): void;
+    private normalizeMessage;
+    getEntries(): readonly LogEntry[];
+    clear(): void;
+}
+export declare class Logger {
+    private loggers;
+    readonly mode: LogMode;
+    readonly silentKinds: Set<LogKind>;
+    constructor(mode?: LogMode);
+    get(id: string): Log;
+    has(id: string): boolean;
+    remove(id: string): boolean;
+    all(): IterableIterator<Log>;
+    clear(): void;
+}
+export declare function stringifyLocation(loc: Location | string | null | undefined): string;
+export declare function stringifyLogEntry(loggerId: string, entry: LogEntry): string;
+export declare function stringifyLogEntryPretty(loggerId: string, entry: LogEntry): string;

package/esm/workspace/helpers/logger.js

@@ -145,4 +145,3 @@ export function stringifyLogEntryPretty(loggerId, entry) {
     }
     return lines.join("\n");
 }
-//# sourceMappingURL=logger.js.map

package/esm/workspace/helpers/package-npm.d.ts

@@ -0,0 +1 @@
+export declare function resolvePackageVersion(startDir: string): string | undefined;

package/esm/workspace/helpers/package-npm.js

@@ -18,4 +18,3 @@ export function resolvePackageVersion(startDir) {
     }
     return undefined;
 }
-//# sourceMappingURL=package-npm.js.map

package/esm/workspace/mod.d.ts

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

package/esm/workspace/mod.js

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

package/esm/workspace/packager.d.ts

@@ -0,0 +1,5 @@
+import type { Bundle, Library } from "./workspace.ts";
+export interface LibraryPackager {
+    discover_library(lib: Library): Promise<Bundle>;
+}
+export declare function LoadLibraryPackager(specifier: string): Promise<LibraryPackager>;

package/esm/workspace/packager.js

@@ -6,7 +6,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import ChildProcess from "child_process";
+import ChildProcess from "node:child_process";
 function parseSpecifier(specifier) {
     let raw = specifier.startsWith("npm:") ? specifier.slice(4) : specifier;
     let exportName;
@@ -50,4 +50,3 @@ export async function LoadLibraryPackager(specifier) {
         return resolveExport(mod, exportName);
     }
 }
-//# sourceMappingURL=packager.js.map

package/esm/workspace/packagers/packager-standard.d.ts

@@ -0,0 +1,7 @@
+import { Bundle, Library } from "../workspace.ts";
+import { type LibraryPackager } from "../packager.ts";
+export declare class DefaultLibraryPackager implements LibraryPackager {
+    discover_library(lib: Library): Promise<Bundle>;
+}
+export declare function setup_library_bundle(lib: Library): Bundle;
+export declare function collect_declarations_field(lib: Library, key: string, value: any): any;

package/esm/workspace/packagers/packager-standard.js

@@ -2,38 +2,62 @@ import {} from "../component.js";
 import { Bundle, Library } from "../workspace.js";
 import { readSingletonConfigFile } from "../helpers/config-loader.js";
 import {} from "../packager.js";
-import { discover_component, discover_library_components, setup_library_bundle } from "../helpers/discover-workspace.js";
+import { discover_component, discover_library_definitions } from "../helpers/discover-workspace.js";
+import { makeNormalizedName, NameStyle } from "../../utils/normalized-name.js";
 export class DefaultLibraryPackager {
     async discover_library(lib) {
         // Setup library infos from bundle manifest
         setup_library_bundle(lib);
         // Collect library declaration
-        await discover_library_components(lib, lib.path);
+        await discover_library_definitions(lib, lib.path);
         return lib.bundle;
     }
 }
-export class BundledLibraryPackager {
-    async discover_library(lib) {
-        const { data: manif } = await readSingletonConfigFile(lib.path, "bundle.manifest");
-        const ws = lib.workspace;
-        let bun = ws.get_bundle(manif.$id);
-        if (!bun) {
-            bun = new Bundle(manif, lib.path, lib.workspace, lib);
-            lib.bundle = bun;
-            ws.bundles.push(bun);
-            lib.log.info(`+ 📦 bundle: ${bun.id}`);
-        }
-        else if (bun.source != lib) {
-            lib.log.warn(`Conflict between two prebuild library bundle`);
-        }
-        // Analyze library deployment manifest (supports json/yaml/yml/toml, singleton)
-        if (manif?.data?.components) {
-            for (const pub of manif.data.components) {
-                const fpath = lib.path + "/" + (pub.ref ?? pub.id);
-                await discover_component(lib, fpath);
-            }
-        }
+export function setup_library_bundle(lib) {
+    const ws = lib.workspace;
+    const manif = make_library_bundle_manifest(lib);
+    let bun = lib.get_bundle(manif.$id);
+    if (!bun) {
+        bun = new Bundle(manif, lib.path, ws, lib);
+        lib.bundle = bun;
+        lib.shelve.push(bun);
+        lib.log.info(`+ 📦 bundle: ${bun.id} 🐣`);
         return bun;
     }
+    else {
+        throw new Error(`Library '${lib.get_id()}' is associate to a bundle '${bun.id}' that is already associated`);
+    }
+}
+export function collect_declarations_field(lib, key, value) {
+    for (const decl of lib.declarations.values()) {
+        if (typeof decl[key] === typeof value) {
+            if (Array.isArray(value))
+                value.push(...decl[key]);
+            else if (typeof value === "object")
+                Object.assign(value, decl[key]);
+            else
+                value = decl[key];
+        }
+    }
+    return value;
+}
+function make_library_bundle_manifest(lib) {
+    return {
+        $id: makeNormalizedName(collect_declarations_field(lib, "$id", lib.name), NameStyle.OBJECT),
+        type: "bundle",
+        name: lib.name,
+        icon: collect_declarations_field(lib, "icon", ""),
+        title: collect_declarations_field(lib, "title", lib.name),
+        tags: collect_declarations_field(lib, "tags", lib.descriptor?.tags),
+        keywords: collect_declarations_field(lib, "keywords", lib.descriptor?.keywords),
+        description: collect_declarations_field(lib, "description", lib.descriptor?.description),
+        selectors: collect_declarations_field(lib, "selectors", undefined),
+        data: {
+            package: lib.get_id(),
+            alias: collect_declarations_field(lib, "alias", lib.name),
+            namespaces: collect_declarations_field(lib, "namespaces", []),
+            dependencies: collect_declarations_field(lib, "dependencies", []),
+            distribueds: collect_declarations_field(lib, "distribueds", {}),
+        }
+    };
 }
-//# sourceMappingURL=packager-standard.js.map

package/esm/workspace/storage.d.ts

@@ -0,0 +1,59 @@
+export type StorageChanges = {
+    added: string[];
+    updated: string[];
+    changed: boolean;
+};
+export interface IStorageTransaction {
+    commitContent(contentData: Uint8Array | string, contentType?: string): string;
+    commitFile(key: string, contentData: Uint8Array | string, contentType?: string): any;
+    accept(): Promise<StorageChanges>;
+}
+export interface IStorageZone {
+    clean(): any;
+    edit(scratch?: boolean): IStorageTransaction;
+    branch(path: string): IStorageZone;
+    getBaseDirFS(): string;
+}
+export declare class SourceEventEmitter {
+    clients: any[];
+    sendEventsToAll(type: string, data: any): void;
+    route(): (req: any, res: any) => void;
+}
+export declare function createContentCID(data: Uint8Array | string): string;
+export declare function createContentKey(contentData: Uint8Array | string, contentType?: string): string;
+export type FileCache = Map<string, string>;
+export declare class StorageTransaction implements IStorageTransaction {
+    private baseDir;
+    private scratch;
+    private root;
+    private pending;
+    constructor(baseDir: string, scratch: boolean, root: StorageFiles);
+    commitContent(contentData: Uint8Array | string, contentType?: string): string;
+    commitFile(key: string, contentData: Uint8Array | string, contentType?: string): void;
+    accept(): Promise<StorageChanges>;
+}
+export declare class SubStorageFiles implements IStorageZone {
+    readonly root: StorageFiles;
+    readonly baseDir: string;
+    constructor(root: StorageFiles, baseDir: string);
+    getBaseDirFS(): string;
+    clean(): void;
+    edit(scratch?: boolean): IStorageTransaction;
+    branch(path: string): IStorageZone;
+}
+export declare class StorageFiles implements IStorageZone {
+    name: string;
+    readonly baseDir: string;
+    cache: FileCache;
+    on_changes: SourceEventEmitter;
+    constructor(name: string, baseDir: string);
+    getBaseDirFS(): string;
+    clean(): void;
+    edit(scratch?: boolean): IStorageTransaction;
+    branch(path: string): IStorageZone;
+    route(): (req: any, res: any) => void;
+}
+export declare function copyToStorageStream(storage: IStorageTransaction, key: string, path: string, contentType?: string): void;
+export declare function removeFile(path: string): void;
+export declare function removeDirectory(path: string): void;
+export declare function readJsonFile<T = any>(path: string): Promise<T>;

package/esm/workspace/storage.js

@@ -1,8 +1,8 @@
 import Fsp from "node:fs/promises";
-import Fs from 'node:fs';
-import Crypto from 'node:crypto';
-import Path from 'node:path';
-import MIME from 'mime';
+import Fs from "node:fs";
+import Crypto from "node:crypto";
+import Path from "node:path";
+import MIME from "mime";
 import { directory } from "../utils/file.js";
 export class SourceEventEmitter {
     clients = [];
@@ -54,17 +54,22 @@ export class StorageTransaction {
         const { root, scratch, baseDir } = this;
         await Fsp.mkdir(baseDir, { recursive: true });
         const changes = { added: [], updated: [], changed: false };
-        const writes = [];
-        for (const [fpath, { data, hash }] of this.pending) {
-            const prev = root.cache.get(fpath);
-            if (prev !== hash) {
-                ;
-                (prev ? changes.updated : changes.added).push(Path.basename(fpath));
-                writes.push(Fsp.mkdir(Path.dirname(fpath), { recursive: true }).then(() => Fsp.writeFile(fpath, data)));
-            }
+        const pending_writes = [...this.pending].filter(([fpath, { hash }]) => root.cache.get(fpath) !== hash);
+        const write_channel = async () => {
+            const item = pending_writes.pop();
+            if (!item)
+                return;
+            const [fpath, { data, hash }] = item;
+            const changelist = root.cache.has(fpath) ? changes.updated : changes.added;
+            changelist.push(Path.basename(fpath));
             root.cache.set(fpath, hash);
-        }
-        await Promise.all(writes);
+            await Fsp.mkdir(Path.dirname(fpath), { recursive: true });
+            await Fsp.writeFile(fpath, data);
+            if (pending_writes.length > 0) {
+                return write_channel();
+            }
+        };
+        await Promise.all(Array.from({ length: Math.min(100, pending_writes.length) }, () => write_channel()));
         this.pending.clear();
         if (changes.updated.length > 0 || changes.added.length > 0) {
             root.on_changes.sendEventsToAll("change", changes);
@@ -169,4 +174,3 @@ export async function readJsonFile(path) {
         return undefined;
     }
 }
-//# sourceMappingURL=storage.js.map