@newhomestar/sdk 0.7.4 → 0.7.6

package/dist/events.d.ts

@@ -187,6 +187,158 @@ export declare function queueEvent(payload: QueueEventPayload): Promise<{
  * startOutboxRelay(db);
  */
 export declare function startOutboxRelay(db: any, options?: OutboxRelayOptions): ReturnType<typeof setInterval>;
+/**
+ * A single PGMQ message received from the Nova Events Service SSE stream.
+ * Passed to InboundHandler and withInboundEvent().
+ */
+export interface InboundMessage {
+    /** PGMQ message ID — used for ACK/NACK and as the idempotency key in inbound_events */
+    msg_id: number | bigint;
+    /** Name of the PGMQ queue this message was read from (e.g. 'jira_queue') */
+    queue: string;
+    /** Full message payload: includes topic, entity_type, action, attributes, metadata */
+    payload: Record<string, unknown>;
+    /** PGMQ read count — how many times this message has been delivered (1 = first delivery) */
+    read_ct?: number;
+}
+/**
+ * Handler function for a specific inbound event topic.
+ *
+ * - `tx`    — Prisma transaction client. Use for all local DB writes.
+ * - `event` — The inbound PGMQ message.
+ *
+ * Return `{ status: 'processed' }` on success or `{ status: 'skipped' }` if
+ * this handler intentionally ignores the event (e.g. loop prevention).
+ *
+ * **Do NOT call external HTTP APIs inside the handler** — Prisma transactions
+ * have a default 5s timeout. External write-backs (e.g., Jira API calls) should
+ * happen after `withInboundEvent()` returns.
+ */
+export type InboundHandler = (tx: any, event: InboundMessage) => Promise<{
+    status: 'processed' | 'skipped';
+    result?: unknown;
+}>;
+/** Options for startInboundConsumer() */
+export interface InboundConsumerOptions {
+    /** PGMQ queue name to consume from (e.g. 'jira_queue') */
+    queueName: string;
+    /**
+     * Map of event topic → handler function.
+     * Keys are full event topic strings, e.g. 'nova_ticketing_service.ticket_created'.
+     * The topic is derived from payload.topic, or payload.entity_type + '.' + payload.action.
+     */
+    handlers: Record<string, InboundHandler>;
+    /**
+     * Fallback handler for unrecognized event types.
+     * Default behavior: skip + ACK (prevents unhandled events from blocking the queue).
+     */
+    defaultHandler?: InboundHandler;
+    /** Events Service base URL (default: NOVA_EVENTS_SERVICE_URL env var) */
+    eventsUrl?: string;
+    /** Service JWT for authentication (default: NOVA_SERVICE_TOKEN env var) */
+    serviceToken?: string;
+    /**
+     * Visibility timeout in seconds requested when reading from PGMQ.
+     * Must be long enough for your handler to complete. Default: 30s.
+     */
+    vt?: number;
+    /**
+     * Maximum delay between reconnect attempts in ms.
+     * Reconnects use exponential backoff: 1s → 2s → 4s → ... → maxReconnectDelay.
+     * Default: 30_000 (30 seconds).
+     */
+    maxReconnectDelay?: number;
+}
+/**
+ * Atomically store an inbound PGMQ message + run the handler in one Prisma
+ * `$transaction`, then send ACK to the Events Service post-commit.
+ *
+ * ## ACID Guarantee
+ *
+ * The `inbound_events` INSERT and all handler DB writes are committed together
+ * in a single Prisma `$transaction`. After commit, ACK is sent to the Events
+ * Service. This gives us exactly-once processing semantics:
+ *
+ * - Transaction fails → rolls back → no ACK → PGMQ re-delivers → full retry ✓
+ * - Transaction succeeds, ACK fails → PGMQ re-delivers → UNIQUE(msg_id) blocks
+ *   re-processing → ACK sent again on the duplicate delivery ✓
+ *
+ * ## Requirements
+ *
+ * Your Prisma schema must include the `InboundEvent` model with:
+ * ```prisma
+ * model InboundEvent {
+ *   id        BigInt  @id @default(autoincrement())
+ *   msgId     BigInt  @unique @map("msg_id")
+ *   ...
+ *   @@map("inbound_events")
+ * }
+ * ```
+ *
+ * @param db      - Prisma client instance (must have `inboundEvent` model)
+ * @param msg     - The PGMQ message received from the SSE stream
+ * @param handler - Business logic callback; receives `(tx, event)`, runs inside the transaction
+ * @returns       - `{ status: 'processed' | 'skipped' | 'duplicate' }`
+ * @throws        - Re-throws handler errors so the SSE consumer can NACK
+ *
+ * @example
+ * const outcome = await withInboundEvent(db, msg, async (tx, event) => {
+ *   await tx.jiraIssue.upsert({ where: { ... }, create: { ... }, update: { ... } });
+ *   return { status: 'processed' };
+ * });
+ */
+export declare function withInboundEvent(db: any, msg: InboundMessage, handler: InboundHandler): Promise<{
+    status: 'processed' | 'skipped' | 'duplicate';
+}>;
+/**
+ * Start an SSE consumer that reads from the integration's PGMQ queue,
+ * routes events to handler functions, and manages ACK/NACK/reconnect automatically.
+ *
+ * Each message is processed via `withInboundEvent()` — ACID guarantee with
+ * exactly-once processing even across re-deliveries and crashes.
+ *
+ * ## Handler routing
+ *
+ * Events are routed by topic string, derived from `payload.topic` or
+ * `payload.entity_type + '.' + payload.action`. If no matching handler is
+ * found, `defaultHandler` is called (default: skip + ACK).
+ *
+ * ## Connection lifecycle
+ *
+ * - Opens `GET /events/queue/stream?queue_name={queueName}` (SSE)
+ * - On message: routes → withInboundEvent() → ACK (or NACK on failure)
+ * - On keepalive (`: keepalive`): no action needed
+ * - On close/error: reconnects with exponential backoff (1s → 2s → 4s → ... → max)
+ * - On `AbortController.abort()`: graceful shutdown, no reconnect
+ *
+ * @param db      - Prisma client (must have `inboundEvent` model)
+ * @param options - Consumer configuration
+ * @returns       - AbortController — call `.abort()` for graceful shutdown
+ *
+ * @example
+ * // At service boot
+ * const consumer = startInboundConsumer(db, {
+ *   queueName: 'jira_queue',
+ *   handlers: {
+ *     'nova_ticketing_service.ticket_created': async (tx, event) => {
+ *       await tx.jiraIssue.upsert({ ... });
+ *       return { status: 'processed' };
+ *     },
+ *     'nova_ticketing_service.ticket_updated': async (tx, event) => {
+ *       await tx.jiraIssue.update({ ... });
+ *       return { status: 'processed' };
+ *     },
+ *   },
+ *   defaultHandler: async (_tx, event) => {
+ *     console.log(`[jira] Skipping unhandled: ${(event.payload as any).topic}`);
+ *     return { status: 'skipped' };
+ *   },
+ * });
+ *
+ * // Graceful shutdown
+ * process.on('SIGTERM', () => consumer.abort());
+ */
+export declare function startInboundConsumer(db: any, options: InboundConsumerOptions): AbortController;
 /**
  * Class-based client when you need more control than the top-level functions.
  * Useful when you want to pass configuration explicitly rather than relying on env vars.

package/dist/events.js

@@ -441,6 +441,390 @@ export function startOutboxRelay(db, options = {}) {
     }, intervalMs);
     return handle;
 }
+// ── withInboundEvent ───────────────────────────────────────────────────────────
+/**
+ * Atomically store an inbound PGMQ message + run the handler in one Prisma
+ * `$transaction`, then send ACK to the Events Service post-commit.
+ *
+ * ## ACID Guarantee
+ *
+ * The `inbound_events` INSERT and all handler DB writes are committed together
+ * in a single Prisma `$transaction`. After commit, ACK is sent to the Events
+ * Service. This gives us exactly-once processing semantics:
+ *
+ * - Transaction fails → rolls back → no ACK → PGMQ re-delivers → full retry ✓
+ * - Transaction succeeds, ACK fails → PGMQ re-delivers → UNIQUE(msg_id) blocks
+ *   re-processing → ACK sent again on the duplicate delivery ✓
+ *
+ * ## Requirements
+ *
+ * Your Prisma schema must include the `InboundEvent` model with:
+ * ```prisma
+ * model InboundEvent {
+ *   id        BigInt  @id @default(autoincrement())
+ *   msgId     BigInt  @unique @map("msg_id")
+ *   ...
+ *   @@map("inbound_events")
+ * }
+ * ```
+ *
+ * @param db      - Prisma client instance (must have `inboundEvent` model)
+ * @param msg     - The PGMQ message received from the SSE stream
+ * @param handler - Business logic callback; receives `(tx, event)`, runs inside the transaction
+ * @returns       - `{ status: 'processed' | 'skipped' | 'duplicate' }`
+ * @throws        - Re-throws handler errors so the SSE consumer can NACK
+ *
+ * @example
+ * const outcome = await withInboundEvent(db, msg, async (tx, event) => {
+ *   await tx.jiraIssue.upsert({ where: { ... }, create: { ... }, update: { ... } });
+ *   return { status: 'processed' };
+ * });
+ */
+export async function withInboundEvent(db, msg, handler) {
+    const eventsUrl = process.env.NOVA_EVENTS_SERVICE_URL;
+    const serviceToken = process.env.NOVA_SERVICE_TOKEN;
+    if (!eventsUrl || !serviceToken) {
+        throw new Error('[withInboundEvent] NOVA_EVENTS_SERVICE_URL and NOVA_SERVICE_TOKEN must be set.');
+    }
+    const msgId = BigInt(msg.msg_id);
+    const queueName = msg.queue;
+    // Derive event_type from the payload
+    const eventType = msg.payload?.topic ??
+        (msg.payload?.entity_type && msg.payload?.action
+            ? `${msg.payload.entity_type}.${msg.payload.action}`
+            : 'unknown.event');
+    // ── Phase 1: Atomic local write + handler in one transaction ───────────────
+    let outcome;
+    try {
+        outcome = await db.$transaction(async (tx) => {
+            // Idempotency check: have we already processed this msg_id?
+            const existing = await tx.inboundEvent.findUnique({
+                where: { msgId },
+                select: { id: true, status: true },
+            });
+            if (existing) {
+                // Already processed — ACK will be sent post-transaction regardless
+                console.log(`[nova/events] withInboundEvent: duplicate msg_id=${msgId} ` +
+                    `(status=${existing.status}) — skipping handler, will re-ACK`);
+                return { status: 'duplicate' };
+            }
+            // Insert the inbound_events row at 'processing' status
+            await tx.inboundEvent.create({
+                data: {
+                    msgId,
+                    queueName,
+                    eventType,
+                    payload: msg.payload,
+                    status: 'processing',
+                    attempts: 1,
+                },
+            });
+            // Run the handler inside the same transaction
+            const handlerResult = await handler(tx, msg);
+            // Update status to processed or skipped
+            await tx.inboundEvent.update({
+                where: { msgId },
+                data: {
+                    status: handlerResult.status,
+                    processedAt: new Date(),
+                },
+            });
+            return { status: handlerResult.status };
+        });
+    }
+    catch (err) {
+        // Transaction failed — record the error (best-effort, outside tx)
+        // Do NOT ACK — let the message be re-delivered by PGMQ after VT expires
+        try {
+            await db.inboundEvent.upsert({
+                where: { msgId },
+                create: {
+                    msgId,
+                    queueName,
+                    eventType,
+                    payload: msg.payload,
+                    status: 'failed',
+                    error: String(err).slice(0, 500),
+                    attempts: 1,
+                },
+                update: {
+                    status: 'failed',
+                    error: String(err).slice(0, 500),
+                    attempts: { increment: 1 },
+                },
+            });
+        }
+        catch (recordErr) {
+            console.error('[nova/events] withInboundEvent: failed to record error:', recordErr);
+        }
+        // Re-throw so the SSE consumer can NACK
+        throw err;
+    }
+    // ── Phase 2: ACK on Events Service (post-commit) ────────────────────────────
+    // Safe because: if ACK fails, PGMQ re-delivers, UNIQUE(msg_id) blocks
+    // re-processing, and we just ACK again on the duplicate delivery.
+    try {
+        const ackRes = await fetch(`${eventsUrl}/events/queue/ack`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${serviceToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                queue_name: queueName,
+                msg_id: Number(msgId),
+            }),
+        });
+        if (ackRes.ok) {
+            // Best-effort: record ack timestamp
+            await db.inboundEvent.update({
+                where: { msgId },
+                data: { ackedAt: new Date() },
+            }).catch(() => { });
+        }
+        else {
+            const text = await ackRes.text().catch(() => '');
+            console.warn(`[nova/events] ACK failed for msg_id=${msgId} (${ackRes.status}: ${text.slice(0, 200)}) — ` +
+                `message will be re-delivered; idempotency guard prevents double-processing`);
+        }
+    }
+    catch (ackErr) {
+        console.warn(`[nova/events] ACK network error for msg_id=${msgId}: ${String(ackErr).slice(0, 200)} — ` +
+            `message will be re-delivered; idempotency guard prevents double-processing`);
+    }
+    return outcome;
+}
+// ── startInboundConsumer ───────────────────────────────────────────────────────
+/**
+ * Start an SSE consumer that reads from the integration's PGMQ queue,
+ * routes events to handler functions, and manages ACK/NACK/reconnect automatically.
+ *
+ * Each message is processed via `withInboundEvent()` — ACID guarantee with
+ * exactly-once processing even across re-deliveries and crashes.
+ *
+ * ## Handler routing
+ *
+ * Events are routed by topic string, derived from `payload.topic` or
+ * `payload.entity_type + '.' + payload.action`. If no matching handler is
+ * found, `defaultHandler` is called (default: skip + ACK).
+ *
+ * ## Connection lifecycle
+ *
+ * - Opens `GET /events/queue/stream?queue_name={queueName}` (SSE)
+ * - On message: routes → withInboundEvent() → ACK (or NACK on failure)
+ * - On keepalive (`: keepalive`): no action needed
+ * - On close/error: reconnects with exponential backoff (1s → 2s → 4s → ... → max)
+ * - On `AbortController.abort()`: graceful shutdown, no reconnect
+ *
+ * @param db      - Prisma client (must have `inboundEvent` model)
+ * @param options - Consumer configuration
+ * @returns       - AbortController — call `.abort()` for graceful shutdown
+ *
+ * @example
+ * // At service boot
+ * const consumer = startInboundConsumer(db, {
+ *   queueName: 'jira_queue',
+ *   handlers: {
+ *     'nova_ticketing_service.ticket_created': async (tx, event) => {
+ *       await tx.jiraIssue.upsert({ ... });
+ *       return { status: 'processed' };
+ *     },
+ *     'nova_ticketing_service.ticket_updated': async (tx, event) => {
+ *       await tx.jiraIssue.update({ ... });
+ *       return { status: 'processed' };
+ *     },
+ *   },
+ *   defaultHandler: async (_tx, event) => {
+ *     console.log(`[jira] Skipping unhandled: ${(event.payload as any).topic}`);
+ *     return { status: 'skipped' };
+ *   },
+ * });
+ *
+ * // Graceful shutdown
+ * process.on('SIGTERM', () => consumer.abort());
+ */
+export function startInboundConsumer(db, options) {
+    const { queueName, handlers, defaultHandler, vt = 30, maxReconnectDelay = 30_000, } = options;
+    const eventsUrl = options.eventsUrl ?? process.env.NOVA_EVENTS_SERVICE_URL;
+    const serviceToken = options.serviceToken ?? process.env.NOVA_SERVICE_TOKEN;
+    if (!eventsUrl || !serviceToken) {
+        console.error('[nova/events] startInboundConsumer: NOVA_EVENTS_SERVICE_URL and NOVA_SERVICE_TOKEN ' +
+            'must be set. Inbound consumer will NOT start.');
+        // Return a no-op AbortController
+        return new AbortController();
+    }
+    const abort = new AbortController();
+    let reconnectAttempt = 0;
+    /** Derive the event topic from a raw PGMQ message payload */
+    function _deriveEventType(payload) {
+        if (typeof payload.topic === 'string')
+            return payload.topic;
+        if (typeof payload.entity_type === 'string' && typeof payload.action === 'string') {
+            return `${payload.entity_type}.${payload.action}`;
+        }
+        return 'unknown.event';
+    }
+    /** Send a NACK to extend the visibility timeout with exponential backoff */
+    async function _nack(msgId, readCt) {
+        try {
+            await fetch(`${eventsUrl}/events/queue/nack`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${serviceToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ queue_name: queueName, msg_id: msgId }),
+            });
+        }
+        catch (err) {
+            console.error(`[nova/events] NACK failed for msg_id=${msgId} read_ct=${readCt}:`, String(err).slice(0, 200));
+        }
+    }
+    /** Process a single parsed SSE message object */
+    async function _processMessage(raw) {
+        const msgId = raw.msg_id;
+        const readCt = raw.read_ct ?? 1;
+        const payload = (raw.message ?? raw.payload ?? raw);
+        if (msgId == null) {
+            console.warn('[nova/events] SSE message missing msg_id — skipping:', JSON.stringify(raw).slice(0, 200));
+            return;
+        }
+        const eventType = _deriveEventType(payload);
+        const handler = handlers[eventType] ?? defaultHandler;
+        const msg = {
+            msg_id: msgId,
+            queue: queueName,
+            payload,
+            read_ct: readCt,
+        };
+        if (!handler) {
+            // No handler registered and no default — skip + ACK to unblock queue
+            console.log(`[nova/events] No handler for event type "${eventType}" (msg_id=${msgId}) — ACK and skip`);
+            try {
+                await fetch(`${eventsUrl}/events/queue/ack`, {
+                    method: 'POST',
+                    headers: { 'Authorization': `Bearer ${serviceToken}`, 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ queue_name: queueName, msg_id: msgId }),
+                });
+            }
+            catch { /* best-effort */ }
+            return;
+        }
+        try {
+            const outcome = await withInboundEvent(db, msg, handler);
+            console.log(`[nova/events] msg_id=${msgId} event="${eventType}" status=${outcome.status} read_ct=${readCt}`);
+        }
+        catch (err) {
+            console.error(`[nova/events] Handler failed for msg_id=${msgId} event="${eventType}" read_ct=${readCt}:`, err);
+            // NACK — extends visibility timeout so PGMQ will re-deliver
+            await _nack(msgId, readCt);
+        }
+    }
+    /** Parse and consume an SSE response body, yielding full message objects */
+    async function _consumeStream(response) {
+        if (!response.body)
+            throw new Error('SSE response has no body');
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let dataLines = [];
+        try {
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                if (abort.signal.aborted)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                // Process complete lines
+                const lines = buffer.split('\n');
+                buffer = lines.pop() ?? ''; // last element may be incomplete
+                for (const raw of lines) {
+                    const line = raw.trimEnd();
+                    if (line === '') {
+                        // Empty line = end of SSE message block
+                        if (dataLines.length > 0) {
+                            const joined = dataLines.join('\n');
+                            dataLines = [];
+                            try {
+                                const parsed = JSON.parse(joined);
+                                // Fire-and-forget within the stream loop; errors caught inside _processMessage
+                                _processMessage(parsed).catch((err) => {
+                                    console.error('[nova/events] _processMessage uncaught error:', err);
+                                });
+                            }
+                            catch {
+                                // Keepalives and comments sometimes have no data
+                            }
+                        }
+                        continue;
+                    }
+                    if (line.startsWith(':')) {
+                        // SSE comment/keepalive (e.g., ": keepalive") — ignore
+                        continue;
+                    }
+                    if (line.startsWith('data: ')) {
+                        dataLines.push(line.slice(6));
+                    }
+                    // event:, id:, retry: fields — not needed for our use case
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    /** Main loop: connect, consume, reconnect */
+    async function _connect() {
+        while (!abort.signal.aborted) {
+            const streamUrl = `${eventsUrl}/events/queue/stream?queue_name=${encodeURIComponent(queueName)}&vt=${vt}`;
+            try {
+                console.log(`[nova/events] Connecting to SSE queue "${queueName}" ` +
+                    `(attempt ${reconnectAttempt + 1})…`);
+                const response = await fetch(streamUrl, {
+                    headers: { 'Authorization': `Bearer ${serviceToken}`, 'Accept': 'text/event-stream' },
+                    signal: abort.signal,
+                });
+                if (!response.ok) {
+                    const text = await response.text().catch(() => '');
+                    throw new Error(`SSE connect failed: HTTP ${response.status} — ${text.slice(0, 200)}`);
+                }
+                // Successfully connected — reset reconnect counter
+                reconnectAttempt = 0;
+                console.log(`[nova/events] SSE consumer connected to queue "${queueName}"`);
+                await _consumeStream(response);
+                if (abort.signal.aborted) {
+                    console.log(`[nova/events] SSE consumer for queue "${queueName}" shut down gracefully`);
+                    return;
+                }
+                console.log(`[nova/events] SSE stream for queue "${queueName}" closed — reconnecting…`);
+            }
+            catch (err) {
+                if (abort.signal.aborted) {
+                    console.log(`[nova/events] SSE consumer for queue "${queueName}" aborted`);
+                    return;
+                }
+                const isAbortError = err?.name === 'AbortError' || err?.code === 20;
+                if (isAbortError)
+                    return;
+                console.error(`[nova/events] SSE connection error for queue "${queueName}":`, String(err).slice(0, 300));
+            }
+            // Exponential backoff: 1s, 2s, 4s, 8s, ... capped at maxReconnectDelay
+            const delayMs = Math.min(1_000 * Math.pow(2, reconnectAttempt), maxReconnectDelay);
+            reconnectAttempt++;
+            console.log(`[nova/events] Reconnecting queue "${queueName}" in ${delayMs}ms…`);
+            await new Promise((resolve) => {
+                const t = setTimeout(resolve, delayMs);
+                abort.signal.addEventListener('abort', () => { clearTimeout(t); resolve(); }, { once: true });
+            });
+        }
+    }
+    // Start the consumer loop (non-blocking)
+    _connect().catch((err) => {
+        console.error(`[nova/events] startInboundConsumer fatal error for queue "${queueName}":`, err);
+    });
+    return abort;
+}
 // ── NovaEventsClient ───────────────────────────────────────────────────────────
 /**
  * Class-based client when you need more control than the top-level functions.

package/dist/index.d.ts

@@ -167,6 +167,15 @@ export declare function action<I extends ZodTypeAny, O extends ZodTypeAny>(cfg:
     path?: string;
     scopes?: string[];
     category?: string;
+    /**
+     * Shorthand for subscribing to Nova event topics.
+     * Equivalent to `triggers: [{ type: 'event', events: [...] }]` but more concise.
+     *
+     * @example
+     * events: 'nova_ticketing_service.ticket_created'
+     * events: ['nova_ticketing_service.ticket_created', 'nova_ticketing_service.ticket_updated']
+     */
+    events?: string | string[];
     /**
      * Per-field parameter metadata — tells the platform where each input field
      * goes (path, query, body, header) and what UI widget to render.

package/dist/index.js

@@ -159,6 +159,15 @@ function buildTriggerMap(def) {
                 }
             }
         }
+        // Shorthand: events: string | string[]
+        const eventsShorthand = actionDef.events;
+        if (eventsShorthand) {
+            const eventList = Array.isArray(eventsShorthand) ? eventsShorthand : [eventsShorthand];
+            for (const topic of eventList) {
+                if (!map.has(topic))
+                    map.set(topic, actionDef); // triggers take precedence over shorthand
+            }
+        }
         // Legacy: capabilities API (backward compat)
         if (actionDef.capabilities) {
             for (const cap of actionDef.capabilities) {
@@ -377,7 +386,7 @@ async function runWorkerSSE(def) {
     console.log(`[nova] ✅ Queue '${def.queue}' ready`);
     const triggerMap = buildTriggerMap(def);
     console.log(`[nova] SSE worker '${def.name}' → ${baseUrl}/events/queue/stream?queue=${def.queue}`);
-    console.log(`[nova] Trigger map:`, Object.fromEntries(triggerMap));
+    console.log(`[nova] Trigger map:`, Object.fromEntries([...triggerMap.entries()].map(([topic, a]) => [topic, `${a.method ?? 'POST'} ${a.path ?? '/'}`])));
     let reconnectDelay = 1_000; // start 1 s, double up to 30 s
     // ── Outer reconnect loop ─────────────────────────────────────────────────
     while (true) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newhomestar/sdk",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "description": "Type-safe SDK for building Nova pipelines (workers & functions)",
   "homepage": "https://github.com/newhomestar/nova-node-sdk#readme",
   "bugs": {