@beignet/provider-db-drizzle 0.0.36 → 0.0.38

package/src/mysql/index.ts

@@ -41,16 +41,17 @@ import {
   type AnyProviderConfigSchema,
   createProvider,
   createProviderInstrumentation,
+  type ProviderInstrumentationTarget,
   type ServiceProvider,
 } from "@beignet/core/providers";
 import { type ExtractTablesWithRelations, type SQL, sql } from "drizzle-orm";
 import type {
   MySqlDatabase,
   MySqlQueryResultHKT,
-  MySqlTransaction,
   MySqlTransactionConfig,
   PreparedQueryHKTBase,
 } from "drizzle-orm/mysql-core";
+import { MySqlTransaction } from "drizzle-orm/mysql-core";
 import { drizzle, type MySql2Database } from "drizzle-orm/mysql2";
 import type { Pool, PoolOptions } from "mysql2/promise";
 import * as mysql from "mysql2/promise";
@@ -192,6 +193,7 @@ export function createDrizzleMysqlUnitOfWork<
       const events = createDomainEventRecorder();
 
       const result = await options.db.transaction(async (tx) => {
+        markMysqlTransactionClient(tx as object);
         const txPorts = options.createTransactionPorts(
           tx as DrizzleMysqlTransaction<TSchema>,
           events,
@@ -300,6 +302,12 @@ function isMysqlDeadlockError(error: unknown): boolean {
 
 const MYSQL_DEADLOCK_RETRY_BASE_MS = 10;
 const MYSQL_DEADLOCK_RETRY_MAX_MS = 250;
+const mysqlTransactionClients = new WeakSet<object>();
+
+function markMysqlTransactionClient<T extends object>(client: T): T {
+  mysqlTransactionClients.add(client);
+  return client;
+}
 
 function mysqlDeadlockRetryDelayMs(attempt: number): number {
   const exponentialDelay = Math.min(
@@ -343,6 +351,8 @@ interface DrizzleMysqlSqlExecutor
 function createMysqlExecutor<TSchema extends Record<string, unknown>>(
   db: DrizzleMysqlDatabase<TSchema>,
   table: SQL,
+  transactionScoped = db instanceof MySqlTransaction ||
+    mysqlTransactionClients.has(db as object),
 ): DrizzleMysqlSqlExecutor {
   return {
     table,
@@ -391,13 +401,20 @@ function createMysqlExecutor<TSchema extends Record<string, unknown>>(
     },
 
     withTransaction(fn) {
+      if (transactionScoped) return undefined;
       if ("transaction" in db && typeof db.transaction === "function") {
         // Outbox claims and idempotency reservations are small Beignet-owned
         // transactions with no app callbacks. Retrying a deadlock victim is
         // therefore safe and lets contenders classify against the winner.
         return runMysqlInternalTransaction(() =>
           db.transaction((tx) =>
-            fn(createMysqlExecutor(tx as DrizzleMysqlDatabase<TSchema>, table)),
+            fn(
+              createMysqlExecutor(
+                markMysqlTransactionClient(tx as DrizzleMysqlDatabase<TSchema>),
+                table,
+                true,
+              ),
+            ),
           ),
         );
       }
@@ -509,6 +526,7 @@ export function createDrizzleMysqlOutboxSetupStatements(
       kind varchar(32) NOT NULL,
       name varchar(255) NOT NULL,
       payload_json longtext NOT NULL,
+      trace_context_json longtext,
       status varchar(32) NOT NULL,
       attempts int NOT NULL DEFAULT 0,
       max_attempts int NOT NULL DEFAULT 3,
@@ -712,12 +730,22 @@ export type DrizzleMysqlProvider<
   Record<PortName, DbPort<TSchema>>
 >;
 
+/** Drizzle MySQL provider backed by an app-supplied pool. */
+export type InjectedDrizzleMysqlProvider<
+  TSchema extends Record<string, unknown>,
+  PortName extends string = "db",
+> = ServiceProvider<
+  unknown,
+  AnyProviderConfigSchema<void>,
+  Record<PortName, DbPort<TSchema>>
+>;
+
 /**
  * Options for creating a Drizzle MySQL provider.
  *
  * @template TSchema - The Drizzle schema type
  */
-export interface DrizzleMysqlProviderOptions<
+interface DrizzleMysqlProviderBaseOptions<
   TSchema extends Record<string, unknown>,
   PortName extends string = "db",
 > {
@@ -735,12 +763,6 @@ export interface DrizzleMysqlProviderOptions<
    */
   portName?: PortName;
 
-  /**
-   * Optional mysql2 pool options merged into the pool created from
-   * `MYSQL_DB_URL` (e.g. `connectionLimit`, `timezone`, TLS settings).
-   */
-  pool?: Omit<PoolOptions, "uri">;
-
   /**
    * Drizzle relational-query mode. Use "planetscale" when connecting to
    * PlanetScale; defaults to "default".
@@ -748,6 +770,26 @@ export interface DrizzleMysqlProviderOptions<
   mode?: "default" | "planetscale";
 }
 
+export type DrizzleMysqlProviderOptions<
+  TSchema extends Record<string, unknown>,
+  PortName extends string = "db",
+> = DrizzleMysqlProviderBaseOptions<TSchema, PortName> &
+  (
+    | {
+        /** Pool options for the provider-created `MYSQL_DB_URL` pool. */
+        pool?: Omit<PoolOptions, "uri">;
+        client?: never;
+        closeOnStop?: never;
+      }
+    | {
+        /** App-supplied mysql2 pool, caller-owned by default. */
+        client: Pool;
+        pool?: never;
+        /** Close the injected pool when the provider stops. @default false */
+        closeOnStop?: boolean;
+      }
+  );
+
 /**
  * Create a Drizzle MySQL provider factory.
  *
@@ -769,14 +811,83 @@ export interface DrizzleMysqlProviderOptions<
  * export const drizzleMysqlProvider = createDrizzleMysqlProvider({ schema });
  * ```
  */
+export function createDrizzleMysqlProvider<
+  TSchema extends Record<string, unknown>,
+  PortName extends string = "db",
+>(
+  options: DrizzleMysqlProviderBaseOptions<TSchema, PortName> & {
+    client: Pool;
+    pool?: never;
+    closeOnStop?: boolean;
+  },
+): InjectedDrizzleMysqlProvider<TSchema, PortName>;
+export function createDrizzleMysqlProvider<
+  TSchema extends Record<string, unknown>,
+  PortName extends string = "db",
+>(
+  options: DrizzleMysqlProviderBaseOptions<TSchema, PortName> & {
+    pool?: Omit<PoolOptions, "uri">;
+    client?: never;
+    closeOnStop?: never;
+  },
+): DrizzleMysqlProvider<TSchema, PortName>;
 export function createDrizzleMysqlProvider<
   TSchema extends Record<string, unknown>,
   PortName extends string = "db",
 >(
   options: DrizzleMysqlProviderOptions<TSchema, PortName>,
-): DrizzleMysqlProvider<TSchema, PortName> {
+):
+  | DrizzleMysqlProvider<TSchema, PortName>
+  | InjectedDrizzleMysqlProvider<TSchema, PortName> {
   const { schema, portName = "db", mode = "default" } = options;
 
+  const setupPool = (ports: unknown, pool: Pool, closeOnStop: boolean) => {
+    const instrumentation = createProviderInstrumentation(
+      ports as ProviderInstrumentationTarget,
+      {
+        providerName: "drizzle-mysql",
+        watcher: "db",
+      },
+    );
+    const logger = createDbQueryLogger(instrumentation, portName);
+    const db: MySql2Database<TSchema> = logger
+      ? drizzle(pool, { schema, logger, mode })
+      : drizzle(pool, { schema, mode });
+    const dbPort: DbPort<TSchema> = {
+      drizzle: db,
+      pool,
+      checkHealth: () => checkMysqlHealth(pool),
+    };
+
+    return {
+      ports: { [portName]: dbPort } as Record<PortName, DbPort<TSchema>>,
+      async stop() {
+        if (!closeOnStop) return;
+        try {
+          await pool.end();
+        } catch (error) {
+          console.error(
+            "[drizzleMysqlProvider] Error closing database connection:",
+            error,
+          );
+        }
+      },
+    };
+  };
+
+  if (options.client) {
+    return createProvider<
+      unknown,
+      AnyProviderConfigSchema<void>,
+      Record<PortName, DbPort<TSchema>>
+    >({
+      name: "drizzle-mysql",
+      setup({ ports }) {
+        return setupPool(ports, options.client, options.closeOnStop ?? false);
+      },
+    });
+  }
+
   return createProvider({
     name: "drizzle-mysql",
 
@@ -798,41 +909,7 @@ export function createDrizzleMysqlProvider<
         ...options.pool,
       });
 
-      const instrumentation = createProviderInstrumentation(ports, {
-        providerName: "drizzle-mysql",
-        watcher: "db",
-      });
-
-      const logger = createDbQueryLogger(instrumentation, portName);
-
-      // 2. Create typed Drizzle instance (mode is required when a schema is
-      //    provided to drizzle-orm/mysql2)
-      const db: MySql2Database<TSchema> = logger
-        ? drizzle(pool, { schema, logger, mode })
-        : drizzle(pool, { schema, mode });
-
-      // 3. Build a typed DbPort
-      const dbPort: DbPort<TSchema> = {
-        drizzle: db,
-        pool,
-        checkHealth: () => checkMysqlHealth(pool),
-      };
-
-      return {
-        ports: { [portName]: dbPort } as Record<PortName, DbPort<TSchema>>,
-        async stop() {
-          // Gracefully close the database connection pool
-          try {
-            await dbPort.pool.end();
-          } catch (error) {
-            // Log error but don't throw - we're shutting down anyway
-            console.error(
-              "[drizzleMysqlProvider] Error closing database connection:",
-              error,
-            );
-          }
-        },
-      };
+      return setupPool(ports, pool, true);
     },
   });
 }

package/src/mysql/schema.ts

@@ -49,6 +49,7 @@ export const outboxMessages = mysqlTable(
     kind: varchar("kind", { length: 32 }).notNull(),
     name: varchar("name", { length: 255 }).notNull(),
     payloadJson: longtext("payload_json").notNull(),
+    traceContextJson: longtext("trace_context_json"),
     status: varchar("status", { length: 32 }).notNull(),
     attempts: int("attempts").notNull().default(0),
     maxAttempts: int("max_attempts").notNull().default(3),

package/src/postgres/index.ts

@@ -41,6 +41,7 @@ import {
   type AnyProviderConfigSchema,
   createProvider,
   createProviderInstrumentation,
+  type ProviderInstrumentationTarget,
   type ServiceProvider,
 } from "@beignet/core/providers";
 import { type ExtractTablesWithRelations, type SQL, sql } from "drizzle-orm";
@@ -401,6 +402,7 @@ export function createDrizzlePostgresOutboxSetupStatements(
       kind text NOT NULL,
       name text NOT NULL,
       payload_json text NOT NULL,
+      trace_context_json text,
       status text NOT NULL,
       attempts integer DEFAULT 0 NOT NULL,
       max_attempts integer DEFAULT 3 NOT NULL,
@@ -605,12 +607,24 @@ export type DrizzlePostgresProvider<
   Record<PortName, DbPort<TSchema>>
 >;
 
+/**
+ * Drizzle Postgres provider backed by an app-supplied pool.
+ */
+export type InjectedDrizzlePostgresProvider<
+  TSchema extends Record<string, unknown>,
+  PortName extends string = "db",
+> = ServiceProvider<
+  unknown,
+  AnyProviderConfigSchema<void>,
+  Record<PortName, DbPort<TSchema>>
+>;
+
 /**
  * Options for creating a Drizzle Postgres provider.
  *
  * @template TSchema - The Drizzle schema type
  */
-export interface DrizzlePostgresProviderOptions<
+interface DrizzlePostgresProviderBaseOptions<
   TSchema extends Record<string, unknown>,
   PortName extends string = "db",
 > {
@@ -627,14 +641,34 @@ export interface DrizzlePostgresProviderOptions<
    * with its own env prefix instead.
    */
   portName?: PortName;
-
-  /**
-   * Optional node-postgres pool configuration merged into the pool created
-   * from `POSTGRES_DB_URL`, e.g. `max`, `ssl`, or timeouts.
-   */
-  pool?: Omit<PoolConfig, "connectionString">;
 }
 
+export type DrizzlePostgresProviderOptions<
+  TSchema extends Record<string, unknown>,
+  PortName extends string = "db",
+> = DrizzlePostgresProviderBaseOptions<TSchema, PortName> &
+  (
+    | {
+        /**
+         * Optional node-postgres pool configuration merged into the pool
+         * created from `POSTGRES_DB_URL`.
+         */
+        pool?: Omit<PoolConfig, "connectionString">;
+        client?: never;
+        closeOnStop?: never;
+      }
+    | {
+        /**
+         * App-supplied node-postgres pool. Injected pools do not require
+         * provider configuration and remain caller-owned by default.
+         */
+        client: Pool;
+        pool?: never;
+        /** Close the injected pool when the provider stops. @default false */
+        closeOnStop?: boolean;
+      }
+  );
+
 /**
  * Create a Drizzle Postgres provider factory.
  *
@@ -658,14 +692,90 @@ export interface DrizzlePostgresProviderOptions<
  * export const drizzlePostgresProvider = createDrizzlePostgresProvider({ schema });
  * ```
  */
+export function createDrizzlePostgresProvider<
+  TSchema extends Record<string, unknown>,
+  PortName extends string = "db",
+>(
+  options: DrizzlePostgresProviderBaseOptions<TSchema, PortName> & {
+    client: Pool;
+    pool?: never;
+    closeOnStop?: boolean;
+  },
+): InjectedDrizzlePostgresProvider<TSchema, PortName>;
+export function createDrizzlePostgresProvider<
+  TSchema extends Record<string, unknown>,
+  PortName extends string = "db",
+>(
+  options: DrizzlePostgresProviderBaseOptions<TSchema, PortName> & {
+    pool?: Omit<PoolConfig, "connectionString">;
+    client?: never;
+    closeOnStop?: never;
+  },
+): DrizzlePostgresProvider<TSchema, PortName>;
 export function createDrizzlePostgresProvider<
   TSchema extends Record<string, unknown>,
   PortName extends string = "db",
 >(
   options: DrizzlePostgresProviderOptions<TSchema, PortName>,
-): DrizzlePostgresProvider<TSchema, PortName> {
+):
+  | DrizzlePostgresProvider<TSchema, PortName>
+  | InjectedDrizzlePostgresProvider<TSchema, PortName> {
+  return createDrizzlePostgresProviderImplementation(options);
+}
+
+function createDrizzlePostgresProviderImplementation<
+  TSchema extends Record<string, unknown>,
+  PortName extends string = "db",
+>(options: DrizzlePostgresProviderOptions<TSchema, PortName>) {
   const { schema, portName = "db" } = options;
 
+  const setupPool = (ports: unknown, pool: Pool, closeOnStop: boolean) => {
+    const instrumentation = createProviderInstrumentation(
+      ports as ProviderInstrumentationTarget,
+      {
+        providerName: "drizzle-postgres",
+        watcher: "db",
+      },
+    );
+    const logger = createDbQueryLogger(instrumentation, portName);
+    const db: NodePgDatabase<TSchema> = logger
+      ? drizzle(pool, { schema, logger })
+      : drizzle(pool, { schema });
+    const dbPort: DbPort<TSchema> = {
+      drizzle: db,
+      pool,
+      checkHealth: () => checkPostgresHealth(pool),
+    };
+
+    return {
+      ports: { [portName]: dbPort } as Record<PortName, DbPort<TSchema>>,
+      async stop() {
+        if (!closeOnStop) return;
+        try {
+          await pool.end();
+        } catch (error) {
+          console.error(
+            "[drizzlePostgresProvider] Error closing database connection:",
+            error,
+          );
+        }
+      },
+    };
+  };
+
+  if (options.client) {
+    return createProvider<
+      unknown,
+      AnyProviderConfigSchema<void>,
+      Record<PortName, DbPort<TSchema>>
+    >({
+      name: "drizzle-postgres",
+      setup({ ports }) {
+        return setupPool(ports, options.client, options.closeOnStop ?? false);
+      },
+    });
+  }
+
   return createProvider({
     name: "drizzle-postgres",
 
@@ -687,40 +797,7 @@ export function createDrizzlePostgresProvider<
         ...options.pool,
       });
 
-      const instrumentation = createProviderInstrumentation(ports, {
-        providerName: "drizzle-postgres",
-        watcher: "db",
-      });
-
-      const logger = createDbQueryLogger(instrumentation, portName);
-
-      // 2. Create typed Drizzle instance
-      const db: NodePgDatabase<TSchema> = logger
-        ? drizzle(pool, { schema, logger })
-        : drizzle(pool, { schema });
-
-      // 3. Build a typed DbPort
-      const dbPort: DbPort<TSchema> = {
-        drizzle: db,
-        pool,
-        checkHealth: () => checkPostgresHealth(pool),
-      };
-
-      return {
-        ports: { [portName]: dbPort } as Record<PortName, DbPort<TSchema>>,
-        async stop() {
-          // Gracefully close the connection pool
-          try {
-            await dbPort.pool.end();
-          } catch (error) {
-            // Log error but don't throw - we're shutting down anyway
-            console.error(
-              "[drizzlePostgresProvider] Error closing database connection:",
-              error,
-            );
-          }
-        },
-      };
+      return setupPool(ports, pool, true);
     },
   });
 }

package/src/postgres/schema.ts

@@ -43,6 +43,7 @@ export const outboxMessages = pgTable(
     kind: text("kind").notNull(),
     name: text("name").notNull(),
     payloadJson: text("payload_json").notNull(),
+    traceContextJson: text("trace_context_json"),
     status: text("status").notNull(),
     attempts: integer("attempts").notNull().default(0),
     maxAttempts: integer("max_attempts").notNull().default(3),

package/src/shared/idempotency-core.ts

@@ -13,6 +13,7 @@
 
 import {
   createIdempotencyStorageKey,
+  DEFAULT_IDEMPOTENCY_RESERVATION_TTL_SEC,
   type IdempotencyCompleteInput,
   type IdempotencyFailInput,
   type IdempotencyPort,
@@ -57,6 +58,8 @@ export interface IdempotencyPortCoreOptions {
    * Clock used by tests and deterministic environments.
    */
   now?: () => Date;
+  /** Token factory used for deterministic tests. */
+  createReservationToken?: () => string;
 }
 
 /**
@@ -84,7 +87,7 @@ export type IdempotencyMutationErrorConstructor = new (
 export function formatIdempotencyMutationErrorMessage(
   args: IdempotencyMutationErrorArgs,
 ): string {
-  return `Idempotency ${args.action} for key "${args.key}" in namespace "${args.namespace}" matched no in-progress reservation with this fingerprint. The reservation may be missing, expired, already completed or released, or reserved with a different fingerprint.`;
+  return `Idempotency ${args.action} for key "${args.key}" in namespace "${args.namespace}" matched no in-progress reservation with this fingerprint and reservation token. The reservation may be missing, expired, already completed or released, or owned by a different execution.`;
 }
 
 function nowFrom(options: IdempotencyPortCoreOptions): Date {
@@ -117,6 +120,7 @@ function validateReserveInput(input: IdempotencyReserveInput): void {
   assertNonEmptyString("key", input.key);
   assertNonEmptyString("fingerprint", input.fingerprint);
   assertIdempotencyTtl(input.ttlSec);
+  assertIdempotencyTtl(input.reservationTtlSec);
 }
 
 function validateMutationInput(
@@ -125,6 +129,65 @@ function validateMutationInput(
   assertNonEmptyString("namespace", input.namespace);
   assertNonEmptyString("key", input.key);
   assertNonEmptyString("fingerprint", input.fingerprint);
+  assertNonEmptyString("reservationToken", input.reservationToken);
+}
+
+type StoredReservationState = {
+  reservationToken: string;
+  replayTtlSec: number | null;
+};
+
+function encodeReservationState(
+  reservationToken: string,
+  replayTtlSec: number | undefined,
+): string {
+  return JSON.stringify({
+    reservationToken,
+    replayTtlSec: replayTtlSec ?? null,
+  });
+}
+
+function decodeReservationState(
+  value: string | null,
+): StoredReservationState | undefined {
+  if (value === null) return undefined;
+  try {
+    const parsed = JSON.parse(value) as {
+      reservationToken?: unknown;
+      replayTtlSec?: unknown;
+    };
+    if (
+      typeof parsed.reservationToken !== "string" ||
+      (parsed.replayTtlSec !== null &&
+        (!Number.isInteger(parsed.replayTtlSec) ||
+          Number(parsed.replayTtlSec) <= 0))
+    ) {
+      return undefined;
+    }
+    return {
+      reservationToken: parsed.reservationToken,
+      replayTtlSec:
+        parsed.replayTtlSec === null ? null : Number(parsed.replayTtlSec),
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+function createRandomReservationToken(): string {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+
+  const bytes = new Uint8Array(16);
+  globalThis.crypto?.getRandomValues?.(bytes);
+  if (bytes.some((value) => value !== 0)) {
+    return Array.from(bytes, (value) =>
+      value.toString(16).padStart(2, "0"),
+    ).join("");
+  }
+
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
 }
 
 /**
@@ -172,7 +235,15 @@ export function createIdempotencyPortCore(
 
     const now = nowFrom(options);
     const nowIso = encodeTimestamp(now);
-    const expiresAt = resolveIdempotencyExpiresAt(input.ttlSec, now);
+    const expiresAt = resolveIdempotencyExpiresAt(
+      input.reservationTtlSec ?? DEFAULT_IDEMPOTENCY_RESERVATION_TTL_SEC,
+      now,
+    );
+    const reservationToken = encodeReservationState(
+      (options.createReservationToken ?? createRandomReservationToken)(),
+      input.ttlSec,
+    );
+    const reservationJson = reservationToken;
     const storageKey = createIdempotencyStorageKey(input);
     const scopeKey = normalizeIdempotencyScope(input.scope);
     const reserved = (): IdempotencyReservation => ({
@@ -181,6 +252,7 @@ export function createIdempotencyPortCore(
       key: input.key,
       scopeKey,
       fingerprint: input.fingerprint,
+      reservationToken,
       reservedAt: now,
       expiresAt,
     });
@@ -204,7 +276,7 @@ export function createIdempotencyPortCore(
       ${scopeKey},
       ${input.fingerprint},
       'in-progress',
-      null,
+      ${reservationJson},
       ${nowIso},
       null,
       ${expiresAt ? encodeTimestamp(expiresAt) : null},
@@ -225,7 +297,7 @@ export function createIdempotencyPortCore(
         scope_key = ${scopeKey},
         fingerprint = ${input.fingerprint},
         status = 'in-progress',
-        result_json = null,
+        result_json = ${reservationJson},
         reserved_at = ${nowIso},
         completed_at = null,
         expires_at = ${expiresAt ? encodeTimestamp(expiresAt) : null},
@@ -265,8 +337,14 @@ export function createIdempotencyPortCore(
     async complete(input) {
       validateMutationInput(input);
 
-      const nowIso = encodeTimestamp(nowFrom(options));
+      const completedAt = nowFrom(options);
+      const completedAtIso = encodeTimestamp(completedAt);
       const storageKey = createIdempotencyStorageKey(input);
+      const reservationState = decodeReservationState(input.reservationToken);
+      const expiresAt = resolveIdempotencyExpiresAt(
+        reservationState?.replayTtlSec ?? undefined,
+        completedAt,
+      );
       const serializedResult = JSON.stringify(input.result);
       const resultJson =
         serializedResult === undefined ? null : serializedResult;
@@ -275,10 +353,12 @@ export function createIdempotencyPortCore(
         set
           status = 'completed',
           result_json = ${resultJson},
-          completed_at = ${nowIso},
-          updated_at = ${nowIso}
+          completed_at = ${completedAtIso},
+          expires_at = ${expiresAt ? encodeTimestamp(expiresAt) : null},
+          updated_at = ${completedAtIso}
         where storage_key = ${storageKey}
           and fingerprint = ${input.fingerprint}
+          and result_json = ${input.reservationToken}
           and status = 'in-progress'`);
 
       assertIdempotencyMutationSucceeded("complete", input, rowsAffected);
@@ -291,6 +371,7 @@ export function createIdempotencyPortCore(
       const rowsAffected = await executor.run(sql`delete from ${executor.table}
         where storage_key = ${storageKey}
           and fingerprint = ${input.fingerprint}
+          and result_json = ${input.reservationToken}
           and status = 'in-progress'`);
 
       assertIdempotencyMutationSucceeded("fail", input, rowsAffected);

package/src/shared/outbox-core.ts

@@ -362,6 +362,7 @@ export function createOutboxPortCore(
         kind,
         name,
         payload_json,
+        trace_context_json,
         status,
         attempts,
         max_attempts,
@@ -378,6 +379,7 @@ export function createOutboxPortCore(
         ${message.kind},
         ${message.name},
         ${JSON.stringify(message.payload)},
+        ${message.trace ? JSON.stringify(message.trace) : null},
         ${message.status},
         ${message.attempts},
         ${message.maxAttempts},