cabloy 5.1.219 → 5.1.221

package/vona/packages-vona/vona-core/src/lib/core/logger/diagnosticLogger.test.ts

@@ -0,0 +1,346 @@
+import assert from 'node:assert/strict';
+import { afterEach, beforeEach, test } from 'node:test';
+import * as Winston from 'winston';
+import Transport from 'winston-transport';
+
+import { createRequestBoundary, runWithRequestBoundary } from '../requestBoundary.ts';
+import { requiresFreshTestResources, TEST_REQUIRE_FRESH_RESOURCES_ENV } from '../testStrictMode.ts';
+import { AppLogger } from './appLogger.ts';
+import { getSuppressedDiagnosticLogger } from './diagnosticLogger.ts';
+
+let previousStrictFlag: string | undefined;
+beforeEach(() => {
+  previousStrictFlag = process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV];
+  delete process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV];
+});
+afterEach(() => {
+  if (previousStrictFlag === undefined) delete process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV];
+  else process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV] = previousStrictFlag;
+});
+
+class MemoryTransport extends Transport {
+  count = 0;
+
+  override log(_info: unknown, callback: () => void) {
+    this.count++;
+    callback();
+  }
+}
+
+// No boundary formatter: only the facade can prevent Winston from reading input.
+function fixture() {
+  const sink = new MemoryTransport();
+  const raw = Winston.createLogger({ transports: [sink] });
+  const factory = new AppLogger();
+  let creations = 0;
+  Object.defineProperty(factory, '_createClient', {
+    value() {
+      creations++;
+      return raw;
+    },
+  });
+  const logger = factory.get();
+  return {
+    raw,
+    logger,
+    sink,
+    factory,
+    creations: () => creations,
+    async close() {
+      try {
+        await factory.dispose();
+      } finally {
+        raw.close();
+        sink.close?.();
+      }
+    },
+  };
+}
+
+function payloadProbe() {
+  let reads = 0;
+  return {
+    payload: {
+      get message() {
+        reads++;
+        return 'local';
+      },
+    },
+    reads: () => reads,
+  };
+}
+
+function throwingProbe() {
+  let reads = 0;
+  const read = () => {
+    reads++;
+    throw new Error('Synthetic logger input must not be evaluated');
+  };
+  return {
+    value: new Proxy({}, { get: read, ownKeys: read }),
+    read,
+    reads: () => reads,
+  };
+}
+
+test(
+  'cached diagnostic handlers never expose raw Winston to a request boundary',
+  { concurrency: false },
+  async () => {
+    const local = fixture();
+    const { raw, logger, sink } = local;
+    const exceptions = logger.exceptions;
+    const rejections = logger.rejections;
+    const probe = payloadProbe();
+    try {
+      assert.equal(local.factory.get(), logger);
+      assert.equal(local.creations(), 1);
+      assert.equal(logger.exceptions, exceptions);
+      assert.equal(logger.rejections, rejections);
+      for (const handler of [exceptions, rejections]) {
+        assert.equal(handler.logger, logger);
+        assert.equal(Reflect.set(handler, 'logger', raw), false);
+      }
+      assert.equal(raw.exceptions.logger, raw);
+      assert.equal(raw.rejections.logger, raw);
+      runWithRequestBoundary(createRequestBoundary(), () => {
+        assert.equal(local.factory.get(), getSuppressedDiagnosticLogger());
+        assert.equal(local.factory.get('unconfigured' as any), getSuppressedDiagnosticLogger());
+        assert.equal(local.factory.child('synthetic' as any), getSuppressedDiagnosticLogger());
+        logger.error(probe.payload);
+        logger.exceptions.logger.error(probe.payload);
+        logger.rejections.logger.error(probe.payload);
+        exceptions.logger.error(probe.payload);
+        rejections.logger.error(probe.payload);
+      });
+      assert.equal(probe.reads(), 0);
+      assert.equal(sink.count, 0);
+      for (const handler of [exceptions, rejections]) {
+        const before = probe.reads();
+        handler.logger.error(probe.payload);
+        assert.ok(probe.reads() > before);
+      }
+      assert.equal(sink.count, 2);
+      const before = probe.reads();
+      raw.error(probe.payload);
+      assert.ok(probe.reads() > before);
+      assert.equal(sink.count, 3);
+    } finally {
+      await local.close();
+    }
+  },
+);
+
+test(
+  'diagnostic handler methods keep their raw receiver and map fluent returns',
+  { concurrency: false },
+  async () => {
+    const local = fixture();
+    try {
+      for (const key of ['exceptions', 'rejections'] as const) {
+        const rawHandler = local.raw[key];
+        const handler = local.logger[key];
+        const marker = {};
+        const original = rawHandler.getAllInfo;
+        Object.defineProperty(rawHandler, 'getAllInfo', {
+          configurable: true,
+          value(this: typeof rawHandler, value: unknown) {
+            assert.equal(this, rawHandler);
+            assert.equal(value, marker);
+            return this;
+          },
+        });
+        try {
+          assert.equal(handler.handlers, rawHandler.handlers);
+          assert.equal(handler.getAllInfo(marker as any), handler);
+          assert.equal(handler.logger, local.logger);
+        } finally {
+          Object.defineProperty(rawHandler, 'getAllInfo', {
+            configurable: true,
+            value: original,
+          });
+        }
+      }
+      const exceptions = local.logger.exceptions;
+      const rejections = local.logger.rejections;
+      local.logger.configure({ transports: [local.sink] });
+      assert.notEqual(local.logger.exceptions, exceptions);
+      assert.notEqual(local.logger.rejections, rejections);
+      assert.equal(local.logger.exceptions.logger, local.logger);
+      assert.equal(local.logger.rejections.logger, local.logger);
+      assert.equal(exceptions.logger, local.logger);
+      assert.equal(rejections.logger, local.logger);
+      runWithRequestBoundary(createRequestBoundary(), () => {
+        exceptions.logger.error('local');
+        rejections.logger.error('local');
+      });
+      assert.equal(local.sink.count, 0);
+    } finally {
+      await local.close();
+    }
+  },
+);
+
+test('strict logger bypasses cached clients and payloads', { concurrency: false }, async () => {
+  const local = fixture();
+  const probe = throwingProbe();
+  try {
+    process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV] = 'true';
+    const suppressed = getSuppressedDiagnosticLogger();
+    assert.equal(local.factory.get(), suppressed);
+    assert.equal(local.factory.get('unconfigured' as any), suppressed);
+    assert.equal(local.factory.child('synthetic' as any), suppressed);
+    assert.equal(local.factory.child('synthetic' as any, 'unconfigured' as any), suppressed);
+    assert.notEqual(suppressed, local.logger);
+    assert.equal(suppressed.error(probe.value), suppressed);
+    assert.equal(suppressed.info(probe.value), suppressed);
+    assert.equal(suppressed.log(probe.value as any), suppressed);
+    assert.equal(suppressed.child(probe.value), suppressed);
+    assert.equal(suppressed.startTimer().done(probe.value), suppressed);
+    let completions = 0;
+    assert.equal(
+      suppressed.write(probe.value, () => completions++),
+      true,
+    );
+    assert.equal(completions, 1);
+    assert.equal(probe.reads(), 0);
+    assert.equal(local.creations(), 1);
+    assert.equal(local.sink.count, 0);
+    delete process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV];
+    assert.equal(local.factory.get(), local.logger);
+    local.factory.child().info('ordinary logging remains available');
+    assert.equal(local.sink.count, 1);
+  } finally {
+    await local.close();
+  }
+});
+
+test('strict entry guards precede cache and app access', { concurrency: false }, async () => {
+  const local = fixture();
+  const probe = throwingProbe();
+  const descriptors = Object.getOwnPropertyDescriptors(local.factory);
+  const cacheKeys = Object.getOwnPropertySymbols(local.factory);
+  try {
+    assert.equal(cacheKeys.length, 2);
+    for (const key of cacheKeys) {
+      Object.defineProperty(local.factory, key, { configurable: true, get: probe.read });
+    }
+    Object.defineProperty(local.factory, 'app', { configurable: true, get: probe.read });
+    process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV] = 'true';
+    assert.equal(local.factory.get(), getSuppressedDiagnosticLogger());
+    assert.equal(local.factory.get(probe.value as any), getSuppressedDiagnosticLogger());
+    Object.defineProperty(local.factory, 'get', { configurable: true, get: probe.read });
+    assert.equal(local.factory.child(), getSuppressedDiagnosticLogger());
+    assert.equal(
+      local.factory.child(probe.value as any, probe.value as any),
+      getSuppressedDiagnosticLogger(),
+    );
+    assert.equal(local.creations(), 1);
+    assert.equal(probe.reads(), 0);
+    assert.equal(local.sink.count, 0);
+  } finally {
+    delete (local.factory as any).get;
+    delete (local.factory as any).app;
+    Object.defineProperties(local.factory, descriptors);
+    await local.close();
+  }
+});
+
+test('strict logger skips real configuration factories', { concurrency: false }, async () => {
+  const factory = new AppLogger();
+  const probe = throwingProbe();
+  let configurations = 0;
+  Object.defineProperty(factory, 'app', {
+    value: {
+      config: {
+        logger: {
+          base() {
+            configurations++;
+            return probe.read();
+          },
+          clients: {
+            default() {
+              configurations++;
+              return probe.read();
+            },
+          },
+          get baseDir() {
+            return probe.read();
+          },
+          get rotate() {
+            return probe.read();
+          },
+        },
+      },
+    },
+  });
+  try {
+    process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV] = 'true';
+    assert.equal(factory.get(), getSuppressedDiagnosticLogger());
+    assert.equal(factory.child('synthetic' as any), getSuppressedDiagnosticLogger());
+    assert.equal(configurations, 0);
+    assert.equal(probe.reads(), 0);
+  } finally {
+    await factory.dispose();
+  }
+});
+
+test('strict file transport fails before any input access', { concurrency: false }, () => {
+  const factory = new AppLogger();
+  const probe = throwingProbe();
+  const args = [probe.value, probe.value, probe.value] as unknown as Parameters<
+    AppLogger['createTransportFile']
+  >;
+  Object.defineProperty(factory, 'app', { get: probe.read });
+  process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV] = 'true';
+  assert.throws(() => factory.createTransportFile(...args), {
+    message: 'Strict test file logger transport is disabled',
+  });
+  runWithRequestBoundary(createRequestBoundary(), () => {
+    assert.throws(() => factory.createTransportFile(...args), {
+      message: 'Strict test file logger transport is disabled',
+    });
+  });
+  assert.equal(probe.reads(), 0);
+});
+
+test('invalid strict flags never fall back to loggers', { concurrency: false }, async () => {
+  const local = fixture();
+  const probe = throwingProbe();
+  Object.defineProperty(local.factory, 'app', { get: probe.read });
+  const args = [probe.value, probe.value, probe.value] as unknown as Parameters<
+    AppLogger['createTransportFile']
+  >;
+  try {
+    const env: NodeJS.ProcessEnv = { NODE_ENV: 'test', META_FLAVOR: 'normal', META_MODE: 'test' };
+    assert.equal(requiresFreshTestResources(), false);
+    assert.equal(requiresFreshTestResources(env), false);
+    assert.equal(
+      requiresFreshTestResources({ ...env, [TEST_REQUIRE_FRESH_RESOURCES_ENV]: 'true' }),
+      true,
+    );
+    for (const flag of ['', 'false', 'TRUE', 'synthetic-invalid-flag']) {
+      process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV] = flag;
+      const expected = { message: 'Invalid strict test resource freshness flag' };
+      assert.throws(() => requiresFreshTestResources(), expected);
+      assert.throws(
+        () => requiresFreshTestResources({ ...env, [TEST_REQUIRE_FRESH_RESOURCES_ENV]: flag }),
+        expected,
+      );
+      const calls = [
+        () => local.factory.get(),
+        () => local.factory.child('synthetic' as any),
+        () => local.factory.createTransportFile(...args),
+      ];
+      for (const call of calls) {
+        assert.throws(call, expected);
+        runWithRequestBoundary(createRequestBoundary(), () => assert.throws(call, expected));
+      }
+    }
+    assert.equal(probe.reads(), 0);
+    assert.equal(local.creations(), 1);
+    assert.equal(local.sink.count, 0);
+  } finally {
+    await local.close();
+  }
+});

package/vona/packages-vona/vona-core/src/lib/core/logger/diagnosticLogger.ts

@@ -0,0 +1,138 @@
+import type * as Winston from 'winston';
+
+import { captureRequestBoundary, getRequestBoundary } from '../requestBoundary.ts';
+
+const loggingMethods = new Set([
+  'log',
+  'error',
+  'warn',
+  'info',
+  'http',
+  'verbose',
+  'debug',
+  'silly',
+]);
+
+function completeWrite(args: unknown[]) {
+  const callback = typeof args[1] === 'function' ? args[1] : args[2];
+  if (typeof callback === 'function') {
+    try {
+      callback();
+    } catch {
+      captureRequestBoundary()?.reportFailure('diagnostic_failed');
+    }
+  }
+  return true;
+}
+
+const suppressedLogger = createFacade();
+
+export function getSuppressedDiagnosticLogger(): Winston.Logger {
+  return suppressedLogger;
+}
+
+export function createDiagnosticLogger(raw: Winston.Logger): Winston.Logger {
+  if (getRequestBoundary()) return getSuppressedDiagnosticLogger();
+  return createFacade(raw);
+}
+
+function createFacade(raw?: Winston.Logger): Winston.Logger {
+  const methods = new Map<PropertyKey, (...args: any[]) => any>();
+  const handlers = new WeakMap<object, Winston.ExceptionHandler | Winston.RejectionHandler>();
+  const inertProfiler = Object.freeze({
+    get logger() {
+      return getSuppressedDiagnosticLogger();
+    },
+    done: () => getSuppressedDiagnosticLogger(),
+  });
+  const facade = new Proxy({} as Winston.Logger, {
+    get(_target, key) {
+      if (
+        loggingMethods.has(key as string) ||
+        ['write', 'child', 'startTimer', 'profile'].includes(key as string)
+      ) {
+        if (!methods.has(key)) {
+          methods.set(key, (...args: any[]) => {
+            if (!raw || getRequestBoundary()) {
+              if (key === 'write') return completeWrite(args);
+              if (key === 'child') return getSuppressedDiagnosticLogger();
+              if (key === 'startTimer') return inertProfiler;
+              return facade;
+            }
+            const result = Reflect.apply(Reflect.get(raw, key, raw), raw, args);
+            if (key === 'child') return createFacade(result as Winston.Logger);
+            if (key === 'startTimer') return wrapProfiler(result as Winston.Profiler, facade);
+            return result === raw ? facade : result;
+          });
+        }
+        return methods.get(key);
+      }
+      if (!raw) return undefined;
+      const value = Reflect.get(raw, key, raw);
+      if ((key === 'exceptions' || key === 'rejections') && value) {
+        if (!handlers.has(value)) handlers.set(value, wrapHandler(value, raw, facade));
+        return handlers.get(value);
+      }
+      if (typeof value !== 'function') return value;
+      if (!methods.has(key)) {
+        methods.set(key, (...args: any[]) => {
+          const result = Reflect.apply(value, raw, args);
+          return result === raw ? facade : result;
+        });
+      }
+      return methods.get(key);
+    },
+    set(_target, key, value) {
+      return raw ? Reflect.set(raw, key, value, raw) : true;
+    },
+  });
+  return facade;
+}
+
+function wrapHandler<T extends Winston.ExceptionHandler | Winston.RejectionHandler>(
+  raw: T,
+  rawLogger: Winston.Logger,
+  logger: Winston.Logger,
+): T {
+  const methods = new Map<PropertyKey, (...args: any[]) => any>();
+  const handler = new Proxy({} as T, {
+    get(_target, key) {
+      if (key === 'logger') return logger;
+      const value = Reflect.get(raw, key, raw);
+      if (typeof value !== 'function') return value;
+      if (!methods.has(key)) {
+        methods.set(key, (...args: any[]) => {
+          const result = Reflect.apply(value, raw, args);
+          if (result === raw) return handler;
+          return result === rawLogger ? logger : result;
+        });
+      }
+      return methods.get(key);
+    },
+    set(_target, key, value) {
+      if (key === 'logger') return false;
+      return Reflect.set(raw, key, value, raw);
+    },
+  });
+  return handler;
+}
+
+function wrapProfiler(raw: Winston.Profiler, logger: Winston.Logger): Winston.Profiler {
+  return new Proxy({} as Winston.Profiler, {
+    get(_target, key) {
+      if (key === 'logger') return logger;
+      if (key === 'done') {
+        return (...args: any[]) => {
+          if (getRequestBoundary()) return logger;
+          const result = Reflect.apply(raw.done, raw, args);
+          return result === raw.logger ? logger : result;
+        };
+      }
+      return Reflect.get(raw, key, raw);
+    },
+    set(_target, key, value) {
+      if (key === 'logger') return false;
+      return Reflect.set(raw, key, value, raw);
+    },
+  });
+}

package/vona/packages-vona/vona-core/src/lib/core/logger/index.ts

@@ -1,2 +1,3 @@
 export * from './appLogger.ts';
+export { createDiagnosticLogger, getSuppressedDiagnosticLogger } from './diagnosticLogger.ts';
 export * from './utils.ts';

package/vona/packages-vona/vona-core/src/lib/core/logger/utils.ts

@@ -11,10 +11,18 @@ import type {
 
 import { cast } from '../../../types/utils/cast.ts';
 import { useApp } from '../../framework/useApp.ts';
+import { getRequestBoundary } from '../requestBoundary.ts';
 
 const SymbolLoggerMessage = Symbol('SymbolLoggerMessage');
 
-export const formatLoggerAxiosError = Winston.format((einfo, { stack, cause }: any) => {
+export const formatLoggerBoundary = Winston.format(info => {
+  if (getRequestBoundary()) return false;
+  return info;
+});
+
+export const formatLoggerAxiosError = Winston.format((einfo, opts: any) => {
+  if (getRequestBoundary()) return false;
+  const { stack, cause } = opts;
   if (
     (einfo instanceof Error && einfo.constructor.name.includes('AxiosError')) ||
     einfo.name === 'AxiosError' ||
@@ -39,10 +47,16 @@ export const formatLoggerAxiosError = Winston.format((einfo, { stack, cause }: a
 });
 
 export const formatLoggerErrors = (opts: ILoggerFormatOpts) => {
-  return Winston.format.combine(formatLoggerAxiosError(opts), Winston.format.errors(opts));
+  if (getRequestBoundary()) return formatLoggerBoundary();
+  return Winston.format.combine(
+    formatLoggerBoundary(),
+    formatLoggerAxiosError(opts),
+    Winston.format.errors(opts),
+  );
 };
 
 export const formatLoggerCtx = Winston.format((info, _opts: any) => {
+  if (getRequestBoundary()) return false;
   const app = useApp();
   if (!app.ctx) return info;
   if (app.ctx.method) info.method = app.ctx.method;
@@ -60,12 +74,14 @@ export const formatLoggerCtx = Winston.format((info, _opts: any) => {
 });
 
 export const formatLoggerDummy = Winston.format(info => {
+  if (getRequestBoundary()) return false;
   const app = useApp();
   if (app.meta.env.LOGGER_DUMMY === 'true') return false;
   return info;
 });
 
 export const formatLoggerFilter = Winston.format(((info: any, opts: ILoggerFormatFilterOpts) => {
+  if (getRequestBoundary()) return false;
   // check client
   const child = typeof opts.child === 'function' ? opts.child() : opts.child;
   if (child && !child.includes(info.name)) {
@@ -90,8 +106,11 @@ export const formatLoggerFilter = Winston.format(((info: any, opts: ILoggerForma
 }) as any);
 
 export const formatLoggerConsole = (clientInfo: ILoggerOptionsClientInfo) => {
-  return Winston.format.printf(
-    ({ timestamp, level, stack, message, name, beanFullName, durationMs, ...meta }) => {
+  return Winston.format.combine(
+    formatLoggerBoundary(),
+    Winston.format.printf(info => {
+      if (getRequestBoundary()) return '';
+      const { timestamp, level, stack, message, name, beanFullName, durationMs, ...meta } = info;
       const textClientName =
         clientInfo.clientName === 'default' ? '' : ` ${chalk.cyan(`[${clientInfo.clientName}]`)}`;
       const textName = name ? ` ${chalk.cyan(`[${name}]`)}` : '';
@@ -101,11 +120,12 @@ export const formatLoggerConsole = (clientInfo: ILoggerOptionsClientInfo) => {
       const textDurationMs = durationMs !== undefined ? ` ${chalk.cyan(`+${durationMs}ms`)}` : '';
       const textStack = stack ? `\n${stack}` : '';
       return `${timestamp} ${level}${textClientName}${textName}${textBeanFullName}${textMeta}${textMessage}${textDurationMs}${textStack}`;
-    },
+    }),
   );
 };
 
 function __formatLoggerFilterCheckInfo(info) {
+  if (getRequestBoundary()) return false;
   if (typeof info.message === 'function') {
     if (info.message[SymbolLoggerMessage] === undefined) {
       info.message[SymbolLoggerMessage] = info.message();

package/vona/packages-vona/vona-core/src/lib/core/requestBoundary.ts

@@ -0,0 +1,89 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+export type RequestBoundaryFailure =
+  | 'observer_failed'
+  | 'diagnostic_failed'
+  | 'late_callback_failed';
+export type VonaScopeOutcome = 'not_created' | 'disposed' | 'dispose_failed';
+export type VonaScopeOutcomeObserver = (outcome: VonaScopeOutcome) => void;
+
+declare const requestBoundaryBrand: unique symbol;
+
+export interface RequestBoundary {
+  readonly [requestBoundaryBrand]: true;
+}
+
+export interface RequestBoundaryCapture {
+  readonly diagnostics: 'suppress';
+  reportFailure(failure: RequestBoundaryFailure): void;
+  snapshot(): Readonly<{ portFault: boolean }>;
+}
+
+const boundaries = new WeakMap<RequestBoundary, RequestBoundaryCapture>();
+const boundaryStorage = new AsyncLocalStorage<RequestBoundary>();
+
+export function createRequestBoundary(options?: {
+  readonly onFailure?: (failure: RequestBoundaryFailure) => void;
+}): RequestBoundary {
+  const onFailure = options?.onFailure;
+  const boundary = Object.freeze({}) as RequestBoundary;
+  let portFault = false;
+  let reporting = false;
+  const reported = new Set<RequestBoundaryFailure>();
+  const capture: RequestBoundaryCapture = Object.freeze({
+    diagnostics: 'suppress',
+    reportFailure(failure: RequestBoundaryFailure) {
+      if (
+        failure !== 'observer_failed' &&
+        failure !== 'diagnostic_failed' &&
+        failure !== 'late_callback_failed'
+      ) {
+        portFault = true;
+        return;
+      }
+      portFault = true;
+      if (reported.has(failure)) return;
+      reported.add(failure);
+      if (reporting || !onFailure) return;
+      reporting = true;
+      try {
+        const result: unknown = onFailure(failure);
+        if (result && (typeof result === 'object' || typeof result === 'function')) {
+          const then = (result as PromiseLike<unknown>).then;
+          if (typeof then === 'function') {
+            portFault = true;
+            void new Promise<unknown>((resolve, reject) => {
+              then.call(result, resolve, reject);
+            }).catch(() => {});
+          }
+        }
+      } catch {
+        portFault = true;
+      } finally {
+        reporting = false;
+      }
+    },
+    snapshot() {
+      return Object.freeze({ portFault });
+    },
+  });
+  boundaries.set(boundary, capture);
+  return boundary;
+}
+
+export function runWithRequestBoundary<T>(boundary: RequestBoundary, continuation: () => T): T {
+  if (!boundaries.has(boundary)) throw new Error('Invalid request boundary');
+  const current = boundaryStorage.getStore();
+  if (current && current !== boundary) throw new Error('Request boundary cannot be replaced');
+  if (current === boundary) return continuation();
+  return boundaryStorage.run(boundary, continuation);
+}
+
+export function getRequestBoundary(): RequestBoundary | undefined {
+  return boundaryStorage.getStore();
+}
+
+export function captureRequestBoundary(): RequestBoundaryCapture | undefined {
+  const boundary = boundaryStorage.getStore();
+  return boundary ? boundaries.get(boundary) : undefined;
+}