Cache scoped filter lookup

Cache the resolved scoped filter list per category so repeated log records
avoid walking category prefixes on every emit. Keep the existing JSON-based
category key so single segment categories containing separators do not collide
with multi-segment categories.

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

Assisted-by: Codex:gpt-5.5

Author: dahlia

packages/logtape/src/config.test.ts

@@ -10,6 +10,7 @@ import {
   compileScopedConfig,
   disposeScopedConfig,
   disposeScopedConfigSync,
+  emitWithScopedConfig,
   scopedConfigHasSink,
 } from "./scoped-config.ts";
 import type { Sink } from "./sink.ts";
@@ -1257,6 +1258,52 @@ test("scoped configuration caches sink dispatch plans", () => {
   assert.strictEqual(scopedConfig.dispatchCache.size, 1);
 });
 
+test("scoped configuration caches filter lookup", () => {
+  const logs: LogRecord[] = [];
+  const filter: Filter = (record) => record.category[0] === "app";
+  const scopedConfig = compileScopedConfig(
+    {
+      sinks: { sink: logs.push.bind(logs) },
+      filters: { filter },
+      loggers: [
+        { category: "app", filters: ["filter"], sinks: ["sink"] },
+        { category: ["app:child"], sinks: ["sink"] },
+      ],
+    },
+    true,
+    (message) => new ConfigError(message),
+  );
+  const emit = (category: readonly string[]): void => {
+    const record: LogRecord = {
+      category,
+      level: "info",
+      message: ["cached"],
+      properties: {},
+      rawMessage: "cached",
+      timestamp: Date.now(),
+    };
+    emitWithScopedConfig(
+      scopedConfig,
+      record,
+      undefined,
+      (sink) => sink(record),
+    );
+  };
+
+  assert.strictEqual(scopedConfig.filterCache.size, 0);
+  emit(["app", "child"]);
+  assert.strictEqual(scopedConfig.filterCache.size, 1);
+  emit(["app", "child"]);
+  assert.strictEqual(scopedConfig.filterCache.size, 1);
+  emit(["app:child"]);
+
+  assert.strictEqual(scopedConfig.filterCache.size, 2);
+  assert.deepStrictEqual(
+    logs.map((record) => record.category),
+    [["app", "child"], ["app", "child"], ["app:child"]],
+  );
+});
+
 test("withConfig() preserves callback and disposal errors", async () => {
   const callbackError = new Error("callback failed");
   const disposeError = new Error("dispose failed");

packages/logtape/src/scoped-config.ts

@@ -33,6 +33,10 @@ export interface ScopedLoggerConfigLike<
 export interface CompiledScopedConfig {
   readonly nodes: ReadonlyMap<string, CompiledScopedLogger>;
   readonly dispatchCache: Map<string, ScopedSinkDispatchPlan>;
+  readonly filterCache: Map<
+    string,
+    readonly ((record: LogRecord) => boolean)[]
+  >;
   parent: CompiledScopedConfig | undefined;
   disposed: boolean;
   readonly syncFilters: Set<Disposable>;
@@ -59,6 +63,7 @@ const defaultScopedLogger: CompiledScopedLogger = {
   parentSinks: "inherit",
   sinks: [],
 };
+const noFilters: readonly ((record: LogRecord) => boolean)[] = [];
 
 export function compileScopedConfig<
   TSinkId extends string,
@@ -199,6 +204,7 @@ export function compileScopedConfig<
     asyncSinks,
     dispatchCache: new Map(),
     disposed: false,
+    filterCache: new Map(),
     nodes,
     parent: undefined,
     syncFilters,
@@ -473,14 +479,27 @@ function filterScopedRecord(
   category: readonly string[],
   record: LogRecord,
 ): boolean {
+  const key = categoryKey(category);
+  let filters = scopedConfig.filterCache.get(key);
+  if (filters == null) {
+    filters = getScopedFilters(scopedConfig, category);
+    scopedConfig.filterCache.set(key, filters);
+  }
+  return filters.every((filter) => filter(record));
+}
+
+function getScopedFilters(
+  scopedConfig: CompiledScopedConfig,
+  category: readonly string[],
+): readonly ((record: LogRecord) => boolean)[] {
   for (let length = category.length; length >= 0; length--) {
     const logger = scopedConfig.nodes.get(
       categoryKey(category.slice(0, length)),
     );
     if (logger == null || logger.filters.length < 1) continue;
-    return logger.filters.every((filter) => filter(record));
+    return logger.filters;
   }
-  return true;
+  return noFilters;
 }
 
 function disposeSyncDisposables(