@ttsc/playground 0.19.3 → 0.20.0

package/src/react/PlaygroundShell.tsx

@@ -12,6 +12,7 @@ import { installPlaygroundDependencies } from "../npm/installPlaygroundDependenc
 import type { ICompilerService } from "../structures/ICompilerService";
 import type { IConsoleMessage } from "../structures/IConsoleMessage";
 import type { IPlaygroundDependencyProgress } from "../structures/IPlaygroundDependencyProgress";
+import type { IPlaygroundInstalledDependency } from "../structures/IPlaygroundInstalledDependency";
 import type { IPlaygroundShellProps } from "../structures/IPlaygroundShellProps";
 import type { ITransformOptions } from "../structures/ITransformOptions";
 import { ConsoleViewer } from "./ConsoleViewer";
@@ -86,20 +87,14 @@ export function PlaygroundShell({
   const dependencyProgressTimer = useRef<number | null>(null);
   const dependencyInstallChain = useRef<Promise<void>>(Promise.resolve());
   const dependencyAbort = useRef<AbortController | null>(null);
-  // Mirror `preinstalledPackages` into a ref so the worker-teardown
-  // effect can read the current value without taking the prop as a
-  // dep — listing the array prop in deps would tear down the worker on
-  // every parent re-render that produces a fresh array reference.
-  const preinstalledPackagesRef =
-    useRef<readonly string[]>(preinstalledPackages);
-  // The ref tracks names the wasm MemFS already has — preinstalled at boot
-  // (via `preinstalledPackages`) plus everything `installPlaygroundDependencies`
-  // has added across the session. A useEffect below merges fresh
-  // preinstalledPackages prop values into the ref so a parent that swaps
-  // the prop later does not race a now-stale Set.
-  const installedDependencyNames = useRef<Set<string>>(
-    new Set<string>(preinstalledPackages),
-  );
+  // Exact mounted identities and active requests. A name-only set cannot
+  // validate a later transitive range or distinguish an npm alias target.
+  const installedDependencies = useRef<
+    Map<string, IPlaygroundInstalledDependency>
+  >(new Map());
+  // Direct source roots selecting the mounted graph. Removing one requires a
+  // full solve and worker replacement so obsolete package files cannot survive.
+  const dependencyRoots = useRef<Set<string>>(new Set());
   // Accumulated runtime-file map produced by every successful
   // installPlaygroundDependencies call. Threaded through to executeBundle so
   // the in-page Execute sandbox's require can resolve any npm package the
@@ -145,17 +140,6 @@ export function PlaygroundShell({
     setSource(next);
   }, []);
 
-  // ── Sync installedDependencyNames + preinstalledPackagesRef on prop change ──
-  // The refs capture the initial value on mount; without this effect a
-  // parent that swaps `preinstalledPackages` later would race a stale
-  // Set against the fresh prop used in `ignoredPackages` below.
-  useEffect(() => {
-    preinstalledPackagesRef.current = preinstalledPackages;
-    for (const name of preinstalledPackages) {
-      installedDependencyNames.current.add(name);
-    }
-  }, [preinstalledPackages]);
-
   // ── Decode source from URL on mount ──
   useEffect(() => {
     const params = new URLSearchParams(window.location.search);
@@ -199,10 +183,11 @@ export function PlaygroundShell({
           input,
           preinstalledPackages,
         );
-        const firstPassMissing = firstPassPackageNames.filter(
-          (name) => !installedDependencyNames.current.has(name),
-        );
-        if (firstPassMissing.length === 0) return null;
+        if (
+          dependencyRootDelta(firstPassPackageNames, dependencyRoots.current)
+            .changed === false
+        )
+          return null;
 
         await wait(DEPENDENCY_INSTALL_QUIET_MS);
         if (sourceVersion.current !== version) return null;
@@ -211,28 +196,44 @@ export function PlaygroundShell({
           latestSource.current,
           preinstalledPackages,
         );
-        const missing = packageNames.filter(
-          (name) => !installedDependencyNames.current.has(name),
+        const delta = dependencyRootDelta(
+          packageNames,
+          dependencyRoots.current,
         );
-        if (missing.length === 0) return null;
+        if (!delta.changed) return null;
+        const replacing = delta.removed.length !== 0;
+        const requested = replacing ? packageNames : delta.added;
 
         if (dependencyProgressTimer.current !== null) {
           window.clearTimeout(dependencyProgressTimer.current);
           dependencyProgressTimer.current = null;
         }
-        setDependencyPackageNames(missing);
+        setDependencyPackageNames(requested);
         const abort = new AbortController();
         dependencyAbort.current = abort;
+        let workerMutated = false;
         try {
-          const installed = await installPlaygroundDependencies(missing, {
-            installedPackages: installedDependencyNames.current,
+          const installed = await installPlaygroundDependencies(requested, {
+            installedDependencies: replacing
+              ? []
+              : installedDependencies.current.values(),
             ignoredPackages: preinstalledPackages,
             signal: abort.signal,
             onProgress: setDependencyProgress,
           });
           if (sourceVersion.current !== version) return null;
+
+          if (replacing) {
+            workerMutated = true;
+            await client.reset();
+            installedDependencies.current = new Map();
+            dependencyRoots.current = new Set();
+            runtimeDependencyFiles.current = {};
+            setEditorExtraLibs({});
+          }
           if (Object.keys(installed.compilerFiles).length > 0) {
             const service = await createCompilerService();
+            workerMutated = true;
             await service.installDependencies({
               files: installed.compilerFiles,
               packages: installed.packages.map(({ name, version }) => ({
@@ -241,21 +242,23 @@ export function PlaygroundShell({
               })),
             });
           }
-          for (const pkg of installed.packages) {
-            installedDependencyNames.current.add(pkg.name);
-          }
-          if (Object.keys(installed.editorLibs).length > 0) {
-            setEditorExtraLibs((prev) => ({
-              ...prev,
-              ...installed.editorLibs,
-            }));
-          }
-          // Accumulate runtime files so the in-page Execute sandbox can
-          // resolve every package the user installed across this session.
-          runtimeDependencyFiles.current = {
-            ...runtimeDependencyFiles.current,
-            ...installed.runtimeFiles,
-          };
+          installedDependencies.current = new Map(
+            installed.resolvedDependencies.map(
+              (dependency) => [dependency.name, dependency] as const,
+            ),
+          );
+          dependencyRoots.current = new Set(packageNames);
+          setEditorExtraLibs((previous) =>
+            replacing
+              ? installed.editorLibs
+              : { ...previous, ...installed.editorLibs },
+          );
+          runtimeDependencyFiles.current = replacing
+            ? installed.runtimeFiles
+            : {
+                ...runtimeDependencyFiles.current,
+                ...installed.runtimeFiles,
+              };
           dependencyProgressTimer.current = window.setTimeout(() => {
             setDependencyProgress(null);
             setDependencyPackageNames([]);
@@ -263,6 +266,13 @@ export function PlaygroundShell({
           }, 350);
           return null;
         } catch (error) {
+          if (workerMutated) {
+            await client.reset();
+            installedDependencies.current = new Map();
+            dependencyRoots.current = new Set();
+            runtimeDependencyFiles.current = {};
+            setEditorExtraLibs({});
+          }
           if (isAbortError(error)) {
             setDependencyProgress(null);
             setDependencyPackageNames([]);
@@ -270,9 +280,9 @@ export function PlaygroundShell({
           }
           setDependencyProgress({
             phase: "error",
-            packageName: missing[0],
+            packageName: requested[0],
             completed: 0,
-            total: missing.length,
+            total: requested.length,
             message: describeUnknownError(error),
           });
           dependencyProgressTimer.current = window.setTimeout(() => {
@@ -288,7 +298,7 @@ export function PlaygroundShell({
       dependencyInstallChain.current = task.then(() => {});
       return task;
     },
-    [createCompilerService, preinstalledPackages],
+    [client, createCompilerService, preinstalledPackages],
   );
 
   // ── Run compile when source / options change ──
@@ -412,28 +422,18 @@ export function PlaygroundShell({
   // from the playground leaks one Worker per mount; a workerUrl swap
   // leaks the previous Worker forever.
   //
-  // Reset the dependency-tracking refs too. They named packages that
-  // existed in the previous worker's MemFS; the fresh worker boots with
-  // only `preinstalledPackages` mounted, so carrying the old names
-  // would make installDependenciesForSource skip the install (because
-  // `installedDependencyNames.current.has(name)` is still true) and
-  // the next compile would fail with `Cannot find module`.
+  // Reset the dependency graph too. Its exact versions, requests, roots, and
+  // runtime files describe only the worker generation that is being closed.
   //
-  // The effect depends on `[client]` ONLY — listing the array prop
-  // `preinstalledPackages` in deps would tear down the worker on every
-  // parent re-render that produces a fresh array reference. We read the
-  // current value through `preinstalledPackagesRef`, which the sync
-  // effect above keeps up to date.
-  useEffect(
-    () => () => {
+  useEffect(() => {
+    setEditorExtraLibs({});
+    return () => {
       void client.reset();
-      installedDependencyNames.current = new Set<string>(
-        preinstalledPackagesRef.current,
-      );
+      installedDependencies.current = new Map();
+      dependencyRoots.current = new Set();
       runtimeDependencyFiles.current = {};
-    },
-    [client],
-  );
+    };
+  }, [client]);
 
   const onPickExample = useCallback(
     (id: string) => {
@@ -843,6 +843,20 @@ function wait(ms: number): Promise<void> {
   return new Promise((resolve) => window.setTimeout(resolve, ms));
 }
 
+function dependencyRootDelta(
+  current: readonly string[],
+  previous: ReadonlySet<string>,
+): { added: string[]; changed: boolean; removed: string[] } {
+  const next = new Set(current);
+  const added = current.filter((name) => !previous.has(name));
+  const removed = [...previous].filter((name) => !next.has(name));
+  return {
+    added,
+    changed: added.length !== 0 || removed.length !== 0,
+    removed,
+  };
+}
+
 function createAbortError(reason: string): Error {
   const error = new Error(`Dependency install aborted: ${reason}.`);
   error.name = "AbortError";

package/src/react/createCompilerClient.ts

@@ -9,72 +9,58 @@ import type { ICreateCompilerClientOptions } from "../structures/ICreateCompiler
  * UI-side singleton: connect to the playground worker over tgrid and return the
  * typed `ICompilerService` driver.
  *
- * The promise is cached; the first call boots, every subsequent call shares the
- * same connection. If the boot rejects the cache is cleared so the next call
- * retries — otherwise every retry would resolve to the same rejection.
+ * One connection generation owns the cached promise and connector. A reset
+ * invalidates that generation before awaiting it, so a late settlement cannot
+ * replace a newer connection or clear its retry state.
  */
 export function createCompilerClient(options: ICreateCompilerClientOptions): {
   connect(): Promise<ICompilerService>;
   reset(): Promise<void>;
 } {
-  let connectionPromise: Promise<ICompilerService> | null = null;
-  // Track the active connector AND the in-flight connector promise so
-  // reset() can dispose either one — disposing only the resolved
-  // `activeConnector` leaks the connector when reset() is called during
-  // an in-flight `await connector.connect(...)` (the connector reference
-  // exists but isn't yet assigned to activeConnector).
-  let activeConnector: WorkerConnector<null, null, null> | null = null;
-  let pendingConnector: Promise<WorkerConnector<null, null, null>> | null =
-    null;
+  type Connection = {
+    connector: WorkerConnector<null, null, null>;
+    close(): Promise<void>;
+    promise: Promise<ICompilerService>;
+  };
+  let current: Connection | null = null;
 
   return {
     connect(): Promise<ICompilerService> {
-      if (connectionPromise) return connectionPromise;
+      if (current) return current.promise;
       const connector: WorkerConnector<null, null, null> = new WorkerConnector(
         null,
         null,
       );
-      const connectPromise = connector
-        .connect(options.workerUrl)
-        .then(() => connector);
-      pendingConnector = connectPromise;
-      connectionPromise = (async () => {
-        try {
-          await connectPromise;
-        } catch (err) {
-          connectionPromise = null;
-          if (pendingConnector === connectPromise) pendingConnector = null;
-          throw err;
-        }
-        if (pendingConnector === connectPromise) pendingConnector = null;
-        activeConnector = connector;
-        return connector.getDriver() as unknown as ICompilerService;
-      })();
-      return connectionPromise;
+      let closePromise: Promise<void> | null = null;
+      const connection = {} as Connection;
+      current = connection;
+      connection.connector = connector;
+      connection.close = () =>
+        (closePromise ??= Promise.resolve()
+          .then(() => connector.close())
+          .catch(() => {}));
+      connection.promise = Promise.resolve()
+        .then(() => connector.connect(options.workerUrl))
+        .then(() => connector.getDriver() as unknown as ICompilerService)
+        .catch(async (error: unknown) => {
+          if (current === connection) {
+            current = null;
+            await connection.close();
+          }
+          throw error;
+        });
+      return connection.promise;
     },
     async reset(): Promise<void> {
-      const inflight = pendingConnector;
-      const active = activeConnector;
-      connectionPromise = null;
-      pendingConnector = null;
-      activeConnector = null;
-      // Swallow close errors: the worker is already being torn down,
-      // and a Retry that fails to close cleanly should not block the
-      // next connect attempt. Cover both code paths — the in-flight
-      // connector (await it first, then close) and the resolved active
-      // connector. Either may be null; both may be the same instance
-      // after a successful connect().
-      if (inflight) {
-        try {
-          const c = await inflight;
-          if (c !== active) await c.close().catch(() => {});
-        } catch {
-          // connect() rejected — nothing to close.
-        }
-      }
-      if (active) {
-        await active.close().catch(() => {});
+      const invalidated = current;
+      current = null;
+      if (!invalidated) return;
+      try {
+        await invalidated.promise;
+      } catch {
+        // A rejected connection never became usable.
       }
+      await invalidated.close();
     },
   };
 }

package/src/sandbox/createSandboxRequire.ts

@@ -30,6 +30,12 @@ interface ISandboxRequireOptions {
     | Record<string, (...args: unknown[]) => void>;
 }
 
+// The sandbox evaluates CommonJS through a `require` wrapper in a browser. It
+// therefore activates `require`; `default` is always available as the portable
+// fallback. `node` and `import` stay inactive because the sandbox supplies
+// neither Node's runtime nor an ESM evaluator.
+const ACTIVE_EXPORT_CONDITIONS = new Set(["require", "default"]);
+
 /**
  * Build a sandboxed `require` function over a runtime pack. Resolves typia /
  * `@typia/*` / randexp specifiers from the pack; throws on anything else so the
@@ -50,6 +56,35 @@ export function createSandboxRequire(
     return null;
   };
 
+  const packageDeclaresExports = (pkg: string): boolean => {
+    const key = `${pkg}/package.json`;
+    if (!has(key)) return false;
+    try {
+      return Object.prototype.hasOwnProperty.call(
+        JSON.parse(pack[key]!) as IPackJson,
+        "exports",
+      );
+    } catch {
+      return false;
+    }
+  };
+
+  const resolveExportTarget = (
+    pkg: string,
+    target: unknown,
+    replacement = "",
+  ): string | null => {
+    const candidates = conditionalExportTargets(target);
+    if (!candidates) return null;
+    for (const candidate of candidates) {
+      const resolved = `${pkg}/${stripDotSlash(
+        candidate.split("*").join(replacement),
+      )}`;
+      if (has(resolved)) return resolved;
+    }
+    return null;
+  };
+
   // Read package.json from pack and resolve via main/exports.
   const resolvePackageEntry = (
     pkg: string,
@@ -66,12 +101,8 @@ export function createSandboxRequire(
     if (subpath === null) {
       // bare "name": honor the root `exports` entry (string, subpath table
       // "." key, or bare condition map) → CJS target, else main, else index.
-      const root = rootExportTarget(pj.exports);
-      const r = pickConditionalExport(root);
-      if (r) {
-        const resolved = `${pkg}/${stripDotSlash(r)}`;
-        return has(resolved) ? resolved : null;
-      }
+      if (pj.exports !== undefined)
+        return resolveExportTarget(pkg, rootExportTarget(pj.exports));
       if (typeof pj.main === "string") {
         return tryPaths(
           `${pkg}/${stripDotSlash(pj.main)}`,
@@ -85,27 +116,36 @@ export function createSandboxRequire(
       }
       return tryPaths(`${pkg}/index.js`, `${pkg}/index.cjs`);
     }
-    // Subpath: honor exports["./subpath"] or exports["./subpath/*"] patterns.
+    // Subpath: honor exact exports and general single-star patterns.
     const exportsAny = pj.exports;
-    if (typeof exportsAny === "object" && exportsAny !== null) {
+    if (
+      exportsAny !== undefined &&
+      typeof exportsAny === "object" &&
+      exportsAny !== null
+    ) {
       const entries = exportsAny as Record<string, unknown>;
       // Exact match first.
-      const exact = entries[`./${subpath}`];
-      const ex = pickConditionalExport(exact);
-      if (ex) {
-        const resolved = `${pkg}/${stripDotSlash(ex)}`;
-        if (has(resolved)) return resolved;
-      }
-      // Wildcard match.
-      for (const [pattern, target] of Object.entries(entries)) {
-        if (!pattern.endsWith("/*")) continue;
-        const prefix = pattern.slice(2, -1); // strip "./" and trailing "*"
-        if (!subpath.startsWith(prefix)) continue;
-        const rest = subpath.slice(prefix.length);
-        const targetStr = pickConditionalExport(target);
-        if (!targetStr) continue;
-        const resolved = `${pkg}/${stripDotSlash(targetStr.replace("*", rest))}`;
-        if (has(resolved)) return resolved;
+      const exactKey = `./${subpath}`;
+      if (
+        Object.prototype.hasOwnProperty.call(entries, exactKey) &&
+        !exactKey.includes("*") &&
+        !exactKey.endsWith("/")
+      )
+        return resolveExportTarget(pkg, entries[exactKey]);
+      // Node resolves the most-specific wildcard, not insertion order.
+      const patterns = Object.entries(entries)
+        .map(([pattern, target]) => ({
+          pattern,
+          replacement: exportPatternReplacement(pattern, exactKey),
+          target,
+        }))
+        .filter(
+          (entry): entry is typeof entry & { replacement: string } =>
+            entry.replacement !== undefined,
+        )
+        .sort((a, b) => compareExportPatternKeys(a.pattern, b.pattern));
+      for (const { replacement, target } of patterns) {
+        return resolveExportTarget(pkg, target, replacement);
       }
     }
     return null;
@@ -136,7 +176,10 @@ export function createSandboxRequire(
     if (subpath === null) {
       return resolvePackageEntry(pkg, null);
     }
-    // First try direct paths (covers the common typia/lib/internal/X case).
+    // A declared exports map is the public boundary. Only packages without one
+    // retain the historical packed-file fallback.
+    if (packageDeclaresExports(pkg)) return resolvePackageEntry(pkg, subpath);
+    // First try direct paths (covers packages that do not declare exports).
     const direct = tryPaths(
       `${pkg}/${subpath}`,
       `${pkg}/${subpath}.js`,
@@ -158,22 +201,22 @@ export function createSandboxRequire(
     const mod: ModuleObj = { exports: {} };
     // Cache before evaluation so cyclic requires see the partial exports.
     cache.set(key, mod);
-    if (key.endsWith(".json")) {
-      mod.exports = JSON.parse(code) as unknown;
-      return mod;
-    }
-    const localRequire = (specifier: string): unknown => {
-      const resolved = resolveSpecifier(specifier, key);
-      if (!resolved) {
-        throw new Error(
-          `require("${specifier}") is not available in the playground sandbox (from ${key})`,
-        );
-      }
-      return evaluate(resolved).exports;
-    };
-    const filename = "/sandbox/" + key;
-    const dir = "/sandbox/" + dirname(key);
     try {
+      if (key.endsWith(".json")) {
+        mod.exports = JSON.parse(code) as unknown;
+        return mod;
+      }
+      const localRequire = (specifier: string): unknown => {
+        const resolved = resolveSpecifier(specifier, key);
+        if (!resolved) {
+          throw new Error(
+            `require("${specifier}") is not available in the playground sandbox (from ${key})`,
+          );
+        }
+        return evaluate(resolved).exports;
+      };
+      const filename = "/sandbox/" + key;
+      const dir = "/sandbox/" + dirname(key);
       const factory = new Function(
         "require",
         "module",
@@ -198,13 +241,18 @@ export function createSandboxRequire(
         filename,
         opts.console,
       );
+      return mod;
     } catch (err) {
+      // The entry is provisional until evaluation succeeds. Preserve a future
+      // replacement rather than evicting by key alone.
+      if (cache.get(key) === mod) {
+        cache.delete(key);
+      }
       // Surface eval-time errors with context so debugging the sandbox is
       // easier when typia ships a module that depends on something missing.
       const message = err instanceof Error ? err.message : String(err);
       throw new Error(`evaluating ${key}: ${message}`);
     }
-    return mod;
   };
 
   return (specifier: string): unknown => {
@@ -218,10 +266,45 @@ export function createSandboxRequire(
   };
 }
 
+/** Capture the middle of one valid single-star exports key. */
+function exportPatternReplacement(
+  pattern: string,
+  subpath: string,
+): string | undefined {
+  const star = pattern.indexOf("*");
+  if (
+    !pattern.startsWith("./") ||
+    star === -1 ||
+    pattern.indexOf("*", star + 1) !== -1
+  ) {
+    return undefined;
+  }
+  const prefix = pattern.slice(0, star);
+  const suffix = pattern.slice(star + 1);
+  if (
+    subpath.length < pattern.length ||
+    !subpath.startsWith(prefix) ||
+    !subpath.endsWith(suffix)
+  ) {
+    return undefined;
+  }
+  return subpath.slice(prefix.length, subpath.length - suffix.length);
+}
+
+/** Node exports patterns rank longer prefixes, then longer full keys, first. */
+function compareExportPatternKeys(left: string, right: string): number {
+  const leftPrefix = left.indexOf("*");
+  const rightPrefix = right.indexOf("*");
+  if (leftPrefix !== rightPrefix) {
+    return rightPrefix - leftPrefix;
+  }
+  return right.length - left.length;
+}
+
 /**
  * Reduce a `package.json` `exports` field to the value describing its ROOT
- * (".") entry, ready for {@link pickConditionalExport}. Node accepts three valid
- * root shapes and they must all resolve consistently:
+ * (".") entry, ready for {@link conditionalExportTargets}. Node accepts three
+ * valid root shapes and they must all resolve consistently:
  *
  * - A bare string target — `"exports": "./index.cjs"`;
  * - A subpath table keyed by "." — `{ ".": <target>, "./sub": ... }`;
@@ -243,14 +326,22 @@ function rootExportTarget(exports: unknown): unknown {
   return hasSubpathKey ? obj["."] : obj;
 }
 
-function pickConditionalExport(value: unknown): string | null {
-  if (typeof value === "string") return value;
+function conditionalExportTargets(value: unknown): string[] | null {
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value)) {
+    const candidates: string[] = [];
+    for (const target of value) {
+      const resolved = conditionalExportTargets(target);
+      if (resolved) candidates.push(...resolved);
+    }
+    return candidates.length === 0 ? null : candidates;
+  }
   if (value && typeof value === "object") {
     const obj = value as Record<string, unknown>;
-    // Prefer require (CJS) > default > node.
-    const pick = obj.require ?? obj.default ?? obj.node;
-    if (typeof pick === "string") return pick;
-    if (pick && typeof pick === "object") return pickConditionalExport(pick);
+    for (const [condition, target] of Object.entries(obj)) {
+      if (!ACTIVE_EXPORT_CONDITIONS.has(condition)) continue;
+      return conditionalExportTargets(target);
+    }
   }
   return null;
 }

package/src/structures/IPlaygroundDependencyInstallOptions.ts

@@ -1,10 +1,22 @@
 import type { IPlaygroundDependencyProgress } from "./IPlaygroundDependencyProgress";
+import type { IPlaygroundInstalledDependency } from "./IPlaygroundInstalledDependency";
 
 /** Options for {@link installPlaygroundDependencies}. */
 export interface IPlaygroundDependencyInstallOptions {
   /** Defaults to `globalThis.fetch`. Override for tests or for offline runs. */
   fetch?: (input: string, init?: RequestInit) => Promise<Response>;
-  /** Package names the wasm already has — skip re-installing them. */
+  /**
+   * Exact package identities already mounted in this session.
+   *
+   * New edges are reconciled against their versions, registry targets, and
+   * active requests before a tarball is reused.
+   */
+  installedDependencies?: Iterable<IPlaygroundInstalledDependency>;
+  /**
+   * Legacy name-only skip list.
+   *
+   * Prefer `installedDependencies`; names alone cannot validate later ranges.
+   */
   installedPackages?: Iterable<string>;
   /** Package names to never install (preinstalled / built-in). */
   ignoredPackages?: Iterable<string>;

package/src/structures/IPlaygroundDependencyInstallResult.ts

@@ -1,7 +1,11 @@
 import type { IPlaygroundDependencyPackage } from "./IPlaygroundDependencyPackage";
+import type { IPlaygroundInstalledDependency } from "./IPlaygroundInstalledDependency";
 
 /** Aggregate result returned by {@link installPlaygroundDependencies}. */
 export interface IPlaygroundDependencyInstallResult {
+  /** Complete exact state after merging installed packages with this call. */
+  resolvedDependencies: IPlaygroundInstalledDependency[];
+  /** Packages whose tarballs were downloaded and unpacked by this call. */
   packages: IPlaygroundDependencyPackage[];
   /**
    * `node_modules/...` keyed map of files to mount inside the wasm-side