alchemy 2.0.0-beta.64 → 2.0.0-beta.65

package/src/AWS/SageMaker/ComputeQuota.ts

@@ -0,0 +1,426 @@
+import * as sagemaker from "@distilled.cloud/aws/sagemaker";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+import * as EffectStream from "effect/Stream";
+import { Unowned } from "../../AdoptPolicy.ts";
+import { isResolved } from "../../Diff.ts";
+import { createPhysicalName } from "../../PhysicalName.ts";
+import * as Provider from "../../Provider.ts";
+import { Resource } from "../../Resource.ts";
+import {
+  createInternalTags,
+  diffTags,
+  hasAlchemyTags,
+  type Tags,
+} from "../../Tags.ts";
+import type { Providers } from "../Providers.ts";
+
+export interface ComputeQuotaProps {
+  /**
+   * Name of the compute allocation. Maximum 63 characters, alphanumeric and
+   * hyphens.
+   * @default ${app}-${stage}-${id}
+   */
+  name?: string;
+  /**
+   * ARN of the EKS-orchestrated HyperPod cluster the allocation applies to.
+   * Changing the cluster replaces the allocation.
+   */
+  clusterArn: string;
+  /**
+   * The team the quota is allocated to (its name maps to a Kubernetes
+   * namespace `hyperpod-ns-<team-name>`) and its fair-share weight.
+   */
+  computeQuotaTarget: sagemaker.ComputeQuotaTarget;
+  /**
+   * The allocation itself: instance-type quotas, the resource-sharing
+   * strategy for idle compute, and whether the team's own tasks can preempt
+   * each other.
+   */
+  computeQuotaConfig?: sagemaker.ComputeQuotaConfig;
+  /**
+   * Whether the quota is enforced.
+   * @default "Enabled"
+   */
+  activationState?: sagemaker.ActivationState;
+  /**
+   * A description of the compute allocation.
+   */
+  description?: string;
+  /**
+   * Tags to associate with the compute allocation. Merged with internal
+   * Alchemy tags.
+   */
+  tags?: Record<string, string>;
+}
+
+export interface ComputeQuota extends Resource<
+  "AWS.SageMaker.ComputeQuota",
+  ComputeQuotaProps,
+  {
+    /**
+     * The compute allocation's ID.
+     */
+    computeQuotaId: string;
+    /**
+     * ARN of the compute allocation.
+     */
+    computeQuotaArn: string;
+    /**
+     * The compute allocation's name.
+     */
+    name: string;
+    /**
+     * ARN of the HyperPod cluster the allocation applies to.
+     */
+    clusterArn: string;
+    /**
+     * The allocation's current version (incremented on every update).
+     */
+    computeQuotaVersion: number;
+    /**
+     * The team the quota is allocated to. Task governance materializes the
+     * `hyperpod-ns-<teamName>` namespace and its Kueue LocalQueue from it.
+     */
+    teamName: string;
+  },
+  never,
+  Providers
+> {}
+
+/**
+ * A SageMaker HyperPod compute allocation (task governance) — reserves
+ * instance capacity on an EKS-orchestrated HyperPod cluster for a team,
+ * with fair-share weights and borrow/lend rules for idle compute.
+ * @resource
+ * @section Creating Compute Allocations
+ * @example Team Quota with Borrowing
+ * ```typescript
+ * import * as AWS from "alchemy/AWS";
+ *
+ * const quota = yield* AWS.SageMaker.ComputeQuota("ResearchQuota", {
+ *   clusterArn: hyperpod.clusterArn,
+ *   computeQuotaTarget: { TeamName: "research", FairShareWeight: 10 },
+ *   computeQuotaConfig: {
+ *     ComputeQuotaResources: [{ InstanceType: "ml.g5.xlarge", Count: 2 }],
+ *     ResourceSharingConfig: { Strategy: "Lend", BorrowLimit: 50 },
+ *   },
+ * });
+ * ```
+ */
+export const ComputeQuota = Resource<ComputeQuota>(
+  "AWS.SageMaker.ComputeQuota",
+);
+
+const createQuotaName = (id: string, props: { name?: string | undefined }) =>
+  props.name
+    ? Effect.succeed(props.name)
+    : createPhysicalName({ id, maxLength: 63 });
+
+const describeQuotaOrUndefined = (quotaId: string) =>
+  sagemaker
+    .describeComputeQuota({ ComputeQuotaId: quotaId })
+    .pipe(Effect.catchTag("ResourceNotFound", () => Effect.succeed(undefined)));
+
+/**
+ * Look a compute allocation up by exact name — used when state was lost
+ * (read without output) or a create raced.
+ */
+const findQuotaByName = Effect.fn(function* (name: string) {
+  const summaries = yield* sagemaker.listComputeQuotas
+    .pages({ NameContains: name })
+    .pipe(
+      EffectStream.runCollect,
+      Effect.map((chunk) =>
+        Array.from(chunk).flatMap((page) => page.ComputeQuotaSummaries ?? []),
+      ),
+    );
+  return summaries.find((s) => s.Name === name && s.Status !== "Deleted");
+});
+
+const fetchQuotaTags = Effect.fn(function* (arn: string) {
+  const response = yield* sagemaker
+    .listTags({ ResourceArn: arn })
+    .pipe(
+      Effect.catchTag("AccessDeniedException", () => Effect.succeed(undefined)),
+    );
+  return Object.fromEntries(
+    (response?.Tags ?? []).flatMap((tag) =>
+      tag.Key !== undefined ? [[tag.Key, tag.Value ?? ""]] : [],
+    ),
+  );
+});
+
+const toAttrs = (
+  described: sagemaker.DescribeComputeQuotaResponse,
+): ComputeQuota["Attributes"] => ({
+  computeQuotaId: described.ComputeQuotaId,
+  computeQuotaArn: described.ComputeQuotaArn,
+  name: described.Name,
+  clusterArn: described.ClusterArn ?? "",
+  computeQuotaVersion: described.ComputeQuotaVersion,
+  teamName: described.ComputeQuotaTarget?.TeamName ?? "",
+});
+
+/**
+ * The compute allocation is still transitioning toward the awaited state —
+ * retried by the bounded wait schedule.
+ */
+class ComputeQuotaNotReady extends Data.TaggedError("ComputeQuotaNotReady")<{
+  readonly quotaId: string;
+  readonly status: string | undefined;
+}> {}
+
+/**
+ * The compute allocation converged to a terminal failed status.
+ */
+export class ComputeQuotaFailed extends Data.TaggedError("ComputeQuotaFailed")<{
+  readonly quotaId: string;
+  readonly status: string | undefined;
+  readonly message: string | undefined;
+}> {}
+
+const FAILED_STATUSES: string[] = [
+  "CreateFailed",
+  "CreateRollbackFailed",
+  "UpdateFailed",
+  "UpdateRollbackFailed",
+  "DeleteFailed",
+  "DeleteRollbackFailed",
+];
+
+// Explicitly-typed retry wrapper — an inline `Effect.retry` in provider
+// lifecycle code leaks `Retry.Return`'s conditional type into declaration
+// emit and widens the provider layer to `unknown` for every consumer of
+// `AWS.providers()`.
+const retryWhileNotReady = <A, E extends { readonly _tag: string }, R>(
+  self: Effect.Effect<A, E, R>,
+): Effect.Effect<A, E, R> =>
+  Effect.retry(self, {
+    while: (e) => e._tag === "ComputeQuotaNotReady",
+    schedule: Schedule.max([Schedule.spaced("5 seconds"), Schedule.recurs(60)]),
+  });
+
+const waitForQuota = (quotaId: string, target: "Ready" | "Gone") =>
+  retryWhileNotReady(
+    Effect.gen(function* () {
+      const described = yield* describeQuotaOrUndefined(quotaId);
+      if (target === "Gone") {
+        if (described === undefined || described.Status === "Deleted") return;
+        if (FAILED_STATUSES.includes(described.Status)) {
+          return yield* Effect.fail(
+            new ComputeQuotaFailed({
+              quotaId,
+              status: described.Status,
+              message: described.FailureReason,
+            }),
+          );
+        }
+        return yield* Effect.fail(
+          new ComputeQuotaNotReady({ quotaId, status: described.Status }),
+        );
+      }
+      if (described?.Status === "Created" || described?.Status === "Updated") {
+        return;
+      }
+      if (
+        described !== undefined &&
+        FAILED_STATUSES.includes(described.Status)
+      ) {
+        return yield* Effect.fail(
+          new ComputeQuotaFailed({
+            quotaId,
+            status: described.Status,
+            message: described.FailureReason,
+          }),
+        );
+      }
+      return yield* Effect.fail(
+        new ComputeQuotaNotReady({ quotaId, status: described?.Status }),
+      );
+    }),
+  );
+
+export const ComputeQuotaProvider = () =>
+  Provider.effect(
+    ComputeQuota,
+    Effect.gen(function* () {
+      return {
+        stables: ["computeQuotaId", "computeQuotaArn", "name", "clusterArn"],
+        list: () =>
+          Effect.gen(function* () {
+            const summaries = yield* sagemaker.listComputeQuotas.pages({}).pipe(
+              EffectStream.runCollect,
+              Effect.map((chunk) =>
+                Array.from(chunk).flatMap(
+                  (page) => page.ComputeQuotaSummaries ?? [],
+                ),
+              ),
+            );
+            return summaries.flatMap((s) =>
+              s.ComputeQuotaId !== undefined && s.Status !== "Deleted"
+                ? [
+                    {
+                      computeQuotaId: s.ComputeQuotaId,
+                      computeQuotaArn: s.ComputeQuotaArn ?? "",
+                      name: s.Name ?? "",
+                      clusterArn: s.ClusterArn ?? "",
+                      computeQuotaVersion: s.ComputeQuotaVersion ?? 1,
+                      teamName: s.ComputeQuotaTarget?.TeamName ?? "",
+                    },
+                  ]
+                : [],
+            );
+          }),
+        read: Effect.fn(function* ({ id, olds, output }) {
+          const quotaId =
+            output?.computeQuotaId ??
+            (yield* findQuotaByName(yield* createQuotaName(id, olds ?? {})))
+              ?.ComputeQuotaId;
+          if (quotaId === undefined) return undefined;
+          const described = yield* describeQuotaOrUndefined(quotaId);
+          if (
+            !described ||
+            described.Status === "Deleting" ||
+            described.Status === "Deleted"
+          ) {
+            return undefined;
+          }
+          const attrs = toAttrs(described);
+          const tags = yield* fetchQuotaTags(attrs.computeQuotaArn);
+          return (yield* hasAlchemyTags(id, tags as Tags))
+            ? attrs
+            : Unowned(attrs);
+        }),
+        diff: Effect.fn(function* ({ id, news, olds }) {
+          if (!isResolved(news)) return;
+          if (olds === undefined) return;
+          const oldName = yield* createQuotaName(id, olds);
+          const newName = yield* createQuotaName(id, news);
+          // The name and target cluster are fixed at creation.
+          if (oldName !== newName || olds.clusterArn !== news.clusterArn) {
+            return { action: "replace" } as const;
+          }
+        }),
+        reconcile: Effect.fn(function* ({ id, news, output, session }) {
+          if (!news) {
+            return yield* Effect.fail(
+              new Error("SageMaker ComputeQuota requires props"),
+            );
+          }
+          const name = yield* createQuotaName(id, news);
+          const internalTags = yield* createInternalTags(id);
+          const desiredTags = { ...internalTags, ...news.tags };
+
+          // Observe — by cached id first, then by name (lost state or race).
+          let quotaId = output?.computeQuotaId;
+          let described =
+            quotaId !== undefined
+              ? yield* describeQuotaOrUndefined(quotaId)
+              : undefined;
+          if (described === undefined) {
+            const found = yield* findQuotaByName(name);
+            described =
+              found?.ComputeQuotaId !== undefined
+                ? yield* describeQuotaOrUndefined(found.ComputeQuotaId)
+                : undefined;
+          }
+
+          // Ensure — create if missing; a Conflict means a concurrent
+          // create won the race, so re-observe by name.
+          if (described === undefined) {
+            const created = yield* sagemaker
+              .createComputeQuota({
+                Name: name,
+                ClusterArn: news.clusterArn,
+                ComputeQuotaConfig: news.computeQuotaConfig,
+                ComputeQuotaTarget: news.computeQuotaTarget,
+                ActivationState: news.activationState,
+                Description: news.description,
+                Tags: Object.entries(desiredTags).map(([Key, Value]) => ({
+                  Key,
+                  Value,
+                })),
+              })
+              .pipe(
+                Effect.catchTag("ConflictException", () =>
+                  Effect.succeed(undefined),
+                ),
+              );
+            quotaId =
+              created?.ComputeQuotaId ??
+              (yield* findQuotaByName(name))?.ComputeQuotaId;
+            if (quotaId === undefined) {
+              return yield* Effect.fail(
+                new Error(`failed to create compute quota ${name}`),
+              );
+            }
+            yield* session.note(`Creating compute quota ${name}...`);
+            yield* waitForQuota(quotaId, "Ready");
+          } else {
+            quotaId = described.ComputeQuotaId;
+            // Wait out any in-flight transition before diffing.
+            yield* waitForQuota(quotaId, "Ready");
+            described = yield* describeQuotaOrUndefined(quotaId);
+            // Sync — diff observed allocation against desired.
+            if (
+              described !== undefined &&
+              (JSON.stringify(described.ComputeQuotaConfig) !==
+                JSON.stringify(news.computeQuotaConfig) ||
+                JSON.stringify(described.ComputeQuotaTarget) !==
+                  JSON.stringify(news.computeQuotaTarget) ||
+                (news.activationState !== undefined &&
+                  described.ActivationState !== news.activationState) ||
+                (described.Description ?? undefined) !==
+                  (news.description ?? undefined))
+            ) {
+              yield* sagemaker.updateComputeQuota({
+                ComputeQuotaId: quotaId,
+                TargetVersion: described.ComputeQuotaVersion,
+                ComputeQuotaConfig: news.computeQuotaConfig,
+                ComputeQuotaTarget: news.computeQuotaTarget,
+                ActivationState: news.activationState,
+                Description: news.description,
+              });
+              yield* session.note(`Updating compute quota ${name}...`);
+              yield* waitForQuota(quotaId, "Ready");
+            }
+          }
+
+          described = yield* describeQuotaOrUndefined(quotaId);
+          if (described === undefined) {
+            return yield* Effect.fail(
+              new Error(`failed to read reconciled compute quota ${name}`),
+            );
+          }
+          const attrs = toAttrs(described);
+
+          // Sync tags — diff against OBSERVED cloud tags.
+          const currentTags = yield* fetchQuotaTags(attrs.computeQuotaArn);
+          const { removed, upsert } = diffTags(currentTags, desiredTags);
+          if (removed.length > 0) {
+            yield* sagemaker.deleteTags({
+              ResourceArn: attrs.computeQuotaArn,
+              TagKeys: removed,
+            });
+          }
+          if (upsert.length > 0) {
+            yield* sagemaker.addTags({
+              ResourceArn: attrs.computeQuotaArn,
+              Tags: upsert.map(({ Key, Value }) => ({ Key, Value })),
+            });
+          }
+
+          yield* session.note(attrs.computeQuotaArn);
+          return attrs;
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          yield* sagemaker
+            .deleteComputeQuota({ ComputeQuotaId: output.computeQuotaId })
+            .pipe(Effect.catchTag("ResourceNotFound", () => Effect.void));
+          yield* waitForQuota(output.computeQuotaId, "Gone");
+        }),
+      };
+    }),
+  );

package/src/AWS/SageMaker/index.ts

@@ -1,5 +1,8 @@
 export * from "./BatchGetRecord.ts";
 export * from "./BatchGetRecordHttp.ts";
+export * from "./Cluster.ts";
+export * from "./ClusterSchedulerConfig.ts";
+export * from "./ComputeQuota.ts";
 export * from "./BatchWriteRecord.ts";
 export * from "./BatchWriteRecordHttp.ts";
 export * from "./DeleteRecord.ts";

package/src/Bundle/PurePlugin.ts

@@ -62,10 +62,11 @@ export interface PurePluginOptions {
    * too. This makes the user's own source tree-shakeable without any
    * configuration.
    *
-   * The package's `sideEffects` field is NOT consulted for this gate —
-   * if your entry's package has init-time side effects you wish to
-   * preserve, declare them in `package.json` (`"sideEffects": ["./foo.ts"]`)
-   * or set this option to `false`.
+   * Only calls whose result is used (variable initializers, exports) are
+   * annotated in the auto-detected package. Top-level calls whose result
+   * is discarded (e.g. Hono/Express-style `app.get("/", handler)` route
+   * registrations) are preserved unless the package explicitly declares
+   * `"sideEffects": false` (or `[]`) in its `package.json`.
    *
    * @default true
    */
@@ -139,19 +140,32 @@ export const purePlugin = (
         if (name === null || !isMatch(name)) return null;
 
         // Only override `moduleSideEffects` when the owning package
-        // explicitly opts in via `sideEffects: false` / `[]`. Pure
-        // annotations themselves are always safe to add (they only mean
-        // "if the result is unused, the call may be dropped"), but
-        // marking arbitrary modules side-effect-free could erase
-        // intentional registrations / mutations the author made at the
-        // top level of files in packages that did not declare so.
+        // explicitly opts in via `sideEffects: false` / `[]`. Marking
+        // arbitrary modules side-effect-free could erase intentional
+        // registrations / mutations the author made at the top level of
+        // files in packages that did not declare so.
+        const isEntry = entryPaths.has(cleanId);
+        const sideEffectFreePkg = isSideEffectFree(info?.sideEffects);
         const markSideEffectFree =
-          markSideEffectFreeOpt &&
-          !entryPaths.has(cleanId) &&
-          isSideEffectFree(info?.sideEffects);
+          markSideEffectFreeOpt && !isEntry && sideEffectFreePkg;
 
         const anchors = collectPureAnchorsCached(code, cleanId);
-        if (anchors === null) {
+        // Annotating a call whose result is BOUND (variable initializer,
+        // export) only lets the minifier drop it when the binding itself
+        // is unused — safe everywhere. Annotating a call whose result is
+        // DISCARDED (a bare expression statement like `app.get("/", h)`)
+        // is an instruction to delete the call under minification, so it
+        // is only applied when the owning package explicitly declared
+        // itself side-effect free, and never to entry modules, whose side
+        // effects we always preserve (#949).
+        const annotateDiscarded = !isEntry && sideEffectFreePkg;
+        const positions =
+          anchors === null
+            ? []
+            : annotateDiscarded
+              ? [...anchors.bound, ...anchors.discarded]
+              : anchors.bound;
+        if (positions.length === 0) {
           // Metadata-only result: omitting `code` tells rolldown the
           // source was NOT transformed, so no sourcemap is expected and
           // no SOURCEMAP_BROKEN warning is emitted.
@@ -162,7 +176,7 @@ export const purePlugin = (
         // rolldown's native side (computed on a background thread). The
         // fallback covers direct hook invocations (unit tests).
         const s = meta.magicString ?? new RolldownMagicString(code);
-        for (const anchor of anchors) s.appendLeft(anchor, PURE_COMMENT);
+        for (const anchor of positions) s.appendLeft(anchor, PURE_COMMENT);
         return {
           code: s,
           moduleSideEffects: markSideEffectFree ? false : null,
@@ -324,14 +338,14 @@ export function packageNameFromId(id: string): string | null {
  */
 const anchorsCache = new Map<
   string,
-  { readonly code: string; readonly anchors: number[] | null }
+  { readonly code: string; readonly anchors: PureAnchors | null }
 >();
 const ANCHORS_CACHE_MAX = 10_000;
 
 const collectPureAnchorsCached = (
   code: string,
   filename: string,
-): number[] | null => {
+): PureAnchors | null => {
   const cached = anchorsCache.get(filename);
   if (cached !== undefined && cached.code === code) {
     return cached.anchors;
@@ -344,16 +358,38 @@ const collectPureAnchorsCached = (
   return anchors;
 };
 
+/**
+ * Offsets at which `/*#__PURE__*\/` may be inserted, split by whether the
+ * call's result is consumed.
+ */
+export interface PureAnchors {
+  /**
+   * Calls whose result is bound — variable initializers, exports,
+   * assignment right-hand sides. Annotating these only lets the minifier
+   * drop the call when the binding itself is unused, so it is safe for
+   * any module.
+   */
+  readonly bound: number[];
+  /**
+   * Top-level calls whose result is discarded (bare expression
+   * statements such as `app.get("/", handler)`). Annotating these tells
+   * the minifier the whole statement is deletable, so they are only safe
+   * in packages that explicitly declare `sideEffects: false` / `[]`.
+   */
+  readonly discarded: number[];
+}
+
 /**
  * Parses `code` and returns the offsets at which `/*#__PURE__*\/` must be
  * inserted — before every top-level `CallExpression` callee / `new`
- * keyword. Returns `null` if the file does not need to be modified
- * (parse failure or no annotations needed).
+ * keyword — classified by whether the call result is bound or discarded.
+ * Returns `null` if the file does not need to be modified (parse failure
+ * or no annotations needed).
  */
 export function collectPureAnchors(
   code: string,
   filename: string,
-): number[] | null {
+): PureAnchors | null {
   let program: Program;
   try {
     // Use TS lang so the parser tolerates TS syntax (`as`, `satisfies`,
@@ -364,51 +400,66 @@ export function collectPureAnchors(
     return null;
   }
 
-  const anchors: number[] = [];
+  const bound: number[] = [];
+  const discarded: number[] = [];
 
-  const visitCall = (call: CallExpression | NewExpression) => {
+  const visitCall = (
+    call: CallExpression | NewExpression,
+    isDiscarded: boolean,
+  ) => {
     if (isIIFE(call)) return;
     // For `new X()`, anchor BEFORE the `new` keyword so we get
     // `/*#__PURE__*/ new X()` (matches babel-plugin-annotate-pure-calls).
     const anchor =
       call.type === "NewExpression" ? call.start : call.callee.start;
     if (alreadyAnnotated(code, anchor)) return;
-    anchors.push(anchor);
+    (isDiscarded ? discarded : bound).push(anchor);
   };
 
-  const visitExpression = (expr: Expression | null | undefined) => {
+  const visitExpression = (
+    expr: Expression | null | undefined,
+    isDiscarded: boolean,
+  ) => {
     if (!expr) return;
     switch (expr.type) {
       case "CallExpression":
       case "NewExpression":
-        visitCall(expr);
+        visitCall(expr, isDiscarded);
         return;
-      case "SequenceExpression":
-        for (const inner of expr.expressions) visitExpression(inner);
+      case "SequenceExpression": {
+        // All but the last expression's results are always discarded;
+        // the last one takes the surrounding context.
+        const exprs = expr.expressions;
+        for (let i = 0; i < exprs.length; i++) {
+          visitExpression(exprs[i], i < exprs.length - 1 ? true : isDiscarded);
+        }
         return;
+      }
       case "ParenthesizedExpression":
-        visitExpression(expr.expression);
+        visitExpression(expr.expression, isDiscarded);
         return;
       case "LogicalExpression":
-        visitExpression(expr.left);
-        visitExpression(expr.right);
+        visitExpression(expr.left, isDiscarded);
+        visitExpression(expr.right, isDiscarded);
         return;
       case "ConditionalExpression":
-        visitExpression(expr.consequent);
-        visitExpression(expr.alternate);
+        visitExpression(expr.consequent, isDiscarded);
+        visitExpression(expr.alternate, isDiscarded);
         return;
       case "AssignmentExpression":
-        visitExpression(expr.right);
+        // The right-hand side's result is stored in the target, so it is
+        // bound even when the assignment appears in statement position.
+        visitExpression(expr.right, false);
         return;
       case "TSAsExpression":
       case "TSSatisfiesExpression":
       case "TSNonNullExpression":
       case "TSTypeAssertion":
-        visitExpression(expr.expression);
+        visitExpression(expr.expression, isDiscarded);
         return;
       case "ChainExpression": {
         const inner = expr.expression;
-        if (inner.type === "CallExpression") visitCall(inner);
+        if (inner.type === "CallExpression") visitCall(inner, isDiscarded);
         return;
       }
       default:
@@ -419,11 +470,11 @@ export function collectPureAnchors(
   const visitTopLevel = (node: Statement) => {
     switch (node.type) {
       case "ExpressionStatement":
-        visitExpression((node as ExpressionStatement).expression);
+        visitExpression((node as ExpressionStatement).expression, true);
         return;
       case "VariableDeclaration":
         for (const decl of (node as VariableDeclaration).declarations) {
-          visitExpression(decl.init);
+          visitExpression(decl.init, false);
         }
         return;
       case "ExportNamedDeclaration": {
@@ -439,7 +490,7 @@ export function collectPureAnchors(
           decl.type !== "ClassDeclaration" &&
           decl.type !== "TSInterfaceDeclaration"
         ) {
-          visitExpression(decl as Expression);
+          visitExpression(decl as Expression, false);
         }
         return;
       }
@@ -455,7 +506,9 @@ export function collectPureAnchors(
     visitTopLevel(node as Statement);
   }
 
-  return anchors.length === 0 ? null : anchors;
+  return bound.length === 0 && discarded.length === 0
+    ? null
+    : { bound, discarded };
 }
 
 function isIIFE(node: CallExpression | NewExpression): boolean {