@beignet/cli 0.0.49 → 0.0.51

package/src/inspect.ts

@@ -1576,36 +1576,57 @@ function parseRouteExports(
   config: ResolvedBeignetConfig,
 ): RouteExport[] {
   const exports: RouteExport[] = [];
-  const imports = parseNamedImports(source, config);
-  const exportRegex =
-    /export const\s+(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s*=\s*([^;\n]+)/g;
-  const apiRouteExportRegex =
-    /export const\s*\{([^}]+)\}\s*=\s*createApiRoute\s*\(/g;
+  const sourceFile = ts.createSourceFile(
+    handlerFile,
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TS,
+  );
+  const imports = parseRouteNamedImports(sourceFile, config, handlerFile);
 
-  for (const match of source.matchAll(apiRouteExportRegex)) {
-    for (const member of match[1].split(",")) {
-      const parts = member.split(":");
-      const method = (parts[1] ?? parts[0])?.trim();
-      if (!method || !isHttpMethod(method)) continue;
+  for (const statement of sourceFile.statements) {
+    if (
+      !ts.isVariableStatement(statement) ||
+      !statement.modifiers?.some(
+        (modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword,
+      )
+    ) {
+      continue;
+    }
 
-      exports.push({
-        method,
-        handlerFile,
-        contractRef: routePath,
-        catchAllPrefix: catchAllRoutePrefix(routePath),
-        source: "next-route",
-      });
+    for (const declaration of statement.declarationList.declarations) {
+      if (
+        !declaration.initializer ||
+        !ts.isObjectBindingPattern(declaration.name) ||
+        !isNamedRouteFactoryCall(declaration.initializer, "createApiRoute")
+      ) {
+        continue;
+      }
+
+      for (const element of declaration.name.elements) {
+        if (!ts.isIdentifier(element.name)) continue;
+        const method = element.name.text;
+        if (!isHttpMethod(method)) continue;
+        exports.push({
+          method,
+          handlerFile,
+          contractRef: routePath,
+          catchAllPrefix: catchAllRoutePrefix(routePath),
+          source: "next-route",
+        });
+      }
     }
   }
 
-  for (const match of source.matchAll(exportRegex)) {
-    const method = match[1] as HttpMethod;
-    const expression = match[2];
-    const contractMatch =
-      /server\.route\(\s*([A-Za-z_$][\w$]*)\s*\)\.handle/.exec(expression);
+  for (const { exportName, declaration } of exportedVariableDeclarations(
+    sourceFile,
+  )) {
+    if (!isHttpMethod(exportName) || !declaration.initializer) continue;
+    const method = exportName;
+    const localName = routeLocalContractIdentifier(declaration.initializer);
 
-    if (contractMatch) {
-      const localName = contractMatch[1];
+    if (localName) {
       const imported = imports.get(localName);
       exports.push({
         method,
@@ -1617,7 +1638,7 @@ function parseRouteExports(
       continue;
     }
 
-    if (/server\.api\b/.test(expression)) {
+    if (isServerApiExpression(declaration.initializer)) {
       exports.push({
         method,
         handlerFile,
@@ -1631,6 +1652,98 @@ function parseRouteExports(
   return exports;
 }
 
+function parseRouteNamedImports(
+  sourceFile: ts.SourceFile,
+  config: ResolvedBeignetConfig,
+  handlerFile: string,
+): Map<string, { importedName: string; contractFile?: string }> {
+  const imports = new Map<
+    string,
+    { importedName: string; contractFile?: string }
+  >();
+
+  for (const statement of sourceFile.statements) {
+    if (
+      !ts.isImportDeclaration(statement) ||
+      !ts.isStringLiteral(statement.moduleSpecifier) ||
+      statement.importClause?.isTypeOnly ||
+      !statement.importClause?.namedBindings ||
+      !ts.isNamedImports(statement.importClause.namedBindings)
+    ) {
+      continue;
+    }
+
+    const contractFile = contractFileFromImport(
+      statement.moduleSpecifier.text,
+      config,
+      handlerFile,
+    );
+    for (const element of statement.importClause.namedBindings.elements) {
+      if (element.isTypeOnly) continue;
+      imports.set(element.name.text, {
+        importedName: element.propertyName?.text ?? element.name.text,
+        contractFile,
+      });
+    }
+  }
+
+  return imports;
+}
+
+function isNamedRouteFactoryCall(
+  expression: ts.Expression,
+  name: string,
+): boolean {
+  const unwrapped = unwrapContractExpression(expression);
+  if (!ts.isCallExpression(unwrapped)) return false;
+  const callee = unwrapContractExpression(unwrapped.expression);
+  return ts.isIdentifier(callee) && callee.text === name;
+}
+
+function routeLocalContractIdentifier(
+  expression: ts.Expression,
+): string | undefined {
+  const handleCall = unwrapContractExpression(expression);
+  if (!ts.isCallExpression(handleCall)) return undefined;
+  const handleAccess = unwrapContractExpression(handleCall.expression);
+  if (
+    !ts.isPropertyAccessExpression(handleAccess) ||
+    handleAccess.name.text !== "handle"
+  ) {
+    return undefined;
+  }
+
+  const routeCall = unwrapContractExpression(handleAccess.expression);
+  if (!ts.isCallExpression(routeCall)) return undefined;
+  const routeAccess = unwrapContractExpression(routeCall.expression);
+  if (
+    !ts.isPropertyAccessExpression(routeAccess) ||
+    routeAccess.name.text !== "route" ||
+    !ts.isIdentifier(routeAccess.expression) ||
+    routeAccess.expression.text !== "server"
+  ) {
+    return undefined;
+  }
+
+  const contract = routeCall.arguments[0];
+  const unwrappedContract = contract
+    ? unwrapContractExpression(contract)
+    : undefined;
+  return unwrappedContract && ts.isIdentifier(unwrappedContract)
+    ? unwrappedContract.text
+    : undefined;
+}
+
+function isServerApiExpression(expression: ts.Expression): boolean {
+  const unwrapped = unwrapContractExpression(expression);
+  return (
+    ts.isPropertyAccessExpression(unwrapped) &&
+    ts.isIdentifier(unwrapped.expression) &&
+    unwrapped.expression.text === "server" &&
+    unwrapped.name.text === "api"
+  );
+}
+
 function catchAllRoutePrefix(routePath: string): string | undefined {
   const segments = routePath.split("/").filter(Boolean);
   const catchAllIndex = segments.findIndex((segment) => segment.endsWith("*"));
@@ -1762,6 +1875,29 @@ function contractFileFromImport(
   config: ResolvedBeignetConfig,
   importerFile?: string,
 ): string | undefined {
+  const resolveCandidate = (candidate: string) => {
+    const extension = path.extname(candidate).toLowerCase();
+    if (!extension) return `${candidate}.ts`;
+
+    let sourceExtension: string | undefined;
+    switch (extension) {
+      case ".js":
+        sourceExtension = ".ts";
+        break;
+      case ".jsx":
+        sourceExtension = ".tsx";
+        break;
+      case ".mjs":
+        sourceExtension = ".mts";
+        break;
+      case ".cjs":
+        sourceExtension = ".cts";
+        break;
+    }
+    return sourceExtension
+      ? `${candidate.slice(0, -extension.length)}${sourceExtension}`
+      : candidate;
+  };
   const contractsPath = directoryPath(config.paths.contracts);
   const aliasPrefix = `@/${contractsPath}/`;
   const aliasExact = `@/${contractsPath}`;
@@ -1772,18 +1908,18 @@ function contractFileFromImport(
     return `${contractsPath}/index.ts`;
   }
   if (sourcePath.startsWith(aliasPrefix)) {
-    return `${sourcePath.slice("@/".length)}.ts`;
+    return resolveCandidate(sourcePath.slice("@/".length));
   }
 
   if (sourcePath.startsWith(relativePrefix)) {
-    return `${sourcePath}.ts`;
+    return resolveCandidate(sourcePath);
   }
 
   if (importerFile && sourcePath.startsWith(".")) {
     const resolved = normalizePath(
       path.join(path.dirname(importerFile), sourcePath),
     );
-    return `${resolved}.ts`;
+    return resolveCandidate(resolved);
   }
 
   return undefined;
@@ -4404,6 +4540,7 @@ type WorkflowRegistrationDrift = {
     unregistered: UnregisteredWorkflowRegistry[];
     wiringFile?: string;
     eventBusFile?: string;
+    unsafeLifecycleFiles: string[];
   };
 };
 
@@ -4482,6 +4619,15 @@ async function inspectWorkflowRegistrationDrift(
   }
 
   const infraDir = directoryPath(path.dirname(config.paths.portWiring));
+  for (const file of drift.listeners.unsafeLifecycleFiles) {
+    diagnostics.push({
+      severity: "warning",
+      code: "BEIGNET_LISTENER_LIFECYCLE_UNSAFE",
+      file,
+      message: `${file} calls registerListeners(...) without the complete provider lifecycle, so server startup can resolve before listeners are ready or shutdown can leak subscriptions. Register listeners in start(), return or await registration.ready, and return or await registration.unsubscribe() in stop().`,
+    });
+  }
+
   const listenerTarget = drift.listeners.wiringFile
     ? `${drift.listeners.wiringFile}, which already calls registerListeners(...)`
     : drift.listeners.eventBusFile
@@ -4652,7 +4798,7 @@ async function workflowRegistrationDrift(
       events: [],
       jobs: [],
     },
-    listeners: { unregistered: [] },
+    listeners: { unregistered: [], unsafeLifecycleFiles: [] },
   };
   if (registries.length === 0) return drift;
 
@@ -4714,7 +4860,12 @@ async function workflowRegistrationDrift(
 
   const listenerRegistries = byKind("listeners");
   if (listenerRegistries.length > 0) {
-    const wiring = await listenerWiringReferences(targetDir, files, config);
+    const wiring = await listenerWiringReferences(
+      targetDir,
+      files,
+      config,
+      listenerRegistries,
+    );
     drift.listeners = {
       unregistered: unregisteredWorkflowRegistries(
         listenerRegistries,
@@ -4722,6 +4873,7 @@ async function workflowRegistrationDrift(
       ),
       wiringFile: wiring.wiringFile,
       eventBusFile: wiring.eventBusFile,
+      unsafeLifecycleFiles: wiring.unsafeLifecycleFiles,
     };
   }
 
@@ -5056,12 +5208,15 @@ async function listenerWiringReferences(
   targetDir: string,
   files: string[],
   config: ResolvedBeignetConfig,
+  listenerRegistries: FeatureWorkflowRegistry[],
 ): Promise<{
   identifiers: Set<string>;
   wiringFile?: string;
   eventBusFile?: string;
+  unsafeLifecycleFiles: string[];
 }> {
   const identifiers = new Set<string>();
+  const unsafeLifecycleFiles = new Set<string>();
   let wiringFile: string | undefined;
   let eventBusFile: string | undefined;
   let centralListenerRegistryReferenced = false;
@@ -5073,35 +5228,54 @@ async function listenerWiringReferences(
 
     const source = await readFile(path.join(targetDir, file), "utf8");
     const namedImports = parseNamedImportSources(source);
-    let foundCall = false;
-
-    for (const match of source.matchAll(/\bregisterListeners\s*\(/g)) {
-      const openParen = (match.index ?? 0) + match[0].length - 1;
-      const closeParen = matchingDelimiterIndex(source, openParen, "(", ")");
-      const argsText =
-        closeParen === -1
-          ? source.slice(openParen)
-          : source.slice(openParen + 1, closeParen);
+    const sourceFile = ts.createSourceFile(
+      file,
+      source,
+      ts.ScriptTarget.Latest,
+      true,
+      file.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
+    );
+    const registerListenersBindings = importedRegisterListenersBindings(
+      source,
+      namedImports,
+    );
+    const calls = registerListenersCalls(sourceFile, registerListenersBindings);
+    let foundRelevantCall = false;
 
-      foundCall = true;
+    for (const call of calls) {
+      const argsText = call.arguments
+        .map((argument) => argument.getText(sourceFile))
+        .join(",");
       const callIdentifiers = identifiersFromArrayExpression(argsText);
+      const referencesCentral = callReferencesCentralListenerRegistry({
+        callIdentifiers,
+        namedImports,
+        importerFile: file,
+        listenerRegistryFile,
+        files,
+      });
+      const referencesFeature = callReferencesFeatureListenerRegistry({
+        callIdentifiers,
+        namedImports,
+        importerFile: file,
+        files,
+        listenerRegistries,
+      });
+      if (!referencesCentral && !referencesFeature) continue;
+
+      foundRelevantCall = true;
       for (const identifier of callIdentifiers) {
         identifiers.add(identifier);
       }
-      if (
-        callReferencesCentralListenerRegistry({
-          callIdentifiers,
-          namedImports,
-          importerFile: file,
-          listenerRegistryFile,
-          files,
-        })
-      ) {
+      if (referencesCentral) {
         centralListenerRegistryReferenced = true;
       }
+      if (!hasSafeListenerRegistrationLifecycle(call, sourceFile)) {
+        unsafeLifecycleFiles.add(file);
+      }
     }
 
-    if (foundCall) {
+    if (foundRelevantCall) {
       wiringFile ??= file;
     } else if (!eventBusFile && /\bcreate\w*EventBus\s*\(/.test(source)) {
       eventBusFile = file;
@@ -5124,7 +5298,368 @@ async function listenerWiringReferences(
     }
   }
 
-  return { identifiers, wiringFile, eventBusFile };
+  return {
+    identifiers,
+    wiringFile,
+    eventBusFile,
+    unsafeLifecycleFiles: [...unsafeLifecycleFiles].sort(),
+  };
+}
+
+type ListenerLifecycleHook =
+  | ts.MethodDeclaration
+  | ts.FunctionExpression
+  | ts.ArrowFunction;
+
+interface ListenerLifecycleTarget {
+  text: string;
+  binding?: ts.Node;
+}
+
+function registerListenersCalls(
+  sourceFile: ts.SourceFile,
+  bindings: ReadonlySet<string>,
+): ts.CallExpression[] {
+  const calls: ts.CallExpression[] = [];
+  const visit = (node: ts.Node): void => {
+    if (
+      ts.isCallExpression(node) &&
+      ((ts.isIdentifier(node.expression) &&
+        bindings.has(node.expression.text)) ||
+        (ts.isPropertyAccessExpression(node.expression) &&
+          node.expression.name.text === "registerListeners" &&
+          ts.isIdentifier(node.expression.expression) &&
+          bindings.has(`${node.expression.expression.text}.*`)))
+    ) {
+      calls.push(node);
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return calls;
+}
+
+function importedRegisterListenersBindings(
+  source: string,
+  namedImports: Map<string, { importedName: string; sourcePath: string }>,
+): Set<string> {
+  const bindings = new Set<string>();
+  for (const [localName, imported] of namedImports) {
+    if (
+      imported.importedName === "registerListeners" &&
+      imported.sourcePath === "@beignet/core/events"
+    ) {
+      bindings.add(localName);
+    }
+  }
+  const namespaceImport =
+    /import\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\s+["']@beignet\/core\/events["']/g;
+  for (const match of source.matchAll(namespaceImport)) {
+    bindings.add(`${match[1]}.*`);
+  }
+  return bindings;
+}
+
+function hasSafeListenerRegistrationLifecycle(
+  call: ts.CallExpression,
+  sourceFile: ts.SourceFile,
+): boolean {
+  const startHook = enclosingListenerLifecycleHook(call, "start");
+  const target = listenerRegistrationTarget(call, sourceFile);
+  if (!startHook || !target) return false;
+  const lifecycleOwner = listenerLifecycleOwner(startHook);
+  if (!lifecycleOwner) return false;
+
+  let observesReadiness = false;
+  let observesCleanup = false;
+  const visit = (node: ts.Node): void => {
+    if (
+      !observesReadiness &&
+      ts.isPropertyAccessExpression(node) &&
+      node.name.text === "ready" &&
+      listenerLifecycleTargetsMatch(
+        listenerLifecycleTarget(node.expression, sourceFile),
+        target,
+      ) &&
+      enclosingListenerLifecycleHook(node, "start") === startHook &&
+      listenerLifecyclePromiseIsObserved(node, startHook)
+    ) {
+      observesReadiness = true;
+    }
+
+    if (
+      !observesCleanup &&
+      ts.isCallExpression(node) &&
+      ts.isPropertyAccessExpression(node.expression) &&
+      node.expression.name.text === "unsubscribe" &&
+      listenerLifecycleTargetsMatch(
+        listenerLifecycleTarget(node.expression.expression, sourceFile),
+        target,
+      )
+    ) {
+      const stopHook = enclosingListenerLifecycleHook(node, "stop");
+      if (
+        stopHook &&
+        listenerLifecycleOwner(stopHook) === lifecycleOwner &&
+        listenerLifecyclePromiseIsObserved(node, stopHook)
+      ) {
+        observesCleanup = true;
+      }
+    }
+
+    if (!observesReadiness || !observesCleanup) {
+      ts.forEachChild(node, visit);
+    }
+  };
+  visit(lifecycleOwner);
+  return observesReadiness && observesCleanup;
+}
+
+function listenerRegistrationTarget(
+  call: ts.CallExpression,
+  sourceFile: ts.SourceFile,
+): ListenerLifecycleTarget | undefined {
+  let expression: ts.Expression = call;
+  while (
+    ts.isParenthesizedExpression(expression.parent) ||
+    ts.isAsExpression(expression.parent) ||
+    ts.isSatisfiesExpression(expression.parent) ||
+    ts.isNonNullExpression(expression.parent)
+  ) {
+    expression = expression.parent;
+  }
+
+  const parent = expression.parent;
+  if (
+    ts.isVariableDeclaration(parent) &&
+    parent.initializer === expression &&
+    ts.isIdentifier(parent.name)
+  ) {
+    return { text: parent.name.text, binding: parent };
+  }
+  if (
+    ts.isBinaryExpression(parent) &&
+    parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+    parent.right === expression
+  ) {
+    return listenerLifecycleTarget(parent.left, sourceFile);
+  }
+  return undefined;
+}
+
+function listenerLifecycleTarget(
+  expression: ts.Expression,
+  sourceFile: ts.SourceFile,
+): ListenerLifecycleTarget | undefined {
+  let current = expression;
+  while (
+    ts.isParenthesizedExpression(current) ||
+    ts.isAsExpression(current) ||
+    ts.isSatisfiesExpression(current) ||
+    ts.isNonNullExpression(current)
+  ) {
+    current = current.expression;
+  }
+  if (!ts.isIdentifier(current) && !ts.isPropertyAccessExpression(current)) {
+    return undefined;
+  }
+
+  return {
+    text: current.getText(sourceFile),
+    binding: listenerLifecycleRootIdentifier(current)
+      ? resolveListenerLifecycleBinding(
+          listenerLifecycleRootIdentifier(current) as ts.Identifier,
+        )
+      : undefined,
+  };
+}
+
+function listenerLifecycleRootIdentifier(
+  expression: ts.Identifier | ts.PropertyAccessExpression,
+): ts.Identifier | undefined {
+  let current: ts.Expression = expression;
+  while (ts.isPropertyAccessExpression(current)) {
+    current = current.expression;
+  }
+  return ts.isIdentifier(current) ? current : undefined;
+}
+
+function resolveListenerLifecycleBinding(
+  identifier: ts.Identifier,
+): ts.Node | undefined {
+  let current: ts.Node | undefined = identifier;
+  while (current) {
+    if (ts.isBlock(current) || ts.isSourceFile(current)) {
+      for (const statement of current.statements) {
+        if (!ts.isVariableStatement(statement)) continue;
+        for (const declaration of statement.declarationList.declarations) {
+          if (
+            ts.isIdentifier(declaration.name) &&
+            declaration.name.text === identifier.text
+          ) {
+            return declaration;
+          }
+        }
+      }
+    }
+
+    if (ts.isFunctionLike(current)) {
+      for (const parameter of current.parameters) {
+        if (
+          ts.isIdentifier(parameter.name) &&
+          parameter.name.text === identifier.text
+        ) {
+          return parameter;
+        }
+      }
+    }
+
+    if (
+      ts.isCatchClause(current) &&
+      current.variableDeclaration &&
+      ts.isIdentifier(current.variableDeclaration.name) &&
+      current.variableDeclaration.name.text === identifier.text
+    ) {
+      return current.variableDeclaration;
+    }
+    current = current.parent;
+  }
+  return undefined;
+}
+
+function listenerLifecycleTargetsMatch(
+  left: ListenerLifecycleTarget | undefined,
+  right: ListenerLifecycleTarget,
+): boolean {
+  return (
+    left?.text === right.text &&
+    (left.binding !== undefined || right.binding !== undefined
+      ? left.binding === right.binding
+      : true)
+  );
+}
+
+function enclosingListenerLifecycleHook(
+  node: ts.Node,
+  hookName: "start" | "stop",
+): ListenerLifecycleHook | undefined {
+  let current: ts.Node | undefined = node.parent;
+  while (current) {
+    if (ts.isMethodDeclaration(current)) {
+      return staticPropertyName(current.name) === hookName
+        ? current
+        : undefined;
+    }
+    if (ts.isFunctionExpression(current) || ts.isArrowFunction(current)) {
+      const parent = current.parent;
+      return ts.isPropertyAssignment(parent) &&
+        staticPropertyName(parent.name) === hookName
+        ? current
+        : undefined;
+    }
+    if (ts.isFunctionDeclaration(current)) return undefined;
+    current = current.parent;
+  }
+  return undefined;
+}
+
+function listenerLifecycleOwner(
+  hook: ListenerLifecycleHook,
+): ts.ObjectLiteralExpression | undefined {
+  if (ts.isMethodDeclaration(hook)) {
+    return ts.isObjectLiteralExpression(hook.parent) ? hook.parent : undefined;
+  }
+  const property = hook.parent;
+  return ts.isPropertyAssignment(property) &&
+    ts.isObjectLiteralExpression(property.parent)
+    ? property.parent
+    : undefined;
+}
+
+function listenerLifecyclePromiseIsObserved(
+  node: ts.Node,
+  hook: ListenerLifecycleHook,
+): boolean {
+  let current: ts.Node | undefined = node;
+  while (current && current !== hook) {
+    const parent: ts.Node = current.parent;
+    if (
+      (ts.isAwaitExpression(parent) && parent.expression === current) ||
+      (ts.isReturnStatement(parent) && parent.expression === current)
+    ) {
+      return true;
+    }
+    if (
+      ts.isParenthesizedExpression(parent) ||
+      ts.isAsExpression(parent) ||
+      ts.isSatisfiesExpression(parent) ||
+      ts.isNonNullExpression(parent)
+    ) {
+      current = parent;
+      continue;
+    }
+    if (
+      ts.isPropertyAccessExpression(parent) &&
+      parent.expression === current
+    ) {
+      const method = parent.name.text;
+      const invocation = parent.parent;
+      if (
+        !["then", "catch", "finally"].includes(method) ||
+        !ts.isCallExpression(invocation) ||
+        invocation.expression !== parent ||
+        method === "catch" ||
+        (method === "then" && invocation.arguments.length > 1)
+      ) {
+        return false;
+      }
+      current = invocation;
+      continue;
+    }
+    return false;
+  }
+  return false;
+}
+
+function callReferencesFeatureListenerRegistry(args: {
+  callIdentifiers: Set<string>;
+  namedImports: Map<string, { importedName: string; sourcePath: string }>;
+  importerFile: string;
+  files: string[];
+  listenerRegistries: FeatureWorkflowRegistry[];
+}): boolean {
+  for (const identifier of args.callIdentifiers) {
+    for (const registry of args.listenerRegistries) {
+      if (
+        identifier === registry.registryName ||
+        registry.members.includes(identifier)
+      ) {
+        return true;
+      }
+    }
+
+    const imported = args.namedImports.get(identifier);
+    if (!imported) continue;
+    const importedFile = sourceFileFromImport(
+      imported.sourcePath,
+      args.importerFile,
+      args.files,
+    );
+    if (!importedFile) continue;
+
+    for (const registry of args.listenerRegistries) {
+      if (
+        (imported.importedName === registry.registryName &&
+          importedFile === registry.indexFile) ||
+        (registry.members.includes(imported.importedName) &&
+          (importedFile === registry.indexFile ||
+            registry.memberFiles.get(imported.importedName) === importedFile))
+      ) {
+        return true;
+      }
+    }
+  }
+  return false;
 }
 
 function callReferencesCentralListenerRegistry(args: {