alchemy 2.0.0-beta.84 → 2.0.0-beta.85

package/src/Auth/Resolve.ts

@@ -6,7 +6,8 @@ import * as Schema from "effect/Schema";
 import { UserFacingError } from "../UserFacingError.ts";
 import { loadConfigProvider } from "../Util/ConfigProvider.ts";
 import { AuthError, getAuthProvider, presentEnvironment } from "./AuthProvider.ts";
-import { ProfileStore, SuppressMissingProviderConfig } from "./Profile.ts";
+import { cacheUntilExpiry } from "./CredentialsCache.ts";
+import { ProfileStore, reloadProviderConfig, SuppressMissingProviderConfig } from "./Profile.ts";
 
 /**
  * Resolve the selected Alchemy profile after the command's dotenv provider is
@@ -86,7 +87,9 @@ export const resolveProviderConfig = <C extends { method: string } = any, Creden
       auth,
       profileName,
       config,
-      resolve: auth.read(profileName, config, (updated) =>
+      // Reload under the credentials lock on every resolve: a refresh
+      // rotates the stored token, so `config` goes stale after the first one.
+      resolve: auth.read(profileName, reloadProviderConfig(profile, auth, profileName), (updated) =>
         profile.setProviderConfig(profileName, providerName, updated).pipe(
           Effect.mapError((cause) =>
             AuthError.make({
@@ -105,9 +108,21 @@ export const resolveProviderConfig = <C extends { method: string } = any, Creden
  * runs on first use, outside the layer build, so the services it needs are
  * captured now and provided to it. Building the layer then never runs the
  * effect, e.g. never requires a configured profile.
+ *
+ * The `ConfigProvider` is a reference, so it is not part of `R`; capture it
+ * too. Otherwise the first use reads config through whatever provider is
+ * ambient there — e.g. a Function's init, which binds every key it loads into
+ * the Function's env and would ship the deployer's credentials (#1842).
  */
 export const deferUntilFirstUse = <A, E, R>(resolve: Effect.Effect<A, E, R>) =>
-  Effect.map(Effect.context<R>(), (context) => resolve.pipe(Effect.provideContext(context)));
+  Effect.map(
+    Effect.all([Effect.context<R>(), ConfigProvider.ConfigProvider]),
+    ([context, configProvider]) =>
+      resolve.pipe(
+        Effect.provideService(ConfigProvider.ConfigProvider, configProvider),
+        Effect.provideContext(context),
+      ),
+  );
 
 /**
  * A provider's credentials could not be resolved when a cloud operation first
@@ -145,6 +160,63 @@ export const orDieCredentialsUnavailable =
       Effect.orDie,
     );
 
+/**
+ * The credential recipe behind every provider's `fromAuthProvider` layer:
+ * {@link resolveProviderConfig}'s precedence, deferred until first use (so
+ * building provider layers never needs a configured profile), cached until
+ * shortly before the credentials expire (forever when `expiresAt` is omitted
+ * or returns `undefined`; failures are never cached, so a later `alchemy
+ * profile` login is picked up), and mapped onto the client's shape.
+ *
+ * A failed resolution fails with {@link CredentialsUnavailable}, which the
+ * engine reports as `CredentialsRequired`. `E` types that failure into the
+ * client SDK's own credentials channel (e.g. distilled's `ConfigError`), so
+ * users never see a new error type.
+ *
+ * ```ts
+ * export const fromAuthProvider = () =>
+ *   Layer.effect(
+ *     Credentials,
+ *     lazyCredentials<StripeResolvedCredentials, ConfigError>()(
+ *       STRIPE_AUTH_PROVIDER_NAME,
+ *       (creds) => ({ apiKey: creds.apiKey, apiBaseUrl: creds.apiBaseUrl }),
+ *     ),
+ *   );
+ * ```
+ */
+export const lazyCredentials = <Resolved, E = CredentialsUnavailable>() =>
+  Effect.fn("lazyCredentials")(function* <A>(
+    providerName: string,
+    toClient: (resolved: Resolved) => A,
+    options?: { readonly expiresAt?: (resolved: Resolved) => number | undefined },
+  ) {
+    const unavailable = (prefix: string) => (cause: { readonly message: string }) =>
+      CredentialsUnavailable.make({
+        provider: providerName,
+        message: `${prefix}${cause.message}`,
+        cause,
+      });
+    const resolve = yield* resolveProviderConfig<{ method: string }, Resolved>(providerName).pipe(
+      Effect.mapError(unavailable("")),
+      Effect.flatMap(({ profileName, resolve }) => {
+        const from = profileName === undefined ? "the environment" : `profile '${profileName}'`;
+        return Effect.logDebug(`${providerName}: credentials from ${from}`).pipe(
+          Effect.annotateLogs({ provider: providerName }),
+          Effect.andThen(resolve),
+          Effect.mapError(
+            unavailable(`Failed to resolve ${providerName} credentials from ${from}: `),
+          ),
+        );
+      }),
+      deferUntilFirstUse,
+    );
+    const cached = yield* cacheUntilExpiry(resolve, options?.expiresAt ?? (() => undefined));
+    // SAFETY: E is only the SDK channel the CredentialsUnavailable fails
+    // through; the engine matches its tag around every provider call.
+    // oxlint-disable-next-line effecttsgo/unsafe-effect-type-assertion -- see SAFETY above
+    return cached.pipe(Effect.map(toClient)) as Effect.Effect<A, E>;
+  });
+
 /** Let an explicit profile override configured selection without disturbing other keys. */
 export const withProfileOverride = (
   base: ConfigProvider.ConfigProvider,

package/src/Auth/StoredAuthProvider.ts

@@ -188,12 +188,11 @@ export const makeStoredAuthProvider = <Resolved>(config: StoredAuthProviderConfi
   const layer = AuthProviderLayer<StoredAuthConfig, Resolved>()(
     provider,
     Effect.gen(function* () {
-      const interaction = Interaction.accessors;
       const persist = (_profileName: string, values: StoredValues) =>
         Effect.gen(function* () {
           const complete = config.complete?.(values) ?? Effect.succeed(values);
           const completed = yield* complete;
-          yield* interaction.output.success(`${provider}: credentials saved.`);
+          yield* Interaction.success(`${provider}: credentials saved.`);
           return {
             method: "stored" as const,
             ...Object.fromEntries(

package/src/Binding.ts

@@ -107,10 +107,9 @@ export const Service = <
   const tag = Context.Service<Self, (...args: any[]) => Effect.Effect<any>>(id);
   const callable = (...args: any[]) =>
     tag.use((f: (...a: any[]) => Effect.Effect<any>) =>
-      Effect.all(
-        args.map((arg) => (Effect.isEffect(arg) ? arg : Effect.succeed(arg))),
-        { concurrency: "unbounded" },
-      ).pipe(
+      Effect.forEach(args, (arg) => (Effect.isEffect(arg) ? arg : Effect.succeed(arg)), {
+        concurrency: "unbounded",
+      }).pipe(
         Effect.flatMap((resolved) =>
           f(...resolved).pipe(
             // Deploy-time data-plane routing: the client's calls must target

package/src/Bundle/Bundle.ts

@@ -1,4 +1,5 @@
 import assert from "node:assert";
+import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
@@ -11,8 +12,10 @@ import { dotAlchemyDirectory } from "../AlchemyContext.ts";
 import { encodeFqn } from "../FQN.ts";
 import { ResourceContext } from "../ResourceContext.ts";
 import { StackContext } from "../StackContext.ts";
+import { LogAnnotation } from "../Util/LogAnnotation.ts";
 import { sha256, sha256Object } from "../Util/sha256.ts";
 import { bundleAnalyzerPlugin, type BundleAnalyzerPluginOptions } from "./BundleAnalyzerPlugin.ts";
+import { namespaceImportPlugin } from "./NamespaceImportPlugin.ts";
 import { purePlugin, type PurePluginOptions } from "./PurePlugin.ts";
 import { rawPlugin } from "./RawPlugin.ts";
 import { unreachableChunksPlugin } from "./UnreachableChunksPlugin.ts";
@@ -119,6 +122,11 @@ export interface BundleFile {
   readonly path: string;
   readonly content: string | Uint8Array<ArrayBufferLike>;
   readonly hash: string;
+  /**
+   * The platform's module type for this file, when its extension doesn't
+   * decide it (e.g. a Cloudflare `Text` rule over `.md` files).
+   */
+  readonly type?: string;
 }
 
 export class BundleError extends Schema.TaggedError<BundleError>()("BundleError", {
@@ -185,9 +193,18 @@ const ALCHEMY_MODULE_TYPES: NonNullable<rolldown.InputOptions["moduleTypes"]> =
  * framework flags win over any caller-provided keys) and
  * {@link ALCHEMY_MODULE_TYPES} into the caller's `moduleTypes` (caller
  * keys win, so an extension can be remapped or disabled per bundle).
+ *
+ * Also enables `experimental.lazyBarrel` unless the caller sets it, so a
+ * runtime importing one service from `@alchemy.run/aws` (a barrel of every
+ * AWS service) compiles that service, not all of them. See
+ * {@link namespaceImportPlugin} for `import * as AWS`.
  */
 const withAlchemyDefine = (inputOptions: rolldown.InputOptions): rolldown.InputOptions => ({
   ...inputOptions,
+  experimental: {
+    lazyBarrel: true,
+    ...inputOptions.experimental,
+  },
   transform: {
     ...inputOptions.transform,
     define: {
@@ -283,6 +300,35 @@ const bundleConcurrency = (() => {
 })();
 const buildPermits = Semaphore.makeUnsafe(bundleConcurrency);
 
+/**
+ * Rolldown's own logs (warnings such as `UNRESOLVED_IMPORT`, plugin timings)
+ * as `output` records in the context of the build: the resource's `fqn` and
+ * trace, one record per log instead of raw lines on stderr. Like any tool
+ * output, they stay in the run log and are never exported. A caller's own
+ * `onLog` wins.
+ */
+const withRolldownLogs = (
+  inputOptions: rolldown.InputOptions,
+  context: Context.Context<never>,
+): rolldown.InputOptions =>
+  inputOptions.onLog !== undefined
+    ? inputOptions
+    : {
+        ...inputOptions,
+        onLog: (level, log) =>
+          Effect.runSyncWith(context)(
+            Effect.logWithLevel(level === "warn" ? "Warn" : level === "debug" ? "Debug" : "Info")(
+              log.frame === undefined ? log.message : `${log.message}\n${log.frame}`,
+            ).pipe(
+              Effect.annotateLogs({
+                [LogAnnotation.stream]: "stderr",
+                ...(log.code === undefined ? {} : { code: log.code }),
+                ...(log.plugin === undefined ? {} : { plugin: log.plugin }),
+              }),
+            ),
+          ),
+      };
+
 /**
  * Build a bundle using rolldown from the given input options and output options.
  * @param inputOptions - The input options for the bundle.
@@ -294,13 +340,13 @@ export const build = (
   outputOptions?: rolldown.OutputOptions,
   extra?: BundleExtraOptions,
 ): Effect.Effect<BundleOutput, BundleError> =>
-  resolveOutputOptions(outputOptions).pipe(
-    Effect.flatMap((options) =>
+  Effect.zip(resolveOutputOptions(outputOptions), Effect.context<never>()).pipe(
+    Effect.flatMap(([options, context]) =>
       Effect.tryPromise({
         try: async () => {
           const rolldown = await loadRolldown();
           const bundle = await rolldown.rolldown({
-            ...withAlchemyDefine(inputOptions),
+            ...withAlchemyDefine(withRolldownLogs(inputOptions, context)),
             plugins: [inputOptions.plugins, await builtInPlugins(extra)],
             optimization: inputOptions.optimization ?? {
               inlineConst: {
@@ -334,7 +380,11 @@ export const watch = (
   extra?: BundleExtraOptions,
 ): Stream.Stream<BundleWatchEvent> =>
   Stream.unwrap(
-    Effect.map(resolveOutputOptions(outputOptions), watchResolved(inputOptions, extra)),
+    Effect.zipWith(
+      resolveOutputOptions(outputOptions),
+      Effect.context<never>(),
+      (options, context) => watchResolved(withRolldownLogs(inputOptions, context), extra)(options),
+    ),
   );
 
 const watchResolved =
@@ -405,11 +455,12 @@ const watchResolved =
         Effect.gen(function* () {
           // Hold a build permit until the watcher's initial build settles.
           yield* buildPermits.take(1);
+          const context = yield* Effect.context();
           let initialBuildSettled = false;
           const settleInitialBuild = () => {
             if (initialBuildSettled) return;
             initialBuildSettled = true;
-            Effect.runFork(buildPermits.release(1));
+            Effect.runForkWith(context)(buildPermits.release(1));
           };
           const watcher = yield* Effect.promise(() => createWatcher(settleInitialBuild)).pipe(
             Effect.onError(() => Effect.sync(settleInitialBuild)),
@@ -444,14 +495,12 @@ const watchResolved =
     );
 
 const ENTRY_PREFIX = "\0virtual:alchemy-entry:";
-// oxlint-disable-next-line no-control-regex
 const ENTRY_REGEX = /^\0virtual:alchemy-entry:/;
 /**
  * Ids the `resolveId` hook looks at: the virtual entry ids themselves, plus
  * bare package specifiers (not starting with `.`, `/` or `\0`) so an
  * unresolvable import in a generated entry fails the build (below).
  */
-// oxlint-disable-next-line no-control-regex
 const ENTRY_OR_BARE_REGEX = /^(?:\0virtual:alchemy-entry:|[^./\0])/;
 
 export const virtualEntryPlugin = Effect.gen(function* () {
@@ -563,6 +612,7 @@ async function builtInPlugins(extra?: BundleExtraOptions): Promise<rolldown.Roll
     extra?.bundleAnalyzer
       ? await bundleAnalyzerPlugin(extra.bundleAnalyzer === true ? {} : extra.bundleAnalyzer)
       : undefined,
+    namespaceImportPlugin(),
     extra?.pure !== false ? purePlugin(extra?.pure ?? {}) : undefined,
     rawPlugin(),
     unreachableChunksPlugin(),
@@ -585,6 +635,7 @@ export function bundleOutputFromFiles(
       files.map((file) => ({
         path: file.path,
         hash: file.hash,
+        ...(file.type ? { type: file.type } : {}),
       })),
     ),
     (hash) => ({ files, hash }),

package/src/Bundle/NamespaceImportPlugin.ts

@@ -0,0 +1,259 @@
+import type { ImportDeclaration, Program } from "@oxc-project/types";
+import picomatch from "picomatch";
+import type * as rolldown from "rolldown";
+
+/**
+ * `rolldown` and `rolldown/parseAst` load `@rolldown/binding-*` at module
+ * scope, so they are imported lazily on first use (#562).
+ */
+const loadRolldown = () => import("rolldown");
+const loadParseAst = () => import("rolldown/parseAst");
+
+/**
+ * Packages whose namespace imports are rewritten by default. Their root
+ * modules re-export every service (`export * as Lambda from "./Lambda/index.ts"`),
+ * and every one of them declares `"sideEffects": false`.
+ */
+export const DEFAULT_NAMESPACE_IMPORT_PACKAGES: ReadonlyArray<string> = [
+  "alchemy",
+  "@alchemy.run/*",
+];
+
+/**
+ * Options for {@link namespaceImportPlugin}.
+ */
+export interface NamespaceImportPluginOptions {
+  /**
+   * Extra package names or globs whose namespace imports are rewritten, in
+   * addition to {@link DEFAULT_NAMESPACE_IMPORT_PACKAGES}. Matched with
+   * picomatch against the package name of the import specifier. Only list
+   * packages that declare `"sideEffects": false`.
+   */
+  readonly packages?: ReadonlyArray<string>;
+}
+
+const SUPPORTED_FILE_RE = /\.(?:m?[jt]sx?|cjs|cts)$/;
+
+/**
+ * Rolldown plugin that rewrites namespace imports of barrel packages into
+ * named imports, so `experimental.lazyBarrel` only compiles the re-exports
+ * a module actually uses.
+ *
+ * ```ts
+ * import * as AWS from "@alchemy.run/aws";
+ * AWS.Lambda.Function;
+ * // becomes
+ * import { Lambda as AWS$Lambda } from "@alchemy.run/aws";
+ * AWS$Lambda.Function;
+ * ```
+ *
+ * Rolldown loads every export of a barrel imported with `import * as ns`,
+ * even when only `ns.X` is read, so without this rewrite one
+ * `import * as AWS from "@alchemy.run/aws"` parses every AWS service.
+ *
+ * A namespace is only rewritten when every reference to its name is a
+ * static member access (`ns.X`, or `ns.X` in a type). Anything else —
+ * passing the namespace around, computed access, a shadowing binding,
+ * JSX — leaves the import untouched.
+ */
+export const namespaceImportPlugin = (
+  options: NamespaceImportPluginOptions = {},
+): rolldown.Plugin => {
+  const isMatch = picomatch([...DEFAULT_NAMESPACE_IMPORT_PACKAGES, ...(options.packages ?? [])]);
+  const matchesSpecifier = (specifier: string) => {
+    const name = packageNameOf(specifier);
+    return name !== null && isMatch(name);
+  };
+
+  return {
+    name: "alchemy:namespace-imports",
+    transform: {
+      filter: { id: SUPPORTED_FILE_RE, code: /import\s*\*\s*as\s/ },
+      async handler(code, id, meta) {
+        const edits = await collectNamespaceImportEdits(code, id, matchesSpecifier);
+        if (edits.length === 0) return null;
+        const s = meta.magicString ?? new (await loadRolldown()).RolldownMagicString(code);
+        for (const edit of edits) s.overwrite(edit.start, edit.end, edit.text);
+        return { code: s };
+      },
+    },
+  };
+};
+
+/** A source replacement over `[start, end)`. */
+export interface NamespaceImportEdit {
+  readonly start: number;
+  readonly end: number;
+  readonly text: string;
+}
+
+/**
+ * Returns the edits that rewrite each eligible namespace import in `code`
+ * (see {@link namespaceImportPlugin}), or an empty array when nothing is
+ * rewritten.
+ */
+export async function collectNamespaceImportEdits(
+  code: string,
+  filename: string,
+  matchesSpecifier: (specifier: string) => boolean,
+): Promise<NamespaceImportEdit[]> {
+  const { parseAst } = await loadParseAst();
+  let program: Program;
+  try {
+    program = parseAst(code, { sourceType: "module", lang: langOf(filename) }, filename);
+  } catch {
+    return [];
+  }
+
+  const candidates = new Map<string, ImportDeclaration>();
+  for (const statement of program.body) {
+    if (statement.type !== "ImportDeclaration") continue;
+    if (statement.importKind === "type" || statement.phase) continue;
+    if (statement.attributes.length > 0) continue;
+    const [specifier, ...rest] = statement.specifiers;
+    if (specifier?.type !== "ImportNamespaceSpecifier" || rest.length > 0) continue;
+    if (!matchesSpecifier(statement.source.value)) continue;
+    // Two imports binding the same name is a syntax error; skip defensively.
+    if (candidates.has(specifier.local.name)) {
+      candidates.delete(specifier.local.name);
+      continue;
+    }
+    candidates.set(specifier.local.name, statement);
+  }
+  if (candidates.size === 0) return [];
+
+  interface Usage {
+    /** Identifier nodes with the namespace's name, wherever they appear. */
+    identifiers: number;
+    /** Rewritable member accesses: `[start, end, member, isType]`. */
+    members: Array<readonly [number, number, string, boolean]>;
+    /** A reference that can't be rewritten (JSX). */
+    blocked: boolean;
+  }
+  const usages = new Map<string, Usage>(
+    [...candidates.keys()].map((name) => [name, { identifiers: 0, members: [], blocked: false }]),
+  );
+
+  // `inType` is set once the walk enters a type: everything below it is
+  // erased by the TypeScript transform, so its members import as `type`.
+  const visit = (node: unknown, inType: boolean): void => {
+    if (Array.isArray(node)) {
+      for (const child of node) visit(child, inType);
+      return;
+    }
+    if (node === null || typeof node !== "object") return;
+    const n = node as { type?: unknown } & Record<string, unknown>;
+    const type = n.type as string;
+    if (type === "Identifier" || type === "JSXIdentifier") {
+      const usage = usages.get(n.name as string);
+      if (usage) {
+        usage.identifiers++;
+        if (type === "JSXIdentifier") usage.blocked = true;
+      }
+      // Fall through: a binding's `typeAnnotation` hangs off its Identifier.
+    } else if (type === "TSImportEqualsDeclaration") {
+      // `import L = AWS.Lambda` aliases a value through a type-shaped name.
+      const usage = usages.get(rootName(n.moduleReference));
+      if (usage) usage.blocked = true;
+    } else if (type === "MemberExpression" || type === "TSQualifiedName") {
+      const [object, property] =
+        type === "MemberExpression" ? [n.object, n.property] : [n.left, n.right];
+      const o = object as { type: string; name?: string };
+      const p = property as { type: string; name?: string };
+      const usage = o.type === "Identifier" ? usages.get(o.name!) : undefined;
+      if (usage && p.type === "Identifier" && n.computed !== true) {
+        usage.members.push([n.start as number, n.end as number, p.name!, inType]);
+      }
+    }
+    const childInType = inType || TYPE_NODES.has(type);
+    for (const key in n) {
+      if (key === "parent" || key === "type" || key === "start" || key === "end") continue;
+      visit(n[key], childInType);
+    }
+  };
+  visit(program.body, false);
+
+  const edits: NamespaceImportEdit[] = [];
+  const taken = new Set<string>();
+  for (const [name, declaration] of candidates) {
+    const usage = usages.get(name)!;
+    // One identifier is the import's own binding; every other one must be
+    // the object of a rewritable member access.
+    if (usage.blocked || usage.members.length === 0) continue;
+    if (usage.identifiers !== usage.members.length + 1) continue;
+
+    const aliases = new Map<string, { alias: string; value: boolean }>();
+    for (const [, , member, isType] of usage.members) {
+      const existing = aliases.get(member);
+      if (existing) {
+        existing.value ||= !isType;
+        continue;
+      }
+      const alias = uniqueAlias(code, taken, `${name}$${member}`);
+      taken.add(alias);
+      aliases.set(member, { alias, value: !isType });
+    }
+    const specifiers = [...aliases]
+      .map(([member, { alias, value }]) => `${value ? "" : "type "}${member} as ${alias}`)
+      .join(", ");
+    const source = code.slice(declaration.source.start, declaration.source.end);
+    edits.push({
+      start: declaration.start,
+      end: declaration.end,
+      text: `import { ${specifiers} } from ${source};`,
+    });
+    for (const [start, end, member] of usage.members) {
+      edits.push({ start, end, text: aliases.get(member)!.alias });
+    }
+  }
+  return edits;
+}
+
+/**
+ * Nodes whose descendants are all types. `typeof ns.X` is a type query over
+ * a value, which a `type` import still satisfies.
+ */
+const TYPE_NODES = new Set([
+  "TSTypeAnnotation",
+  "TSTypeReference",
+  "TSTypeQuery",
+  "TSInterfaceDeclaration",
+  "TSInterfaceHeritage",
+  "TSClassImplements",
+  "TSTypeAliasDeclaration",
+  "TSTypeParameterInstantiation",
+  "TSTypeParameterDeclaration",
+]);
+
+/** The leftmost identifier of `a.b.c` (or `a`), or `""`. */
+const rootName = (node: unknown): string => {
+  let n = node as { type?: string; name?: string; left?: unknown; object?: unknown } | null;
+  while (n && (n.type === "TSQualifiedName" || n.type === "MemberExpression")) {
+    n = (n.left ?? n.object) as typeof n;
+  }
+  return n?.type === "Identifier" ? n.name! : "";
+};
+
+/** The package name of a bare import specifier, or `null` for relative/absolute ones. */
+const packageNameOf = (specifier: string): string | null => {
+  if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.includes(":")) {
+    return null;
+  }
+  const parts = specifier.split("/");
+  return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0]!;
+};
+
+const langOf = (filename: string): "js" | "jsx" | "ts" | "tsx" => {
+  const clean = filename.replace(/[?#].*$/, "");
+  if (clean.endsWith(".tsx")) return "tsx";
+  if (clean.endsWith(".jsx")) return "jsx";
+  // TS is a superset of JS for parsing published `.js` files.
+  return "ts";
+};
+
+/** `base`, suffixed until it occurs nowhere in `code` and isn't already `taken`. */
+const uniqueAlias = (code: string, taken: ReadonlySet<string>, base: string): string => {
+  let alias = base;
+  while (code.includes(alias) || taken.has(alias)) alias += "$";
+  return alias;
+};

package/src/Bundle/index.ts

@@ -1,6 +1,7 @@
 export * from "./Bundle.ts";
 export * from "./BundleAnalyzerPlugin.ts";
 export * from "./InstalledPackages.ts";
+export * from "./NamespaceImportPlugin.ts";
 export * from "./PurePlugin.ts";
 export * from "./RawPlugin.ts";
 export * from "./TempRoot.ts";

package/src/Cli/Format.ts

@@ -1,4 +1,5 @@
-import { ansiFg, theme } from "./CliKit/index.ts";
+import { ansiFg } from "../Util/Terminal.ts";
+import { theme } from "../Util/Theme.ts";
 
 /** `450ms` under a second, `1.2s` at or above — shared by every renderer. */
 export const formatElapsed = (ms: number): string =>