@lssm/lib.contracts 0.0.0-canary-20251217062943 → 0.0.0-canary-20251217072406

package/dist/integrations/spec.js

@@ -1 +1,39 @@
-const e=e=>`${e.key}.v${e.version}`;var t=class{items=new Map;register(t){let n=e(t.meta);if(this.items.has(n))throw Error(`Duplicate IntegrationSpec ${n}`);return this.items.set(n,t),this}list(){return[...this.items.values()]}get(t,n){if(n!=null)return this.items.get(e({key:t,version:n}));let r,i=-1/0;for(let e of this.items.values())e.meta.key===t&&e.meta.version>i&&(i=e.meta.version,r=e);return r}getByCategory(e){return this.list().filter(t=>t.meta.category===e)}};function n(t){return e(t)}export{t as IntegrationSpecRegistry,n as makeIntegrationSpecKey};
+//#region src/integrations/spec.ts
+const integrationKey = (meta) => `${meta.key}.v${meta.version}`;
+var IntegrationSpecRegistry = class {
+	items = /* @__PURE__ */ new Map();
+	register(spec) {
+		const key = integrationKey(spec.meta);
+		if (this.items.has(key)) throw new Error(`Duplicate IntegrationSpec ${key}`);
+		this.items.set(key, spec);
+		return this;
+	}
+	list() {
+		return [...this.items.values()];
+	}
+	get(key, version) {
+		if (version != null) return this.items.get(integrationKey({
+			key,
+			version
+		}));
+		let latest;
+		let maxVersion = -Infinity;
+		for (const spec of this.items.values()) {
+			if (spec.meta.key !== key) continue;
+			if (spec.meta.version > maxVersion) {
+				maxVersion = spec.meta.version;
+				latest = spec;
+			}
+		}
+		return latest;
+	}
+	getByCategory(category) {
+		return this.list().filter((spec) => spec.meta.category === category);
+	}
+};
+function makeIntegrationSpecKey(meta) {
+	return integrationKey(meta);
+}
+
+//#endregion
+export { IntegrationSpecRegistry, makeIntegrationSpecKey };

package/dist/jobs/define-job.js

@@ -1 +1,16 @@
-function e(e,t){e.register(t.type,async e=>{let n=t.schema.parse(e.payload);await t.handler(n,e)})}export{e as registerDefinedJob};
+//#region src/jobs/define-job.ts
+/**
+* Register a `DefinedJob` on a queue with payload validation.
+*
+* - Parses and validates payload via the job's Zod schema
+* - Invokes the defined handler with the validated payload
+*/
+function registerDefinedJob(queue, job) {
+	queue.register(job.type, async (queuedJob) => {
+		const parsed = job.schema.parse(queuedJob.payload);
+		await job.handler(parsed, queuedJob);
+	});
+}
+
+//#endregion
+export { registerDefinedJob };

package/dist/jobs/gcp-cloud-tasks.js

@@ -1 +1,53 @@
-import{DEFAULT_RETRY_POLICY as e}from"./queue.js";import{randomUUID as t}from"node:crypto";var n=class{handlers=new Map;constructor(e){this.options=e}async enqueue(n,r,i={}){let a=i.delaySeconds==null?void 0:{seconds:Math.floor(Date.now()/1e3)+i.delaySeconds},o=Buffer.from(JSON.stringify({id:t(),type:n,payload:r}),`utf-8`);return await this.options.client.createTask({parent:`projects/${this.options.projectId}/locations/${this.options.location}/queues/${this.options.queue}`,task:{httpRequest:{httpMethod:`POST`,url:this.options.resolveUrl(n),body:o,headers:{"Content-Type":`application/json`},oidcToken:this.options.serviceAccountEmail?{serviceAccountEmail:this.options.serviceAccountEmail}:void 0},scheduleTime:a}}),{id:t(),type:n,version:1,payload:r,status:`pending`,priority:i.priority??0,attempts:0,maxRetries:i.maxRetries??e.maxRetries,createdAt:new Date,updatedAt:new Date}}register(e,t){this.handlers.set(e,t)}start(){}async stop(){this.handlers.clear()}};export{n as GcpCloudTasksQueue};
+import { DEFAULT_RETRY_POLICY } from "./queue.js";
+import { randomUUID } from "node:crypto";
+
+//#region src/jobs/gcp-cloud-tasks.ts
+var GcpCloudTasksQueue = class {
+	handlers = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+	}
+	async enqueue(jobType, payload, options = {}) {
+		const enqueueTime = options.delaySeconds != null ? { seconds: Math.floor(Date.now() / 1e3) + options.delaySeconds } : void 0;
+		const body = Buffer.from(JSON.stringify({
+			id: randomUUID(),
+			type: jobType,
+			payload
+		}), "utf-8");
+		await this.options.client.createTask({
+			parent: `projects/${this.options.projectId}/locations/${this.options.location}/queues/${this.options.queue}`,
+			task: {
+				httpRequest: {
+					httpMethod: "POST",
+					url: this.options.resolveUrl(jobType),
+					body,
+					headers: { "Content-Type": "application/json" },
+					oidcToken: this.options.serviceAccountEmail ? { serviceAccountEmail: this.options.serviceAccountEmail } : void 0
+				},
+				scheduleTime: enqueueTime
+			}
+		});
+		return {
+			id: randomUUID(),
+			type: jobType,
+			version: 1,
+			payload,
+			status: "pending",
+			priority: options.priority ?? 0,
+			attempts: 0,
+			maxRetries: options.maxRetries ?? DEFAULT_RETRY_POLICY.maxRetries,
+			createdAt: /* @__PURE__ */ new Date(),
+			updatedAt: /* @__PURE__ */ new Date()
+		};
+	}
+	register(jobType, handler) {
+		this.handlers.set(jobType, handler);
+	}
+	start() {}
+	async stop() {
+		this.handlers.clear();
+	}
+};
+
+//#endregion
+export { GcpCloudTasksQueue };

package/dist/jobs/gcp-pubsub.js

@@ -1 +1,39 @@
-import{DEFAULT_RETRY_POLICY as e}from"./queue.js";import{randomUUID as t}from"node:crypto";var n=class{handlers=new Map;constructor(e){this.options=e}async enqueue(n,r,i={}){return await this.options.client.topic(this.options.topicName).publishMessage({data:Buffer.from(JSON.stringify({id:t(),type:n,payload:r}),`utf-8`)}),{id:t(),type:n,version:1,payload:r,status:`pending`,priority:i.priority??0,attempts:0,maxRetries:i.maxRetries??e.maxRetries,createdAt:new Date,updatedAt:new Date}}register(e,t){this.handlers.set(e,t)}start(){}async stop(){this.handlers.clear()}};export{n as GcpPubSubQueue};
+import { DEFAULT_RETRY_POLICY } from "./queue.js";
+import { randomUUID } from "node:crypto";
+
+//#region src/jobs/gcp-pubsub.ts
+var GcpPubSubQueue = class {
+	handlers = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+	}
+	async enqueue(jobType, payload, options = {}) {
+		await this.options.client.topic(this.options.topicName).publishMessage({ data: Buffer.from(JSON.stringify({
+			id: randomUUID(),
+			type: jobType,
+			payload
+		}), "utf-8") });
+		return {
+			id: randomUUID(),
+			type: jobType,
+			version: 1,
+			payload,
+			status: "pending",
+			priority: options.priority ?? 0,
+			attempts: 0,
+			maxRetries: options.maxRetries ?? DEFAULT_RETRY_POLICY.maxRetries,
+			createdAt: /* @__PURE__ */ new Date(),
+			updatedAt: /* @__PURE__ */ new Date()
+		};
+	}
+	register(jobType, handler) {
+		this.handlers.set(jobType, handler);
+	}
+	start() {}
+	async stop() {
+		this.handlers.clear();
+	}
+};
+
+//#endregion
+export { GcpPubSubQueue };

package/dist/jobs/handlers/gmail-sync-handler.js

@@ -1 +1,9 @@
-function e(e){return async t=>{await e.syncThreads(t.payload)}}export{e as createGmailSyncHandler};
+//#region src/jobs/handlers/gmail-sync-handler.ts
+function createGmailSyncHandler(adapter) {
+	return async (job) => {
+		await adapter.syncThreads(job.payload);
+	};
+}
+
+//#endregion
+export { createGmailSyncHandler };

package/dist/jobs/handlers/index.js

@@ -1 +1,12 @@
-import{registerDefinedJob as e}from"../define-job.js";import{createGmailSyncHandler as t}from"./gmail-sync-handler.js";import{PING_JOB_TYPE as n,PingPayloadSchema as r,pingJob as i}from"./ping-handler.js";import{createStorageDocumentHandler as a}from"./storage-document-handler.js";function o(t){e(t,i)}export{n as PING_JOB_TYPE,r as PingPayloadSchema,t as createGmailSyncHandler,a as createStorageDocumentHandler,i as pingJob,o as registerAllJobs};
+import { registerDefinedJob } from "../define-job.js";
+import { createGmailSyncHandler } from "./gmail-sync-handler.js";
+import { PING_JOB_TYPE, PingPayloadSchema, pingJob } from "./ping-handler.js";
+import { createStorageDocumentHandler } from "./storage-document-handler.js";
+
+//#region src/jobs/handlers/index.ts
+function registerAllJobs(queue) {
+	registerDefinedJob(queue, pingJob);
+}
+
+//#endregion
+export { PING_JOB_TYPE, PingPayloadSchema, createGmailSyncHandler, createStorageDocumentHandler, pingJob, registerAllJobs };

package/dist/jobs/handlers/ping-handler.js

@@ -1 +1,15 @@
-import*as e from"zod";const t=`core.ping`,n=e.object({}),r={type:t,schema:n,handler:async(e,t)=>{console.log(`[ping] job id=%s attempts=%d`,t.id,t.attempts)}};export{t as PING_JOB_TYPE,n as PingPayloadSchema,r as pingJob};
+import * as z$1 from "zod";
+
+//#region src/jobs/handlers/ping-handler.ts
+const PING_JOB_TYPE = "core.ping";
+const PingPayloadSchema = z$1.object({});
+const pingJob = {
+	type: PING_JOB_TYPE,
+	schema: PingPayloadSchema,
+	handler: async (_payload, job) => {
+		console.log("[ping] job id=%s attempts=%d", job.id, job.attempts);
+	}
+};
+
+//#endregion
+export { PING_JOB_TYPE, PingPayloadSchema, pingJob };

package/dist/jobs/handlers/storage-document-handler.js

@@ -1 +1,14 @@
-function e(e,t){return async n=>{let r=await e.getObject({bucket:n.payload.bucket,key:n.payload.key});if(!r)throw Error(`Object ${n.payload.bucket}/${n.payload.key} not found`);await t.ingestObject(r)}}export{e as createStorageDocumentHandler};
+//#region src/jobs/handlers/storage-document-handler.ts
+function createStorageDocumentHandler(storage, adapter) {
+	return async (job) => {
+		const object = await storage.getObject({
+			bucket: job.payload.bucket,
+			key: job.payload.key
+		});
+		if (!object) throw new Error(`Object ${job.payload.bucket}/${job.payload.key} not found`);
+		await adapter.ingestObject(object);
+	};
+}
+
+//#endregion
+export { createStorageDocumentHandler };

package/dist/jobs/index.js

@@ -1 +1,4 @@
-import{registerDefinedJob as e}from"./define-job.js";import{DEFAULT_RETRY_POLICY as t,calculateBackoff as n,defineJobType as r}from"./queue.js";export{t as DEFAULT_RETRY_POLICY,n as calculateBackoff,r as defineJobType,e as registerDefinedJob};
+import { registerDefinedJob } from "./define-job.js";
+import { DEFAULT_RETRY_POLICY, calculateBackoff, defineJobType } from "./queue.js";
+
+export { DEFAULT_RETRY_POLICY, calculateBackoff, defineJobType, registerDefinedJob };

package/dist/jobs/memory-queue.js

@@ -1 +1,71 @@
-import{DEFAULT_RETRY_POLICY as e}from"./queue.js";import{randomUUID as t}from"node:crypto";var n=class{jobs=[];handlers=new Map;timer;processing=!1;constructor(e=200){this.pollIntervalMs=e}async enqueue(n,r,i={}){let a={id:t(),type:n,version:1,payload:r,status:`pending`,priority:i.priority??0,attempts:0,maxRetries:i.maxRetries??e.maxRetries,createdAt:new Date,updatedAt:new Date};return i.delaySeconds&&(a.updatedAt=new Date(Date.now()+i.delaySeconds*1e3)),this.jobs.push(a),a}register(e,t){this.handlers.set(e,t)}start(){this.timer||=setInterval(()=>{this.processNext()},this.pollIntervalMs)}async stop(){for(this.timer&&=(clearInterval(this.timer),void 0);this.processing;)await new Promise(e=>setTimeout(e,10))}async processNext(){if(this.processing)return;let e=this.jobs.find(e=>e.status===`pending`&&e.updatedAt<=new Date);if(!e)return;let t=this.handlers.get(e.type);if(t){this.processing=!0,e.status=`running`,e.updatedAt=new Date,e.attempts+=1;try{await t(e),e.status=`completed`,e.updatedAt=new Date}catch(t){e.status=`failed`,e.lastError=t instanceof Error?t.message:`Unknown job error`,e.updatedAt=new Date}finally{this.processing=!1}}}};export{n as MemoryJobQueue};
+import { DEFAULT_RETRY_POLICY } from "./queue.js";
+import { randomUUID } from "node:crypto";
+
+//#region src/jobs/memory-queue.ts
+var MemoryJobQueue = class {
+	jobs = [];
+	handlers = /* @__PURE__ */ new Map();
+	timer;
+	processing = false;
+	constructor(pollIntervalMs = 200) {
+		this.pollIntervalMs = pollIntervalMs;
+	}
+	async enqueue(jobType, payload, options = {}) {
+		const job = {
+			id: randomUUID(),
+			type: jobType,
+			version: 1,
+			payload,
+			status: "pending",
+			priority: options.priority ?? 0,
+			attempts: 0,
+			maxRetries: options.maxRetries ?? DEFAULT_RETRY_POLICY.maxRetries,
+			createdAt: /* @__PURE__ */ new Date(),
+			updatedAt: /* @__PURE__ */ new Date()
+		};
+		if (options.delaySeconds) job.updatedAt = new Date(Date.now() + options.delaySeconds * 1e3);
+		this.jobs.push(job);
+		return job;
+	}
+	register(jobType, handler) {
+		this.handlers.set(jobType, handler);
+	}
+	start() {
+		if (this.timer) return;
+		this.timer = setInterval(() => {
+			this.processNext();
+		}, this.pollIntervalMs);
+	}
+	async stop() {
+		if (this.timer) {
+			clearInterval(this.timer);
+			this.timer = void 0;
+		}
+		while (this.processing) await new Promise((resolve) => setTimeout(resolve, 10));
+	}
+	async processNext() {
+		if (this.processing) return;
+		const job = this.jobs.find((j) => j.status === "pending" && j.updatedAt <= /* @__PURE__ */ new Date());
+		if (!job) return;
+		const handler = this.handlers.get(job.type);
+		if (!handler) return;
+		this.processing = true;
+		job.status = "running";
+		job.updatedAt = /* @__PURE__ */ new Date();
+		job.attempts += 1;
+		try {
+			await handler(job);
+			job.status = "completed";
+			job.updatedAt = /* @__PURE__ */ new Date();
+		} catch (error) {
+			job.status = "failed";
+			job.lastError = error instanceof Error ? error.message : "Unknown job error";
+			job.updatedAt = /* @__PURE__ */ new Date();
+		} finally {
+			this.processing = false;
+		}
+	}
+};
+
+//#endregion
+export { MemoryJobQueue };

package/dist/jobs/queue.js

@@ -1 +1,33 @@
-import"zod";const e={maxRetries:3,initialBackoffMs:1e3,maxBackoffMs:6e4,multiplier:2,jitter:!0};function t(t,n=e){let r=Math.min(n.initialBackoffMs*n.multiplier**(t-1),n.maxBackoffMs);if(n.jitter){let e=.8+Math.random()*.4;return Math.floor(r*e)}return r}function n(e){return e}export{e as DEFAULT_RETRY_POLICY,t as calculateBackoff,n as defineJobType};
+import "zod";
+
+//#region src/jobs/queue.ts
+/**
+* Default retry policy.
+*/
+const DEFAULT_RETRY_POLICY = {
+	maxRetries: 3,
+	initialBackoffMs: 1e3,
+	maxBackoffMs: 6e4,
+	multiplier: 2,
+	jitter: true
+};
+/**
+* Calculate backoff delay for a retry attempt.
+*/
+function calculateBackoff(attempt, policy = DEFAULT_RETRY_POLICY) {
+	const baseDelay = Math.min(policy.initialBackoffMs * Math.pow(policy.multiplier, attempt - 1), policy.maxBackoffMs);
+	if (policy.jitter) {
+		const jitterFactor = .8 + Math.random() * .4;
+		return Math.floor(baseDelay * jitterFactor);
+	}
+	return baseDelay;
+}
+/**
+* Define a typed job type.
+*/
+function defineJobType(def) {
+	return def;
+}
+
+//#endregion
+export { DEFAULT_RETRY_POLICY, calculateBackoff, defineJobType };

package/dist/jobs/scaleway-sqs-queue.js

@@ -1 +1,153 @@
-import{DEFAULT_RETRY_POLICY as e}from"./queue.js";import{randomUUID as t}from"crypto";import{DeleteMessageCommand as n,ReceiveMessageCommand as r,SQSClient as i,SendMessageCommand as a}from"@aws-sdk/client-sqs";var o=class{sqs;queueUrl;waitTimeSeconds;maxNumberOfMessages;visibilityTimeoutSeconds;handlers=new Map;running=!1;constructor(e){let t=process.env.SCALEWAY_ACCESS_KEY_QUEUE,n=process.env.SCALEWAY_SECRET_KEY_QUEUE;if(!t||!n)throw Error(`Missing SCALEWAY_ACCESS_KEY_QUEUE / SCALEWAY_SECRET_KEY_QUEUE in env`);this.sqs=new i({region:e.region??process.env.SCALEWAY_REGION??`par`,endpoint:`https://sqs.mnq.fr-par.scaleway.com`,credentials:{accessKeyId:t,secretAccessKey:n}}),this.queueUrl=e.queueUrl,this.waitTimeSeconds=e.waitTimeSeconds??20,this.maxNumberOfMessages=e.maxNumberOfMessages??5,this.visibilityTimeoutSeconds=e.visibilityTimeoutSeconds??60}async enqueue(n,r,i={}){let o=t(),s=new Date,c={id:o,type:n,payload:r};return await this.sqs.send(new a({QueueUrl:this.queueUrl,MessageBody:JSON.stringify(c),DelaySeconds:i.delaySeconds??0})),{id:o,type:n,version:1,payload:r,status:`pending`,priority:i.priority??0,attempts:0,maxRetries:i.maxRetries??e.maxRetries,createdAt:s,updatedAt:s}}register(e,t){if(this.handlers.has(e))throw Error(`Handler already registered for job type "${e}"`);this.handlers.set(e,t)}start(){this.running||(this.running=!0,this.pollLoop().catch(e=>{console.error(`[queue] Fatal error in poll loop`,e),process.exit(1)}))}async stop(){this.running=!1}async pollLoop(){for(console.log(`[queue] SQS worker started for queue:`,this.queueUrl);this.running;)try{let t=(await this.sqs.send(new r({QueueUrl:this.queueUrl,MaxNumberOfMessages:this.maxNumberOfMessages,WaitTimeSeconds:this.waitTimeSeconds,VisibilityTimeout:this.visibilityTimeoutSeconds,MessageSystemAttributeNames:[`ApproximateReceiveCount`]}))).Messages??[];if(t.length===0)continue;for(let n of t){if(!n.Body||!n.ReceiptHandle){console.warn(`[queue] Message missing Body or ReceiptHandle`,n.MessageId);continue}let t;try{t=JSON.parse(n.Body)}catch(e){console.error(`[queue] Failed to parse message body (id=${n.MessageId}), deleting`,e),await this.deleteMessage(n.ReceiptHandle);continue}let r=this.handlers.get(t.type);if(!r){console.error(`[queue] No handler registered for type "${t.type}", deleting message`),await this.deleteMessage(n.ReceiptHandle);continue}let i=new Date,a=parseInt(n.Attributes?.ApproximateReceiveCount??`1`,10),o={id:t.id,type:t.type,version:1,payload:t.payload,status:`pending`,priority:0,attempts:a,maxRetries:e.maxRetries,createdAt:i,updatedAt:i};o.status=`running`,o.updatedAt=new Date;try{await r(o),o.status=`completed`,o.updatedAt=new Date,await this.deleteMessage(n.ReceiptHandle)}catch(e){o.status=`failed`,o.lastError=e instanceof Error?e.message:`Unknown job error`,o.updatedAt=new Date,console.error(`[queue] Error while handling job type=${o.type} id=${o.id}`,e)}}}catch(e){e&&typeof e==`object`&&`$response`in e?console.error(`[queue] Error while polling SQS`,e,e.$response):console.error(`[queue] Error while polling SQS`,e),await this.sleep(5e3)}console.log(`[queue] SQS worker stopped`)}async deleteMessage(e){try{await this.sqs.send(new n({QueueUrl:this.queueUrl,ReceiptHandle:e}))}catch(e){console.error(`[queue] Failed to delete message`,e)}}async sleep(e){await new Promise(t=>setTimeout(t,e))}};export{o as ScalewaySqsJobQueue};
+import { DEFAULT_RETRY_POLICY } from "./queue.js";
+import { randomUUID } from "crypto";
+import { DeleteMessageCommand, ReceiveMessageCommand, SQSClient, SendMessageCommand } from "@aws-sdk/client-sqs";
+
+//#region src/jobs/scaleway-sqs-queue.ts
+var ScalewaySqsJobQueue = class {
+	sqs;
+	queueUrl;
+	waitTimeSeconds;
+	maxNumberOfMessages;
+	visibilityTimeoutSeconds;
+	handlers = /* @__PURE__ */ new Map();
+	running = false;
+	constructor(config) {
+		const accessKeyId = process.env.SCALEWAY_ACCESS_KEY_QUEUE;
+		const secretAccessKey = process.env.SCALEWAY_SECRET_KEY_QUEUE;
+		if (!accessKeyId || !secretAccessKey) throw new Error("Missing SCALEWAY_ACCESS_KEY_QUEUE / SCALEWAY_SECRET_KEY_QUEUE in env");
+		this.sqs = new SQSClient({
+			region: config.region ?? process.env.SCALEWAY_REGION ?? "par",
+			endpoint: "https://sqs.mnq.fr-par.scaleway.com",
+			credentials: {
+				accessKeyId,
+				secretAccessKey
+			}
+		});
+		this.queueUrl = config.queueUrl;
+		this.waitTimeSeconds = config.waitTimeSeconds ?? 20;
+		this.maxNumberOfMessages = config.maxNumberOfMessages ?? 5;
+		this.visibilityTimeoutSeconds = config.visibilityTimeoutSeconds ?? 60;
+	}
+	async enqueue(jobType, payload, options = {}) {
+		const id = randomUUID();
+		const now = /* @__PURE__ */ new Date();
+		const envelope = {
+			id,
+			type: jobType,
+			payload
+		};
+		await this.sqs.send(new SendMessageCommand({
+			QueueUrl: this.queueUrl,
+			MessageBody: JSON.stringify(envelope),
+			DelaySeconds: options.delaySeconds ?? 0
+		}));
+		return {
+			id,
+			type: jobType,
+			version: 1,
+			payload,
+			status: "pending",
+			priority: options.priority ?? 0,
+			attempts: 0,
+			maxRetries: options.maxRetries ?? DEFAULT_RETRY_POLICY.maxRetries,
+			createdAt: now,
+			updatedAt: now
+		};
+	}
+	register(jobType, handler) {
+		if (this.handlers.has(jobType)) throw new Error(`Handler already registered for job type "${jobType}"`);
+		this.handlers.set(jobType, handler);
+	}
+	start() {
+		if (this.running) return;
+		this.running = true;
+		this.pollLoop().catch((err) => {
+			console.error("[queue] Fatal error in poll loop", err);
+			process.exit(1);
+		});
+	}
+	async stop() {
+		this.running = false;
+	}
+	async pollLoop() {
+		console.log("[queue] SQS worker started for queue:", this.queueUrl);
+		while (this.running) try {
+			const messages = (await this.sqs.send(new ReceiveMessageCommand({
+				QueueUrl: this.queueUrl,
+				MaxNumberOfMessages: this.maxNumberOfMessages,
+				WaitTimeSeconds: this.waitTimeSeconds,
+				VisibilityTimeout: this.visibilityTimeoutSeconds,
+				MessageSystemAttributeNames: ["ApproximateReceiveCount"]
+			}))).Messages ?? [];
+			if (messages.length === 0) continue;
+			for (const msg of messages) {
+				if (!msg.Body || !msg.ReceiptHandle) {
+					console.warn("[queue] Message missing Body or ReceiptHandle", msg.MessageId);
+					continue;
+				}
+				let envelope;
+				try {
+					envelope = JSON.parse(msg.Body);
+				} catch (err) {
+					console.error(`[queue] Failed to parse message body (id=${msg.MessageId}), deleting`, err);
+					await this.deleteMessage(msg.ReceiptHandle);
+					continue;
+				}
+				const handler = this.handlers.get(envelope.type);
+				if (!handler) {
+					console.error(`[queue] No handler registered for type "${envelope.type}", deleting message`);
+					await this.deleteMessage(msg.ReceiptHandle);
+					continue;
+				}
+				const now = /* @__PURE__ */ new Date();
+				const attempts = parseInt(msg.Attributes?.ApproximateReceiveCount ?? "1", 10);
+				const job = {
+					id: envelope.id,
+					type: envelope.type,
+					version: 1,
+					payload: envelope.payload,
+					status: "pending",
+					priority: 0,
+					attempts,
+					maxRetries: DEFAULT_RETRY_POLICY.maxRetries,
+					createdAt: now,
+					updatedAt: now
+				};
+				job.status = "running";
+				job.updatedAt = /* @__PURE__ */ new Date();
+				try {
+					await handler(job);
+					job.status = "completed";
+					job.updatedAt = /* @__PURE__ */ new Date();
+					await this.deleteMessage(msg.ReceiptHandle);
+				} catch (err) {
+					job.status = "failed";
+					job.lastError = err instanceof Error ? err.message : "Unknown job error";
+					job.updatedAt = /* @__PURE__ */ new Date();
+					console.error(`[queue] Error while handling job type=${job.type} id=${job.id}`, err);
+				}
+			}
+		} catch (err) {
+			if (!!err && typeof err === "object" && "$response" in err) console.error("[queue] Error while polling SQS", err, err.$response);
+			else console.error("[queue] Error while polling SQS", err);
+			await this.sleep(5e3);
+		}
+		console.log("[queue] SQS worker stopped");
+	}
+	async deleteMessage(receiptHandle) {
+		try {
+			await this.sqs.send(new DeleteMessageCommand({
+				QueueUrl: this.queueUrl,
+				ReceiptHandle: receiptHandle
+			}));
+		} catch (err) {
+			console.error("[queue] Failed to delete message", err);
+		}
+	}
+	async sleep(ms) {
+		await new Promise((resolve) => setTimeout(resolve, ms));
+	}
+};
+
+//#endregion
+export { ScalewaySqsJobQueue };

package/dist/jsonschema.d.ts

@@ -1,13 +1,13 @@
 import { Stability, Tag } from "./ownership.js";
 import { ContractSpec, OpKind } from "./spec.js";
 import z from "zod";
-import * as _lssm_lib_schema84 from "@lssm/lib.schema";
+import * as _lssm_lib_schema0 from "@lssm/lib.schema";
 import { AnySchemaModel } from "@lssm/lib.schema";
 
 //#region src/jsonschema.d.ts
 declare function jsonSchemaForSpec(spec: ContractSpec<AnySchemaModel, AnySchemaModel>): {
-  input: z.core.ZodStandardJSONSchemaPayload<_lssm_lib_schema84.TopLevelZodFromModel<_lssm_lib_schema84.SchemaModelFieldsAnyConfig<AnySchemaModel | _lssm_lib_schema84.AnyFieldType | _lssm_lib_schema84.AnyEnumType>>> | null;
-  output: z.core.ZodStandardJSONSchemaPayload<_lssm_lib_schema84.TopLevelZodFromModel<_lssm_lib_schema84.SchemaModelFieldsAnyConfig<AnySchemaModel | _lssm_lib_schema84.AnyFieldType | _lssm_lib_schema84.AnyEnumType>>> | null;
+  input: z.core.ZodStandardJSONSchemaPayload<_lssm_lib_schema0.TopLevelZodFromModel<_lssm_lib_schema0.SchemaModelFieldsAnyConfig<AnySchemaModel | _lssm_lib_schema0.AnyFieldType | _lssm_lib_schema0.AnyEnumType>>> | null;
+  output: z.core.ZodStandardJSONSchemaPayload<_lssm_lib_schema0.TopLevelZodFromModel<_lssm_lib_schema0.SchemaModelFieldsAnyConfig<AnySchemaModel | _lssm_lib_schema0.AnyFieldType | _lssm_lib_schema0.AnyEnumType>>> | null;
   meta: {
     name: string;
     version: number;

package/dist/jsonschema.js

@@ -1 +1,32 @@
-import e from"zod";function t(t){return{input:t.io.input?e.toJSONSchema(t.io.input.getZod()):null,output:t.io.output?e.toJSONSchema(t.io.output.getZod()):null,meta:{name:t.meta.name,version:t.meta.version,kind:t.meta.kind,description:t.meta.description,tags:t.meta.tags??[],stability:t.meta.stability??`stable`}}}function n(e,t){return`/${e.replace(/\./g,`/`)}/v${t}`}function r(e,t){return`${e}.v${t}`}function i(e,t){return`${e.replace(/\./g,`_`)}_v${t}`}export{i as defaultGqlField,r as defaultMcpTool,n as defaultRestPath,t as jsonSchemaForSpec};
+import z from "zod";
+
+//#region src/jsonschema.ts
+function jsonSchemaForSpec(spec) {
+	return {
+		input: spec.io.input ? z.toJSONSchema(spec.io.input.getZod()) : null,
+		output: spec.io.output ? z.toJSONSchema(spec.io.output.getZod()) : null,
+		meta: {
+			name: spec.meta.name,
+			version: spec.meta.version,
+			kind: spec.meta.kind,
+			description: spec.meta.description,
+			tags: spec.meta.tags ?? [],
+			stability: spec.meta.stability ?? "stable"
+		}
+	};
+}
+/** Helper to derive default REST path */
+function defaultRestPath(name, version) {
+	return `/${name.replace(/\./g, "/")}/v${version}`;
+}
+/** Helper to derive default MCP tool name */
+function defaultMcpTool(name, version) {
+	return `${name}.v${version}`;
+}
+/** Helper to derive default GraphQL field name */
+function defaultGqlField(name, version) {
+	return `${name.replace(/\./g, "_")}_v${version}`;
+}
+
+//#endregion
+export { defaultGqlField, defaultMcpTool, defaultRestPath, jsonSchemaForSpec };