@playcraft/cli 0.1.54 → 0.1.55-beta

package/templates/preview-runtime/v1/runtime.mjs

@@ -0,0 +1,1121 @@
+// ../iframe-bridge/package.json
+var package_default = {
+  name: "@playcraft/iframe-bridge",
+  version: "0.0.55",
+  private: false,
+  type: "module",
+  description: "PlayCraft iframe postMessage bridge SDK for parent \u2194 child communication",
+  sideEffects: false,
+  publishConfig: {
+    access: "public"
+  },
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      default: "./dist/index.js"
+    }
+  },
+  files: [
+    "dist",
+    "README.md"
+  ],
+  scripts: {
+    build: `node -e "require('fs').rmSync('dist',{recursive:true,force:true})" && rollup -c`,
+    dev: "rollup -c -w",
+    typecheck: "tsc -p tsconfig.json --noEmit",
+    prepublishOnly: "pnpm build",
+    test: "vitest run",
+    "test:watch": "vitest",
+    playground: 'pnpm --filter "@playcraft/iframe-bridge-playground-*" --parallel dev',
+    lint: "echo 'No eslint config yet'",
+    release: "node ../../scripts/release-npm.mjs --packages=iframe-bridge --skip-install --skip-tests --skip-git-push"
+  },
+  devDependencies: {
+    "@rollup/plugin-json": "6.1.0",
+    "@rollup/plugin-node-resolve": "16.0.3",
+    "@rollup/plugin-swc": "0.4.0",
+    "@swc/core": "1.15.3",
+    "@types/node": "^25.2.0",
+    "happy-dom": "^20.0.10",
+    rollup: "4.57.1",
+    "rollup-plugin-dts": "6.3.0",
+    typescript: "^5.9.3",
+    vite: "^8.0.3",
+    vitest: "^3.2.4"
+  }
+};
+
+// ../iframe-bridge/src/configs/constants.ts
+var PROTOCOL_VERSION = package_default.version;
+var DEFAULT_REQUEST_TIMEOUT_MS = 15e4;
+var BridgeErrorCodes = {
+  ABORTED: "ABORTED",
+  DESTROYED: "DESTROYED",
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  INVALID_PARAM: "INVALID_PARAM",
+  METHOD_NOT_FOUND: "METHOD_NOT_FOUND",
+  PEER_UNAVAILABLE: "PEER_UNAVAILABLE",
+  REQUEST_FAILED: "REQUEST_FAILED",
+  TIMEOUT: "TIMEOUT"
+};
+var RetCodes = {
+  OK: 0,
+  INVALID_PARAM: 1,
+  TIMEOUT: 2,
+  ABORTED: 3,
+  REQUEST_FAILED: 4,
+  INTERNAL_ERROR: 5,
+  PEER_UNAVAILABLE: 6,
+  DESTROYED: 7,
+  METHOD_NOT_FOUND: 8
+};
+var ERROR_CODE_TO_RET = {
+  [BridgeErrorCodes.INVALID_PARAM]: RetCodes.INVALID_PARAM,
+  [BridgeErrorCodes.TIMEOUT]: RetCodes.TIMEOUT,
+  [BridgeErrorCodes.ABORTED]: RetCodes.ABORTED,
+  [BridgeErrorCodes.REQUEST_FAILED]: RetCodes.REQUEST_FAILED,
+  [BridgeErrorCodes.INTERNAL_ERROR]: RetCodes.INTERNAL_ERROR,
+  [BridgeErrorCodes.PEER_UNAVAILABLE]: RetCodes.PEER_UNAVAILABLE,
+  [BridgeErrorCodes.DESTROYED]: RetCodes.DESTROYED,
+  [BridgeErrorCodes.METHOD_NOT_FOUND]: RetCodes.METHOD_NOT_FOUND
+};
+var RET_TO_ERROR_CODE = {
+  [RetCodes.INVALID_PARAM]: BridgeErrorCodes.INVALID_PARAM,
+  [RetCodes.TIMEOUT]: BridgeErrorCodes.TIMEOUT,
+  [RetCodes.ABORTED]: BridgeErrorCodes.ABORTED,
+  [RetCodes.REQUEST_FAILED]: BridgeErrorCodes.REQUEST_FAILED,
+  [RetCodes.INTERNAL_ERROR]: BridgeErrorCodes.INTERNAL_ERROR,
+  [RetCodes.PEER_UNAVAILABLE]: BridgeErrorCodes.PEER_UNAVAILABLE,
+  [RetCodes.DESTROYED]: BridgeErrorCodes.DESTROYED,
+  [RetCodes.METHOD_NOT_FOUND]: BridgeErrorCodes.METHOD_NOT_FOUND
+};
+function errorCodeToRet(code) {
+  return ERROR_CODE_TO_RET[code] ?? RetCodes.REQUEST_FAILED;
+}
+function retToErrorCode(ret) {
+  return RET_TO_ERROR_CODE[ret] ?? BridgeErrorCodes.REQUEST_FAILED;
+}
+
+// ../iframe-bridge/src/utils/envelope.ts
+function isEnvelopeKind(kind) {
+  return kind === "req" || kind === "res";
+}
+function isPlaycraftEnvelopeShape(data) {
+  if (!data || typeof data !== "object") return false;
+  const env = data;
+  return typeof env.__playcraft__ === "string" && isEnvelopeKind(env.kind) && typeof env.id === "string" && typeof env.name === "string";
+}
+function getPlaycraftEnvelopeVersionMismatch(data) {
+  if (!isPlaycraftEnvelopeShape(data)) return void 0;
+  const peer = data.__playcraft__;
+  if (peer === PROTOCOL_VERSION) return void 0;
+  return { local: PROTOCOL_VERSION, peer };
+}
+function createEnvelope(kind, id, name, data) {
+  return { __playcraft__: PROTOCOL_VERSION, kind, id, name, data };
+}
+function createSuccessResponse(id, name, data) {
+  return { ...createEnvelope("res", id, name), ret: RetCodes.OK, data };
+}
+function createErrorResponse(id, name, error) {
+  return {
+    ...createEnvelope("res", id, name),
+    ret: error.ret,
+    msg: error.msg
+  };
+}
+function isPlaycraftEnvelope(data) {
+  return isPlaycraftEnvelopeShape(data);
+}
+
+// ../iframe-bridge/src/utils/errors.ts
+var PlaycraftBridgeError = class extends Error {
+  code;
+  detail;
+  constructor(code, message, detail) {
+    super(message);
+    this.name = "PlaycraftBridgeError";
+    this.code = code;
+    this.detail = detail;
+  }
+};
+function isRpcError(value) {
+  return !!value && typeof value === "object" && "ret" in value && "msg" in value && typeof value.ret === "number" && typeof value.msg === "string";
+}
+function isLegacyCodeMessageError(value) {
+  return !!value && typeof value === "object" && "code" in value && "message" in value && typeof value.code === "string" && typeof value.message === "string";
+}
+function toPlaycraftError(err) {
+  if (isRpcError(err)) {
+    return err;
+  }
+  if (err instanceof PlaycraftBridgeError) {
+    return {
+      ret: errorCodeToRet(err.code),
+      msg: err.message
+    };
+  }
+  if (isLegacyCodeMessageError(err)) {
+    return {
+      ret: errorCodeToRet(err.code),
+      msg: err.message
+    };
+  }
+  return {
+    ret: RetCodes.INTERNAL_ERROR,
+    msg: err instanceof Error ? err.message : String(err)
+  };
+}
+
+// ../iframe-bridge/src/configs/method-names.ts
+var BridgeMethods = {
+  form: {
+    get: "form.get",
+    set: "form.set"
+  },
+  image: {
+    aiGenerate: "image.aiGenerate"
+  },
+  dialog: {
+    close: "dialog.close"
+  },
+  storage: {
+    get: "storage.get"
+  },
+  child: {
+    ready: "child.ready"
+  },
+  host: {
+    init: "host.init"
+  },
+  runtimeParameters: {
+    hello: "runtime.parameters.hello",
+    snapshot: "runtime.parameters.snapshot",
+    patch: "runtime.parameters.patch",
+    restart: "runtime.parameters.restart",
+    status: "runtime.parameters.status",
+    dispose: "runtime.parameters.dispose",
+    capabilities: "runtime.parameters.capabilities",
+    result: "runtime.parameters.result",
+    resyncRequired: "runtime.parameters.resync-required"
+  }
+};
+var BRIDGE_EVENT_NAMES = [
+  BridgeMethods.child.ready,
+  BridgeMethods.host.init,
+  BridgeMethods.dialog.close,
+  BridgeMethods.runtimeParameters.capabilities,
+  BridgeMethods.runtimeParameters.result,
+  BridgeMethods.runtimeParameters.resyncRequired
+];
+var BRIDGE_RPC_NAMES = [
+  BridgeMethods.form.get,
+  BridgeMethods.form.set,
+  BridgeMethods.image.aiGenerate,
+  BridgeMethods.storage.get,
+  BridgeMethods.runtimeParameters.hello,
+  BridgeMethods.runtimeParameters.snapshot,
+  BridgeMethods.runtimeParameters.patch,
+  BridgeMethods.runtimeParameters.restart,
+  BridgeMethods.runtimeParameters.status,
+  BridgeMethods.runtimeParameters.dispose
+];
+
+// ../iframe-bridge/src/configs/perspective.ts
+var BridgePerspectives = {
+  parent: "parent",
+  child: "child"
+};
+function bridgePeerForPerspective(perspective) {
+  return perspective === BridgePerspectives.parent ? "Parent" : "Child";
+}
+
+// ../iframe-bridge/src/utils/debug-log.ts
+var PARENT_TO_CHILD_REQS = /* @__PURE__ */ new Set([BridgeMethods.host.init]);
+var PEER_CONSOLE_STYLES = {
+  Parent: "color: #6366f1; font-weight: bold",
+  Child: "color: #fead43; font-weight: bold"
+};
+var LOCAL_CONSOLE_STYLES = {
+  [BridgePerspectives.parent]: "color: #6366f1; font-weight: bold",
+  [BridgePerspectives.child]: "color: #fead43; font-weight: bold"
+};
+function resolveWireFlow(name, kind) {
+  if (kind === "res" || PARENT_TO_CHILD_REQS.has(name)) {
+    return { from: "Parent", to: "Child" };
+  }
+  return { from: "Child", to: "Parent" };
+}
+function logBridgeDebug(perspective, direction, msg) {
+  if (!perspective) {
+    console.debug(`[playcraft:${direction}]`, msg);
+    return;
+  }
+  const { from, to } = resolveWireFlow(msg.name, msg.kind);
+  const localLabel = bridgePeerForPerspective(perspective);
+  console.debug(
+    `%c[${localLabel}]%c %c${from}%c \u2192 %c${to}%c \xB7 ${direction} \xB7 ${msg.kind} \xB7 ${msg.name}`,
+    LOCAL_CONSOLE_STYLES[perspective],
+    "",
+    PEER_CONSOLE_STYLES[from],
+    "color: inherit",
+    PEER_CONSOLE_STYLES[to],
+    "color: inherit",
+    msg
+  );
+}
+
+// ../iframe-bridge/src/utils/is-event-name.ts
+var EVENT_NAMES = new Set(BRIDGE_EVENT_NAMES);
+function isEventName(name) {
+  return EVENT_NAMES.has(name);
+}
+
+// ../iframe-bridge/src/utils/id.ts
+var idSeq = 0;
+function genId() {
+  return `${Date.now()}-${idSeq++}`;
+}
+
+// ../iframe-bridge/src/utils/send-req.ts
+function sendReq(bridge, name, data) {
+  bridge.postMessage(createEnvelope("req", genId(), name, data));
+}
+
+// ../iframe-bridge/src/libs/invoke.ts
+function normalizeInvokeCall(call) {
+  if (Array.isArray(call)) {
+    const [name, data, options] = call;
+    return { name, data, options };
+  }
+  return call;
+}
+function isInvokeGroups(input) {
+  return Array.isArray(input) && input.length > 0 && typeof input[0] === "object" && input[0] !== null && "calls" in input[0];
+}
+async function settleParallel(promises) {
+  const settled = await Promise.allSettled(promises);
+  return settled.map(
+    (outcome) => outcome.status === "fulfilled" ? outcome.value : { error: toPlaycraftError(outcome.reason) }
+  );
+}
+async function runInvokeCalls(bridge, calls, mode, batchOptions = {}, defaultTimeout = DEFAULT_REQUEST_TIMEOUT_MS) {
+  const normalized = calls.map(normalizeInvokeCall);
+  const shared = { timeout: batchOptions.timeout, signal: batchOptions.signal };
+  if (mode === "parallel") {
+    return settleParallel(
+      normalized.map(
+        (call) => emitOne(bridge, call.name, call.data, { ...shared, ...call.options }, defaultTimeout)
+      )
+    );
+  }
+  const results = [];
+  for (const call of normalized) {
+    results.push(
+      await emitOne(bridge, call.name, call.data, { ...shared, ...call.options }, defaultTimeout)
+    );
+  }
+  return results;
+}
+function emitOne(bridge, name, data, options = {}, defaultTimeout = DEFAULT_REQUEST_TIMEOUT_MS) {
+  if (isEventName(name)) {
+    sendReq(bridge, name, data ?? {});
+    return Promise.resolve(void 0);
+  }
+  const timeout = options.timeout ?? defaultTimeout;
+  const id = genId();
+  return new Promise((resolve, reject) => {
+    let pending;
+    const offMessage = bridge.addEventListener("message", (e) => {
+      const msg = e.data;
+      if (msg.kind !== "res" || msg.id !== id || msg.name !== name) return;
+      clearTimeout(pending.timer);
+      pending.cleanupAbortListener?.();
+      offMessage();
+      if (msg.ret === RetCodes.OK) {
+        resolve(msg.data);
+      } else {
+        reject(
+          new PlaycraftBridgeError(
+            retToErrorCode(msg.ret ?? RetCodes.REQUEST_FAILED),
+            msg.msg ?? "request failed"
+          )
+        );
+      }
+    });
+    pending = {
+      resolve,
+      reject,
+      timer: setTimeout(() => {
+        offMessage();
+        reject(
+          new PlaycraftBridgeError(
+            BridgeErrorCodes.TIMEOUT,
+            `[playcraft] emit "${name}" timeout after ${timeout}ms`
+          )
+        );
+      }, timeout),
+      offMessage
+    };
+    if (options.signal) {
+      const onAbort = () => {
+        clearTimeout(pending.timer);
+        offMessage();
+        reject(
+          new PlaycraftBridgeError(BridgeErrorCodes.ABORTED, `[playcraft] emit "${name}" aborted`)
+        );
+      };
+      if (options.signal.aborted) {
+        onAbort();
+        return;
+      }
+      options.signal.addEventListener("abort", onAbort, { once: true });
+      pending.cleanupAbortListener = () => options.signal?.removeEventListener("abort", onAbort);
+    }
+    try {
+      bridge.postMessage(createEnvelope("req", id, name, data));
+    } catch (err) {
+      clearTimeout(pending.timer);
+      offMessage();
+      reject(err);
+    }
+  });
+}
+function emitForBridge(bridge, nameOrCalls, dataOrOptions, options) {
+  if (typeof nameOrCalls === "string") {
+    return emitOne(
+      bridge,
+      nameOrCalls,
+      dataOrOptions,
+      options
+    );
+  }
+  const batchOptions = dataOrOptions ?? {};
+  if (isInvokeGroups(nameOrCalls)) {
+    const outerMode = batchOptions.mode ?? "serial";
+    const runGroup = (group) => runInvokeCalls(bridge, group.calls, group.mode ?? "serial", batchOptions);
+    if (outerMode === "parallel") {
+      return settleParallel(nameOrCalls.map(runGroup));
+    }
+    return (async () => {
+      const results = [];
+      for (const group of nameOrCalls) {
+        results.push(await runGroup(group));
+      }
+      return results;
+    })();
+  }
+  return runInvokeCalls(bridge, nameOrCalls, batchOptions.mode ?? "serial", batchOptions);
+}
+
+// ../iframe-bridge/src/libs/handle.ts
+function safeReply(bridge, message) {
+  try {
+    bridge.postMessage(message);
+  } catch (err) {
+    if (err instanceof PlaycraftBridgeError && err.code === BridgeErrorCodes.PEER_UNAVAILABLE) {
+      return;
+    }
+    throw err;
+  }
+}
+function onForBridge(bridge, name, fn) {
+  return bridge.addEventListener("message", async (e) => {
+    const msg = e.data;
+    if (msg.kind !== "req" || msg.name !== name) return;
+    if (isEventName(name)) {
+      await fn(msg.data);
+      return;
+    }
+    try {
+      const data = await fn(msg.data, {
+        id: msg.id
+      });
+      safeReply(bridge, createSuccessResponse(msg.id, msg.name, data));
+    } catch (err) {
+      safeReply(bridge, createErrorResponse(msg.id, msg.name, toPlaycraftError(err)));
+    }
+  });
+}
+
+// ../iframe-bridge/src/libs/bridge.ts
+var Bridge = class {
+  constructor(options) {
+    this.options = options;
+    this.targetOrigin = options.targetOrigin;
+    this.messageTarget = options.messageTarget ?? window;
+    this.messageTarget.addEventListener("message", this.onWindowMessage);
+  }
+  options;
+  targetOrigin;
+  listeners = /* @__PURE__ */ new Set();
+  warnedPeerVersions = /* @__PURE__ */ new Set();
+  destroyed = false;
+  messageTarget;
+  emit(nameOrCalls, dataOrOptions, options) {
+    return emitForBridge(this, nameOrCalls, dataOrOptions, options);
+  }
+  on(name, fn) {
+    return onForBridge(this, name, fn);
+  }
+  postMessage(message, targetOrigin = this.options.targetOrigin, transfer) {
+    this.assertAlive();
+    const peer = this.options.peer();
+    if (!peer) {
+      throw new PlaycraftBridgeError(
+        BridgeErrorCodes.PEER_UNAVAILABLE,
+        "[playcraft] peer window is not available"
+      );
+    }
+    this.log("send", message);
+    peer.postMessage(message, targetOrigin, transfer ?? []);
+  }
+  addEventListener(type, listener) {
+    this.assertAlive();
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.messageTarget.removeEventListener("message", this.onWindowMessage);
+    this.listeners.clear();
+  }
+  assertAlive() {
+    if (this.destroyed) {
+      throw new PlaycraftBridgeError(BridgeErrorCodes.DESTROYED, "[playcraft] bridge destroyed");
+    }
+  }
+  log(event, msg) {
+    const { debug, perspective } = this.options;
+    if (!debug) return;
+    if (typeof debug === "function") debug(event, msg);
+    else logBridgeDebug(perspective, event, msg);
+  }
+  warnVersionMismatch(localVersion, peerVersion) {
+    if (this.warnedPeerVersions.has(peerVersion)) return;
+    this.warnedPeerVersions.add(peerVersion);
+    console.warn(
+      `[playcraft] protocol version mismatch: local ${localVersion}, peer ${peerVersion}. Messages are still processed; align @playcraft/iframe-bridge versions when possible.`
+    );
+  }
+  onWindowMessage = (e) => {
+    const msgEvent = e;
+    if (this.destroyed || !this.options.allowedOrigins.includes(msgEvent.origin)) return;
+    if (this.options.strictSource) {
+      const peer = this.options.peer();
+      if (!peer || msgEvent.source !== peer) return;
+    }
+    if (!isPlaycraftEnvelope(msgEvent.data)) return;
+    const mismatch = getPlaycraftEnvelopeVersionMismatch(msgEvent.data);
+    if (mismatch) {
+      this.warnVersionMismatch(mismatch.local, mismatch.peer);
+    }
+    this.log("recv", msgEvent.data);
+    const event = {
+      data: msgEvent.data,
+      origin: msgEvent.origin,
+      source: msgEvent.source
+    };
+    this.listeners.forEach((fn) => fn(event));
+  };
+};
+
+// ../preview-runtime/src/protocol.ts
+var ProtocolError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ProtocolError";
+  }
+  code;
+};
+var forbidden = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var record = (value) => !!value && typeof value === "object" && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+var exactKeys = (value, allowed) => {
+  if (Object.keys(value).some((key) => !allowed.includes(key)))
+    throw new ProtocolError("INVALID", "Unexpected message field");
+};
+var string = (v) => typeof v === "string" && v.length > 0 && v.length <= 1024;
+var revision = (v) => Number.isSafeInteger(v) && v >= 0;
+function assertJson(value, depth = 0) {
+  if (depth > 64) throw new ProtocolError("LIMIT", "Configuration nesting exceeds limit");
+  if (value === null || typeof value === "boolean" || typeof value === "string" || typeof value === "number" && Number.isFinite(value))
+    return;
+  if (Array.isArray(value)) {
+    for (const child of value) assertJson(child, depth + 1);
+    return;
+  }
+  if (record(value)) {
+    for (const [key, child] of Object.entries(value)) {
+      if (forbidden.has(key)) throw new ProtocolError("INVALID", "Unsafe configuration key");
+      assertJson(child, depth + 1);
+    }
+    return;
+  }
+  throw new ProtocolError("INVALID", "Configuration must contain finite JSON data");
+}
+function clone(value) {
+  return structuredClone(value);
+}
+function freeze(value) {
+  if (value && typeof value === "object") {
+    Object.freeze(value);
+    for (const child of Object.values(value)) freeze(child);
+  }
+  return value;
+}
+function fingerprint(value) {
+  if (Array.isArray(value)) return "[" + value.map(fingerprint).join(",") + "]";
+  if (record(value))
+    return "{" + Object.keys(value).sort().map((k) => JSON.stringify(k) + ":" + fingerprint(value[k])).join(",") + "}";
+  return JSON.stringify(value);
+}
+function assertHello(value) {
+  if (!record(value) || value.protocolVersion !== 1 || !string(value.sessionId) || !revision(value.frameEpoch) || !string(value.schemaVersion) || !string(value.configContractVersion) || !string(value.locale) || !record(value.scope))
+    throw new ProtocolError("IDENTITY", "Invalid runtime session binding");
+  if (!["projectId", "branchName", "themeId"].every(
+    (k) => string(value.scope[k])
+  ))
+    throw new ProtocolError("IDENTITY", "Invalid configuration scope");
+  exactKeys(value.scope, ["projectId", "branchName", "themeId"]);
+}
+function assertIdentity(value) {
+  assertHello(value);
+  if (!string(value.runtimeInstanceId))
+    throw new ProtocolError("IDENTITY", "Missing runtime instance");
+}
+function sameIdentity(a, b) {
+  try {
+    assertIdentity(b);
+  } catch {
+    return false;
+  }
+  return [
+    "protocolVersion",
+    "sessionId",
+    "frameEpoch",
+    "runtimeInstanceId",
+    "schemaVersion",
+    "configContractVersion",
+    "locale"
+  ].every((k) => a[k] === b[k]) && fingerprint(a.scope) === fingerprint(b.scope);
+}
+function assertBinding(expected, actual) {
+  if (fingerprint(expected.scope) !== fingerprint(actual.scope) || expected.locale !== actual.locale || expected.schemaVersion !== actual.schemaVersion || expected.configContractVersion !== actual.configContractVersion)
+    throw new ProtocolError("CONTRACT", "Scope, locale, schema or configuration contract mismatch");
+}
+function assertDocuments(value) {
+  assertJson(value);
+  if (!record(value) || Object.values(value).some((v) => !record(v)))
+    throw new ProtocolError("INVALID", "Expected raw document objects");
+}
+var identityKeys = [
+  "protocolVersion",
+  "sessionId",
+  "frameEpoch",
+  "runtimeInstanceId",
+  "scope",
+  "schemaVersion",
+  "configContractVersion",
+  "locale"
+];
+function assertSnapshot(value) {
+  assertIdentity(value);
+  exactKeys(value, [
+    ...identityKeys,
+    "draftRevision",
+    "documents"
+  ]);
+  if (!revision(value.draftRevision))
+    throw new ProtocolError("INVALID", "Invalid snapshot revision");
+  assertDocuments(value.documents);
+  limit(value, 512 * 1024);
+}
+function assertPatch(value) {
+  assertIdentity(value);
+  const v = value;
+  exactKeys(v, [
+    ...identityKeys,
+    "baseDraftRevision",
+    "draftRevision",
+    "phase",
+    "operations"
+  ]);
+  if (!revision(v.baseDraftRevision) || !revision(v.draftRevision) || v.draftRevision !== v.baseDraftRevision + 1 || !["preview", "commit"].includes(v.phase) || !Array.isArray(v.operations) || v.operations.length > 256)
+    throw new ProtocolError("INVALID", "Invalid patch sequence or operation count");
+  for (const op of v.operations) {
+    if (!record(op) || !["set", "remove"].includes(op.op) || !string(op.documentId) || forbidden.has(op.documentId) || !Array.isArray(op.path) || !op.path.length || op.path.length > 32 || op.path.some((p) => !string(p) || forbidden.has(p)))
+      throw new ProtocolError("INVALID", "Unsafe or invalid operation path");
+    exactKeys(
+      op,
+      op.op === "set" ? ["op", "documentId", "path", "value"] : ["op", "documentId", "path"]
+    );
+    if (op.op === "set") assertJson(op.value);
+  }
+  limit(v, 64 * 1024);
+}
+function limit(value, bytes) {
+  if (new TextEncoder().encode(JSON.stringify(value)).length > bytes)
+    throw new ProtocolError("LIMIT", "Runtime message exceeds byte limit");
+}
+function applyOperations(documents, operations) {
+  const next = clone(documents);
+  for (const op of operations) {
+    if (op.op === "remove" && readPath(next[op.documentId], op.path) === void 0) continue;
+    let target = next[op.documentId] ??= {};
+    for (const part of op.path.slice(0, -1)) {
+      if (!record(target[part])) target[part] = {};
+      target = target[part];
+    }
+    const key = op.path[op.path.length - 1];
+    if (op.op === "set") target[key] = clone(op.value);
+    else delete target[key];
+  }
+  return next;
+}
+function readPath(value, path) {
+  for (const key of path) {
+    if (!record(value) && !Array.isArray(value)) return void 0;
+    value = value[key];
+  }
+  return value;
+}
+
+// ../preview-runtime/src/runtime.ts
+function createParameterRuntime(options) {
+  const runtimeInstanceId = crypto.randomUUID();
+  let identity;
+  let controller = new AbortController();
+  let queue = Promise.resolve();
+  let adapter;
+  let target;
+  let installed;
+  let receivedRevision = -1, installedRevision = -1, appliedRevision = -1;
+  let stage = "bootstrap-ready";
+  let status = "idle";
+  let error;
+  let disposed = false;
+  let cleanupFailure;
+  let resultSequence = 0;
+  const retiredSessions = /* @__PURE__ */ new Set();
+  const groups = /* @__PURE__ */ new Map();
+  const receipts = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  const capabilityListeners = /* @__PURE__ */ new Set();
+  async function release(game) {
+    try {
+      await game?.dispose();
+    } catch (e) {
+      cleanupFailure = e;
+      throw e;
+    }
+  }
+  for (const field of options.fields)
+    groups.set(field.groupId, { groupId: field.groupId, appliedRevision: -1, status: "unknown" });
+  const capabilities = () => ({
+    ...requireIdentity(),
+    stage,
+    canAcceptSnapshot: true,
+    fields: clone(options.fields)
+  });
+  function requireIdentity() {
+    if (!identity || disposed)
+      throw new ProtocolError("SESSION", "Runtime session is not connected");
+    return identity;
+  }
+  function check(value) {
+    assertIdentity(value);
+    if (!sameIdentity(requireIdentity(), value))
+      throw new ProtocolError("STALE", "Stale runtime identity");
+  }
+  const result = () => ({
+    ...requireIdentity(),
+    resultSequence,
+    receivedRevision,
+    installedRevision,
+    appliedRevision,
+    status,
+    groups: clone([...groups.values()]),
+    ...error ? { error } : {}
+  });
+  function publish() {
+    if (!identity || disposed) return;
+    resultSequence++;
+    const value = result();
+    listeners.forEach((fn) => fn(value));
+  }
+  function context(config, beforeConfig, draftRevision, fields, signal) {
+    return {
+      config,
+      beforeConfig,
+      draftRevision,
+      fields,
+      signal,
+      assertCurrent() {
+        signal.throwIfAborted();
+        if (signal !== controller.signal || disposed)
+          throw new ProtocolError("STALE", "Application task expired");
+      }
+    };
+  }
+  function enqueue(work) {
+    const signal = controller.signal;
+    queue = queue.then(async () => {
+      if (signal.aborted) return;
+      try {
+        await work(signal);
+      } catch (e) {
+        if (signal.aborted) return;
+        status = "error";
+        installedRevision = appliedRevision = -1;
+        error = e instanceof Error ? e.message : String(e);
+        for (const group of groups.values()) group.status = "unknown";
+        publish();
+      }
+    });
+  }
+  function remember(kind, request) {
+    const key = `${kind}:${request.draftRevision}`;
+    const previous = receipts.get(key);
+    if (previous) {
+      if (previous.fingerprint !== fingerprint(request))
+        throw new ProtocolError("CONFLICT", "Revision was already accepted with different content");
+      return previous.receipt;
+    }
+    return void 0;
+  }
+  function accept(kind, request) {
+    receivedRevision = request.draftRevision;
+    const receipt = { accepted: true, receivedRevision };
+    receipts.set(`${kind}:${receivedRevision}`, { fingerprint: fingerprint(request), receipt });
+    if (receipts.size > 256) receipts.delete(receipts.keys().next().value);
+    return receipt;
+  }
+  function updateState(rev, changed) {
+    for (const field of changed)
+      groups.set(field.groupId, {
+        groupId: field.groupId,
+        appliedRevision: rev,
+        status: "applied"
+      });
+    let pending = false, reload = false;
+    for (const field of options.fields) {
+      if (fingerprint(readPath(installed?.[field.documentId], field.path)) !== fingerprint(readPath(target?.[field.documentId], field.path))) {
+        const group = groups.get(field.groupId);
+        group.status = field.mode === "reload" ? "requires-reload" : "pending-commit";
+        pending = true;
+        reload ||= field.mode === "reload";
+      }
+    }
+    if (fingerprint(installed) === fingerprint(target)) {
+      appliedRevision = receivedRevision;
+      installedRevision = receivedRevision;
+      status = "applied";
+    } else status = reload ? "requires-reload" : pending ? "pending-commit" : "applying";
+    publish();
+  }
+  async function applyTarget(documents, rev, commit, signal) {
+    if (status === "error") return;
+    if (!adapter || !installed)
+      throw new ProtocolError("STATE", "Initial snapshot must create the game first");
+    const operations = [];
+    for (const field of options.fields) {
+      if (field.mode !== "live" && !(commit && field.mode === "restart-scene")) continue;
+      const value = readPath(documents[field.documentId], field.path);
+      operations.push(
+        value === void 0 ? { op: "remove", documentId: field.documentId, path: field.path } : {
+          op: "set",
+          documentId: field.documentId,
+          path: field.path,
+          value: clone(value)
+        }
+      );
+    }
+    const candidate = applyOperations(installed, operations);
+    const before = options.source.get();
+    const config = freeze(options.resolve(freeze(clone(candidate))));
+    const changed = options.fields.filter(
+      (field) => fingerprint(readPath(before, field.effectivePath)) !== fingerprint(readPath(config, field.effectivePath))
+    );
+    const ctx = context(config, before, rev, changed, signal);
+    ctx.assertCurrent();
+    status = "applying";
+    publish();
+    options.source.install(config);
+    installedRevision = fingerprint(candidate) === fingerprint(documents) ? rev : -1;
+    try {
+      if (changed.some((field) => field.mode === "restart-scene")) await adapter.restartScene(ctx);
+      else if (changed.length) await adapter.apply(ctx);
+      ctx.assertCurrent();
+      await adapter.afterRender(ctx);
+      ctx.assertCurrent();
+      installed = candidate;
+      updateState(rev, changed);
+    } catch (e) {
+      if (!signal.aborted) options.source.install(before);
+      throw e;
+    }
+  }
+  return {
+    hello(value) {
+      assertHello(value);
+      assertBinding(options.binding, value);
+      if (disposed) throw new ProtocolError("DISPOSED", "Runtime endpoint is disposed");
+      if (retiredSessions.has(value.sessionId))
+        throw new ProtocolError("STALE", "Retired runtime session");
+      if (identity && value.sessionId === identity.sessionId && value.frameEpoch < identity.frameEpoch)
+        throw new ProtocolError("STALE", "Old frame epoch");
+      if (identity && fingerprint({ ...identity, runtimeInstanceId: void 0 }) === fingerprint({ ...value, runtimeInstanceId: void 0 }))
+        return capabilities();
+      if (identity && identity.sessionId !== value.sessionId)
+        retiredSessions.add(identity.sessionId);
+      controller.abort();
+      controller = new AbortController();
+      const previous = adapter;
+      adapter = void 0;
+      queue = queue.then(async () => {
+        await release(previous);
+      }).catch((e) => {
+        cleanupFailure = e;
+      });
+      identity = freeze({ ...clone(value), runtimeInstanceId });
+      target = installed = void 0;
+      receivedRevision = installedRevision = appliedRevision = -1;
+      receipts.clear();
+      stage = "bootstrap-ready";
+      status = "idle";
+      error = void 0;
+      resultSequence = 0;
+      for (const group of groups.values()) {
+        group.appliedRevision = -1;
+        group.status = "unknown";
+      }
+      return capabilities();
+    },
+    snapshot(value) {
+      assertSnapshot(value);
+      check(value);
+      const previous = remember("snapshot", value);
+      if (previous) return previous;
+      if (value.draftRevision < receivedRevision)
+        throw new ProtocolError("STALE", "Old snapshot revision");
+      if (value.draftRevision === receivedRevision && fingerprint(value.documents) !== fingerprint(target))
+        throw new ProtocolError("CONFLICT", "Snapshot cannot change an already accepted revision");
+      const rev = value.draftRevision;
+      const documents = freeze(clone(value.documents));
+      options.resolve(documents);
+      target = documents;
+      const receipt = accept("snapshot", value);
+      enqueue(async (signal) => {
+        if (cleanupFailure)
+          throw new ProtocolError(
+            "RECOVERY",
+            "Previous game cleanup failed; reload the preview frame"
+          );
+        const before = options.source.get();
+        const config = freeze(options.resolve(documents));
+        const ctx = context(config, before, rev, clone(options.fields), signal);
+        ctx.assertCurrent();
+        status = "applying";
+        publish();
+        const previousAdapter = adapter;
+        adapter = void 0;
+        stage = "bootstrap-ready";
+        await release(previousAdapter);
+        ctx.assertCurrent();
+        options.source.install(config);
+        installedRevision = rev;
+        let created;
+        try {
+          created = await options.createGame(ctx);
+          if (signal.aborted) {
+            await release(created);
+            return;
+          }
+          ctx.assertCurrent();
+          adapter = created;
+          stage = "game-ready";
+          capabilityListeners.forEach((fn) => fn(capabilities()));
+          await created.afterRender(ctx);
+          ctx.assertCurrent();
+          installed = clone(documents);
+          error = void 0;
+          updateState(rev, options.fields);
+        } catch (e) {
+          if (!signal.aborted) {
+            adapter = void 0;
+            stage = "bootstrap-ready";
+            options.source.install(before);
+            capabilityListeners.forEach((fn) => fn(capabilities()));
+          }
+          await release(created);
+          throw e;
+        }
+      });
+      return receipt;
+    },
+    patch(value) {
+      assertPatch(value);
+      check(value);
+      const previous = remember("patch", value);
+      if (previous) return previous;
+      if (!target || value.baseDraftRevision !== receivedRevision)
+        throw new ProtocolError("RESYNC", "Patch base does not match received revision");
+      if (status === "error")
+        throw new ProtocolError(
+          "RECOVERY",
+          "Application state is unknown; send a recovery snapshot"
+        );
+      for (const op of value.operations)
+        if (!options.fields.some(
+          (field) => field.documentId === op.documentId && fingerprint(field.path) === fingerprint(op.path)
+        ))
+          throw new ProtocolError("UNSUPPORTED", "Unregistered parameter path");
+      const documents = freeze(applyOperations(target, value.operations));
+      const rev = value.draftRevision, commit = value.phase === "commit";
+      options.resolve(documents);
+      target = documents;
+      const receipt = accept("patch", value);
+      enqueue((signal) => applyTarget(documents, rev, commit, signal));
+      return receipt;
+    },
+    restart(value) {
+      check(value);
+      if (status === "error")
+        throw new ProtocolError(
+          "RECOVERY",
+          "Application state is unknown; send a recovery snapshot"
+        );
+      const rev = value.draftRevision;
+      if (rev !== receivedRevision || !target)
+        throw new ProtocolError("STALE", "Restart must name the current target");
+      const documents = clone(target);
+      enqueue((signal) => applyTarget(documents, rev, true, signal));
+      return { accepted: true, receivedRevision };
+    },
+    status(value) {
+      check(value);
+      return result();
+    },
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => listeners.delete(fn);
+    },
+    onCapabilities(fn) {
+      capabilityListeners.add(fn);
+      return () => capabilityListeners.delete(fn);
+    },
+    async settled() {
+      await queue;
+    },
+    async dispose() {
+      if (disposed) return;
+      disposed = true;
+      controller.abort();
+      listeners.clear();
+      capabilityListeners.clear();
+      await queue;
+      await adapter?.dispose();
+      adapter = void 0;
+    }
+  };
+}
+
+// ../preview-runtime/src/preview.ts
+function readWorkspacePreviewContext(expectedContractVersion) {
+  try {
+    const mark = "playcraft-preview-storage:";
+    if (!window.name.startsWith(mark)) throw new Error("Missing workspace context");
+    const context = JSON.parse(window.name.slice(mark.length)).__playcraft_preview_context__;
+    if (!context || typeof context.parentOrigin !== "string" || !context.binding)
+      throw new Error("Missing workspace binding");
+    const parent = new URL(context.parentOrigin);
+    if (!["http:", "https:"].includes(parent.protocol) || parent.origin !== context.parentOrigin || parent.origin === "null")
+      throw new Error("Invalid parent origin");
+    const hello = {
+      ...context.binding,
+      protocolVersion: 1,
+      sessionId: "workspace-context",
+      frameEpoch: 0
+    };
+    assertHello(hello);
+    if (context.binding.configContractVersion !== expectedContractVersion)
+      throw new Error("Unexpected configuration contract");
+    const profiles = document.querySelectorAll("script#playcraft-runtime-profile");
+    if (profiles.length !== 1 || profiles[0].getAttribute("type") !== "application/json")
+      throw new Error("Missing build profile");
+    const profile = JSON.parse(profiles[0].textContent ?? "");
+    if (profile.version !== 1 || profile.protocolVersion !== 1 || profile.target !== "editor-static")
+      throw new Error("Invalid build profile");
+    assertBinding(profile.binding, hello);
+    return freeze(
+      clone({ binding: context.binding, parentOrigin: parent.origin })
+    );
+  } catch (error) {
+    throw new ProtocolError(
+      "CONTEXT",
+      error instanceof Error ? error.message : "Invalid workspace preview context"
+    );
+  }
+}
+function connectPreviewRuntime(options) {
+  const origin = new URL(options.parentOrigin).origin;
+  if (origin === "null" || options.parentOrigin !== origin)
+    throw new ProtocolError("ORIGIN", "An exact parent origin is required");
+  const runtime = createParameterRuntime(options);
+  const bridge = new Bridge({
+    peer: () => window.parent,
+    targetOrigin: origin,
+    allowedOrigins: [origin],
+    strictSource: true
+  });
+  const names = BridgeMethods.runtimeParameters;
+  const off = [
+    bridge.on(names.hello, (value) => runtime.hello(value)),
+    bridge.on(names.snapshot, (value) => runtime.snapshot(value)),
+    bridge.on(names.patch, (value) => {
+      try {
+        return runtime.patch(value);
+      } catch (error) {
+        if (error instanceof ProtocolError && error.code === "RESYNC")
+          void bridge.emit(
+            names.resyncRequired,
+            { ...runtime.status(value), reason: error.message },
+            { timeout: 1e3 }
+          ).catch(() => {
+          });
+        throw error;
+      }
+    }),
+    bridge.on(names.restart, (value) => runtime.restart(value)),
+    bridge.on(names.status, (value) => runtime.status(value)),
+    bridge.on(names.dispose, async (value) => {
+      runtime.status(value);
+      await runtime.dispose();
+      return { disposed: true };
+    }),
+    runtime.subscribe((value) => {
+      void bridge.emit(names.result, value, { timeout: 1e3 }).catch(() => {
+      });
+    }),
+    runtime.onCapabilities((value) => {
+      void bridge.emit(names.capabilities, value, { timeout: 1e3 }).catch(() => {
+      });
+    })
+  ];
+  return {
+    runtime,
+    async dispose() {
+      off.forEach((fn) => fn());
+      bridge.destroy();
+      await runtime.dispose();
+    }
+  };
+}
+export {
+  connectPreviewRuntime,
+  readWorkspacePreviewContext
+};