@webiny/background-tasks-standalone 0.0.0-unstable.5387e5f7c8 → 0.0.0-unstable.eb81deee7e

package/BackgroundTasksStandaloneFeature.d.ts

@@ -1,7 +1,3 @@
-/**
- * Background tasks for the standalone server. Register at the root container: the loop is one
- * long-lived object for the whole process, and it needs the root's `EventDispatcher`.
- */
 export declare const BackgroundTasksStandaloneFeature: {
     name: string;
     register(container: import("@webiny/di").Container): void;

package/BackgroundTasksStandaloneFeature.js

@@ -1,15 +1,16 @@
 import { createFeature } from "@webiny/feature/api";
-import { BackgroundTaskEventType } from "@webiny/event-handler-core";
-import { DispatchingTaskLoop } from "./loop/DispatchingTaskLoop.js";
-import { InProcessTaskService } from "./service/InProcessTaskService.js";
-import { InProcessBackgroundTaskHandler } from "./handlers/InProcessBackgroundTaskHandler.js";
+import { uuid } from "@webiny/stdlib";
+import { WorkerService } from "./service/WorkerTaskService.js";
+import { BackgroundTaskRouteDefinition } from "./routes/BackgroundTaskRoute.js";
+import { InternalToken } from "./domain/InternalToken.js";
 const BackgroundTasksStandaloneFeature = createFeature({
     name: "BackgroundTasksServer",
     register (container) {
-        container.register(BackgroundTaskEventType);
-        container.register(InProcessBackgroundTaskHandler);
-        container.register(DispatchingTaskLoop).inSingletonScope();
-        container.register(InProcessTaskService);
+        container.registerInstance(InternalToken, {
+            value: uuid()
+        });
+        container.register(WorkerService);
+        container.register(BackgroundTaskRouteDefinition);
     }
 });
 export { BackgroundTasksStandaloneFeature };

package/BackgroundTasksStandaloneFeature.js.map

@@ -1 +1 @@
-{"version":3,"file":"BackgroundTasksStandaloneFeature.js","sources":["../src/BackgroundTasksStandaloneFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { BackgroundTaskEventType } from \"@webiny/event-handler-core\";\nimport { DispatchingTaskLoop } from \"~/loop/DispatchingTaskLoop.js\";\nimport { InProcessTaskService } from \"~/service/InProcessTaskService.js\";\nimport { InProcessBackgroundTaskHandler } from \"~/handlers/InProcessBackgroundTaskHandler.js\";\n\n/**\n * Background tasks for the standalone server. Register at the root container: the loop is one\n * long-lived object for the whole process, and it needs the root's `EventDispatcher`.\n */\nexport const BackgroundTasksStandaloneFeature = createFeature({\n    name: \"BackgroundTasksServer\",\n    register(container) {\n        container.register(BackgroundTaskEventType);\n        container.register(InProcessBackgroundTaskHandler);\n        container.register(DispatchingTaskLoop).inSingletonScope();\n        container.register(InProcessTaskService);\n    }\n});\n"],"names":["BackgroundTasksStandaloneFeature","createFeature","container","BackgroundTaskEventType","InProcessBackgroundTaskHandler","DispatchingTaskLoop","InProcessTaskService"],"mappings":";;;;;AAUO,MAAMA,mCAAmCC,cAAc;IAC1D,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG,qBAAqB,gBAAgB;QACxDH,UAAU,QAAQ,CAACI;IACvB;AACJ"}
+{"version":3,"file":"BackgroundTasksStandaloneFeature.js","sources":["../src/BackgroundTasksStandaloneFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { uuid } from \"@webiny/stdlib\";\nimport { WorkerService } from \"~/service/WorkerTaskService.js\";\nimport { BackgroundTaskRouteDefinition } from \"~/routes/BackgroundTaskRoute.js\";\nimport { InternalToken } from \"~/domain/InternalToken.js\";\n\nexport const BackgroundTasksStandaloneFeature = createFeature({\n    name: \"BackgroundTasksServer\",\n    register(container) {\n        container.registerInstance(InternalToken, { value: uuid() });\n        container.register(WorkerService);\n        container.register(BackgroundTaskRouteDefinition);\n    }\n});\n"],"names":["BackgroundTasksStandaloneFeature","createFeature","container","InternalToken","uuid","WorkerService","BackgroundTaskRouteDefinition"],"mappings":";;;;;AAMO,MAAMA,mCAAmCC,cAAc;IAC1D,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,gBAAgB,CAACC,eAAe;YAAE,OAAOC;QAAO;QAC1DF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;IACvB;AACJ"}

package/domain/InternalToken.d.ts

@@ -0,0 +1,8 @@
+interface IInternalToken {
+    readonly value: string;
+}
+export declare const InternalToken: import("@webiny/di").Abstraction<IInternalToken>;
+export declare namespace InternalToken {
+    type Interface = IInternalToken;
+}
+export {};

package/domain/InternalToken.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const InternalToken = createAbstraction("BackgroundTasks/InternalToken");
+export { InternalToken };
+
+//# sourceMappingURL=InternalToken.js.map

package/domain/InternalToken.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/InternalToken.js","sources":["../../src/domain/InternalToken.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\n\n/*\n * Per-process token generated at startup, shared between WorkerService and BackgroundTaskRoute\n * via DI. Workers send it as a header; the route rejects requests without a matching value.\n * This only works within a single server process. For multi-server deployments where workers\n * on one server may hit another server's route, replace with a shared secret (env var or\n * config service).\n */\n\ninterface IInternalToken {\n    readonly value: string;\n}\n\nexport const InternalToken = createAbstraction<IInternalToken>(\"BackgroundTasks/InternalToken\");\n\nexport namespace InternalToken {\n    export type Interface = IInternalToken;\n}\n"],"names":["InternalToken","createAbstraction"],"mappings":";AAcO,MAAMA,gBAAgBC,kBAAkC"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/background-tasks-standalone",
-	"version": "0.0.0-unstable.5387e5f7c8",
+	"version": "0.0.0-unstable.eb81deee7e",
 	"type": "module",
 	"exports": {
 		".": "./index.js",
@@ -14,15 +14,16 @@
 	},
 	"license": "MIT",
 	"dependencies": {
-		"@webiny/api-core": "0.0.0-unstable.5387e5f7c8",
-		"@webiny/background-tasks": "0.0.0-unstable.5387e5f7c8",
-		"@webiny/event-handler-core": "0.0.0-unstable.5387e5f7c8",
-		"@webiny/feature": "0.0.0-unstable.5387e5f7c8",
-		"@webiny/utils": "0.0.0-unstable.5387e5f7c8"
+		"@webiny/api-core": "0.0.0-unstable.eb81deee7e",
+		"@webiny/background-tasks": "0.0.0-unstable.eb81deee7e",
+		"@webiny/event-handler-core": "0.0.0-unstable.eb81deee7e",
+		"@webiny/feature": "0.0.0-unstable.eb81deee7e",
+		"@webiny/stdlib": "0.0.17",
+		"@webiny/utils": "0.0.0-unstable.eb81deee7e"
 	},
 	"devDependencies": {
-		"@webiny/build-tools": "0.0.0-unstable.5387e5f7c8",
-		"@webiny/di": "2.0.0",
+		"@webiny/build-tools": "0.0.0-unstable.eb81deee7e",
+		"@webiny/di": "1.1.0",
 		"rimraf": "6.1.3",
 		"typescript": "7.0.2",
 		"vitest": "4.1.11"

package/routes/BackgroundTaskRoute.d.ts

@@ -0,0 +1,25 @@
+import { HttpRouteDefinition, HttpRouteHandler } from "@webiny/event-handler-core";
+import type { Container } from "@webiny/feature/api";
+import { InternalToken } from "../domain/InternalToken.js";
+declare class BackgroundTaskRouteImpl implements HttpRouteHandler.Interface {
+    private readonly container;
+    private readonly internalToken;
+    constructor(container: Container, internalToken: InternalToken.Interface);
+    handle(request: HttpRouteHandler.Request, response: HttpRouteHandler.Response): Promise<import("@webiny/event-handler-core").IHttpResponseBuilder>;
+}
+export declare const BackgroundTaskRoute: typeof BackgroundTaskRouteImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-core").IHttpRoute>;
+};
+declare class BackgroundTaskRouteDefinitionImpl implements HttpRouteDefinition.Interface {
+    readonly name = "background-task";
+    readonly method = "POST";
+    readonly path = "/background-task";
+    readonly handler: typeof BackgroundTaskRouteImpl & {
+        __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-core").IHttpRoute>;
+    };
+}
+/** What the router matches on. Zero dependencies, so building it costs nothing. */
+export declare const BackgroundTaskRouteDefinition: typeof BackgroundTaskRouteDefinitionImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-core").IHttpRouteDefinition>;
+};
+export {};

package/routes/BackgroundTaskRoute.js

@@ -0,0 +1,66 @@
+import { HttpRouteDefinition, HttpRouteHandler, RequestContainer } from "@webiny/event-handler-core";
+import { RawTenantId, RequestTenantLoader } from "@webiny/api-core/features/requestContext/index.js";
+import { TaskRunner } from "@webiny/background-tasks/api/runner/index.js";
+import { TaskEventValidation } from "@webiny/background-tasks/api/runner/TaskEventValidation.js";
+import { ProcessTimer } from "../timer/ProcessTimer.js";
+import { InternalToken } from "../domain/InternalToken.js";
+const INTERNAL_HEADER = "x-webiny-background-task-token";
+class BackgroundTaskRouteImpl {
+    constructor(container, internalToken){
+        this.container = container;
+        this.internalToken = internalToken;
+    }
+    async handle(request, response) {
+        if (request.headers[INTERNAL_HEADER] !== this.internalToken.value) return response.status(403).json({
+            error: "Forbidden."
+        });
+        const taskEvent = request.body;
+        if (!taskEvent || !taskEvent.webinyTaskId) return response.status(400).json({
+            error: "Missing webinyTaskId in request body."
+        });
+        try {
+            if (taskEvent.tenant) {
+                this.container.resolve(RawTenantId).set(taskEvent.tenant);
+                await this.container.resolve(RequestTenantLoader).establish();
+            }
+            const ctx = {
+                container: this.container
+            };
+            const timer = new ProcessTimer();
+            const runner = new TaskRunner(ctx, timer, new TaskEventValidation());
+            const result = await runner.run(taskEvent);
+            return response.json(result);
+        } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`Background task route error: ${message}`);
+            return response.status(500).json({
+                status: "error",
+                error: {
+                    message
+                }
+            });
+        }
+    }
+}
+const BackgroundTaskRoute = HttpRouteHandler.createImplementation({
+    implementation: BackgroundTaskRouteImpl,
+    dependencies: [
+        RequestContainer,
+        InternalToken
+    ]
+});
+class BackgroundTaskRouteDefinitionImpl {
+    constructor(){
+        this.name = "background-task";
+        this.method = "POST";
+        this.path = "/background-task";
+        this.handler = BackgroundTaskRoute;
+    }
+}
+const BackgroundTaskRouteDefinition = HttpRouteDefinition.createImplementation({
+    implementation: BackgroundTaskRouteDefinitionImpl,
+    dependencies: []
+});
+export { BackgroundTaskRoute, BackgroundTaskRouteDefinition };
+
+//# sourceMappingURL=BackgroundTaskRoute.js.map

package/routes/BackgroundTaskRoute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes/BackgroundTaskRoute.js","sources":["../../src/routes/BackgroundTaskRoute.ts"],"sourcesContent":["import {\n    HttpRouteDefinition,\n    HttpRouteHandler,\n    RequestContainer\n} from \"@webiny/event-handler-core\";\nimport {\n    RawTenantId,\n    RequestTenantLoader\n} from \"@webiny/api-core/features/requestContext/index.js\";\nimport { TaskRunner } from \"@webiny/background-tasks/api/runner/index.js\";\nimport { TaskEventValidation } from \"@webiny/background-tasks/api/runner/TaskEventValidation.js\";\nimport type { Context } from \"@webiny/background-tasks/api/types.js\";\nimport type { Container } from \"@webiny/feature/api\";\nimport { ProcessTimer } from \"~/timer/ProcessTimer.js\";\nimport { InternalToken } from \"~/domain/InternalToken.js\";\n\n/* Shared between worker and route to gate access. */\nconst INTERNAL_HEADER = \"x-webiny-background-task-token\";\n\nclass BackgroundTaskRouteImpl implements HttpRouteHandler.Interface {\n    public constructor(\n        private readonly container: Container,\n        private readonly internalToken: InternalToken.Interface\n    ) {}\n\n    public async handle(request: HttpRouteHandler.Request, response: HttpRouteHandler.Response) {\n        /* Reject requests without a matching internal token. */\n        if (request.headers[INTERNAL_HEADER] !== this.internalToken.value) {\n            return response.status(403).json({ error: \"Forbidden.\" });\n        }\n\n        const taskEvent = request.body;\n\n        if (!taskEvent || !taskEvent.webinyTaskId) {\n            return response.status(400).json({ error: \"Missing webinyTaskId in request body.\" });\n        }\n\n        try {\n            if (taskEvent.tenant) {\n                this.container.resolve(RawTenantId).set(taskEvent.tenant);\n                await this.container.resolve(RequestTenantLoader).establish();\n            }\n\n            // TaskRunner still takes the legacy context object, which now only carries the container.\n            const ctx: Record<string, any> = { container: this.container };\n\n            const timer = new ProcessTimer();\n            const runner = new TaskRunner(ctx as Context, timer, new TaskEventValidation());\n            const result = await runner.run(taskEvent);\n\n            return response.json(result);\n        } catch (err) {\n            const message = err instanceof Error ? err.message : String(err);\n            console.error(`Background task route error: ${message}`);\n            return response.status(500).json({ status: \"error\", error: { message } });\n        }\n    }\n}\n\nexport const BackgroundTaskRoute = HttpRouteHandler.createImplementation({\n    implementation: BackgroundTaskRouteImpl,\n    dependencies: [RequestContainer, InternalToken]\n});\n\nclass BackgroundTaskRouteDefinitionImpl implements HttpRouteDefinition.Interface {\n    readonly name = \"background-task\";\n    readonly method = \"POST\";\n    readonly path = \"/background-task\";\n    readonly handler = BackgroundTaskRoute;\n}\n\n/** What the router matches on. Zero dependencies, so building it costs nothing. */\nexport const BackgroundTaskRouteDefinition = HttpRouteDefinition.createImplementation({\n    implementation: BackgroundTaskRouteDefinitionImpl,\n    dependencies: []\n});\n"],"names":["INTERNAL_HEADER","BackgroundTaskRouteImpl","container","internalToken","request","response","taskEvent","RawTenantId","RequestTenantLoader","ctx","timer","ProcessTimer","runner","TaskRunner","TaskEventValidation","result","err","message","Error","String","console","BackgroundTaskRoute","HttpRouteHandler","RequestContainer","InternalToken","BackgroundTaskRouteDefinitionImpl","BackgroundTaskRouteDefinition","HttpRouteDefinition"],"mappings":";;;;;;AAiBA,MAAMA,kBAAkB;AAExB,MAAMC;IACF,YACqBC,SAAoB,EACpBC,aAAsC,CACzD;aAFmBD,SAAS,GAATA;aACAC,aAAa,GAAbA;IAClB;IAEH,MAAa,OAAOC,OAAiC,EAAEC,QAAmC,EAAE;QAExF,IAAID,QAAQ,OAAO,CAACJ,gBAAgB,KAAK,IAAI,CAAC,aAAa,CAAC,KAAK,EAC7D,OAAOK,SAAS,MAAM,CAAC,KAAK,IAAI,CAAC;YAAE,OAAO;QAAa;QAG3D,MAAMC,YAAYF,QAAQ,IAAI;QAE9B,IAAI,CAACE,aAAa,CAACA,UAAU,YAAY,EACrC,OAAOD,SAAS,MAAM,CAAC,KAAK,IAAI,CAAC;YAAE,OAAO;QAAwC;QAGtF,IAAI;YACA,IAAIC,UAAU,MAAM,EAAE;gBAClB,IAAI,CAAC,SAAS,CAAC,OAAO,CAACC,aAAa,GAAG,CAACD,UAAU,MAAM;gBACxD,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACE,qBAAqB,SAAS;YAC/D;YAGA,MAAMC,MAA2B;gBAAE,WAAW,IAAI,CAAC,SAAS;YAAC;YAE7D,MAAMC,QAAQ,IAAIC;YAClB,MAAMC,SAAS,IAAIC,WAAWJ,KAAgBC,OAAO,IAAII;YACzD,MAAMC,SAAS,MAAMH,OAAO,GAAG,CAACN;YAEhC,OAAOD,SAAS,IAAI,CAACU;QACzB,EAAE,OAAOC,KAAK;YACV,MAAMC,UAAUD,eAAeE,QAAQF,IAAI,OAAO,GAAGG,OAAOH;YAC5DI,QAAQ,KAAK,CAAC,CAAC,6BAA6B,EAAEH,SAAS;YACvD,OAAOZ,SAAS,MAAM,CAAC,KAAK,IAAI,CAAC;gBAAE,QAAQ;gBAAS,OAAO;oBAAEY;gBAAQ;YAAE;QAC3E;IACJ;AACJ;AAEO,MAAMI,sBAAsBC,iBAAiB,oBAAoB,CAAC;IACrE,gBAAgBrB;IAChB,cAAc;QAACsB;QAAkBC;KAAc;AACnD;AAEA,MAAMC;;aACO,IAAI,GAAG;aACP,MAAM,GAAG;aACT,IAAI,GAAG;aACP,OAAO,GAAGJ;;AACvB;AAGO,MAAMK,gCAAgCC,oBAAoB,oBAAoB,CAAC;IAClF,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

package/service/WorkerTaskService.d.ts

@@ -0,0 +1,16 @@
+import { TaskService } from "@webiny/background-tasks/api/domain/TaskService.js";
+import { TenantContext } from "@webiny/api-core/exports/api/tenancy.js";
+import { InternalToken } from "../domain/InternalToken.js";
+declare class WorkerServiceImpl implements TaskService.Interface {
+    private readonly tenantContext;
+    private readonly internalToken;
+    private readonly serverUrl;
+    private readonly handles;
+    constructor(tenantContext: TenantContext.Interface, internalToken: InternalToken.Interface);
+    send(task: TaskService.SendTaskParams, delay: number): Promise<unknown>;
+    fetch(task: TaskService.Task): Promise<Record<string, unknown> | null>;
+}
+export declare const WorkerService: typeof WorkerServiceImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/background-tasks/api/domain/TaskService.js").ITaskService>;
+};
+export {};

package/service/WorkerTaskService.js

@@ -0,0 +1,87 @@
+import { Worker } from "node:worker_threads";
+import { TaskService } from "@webiny/background-tasks/api/domain/TaskService.js";
+import { TenantContext } from "@webiny/api-core/exports/api/tenancy.js";
+import { InternalToken } from "../domain/InternalToken.js";
+const DEFAULT_SERVER_PORT = 3002;
+const DEFAULT_MAX_DURATION_MS = 86400000;
+class WorkerServiceImpl {
+    constructor(tenantContext, internalToken){
+        this.tenantContext = tenantContext;
+        this.internalToken = internalToken;
+        this.handles = new Map();
+        const port = process.env.PORT || DEFAULT_SERVER_PORT;
+        this.serverUrl = `http://localhost:${port}/background-task`;
+    }
+    async send(task, delay) {
+        const tenant = this.tenantContext.getTenant();
+        if (!tenant) {
+            console.error("Tenant not found.");
+            return null;
+        }
+        const worker = new Worker(new URL("../worker/workerEntry.js", import.meta.url));
+        const handle = {
+            worker,
+            startedAt: Date.now(),
+            taskId: task.id,
+            status: "running",
+            exitCode: null
+        };
+        this.handles.set(task.id, handle);
+        worker.on("message", (msg)=>{
+            if ("done" === msg.type) handle.status = "done";
+            else if ("error" === msg.type) {
+                handle.status = "error";
+                console.error(`Background task "${task.id}" (${task.definitionId}) failed:`, msg.error);
+            }
+        });
+        worker.on("error", (err)=>{
+            handle.status = "error";
+            console.error(`Worker error for task "${task.id}": ${err.message}`);
+        });
+        worker.on("exit", (code)=>{
+            handle.exitCode = code;
+            if ("running" === handle.status) handle.status = 0 === code ? "done" : "error";
+            setTimeout(()=>{
+                this.handles.delete(task.id);
+            }, 60000);
+        });
+        worker.postMessage({
+            type: "start",
+            taskEvent: {
+                webinyTaskId: task.id,
+                webinyTaskDefinitionId: task.definitionId,
+                tenant: tenant.id,
+                delay,
+                endpoint: this.serverUrl,
+                executionName: task.id,
+                stateMachineId: ""
+            },
+            serverUrl: this.serverUrl,
+            maxDurationMs: DEFAULT_MAX_DURATION_MS,
+            internalToken: this.internalToken.value
+        });
+        return {
+            workerId: worker.threadId,
+            taskId: task.id
+        };
+    }
+    async fetch(task) {
+        const handle = this.handles.get(task.id);
+        if (!handle) return null;
+        return {
+            status: handle.status,
+            startedAt: handle.startedAt,
+            exitCode: handle.exitCode
+        };
+    }
+}
+const WorkerService = TaskService.createImplementation({
+    implementation: WorkerServiceImpl,
+    dependencies: [
+        TenantContext,
+        InternalToken
+    ]
+});
+export { WorkerService };
+
+//# sourceMappingURL=WorkerTaskService.js.map

package/service/WorkerTaskService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service/WorkerTaskService.js","sources":["../../src/service/WorkerTaskService.ts"],"sourcesContent":["import { Worker } from \"node:worker_threads\";\nimport type { WorkerToParentMessage } from \"~/worker/TaskOrchestratorMessage.js\";\nimport { TaskService } from \"@webiny/background-tasks/api/domain/TaskService.js\";\nimport { TenantContext } from \"@webiny/api-core/exports/api/tenancy.js\";\nimport { InternalToken } from \"~/domain/InternalToken.js\";\n\n// Matches findFreePort's search base in spawnApiServer (and the scheduler's self-callback default), so\n// every self-callback in the standalone hosting type agrees on the same fallback. In practice never used:\n// spawnApiServer always injects the resolved port as process.env.PORT.\nconst DEFAULT_SERVER_PORT = 3002;\nconst DEFAULT_MAX_DURATION_MS = 86_400_000;\n\ninterface WorkerHandle {\n    readonly worker: Worker;\n    readonly startedAt: number;\n    readonly taskId: string;\n    status: \"running\" | \"done\" | \"error\";\n    exitCode: number | null;\n}\n\nclass WorkerServiceImpl implements TaskService.Interface {\n    private readonly serverUrl: string;\n    private readonly handles: Map<string, WorkerHandle> = new Map();\n\n    public constructor(\n        private readonly tenantContext: TenantContext.Interface,\n        private readonly internalToken: InternalToken.Interface\n    ) {\n        // Single-process standalone hosting type: the worker POSTs the task back to THIS server's\n        // `/background-task` route. The port is the one the server actually listens on — injected at\n        // runtime as `process.env.PORT` by `spawnApiServer` (dynamic, chosen via findFreePort), NOT a\n        // build-time value. It cannot be a build param: the port isn't known until the process starts.\n        const port = process.env.PORT || DEFAULT_SERVER_PORT;\n        this.serverUrl = `http://localhost:${port}/background-task`;\n    }\n\n    public async send(task: TaskService.SendTaskParams, delay: number): Promise<unknown> {\n        const tenant = this.tenantContext.getTenant();\n        if (!tenant) {\n            console.error(\"Tenant not found.\");\n            return null;\n        }\n\n        // Resolved relative to this module (import.meta.url), not the process cwd, so it works no\n        // matter where the server is launched. The app bundler recognizes this exact shape and emits\n        // the worker as its own chunk into build/ (the server build sets assetPrefix \"auto\" so the\n        // chunk URL resolves relative to the running handler — see createRsbuildConfig). Un-bundled\n        // (dev), import.meta.url is the real dist file and this resolves to dist/worker/workerEntry.js.\n        const worker = new Worker(new URL(\"../worker/workerEntry.js\", import.meta.url));\n\n        const handle: WorkerHandle = {\n            worker,\n            startedAt: Date.now(),\n            taskId: task.id,\n            status: \"running\",\n            exitCode: null\n        };\n\n        this.handles.set(task.id, handle);\n\n        worker.on(\"message\", (msg: WorkerToParentMessage) => {\n            if (msg.type === \"done\") {\n                handle.status = \"done\";\n            } else if (msg.type === \"error\") {\n                handle.status = \"error\";\n                // Surface the worker's error — otherwise a failed task shows only as a stuck record.\n                console.error(\n                    `Background task \"${task.id}\" (${task.definitionId}) failed:`,\n                    msg.error\n                );\n            }\n        });\n\n        worker.on(\"error\", (err: Error) => {\n            handle.status = \"error\";\n            console.error(`Worker error for task \"${task.id}\": ${err.message}`);\n        });\n\n        worker.on(\"exit\", (code: number) => {\n            handle.exitCode = code;\n            if (handle.status === \"running\") {\n                handle.status = code === 0 ? \"done\" : \"error\";\n            }\n            /* Clean up handle after 60s to allow pending fetch() calls. */\n            setTimeout(() => {\n                this.handles.delete(task.id);\n            }, 60_000);\n        });\n\n        worker.postMessage({\n            type: \"start\",\n            taskEvent: {\n                webinyTaskId: task.id,\n                webinyTaskDefinitionId: task.definitionId,\n                tenant: tenant.id,\n                delay,\n                // Satisfy the shared runner's AWS-Step-Functions-shaped validation. No SFN in a single\n                // process: executionName is a stable run id (the task id); endpoint/stateMachineId are\n                // validate-only off-AWS.\n                endpoint: this.serverUrl,\n                executionName: task.id,\n                stateMachineId: \"\"\n            },\n            serverUrl: this.serverUrl,\n            maxDurationMs: DEFAULT_MAX_DURATION_MS,\n            internalToken: this.internalToken.value\n        });\n\n        return { workerId: worker.threadId, taskId: task.id };\n    }\n\n    public async fetch(task: TaskService.Task): Promise<Record<string, unknown> | null> {\n        const handle = this.handles.get(task.id);\n        if (!handle) {\n            return null;\n        }\n\n        return {\n            status: handle.status,\n            startedAt: handle.startedAt,\n            exitCode: handle.exitCode\n        };\n    }\n}\n\nexport const WorkerService = TaskService.createImplementation({\n    implementation: WorkerServiceImpl,\n    dependencies: [TenantContext, InternalToken]\n});\n"],"names":["DEFAULT_SERVER_PORT","DEFAULT_MAX_DURATION_MS","WorkerServiceImpl","tenantContext","internalToken","Map","port","process","task","delay","tenant","console","worker","Worker","URL","handle","Date","msg","err","code","setTimeout","WorkerService","TaskService","TenantContext","InternalToken"],"mappings":";;;;AASA,MAAMA,sBAAsB;AAC5B,MAAMC,0BAA0B;AAUhC,MAAMC;IAIF,YACqBC,aAAsC,EACtCC,aAAsC,CACzD;aAFmBD,aAAa,GAAbA;aACAC,aAAa,GAAbA;aAJJ,OAAO,GAA8B,IAAIC;QAUtD,MAAMC,OAAOC,QAAQ,GAAG,CAAC,IAAI,IAAIP;QACjC,IAAI,CAAC,SAAS,GAAG,CAAC,iBAAiB,EAAEM,KAAK,gBAAgB,CAAC;IAC/D;IAEA,MAAa,KAAKE,IAAgC,EAAEC,KAAa,EAAoB;QACjF,MAAMC,SAAS,IAAI,CAAC,aAAa,CAAC,SAAS;QAC3C,IAAI,CAACA,QAAQ;YACTC,QAAQ,KAAK,CAAC;YACd,OAAO;QACX;QAOA,MAAMC,SAAS,IAAIC,OAAO,IAAIC,IAAI,4BAA4B,YAAY,GAAG;QAE7E,MAAMC,SAAuB;YACzBH;YACA,WAAWI,KAAK,GAAG;YACnB,QAAQR,KAAK,EAAE;YACf,QAAQ;YACR,UAAU;QACd;QAEA,IAAI,CAAC,OAAO,CAAC,GAAG,CAACA,KAAK,EAAE,EAAEO;QAE1BH,OAAO,EAAE,CAAC,WAAW,CAACK;YAClB,IAAIA,AAAa,WAAbA,IAAI,IAAI,EACRF,OAAO,MAAM,GAAG;iBACb,IAAIE,AAAa,YAAbA,IAAI,IAAI,EAAc;gBAC7BF,OAAO,MAAM,GAAG;gBAEhBJ,QAAQ,KAAK,CACT,CAAC,iBAAiB,EAAEH,KAAK,EAAE,CAAC,GAAG,EAAEA,KAAK,YAAY,CAAC,SAAS,CAAC,EAC7DS,IAAI,KAAK;YAEjB;QACJ;QAEAL,OAAO,EAAE,CAAC,SAAS,CAACM;YAChBH,OAAO,MAAM,GAAG;YAChBJ,QAAQ,KAAK,CAAC,CAAC,uBAAuB,EAAEH,KAAK,EAAE,CAAC,GAAG,EAAEU,IAAI,OAAO,EAAE;QACtE;QAEAN,OAAO,EAAE,CAAC,QAAQ,CAACO;YACfJ,OAAO,QAAQ,GAAGI;YAClB,IAAIJ,AAAkB,cAAlBA,OAAO,MAAM,EACbA,OAAO,MAAM,GAAGI,AAAS,MAATA,OAAa,SAAS;YAG1CC,WAAW;gBACP,IAAI,CAAC,OAAO,CAAC,MAAM,CAACZ,KAAK,EAAE;YAC/B,GAAG;QACP;QAEAI,OAAO,WAAW,CAAC;YACf,MAAM;YACN,WAAW;gBACP,cAAcJ,KAAK,EAAE;gBACrB,wBAAwBA,KAAK,YAAY;gBACzC,QAAQE,OAAO,EAAE;gBACjBD;gBAIA,UAAU,IAAI,CAAC,SAAS;gBACxB,eAAeD,KAAK,EAAE;gBACtB,gBAAgB;YACpB;YACA,WAAW,IAAI,CAAC,SAAS;YACzB,eAAeP;YACf,eAAe,IAAI,CAAC,aAAa,CAAC,KAAK;QAC3C;QAEA,OAAO;YAAE,UAAUW,OAAO,QAAQ;YAAE,QAAQJ,KAAK,EAAE;QAAC;IACxD;IAEA,MAAa,MAAMA,IAAsB,EAA2C;QAChF,MAAMO,SAAS,IAAI,CAAC,OAAO,CAAC,GAAG,CAACP,KAAK,EAAE;QACvC,IAAI,CAACO,QACD,OAAO;QAGX,OAAO;YACH,QAAQA,OAAO,MAAM;YACrB,WAAWA,OAAO,SAAS;YAC3B,UAAUA,OAAO,QAAQ;QAC7B;IACJ;AACJ;AAEO,MAAMM,gBAAgBC,YAAY,oBAAoB,CAAC;IAC1D,gBAAgBpB;IAChB,cAAc;QAACqB;QAAeC;KAAc;AAChD"}

package/worker/TaskOrchestrator.d.ts

@@ -0,0 +1,12 @@
+import type { StartMessage, WorkerToParentMessage } from "./TaskOrchestratorMessage.js";
+export declare class TaskOrchestrator {
+    private readonly serverUrl;
+    private readonly taskEvent;
+    private readonly timer;
+    private readonly internalToken;
+    private readonly postMessage;
+    constructor(message: StartMessage, postMessage: (msg: WorkerToParentMessage) => void);
+    run(): Promise<void>;
+    private post;
+    private wait;
+}

package/worker/TaskOrchestrator.js

@@ -0,0 +1,120 @@
+import node_http from "node:http";
+import { ProcessTimer } from "../timer/ProcessTimer.js";
+class TaskOrchestrator {
+    constructor(message, postMessage){
+        this.serverUrl = message.serverUrl;
+        this.taskEvent = message.taskEvent;
+        this.timer = new ProcessTimer(message.maxDurationMs);
+        this.internalToken = message.internalToken;
+        this.postMessage = postMessage;
+    }
+    async run() {
+        const taskId = this.taskEvent.webinyTaskId;
+        try {
+            if (this.taskEvent.delay > 0) await this.wait(1000 * this.taskEvent.delay);
+            let input = {};
+            let continueLoop = true;
+            while(continueLoop){
+                if (this.timer.getRemainingMilliseconds() <= 0) return void this.postMessage({
+                    type: "error",
+                    taskId,
+                    error: "Task exceeded maximum duration."
+                });
+                const payload = {
+                    ...this.taskEvent,
+                    input
+                };
+                const response = await this.post(payload);
+                switch(response.status){
+                    case "continue":
+                        input = response.input || {};
+                        if (response.wait && response.wait > 0) await this.wait(1000 * response.wait);
+                        break;
+                    case "done":
+                        this.postMessage({
+                            type: "done",
+                            taskId,
+                            result: response
+                        });
+                        continueLoop = false;
+                        break;
+                    case "error":
+                        this.postMessage({
+                            type: "error",
+                            taskId,
+                            error: JSON.stringify(response)
+                        });
+                        continueLoop = false;
+                        break;
+                    default:
+                        this.postMessage({
+                            type: "error",
+                            taskId,
+                            error: `Unknown response status: ${response.status}`
+                        });
+                        continueLoop = false;
+                        break;
+                }
+            }
+        } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.postMessage({
+                type: "error",
+                taskId,
+                error: message
+            });
+        }
+    }
+    post(payload) {
+        return new Promise((resolve, reject)=>{
+            const url = new URL(this.serverUrl);
+            const body = JSON.stringify(payload);
+            const remaining = this.timer.getRemainingMilliseconds();
+            let deadline;
+            const fail = (error)=>{
+                clearTimeout(deadline);
+                reject(error);
+            };
+            const req = node_http.request({
+                hostname: url.hostname,
+                port: url.port,
+                path: url.pathname,
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    "content-length": Buffer.byteLength(body),
+                    "x-webiny-background-task-token": this.internalToken
+                }
+            }, (res)=>{
+                let data = "";
+                res.on("data", (chunk)=>{
+                    data += chunk;
+                });
+                res.on("error", fail);
+                res.on("end", ()=>{
+                    clearTimeout(deadline);
+                    if (!res.statusCode || res.statusCode < 200 || res.statusCode >= 300) return void reject(new Error(`HTTP ${res.statusCode}: ${data}`));
+                    try {
+                        resolve(JSON.parse(data));
+                    } catch  {
+                        reject(new Error(`Invalid JSON response: ${data}`));
+                    }
+                });
+            });
+            deadline = setTimeout(()=>{
+                const exceeded = new Error("Task exceeded maximum duration.");
+                req.destroy(exceeded);
+                fail(exceeded);
+            }, remaining);
+            req.on("error", fail);
+            req.write(body);
+            req.end();
+        });
+    }
+    wait(ms) {
+        return new Promise((resolve)=>setTimeout(resolve, ms));
+    }
+}
+export { TaskOrchestrator };
+
+//# sourceMappingURL=TaskOrchestrator.js.map

package/worker/TaskOrchestrator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker/TaskOrchestrator.js","sources":["../../src/worker/TaskOrchestrator.ts"],"sourcesContent":["import http from \"node:http\";\nimport type { Timer } from \"@webiny/utils/features/Timer/abstraction.js\";\nimport type { StartMessage, WorkerToParentMessage } from \"./TaskOrchestratorMessage.js\";\nimport { ProcessTimer } from \"~/timer/ProcessTimer.js\";\n\ninterface TaskResponse {\n    status: string;\n    input?: Record<string, unknown>;\n    wait?: number;\n    [key: string]: unknown;\n}\n\n/* Dumb HTTP client loop. It posts the task event to the running server's background-task\n * endpoint, then continues, exits, or errors based on the response status. ProcessTimer is the\n * safety net for the worker's maximum allowed duration. */\nexport class TaskOrchestrator {\n    private readonly serverUrl: string;\n    private readonly taskEvent: StartMessage[\"taskEvent\"];\n    private readonly timer: Timer.Interface;\n    private readonly internalToken: string;\n    private readonly postMessage: (msg: WorkerToParentMessage) => void;\n\n    public constructor(message: StartMessage, postMessage: (msg: WorkerToParentMessage) => void) {\n        this.serverUrl = message.serverUrl;\n        this.taskEvent = message.taskEvent;\n        this.timer = new ProcessTimer(message.maxDurationMs);\n        this.internalToken = message.internalToken;\n        this.postMessage = postMessage;\n    }\n\n    public async run(): Promise<void> {\n        const taskId = this.taskEvent.webinyTaskId;\n\n        try {\n            if (this.taskEvent.delay > 0) {\n                await this.wait(this.taskEvent.delay * 1000);\n            }\n\n            let input: Record<string, unknown> = {};\n            let continueLoop = true;\n\n            while (continueLoop) {\n                if (this.timer.getRemainingMilliseconds() <= 0) {\n                    this.postMessage({\n                        type: \"error\",\n                        taskId,\n                        error: \"Task exceeded maximum duration.\"\n                    });\n                    return;\n                }\n\n                const payload = {\n                    ...this.taskEvent,\n                    input\n                };\n\n                const response = await this.post(payload);\n\n                switch (response.status) {\n                    case \"continue\": {\n                        input = response.input || {};\n                        if (response.wait && response.wait > 0) {\n                            await this.wait(response.wait * 1000);\n                        }\n                        break;\n                    }\n                    case \"done\": {\n                        this.postMessage({ type: \"done\", taskId, result: response });\n                        continueLoop = false;\n                        break;\n                    }\n                    case \"error\": {\n                        this.postMessage({\n                            type: \"error\",\n                            taskId,\n                            error: JSON.stringify(response)\n                        });\n                        continueLoop = false;\n                        break;\n                    }\n                    default: {\n                        this.postMessage({\n                            type: \"error\",\n                            taskId,\n                            error: `Unknown response status: ${response.status}`\n                        });\n                        continueLoop = false;\n                        break;\n                    }\n                }\n            }\n        } catch (err) {\n            const message = err instanceof Error ? err.message : String(err);\n            this.postMessage({ type: \"error\", taskId, error: message });\n        }\n    }\n\n    private post(payload: Record<string, unknown>): Promise<TaskResponse> {\n        return new Promise((resolve, reject) => {\n            const url = new URL(this.serverUrl);\n            const body = JSON.stringify(payload);\n\n            /*\n             * The server answers only once the iteration finishes, so this is how long one iteration\n             * may take. It used to be a fixed 60s, well short of the task's own budget: an AI call\n             * that retried through a provider overload failed the task for running a little over a\n             * minute. Bounded by what is left of the budget instead.\n             *\n             * A deadline, not the request's `timeout` option. That one only measures silence and\n             * restarts on every chunk, so a response trickling in could outlive the budget and still\n             * come back as `done`.\n             */\n            const remaining = this.timer.getRemainingMilliseconds();\n            let deadline: NodeJS.Timeout | undefined;\n\n            const fail = (error: Error) => {\n                clearTimeout(deadline);\n                reject(error);\n            };\n\n            const req = http.request(\n                {\n                    hostname: url.hostname,\n                    port: url.port,\n                    path: url.pathname,\n                    method: \"POST\",\n                    headers: {\n                        \"content-type\": \"application/json\",\n                        \"content-length\": Buffer.byteLength(body),\n                        \"x-webiny-background-task-token\": this.internalToken\n                    }\n                },\n                res => {\n                    let data = \"\";\n                    res.on(\"data\", chunk => {\n                        data += chunk;\n                    });\n                    // Where a deadline that fires mid-response surfaces.\n                    res.on(\"error\", fail);\n                    res.on(\"end\", () => {\n                        clearTimeout(deadline);\n                        if (!res.statusCode || res.statusCode < 200 || res.statusCode >= 300) {\n                            reject(new Error(`HTTP ${res.statusCode}: ${data}`));\n                            return;\n                        }\n                        try {\n                            resolve(JSON.parse(data) as TaskResponse);\n                        } catch {\n                            reject(new Error(`Invalid JSON response: ${data}`));\n                        }\n                    });\n                }\n            );\n\n            deadline = setTimeout(() => {\n                const exceeded = new Error(\"Task exceeded maximum duration.\");\n                req.destroy(exceeded);\n                fail(exceeded);\n            }, remaining);\n\n            req.on(\"error\", fail);\n            req.write(body);\n            req.end();\n        });\n    }\n\n    private wait(ms: number): Promise<void> {\n        return new Promise(resolve => setTimeout(resolve, ms));\n    }\n}\n"],"names":["TaskOrchestrator","message","postMessage","ProcessTimer","taskId","input","continueLoop","payload","response","JSON","err","Error","String","Promise","resolve","reject","url","URL","body","remaining","deadline","fail","error","clearTimeout","req","http","Buffer","res","data","chunk","setTimeout","exceeded","ms"],"mappings":";;AAeO,MAAMA;IAOT,YAAmBC,OAAqB,EAAEC,WAAiD,CAAE;QACzF,IAAI,CAAC,SAAS,GAAGD,QAAQ,SAAS;QAClC,IAAI,CAAC,SAAS,GAAGA,QAAQ,SAAS;QAClC,IAAI,CAAC,KAAK,GAAG,IAAIE,aAAaF,QAAQ,aAAa;QACnD,IAAI,CAAC,aAAa,GAAGA,QAAQ,aAAa;QAC1C,IAAI,CAAC,WAAW,GAAGC;IACvB;IAEA,MAAa,MAAqB;QAC9B,MAAME,SAAS,IAAI,CAAC,SAAS,CAAC,YAAY;QAE1C,IAAI;YACA,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,GAAG,GACvB,MAAM,IAAI,CAAC,IAAI,CAAC,AAAuB,OAAvB,IAAI,CAAC,SAAS,CAAC,KAAK;YAGxC,IAAIC,QAAiC,CAAC;YACtC,IAAIC,eAAe;YAEnB,MAAOA,aAAc;gBACjB,IAAI,IAAI,CAAC,KAAK,CAAC,wBAAwB,MAAM,GAAG,YAC5C,IAAI,CAAC,WAAW,CAAC;oBACb,MAAM;oBACNF;oBACA,OAAO;gBACX;gBAIJ,MAAMG,UAAU;oBACZ,GAAG,IAAI,CAAC,SAAS;oBACjBF;gBACJ;gBAEA,MAAMG,WAAW,MAAM,IAAI,CAAC,IAAI,CAACD;gBAEjC,OAAQC,SAAS,MAAM;oBACnB,KAAK;wBACDH,QAAQG,SAAS,KAAK,IAAI,CAAC;wBAC3B,IAAIA,SAAS,IAAI,IAAIA,SAAS,IAAI,GAAG,GACjC,MAAM,IAAI,CAAC,IAAI,CAACA,AAAgB,OAAhBA,SAAS,IAAI;wBAEjC;oBAEJ,KAAK;wBACD,IAAI,CAAC,WAAW,CAAC;4BAAE,MAAM;4BAAQJ;4BAAQ,QAAQI;wBAAS;wBAC1DF,eAAe;wBACf;oBAEJ,KAAK;wBACD,IAAI,CAAC,WAAW,CAAC;4BACb,MAAM;4BACNF;4BACA,OAAOK,KAAK,SAAS,CAACD;wBAC1B;wBACAF,eAAe;wBACf;oBAEJ;wBACI,IAAI,CAAC,WAAW,CAAC;4BACb,MAAM;4BACNF;4BACA,OAAO,CAAC,yBAAyB,EAAEI,SAAS,MAAM,EAAE;wBACxD;wBACAF,eAAe;wBACf;gBAER;YACJ;QACJ,EAAE,OAAOI,KAAK;YACV,MAAMT,UAAUS,eAAeC,QAAQD,IAAI,OAAO,GAAGE,OAAOF;YAC5D,IAAI,CAAC,WAAW,CAAC;gBAAE,MAAM;gBAASN;gBAAQ,OAAOH;YAAQ;QAC7D;IACJ;IAEQ,KAAKM,OAAgC,EAAyB;QAClE,OAAO,IAAIM,QAAQ,CAACC,SAASC;YACzB,MAAMC,MAAM,IAAIC,IAAI,IAAI,CAAC,SAAS;YAClC,MAAMC,OAAOT,KAAK,SAAS,CAACF;YAY5B,MAAMY,YAAY,IAAI,CAAC,KAAK,CAAC,wBAAwB;YACrD,IAAIC;YAEJ,MAAMC,OAAO,CAACC;gBACVC,aAAaH;gBACbL,OAAOO;YACX;YAEA,MAAME,MAAMC,UAAAA,OAAY,CACpB;gBACI,UAAUT,IAAI,QAAQ;gBACtB,MAAMA,IAAI,IAAI;gBACd,MAAMA,IAAI,QAAQ;gBAClB,QAAQ;gBACR,SAAS;oBACL,gBAAgB;oBAChB,kBAAkBU,OAAO,UAAU,CAACR;oBACpC,kCAAkC,IAAI,CAAC,aAAa;gBACxD;YACJ,GACAS,CAAAA;gBACI,IAAIC,OAAO;gBACXD,IAAI,EAAE,CAAC,QAAQE,CAAAA;oBACXD,QAAQC;gBACZ;gBAEAF,IAAI,EAAE,CAAC,SAASN;gBAChBM,IAAI,EAAE,CAAC,OAAO;oBACVJ,aAAaH;oBACb,IAAI,CAACO,IAAI,UAAU,IAAIA,IAAI,UAAU,GAAG,OAAOA,IAAI,UAAU,IAAI,KAAK,YAClEZ,OAAO,IAAIJ,MAAM,CAAC,KAAK,EAAEgB,IAAI,UAAU,CAAC,EAAE,EAAEC,MAAM;oBAGtD,IAAI;wBACAd,QAAQL,KAAK,KAAK,CAACmB;oBACvB,EAAE,OAAM;wBACJb,OAAO,IAAIJ,MAAM,CAAC,uBAAuB,EAAEiB,MAAM;oBACrD;gBACJ;YACJ;YAGJR,WAAWU,WAAW;gBAClB,MAAMC,WAAW,IAAIpB,MAAM;gBAC3Ba,IAAI,OAAO,CAACO;gBACZV,KAAKU;YACT,GAAGZ;YAEHK,IAAI,EAAE,CAAC,SAASH;YAChBG,IAAI,KAAK,CAACN;YACVM,IAAI,GAAG;QACX;IACJ;IAEQ,KAAKQ,EAAU,EAAiB;QACpC,OAAO,IAAInB,QAAQC,CAAAA,UAAWgB,WAAWhB,SAASkB;IACtD;AACJ"}

package/worker/TaskOrchestratorMessage.d.ts

@@ -0,0 +1,28 @@
+export interface TaskEventPayload {
+    readonly webinyTaskId: string;
+    readonly webinyTaskDefinitionId: string;
+    readonly tenant: string;
+    readonly delay: number;
+    readonly endpoint: string;
+    readonly executionName: string;
+    readonly stateMachineId: string;
+}
+export interface StartMessage {
+    readonly type: "start";
+    readonly taskEvent: TaskEventPayload;
+    readonly serverUrl: string;
+    readonly maxDurationMs: number;
+    readonly internalToken: string;
+}
+export interface DoneMessage {
+    readonly type: "done";
+    readonly taskId: string;
+    readonly result: unknown;
+}
+export interface ErrorMessage {
+    readonly type: "error";
+    readonly taskId: string;
+    readonly error: string;
+}
+export type WorkerToParentMessage = DoneMessage | ErrorMessage;
+export type ParentToWorkerMessage = StartMessage;

package/worker/workerEntry.d.ts

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

package/worker/workerEntry.js

@@ -0,0 +1,12 @@
+import { parentPort } from "node:worker_threads";
+import { TaskOrchestrator } from "./TaskOrchestrator.js";
+if (!parentPort) throw new Error("workerEntry must be run inside a worker thread.");
+const port = parentPort;
+port.on("message", async (message)=>{
+    if ("start" !== message.type) return;
+    const orchestrator = new TaskOrchestrator(message, (msg)=>port.postMessage(msg));
+    await orchestrator.run();
+    process.exit(0);
+});
+
+//# sourceMappingURL=workerEntry.js.map

package/worker/workerEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker/workerEntry.js","sources":["../../src/worker/workerEntry.ts"],"sourcesContent":["import { parentPort } from \"node:worker_threads\";\nimport type { ParentToWorkerMessage } from \"./TaskOrchestratorMessage.js\";\nimport { TaskOrchestrator } from \"./TaskOrchestrator.js\";\n\nif (!parentPort) {\n    throw new Error(\"workerEntry must be run inside a worker thread.\");\n}\n\nconst port = parentPort;\n\nport.on(\"message\", async (message: ParentToWorkerMessage) => {\n    if (message.type !== \"start\") {\n        return;\n    }\n\n    const orchestrator = new TaskOrchestrator(message, msg => port.postMessage(msg));\n    await orchestrator.run();\n\n    process.exit(0);\n});\n"],"names":["parentPort","Error","port","message","orchestrator","TaskOrchestrator","msg","process"],"mappings":";;AAIA,IAAI,CAACA,YACD,MAAM,IAAIC,MAAM;AAGpB,MAAMC,OAAOF;AAEbE,KAAK,EAAE,CAAC,WAAW,OAAOC;IACtB,IAAIA,AAAiB,YAAjBA,QAAQ,IAAI,EACZ;IAGJ,MAAMC,eAAe,IAAIC,iBAAiBF,SAASG,CAAAA,MAAOJ,KAAK,WAAW,CAACI;IAC3E,MAAMF,aAAa,GAAG;IAEtBG,QAAQ,IAAI,CAAC;AACjB"}

package/domain/TaskLoop.d.ts

@@ -1,15 +0,0 @@
-import type { IBackgroundTaskEvent } from "@webiny/event-handler-core";
-/**
- * Drives a triggered task to completion inside this process: runs one iteration, waits as long as
- * the iteration asks, and runs the next until the task stops asking to continue. The standalone
- * counterpart of the Step Functions state machine that drives a task on AWS.
- *
- * `start` returns at once. The task runs after the request that triggered it has finished.
- */
-export interface ITaskLoop {
-    start(event: IBackgroundTaskEvent): void;
-}
-export declare const TaskLoop: import("@webiny/di").Abstraction<ITaskLoop>;
-export declare namespace TaskLoop {
-    type Interface = ITaskLoop;
-}

package/domain/TaskLoop.js

@@ -1,5 +0,0 @@
-import { createAbstraction } from "@webiny/feature/api";
-const TaskLoop = createAbstraction("BackgroundTasks/TaskLoop");
-export { TaskLoop };
-
-//# sourceMappingURL=TaskLoop.js.map

package/domain/TaskLoop.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"domain/TaskLoop.js","sources":["../../src/domain/TaskLoop.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IBackgroundTaskEvent } from \"@webiny/event-handler-core\";\n\n/**\n * Drives a triggered task to completion inside this process: runs one iteration, waits as long as\n * the iteration asks, and runs the next until the task stops asking to continue. The standalone\n * counterpart of the Step Functions state machine that drives a task on AWS.\n *\n * `start` returns at once. The task runs after the request that triggered it has finished.\n */\nexport interface ITaskLoop {\n    start(event: IBackgroundTaskEvent): void;\n}\n\nexport const TaskLoop = createAbstraction<ITaskLoop>(\"BackgroundTasks/TaskLoop\");\n\nexport namespace TaskLoop {\n    export type Interface = ITaskLoop;\n}\n"],"names":["TaskLoop","createAbstraction"],"mappings":";AAcO,MAAMA,WAAWC,kBAA6B"}

package/handlers/InProcessBackgroundTaskHandler.d.ts

@@ -1,22 +0,0 @@
-import type { Container } from "@webiny/feature/api";
-import { BackgroundTaskEventHandler } from "@webiny/event-handler-core";
-import type { EventContext } from "@webiny/event-handler-core";
-import type { IBackgroundTaskEvent } from "@webiny/event-handler-core";
-import { RawTenantId } from "@webiny/api-core/features/requestContext/index.js";
-import { RequestTenantLoader } from "@webiny/api-core/features/requestContext/index.js";
-/**
- * Runs one iteration of a background task in the request container the dispatcher built for it.
- * The standalone counterpart of `BackgroundTaskLambdaHandler`: same tenant set-up and runner, with
- * a process timer in place of the Lambda countdown.
- */
-declare class InProcessBackgroundTaskHandlerImpl implements BackgroundTaskEventHandler.Interface {
-    private readonly container;
-    private readonly rawTenantId;
-    private readonly tenantLoader;
-    constructor(container: Container, rawTenantId: RawTenantId.Interface, tenantLoader: RequestTenantLoader.Interface);
-    execute(eventCtx: EventContext<IBackgroundTaskEvent>): Promise<unknown>;
-}
-export declare const InProcessBackgroundTaskHandler: typeof InProcessBackgroundTaskHandlerImpl & {
-    __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-core/features/backgroundTask/BackgroundTaskEventHandler").IBackgroundTaskEventHandler>;
-};
-export {};

package/handlers/InProcessBackgroundTaskHandler.js

@@ -1,34 +0,0 @@
-import { BackgroundTaskEventHandler, RequestContainer } from "@webiny/event-handler-core";
-import { RawTenantId, RequestTenantLoader } from "@webiny/api-core/features/requestContext/index.js";
-import { TaskRunner } from "@webiny/background-tasks/api/runner/index.js";
-import { TaskEventValidation } from "@webiny/background-tasks/api/runner/TaskEventValidation.js";
-import { ProcessTimer } from "../timer/ProcessTimer.js";
-class InProcessBackgroundTaskHandlerImpl {
-    constructor(container, rawTenantId, tenantLoader){
-        this.container = container;
-        this.rawTenantId = rawTenantId;
-        this.tenantLoader = tenantLoader;
-    }
-    async execute(eventCtx) {
-        const taskEvent = eventCtx.event;
-        this.rawTenantId.set(taskEvent.tenant);
-        await this.tenantLoader.establish();
-        const ctx = {
-            container: this.container
-        };
-        const timer = new ProcessTimer();
-        const runner = new TaskRunner(ctx, timer, new TaskEventValidation());
-        return runner.run(taskEvent);
-    }
-}
-const InProcessBackgroundTaskHandler = BackgroundTaskEventHandler.createImplementation({
-    implementation: InProcessBackgroundTaskHandlerImpl,
-    dependencies: [
-        RequestContainer,
-        RawTenantId,
-        RequestTenantLoader
-    ]
-});
-export { InProcessBackgroundTaskHandler };
-
-//# sourceMappingURL=InProcessBackgroundTaskHandler.js.map

package/handlers/InProcessBackgroundTaskHandler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"handlers/InProcessBackgroundTaskHandler.js","sources":["../../src/handlers/InProcessBackgroundTaskHandler.ts"],"sourcesContent":["import type { Container } from \"@webiny/feature/api\";\nimport { BackgroundTaskEventHandler } from \"@webiny/event-handler-core\";\nimport { RequestContainer } from \"@webiny/event-handler-core\";\nimport type { EventContext } from \"@webiny/event-handler-core\";\nimport type { IBackgroundTaskEvent } from \"@webiny/event-handler-core\";\nimport { RawTenantId } from \"@webiny/api-core/features/requestContext/index.js\";\nimport { RequestTenantLoader } from \"@webiny/api-core/features/requestContext/index.js\";\nimport { TaskRunner } from \"@webiny/background-tasks/api/runner/index.js\";\nimport { TaskEventValidation } from \"@webiny/background-tasks/api/runner/TaskEventValidation.js\";\nimport type { Context } from \"@webiny/background-tasks/api/types.js\";\nimport { ProcessTimer } from \"~/timer/ProcessTimer.js\";\n\n/**\n * Runs one iteration of a background task in the request container the dispatcher built for it.\n * The standalone counterpart of `BackgroundTaskLambdaHandler`: same tenant set-up and runner, with\n * a process timer in place of the Lambda countdown.\n */\nclass InProcessBackgroundTaskHandlerImpl implements BackgroundTaskEventHandler.Interface {\n    public constructor(\n        private readonly container: Container,\n        private readonly rawTenantId: RawTenantId.Interface,\n        private readonly tenantLoader: RequestTenantLoader.Interface\n    ) {}\n\n    public async execute(eventCtx: EventContext<IBackgroundTaskEvent>): Promise<unknown> {\n        const taskEvent = eventCtx.event;\n\n        this.rawTenantId.set(taskEvent.tenant);\n        await this.tenantLoader.establish();\n\n        // TaskRunner still takes the legacy context object, which now only carries the container.\n        const ctx: Record<string, any> = { container: this.container };\n\n        const timer = new ProcessTimer();\n        const runner = new TaskRunner(ctx as Context, timer, new TaskEventValidation());\n\n        // The loop reads `status`, `wait` and `delay` from this to decide what happens next.\n        return runner.run(taskEvent);\n    }\n}\n\nexport const InProcessBackgroundTaskHandler = BackgroundTaskEventHandler.createImplementation({\n    implementation: InProcessBackgroundTaskHandlerImpl,\n    dependencies: [RequestContainer, RawTenantId, RequestTenantLoader]\n});\n"],"names":["InProcessBackgroundTaskHandlerImpl","container","rawTenantId","tenantLoader","eventCtx","taskEvent","ctx","timer","ProcessTimer","runner","TaskRunner","TaskEventValidation","InProcessBackgroundTaskHandler","BackgroundTaskEventHandler","RequestContainer","RawTenantId","RequestTenantLoader"],"mappings":";;;;;AAiBA,MAAMA;IACF,YACqBC,SAAoB,EACpBC,WAAkC,EAClCC,YAA2C,CAC9D;aAHmBF,SAAS,GAATA;aACAC,WAAW,GAAXA;aACAC,YAAY,GAAZA;IAClB;IAEH,MAAa,QAAQC,QAA4C,EAAoB;QACjF,MAAMC,YAAYD,SAAS,KAAK;QAEhC,IAAI,CAAC,WAAW,CAAC,GAAG,CAACC,UAAU,MAAM;QACrC,MAAM,IAAI,CAAC,YAAY,CAAC,SAAS;QAGjC,MAAMC,MAA2B;YAAE,WAAW,IAAI,CAAC,SAAS;QAAC;QAE7D,MAAMC,QAAQ,IAAIC;QAClB,MAAMC,SAAS,IAAIC,WAAWJ,KAAgBC,OAAO,IAAII;QAGzD,OAAOF,OAAO,GAAG,CAACJ;IACtB;AACJ;AAEO,MAAMO,iCAAiCC,2BAA2B,oBAAoB,CAAC;IAC1F,gBAAgBb;IAChB,cAAc;QAACc;QAAkBC;QAAaC;KAAoB;AACtE"}

package/loop/DispatchingTaskLoop.d.ts

@@ -1,17 +0,0 @@
-import { EventDispatcher } from "@webiny/event-handler-core";
-import type { IBackgroundTaskEvent } from "@webiny/event-handler-core";
-import { TaskLoop } from "../domain/TaskLoop.js";
-/**
- * Each iteration is one dispatched `BackgroundTaskEvent`, handled in a fresh request container like
- * an HTTP request would be. Root singleton: one loop drives every task in the process.
- */
-declare class DispatchingTaskLoopImpl implements TaskLoop.Interface {
-    private readonly dispatcher;
-    constructor(dispatcher: EventDispatcher.Interface);
-    start(event: IBackgroundTaskEvent): void;
-    private run;
-}
-export declare const DispatchingTaskLoop: typeof DispatchingTaskLoopImpl & {
-    __abstraction: import("@webiny/di").Abstraction<import("~/domain/TaskLoop.js").ITaskLoop>;
-};
-export {};

package/loop/DispatchingTaskLoop.js

@@ -1,48 +0,0 @@
-import { EventDispatcher } from "@webiny/event-handler-core";
-import { TaskLoop } from "../domain/TaskLoop.js";
-import { ProcessTimer } from "../timer/ProcessTimer.js";
-const MAX_TASK_DURATION_MS = 86400000;
-function sleep(ms) {
-    return new Promise((resolve)=>setTimeout(resolve, ms));
-}
-class DispatchingTaskLoopImpl {
-    constructor(dispatcher){
-        this.dispatcher = dispatcher;
-    }
-    start(event) {
-        this.run(event);
-    }
-    async run(firstEvent) {
-        const taskId = firstEvent.webinyTaskId;
-        const timer = new ProcessTimer(MAX_TASK_DURATION_MS);
-        let event = firstEvent;
-        while(timer.getRemainingMilliseconds() > 0){
-            let result;
-            try {
-                result = await this.dispatcher.dispatch(event);
-            } catch (error) {
-                console.error(`Background task "${taskId}" failed:`, error);
-                return;
-            }
-            const status = result?.status;
-            if ("done" === status || "aborted" === status) return;
-            if ("continue" !== status) return void console.error(`Background task "${taskId}" stopped with status "${status}":`, result);
-            event = {
-                ...event,
-                delay: result?.delay ?? -1
-            };
-            const wait = result?.wait ?? 0;
-            if (wait > 0) await sleep(1000 * wait);
-        }
-        console.error(`Background task "${taskId}" exceeded the maximum duration.`);
-    }
-}
-const DispatchingTaskLoop = TaskLoop.createImplementation({
-    implementation: DispatchingTaskLoopImpl,
-    dependencies: [
-        EventDispatcher
-    ]
-});
-export { DispatchingTaskLoop };
-
-//# sourceMappingURL=DispatchingTaskLoop.js.map

package/loop/DispatchingTaskLoop.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"loop/DispatchingTaskLoop.js","sources":["../../src/loop/DispatchingTaskLoop.ts"],"sourcesContent":["import { EventDispatcher } from \"@webiny/event-handler-core\";\nimport type { IBackgroundTaskEvent } from \"@webiny/event-handler-core\";\nimport { TaskLoop } from \"~/domain/TaskLoop.js\";\nimport { ProcessTimer } from \"~/timer/ProcessTimer.js\";\n\n// 24 hours, the most one task may run in total.\nconst MAX_TASK_DURATION_MS = 86_400_000;\n\n// What the runner answers for one iteration; only the fields the loop reads.\ninterface IIterationResult {\n    status?: string;\n    wait?: number;\n    delay?: number;\n}\n\nfunction sleep(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n}\n\n/**\n * Each iteration is one dispatched `BackgroundTaskEvent`, handled in a fresh request container like\n * an HTTP request would be. Root singleton: one loop drives every task in the process.\n */\nclass DispatchingTaskLoopImpl implements TaskLoop.Interface {\n    public constructor(private readonly dispatcher: EventDispatcher.Interface) {}\n\n    public start(event: IBackgroundTaskEvent): void {\n        void this.run(event);\n    }\n\n    private async run(firstEvent: IBackgroundTaskEvent): Promise<void> {\n        const taskId = firstEvent.webinyTaskId;\n        const timer = new ProcessTimer(MAX_TASK_DURATION_MS);\n        let event = firstEvent;\n\n        while (timer.getRemainingMilliseconds() > 0) {\n            let result: IIterationResult | undefined;\n            try {\n                result = await this.dispatcher.dispatch<IIterationResult>(event);\n            } catch (error) {\n                console.error(`Background task \"${taskId}\" failed:`, error);\n                return;\n            }\n\n            const status = result?.status;\n            if (status === \"done\" || status === \"aborted\") {\n                return;\n            }\n            if (status !== \"continue\") {\n                console.error(\n                    `Background task \"${taskId}\" stopped with status \"${status}\":`,\n                    result\n                );\n                return;\n            }\n\n            /*\n             * The first event carries the trigger's delay, and the runner answers it with `continue`\n             * and `wait: delay` without running anything. Every later event must carry the delay the\n             * runner sent back (-1), as the Step Functions state does on AWS. Resending the original\n             * delay would make the runner answer `continue` forever.\n             */\n            event = { ...event, delay: result?.delay ?? -1 };\n\n            const wait = result?.wait ?? 0;\n            if (wait > 0) {\n                await sleep(wait * 1000);\n            }\n        }\n\n        console.error(`Background task \"${taskId}\" exceeded the maximum duration.`);\n    }\n}\n\nexport const DispatchingTaskLoop = TaskLoop.createImplementation({\n    implementation: DispatchingTaskLoopImpl,\n    dependencies: [EventDispatcher]\n});\n"],"names":["MAX_TASK_DURATION_MS","sleep","ms","Promise","resolve","setTimeout","DispatchingTaskLoopImpl","dispatcher","event","firstEvent","taskId","timer","ProcessTimer","result","error","console","status","wait","DispatchingTaskLoop","TaskLoop","EventDispatcher"],"mappings":";;;AAMA,MAAMA,uBAAuB;AAS7B,SAASC,MAAMC,EAAU;IACrB,OAAO,IAAIC,QAAQC,CAAAA,UAAWC,WAAWD,SAASF;AACtD;AAMA,MAAMI;IACF,YAAoCC,UAAqC,CAAE;aAAvCA,UAAU,GAAVA;IAAwC;IAErE,MAAMC,KAA2B,EAAQ;QACvC,IAAI,CAAC,GAAG,CAACA;IAClB;IAEA,MAAc,IAAIC,UAAgC,EAAiB;QAC/D,MAAMC,SAASD,WAAW,YAAY;QACtC,MAAME,QAAQ,IAAIC,aAAaZ;QAC/B,IAAIQ,QAAQC;QAEZ,MAAOE,MAAM,wBAAwB,KAAK,EAAG;YACzC,IAAIE;YACJ,IAAI;gBACAA,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAmBL;YAC9D,EAAE,OAAOM,OAAO;gBACZC,QAAQ,KAAK,CAAC,CAAC,iBAAiB,EAAEL,OAAO,SAAS,CAAC,EAAEI;gBACrD;YACJ;YAEA,MAAME,SAASH,QAAQ;YACvB,IAAIG,AAAW,WAAXA,UAAqBA,AAAW,cAAXA,QACrB;YAEJ,IAAIA,AAAW,eAAXA,QAAuB,YACvBD,QAAQ,KAAK,CACT,CAAC,iBAAiB,EAAEL,OAAO,uBAAuB,EAAEM,OAAO,EAAE,CAAC,EAC9DH;YAWRL,QAAQ;gBAAE,GAAGA,KAAK;gBAAE,OAAOK,QAAQ,SAAS;YAAG;YAE/C,MAAMI,OAAOJ,QAAQ,QAAQ;YAC7B,IAAII,OAAO,GACP,MAAMhB,MAAMgB,AAAO,OAAPA;QAEpB;QAEAF,QAAQ,KAAK,CAAC,CAAC,iBAAiB,EAAEL,OAAO,gCAAgC,CAAC;IAC9E;AACJ;AAEO,MAAMQ,sBAAsBC,SAAS,oBAAoB,CAAC;IAC7D,gBAAgBb;IAChB,cAAc;QAACc;KAAgB;AACnC"}

package/service/InProcessTaskService.d.ts

@@ -1,19 +0,0 @@
-import { TaskService } from "@webiny/background-tasks/api/domain/TaskService.js";
-import { TenantContext } from "@webiny/api-core/exports/api/tenancy.js";
-import { TaskLoop } from "../domain/TaskLoop.js";
-/**
- * Starts a triggered task in this process. Builds the same event Step Functions would deliver on
- * AWS and hands it to the task loop. `endpoint`, `executionName` and `stateMachineId` only satisfy
- * the runner's event validation; nothing reads them off AWS.
- */
-declare class InProcessTaskServiceImpl implements TaskService.Interface {
-    private readonly tenantContext;
-    private readonly taskLoop;
-    constructor(tenantContext: TenantContext.Interface, taskLoop: TaskLoop.Interface);
-    send(task: TaskService.SendTaskParams, delay: number): Promise<unknown>;
-    fetch(): Promise<null>;
-}
-export declare const InProcessTaskService: typeof InProcessTaskServiceImpl & {
-    __abstraction: import("@webiny/di").Abstraction<import("@webiny/background-tasks/api/domain/TaskService.js").ITaskService>;
-};
-export {};

package/service/InProcessTaskService.js

@@ -1,39 +0,0 @@
-import { TaskService } from "@webiny/background-tasks/api/domain/TaskService.js";
-import { TenantContext } from "@webiny/api-core/exports/api/tenancy.js";
-import { TaskLoop } from "../domain/TaskLoop.js";
-class InProcessTaskServiceImpl {
-    constructor(tenantContext, taskLoop){
-        this.tenantContext = tenantContext;
-        this.taskLoop = taskLoop;
-    }
-    async send(task, delay) {
-        const tenant = this.tenantContext.getTenant();
-        if (!tenant) return null;
-        const event = {
-            webinyTaskId: task.id,
-            webinyTaskDefinitionId: task.definitionId,
-            tenant: tenant.id,
-            delay,
-            endpoint: "in-process",
-            executionName: task.id,
-            stateMachineId: ""
-        };
-        this.taskLoop.start(event);
-        return {
-            taskId: task.id
-        };
-    }
-    async fetch() {
-        return null;
-    }
-}
-const InProcessTaskService = TaskService.createImplementation({
-    implementation: InProcessTaskServiceImpl,
-    dependencies: [
-        TenantContext,
-        TaskLoop
-    ]
-});
-export { InProcessTaskService };
-
-//# sourceMappingURL=InProcessTaskService.js.map

package/service/InProcessTaskService.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"service/InProcessTaskService.js","sources":["../../src/service/InProcessTaskService.ts"],"sourcesContent":["import type { IBackgroundTaskEvent } from \"@webiny/event-handler-core\";\nimport { TaskService } from \"@webiny/background-tasks/api/domain/TaskService.js\";\nimport { TenantContext } from \"@webiny/api-core/exports/api/tenancy.js\";\nimport { TaskLoop } from \"~/domain/TaskLoop.js\";\n\n/**\n * Starts a triggered task in this process. Builds the same event Step Functions would deliver on\n * AWS and hands it to the task loop. `endpoint`, `executionName` and `stateMachineId` only satisfy\n * the runner's event validation; nothing reads them off AWS.\n */\nclass InProcessTaskServiceImpl implements TaskService.Interface {\n    public constructor(\n        private readonly tenantContext: TenantContext.Interface,\n        private readonly taskLoop: TaskLoop.Interface\n    ) {}\n\n    public async send(task: TaskService.SendTaskParams, delay: number): Promise<unknown> {\n        const tenant = this.tenantContext.getTenant();\n        if (!tenant) {\n            return null;\n        }\n\n        const event: IBackgroundTaskEvent = {\n            webinyTaskId: task.id,\n            webinyTaskDefinitionId: task.definitionId,\n            tenant: tenant.id,\n            delay,\n            endpoint: \"in-process\",\n            executionName: task.id,\n            stateMachineId: \"\"\n        };\n\n        this.taskLoop.start(event);\n\n        return { taskId: task.id };\n    }\n\n    public async fetch(): Promise<null> {\n        // A running task has no execution record outside the task itself.\n        return null;\n    }\n}\n\nexport const InProcessTaskService = TaskService.createImplementation({\n    implementation: InProcessTaskServiceImpl,\n    dependencies: [TenantContext, TaskLoop]\n});\n"],"names":["InProcessTaskServiceImpl","tenantContext","taskLoop","task","delay","tenant","event","InProcessTaskService","TaskService","TenantContext","TaskLoop"],"mappings":";;;AAUA,MAAMA;IACF,YACqBC,aAAsC,EACtCC,QAA4B,CAC/C;aAFmBD,aAAa,GAAbA;aACAC,QAAQ,GAARA;IAClB;IAEH,MAAa,KAAKC,IAAgC,EAAEC,KAAa,EAAoB;QACjF,MAAMC,SAAS,IAAI,CAAC,aAAa,CAAC,SAAS;QAC3C,IAAI,CAACA,QACD,OAAO;QAGX,MAAMC,QAA8B;YAChC,cAAcH,KAAK,EAAE;YACrB,wBAAwBA,KAAK,YAAY;YACzC,QAAQE,OAAO,EAAE;YACjBD;YACA,UAAU;YACV,eAAeD,KAAK,EAAE;YACtB,gBAAgB;QACpB;QAEA,IAAI,CAAC,QAAQ,CAAC,KAAK,CAACG;QAEpB,OAAO;YAAE,QAAQH,KAAK,EAAE;QAAC;IAC7B;IAEA,MAAa,QAAuB;QAEhC,OAAO;IACX;AACJ;AAEO,MAAMI,uBAAuBC,YAAY,oBAAoB,CAAC;IACjE,gBAAgBR;IAChB,cAAc;QAACS;QAAeC;KAAS;AAC3C"}