@playcraft/cli 0.1.66 → 0.1.68

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

@@ -1,3 +1,231 @@
+// ../preview-runtime/src/protocol.ts
+var PROTOCOL_VERSION = 1;
+var MAX_IMAGE_RESOURCE_BYTES = 32 * 1024 * 1024;
+var ResourceLoadError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ResourceLoadError";
+  }
+};
+var SupersededResourceError = class extends Error {
+  constructor() {
+    super("A newer image value replaced this resource request");
+    this.name = "SupersededResourceError";
+  }
+};
+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 assertImageResourceRequest(value) {
+  assertIdentity(value);
+  const request = value;
+  exactKeys(value, [
+    ...identityKeys,
+    "draftRevision",
+    "documentId",
+    "path",
+    "value",
+    "resourceSequence",
+    "expectedContentHash"
+  ]);
+  if (!revision(request.draftRevision) || !string(request.documentId) || forbidden.has(request.documentId) || !Array.isArray(request.path) || !request.path.length || request.path.length > 32 || request.path.some((part) => !string(part) || forbidden.has(part)) || !string(request.value) || (request.resourceSequence !== void 0 || request.expectedContentHash !== void 0) && (!revision(request.resourceSequence) || request.resourceSequence === 0 || request.expectedContentHash !== void 0 && (typeof request.expectedContentHash !== "string" || !/^[a-f0-9]{64}$/.test(request.expectedContentHash))))
+    throw new ProtocolError("INVALID", "Invalid image resource request");
+}
+function assertImageRefresh(value) {
+  assertIdentity(value);
+  const request = value;
+  exactKeys(value, [
+    ...identityKeys,
+    "draftRevision",
+    "resourceSequence",
+    "images"
+  ]);
+  if (!revision(request.draftRevision) || !revision(request.resourceSequence) || request.resourceSequence === 0 || !Array.isArray(request.images) || !request.images.length || request.images.length > 64)
+    throw new ProtocolError("INVALID", "Invalid image refresh sequence or target count");
+  const seen = /* @__PURE__ */ new Set();
+  for (const image of request.images) {
+    if (!record(image) || !string(image.documentId) || forbidden.has(image.documentId) || !Array.isArray(image.path) || !image.path.length || image.path.length > 32 || image.path.some((part) => !string(part) || forbidden.has(part)) || image.contentHash !== null && (typeof image.contentHash !== "string" || !/^[a-f0-9]{64}$/.test(image.contentHash)))
+      throw new ProtocolError("INVALID", "Invalid image refresh target");
+    exactKeys(image, ["documentId", "path", "contentHash"]);
+    const key = fingerprint([image.documentId, image.path]);
+    if (seen.has(key)) throw new ProtocolError("INVALID", "Duplicate image refresh target");
+    seen.add(key);
+  }
+  limit(value, 64 * 1024);
+}
+function assertImageResourceData(value) {
+  if (!record(value) || typeof value.mimeType !== "string" || typeof value.dataUrl !== "string")
+    throw new ProtocolError("INVALID", "Invalid image resource response");
+  const allowed = ["image/png", "image/jpeg", "image/webp", "image/gif", "image/avif", "image/bmp"];
+  if (!allowed.includes(value.mimeType))
+    throw new ProtocolError("INVALID", "Unsupported image resource type");
+  const prefix = `data:${value.mimeType};base64,`;
+  const data = value.dataUrl.startsWith(prefix) ? value.dataUrl.slice(prefix.length) : "";
+  if (!data || data.length % 4 !== 0 || data.length > Math.ceil(MAX_IMAGE_RESOURCE_BYTES / 3) * 4 || !/^[A-Za-z0-9+/]+={0,2}$/.test(data))
+    throw new ProtocolError("LIMIT", "Invalid or oversized image resource data");
+  const bytes = data.length / 4 * 3 - (data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0);
+  if (bytes > MAX_IMAGE_RESOURCE_BYTES)
+    throw new ProtocolError("LIMIT", "Image resource exceeds the byte limit");
+  if (value.contentHash !== void 0 && !/^[a-f0-9]{64}$/.test(String(value.contentHash)))
+    throw new ProtocolError("INVALID", "Invalid image content fingerprint");
+}
+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;
+}
+
 // ../iframe-bridge/package.json
 var package_default = {
   name: "@playcraft/iframe-bridge",
@@ -48,7 +276,7 @@ var package_default = {
 };
 
 // ../iframe-bridge/src/configs/constants.ts
-var PROTOCOL_VERSION = package_default.version;
+var PROTOCOL_VERSION2 = package_default.version;
 var DEFAULT_REQUEST_TIMEOUT_MS = 15e4;
 var BridgeErrorCodes = {
   ABORTED: "ABORTED",
@@ -110,11 +338,11 @@ function isPlaycraftEnvelopeShape(data) {
 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 };
+  if (peer === PROTOCOL_VERSION2) return void 0;
+  return { local: PROTOCOL_VERSION2, peer };
 }
 function createEnvelope(kind, id, name, data) {
-  return { __playcraft__: PROTOCOL_VERSION, kind, id, name, data };
+  return { __playcraft__: PROTOCOL_VERSION2, kind, id, name, data };
 }
 function createSuccessResponse(id, name, data) {
   return { ...createEnvelope("res", id, name), ret: RetCodes.OK, data };
@@ -202,6 +430,12 @@ var BridgeMethods = {
     capabilities: "runtime.parameters.capabilities",
     result: "runtime.parameters.result",
     resyncRequired: "runtime.parameters.resync-required"
+  },
+  levelEditor: {
+    hello: "runtime.level-editor.hello",
+    snapshot: "runtime.level-editor.snapshot",
+    cancel: "runtime.level-editor.cancel",
+    dispose: "runtime.level-editor.dispose"
   }
 };
 var BRIDGE_EVENT_NAMES = [
@@ -224,7 +458,11 @@ var BRIDGE_RPC_NAMES = [
   BridgeMethods.runtimeParameters.status,
   BridgeMethods.runtimeParameters.dispose,
   BridgeMethods.runtimeParameters.asset,
-  BridgeMethods.runtimeParameters.refreshImages
+  BridgeMethods.runtimeParameters.refreshImages,
+  BridgeMethods.levelEditor.hello,
+  BridgeMethods.levelEditor.snapshot,
+  BridgeMethods.levelEditor.cancel,
+  BridgeMethods.levelEditor.dispose
 ];
 
 // ../iframe-bridge/src/configs/perspective.ts
@@ -479,264 +717,471 @@ var Bridge = class {
   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 MAX_IMAGE_RESOURCE_BYTES = 32 * 1024 * 1024;
-var ResourceLoadError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ResourceLoadError";
-  }
-};
-var SupersededResourceError = class extends Error {
-  constructor() {
-    super("A newer image value replaced this resource request");
-    this.name = "SupersededResourceError";
-  }
-};
-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 assertImageRefresh(value) {
-  assertIdentity(value);
-  const request = value;
-  exactKeys(value, [
-    ...identityKeys,
-    "draftRevision",
-    "resourceSequence",
-    "images"
-  ]);
-  if (!revision(request.draftRevision) || !revision(request.resourceSequence) || request.resourceSequence === 0 || !Array.isArray(request.images) || !request.images.length || request.images.length > 64)
-    throw new ProtocolError("INVALID", "Invalid image refresh sequence or target count");
-  const seen = /* @__PURE__ */ new Set();
-  for (const image of request.images) {
-    if (!record(image) || !string(image.documentId) || forbidden.has(image.documentId) || !Array.isArray(image.path) || !image.path.length || image.path.length > 32 || image.path.some((part) => !string(part) || forbidden.has(part)) || image.contentHash !== null && (typeof image.contentHash !== "string" || !/^[a-f0-9]{64}$/.test(image.contentHash)))
-      throw new ProtocolError("INVALID", "Invalid image refresh target");
-    exactKeys(image, ["documentId", "path", "contentHash"]);
-    const key = fingerprint([image.documentId, image.path]);
-    if (seen.has(key)) throw new ProtocolError("INVALID", "Duplicate image refresh target");
-    seen.add(key);
-  }
-  limit(value, 64 * 1024);
-}
-function assertImageResourceData(value) {
-  if (!record(value) || typeof value.mimeType !== "string" || typeof value.dataUrl !== "string")
-    throw new ProtocolError("INVALID", "Invalid image resource response");
-  const allowed = ["image/png", "image/jpeg", "image/webp", "image/gif", "image/avif", "image/bmp"];
-  if (!allowed.includes(value.mimeType))
-    throw new ProtocolError("INVALID", "Unsupported image resource type");
-  const prefix = `data:${value.mimeType};base64,`;
-  const data = value.dataUrl.startsWith(prefix) ? value.dataUrl.slice(prefix.length) : "";
-  if (!data || data.length % 4 !== 0 || data.length > Math.ceil(MAX_IMAGE_RESOURCE_BYTES / 3) * 4 || !/^[A-Za-z0-9+/]+={0,2}$/.test(data))
-    throw new ProtocolError("LIMIT", "Invalid or oversized image resource data");
-  const bytes = data.length / 4 * 3 - (data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0);
-  if (bytes > MAX_IMAGE_RESOURCE_BYTES)
-    throw new ProtocolError("LIMIT", "Image resource exceeds the byte limit");
-  if (value.contentHash !== void 0 && !/^[a-f0-9]{64}$/.test(String(value.contentHash)))
-    throw new ProtocolError("INVALID", "Invalid image content fingerprint");
-}
-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"]
+    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.`
     );
-    if (op.op === "set") assertJson(op.value);
   }
-  limit(v, 64 * 1024);
+  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/host.ts
+function validateCapabilities(value, binding) {
+  assertIdentity(value);
+  assertBinding(binding, value);
+  const cap = value;
+  if (!["bootstrap-ready", "game-ready"].includes(cap.stage) || cap.canAcceptSnapshot !== true || cap.canRefreshImages !== void 0 && cap.canRefreshImages !== true || cap.canReportMissingImages !== void 0 && (cap.canReportMissingImages !== true || cap.canRefreshImages !== true) || !Array.isArray(cap.fields) || cap.fields.some(
+    (field) => !field || typeof field.documentId !== "string" || !Array.isArray(field.path) || !field.path.every((p) => typeof p === "string") || !Array.isArray(field.effectivePath) || !field.effectivePath.every((p) => typeof p === "string") || typeof field.groupId !== "string" || field.resource !== void 0 && field.resource !== "image" || !["live", "restart-scene", "reload"].includes(field.mode)
+  ))
+    throw new ProtocolError("INVALID", "Invalid runtime capabilities");
+  return clone(cap);
 }
-function limit(value, bytes) {
-  if (new TextEncoder().encode(JSON.stringify(value)).length > bytes)
-    throw new ProtocolError("LIMIT", "Runtime message exceeds byte limit");
+function validateResult(value, identity) {
+  if (!sameIdentity(identity, value)) throw new ProtocolError("STALE", "Stale result identity");
+  const result = value;
+  if (!revision(result.resultSequence) || ![result.receivedRevision, result.installedRevision, result.appliedRevision].every(
+    (v) => Number.isSafeInteger(v) && v >= -1
+  ) || result.appliedRevision > result.receivedRevision || result.installedRevision > result.receivedRevision || !["idle", "applying", "applied", "pending-commit", "requires-reload", "error"].includes(
+    result.status
+  ) || result.recoverable !== void 0 && result.recoverable !== true || result.resourceErrors !== void 0 && (!Array.isArray(result.resourceErrors) || result.resourceErrors.some(
+    (item) => !item || typeof item.documentId !== "string" || !Array.isArray(item.path) || !item.path.every((part) => typeof part === "string") || typeof item.error !== "string"
+  )) || !Array.isArray(result.groups) || result.groups.some(
+    (g) => !g || typeof g.groupId !== "string" || !Number.isSafeInteger(g.appliedRevision) || !["applied", "pending-commit", "requires-reload", "unknown"].includes(g.status)
+  ))
+    throw new ProtocolError("INVALID", "Invalid application result");
+  return clone(result);
 }
-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];
+function createParameterHost(options) {
+  const origin = new URL(options.targetOrigin).origin;
+  if (origin === "null" || origin !== options.targetOrigin)
+    throw new ProtocolError("ORIGIN", "An exact preview origin is required");
+  const opaque = options.transport === "opaque-sandbox";
+  if (options.transport !== void 0 && options.transport !== "origin" && !opaque)
+    throw new ProtocolError("ORIGIN", "Unknown preview transport");
+  function assertFrameOrigin() {
+    if (!opaque) return;
+    let frameUrl;
+    try {
+      frameUrl = new URL(options.iframe.src);
+    } catch {
+      throw new ProtocolError("ORIGIN", "An absolute preview address is required");
     }
-    const key = op.path[op.path.length - 1];
-    if (op.op === "set") target[key] = clone(op.value);
-    else delete target[key];
+    if (!["http:", "https:"].includes(frameUrl.protocol) || frameUrl.origin !== origin)
+      throw new ProtocolError("ORIGIN", "The preview address does not match its expected origin");
   }
-  return next;
-}
-function readPath(value, path) {
-  for (const key of path) {
-    if (!record(value) && !Array.isArray(value)) return void 0;
-    value = value[key];
+  assertFrameOrigin();
+  assertDocuments(options.documents);
+  const binding = freeze(clone(options.binding));
+  const sessionId = crypto.randomUUID();
+  let frameEpoch = 0, identity;
+  let bridge;
+  let abort = new AbortController();
+  let serial = Promise.resolve();
+  let state = {
+    connection: "idle",
+    draftRevision: 0,
+    documents: freeze(clone(options.documents))
+  };
+  let disposed = false;
+  const documentHistory = /* @__PURE__ */ new Map([[0, state.documents]]);
+  const imageRequests = /* @__PURE__ */ new Map();
+  const refreshTargets = /* @__PURE__ */ new Map();
+  let resourceSequence = 0;
+  let imageReads = 0;
+  const imageWaiters = /* @__PURE__ */ new Set();
+  async function imageSlot(signal) {
+    while (imageReads >= 2) {
+      await new Promise((resolve, reject) => {
+        const wake = () => {
+          imageWaiters.delete(wake);
+          signal.removeEventListener("abort", cancelled);
+          resolve();
+        };
+        const cancelled = () => {
+          imageWaiters.delete(wake);
+          reject(signal.reason);
+        };
+        signal.throwIfAborted();
+        signal.addEventListener("abort", cancelled, { once: true });
+        imageWaiters.add(wake);
+      });
+    }
+    signal.throwIfAborted();
+    imageReads++;
+    return () => {
+      imageReads--;
+      [...imageWaiters].forEach((wake) => wake());
+    };
   }
-  return value;
+  const names = BridgeMethods.runtimeParameters;
+  const getState = () => freeze(clone(state));
+  const publish = () => options.onState?.(getState());
+  function receiveResult(value, currentIdentity) {
+    const result = validateResult(value, currentIdentity);
+    if (state.result && result.resultSequence < state.result.resultSequence) return;
+    state = { ...state, result };
+    publish();
+  }
+  function failed(error, epoch) {
+    if (epoch !== frameEpoch || disposed) return;
+    state = {
+      ...state,
+      connection: "error",
+      error: error instanceof Error ? error.message : String(error)
+    };
+    publish();
+  }
+  function receipt(value, expected) {
+    const r = value;
+    if (!r || r.accepted !== true || r.receivedRevision !== expected)
+      throw new ProtocolError("INVALID", "Invalid acceptance receipt");
+    return r;
+  }
+  const host = {
+    getState,
+    async connect() {
+      if (disposed) throw new ProtocolError("DISPOSED", "Preview host is disposed");
+      const epoch = ++frameEpoch;
+      abort.abort();
+      abort = new AbortController();
+      const signal = abort.signal;
+      bridge?.destroy();
+      bridge = void 0;
+      identity = void 0;
+      serial = Promise.resolve();
+      refreshTargets.clear();
+      resourceSequence = 0;
+      state = {
+        ...state,
+        connection: "connecting",
+        capabilities: void 0,
+        result: void 0,
+        error: void 0
+      };
+      publish();
+      try {
+        assertFrameOrigin();
+      } catch (error) {
+        failed(error, epoch);
+        throw error;
+      }
+      const current = new Bridge({
+        peer: () => options.iframe.contentWindow,
+        targetOrigin: opaque ? "*" : origin,
+        allowedOrigins: [opaque ? "null" : origin],
+        strictSource: true
+      });
+      bridge = current;
+      const hello = { ...binding, protocolVersion: PROTOCOL_VERSION, sessionId, frameEpoch: epoch };
+      assertHello(hello);
+      current.on(names.capabilities, (value) => {
+        if (!identity || signal.aborted || !sameIdentity(identity, value)) return;
+        try {
+          state = { ...state, capabilities: validateCapabilities(value, binding) };
+          publish();
+        } catch (error) {
+          failed(error, epoch);
+        }
+      });
+      current.on(names.result, (value) => {
+        if (!identity || signal.aborted || !sameIdentity(identity, value)) return;
+        try {
+          receiveResult(value, identity);
+        } catch (error) {
+          failed(error, epoch);
+        }
+      });
+      current.on(names.resyncRequired, (value) => {
+        if (!identity || signal.aborted || !sameIdentity(identity, value)) return;
+        failed(
+          new ProtocolError(
+            "RESYNC",
+            "Runtime requested a complete snapshot; reconnect to recover"
+          ),
+          epoch
+        );
+      });
+      current.on(names.asset, async (value) => {
+        assertImageResourceRequest(value);
+        if (!identity || signal.aborted || !sameIdentity(identity, value))
+          throw new ProtocolError("STALE", "Stale image resource identity");
+        assertFrameOrigin();
+        const frameAddress = options.iframe.src;
+        if (!state.capabilities?.fields.some(
+          (field) => field.resource === "image" && field.documentId === value.documentId && fingerprint(field.path) === fingerprint(value.path)
+        ))
+          throw new ProtocolError("UNSUPPORTED", "Unregistered image resource field");
+        if (!options.resolveImage)
+          throw new ProtocolError("UNSUPPORTED", "Image resource reader is unavailable");
+        const key = fingerprint([value.documentId, value.path]);
+        const refresh = value.resourceSequence === void 0 ? void 0 : refreshTargets.get(key);
+        if (value.resourceSequence !== void 0 && (!refresh || refresh.sequence !== value.resourceSequence || (refresh.contentHash === null ? value.expectedContentHash !== void 0 : refresh.contentHash !== value.expectedContentHash) || value.draftRevision < refresh.draftRevision || value.draftRevision > state.draftRevision))
+          return { ...value, status: "stale" };
+        const version = documentHistory.get(value.draftRevision);
+        if (!version && !refresh)
+          throw new ProtocolError("STALE", "Expired image resource revision");
+        const raw = version ? readPath(version[value.documentId], value.path) : refresh.raw;
+        if (raw !== void 0 && raw !== value.value)
+          throw new ProtocolError("INVALID", "Image resource value does not match its parameter");
+        const stale = () => fingerprint(readPath(state.documents[value.documentId], value.path)) !== fingerprint(raw) || refresh !== void 0 && refreshTargets.get(key) !== refresh;
+        if (stale()) return { ...value, status: "stale" };
+        if (imageRequests.size >= 64)
+          throw new ProtocolError("LIMIT", "Too many pending image resource reads");
+        const read = new AbortController();
+        const cancel = () => read.abort(signal.reason);
+        signal.addEventListener("abort", cancel, { once: true });
+        imageRequests.set(read, { request: clone(value), raw });
+        const timer = setTimeout(
+          () => read.abort(new ResourceLoadError("Image resource read timed out")),
+          15e3
+        );
+        let release;
+        let offAbort = () => {
+        };
+        try {
+          release = await imageSlot(read.signal);
+          read.signal.throwIfAborted();
+          const cancelled = new Promise((_, reject) => {
+            const onAbort = () => reject(read.signal.reason);
+            read.signal.addEventListener("abort", onAbort, { once: true });
+            offAbort = () => read.signal.removeEventListener("abort", onAbort);
+          });
+          const data = await Promise.race([
+            options.resolveImage(
+              { documentId: value.documentId, path: clone(value.path), value: value.value },
+              read.signal
+            ),
+            cancelled
+          ]);
+          read.signal.throwIfAborted();
+          assertFrameOrigin();
+          if (options.iframe.src !== frameAddress)
+            throw new ProtocolError("ORIGIN", "The preview address changed during an image read");
+          if (!identity || !sameIdentity(identity, value) || stale())
+            return { ...value, status: "stale" };
+          assertImageResourceData(data);
+          if (value.expectedContentHash !== void 0 && data.contentHash !== value.expectedContentHash)
+            throw new ResourceLoadError("Image resource content changed during refresh");
+          return { ...value, ...data, status: "ready" };
+        } catch (error) {
+          if (error instanceof SupersededResourceError || stale())
+            return { ...value, status: "stale" };
+          if (signal.aborted || !identity || !sameIdentity(identity, value))
+            throw new ProtocolError("STALE", "Image resource session expired");
+          if (error instanceof ProtocolError) throw error;
+          return {
+            ...value,
+            status: "failed",
+            error: error instanceof Error ? error.message : "Image resource read failed"
+          };
+        } finally {
+          clearTimeout(timer);
+          offAbort();
+          signal.removeEventListener("abort", cancel);
+          imageRequests.delete(read);
+          release?.();
+        }
+      });
+      try {
+        let cap;
+        const deadline = Date.now() + 1e4;
+        while (!cap) {
+          signal.throwIfAborted();
+          try {
+            cap = validateCapabilities(
+              await current.emit(names.hello, hello, { timeout: 800, signal }),
+              binding
+            );
+          } catch (error) {
+            if (signal.aborted || Date.now() >= deadline || error instanceof ProtocolError)
+              throw error;
+          }
+        }
+        if (cap.sessionId !== sessionId || cap.frameEpoch !== epoch)
+          throw new ProtocolError("STALE", "Handshake returned a different session");
+        signal.throwIfAborted();
+        identity = { ...hello, runtimeInstanceId: cap.runtimeInstanceId };
+        state = { ...state, capabilities: cap };
+        publish();
+        const draftRevision = state.draftRevision;
+        const request = { ...identity, draftRevision, documents: clone(state.documents) };
+        receipt(
+          await current.emit(names.snapshot, request, { timeout: 5e3, signal }),
+          draftRevision
+        );
+        signal.throwIfAborted();
+        state = { ...state, connection: "ready" };
+        publish();
+        const result = await current.emit(names.status, identity, { timeout: 2e3, signal });
+        signal.throwIfAborted();
+        receiveResult(result, identity);
+        return state.capabilities;
+      } catch (error) {
+        failed(error, epoch);
+        throw error;
+      }
+    },
+    patch(operations, phase = "preview") {
+      if (!identity || !bridge || disposed || state.connection !== "ready")
+        return Promise.reject(new ProtocolError("SESSION", "Preview is not connected"));
+      const epoch = frameEpoch, signal = abort.signal, current = bridge;
+      const request = {
+        ...identity,
+        baseDraftRevision: state.draftRevision,
+        draftRevision: state.draftRevision + 1,
+        operations: clone(operations),
+        phase
+      };
+      assertPatch(request);
+      state = {
+        ...state,
+        draftRevision: request.draftRevision,
+        documents: freeze(applyOperations(state.documents, request.operations))
+      };
+      for (const [key, refresh] of refreshTargets) {
+        const field = state.capabilities?.fields.find(
+          (field2) => fingerprint([field2.documentId, field2.path]) === key
+        );
+        if (field && fingerprint(readPath(state.documents[field.documentId], field.path)) !== fingerprint(refresh.raw))
+          refreshTargets.delete(key);
+      }
+      documentHistory.set(request.draftRevision, state.documents);
+      if (documentHistory.size > 64) documentHistory.delete(documentHistory.keys().next().value);
+      for (const [controller, image] of imageRequests)
+        if (fingerprint(readPath(state.documents[image.request.documentId], image.request.path)) !== fingerprint(image.raw))
+          controller.abort(new SupersededResourceError());
+      publish();
+      const work = serial.then(async () => {
+        signal.throwIfAborted();
+        if (state.connection === "error")
+          throw new ProtocolError("RECOVERY", "Reconnect to replay the retained draft");
+        return receipt(
+          await current.emit(names.patch, request, { timeout: 3e3, signal }),
+          request.draftRevision
+        );
+      }).catch((error) => {
+        failed(error, epoch);
+        throw error;
+      });
+      serial = work.catch(() => {
+      });
+      return work;
+    },
+    refreshImages(images) {
+      if (!identity || !bridge || disposed || state.connection !== "ready")
+        return Promise.reject(new ProtocolError("SESSION", "Preview is not connected"));
+      if (state.capabilities?.canRefreshImages !== true || state.capabilities.stage !== "game-ready")
+        return Promise.reject(
+          new ProtocolError("UNSUPPORTED", "This preview cannot refresh images")
+        );
+      const request = {
+        ...identity,
+        draftRevision: state.draftRevision,
+        resourceSequence: resourceSequence + 1,
+        images: clone(images)
+      };
+      assertImageRefresh(request);
+      for (const image of request.images) {
+        if (image.contentHash === null && state.capabilities.canReportMissingImages !== true)
+          return Promise.reject(
+            new ProtocolError("UNSUPPORTED", "This preview cannot report missing images")
+          );
+        if (!state.capabilities.fields.some(
+          (field) => field.resource === "image" && field.mode === "live" && field.documentId === image.documentId && fingerprint(field.path) === fingerprint(image.path)
+        ))
+          return Promise.reject(new ProtocolError("UNSUPPORTED", "Unregistered live image field"));
+        if (readPath(state.documents[image.documentId], image.path) === "")
+          return Promise.reject(
+            new ProtocolError("UNSUPPORTED", "Image refresh requires a nonempty image")
+          );
+      }
+      resourceSequence = request.resourceSequence;
+      for (const image of request.images) {
+        const key = fingerprint([image.documentId, image.path]);
+        refreshTargets.set(key, {
+          sequence: resourceSequence,
+          contentHash: image.contentHash,
+          draftRevision: request.draftRevision,
+          raw: clone(readPath(state.documents[image.documentId], image.path))
+        });
+        for (const [controller, pending] of imageRequests)
+          if (fingerprint([pending.request.documentId, pending.request.path]) === key)
+            controller.abort(new SupersededResourceError());
+      }
+      const epoch = frameEpoch, signal = abort.signal, current = bridge;
+      const work = serial.then(async () => {
+        signal.throwIfAborted();
+        if (state.connection === "error")
+          throw new ProtocolError("RECOVERY", "Reconnect to recover the preview");
+        const value = await current.emit(names.refreshImages, request, { timeout: 3e3, signal });
+        receipt(value, request.draftRevision);
+        const response = value;
+        if (response.resourceSequence !== request.resourceSequence)
+          throw new ProtocolError("INVALID", "Invalid image refresh receipt");
+        return response;
+      }).catch((error) => {
+        if (!(error instanceof ProtocolError && ["STALE", "UNSUPPORTED"].includes(error.code)))
+          failed(error, epoch);
+        throw error;
+      });
+      serial = work.catch(() => {
+      });
+      return work;
+    },
+    dispose(options2 = {}) {
+      if (disposed) return;
+      disposed = true;
+      if (options2.notifyRuntime !== false && bridge && identity)
+        void bridge.emit(names.dispose, identity, { timeout: 1e3 }).catch(() => {
+        });
+      abort.abort();
+      bridge?.destroy();
+      bridge = void 0;
+      state = { ...state, connection: "disposed" };
+      publish();
+    }
+  };
+  return host;
 }
 
 // ../preview-runtime/src/runtime.ts
@@ -1651,8 +2096,448 @@ function connectPreviewRuntime(options) {
     }
   };
 }
+
+// ../preview-runtime/src/level-editor.ts
+var frameResetPrefix = "level_editor_frame_reset_required:";
+var LevelEditorFrameResetError = class extends Error {
+  constructor(reason, cause) {
+    super(
+      `${frameResetPrefix}${reason}${cause instanceof Error ? `:${cause.message.slice(0, 512)}` : ""}`
+    );
+    this.reason = reason;
+    this.name = "LevelEditorFrameResetError";
+  }
+  reason;
+  code = "LEVEL_EDITOR_FRAME_RESET_REQUIRED";
+  requiresNewFrame = true;
+};
+function isLevelEditorFrameResetError(value) {
+  if (typeof value === "string") return value.startsWith(frameResetPrefix);
+  return !!value && typeof value === "object" && "message" in value && typeof value.message === "string" && value.message.startsWith(frameResetPrefix);
+}
+function boundedInteger(value, fallback, maximum) {
+  const result = value ?? fallback;
+  if (!Number.isSafeInteger(result) || result < 1 || result > maximum)
+    throw new Error("level_editor_invalid_deadline");
+  return result;
+}
+var bindingKeys = [
+  "workspaceId",
+  "directoryName",
+  "editorId",
+  "dataContractVersion",
+  "executionContractHash"
+];
+var identityKeys2 = [
+  ...bindingKeys,
+  "protocolVersion",
+  "hostSessionId",
+  "frameEpoch",
+  "runtimeInstanceId"
+];
+var object = (v) => {
+  if (!v || typeof v !== "object" || Array.isArray(v))
+    throw new Error("level_editor_invalid_message");
+  return v;
+};
+function assertBinding2(value) {
+  const v = object(value);
+  if (["workspaceId", "directoryName", "editorId"].some(
+    (k) => typeof v[k] !== "string" || !v[k].length
+  ) || !Number.isSafeInteger(v.dataContractVersion) || Number(v.dataContractVersion) < 1 || typeof v.executionContractHash !== "string" || !/^[a-f0-9]{64}$/.test(v.executionContractHash))
+    throw new Error("level_editor_invalid_binding");
+}
+function match(value, expected, keys) {
+  const v = object(value);
+  if (keys.some((k) => v[k] !== expected[k])) throw new Error("level_editor_stale_runtime");
+  return v;
+}
+function cloneDocuments(value) {
+  const v = object(value);
+  const walk = (item, depth = 0) => {
+    if (depth > 64) throw new Error("level_editor_snapshot_limit");
+    if (item === null || typeof item === "string" || typeof item === "boolean") return;
+    if (typeof item === "number" && Number.isFinite(item)) return;
+    if (!item || typeof item !== "object") throw new Error("level_editor_invalid_snapshot");
+    if (Array.isArray(item)) {
+      for (const child of item) walk(child, depth + 1);
+    } else
+      for (const [key, child] of Object.entries(item)) {
+        if (["__proto__", "constructor", "prototype"].includes(key))
+          throw new Error("level_editor_unsafe_key");
+        walk(child, depth + 1);
+      }
+  };
+  walk(v);
+  if (JSON.stringify(v).length > 16 * 1024 * 1024) throw new Error("level_editor_snapshot_limit");
+  return structuredClone(v);
+}
+function createLevelEditorRuntime(options) {
+  assertBinding2(options.binding);
+  if (!options.commands.length || options.commands.length > 256 || new Set(options.commands).size !== options.commands.length || options.commands.some((k) => typeof k !== "string" || !k || k.length > 128))
+    throw new Error("level_editor_invalid_capabilities");
+  const binding = structuredClone(options.binding);
+  const lifecycle = {
+    version: 1,
+    canCancel: true,
+    requiresNewFrameOnFailure: true,
+    applicationTimeoutMs: boundedInteger(options.applicationTimeoutMs, 25e3, 25e3),
+    disposeTimeoutMs: boundedInteger(options.disposeTimeoutMs, 2e3, 5e3),
+    maxPendingSnapshots: boundedInteger(options.maxPendingSnapshots, 8, 64)
+  };
+  let identity;
+  const retiredHosts = /* @__PURE__ */ new Set();
+  let revision2 = -1, documentsKey = "", disposed = false;
+  let queue = Promise.resolve();
+  let abort = new AbortController();
+  let retired;
+  let cleanup;
+  const pending = /* @__PURE__ */ new Set();
+  const assertAlive = () => {
+    if (retired) throw retired;
+    if (disposed) throw new Error("level_editor_disposed");
+  };
+  function finish(job, error, result) {
+    if (!pending.delete(job)) return;
+    clearTimeout(job.timer);
+    if (error !== void 0) job.reject(error);
+    else job.resolve(result);
+  }
+  function startCleanup(reason) {
+    if (cleanup) return cleanup;
+    const controller = new AbortController();
+    cleanup = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const error = new LevelEditorFrameResetError("dispose_timeout");
+        controller.abort(error);
+        reject(error);
+      }, lifecycle.disposeTimeoutMs);
+      Promise.resolve().then(() => options.adapter.dispose({ signal: controller.signal, reason })).then(
+        () => {
+          clearTimeout(timer);
+          resolve();
+        },
+        (error) => {
+          clearTimeout(timer);
+          const failure = new LevelEditorFrameResetError("dispose_failed", error);
+          controller.abort(failure);
+          reject(failure);
+        }
+      );
+    });
+    void cleanup.catch(() => {
+    });
+    return cleanup;
+  }
+  function retire(reason, cause) {
+    if (retired) return retired;
+    retired = new LevelEditorFrameResetError(reason, cause);
+    abort.abort(retired);
+    for (const job of pending) finish(job, retired);
+    void startCleanup(reason);
+    return retired;
+  }
+  return {
+    hello(value) {
+      assertAlive();
+      const v = match(value, binding, bindingKeys);
+      if (v.protocolVersion !== 1 || typeof v.hostSessionId !== "string" || !v.hostSessionId || !Number.isSafeInteger(v.frameEpoch) || Number(v.frameEpoch) < 0)
+        throw new Error("level_editor_invalid_hello");
+      if (retiredHosts.has(v.hostSessionId) || identity && identity.hostSessionId === v.hostSessionId && Number(v.frameEpoch) < identity.frameEpoch)
+        throw new Error("level_editor_stale_runtime");
+      if (identity && (identity.hostSessionId !== v.hostSessionId || identity.frameEpoch !== v.frameEpoch)) {
+        if (pending.size) throw retire("host_replaced_during_application");
+        if (identity.hostSessionId !== v.hostSessionId) retiredHosts.add(identity.hostSessionId);
+        abort.abort();
+        abort = new AbortController();
+        revision2 = -1;
+        documentsKey = "";
+        identity = void 0;
+      }
+      identity ??= {
+        ...binding,
+        protocolVersion: 1,
+        hostSessionId: v.hostSessionId,
+        frameEpoch: Number(v.frameEpoch),
+        runtimeInstanceId: crypto.randomUUID()
+      };
+      return { ...identity, commands: [...options.commands], lifecycle: { ...lifecycle } };
+    },
+    snapshot(value) {
+      if (retired) return Promise.reject(retired);
+      if (!identity || disposed) return Promise.reject(new Error("level_editor_not_connected"));
+      const v = match(value, identity, identityKeys2);
+      if (!Number.isSafeInteger(v.draftRevision) || Number(v.draftRevision) < 0 || !["edit", "play"].includes(String(v.mode)))
+        return Promise.reject(new Error("level_editor_invalid_snapshot"));
+      const documents = cloneDocuments(v.documents), selection = object(v.selection);
+      if (Object.entries(selection).some(
+        ([key2, item]) => ["__proto__", "constructor", "prototype"].includes(key2) || !(typeof item === "string" || typeof item === "number" && Number.isFinite(item))
+      ))
+        return Promise.reject(new Error("level_editor_invalid_selection"));
+      const incoming = Number(v.draftRevision), key = JSON.stringify(documents);
+      const requestIdentity = { ...identity };
+      const context = {
+        documents,
+        selection: structuredClone(selection),
+        draftRevision: incoming,
+        mode: v.mode,
+        signal: abort.signal
+      };
+      if (pending.size >= lifecycle.maxPendingSnapshots)
+        return Promise.reject(retire("pending_limit"));
+      return new Promise((resolve, reject) => {
+        const job = {
+          revision: incoming,
+          resolve,
+          reject,
+          timer: setTimeout(() => retire("application_timeout"), lifecycle.applicationTimeoutMs)
+        };
+        pending.add(job);
+        queue = queue.catch(() => {
+        }).then(async () => {
+          if (!pending.has(job)) return;
+          try {
+            assertAlive();
+            if (incoming < revision2 || incoming === revision2 && key !== documentsKey) {
+              finish(job, new Error("level_editor_stale_snapshot"));
+              return;
+            }
+            if (context.mode === "edit") await options.adapter.enterEdit(context);
+            else await options.adapter.loadLevel(context);
+            assertAlive();
+            context.signal.throwIfAborted();
+            await options.adapter.afterRender(context);
+            assertAlive();
+            context.signal.throwIfAborted();
+            match(identity, requestIdentity, identityKeys2);
+            revision2 = incoming;
+            documentsKey = key;
+            finish(job, void 0, {
+              ...requestIdentity,
+              applied: true,
+              draftRevision: incoming,
+              mode: context.mode
+            });
+          } catch (error) {
+            retire("adapter_failed", error);
+          }
+        });
+      });
+    },
+    cancel(value) {
+      assertAlive();
+      if (!identity) throw new Error("level_editor_not_connected");
+      const v = match(value, identity, identityKeys2);
+      if (!Number.isSafeInteger(v.draftRevision) || Number(v.draftRevision) < 0)
+        throw new Error("level_editor_invalid_snapshot");
+      const cancelled = [...pending].some((job) => job.revision === v.draftRevision);
+      if (cancelled) retire("application_cancelled");
+      return { ...identity, cancelled, requiresNewFrame: cancelled };
+    },
+    dispose(value) {
+      if (value !== void 0) {
+        if (!identity) throw new Error("level_editor_not_connected");
+        match(value, identity, identityKeys2);
+      }
+      disposed = true;
+      retire("disposed");
+      return startCleanup("disposed");
+    }
+  };
+}
+function readLevelEditorPreviewContext() {
+  const profiles = document.querySelectorAll(
+    'script#playcraft-level-editor-profile[type="application/json"]'
+  );
+  if (profiles.length !== 1) throw new Error("level_editor_build_profile_missing");
+  const profile = object(JSON.parse(profiles[0].textContent ?? ""));
+  if (profile.protocolVersion !== 1) throw new Error("level_editor_build_profile_invalid");
+  assertBinding2(profile.binding);
+  const mark = "playcraft-preview-storage:";
+  if (!window.name.startsWith(mark)) throw new Error("level_editor_parent_missing");
+  const context = object(
+    object(JSON.parse(window.name.slice(mark.length))).__playcraft_level_editor_context__
+  );
+  const parentOrigin = String(context.parentOrigin);
+  if (new URL(parentOrigin).origin !== parentOrigin || !/^https?:/.test(parentOrigin))
+    throw new Error("level_editor_parent_invalid");
+  return { binding: structuredClone(profile.binding), parentOrigin };
+}
+function connectLevelEditorRuntime(options) {
+  if (new URL(options.parentOrigin).origin !== options.parentOrigin || !/^https?:/.test(options.parentOrigin))
+    throw new Error("level_editor_parent_invalid");
+  const runtime = createLevelEditorRuntime(options);
+  const bridge = new Bridge({
+    peer: () => window.parent,
+    targetOrigin: options.parentOrigin,
+    allowedOrigins: [options.parentOrigin],
+    strictSource: true
+  });
+  const off = [
+    bridge.on(BridgeMethods.levelEditor.hello, (value) => runtime.hello(value)),
+    bridge.on(BridgeMethods.levelEditor.snapshot, (value) => runtime.snapshot(value)),
+    bridge.on(BridgeMethods.levelEditor.cancel, (value) => runtime.cancel(value)),
+    bridge.on(BridgeMethods.levelEditor.dispose, async (value) => {
+      await runtime.dispose(value);
+      return { disposed: true };
+    })
+  ];
+  return {
+    runtime,
+    async dispose() {
+      off.forEach((fn) => fn());
+      bridge.destroy();
+      await runtime.dispose();
+    }
+  };
+}
+function createLevelEditorHost(options) {
+  assertBinding2(options.binding);
+  const requestTimeoutMs = boundedInteger(options.requestTimeoutMs, 3e4, 3e4);
+  const connectTimeoutMs = boundedInteger(options.connectTimeoutMs, 8e3, 8e3);
+  const hello = {
+    ...structuredClone(options.binding),
+    protocolVersion: 1,
+    hostSessionId: crypto.randomUUID(),
+    frameEpoch: options.frameEpoch ?? 0
+  };
+  const bridge = new Bridge({
+    peer: () => options.iframe.contentWindow,
+    targetOrigin: options.opaque ? "*" : options.targetOrigin,
+    allowedOrigins: options.opaque ? ["null"] : [options.targetOrigin],
+    strictSource: true
+  });
+  let identity;
+  let disposed = false;
+  let retired;
+  const connecting = /* @__PURE__ */ new Set();
+  const pending = /* @__PURE__ */ new Map();
+  function cancelRemote(revision2) {
+    if (!identity?.lifecycle?.canCancel) return;
+    const controller = new AbortController();
+    void bridge.emit(
+      BridgeMethods.levelEditor.cancel,
+      { ...identity, draftRevision: revision2 },
+      { timeout: 1e3, signal: controller.signal }
+    ).catch(() => {
+    });
+    controller.abort();
+  }
+  function retire(reason, cause) {
+    if (retired) return retired;
+    retired = new LevelEditorFrameResetError(reason, cause);
+    for (const controller of connecting) controller.abort(retired);
+    for (const [controller, revision2] of pending) {
+      cancelRemote(revision2);
+      controller.abort(retired);
+    }
+    return retired;
+  }
+  return {
+    async connect() {
+      if (retired) throw retired;
+      if (disposed) throw new Error("level_editor_host_disposed");
+      const controller = new AbortController();
+      connecting.add(controller);
+      try {
+        const value = object(
+          await bridge.emit(BridgeMethods.levelEditor.hello, hello, {
+            timeout: connectTimeoutMs,
+            signal: controller.signal
+          })
+        );
+        if (retired) throw retired;
+        match(value, hello, [...bindingKeys, "protocolVersion", "hostSessionId", "frameEpoch"]);
+        if (disposed || typeof value.runtimeInstanceId !== "string" || !value.runtimeInstanceId || !Array.isArray(value.commands) || !value.commands.length || value.commands.length > 256 || value.commands.some((k) => typeof k !== "string" || !k))
+          throw new Error("level_editor_invalid_capabilities");
+        if (value.lifecycle !== void 0) {
+          const policy = object(value.lifecycle);
+          if (policy.version !== 1 || policy.canCancel !== true || policy.requiresNewFrameOnFailure !== true)
+            throw new Error("level_editor_invalid_capabilities");
+          if (typeof policy.applicationTimeoutMs !== "number" || typeof policy.disposeTimeoutMs !== "number" || typeof policy.maxPendingSnapshots !== "number")
+            throw new Error("level_editor_invalid_capabilities");
+          boundedInteger(policy.applicationTimeoutMs, 25e3, 25e3);
+          boundedInteger(policy.disposeTimeoutMs, 2e3, 5e3);
+          boundedInteger(policy.maxPendingSnapshots, 8, 64);
+        }
+        identity = value;
+        return identity;
+      } catch (error) {
+        if (retired) throw retired;
+        if (isLevelEditorFrameResetError(error)) throw retire("runtime_retired", error);
+        throw error;
+      } finally {
+        connecting.delete(controller);
+      }
+    },
+    async snapshot(input, request = {}) {
+      if (retired) throw retired;
+      if (!identity || disposed) throw new Error("level_editor_not_connected");
+      if (request.signal?.aborted) throw new Error("level_editor_request_aborted");
+      const controller = new AbortController();
+      pending.set(controller, input.draftRevision);
+      const cancelled = () => retire("application_cancelled");
+      request.signal?.addEventListener("abort", cancelled, { once: true });
+      try {
+        const value = object(
+          await bridge.emit(
+            BridgeMethods.levelEditor.snapshot,
+            { ...identity, ...input },
+            { timeout: requestTimeoutMs, signal: controller.signal }
+          )
+        );
+        if (retired) throw retired;
+        match(value, identity, identityKeys2);
+        if (disposed || value.applied !== true || value.draftRevision !== input.draftRevision || value.mode !== input.mode)
+          throw new Error("level_editor_application_mismatch");
+        return value;
+      } catch (error) {
+        throw retire("application_failed", error);
+      } finally {
+        pending.delete(controller);
+        request.signal?.removeEventListener("abort", cancelled);
+      }
+    },
+    dispose() {
+      if (disposed) return;
+      if (pending.size) retire("host_disposed_during_application");
+      disposed = true;
+      for (const controller of connecting) controller.abort();
+      bridge.destroy();
+    }
+  };
+}
 export {
+  LevelEditorFrameResetError,
+  MAX_IMAGE_RESOURCE_BYTES,
+  PROTOCOL_VERSION,
+  ProtocolError,
   ResourceLoadError,
+  SupersededResourceError,
+  applyOperations,
+  assertBinding,
+  assertDocuments,
+  assertHello,
+  assertIdentity,
+  assertImageRefresh,
+  assertImageResourceData,
+  assertImageResourceRequest,
+  assertJson,
+  assertPatch,
+  assertSnapshot,
+  clone,
+  connectLevelEditorRuntime,
   connectPreviewRuntime,
-  readWorkspacePreviewContext
+  createLevelEditorHost,
+  createLevelEditorRuntime,
+  createParameterHost,
+  createParameterRuntime,
+  fingerprint,
+  freeze,
+  isLevelEditorFrameResetError,
+  readLevelEditorPreviewContext,
+  readPath,
+  readWorkspacePreviewContext,
+  revision,
+  sameIdentity
 };