@ismaelsoilet/synapsejs 1.4.0 → 1.8.0

package/src/core/postgres-client.ts

@@ -21,6 +21,7 @@ import {
 export class PostgresDatabaseClient implements DatabaseClient {
   private client: postgres.Sql;
 
+  // biome-ignore lint/suspicious/noExplicitAny: external postgres.js options boundary
   constructor(connectionString: string, options?: postgres.Options<any>) {
     this.client = postgres(connectionString, {
       max: options?.max || 10,
@@ -34,6 +35,7 @@ export class PostgresDatabaseClient implements DatabaseClient {
 
   async query<T = unknown>(queryStr: string, params: unknown[] = []): Promise<T[]> {
     // postgres.js unsafe executes raw SQL with parameter bindings
+    // biome-ignore lint/suspicious/noExplicitAny: external postgres.js unsafe bindings boundary
     const result = await this.client.unsafe(queryStr, params as any[]);
     return result as unknown as T[];
   }
@@ -97,20 +99,24 @@ export class PostgresDatabaseClient implements DatabaseClient {
     const res = await this.client.begin(async (sqlTx) => {
       const txClient: DatabaseClient = {
         query: async <U = unknown>(q: string, p: unknown[] = []) => {
+          // biome-ignore lint/suspicious/noExplicitAny: external postgres.js unsafe bindings boundary
           const res = await sqlTx.unsafe(q, p as any[]);
           return res as unknown as U[];
         },
         queryOne: async <U = unknown>(q: string, p: unknown[] = []) => {
+          // biome-ignore lint/suspicious/noExplicitAny: external postgres.js unsafe bindings boundary
           const res = await sqlTx.unsafe(q, p as any[]);
           return (res[0] ?? null) as U | null;
         },
         sql: async <U = unknown>(strings: TemplateStringsArray, ...values: unknown[]) => {
           const { text, params } = compileTaggedSql(strings, ...values);
+          // biome-ignore lint/suspicious/noExplicitAny: external postgres.js unsafe bindings boundary
           const res = await sqlTx.unsafe(text, params as any[]);
           return res as unknown as U[];
         },
         sqlOne: async <U = unknown>(strings: TemplateStringsArray, ...values: unknown[]) => {
           const { text, params } = compileTaggedSql(strings, ...values);
+          // biome-ignore lint/suspicious/noExplicitAny: external postgres.js unsafe bindings boundary
           const res = await sqlTx.unsafe(text, params as any[]);
           return (res[0] ?? null) as U | null;
         },

package/src/core/postgres-queue.ts

@@ -136,9 +136,29 @@ export class PostgresQueueEngine {
     const now = Date.now();
     const staleThreshold = now - this.visibilityTimeoutMs;
 
+    // 1. Mover tarefas zumbi expiradas para a tabela de DLQ
+    const deadJobs = await this.db.query<JobRecord>(
+      `UPDATE _synapse_jobs
+       SET status = 'dlq', locked_at = NULL, updated_at = $1, last_error = 'Visibility timeout exceeded max attempts'
+       WHERE status = 'running' AND locked_at < $2 AND attempts >= max_attempts
+       RETURNING *;`,
+      [now, staleThreshold]
+    );
+
+    for (const deadJob of deadJobs) {
+      await this.db
+        .query(
+          `INSERT INTO _synapse_jobs_dlq (id, name, payload, attempts, max_attempts, last_error, failed_at)
+           VALUES ($1, $2, $3, $4, $5, $6, $7)
+           ON CONFLICT (id) DO UPDATE SET attempts = EXCLUDED.attempts, last_error = EXCLUDED.last_error, failed_at = EXCLUDED.failed_at;`,
+          [deadJob.id, deadJob.name, deadJob.payload, deadJob.attempts, deadJob.max_attempts, deadJob.last_error, now]
+        )
+        .catch(() => {});
+    }
+
     const rows = await this.db.query<JobRecord>(
       `UPDATE _synapse_jobs
-       SET status = 'running', locked_at = $1, updated_at = $1
+       SET status = 'running', locked_at = $1, updated_at = $1, attempts = attempts + 1
        WHERE id = (
          SELECT id FROM _synapse_jobs
          WHERE (status = 'pending' AND run_at <= $1)
@@ -201,8 +221,8 @@ export class PostgresQueueEngine {
       await this.db.query(
         `UPDATE _synapse_jobs
          SET status = 'completed', attempts = $1, locked_at = NULL, updated_at = $2, last_error = NULL
-         WHERE id = $3`,
-        [attempts, now, job.id]
+         WHERE id = $3 AND (locked_at = $4 OR locked_at IS NULL)`,
+        [attempts, now, job.id, job.locked_at]
       );
       return true;
     } catch (handlerErr: unknown) {
@@ -218,8 +238,8 @@ export class PostgresQueueEngine {
         await this.db.query(
           `UPDATE _synapse_jobs
            SET status = 'pending', attempts = $1, run_at = $2, locked_at = NULL, updated_at = $3, last_error = $4
-           WHERE id = $5`,
-          [attempts, nextRunAt, now, errorMsg, job.id]
+           WHERE id = $5 AND (locked_at = $6 OR locked_at IS NULL)`,
+          [attempts, nextRunAt, now, errorMsg, job.id, job.locked_at]
         );
       } else {
         await this.sendToDlq(job, attempts, `Esgotado limite de tentativas (${job.max_attempts}): ${errorMsg}`, now);
@@ -244,8 +264,8 @@ export class PostgresQueueEngine {
     await this.db.query(
       `UPDATE _synapse_jobs
        SET status = 'dlq', attempts = $1, locked_at = NULL, updated_at = $2, last_error = $3
-       WHERE id = $4`,
-      [attempts, now, errorMsg, job.id]
+       WHERE id = $4 AND (locked_at = $5 OR locked_at IS NULL)`,
+      [attempts, now, errorMsg, job.id, job.locked_at]
     );
 
     this.logger.warn(`[DLQ] Job ${job.name} (${job.id}) movido para Dead Letter Queue: ${dlqId}`);

package/src/core/query-builder.ts

@@ -56,6 +56,31 @@ export function sanitizeIdentifier(ident: string): string {
   return trimmed;
 }
 
+const VALID_WHERE_OPERATORS = new Set<string>([
+  '=',
+  '!=',
+  '<>',
+  '>',
+  '<',
+  '>=',
+  '<=',
+  'LIKE',
+  'ILIKE',
+  'IN',
+  'NOT IN',
+  'IS NULL',
+  'IS NOT NULL',
+  'BETWEEN'
+]);
+
+export function sanitizeOperator(op: string): WhereOperator {
+  const normalized = op.trim().toUpperCase();
+  if (!VALID_WHERE_OPERATORS.has(normalized)) {
+    throw new Error(`Invalid SQL operator: "${op}"`);
+  }
+  return normalized as WhereOperator;
+}
+
 /** Normalize WhereCondition into an array of WhereClauseItem */
 function normalizeWhere(where?: WhereCondition): WhereClauseItem[] {
   if (!where) return [];
@@ -70,6 +95,13 @@ function normalizeWhere(where?: WhereCondition): WhereClauseItem[] {
       items.push({ column, op: 'IS NULL' });
     } else if (Array.isArray(value)) {
       items.push({ column, op: 'IN', value });
+    } else if (typeof value === 'object' && value !== null && 'op' in value) {
+      const cond = value as { op: string; val?: unknown; value?: unknown };
+      items.push({
+        column,
+        op: cond.op as WhereOperator,
+        value: cond.val !== undefined ? cond.val : cond.value
+      });
     } else {
       items.push({ column, op: '=', value });
     }
@@ -77,6 +109,46 @@ function normalizeWhere(where?: WhereCondition): WhereClauseItem[] {
   return items;
 }
 
+/** Compiles WhereClauseItem array into parameterized SQL condition strings */
+export function compileWhereClauses(whereItems: WhereClauseItem[], params: unknown[]): string[] {
+  const conditions: string[] = [];
+
+  for (const item of whereItems) {
+    const col = sanitizeIdentifier(item.column);
+    const op = sanitizeOperator(item.op);
+
+    if (op === 'IS NULL' || op === 'IS NOT NULL') {
+      conditions.push(`${col} ${op}`);
+    } else if (op === 'IN' || op === 'NOT IN') {
+      const arr = Array.isArray(item.value) ? item.value : [item.value];
+      if (arr.length === 0) {
+        conditions.push(op === 'IN' ? '1=0' : '1=1');
+      } else {
+        const placeholders = arr.map((val) => {
+          params.push(val);
+          return `$${params.length}`;
+        });
+        conditions.push(`${col} ${op} (${placeholders.join(', ')})`);
+      }
+    } else if (op === 'BETWEEN') {
+      const arr = Array.isArray(item.value) ? item.value : [];
+      if (arr.length !== 2) {
+        throw new Error(`BETWEEN operator requires an array of 2 values, received: ${JSON.stringify(item.value)}`);
+      }
+      params.push(arr[0]);
+      const p1 = `$${params.length}`;
+      params.push(arr[1]);
+      const p2 = `$${params.length}`;
+      conditions.push(`${col} BETWEEN ${p1} AND ${p2}`);
+    } else {
+      params.push(item.value);
+      conditions.push(`${col} ${op} $${params.length}`);
+    }
+  }
+
+  return conditions;
+}
+
 /**
  * Maps flat prefixed columns (e.g. "customer_name") into nested objects ({ customer: { name } })
  */
@@ -174,42 +246,7 @@ export function compileSelect(table: string, options?: QueryOptions): { sql: str
   // 2. WHERE clause
   const whereItems = normalizeWhere(options?.where);
   if (whereItems.length > 0) {
-    const conditions: string[] = [];
-
-    for (const item of whereItems) {
-      const col = sanitizeIdentifier(item.column);
-      const op = item.op.toUpperCase() as WhereOperator;
-
-      if (op === 'IS NULL' || op === 'IS NOT NULL') {
-        conditions.push(`${col} ${op}`);
-      } else if (op === 'IN' || op === 'NOT IN') {
-        const arr = Array.isArray(item.value) ? item.value : [item.value];
-        if (arr.length === 0) {
-          // Empty IN clause: IN () is invalid SQL -> false / true condition
-          conditions.push(op === 'IN' ? '1=0' : '1=1');
-        } else {
-          const placeholders = arr.map((val) => {
-            params.push(val);
-            return `$${params.length}`;
-          });
-          conditions.push(`${col} ${op} (${placeholders.join(', ')})`);
-        }
-      } else if (op === 'BETWEEN') {
-        const arr = Array.isArray(item.value) ? item.value : [];
-        if (arr.length !== 2) {
-          throw new Error(`BETWEEN operator requires an array of 2 values, received: ${JSON.stringify(item.value)}`);
-        }
-        params.push(arr[0]);
-        const p1 = `$${params.length}`;
-        params.push(arr[1]);
-        const p2 = `$${params.length}`;
-        conditions.push(`${col} BETWEEN ${p1} AND ${p2}`);
-      } else {
-        params.push(item.value);
-        conditions.push(`${col} ${op} $${params.length}`);
-      }
-    }
-
+    const conditions = compileWhereClauses(whereItems, params);
     if (conditions.length > 0) {
       sql += ` WHERE ${conditions.join(' AND ')}`;
     }
@@ -299,18 +336,7 @@ export function compileUpdate(
     throw new Error(`Unconditional UPDATE on ${table} is blocked for safety. Provide a WHERE condition.`);
   }
 
-  const conditions: string[] = [];
-  for (const item of whereItems) {
-    const col = sanitizeIdentifier(item.column);
-    const op = item.op.toUpperCase() as WhereOperator;
-    if (op === 'IS NULL' || op === 'IS NOT NULL') {
-      conditions.push(`${col} ${op}`);
-    } else {
-      params.push(item.value);
-      conditions.push(`${col} ${op} $${params.length}`);
-    }
-  }
-
+  const conditions = compileWhereClauses(whereItems, params);
   sql += ` WHERE ${conditions.join(' AND ')} RETURNING *;`;
   return { sql, params };
 }
@@ -326,18 +352,7 @@ export function compileDelete(table: string, where: WhereCondition): { sql: stri
   }
 
   const params: unknown[] = [];
-  const conditions: string[] = [];
-  for (const item of whereItems) {
-    const col = sanitizeIdentifier(item.column);
-    const op = item.op.toUpperCase() as WhereOperator;
-    if (op === 'IS NULL' || op === 'IS NOT NULL') {
-      conditions.push(`${col} ${op}`);
-    } else {
-      params.push(item.value);
-      conditions.push(`${col} ${op} $${params.length}`);
-    }
-  }
-
+  const conditions = compileWhereClauses(whereItems, params);
   const sql = `DELETE FROM ${safeTable} WHERE ${conditions.join(' AND ')} RETURNING *;`;
   return { sql, params };
 }

package/src/core/session-context.ts

@@ -79,7 +79,7 @@ export function requireTenant(session?: SessionContext, expectedTenantId?: strin
     return Err('UNAUTHORIZED');
   }
 
-  if (expectedTenantId && session.tenantId && session.tenantId !== expectedTenantId) {
+  if (expectedTenantId && session.tenantId !== expectedTenantId) {
     return Err('FORBIDDEN');
   }
 

package/src/core/session-token.ts

@@ -17,6 +17,7 @@ import { Err, Ok, type Result } from './machine-types';
 export interface SessionClaims {
   userId: string;
   roles: string[];
+  tenantId?: string;
   /** Expiry, in seconds since the epoch. */
   exp: number;
 }
@@ -118,7 +119,7 @@ function constantTimeEquals(left: string, right: string): boolean {
 }
 
 export function signSessionToken(
-  claims: { userId: string; roles: string[] },
+  claims: { userId: string; roles: string[]; tenantId?: string },
   secret: string,
   maxAgeSeconds = 86_400
 ): string {
@@ -126,6 +127,7 @@ export function signSessionToken(
     JSON.stringify({
       userId: claims.userId,
       roles: claims.roles,
+      tenantId: claims.tenantId,
       exp: Math.floor(Date.now() / 1000) + maxAgeSeconds
     })
   );
@@ -162,6 +164,10 @@ export function verifySessionToken(
     return Err('INVALID_TOKEN');
   }
 
+  if (claims.tenantId !== undefined && typeof claims.tenantId !== 'string') {
+    return Err('INVALID_TOKEN');
+  }
+
   if (claims.exp * 1000 < Date.now()) {
     return Err('EXPIRED_TOKEN');
   }

package/src/core/sqlite-client.ts

@@ -38,6 +38,7 @@ export class SqliteDatabaseClient implements DatabaseClient {
   private statements: Map<string, Statement<unknown, SQLQueryBindings[]>> = new Map();
   private maxStatements: number;
   private txLock: Promise<void> = Promise.resolve();
+  private txDepth = 0;
 
   constructor(filePath?: string, maxStatements = 500) {
     this.maxStatements = maxStatements;
@@ -53,6 +54,11 @@ export class SqliteDatabaseClient implements DatabaseClient {
     }
 
     this.db.run('PRAGMA journal_mode = WAL;');
+    this.db.run('PRAGMA synchronous = NORMAL;');
+    this.db.run('PRAGMA busy_timeout = 5000;');
+    this.db.run('PRAGMA temp_store = MEMORY;');
+    this.db.run('PRAGMA cache_size = -64000;');
+    this.db.run('PRAGMA mmap_size = 268435456;');
     this.db.run('PRAGMA foreign_keys = ON;');
   }
 
@@ -161,6 +167,22 @@ export class SqliteDatabaseClient implements DatabaseClient {
   }
 
   async transaction<T>(operation: (tx: DatabaseClient) => Promise<T>): Promise<T> {
+    if (this.txDepth > 0) {
+      // Reentrant transaction: use SQLite SAVEPOINT
+      const spId = `sp_${++this.txDepth}`;
+      this.db.run(`SAVEPOINT ${spId};`);
+      try {
+        const result = await operation(this);
+        this.db.run(`RELEASE SAVEPOINT ${spId};`);
+        return result;
+      } catch (err) {
+        this.db.run(`ROLLBACK TO SAVEPOINT ${spId};`);
+        throw err;
+      } finally {
+        this.txDepth--;
+      }
+    }
+
     let releaseLock: () => void = () => {};
     const lockAcquired = new Promise<void>((resolve) => {
       releaseLock = resolve;
@@ -172,7 +194,8 @@ export class SqliteDatabaseClient implements DatabaseClient {
     await previousLock;
 
     try {
-      this.db.run('BEGIN TRANSACTION;');
+      this.txDepth = 1;
+      this.db.run('BEGIN IMMEDIATE TRANSACTION;');
       try {
         const result = await operation(this);
         this.db.run('COMMIT;');
@@ -180,6 +203,8 @@ export class SqliteDatabaseClient implements DatabaseClient {
       } catch (err) {
         this.db.run('ROLLBACK;');
         throw err;
+      } finally {
+        this.txDepth = 0;
       }
     } finally {
       releaseLock();

package/src/core/storage.ts

@@ -219,11 +219,7 @@ export class S3StorageAdapter implements StorageClient {
     });
 
     if (!response.ok && response.status !== 200 && response.status !== 204) {
-      if (response.status === 403 || response.status === 404) {
-        // Fallback for mock/test environments
-      } else {
-        throw new Error(`Storage upload failed with HTTP status ${response.status}`);
-      }
+      throw new Error(`Storage upload failed with HTTP status ${response.status}`);
     }
 
     return {

package/src/core/websocket.ts

@@ -0,0 +1,30 @@
+/**
+ * SynapseJS - Native Bidirectional WebSocket Abstraction
+ *
+ * Provides a type-safe contract for real-time duplex communication
+ * seamlessly integrated with native Bun.serve WebSockets.
+ */
+
+export interface SynapseWebSocket<TServerMsg = unknown> {
+  readonly id: string;
+  readonly sliceKey: string;
+  send(message: TServerMsg | string): void;
+  close(code?: number, reason?: string): void;
+  data: Record<string, unknown>;
+}
+
+export interface SliceSocketDefinition<TClientMsg = unknown, TServerMsg = unknown> {
+  onOpen?: (ws: SynapseWebSocket<TServerMsg>) => void | Promise<void>;
+  onMessage: (ws: SynapseWebSocket<TServerMsg>, message: TClientMsg) => void | Promise<void>;
+  onClose?: (ws: SynapseWebSocket<TServerMsg>, code: number, reason: string) => void | Promise<void>;
+}
+
+/**
+ * Declares a bidirectional WebSocket endpoint for a slice.
+ * Automatically discovered and mounted at `GET /_synapse/ws/:domain/:name`.
+ */
+export function defineSocket<TClientMsg = unknown, TServerMsg = unknown>(
+  def: SliceSocketDefinition<TClientMsg, TServerMsg>
+): SliceSocketDefinition<TClientMsg, TServerMsg> {
+  return def;
+}

package/src/index.ts

@@ -65,7 +65,13 @@ export {
   parseOracleJunit,
   runSliceOracles
 } from './compiler/oracle-runner';
-export { type ScaffoldError, type ScaffoldErrorCode, scaffoldCrud, scaffoldSlice } from './compiler/scaffolder';
+export {
+  type ScaffoldError,
+  type ScaffoldErrorCode,
+  scaffoldCrud,
+  scaffoldShared,
+  scaffoldSlice
+} from './compiler/scaffolder';
 export { orderSlicesByDag, parseTableDependencies } from './compiler/schema-dag';
 export {
   checkSchemaDrift,
@@ -130,4 +136,5 @@ export {
   type SliceMetadata,
   SynapseServer
 } from './runtime/server';
+export { SYNAPSE_VERSION } from './version';
 export { fc };

package/src/mcp/server.ts

@@ -8,9 +8,13 @@
 
 import {
   type AbortGateResult,
+  type ModelRouteResult,
   modulateReasoningEffort,
+  type NudgeGateResult,
   type ReasoningEffortResult,
+  routeModelTier,
   shouldAbortTrajectory,
+  shouldNudgeContinuation,
   type TestTriageResult,
   triageTestFailure,
   type VerificationResult,
@@ -28,6 +32,7 @@ import { type SliceTemplate, scaffoldCrud, scaffoldSlice } from '../compiler/sca
 import { checkSchemaDrift } from '../compiler/schema-drift';
 import { findSliceFiles, resolveSlicesDir } from '../compiler/slice-discovery';
 import { artifactDirectory, splitSlice, verifySplit, writeSplitArtifacts } from '../compiler/slice-splitter';
+import { SYNAPSE_VERSION } from '../version';
 
 interface JsonRpcRequest {
   jsonrpc: string;
@@ -90,7 +95,7 @@ export class SynapseMcpServer {
             },
             serverInfo: {
               name: 'synapse-mcp',
-              version: '1.2.0'
+              version: SYNAPSE_VERSION
             }
           }
         };
@@ -272,6 +277,51 @@ export class SynapseMcpServer {
                     }
                   }
                 }
+              },
+              {
+                name: 'synapse_triage_error',
+                description:
+                  'Triage an arbitrary test failure or execution error log using Jev System One to classify root causes (env_missing vs flaky_transient vs deep_logic) and avoid token waste',
+                inputSchema: {
+                  type: 'object',
+                  required: ['failureLog'],
+                  properties: {
+                    failureLog: {
+                      type: 'string',
+                      description: 'Error log, stack trace or terminal output to triage'
+                    }
+                  }
+                }
+              },
+              {
+                name: 'synapse_route_task',
+                description:
+                  'Semantically route a development task to the optimal model/reasoning tier via Jev System One',
+                inputSchema: {
+                  type: 'object',
+                  required: ['task'],
+                  properties: {
+                    task: {
+                      type: 'string',
+                      description: 'Description of the coding, refactoring, or diagnostic task'
+                    }
+                  }
+                }
+              },
+              {
+                name: 'synapse_evaluate_nudge',
+                description:
+                  'Evaluate whether an agent is prematurely stopping or needs a proactive nudge to continue verification',
+                inputSchema: {
+                  type: 'object',
+                  required: ['transcriptTail'],
+                  properties: {
+                    transcriptTail: {
+                      type: 'string',
+                      description: 'Recent transcript steps or conversation history tail'
+                    }
+                  }
+                }
               }
             ]
           }
@@ -597,6 +647,18 @@ export class SynapseMcpServer {
               sessionContextTokens
             });
             contentText = JSON.stringify(result, null, 2);
+          } else if (toolName === 'synapse_triage_error') {
+            const failureLog = String(args.failureLog || '');
+            const result: TestTriageResult = await triageTestFailure(failureLog);
+            contentText = JSON.stringify(result, null, 2);
+          } else if (toolName === 'synapse_route_task') {
+            const task = String(args.task || '');
+            const result: ModelRouteResult = await routeModelTier(task);
+            contentText = JSON.stringify(result, null, 2);
+          } else if (toolName === 'synapse_evaluate_nudge') {
+            const transcriptTail = String(args.transcriptTail || '');
+            const result: NudgeGateResult = await shouldNudgeContinuation(transcriptTail);
+            contentText = JSON.stringify(result, null, 2);
           } else {
             return {
               jsonrpc: '2.0',

package/src/runtime/discovery-rules.ts

@@ -13,7 +13,11 @@ export const WEBHOOK_SUFFIX = 'Webhook';
 export const LOADER_SUFFIX = 'Loader';
 export const SCHEMA_SUFFIX = 'Schema';
 export const META_SUFFIX = 'Meta';
+export const CACHE_SUFFIX = 'Cache';
+export const SOCKET_SUFFIX = 'Socket';
 export const SLICE_META_EXPORT = 'sliceMeta';
+export const SLICE_CACHE_EXPORT = 'sliceCache';
+export const SLICE_SOCKET_EXPORT = 'sliceSocket';
 export const SLICE_DDL_EXPORT = 'sliceSchema';
 export const SLICE_ORACLE_EXPORT = 'sliceTests';
 
@@ -21,7 +25,14 @@ export const SLICE_ORACLE_EXPORT = 'sliceTests';
 export const COMPONENT_SUFFIXES = ['Trigger', 'View', 'Form', 'Component'] as const;
 
 /** Everything the server side of a slice is built from. */
-export const SERVER_ROOT_SUFFIXES = [ACTION_SUFFIX, JOB_SUFFIX, WEBHOOK_SUFFIX, META_SUFFIX] as const;
+export const SERVER_ROOT_SUFFIXES = [
+  ACTION_SUFFIX,
+  JOB_SUFFIX,
+  WEBHOOK_SUFFIX,
+  META_SUFFIX,
+  CACHE_SUFFIX,
+  SOCKET_SUFFIX
+] as const;
 
 /** Test-only exports, dropped from both runtime bundles. */
 export const TEST_ONLY_EXPORTS = [SLICE_ORACLE_EXPORT] as const;
@@ -58,6 +69,14 @@ export function isMeta(name: string): boolean {
   return name === SLICE_META_EXPORT || name.endsWith(META_SUFFIX);
 }
 
+export function isCache(name: string): boolean {
+  return name === SLICE_CACHE_EXPORT || name.endsWith(CACHE_SUFFIX);
+}
+
+export function isSocket(name: string): boolean {
+  return name === SLICE_SOCKET_EXPORT || name.endsWith(SOCKET_SUFFIX);
+}
+
 export function isTestOnly(name: string): boolean {
   return hasSuffix(name, TEST_ONLY_EXPORTS);
 }

package/src/runtime/event-hub.ts

@@ -46,7 +46,12 @@ export class EventHub {
     let notified = 0;
     for (const listener of listeners) {
       try {
-        listener(data);
+        const result: unknown = listener(data);
+        if (result && typeof (result as { catch?: unknown }).catch === 'function') {
+          (result as { catch: (fn: (err: unknown) => void) => void }).catch((err: unknown) => {
+            console.error(`[EventHub] Erro assíncrono no listener do tópico "${topic}":`, err);
+          });
+        }
         notified++;
       } catch (err) {
         console.error(`[EventHub] Erro no listener do tópico "${topic}":`, err);