@qlever-llc/trellis 0.7.0 → 0.8.0-rc.2

package/script/npm/src/server/internal_jobs/runtime-worker.js

@@ -0,0 +1,393 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobsInfrastructureMissingError = exports.WorkerHostStopError = exports.WorkerLoopStopError = void 0;
+exports.processWorkPayloadWithContextAndHeartbeat = processWorkPayloadWithContextAndHeartbeat;
+exports.projectedWorkDecision = projectedWorkDecision;
+exports.ackActionForOutcome = ackActionForOutcome;
+exports.startQueueWorkerLoop = startQueueWorkerLoop;
+exports.startNatsQueueWorker = startNatsQueueWorker;
+exports.startWorkerHostFromBinding = startWorkerHostFromBinding;
+exports.startNatsWorkerHostFromBinding = startNatsWorkerHostFromBinding;
+const jetstream_1 = require("@nats-io/jetstream");
+const cancellation_registry_js_1 = require("./cancellation-registry.js");
+const heartbeat_js_1 = require("./heartbeat.js");
+const job_manager_js_1 = require("./job-manager.js");
+const projection_js_1 = require("./projection.js");
+class WorkerLoopStopError extends AggregateError {
+    constructor(errors) {
+        super(errors, "queue worker loop failed");
+        this.name = "WorkerLoopStopError";
+    }
+}
+exports.WorkerLoopStopError = WorkerLoopStopError;
+class WorkerHostStopError extends AggregateError {
+    constructor(errors) {
+        super(errors, "worker host stop failed");
+        this.name = "WorkerHostStopError";
+    }
+}
+exports.WorkerHostStopError = WorkerHostStopError;
+class JobsInfrastructureMissingError extends Error {
+    constructor(stream, queueType) {
+        super(`Jobs work stream '${stream}' was not found while starting queue '${queueType}'. ` +
+            "The built-in Trellis jobs infrastructure is missing or not provisioned for this environment. " +
+            `Start Trellis and bootstrap the service again so '${stream}' exists before workers start.`);
+        this.name = "JobsInfrastructureMissingError";
+    }
+}
+exports.JobsInfrastructureMissingError = JobsInfrastructureMissingError;
+function isCustomNatsRuntimeDeps(args) {
+    return args.jsm !== undefined && args.js !== undefined;
+}
+function toWorkerConsumer(consumer) {
+    return {
+        async consume() {
+            const messages = await consumer.consume();
+            return {
+                stop: messages.stop?.bind(messages),
+                close: messages.close?.bind(messages),
+                async *[Symbol.asyncIterator]() {
+                    for await (const msg of messages) {
+                        yield {
+                            data: msg.data,
+                            subject: msg.subject,
+                            info: {
+                                redeliveryCount: Math.max(0, msg.info.deliveryCount - 1),
+                            },
+                            ack: msg.ack.bind(msg),
+                            nak: msg.nak.bind(msg),
+                            inProgress: msg.working.bind(msg),
+                        };
+                    }
+                },
+            };
+        },
+    };
+}
+async function processWorkPayloadWithContextAndHeartbeat(manager, payload, cancellation, heartbeat, handler, validation, runtime) {
+    const event = parseWorkPayloadEvent(payload);
+    if (!event) {
+        return undefined;
+    }
+    const job = (0, projection_js_1.jobFromWorkEvent)(event);
+    if (!job) {
+        return undefined;
+    }
+    return await manager.processWithHeartbeat(job, cancellation, heartbeat, async (activeJob) => {
+        try {
+            await validation?.validatePayload?.({
+                schema: validation.payloadSchema,
+                job: activeJob.job(),
+            });
+        }
+        catch (error) {
+            throw job_manager_js_1.JobProcessError.failed(error instanceof Error ? error.message : String(error));
+        }
+        return await handler(activeJob);
+    }, {
+        redeliveryCount: runtime?.redeliveryCount,
+    }, {
+        validateResult: validation?.validateResult
+            ? (result, resultJob) => validation.validateResult({
+                schema: validation.resultSchema,
+                result,
+                job: resultJob,
+            })
+            : undefined,
+    });
+}
+function projectedWorkDecision(projected, _work) {
+    if (!projected) {
+        return "process";
+    }
+    return (0, projection_js_1.isTerminal)(projected.state) ? "skip-ack" : "process";
+}
+function ackActionForOutcome(outcome) {
+    if (!outcome) {
+        return "ack";
+    }
+    switch (outcome.outcome) {
+        case "retry":
+        case "interrupted":
+            return "nak";
+        default:
+            return "ack";
+    }
+}
+async function startQueueWorkerLoop(options) {
+    const registry = new cancellation_registry_js_1.ActiveJobCancellationRegistry();
+    const activeTokens = new Set();
+    const messages = await options.consumer.consume();
+    const hostCancellation = options.hostCancellation;
+    const stopConsuming = () => {
+        if (typeof messages.stop === "function") {
+            messages.stop();
+        }
+        if (typeof messages.close === "function") {
+            void messages.close();
+        }
+    };
+    const cancelActiveForShutdown = () => {
+        for (const token of activeTokens) {
+            token.cancelForShutdown();
+        }
+    };
+    const hostAbortHandler = () => {
+        cancelActiveForShutdown();
+        stopConsuming();
+    };
+    hostCancellation?.signal.addEventListener("abort", hostAbortHandler);
+    if (hostCancellation?.signal.aborted) {
+        hostAbortHandler();
+    }
+    const workTask = (async () => {
+        for await (const msg of messages) {
+            const event = parseWorkPayloadEvent(msg.data);
+            const job = event
+                ? (0, projection_js_1.jobFromWorkEvent)(event)
+                : undefined;
+            if (!job) {
+                await msg.ack();
+                continue;
+            }
+            const key = `${job.service}.${job.type}.${job.id}`;
+            if (hostCancellation?.isHostShutdown()) {
+                await msg.nak();
+                continue;
+            }
+            const projected = options.getProjectedJob
+                ? await options.getProjectedJob(job)
+                : undefined;
+            if (hostCancellation?.isHostShutdown()) {
+                await msg.nak();
+                continue;
+            }
+            if (projectedWorkDecision(projected, job) === "skip-ack") {
+                registry.clearPending(key);
+                await msg.ack();
+                continue;
+            }
+            const token = new job_manager_js_1.JobCancellationToken();
+            if (hostCancellation?.isHostShutdown()) {
+                token.cancelForShutdown();
+            }
+            activeTokens.add(token);
+            const guard = registry.register(key, token);
+            try {
+                const outcome = await processWorkPayloadWithContextAndHeartbeat(options.manager, msg.data, token, async () => {
+                    await msg.inProgress();
+                }, options.handler, {
+                    payloadSchema: options.payloadSchema,
+                    validatePayload: options.validatePayload,
+                    resultSchema: options.resultSchema,
+                    validateResult: options.validateResult,
+                }, {
+                    redeliveryCount: msg.info?.redeliveryCount,
+                });
+                if (ackActionForOutcome(outcome) === "ack") {
+                    await msg.ack();
+                }
+                else {
+                    await msg.nak();
+                }
+            }
+            finally {
+                guard.dispose();
+                activeTokens.delete(token);
+            }
+        }
+    })();
+    let workFailure;
+    const observedWorkTask = workTask.catch((error) => {
+        workFailure = error;
+    });
+    const cancelTask = (async () => {
+        for await (const msg of options.cancelSubscription) {
+            const event = parseWorkPayloadEvent(msg.data);
+            if (!event || event.eventType !== "cancelled") {
+                continue;
+            }
+            registry.cancel(`${event.service}.${event.jobType}.${event.jobId}`);
+        }
+    })();
+    let cancelFailure;
+    const observedCancelTask = cancelTask.catch((error) => {
+        cancelFailure = error;
+    });
+    return {
+        async stop() {
+            options.cancelSubscription.unsubscribe();
+            cancelActiveForShutdown();
+            stopConsuming();
+            await Promise.all([observedWorkTask, observedCancelTask]);
+            hostCancellation?.signal.removeEventListener("abort", hostAbortHandler);
+            const failures = [workFailure, cancelFailure].filter((error) => error !== undefined);
+            if (failures.length > 0) {
+                throw new WorkerLoopStopError(failures);
+            }
+        },
+    };
+}
+async function startNatsQueueWorker(options) {
+    const queue = getQueueBinding(options.binding, options.queueType);
+    const jsm = isCustomNatsRuntimeDeps(options)
+        ? options.jsm
+        : await (0, jetstream_1.jetstreamManager)(options.nats);
+    const js = isCustomNatsRuntimeDeps(options) ? options.js : {
+        consumers: {
+            getConsumerFromInfo(info) {
+                return toWorkerConsumer((0, jetstream_1.jetstream)(options.nats).consumers.getConsumerFromInfo(info));
+            },
+        },
+    };
+    const info = await ensureConsumerInfo(jsm, options.binding.workStream, queue);
+    const consumer = js.consumers.getConsumerFromInfo(info);
+    const cancelSubscription = options.nats.subscribe(`${queue.publishPrefix}.*.cancelled`);
+    return await startQueueWorkerLoop({
+        manager: options.manager,
+        consumer,
+        cancelSubscription,
+        hostCancellation: options.hostCancellation,
+        getProjectedJob: options.getProjectedJob,
+        payloadSchema: queue.payload,
+        validatePayload: options.validatePayload,
+        resultSchema: queue.result,
+        validateResult: options.validateResult,
+        handler: options.handler,
+    });
+}
+async function startWorkerHostFromBinding(binding, options) {
+    const queueTypes = options.queueTypes ??
+        Object.keys(binding.jobs.queues).sort();
+    for (const queueType of queueTypes) {
+        const queue = binding.jobs.queues[queueType];
+        if (!queue) {
+            throw new Error(`Requested worker queue binding '${queueType}' is missing`);
+        }
+        if (queue.concurrency < 1) {
+            throw new Error(`Worker queue '${queueType}' has invalid concurrency ${queue.concurrency}; expected >= 1`);
+        }
+    }
+    const cancellation = new job_manager_js_1.JobCancellationToken();
+    const heartbeatLoops = options.heartbeatPublisher
+        ? await Promise.all(queueTypes.map((queueType) => (0, heartbeat_js_1.startWorkerHeartbeatLoop)({
+            publisher: options.heartbeatPublisher,
+            service: binding.jobs.namespace,
+            jobType: queueType,
+            instanceId: options.instanceId,
+            concurrency: binding.jobs.queues[queueType].concurrency,
+            version: options.version,
+            intervalMs: options.heartbeatIntervalMs,
+            nowIso: options.nowIso,
+        })))
+        : [];
+    const workers = [];
+    for (const queueType of queueTypes) {
+        const queue = binding.jobs.queues[queueType];
+        for (let workerIndex = 0; workerIndex < queue.concurrency; workerIndex += 1) {
+            const handle = await options.startWorker({
+                queueType,
+                workerIndex,
+                cancellation,
+            });
+            if (handle && typeof handle === "object" && "stop" in handle &&
+                typeof handle.stop === "function") {
+                workers.push(handle);
+            }
+        }
+    }
+    return {
+        workerCount() {
+            return workers.length;
+        },
+        async stop() {
+            cancellation.cancelForShutdown();
+            const results = await Promise.allSettled([
+                ...workers.map((worker) => worker.stop()),
+                ...heartbeatLoops.map((loop) => loop.stop()),
+            ]);
+            const failures = results
+                .filter((result) => result.status === "rejected")
+                .map((result) => result.reason);
+            if (failures.length > 0) {
+                throw new WorkerHostStopError(failures);
+            }
+        },
+    };
+}
+async function startNatsWorkerHostFromBinding(binding, options) {
+    return await startWorkerHostFromBinding(binding, {
+        instanceId: options.instanceId,
+        queueTypes: options.queueTypes,
+        heartbeatPublisher: options.heartbeatPublisher,
+        heartbeatIntervalMs: options.heartbeatIntervalMs,
+        version: options.version,
+        nowIso: options.nowIso,
+        startWorker: async ({ queueType, cancellation }) => {
+            const common = {
+                manager: options.manager,
+                binding,
+                queueType,
+                hostCancellation: cancellation,
+                getProjectedJob: options.getProjectedJob,
+                validatePayload: options.validatePayload,
+                validateResult: options.validateResult,
+                handler: options.handler,
+            };
+            return await (isCustomNatsRuntimeDeps(options)
+                ? startNatsQueueWorker({
+                    ...common,
+                    nats: options.nats,
+                    jsm: options.jsm,
+                    js: options.js,
+                })
+                : startNatsQueueWorker({ ...common, nats: options.nats }));
+        },
+    });
+}
+async function ensureConsumerInfo(jsm, stream, queue) {
+    const config = {
+        durable_name: queue.consumerName,
+        ack_policy: "explicit",
+        filter_subject: queue.workSubject,
+        ack_wait: queue.ackWaitMs * 1_000_000,
+        max_deliver: queue.maxDeliver,
+        backoff: queue.backoffMs.map((delay) => delay * 1_000_000),
+    };
+    try {
+        return await jsm.consumers.add(stream, config);
+    }
+    catch (addError) {
+        try {
+            return await jsm.consumers.info(stream, queue.consumerName);
+        }
+        catch (infoError) {
+            if (isStreamNotFoundError(addError) || isStreamNotFoundError(infoError)) {
+                throw new JobsInfrastructureMissingError(stream, queue.queueType);
+            }
+            throw infoError;
+        }
+    }
+}
+function isStreamNotFoundError(error) {
+    return error instanceof Error && (error.name === "StreamNotFoundError" ||
+        error.message.includes("stream not found"));
+}
+function getQueueBinding(binding, queueType) {
+    const queue = binding.jobs.queues[queueType];
+    if (!queue) {
+        throw new Error(`Requested worker queue binding '${queueType}' is missing`);
+    }
+    if (queue.concurrency < 1) {
+        throw new Error(`Worker queue '${queueType}' has invalid concurrency ${queue.concurrency}; expected >= 1`);
+    }
+    return queue;
+}
+function parseWorkPayloadEvent(payload) {
+    try {
+        return JSON.parse(new TextDecoder().decode(payload));
+    }
+    catch {
+        return undefined;
+    }
+}

package/script/npm/src/server/internal_jobs/types.d.ts

@@ -0,0 +1,87 @@
+import { type StaticDecode, Type } from "typebox";
+export declare const JobStateSchema: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"active">, Type.TLiteral<"retry">, Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"cancelled">, Type.TLiteral<"expired">, Type.TLiteral<"dead">, Type.TLiteral<"dismissed">]>;
+export type JobState = StaticDecode<typeof JobStateSchema>;
+export declare const JobLogEntrySchema: Type.TObject<{
+    timestamp: Type.TString;
+    level: Type.TUnion<[Type.TLiteral<"info">, Type.TLiteral<"warn">, Type.TLiteral<"error">]>;
+    message: Type.TString;
+}>;
+export type JobLogEntry = StaticDecode<typeof JobLogEntrySchema>;
+export declare const JobProgressSchema: Type.TObject<{
+    step: Type.TOptional<Type.TString>;
+    message: Type.TOptional<Type.TString>;
+    current: Type.TOptional<Type.TInteger>;
+    total: Type.TOptional<Type.TInteger>;
+}>;
+export type JobProgress = StaticDecode<typeof JobProgressSchema>;
+export declare const JobSchema: Type.TObject<{
+    id: Type.TString;
+    service: Type.TString;
+    type: Type.TString;
+    state: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"active">, Type.TLiteral<"retry">, Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"cancelled">, Type.TLiteral<"expired">, Type.TLiteral<"dead">, Type.TLiteral<"dismissed">]>;
+    payload: Type.TUnknown;
+    result: Type.TOptional<Type.TUnknown>;
+    createdAt: Type.TString;
+    updatedAt: Type.TString;
+    startedAt: Type.TOptional<Type.TString>;
+    completedAt: Type.TOptional<Type.TString>;
+    tries: Type.TInteger;
+    maxTries: Type.TInteger;
+    lastError: Type.TOptional<Type.TString>;
+    deadline: Type.TOptional<Type.TString>;
+    progress: Type.TOptional<Type.TObject<{
+        step: Type.TOptional<Type.TString>;
+        message: Type.TOptional<Type.TString>;
+        current: Type.TOptional<Type.TInteger>;
+        total: Type.TOptional<Type.TInteger>;
+    }>>;
+    logs: Type.TOptional<Type.TArray<Type.TObject<{
+        timestamp: Type.TString;
+        level: Type.TUnion<[Type.TLiteral<"info">, Type.TLiteral<"warn">, Type.TLiteral<"error">]>;
+        message: Type.TString;
+    }>>>;
+}>;
+export type Job<TPayload = unknown, TResult = unknown> = Omit<StaticDecode<typeof JobSchema>, "payload" | "result"> & {
+    payload: TPayload;
+    result?: TResult;
+};
+export declare const JobEventSchema: Type.TObject<{
+    jobId: Type.TString;
+    service: Type.TString;
+    jobType: Type.TString;
+    eventType: Type.TUnion<[Type.TLiteral<"created">, Type.TLiteral<"started">, Type.TLiteral<"retry">, Type.TLiteral<"progress">, Type.TLiteral<"logged">, Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"cancelled">, Type.TLiteral<"expired">, Type.TLiteral<"retried">, Type.TLiteral<"dead">, Type.TLiteral<"dismissed">]>;
+    state: Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"active">, Type.TLiteral<"retry">, Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"cancelled">, Type.TLiteral<"expired">, Type.TLiteral<"dead">, Type.TLiteral<"dismissed">]>;
+    previousState: Type.TOptional<Type.TUnion<[Type.TLiteral<"pending">, Type.TLiteral<"active">, Type.TLiteral<"retry">, Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"cancelled">, Type.TLiteral<"expired">, Type.TLiteral<"dead">, Type.TLiteral<"dismissed">]>>;
+    tries: Type.TInteger;
+    maxTries: Type.TOptional<Type.TInteger>;
+    error: Type.TOptional<Type.TString>;
+    progress: Type.TOptional<Type.TObject<{
+        step: Type.TOptional<Type.TString>;
+        message: Type.TOptional<Type.TString>;
+        current: Type.TOptional<Type.TInteger>;
+        total: Type.TOptional<Type.TInteger>;
+    }>>;
+    logs: Type.TOptional<Type.TArray<Type.TObject<{
+        timestamp: Type.TString;
+        level: Type.TUnion<[Type.TLiteral<"info">, Type.TLiteral<"warn">, Type.TLiteral<"error">]>;
+        message: Type.TString;
+    }>>>;
+    payload: Type.TOptional<Type.TUnknown>;
+    result: Type.TOptional<Type.TUnknown>;
+    deadline: Type.TOptional<Type.TString>;
+    timestamp: Type.TString;
+}>;
+export type JobEvent<TPayload = unknown, TResult = unknown> = Omit<StaticDecode<typeof JobEventSchema>, "payload" | "result"> & {
+    payload?: TPayload;
+    result?: TResult;
+};
+export declare const WorkerHeartbeatSchema: Type.TObject<{
+    service: Type.TString;
+    jobType: Type.TString;
+    instanceId: Type.TString;
+    concurrency: Type.TOptional<Type.TInteger>;
+    version: Type.TOptional<Type.TString>;
+    timestamp: Type.TString;
+}>;
+export type WorkerHeartbeat = StaticDecode<typeof WorkerHeartbeatSchema>;
+//# sourceMappingURL=types.d.ts.map

package/script/npm/src/server/internal_jobs/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/server/internal_jobs/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAElD,eAAO,MAAM,cAAc,wPAUzB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,YAAY,CAAC,OAAO,cAAc,CAAC,CAAC;AAE3D,eAAO,MAAM,iBAAiB;;;;EAQ5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,YAAY,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEjE,eAAO,MAAM,iBAAiB;;;;;EAK5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,YAAY,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEjE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBpB,CAAC;AAEH,MAAM,MAAM,GAAG,CAAC,QAAQ,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO,IACjD,IAAI,CAAC,YAAY,CAAC,OAAO,SAAS,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAC,GAC1D;IACA,OAAO,EAAE,QAAQ,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEJ,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;EA6BzB,CAAC;AAEH,MAAM,MAAM,QAAQ,CAAC,QAAQ,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO,IACtD,IAAI,CAAC,YAAY,CAAC,OAAO,cAAc,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAC,GAC/D;IACA,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEJ,eAAO,MAAM,qBAAqB;;;;;;;EAOhC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,YAAY,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/script/npm/src/server/internal_jobs/types.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerHeartbeatSchema = exports.JobEventSchema = exports.JobSchema = exports.JobProgressSchema = exports.JobLogEntrySchema = exports.JobStateSchema = void 0;
+const typebox_1 = require("typebox");
+exports.JobStateSchema = typebox_1.Type.Union([
+    typebox_1.Type.Literal("pending"),
+    typebox_1.Type.Literal("active"),
+    typebox_1.Type.Literal("retry"),
+    typebox_1.Type.Literal("completed"),
+    typebox_1.Type.Literal("failed"),
+    typebox_1.Type.Literal("cancelled"),
+    typebox_1.Type.Literal("expired"),
+    typebox_1.Type.Literal("dead"),
+    typebox_1.Type.Literal("dismissed"),
+]);
+exports.JobLogEntrySchema = typebox_1.Type.Object({
+    timestamp: typebox_1.Type.String({ format: "date-time" }),
+    level: typebox_1.Type.Union([
+        typebox_1.Type.Literal("info"),
+        typebox_1.Type.Literal("warn"),
+        typebox_1.Type.Literal("error"),
+    ]),
+    message: typebox_1.Type.String(),
+});
+exports.JobProgressSchema = typebox_1.Type.Object({
+    step: typebox_1.Type.Optional(typebox_1.Type.String()),
+    message: typebox_1.Type.Optional(typebox_1.Type.String()),
+    current: typebox_1.Type.Optional(typebox_1.Type.Integer({ minimum: 0 })),
+    total: typebox_1.Type.Optional(typebox_1.Type.Integer({ minimum: 0 })),
+});
+exports.JobSchema = typebox_1.Type.Object({
+    id: typebox_1.Type.String({ minLength: 1 }),
+    service: typebox_1.Type.String({ minLength: 1 }),
+    type: typebox_1.Type.String({ minLength: 1 }),
+    state: exports.JobStateSchema,
+    payload: typebox_1.Type.Unknown(),
+    result: typebox_1.Type.Optional(typebox_1.Type.Unknown()),
+    createdAt: typebox_1.Type.String({ format: "date-time" }),
+    updatedAt: typebox_1.Type.String({ format: "date-time" }),
+    startedAt: typebox_1.Type.Optional(typebox_1.Type.String({ format: "date-time" })),
+    completedAt: typebox_1.Type.Optional(typebox_1.Type.String({ format: "date-time" })),
+    tries: typebox_1.Type.Integer({ minimum: 0 }),
+    maxTries: typebox_1.Type.Integer({ minimum: 1 }),
+    lastError: typebox_1.Type.Optional(typebox_1.Type.String()),
+    deadline: typebox_1.Type.Optional(typebox_1.Type.String({ format: "date-time" })),
+    progress: typebox_1.Type.Optional(exports.JobProgressSchema),
+    logs: typebox_1.Type.Optional(typebox_1.Type.Array(exports.JobLogEntrySchema)),
+});
+exports.JobEventSchema = typebox_1.Type.Object({
+    jobId: typebox_1.Type.String({ minLength: 1 }),
+    service: typebox_1.Type.String({ minLength: 1 }),
+    jobType: typebox_1.Type.String({ minLength: 1 }),
+    eventType: typebox_1.Type.Union([
+        typebox_1.Type.Literal("created"),
+        typebox_1.Type.Literal("started"),
+        typebox_1.Type.Literal("retry"),
+        typebox_1.Type.Literal("progress"),
+        typebox_1.Type.Literal("logged"),
+        typebox_1.Type.Literal("completed"),
+        typebox_1.Type.Literal("failed"),
+        typebox_1.Type.Literal("cancelled"),
+        typebox_1.Type.Literal("expired"),
+        typebox_1.Type.Literal("retried"),
+        typebox_1.Type.Literal("dead"),
+        typebox_1.Type.Literal("dismissed"),
+    ]),
+    state: exports.JobStateSchema,
+    previousState: typebox_1.Type.Optional(exports.JobStateSchema),
+    tries: typebox_1.Type.Integer({ minimum: 0 }),
+    maxTries: typebox_1.Type.Optional(typebox_1.Type.Integer({ minimum: 1 })),
+    error: typebox_1.Type.Optional(typebox_1.Type.String()),
+    progress: typebox_1.Type.Optional(exports.JobProgressSchema),
+    logs: typebox_1.Type.Optional(typebox_1.Type.Array(exports.JobLogEntrySchema)),
+    payload: typebox_1.Type.Optional(typebox_1.Type.Unknown()),
+    result: typebox_1.Type.Optional(typebox_1.Type.Unknown()),
+    deadline: typebox_1.Type.Optional(typebox_1.Type.String({ format: "date-time" })),
+    timestamp: typebox_1.Type.String({ format: "date-time" }),
+});
+exports.WorkerHeartbeatSchema = typebox_1.Type.Object({
+    service: typebox_1.Type.String({ minLength: 1 }),
+    jobType: typebox_1.Type.String({ minLength: 1 }),
+    instanceId: typebox_1.Type.String({ minLength: 1 }),
+    concurrency: typebox_1.Type.Optional(typebox_1.Type.Integer({ minimum: 1 })),
+    version: typebox_1.Type.Optional(typebox_1.Type.String({ minLength: 1 })),
+    timestamp: typebox_1.Type.String({ format: "date-time" }),
+});

package/script/npm/src/server/runtime.d.ts

@@ -0,0 +1,17 @@
+import type { NatsConnection } from "@nats-io/nats-core";
+export type NatsConnectOpts = {
+    servers: string | string[];
+    token?: string;
+    inboxPrefix?: string;
+    authenticator?: unknown;
+    maxReconnectAttempts?: number;
+} & Record<string, unknown>;
+export type NatsConnectFn = (opts: NatsConnectOpts) => Promise<NatsConnection>;
+export type NatsCredsAuthenticatorFn = (creds: Uint8Array) => unknown;
+export type ReadFileSyncFn = (path: string) => Uint8Array;
+export type TrellisServiceRuntimeDeps = {
+    connect: NatsConnectFn;
+    credsAuthenticator?: NatsCredsAuthenticatorFn;
+    readFileSync?: ReadFileSyncFn;
+};
+//# sourceMappingURL=runtime.d.ts.map

package/script/npm/src/server/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../src/server/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAOzD,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE5B,MAAM,MAAM,aAAa,GAAG,CAAC,IAAI,EAAE,eAAe,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;AAE/E,MAAM,MAAM,wBAAwB,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC;AAEtE,MAAM,MAAM,cAAc,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,UAAU,CAAC;AAE1D,MAAM,MAAM,yBAAyB,GAAG;IACtC,OAAO,EAAE,aAAa,CAAC;IACvB,kBAAkB,CAAC,EAAE,wBAAwB,CAAC;IAC9C,YAAY,CAAC,EAAE,cAAc,CAAC;CAC/B,CAAC"}

package/script/npm/src/server/runtime.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });