@webiny/background-tasks-standalone 6.6.0-alpha.4

package/BackgroundTasksStandaloneFeature.d.ts

@@ -0,0 +1,4 @@
+export declare const BackgroundTasksStandaloneFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/BackgroundTasksStandaloneFeature.js

@@ -0,0 +1,18 @@
+import { createFeature } from "@webiny/feature/api";
+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.registerInstance(InternalToken, {
+            value: uuid()
+        });
+        container.register(WorkerService);
+        container.register(BackgroundTaskRouteDefinition);
+    }
+});
+export { BackgroundTasksStandaloneFeature };
+
+//# sourceMappingURL=BackgroundTasksStandaloneFeature.js.map

package/BackgroundTasksStandaloneFeature.js.map

@@ -0,0 +1 @@
+{"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/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# @webiny/background-tasks-standalone
+
+> [!NOTE]
+> This package is part of the [Webiny](https://www.webiny.com) monorepo.
+> It’s **included in every Webiny project by default** and is not meant to be used as a standalone package.
+
+📘 **Documentation:** [https://www.webiny.com/docs](https://www.webiny.com/docs)
+
+---
+
+_This README file is automatically generated during the publish process._

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/index.d.ts

@@ -0,0 +1 @@
+export { BackgroundTasksStandaloneFeature } from "./BackgroundTasksStandaloneFeature.js";

package/index.js

@@ -0,0 +1 @@
+export { BackgroundTasksStandaloneFeature } from "./BackgroundTasksStandaloneFeature.js";

package/package.json

@@ -0,0 +1,38 @@
+{
+	"name": "@webiny/background-tasks-standalone",
+	"version": "6.6.0-alpha.4",
+	"type": "module",
+	"exports": {
+		".": "./index.js",
+		"./*": "./*"
+	},
+	"description": "Node server transport for Webiny background tasks (worker-thread orchestrator).",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git",
+		"directory": "packages/background-tasks-standalone"
+	},
+	"license": "MIT",
+	"dependencies": {
+		"@webiny/api-core": "6.6.0-alpha.4",
+		"@webiny/api-graphql": "6.6.0-alpha.4",
+		"@webiny/background-tasks": "6.6.0-alpha.4",
+		"@webiny/event-handler-core": "6.6.0-alpha.4",
+		"@webiny/feature": "6.6.0-alpha.4",
+		"@webiny/stdlib": "0.0.17",
+		"@webiny/utils": "6.6.0-alpha.4"
+	},
+	"devDependencies": {
+		"@webiny/build-tools": "6.6.0-alpha.4",
+		"@webiny/di": "1.1.0",
+		"rimraf": "6.1.3",
+		"typescript": "7.0.2",
+		"vitest": "4.1.11"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"webiny": {
+		"publishFrom": "dist"
+	}
+}

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,69 @@
+import { HttpRouteDefinition, HttpRouteHandler, RequestContainer } from "@webiny/event-handler-core";
+import { GraphQLContextEnhancer, GraphQLContextualSchema } from "@webiny/api-graphql";
+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
+            };
+            for (const enhancer of this.container.resolveAll(GraphQLContextEnhancer))await enhancer.enhance(ctx);
+            for (const schema of this.container.resolveAll(GraphQLContextualSchema))await schema.build(ctx);
+            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 { GraphQLContextEnhancer, GraphQLContextualSchema } from \"@webiny/api-graphql\";\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            /* TODO: remove once legacy ctx is gone — resolve services directly from the container. */\n            const ctx: Record<string, any> = { container: this.container };\n            for (const enhancer of this.container.resolveAll(GraphQLContextEnhancer)) {\n                await enhancer.enhance(ctx);\n            }\n            for (const schema of this.container.resolveAll(GraphQLContextualSchema)) {\n                await schema.build(ctx);\n            }\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","enhancer","GraphQLContextEnhancer","schema","GraphQLContextualSchema","timer","ProcessTimer","runner","TaskRunner","TaskEventValidation","result","err","message","Error","String","console","BackgroundTaskRoute","HttpRouteHandler","RequestContainer","InternalToken","BackgroundTaskRouteDefinitionImpl","BackgroundTaskRouteDefinition","HttpRouteDefinition"],"mappings":";;;;;;;AAkBA,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;YAC7D,KAAK,MAAMC,YAAY,IAAI,CAAC,SAAS,CAAC,UAAU,CAACC,wBAC7C,MAAMD,SAAS,OAAO,CAACD;YAE3B,KAAK,MAAMG,UAAU,IAAI,CAAC,SAAS,CAAC,UAAU,CAACC,yBAC3C,MAAMD,OAAO,KAAK,CAACH;YAGvB,MAAMK,QAAQ,IAAIC;YAClB,MAAMC,SAAS,IAAIC,WAAWR,KAAgBK,OAAO,IAAII;YACzD,MAAMC,SAAS,MAAMH,OAAO,GAAG,CAACV;YAEhC,OAAOD,SAAS,IAAI,CAACc;QACzB,EAAE,OAAOC,KAAK;YACV,MAAMC,UAAUD,eAAeE,QAAQF,IAAI,OAAO,GAAGG,OAAOH;YAC5DI,QAAQ,KAAK,CAAC,CAAC,6BAA6B,EAAEH,SAAS;YACvD,OAAOhB,SAAS,MAAM,CAAC,KAAK,IAAI,CAAC;gBAAE,QAAQ;gBAAS,OAAO;oBAAEgB;gBAAQ;YAAE;QAC3E;IACJ;AACJ;AAEO,MAAMI,sBAAsBC,iBAAiB,oBAAoB,CAAC;IACrE,gBAAgBzB;IAChB,cAAc;QAAC0B;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/timer/ProcessTimer.d.ts

@@ -0,0 +1,8 @@
+import type { Timer } from "@webiny/utils/features/Timer/abstraction.js";
+export declare class ProcessTimer implements Timer.Interface {
+    private readonly startTime;
+    private readonly maxDurationMs;
+    constructor(maxDurationMs?: number);
+    getRemainingMilliseconds(): number;
+    getRemainingSeconds(): number;
+}

package/timer/ProcessTimer.js

@@ -0,0 +1,19 @@
+const DEFAULT_MAX_DURATION_MS = 86400000;
+class ProcessTimer {
+    constructor(maxDurationMs = DEFAULT_MAX_DURATION_MS){
+        this.startTime = process.hrtime();
+        this.maxDurationMs = maxDurationMs;
+    }
+    getRemainingMilliseconds() {
+        const elapsed = process.hrtime(this.startTime);
+        const elapsedMs = 1000 * elapsed[0] + elapsed[1] / 1000000;
+        const remaining = this.maxDurationMs - elapsedMs;
+        return remaining > 0 ? remaining : 0;
+    }
+    getRemainingSeconds() {
+        return Math.floor(this.getRemainingMilliseconds() / 1000);
+    }
+}
+export { ProcessTimer };
+
+//# sourceMappingURL=ProcessTimer.js.map

package/timer/ProcessTimer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer/ProcessTimer.js","sources":["../../src/timer/ProcessTimer.ts"],"sourcesContent":["import type { Timer } from \"@webiny/utils/features/Timer/abstraction.js\";\n\nconst DEFAULT_MAX_DURATION_MS = 86_400_000; /* 24 hours. */\n\nexport class ProcessTimer implements Timer.Interface {\n    private readonly startTime: [number, number];\n    private readonly maxDurationMs: number;\n\n    public constructor(maxDurationMs: number = DEFAULT_MAX_DURATION_MS) {\n        this.startTime = process.hrtime();\n        this.maxDurationMs = maxDurationMs;\n    }\n\n    public getRemainingMilliseconds(): number {\n        const elapsed = process.hrtime(this.startTime);\n        const elapsedMs = elapsed[0] * 1000 + elapsed[1] / 1_000_000;\n        const remaining = this.maxDurationMs - elapsedMs;\n        return remaining > 0 ? remaining : 0;\n    }\n\n    public getRemainingSeconds(): number {\n        return Math.floor(this.getRemainingMilliseconds() / 1000);\n    }\n}\n"],"names":["DEFAULT_MAX_DURATION_MS","ProcessTimer","maxDurationMs","process","elapsed","elapsedMs","remaining","Math"],"mappings":"AAEA,MAAMA,0BAA0B;AAEzB,MAAMC;IAIT,YAAmBC,gBAAwBF,uBAAuB,CAAE;QAChE,IAAI,CAAC,SAAS,GAAGG,QAAQ,MAAM;QAC/B,IAAI,CAAC,aAAa,GAAGD;IACzB;IAEO,2BAAmC;QACtC,MAAME,UAAUD,QAAQ,MAAM,CAAC,IAAI,CAAC,SAAS;QAC7C,MAAME,YAAYD,AAAa,OAAbA,OAAO,CAAC,EAAE,GAAUA,OAAO,CAAC,EAAE,GAAG;QACnD,MAAME,YAAY,IAAI,CAAC,aAAa,GAAGD;QACvC,OAAOC,YAAY,IAAIA,YAAY;IACvC;IAEO,sBAA8B;QACjC,OAAOC,KAAK,KAAK,CAAC,IAAI,CAAC,wBAAwB,KAAK;IACxD;AACJ"}

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,111 @@
+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 req = node_http.request({
+                hostname: url.hostname,
+                port: url.port,
+                path: url.pathname,
+                method: "POST",
+                timeout: 60000,
+                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("end", ()=>{
+                    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}`));
+                    }
+                });
+            });
+            req.on("timeout", ()=>{
+                req.destroy(new Error("Request timed out after 60s."));
+            });
+            req.on("error", reject);
+            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            const req = http.request(\n                {\n                    hostname: url.hostname,\n                    port: url.port,\n                    path: url.pathname,\n                    method: \"POST\",\n                    timeout: 60_000,\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                    res.on(\"end\", () => {\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            req.on(\"timeout\", () => {\n                req.destroy(new Error(\"Request timed out after 60s.\"));\n            });\n            req.on(\"error\", reject);\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","req","http","Buffer","res","data","chunk","ms","setTimeout"],"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;YAE5B,MAAMY,MAAMC,UAAAA,OAAY,CACpB;gBACI,UAAUJ,IAAI,QAAQ;gBACtB,MAAMA,IAAI,IAAI;gBACd,MAAMA,IAAI,QAAQ;gBAClB,QAAQ;gBACR,SAAS;gBACT,SAAS;oBACL,gBAAgB;oBAChB,kBAAkBK,OAAO,UAAU,CAACH;oBACpC,kCAAkC,IAAI,CAAC,aAAa;gBACxD;YACJ,GACAI,CAAAA;gBACI,IAAIC,OAAO;gBACXD,IAAI,EAAE,CAAC,QAAQE,CAAAA;oBACXD,QAAQC;gBACZ;gBACAF,IAAI,EAAE,CAAC,OAAO;oBACV,IAAI,CAACA,IAAI,UAAU,IAAIA,IAAI,UAAU,GAAG,OAAOA,IAAI,UAAU,IAAI,KAAK,YAClEP,OAAO,IAAIJ,MAAM,CAAC,KAAK,EAAEW,IAAI,UAAU,CAAC,EAAE,EAAEC,MAAM;oBAGtD,IAAI;wBACAT,QAAQL,KAAK,KAAK,CAACc;oBACvB,EAAE,OAAM;wBACJR,OAAO,IAAIJ,MAAM,CAAC,uBAAuB,EAAEY,MAAM;oBACrD;gBACJ;YACJ;YAGJJ,IAAI,EAAE,CAAC,WAAW;gBACdA,IAAI,OAAO,CAAC,IAAIR,MAAM;YAC1B;YACAQ,IAAI,EAAE,CAAC,SAASJ;YAChBI,IAAI,KAAK,CAACD;YACVC,IAAI,GAAG;QACX;IACJ;IAEQ,KAAKM,EAAU,EAAiB;QACpC,OAAO,IAAIZ,QAAQC,CAAAA,UAAWY,WAAWZ,SAASW;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"}