@porulle/core 0.34.0 → 0.35.1

package/dist/test-utils/create-pglite-adapter.d.ts

@@ -38,8 +38,12 @@ export interface QueryLog {
  *   - db: The Drizzle ORM instance for direct queries
  *   - cleanup: Function to truncate all tables (call between tests)
  */
+/** The test adapter carries one thing a production adapter does not: see `inTransaction`. */
+export type PGliteTestAdapter = DatabaseAdapter & {
+    inTransaction(): boolean;
+};
 export declare function createPGliteTestAdapter(): Promise<{
-    adapter: DatabaseAdapter;
+    adapter: PGliteTestAdapter;
     db: DrizzleDatabase;
     cleanup: () => Promise<void>;
     queryLog: QueryLog;

package/dist/test-utils/create-pglite-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-pglite-adapter.d.ts","sourceRoot":"","sources":["../../src/test-utils/create-pglite-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAMrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAExE;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ;IACvB,4DAA4D;IAC5D,KAAK,IAAI,IAAI,CAAC;IACd,mEAAmE;IACnE,IAAI,IAAI,MAAM,EAAE,CAAC;CAClB;AA0BD;;;;;;;;;;GAUG;AACH,wBAAsB,uBAAuB,IAAI,OAAO,CAAC;IACvD,OAAO,EAAE,eAAe,CAAC;IACzB,EAAE,EAAE,eAAe,CAAC;IACpB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,QAAQ,EAAE,QAAQ,CAAC;CACpB,CAAC,CA6GD"}
+{"version":3,"file":"create-pglite-adapter.d.ts","sourceRoot":"","sources":["../../src/test-utils/create-pglite-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAMrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAExE;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ;IACvB,4DAA4D;IAC5D,KAAK,IAAI,IAAI,CAAC;IACd,mEAAmE;IACnE,IAAI,IAAI,MAAM,EAAE,CAAC;CAClB;AA0BD;;;;;;;;;;GAUG;AACH,6FAA6F;AAC7F,MAAM,MAAM,iBAAiB,GAAG,eAAe,GAAG;IAAE,aAAa,IAAI,OAAO,CAAA;CAAE,CAAC;AAE/E,wBAAsB,uBAAuB,IAAI,OAAO,CAAC;IACvD,OAAO,EAAE,iBAAiB,CAAC;IAC3B,EAAE,EAAE,eAAe,CAAC;IACpB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,QAAQ,EAAE,QAAQ,CAAC;CACpB,CAAC,CA4HD"}

package/dist/test-utils/create-pglite-adapter.js

@@ -36,17 +36,6 @@ async function pushCoreSchema(db) {
     const { apply } = await drizzleKit.pushSchema(coreSchema, db);
     await apply();
 }
-/**
- * Creates a PGlite-backed database adapter for testing.
- *
- * Each call creates a new isolated PGlite instance with its own
- * in-memory database. Core schema is pushed once during initialization.
- *
- * @returns A promise resolving to an object containing:
- *   - adapter: The DatabaseAdapter for use with createKernel
- *   - db: The Drizzle ORM instance for direct queries
- *   - cleanup: Function to truncate all tables (call between tests)
- */
 export async function createPGliteTestAdapter() {
     // Create in-memory PGlite instance
     const pg = new PGlite();
@@ -128,6 +117,21 @@ export async function createPGliteTestAdapter() {
         provider: "postgresql",
         db,
         transaction,
+        /**
+         * Whether a transaction body is executing RIGHT NOW on this adapter.
+         *
+         * Exposed for one reason: an after-hook that fires before its transaction commits is
+         * invisible to every assertion a PGlite suite can otherwise make. This adapter hands the
+         * transaction body the SAME `db` handle it hands everyone else, so a hook's query inside an
+         * open transaction succeeds and reads uncommitted rows exactly as if it had committed — the
+         * instrument is blind to the defect by construction. A recording jobs adapter stamping each
+         * enqueue with this flag is the only thing in a PGlite test that can tell "enqueued after
+         * commit" from "enqueued inside the transaction that may still roll back".
+         *
+         * Test-utils only. Production adapters do not carry it, and nothing outside a test may branch
+         * on it — a behaviour that depends on this flag would be a behaviour no production adapter has.
+         */
+        inTransaction: () => inTransaction,
     };
     /**
      * Cleanup function to reset data between tests.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@porulle/core",
-  "version": "0.34.0",
+  "version": "0.35.1",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/kernel/database/adapter.ts

@@ -1,3 +1,5 @@
+import { withDeferredHooks } from "../hooks/deferred.js";
+
 /**
  * Database adapter interface for the commerce engine.
  *
@@ -72,6 +74,24 @@ function normalizeExecuteShape<T extends object>(db: T): T {
           return result;
         };
       }
+      if (prop === "transaction") {
+        const orig = Reflect.get(target, prop, target);
+        if (typeof orig !== "function") return orig;
+        // The OTHER half of the after-commit drain, and the one the card this shipped for
+        // actually needs. `createDatabaseConnection().transaction` covers core services and REST
+        // routes, but a plugin does not get the adapter — it is handed this db HANDLE as
+        // `ctx.db` (TaskContext.db is a DrizzleDatabase) and calls `ctx.db.transaction(...)`.
+        // `plugin-channel-connector` constructs its service with no transaction argument in
+        // production and therefore imports every product through exactly this path, so without
+        // the wrapper here the fix would be green in every suite (they inject the adapter's
+        // transaction explicitly) and inert on the deployed import.
+        //
+        // Double-wrapping is safe: `withDeferredHooks` joins an existing store and drains only at
+        // the outermost boundary, so adapter.transaction -> db.transaction nests without draining
+        // twice.
+        return (fn: (tx: unknown) => Promise<unknown>) =>
+          withDeferredHooks(() => (orig as (f: typeof fn) => Promise<unknown>).call(target, fn));
+      }
       const value = Reflect.get(target, prop, target);
       // Bind methods to the real instance so drizzle's internals (incl. any
       // private fields) are never accessed through the proxy.
@@ -86,7 +106,10 @@ export function createDatabaseConnection(input: DatabaseConnectionFactoryInput):
     provider: adapter.provider,
     db: normalizeExecuteShape(adapter.db as object),
     transaction<T>(fn: (tx: unknown) => Promise<T>): Promise<T> {
-      return adapter.transaction((tx) => fn(normalizeExecuteShape(tx as object)));
+      return withDeferredHooks(() =>
+        // adapter.transaction resolving IS the commit, so draining after it
+        // resolves is draining after commit.
+        adapter.transaction((tx) => fn(normalizeExecuteShape(tx as object))));
     },
   };
 }

package/src/kernel/hooks/deferred.ts

@@ -0,0 +1,53 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+interface DeferredStore {
+  deferred: Array<() => Promise<void>>;
+}
+
+const deferredStorage = new AsyncLocalStorage<DeferredStore>();
+
+export function isInsideTransaction(): boolean {
+  return deferredStorage.getStore() != null;
+}
+
+export function deferAfterCommit(thunk: () => Promise<void>): boolean {
+  const pending = deferredStorage.getStore();
+  if (!pending) return false;
+  pending.deferred.push(thunk);
+  return true;
+}
+
+async function drainDeferred(pending: DeferredStore): Promise<void> {
+  // `for...of` over a live array on purpose: a deferred hook that defers another one is drained
+  // in the same pass rather than being dropped.
+  for (const thunk of pending.deferred) {
+    try {
+      await thunk();
+    } catch {
+      // Each thunk logs its own hook failure (see runAfterHooks); swallow so siblings still run.
+    }
+  }
+}
+
+export async function withDeferredHooks<T>(fn: () => Promise<T>): Promise<T> {
+  const existing = deferredStorage.getStore();
+  if (existing) {
+    return fn();
+  }
+
+  const pending: DeferredStore = { deferred: [] };
+  // A throw propagates without reaching the drain: a rolled-back transaction discards its deferred
+  // hooks rather than announcing a write that never happened. Stated rather than implied.
+  const result = await deferredStorage.run(pending, fn);
+
+  // AWAITED, never `void`. `adapter.transaction` resolving IS the commit, so the hooks below run
+  // after commit — and they must still run INSIDE the invocation that started them. The Workers
+  // runtime discards a promise that is neither awaited nor handed to `waitUntil` once the
+  // invocation ends, which this codebase has already paid for once: a fire-and-forget queue nudge
+  // wrote 104 outbox rows and sent ZERO messages on the deployed Worker while every Node test
+  // passed. Detaching this drain would do the same to every webhook and search-index update in the
+  // product. "After commit" is the requirement; "after the service method returns" is not, and is
+  // what tempts you to detach it.
+  await drainDeferred(pending);
+  return result;
+}

package/src/kernel/hooks/executor.ts

@@ -1,4 +1,5 @@
 import type { AfterHook, BeforeHook, HookContext, HookOperation } from "./types.js";
+import { deferAfterCommit } from "./deferred.js";
 
 export interface HookError {
   hookName: string;
@@ -84,30 +85,66 @@ export async function runAfterHooks<T>(
   committedResult: T,
   operation: HookOperation,
   context: HookContext,
+  runsInTransaction: (hook: AfterHook<T>) => boolean = () => false,
 ): Promise<HookReport> {
   const errors: HookError[] = [];
   for (const hook of hooks) {
     const hookName = hook.name || "(anonymous afterHook)";
-    try {
-      await withTimeout(
+    const runHook = () =>
+      withTimeout(
         hook({
           data: originalData,
           result: committedResult,
           operation,
-          context,
+          context: runsInTransaction(hook)
+            ? context
+            : { ...context, tx: null },
         }),
         HOOK_TIMEOUT_MS,
         hookName,
       );
-    } catch (error) {
-      errors.push({
-        hookName,
-        message: error instanceof Error ? error.message : String(error),
-      });
-      context.logger.error(`After-hook "${hookName}" failed`, {
-        error,
-      });
+
+    if (runsInTransaction(hook)) {
+      try {
+        await runHook();
+      } catch (error) {
+        errors.push({
+          hookName,
+          message: error instanceof Error ? error.message : String(error),
+        });
+        context.logger.error(`After-hook "${hookName}" failed`, {
+          error,
+        });
+      }
+      continue;
+    }
+
+    const deferred = deferAfterCommit(async () => {
+      try {
+        await runHook();
+      } catch (error) {
+        context.logger.error(`After-commit hook "${hookName}" failed`, {
+          error,
+        });
+      }
+    });
+
+    if (!deferred) {
+      try {
+        await runHook();
+      } catch (error) {
+        errors.push({
+          hookName,
+          message: error instanceof Error ? error.message : String(error),
+        });
+        context.logger.error(`After-hook "${hookName}" failed`, {
+          error,
+        });
+      }
     }
   }
+  // After-commit hook failures are logged when the transaction drains; they
+  // cannot appear here because deferred hooks run after commit, once the
+  // service method has already returned its Result.
   return { errors, hasErrors: errors.length > 0 };
 }

package/src/kernel/hooks/registry.ts

@@ -1,5 +1,29 @@
 export type HookHandler = (...args: never[]) => unknown;
 
+/**
+ * Handlers a PLUGIN asked to run inside the writing transaction.
+ *
+ * Module-level rather than per-registry because a plugin's declaration and its registration are
+ * separated by the manifest merge: `manifest.hooks()` returns `{ key, handler, inTransaction }`
+ * records, which are flattened into `config.hooks` as a bare `key -> handler[]` map long before any
+ * HookRegistry exists. Marking the function itself is the only channel that survives that.
+ *
+ * Shipped in 0.35.1 because 0.35.0 made after-commit the default with no way for a plugin to opt
+ * out, which silently moved `loom_projection_pending` — a transactional outbox whose whole point is
+ * committing with the write it records — to after the commit.
+ */
+const pluginInTransactionHandlers = new WeakSet<object>();
+
+/** Declare that this handler must run inside the writing transaction. Called by the manifest merge. */
+export function markHookInTransaction(handler: unknown): void {
+  if (typeof handler === "function") pluginInTransactionHandlers.add(handler as object);
+}
+
+/** Whether a plugin asked for this handler to run in-transaction. Read by the kernel at boot. */
+export function isHookMarkedInTransaction(handler: unknown): boolean {
+  return typeof handler === "function" && pluginInTransactionHandlers.has(handler as object);
+}
+
 type HookEntry = {
   prepended: HookHandler[];
   configured: HookHandler[];
@@ -8,6 +32,7 @@ type HookEntry = {
 
 export class HookRegistry {
   private registry = new Map<string, HookEntry>();
+  private inTransactionHandlers = new WeakSet<HookHandler>();
   private logger?: { error: (obj: Record<string, unknown>, msg: string) => void };
 
   registerConfigHooks(hookName: string, handlers: HookHandler[]): void {
@@ -20,11 +45,25 @@ export class HookRegistry {
     this.registry.get(hookName)!.appended.push(handler);
   }
 
+  appendInTransaction(hookName: string, handler: HookHandler): void {
+    this.inTransactionHandlers.add(handler);
+    this.append(hookName, handler);
+  }
+
   prepend(hookName: string, handler: HookHandler): void {
     this.ensureEntry(hookName);
     this.registry.get(hookName)!.prepended.push(handler);
   }
 
+  prependInTransaction(hookName: string, handler: HookHandler): void {
+    this.inTransactionHandlers.add(handler);
+    this.prepend(hookName, handler);
+  }
+
+  runsInTransaction(handler: HookHandler): boolean {
+    return this.inTransactionHandlers.has(handler);
+  }
+
   resolve(hookName: string): HookHandler[] {
     const entry = this.registry.get(hookName);
     if (!entry) return [];

package/src/kernel/plugin/manifest.ts

@@ -1,4 +1,5 @@
 import type { Hono } from "hono";
+import { markHookInTransaction } from "../hooks/registry.js";
 import type { OpenAPIHono, RouteConfig } from "@hono/zod-openapi";
 import type { PluginDb } from "../database/plugin-types.js";
 import type { DatabaseAdapter } from "../database/adapter.js";
@@ -43,6 +44,15 @@ export type PluginRouteRegistration =
 export interface PluginHookRegistration {
   key: string;
   handler: (...args: unknown[]) => unknown;
+  /**
+   * Run this hook INSIDE the writing transaction instead of after it commits.
+   *
+   * The default is after-commit and is correct for anything with an external effect — a webhook, a
+   * search-index write, an email — none of which may announce a write that can still roll back.
+   * Set this only for an OUTBOX WRITER: a hook whose own write must commit or roll back together
+   * with the row it records. `loom_projection_pending` is the case this exists for.
+   */
+  inTransaction?: boolean;
 }
 
 // ─── Plugin Context (available to routes at boot time) ───────
@@ -294,6 +304,9 @@ export function defineCommercePlugin(
         ...(result.hooks ?? {}),
       };
       for (const reg of registrations) {
+        // The marker rides on the function because this map is a bare key -> handler[] and cannot
+        // carry it; the kernel reads it back when it registers these at boot.
+        if (reg.inTransaction) markHookInTransaction(reg.handler);
         hookMap[reg.key] = [...(hookMap[reg.key] ?? []), reg.handler];
       }
       result = { ...result, hooks: hookMap };

package/src/modules/catalog/entity-service.ts

@@ -285,7 +285,7 @@ export class EntityService {
     if (existingBySlug) return Err(new CommerceConflictError(`Entity with slug ${input.slug} already exists.`));
     const beforeHooks = this.deps.hooks.resolve("catalog.beforeCreate") as CatalogCreateBeforeHook[];
     const afterHooks = this.deps.hooks.resolve("catalog.afterCreate") as CatalogCreateAfterHook[];
-    const context: HookContext = createHookContext({ actor, tx: ctx?.tx ?? null, logger: createLogger("catalog.create"), services: this.deps.services, context: { moduleName: "catalog" }, ...hookDatabaseArg(this.deps.database), commerceConfig: this.deps.config });
+    const context: HookContext = catalogHookContext(this.deps, actor, ctx, "create");
     const processedInput = await runBeforeHooks(beforeHooks, input, "create", context);
     if (processedInput.sourceStoreId != null) assertPermission(actor, "catalog:sync");
     const customFieldsResult = await this.validateCustomFields(processedInput.type, processedInput.customFields, actor, ctx);
@@ -297,7 +297,7 @@ export class EntityService {
       await this.repo.createAttribute({ entityId: entity.id, locale: processedInput.attributes.locale ?? "en", title: processedInput.attributes.title, subtitle: processedInput.attributes.subtitle, description: processedInput.attributes.description, richDescription: processedInput.attributes.richDescription, seoTitle: processedInput.attributes.seoTitle, seoDescription: processedInput.attributes.seoDescription }, ctx);
     }
     await this.writeCustomFields(entity.id, customFieldsResult.value, ctx);
-    const hookReport = await runAfterHooks(afterHooks, null, entity, "create", context);
+    const hookReport = await runAfterHooks(afterHooks, null, entity, "create", context, (hook) => this.deps.hooks.runsInTransaction(hook));
     const hydrated = await this.hydrateEntity(entity, undefined, ctx);
     return Ok(hydrated, hookReport.hasErrors ? { hookErrors: hookReport.errors } : undefined);
   } catch (error) { return Err(toCommerceError(error)); } }
@@ -318,7 +318,7 @@ export class EntityService {
     const updated = await this.repo.updateEntity(id, { ...(processed.slug !== undefined ? { slug: processed.slug } : {}), ...(processed.status !== undefined ? { status: processed.status as SellableEntity["status"] } : {}), ...(processed.taxClass !== undefined ? { taxClass: processed.taxClass } : {}), ...(processed.metadata !== undefined ? { metadata: processed.metadata } : {}), ...(processed.isVisible !== undefined ? { isVisible: processed.isVisible } : {}) }, txCtx);
     if (!updated) return Err(new CommerceNotFoundError("Entity not found."));
     await this.writeCustomFields(existing.id, customFieldsResult.value, txCtx, true);
-    const hookReport = await runAfterHooks(afterHooks, existing, updated, "update", context);
+    const hookReport = await runAfterHooks(afterHooks, existing, updated, "update", context, (hook) => this.deps.hooks.runsInTransaction(hook));
     const hydrated = await this.hydrateEntity(updated, undefined, txCtx);
     return Ok(hydrated, hookReport.hasErrors ? { hookErrors: hookReport.errors } : undefined);
   } catch (error) { return Err(toCommerceError(error)); } }
@@ -367,7 +367,7 @@ export class EntityService {
     }
     const result = await this.hydrateEntity(entity, processed.options ?? options, ctx);
     const entityAfterHooks = this.deps.hooks.resolve(`catalog.${entity.type}.afterRead`) as CatalogReadAfterHook[];
-    const report = mergeHookReports(await runAfterHooks(globalAfterHooks, null, result, "read", context), await runAfterHooks(entityAfterHooks, null, result, "read", context));
+    const report = mergeHookReports(await runAfterHooks(globalAfterHooks, null, result, "read", context, (hook) => this.deps.hooks.runsInTransaction(hook)), await runAfterHooks(entityAfterHooks, null, result, "read", context, (hook) => this.deps.hooks.runsInTransaction(hook)));
     return Ok(result, report.hasErrors ? { hookErrors: report.errors } : undefined);
   }
 
@@ -418,7 +418,7 @@ export class EntityService {
     }
     const result = await this.hydrateEntity(entity, processed.options ?? options, ctx);
     const entityAfterHooks = this.deps.hooks.resolve(`catalog.${entity.type}.afterRead`) as CatalogReadAfterHook[];
-    const report = mergeHookReports(await runAfterHooks(globalAfterHooks, null, result, "read", context), await runAfterHooks(entityAfterHooks, null, result, "read", context));
+    const report = mergeHookReports(await runAfterHooks(globalAfterHooks, null, result, "read", context, (hook) => this.deps.hooks.runsInTransaction(hook)), await runAfterHooks(entityAfterHooks, null, result, "read", context, (hook) => this.deps.hooks.runsInTransaction(hook)));
     return Ok(result, report.hasErrors ? { hookErrors: report.errors } : undefined);
   }
 
@@ -490,7 +490,7 @@ export class EntityService {
     const result = { items: hydratedItems, pagination: paged.pagination };
     const listTypeFilter = processed.filter?.type;
     const entityAfterHooks = listTypeFilter ? (this.deps.hooks.resolve(`catalog.${listTypeFilter}.afterList`) as CatalogListAfterHook[]) : [];
-    const report = mergeHookReports(await runAfterHooks(globalAfterHooks, null, result, "list", context), await runAfterHooks(entityAfterHooks, null, result, "list", context));
+    const report = mergeHookReports(await runAfterHooks(globalAfterHooks, null, result, "list", context, (hook) => this.deps.hooks.runsInTransaction(hook)), await runAfterHooks(entityAfterHooks, null, result, "list", context, (hook) => this.deps.hooks.runsInTransaction(hook)));
     return Ok(result, report.hasErrors ? { hookErrors: report.errors } : undefined);
   }
 
@@ -533,7 +533,7 @@ export class EntityService {
       const afterHooks = this.deps.hooks.resolve("catalog.afterUpdate") as CatalogUpdateAfterHook[];
       const context = catalogHookContext(this.deps, actor, ctx, "update");
       context.context.changedFieldPaths = changedFieldPaths;
-      await runAfterHooks(afterHooks, entity, entity, "update", context);
+      await runAfterHooks(afterHooks, entity, entity, "update", context, (hook) => this.deps.hooks.runsInTransaction(hook));
     }
     return Ok(undefined);
   }

package/src/modules/customers/service.ts

@@ -102,7 +102,7 @@ export class CustomerService {
       "customers.afterCreate",
     ) as AfterHook<Customer>[];
     const hctx = hookContext(actor ?? null, this.deps.services, this.deps.database, this.deps.config, ctx?.tx ?? null);
-    await runAfterHooks(afterHooks, null, customer, "create", hctx);
+    await runAfterHooks(afterHooks, null, customer, "create", hctx, (hook) => this.deps.hooks.runsInTransaction(hook));
 
     return Ok(customer);
   }
@@ -195,7 +195,7 @@ export class CustomerService {
       "customers.afterCreate",
     ) as AfterHook<Customer>[];
     const hctx = hookContext(actor, this.deps.services, this.deps.database, this.deps.config, ctx?.tx ?? null);
-    await runAfterHooks(afterHooks, null, customer, "create", hctx);
+    await runAfterHooks(afterHooks, null, customer, "create", hctx, (hook) => this.deps.hooks.runsInTransaction(hook));
 
     return customer;
   }
@@ -277,7 +277,7 @@ export class CustomerService {
     const hctx = hookContext(
       actor ?? ctx?.actor ?? null, this.deps.services, this.deps.database, this.deps.config, ctx?.tx ?? null,
     );
-    await runAfterHooks(afterHooks, existing, updated, "update", hctx);
+    await runAfterHooks(afterHooks, existing, updated, "update", hctx, (hook) => this.deps.hooks.runsInTransaction(hook));
 
     return Ok(updated);
   }
@@ -308,7 +308,7 @@ export class CustomerService {
       "customers.afterUpdate",
     ) as AfterHook<Customer>[];
     const hctx = hookContext(resolvedActor, this.deps.services, this.deps.database, this.deps.config, ctx?.tx ?? null);
-    await runAfterHooks(afterHooks, customer, updated, "update", hctx);
+    await runAfterHooks(afterHooks, customer, updated, "update", hctx, (hook) => this.deps.hooks.runsInTransaction(hook));
 
     return Ok(updated);
   }

package/src/modules/fulfillment/service.ts

@@ -331,7 +331,7 @@ export class FulfillmentService {
         database: { db: this.deps.database.db as PluginDb },
         commerceConfig: this.deps.config,
       });
-      await runAfterHooks(afterHooks, null, record, "create", hookCtx);
+      await runAfterHooks(afterHooks, null, record, "create", hookCtx, (hook) => this.deps.hooks.runsInTransaction(hook));
 
       // Create a fulfillment line item linking this fulfillment to the order line item
       for (const li of record.lineItems) {
@@ -490,7 +490,7 @@ export class FulfillmentService {
       database: { db: this.deps.database.db as PluginDb },
       commerceConfig: this.deps.config,
     });
-    await runAfterHooks(afterHooks, null, record, "create", hookCtx);
+    await runAfterHooks(afterHooks, null, record, "create", hookCtx, (hook) => this.deps.hooks.runsInTransaction(hook));
 
     return Ok(record);
   }

package/src/modules/inventory/service.ts

@@ -446,6 +446,7 @@ export class InventoryService {
         level,
         "update",
         hookCtx,
+        (hook) => this.deps.hooks.runsInTransaction(hook),
       );
 
       return Ok({ level, before, after, delta, movementId: movement.id });

package/src/modules/orders/service.ts

@@ -749,6 +749,7 @@ export class OrderService {
       hydrated,
       "create",
       hookCtx,
+      (hook) => this.deps.hooks.runsInTransaction(hook),
     );
 
     return Ok(
@@ -797,7 +798,7 @@ export class OrderService {
     ) as AfterHook<HydratedOrder>[];
     if (afterGetHooks.length > 0) {
       const hookCtx = context(actor, this.deps.services, this.deps.database, this.deps.config, ctx?.tx);
-      await runAfterHooks(afterGetHooks, null, hydrated, "read", hookCtx);
+      await runAfterHooks(afterGetHooks, null, hydrated, "read", hookCtx, (hook) => this.deps.hooks.runsInTransaction(hook));
     }
 
     return Ok(hydrated);
@@ -1257,6 +1258,7 @@ export class OrderService {
       hydrated,
       "statusChange",
       hookCtx,
+      (hook) => this.deps.hooks.runsInTransaction(hook),
     );
 
     return Ok(

package/src/modules/promotions/service.ts

@@ -245,7 +245,7 @@ export class PromotionService {
     const hctx = hookContext(
       actor ?? ctx?.actor ?? null, this.deps.services, this.deps.database, this.deps.config, ctx?.tx ?? null,
     );
-    await runAfterHooks(afterHooks, null, promotion, "create", hctx);
+    await runAfterHooks(afterHooks, null, promotion, "create", hctx, (hook) => this.deps.hooks.runsInTransaction(hook));
 
     return Ok(promotion);
   }
@@ -266,7 +266,7 @@ export class PromotionService {
     ) as AfterHook<Promotion>[];
     // Actor-less by design; resolves to the deployment's declared organization.
     const hctx = hookContext(null, this.deps.services, this.deps.database, this.deps.config, ctx?.tx ?? null);
-    await runAfterHooks(afterHooks, promotion, updated, "update", hctx);
+    await runAfterHooks(afterHooks, promotion, updated, "update", hctx, (hook) => this.deps.hooks.runsInTransaction(hook));
 
     return Ok(updated);
   }
@@ -345,7 +345,7 @@ export class PromotionService {
     const hctx = hookContext(
       actor ?? ctx?.actor ?? null, this.deps.services, this.deps.database, this.deps.config, ctx?.tx ?? null,
     );
-    await runAfterHooks(afterHooks, existing, updated, "update", hctx);
+    await runAfterHooks(afterHooks, existing, updated, "update", hctx, (hook) => this.deps.hooks.runsInTransaction(hook));
 
     return Ok(updated);
   }

package/src/runtime/kernel-register-hooks.ts

@@ -58,6 +58,6 @@ export function registerConfiguredKernelHooks(
   hooks.append("catalog.afterUpdate", syncToSearchIndex);
 
   for (const [key, handler] of Object.entries(auditHooks)) {
-    hooks.append(key, handler);
+    hooks.appendInTransaction(key, handler);
   }
 }

package/src/runtime/kernel.ts

@@ -1,5 +1,5 @@
 import type { CommerceConfig } from "../config/types.js";
-import { HookRegistry, type HookHandler } from "../kernel/hooks/registry.js";
+import { HookRegistry, isHookMarkedInTransaction, type HookHandler } from "../kernel/hooks/registry.js";
 import { createDatabaseConnection } from "../kernel/database/adapter.js";
 import type { DrizzleDatabase } from "../kernel/database/drizzle-db.js";
 import type { AppModule } from "../kernel/module/index.js";
@@ -162,7 +162,14 @@ export function createKernel(config: CommerceConfig): Kernel {
 
   for (const [key, handlers] of Object.entries(config.hooks ?? {})) {
     for (const handler of handlers) {
-      hooks.append(key, handler as HookHandler);
+      // A plugin that declared `inTransaction` gets appendInTransaction, so its hook runs inside
+      // the writing transaction rather than in the after-commit drain. Everything else defaults to
+      // after-commit, which is what 0.35.0 established.
+      if (isHookMarkedInTransaction(handler)) {
+        hooks.appendInTransaction(key, handler as HookHandler);
+      } else {
+        hooks.append(key, handler as HookHandler);
+      }
     }
   }
 

package/src/test-utils/create-pglite-adapter.ts

@@ -74,8 +74,11 @@ async function pushCoreSchema(db: DrizzleDatabase): Promise<void> {
  *   - db: The Drizzle ORM instance for direct queries
  *   - cleanup: Function to truncate all tables (call between tests)
  */
+/** The test adapter carries one thing a production adapter does not: see `inTransaction`. */
+export type PGliteTestAdapter = DatabaseAdapter & { inTransaction(): boolean };
+
 export async function createPGliteTestAdapter(): Promise<{
-  adapter: DatabaseAdapter;
+  adapter: PGliteTestAdapter;
   db: DrizzleDatabase;
   cleanup: () => Promise<void>;
   queryLog: QueryLog;
@@ -160,10 +163,25 @@ export async function createPGliteTestAdapter(): Promise<{
     return run as Promise<T>;
   }
 
-  const adapter: DatabaseAdapter = {
+  const adapter: DatabaseAdapter & { inTransaction(): boolean } = {
     provider: "postgresql",
     db,
     transaction,
+    /**
+     * Whether a transaction body is executing RIGHT NOW on this adapter.
+     *
+     * Exposed for one reason: an after-hook that fires before its transaction commits is
+     * invisible to every assertion a PGlite suite can otherwise make. This adapter hands the
+     * transaction body the SAME `db` handle it hands everyone else, so a hook's query inside an
+     * open transaction succeeds and reads uncommitted rows exactly as if it had committed — the
+     * instrument is blind to the defect by construction. A recording jobs adapter stamping each
+     * enqueue with this flag is the only thing in a PGlite test that can tell "enqueued after
+     * commit" from "enqueued inside the transaction that may still roll back".
+     *
+     * Test-utils only. Production adapters do not carry it, and nothing outside a test may branch
+     * on it — a behaviour that depends on this flag would be a behaviour no production adapter has.
+     */
+    inTransaction: () => inTransaction,
   };
 
   /**