@blokjs/trigger-pubsub 1.1.0 → 1.2.0

package/dist/adapters/GCPPubSubAdapter.js

@@ -98,6 +98,17 @@ export class GCPPubSubAdapter {
             },
             maxAckDeadline: Duration.from({ seconds: config.ackDeadline || 30 }),
         });
+        // `deadLetterTopic` / `filter` are set at the GCP subscription
+        // resource level — they can only be provisioned at create time (or
+        // via setMetadata for the dead-letter policy). Reconcile them here:
+        // create the subscription with the requested policy, or if it
+        // already exists, verify it matches and throw on a mismatch rather
+        // than silently ignoring the author's intent.
+        await this.reconcileSubscriptionConfig(subscription, subscriptionName, config);
+        // Translate `startFrom` into a GCP seek BEFORE attaching listeners,
+        // so replay happens before the streaming pull starts delivering.
+        // GCP seeks by timestamp/snapshot; there is no sequence-number seek.
+        await this.applyStartFrom(subscription, config.startFrom);
         // Message handler
         const messageHandler = async (gcpMessage) => {
             // Parse message data
@@ -144,6 +155,71 @@ export class GCPPubSubAdapter {
         this.subscriptions.set(subscriptionName, subscription);
         console.log(`[GCPPubSubAdapter] Subscribed to: ${subscriptionName}`);
     }
+    /**
+     * Translate `startFrom` into a GCP `subscription.seek()`.
+     *
+     * - `"latest"` / unset → no-op (streaming pull already delivers only
+     *   messages published after the subscriber attaches).
+     * - `"earliest"` → seek to the epoch; GCP clamps to the retention floor
+     *   and replays everything still retained.
+     * - `{ timestamp }` (unix seconds) → seek to that wall-clock instant.
+     * - `{ seq }` → rejected: GCP Pub/Sub has no sequence-number cursor.
+     */
+    async applyStartFrom(subscription, startFrom) {
+        if (startFrom === undefined || startFrom === "latest")
+            return;
+        if (startFrom === "earliest") {
+            await subscription.seek(new Date(0));
+            return;
+        }
+        if ("timestamp" in startFrom) {
+            await subscription.seek(new Date(startFrom.timestamp * 1000));
+            return;
+        }
+        // { seq } — GCP Pub/Sub seeks by timestamp or snapshot only; there is
+        // no offset/sequence cursor. Reject loudly instead of silently
+        // dropping the author's replay intent.
+        throw new Error("[GCPPubSubAdapter] startFrom `{seq}` is not supported — GCP Pub/Sub seeks by timestamp or snapshot only. Use `{timestamp}`, `earliest`, or `latest`.");
+    }
+    /**
+     * Provision `deadLetterTopic` / `filter` on the subscription resource.
+     *
+     * These are create-time properties in GCP. When the subscription does
+     * not yet exist we create it with the requested policy/filter. When it
+     * already exists we verify the live metadata matches — `filter` is
+     * immutable so a mismatch throws; a dead-letter mismatch is patched via
+     * `setMetadata` (the one field GCP lets you change after creation).
+     */
+    async reconcileSubscriptionConfig(subscription, subscriptionName, config) {
+        if (!config.deadLetterTopic && !config.filter)
+            return;
+        const deadLetterPolicy = config.deadLetterTopic
+            ? { deadLetterTopic: this.requireClient().topic(config.deadLetterTopic).name }
+            : undefined;
+        const [exists] = await subscription.exists();
+        if (!exists) {
+            // A subscription obtained via `client.subscription(name)` is
+            // detached from its topic and the SDK refuses to `.create()` it
+            // ("Subscriptions can only be created when accessed through
+            // Topics"). Create through the topic instead.
+            await this.requireClient()
+                .topic(config.topic)
+                .createSubscription(subscriptionName, {
+                ...(config.filter ? { filter: config.filter } : {}),
+                ...(deadLetterPolicy ? { deadLetterPolicy } : {}),
+            });
+            return;
+        }
+        const [metadata] = await subscription.getMetadata();
+        // `filter` is immutable after creation — a mismatch means the caller
+        // asked for a filter the pre-existing subscription can't honor.
+        if (config.filter && (metadata.filter || "") !== config.filter) {
+            throw new Error(`[GCPPubSubAdapter] subscription "${subscriptionName}" already exists with filter "${metadata.filter || ""}" which differs from the requested filter "${config.filter}". GCP filters are immutable; delete and recreate the subscription.`);
+        }
+        if (deadLetterPolicy && metadata.deadLetterPolicy?.deadLetterTopic !== deadLetterPolicy.deadLetterTopic) {
+            await subscription.setMetadata({ deadLetterPolicy });
+        }
+    }
     /**
      * Unsubscribe from a GCP Pub/Sub subscription
      */
@@ -195,4 +271,4 @@ export class GCPPubSubAdapter {
     }
 }
 export default GCPPubSubAdapter;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GCPPubSubAdapter.js","sourceRoot":"","sources":["../../src/adapters/GCPPubSubAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * GCPPubSubAdapter - Google Cloud Pub/Sub adapter for PubSubTrigger\n *\n * Uses @google-cloud/pubsub for GCP Pub/Sub connectivity.\n * Requires: npm install @google-cloud/pubsub\n *\n * Environment variables:\n * - GOOGLE_CLOUD_PROJECT: GCP project ID\n * - GOOGLE_APPLICATION_CREDENTIALS: Path to service account key file (optional if using default credentials)\n * - PUBSUB_EMULATOR_HOST: Pub/Sub emulator host for local development (optional)\n */\n\nimport type { PubSubTriggerOpts } from \"@blokjs/helper\";\nimport type { Message, PubSub, Subscription } from \"@google-cloud/pubsub\";\nimport { v4 as uuid } from \"uuid\";\nimport type { PubSubAdapter, PubSubMessage } from \"../PubSubTrigger\";\n\n/**\n * GCP Pub/Sub configuration\n */\nexport interface GCPPubSubConfig {\n\tprojectId?: string;\n\tcredentials?: {\n\t\tclient_email: string;\n\t\tprivate_key: string;\n\t};\n}\n\n/**\n * GCPPubSubAdapter - Google Cloud Pub/Sub implementation\n */\nexport class GCPPubSubAdapter implements PubSubAdapter {\n\treadonly provider = \"gcp\" as const;\n\n\tprivate client: PubSub | undefined;\n\tprivate subscriptions: Map<string, Subscription> = new Map();\n\tprivate connected = false;\n\tprivate config: GCPPubSubConfig;\n\n\t/**\n\t * Type-narrowing accessor for `this.client`. Field is undefined until\n\t * `connect()` runs.\n\t */\n\tprivate requireClient(): PubSub {\n\t\tif (!this.client) {\n\t\t\tthrow new Error(\"[GCPPubSubAdapter] client is not initialised — call connect() first\");\n\t\t}\n\t\treturn this.client;\n\t}\n\n\tconstructor(config?: GCPPubSubConfig) {\n\t\tthis.config = {\n\t\t\tprojectId: config?.projectId || process.env.GOOGLE_CLOUD_PROJECT,\n\t\t\tcredentials: config?.credentials,\n\t\t};\n\t}\n\n\t/**\n\t * Connect to GCP Pub/Sub\n\t */\n\tasync connect(): Promise<void> {\n\t\tif (this.connected) return;\n\n\t\ttry {\n\t\t\t// Dynamic import of @google-cloud/pubsub\n\t\t\tconst { PubSub } = await import(\"@google-cloud/pubsub\");\n\n\t\t\tthis.client = new PubSub({\n\t\t\t\tprojectId: this.config.projectId,\n\t\t\t\tcredentials: this.config.credentials,\n\t\t\t});\n\n\t\t\tthis.connected = true;\n\t\t\tconsole.log(`[GCPPubSubAdapter] Connected to GCP Pub/Sub: ${this.config.projectId}`);\n\t\t} catch (error) {\n\t\t\tthrow new Error(\n\t\t\t\t`Failed to connect to GCP Pub/Sub: ${(error as Error).message}. Make sure @google-cloud/pubsub is installed: npm install @google-cloud/pubsub`,\n\t\t\t);\n\t\t}\n\t}\n\n\t/**\n\t * Disconnect from GCP Pub/Sub\n\t */\n\tasync disconnect(): Promise<void> {\n\t\tif (!this.connected) return;\n\n\t\ttry {\n\t\t\t// Close all subscriptions\n\t\t\tfor (const [name, subscription] of this.subscriptions) {\n\t\t\t\tawait subscription.close();\n\t\t\t}\n\t\t\tthis.subscriptions.clear();\n\n\t\t\tawait this.requireClient().close();\n\t\t\tthis.connected = false;\n\t\t\tconsole.log(\"[GCPPubSubAdapter] Disconnected from GCP Pub/Sub\");\n\t\t} catch (error) {\n\t\t\tconsole.error(`[GCPPubSubAdapter] Error disconnecting: ${(error as Error).message}`);\n\t\t}\n\t}\n\n\t/**\n\t * Subscribe to a GCP Pub/Sub topic\n\t */\n\tasync subscribe(config: PubSubTriggerOpts, handler: (message: PubSubMessage) => Promise<void>): Promise<void> {\n\t\tif (!this.connected) {\n\t\t\tthrow new Error(\"Not connected to GCP Pub/Sub. Call connect() first.\");\n\t\t}\n\n\t\tif (!config.subscription) {\n\t\t\tthrow new Error(\"[GCPPubSubAdapter] `subscription` is required — must be the GCP subscription name.\");\n\t\t}\n\t\tconst subscriptionName = config.subscription;\n\n\t\t// Get the subscription. The GCP SDK calls the per-subscription\n\t\t// deadline `maxAckDeadline` (a `Duration`); our author-facing\n\t\t// field is `ackDeadline` (seconds) for parity with other\n\t\t// providers. `Duration` is the GCP SDK's tc39-Temporal-shaped\n\t\t// shim — construct via `Duration.from({seconds})`.\n\t\tconst { Duration } = await import(\"@google-cloud/pubsub\");\n\t\tconst subscription = this.requireClient().subscription(subscriptionName, {\n\t\t\tflowControl: {\n\t\t\t\tmaxMessages: config.maxMessages || 10,\n\t\t\t},\n\t\t\tmaxAckDeadline: Duration.from({ seconds: config.ackDeadline || 30 }),\n\t\t});\n\n\t\t// Message handler\n\t\tconst messageHandler = async (gcpMessage: Message) => {\n\t\t\t// Parse message data\n\t\t\tlet body: unknown;\n\t\t\ttry {\n\t\t\t\tconst data = gcpMessage.data.toString();\n\t\t\t\tbody = JSON.parse(data);\n\t\t\t} catch {\n\t\t\t\tbody = gcpMessage.data.toString();\n\t\t\t}\n\n\t\t\t// Create pub/sub message\n\t\t\tconst pubsubMessage: PubSubMessage = {\n\t\t\t\tid: gcpMessage.id || uuid(),\n\t\t\t\tbody,\n\t\t\t\tattributes: gcpMessage.attributes || {},\n\t\t\t\traw: gcpMessage,\n\t\t\t\ttopic: config.topic,\n\t\t\t\tsubscription: subscriptionName,\n\t\t\t\tpublishTime: gcpMessage.publishTime ? new Date(gcpMessage.publishTime) : new Date(),\n\t\t\t\tack: async () => {\n\t\t\t\t\tgcpMessage.ack();\n\t\t\t\t},\n\t\t\t\tnack: async () => {\n\t\t\t\t\tgcpMessage.nack();\n\t\t\t\t},\n\t\t\t};\n\n\t\t\t// Process message\n\t\t\ttry {\n\t\t\t\tawait handler(pubsubMessage);\n\t\t\t} catch (error) {\n\t\t\t\tconsole.error(`[GCPPubSubAdapter] Error processing message: ${(error as Error).message}`);\n\t\t\t}\n\t\t};\n\n\t\t// Error handler\n\t\tconst errorHandler = (error: Error) => {\n\t\t\tconsole.error(`[GCPPubSubAdapter] Subscription error: ${error.message}`);\n\t\t};\n\n\t\t// Attach listeners\n\t\tsubscription.on(\"message\", messageHandler);\n\t\tsubscription.on(\"error\", errorHandler);\n\n\t\t// Store subscription reference\n\t\tthis.subscriptions.set(subscriptionName, subscription);\n\n\t\tconsole.log(`[GCPPubSubAdapter] Subscribed to: ${subscriptionName}`);\n\t}\n\n\t/**\n\t * Unsubscribe from a GCP Pub/Sub subscription\n\t */\n\tasync unsubscribe(subscriptionName: string): Promise<void> {\n\t\tconst subscription = this.subscriptions.get(subscriptionName);\n\t\tif (subscription) {\n\t\t\tawait subscription.close();\n\t\t\tthis.subscriptions.delete(subscriptionName);\n\t\t\tconsole.log(`[GCPPubSubAdapter] Unsubscribed from: ${subscriptionName}`);\n\t\t}\n\t}\n\n\t/**\n\t * Check if connected to GCP Pub/Sub\n\t */\n\tisConnected(): boolean {\n\t\treturn this.connected;\n\t}\n\n\t/**\n\t * v0.7 PR 6 — publish to a GCP Pub/Sub topic.\n\t *\n\t * `partitionKey` / `orderingKey` map to GCP's `orderingKey` (the\n\t * topic must have message ordering enabled — otherwise the field\n\t * is ignored by the broker).\n\t */\n\tasync publish(\n\t\ttopic: string,\n\t\tpayload: unknown,\n\t\topts?: { partitionKey?: string; orderingKey?: string },\n\t): Promise<void> {\n\t\tif (!this.connected) throw new Error(\"[blok][pubsub-gcp] not connected. Call connect() first.\");\n\t\tconst body = typeof payload === \"string\" ? payload : JSON.stringify(payload);\n\t\tconst t = this.requireClient().topic(topic);\n\t\tawait t.publishMessage({\n\t\t\tdata: Buffer.from(body),\n\t\t\torderingKey: opts?.orderingKey ?? opts?.partitionKey,\n\t\t});\n\t}\n\n\t/**\n\t * Health check - verify GCP Pub/Sub connectivity\n\t */\n\tasync healthCheck(): Promise<boolean> {\n\t\tif (!this.connected) return false;\n\n\t\ttry {\n\t\t\t// List subscriptions as a health check\n\t\t\tconst [subscriptions] = await this.requireClient().getSubscriptions({ pageSize: 1 });\n\t\t\treturn true;\n\t\t} catch {\n\t\t\treturn false;\n\t\t}\n\t}\n}\n\nexport default GCPPubSubAdapter;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GCPPubSubAdapter.js","sourceRoot":"","sources":["../../src/adapters/GCPPubSubAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * GCPPubSubAdapter - Google Cloud Pub/Sub adapter for PubSubTrigger\n *\n * Uses @google-cloud/pubsub for GCP Pub/Sub connectivity.\n * Requires: npm install @google-cloud/pubsub\n *\n * Environment variables:\n * - GOOGLE_CLOUD_PROJECT: GCP project ID\n * - GOOGLE_APPLICATION_CREDENTIALS: Path to service account key file (optional if using default credentials)\n * - PUBSUB_EMULATOR_HOST: Pub/Sub emulator host for local development (optional)\n */\n\nimport type { PubSubTriggerOpts } from \"@blokjs/helper\";\nimport type { Message, PubSub, Subscription } from \"@google-cloud/pubsub\";\nimport { v4 as uuid } from \"uuid\";\nimport type { PubSubAdapter, PubSubMessage } from \"../PubSubTrigger\";\n\n/**\n * GCP Pub/Sub configuration\n */\nexport interface GCPPubSubConfig {\n\tprojectId?: string;\n\tcredentials?: {\n\t\tclient_email: string;\n\t\tprivate_key: string;\n\t};\n}\n\n/**\n * GCPPubSubAdapter - Google Cloud Pub/Sub implementation\n */\nexport class GCPPubSubAdapter implements PubSubAdapter {\n\treadonly provider = \"gcp\" as const;\n\n\tprivate client: PubSub | undefined;\n\tprivate subscriptions: Map<string, Subscription> = new Map();\n\tprivate connected = false;\n\tprivate config: GCPPubSubConfig;\n\n\t/**\n\t * Type-narrowing accessor for `this.client`. Field is undefined until\n\t * `connect()` runs.\n\t */\n\tprivate requireClient(): PubSub {\n\t\tif (!this.client) {\n\t\t\tthrow new Error(\"[GCPPubSubAdapter] client is not initialised — call connect() first\");\n\t\t}\n\t\treturn this.client;\n\t}\n\n\tconstructor(config?: GCPPubSubConfig) {\n\t\tthis.config = {\n\t\t\tprojectId: config?.projectId || process.env.GOOGLE_CLOUD_PROJECT,\n\t\t\tcredentials: config?.credentials,\n\t\t};\n\t}\n\n\t/**\n\t * Connect to GCP Pub/Sub\n\t */\n\tasync connect(): Promise<void> {\n\t\tif (this.connected) return;\n\n\t\ttry {\n\t\t\t// Dynamic import of @google-cloud/pubsub\n\t\t\tconst { PubSub } = await import(\"@google-cloud/pubsub\");\n\n\t\t\tthis.client = new PubSub({\n\t\t\t\tprojectId: this.config.projectId,\n\t\t\t\tcredentials: this.config.credentials,\n\t\t\t});\n\n\t\t\tthis.connected = true;\n\t\t\tconsole.log(`[GCPPubSubAdapter] Connected to GCP Pub/Sub: ${this.config.projectId}`);\n\t\t} catch (error) {\n\t\t\tthrow new Error(\n\t\t\t\t`Failed to connect to GCP Pub/Sub: ${(error as Error).message}. Make sure @google-cloud/pubsub is installed: npm install @google-cloud/pubsub`,\n\t\t\t);\n\t\t}\n\t}\n\n\t/**\n\t * Disconnect from GCP Pub/Sub\n\t */\n\tasync disconnect(): Promise<void> {\n\t\tif (!this.connected) return;\n\n\t\ttry {\n\t\t\t// Close all subscriptions\n\t\t\tfor (const [name, subscription] of this.subscriptions) {\n\t\t\t\tawait subscription.close();\n\t\t\t}\n\t\t\tthis.subscriptions.clear();\n\n\t\t\tawait this.requireClient().close();\n\t\t\tthis.connected = false;\n\t\t\tconsole.log(\"[GCPPubSubAdapter] Disconnected from GCP Pub/Sub\");\n\t\t} catch (error) {\n\t\t\tconsole.error(`[GCPPubSubAdapter] Error disconnecting: ${(error as Error).message}`);\n\t\t}\n\t}\n\n\t/**\n\t * Subscribe to a GCP Pub/Sub topic\n\t */\n\tasync subscribe(config: PubSubTriggerOpts, handler: (message: PubSubMessage) => Promise<void>): Promise<void> {\n\t\tif (!this.connected) {\n\t\t\tthrow new Error(\"Not connected to GCP Pub/Sub. Call connect() first.\");\n\t\t}\n\n\t\tif (!config.subscription) {\n\t\t\tthrow new Error(\"[GCPPubSubAdapter] `subscription` is required — must be the GCP subscription name.\");\n\t\t}\n\t\tconst subscriptionName = config.subscription;\n\n\t\t// Get the subscription. The GCP SDK calls the per-subscription\n\t\t// deadline `maxAckDeadline` (a `Duration`); our author-facing\n\t\t// field is `ackDeadline` (seconds) for parity with other\n\t\t// providers. `Duration` is the GCP SDK's tc39-Temporal-shaped\n\t\t// shim — construct via `Duration.from({seconds})`.\n\t\tconst { Duration } = await import(\"@google-cloud/pubsub\");\n\t\tconst subscription = this.requireClient().subscription(subscriptionName, {\n\t\t\tflowControl: {\n\t\t\t\tmaxMessages: config.maxMessages || 10,\n\t\t\t},\n\t\t\tmaxAckDeadline: Duration.from({ seconds: config.ackDeadline || 30 }),\n\t\t});\n\n\t\t// `deadLetterTopic` / `filter` are set at the GCP subscription\n\t\t// resource level — they can only be provisioned at create time (or\n\t\t// via setMetadata for the dead-letter policy). Reconcile them here:\n\t\t// create the subscription with the requested policy, or if it\n\t\t// already exists, verify it matches and throw on a mismatch rather\n\t\t// than silently ignoring the author's intent.\n\t\tawait this.reconcileSubscriptionConfig(subscription, subscriptionName, config);\n\n\t\t// Translate `startFrom` into a GCP seek BEFORE attaching listeners,\n\t\t// so replay happens before the streaming pull starts delivering.\n\t\t// GCP seeks by timestamp/snapshot; there is no sequence-number seek.\n\t\tawait this.applyStartFrom(subscription, config.startFrom);\n\n\t\t// Message handler\n\t\tconst messageHandler = async (gcpMessage: Message) => {\n\t\t\t// Parse message data\n\t\t\tlet body: unknown;\n\t\t\ttry {\n\t\t\t\tconst data = gcpMessage.data.toString();\n\t\t\t\tbody = JSON.parse(data);\n\t\t\t} catch {\n\t\t\t\tbody = gcpMessage.data.toString();\n\t\t\t}\n\n\t\t\t// Create pub/sub message\n\t\t\tconst pubsubMessage: PubSubMessage = {\n\t\t\t\tid: gcpMessage.id || uuid(),\n\t\t\t\tbody,\n\t\t\t\tattributes: gcpMessage.attributes || {},\n\t\t\t\traw: gcpMessage,\n\t\t\t\ttopic: config.topic,\n\t\t\t\tsubscription: subscriptionName,\n\t\t\t\tpublishTime: gcpMessage.publishTime ? new Date(gcpMessage.publishTime) : new Date(),\n\t\t\t\tack: async () => {\n\t\t\t\t\tgcpMessage.ack();\n\t\t\t\t},\n\t\t\t\tnack: async () => {\n\t\t\t\t\tgcpMessage.nack();\n\t\t\t\t},\n\t\t\t};\n\n\t\t\t// Process message\n\t\t\ttry {\n\t\t\t\tawait handler(pubsubMessage);\n\t\t\t} catch (error) {\n\t\t\t\tconsole.error(`[GCPPubSubAdapter] Error processing message: ${(error as Error).message}`);\n\t\t\t}\n\t\t};\n\n\t\t// Error handler\n\t\tconst errorHandler = (error: Error) => {\n\t\t\tconsole.error(`[GCPPubSubAdapter] Subscription error: ${error.message}`);\n\t\t};\n\n\t\t// Attach listeners\n\t\tsubscription.on(\"message\", messageHandler);\n\t\tsubscription.on(\"error\", errorHandler);\n\n\t\t// Store subscription reference\n\t\tthis.subscriptions.set(subscriptionName, subscription);\n\n\t\tconsole.log(`[GCPPubSubAdapter] Subscribed to: ${subscriptionName}`);\n\t}\n\n\t/**\n\t * Translate `startFrom` into a GCP `subscription.seek()`.\n\t *\n\t * - `\"latest\"` / unset → no-op (streaming pull already delivers only\n\t *   messages published after the subscriber attaches).\n\t * - `\"earliest\"` → seek to the epoch; GCP clamps to the retention floor\n\t *   and replays everything still retained.\n\t * - `{ timestamp }` (unix seconds) → seek to that wall-clock instant.\n\t * - `{ seq }` → rejected: GCP Pub/Sub has no sequence-number cursor.\n\t */\n\tprivate async applyStartFrom(subscription: Subscription, startFrom: PubSubTriggerOpts[\"startFrom\"]): Promise<void> {\n\t\tif (startFrom === undefined || startFrom === \"latest\") return;\n\t\tif (startFrom === \"earliest\") {\n\t\t\tawait subscription.seek(new Date(0));\n\t\t\treturn;\n\t\t}\n\t\tif (\"timestamp\" in startFrom) {\n\t\t\tawait subscription.seek(new Date(startFrom.timestamp * 1000));\n\t\t\treturn;\n\t\t}\n\t\t// { seq } — GCP Pub/Sub seeks by timestamp or snapshot only; there is\n\t\t// no offset/sequence cursor. Reject loudly instead of silently\n\t\t// dropping the author's replay intent.\n\t\tthrow new Error(\n\t\t\t\"[GCPPubSubAdapter] startFrom `{seq}` is not supported — GCP Pub/Sub seeks by timestamp or snapshot only. Use `{timestamp}`, `earliest`, or `latest`.\",\n\t\t);\n\t}\n\n\t/**\n\t * Provision `deadLetterTopic` / `filter` on the subscription resource.\n\t *\n\t * These are create-time properties in GCP. When the subscription does\n\t * not yet exist we create it with the requested policy/filter. When it\n\t * already exists we verify the live metadata matches — `filter` is\n\t * immutable so a mismatch throws; a dead-letter mismatch is patched via\n\t * `setMetadata` (the one field GCP lets you change after creation).\n\t */\n\tprivate async reconcileSubscriptionConfig(\n\t\tsubscription: Subscription,\n\t\tsubscriptionName: string,\n\t\tconfig: PubSubTriggerOpts,\n\t): Promise<void> {\n\t\tif (!config.deadLetterTopic && !config.filter) return;\n\n\t\tconst deadLetterPolicy = config.deadLetterTopic\n\t\t\t? { deadLetterTopic: this.requireClient().topic(config.deadLetterTopic).name }\n\t\t\t: undefined;\n\n\t\tconst [exists] = await subscription.exists();\n\t\tif (!exists) {\n\t\t\t// A subscription obtained via `client.subscription(name)` is\n\t\t\t// detached from its topic and the SDK refuses to `.create()` it\n\t\t\t// (\"Subscriptions can only be created when accessed through\n\t\t\t// Topics\"). Create through the topic instead.\n\t\t\tawait this.requireClient()\n\t\t\t\t.topic(config.topic)\n\t\t\t\t.createSubscription(subscriptionName, {\n\t\t\t\t\t...(config.filter ? { filter: config.filter } : {}),\n\t\t\t\t\t...(deadLetterPolicy ? { deadLetterPolicy } : {}),\n\t\t\t\t});\n\t\t\treturn;\n\t\t}\n\n\t\tconst [metadata] = await subscription.getMetadata();\n\n\t\t// `filter` is immutable after creation — a mismatch means the caller\n\t\t// asked for a filter the pre-existing subscription can't honor.\n\t\tif (config.filter && (metadata.filter || \"\") !== config.filter) {\n\t\t\tthrow new Error(\n\t\t\t\t`[GCPPubSubAdapter] subscription \"${subscriptionName}\" already exists with filter \"${metadata.filter || \"\"}\" which differs from the requested filter \"${config.filter}\". GCP filters are immutable; delete and recreate the subscription.`,\n\t\t\t);\n\t\t}\n\n\t\tif (deadLetterPolicy && metadata.deadLetterPolicy?.deadLetterTopic !== deadLetterPolicy.deadLetterTopic) {\n\t\t\tawait subscription.setMetadata({ deadLetterPolicy });\n\t\t}\n\t}\n\n\t/**\n\t * Unsubscribe from a GCP Pub/Sub subscription\n\t */\n\tasync unsubscribe(subscriptionName: string): Promise<void> {\n\t\tconst subscription = this.subscriptions.get(subscriptionName);\n\t\tif (subscription) {\n\t\t\tawait subscription.close();\n\t\t\tthis.subscriptions.delete(subscriptionName);\n\t\t\tconsole.log(`[GCPPubSubAdapter] Unsubscribed from: ${subscriptionName}`);\n\t\t}\n\t}\n\n\t/**\n\t * Check if connected to GCP Pub/Sub\n\t */\n\tisConnected(): boolean {\n\t\treturn this.connected;\n\t}\n\n\t/**\n\t * v0.7 PR 6 — publish to a GCP Pub/Sub topic.\n\t *\n\t * `partitionKey` / `orderingKey` map to GCP's `orderingKey` (the\n\t * topic must have message ordering enabled — otherwise the field\n\t * is ignored by the broker).\n\t */\n\tasync publish(\n\t\ttopic: string,\n\t\tpayload: unknown,\n\t\topts?: { partitionKey?: string; orderingKey?: string },\n\t): Promise<void> {\n\t\tif (!this.connected) throw new Error(\"[blok][pubsub-gcp] not connected. Call connect() first.\");\n\t\tconst body = typeof payload === \"string\" ? payload : JSON.stringify(payload);\n\t\tconst t = this.requireClient().topic(topic);\n\t\tawait t.publishMessage({\n\t\t\tdata: Buffer.from(body),\n\t\t\torderingKey: opts?.orderingKey ?? opts?.partitionKey,\n\t\t});\n\t}\n\n\t/**\n\t * Health check - verify GCP Pub/Sub connectivity\n\t */\n\tasync healthCheck(): Promise<boolean> {\n\t\tif (!this.connected) return false;\n\n\t\ttry {\n\t\t\t// List subscriptions as a health check\n\t\t\tconst [subscriptions] = await this.requireClient().getSubscriptions({ pageSize: 1 });\n\t\t\treturn true;\n\t\t} catch {\n\t\t\treturn false;\n\t\t}\n\t}\n}\n\nexport default GCPPubSubAdapter;\n"]}

package/dist/adapters/KafkaPubSubAdapter.d.ts

@@ -10,10 +10,8 @@
  * Replay cursors via `startFrom`:
  *   - `"earliest"` → `fromBeginning: true` on first subscribe.
  *   - `"latest"` (default) → only new messages.
- *   - `{seq: N}` / `{timestamp: ms}` — provider-specific. Cleanest
- *     long-term path is Kafka's `admin.seek({offset|timestamp})` post-
- *     subscribe; v1 honors `earliest` / `latest` and `{seq}` via
- *     `auto.offset.reset` only.
+ *   - `{seq: N}` → `consumer.seek()` every assigned partition to offset N.
+ *   - `{timestamp: ms}` → resolve broker offsets at that timestamp, then seek.
  *
  * Requires `kafkajs` as a peer dependency.
  *
@@ -43,6 +41,7 @@ export declare class KafkaPubSubAdapter implements PubSubAdapter {
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     subscribe(config: PubSubTriggerOpts, handler: (message: PubSubMessage) => Promise<void>): Promise<void>;
+    private applyStartFrom;
     unsubscribe(subscription: string): Promise<void>;
     publish(topic: string, payload: unknown, opts?: {
         partitionKey?: string;

package/dist/adapters/KafkaPubSubAdapter.js

@@ -10,10 +10,8 @@
  * Replay cursors via `startFrom`:
  *   - `"earliest"` → `fromBeginning: true` on first subscribe.
  *   - `"latest"` (default) → only new messages.
- *   - `{seq: N}` / `{timestamp: ms}` — provider-specific. Cleanest
- *     long-term path is Kafka's `admin.seek({offset|timestamp})` post-
- *     subscribe; v1 honors `earliest` / `latest` and `{seq}` via
- *     `auto.offset.reset` only.
+ *   - `{seq: N}` → `consumer.seek()` every assigned partition to offset N.
+ *   - `{timestamp: ms}` → resolve broker offsets at that timestamp, then seek.
  *
  * Requires `kafkajs` as a peer dependency.
  *
@@ -94,6 +92,7 @@ export class KafkaPubSubAdapter {
         const groupId = config.consumerGroup ?? `blok-fanout-${uuid().slice(0, 8)}-${config.topic.replace(/[^a-zA-Z0-9_]/g, "_")}`;
         const consumer = this.kafka.consumer({ groupId });
         await consumer.connect();
+        const seekCursor = typeof config.startFrom === "object" ? config.startFrom : undefined;
         const fromBeginning = config.startFrom === "earliest";
         await consumer.subscribe({ topic: config.topic, fromBeginning });
         this.consumers.set(`${config.topic}#${groupId}`, consumer);
@@ -113,6 +112,13 @@ export class KafkaPubSubAdapter {
                     for (const [k, v] of Object.entries(message.headers))
                         attributes[k] = v?.toString("utf8") ?? "";
                 }
+                // kafkajs has no per-message nack; the ONLY way to suppress the
+                // auto-commit of a failed offset is to throw out of eachMessage.
+                // PubSubTrigger.handleMessage catches handler errors and calls
+                // nack() (it never re-throws), so without this flag the offset
+                // would auto-commit and the failed message would be lost. We set
+                // a flag on nack() and throw after the handler returns.
+                let nacked = false;
                 const msg = {
                     id: `${config.topic}:${message.offset}`,
                     body,
@@ -125,15 +131,41 @@ export class KafkaPubSubAdapter {
                         /* autoCommit handles ack */
                     },
                     nack: async () => {
-                        /* kafkajs has no per-message nack; the offset commit is suppressed by throwing */
+                        nacked = true;
                     },
                 };
-                // On handler failure: re-throw so kafkajs suppresses the
-                // offset commit; the consumer will re-poll the message
-                // on the next cycle. The throw is intentional.
                 await handler(msg);
+                // At-least-once (default): a nacked message must NOT be
+                // committed — throw so kafkajs redelivers it. At-most-once
+                // (ack:false) never commits per-message anyway, so a nack is a
+                // no-op there (the message is considered consumed once).
+                if (nacked && config.ack !== false) {
+                    throw new Error(`[blok][pubsub-kafka] message ${msg.id} nacked — suppressing offset commit for redelivery`);
+                }
             },
         });
+        if (seekCursor)
+            await this.applyStartFrom(consumer, config.topic, seekCursor);
+    }
+    async applyStartFrom(consumer, topic, cursor) {
+        const admin = this.kafka.admin();
+        await admin.connect();
+        try {
+            if ("seq" in cursor) {
+                const offset = String(cursor.seq);
+                const metadata = await admin.fetchTopicMetadata({ topics: [topic] });
+                for (const partition of metadata.topics[0]?.partitions ?? []) {
+                    consumer.seek({ topic, partition: partition.partitionId, offset });
+                }
+                return;
+            }
+            const offsets = await admin.fetchTopicOffsetsByTimestamp(topic, cursor.timestamp);
+            for (const { partition, offset } of offsets)
+                consumer.seek({ topic, partition, offset });
+        }
+        finally {
+            await admin.disconnect().catch(() => { });
+        }
     }
     async unsubscribe(subscription) {
         const consumer = this.consumers.get(subscription);
@@ -165,4 +197,4 @@ export class KafkaPubSubAdapter {
         return this.connected;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"KafkaPubSubAdapter.js","sourceRoot":"","sources":["../../src/adapters/KafkaPubSubAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * KafkaPubSubAdapter — v0.7 PR 6 — Pub/Sub adapter backed by Apache\n * Kafka via `kafkajs`.\n *\n * Pub/Sub vs Worker semantics: this adapter uses **per-subscriber\n * consumer groups** so multiple subscribers each receive every message\n * (fan-out). When `consumerGroup` is explicitly set, all subscribers\n * share that group and compete (1 of N gets each message).\n *\n * Replay cursors via `startFrom`:\n *   - `\"earliest\"` → `fromBeginning: true` on first subscribe.\n *   - `\"latest\"` (default) → only new messages.\n *   - `{seq: N}` / `{timestamp: ms}` — provider-specific. Cleanest\n *     long-term path is Kafka's `admin.seek({offset|timestamp})` post-\n *     subscribe; v1 honors `earliest` / `latest` and `{seq}` via\n *     `auto.offset.reset` only.\n *\n * Requires `kafkajs` as a peer dependency.\n *\n * Environment variables:\n *   - `KAFKA_BROKERS`           — comma-separated (default `localhost:9092`).\n *   - `KAFKA_CLIENT_ID`         — default `\"blok-pubsub\"`.\n *   - `KAFKA_SASL_USERNAME` / `KAFKA_SASL_PASSWORD`  — SASL/PLAIN.\n *   - `KAFKA_SSL`               — `\"true\"` enables TLS.\n */\n\nimport type { PubSubTriggerOpts } from \"@blokjs/helper\";\nimport { v4 as uuid } from \"uuid\";\nimport type { PubSubAdapter, PubSubMessage } from \"../PubSubTrigger\";\n\nexport interface KafkaPubSubConfig {\n\tbrokers: string[];\n\tclientId: string;\n\tsaslUsername?: string;\n\tsaslPassword?: string;\n\tssl: boolean;\n}\n\ninterface KafkaConsumerHandle {\n\tdisconnect: () => Promise<void>;\n\tstop: () => Promise<void>;\n}\n\nexport class KafkaPubSubAdapter implements PubSubAdapter {\n\treadonly provider = \"kafka\" as const;\n\tprivate readonly config: KafkaPubSubConfig;\n\t// biome-ignore lint/suspicious/noExplicitAny: kafkajs's exported `Kafka` constructor is loosely typed.\n\tprivate kafka: any = null;\n\t// biome-ignore lint/suspicious/noExplicitAny: producer is created lazily and typed loosely.\n\tprivate producer: any = null;\n\tprivate consumers: Map<string, KafkaConsumerHandle> = new Map();\n\tprivate connected = false;\n\n\tconstructor(config?: Partial<KafkaPubSubConfig>) {\n\t\tthis.config = {\n\t\t\tbrokers: config?.brokers ?? (process.env.KAFKA_BROKERS ?? \"localhost:9092\").split(\",\").map((s) => s.trim()),\n\t\t\tclientId: config?.clientId ?? process.env.KAFKA_CLIENT_ID ?? \"blok-pubsub\",\n\t\t\tsaslUsername: config?.saslUsername ?? process.env.KAFKA_SASL_USERNAME,\n\t\t\tsaslPassword: config?.saslPassword ?? process.env.KAFKA_SASL_PASSWORD,\n\t\t\tssl: config?.ssl ?? process.env.KAFKA_SSL === \"true\",\n\t\t};\n\t}\n\n\tasync connect(): Promise<void> {\n\t\tif (this.connected) return;\n\t\ttry {\n\t\t\t// biome-ignore lint/suspicious/noExplicitAny: kafkajs is a runtime peer dep.\n\t\t\tconst kafkajs: any = await import(\"kafkajs\");\n\t\t\tconst sasl =\n\t\t\t\tthis.config.saslUsername && this.config.saslPassword\n\t\t\t\t\t? { mechanism: \"plain\", username: this.config.saslUsername, password: this.config.saslPassword }\n\t\t\t\t\t: undefined;\n\t\t\tthis.kafka = new kafkajs.Kafka({\n\t\t\t\tclientId: this.config.clientId,\n\t\t\t\tbrokers: this.config.brokers,\n\t\t\t\tssl: this.config.ssl,\n\t\t\t\tsasl,\n\t\t\t});\n\t\t\tthis.producer = this.kafka.producer();\n\t\t\tawait this.producer.connect();\n\t\t\tthis.connected = true;\n\t\t} catch (err) {\n\t\t\tthrow new Error(\n\t\t\t\t`[blok][pubsub-kafka] connect failed: ${(err as Error).message}. Install kafkajs as a peer dependency: bun add kafkajs`,\n\t\t\t);\n\t\t}\n\t}\n\n\tasync disconnect(): Promise<void> {\n\t\tif (!this.connected) return;\n\t\tfor (const consumer of this.consumers.values()) {\n\t\t\ttry {\n\t\t\t\tawait consumer.disconnect();\n\t\t\t} catch {\n\t\t\t\t/* ignore */\n\t\t\t}\n\t\t}\n\t\tthis.consumers.clear();\n\t\ttry {\n\t\t\tawait this.producer?.disconnect();\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t\tthis.producer = null;\n\t\tthis.connected = false;\n\t}\n\n\tasync subscribe(config: PubSubTriggerOpts, handler: (message: PubSubMessage) => Promise<void>): Promise<void> {\n\t\tif (!this.connected) throw new Error(\"[blok][pubsub-kafka] not connected. Call connect() first.\");\n\t\t// Fan-out: distinct group id per subscriber instance. Competing-\n\t\t// consumer: explicit consumerGroup shared across all subscribers.\n\t\tconst groupId =\n\t\t\tconfig.consumerGroup ?? `blok-fanout-${uuid().slice(0, 8)}-${config.topic.replace(/[^a-zA-Z0-9_]/g, \"_\")}`;\n\t\tconst consumer = this.kafka.consumer({ groupId });\n\t\tawait consumer.connect();\n\t\tconst fromBeginning = config.startFrom === \"earliest\";\n\t\tawait consumer.subscribe({ topic: config.topic, fromBeginning });\n\t\tthis.consumers.set(`${config.topic}#${groupId}`, consumer);\n\n\t\tawait consumer.run({\n\t\t\tautoCommit: config.ack !== false,\n\t\t\teachMessage: async ({\n\t\t\t\tmessage,\n\t\t\t}: {\n\t\t\t\tmessage: { key?: Buffer; value?: Buffer; offset: string; timestamp: string; headers?: Record<string, Buffer> };\n\t\t\t}) => {\n\t\t\t\tconst text = message.value?.toString(\"utf8\") ?? \"\";\n\t\t\t\tlet body: unknown = text;\n\t\t\t\ttry {\n\t\t\t\t\tbody = text.length > 0 ? JSON.parse(text) : null;\n\t\t\t\t} catch {\n\t\t\t\t\t/* leave as text */\n\t\t\t\t}\n\t\t\t\tconst attributes: Record<string, string> = {};\n\t\t\t\tif (message.headers) {\n\t\t\t\t\tfor (const [k, v] of Object.entries(message.headers)) attributes[k] = v?.toString(\"utf8\") ?? \"\";\n\t\t\t\t}\n\t\t\t\tconst msg: PubSubMessage = {\n\t\t\t\t\tid: `${config.topic}:${message.offset}`,\n\t\t\t\t\tbody,\n\t\t\t\t\tattributes,\n\t\t\t\t\traw: message,\n\t\t\t\t\ttopic: config.topic,\n\t\t\t\t\tsubscription: groupId,\n\t\t\t\t\tpublishTime: new Date(Number.parseInt(message.timestamp, 10)),\n\t\t\t\t\tack: async () => {\n\t\t\t\t\t\t/* autoCommit handles ack */\n\t\t\t\t\t},\n\t\t\t\t\tnack: async () => {\n\t\t\t\t\t\t/* kafkajs has no per-message nack; the offset commit is suppressed by throwing */\n\t\t\t\t\t},\n\t\t\t\t};\n\t\t\t\t// On handler failure: re-throw so kafkajs suppresses the\n\t\t\t\t// offset commit; the consumer will re-poll the message\n\t\t\t\t// on the next cycle. The throw is intentional.\n\t\t\t\tawait handler(msg);\n\t\t\t},\n\t\t});\n\t}\n\n\tasync unsubscribe(subscription: string): Promise<void> {\n\t\tconst consumer = this.consumers.get(subscription);\n\t\tif (!consumer) return;\n\t\ttry {\n\t\t\tawait consumer.stop();\n\t\t\tawait consumer.disconnect();\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t\tthis.consumers.delete(subscription);\n\t}\n\n\tasync publish(\n\t\ttopic: string,\n\t\tpayload: unknown,\n\t\topts?: { partitionKey?: string; orderingKey?: string },\n\t): Promise<void> {\n\t\tif (!this.connected || !this.producer) throw new Error(\"[blok][pubsub-kafka] not connected. Call connect() first.\");\n\t\tconst body = typeof payload === \"string\" ? payload : JSON.stringify(payload);\n\t\tconst key = opts?.partitionKey ?? opts?.orderingKey;\n\t\tawait this.producer.send({\n\t\t\ttopic,\n\t\t\tmessages: [{ key, value: body }],\n\t\t});\n\t}\n\n\tisConnected(): boolean {\n\t\treturn this.connected;\n\t}\n\n\tasync healthCheck(): Promise<boolean> {\n\t\treturn this.connected;\n\t}\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"KafkaPubSubAdapter.js","sourceRoot":"","sources":["../../src/adapters/KafkaPubSubAdapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,EAAE,EAAE,IAAI,IAAI,EAAE,MAAM,MAAM,CAAC;AAuClC,MAAM,OAAO,kBAAkB;IACrB,QAAQ,GAAG,OAAgB,CAAC;IACpB,MAAM,CAAoB;IAC3C,uGAAuG;IAC/F,KAAK,GAAQ,IAAI,CAAC;IAC1B,4FAA4F;IACpF,QAAQ,GAAQ,IAAI,CAAC;IACrB,SAAS,GAAqC,IAAI,GAAG,EAAE,CAAC;IACxD,SAAS,GAAG,KAAK,CAAC;IAE1B,YAAY,MAAmC;QAC9C,IAAI,CAAC,MAAM,GAAG;YACb,OAAO,EAAE,MAAM,EAAE,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,IAAI,gBAAgB,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;YAC3G,QAAQ,EAAE,MAAM,EAAE,QAAQ,IAAI,OAAO,CAAC,GAAG,CAAC,eAAe,IAAI,aAAa;YAC1E,YAAY,EAAE,MAAM,EAAE,YAAY,IAAI,OAAO,CAAC,GAAG,CAAC,mBAAmB;YACrE,YAAY,EAAE,MAAM,EAAE,YAAY,IAAI,OAAO,CAAC,GAAG,CAAC,mBAAmB;YACrE,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC,SAAS,KAAK,MAAM;SACpD,CAAC;IACH,CAAC;IAED,KAAK,CAAC,OAAO;QACZ,IAAI,IAAI,CAAC,SAAS;YAAE,OAAO;QAC3B,IAAI,CAAC;YACJ,6EAA6E;YAC7E,MAAM,OAAO,GAAQ,MAAM,MAAM,CAAC,SAAS,CAAC,CAAC;YAC7C,MAAM,IAAI,GACT,IAAI,CAAC,MAAM,CAAC,YAAY,IAAI,IAAI,CAAC,MAAM,CAAC,YAAY;gBACnD,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE;gBAChG,CAAC,CAAC,SAAS,CAAC;YACd,IAAI,CAAC,KAAK,GAAG,IAAI,OAAO,CAAC,KAAK,CAAC;gBAC9B,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ;gBAC9B,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO;gBAC5B,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG;gBACpB,IAAI;aACJ,CAAC,CAAC;YACH,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;YACtC,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;YAC9B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACvB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CACd,wCAAyC,GAAa,CAAC,OAAO,yDAAyD,CACvH,CAAC;QACH,CAAC;IACF,CAAC;IAED,KAAK,CAAC,UAAU;QACf,IAAI,CAAC,IAAI,CAAC,SAAS;YAAE,OAAO;QAC5B,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,EAAE,CAAC;YAChD,IAAI,CAAC;gBACJ,MAAM,QAAQ,CAAC,UAAU,EAAE,CAAC;YAC7B,CAAC;YAAC,MAAM,CAAC;gBACR,YAAY;YACb,CAAC;QACF,CAAC;QACD,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;QACvB,IAAI,CAAC;YACJ,MAAM,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE,CAAC;QACnC,CAAC;QAAC,MAAM,CAAC;YACR,YAAY;QACb,CAAC;QACD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;IACxB,CAAC;IAED,KAAK,CAAC,SAAS,CAAC,MAAyB,EAAE,OAAkD;QAC5F,IAAI,CAAC,IAAI,CAAC,SAAS;YAAE,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;QAClG,iEAAiE;QACjE,kEAAkE;QAClE,MAAM,OAAO,GACZ,MAAM,CAAC,aAAa,IAAI,eAAe,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,gBAAgB,EAAE,GAAG,CAAC,EAAE,CAAC;QAC5G,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAwB,CAAC;QACzE,MAAM,QAAQ,CAAC,OAAO,EAAE,CAAC;QACzB,MAAM,UAAU,GAAG,OAAO,MAAM,CAAC,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;QACvF,MAAM,aAAa,GAAG,MAAM,CAAC,SAAS,KAAK,UAAU,CAAC;QACtD,MAAM,QAAQ,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,aAAa,EAAE,CAAC,CAAC;QACjE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,KAAK,IAAI,OAAO,EAAE,EAAE,QAAQ,CAAC,CAAC;QAE3D,MAAM,QAAQ,CAAC,GAAG,CAAC;YAClB,UAAU,EAAE,MAAM,CAAC,GAAG,KAAK,KAAK;YAChC,WAAW,EAAE,KAAK,EAAE,EACnB,OAAO,GAGP,EAAE,EAAE;gBACJ,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;gBACnD,IAAI,IAAI,GAAY,IAAI,CAAC;gBACzB,IAAI,CAAC;oBACJ,IAAI,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;gBAClD,CAAC;gBAAC,MAAM,CAAC;oBACR,mBAAmB;gBACpB,CAAC;gBACD,MAAM,UAAU,GAA2B,EAAE,CAAC;gBAC9C,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;oBACrB,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC;wBAAE,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;gBACjG,CAAC;gBACD,gEAAgE;gBAChE,iEAAiE;gBACjE,+DAA+D;gBAC/D,+DAA+D;gBAC/D,iEAAiE;gBACjE,wDAAwD;gBACxD,IAAI,MAAM,GAAG,KAAK,CAAC;gBACnB,MAAM,GAAG,GAAkB;oBAC1B,EAAE,EAAE,GAAG,MAAM,CAAC,KAAK,IAAI,OAAO,CAAC,MAAM,EAAE;oBACvC,IAAI;oBACJ,UAAU;oBACV,GAAG,EAAE,OAAO;oBACZ,KAAK,EAAE,MAAM,CAAC,KAAK;oBACnB,YAAY,EAAE,OAAO;oBACrB,WAAW,EAAE,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;oBAC7D,GAAG,EAAE,KAAK,IAAI,EAAE;wBACf,4BAA4B;oBAC7B,CAAC;oBACD,IAAI,EAAE,KAAK,IAAI,EAAE;wBAChB,MAAM,GAAG,IAAI,CAAC;oBACf,CAAC;iBACD,CAAC;gBACF,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;gBACnB,wDAAwD;gBACxD,2DAA2D;gBAC3D,+DAA+D;gBAC/D,yDAAyD;gBACzD,IAAI,MAAM,IAAI,MAAM,CAAC,GAAG,KAAK,KAAK,EAAE,CAAC;oBACpC,MAAM,IAAI,KAAK,CAAC,gCAAgC,GAAG,CAAC,EAAE,oDAAoD,CAAC,CAAC;gBAC7G,CAAC;YACF,CAAC;SACD,CAAC,CAAC;QACH,IAAI,UAAU;YAAE,MAAM,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,MAAM,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;IAC/E,CAAC;IAEO,KAAK,CAAC,cAAc,CAAC,QAA6B,EAAE,KAAa,EAAE,MAAuB;QACjG,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,EAAsB,CAAC;QACrD,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC;QACtB,IAAI,CAAC;YACJ,IAAI,KAAK,IAAI,MAAM,EAAE,CAAC;gBACrB,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBAClC,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;gBACrE,KAAK,MAAM,SAAS,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,UAAU,IAAI,EAAE,EAAE,CAAC;oBAC9D,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC,CAAC;gBACpE,CAAC;gBACD,OAAO;YACR,CAAC;YACD,MAAM,OAAO,GAAG,MAAM,KAAK,CAAC,4BAA4B,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC;YAClF,KAAK,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,OAAO;gBAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAAC;QAC1F,CAAC;gBAAS,CAAC;YACV,MAAM,KAAK,CAAC,UAAU,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;QAC1C,CAAC;IACF,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,YAAoB;QACrC,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QAClD,IAAI,CAAC,QAAQ;YAAE,OAAO;QACtB,IAAI,CAAC;YACJ,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;YACtB,MAAM,QAAQ,CAAC,UAAU,EAAE,CAAC;QAC7B,CAAC;QAAC,MAAM,CAAC;YACR,YAAY;QACb,CAAC;QACD,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;IACrC,CAAC;IAED,KAAK,CAAC,OAAO,CACZ,KAAa,EACb,OAAgB,EAChB,IAAsD;QAEtD,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;QACpH,MAAM,IAAI,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QAC7E,MAAM,GAAG,GAAG,IAAI,EAAE,YAAY,IAAI,IAAI,EAAE,WAAW,CAAC;QACpD,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;YACxB,KAAK;YACL,QAAQ,EAAE,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;SAChC,CAAC,CAAC;IACJ,CAAC;IAED,WAAW;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACvB,CAAC;IAED,KAAK,CAAC,WAAW;QAChB,OAAO,IAAI,CAAC,SAAS,CAAC;IACvB,CAAC;CACD","sourcesContent":["/**\n * KafkaPubSubAdapter — v0.7 PR 6 — Pub/Sub adapter backed by Apache\n * Kafka via `kafkajs`.\n *\n * Pub/Sub vs Worker semantics: this adapter uses **per-subscriber\n * consumer groups** so multiple subscribers each receive every message\n * (fan-out). When `consumerGroup` is explicitly set, all subscribers\n * share that group and compete (1 of N gets each message).\n *\n * Replay cursors via `startFrom`:\n *   - `\"earliest\"` → `fromBeginning: true` on first subscribe.\n *   - `\"latest\"` (default) → only new messages.\n *   - `{seq: N}` → `consumer.seek()` every assigned partition to offset N.\n *   - `{timestamp: ms}` → resolve broker offsets at that timestamp, then seek.\n *\n * Requires `kafkajs` as a peer dependency.\n *\n * Environment variables:\n *   - `KAFKA_BROKERS`           — comma-separated (default `localhost:9092`).\n *   - `KAFKA_CLIENT_ID`         — default `\"blok-pubsub\"`.\n *   - `KAFKA_SASL_USERNAME` / `KAFKA_SASL_PASSWORD`  — SASL/PLAIN.\n *   - `KAFKA_SSL`               — `\"true\"` enables TLS.\n */\n\nimport type { PubSubTriggerOpts } from \"@blokjs/helper\";\nimport { v4 as uuid } from \"uuid\";\nimport type { PubSubAdapter, PubSubMessage } from \"../PubSubTrigger\";\n\nexport interface KafkaPubSubConfig {\n\tbrokers: string[];\n\tclientId: string;\n\tsaslUsername?: string;\n\tsaslPassword?: string;\n\tssl: boolean;\n}\n\ntype KafkaSeekCursor = Extract<PubSubTriggerOpts[\"startFrom\"], { seq: number } | { timestamp: number }>;\n\ninterface KafkaConsumerHandle {\n\tconnect: () => Promise<void>;\n\tdisconnect: () => Promise<void>;\n\trun: (opts: {\n\t\tautoCommit: boolean;\n\t\teachMessage: (payload: {\n\t\t\tmessage: { key?: Buffer; value?: Buffer; offset: string; timestamp: string; headers?: Record<string, Buffer> };\n\t\t}) => Promise<void>;\n\t}) => Promise<void>;\n\tseek: (opts: { topic: string; partition: number; offset: string }) => void;\n\tstop: () => Promise<void>;\n\tsubscribe: (opts: { topic: string; fromBeginning: boolean }) => Promise<void>;\n}\n\ninterface KafkaAdminClient {\n\tconnect: () => Promise<void>;\n\tdisconnect: () => Promise<void>;\n\tfetchTopicMetadata: (opts: { topics: string[] }) => Promise<{\n\t\ttopics: Array<{ partitions: Array<{ partitionId: number }> }>;\n\t}>;\n\tfetchTopicOffsetsByTimestamp: (\n\t\ttopic: string,\n\t\ttimestamp: number,\n\t) => Promise<Array<{ partition: number; offset: string }>>;\n}\n\nexport class KafkaPubSubAdapter implements PubSubAdapter {\n\treadonly provider = \"kafka\" as const;\n\tprivate readonly config: KafkaPubSubConfig;\n\t// biome-ignore lint/suspicious/noExplicitAny: kafkajs's exported `Kafka` constructor is loosely typed.\n\tprivate kafka: any = null;\n\t// biome-ignore lint/suspicious/noExplicitAny: producer is created lazily and typed loosely.\n\tprivate producer: any = null;\n\tprivate consumers: Map<string, KafkaConsumerHandle> = new Map();\n\tprivate connected = false;\n\n\tconstructor(config?: Partial<KafkaPubSubConfig>) {\n\t\tthis.config = {\n\t\t\tbrokers: config?.brokers ?? (process.env.KAFKA_BROKERS ?? \"localhost:9092\").split(\",\").map((s) => s.trim()),\n\t\t\tclientId: config?.clientId ?? process.env.KAFKA_CLIENT_ID ?? \"blok-pubsub\",\n\t\t\tsaslUsername: config?.saslUsername ?? process.env.KAFKA_SASL_USERNAME,\n\t\t\tsaslPassword: config?.saslPassword ?? process.env.KAFKA_SASL_PASSWORD,\n\t\t\tssl: config?.ssl ?? process.env.KAFKA_SSL === \"true\",\n\t\t};\n\t}\n\n\tasync connect(): Promise<void> {\n\t\tif (this.connected) return;\n\t\ttry {\n\t\t\t// biome-ignore lint/suspicious/noExplicitAny: kafkajs is a runtime peer dep.\n\t\t\tconst kafkajs: any = await import(\"kafkajs\");\n\t\t\tconst sasl =\n\t\t\t\tthis.config.saslUsername && this.config.saslPassword\n\t\t\t\t\t? { mechanism: \"plain\", username: this.config.saslUsername, password: this.config.saslPassword }\n\t\t\t\t\t: undefined;\n\t\t\tthis.kafka = new kafkajs.Kafka({\n\t\t\t\tclientId: this.config.clientId,\n\t\t\t\tbrokers: this.config.brokers,\n\t\t\t\tssl: this.config.ssl,\n\t\t\t\tsasl,\n\t\t\t});\n\t\t\tthis.producer = this.kafka.producer();\n\t\t\tawait this.producer.connect();\n\t\t\tthis.connected = true;\n\t\t} catch (err) {\n\t\t\tthrow new Error(\n\t\t\t\t`[blok][pubsub-kafka] connect failed: ${(err as Error).message}. Install kafkajs as a peer dependency: bun add kafkajs`,\n\t\t\t);\n\t\t}\n\t}\n\n\tasync disconnect(): Promise<void> {\n\t\tif (!this.connected) return;\n\t\tfor (const consumer of this.consumers.values()) {\n\t\t\ttry {\n\t\t\t\tawait consumer.disconnect();\n\t\t\t} catch {\n\t\t\t\t/* ignore */\n\t\t\t}\n\t\t}\n\t\tthis.consumers.clear();\n\t\ttry {\n\t\t\tawait this.producer?.disconnect();\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t\tthis.producer = null;\n\t\tthis.connected = false;\n\t}\n\n\tasync subscribe(config: PubSubTriggerOpts, handler: (message: PubSubMessage) => Promise<void>): Promise<void> {\n\t\tif (!this.connected) throw new Error(\"[blok][pubsub-kafka] not connected. Call connect() first.\");\n\t\t// Fan-out: distinct group id per subscriber instance. Competing-\n\t\t// consumer: explicit consumerGroup shared across all subscribers.\n\t\tconst groupId =\n\t\t\tconfig.consumerGroup ?? `blok-fanout-${uuid().slice(0, 8)}-${config.topic.replace(/[^a-zA-Z0-9_]/g, \"_\")}`;\n\t\tconst consumer = this.kafka.consumer({ groupId }) as KafkaConsumerHandle;\n\t\tawait consumer.connect();\n\t\tconst seekCursor = typeof config.startFrom === \"object\" ? config.startFrom : undefined;\n\t\tconst fromBeginning = config.startFrom === \"earliest\";\n\t\tawait consumer.subscribe({ topic: config.topic, fromBeginning });\n\t\tthis.consumers.set(`${config.topic}#${groupId}`, consumer);\n\n\t\tawait consumer.run({\n\t\t\tautoCommit: config.ack !== false,\n\t\t\teachMessage: async ({\n\t\t\t\tmessage,\n\t\t\t}: {\n\t\t\t\tmessage: { key?: Buffer; value?: Buffer; offset: string; timestamp: string; headers?: Record<string, Buffer> };\n\t\t\t}) => {\n\t\t\t\tconst text = message.value?.toString(\"utf8\") ?? \"\";\n\t\t\t\tlet body: unknown = text;\n\t\t\t\ttry {\n\t\t\t\t\tbody = text.length > 0 ? JSON.parse(text) : null;\n\t\t\t\t} catch {\n\t\t\t\t\t/* leave as text */\n\t\t\t\t}\n\t\t\t\tconst attributes: Record<string, string> = {};\n\t\t\t\tif (message.headers) {\n\t\t\t\t\tfor (const [k, v] of Object.entries(message.headers)) attributes[k] = v?.toString(\"utf8\") ?? \"\";\n\t\t\t\t}\n\t\t\t\t// kafkajs has no per-message nack; the ONLY way to suppress the\n\t\t\t\t// auto-commit of a failed offset is to throw out of eachMessage.\n\t\t\t\t// PubSubTrigger.handleMessage catches handler errors and calls\n\t\t\t\t// nack() (it never re-throws), so without this flag the offset\n\t\t\t\t// would auto-commit and the failed message would be lost. We set\n\t\t\t\t// a flag on nack() and throw after the handler returns.\n\t\t\t\tlet nacked = false;\n\t\t\t\tconst msg: PubSubMessage = {\n\t\t\t\t\tid: `${config.topic}:${message.offset}`,\n\t\t\t\t\tbody,\n\t\t\t\t\tattributes,\n\t\t\t\t\traw: message,\n\t\t\t\t\ttopic: config.topic,\n\t\t\t\t\tsubscription: groupId,\n\t\t\t\t\tpublishTime: new Date(Number.parseInt(message.timestamp, 10)),\n\t\t\t\t\tack: async () => {\n\t\t\t\t\t\t/* autoCommit handles ack */\n\t\t\t\t\t},\n\t\t\t\t\tnack: async () => {\n\t\t\t\t\t\tnacked = true;\n\t\t\t\t\t},\n\t\t\t\t};\n\t\t\t\tawait handler(msg);\n\t\t\t\t// At-least-once (default): a nacked message must NOT be\n\t\t\t\t// committed — throw so kafkajs redelivers it. At-most-once\n\t\t\t\t// (ack:false) never commits per-message anyway, so a nack is a\n\t\t\t\t// no-op there (the message is considered consumed once).\n\t\t\t\tif (nacked && config.ack !== false) {\n\t\t\t\t\tthrow new Error(`[blok][pubsub-kafka] message ${msg.id} nacked — suppressing offset commit for redelivery`);\n\t\t\t\t}\n\t\t\t},\n\t\t});\n\t\tif (seekCursor) await this.applyStartFrom(consumer, config.topic, seekCursor);\n\t}\n\n\tprivate async applyStartFrom(consumer: KafkaConsumerHandle, topic: string, cursor: KafkaSeekCursor): Promise<void> {\n\t\tconst admin = this.kafka.admin() as KafkaAdminClient;\n\t\tawait admin.connect();\n\t\ttry {\n\t\t\tif (\"seq\" in cursor) {\n\t\t\t\tconst offset = String(cursor.seq);\n\t\t\t\tconst metadata = await admin.fetchTopicMetadata({ topics: [topic] });\n\t\t\t\tfor (const partition of metadata.topics[0]?.partitions ?? []) {\n\t\t\t\t\tconsumer.seek({ topic, partition: partition.partitionId, offset });\n\t\t\t\t}\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tconst offsets = await admin.fetchTopicOffsetsByTimestamp(topic, cursor.timestamp);\n\t\t\tfor (const { partition, offset } of offsets) consumer.seek({ topic, partition, offset });\n\t\t} finally {\n\t\t\tawait admin.disconnect().catch(() => {});\n\t\t}\n\t}\n\n\tasync unsubscribe(subscription: string): Promise<void> {\n\t\tconst consumer = this.consumers.get(subscription);\n\t\tif (!consumer) return;\n\t\ttry {\n\t\t\tawait consumer.stop();\n\t\t\tawait consumer.disconnect();\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t\tthis.consumers.delete(subscription);\n\t}\n\n\tasync publish(\n\t\ttopic: string,\n\t\tpayload: unknown,\n\t\topts?: { partitionKey?: string; orderingKey?: string },\n\t): Promise<void> {\n\t\tif (!this.connected || !this.producer) throw new Error(\"[blok][pubsub-kafka] not connected. Call connect() first.\");\n\t\tconst body = typeof payload === \"string\" ? payload : JSON.stringify(payload);\n\t\tconst key = opts?.partitionKey ?? opts?.orderingKey;\n\t\tawait this.producer.send({\n\t\t\ttopic,\n\t\t\tmessages: [{ key, value: body }],\n\t\t});\n\t}\n\n\tisConnected(): boolean {\n\t\treturn this.connected;\n\t}\n\n\tasync healthCheck(): Promise<boolean> {\n\t\treturn this.connected;\n\t}\n}\n"]}

package/dist/adapters/NATSPubSubAdapter.js

@@ -108,25 +108,39 @@ export class NATSPubSubAdapter {
                 }
             }
             const js = this.conn.jetstream();
-            const startSeq = typeof config.startFrom === "object" && config.startFrom && "seq" in config.startFrom
-                ? config.startFrom.seq
-                : undefined;
-            const deliverPolicy = config.startFrom === "earliest"
-                ? "all"
-                : config.startFrom === "latest"
-                    ? "new"
-                    : startSeq !== undefined
-                        ? "by_start_sequence"
-                        : "all";
-            const sub = await js.subscribe(config.topic, {
-                config: {
-                    durable_name: config.consumerGroup ??
-                        `blok-${(config.subscription ?? config.topic ?? "default").replace(/[^a-zA-Z0-9_]/g, "_")}`,
-                    deliver_policy: deliverPolicy,
-                    opt_start_seq: startSeq,
-                    ack_policy: config.ack === false ? "none" : "explicit",
-                },
-            });
+            // nats.js `js.subscribe` needs a ConsumerOptsBuilder, NOT a raw
+            // `{ config }` object — only the builder installs the push
+            // `deliver_subject` JetStream requires. A raw config throws
+            // "push consumer requires deliver_subject" at runtime (the typed
+            // API accepts it, so tsc never catches this).
+            // biome-ignore lint/suspicious/noExplicitAny: nats is a runtime peer dep.
+            const nats = await import("nats");
+            const durableName = config.consumerGroup ??
+                `blok-${(config.subscription ?? config.topic ?? "default").replace(/[^a-zA-Z0-9_]/g, "_")}`;
+            const opts = nats.consumerOpts();
+            opts.durable(durableName);
+            opts.deliverTo(nats.createInbox());
+            opts.manualAck(); // dispatchJsMessage ack/naks explicitly
+            if (config.ack === false)
+                opts.ackNone();
+            else
+                opts.ackExplicit();
+            // Replay position: `earliest` = full retained history; `{seq}` /
+            // `{timestamp}` resume from a cursor; `latest` (and the default,
+            // per the schema) = new messages only.
+            if (config.startFrom === "earliest") {
+                opts.deliverAll();
+            }
+            else if (typeof config.startFrom === "object" && config.startFrom && "seq" in config.startFrom) {
+                opts.startSequence(config.startFrom.seq);
+            }
+            else if (typeof config.startFrom === "object" && config.startFrom && "timestamp" in config.startFrom) {
+                opts.startTime(new Date(config.startFrom.timestamp));
+            }
+            else {
+                opts.deliverNew();
+            }
+            const sub = await js.subscribe(config.topic, opts);
             this.subscriptions.set(subKey, { unsubscribe: () => sub.unsubscribe() });
             // Drive the async iterator in a background loop.
             void (async () => {
@@ -257,4 +271,4 @@ export class NATSPubSubAdapter {
         return this.connected;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"NATSPubSubAdapter.js","sourceRoot":"","sources":["../../src/adapters/NATSPubSubAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * NATSPubSubAdapter — v0.7 PR 6 — Pub/Sub adapter backed by NATS.\n *\n * Two modes:\n *   - **Fan-out** (default, when `consumerGroup` is absent): every\n *     subscriber receives every message on the subject. NATS Core\n *     publish/subscribe semantics — cheapest path, no persistence.\n *   - **Competing-consumer** (when `consumerGroup` is set): NATS\n *     Queue Group — exactly one subscriber in the named group\n *     receives each message. Pure NATS Core.\n *   - **Durable** (when `durable: true`): subscribe via NATS\n *     JetStream consumer so the subscription survives restarts and\n *     replays missed messages from `startFrom`. Required for the\n *     `{seq}` / `{timestamp}` replay cursors.\n *\n * Subject wildcards (`orders.*.created`, `orders.>`) are honored by\n * NATS natively in both modes.\n *\n * Requires `nats` as a peer dependency:\n *\n *     bun add nats\n *\n * Environment variables:\n *   - `NATS_SERVERS`   — comma-separated URLs (default `localhost:4222`).\n *   - `NATS_TOKEN`     — bearer token authentication.\n *   - `NATS_USER` / `NATS_PASS`  — userpass authentication.\n */\n\nimport type { PubSubTriggerOpts } from \"@blokjs/helper\";\nimport { v4 as uuid } from \"uuid\";\nimport type { PubSubAdapter, PubSubMessage } from \"../PubSubTrigger\";\n\nexport interface NATSPubSubConfig {\n\tservers: string[];\n\ttoken?: string;\n\tuser?: string;\n\tpass?: string;\n}\n\ninterface NatsSubscription {\n\tunsubscribe: () => void | Promise<void>;\n}\n\ninterface NatsConnection {\n\tclose: () => Promise<void>;\n\tdrain: () => Promise<void>;\n\tsubscribe: (\n\t\tsubject: string,\n\t\topts?: { queue?: string; callback?: (err: Error | null, msg: NatsMsg) => void },\n\t) => NatsSubscription;\n\tpublish: (subject: string, payload: Uint8Array) => void;\n\tjetstream?: () => NatsJetStream;\n\tjetstreamManager?: () => Promise<NatsJetStreamManager>;\n}\n\ninterface NatsJetStream {\n\tsubscribe: (\n\t\tsubject: string,\n\t\topts?: unknown,\n\t) => Promise<{\n\t\t[Symbol.asyncIterator]: () => AsyncIterator<NatsJsMsg>;\n\t\tunsubscribe: () => Promise<void> | void;\n\t}>;\n\tpublish: (subject: string, payload: Uint8Array) => Promise<unknown>;\n}\n\ninterface NatsJetStreamManager {\n\tstreams: { add: (config: unknown) => Promise<unknown>; info: (name: string) => Promise<unknown> };\n\tconsumers: { add: (stream: string, config: unknown) => Promise<unknown> };\n}\n\ninterface NatsMsg {\n\tsubject: string;\n\tdata: Uint8Array;\n\tsid: number;\n\trespond?: (data?: Uint8Array) => boolean;\n}\n\ninterface NatsJsMsg {\n\tsubject: string;\n\tdata: Uint8Array;\n\tseq: number;\n\tack: () => void;\n\tnak: (millis?: number) => void;\n\tinfo: { stream: string; consumer: string; redeliveryCount: number; timestampNanos?: number };\n}\n\nconst TEXT_DECODER = new TextDecoder();\nconst TEXT_ENCODER = new TextEncoder();\n\nexport class NATSPubSubAdapter implements PubSubAdapter {\n\treadonly provider = \"nats\" as const;\n\tprivate readonly config: NATSPubSubConfig;\n\tprivate conn: NatsConnection | null = null;\n\tprivate subscriptions: Map<string, NatsSubscription | { unsubscribe: () => Promise<void> | void }> = new Map();\n\tprivate connected = false;\n\n\tconstructor(config?: Partial<NATSPubSubConfig>) {\n\t\tthis.config = {\n\t\t\tservers: config?.servers ?? (process.env.NATS_SERVERS ?? \"localhost:4222\").split(\",\").map((s) => s.trim()),\n\t\t\ttoken: config?.token ?? process.env.NATS_TOKEN,\n\t\t\tuser: config?.user ?? process.env.NATS_USER,\n\t\t\tpass: config?.pass ?? process.env.NATS_PASS,\n\t\t};\n\t}\n\n\tasync connect(): Promise<void> {\n\t\tif (this.connected) return;\n\t\ttry {\n\t\t\t// biome-ignore lint/suspicious/noExplicitAny: nats is a runtime peer dep.\n\t\t\tconst nats: any = await import(\"nats\");\n\t\t\tthis.conn = (await nats.connect({\n\t\t\t\tservers: this.config.servers,\n\t\t\t\ttoken: this.config.token,\n\t\t\t\tuser: this.config.user,\n\t\t\t\tpass: this.config.pass,\n\t\t\t})) as NatsConnection;\n\t\t\tthis.connected = true;\n\t\t} catch (err) {\n\t\t\tthrow new Error(\n\t\t\t\t`[blok][pubsub-nats] connect failed: ${(err as Error).message}. Install nats as a peer dependency: bun add nats`,\n\t\t\t);\n\t\t}\n\t}\n\n\tasync disconnect(): Promise<void> {\n\t\tif (!this.connected) return;\n\t\tfor (const sub of this.subscriptions.values()) {\n\t\t\ttry {\n\t\t\t\tconst result = sub.unsubscribe();\n\t\t\t\tif (result instanceof Promise) await result;\n\t\t\t} catch {\n\t\t\t\t/* ignore */\n\t\t\t}\n\t\t}\n\t\tthis.subscriptions.clear();\n\t\ttry {\n\t\t\tawait this.conn?.drain();\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t\tthis.conn = null;\n\t\tthis.connected = false;\n\t}\n\n\tasync subscribe(config: PubSubTriggerOpts, handler: (message: PubSubMessage) => Promise<void>): Promise<void> {\n\t\tif (!this.connected || !this.conn) throw new Error(\"[blok][pubsub-nats] not connected. Call connect() first.\");\n\t\tconst subKey = `${config.topic}#${config.consumerGroup ?? \"\"}`;\n\n\t\tif (config.durable === true) {\n\t\t\t// JetStream durable subscription — survives restarts.\n\t\t\tif (!this.conn.jetstream) {\n\t\t\t\tthrow new Error(\"[blok][pubsub-nats] durable subscriptions require JetStream support in the nats client\");\n\t\t\t}\n\t\t\tconst jsm = await this.conn.jetstreamManager?.();\n\t\t\tif (jsm) {\n\t\t\t\t// Auto-create a stream covering the subject if one doesn't\n\t\t\t\t// exist. Production deployments should pre-provision via\n\t\t\t\t// `nats stream add` to control retention.\n\t\t\t\ttry {\n\t\t\t\t\tawait jsm.streams.add({\n\t\t\t\t\t\tname: `blok-${(config.topic ?? \"\").replace(/[^a-zA-Z0-9_]/g, \"_\")}`,\n\t\t\t\t\t\tsubjects: [config.topic],\n\t\t\t\t\t});\n\t\t\t\t} catch {\n\t\t\t\t\t/* stream already exists — ignore */\n\t\t\t\t}\n\t\t\t}\n\t\t\tconst js = this.conn.jetstream();\n\t\t\tconst startSeq =\n\t\t\t\ttypeof config.startFrom === \"object\" && config.startFrom && \"seq\" in config.startFrom\n\t\t\t\t\t? config.startFrom.seq\n\t\t\t\t\t: undefined;\n\t\t\tconst deliverPolicy =\n\t\t\t\tconfig.startFrom === \"earliest\"\n\t\t\t\t\t? \"all\"\n\t\t\t\t\t: config.startFrom === \"latest\"\n\t\t\t\t\t\t? \"new\"\n\t\t\t\t\t\t: startSeq !== undefined\n\t\t\t\t\t\t\t? \"by_start_sequence\"\n\t\t\t\t\t\t\t: \"all\";\n\t\t\tconst sub = await js.subscribe(config.topic, {\n\t\t\t\tconfig: {\n\t\t\t\t\tdurable_name:\n\t\t\t\t\t\tconfig.consumerGroup ??\n\t\t\t\t\t\t`blok-${(config.subscription ?? config.topic ?? \"default\").replace(/[^a-zA-Z0-9_]/g, \"_\")}`,\n\t\t\t\t\tdeliver_policy: deliverPolicy,\n\t\t\t\t\topt_start_seq: startSeq,\n\t\t\t\t\tack_policy: config.ack === false ? \"none\" : \"explicit\",\n\t\t\t\t},\n\t\t\t});\n\t\t\tthis.subscriptions.set(subKey, { unsubscribe: () => sub.unsubscribe() });\n\t\t\t// Drive the async iterator in a background loop.\n\t\t\tvoid (async () => {\n\t\t\t\ttry {\n\t\t\t\t\tfor await (const msg of sub as unknown as AsyncIterable<NatsJsMsg>) {\n\t\t\t\t\t\tawait this.dispatchJsMessage(msg, config, handler);\n\t\t\t\t\t}\n\t\t\t\t} catch (err) {\n\t\t\t\t\t// Subscription closed or connection lost — let the trigger\n\t\t\t\t\t// re-listen via HMR/reconnect logic. Log for visibility.\n\t\t\t\t\tconsole.error(`[blok][pubsub-nats] subscription error: ${(err as Error).message}`);\n\t\t\t\t}\n\t\t\t})();\n\t\t\treturn;\n\t\t}\n\n\t\t// Core NATS subscription — fire-and-forget, with optional queue\n\t\t// group for competing-consumer semantics.\n\t\tconst sub = this.conn.subscribe(config.topic, {\n\t\t\tqueue: config.consumerGroup,\n\t\t\tcallback: (err, msg) => {\n\t\t\t\tif (err) {\n\t\t\t\t\tconsole.error(`[blok][pubsub-nats] subscribe error: ${err.message}`);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tvoid this.dispatchCoreMessage(msg, config, handler);\n\t\t\t},\n\t\t});\n\t\tthis.subscriptions.set(subKey, sub);\n\t}\n\n\tprivate async dispatchJsMessage(\n\t\tmsg: NatsJsMsg,\n\t\tconfig: PubSubTriggerOpts,\n\t\thandler: (message: PubSubMessage) => Promise<void>,\n\t): Promise<void> {\n\t\tconst text = TEXT_DECODER.decode(msg.data);\n\t\tlet body: unknown = text;\n\t\ttry {\n\t\t\tbody = text.length > 0 ? JSON.parse(text) : null;\n\t\t} catch {\n\t\t\t/* leave as text */\n\t\t}\n\t\tconst message: PubSubMessage = {\n\t\t\tid: `${msg.info.stream}:${msg.seq}`,\n\t\t\tbody,\n\t\t\tattributes: { subject: msg.subject },\n\t\t\traw: msg,\n\t\t\ttopic: msg.subject,\n\t\t\tsubscription: msg.info.consumer,\n\t\t\tpublishTime: msg.info.timestampNanos ? new Date(msg.info.timestampNanos / 1e6) : undefined,\n\t\t\tack: async () => {\n\t\t\t\tmsg.ack();\n\t\t\t},\n\t\t\tnack: async () => {\n\t\t\t\tmsg.nak();\n\t\t\t},\n\t\t};\n\t\ttry {\n\t\t\tawait handler(message);\n\t\t\tif (config.ack !== false) msg.ack();\n\t\t} catch {\n\t\t\tmsg.nak();\n\t\t}\n\t}\n\n\tprivate async dispatchCoreMessage(\n\t\tmsg: NatsMsg,\n\t\t_config: PubSubTriggerOpts,\n\t\thandler: (message: PubSubMessage) => Promise<void>,\n\t): Promise<void> {\n\t\tconst text = TEXT_DECODER.decode(msg.data);\n\t\tlet body: unknown = text;\n\t\ttry {\n\t\t\tbody = text.length > 0 ? JSON.parse(text) : null;\n\t\t} catch {\n\t\t\t/* leave as text */\n\t\t}\n\t\tconst message: PubSubMessage = {\n\t\t\tid: `${msg.subject}:${msg.sid}:${uuid()}`,\n\t\t\tbody,\n\t\t\tattributes: { subject: msg.subject },\n\t\t\traw: msg,\n\t\t\ttopic: msg.subject,\n\t\t\tack: async () => {\n\t\t\t\t/* core NATS has no explicit ack */\n\t\t\t},\n\t\t\tnack: async () => {\n\t\t\t\t/* core NATS has no explicit nack */\n\t\t\t},\n\t\t};\n\t\ttry {\n\t\t\tawait handler(message);\n\t\t} catch (err) {\n\t\t\tconsole.error(`[blok][pubsub-nats] handler error: ${(err as Error).message}`);\n\t\t}\n\t}\n\n\tasync unsubscribe(subscription: string): Promise<void> {\n\t\tconst sub = this.subscriptions.get(subscription);\n\t\tif (!sub) return;\n\t\ttry {\n\t\t\tconst result = sub.unsubscribe();\n\t\t\tif (result instanceof Promise) await result;\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t\tthis.subscriptions.delete(subscription);\n\t}\n\n\tasync publish(topic: string, payload: unknown): Promise<void> {\n\t\tif (!this.connected || !this.conn) throw new Error(\"[blok][pubsub-nats] not connected. Call connect() first.\");\n\t\tconst body = typeof payload === \"string\" ? payload : JSON.stringify(payload);\n\t\tconst data = TEXT_ENCODER.encode(body);\n\t\t// Use core NATS publish. When a durable subscriber has been\n\t\t// installed for this subject, the subscribe() path created a\n\t\t// JetStream stream with a subject filter that captures any\n\t\t// publish to `topic` — so durable consumers see the message via\n\t\t// the stream while core subscribers see it directly. The earlier\n\t\t// \"try js.publish first, fall back to core\" logic caused\n\t\t// **double-delivery**: js.publish to a subject covered by a\n\t\t// stream goes to BOTH the stream and core subscribers, then the\n\t\t// fallback would publish AGAIN if js.publish timed out (vs\n\t\t// returning 503 fast). Sticking to core publish avoids the race.\n\t\tthis.conn.publish(topic, data);\n\t}\n\n\tisConnected(): boolean {\n\t\treturn this.connected;\n\t}\n\n\tasync healthCheck(): Promise<boolean> {\n\t\treturn this.connected;\n\t}\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"NATSPubSubAdapter.js","sourceRoot":"","sources":["../../src/adapters/NATSPubSubAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * NATSPubSubAdapter — v0.7 PR 6 — Pub/Sub adapter backed by NATS.\n *\n * Two modes:\n *   - **Fan-out** (default, when `consumerGroup` is absent): every\n *     subscriber receives every message on the subject. NATS Core\n *     publish/subscribe semantics — cheapest path, no persistence.\n *   - **Competing-consumer** (when `consumerGroup` is set): NATS\n *     Queue Group — exactly one subscriber in the named group\n *     receives each message. Pure NATS Core.\n *   - **Durable** (when `durable: true`): subscribe via NATS\n *     JetStream consumer so the subscription survives restarts and\n *     replays missed messages from `startFrom`. Required for the\n *     `{seq}` / `{timestamp}` replay cursors.\n *\n * Subject wildcards (`orders.*.created`, `orders.>`) are honored by\n * NATS natively in both modes.\n *\n * Requires `nats` as a peer dependency:\n *\n *     bun add nats\n *\n * Environment variables:\n *   - `NATS_SERVERS`   — comma-separated URLs (default `localhost:4222`).\n *   - `NATS_TOKEN`     — bearer token authentication.\n *   - `NATS_USER` / `NATS_PASS`  — userpass authentication.\n */\n\nimport type { PubSubTriggerOpts } from \"@blokjs/helper\";\nimport { v4 as uuid } from \"uuid\";\nimport type { PubSubAdapter, PubSubMessage } from \"../PubSubTrigger\";\n\nexport interface NATSPubSubConfig {\n\tservers: string[];\n\ttoken?: string;\n\tuser?: string;\n\tpass?: string;\n}\n\ninterface NatsSubscription {\n\tunsubscribe: () => void | Promise<void>;\n}\n\ninterface NatsConnection {\n\tclose: () => Promise<void>;\n\tdrain: () => Promise<void>;\n\tsubscribe: (\n\t\tsubject: string,\n\t\topts?: { queue?: string; callback?: (err: Error | null, msg: NatsMsg) => void },\n\t) => NatsSubscription;\n\tpublish: (subject: string, payload: Uint8Array) => void;\n\tjetstream?: () => NatsJetStream;\n\tjetstreamManager?: () => Promise<NatsJetStreamManager>;\n}\n\ninterface NatsJetStream {\n\tsubscribe: (\n\t\tsubject: string,\n\t\topts?: unknown,\n\t) => Promise<{\n\t\t[Symbol.asyncIterator]: () => AsyncIterator<NatsJsMsg>;\n\t\tunsubscribe: () => Promise<void> | void;\n\t}>;\n\tpublish: (subject: string, payload: Uint8Array) => Promise<unknown>;\n}\n\ninterface NatsJetStreamManager {\n\tstreams: { add: (config: unknown) => Promise<unknown>; info: (name: string) => Promise<unknown> };\n\tconsumers: { add: (stream: string, config: unknown) => Promise<unknown> };\n}\n\ninterface NatsMsg {\n\tsubject: string;\n\tdata: Uint8Array;\n\tsid: number;\n\trespond?: (data?: Uint8Array) => boolean;\n}\n\ninterface NatsJsMsg {\n\tsubject: string;\n\tdata: Uint8Array;\n\tseq: number;\n\tack: () => void;\n\tnak: (millis?: number) => void;\n\tinfo: { stream: string; consumer: string; redeliveryCount: number; timestampNanos?: number };\n}\n\nconst TEXT_DECODER = new TextDecoder();\nconst TEXT_ENCODER = new TextEncoder();\n\nexport class NATSPubSubAdapter implements PubSubAdapter {\n\treadonly provider = \"nats\" as const;\n\tprivate readonly config: NATSPubSubConfig;\n\tprivate conn: NatsConnection | null = null;\n\tprivate subscriptions: Map<string, NatsSubscription | { unsubscribe: () => Promise<void> | void }> = new Map();\n\tprivate connected = false;\n\n\tconstructor(config?: Partial<NATSPubSubConfig>) {\n\t\tthis.config = {\n\t\t\tservers: config?.servers ?? (process.env.NATS_SERVERS ?? \"localhost:4222\").split(\",\").map((s) => s.trim()),\n\t\t\ttoken: config?.token ?? process.env.NATS_TOKEN,\n\t\t\tuser: config?.user ?? process.env.NATS_USER,\n\t\t\tpass: config?.pass ?? process.env.NATS_PASS,\n\t\t};\n\t}\n\n\tasync connect(): Promise<void> {\n\t\tif (this.connected) return;\n\t\ttry {\n\t\t\t// biome-ignore lint/suspicious/noExplicitAny: nats is a runtime peer dep.\n\t\t\tconst nats: any = await import(\"nats\");\n\t\t\tthis.conn = (await nats.connect({\n\t\t\t\tservers: this.config.servers,\n\t\t\t\ttoken: this.config.token,\n\t\t\t\tuser: this.config.user,\n\t\t\t\tpass: this.config.pass,\n\t\t\t})) as NatsConnection;\n\t\t\tthis.connected = true;\n\t\t} catch (err) {\n\t\t\tthrow new Error(\n\t\t\t\t`[blok][pubsub-nats] connect failed: ${(err as Error).message}. Install nats as a peer dependency: bun add nats`,\n\t\t\t);\n\t\t}\n\t}\n\n\tasync disconnect(): Promise<void> {\n\t\tif (!this.connected) return;\n\t\tfor (const sub of this.subscriptions.values()) {\n\t\t\ttry {\n\t\t\t\tconst result = sub.unsubscribe();\n\t\t\t\tif (result instanceof Promise) await result;\n\t\t\t} catch {\n\t\t\t\t/* ignore */\n\t\t\t}\n\t\t}\n\t\tthis.subscriptions.clear();\n\t\ttry {\n\t\t\tawait this.conn?.drain();\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t\tthis.conn = null;\n\t\tthis.connected = false;\n\t}\n\n\tasync subscribe(config: PubSubTriggerOpts, handler: (message: PubSubMessage) => Promise<void>): Promise<void> {\n\t\tif (!this.connected || !this.conn) throw new Error(\"[blok][pubsub-nats] not connected. Call connect() first.\");\n\t\tconst subKey = `${config.topic}#${config.consumerGroup ?? \"\"}`;\n\n\t\tif (config.durable === true) {\n\t\t\t// JetStream durable subscription — survives restarts.\n\t\t\tif (!this.conn.jetstream) {\n\t\t\t\tthrow new Error(\"[blok][pubsub-nats] durable subscriptions require JetStream support in the nats client\");\n\t\t\t}\n\t\t\tconst jsm = await this.conn.jetstreamManager?.();\n\t\t\tif (jsm) {\n\t\t\t\t// Auto-create a stream covering the subject if one doesn't\n\t\t\t\t// exist. Production deployments should pre-provision via\n\t\t\t\t// `nats stream add` to control retention.\n\t\t\t\ttry {\n\t\t\t\t\tawait jsm.streams.add({\n\t\t\t\t\t\tname: `blok-${(config.topic ?? \"\").replace(/[^a-zA-Z0-9_]/g, \"_\")}`,\n\t\t\t\t\t\tsubjects: [config.topic],\n\t\t\t\t\t});\n\t\t\t\t} catch {\n\t\t\t\t\t/* stream already exists — ignore */\n\t\t\t\t}\n\t\t\t}\n\t\t\tconst js = this.conn.jetstream();\n\t\t\t// nats.js `js.subscribe` needs a ConsumerOptsBuilder, NOT a raw\n\t\t\t// `{ config }` object — only the builder installs the push\n\t\t\t// `deliver_subject` JetStream requires. A raw config throws\n\t\t\t// \"push consumer requires deliver_subject\" at runtime (the typed\n\t\t\t// API accepts it, so tsc never catches this).\n\t\t\t// biome-ignore lint/suspicious/noExplicitAny: nats is a runtime peer dep.\n\t\t\tconst nats: any = await import(\"nats\");\n\t\t\tconst durableName =\n\t\t\t\tconfig.consumerGroup ??\n\t\t\t\t`blok-${(config.subscription ?? config.topic ?? \"default\").replace(/[^a-zA-Z0-9_]/g, \"_\")}`;\n\t\t\tconst opts = nats.consumerOpts();\n\t\t\topts.durable(durableName);\n\t\t\topts.deliverTo(nats.createInbox());\n\t\t\topts.manualAck(); // dispatchJsMessage ack/naks explicitly\n\t\t\tif (config.ack === false) opts.ackNone();\n\t\t\telse opts.ackExplicit();\n\t\t\t// Replay position: `earliest` = full retained history; `{seq}` /\n\t\t\t// `{timestamp}` resume from a cursor; `latest` (and the default,\n\t\t\t// per the schema) = new messages only.\n\t\t\tif (config.startFrom === \"earliest\") {\n\t\t\t\topts.deliverAll();\n\t\t\t} else if (typeof config.startFrom === \"object\" && config.startFrom && \"seq\" in config.startFrom) {\n\t\t\t\topts.startSequence(config.startFrom.seq);\n\t\t\t} else if (typeof config.startFrom === \"object\" && config.startFrom && \"timestamp\" in config.startFrom) {\n\t\t\t\topts.startTime(new Date(config.startFrom.timestamp));\n\t\t\t} else {\n\t\t\t\topts.deliverNew();\n\t\t\t}\n\t\t\tconst sub = await js.subscribe(config.topic, opts);\n\t\t\tthis.subscriptions.set(subKey, { unsubscribe: () => sub.unsubscribe() });\n\t\t\t// Drive the async iterator in a background loop.\n\t\t\tvoid (async () => {\n\t\t\t\ttry {\n\t\t\t\t\tfor await (const msg of sub as unknown as AsyncIterable<NatsJsMsg>) {\n\t\t\t\t\t\tawait this.dispatchJsMessage(msg, config, handler);\n\t\t\t\t\t}\n\t\t\t\t} catch (err) {\n\t\t\t\t\t// Subscription closed or connection lost — let the trigger\n\t\t\t\t\t// re-listen via HMR/reconnect logic. Log for visibility.\n\t\t\t\t\tconsole.error(`[blok][pubsub-nats] subscription error: ${(err as Error).message}`);\n\t\t\t\t}\n\t\t\t})();\n\t\t\treturn;\n\t\t}\n\n\t\t// Core NATS subscription — fire-and-forget, with optional queue\n\t\t// group for competing-consumer semantics.\n\t\tconst sub = this.conn.subscribe(config.topic, {\n\t\t\tqueue: config.consumerGroup,\n\t\t\tcallback: (err, msg) => {\n\t\t\t\tif (err) {\n\t\t\t\t\tconsole.error(`[blok][pubsub-nats] subscribe error: ${err.message}`);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tvoid this.dispatchCoreMessage(msg, config, handler);\n\t\t\t},\n\t\t});\n\t\tthis.subscriptions.set(subKey, sub);\n\t}\n\n\tprivate async dispatchJsMessage(\n\t\tmsg: NatsJsMsg,\n\t\tconfig: PubSubTriggerOpts,\n\t\thandler: (message: PubSubMessage) => Promise<void>,\n\t): Promise<void> {\n\t\tconst text = TEXT_DECODER.decode(msg.data);\n\t\tlet body: unknown = text;\n\t\ttry {\n\t\t\tbody = text.length > 0 ? JSON.parse(text) : null;\n\t\t} catch {\n\t\t\t/* leave as text */\n\t\t}\n\t\tconst message: PubSubMessage = {\n\t\t\tid: `${msg.info.stream}:${msg.seq}`,\n\t\t\tbody,\n\t\t\tattributes: { subject: msg.subject },\n\t\t\traw: msg,\n\t\t\ttopic: msg.subject,\n\t\t\tsubscription: msg.info.consumer,\n\t\t\tpublishTime: msg.info.timestampNanos ? new Date(msg.info.timestampNanos / 1e6) : undefined,\n\t\t\tack: async () => {\n\t\t\t\tmsg.ack();\n\t\t\t},\n\t\t\tnack: async () => {\n\t\t\t\tmsg.nak();\n\t\t\t},\n\t\t};\n\t\ttry {\n\t\t\tawait handler(message);\n\t\t\tif (config.ack !== false) msg.ack();\n\t\t} catch {\n\t\t\tmsg.nak();\n\t\t}\n\t}\n\n\tprivate async dispatchCoreMessage(\n\t\tmsg: NatsMsg,\n\t\t_config: PubSubTriggerOpts,\n\t\thandler: (message: PubSubMessage) => Promise<void>,\n\t): Promise<void> {\n\t\tconst text = TEXT_DECODER.decode(msg.data);\n\t\tlet body: unknown = text;\n\t\ttry {\n\t\t\tbody = text.length > 0 ? JSON.parse(text) : null;\n\t\t} catch {\n\t\t\t/* leave as text */\n\t\t}\n\t\tconst message: PubSubMessage = {\n\t\t\tid: `${msg.subject}:${msg.sid}:${uuid()}`,\n\t\t\tbody,\n\t\t\tattributes: { subject: msg.subject },\n\t\t\traw: msg,\n\t\t\ttopic: msg.subject,\n\t\t\tack: async () => {\n\t\t\t\t/* core NATS has no explicit ack */\n\t\t\t},\n\t\t\tnack: async () => {\n\t\t\t\t/* core NATS has no explicit nack */\n\t\t\t},\n\t\t};\n\t\ttry {\n\t\t\tawait handler(message);\n\t\t} catch (err) {\n\t\t\tconsole.error(`[blok][pubsub-nats] handler error: ${(err as Error).message}`);\n\t\t}\n\t}\n\n\tasync unsubscribe(subscription: string): Promise<void> {\n\t\tconst sub = this.subscriptions.get(subscription);\n\t\tif (!sub) return;\n\t\ttry {\n\t\t\tconst result = sub.unsubscribe();\n\t\t\tif (result instanceof Promise) await result;\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t\tthis.subscriptions.delete(subscription);\n\t}\n\n\tasync publish(topic: string, payload: unknown): Promise<void> {\n\t\tif (!this.connected || !this.conn) throw new Error(\"[blok][pubsub-nats] not connected. Call connect() first.\");\n\t\tconst body = typeof payload === \"string\" ? payload : JSON.stringify(payload);\n\t\tconst data = TEXT_ENCODER.encode(body);\n\t\t// Use core NATS publish. When a durable subscriber has been\n\t\t// installed for this subject, the subscribe() path created a\n\t\t// JetStream stream with a subject filter that captures any\n\t\t// publish to `topic` — so durable consumers see the message via\n\t\t// the stream while core subscribers see it directly. The earlier\n\t\t// \"try js.publish first, fall back to core\" logic caused\n\t\t// **double-delivery**: js.publish to a subject covered by a\n\t\t// stream goes to BOTH the stream and core subscribers, then the\n\t\t// fallback would publish AGAIN if js.publish timed out (vs\n\t\t// returning 503 fast). Sticking to core publish avoids the race.\n\t\tthis.conn.publish(topic, data);\n\t}\n\n\tisConnected(): boolean {\n\t\treturn this.connected;\n\t}\n\n\tasync healthCheck(): Promise<boolean> {\n\t\treturn this.connected;\n\t}\n}\n"]}

package/dist/adapters/RedisStreamsPubSubAdapter.d.ts

@@ -7,10 +7,17 @@
  * message (fan-out). When `consumerGroup` is explicitly set on the
  * workflow, all subscribers in the group compete (1 of N gets each).
  *
- * Replay cursors:
- *   - `"earliest"` / unset → `$` (only new messages by default).
- *   - `"earliest"` with explicit intent → `0` (replay full stream).
+ * Replay cursors (`startFrom`):
+ *   - unset / `"latest"` → `$` (only new messages).
+ *   - `"earliest"` → `0` (replay full retained stream).
  *   - `{seq: N}` → resume from stream id `N-0`.
+ *   - `{timestamp: ms}` → resume from id `ms-0` (time cursor).
+ * When the consumer group already exists, `startFrom` is applied via
+ * `XGROUP SETID` so a reconnect / second subscribe still repositions it.
+ *
+ * Group lifecycle: an explicit `consumerGroup` (competing-consumer) or
+ * `durable: true` persists the group; an auto-generated fan-out group is
+ * non-durable and torn down (`XGROUP DESTROY`) on unsubscribe/disconnect.
  *
  * Requires `ioredis` as a peer dependency.
  *