Close scoped disposal races

Skip scoped configurations that are already disposing when collecting retained
resources for another scope.  This lets the still-running disposer finish the
shared resource cleanup instead of leaking it through mutual retention.

Validate scoped logger shapes before compiling them, so malformed runtime
inputs raise ConfigError rather than incidental TypeError exceptions.  Also
copy sync disposable sets before iterating so cleanup does not mutate the set
being traversed.

#188 (comment)
#188 (comment)
#188 (comment)

Assisted-by: Codex:gpt-5.5

Author: dahlia

packages/logtape/src/config.test.ts

@@ -590,6 +590,46 @@ test("withConfig() rejects invalid scoped configuration", async () => {
         }, () => {}),
       ConfigError,
     );
+    await assert.rejects(
+      () =>
+        withConfig({
+          sinks: {},
+          loggers: [null],
+        } as never, () => {}),
+      ConfigError,
+    );
+    await assert.rejects(
+      () =>
+        withConfig({
+          sinks: {},
+          loggers: [{ category: 1 }],
+        } as never, () => {}),
+      ConfigError,
+    );
+    await assert.rejects(
+      () =>
+        withConfig({
+          sinks: {},
+          loggers: [{ category: ["app", 1] }],
+        } as never, () => {}),
+      ConfigError,
+    );
+    await assert.rejects(
+      () =>
+        withConfig({
+          sinks: {},
+          loggers: [{ category: "app", sinks: "sink" }],
+        } as never, () => {}),
+      ConfigError,
+    );
+    await assert.rejects(
+      () =>
+        withConfig({
+          sinks: {},
+          loggers: [{ category: "app", filters: "filter" }],
+        } as never, () => {}),
+      ConfigError,
+    );
   } finally {
     await reset();
   }
@@ -951,6 +991,68 @@ test("withConfig() does not dispose resources still owned by sibling scopes", as
   }
 });
 
+test("withConfig() disposes resources after overlapping scopes finish", async () => {
+  const events: string[] = [];
+  const sharedSink: Sink & AsyncDisposable = () => {};
+  sharedSink[Symbol.asyncDispose] = async () => {
+    await Promise.resolve();
+    events.push("shared sink");
+  };
+  let releaseFirstDisposal!: () => void;
+  let markFirstDisposalStarted!: () => void;
+  const firstDisposalStarted = new Promise<void>((resolve) => {
+    markFirstDisposalStarted = resolve;
+  });
+  const firstDisposalRelease = new Promise<void>((resolve) => {
+    releaseFirstDisposal = resolve;
+  });
+  const firstFilter: Filter & AsyncDisposable = () => true;
+  firstFilter[Symbol.asyncDispose] = async () => {
+    markFirstDisposalStarted();
+    await firstDisposalRelease;
+    events.push("first filter");
+  };
+
+  await configure({
+    sinks: {},
+    loggers: [{ category: ["logtape", "meta"], sinks: [] }],
+    contextLocalStorage: new AsyncLocalStorage(),
+    reset: true,
+  });
+
+  try {
+    let finishFirst!: () => void;
+    const releaseFirst = new Promise<void>((resolve) => {
+      finishFirst = resolve;
+    });
+    const firstDone = withConfig({
+      sinks: { shared: sharedSink },
+      filters: { first: firstFilter },
+      loggers: [
+        { category: "app", filters: ["first"], sinks: ["shared"] },
+      ],
+    }, async () => {
+      await releaseFirst;
+    });
+    const secondDone = withConfig({
+      sinks: { shared: sharedSink },
+      loggers: [{ category: "app", sinks: ["shared"] }],
+    }, async () => {
+      finishFirst();
+      await firstDisposalStarted;
+    });
+
+    await secondDone;
+    assert.deepStrictEqual(events, ["shared sink"]);
+    releaseFirstDisposal();
+    await firstDone;
+
+    assert.deepStrictEqual(events, ["shared sink", "first filter"]);
+  } finally {
+    await reset();
+  }
+});
+
 test("withConfig() does not dispose resources still owned globally", async () => {
   const records: LogRecord[] = [];
   const events: string[] = [];

packages/logtape/src/config.ts

@@ -459,7 +459,9 @@ function getRetainedDisposables(
     getGlobalDisposables(),
   );
   for (const activeScopedConfig of activeScopedConfigs) {
-    if (activeScopedConfig === scopedConfig) continue;
+    if (activeScopedConfig === scopedConfig || activeScopedConfig.disposed) {
+      continue;
+    }
     addScopedConfigDisposables(disposables, activeScopedConfig);
   }
   return disposables;

packages/logtape/src/scoped-config.ts

@@ -81,7 +81,38 @@ export function compileScopedConfig<
   const nodes = new Map<string, CompiledScopedLogger>();
   const configuredCategories = new Set<string>();
   for (const logger of config.loggers) {
-    const category = normalizeCategory(logger.category);
+    if (!isObjectLike(logger)) {
+      throw createError("Logger configuration must be an object.");
+    }
+    const loggerConfig = logger as ScopedLoggerConfigLike<TSinkId, TFilterId>;
+    const category = normalizeCategory(loggerConfig.category, createError);
+    if (
+      loggerConfig.sinks !== undefined && !Array.isArray(loggerConfig.sinks)
+    ) {
+      throw createError("Logger sinks must be an array.");
+    }
+    if (
+      loggerConfig.filters !== undefined &&
+      !Array.isArray(loggerConfig.filters)
+    ) {
+      throw createError("Logger filters must be an array.");
+    }
+    if (
+      loggerConfig.parentSinks !== undefined &&
+      loggerConfig.parentSinks !== "inherit" &&
+      loggerConfig.parentSinks !== "override"
+    ) {
+      throw createError(
+        'Logger parentSinks must be "inherit" or "override".',
+      );
+    }
+    if (
+      loggerConfig.lowestLevel !== undefined &&
+      loggerConfig.lowestLevel !== null &&
+      !isLogLevel(loggerConfig.lowestLevel)
+    ) {
+      throw createError("Logger lowestLevel must be a log level or null.");
+    }
     const key = categoryKey(category);
     if (configuredCategories.has(key)) {
       throw createError(
@@ -92,7 +123,7 @@ export function compileScopedConfig<
     configuredCategories.add(key);
 
     const sinks: Sink[] = [];
-    const sinkIds: readonly TSinkId[] = logger.sinks ?? [];
+    const sinkIds: readonly TSinkId[] = loggerConfig.sinks ?? [];
     for (const sinkId of sinkIds) {
       const sink = config.sinks[sinkId];
       if (!sink) throw createError(`Sink not found: ${sinkId}.`);
@@ -103,7 +134,7 @@ export function compileScopedConfig<
     }
 
     const filters: ((record: LogRecord) => boolean)[] = [];
-    const filterIds: readonly TFilterId[] = logger.filters ?? [];
+    const filterIds: readonly TFilterId[] = loggerConfig.filters ?? [];
     for (const filterId of filterIds) {
       const filter = config.filters?.[filterId];
       if (filter === undefined) {
@@ -119,10 +150,10 @@ export function compileScopedConfig<
 
     nodes.set(key, {
       filters,
-      lowestLevel: logger.lowestLevel === undefined
+      lowestLevel: loggerConfig.lowestLevel === undefined
         ? "trace"
-        : logger.lowestLevel,
-      parentSinks: logger.parentSinks ?? "inherit",
+        : loggerConfig.lowestLevel,
+      parentSinks: loggerConfig.parentSinks ?? "inherit",
       sinks,
     });
   }
@@ -349,8 +380,18 @@ function addScopedDisposables(
   for (const disposable of scopedConfig.asyncSinks) disposables.add(disposable);
 }
 
-function normalizeCategory(category: string | readonly string[]): string[] {
-  return typeof category === "string" ? [category] : [...category];
+function normalizeCategory(
+  category: unknown,
+  createError: (message: string) => Error,
+): string[] {
+  if (typeof category === "string") return [category];
+  if (!Array.isArray(category)) {
+    throw createError("Logger category must be a string or array of strings.");
+  }
+  if (category.some((part) => typeof part !== "string")) {
+    throw createError("Logger category must only contain strings.");
+  }
+  return [...category];
 }
 
 function categoryKey(category: readonly string[]): string {
@@ -443,17 +484,17 @@ function disposeSyncDisposables(
   disposables: Set<Disposable>,
   retainedDisposables: ReadonlySet<Disposable | AsyncDisposable>,
 ): void {
+  const disposableList = filterRetainedDisposables(
+    disposables,
+    retainedDisposables,
+  );
   const errors: unknown[] = [];
   try {
-    for (const disposable of disposables) {
+    for (const disposable of disposableList) {
       try {
-        if (!retainedDisposables.has(disposable)) {
-          disposable[Symbol.dispose]();
-        }
+        disposable[Symbol.dispose]();
       } catch (error) {
         errors.push(error);
-      } finally {
-        disposables.delete(disposable);
       }
     }
   } finally {