@immediately-run/sandpack-client 2.21.1 → 2.22.1

package/dist/{types-BgalzxpH.mjs → types-DRg992RB.mjs}

@@ -43,7 +43,7 @@ var GUARDED_WRITE_METHODS = [
  * (roadmap R3-110).
  *
  * This is a module-level function (not a class method) and its **only** reference
- * is behind the `if (IS_DEV)` branch in the constructor — so once a consumer's
+ * is behind the `if (IS_DEV)` branch in {@link ensureGuard} — so once a consumer's
  * production build folds `IS_DEV` to `false`, the branch and this whole function
  * tree-shake away (a class method would be retained). No-op in production.
  */
@@ -71,6 +71,35 @@ function installOutOfBandGuard(fsContext) {
         _loop_1(method);
     }
 }
+/**
+ * The true raw write methods per bound context, captured once and shared by every
+ * SandpackFS instance that adopts that context. Without this, a second instance's
+ * constructor captures the first instance's wrapper as its "raw" method — because the
+ * guard has already replaced `fsContext.fs.promises` entries — so SandpackFS's own
+ * writes trip the guard once per prior adoption (the R3-614 stacking bug).
+ */
+var RAW = new WeakMap();
+/**
+ * Return the context's raw write methods, capturing them and installing the out-of-band
+ * guard exactly once per context (see {@link installOutOfBandGuard}). Reads `RAW` first,
+ * so adopting the same context any number of times never re-wraps, never re-captures a
+ * wrapper as raw, and never disarms a sibling instance.
+ */
+function ensureGuard(fsContext) {
+    var existing = RAW.get(fsContext);
+    if (existing)
+        return existing;
+    var p = fsContext.fs.promises;
+    var raw = {
+        writeFile: p.writeFile.bind(p),
+        unlink: p.unlink.bind(p),
+        mkdir: p.mkdir.bind(p),
+    };
+    RAW.set(fsContext, raw);
+    if (IS_DEV)
+        installOutOfBandGuard(fsContext);
+    return raw;
+}
 var mountCounter = 0;
 var normalize = function (path) {
     return path.startsWith("/") ? path : "/".concat(path);
@@ -117,12 +146,10 @@ var SandpackFS = /** @class */ (function () {
          *  unmount in {@link dispose}. Unset for an adopted context, whose lifecycle
          *  belongs to the caller. */
         this.ownedMountPoint = undefined;
-        var p = fsContext.fs.promises;
-        this.rawWriteFile = p.writeFile.bind(p);
-        this.rawUnlink = p.unlink.bind(p);
-        this.rawMkdir = p.mkdir.bind(p);
-        if (IS_DEV)
-            installOutOfBandGuard(fsContext);
+        var raw = ensureGuard(fsContext);
+        this.rawWriteFile = raw.writeFile;
+        this.rawUnlink = raw.unlink;
+        this.rawMkdir = raw.mkdir;
     }
     /**
      * Create the `MessagePort` shared with the child iframe, wiring the iframe's

package/dist/types.d.ts

@@ -37,6 +37,18 @@ export interface ClientOptions {
      * `allow-same-origin`). Required for the runtime client to transpile.
      */
     babelWorkerURL?: string;
+    /**
+     * Called when the client REFUSES to register a frame because it booted from a
+     * navigation the client did not perform (R3-353 — a sandboxed frame may always
+     * navigate itself, and the browsing context survives, so a page the app chose
+     * could otherwise post `initialized` and be handed this frame's grants).
+     *
+     * By the time this fires the frame has been blanked and the client destroyed:
+     * nothing was connected and no fs port was minted. The host's job is to surface
+     * it (and/or re-create the frame from a clean state), not to decide whether to
+     * allow it — that decision has already been made, fail-closed.
+     */
+    onUnexpectedNavigation?: () => void;
     /**
      * Level of logging to do in the bundler
      */
@@ -239,7 +251,13 @@ export type ClientStatus = "initializing" | "installing-dependencies" | "transpi
 export type SandpackMessageConsoleMethods = "log" | "debug" | "info" | "warn" | "error" | "table" | "clear" | "time" | "timeEnd" | "count" | "assert";
 export interface BaseSandpackMessage {
     type: string;
-    $id?: number;
+    /**
+     * The sender's channel id. Newer peers mint it as a crypto-random hex STRING
+     * (R3-367 — 64 bits); ids older peers minted as numbers still flow, because
+     * each side compares the value it itself sent. Correlation only — never an
+     * authenticator (the evt.source check in IFrameProtocol is).
+     */
+    $id?: string | number;
     codesandbox?: boolean;
     /**
      * Transferable objects (e.g. a `MessagePort`) to hand to the iframe alongside

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@immediately-run/sandpack-client",
-  "version": "2.21.1",
+  "version": "2.22.1",
   "description": "",
   "keywords": [],
   "repository": {