@mandujs/core 0.53.1 → 0.53.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandujs/core",
-  "version": "0.53.1",
+  "version": "0.53.3",
   "description": "Mandu Framework Core - Spec, Generator, Guard, Runtime",
   "type": "module",
   "main": "./src/index.ts",

package/src/bundler/build.ts

@@ -65,9 +65,9 @@ function manduDefaultPlugins(options: BundlerOptions): BunPlugin[] {
  * this; SSR builds use `manduDefaultPlugins()` directly because React
  * Compiler offers zero benefit for one-shot HTML rendering.
  */
-function manduClientPlugins(options: BundlerOptions): BunPlugin[] {
-  const base = manduDefaultPlugins(options);
-  if (options.reactCompiler?.enabled !== true) return base;
+function manduClientPlugins(options: BundlerOptions): BunPlugin[] {
+  const base = manduDefaultPlugins(options);
+  if (options.reactCompiler?.enabled !== true) return base;
   // Lazy import to avoid pulling the react-compiler module into every
   // build graph — SSR / non-client paths never touch this branch.
   const { reactCompiler } = require("./plugins/react-compiler") as typeof __ManduPluginsReactCompilerTypes0;
@@ -75,9 +75,41 @@ function manduClientPlugins(options: BundlerOptions): BunPlugin[] {
     ...base,
     reactCompiler({
       reactCompilerConfig: options.reactCompiler.compilerConfig,
-    }),
-  ];
-}
+    }),
+  ];
+}
+
+function resolveBundlerMode(options: BundlerOptions): "development" | "production" {
+  return options.mode ?? (process.env.NODE_ENV === "production" ? "production" : "development");
+}
+
+function isDevelopmentBuild(options: BundlerOptions): boolean {
+  return resolveBundlerMode(options) === "development";
+}
+
+function shouldMinify(options: BundlerOptions): boolean {
+  return options.minify ?? (resolveBundlerMode(options) === "production");
+}
+
+function shouldSplitChunks(options: BundlerOptions): boolean {
+  return options.splitting ?? (resolveBundlerMode(options) === "production");
+}
+
+function nodeEnvDefine(options: BundlerOptions): string {
+  return JSON.stringify(resolveBundlerMode(options));
+}
+
+function resolveClientOutDir(rootDir: string, outDir?: string): string {
+  const defaultOutDir = path.join(rootDir, ".mandu/client");
+  if (!outDir) return defaultOutDir;
+
+  const resolvedOutDir = path.isAbsolute(outDir) ? outDir : path.resolve(rootDir, outDir);
+  if (path.normalize(resolvedOutDir) === path.normalize(path.join(rootDir, ".mandu"))) {
+    return defaultOutDir;
+  }
+
+  return resolvedOutDir;
+}
 
 /**
  * Scan for *.island.tsx / *.island.ts files across hydrated route directories.
@@ -230,20 +262,20 @@ async function buildPerIslandBundle(
   // Phase 7.1 B-1/B-4: wire Bun's native React Fast Refresh transform +
   // Mandu's boundary injection plugin — but only in dev. Production
   // bundles stay clean of `$RefreshReg$` / `$RefreshSig$` stubs.
-  const isDev = (options.minify ?? process.env.NODE_ENV === "production") === false;
+  const isDev = isDevelopmentBuild(options);
   try {
     await Bun.write(entryPath, generateIslandEntry(entry.name, entry.filePath));
     const result = await safeBuild({
       entrypoints: [entryPath],
       outdir: outDir,
       naming: outputName,
-      minify: options.minify ?? process.env.NODE_ENV === "production",
+      minify: shouldMinify(options),
       sourcemap: options.sourcemap ? "external" : "none",
       target: "browser",
       ...(isDev ? { reactFastRefresh: true } : {}),
       plugins: [...manduClientPlugins(options), ...(isDev ? [fastRefreshPlugin()] : [])],
       external: ["react", "react-dom", "react-dom/client", ...(options.external || [])],
-      define: { "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV || "development"), ...options.define },
+      define: { "process.env.NODE_ENV": nodeEnvDefine(options), ...options.define },
     });
     await fs.unlink(entryPath).catch(() => {});
     if (!result.success) {
@@ -1235,12 +1267,12 @@ async function buildRouterRuntime(
       entrypoints: [routerPath],
       outdir: outDir,
       naming: outputName,
-      minify: options.minify ?? process.env.NODE_ENV === "production",
+      minify: shouldMinify(options),
       sourcemap: options.sourcemap ? "external" : "none",
       target: "browser",
       plugins: manduDefaultPlugins(options),
       define: {
-        "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV || "development"),
+        "process.env.NODE_ENV": nodeEnvDefine(options),
         ...options.define,
       },
     });
@@ -1311,13 +1343,13 @@ async function buildRuntime(
       entrypoints: [runtimePath],
       outdir: outDir,
       naming: outputName,
-      minify: options.minify ?? process.env.NODE_ENV === "production",
+      minify: shouldMinify(options),
       sourcemap: options.sourcemap ? "external" : "none",
       target: "browser",
       external: ["react", "react-dom", "react-dom/client"],
       plugins: manduDefaultPlugins(options),
       define: {
-        "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV || "development"),
+        "process.env.NODE_ENV": nodeEnvDefine(options),
         ...options.define,
       },
     });
@@ -1472,8 +1504,7 @@ async function buildVendorShims(
   // Phase 7.1 B-2: dev-only Fast Refresh shims. In production we skip
   // them entirely so `react-refresh/runtime` is never bundled and the
   // attack surface / bundle size regressions stay zero for deploys.
-  const isDev =
-    (options.minify ?? process.env.NODE_ENV === "production") === false;
+  const isDev = isDevelopmentBuild(options);
 
   const shims: Array<{ name: string; source: string; key: VendorShimKey; cacheId: string }> = [
     { name: "_react", source: generateReactShimSource(), key: "react", cacheId: "react" },
@@ -1601,13 +1632,13 @@ async function buildVendorShims(
         entrypoints: [srcPath],
         outdir: outDir,
         naming: outputName,
-        minify: options.minify ?? process.env.NODE_ENV === "production",
+        minify: shouldMinify(options),
         sourcemap: options.sourcemap ? "external" : "none",
         target: "browser",
         external: shimExternal,
         plugins: manduDefaultPlugins(options),
         define: {
-          "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV || "development"),
+          "process.env.NODE_ENV": nodeEnvDefine(options),
           ...options.define,
         },
       });
@@ -1697,8 +1728,7 @@ async function buildIsland(
 
   // Phase 7.1 B-1/B-4: wire native Fast Refresh transform + Mandu's
   // boundary injection plugin. Dev-only; prod bundles remain clean.
-  const isDev =
-    (options.minify ?? process.env.NODE_ENV === "production") === false;
+  const isDev = isDevelopmentBuild(options);
   try {
     // 엔트리 래퍼 생성
     await Bun.write(entryPath, generateIslandEntry(route.id, clientModulePath));
@@ -1709,15 +1739,15 @@ async function buildIsland(
       entrypoints: [entryPath],
       outdir: outDir,
       naming: options.splitting ? "[name]-[hash].js" : outputName,
-      minify: options.minify ?? process.env.NODE_ENV === "production",
+      minify: shouldMinify(options),
       sourcemap: options.sourcemap ? "external" : "none",
       target: "browser",
-      splitting: options.splitting ?? (process.env.NODE_ENV === "production"),
+      splitting: shouldSplitChunks(options),
       ...(isDev ? { reactFastRefresh: true } : {}),
       plugins: [...manduClientPlugins(options), ...(isDev ? [fastRefreshPlugin()] : [])],
       external: ["react", "react-dom", "react-dom/client", ...(options.external || [])],
       define: {
-        "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV || "development"),
+        "process.env.NODE_ENV": nodeEnvDefine(options),
         ...options.define,
       },
     });
@@ -1911,15 +1941,13 @@ export async function buildClientBundles(
       errors.push(`onBundleComplete[${e.source}]: ${e.error.message}`);
     }
   };
-  const env = (process.env.NODE_ENV === "production" ? "production" : "development") as
-    | "development"
-    | "production";
+  const env = resolveBundlerMode(options);
 
   // 1. Hydration이 필요한 라우트 필터링
   const hydratedRoutes = getHydratedRoutes(manifest);
 
   // 2. 출력 디렉토리 생성 (항상 필요 - 매니페스트 저장용)
-  const outDir = options.outDir || path.join(rootDir, ".mandu/client");
+  const outDir = resolveClientOutDir(rootDir, options.outDir);
   await fs.mkdir(outDir, { recursive: true });
 
   // Hydration 라우트가 없어도 빈 매니페스트를 저장해야 함

package/src/bundler/dev.ts

@@ -409,11 +409,12 @@ export async function startDevBundler(options: DevBundlerOptions): Promise<DevBu
   } = options;
 
   // 초기 빌드
-  console.log("🔨 Initial client bundle build...");
-  const initialBuild = await buildClientBundles(manifest, rootDir, {
-    minify: false,
-    sourcemap: true,
-    reactCompiler,
+  console.log("🔨 Initial client bundle build...");
+  const initialBuild = await buildClientBundles(manifest, rootDir, {
+    mode: "development",
+    minify: false,
+    sourcemap: true,
+    reactCompiler,
   });
 
   if (initialBuild.success) {
@@ -1321,10 +1322,11 @@ export async function startDevBundler(options: DevBundlerOptions): Promise<DevBu
       const targetIds = Array.from(new Set(islandRoots.map((r) => r.routeId)));
       const startTime = performance.now();
       try {
-        const result = await buildClientBundles(manifest, rootDir, {
-          minify: false,
-          sourcemap: true,
-          targetRouteIds: targetIds,
+        const result = await buildClientBundles(manifest, rootDir, {
+          mode: "development",
+          minify: false,
+          sourcemap: true,
+          targetRouteIds: targetIds,
           reactCompiler,
         });
         const buildTime = performance.now() - startTime;
@@ -1379,10 +1381,11 @@ export async function startDevBundler(options: DevBundlerOptions): Promise<DevBu
 
       try {
         // #185: framework 번들 (runtime/router/vendor/devtools) 스킵 — 사용자 코드 변경 시 불필요
-        const result = await buildClientBundles(manifest, rootDir, {
-          minify: false,
-          sourcemap: true,
-          skipFrameworkBundles: true,
+        const result = await buildClientBundles(manifest, rootDir, {
+          mode: "development",
+          minify: false,
+          sourcemap: true,
+          skipFrameworkBundles: true,
           reactCompiler,
         });
 
@@ -1504,10 +1507,11 @@ export async function startDevBundler(options: DevBundlerOptions): Promise<DevBu
 
     try {
       // 단일 island만 재빌드 (Runtime/Router/Vendor 스킵, #122)
-      const result = await buildClientBundles(manifest, rootDir, {
-        minify: false,
-        sourcemap: true,
-        targetRouteIds: [routeId],
+      const result = await buildClientBundles(manifest, rootDir, {
+        mode: "development",
+        minify: false,
+        sourcemap: true,
+        targetRouteIds: [routeId],
         reactCompiler,
       });
 

package/src/bundler/types.ts

@@ -123,9 +123,14 @@ export interface IslandFileEntry {
 /**
  * 번들러 옵션
  */
-export interface BundlerOptions {
-  /** 코드 압축 여부 (기본: production에서 true) */
-  minify?: boolean;
+export interface BundlerOptions {
+  /**
+   * Build mode. This controls development-only transforms such as React
+   * Fast Refresh independently from minification.
+   */
+  mode?: "development" | "production";
+  /** 코드 압축 여부 (기본: production에서 true) */
+  minify?: boolean;
   /** 소스맵 생성 여부 */
   sourcemap?: boolean;
   /** 파일 감시 모드 */

package/src/config/validate.ts

@@ -237,9 +237,9 @@ const BuildBudgetConfigSchema = z
 /**
  * Build 설정 스키마 (strict)
  */
-const BuildConfigSchema = z
-  .object({
-    outDir: z.string().default(".mandu"),
+const BuildConfigSchema = z
+  .object({
+    outDir: z.string().default(".mandu/client"),
     minify: z.boolean().default(true),
     sourcemap: z.boolean().default(false),
     splitting: z.boolean().default(false),

package/src/db/index.ts

@@ -115,7 +115,7 @@ export interface DbConfig {
  * returns the full result array. The attached methods support one-shot
  * reads, transactions, and shutdown.
  */
-export interface Db {
+export interface Db {
   /**
    * Tagged-template query. Values are bound as parameters, never
    * interpolated as SQL text.
@@ -158,8 +158,17 @@ export interface Db {
    * Closes the connection pool. Subsequent queries reject with a clear
    * "pool closed" error. Calling `close()` twice is a no-op (idempotent).
    */
-  close(): Promise<void>;
-}
+  close(options?: DbCloseOptions): Promise<void>;
+}
+
+/** Options forwarded to Bun.SQL pool shutdown. */
+export interface DbCloseOptions {
+  /**
+   * Maximum seconds to wait for in-flight queries before closing the pool.
+   * `0` asks Bun.SQL to close immediately.
+   */
+  timeout?: number;
+}
 
 // ─── Bun runtime surface (structural; no `any`) ─────────────────────────────
 
@@ -181,14 +190,14 @@ interface BunSqlOptions {
  * A Bun.SQL instance — itself a callable tagged-template function with
  * methods attached. We only model the subset we actually use.
  */
-interface BunSqlInstance {
-  <T = unknown>(strings: TemplateStringsArray, ...values: unknown[]): Promise<
-    T[] & { count?: number; command?: string }
-  >;
-  begin<R>(fn: (tx: BunSqlInstance) => Promise<R>): Promise<R>;
-  close(): Promise<void>;
-  readonly options?: BunSqlOptions;
-}
+interface BunSqlInstance {
+  <T = unknown>(strings: TemplateStringsArray, ...values: unknown[]): Promise<
+    T[] & { count?: number; command?: string }
+  >;
+  begin<R>(fn: (tx: BunSqlInstance) => Promise<R>): Promise<R>;
+  close(options?: DbCloseOptions): Promise<void>;
+  readonly options?: BunSqlOptions;
+}
 
 /**
  * Constructor surface — `Bun.SQL` is a class; we only need the `new`
@@ -250,13 +259,35 @@ function getBunSqlCtor(): BunSqlCtor {
 
 // ─── Error helpers ──────────────────────────────────────────────────────────
 
-const POOL_CLOSED_MESSAGE =
-  "[@mandujs/core/db] pool closed — query issued after Db.close().";
-
-/**
- * Structural check for "connection/pool closed" errors that Bun.SQL raises
- * after `.close()`. Bun surfaces these as `SQLiteError` / `PostgresError` /
- * `MySQLError` with a `code` ending in `CLOSED`.
+const POOL_CLOSED_MESSAGE =
+  "[@mandujs/core/db] pool closed — query issued after Db.close().";
+
+const PIN_DB_HANDLE = Symbol.for("@mandujs/core/db/pin-handle");
+
+interface DbHandlePin {
+  [PIN_DB_HANDLE]?: <R>(fn: () => Promise<R>) => Promise<R>;
+}
+
+/**
+ * Internal helper for code paths that must keep a MySQL session alive across
+ * transaction boundaries, such as named advisory locks. Public Db callers do
+ * not need this; normal MySQL transactions recycle the handle afterwards.
+ *
+ * @internal
+ */
+export async function withPinnedDbHandle<R>(
+  db: Db,
+  fn: () => Promise<R>,
+): Promise<R> {
+  const pin = (db as DbHandlePin)[PIN_DB_HANDLE];
+  if (!pin) return await fn();
+  return await pin(fn);
+}
+
+/**
+ * Structural check for "connection/pool closed" errors that Bun.SQL raises
+ * after `.close()`. Bun surfaces these as `SQLiteError` / `PostgresError` /
+ * `MySQLError` with a `code` ending in `CLOSED`.
  */
 function isPoolClosedError(err: unknown): boolean {
   if (!err || typeof err !== "object") return false;
@@ -427,12 +458,14 @@ function buildDbHandle(bunSql: BunSqlInstance, provider: SqlProvider): Db {
       });
     };
 
-  (db as { close: Db["close"] }).close = async function close(): Promise<void> {
-    if (closed) return; // idempotent
-    closed = true;
-    try {
-      await bunSql.close();
-    } catch (err) {
+  (db as { close: Db["close"] }).close = async function close(
+    options?: DbCloseOptions,
+  ): Promise<void> {
+    if (closed) return; // idempotent
+    closed = true;
+    try {
+      await bunSql.close(options);
+    } catch (err) {
       // Bun.SQL can throw if already-closed under the hood (mostly from a
       // racing concurrent close). We already flipped our flag so subsequent
       // queries reject cleanly — swallow this one.
@@ -451,7 +484,7 @@ function buildDbHandle(bunSql: BunSqlInstance, provider: SqlProvider): Db {
  *
  * @throws {TypeError} when `config.url` is missing or empty.
  */
-export function createDb(config: DbConfig): Db {
+export function createDb(config: DbConfig): Db {
   // Up-front config validation. We check `url` here (not only in
   // `_createDbWith`) so the error fires at construction time — matches
   // the TypeError contract the public API documents.
@@ -469,18 +502,43 @@ export function createDb(config: DbConfig): Db {
   // fires on the first real call, with a version-specific message.
   //
   // We still need to *return* a Db now, so call through a forwarding
-  // function that probes on demand.
-  let real: Db | null = null;
-  function materialize(): Db {
-    if (real) return real;
-    real = _createDbWith(getBunSqlCtor(), config);
-    return real;
-  }
-
-  const forward = async function forwardCall<T extends Row = Row>(
-    strings: TemplateStringsArray,
-    ...values: unknown[]
-  ): Promise<T[]> {
+  // function that probes on demand.
+  let real: Db | null = null;
+  let closed = false;
+  let pinDepth = 0;
+  let pendingMysqlRecycle = false;
+  function materialize(): Db {
+    if (closed) {
+      throw new Error(POOL_CLOSED_MESSAGE);
+    }
+    if (real) return real;
+    real = _createDbWith(getBunSqlCtor(), config);
+    return real;
+  }
+
+  async function flushPendingMysqlRecycle(): Promise<void> {
+    if (provider !== "mysql" || pinDepth > 0 || !pendingMysqlRecycle) return;
+    pendingMysqlRecycle = false;
+    if (closed || !real) return;
+    const db = real;
+    real = null;
+    await db.close({ timeout: 0 });
+  }
+
+  async function recycleMysqlHandle(db: Db): Promise<void> {
+    if (provider !== "mysql" || real !== db || closed) return;
+    if (pinDepth > 0) {
+      pendingMysqlRecycle = true;
+      return;
+    }
+    real = null;
+    await db.close({ timeout: 0 });
+  }
+
+  const forward = async function forwardCall<T extends Row = Row>(
+    strings: TemplateStringsArray,
+    ...values: unknown[]
+  ): Promise<T[]> {
     return await materialize()<T>(strings, ...values);
   } as unknown as Db;
 
@@ -497,17 +555,46 @@ export function createDb(config: DbConfig): Db {
     ...values: unknown[]
   ): Promise<T | null> {
     return await materialize().one<T>(strings, ...values);
-  };
-  (forward as { transaction: Db["transaction"] }).transaction =
-    async function transaction<R>(fn: (tx: Db) => Promise<R>): Promise<R> {
-      return await materialize().transaction(fn);
-    };
-  (forward as { close: Db["close"] }).close = async function close(): Promise<void> {
-    // If no query ever ran, materialize() was never called — nothing to
-    // close. Only materialize + close if a real handle exists.
-    if (!real) return;
-    await real.close();
-  };
-
-  return forward;
-}
+  };
+  (forward as { transaction: Db["transaction"] }).transaction =
+    async function transaction<R>(fn: (tx: Db) => Promise<R>): Promise<R> {
+      const hadMaterializedHandle = real !== null;
+      let db = materialize();
+      if (provider === "mysql" && hadMaterializedHandle) {
+        await recycleMysqlHandle(db);
+        db = materialize();
+      }
+      try {
+        return await db.transaction(fn);
+      } finally {
+        await recycleMysqlHandle(db);
+      }
+    };
+  (forward as { close: Db["close"] }).close = async function close(
+    options?: DbCloseOptions,
+  ): Promise<void> {
+    if (closed) return;
+    closed = true;
+    // If no query ever ran, materialize() was never called — nothing to close.
+    if (!real) return;
+    const db = real;
+    real = null;
+    await db.close(options);
+  };
+  Object.defineProperty(forward, PIN_DB_HANDLE, {
+    value: async function withPinnedHandle<R>(fn: () => Promise<R>): Promise<R> {
+      pinDepth += 1;
+      try {
+        return await fn();
+      } finally {
+        pinDepth -= 1;
+        await flushPendingMysqlRecycle();
+      }
+    },
+    enumerable: false,
+    writable: false,
+    configurable: false,
+  });
+
+  return forward;
+}

package/src/db/migrations/lock.ts

@@ -126,6 +126,7 @@ async function acquireMysqlLock(
   db: Db,
   lockId: string,
 ): Promise<MigrationLock> {
+  const processLock = await acquireMysqlProcessMutex(lockId);
   // `GET_LOCK` returns:
   //   1 — lock granted
   //   0 — timeout (still blocked after the timeout)
@@ -133,18 +134,23 @@ async function acquireMysqlLock(
   //
   // Bun.SQL returns the single row as `[{ acquired: 1 }]`; we destructure
   // defensively to handle any driver-side aliasing.
-  const timeoutSec = MYSQL_LOCK_TIMEOUT_SECONDS;
-  const rows = await db<{ acquired: number | bigint | null }>`
-    SELECT GET_LOCK(${lockId}, ${timeoutSec}) AS acquired
-  `;
-  const first = rows[0];
-  const value = first ? Number(first.acquired) : NaN;
-  if (value !== 1) {
-    throw new Error(
-      `[@mandujs/core/db/migrations] GET_LOCK(${JSON.stringify(lockId)}, ${timeoutSec}) ` +
-        `returned ${value === 0 ? "0 (timeout)" : "NULL (error)"}; ` +
-        `another migration runner may be holding the lock.`,
-    );
+  try {
+    const timeoutSec = MYSQL_LOCK_TIMEOUT_SECONDS;
+    const rows = await db<{ acquired: number | bigint | null }>`
+      SELECT GET_LOCK(${lockId}, ${timeoutSec}) AS acquired
+    `;
+    const first = rows[0];
+    const value = first ? Number(first.acquired) : NaN;
+    if (value !== 1) {
+      throw new Error(
+        `[@mandujs/core/db/migrations] GET_LOCK(${JSON.stringify(lockId)}, ${timeoutSec}) ` +
+          `returned ${value === 0 ? "0 (timeout)" : "NULL (error)"}; ` +
+          `another migration runner may be holding the lock.`,
+      );
+    }
+  } catch (err) {
+    await processLock.release();
+    throw err;
   }
 
   let _released = false;
@@ -159,6 +165,55 @@ async function acquireMysqlLock(
         console.warn(
           `[@mandujs/core/db/migrations] RELEASE_LOCK failed: ${msg}`,
         );
+      } finally {
+        await processLock.release();
+      }
+    },
+  };
+}
+
+/**
+ * Same-process MySQL runners are serialised before hitting GET_LOCK.
+ * Cross-process safety still comes from MySQL's named lock; this mutex only
+ * avoids concurrent GET_LOCK calls from separate Bun.SQL pools in one runtime.
+ */
+const MYSQL_LOCK_REGISTRY_SYMBOL = Symbol.for(
+  "@mandujs/core/db/migrations/mysql-locks",
+);
+interface MysqlLockRegistry {
+  chains: Map<string, Promise<void>>;
+}
+function getMysqlLockRegistry(): MysqlLockRegistry {
+  const g = globalThis as unknown as Record<symbol, unknown>;
+  let reg = g[MYSQL_LOCK_REGISTRY_SYMBOL] as MysqlLockRegistry | undefined;
+  if (!reg) {
+    reg = { chains: new Map() };
+    g[MYSQL_LOCK_REGISTRY_SYMBOL] = reg;
+  }
+  return reg;
+}
+
+async function acquireMysqlProcessMutex(lockId: string): Promise<MigrationLock> {
+  const registry = getMysqlLockRegistry();
+  const previous = registry.chains.get(lockId) ?? Promise.resolve();
+
+  let release!: () => void;
+  const nextPromise = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  const tail = previous.then(() => nextPromise);
+  registry.chains.set(lockId, tail);
+
+  await previous;
+
+  let _released = false;
+  return {
+    async release(): Promise<void> {
+      if (_released) return;
+      _released = true;
+      release();
+      if (registry.chains.get(lockId) === tail) {
+        registry.chains.delete(lockId);
       }
     },
   };