@ms-cloudpack/api-server 0.63.10 → 0.64.0

package/lib/types/ZodNotifyLinkChangeInput.d.ts

@@ -1,45 +1,13 @@
-import { z } from 'zod';
-export declare const ZodNotifyLinkChangeInput: z.ZodObject<{
-    packagePath: z.ZodString;
-    hash: z.ZodOptional<z.ZodString>;
-    definition: z.ZodOptional<z.ZodObject<{
-        name: z.ZodString;
-        version: z.ZodString;
-        exports: z.ZodAny;
-        dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUndefined, z.ZodString]>>>;
-        peerDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUndefined, z.ZodString]>>>;
-    }, "strip", z.ZodTypeAny, {
-        name: string;
-        version: string;
-        exports?: any;
-        dependencies?: Record<string, string | undefined> | undefined;
-        peerDependencies?: Record<string, string | undefined> | undefined;
-    }, {
-        name: string;
-        version: string;
-        exports?: any;
-        dependencies?: Record<string, string | undefined> | undefined;
-        peerDependencies?: Record<string, string | undefined> | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    packagePath: string;
-    hash?: string | undefined;
-    definition?: {
-        name: string;
-        version: string;
-        exports?: any;
-        dependencies?: Record<string, string | undefined> | undefined;
-        peerDependencies?: Record<string, string | undefined> | undefined;
-    } | undefined;
-}, {
-    packagePath: string;
-    hash?: string | undefined;
-    definition?: {
-        name: string;
-        version: string;
-        exports?: any;
-        dependencies?: Record<string, string | undefined> | undefined;
-        peerDependencies?: Record<string, string | undefined> | undefined;
-    } | undefined;
-}>;
+import { z } from 'zod/v4-mini';
+export declare const ZodNotifyLinkChangeInput: z.ZodMiniObject<{
+    packagePath: z.ZodMiniString<string>;
+    hash: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    definition: z.ZodMiniOptional<z.ZodMiniObject<{
+        name: z.ZodMiniString<string>;
+        version: z.ZodMiniString<string>;
+        exports: z.ZodMiniOptional<z.ZodMiniAny>;
+        dependencies: z.ZodMiniOptional<z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniUndefined, z.ZodMiniString<string>]>>>>;
+        peerDependencies: z.ZodMiniOptional<z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniUndefined, z.ZodMiniString<string>]>>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 //# sourceMappingURL=ZodNotifyLinkChangeInput.d.ts.map

package/lib/types/ZodNotifyLinkChangeInput.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ZodNotifyLinkChangeInput.d.ts","sourceRoot":"","sources":["../../src/types/ZodNotifyLinkChangeInput.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAInC,CAAC"}
+{"version":3,"file":"ZodNotifyLinkChangeInput.d.ts","sourceRoot":"","sources":["../../src/types/ZodNotifyLinkChangeInput.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,aAAa,CAAC;AAGhC,eAAO,MAAM,wBAAwB;;;;;;;;;;iBAInC,CAAC"}

package/lib/types/ZodNotifyLinkChangeInput.js

@@ -1,8 +1,12 @@
-import { z } from 'zod';
+//
+// This must be in a separate file because it's imported by busSources.ts, which is also used
+// in the browser, so it must only import zod types.
+//
+import { z } from 'zod/v4-mini';
 import { ZodLinkPackageDefinition } from '../types/LinkPath.js';
 export const ZodNotifyLinkChangeInput = z.object({
     packagePath: z.string(),
-    hash: z.string().optional(),
-    definition: ZodLinkPackageDefinition.optional(),
+    hash: z.optional(z.string()),
+    definition: z.optional(ZodLinkPackageDefinition),
 });
 //# sourceMappingURL=ZodNotifyLinkChangeInput.js.map

package/lib/types/ZodNotifyLinkChangeInput.js.map

@@ -1 +1 @@
-{"version":3,"file":"ZodNotifyLinkChangeInput.js","sourceRoot":"","sources":["../../src/types/ZodNotifyLinkChangeInput.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAEhE,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/C,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC3B,UAAU,EAAE,wBAAwB,CAAC,QAAQ,EAAE;CAChD,CAAC,CAAC","sourcesContent":["import { z } from 'zod';\nimport { ZodLinkPackageDefinition } from '../types/LinkPath.js';\n\nexport const ZodNotifyLinkChangeInput = z.object({\n  packagePath: z.string(),\n  hash: z.string().optional(),\n  definition: ZodLinkPackageDefinition.optional(),\n});\n"]}
+{"version":3,"file":"ZodNotifyLinkChangeInput.js","sourceRoot":"","sources":["../../src/types/ZodNotifyLinkChangeInput.ts"],"names":[],"mappings":"AAAA,EAAE;AACF,6FAA6F;AAC7F,oDAAoD;AACpD,EAAE;AACF,OAAO,EAAE,CAAC,EAAE,MAAM,aAAa,CAAC;AAChC,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAEhE,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/C,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC5B,UAAU,EAAE,CAAC,CAAC,QAAQ,CAAC,wBAAwB,CAAC;CACjD,CAAC,CAAC","sourcesContent":["//\n// This must be in a separate file because it's imported by busSources.ts, which is also used\n// in the browser, so it must only import zod types.\n//\nimport { z } from 'zod/v4-mini';\nimport { ZodLinkPackageDefinition } from '../types/LinkPath.js';\n\nexport const ZodNotifyLinkChangeInput = z.object({\n  packagePath: z.string(),\n  hash: z.optional(z.string()),\n  definition: z.optional(ZodLinkPackageDefinition),\n});\n"]}

package/lib/types/ZodResolveMap.d.ts

@@ -1,4 +1,4 @@
-import { type ZodSchema } from 'zod';
+import { z } from 'zod/v4-mini';
 import type { ResolveMap } from '@ms-cloudpack/common-types';
-export declare const ZodResolveMap: ZodSchema<ResolveMap>;
+export declare const ZodResolveMap: z.ZodMiniType<ResolveMap, ResolveMap>;
 //# sourceMappingURL=ZodResolveMap.d.ts.map

package/lib/types/ZodResolveMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ZodResolveMap.d.ts","sourceRoot":"","sources":["../../src/types/ZodResolveMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAK,KAAK,SAAS,EAAE,MAAM,KAAK,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAmB,MAAM,4BAA4B,CAAC;AAgB9E,eAAO,MAAM,aAAa,EAAE,SAAS,CAAC,UAAU,CAA4C,CAAC"}
+{"version":3,"file":"ZodResolveMap.d.ts","sourceRoot":"","sources":["../../src/types/ZodResolveMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,aAAa,CAAC;AAChC,OAAO,KAAK,EAAE,UAAU,EAAmB,MAAM,4BAA4B,CAAC;AAqB9E,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,WAAW,CAAC,UAAU,EAAE,UAAU,CAA4C,CAAC"}

package/lib/types/ZodResolveMap.js

@@ -1,14 +1,14 @@
-import { z } from 'zod';
+import { z } from 'zod/v4-mini';
 import { matchingZodObject } from '../utilities/matchingZodObject.js';
 const ZodResolveMapEntry = z.lazy(() => matchingZodObject({
     name: z.string(),
     version: z.string(),
     path: z.string(),
-    dependencies: z.record(z.string()),
-    requiredBy: z.record(z.string()),
-    isExternal: z.boolean().optional(),
-    isLinked: z.boolean().optional(),
-    scopedVersions: z.record(z.lazy(() => ZodResolveMapEntry)).optional(),
+    dependencies: z.record(z.string(), z.string()),
+    requiredBy: z.record(z.string(), z.string()),
+    isExternal: z.optional(z.boolean()),
+    isLinked: z.optional(z.boolean()),
+    scopedVersions: z.optional(z.record(z.string(), z.lazy(() => ZodResolveMapEntry))),
 }));
 export const ZodResolveMap = z.record(z.string(), ZodResolveMapEntry);
 //# sourceMappingURL=ZodResolveMap.js.map

package/lib/types/ZodResolveMap.js.map

@@ -1 +1 @@
-{"version":3,"file":"ZodResolveMap.js","sourceRoot":"","sources":["../../src/types/ZodResolveMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAkB,MAAM,KAAK,CAAC;AAExC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAEtE,MAAM,kBAAkB,GAA+B,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CACjE,iBAAiB,CAAkB;IACjC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,YAAY,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAClC,UAAU,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAChC,UAAU,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IAClC,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IAChC,cAAc,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,kBAAkB,CAAC,CAAC,CAAC,QAAQ,EAAE;CACtE,CAAC,CACH,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAA0B,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,kBAAkB,CAAC,CAAC","sourcesContent":["import { z, type ZodSchema } from 'zod';\nimport type { ResolveMap, ResolveMapEntry } from '@ms-cloudpack/common-types';\nimport { matchingZodObject } from '../utilities/matchingZodObject.js';\n\nconst ZodResolveMapEntry: ZodSchema<ResolveMapEntry> = z.lazy(() =>\n  matchingZodObject<ResolveMapEntry>({\n    name: z.string(),\n    version: z.string(),\n    path: z.string(),\n    dependencies: z.record(z.string()),\n    requiredBy: z.record(z.string()),\n    isExternal: z.boolean().optional(),\n    isLinked: z.boolean().optional(),\n    scopedVersions: z.record(z.lazy(() => ZodResolveMapEntry)).optional(),\n  }),\n);\n\nexport const ZodResolveMap: ZodSchema<ResolveMap> = z.record(z.string(), ZodResolveMapEntry);\n"]}
+{"version":3,"file":"ZodResolveMap.js","sourceRoot":"","sources":["../../src/types/ZodResolveMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,aAAa,CAAC;AAEhC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAEtE,MAAM,kBAAkB,GAAoD,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CACtF,iBAAiB,CAAkB;IACjC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,YAAY,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;IAC9C,UAAU,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;IAC5C,UAAU,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;IACnC,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;IACjC,cAAc,EAAE,CAAC,CAAC,QAAQ,CACxB,CAAC,CAAC,MAAM,CACN,CAAC,CAAC,MAAM,EAAE,EACV,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,kBAAkB,CAAC,CACjC,CACF;CACF,CAAC,CACH,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAA0C,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,kBAAkB,CAAC,CAAC","sourcesContent":["import { z } from 'zod/v4-mini';\nimport type { ResolveMap, ResolveMapEntry } from '@ms-cloudpack/common-types';\nimport { matchingZodObject } from '../utilities/matchingZodObject.js';\n\nconst ZodResolveMapEntry: z.ZodMiniType<ResolveMapEntry, ResolveMapEntry> = z.lazy(() =>\n  matchingZodObject<ResolveMapEntry>({\n    name: z.string(),\n    version: z.string(),\n    path: z.string(),\n    dependencies: z.record(z.string(), z.string()),\n    requiredBy: z.record(z.string(), z.string()),\n    isExternal: z.optional(z.boolean()),\n    isLinked: z.optional(z.boolean()),\n    scopedVersions: z.optional(\n      z.record(\n        z.string(),\n        z.lazy(() => ZodResolveMapEntry),\n      ),\n    ),\n  }),\n);\n\nexport const ZodResolveMap: z.ZodMiniType<ResolveMap, ResolveMap> = z.record(z.string(), ZodResolveMapEntry);\n"]}

package/lib/utilities/TaskRunner.d.ts

@@ -1,21 +1,39 @@
-import type { Task } from '../types/Task.js';
 import type { DataBus } from '@ms-cloudpack/data-bus';
+import type { Task } from '../types/Task.js';
+import type { TaskStats } from '../types/TaskStats.js';
 /**
  * TaskRunner tracks the status of tasks, manages concurrency, allows reusing task results,
  * and sends notifications about task status to the data bus (currently just used for `start`).
  *
  * NOTE: To enable data bus notifications, you must call `connectToBus()`.
  * `createApiContext` does this with the `taskRunner` passed in.
+ * (`createPartialApiContext` does not create or connect a data bus.)
  */
 export declare class TaskRunner {
     private _bus;
-    private _queue;
-    private _taskStats;
-    private _pendingTasks;
-    private _completedTasks;
-    private _requiresRerun;
-    private _prevTasks;
+    private readonly _queue;
+    /** Stats about task errors/warnings, only updated if a bus is connected */
+    private _taskIssues;
+    /**
+     * Tasks that are currently either running or waiting. (Note that `PQeueue`'s definition of
+     * "pending" is slightly different: it only counts tasks that are currently running.)
+     */
+    private readonly _pendingTasks;
+    /** Tasks that have completed */
+    private readonly _completedTasks;
+    /**
+     * Task IDs where a re-run was requested while the task was running.
+     * We let the current task finish, and then re-run it.
+     */
+    private readonly _requiresRerun;
+    /** All previously-seen tasks (regardless of state) */
+    private readonly _allTasks;
     constructor();
+    /**
+     * Get current task stats. Public for testing.
+     * @internal
+     */
+    get _taskStats(): Readonly<TaskStats>;
     /**
      * Connects the TaskRunner to the data bus. Tasks will still run without this, but they won't
      * send any notifications to a client (which only matters if a client is listening, e.g.
@@ -27,29 +45,43 @@ export declare class TaskRunner {
      *
      * If a task with the same `id` was already added, it returns either the previous result
      * (if completed) or the promise (if pending). Pass `options.rerun` to force re-running.
+     *
+     * (Note that any re-runs will use the *original* task function, not the new one.
+     * If something has changed that requires a new task function, you should incorporate this
+     * into the `id`.)
      */
     add<TReturn>(task: Task<TReturn>, options?: {
         rerun?: boolean;
         priority?: number;
     }): Promise<TReturn>;
     /**
-     * The remove method disposes a task if available
-     * and then removes it from the TaskRunner.
-     *
-     * This is useful when the state of a task needs to be cleared.
+     * Dispose in-memory resources of all tasks and clear the TaskRunner's state.
+     */
+    dispose(): void;
+    /**
+     * Clear the result of a specific task (could involve deleting files from disk) and remove
+     * it from the TaskRunner's task records.
+     */
+    clearResult(id: string): Promise<void>;
+    /**
+     * Clear the results of all tasks (might include deleting files on disk) and clear the
+     * TaskRunner's task records.
      *
-     * It is intended to be used by the api server
-     * to clear the TaskRunner's state before reloading the page.
+     * (To only dispose in-memory resources, use `dispose()`.)
      */
-    remove(id: string): void;
+    clearAllResults(): Promise<void>;
     /**
-     * The clear method disposes all tasks and clears the TaskRunner.
+     * Pauses the TaskRunner (for testing).
+     * @internal
      */
-    clear(): void;
-    /** Pauses the TaskRunner (for testing). */
     _pause(): void;
-    /** Starts or resumes the TaskRunner (for testing). */
+    /**
+     * Starts or resumes the TaskRunner (for testing).
+     * @internal
+     */
     _start(): void;
+    /** Remove any records of previous issues with this task from the totals */
+    private _removeTaskIssues;
     /**
      * Internal method to report the start of a task to the bus.
      */
@@ -58,5 +90,11 @@ export declare class TaskRunner {
      * Internal method to report the end of a task to the bus.
      */
     private _reportEnd;
+    /** Get the task list from the data bus, and find the task's index. */
+    private _findFromTaskList;
+    /**
+     * Publish tasks and/or stats to the data bus.
+     */
+    private _publishUpdates;
 }
 //# sourceMappingURL=TaskRunner.d.ts.map

package/lib/utilities/TaskRunner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TaskRunner.d.ts","sourceRoot":"","sources":["../../src/utilities/TaskRunner.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAK7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAEtD;;;;;;GAMG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,IAAI,CAAsB;IAClC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,UAAU,CAAY;IAC9B,OAAO,CAAC,aAAa,CAAgC;IACrD,OAAO,CAAC,eAAe,CAAuB;IAC9C,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,UAAU,CAA6B;;IAW/C;;;;OAIG;IACI,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAIvC;;;;;OAKG;IACH,GAAG,CAAC,OAAO,EACT,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,EACnB,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GACA,OAAO,CAAC,OAAO,CAAC;IAiEnB;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAgBxB;;OAEG;IACH,KAAK,IAAI,IAAI;IASb,2CAA2C;IAC3C,MAAM,IAAI,IAAI;IAId,sDAAsD;IACtD,MAAM,IAAI,IAAI;IAId;;OAEG;IACH,OAAO,CAAC,YAAY;IAoCpB;;OAEG;IACH,OAAO,CAAC,UAAU;CA8BnB"}
+{"version":3,"file":"TaskRunner.d.ts","sourceRoot":"","sources":["../../src/utilities/TaskRunner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAGtD,OAAO,KAAK,EAAE,IAAI,EAAsB,MAAM,kBAAkB,CAAC;AAGjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AASvD;;;;;;;GAOG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,IAAI,CAAsB;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,2EAA2E;IAC3E,OAAO,CAAC,WAAW,CAAiB;IACpC;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgC;IAC9D,gCAAgC;IAChC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAuB;IACvD;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAc;IAC7C,sDAAsD;IACtD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6B;;IAWvD;;;OAGG;IACH,IAAI,UAAU,IAAI,QAAQ,CAAC,SAAS,CAAC,CAQpC;IAED;;;;OAIG;IACI,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAIvC;;;;;;;;;OASG;IACH,GAAG,CAAC,OAAO,EACT,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,EACnB,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GACA,OAAO,CAAC,OAAO,CAAC;IAyEnB;;OAEG;IAGH,OAAO,IAAI,IAAI;IAYf;;;OAGG;IACG,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAoB5C;;;;;OAKG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IActC;;;OAGG;IACH,MAAM,IAAI,IAAI;IAId;;;OAGG;IACH,MAAM,IAAI,IAAI;IAId,2EAA2E;IAC3E,OAAO,CAAC,iBAAiB;IAOzB;;OAEG;IACH,OAAO,CAAC,YAAY;IAqBpB;;OAEG;IACH,OAAO,CAAC,UAAU;IA0ClB,sEAAsE;IACtE,OAAO,CAAC,iBAAiB;IAMzB;;OAEG;IACH,OAAO,CAAC,eAAe;CAMxB"}

package/lib/utilities/TaskRunner.js

@@ -1,27 +1,52 @@
 import PQueue from 'p-queue';
-import { taskListSource, taskStatsSource } from '../index.browser.js';
+import { taskListSource, taskStatsSource } from '../data/busSources.js';
 /**
  * TaskRunner tracks the status of tasks, manages concurrency, allows reusing task results,
  * and sends notifications about task status to the data bus (currently just used for `start`).
  *
  * NOTE: To enable data bus notifications, you must call `connectToBus()`.
  * `createApiContext` does this with the `taskRunner` passed in.
+ * (`createPartialApiContext` does not create or connect a data bus.)
  */
 export class TaskRunner {
     _bus;
     _queue;
-    _taskStats;
+    /** Stats about task errors/warnings, only updated if a bus is connected */
+    _taskIssues;
+    /**
+     * Tasks that are currently either running or waiting. (Note that `PQeueue`'s definition of
+     * "pending" is slightly different: it only counts tasks that are currently running.)
+     */
     _pendingTasks;
+    /** Tasks that have completed */
     _completedTasks;
+    /**
+     * Task IDs where a re-run was requested while the task was running.
+     * We let the current task finish, and then re-run it.
+     */
     _requiresRerun;
-    _prevTasks;
+    /** All previously-seen tasks (regardless of state) */
+    _allTasks;
     constructor() {
         this._queue = new PQueue({ concurrency: 10 });
-        this._taskStats = getDefaultTaskStats();
+        this._taskIssues = { totalErrors: 0, totalWarnings: 0, taskWarnings: {}, taskErrors: {} };
         this._pendingTasks = new Map();
         this._completedTasks = new Map();
         this._requiresRerun = new Set();
-        this._prevTasks = new Map();
+        this._allTasks = new Map();
+    }
+    /**
+     * Get current task stats. Public for testing.
+     * @internal
+     */
+    get _taskStats() {
+        return {
+            status: this._pendingTasks.size ? 'pending' : 'idle',
+            remainingTasks: this._pendingTasks.size,
+            totalTasks: this._allTasks.size,
+            totalErrors: this._taskIssues.totalErrors,
+            totalWarnings: this._taskIssues.totalWarnings,
+        };
     }
     /**
      * Connects the TaskRunner to the data bus. Tasks will still run without this, but they won't
@@ -36,12 +61,16 @@ export class TaskRunner {
      *
      * If a task with the same `id` was already added, it returns either the previous result
      * (if completed) or the promise (if pending). Pass `options.rerun` to force re-running.
+     *
+     * (Note that any re-runs will use the *original* task function, not the new one.
+     * If something has changed that requires a new task function, you should incorporate this
+     * into the `id`.)
      */
     add(task, options) {
         const { name, id, execute } = task;
         const { rerun, priority } = options || {};
-        if (!this._prevTasks.has(id)) {
-            this._prevTasks.set(id, task);
+        if (!this._allTasks.has(id)) {
+            this._allTasks.set(id, task);
         }
         // Check if we are already completed the task with that id.
         const action = this._completedTasks.get(id);
@@ -58,18 +87,26 @@ export class TaskRunner {
         }
         const resultPromise = (async () => {
             let taskResult;
-            do {
-                // Delete from rerun list (if present).
-                this._requiresRerun.delete(id);
-                taskResult = await this._queue.add(execute, 
-                // Removes void from return type.
-                // Read more on: https://github.com/sindresorhus/p-queue/issues/175
-                { throwOnTimeout: true, priority });
-            } while (this._requiresRerun.has(id));
-            // Delete from pending list.
-            this._pendingTasks.delete(id);
-            if (task.getEndDescription) {
-                this._reportEnd(id, task.getEndDescription(taskResult));
+            let taskError;
+            try {
+                do {
+                    // Delete from rerun list (if present).
+                    this._requiresRerun.delete(id);
+                    taskResult = await this._queue.add(execute, 
+                    // Removes void from return type.
+                    // Read more on: https://github.com/sindresorhus/p-queue/issues/175
+                    { throwOnTimeout: true, priority });
+                } while (this._requiresRerun.has(id));
+            }
+            catch (error) {
+                taskError = error;
+                // Re-throw the error, but `finally` will handle completion
+                throw error;
+            }
+            finally {
+                // Delete from pending list.
+                this._pendingTasks.delete(id);
+                this._reportEnd(task, taskResult, taskError);
             }
             // Extra check to ensure that the task returned a value.
             // It should never throw, if it does we have a bug.
@@ -81,124 +118,165 @@ export class TaskRunner {
             return taskResult;
         })();
         this._pendingTasks.set(id, resultPromise);
-        this._completedTasks.delete(id);
-        if (task.getStartDescription) {
-            this._reportStart(id, task.getStartDescription());
+        const wasCompleted = this._completedTasks.delete(id);
+        if (wasCompleted) {
+            this._removeTaskIssues(task.id);
         }
+        this._reportStart(task);
         return resultPromise;
     }
     /**
-     * The remove method disposes a task if available
-     * and then removes it from the TaskRunner.
-     *
-     * This is useful when the state of a task needs to be cleared.
-     *
-     * It is intended to be used by the api server
-     * to clear the TaskRunner's state before reloading the page.
+     * Dispose in-memory resources of all tasks and clear the TaskRunner's state.
      */
-    remove(id) {
-        this._prevTasks
-            .get(id)
-            ?.dispose?.()
-            .catch(() => {
-            console.debug(`Error disposing task: ${id}`);
-        });
-        this._prevTasks.get(id)?.onDispose?.();
-        this._prevTasks.delete(id);
-        this._requiresRerun.delete(id);
-        if (this._pendingTasks.has(id)) {
-            this._pendingTasks.delete(id);
-            this._taskStats.remainingTasks = this._pendingTasks.size;
+    // NOTE: This is also used by clearAllResults(), so if it's updated to do anything that
+    // renders the TaskRunner unusable/finished, the common parts should be refactored out.
+    dispose() {
+        this._queue.clear();
+        for (const task of this._allTasks.values()) {
+            task.dispose?.();
         }
+        this._allTasks.clear();
+        this._pendingTasks.clear();
+        this._completedTasks.clear();
+        this._requiresRerun.clear();
+        this._taskIssues = { totalErrors: 0, totalWarnings: 0, taskWarnings: {}, taskErrors: {} };
+    }
+    /**
+     * Clear the result of a specific task (could involve deleting files from disk) and remove
+     * it from the TaskRunner's task records.
+     */
+    async clearResult(id) {
+        const task = this._allTasks.get(id);
+        task?.dispose?.();
+        await task?.clear?.();
+        this._allTasks.delete(id);
+        this._requiresRerun.delete(id);
+        this._pendingTasks.delete(id);
         this._completedTasks.delete(id);
+        this._removeTaskIssues(id);
+        if (this._bus) {
+            const { tasks, index } = this._findFromTaskList(id);
+            if (index !== -1) {
+                tasks.splice(index, 1);
+                this._publishUpdates({ tasks, stats: true });
+            }
+        }
     }
     /**
-     * The clear method disposes all tasks and clears the TaskRunner.
+     * Clear the results of all tasks (might include deleting files on disk) and clear the
+     * TaskRunner's task records.
+     *
+     * (To only dispose in-memory resources, use `dispose()`.)
      */
-    clear() {
-        this._taskStats = getDefaultTaskStats();
-        this._bus?.publish(taskListSource, { tasks: [] });
-        for (const id of this._prevTasks.keys()) {
-            this.remove(id);
+    async clearAllResults() {
+        // Publish the empty task list first since deleting things might take awhile.
+        this._publishUpdates({ tasks: [] });
+        for (const task of this._allTasks.values()) {
+            task.dispose?.();
+            await task.clear?.();
         }
+        this.dispose();
+        // Publish new stats after clearing everything (otherwise the calculated values will be wrong)
+        this._publishUpdates({ stats: true });
     }
-    /** Pauses the TaskRunner (for testing). */
+    /**
+     * Pauses the TaskRunner (for testing).
+     * @internal
+     */
     _pause() {
         this._queue.pause();
     }
-    /** Starts or resumes the TaskRunner (for testing). */
+    /**
+     * Starts or resumes the TaskRunner (for testing).
+     * @internal
+     */
     _start() {
         this._queue.start();
     }
+    /** Remove any records of previous issues with this task from the totals */
+    _removeTaskIssues(id) {
+        this._taskIssues.totalErrors -= this._taskIssues.taskErrors[id] || 0;
+        this._taskIssues.totalWarnings -= this._taskIssues.taskWarnings[id] || 0;
+        delete this._taskIssues.taskErrors[id];
+        delete this._taskIssues.taskWarnings[id];
+    }
     /**
      * Internal method to report the start of a task to the bus.
      */
-    _reportStart(id, description) {
-        if (!this._bus)
+    _reportStart(task) {
+        if (!this._bus || !task.getStartDescription)
             return;
-        const bus = this._bus;
-        const { tasks } = bus.getData(taskListSource.path) || { tasks: [] };
-        const index = tasks.findIndex((t) => t.id === id);
-        const previousDescription = tasks[index];
-        const now = new Date().getTime();
-        if (!previousDescription) {
-            this._taskStats.totalTasks++;
-        }
-        if (previousDescription?.status === 'complete') {
-            this._taskStats.totalErrors -= previousDescription.errors?.length || 0;
-            this._taskStats.totalWarnings -= previousDescription.warnings?.length || 0;
-        }
-        this._taskStats.remainingTasks = this._pendingTasks.size;
-        this._taskStats.status = 'pending';
-        const task = {
-            ...description,
+        const { tasks, index } = this._findFromTaskList(task.id);
+        const taskDesc = {
+            id: task.id,
+            name: task.name,
+            ...task.getStartDescription(),
             status: 'pending',
-            startTime: now,
+            startTime: Date.now(),
         };
         if (index === -1) {
-            tasks.push(task);
+            tasks.push(taskDesc);
         }
         else {
-            tasks[index] = task;
+            tasks[index] = taskDesc;
         }
-        bus.publish(taskStatsSource, this._taskStats);
-        bus.publish(taskListSource, { tasks });
+        this._publishUpdates({ tasks, stats: true });
     }
     /**
      * Internal method to report the end of a task to the bus.
      */
-    _reportEnd(id, description) {
-        if (!this._bus)
+    _reportEnd(task, taskResult, taskError) {
+        if (!this._bus || !task.getEndDescription)
             return;
-        const bus = this._bus;
-        const { tasks } = bus.getData(taskListSource.path) || { tasks: [] };
-        const index = tasks.findIndex((t) => t.id === id);
-        const previousDescription = tasks[index];
-        const now = new Date().getTime();
-        if (previousDescription) {
-            this._taskStats.remainingTasks = this._pendingTasks.size;
-            this._taskStats.totalErrors += description?.errors?.length || 0;
-            this._taskStats.totalWarnings += description?.warnings?.length || 0;
+        // Replace the usual description with an error if relevant
+        const description = taskError
+            ? {
+                errors: [
+                    {
+                        source: 'running task',
+                        text: taskError instanceof Error ? taskError.stack || taskError.message : String(taskError),
+                    },
+                ],
+            }
+            : task.getEndDescription(taskResult);
+        const errorCount = description.errors?.length || 0;
+        const warningCount = description.warnings?.length || 0;
+        if (errorCount) {
+            this._taskIssues.taskErrors[task.id] = errorCount;
+            this._taskIssues.totalErrors += errorCount;
+        }
+        if (warningCount) {
+            this._taskIssues.taskWarnings[task.id] = warningCount;
+            this._taskIssues.totalWarnings += warningCount;
+        }
+        const { tasks, index } = this._findFromTaskList(task.id);
+        const startDescription = tasks[index];
+        if (startDescription) {
+            const now = Date.now();
             tasks[index] = {
-                ...previousDescription,
+                ...startDescription,
                 ...description,
                 status: 'complete',
-                durationMilliseconds: now - previousDescription.startTime,
+                duration: now - startDescription.startTime,
                 lastUpdated: now,
             };
-            if (this._taskStats.remainingTasks === 0) {
-                this._taskStats.status = 'idle';
-            }
-            bus.publish(taskStatsSource, this._taskStats);
-            bus.publish(taskListSource, { tasks });
+            this._publishUpdates({ tasks, stats: true });
         }
     }
+    /** Get the task list from the data bus, and find the task's index. */
+    _findFromTaskList(id) {
+        const tasks = this._bus?.getData(taskListSource.path)?.tasks || [];
+        const index = tasks.findIndex((t) => t.id === id);
+        return { tasks, index };
+    }
+    /**
+     * Publish tasks and/or stats to the data bus.
+     */
+    _publishUpdates(params) {
+        const { tasks, stats } = params;
+        // Publish using .path for easier testing
+        stats && this._bus?.publish(taskStatsSource.path, this._taskStats);
+        tasks && this._bus?.publish(taskListSource.path, { tasks });
+    }
 }
-const getDefaultTaskStats = () => ({
-    status: 'idle',
-    remainingTasks: 0,
-    totalTasks: 0,
-    totalErrors: 0,
-    totalWarnings: 0,
-});
 //# sourceMappingURL=TaskRunner.js.map