veryfront 0.1.499 → 0.1.501

package/src/src/server/service-server.ts

@@ -43,12 +43,80 @@ export type StartNodeVeryfrontServerOptions = {
   hardShutdownTimeoutMs?: number;
 };
 
+export type StartVeryfrontServerOptions = {
+  runtime: VeryfrontServiceServerRuntime;
+  port: number;
+  bindAddress?: string;
+  logger?: VeryfrontServiceServerLogger;
+  signals?: readonly NodeJS.Signals[];
+  hardShutdownTimeoutMs?: number;
+};
+
+export type VeryfrontServiceServerRuntimeKind = "node" | "deno" | "bun";
+
+export type VeryfrontServiceServer = {
+  ready: Promise<void>;
+  stop: () => Promise<void>;
+  port: number;
+  url: string;
+  runtime: VeryfrontServiceServerRuntimeKind;
+};
+
 export type NodeVeryfrontServiceServer = {
   server: import("node:http").Server;
   ready: Promise<void>;
   stop: () => Promise<void>;
   port: number;
   url: string;
+  runtime: "node";
+};
+
+type DenoServeOptions = {
+  port: number;
+  hostname?: string;
+  signal?: AbortSignal;
+  onListen?: (address: { port: number; hostname: string }) => void;
+};
+
+type DenoServeHandler = (request: Request) => Response | Promise<Response>;
+
+type DenoHttpServer = {
+  addr?: {
+    port?: number;
+  };
+  finished?: Promise<void>;
+  shutdown?: () => void | Promise<void>;
+};
+
+type DenoServeRuntime = {
+  serve: (options: DenoServeOptions, handler: DenoServeHandler) => DenoHttpServer;
+  addSignalListener?: (signal: NodeJS.Signals, handler: SignalHandler) => void;
+  removeSignalListener?: (signal: NodeJS.Signals, handler: SignalHandler) => void;
+  exit?: (code: number) => never | void;
+};
+
+type BunServeOptions = {
+  port: number;
+  hostname?: string;
+  fetch: VeryfrontServiceServerFetch;
+};
+
+type BunHttpServer = {
+  port?: number;
+  url?: URL;
+  stop?: () => void | Promise<void>;
+};
+
+type BunServeRuntime = {
+  serve: (options: BunServeOptions) => BunHttpServer;
+};
+
+type SignalHandler = () => void;
+
+type SignalRuntime = {
+  add: (signal: NodeJS.Signals, handler: SignalHandler) => void;
+  remove?: (signal: NodeJS.Signals, handler: SignalHandler) => void;
+  exit?: (code: number) => never | void;
 };
 
 function defaultNotFound(): Response {
@@ -116,6 +184,365 @@ function closeNodeServer(server: import("node:http").Server): Promise<void> {
   });
 }
 
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function isDenoHttpServer(value: unknown): value is DenoHttpServer {
+  if (!isObject(value)) {
+    return false;
+  }
+  const finished = value.finished;
+  const shutdown = value.shutdown;
+  const addr = value.addr;
+  const port = isObject(addr) ? addr.port : undefined;
+  return (addr === undefined || isObject(addr)) &&
+    (port === undefined || typeof port === "number") &&
+    (finished === undefined || finished instanceof Promise) &&
+    (shutdown === undefined || typeof shutdown === "function");
+}
+
+function isBunHttpServer(value: unknown): value is BunHttpServer {
+  if (!isObject(value)) {
+    return false;
+  }
+  const port = value.port;
+  const url = value.url;
+  const stop = value.stop;
+  return (port === undefined || typeof port === "number") &&
+    (url === undefined || url instanceof URL) &&
+    (stop === undefined || typeof stop === "function");
+}
+
+function getDenoServeRuntime(): DenoServeRuntime | null {
+  const denoGlobal: unknown = Reflect.get(dntShim.dntGlobalThis, "Deno");
+  if (!isObject(denoGlobal)) {
+    return null;
+  }
+  const serve = denoGlobal.serve;
+  const addSignalListener = denoGlobal.addSignalListener;
+  const removeSignalListener = denoGlobal.removeSignalListener;
+  const exit = denoGlobal.exit;
+  if (typeof serve !== "function") {
+    return null;
+  }
+  const runtime: DenoServeRuntime = {
+    serve: (options, handler) => {
+      const server: unknown = Reflect.apply(serve, denoGlobal, [options, handler]);
+      if (!isDenoHttpServer(server)) {
+        return {};
+      }
+      return server;
+    },
+  };
+  if (typeof addSignalListener === "function") {
+    runtime.addSignalListener = (signal, handler) => {
+      Reflect.apply(addSignalListener, denoGlobal, [signal, handler]);
+    };
+  }
+  if (typeof removeSignalListener === "function") {
+    runtime.removeSignalListener = (signal, handler) => {
+      Reflect.apply(removeSignalListener, denoGlobal, [signal, handler]);
+    };
+  }
+  if (typeof exit === "function") {
+    runtime.exit = (code) => Reflect.apply(exit, denoGlobal, [code]);
+  }
+  return runtime;
+}
+
+function getBunServeRuntime(): BunServeRuntime | null {
+  const bunGlobal: unknown = Reflect.get(dntShim.dntGlobalThis, "Bun");
+  if (!isObject(bunGlobal)) {
+    return null;
+  }
+  const serve = bunGlobal.serve;
+  if (typeof serve !== "function") {
+    return null;
+  }
+  return {
+    serve: (options) => {
+      const server: unknown = Reflect.apply(serve, bunGlobal, [options]);
+      if (!isBunHttpServer(server)) {
+        return {};
+      }
+      return server;
+    },
+  };
+}
+
+function getProcessSignalRuntime(): SignalRuntime | null {
+  const processGlobal: unknown = Reflect.get(dntShim.dntGlobalThis, "process");
+  if (!isObject(processGlobal)) {
+    return null;
+  }
+  const on = processGlobal.on;
+  const off = processGlobal.off;
+  const removeListener = processGlobal.removeListener;
+  const exit = processGlobal.exit;
+  if (typeof on !== "function") {
+    return null;
+  }
+  const runtime: SignalRuntime = {
+    add: (signal, handler) => {
+      Reflect.apply(on, processGlobal, [signal, handler]);
+    },
+  };
+  if (typeof off === "function") {
+    runtime.remove = (signal, handler) => {
+      Reflect.apply(off, processGlobal, [signal, handler]);
+    };
+  } else if (typeof removeListener === "function") {
+    runtime.remove = (signal, handler) => {
+      Reflect.apply(removeListener, processGlobal, [signal, handler]);
+    };
+  }
+  if (typeof exit === "function") {
+    runtime.exit = (code) => Reflect.apply(exit, processGlobal, [code]);
+  }
+  return runtime;
+}
+
+function createDenoSignalRuntime(deno: DenoServeRuntime): SignalRuntime | null {
+  if (!deno.addSignalListener) {
+    return null;
+  }
+  return {
+    add: deno.addSignalListener,
+    remove: deno.removeSignalListener,
+    exit: deno.exit,
+  };
+}
+
+function resolveRuntimeKind(): VeryfrontServiceServerRuntimeKind {
+  if (getBunServeRuntime()) {
+    return "bun";
+  }
+  if (getDenoServeRuntime()) {
+    return "deno";
+  }
+  return "node";
+}
+
+async function stopRuntime(
+  runtime: VeryfrontServiceServerRuntime,
+  stopServer: () => void | Promise<void>,
+): Promise<void> {
+  runtime.setShuttingDown();
+  await stopServer();
+  await runtime.stop();
+}
+
+function installSignalHandlers(options: {
+  signalRuntime: SignalRuntime | null;
+  signals?: readonly NodeJS.Signals[];
+  logger: VeryfrontServiceServerLogger;
+  stop: () => Promise<void>;
+  hardShutdownTimeoutMs?: number;
+  runtime: VeryfrontServiceServerRuntimeKind;
+}): () => void {
+  if (!options.signalRuntime) {
+    return () => undefined;
+  }
+
+  const hardShutdownTimeoutMs = options.hardShutdownTimeoutMs ?? 20_000;
+  const installedHandlers: Array<{ signal: NodeJS.Signals; handler: SignalHandler }> = [];
+  let signalShutdownStarted = false;
+
+  for (const signal of options.signals ?? ["SIGTERM"]) {
+    const handler = () => {
+      if (signalShutdownStarted) {
+        return;
+      }
+
+      signalShutdownStarted = true;
+      options.logger.info?.("Veryfront service server received shutdown signal", {
+        signal,
+        runtime: options.runtime,
+      });
+      const hardTimeout = dntShim.setTimeout(() => {
+        options.logger.error?.("Veryfront service server graceful shutdown timed out", {
+          signal,
+          runtime: options.runtime,
+        });
+        options.signalRuntime?.exit?.(1);
+      }, hardShutdownTimeoutMs);
+
+      void options.stop()
+        .then(() => {
+          clearTimeout(hardTimeout);
+          options.signalRuntime?.exit?.(0);
+        })
+        .catch((error: unknown) => {
+          clearTimeout(hardTimeout);
+          options.logger.error?.("Veryfront service server shutdown failed", {
+            signal,
+            runtime: options.runtime,
+            error: error instanceof Error ? error.message : String(error),
+          });
+          options.signalRuntime?.exit?.(1);
+        });
+    };
+
+    try {
+      options.signalRuntime.add(signal, handler);
+      installedHandlers.push({ signal, handler });
+    } catch (error) {
+      options.logger.warn?.("Veryfront service server could not install shutdown signal handler", {
+        signal,
+        runtime: options.runtime,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  return () => {
+    for (const { signal, handler } of installedHandlers) {
+      try {
+        options.signalRuntime?.remove?.(signal, handler);
+      } catch (error) {
+        options.logger.warn?.("Veryfront service server could not remove shutdown signal handler", {
+          signal,
+          runtime: options.runtime,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+  };
+}
+
+async function startDenoVeryfrontServer(
+  options: StartVeryfrontServerOptions,
+  deno: DenoServeRuntime,
+): Promise<VeryfrontServiceServer> {
+  const logger = options.logger ?? serverLogger.component("service-server");
+  const bindAddress = options.bindAddress ?? "0.0.0.0";
+  const abortController = new AbortController();
+  const server = deno.serve({
+    port: options.port,
+    hostname: bindAddress,
+    signal: abortController.signal,
+    onListen: () => undefined,
+  }, options.runtime.fetch);
+  let shutdownStarted = false;
+  let removeSignalHandlers: () => void = () => undefined;
+
+  const stop = async () => {
+    if (shutdownStarted) {
+      return;
+    }
+
+    shutdownStarted = true;
+    try {
+      await stopRuntime(options.runtime, async () => {
+        if (server.shutdown) {
+          await server.shutdown();
+          return;
+        }
+        abortController.abort();
+        await server.finished?.catch(() => undefined);
+      });
+    } finally {
+      removeSignalHandlers();
+    }
+  };
+
+  removeSignalHandlers = installSignalHandlers({
+    signalRuntime: createDenoSignalRuntime(deno),
+    signals: options.signals,
+    logger,
+    stop,
+    hardShutdownTimeoutMs: options.hardShutdownTimeoutMs,
+    runtime: "deno",
+  });
+
+  logger.info?.("Veryfront service server listening", {
+    port: server.addr?.port ?? options.port,
+    bindAddress,
+    runtime: "deno",
+  });
+
+  return {
+    ready: Promise.resolve(),
+    stop,
+    port: server.addr?.port ?? options.port,
+    url: `http://${bindAddress}:${server.addr?.port ?? options.port}`,
+    runtime: "deno",
+  };
+}
+
+async function startBunVeryfrontServer(
+  options: StartVeryfrontServerOptions,
+  bun: BunServeRuntime,
+): Promise<VeryfrontServiceServer> {
+  const logger = options.logger ?? serverLogger.component("service-server");
+  const bindAddress = options.bindAddress ?? "0.0.0.0";
+  const server = bun.serve({
+    port: options.port,
+    hostname: bindAddress,
+    fetch: options.runtime.fetch,
+  });
+  let shutdownStarted = false;
+  let removeSignalHandlers: () => void = () => undefined;
+
+  const stop = async () => {
+    if (shutdownStarted) {
+      return;
+    }
+
+    shutdownStarted = true;
+    try {
+      await stopRuntime(options.runtime, async () => {
+        await server.stop?.();
+      });
+    } finally {
+      removeSignalHandlers();
+    }
+  };
+
+  removeSignalHandlers = installSignalHandlers({
+    signalRuntime: getProcessSignalRuntime(),
+    signals: options.signals,
+    logger,
+    stop,
+    hardShutdownTimeoutMs: options.hardShutdownTimeoutMs,
+    runtime: "bun",
+  });
+
+  logger.info?.("Veryfront service server listening", {
+    port: server.port ?? options.port,
+    bindAddress,
+    runtime: "bun",
+  });
+
+  return {
+    ready: Promise.resolve(),
+    stop,
+    port: server.port ?? options.port,
+    url: server.url?.toString() ?? `http://${bindAddress}:${options.port}`,
+    runtime: "bun",
+  };
+}
+
+export async function startVeryfrontServer(
+  options: StartVeryfrontServerOptions,
+): Promise<VeryfrontServiceServer | NodeVeryfrontServiceServer> {
+  const runtimeKind = resolveRuntimeKind();
+  if (runtimeKind === "bun") {
+    const bun = getBunServeRuntime();
+    if (bun) {
+      return await startBunVeryfrontServer(options, bun);
+    }
+  }
+  if (runtimeKind === "deno") {
+    const deno = getDenoServeRuntime();
+    if (deno) {
+      return await startDenoVeryfrontServer(options, deno);
+    }
+  }
+  return await startNodeVeryfrontServer(options);
+}
+
 export async function startNodeVeryfrontServer(
   options: StartNodeVeryfrontServerOptions,
 ): Promise<NodeVeryfrontServiceServer> {
@@ -183,5 +610,6 @@ export async function startNodeVeryfrontServer(
     stop,
     port: options.port,
     url: `http://${bindAddress}:${options.port}`,
+    runtime: "node",
   };
 }

package/src/src/server/services/rsc/endpoints/script-handlers.ts

@@ -19,18 +19,18 @@ async function buildOrServeScript(
   adapter: RuntimeAdapter,
   path: string,
   fallbackBundle: string,
-  esbuildOptions: Omit<import("../../../../extensions/bundler.js").BuildOptions, "stdin"> & {
-    stdin: import("../../../../extensions/bundler.js").StdinOptions;
+  esbuildOptions: Omit<import("../../../../extensions/bundler/index.js").BuildOptions, "stdin"> & {
+    stdin: import("../../../../extensions/bundler/index.js").StdinOptions;
   },
 ): Promise<Response> {
   // If a pre-built bundle was injected at compile time, serve it directly
   if (fallbackBundle) return jsResponse(fallbackBundle);
 
-  let esbuild: typeof import("../../../../extensions/bundler.js") | null = null;
+  let esbuild: typeof import("../../../../extensions/bundler/index.js") | null = null;
 
   try {
     const src = await adapter.fs.readFile(path);
-    esbuild = await import("../../../../extensions/bundler.js");
+    esbuild = await import("../../../../extensions/bundler/index.js");
     const result = await esbuild.build({
       ...esbuildOptions,
       stdin: { ...esbuildOptions.stdin, contents: src },

package/src/src/server/services/rsc/orchestrators/hydrator-handler.ts

@@ -32,7 +32,7 @@ export class HydratorHandler {
   }
 
   private async bundleHydrator(filePath: string): Promise<string> {
-    const { build, stop } = await import("../../../../extensions/bundler.js");
+    const { build, stop } = await import("../../../../extensions/bundler/index.js");
 
     try {
       const source = await this.readHydratorFile(filePath);

package/src/src/server/shared/browser-module-bundler.ts

@@ -23,7 +23,7 @@ export function bundleBrowserModule(
   return withSpan(
     "server.browser-module.bundle",
     async () => {
-      const { build } = await import("../../extensions/bundler.js");
+      const { build } = await import("../../extensions/bundler/index.js");
       const src = await options.adapter.fs.readFile(absPath);
       const importMapJson = await buildImportMapJson({
         projectDir: options.projectDir,

package/src/src/testing/init.ts

@@ -12,7 +12,7 @@
 import * as dntShim from "../../_dnt.shims.js";
 
 
-import { EsbuildBundler, EsModuleLexer } from "../../extensions/ext-esbuild/src/index.js";
+import { EsbuildBundler, EsModuleLexer } from "../../extensions/ext-bundler-esbuild/src/index.js";
 import { register as registerContract } from "../extensions/contracts.js";
 
 const g = dntShim.dntGlobalThis as Record<string, unknown>;

package/src/src/transforms/esm/http-bundler.ts

@@ -8,7 +8,7 @@ import * as dntShim from "../../../_dnt.shims.js";
 
 
 import { rendererLogger as logger } from "../../utils/index.js";
-import type { Plugin } from "../../extensions/bundler.js";
+import type { Plugin } from "../../extensions/bundler/index.js";
 import { replaceSpecifiers } from "./lexer.js";
 import { DEFAULT_REACT_VERSION, getReactUrls } from "./package-registry.js";
 import {

package/src/src/transforms/esm/lexer.ts

@@ -1,9 +1,6 @@
 import { logger as baseLogger } from "../../utils/index.js";
 import { resolve as resolveContract } from "../../extensions/contracts.js";
-import type {
-  ImportSpecifier,
-  ModuleLexer,
-} from "../../extensions/interfaces/module-lexer.js";
+import type { ImportSpecifier, ModuleLexer } from "../../extensions/bundler/module-lexer.js";
 
 export type { ImportSpecifier };
 

package/src/src/transforms/esm/transform-utils.ts

@@ -1,4 +1,4 @@
-import type { Loader } from "../../extensions/bundler.js";
+import type { Loader } from "../../extensions/bundler/index.js";
 import { shortHash } from "../../utils/hash-utils.js";
 
 /**

package/src/src/transforms/import-rewriter/parse-cache.ts

@@ -6,7 +6,7 @@
  */
 
 import { resolve as resolveContract } from "../../extensions/contracts.js";
-import type { ModuleLexer } from "../../extensions/interfaces/module-lexer.js";
+import type { ModuleLexer } from "../../extensions/bundler/module-lexer.js";
 import type { ImportSpecifierInfo } from "./types.js";
 import type { ImportSpecifier } from "../esm/lexer.js";
 

package/src/src/transforms/md/compiler/md-compiler.ts

@@ -5,7 +5,7 @@ import type {
   CompilationTarget,
   ContentRuntimeBundle,
   ContentTransformer,
-} from "../../../extensions/interfaces/index.js";
+} from "../../../extensions/transform/index.js";
 import { createError, toError } from "../../../errors/veryfront-error.js";
 import { withSpan } from "../../../observability/tracing/otlp-setup.js";
 

package/src/src/transforms/mdx/compiler/import-rewriter.ts

@@ -1,5 +1,5 @@
 import { dirname, join, resolve as pathResolve } from "../../../platform/compat/path/index.js";
-import type { CompilationTarget } from "../../../extensions/interfaces/index.js";
+import type { CompilationTarget } from "../../../extensions/transform/index.js";
 
 export interface ImportRewriterConfig {
   filePath: string;

package/src/src/transforms/mdx/compiler/index.ts

@@ -11,7 +11,7 @@ export type {
   CompilationMode,
   CompilationTarget,
   ContentRuntimeBundle,
-} from "../../../extensions/interfaces/index.js";
+} from "../../../extensions/transform/index.js";
 export type { FrontmatterExtractionResult } from "./frontmatter-extractor.js";
 export type { ImportRewriterConfig } from "./import-rewriter.js";
 
@@ -21,7 +21,7 @@ import type {
   CompilationMode,
   CompilationTarget,
   ContentRuntimeBundle,
-} from "../../../extensions/interfaces/index.js";
+} from "../../../extensions/transform/index.js";
 
 function isMarkdownFile(filePath?: string): boolean {
   return filePath?.endsWith(".md") ?? false;

package/src/src/transforms/mdx/compiler/mdx-compiler.ts

@@ -5,7 +5,7 @@ import type {
   CompilationTarget,
   ContentRuntimeBundle,
   ContentTransformer,
-} from "../../../extensions/interfaces/index.js";
+} from "../../../extensions/transform/index.js";
 import { createError, toError } from "../../../errors/veryfront-error.js";
 import { withSpan } from "../../../observability/tracing/otlp-setup.js";
 

package/src/src/transforms/mdx/esm-module-loader/import-transformer.ts

@@ -91,7 +91,7 @@ export async function transformJsxImports(
   adapter: ESMLoaderContext["adapter"],
   esmCacheDir: string,
 ): Promise<string> {
-  const { transform } = await import("../../../extensions/bundler.js");
+  const { transform } = await import("../../../extensions/bundler/index.js");
 
   const importsToProcess: Array<{
     fullMatch: string;

package/src/src/transforms/pipeline/stages/ssr-vf-modules/transform.ts

@@ -107,7 +107,7 @@ export async function transformFrameworkCode(
       depth,
     });
     // Return minimally transformed code - it will fail at runtime but won't hang
-    const { transform } = await import("../../../../extensions/bundler.js");
+    const { transform } = await import("../../../../extensions/bundler/index.js");
     const ext = sourcePath.match(/\.(tsx?|jsx?)$/)?.[1] ?? "tsx";
     let loader: "tsx" | "ts" | "jsx" | "js" = "js";
     if (ext === "tsx") loader = "tsx";
@@ -151,7 +151,7 @@ export async function transformFrameworkCode(
   transformingFiles.add(sourcePath);
 
   try {
-    const { transform } = await import("../../../../extensions/bundler.js");
+    const { transform } = await import("../../../../extensions/bundler/index.js");
 
     const ext = sourcePath.match(/\.(tsx?|jsx?)$/)?.[1] ?? "tsx";
     let loader: "tsx" | "ts" | "jsx" | "js" = "js";

package/src/src/transforms/plugins/babel-node-positions.ts

@@ -1,15 +1,15 @@
 /**
  * Shim over the `CodeParser` contract's `injectJsxNodePositions()` method.
  *
- * The actual Babel-based implementation lives in `@veryfront/ext-babel`.
+ * The actual Babel-based implementation lives in `@veryfront/ext-parser-babel`.
  * Core modules continue to import from this path; the shim resolves the
  * contract at call time. Position injection powers Studio Navigator only —
- * if `ext-babel` is not installed we return the source unchanged rather
+ * if `ext-parser-babel` is not installed we return the source unchanged rather
  * than fail the SSR path.
  */
 
 import { tryResolve } from "../../extensions/contracts.js";
-import type { CodeParser } from "../../extensions/interfaces/index.js";
+import type { CodeParser } from "../../extensions/parser/index.js";
 
 interface TransformOptions {
   filePath: string;

package/src/src/transforms/plugins/plugin-loader.ts

@@ -1,6 +1,6 @@
 /**
  * Shim that routes MDX plugin lookups through the `ContentTransformer`
- * extension contract (default implementation: `@veryfront/ext-mdx`).
+ * extension contract (default implementation: `@veryfront/ext-transform-mdx`).
  *
  * Build-time MDX compilers (`src/build/compiler/mdx-compiler/mdx-processor.ts`,
  * `src/build/renderer/services/mdx-bundler.ts`, `layout-applicator.ts`)
@@ -9,14 +9,14 @@
  * `ContentTransformer` implementation is registered.
  *
  * When no implementation is registered, the lookup throws with an
- * actionable install message pointing at `@veryfront/ext-mdx`.
+ * actionable install message pointing at `@veryfront/ext-transform-mdx`.
  *
  * @module transforms/plugins/plugin-loader
  */
 
 import type { Pluggable } from "unified";
 import { resolve as resolveContract } from "../../extensions/contracts.js";
-import type { ContentTransformer } from "../../extensions/interfaces/index.js";
+import type { ContentTransformer } from "../../extensions/transform/index.js";
 
 export function getRemarkPlugins(): Pluggable[] {
   const transformer = resolveContract<ContentTransformer>("ContentTransformer");

package/src/src/utils/version-constant.ts

@@ -1,3 +1,3 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.499";
+export const VERSION = "0.1.501";

package/esm/extensions/ext-anthropic/src/anthropic-provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"anthropic-provider.d.ts","sourceRoot":"","sources":["../../../../src/extensions/ext-anthropic/src/anthropic-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,6CAA6C,CAAC;AAChG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EACL,kBAAkB,EAIlB,aAAa,EACb,UAAU,EACV,iBAAiB,EAEjB,aAAa,EACb,uBAAuB,EACvB,kBAAkB,EAClB,sBAAsB,EACtB,oBAAoB,EAMpB,+BAA+B,EAE/B,8BAA8B,EAC/B,MAAM,uCAAuC,CAAC;AAG/C,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,UAAU,EACV,iBAAiB,EACjB,aAAa,EACb,uBAAuB,EACvB,kBAAkB,EAClB,sBAAsB,EACtB,oBAAoB,EACpB,+BAA+B,EAC/B,8BAA8B,GAC/B,CAAC;AAEF,MAAM,WAAW,sBAAsB;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACjC;AAkjCD,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,sBAAsB,EAC9B,OAAO,EAAE,MAAM,GACd,YAAY,CAyEd;AAED,qBAAa,iBAAkB,YAAW,UAAU;IAClD,QAAQ,CAAC,EAAE,eAAe;IAE1B,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,GAAG,YAAY;CAYrE"}

package/esm/extensions/ext-anthropic/src/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/extensions/ext-anthropic/src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAGzE,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAE5D,QAAA,MAAM,YAAY,EAAE,gBAkBnB,CAAC;AAEF,eAAe,YAAY,CAAC;AAC5B,OAAO,EAAE,iBAAiB,EAAE,CAAC"}