castle-web-sdk 0.4.16 → 0.4.18

package/dist/castle.d.ts

@@ -11,7 +11,7 @@ export { Pass } from "./passes";
 export type { CastlePassApi, PassOfferResult, PassOfferStatus, } from "./passes";
 export { Portal } from "./portal";
 export type { CastlePortalApi, PortalOpenResult, PortalOpenStatus, PortalPrefetchResult, PortalPrefetchStatus, } from "./portal";
-export { CARD_RATIO, fileUrl, initCard, onBeforeRestart, onFilesChanged, onSaveReloadState, requestReload, setup, takeReloadState, writeFileOnce, } from "./runtime";
+export { CARD_RATIO, deleteFile, fileUrl, initCard, onBeforeRestart, onFilesChanged, onSaveReloadState, openFile, renameFile, requestReload, setup, takeReloadState, writeFileOnce, } from "./runtime";
 export type { FileChange, FilesChangedEvent } from "./runtime";
 export { flushSaves, hasPendingSave, onSaveState, writeFile, } from "./saveQueue";
 export type { SaveState } from "./saveQueue";

package/dist/castle.js

@@ -7,7 +7,7 @@ export { Leaderboard } from "./leaderboard";
 export { Lifecycle } from "./lifecycle";
 export { Pass } from "./passes";
 export { Portal } from "./portal";
-export { CARD_RATIO, fileUrl, initCard, onBeforeRestart, onFilesChanged, onSaveReloadState, requestReload, setup, takeReloadState, writeFileOnce, } from "./runtime";
+export { CARD_RATIO, deleteFile, fileUrl, initCard, onBeforeRestart, onFilesChanged, onSaveReloadState, openFile, renameFile, requestReload, setup, takeReloadState, writeFileOnce, } from "./runtime";
 export { flushSaves, hasPendingSave, onSaveState, writeFile, } from "./saveQueue";
 export { SharedStorage, Storage } from "./storage";
 export { Time } from "./time";

package/dist/runtime.d.ts

@@ -32,6 +32,9 @@ export declare function setup(): void;
  */
 export declare function writeFileOnce(path: string, contents: string): Promise<LocalResponse>;
 export declare function fileUrl(path: string): string;
+export declare function renameFile(from: string, to: string): Promise<void>;
+export declare function deleteFile(path: string): Promise<void>;
+export declare function openFile(path: string): void;
 export declare function initCard(): HTMLDivElement;
 export declare function sendLocalCommand<C extends CommandName>(command: C, params: CommandParams[C]): Promise<CommandResponseEnvelope>;
 /**

package/dist/runtime.js

@@ -66,6 +66,41 @@ export function writeFileOnce(path, contents) {
 export function fileUrl(path) {
     return `/__castle/files/raw?path=${encodeURIComponent(path)}`;
 }
+// Move a deck file. `writeFile`'s counterpart for the case where the file's
+// NAME is the thing changing -- an editor renaming a blueprint has to move the
+// file, not write a copy and leave the old one behind. Rejects when the
+// destination exists or the source is gone (the serve's own guards), so a
+// caller can surface the collision instead of silently clobbering.
+export async function renameFile(from, to) {
+    await fileOp("rename", { from, to });
+}
+// Delete a deck file. Editor UI only, same as `writeFile` -- a published deck
+// has no serve to ask.
+export async function deleteFile(path) {
+    await fileOp("delete", { path });
+}
+async function fileOp(action, body) {
+    const res = await fetch(`/__castle/files/${action}`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    if (res.ok)
+        return;
+    const detail = await res.text().catch(() => "");
+    throw new Error(`castle: ${action} failed (${res.status}) ${detail}`.trim());
+}
+// Ask the editor shell to open (or focus) an editor for `path`. This is how a
+// kit editor hands the creator off to another file -- the creation modal
+// dropping them into the pixel editor for the sprite it just made. A no-op
+// anywhere there's no shell listening (a published deck, a bare serve), which
+// is why it neither returns nor throws: the handoff is a courtesy, and the
+// file was already written before we asked.
+export function openFile(path) {
+    if (typeof window === "undefined" || window.parent === window)
+        return;
+    window.parent.postMessage({ type: "castle-open-file", path }, "*");
+}
 export function initCard() {
     const style = document.createElement("style");
     style.textContent = `
@@ -441,6 +476,8 @@ function initHostCapture() {
     // than starting a second capture alongside the one already running.
     const inFlight = new Set();
     window.addEventListener("message", (event) => {
+        if (!isTrustedShellMessage(event))
+            return;
         const data = event.data;
         if (!data || data.type !== HOST_CAPTURE_REQUEST)
             return;
@@ -454,11 +491,17 @@ function initHostCapture() {
             if (requestId)
                 inFlight.delete(requestId);
             const target = event.source ?? window.parent;
-            target.postMessage({ type: HOST_CAPTURE_RESULT, requestId, dataUrl, ok: !!dataUrl }, "*");
+            target.postMessage({ type: HOST_CAPTURE_RESULT, requestId, dataUrl, ok: !!dataUrl }, event.origin);
         };
         void captureScreenshot().then(reply, () => reply(null));
     });
 }
+function isTrustedShellMessage(event) {
+    const expectedOrigin = window
+        .__castleShellOrigin;
+    return (event.source === window.parent &&
+        (expectedOrigin ? event.origin === expectedOrigin : event.origin !== "null"));
+}
 // ─── local dev-server socket ───────────────────────────────────────────────────
 // Reconnect policy mirrors the shell's terminal client: back off while the tab
 // is visible, stay quiet while it is hidden or offline, and force a FRESH socket
@@ -490,6 +533,7 @@ let localServeSeen = false;
 let needsWakeReconnect = false;
 const intentionallyClosed = new WeakSet();
 const connectionListeners = new Set();
+let bridgeListening = false;
 /**
  * Notified `true` on every fresh dev-server socket and `false` when one is lost.
  * What lets a queued write know the moment retrying is worth it again.
@@ -539,6 +583,10 @@ function connectLocal() {
     clearReconnectTimer();
     if (!canConnectLocal())
         return;
+    if (typeof window !== "undefined" && window.parent !== window) {
+        connectBridge();
+        return;
+    }
     fetch("/__castle/ws-port")
         .then((r) => r.json())
         .then(({ port, path }) => {
@@ -555,6 +603,48 @@ function connectLocal() {
             scheduleReconnect();
     });
 }
+function connectBridge() {
+    if (bridgeListening || ws?.readyState === WebSocket.OPEN)
+        return;
+    bridgeListening = true;
+    const onInit = (event) => {
+        const data = event.data;
+        if (!data ||
+            data.type !== "castle-bridge-init" ||
+            !isTrustedShellMessage(event) ||
+            event.ports.length !== 1) {
+            return;
+        }
+        const port = event.ports[0];
+        const socket = {
+            readyState: WebSocket.OPEN,
+            send: (value) => {
+                try {
+                    port.postMessage(JSON.parse(value));
+                }
+                catch {
+                    /* malformed local payload */
+                }
+            },
+        };
+        port.onmessage = (messageEvent) => {
+            const value = messageEvent.data;
+            if (!value || typeof value !== "object")
+                return;
+            handleLocalMessage(value);
+        };
+        port.start();
+        localServeSeen = true;
+        ws = socket;
+        for (const msg of logBuffer)
+            socket.send(JSON.stringify(msg));
+        logBuffer = [];
+        bridgeListening = false;
+        window.removeEventListener("message", onInit);
+        setConnected(true);
+    };
+    window.addEventListener("message", onInit);
+}
 function stopHeartbeat() {
     if (pingTimer !== null) {
         clearInterval(pingTimer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "castle-web-sdk",
-  "version": "0.4.16",
+  "version": "0.4.18",
   "type": "module",
   "main": "dist/castle.js",
   "types": "dist/castle.d.ts",