@midscene/core 1.12.10-beta-20260920031616.0 → 1.13.0

package/dist/es/test-runner/engine/project-runtime.mjs

@@ -0,0 +1,142 @@
+import { getDebug } from "@midscene/shared/logger";
+import { ProjectSetupError, ProjectTeardownError, WorkflowLifecycleError } from "../errors.mjs";
+import { ResourceCleanupDeferredError, cleanupScopeResources, linkResourceSignal } from "./resource-operations.mjs";
+const createProjectRuntime = (options)=>{
+    const startedAt = new Date();
+    const controller = new AbortController();
+    const parentSignal = options.signal;
+    linkResourceSignal(controller.signal, parentSignal);
+    const abortFromParent = ()=>controller.abort(parentSignal?.reason);
+    if (parentSignal?.aborted) abortFromParent();
+    else parentSignal?.addEventListener('abort', abortFromParent, {
+        once: true
+    });
+    const teardownStack = [];
+    let context;
+    let setupError;
+    let started = false;
+    let acceptingTeardowns = void 0 !== options.setup;
+    let finishedResult;
+    let finishPromise;
+    const createResult = (requestedStatus, teardownErrors = [])=>{
+        const endedAt = new Date();
+        return {
+            projectName: options.project.name,
+            status: 'failed' === requestedStatus || setupError || teardownErrors.length > 0 ? 'failed' : 'success',
+            ...setupError ? {
+                setupError
+            } : {},
+            ...teardownErrors.length > 0 ? {
+                teardownErrors: [
+                    ...teardownErrors
+                ]
+            } : {},
+            startedAt: startedAt.toISOString(),
+            endedAt: endedAt.toISOString(),
+            durationMs: Math.max(0, endedAt.getTime() - startedAt.getTime())
+        };
+    };
+    const onTeardown = (teardown)=>{
+        if (!acceptingTeardowns) throw new WorkflowLifecycleError('onTeardown() can only be called while Project setup is running.', {
+            projectName: options.project.name
+        });
+        if ('function' != typeof teardown) throw new WorkflowLifecycleError('Project onTeardown() requires a teardown function.', {
+            projectName: options.project.name
+        });
+        teardownStack.push({
+            registrationIndex: teardownStack.length,
+            teardown
+        });
+    };
+    return {
+        get context () {
+            return context;
+        },
+        get signal () {
+            return controller.signal;
+        },
+        get canRun () {
+            return started && !setupError && !controller.signal.aborted;
+        },
+        async start () {
+            if (started) throw new WorkflowLifecycleError('Project runtime has already started.', {
+                projectName: options.project.name
+            });
+            started = true;
+            if (controller.signal.aborted) {
+                acceptingTeardowns = false;
+                return createResult('failed');
+            }
+            if (options.setup) try {
+                context = await options.setup.setup({
+                    project: options.project,
+                    env: Object.freeze({
+                        ...process.env
+                    }),
+                    signal: controller.signal,
+                    onTeardown
+                });
+            } catch (error) {
+                setupError = new ProjectSetupError(error, {
+                    projectName: options.project.name
+                });
+            } finally{
+                acceptingTeardowns = false;
+            }
+            return createResult(setupError ? 'failed' : 'success');
+        },
+        async finish (requestedStatus = 'success') {
+            if (finishPromise) return finishPromise;
+            if (!started) throw new WorkflowLifecycleError('Project runtime must start before it can finish.', {
+                projectName: options.project.name
+            });
+            finishPromise = (async ()=>{
+                const statusBeforeTeardown = createResult(requestedStatus).status;
+                const teardownErrors = [];
+                let deferredCleanup = false;
+                const cleanup = async ()=>{
+                    const priorErrors = teardownErrors.length;
+                    for (const { registrationIndex, teardown } of teardownStack.reverse())try {
+                        await teardown({
+                            project: options.project,
+                            context,
+                            status: statusBeforeTeardown,
+                            ...setupError ? {
+                                setupError
+                            } : {}
+                        });
+                    } catch (error) {
+                        teardownErrors.push(new ProjectTeardownError(error, {
+                            projectName: options.project.name,
+                            registrationIndex
+                        }));
+                    }
+                    if (deferredCleanup && teardownErrors.length > priorErrors) throw new AggregateError(teardownErrors.slice(priorErrors), 'Deferred Project cleanup failed');
+                };
+                try {
+                    if (teardownStack.length) await cleanupScopeResources(controller.signal, cleanup, {
+                        onDeferredError: (error)=>getDebug('runner:cleanup', {
+                                console: true
+                            })(`Deferred Project cleanup failed: ${String(error)}`)
+                    });
+                } catch (error) {
+                    deferredCleanup = error instanceof ResourceCleanupDeferredError;
+                    teardownErrors.push(new ProjectTeardownError(error, {
+                        projectName: options.project.name,
+                        registrationIndex: -1
+                    }));
+                }
+                parentSignal?.removeEventListener('abort', abortFromParent);
+                finishedResult = createResult(requestedStatus, teardownErrors);
+                return finishedResult;
+            })();
+            return finishPromise;
+        },
+        abort (reason) {
+            controller.abort(reason);
+        }
+    };
+};
+export { createProjectRuntime };
+
+//# sourceMappingURL=project-runtime.mjs.map

package/dist/es/test-runner/engine/project-runtime.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-runner/engine/project-runtime.mjs","sources":["../../../../src/test-runner/engine/project-runtime.ts"],"sourcesContent":["import { getDebug } from '@midscene/shared/logger';\nimport {\n  ProjectSetupError,\n  ProjectTeardownError,\n  WorkflowLifecycleError,\n} from '../errors';\nimport {\n  ResourceCleanupDeferredError,\n  cleanupScopeResources,\n  linkResourceSignal,\n} from './resource-operations';\nimport type {\n  ProjectRuntime,\n  ProjectRuntimeOptions,\n  ProjectRuntimeResult,\n} from './types';\n\nexport const createProjectRuntime = <TProjectContext = unknown>(\n  options: ProjectRuntimeOptions<TProjectContext>,\n): ProjectRuntime<TProjectContext> => {\n  const startedAt = new Date();\n  const controller = new AbortController();\n  const parentSignal = options.signal;\n  linkResourceSignal(controller.signal, parentSignal);\n  const abortFromParent = () => controller.abort(parentSignal?.reason);\n  if (parentSignal?.aborted) abortFromParent();\n  else parentSignal?.addEventListener('abort', abortFromParent, { once: true });\n\n  const teardownStack: Array<{\n    registrationIndex: number;\n    teardown: Parameters<\n      Parameters<NonNullable<typeof options.setup>['setup']>[0]['onTeardown']\n    >[0];\n  }> = [];\n  let context: TProjectContext | undefined;\n  let setupError: ProjectSetupError | undefined;\n  let started = false;\n  let acceptingTeardowns = options.setup !== undefined;\n  let finishedResult: ProjectRuntimeResult<TProjectContext> | undefined;\n  let finishPromise: Promise<ProjectRuntimeResult<TProjectContext>> | undefined;\n\n  const createResult = (\n    requestedStatus: 'success' | 'failed',\n    teardownErrors: readonly ProjectTeardownError[] = [],\n  ): ProjectRuntimeResult<TProjectContext> => {\n    const endedAt = new Date();\n    return {\n      projectName: options.project.name,\n      status:\n        requestedStatus === 'failed' || setupError || teardownErrors.length > 0\n          ? 'failed'\n          : 'success',\n      ...(setupError ? { setupError } : {}),\n      ...(teardownErrors.length > 0\n        ? { teardownErrors: [...teardownErrors] }\n        : {}),\n      startedAt: startedAt.toISOString(),\n      endedAt: endedAt.toISOString(),\n      durationMs: Math.max(0, endedAt.getTime() - startedAt.getTime()),\n    };\n  };\n\n  const onTeardown = (\n    teardown: (typeof teardownStack)[number]['teardown'],\n  ): void => {\n    if (!acceptingTeardowns) {\n      throw new WorkflowLifecycleError(\n        'onTeardown() can only be called while Project setup is running.',\n        { projectName: options.project.name },\n      );\n    }\n    if (typeof teardown !== 'function') {\n      throw new WorkflowLifecycleError(\n        'Project onTeardown() requires a teardown function.',\n        { projectName: options.project.name },\n      );\n    }\n    teardownStack.push({\n      registrationIndex: teardownStack.length,\n      teardown,\n    });\n  };\n\n  return {\n    get context() {\n      return context;\n    },\n    get signal() {\n      return controller.signal;\n    },\n    get canRun() {\n      return started && !setupError && !controller.signal.aborted;\n    },\n    async start() {\n      if (started) {\n        throw new WorkflowLifecycleError(\n          'Project runtime has already started.',\n          {\n            projectName: options.project.name,\n          },\n        );\n      }\n      started = true;\n      if (controller.signal.aborted) {\n        acceptingTeardowns = false;\n        return createResult('failed');\n      }\n      if (options.setup) {\n        try {\n          context = await options.setup.setup({\n            project: options.project,\n            env: Object.freeze({ ...process.env }),\n            signal: controller.signal,\n            onTeardown,\n          });\n        } catch (error) {\n          setupError = new ProjectSetupError(error, {\n            projectName: options.project.name,\n          });\n        } finally {\n          acceptingTeardowns = false;\n        }\n      }\n      return createResult(setupError ? 'failed' : 'success');\n    },\n    async finish(requestedStatus = 'success') {\n      if (finishPromise) return finishPromise;\n      if (!started) {\n        throw new WorkflowLifecycleError(\n          'Project runtime must start before it can finish.',\n          { projectName: options.project.name },\n        );\n      }\n      finishPromise = (async () => {\n        const statusBeforeTeardown = createResult(requestedStatus).status;\n        const teardownErrors: ProjectTeardownError[] = [];\n        let deferredCleanup = false;\n        const cleanup = async () => {\n          const priorErrors = teardownErrors.length;\n          for (const {\n            registrationIndex,\n            teardown,\n          } of teardownStack.reverse()) {\n            try {\n              await teardown({\n                project: options.project,\n                context,\n                status: statusBeforeTeardown,\n                ...(setupError ? { setupError } : {}),\n              });\n            } catch (error) {\n              teardownErrors.push(\n                new ProjectTeardownError(error, {\n                  projectName: options.project.name,\n                  registrationIndex,\n                }),\n              );\n            }\n          }\n          if (deferredCleanup && teardownErrors.length > priorErrors)\n            throw new AggregateError(\n              teardownErrors.slice(priorErrors),\n              'Deferred Project cleanup failed',\n            );\n        };\n        try {\n          if (teardownStack.length)\n            await cleanupScopeResources(controller.signal, cleanup, {\n              onDeferredError: (error) =>\n                getDebug('runner:cleanup', { console: true })(\n                  `Deferred Project cleanup failed: ${String(error)}`,\n                ),\n            });\n        } catch (error) {\n          deferredCleanup = error instanceof ResourceCleanupDeferredError;\n          teardownErrors.push(\n            new ProjectTeardownError(error, {\n              projectName: options.project.name,\n              registrationIndex: -1,\n            }),\n          );\n        }\n        parentSignal?.removeEventListener('abort', abortFromParent);\n        finishedResult = createResult(requestedStatus, teardownErrors);\n        return finishedResult;\n      })();\n      return finishPromise;\n    },\n    abort(reason) {\n      controller.abort(reason);\n    },\n  };\n};\n"],"names":["createProjectRuntime","options","startedAt","Date","controller","AbortController","parentSignal","linkResourceSignal","abortFromParent","teardownStack","context","setupError","started","acceptingTeardowns","undefined","finishedResult","finishPromise","createResult","requestedStatus","teardownErrors","endedAt","Math","onTeardown","teardown","WorkflowLifecycleError","Object","process","error","ProjectSetupError","statusBeforeTeardown","deferredCleanup","cleanup","priorErrors","registrationIndex","ProjectTeardownError","AggregateError","cleanupScopeResources","getDebug","String","ResourceCleanupDeferredError","reason"],"mappings":"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"}

package/dist/es/test-runner/engine/registry.mjs

@@ -0,0 +1,61 @@
+import { DuplicateNodeError, NodeNotFoundError } from "../errors.mjs";
+import { defineNode } from "../node/define-node.mjs";
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+var _nodes = /*#__PURE__*/ new WeakMap();
+class NodeRegistry {
+    register(node) {
+        defineNode(node);
+        if (_class_private_field_get(this, _nodes).has(node.name)) throw new DuplicateNodeError(node.name);
+        _class_private_field_get(this, _nodes).set(node.name, node);
+        return this;
+    }
+    get(name) {
+        return _class_private_field_get(this, _nodes).get(name);
+    }
+    require(name) {
+        const node = this.get(name);
+        if (!node) throw new NodeNotFoundError(name);
+        return node;
+    }
+    has(name) {
+        return _class_private_field_get(this, _nodes).has(name);
+    }
+    names() {
+        return [
+            ..._class_private_field_get(this, _nodes).keys()
+        ];
+    }
+    definitions() {
+        return [
+            ..._class_private_field_get(this, _nodes).values()
+        ];
+    }
+    constructor(nodes = []){
+        _class_private_field_init(this, _nodes, {
+            writable: true,
+            value: new Map()
+        });
+        for (const node of nodes)this.register(node);
+    }
+}
+export { NodeRegistry };
+
+//# sourceMappingURL=registry.mjs.map

package/dist/es/test-runner/engine/registry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-runner/engine/registry.mjs","sources":["../../../../src/test-runner/engine/registry.ts"],"sourcesContent":["import { DuplicateNodeError, NodeNotFoundError } from '../errors';\nimport { defineNode } from '../node/define-node';\nimport type { NodeDefinition } from '../node/types';\n\nexport class NodeRegistry {\n  readonly #nodes = new Map<string, NodeDefinition<any, any, any>>();\n\n  constructor(nodes: readonly NodeDefinition<any, any>[] = []) {\n    for (const node of nodes) {\n      this.register(node);\n    }\n  }\n\n  register<TInput, TData>(node: NodeDefinition<TInput, TData>): this {\n    defineNode(node);\n\n    if (this.#nodes.has(node.name)) {\n      throw new DuplicateNodeError(node.name);\n    }\n\n    this.#nodes.set(node.name, node);\n    return this;\n  }\n\n  get(name: string): NodeDefinition<any, any> | undefined {\n    return this.#nodes.get(name);\n  }\n\n  require(name: string): NodeDefinition<any, any> {\n    const node = this.get(name);\n    if (!node) {\n      throw new NodeNotFoundError(name);\n    }\n    return node;\n  }\n\n  has(name: string): boolean {\n    return this.#nodes.has(name);\n  }\n\n  names(): string[] {\n    return [...this.#nodes.keys()];\n  }\n\n  definitions(): readonly NodeDefinition<any, any, any>[] {\n    return [...this.#nodes.values()];\n  }\n}\n"],"names":["_nodes","NodeRegistry","node","defineNode","DuplicateNodeError","name","NodeNotFoundError","nodes","Map"],"mappings":";;;;;;;;;;;;;;;;;;;;;IAKWA,SAAAA,WAAAA,GAAAA,IAAAA;AADJ,MAAMC;IASX,SAAwBC,IAAmC,EAAQ;QACjEC,WAAWD;QAEX,IAAI,6BAAI,EAACF,QAAO,GAAG,CAACE,KAAK,IAAI,GAC3B,MAAM,IAAIE,mBAAmBF,KAAK,IAAI;QAGxC,6BAAI,EAACF,QAAO,GAAG,CAACE,KAAK,IAAI,EAAEA;QAC3B,OAAO,IAAI;IACb;IAEA,IAAIG,IAAY,EAAwC;QACtD,OAAO,6BAAI,EAACL,QAAO,GAAG,CAACK;IACzB;IAEA,QAAQA,IAAY,EAA4B;QAC9C,MAAMH,OAAO,IAAI,CAAC,GAAG,CAACG;QACtB,IAAI,CAACH,MACH,MAAM,IAAII,kBAAkBD;QAE9B,OAAOH;IACT;IAEA,IAAIG,IAAY,EAAW;QACzB,OAAO,6BAAI,EAACL,QAAO,GAAG,CAACK;IACzB;IAEA,QAAkB;QAChB,OAAO;eAAI,6BAAI,EAACL,QAAO,IAAI;SAAG;IAChC;IAEA,cAAwD;QACtD,OAAO;eAAI,6BAAI,EAACA,QAAO,MAAM;SAAG;IAClC;IAvCA,YAAYO,QAA6C,EAAE,CAAE;QAF7D,gCAASP,QAAAA;;mBAAS,IAAIQ;;QAGpB,KAAK,MAAMN,QAAQK,MACjB,IAAI,CAAC,QAAQ,CAACL;IAElB;AAoCF"}

package/dist/es/test-runner/engine/resource-operations.mjs

@@ -0,0 +1,211 @@
+import { WorkflowError } from "../errors.mjs";
+const stateKey = Symbol.for('@midscene/core/resource-operations/v3');
+const host = globalThis;
+host[stateKey] ??= {
+    resources: new WeakMap(),
+    scopes: new WeakMap(),
+    parents: new WeakMap(),
+    cleanupOwners: new WeakMap()
+};
+const { resources: resource_operations_resources, scopes, parents, cleanupOwners } = host[stateKey];
+const resourceHandle = (resource)=>{
+    let handle = resource_operations_resources.get(resource);
+    if (!handle) {
+        handle = {
+            operations: new Map(),
+            retiring: new Set()
+        };
+        resource_operations_resources.set(resource, handle);
+    }
+    return handle;
+};
+const getResourceCleanupCompletion = (owner)=>resource_operations_resources.get(owner)?.cleanup;
+const RESOURCE_CLEANUP_GRACE_MS = 1000;
+function linkResourceSignal(signal, parent) {
+    if (parent && parent !== signal) parents.set(signal, parent);
+}
+function* ownerSignals(signal) {
+    const seen = new Set();
+    for(let owner = signal; owner && !seen.has(owner); owner = parents.get(owner)){
+        seen.add(owner);
+        yield owner;
+    }
+}
+function createResourceScope(parent) {
+    const controller = new AbortController();
+    const scope = {
+        operations: new Map(),
+        resources: new Set()
+    };
+    scopes.set(controller.signal, scope);
+    linkResourceSignal(controller.signal, parent);
+    const abort = ()=>controller.abort(parent?.reason);
+    if (parent?.aborted) abort();
+    else parent?.addEventListener('abort', abort, {
+        once: true
+    });
+    return {
+        signal: controller.signal,
+        dispose () {
+            parent?.removeEventListener('abort', abort);
+            scope.resources = void 0;
+            if (!scope.operations.size) scopes.delete(controller.signal);
+        }
+    };
+}
+function assertResourceAvailable(resource, exclusive = false, signal) {
+    const retiringOwners = resource_operations_resources.get(resource)?.retiring;
+    const isOwnerCleanup = [
+        ...ownerSignals(signal)
+    ].some((ownerSignal)=>{
+        const owner = cleanupOwners.get(ownerSignal);
+        return void 0 !== owner && retiringOwners?.has(owner);
+    });
+    if (retiringOwners?.size && !isOwnerCleanup) throw new WorkflowError('A resource cannot execute overlapping Runner operations while its cleanup is pending.', {
+        code: 'RESOURCE_CLEANUP_PENDING'
+    });
+    const pending = resource_operations_resources.get(resource)?.operations;
+    if (exclusive && pending?.size && !isOwnerCleanup) throw new WorkflowError('The same Agent instance cannot execute overlapping Runner operations.', {
+        code: 'RESOURCE_OPERATION_PENDING'
+    });
+    if (pending && !isOwnerCleanup && [
+        ...pending.values()
+    ].some((signal)=>signal.aborted)) throw new WorkflowError('Cannot reuse an Agent while an aborted YAML action or Runner operation is still running.', {
+        code: 'RESOURCE_OPERATION_PENDING'
+    });
+    return isOwnerCleanup;
+}
+const retainForCleanup = (owner, resource)=>{
+    owner.resources.add(resource);
+    resourceHandle(resource).retiring.add(owner);
+};
+function trackResourceOperation(resource, operation, signal) {
+    const active = resourceHandle(resource).operations;
+    active.set(operation, signal);
+    const ownerScopes = [];
+    let retainedByScope = false;
+    for (const ownerSignal of ownerSignals(signal)){
+        const scope = scopes.get(ownerSignal) ?? {
+            operations: new Map()
+        };
+        scopes.set(ownerSignal, scope);
+        scope.operations.set(resource, (scope.operations.get(resource) ?? 0) + 1);
+        ownerScopes.push([
+            ownerSignal,
+            scope
+        ]);
+        if (!retainedByScope && scope.resources) {
+            scope.resources.add(resource);
+            retainedByScope = true;
+        }
+        const cleanupOwner = cleanupOwners.get(ownerSignal);
+        if (cleanupOwner) retainForCleanup(cleanupOwner, resource);
+    }
+    const finish = ()=>{
+        active.delete(operation);
+        for (const [ownerSignal, scope] of ownerScopes){
+            const count = scope.operations.get(resource) - 1;
+            if (count) scope.operations.set(resource, count);
+            else scope.operations.delete(resource);
+            if (!scope.operations.size && !scope.resources) scopes.delete(ownerSignal);
+        }
+    };
+    operation.then(finish, finish);
+    return operation;
+}
+async function waitForResourceIdle(resource) {
+    while(resource_operations_resources.get(resource)?.operations?.size)await Promise.allSettled([
+        ...resource_operations_resources.get(resource).operations.keys()
+    ]);
+}
+class ResourceCleanupDeferredError extends WorkflowError {
+    constructor(graceMs, resourceCount){
+        super('Resource cleanup was deferred because an operation did not stop after cancellation. The resource remains quarantined and cleanup will run when that operation settles.', {
+            code: 'RESOURCE_CLEANUP_DEFERRED',
+            details: {
+                graceMs,
+                resourceCount
+            }
+        });
+    }
+}
+async function runResourceCleanup(resources, cleanup, options, beforeCleanup) {
+    const owner = {
+        resources: new Set(),
+        signal: beforeCleanup?.signal
+    };
+    for (const resource of resources)retainForCleanup(owner, resource);
+    if (owner.signal) cleanupOwners.set(owner.signal, owner);
+    let defer;
+    const deferred = new Promise((resolve)=>{
+        defer = ()=>resolve({
+                deferred: true
+            });
+    });
+    const graceMs = options.graceMs ?? RESOURCE_CLEANUP_GRACE_MS;
+    const drain = async ()=>{
+        const pending = [
+            ...owner.resources
+        ].filter((resource)=>resourceHandle(resource).operations.size);
+        if (!pending.length) return;
+        const timer = setTimeout(defer, graceMs);
+        try {
+            await Promise.all(pending.map(waitForResourceIdle));
+        } finally{
+            clearTimeout(timer);
+        }
+    };
+    const completion = (async ()=>{
+        try {
+            if (beforeCleanup) await beforeCleanup.run(beforeCleanup.signal);
+            await drain();
+            return await cleanup();
+        } finally{
+            if (owner.signal) cleanupOwners.delete(owner.signal);
+            for (const resource of owner.resources){
+                const owners = resourceHandle(resource).retiring;
+                owners.delete(owner);
+            }
+        }
+    })();
+    const ownerKey = options.owner ?? beforeCleanup?.signal ?? resources[0];
+    if (ownerKey) resourceHandle(ownerKey).cleanup = completion;
+    const outcome = await Promise.race([
+        completion.then((value)=>({
+                value
+            })),
+        deferred
+    ]);
+    if ('deferred' in outcome) {
+        completion.catch((error)=>{
+            try {
+                options.onDeferredError(error);
+            } catch  {}
+        });
+        if (options.signal) trackResourceOperation({}, completion, options.signal);
+        throw new ResourceCleanupDeferredError(graceMs, owner.resources.size);
+    }
+    return outcome.value;
+}
+function cleanupResources(resources, cleanup, options) {
+    return runResourceCleanup(resources, cleanup, options);
+}
+async function cleanupScopeResources(signal, cleanup, options) {
+    const cleanupSignal = new AbortController().signal;
+    linkResourceSignal(cleanupSignal, signal);
+    const scope = scopes.get(signal);
+    return runResourceCleanup([
+        ...scope?.resources ?? [],
+        ...scope?.operations.keys() ?? []
+    ], cleanup, {
+        ...options,
+        owner: signal,
+        signal
+    }, options.beforeCleanup ? {
+        signal: cleanupSignal,
+        run: options.beforeCleanup
+    } : void 0);
+}
+export { RESOURCE_CLEANUP_GRACE_MS, ResourceCleanupDeferredError, assertResourceAvailable, cleanupResources, cleanupScopeResources, createResourceScope, getResourceCleanupCompletion, linkResourceSignal, trackResourceOperation, waitForResourceIdle };
+
+//# sourceMappingURL=resource-operations.mjs.map

package/dist/es/test-runner/engine/resource-operations.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-runner/engine/resource-operations.mjs","sources":["../../../../src/test-runner/engine/resource-operations.ts"],"sourcesContent":["import { WorkflowError } from '../errors';\n\ninterface CleanupOwner {\n  resources: Set<object>;\n  signal?: AbortSignal;\n}\n\ninterface ResourceScope {\n  operations: Map<object, number>;\n  resources?: Set<object>;\n}\n\ninterface ResourceHandle {\n  operations: Map<Promise<unknown>, AbortSignal>;\n  retiring: Set<CleanupOwner>;\n  cleanup?: Promise<unknown>;\n}\n\ninterface ResourceState {\n  resources: WeakMap<object, ResourceHandle>;\n  scopes: WeakMap<AbortSignal, ResourceScope>;\n  parents: WeakMap<AbortSignal, AbortSignal>;\n  cleanupOwners: WeakMap<AbortSignal, CleanupOwner>;\n}\n\n// CJS and ESM hosts must agree about ownership of the same Agent instance.\nconst stateKey = Symbol.for('@midscene/core/resource-operations/v3');\nconst host = globalThis as typeof globalThis & { [stateKey]?: ResourceState };\nhost[stateKey] ??= {\n  resources: new WeakMap(),\n  scopes: new WeakMap(),\n  parents: new WeakMap(),\n  cleanupOwners: new WeakMap(),\n};\nconst { resources, scopes, parents, cleanupOwners } = host[stateKey];\nconst resourceHandle = (resource: object): ResourceHandle => {\n  let handle = resources.get(resource);\n  if (!handle) {\n    handle = { operations: new Map(), retiring: new Set() };\n    resources.set(resource, handle);\n  }\n  return handle;\n};\n\n/** Actual teardown completion belongs to the owner, never to a thrown error. */\nexport const getResourceCleanupCompletion = (\n  owner: object,\n): Promise<unknown> | undefined => resources.get(owner)?.cleanup;\n\nexport const RESOURCE_CLEANUP_GRACE_MS = 1000;\n\n/** Resource ancestry is independent of cancellation: cleanup can outlive abort. */\nexport function linkResourceSignal(signal: AbortSignal, parent?: AbortSignal) {\n  if (parent && parent !== signal) parents.set(signal, parent);\n}\n\nfunction* ownerSignals(signal?: AbortSignal): Generator<AbortSignal> {\n  const seen = new Set<AbortSignal>();\n  for (\n    let owner = signal;\n    owner && !seen.has(owner);\n    owner = parents.get(owner)\n  ) {\n    seen.add(owner);\n    yield owner;\n  }\n}\n\n/** Each Case/document owns its cleanup, even when cancellation is shared. */\nexport function createResourceScope(parent?: AbortSignal) {\n  const controller = new AbortController();\n  const scope: ResourceScope = { operations: new Map(), resources: new Set() };\n  scopes.set(controller.signal, scope);\n  linkResourceSignal(controller.signal, parent);\n  const abort = () => controller.abort(parent?.reason);\n  if (parent?.aborted) abort();\n  else parent?.addEventListener('abort', abort, { once: true });\n  return {\n    signal: controller.signal,\n    dispose() {\n      parent?.removeEventListener('abort', abort);\n      scope.resources = undefined;\n      if (!scope.operations.size) scopes.delete(controller.signal);\n    },\n  };\n}\n\nexport function assertResourceAvailable(\n  resource: object,\n  exclusive = false,\n  signal?: AbortSignal,\n): boolean {\n  const retiringOwners = resources.get(resource)?.retiring;\n  const isOwnerCleanup = [...ownerSignals(signal)].some((ownerSignal) => {\n    const owner = cleanupOwners.get(ownerSignal);\n    return owner !== undefined && retiringOwners?.has(owner);\n  });\n  if (retiringOwners?.size && !isOwnerCleanup)\n    throw new WorkflowError(\n      'A resource cannot execute overlapping Runner operations while its cleanup is pending.',\n      { code: 'RESOURCE_CLEANUP_PENDING' },\n    );\n  const pending = resources.get(resource)?.operations;\n  if (exclusive && pending?.size && !isOwnerCleanup)\n    throw new WorkflowError(\n      'The same Agent instance cannot execute overlapping Runner operations.',\n      { code: 'RESOURCE_OPERATION_PENDING' },\n    );\n  if (\n    pending &&\n    !isOwnerCleanup &&\n    [...pending.values()].some((signal) => signal.aborted)\n  )\n    throw new WorkflowError(\n      'Cannot reuse an Agent while an aborted YAML action or Runner operation is still running.',\n      { code: 'RESOURCE_OPERATION_PENDING' },\n    );\n  return isOwnerCleanup;\n}\n\nconst retainForCleanup = (owner: CleanupOwner, resource: object) => {\n  owner.resources.add(resource);\n  resourceHandle(resource).retiring.add(owner);\n};\n\n/** Track actual completion, not the Runner timeout race. */\nexport function trackResourceOperation<T>(\n  resource: object,\n  operation: Promise<T>,\n  signal: AbortSignal,\n): Promise<T> {\n  const active = resourceHandle(resource).operations;\n  active.set(operation, signal);\n  const ownerScopes: Array<[AbortSignal, ResourceScope]> = [];\n  let retainedByScope = false;\n  for (const ownerSignal of ownerSignals(signal)) {\n    const scope: ResourceScope = scopes.get(ownerSignal) ?? {\n      operations: new Map(),\n    };\n    scopes.set(ownerSignal, scope);\n    scope.operations.set(resource, (scope.operations.get(resource) ?? 0) + 1);\n    ownerScopes.push([ownerSignal, scope]);\n    // Only the closest owner retains idle resources for its teardown. Parents\n    // wait on active operations, not every Agent used by completed Cases.\n    if (!retainedByScope && scope.resources) {\n      scope.resources.add(resource);\n      retainedByScope = true;\n    }\n    const cleanupOwner = cleanupOwners.get(ownerSignal);\n    if (cleanupOwner) retainForCleanup(cleanupOwner, resource);\n  }\n  const finish = () => {\n    active.delete(operation);\n    for (const [ownerSignal, scope] of ownerScopes) {\n      const count = scope.operations.get(resource)! - 1;\n      if (count) scope.operations.set(resource, count);\n      else scope.operations.delete(resource);\n      if (!scope.operations.size && !scope.resources)\n        scopes.delete(ownerSignal);\n    }\n  };\n  void operation.then(finish, finish);\n  return operation;\n}\n\nexport async function waitForResourceIdle(resource: object): Promise<void> {\n  while (resources.get(resource)?.operations?.size)\n    await Promise.allSettled([...resources.get(resource)!.operations.keys()]);\n}\n\nexport class ResourceCleanupDeferredError extends WorkflowError {\n  constructor(graceMs: number, resourceCount: number) {\n    super(\n      'Resource cleanup was deferred because an operation did not stop after cancellation. The resource remains quarantined and cleanup will run when that operation settles.',\n      {\n        code: 'RESOURCE_CLEANUP_DEFERRED',\n        details: { graceMs, resourceCount },\n      },\n    );\n  }\n}\n\ninterface CleanupOptions {\n  /** Stable owner of this cleanup, distinct from borrowed resource identities. */\n  owner?: object;\n  /** Parent scope observes deferred completion without host-specific forwarding. */\n  signal?: AbortSignal;\n  graceMs?: number;\n  onDeferredError(error: unknown): void;\n}\n\n/** Bound draining, but keep ownership until the actual cleanup has finished. */\nasync function runResourceCleanup<T>(\n  resources: readonly object[],\n  cleanup: () => Promise<T>,\n  options: CleanupOptions,\n  beforeCleanup?: {\n    signal: AbortSignal;\n    run(signal: AbortSignal): Promise<void>;\n  },\n): Promise<T> {\n  const owner: CleanupOwner = {\n    resources: new Set(),\n    signal: beforeCleanup?.signal,\n  };\n  for (const resource of resources) retainForCleanup(owner, resource);\n  if (owner.signal) cleanupOwners.set(owner.signal, owner);\n\n  let defer!: () => void;\n  const deferred = new Promise<{ deferred: true }>((resolve) => {\n    defer = () => resolve({ deferred: true });\n  });\n  const graceMs = options.graceMs ?? RESOURCE_CLEANUP_GRACE_MS;\n  const drain = async () => {\n    const pending = [...owner.resources].filter(\n      (resource) => resourceHandle(resource).operations.size,\n    );\n    if (!pending.length) return;\n    const timer = setTimeout(defer, graceMs);\n    try {\n      await Promise.all(pending.map(waitForResourceIdle));\n    } finally {\n      clearTimeout(timer);\n    }\n  };\n  const completion = (async () => {\n    try {\n      if (beforeCleanup) {\n        // Authored lifecycle cleanup must be allowed to stop or reset a\n        // resource whose timed-out operation is still settling. Its signal is\n        // registered as the retiring owner's cleanup signal, so unrelated\n        // scopes remain quarantined while this hook runs.\n        await beforeCleanup.run(beforeCleanup.signal);\n      }\n      // Lifecycle hooks can themselves time out with an action still running.\n      // Drain both the original work and any operation started by the hook\n      // before disposing the resource.\n      await drain();\n      return await cleanup();\n    } finally {\n      if (owner.signal) cleanupOwners.delete(owner.signal);\n      for (const resource of owner.resources) {\n        const owners = resourceHandle(resource).retiring;\n        owners.delete(owner);\n      }\n    }\n  })();\n  const ownerKey = options.owner ?? beforeCleanup?.signal ?? resources[0];\n  if (ownerKey) resourceHandle(ownerKey).cleanup = completion;\n  const outcome = await Promise.race([\n    completion.then((value) => ({ value })),\n    deferred,\n  ]);\n  if ('deferred' in outcome) {\n    void completion.catch((error) => {\n      try {\n        options.onDeferredError(error);\n      } catch {\n        // The returned completion still carries the original cleanup failure.\n      }\n    });\n    if (options.signal) trackResourceOperation({}, completion, options.signal);\n    throw new ResourceCleanupDeferredError(graceMs, owner.resources.size);\n  }\n  return outcome.value;\n}\n\nexport function cleanupResources<T>(\n  resources: readonly object[],\n  cleanup: () => Promise<T>,\n  options: CleanupOptions,\n): Promise<T> {\n  return runResourceCleanup(resources, cleanup, options);\n}\n\nexport async function cleanupScopeResources<T>(\n  signal: AbortSignal,\n  cleanup: () => Promise<T>,\n  options: CleanupOptions & {\n    beforeCleanup?(signal: AbortSignal): Promise<void>;\n  },\n): Promise<T> {\n  const cleanupSignal = new AbortController().signal;\n  linkResourceSignal(cleanupSignal, signal);\n  const scope = scopes.get(signal);\n  return runResourceCleanup(\n    [...(scope?.resources ?? []), ...(scope?.operations.keys() ?? [])],\n    cleanup,\n    { ...options, owner: signal, signal },\n    options.beforeCleanup\n      ? { signal: cleanupSignal, run: options.beforeCleanup }\n      : undefined,\n  );\n}\n"],"names":["stateKey","Symbol","host","globalThis","WeakMap","resources","scopes","parents","cleanupOwners","resourceHandle","resource","handle","Map","Set","getResourceCleanupCompletion","owner","RESOURCE_CLEANUP_GRACE_MS","linkResourceSignal","signal","parent","ownerSignals","seen","createResourceScope","controller","AbortController","scope","abort","undefined","assertResourceAvailable","exclusive","retiringOwners","isOwnerCleanup","ownerSignal","WorkflowError","pending","retainForCleanup","trackResourceOperation","operation","active","ownerScopes","retainedByScope","cleanupOwner","finish","count","waitForResourceIdle","Promise","ResourceCleanupDeferredError","graceMs","resourceCount","runResourceCleanup","cleanup","options","beforeCleanup","defer","deferred","resolve","drain","timer","setTimeout","clearTimeout","completion","owners","ownerKey","outcome","value","error","cleanupResources","cleanupScopeResources","cleanupSignal"],"mappings":"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"}