claude: Refactor quarto-api with dependency inversion and registry pattern

Refactored src/core/quarto-api.ts (397 lines) into modular structure
under src/core/api/ (13 files, 743 lines) to eliminate circular
dependencies using dependency inversion and registry pattern.

Architecture:
- types.ts: Interface definitions using ONLY import type
- registry.ts: Generic registry with eager validation
- 9 namespace modules: crypto, console, markdown-regex, mapped-string,
  format, path, text, system, jupyter
- register.ts: Side-effect aggregation module
- index.ts: Main entry with lazy Proxy initialization

Key features:
- Zero circular dependencies via import type only in types.ts
- Eager validation: All namespaces validated at startup
- Lazy initialization: Proxy-based API creation on first access
- Type safety: Full TypeScript checking maintained
- API compatibility: Zero changes to QuartoAPI interface surface

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: gordonwoodhull

src/core/api/console.ts

@@ -0,0 +1,23 @@
+// src/core/api/console.ts
+
+import { globalRegistry } from "./registry.ts";
+import type { ConsoleNamespace } from "./types.ts";
+
+// Import implementations
+import { completeMessage, withSpinner } from "../console.ts";
+import * as log from "../../deno_ral/log.ts";
+import type { LogMessageOptions } from "../log.ts";
+
+// Register console namespace
+globalRegistry.register("console", (): ConsoleNamespace => {
+  return {
+    withSpinner,
+    completeMessage,
+    info: (message: string, options?: LogMessageOptions) =>
+      log.info(message, options),
+    warning: (message: string, options?: LogMessageOptions) =>
+      log.warning(message, options),
+    error: (message: string, options?: LogMessageOptions) =>
+      log.error(message, options),
+  };
+});

src/core/api/crypto.ts

@@ -0,0 +1,14 @@
+// src/core/api/crypto.ts
+
+import { globalRegistry } from "./registry.ts";
+import type { CryptoNamespace } from "./types.ts";
+
+// Import implementation
+import { md5HashSync } from "../hash.ts";
+
+// Register crypto namespace
+globalRegistry.register("crypto", (): CryptoNamespace => {
+  return {
+    md5Hash: md5HashSync,
+  };
+});

src/core/api/format.ts

@@ -0,0 +1,29 @@
+// src/core/api/format.ts
+
+import { globalRegistry } from "./registry.ts";
+import type { FormatNamespace } from "./types.ts";
+
+// Import implementations
+import {
+  isHtmlCompatible,
+  isHtmlDashboardOutput,
+  isIpynbOutput,
+  isLatexOutput,
+  isMarkdownOutput,
+  isPresentationOutput,
+} from "../../config/format.ts";
+import { isServerShiny, isServerShinyPython } from "../render.ts";
+
+// Register format namespace
+globalRegistry.register("format", (): FormatNamespace => {
+  return {
+    isHtmlCompatible,
+    isIpynbOutput,
+    isLatexOutput,
+    isMarkdownOutput,
+    isPresentationOutput,
+    isHtmlDashboardOutput: (format?: string) => !!isHtmlDashboardOutput(format),
+    isServerShiny,
+    isServerShinyPython,
+  };
+});

src/core/api/index.ts

@@ -0,0 +1,48 @@
+// src/core/api/index.ts
+//
+// Main entry point for QuartoAPI
+// This module exports the global quartoAPI instance and all related types
+
+import { globalRegistry } from "./registry.ts";
+import type { QuartoAPI } from "./types.ts";
+
+// Export all types for external use
+export type {
+  ConsoleNamespace,
+  CryptoNamespace,
+  FormatNamespace,
+  JupyterNamespace,
+  MappedStringNamespace,
+  MarkdownRegexNamespace,
+  PathNamespace,
+  QuartoAPI,
+  SystemNamespace,
+  TextNamespace,
+} from "./types.ts";
+
+// Export registry utilities (mainly for testing)
+export {
+  globalRegistry,
+  QuartoAPIRegistry,
+  RegistryFinalizedError,
+  UnregisteredNamespaceError,
+} from "./registry.ts";
+
+/**
+ * The global QuartoAPI instance
+ *
+ * This is created lazily on first access via a getter.
+ * The register.ts module (imported in src/quarto.ts) ensures all
+ * namespaces are registered before any code accesses the API.
+ */
+let _quartoAPI: QuartoAPI | null = null;
+
+export const quartoAPI = new Proxy({} as QuartoAPI, {
+  get(_target, prop) {
+    // Create API on first access
+    if (_quartoAPI === null) {
+      _quartoAPI = globalRegistry.createAPI();
+    }
+    return _quartoAPI[prop as keyof QuartoAPI];
+  },
+});

src/core/api/jupyter.ts

@@ -0,0 +1,82 @@
+// src/core/api/jupyter.ts
+
+import { globalRegistry } from "./registry.ts";
+import type { JupyterNamespace } from "./types.ts";
+
+// Import implementations
+import {
+  executeResultEngineDependencies,
+  executeResultIncludes,
+  isJupyterNotebook,
+  jupyterAssets,
+  jupyterFromJSON,
+  jupyterKernelspecFromMarkdown,
+  jupyterToMarkdown,
+  kJupyterNotebookExtensions,
+  quartoMdToJupyter,
+} from "../jupyter/jupyter.ts";
+import {
+  jupyterNotebookFiltered,
+  markdownFromNotebookFile,
+  markdownFromNotebookJSON,
+} from "../jupyter/jupyter-filters.ts";
+import { includesForJupyterWidgetDependencies } from "../jupyter/widgets.ts";
+import { pythonExec } from "../jupyter/exec.ts";
+import { jupyterCapabilities } from "../jupyter/capabilities.ts";
+import { jupyterKernelspecForLanguage } from "../jupyter/kernels.ts";
+import {
+  jupyterCapabilitiesJson,
+  jupyterCapabilitiesMessage,
+  jupyterInstallationMessage,
+  jupyterUnactivatedEnvMessage,
+  pythonInstallationMessage,
+} from "../jupyter/jupyter-shared.ts";
+import {
+  isJupyterPercentScript,
+  markdownFromJupyterPercentScript,
+} from "../jupyter/percent.ts";
+import type { JupyterWidgetDependencies } from "../jupyter/types.ts";
+
+// Register jupyter namespace
+globalRegistry.register("jupyter", (): JupyterNamespace => {
+  return {
+    // 1. Notebook Detection & Introspection
+    isJupyterNotebook,
+    isPercentScript: isJupyterPercentScript,
+    notebookExtensions: kJupyterNotebookExtensions,
+    kernelspecFromMarkdown: jupyterKernelspecFromMarkdown,
+    kernelspecForLanguage: jupyterKernelspecForLanguage,
+    fromJSON: jupyterFromJSON,
+
+    // 2. Notebook Conversion
+    toMarkdown: jupyterToMarkdown,
+    markdownFromNotebookFile,
+    markdownFromNotebookJSON,
+    percentScriptToMarkdown: markdownFromJupyterPercentScript,
+    quartoMdToJupyter,
+
+    // 3. Notebook Processing & Assets
+    notebookFiltered: jupyterNotebookFiltered,
+    assets: jupyterAssets,
+    widgetDependencyIncludes: includesForJupyterWidgetDependencies,
+    resultIncludes: (
+      tempDir: string,
+      dependencies?: JupyterWidgetDependencies,
+    ) => {
+      return executeResultIncludes(tempDir, dependencies) || {};
+    },
+    resultEngineDependencies: (dependencies?: JupyterWidgetDependencies) => {
+      const result = executeResultEngineDependencies(dependencies);
+      return result as Array<JupyterWidgetDependencies> | undefined;
+    },
+
+    // 4. Runtime & Environment
+    pythonExec,
+    capabilities: jupyterCapabilities,
+    capabilitiesMessage: jupyterCapabilitiesMessage,
+    capabilitiesJson: jupyterCapabilitiesJson,
+    installationMessage: jupyterInstallationMessage,
+    unactivatedEnvMessage: jupyterUnactivatedEnvMessage,
+    pythonInstallationMessage,
+  };
+});

src/core/api/mapped-string.ts

@@ -0,0 +1,30 @@
+// src/core/api/mapped-string.ts
+
+import { globalRegistry } from "./registry.ts";
+import type { MappedStringNamespace } from "./types.ts";
+
+// Import implementations
+import {
+  asMappedString,
+  mappedIndexToLineCol,
+  mappedLines,
+  mappedNormalizeNewlines,
+} from "../lib/mapped-text.ts";
+import { mappedStringFromFile } from "../mapped-text.ts";
+import type { MappedString } from "../lib/text-types.ts";
+
+// Register mappedString namespace
+globalRegistry.register("mappedString", (): MappedStringNamespace => {
+  return {
+    fromString: asMappedString,
+    fromFile: mappedStringFromFile,
+    normalizeNewlines: mappedNormalizeNewlines,
+    splitLines: (str: MappedString, keepNewLines?: boolean) => {
+      return mappedLines(str, keepNewLines);
+    },
+    indexToLineCol: (str: MappedString, offset: number) => {
+      const fn = mappedIndexToLineCol(str);
+      return fn(offset);
+    },
+  };
+});

src/core/api/markdown-regex.ts

@@ -0,0 +1,22 @@
+// src/core/api/markdown-regex.ts
+
+import { globalRegistry } from "./registry.ts";
+import type { MarkdownRegexNamespace } from "./types.ts";
+
+// Import implementations
+import { readYamlFromMarkdown } from "../yaml.ts";
+import {
+  languagesInMarkdown,
+  partitionMarkdown,
+} from "../pandoc/pandoc-partition.ts";
+import { breakQuartoMd } from "../lib/break-quarto-md.ts";
+
+// Register markdownRegex namespace
+globalRegistry.register("markdownRegex", (): MarkdownRegexNamespace => {
+  return {
+    extractYaml: readYamlFromMarkdown,
+    partition: partitionMarkdown,
+    getLanguages: languagesInMarkdown,
+    breakQuartoMd,
+  };
+});

src/core/api/path.ts

@@ -0,0 +1,39 @@
+// src/core/api/path.ts
+
+import { globalRegistry } from "./registry.ts";
+import type { PathNamespace } from "./types.ts";
+
+// Import implementations
+import {
+  dirAndStem,
+  isQmdFile,
+  normalizePath,
+  pathWithForwardSlashes,
+} from "../path.ts";
+import { quartoDataDir, quartoRuntimeDir } from "../appdirs.ts";
+import { resourcePath } from "../resources.ts";
+import { inputFilesDir } from "../render.ts";
+
+// Register path namespace
+globalRegistry.register("path", (): PathNamespace => {
+  return {
+    absolute: normalizePath,
+    toForwardSlashes: pathWithForwardSlashes,
+    runtime: quartoRuntimeDir,
+    resource: (...parts: string[]) => {
+      if (parts.length === 0) {
+        return resourcePath();
+      } else if (parts.length === 1) {
+        return resourcePath(parts[0]);
+      } else {
+        // Join multiple parts with the first one
+        const joined = parts.join("/");
+        return resourcePath(joined);
+      }
+    },
+    dirAndStem,
+    isQmdFile,
+    inputFilesDir,
+    dataDir: quartoDataDir,
+  };
+});

src/core/api/register.ts

@@ -0,0 +1,15 @@
+// src/core/api/register.ts
+//
+// Side-effect module that imports all namespace registrations
+// This module has no exports - its purpose is to trigger registration
+// of all QuartoAPI namespaces with the global registry.
+
+import "./markdown-regex.ts";
+import "./mapped-string.ts";
+import "./jupyter.ts";
+import "./format.ts";
+import "./path.ts";
+import "./system.ts";
+import "./text.ts";
+import "./console.ts";
+import "./crypto.ts";