@kotao/storefront 0.2.4 → 0.2.6

package/dist/chunk-XXNCFWXT.js

@@ -0,0 +1,2118 @@
+import { HydrogenEditorManifestSchema, HYDROGEN_EDITOR_MANIFEST_LIMITS, HydrogenInstanceSchema, HydrogenInstanceStylesSchema, HydrogenContentBindingSchema, HydrogenDocumentSchema, HydrogenBreakpointSchema, HydrogenComponentDefinitionSchema, HydrogenEditCapabilitySchema, HydrogenSourceLocationSchema, HydrogenUnsupportedFindingSchema } from '@kotao/storefront-contracts';
+
+// src/editor/hydrogen.ts
+var HOST_SOURCE = "kotao:workspaces-hydrogen-editor";
+var PREVIEW_SOURCE = "kotao:storefront-hydrogen-preview";
+var SHA_1 = /^[a-f0-9]{40}$/;
+var SHA_256 = /^[a-f0-9]{64}$/;
+var OPAQUE_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+var CHANNEL_NONCE = /^[A-Za-z0-9_-]{32,256}$/;
+var OPERATION_FAILURE_CODES = /* @__PURE__ */ new Set([
+  "CAPABILITY_DENIED",
+  "COMPONENT_NOT_FOUND",
+  "DOCUMENT_MISMATCH",
+  "DUPLICATE_OPERATION_CONFLICT",
+  "INSTANCE_NOT_FOUND",
+  "INVALID_OPERATION",
+  "OPERATION_LIMIT_EXCEEDED",
+  "REVISION_MISMATCH",
+  "SLOT_CONSTRAINT",
+  "UNSUPPORTED_BOUNDARY"
+]);
+var PROTOCOL_FAILURE_CODES = /* @__PURE__ */ new Set([
+  "AUTH_CONTEXT_MISMATCH",
+  "BUFFER_LIMIT_EXCEEDED",
+  "DUPLICATE_MESSAGE_CONFLICT",
+  "MESSAGE_EXPIRED",
+  "MESSAGE_TOO_DEEP",
+  "MESSAGE_TOO_LARGE",
+  "SEQUENCE_STALE",
+  "UNKNOWN_MESSAGE",
+  "UNSUPPORTED_PROTOCOL"
+]);
+var HYDROGEN_EDITOR_PROTOCOL_VERSION = 1;
+var HYDROGEN_EDITOR_BRIDGE_LIMITS = {
+  maxMessageBytes: 131072,
+  maxMessageDepth: 32,
+  maxBufferedMessages: 100,
+  maxDraftOperations: 1e3,
+  maxProcessedMessages: 2048
+};
+var HydrogenEditorConfigurationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HydrogenEditorConfigurationError";
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlyKeys(value, keys) {
+  const allowed = new Set(keys);
+  return Object.keys(value).every((key) => allowed.has(key));
+}
+function isOpaqueId(value) {
+  return typeof value === "string" && OPAQUE_ID.test(value);
+}
+function isNonnegativeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isPositiveInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function exactOrigin(value, label) {
+  try {
+    const parsed = new URL(value);
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:" || parsed.username !== "" || parsed.password !== "" || parsed.origin !== value || parsed.pathname !== "/" || parsed.search !== "" || parsed.hash !== "") {
+      throw new Error("not an exact origin");
+    }
+    return value;
+  } catch {
+    throw new HydrogenEditorConfigurationError(`${label} must be an exact http(s) origin`);
+  }
+}
+function validateSecurityContext(security, now) {
+  if (!isOpaqueId(security.sessionId)) {
+    throw new HydrogenEditorConfigurationError("sessionId must be a bounded opaque identifier");
+  }
+  if (!SHA_1.test(security.baseSha)) {
+    throw new HydrogenEditorConfigurationError("baseSha must be a 40-character lowercase Git SHA");
+  }
+  if (!SHA_256.test(security.manifestHash)) {
+    throw new HydrogenEditorConfigurationError("manifestHash must be a lowercase SHA-256 digest");
+  }
+  if (!CHANNEL_NONCE.test(security.channelNonce)) {
+    throw new HydrogenEditorConfigurationError(
+      "channelNonce must be a 32..256 character base64url value"
+    );
+  }
+  if (security.previewToken.length < 32 || security.previewToken.length > 4096) {
+    throw new HydrogenEditorConfigurationError("previewToken must contain 32..4096 characters");
+  }
+  if (!Number.isSafeInteger(security.expiresAt) || security.expiresAt <= now) {
+    throw new HydrogenEditorConfigurationError("editor preview security context is expired");
+  }
+}
+function jsonSignature(value) {
+  const ancestors = /* @__PURE__ */ new Set();
+  const visit = (candidate, depth) => {
+    if (depth > HYDROGEN_EDITOR_BRIDGE_LIMITS.maxMessageDepth) return false;
+    if (candidate === null || typeof candidate === "string" || typeof candidate === "boolean" || typeof candidate === "number" && Number.isFinite(candidate)) {
+      return true;
+    }
+    if (typeof candidate !== "object") return false;
+    if (ancestors.has(candidate)) return false;
+    ancestors.add(candidate);
+    let valid;
+    if (Array.isArray(candidate)) {
+      valid = candidate.every((item) => visit(item, depth + 1));
+    } else {
+      const record = candidate;
+      valid = Object.values(record).every((item) => visit(item, depth + 1));
+    }
+    ancestors.delete(candidate);
+    return valid;
+  };
+  if (!visit(value, 0)) return null;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return null;
+  }
+}
+function protocolFailure(code, message) {
+  return { code, message };
+}
+function parseProtocolFailure(value) {
+  return isRecord(value) && typeof value.code === "string" && PROTOCOL_FAILURE_CODES.has(value.code) && typeof value.message === "string" && value.message.length <= 2048 ? value : null;
+}
+function operationFailure(code, message, instance, capability) {
+  return {
+    code,
+    message,
+    ...instance !== void 0 ? { instanceId: instance.instanceId, source: instance.source } : {},
+    ...capability !== void 0 ? { capability } : {}
+  };
+}
+function rejectOperation(operation, revision, failure) {
+  return {
+    status: "rejected",
+    revision,
+    operationId: operation.operationId,
+    failure
+  };
+}
+function parseOperation(value) {
+  if (!isRecord(value) || !isOpaqueId(value.operationId) || !isPositiveInteger(value.revision) || typeof value.type !== "string") {
+    return null;
+  }
+  const base = {
+    operationId: value.operationId,
+    revision: value.revision
+  };
+  switch (value.type) {
+    case "prop.patch": {
+      if (!hasOnlyKeys(value, [
+        "type",
+        "operationId",
+        "revision",
+        "instanceId",
+        "propName",
+        "binding"
+      ]) || !isOpaqueId(value.instanceId) || typeof value.propName !== "string" || value.propName.length === 0 || value.propName.length > 128) {
+        return null;
+      }
+      const binding = HydrogenContentBindingSchema.safeParse(value.binding);
+      return binding.success ? {
+        ...base,
+        type: "prop.patch",
+        instanceId: value.instanceId,
+        propName: value.propName,
+        binding: binding.data
+      } : null;
+    }
+    case "styles.patch": {
+      if (!hasOnlyKeys(value, ["type", "operationId", "revision", "instanceId", "styles"]) || !isOpaqueId(value.instanceId)) {
+        return null;
+      }
+      const styles = HydrogenInstanceStylesSchema.safeParse(value.styles);
+      return styles.success ? {
+        ...base,
+        type: "styles.patch",
+        instanceId: value.instanceId,
+        styles: styles.data
+      } : null;
+    }
+    case "variant.set":
+      return hasOnlyKeys(value, ["type", "operationId", "revision", "instanceId", "variantId"]) && isOpaqueId(value.instanceId) && (value.variantId === null || isOpaqueId(value.variantId)) ? {
+        ...base,
+        type: "variant.set",
+        instanceId: value.instanceId,
+        variantId: value.variantId
+      } : null;
+    case "slot.insert": {
+      if (!hasOnlyKeys(value, [
+        "type",
+        "operationId",
+        "revision",
+        "parentInstanceId",
+        "slotId",
+        "index",
+        "instance"
+      ]) || !isOpaqueId(value.parentInstanceId) || !isOpaqueId(value.slotId) || !isNonnegativeInteger(value.index) || !isRecord(value.instance)) {
+        return null;
+      }
+      const parsed = HydrogenInstanceSchema.safeParse({ ...value.instance, parent: null });
+      if (!parsed.success) return null;
+      const instance = {
+        instanceId: parsed.data.instanceId,
+        componentId: parsed.data.componentId,
+        documentId: parsed.data.documentId,
+        source: parsed.data.source,
+        ...parsed.data.variantId !== void 0 ? { variantId: parsed.data.variantId } : {},
+        props: parsed.data.props,
+        styles: parsed.data.styles
+      };
+      return {
+        ...base,
+        type: "slot.insert",
+        parentInstanceId: value.parentInstanceId,
+        slotId: value.slotId,
+        index: value.index,
+        instance
+      };
+    }
+    case "instance.move":
+      return hasOnlyKeys(value, [
+        "type",
+        "operationId",
+        "revision",
+        "instanceId",
+        "parentInstanceId",
+        "slotId",
+        "index"
+      ]) && isOpaqueId(value.instanceId) && isOpaqueId(value.parentInstanceId) && isOpaqueId(value.slotId) && isNonnegativeInteger(value.index) ? {
+        ...base,
+        type: "instance.move",
+        instanceId: value.instanceId,
+        parentInstanceId: value.parentInstanceId,
+        slotId: value.slotId,
+        index: value.index
+      } : null;
+    case "instance.remove":
+      return hasOnlyKeys(value, ["type", "operationId", "revision", "instanceId"]) && isOpaqueId(value.instanceId) ? {
+        ...base,
+        type: "instance.remove",
+        instanceId: value.instanceId
+      } : null;
+    default:
+      return null;
+  }
+}
+var DIRECT_CANVAS_LAYOUT_CONTROLS = /* @__PURE__ */ new Set(["gap", "height", "margin", "padding", "width"]);
+function parseHydrogenEditorCanvasIntent(value) {
+  if (!isRecord(value) || typeof value.type !== "string") return null;
+  switch (value.type) {
+    case "instance.move":
+      return hasOnlyKeys(value, ["type", "instanceId", "parentInstanceId", "slotId", "index"]) && isOpaqueId(value.instanceId) && isOpaqueId(value.parentInstanceId) && isOpaqueId(value.slotId) && isNonnegativeInteger(value.index) ? {
+        type: "instance.move",
+        instanceId: value.instanceId,
+        parentInstanceId: value.parentInstanceId,
+        slotId: value.slotId,
+        index: value.index
+      } : null;
+    case "prop.inline":
+      return hasOnlyKeys(value, ["type", "instanceId", "propName", "value"]) && isOpaqueId(value.instanceId) && typeof value.propName === "string" && value.propName.length > 0 && value.propName.length <= 128 && typeof value.value === "string" && value.value.length <= 1e4 ? {
+        type: "prop.inline",
+        instanceId: value.instanceId,
+        propName: value.propName,
+        value: value.value
+      } : null;
+    case "styles.adjust":
+      return hasOnlyKeys(value, ["type", "instanceId", "controlId", "value", "breakpointId"]) && isOpaqueId(value.instanceId) && isOpaqueId(value.controlId) && typeof value.value === "number" && Number.isFinite(value.value) && value.value >= 0 && value.value <= 4096 && (value.breakpointId === void 0 || isOpaqueId(value.breakpointId)) ? {
+        type: "styles.adjust",
+        instanceId: value.instanceId,
+        controlId: value.controlId,
+        value: Math.round(value.value * 100) / 100,
+        ...value.breakpointId !== void 0 ? { breakpointId: value.breakpointId } : {}
+      } : null;
+    case "slot.insert.request":
+      return hasOnlyKeys(value, ["type", "parentInstanceId", "slotId", "index"]) && isOpaqueId(value.parentInstanceId) && isOpaqueId(value.slotId) && isNonnegativeInteger(value.index) ? {
+        type: "slot.insert.request",
+        parentInstanceId: value.parentInstanceId,
+        slotId: value.slotId,
+        index: value.index
+      } : null;
+    default:
+      return null;
+  }
+}
+function parseEnvelope(value, source, security, state, now) {
+  const signature = jsonSignature(value);
+  if (signature === null) {
+    return protocolFailure("MESSAGE_TOO_DEEP", "message is cyclic, non-JSON, or exceeds depth 32");
+  }
+  if (new TextEncoder().encode(signature).byteLength > HYDROGEN_EDITOR_BRIDGE_LIMITS.maxMessageBytes) {
+    return protocolFailure("MESSAGE_TOO_LARGE", "message exceeds 128 KiB");
+  }
+  if (!isRecord(value)) {
+    return protocolFailure("UNKNOWN_MESSAGE", "message must be an object");
+  }
+  if (value.protocolVersion !== HYDROGEN_EDITOR_PROTOCOL_VERSION) {
+    return protocolFailure("UNSUPPORTED_PROTOCOL", "unsupported Hydrogen editor protocol version");
+  }
+  if (value.source !== source || value.sessionId !== security.sessionId || value.baseSha !== security.baseSha || value.manifestHash !== security.manifestHash || value.channelNonce !== security.channelNonce || value.previewToken !== security.previewToken) {
+    return protocolFailure(
+      "AUTH_CONTEXT_MISMATCH",
+      "message does not match the active editor session"
+    );
+  }
+  if (now >= security.expiresAt) {
+    return protocolFailure("MESSAGE_EXPIRED", "editor preview token has expired");
+  }
+  if (!isOpaqueId(value.messageId) || !isPositiveInteger(value.sequence) || typeof value.type !== "string" || value.type.length > 128) {
+    return protocolFailure("UNKNOWN_MESSAGE", "message envelope is invalid");
+  }
+  const previous = state.messages.get(value.messageId);
+  if (previous !== void 0) {
+    return previous === signature ? { envelope: value, duplicate: true } : protocolFailure(
+      "DUPLICATE_MESSAGE_CONFLICT",
+      "messageId was reused with a different payload"
+    );
+  }
+  if (value.sequence <= state.sequence) {
+    return protocolFailure("SEQUENCE_STALE", "message sequence is not newer than the last message");
+  }
+  state.sequence = value.sequence;
+  state.messages.set(value.messageId, signature);
+  if (state.messages.size > HYDROGEN_EDITOR_BRIDGE_LIMITS.maxProcessedMessages) {
+    const oldest = state.messages.keys().next().value;
+    if (typeof oldest === "string") state.messages.delete(oldest);
+  }
+  return { envelope: value, duplicate: false };
+}
+function createEnvelope(source, security, sequence, type, payload) {
+  return {
+    source,
+    protocolVersion: HYDROGEN_EDITOR_PROTOCOL_VERSION,
+    sessionId: security.sessionId,
+    baseSha: security.baseSha,
+    manifestHash: security.manifestHash,
+    channelNonce: security.channelNonce,
+    previewToken: security.previewToken,
+    messageId: `${source === HOST_SOURCE ? "host" : "preview"}:${sequence}`,
+    sequence,
+    type,
+    ...payload !== void 0 ? { payload } : {}
+  };
+}
+function postEnvelope(target, targetOrigin, envelope) {
+  const signature = jsonSignature(envelope);
+  if (signature === null || new TextEncoder().encode(signature).byteLength > HYDROGEN_EDITOR_BRIDGE_LIMITS.maxMessageBytes) {
+    throw new HydrogenEditorConfigurationError("outbound editor message exceeds protocol bounds");
+  }
+  target.postMessage(envelope, targetOrigin);
+}
+function findingsForInstance(manifest, instance, component) {
+  const anchors = /* @__PURE__ */ new Set([instance.source.anchorId, component.source.anchorId]);
+  return manifest.unsupportedFindings.filter((finding) => {
+    switch (finding.target.kind) {
+      case "manifest":
+        return true;
+      case "component":
+        return finding.target.componentId === component.componentId;
+      case "instance":
+        return finding.target.instanceId === instance.instanceId;
+      case "source":
+        return anchors.has(finding.target.anchorId);
+    }
+  }).map((finding) => ({
+    code: finding.code,
+    severity: finding.severity,
+    message: finding.message,
+    ...finding.capability !== void 0 ? { capability: finding.capability } : {},
+    ...finding.source !== void 0 ? { source: finding.source } : {}
+  }));
+}
+function instanceIdsForDocument(instances, documentId) {
+  return [...instances.values()].filter((instance) => instance.documentId === documentId).sort((left, right) => left.instanceId.localeCompare(right.instanceId)).map((instance) => instance.instanceId);
+}
+function childrenForSlot(instances, parentInstanceId, slotId) {
+  return [...instances.values()].filter(
+    (instance) => instance.parent?.instanceId === parentInstanceId && instance.parent.slotId === slotId
+  ).sort((left, right) => (left.parent?.index ?? 0) - (right.parent?.index ?? 0));
+}
+function resolvedProps(instance, component) {
+  const variant = component.variants.find((candidate) => candidate.variantId === instance.variantId);
+  const defaults = Object.fromEntries(
+    component.props.flatMap(
+      (control) => control.defaultBinding === void 0 ? [] : [[control.propName, control.defaultBinding]]
+    )
+  );
+  return Object.fromEntries(
+    Object.entries({ ...defaults, ...instance.props, ...variant?.props }).flatMap(
+      ([propName, binding]) => binding.kind === "inline" ? [[propName, binding.value]] : []
+    )
+  );
+}
+function bindingMatchesControl(binding, control) {
+  if (!control.allowedBindings.includes(binding.kind)) return false;
+  if (binding.kind === "external") return true;
+  const value = binding.value;
+  switch (control.control) {
+    case "number":
+      return typeof value === "number" && Number.isFinite(value) && (control.min === void 0 || value >= control.min) && (control.max === void 0 || value <= control.max);
+    case "boolean":
+      return typeof value === "boolean";
+    case "select":
+      return typeof value === "string" && control.options.some((option) => option.value === value);
+    case "text":
+    case "textarea":
+    case "richtext":
+    case "color":
+    case "image":
+    case "url":
+    case "product":
+    case "collection":
+      return typeof value === "string";
+  }
+}
+function styleValueAllowed(value, allowedValues) {
+  return (typeof value === "string" || typeof value === "number" && Number.isFinite(value)) && (allowedValues === void 0 || allowedValues.includes(String(value)));
+}
+function instanceMatchesComponentContract(manifest, instance, component) {
+  const controls = new Map(component.props.map((control) => [control.propName, control]));
+  for (const [propName, binding] of Object.entries(instance.props)) {
+    const control = controls.get(propName);
+    if (control === void 0 || !bindingMatchesControl(binding, control)) return false;
+  }
+  if (component.props.some(
+    (control) => control.required && instance.props[control.propName] === void 0 && control.defaultBinding === void 0
+  )) {
+    return false;
+  }
+  if (instance.variantId !== void 0 && !component.variants.some((variant) => variant.variantId === instance.variantId)) {
+    return false;
+  }
+  const tokenControls = new Map(component.styles.tokens.map((token) => [token.tokenId, token]));
+  const layoutControls = new Map(
+    component.styles.layout.map((control) => [control.controlId, control])
+  );
+  const breakpoints = new Set(manifest.breakpoints.map((breakpoint) => breakpoint.breakpointId));
+  const overrideIds = /* @__PURE__ */ new Set();
+  for (const override of instance.styles.overrides) {
+    if (!component.styles.responsive || !breakpoints.has(override.breakpointId) || overrideIds.has(override.breakpointId)) {
+      return false;
+    }
+    overrideIds.add(override.breakpointId);
+  }
+  for (const values of [
+    instance.styles.base,
+    ...instance.styles.overrides.map((override) => override.values)
+  ]) {
+    for (const [tokenId, value] of Object.entries(values.tokens)) {
+      const control = tokenControls.get(tokenId);
+      if (control === void 0 || !styleValueAllowed(value, control.allowedValues)) return false;
+    }
+    for (const [controlId, value] of Object.entries(values.layout)) {
+      const control = layoutControls.get(controlId);
+      if (control === void 0 || !styleValueAllowed(value, control.allowedValues)) return false;
+    }
+  }
+  return true;
+}
+function cloneManifest(manifest) {
+  return HydrogenEditorManifestSchema.parse(manifest);
+}
+var HydrogenEditorPreviewStoreImpl = class {
+  manifest;
+  components;
+  documents;
+  instances = /* @__PURE__ */ new Map();
+  mounted = /* @__PURE__ */ new Set();
+  operations = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  instanceListeners = /* @__PURE__ */ new Map();
+  snapshotCache = null;
+  instanceSnapshotCache = /* @__PURE__ */ new Map();
+  documentId;
+  route;
+  revision = 0;
+  selectedInstanceId = null;
+  hoveredInstanceId = null;
+  constructor(manifest, documentId, route) {
+    this.manifest = cloneManifest(manifest);
+    this.components = new Map(
+      this.manifest.components.map((component) => [component.componentId, component])
+    );
+    this.documents = new Map(
+      this.manifest.documents.map((document) => [document.documentId, document])
+    );
+    for (const instance of this.manifest.instances)
+      this.instances.set(instance.instanceId, instance);
+    if (!this.documents.has(documentId)) {
+      throw new HydrogenEditorConfigurationError(`unknown Hydrogen document "${documentId}"`);
+    }
+    this.documentId = documentId;
+    this.route = route;
+  }
+  getSnapshot() {
+    if (this.snapshotCache !== null) return this.snapshotCache;
+    const document = this.documents.get(this.documentId);
+    if (document === void 0) {
+      throw new HydrogenEditorConfigurationError(`unknown Hydrogen document "${this.documentId}"`);
+    }
+    const instanceIds = instanceIdsForDocument(this.instances, this.documentId);
+    const selected = this.selectedInstanceId;
+    const selectedInstance = selected === null ? void 0 : this.instances.get(selected);
+    this.snapshotCache = {
+      document,
+      ...this.route !== void 0 ? { route: this.route } : {},
+      revision: this.revision,
+      selectedInstanceId: selected,
+      hoveredInstanceId: this.hoveredInstanceId,
+      selectionStatus: selected === null ? "none" : selectedInstance?.documentId === this.documentId ? "active" : "out-of-route",
+      instanceIds,
+      mountedInstanceIds: instanceIds.filter((instanceId) => this.mounted.has(instanceId))
+    };
+    return this.snapshotCache;
+  }
+  getInstanceSnapshot(instanceId) {
+    if (this.instanceSnapshotCache.has(instanceId)) {
+      return this.instanceSnapshotCache.get(instanceId) ?? null;
+    }
+    const instance = this.instances.get(instanceId);
+    const component = instance === void 0 ? void 0 : this.components.get(instance.componentId);
+    if (instance === void 0 || component === void 0) {
+      this.instanceSnapshotCache.set(instanceId, null);
+      return null;
+    }
+    const childInstanceIds = Object.fromEntries(
+      component.slots.map((slot) => [
+        slot.slotId,
+        childrenForSlot(this.instances, instanceId, slot.slotId).map((child) => child.instanceId)
+      ])
+    );
+    const capabilityReasons = findingsForInstance(this.manifest, instance, component);
+    const snapshot = {
+      instance,
+      component,
+      childInstanceIds,
+      resolvedProps: resolvedProps(instance, component),
+      mounted: this.mounted.has(instanceId),
+      editable: component.capabilities.length > 0 && !capabilityReasons.some((reason) => reason.severity === "blocking"),
+      capabilityReasons
+    };
+    this.instanceSnapshotCache.set(instanceId, snapshot);
+    return snapshot;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  subscribeInstance(instanceId, listener) {
+    const listeners = this.instanceListeners.get(instanceId) ?? /* @__PURE__ */ new Set();
+    listeners.add(listener);
+    this.instanceListeners.set(instanceId, listeners);
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size === 0) this.instanceListeners.delete(instanceId);
+    };
+  }
+  setMounted(instanceId, mounted) {
+    if (!this.instances.has(instanceId)) return;
+    const changed = mounted ? !this.mounted.has(instanceId) : this.mounted.has(instanceId);
+    if (!changed) return;
+    if (mounted) this.mounted.add(instanceId);
+    else this.mounted.delete(instanceId);
+    this.emit(/* @__PURE__ */ new Set([instanceId]));
+  }
+  setSelection(instanceId) {
+    if (instanceId !== null && !this.instances.has(instanceId)) return false;
+    if (this.selectedInstanceId === instanceId) return true;
+    this.selectedInstanceId = instanceId;
+    this.emit(/* @__PURE__ */ new Set());
+    return true;
+  }
+  setHover(instanceId) {
+    if (instanceId !== null && !this.instances.has(instanceId)) return false;
+    if (this.hoveredInstanceId === instanceId) return true;
+    this.hoveredInstanceId = instanceId;
+    this.emit(/* @__PURE__ */ new Set());
+    return true;
+  }
+  reconcile(documentId, route) {
+    if (!this.documents.has(documentId)) {
+      throw new HydrogenEditorConfigurationError(`unknown Hydrogen document "${documentId}"`);
+    }
+    this.documentId = documentId;
+    this.route = route;
+    if (this.hoveredInstanceId !== null && this.instances.get(this.hoveredInstanceId)?.documentId !== documentId) {
+      this.hoveredInstanceId = null;
+    }
+    this.emit(/* @__PURE__ */ new Set());
+  }
+  emit(changedInstanceIds) {
+    this.snapshotCache = null;
+    for (const instanceId of changedInstanceIds) {
+      this.instanceSnapshotCache.delete(instanceId);
+      for (const listener of this.instanceListeners.get(instanceId) ?? []) listener();
+    }
+    for (const listener of this.listeners) listener();
+  }
+  componentFor(instance) {
+    const component = this.components.get(instance.componentId);
+    return component ?? operationFailure(
+      "COMPONENT_NOT_FOUND",
+      `component "${instance.componentId}" is not declared`,
+      instance
+    );
+  }
+  rejectUnsupported(instance, capability) {
+    const component = this.components.get(instance.componentId);
+    if (component === void 0) {
+      return operationFailure(
+        "COMPONENT_NOT_FOUND",
+        `component "${instance.componentId}" is not declared`,
+        instance
+      );
+    }
+    const blocking = findingsForInstance(this.manifest, instance, component).find(
+      (finding) => finding.severity === "blocking" && (finding.capability === void 0 || finding.capability === capability)
+    );
+    return blocking === void 0 ? null : operationFailure(
+      "UNSUPPORTED_BOUNDARY",
+      blocking.message,
+      instance,
+      blocking.capability ?? capability
+    );
+  }
+  requireCapability(instance, capability) {
+    const component = this.componentFor(instance);
+    if ("code" in component) return component;
+    if (!component.capabilities.includes(capability)) {
+      return operationFailure(
+        "CAPABILITY_DENIED",
+        `component "${component.componentId}" does not allow "${capability}" edits`,
+        instance,
+        capability
+      );
+    }
+    return this.rejectUnsupported(instance, capability);
+  }
+  validateStyles(instance, component, styles) {
+    const capabilityFailure = this.requireCapability(instance, "styles") ?? (styles.overrides.length > 0 ? this.requireCapability(instance, "responsive") : null);
+    if (capabilityFailure !== null) return capabilityFailure;
+    const tokenControls = new Map(component.styles.tokens.map((token) => [token.tokenId, token]));
+    const layoutControls = new Map(
+      component.styles.layout.map((control) => [control.controlId, control])
+    );
+    const breakpoints = new Set(this.manifest.breakpoints.map((item) => item.breakpointId));
+    const overrideIds = /* @__PURE__ */ new Set();
+    for (const override of styles.overrides) {
+      if (overrideIds.has(override.breakpointId) || !breakpoints.has(override.breakpointId)) {
+        return operationFailure(
+          "CAPABILITY_DENIED",
+          `responsive breakpoint "${override.breakpointId}" is unknown or duplicated`,
+          instance,
+          "responsive"
+        );
+      }
+      overrideIds.add(override.breakpointId);
+    }
+    const values = [styles.base, ...styles.overrides.map((override) => override.values)];
+    for (const value of values) {
+      for (const [tokenId, tokenValue] of Object.entries(value.tokens)) {
+        const control = tokenControls.get(tokenId);
+        if (control === void 0 || !styleValueAllowed(tokenValue, control.allowedValues)) {
+          return operationFailure(
+            "CAPABILITY_DENIED",
+            `style token "${tokenId}" is undeclared or outside its allowed values`,
+            instance,
+            "styles"
+          );
+        }
+      }
+      for (const [controlId, layoutValue] of Object.entries(value.layout)) {
+        const control = layoutControls.get(controlId);
+        if (control === void 0 || !styleValueAllowed(layoutValue, control.allowedValues)) {
+          return operationFailure(
+            "CAPABILITY_DENIED",
+            `layout control "${controlId}" is undeclared or outside its allowed values`,
+            instance,
+            "styles"
+          );
+        }
+      }
+    }
+    return null;
+  }
+  validateInsertedInstance(instance, component) {
+    const propControls = new Map(component.props.map((control) => [control.propName, control]));
+    for (const [propName, binding] of Object.entries(instance.props)) {
+      const control = propControls.get(propName);
+      const contentCapability = binding.kind === "external" ? "external-content" : "inline-content";
+      const capabilityFailure = this.requireCapability(instance, "props") ?? this.requireCapability(instance, contentCapability);
+      if (control === void 0 || !bindingMatchesControl(binding, control) || capabilityFailure !== null) {
+        return capabilityFailure ?? operationFailure(
+          "CAPABILITY_DENIED",
+          `inserted prop "${propName}" is not declared or violates its control`,
+          instance,
+          contentCapability
+        );
+      }
+    }
+    for (const control of component.props) {
+      if (control.required && instance.props[control.propName] === void 0 && control.defaultBinding === void 0) {
+        return operationFailure(
+          "CAPABILITY_DENIED",
+          `inserted instance is missing required prop "${control.propName}"`,
+          instance,
+          "props"
+        );
+      }
+    }
+    if (instance.variantId !== void 0 && !component.variants.some((variant) => variant.variantId === instance.variantId)) {
+      return operationFailure(
+        "CAPABILITY_DENIED",
+        `variant "${instance.variantId}" is not declared`,
+        instance,
+        "variants"
+      );
+    }
+    const styleValuesPresent = Object.keys(instance.styles.base.tokens).length > 0 || Object.keys(instance.styles.base.layout).length > 0 || instance.styles.overrides.length > 0;
+    if (styleValuesPresent) {
+      const styleFailure = this.validateStyles(instance, component, instance.styles);
+      if (styleFailure !== null) return styleFailure;
+    }
+    const sourceAnchorCollision = this.manifest.components.some(
+      (candidate) => candidate.source.anchorId === instance.source.anchorId
+    ) || [...this.instances.values()].some(
+      (candidate) => candidate.source.anchorId === instance.source.anchorId
+    );
+    if (sourceAnchorCollision) {
+      return operationFailure(
+        "INVALID_OPERATION",
+        `source anchor "${instance.source.anchorId}" is already in use`,
+        instance,
+        "insert"
+      );
+    }
+    return this.rejectUnsupported(instance, "insert");
+  }
+  normalizeSlot(parentInstanceId, slotId) {
+    const changed = /* @__PURE__ */ new Set([parentInstanceId]);
+    for (const [index, child] of childrenForSlot(
+      this.instances,
+      parentInstanceId,
+      slotId
+    ).entries()) {
+      if (child.parent?.index === index) continue;
+      this.instances.set(child.instanceId, {
+        ...child,
+        parent: { instanceId: parentInstanceId, slotId, index }
+      });
+      changed.add(child.instanceId);
+    }
+    return changed;
+  }
+  insertAt(instance, parentInstanceId, slotId, index) {
+    const siblings = childrenForSlot(this.instances, parentInstanceId, slotId);
+    const boundedIndex = Math.min(index, siblings.length);
+    for (const sibling of siblings) {
+      const siblingIndex = sibling.parent?.index ?? 0;
+      if (siblingIndex < boundedIndex) continue;
+      this.instances.set(sibling.instanceId, {
+        ...sibling,
+        parent: { instanceId: parentInstanceId, slotId, index: siblingIndex + 1 }
+      });
+    }
+    this.instances.set(instance.instanceId, {
+      ...instance,
+      parent: { instanceId: parentInstanceId, slotId, index: boundedIndex }
+    });
+    return /* @__PURE__ */ new Set([
+      instance.instanceId,
+      parentInstanceId,
+      ...siblings.map((item) => item.instanceId)
+    ]);
+  }
+  validateSlotTarget(parent, slotId, childComponentId, mode) {
+    const capability = mode === "insert" ? "insert" : "reorder";
+    const capabilityFailure = this.requireCapability(parent, capability);
+    if (capabilityFailure !== null) return capabilityFailure;
+    const component = this.components.get(parent.componentId);
+    const slot = component?.slots.find((candidate) => candidate.slotId === slotId);
+    if (slot === void 0) {
+      return operationFailure(
+        "SLOT_CONSTRAINT",
+        `component "${parent.componentId}" has no slot "${slotId}"`,
+        parent,
+        capability
+      );
+    }
+    if (slot.insertion === "fixed" || mode === "reorder" && slot.insertion !== "reorder" || slot.accepts.mode === "include" && !slot.accepts.componentIds.includes(childComponentId)) {
+      return operationFailure(
+        "SLOT_CONSTRAINT",
+        `slot "${slotId}" does not accept this ${mode} operation`,
+        parent,
+        capability
+      );
+    }
+    return null;
+  }
+  applyValidatedOperation(operation) {
+    switch (operation.type) {
+      case "prop.patch": {
+        const instance = this.instances.get(operation.instanceId);
+        if (instance === void 0) {
+          return {
+            changedInstanceIds: /* @__PURE__ */ new Set(),
+            result: rejectOperation(
+              operation,
+              this.revision,
+              operationFailure(
+                "INSTANCE_NOT_FOUND",
+                `instance "${operation.instanceId}" is not declared`
+              )
+            )
+          };
+        }
+        const component = this.components.get(instance.componentId);
+        const control = component?.props.find((prop) => prop.propName === operation.propName);
+        const requiredCapability = operation.binding.kind === "external" ? "external-content" : "inline-content";
+        const capabilityFailure = this.requireCapability(instance, "props") ?? this.requireCapability(instance, requiredCapability);
+        if (capabilityFailure !== null || control === void 0 || !bindingMatchesControl(operation.binding, control)) {
+          return {
+            changedInstanceIds: /* @__PURE__ */ new Set(),
+            result: rejectOperation(
+              operation,
+              this.revision,
+              capabilityFailure ?? operationFailure(
+                "CAPABILITY_DENIED",
+                `prop "${operation.propName}" does not allow "${operation.binding.kind}" content`,
+                instance,
+                requiredCapability
+              )
+            )
+          };
+        }
+        this.instances.set(instance.instanceId, {
+          ...instance,
+          props: { ...instance.props, [operation.propName]: operation.binding }
+        });
+        return {
+          changedInstanceIds: /* @__PURE__ */ new Set([instance.instanceId]),
+          result: {
+            status: "applied",
+            revision: operation.revision,
+            operationId: operation.operationId
+          }
+        };
+      }
+      case "styles.patch": {
+        const instance = this.instances.get(operation.instanceId);
+        if (instance === void 0) {
+          return {
+            changedInstanceIds: /* @__PURE__ */ new Set(),
+            result: rejectOperation(
+              operation,
+              this.revision,
+              operationFailure(
+                "INSTANCE_NOT_FOUND",
+                `instance "${operation.instanceId}" is not declared`
+              )
+            )
+          };
+        }
+        const component = this.components.get(instance.componentId);
+        const capabilityFailure = component === void 0 ? operationFailure(
+          "COMPONENT_NOT_FOUND",
+          `component "${instance.componentId}" is not declared`,
+          instance
+        ) : this.validateStyles(instance, component, operation.styles);
+        if (capabilityFailure !== null) {
+          return {
+            changedInstanceIds: /* @__PURE__ */ new Set(),
+            result: rejectOperation(operation, this.revision, capabilityFailure)
+          };
+        }
+        this.instances.set(instance.instanceId, { ...instance, styles: operation.styles });
+        return {
+          changedInstanceIds: /* @__PURE__ */ new Set([instance.instanceId]),
+          result: {
+            status: "applied",
+            revision: operation.revision,
+            operationId: operation.operationId
+          }
+        };
+      }
+      case "variant.set": {
+        const instance = this.instances.get(operation.instanceId);
+        if (instance === void 0) {
+          return {
+            changedInstanceIds: /* @__PURE__ */ new Set(),
+            result: rejectOperation(
+              operation,
+              this.revision,
+              operationFailure(
+                "INSTANCE_NOT_FOUND",
+                `instance "${operation.instanceId}" is not declared`
+              )
+            )
+          };
+        }
+        const capabilityFailure = this.requireCapability(instance, "variants");
+        const component = this.components.get(instance.componentId);
+        if (capabilityFailure !== null || operation.variantId !== null && !component?.variants.some((variant) => variant.variantId === operation.variantId)) {
+          return {
+            changedInstanceIds: /* @__PURE__ */ new Set(),
+            result: rejectOperation(
+              operation,
+              this.revision,
+              capabilityFailure ?? operationFailure(
+                "CAPABILITY_DENIED",
+                `variant "${operation.variantId}" is not declared`,
+                instance,
+                "variants"
+              )
+            )
+          };
+        }
+        const next = operation.variantId === null ? (({ variantId: _variantId, ...rest }) => rest)(instance) : { ...instance, variantId: operation.variantId };
+        this.instances.set(instance.instanceId, next);
+        return {
+          changedInstanceIds: /* @__PURE__ */ new Set([instance.instanceId]),
+          result: {
+            status: "applied",
+            revision: operation.revision,
+            operationId: operation.operationId
+          }
+        };
+      }
+      case "slot.insert": {
+        const parent = this.instances.get(operation.parentInstanceId);
+        const component = this.components.get(operation.instance.componentId);
+        if (parent === void 0 || component === void 0) {
+          return {
+            changedInstanceIds: /* @__PURE__ */ new Set(),
+            result: rejectOperation(
+              operation,
+              this.revision,
+              parent === void 0 ? operationFailure(
+                "INSTANCE_NOT_FOUND",
+                `parent instance "${operation.parentInstanceId}" is not declared`
+              ) : operationFailure(
+                "COMPONENT_NOT_FOUND",
+                `component "${operation.instance.componentId}" is not declared`
+              )
+            )
+          };
+        }
+        const documentInstanceCount = [...this.instances.values()].filter(
+          (instance) => instance.documentId === parent.documentId
+        ).length;
+        let parentDepth = 1;
+        let ancestor = parent;
+        while (ancestor.parent !== null) {
+          parentDepth += 1;
+          ancestor = this.instances.get(ancestor.parent.instanceId);
+          if (ancestor === void 0) break;
+        }
+        if (this.instances.has(operation.instance.instanceId) || operation.instance.documentId !== parent.documentId || this.instances.size >= HYDROGEN_EDITOR_MANIFEST_LIMITS.maxInstances || documentInstanceCount >= HYDROGEN_EDITOR_MANIFEST_LIMITS.maxInstancesPerDocument || parentDepth >= HYDROGEN_EDITOR_MANIFEST_LIMITS.maxDepth) {
+          return {
+            changedInstanceIds: /* @__PURE__ */ new Set(),
+            result: rejectOperation(
+              operation,
+              this.revision,
+              operationFailure(
+                "DOCUMENT_MISMATCH",
+                "inserted instance identity is duplicate, cross-document, or exceeds manifest limits",
+                parent,
+                "insert"
+              )
+            )
+          };
+        }
+        const targetFailure = this.validateSlotTarget(
+          parent,
+          operation.slotId,
+          operation.instance.componentId,
+          "insert"
+        );
+        const slot = this.components.get(parent.componentId)?.slots.find((candidate) => candidate.slotId === operation.slotId);
+        if (targetFailure !== null || slot === void 0 || childrenForSlot(this.instances, parent.instanceId, operation.slotId).length >= slot.maxInstances) {
+          return {
+            changedInstanceIds: /* @__PURE__ */ new Set(),
+            result: rejectOperation(
+              operation,
+              this.revision,
+              targetFailure ?? operationFailure(
+                "SLOT_CONSTRAINT",
+                `slot "${operation.slotId}" reached its instance limit`,
+                parent,
+                "insert"
+              )
+            )
+          };
+        }
+        const parsed = HydrogenInstanceSchema.safeParse({
+          ...operation.instance,
+          parent: {
+            instanceId: parent.instanceId,
+            slotId: operation.slotId,
+            index: operation.index
+          }
+        });
+        if (!parsed.success) {
+          return {
+            changedInstanceIds: /* @__PURE__ */ new Set(),
+            result: rejectOperation(
+              operation,
+              this.revision,
+              operationFailure(
+                "INVALID_OPERATION",
+                "inserted instance does not satisfy the Hydrogen instance contract",
+                parent,
+                "insert"
+              )
+            )
+          };
+        }
+        const insertedFailure = this.validateInsertedInstance(parsed.data, component);
+        if (insertedFailure !== null) {
+          return {
+            changedInstanceIds: /* @__PURE__ */ new Set(),
+            result: rejectOperation(operation, this.revision, insertedFailure)
+          };
+        }
+        return {
+          changedInstanceIds: this.insertAt(
+            parsed.data,
+            parent.instanceId,
+            operation.slotId,
+            operation.index
+          ),
+          result: {
+            status: "applied",
+            revision: operation.revision,
+            operationId: operation.operationId
+          }
+        };
+      }
+      case "instance.move": {
+        const instance = this.instances.get(operation.instanceId);
+        const parent = this.instances.get(operation.parentInstanceId);
+        if (instance === void 0 || parent === void 0 || instance.parent === null) {
+          return {
+            changedInstanceIds: /* @__PURE__ */ new Set(),
+            result: rejectOperation(
+              operation,
+              this.revision,
+              operationFailure(
+                "INSTANCE_NOT_FOUND",
+                "move requires an existing non-root instance and parent",
+                instance,
+                "reorder"
+              )
+            )
+          };
+        }
+        const targetFailure = this.validateSlotTarget(
+          parent,
+          operation.slotId,
+          instance.componentId,
+          "reorder"
+        );
+        const oldParent = this.instances.get(instance.parent.instanceId);
+        const oldSlot = this.components.get(oldParent?.componentId ?? "")?.slots.find((slot) => slot.slotId === instance.parent?.slotId);
+        const oldTargetFailure = oldParent === void 0 || oldSlot === void 0 ? null : this.validateSlotTarget(oldParent, oldSlot.slotId, instance.componentId, "reorder");
+        const targetSlot = this.components.get(parent.componentId)?.slots.find((slot) => slot.slotId === operation.slotId);
+        const movingWithinSlot = instance.parent.instanceId === parent.instanceId && instance.parent.slotId === operation.slotId;
+        const targetCount = childrenForSlot(
+          this.instances,
+          parent.instanceId,
+          operation.slotId
+        ).length;
+        let cursor = parent;
+        let createsCycle = false;
+        while (cursor?.parent !== null && cursor?.parent !== void 0) {
+          if (cursor.instanceId === instance.instanceId) {
+            createsCycle = true;
+            break;
+          }
+          cursor = this.instances.get(cursor.parent.instanceId);
+        }
+        if (targetFailure !== null || oldTargetFailure !== null || oldParent === void 0 || oldSlot === void 0 || targetSlot === void 0 || !movingWithinSlot && targetCount >= targetSlot.maxInstances || !movingWithinSlot && childrenForSlot(this.instances, oldParent.instanceId, oldSlot.slotId).length <= oldSlot.minInstances || createsCycle || parent.documentId !== instance.documentId) {
+          return {
+            changedInstanceIds: /* @__PURE__ */ new Set(),
+            result: rejectOperation(
+              operation,
+              this.revision,
+              targetFailure ?? oldTargetFailure ?? operationFailure(
+                "SLOT_CONSTRAINT",
+                "move violates slot cardinality, document, or tree constraints",
+                instance,
+                "reorder"
+              )
+            )
+          };
+        }
+        this.instances.delete(instance.instanceId);
+        const changed = this.normalizeSlot(oldParent.instanceId, oldSlot.slotId);
+        const inserted = this.insertAt(
+          instance,
+          parent.instanceId,
+          operation.slotId,
+          operation.index
+        );
+        for (const id of inserted) changed.add(id);
+        return {
+          changedInstanceIds: changed,
+          result: {
+            status: "applied",
+            revision: operation.revision,
+            operationId: operation.operationId
+          }
+        };
+      }
+      case "instance.remove": {
+        const instance = this.instances.get(operation.instanceId);
+        if (instance === void 0 || instance.parent === null) {
+          return {
+            changedInstanceIds: /* @__PURE__ */ new Set(),
+            result: rejectOperation(
+              operation,
+              this.revision,
+              operationFailure(
+                "INSTANCE_NOT_FOUND",
+                "remove requires an existing non-root instance",
+                instance,
+                "remove"
+              )
+            )
+          };
+        }
+        const capabilityFailure = this.requireCapability(instance, "remove");
+        const parent = this.instances.get(instance.parent.instanceId);
+        const slot = this.components.get(parent?.componentId ?? "")?.slots.find((candidate) => candidate.slotId === instance.parent?.slotId);
+        const siblings = parent === void 0 || slot === void 0 ? [] : childrenForSlot(this.instances, parent.instanceId, slot.slotId);
+        if (capabilityFailure !== null || parent === void 0 || slot === void 0 || !slot.removableChildren || siblings.length <= slot.minInstances) {
+          return {
+            changedInstanceIds: /* @__PURE__ */ new Set(),
+            result: rejectOperation(
+              operation,
+              this.revision,
+              capabilityFailure ?? operationFailure(
+                "SLOT_CONSTRAINT",
+                "instance cannot be removed from this slot",
+                instance,
+                "remove"
+              )
+            )
+          };
+        }
+        const removeIds = /* @__PURE__ */ new Set();
+        const collect = (instanceId) => {
+          if (removeIds.has(instanceId)) return;
+          removeIds.add(instanceId);
+          for (const candidate of this.instances.values()) {
+            if (candidate.parent?.instanceId === instanceId) collect(candidate.instanceId);
+          }
+        };
+        collect(instance.instanceId);
+        for (const instanceId of removeIds) {
+          this.instances.delete(instanceId);
+          this.mounted.delete(instanceId);
+        }
+        const changed = this.normalizeSlot(parent.instanceId, slot.slotId);
+        for (const instanceId of removeIds) changed.add(instanceId);
+        if (removeIds.has(this.selectedInstanceId ?? "")) this.selectedInstanceId = null;
+        if (removeIds.has(this.hoveredInstanceId ?? "")) this.hoveredInstanceId = null;
+        return {
+          changedInstanceIds: changed,
+          result: {
+            status: "applied",
+            revision: operation.revision,
+            operationId: operation.operationId
+          }
+        };
+      }
+    }
+  }
+  apply(operation) {
+    const signature = jsonSignature(operation);
+    if (signature === null) {
+      return rejectOperation(
+        operation,
+        this.revision,
+        operationFailure("INVALID_OPERATION", "operation is not bounded JSON")
+      );
+    }
+    const previous = this.operations.get(operation.operationId);
+    if (previous !== void 0) {
+      return previous.signature === signature ? previous.result : rejectOperation(
+        operation,
+        this.revision,
+        operationFailure(
+          "DUPLICATE_OPERATION_CONFLICT",
+          "operationId was reused with a different operation"
+        )
+      );
+    }
+    if (this.operations.size >= HYDROGEN_EDITOR_BRIDGE_LIMITS.maxDraftOperations) {
+      return rejectOperation(
+        operation,
+        this.revision,
+        operationFailure("OPERATION_LIMIT_EXCEEDED", "draft operation limit reached")
+      );
+    }
+    if (operation.revision !== this.revision + 1) {
+      const result = rejectOperation(
+        operation,
+        this.revision,
+        operationFailure(
+          "REVISION_MISMATCH",
+          `expected preview revision ${this.revision + 1}, received ${operation.revision}`
+        )
+      );
+      this.operations.set(operation.operationId, { signature, result });
+      return result;
+    }
+    const mutation = this.applyValidatedOperation(operation);
+    this.operations.set(operation.operationId, { signature, result: mutation.result });
+    if (mutation.result.status === "applied") {
+      this.revision = operation.revision;
+      this.emit(mutation.changedInstanceIds);
+    }
+    return mutation.result;
+  }
+};
+function canvasOperationForIntent(store, intent, operationId) {
+  const revision = store.revision + 1;
+  if (intent.type === "instance.move") {
+    return {
+      type: "instance.move",
+      operationId,
+      revision,
+      instanceId: intent.instanceId,
+      parentInstanceId: intent.parentInstanceId,
+      slotId: intent.slotId,
+      index: intent.index
+    };
+  }
+  const snapshot = store.getInstanceSnapshot(intent.instanceId);
+  if (snapshot === null) {
+    return operationFailure("INSTANCE_NOT_FOUND", `instance "${intent.instanceId}" is not declared`);
+  }
+  if (intent.type === "prop.inline") {
+    const control2 = snapshot.component.props.find(
+      (candidate) => candidate.propName === intent.propName
+    );
+    if (control2 === void 0 || !control2.allowedBindings.includes("inline") || (snapshot.instance.props[intent.propName] ?? control2.defaultBinding)?.kind === "external" || !snapshot.component.capabilities.includes("props") || !snapshot.component.capabilities.includes("inline-content")) {
+      return operationFailure(
+        "CAPABILITY_DENIED",
+        `prop "${intent.propName}" is not an inline-editable canvas control`,
+        snapshot.instance,
+        "inline-content"
+      );
+    }
+    return {
+      type: "prop.patch",
+      operationId,
+      revision,
+      instanceId: intent.instanceId,
+      propName: intent.propName,
+      binding: { kind: "inline", value: intent.value }
+    };
+  }
+  const control = snapshot.component.styles.layout.find(
+    (candidate) => candidate.controlId === intent.controlId
+  );
+  if (control === void 0 || !DIRECT_CANVAS_LAYOUT_CONTROLS.has(control.control) || !snapshot.component.capabilities.includes("styles") || intent.breakpointId !== void 0 && (!snapshot.component.styles.responsive || !snapshot.component.capabilities.includes("responsive"))) {
+    return operationFailure(
+      "CAPABILITY_DENIED",
+      `layout control "${intent.controlId}" is not directly editable on the canvas`,
+      snapshot.instance,
+      intent.breakpointId === void 0 ? "styles" : "responsive"
+    );
+  }
+  const value = `${intent.value}px`;
+  if (control.allowedValues !== void 0 && !control.allowedValues.includes(value)) {
+    return operationFailure(
+      "CAPABILITY_DENIED",
+      `layout value "${value}" is outside the declared allowed values`,
+      snapshot.instance,
+      "styles"
+    );
+  }
+  const styles = HydrogenInstanceStylesSchema.parse(snapshot.instance.styles);
+  if (intent.breakpointId === void 0) {
+    return {
+      type: "styles.patch",
+      operationId,
+      revision,
+      instanceId: intent.instanceId,
+      styles: {
+        ...styles,
+        base: {
+          ...styles.base,
+          layout: { ...styles.base.layout, [intent.controlId]: value }
+        }
+      }
+    };
+  }
+  if (!store.manifest.breakpoints.some(
+    (breakpoint) => breakpoint.breakpointId === intent.breakpointId
+  )) {
+    return operationFailure(
+      "CAPABILITY_DENIED",
+      `responsive breakpoint "${intent.breakpointId}" is unknown`,
+      snapshot.instance,
+      "responsive"
+    );
+  }
+  const existing = styles.overrides.find(
+    (override2) => override2.breakpointId === intent.breakpointId
+  );
+  const override = {
+    breakpointId: intent.breakpointId,
+    values: {
+      tokens: existing?.values.tokens ?? {},
+      layout: { ...existing?.values.layout, [intent.controlId]: value }
+    }
+  };
+  return {
+    type: "styles.patch",
+    operationId,
+    revision,
+    instanceId: intent.instanceId,
+    styles: {
+      ...styles,
+      overrides: [
+        ...styles.overrides.filter((candidate) => candidate.breakpointId !== intent.breakpointId),
+        override
+      ]
+    }
+  };
+}
+function validateCanvasInsertRequest(store, request) {
+  const parent = store.getInstanceSnapshot(request.parentInstanceId);
+  if (parent === null) {
+    return operationFailure(
+      "INSTANCE_NOT_FOUND",
+      `parent instance "${request.parentInstanceId}" is not declared`
+    );
+  }
+  const slot = parent.component.slots.find((candidate) => candidate.slotId === request.slotId);
+  const children = parent.childInstanceIds[request.slotId];
+  if (slot === void 0 || slot.insertion === "fixed" || !parent.component.capabilities.includes("insert") || children === void 0 || children.length >= slot.maxInstances || request.index > children.length) {
+    return operationFailure(
+      "SLOT_CONSTRAINT",
+      `slot "${request.slotId}" does not accept an insertion at index ${request.index}`,
+      parent.instance,
+      "insert"
+    );
+  }
+  const blocking = parent.capabilityReasons.find(
+    (reason) => reason.severity === "blocking" && (reason.capability === void 0 || reason.capability === "insert")
+  );
+  return blocking === void 0 ? null : operationFailure(
+    "UNSUPPORTED_BOUNDARY",
+    blocking.message,
+    parent.instance,
+    blocking.capability ?? "insert"
+  );
+}
+function readyDocument(store) {
+  const snapshot = store.getSnapshot();
+  const instances = snapshot.instanceIds.flatMap((instanceId) => {
+    const instance = store.getInstanceSnapshot(instanceId);
+    return instance === null ? [] : [
+      {
+        instance: instance.instance,
+        mounted: instance.mounted,
+        editable: instance.editable,
+        capabilityReasons: instance.capabilityReasons
+      }
+    ];
+  });
+  const componentIds = new Set(instances.map(({ instance }) => instance.componentId));
+  let discoveredComponent = true;
+  while (discoveredComponent) {
+    discoveredComponent = false;
+    for (const componentId of [...componentIds]) {
+      const component = store.components.get(componentId);
+      for (const slot of component?.slots ?? []) {
+        const candidates = slot.accepts.mode === "any" ? [...store.components.keys()] : slot.accepts.componentIds;
+        for (const candidate of candidates) {
+          if (componentIds.has(candidate)) continue;
+          componentIds.add(candidate);
+          discoveredComponent = true;
+        }
+      }
+    }
+  }
+  const components = [...componentIds].flatMap((componentId) => {
+    const component = store.components.get(componentId);
+    return component === void 0 ? [] : [component];
+  });
+  const instanceIds = new Set(instances.map(({ instance }) => instance.instanceId));
+  const componentAnchorIds = new Set(components.map((component) => component.source.anchorId));
+  const instanceAnchorIds = new Set(instances.map(({ instance }) => instance.source.anchorId));
+  const unsupportedFindings = store.manifest.unsupportedFindings.filter((finding) => {
+    switch (finding.target.kind) {
+      case "manifest":
+        return true;
+      case "component":
+        return componentIds.has(finding.target.componentId);
+      case "instance":
+        return instanceIds.has(finding.target.instanceId);
+      case "source":
+        return componentAnchorIds.has(finding.target.anchorId) || instanceAnchorIds.has(finding.target.anchorId);
+    }
+  });
+  return {
+    protocolVersion: HYDROGEN_EDITOR_PROTOCOL_VERSION,
+    document: snapshot.document,
+    breakpoints: store.manifest.breakpoints,
+    ...snapshot.route !== void 0 ? { route: snapshot.route } : {},
+    revision: snapshot.revision,
+    selectedInstanceId: snapshot.selectedInstanceId,
+    hoveredInstanceId: snapshot.hoveredInstanceId,
+    selectionStatus: snapshot.selectionStatus,
+    components,
+    instances,
+    unsupportedFindings
+  };
+}
+function createHydrogenEditorSourceProjection({
+  manifest,
+  documentId,
+  route,
+  revision = 0,
+  selectedInstanceId
+}) {
+  if (!isNonnegativeInteger(revision)) {
+    throw new HydrogenEditorConfigurationError("revision must be a nonnegative integer");
+  }
+  const parsedManifest = HydrogenEditorManifestSchema.parse(manifest);
+  const document = parsedManifest.documents.find((candidate) => candidate.documentId === documentId);
+  if (document === void 0) {
+    throw new HydrogenEditorConfigurationError(`unknown Hydrogen document "${documentId}"`);
+  }
+  const store = new HydrogenEditorPreviewStoreImpl(
+    parsedManifest,
+    documentId,
+    route ?? document.route
+  );
+  store.revision = revision;
+  const selection = selectedInstanceId === void 0 ? document.rootInstanceIds[0] ?? parsedManifest.instances.find((instance) => instance.documentId === documentId)?.instanceId ?? null : selectedInstanceId;
+  if (!store.setSelection(selection)) {
+    throw new HydrogenEditorConfigurationError(
+      `unknown Hydrogen instance "${selectedInstanceId ?? ""}"`
+    );
+  }
+  return readyDocument(store);
+}
+function reconciliationDocument(store, reason) {
+  const snapshot = store.getSnapshot();
+  return {
+    reason,
+    documentId: snapshot.document.documentId,
+    ...snapshot.route !== void 0 ? { route: snapshot.route } : {},
+    revision: snapshot.revision,
+    selectedInstanceId: snapshot.selectedInstanceId,
+    selectionStatus: snapshot.selectionStatus,
+    mountedInstanceIds: snapshot.mountedInstanceIds
+  };
+}
+function isNullableOpaqueId(value) {
+  return value === null || isOpaqueId(value);
+}
+function parseReadyDocument(value, expectedManifest, submittedInstances) {
+  if (!isRecord(value) || value.protocolVersion !== HYDROGEN_EDITOR_PROTOCOL_VERSION || !isNonnegativeInteger(value.revision) || !isNullableOpaqueId(value.selectedInstanceId) || !isNullableOpaqueId(value.hoveredInstanceId) || value.selectionStatus !== "active" && value.selectionStatus !== "out-of-route" && value.selectionStatus !== "none" || value.route !== void 0 && typeof value.route !== "string" || !Array.isArray(value.breakpoints) || !Array.isArray(value.components) || !Array.isArray(value.instances) || !Array.isArray(value.unsupportedFindings)) {
+    return null;
+  }
+  const document = HydrogenDocumentSchema.safeParse(value.document);
+  const breakpoints = value.breakpoints.map(
+    (breakpoint) => HydrogenBreakpointSchema.safeParse(breakpoint)
+  );
+  const components = value.components.map(
+    (component) => HydrogenComponentDefinitionSchema.safeParse(component)
+  );
+  const instances = value.instances.map((candidate) => {
+    if (!isRecord(candidate) || typeof candidate.mounted !== "boolean" || typeof candidate.editable !== "boolean" || !Array.isArray(candidate.capabilityReasons)) {
+      return null;
+    }
+    const instance = HydrogenInstanceSchema.safeParse(candidate.instance);
+    if (!instance.success) return null;
+    const reasons = candidate.capabilityReasons.flatMap((reason) => {
+      if (!isRecord(reason) || typeof reason.code !== "string" || reason.code.length === 0 || reason.code.length > 128 || reason.severity !== "warning" && reason.severity !== "blocking" || typeof reason.message !== "string" || reason.message.length === 0 || reason.message.length > 2048) {
+        return [];
+      }
+      const capability = reason.capability === void 0 ? void 0 : HydrogenEditCapabilitySchema.safeParse(reason.capability);
+      const source = reason.source === void 0 ? void 0 : HydrogenSourceLocationSchema.safeParse(reason.source);
+      if (capability !== void 0 && !capability.success) return [];
+      if (source !== void 0 && !source.success) return [];
+      return [
+        {
+          code: reason.code,
+          severity: reason.severity,
+          message: reason.message,
+          ...capability?.success ? { capability: capability.data } : {},
+          ...source?.success ? { source: source.data } : {}
+        }
+      ];
+    });
+    if (reasons.length !== candidate.capabilityReasons.length) return null;
+    return {
+      instance: instance.data,
+      mounted: candidate.mounted,
+      editable: candidate.editable,
+      capabilityReasons: reasons
+    };
+  });
+  if (!document.success || breakpoints.some((breakpoint) => !breakpoint.success) || components.some((component) => !component.success) || value.breakpoints.length > HYDROGEN_EDITOR_MANIFEST_LIMITS.maxBreakpoints || instances.some((instance) => instance === null) || value.components.length > HYDROGEN_EDITOR_MANIFEST_LIMITS.maxComponents || value.instances.length > HYDROGEN_EDITOR_MANIFEST_LIMITS.maxInstancesPerDocument) {
+    return null;
+  }
+  const unsupportedFindings = value.unsupportedFindings.map(
+    (finding) => HydrogenUnsupportedFindingSchema.safeParse(finding)
+  );
+  if (unsupportedFindings.some((finding) => !finding.success) || unsupportedFindings.length > HYDROGEN_EDITOR_MANIFEST_LIMITS.maxFindings) {
+    return null;
+  }
+  const parsedComponents = components.flatMap(
+    (component) => component.success ? [component.data] : []
+  );
+  const parsedBreakpoints = breakpoints.flatMap(
+    (breakpoint) => breakpoint.success ? [breakpoint.data] : []
+  );
+  const parsedInstances = instances.flatMap((instance) => instance === null ? [] : [instance]);
+  const parsedFindings = unsupportedFindings.flatMap(
+    (finding) => finding.success ? [finding.data] : []
+  );
+  const expectedDocument = expectedManifest.documents.find(
+    (candidate) => candidate.documentId === document.data.documentId
+  );
+  if (expectedDocument === void 0 || jsonSignature(expectedDocument) !== jsonSignature(document.data) || jsonSignature(expectedManifest.breakpoints) !== jsonSignature(parsedBreakpoints)) {
+    return null;
+  }
+  const expectedComponents = new Map(
+    expectedManifest.components.map((component) => [component.componentId, component])
+  );
+  const componentIds = /* @__PURE__ */ new Set();
+  for (const component of parsedComponents) {
+    const expected = expectedComponents.get(component.componentId);
+    if (componentIds.has(component.componentId) || expected === void 0 || jsonSignature(expected) !== jsonSignature(component)) {
+      return null;
+    }
+    componentIds.add(component.componentId);
+  }
+  const expectedInstances = new Map(
+    expectedManifest.instances.map((instance) => [instance.instanceId, instance])
+  );
+  const instanceIds = /* @__PURE__ */ new Set();
+  const sourceAnchors = new Set(parsedComponents.map((component) => component.source.anchorId));
+  const normalizedInstances = [];
+  for (const candidate of parsedInstances) {
+    const instance = candidate.instance;
+    const component = expectedComponents.get(instance.componentId);
+    const expected = expectedInstances.get(instance.instanceId);
+    const submitted = submittedInstances.get(instance.instanceId);
+    const trustedIdentity = expected ?? submitted;
+    if (instanceIds.has(instance.instanceId) || sourceAnchors.has(instance.source.anchorId) || component === void 0 || !componentIds.has(component.componentId) || trustedIdentity === void 0 || trustedIdentity.componentId !== instance.componentId || trustedIdentity.documentId !== instance.documentId || jsonSignature(trustedIdentity.source) !== jsonSignature(instance.source) || instance.documentId !== document.data.documentId || !instanceMatchesComponentContract(expectedManifest, instance, component)) {
+      return null;
+    }
+    instanceIds.add(instance.instanceId);
+    sourceAnchors.add(instance.source.anchorId);
+    const capabilityReasons = findingsForInstance(expectedManifest, instance, component);
+    normalizedInstances.push({
+      instance,
+      mounted: candidate.mounted,
+      editable: component.capabilities.length > 0 && !capabilityReasons.some((reason) => reason.severity === "blocking"),
+      capabilityReasons
+    });
+  }
+  for (const candidate of normalizedInstances) {
+    const parent = candidate.instance.parent;
+    if (parent === null) {
+      if (!document.data.rootInstanceIds.includes(candidate.instance.instanceId)) return null;
+      continue;
+    }
+    const parentInstance = normalizedInstances.find(
+      (item) => item.instance.instanceId === parent.instanceId
+    )?.instance;
+    const parentComponent = parentInstance === void 0 ? void 0 : expectedComponents.get(parentInstance.componentId);
+    const slot = parentComponent?.slots.find((item) => item.slotId === parent.slotId);
+    if (parentInstance === void 0 || slot === void 0 || slot.accepts.mode === "include" && !slot.accepts.componentIds.includes(candidate.instance.componentId)) {
+      return null;
+    }
+  }
+  if (document.data.rootInstanceIds.some((instanceId) => !instanceIds.has(instanceId)) || value.selectedInstanceId !== null && !expectedInstances.has(value.selectedInstanceId) && !submittedInstances.has(value.selectedInstanceId) || value.hoveredInstanceId !== null && !instanceIds.has(value.hoveredInstanceId)) {
+    return null;
+  }
+  const expectedFindingSignatures = new Set(
+    expectedManifest.unsupportedFindings.filter((finding) => {
+      switch (finding.target.kind) {
+        case "manifest":
+          return true;
+        case "component":
+          return componentIds.has(finding.target.componentId);
+        case "instance":
+          return instanceIds.has(finding.target.instanceId);
+        case "source":
+          return sourceAnchors.has(finding.target.anchorId);
+      }
+    }).map((finding) => jsonSignature(finding))
+  );
+  const receivedFindingSignatures = new Set(parsedFindings.map((finding) => jsonSignature(finding)));
+  if (receivedFindingSignatures.size !== expectedFindingSignatures.size || [...receivedFindingSignatures].some((signature) => !expectedFindingSignatures.has(signature))) {
+    return null;
+  }
+  return {
+    protocolVersion: HYDROGEN_EDITOR_PROTOCOL_VERSION,
+    document: document.data,
+    breakpoints: parsedBreakpoints,
+    ...value.route !== void 0 ? { route: value.route } : {},
+    revision: value.revision,
+    selectedInstanceId: value.selectedInstanceId,
+    hoveredInstanceId: value.hoveredInstanceId,
+    selectionStatus: value.selectionStatus,
+    components: parsedComponents,
+    instances: normalizedInstances,
+    unsupportedFindings: parsedFindings
+  };
+}
+function parseApplyResult(value) {
+  if (!isRecord(value) || value.status !== "applied" && value.status !== "duplicate" && value.status !== "rejected" || !isNonnegativeInteger(value.revision) || !isOpaqueId(value.operationId)) {
+    return null;
+  }
+  if (value.status === "rejected") {
+    if (!isRecord(value.failure) || typeof value.failure.code !== "string" || !OPERATION_FAILURE_CODES.has(value.failure.code) || typeof value.failure.message !== "string" || value.failure.message.length > 2048 || value.failure.instanceId !== void 0 && !isOpaqueId(value.failure.instanceId)) {
+      return null;
+    }
+    const capability = value.failure.capability === void 0 ? void 0 : HydrogenEditCapabilitySchema.safeParse(value.failure.capability);
+    const source = value.failure.source === void 0 ? void 0 : HydrogenSourceLocationSchema.safeParse(value.failure.source);
+    if (capability !== void 0 && !capability.success) return null;
+    if (source !== void 0 && !source.success) return null;
+    return {
+      status: "rejected",
+      revision: value.revision,
+      operationId: value.operationId,
+      failure: {
+        code: value.failure.code,
+        message: value.failure.message,
+        ...value.failure.instanceId !== void 0 ? { instanceId: value.failure.instanceId } : {},
+        ...capability?.success ? { capability: capability.data } : {},
+        ...source?.success ? { source: source.data } : {}
+      }
+    };
+  }
+  return {
+    status: value.status,
+    revision: value.revision,
+    operationId: value.operationId
+  };
+}
+function parseCanvasOperationEvent(value) {
+  if (!isRecord(value) || !hasOnlyKeys(value, ["intent", "operation", "result"])) return null;
+  const intent = parseHydrogenEditorCanvasIntent(value.intent);
+  const operation = parseOperation(value.operation);
+  const result = parseApplyResult(value.result);
+  if (intent === null || intent.type === "slot.insert.request" || operation === null || result === null || operation.operationId !== result.operationId) {
+    return null;
+  }
+  const matches = intent.type === "instance.move" && operation.type === "instance.move" && operation.instanceId === intent.instanceId && operation.parentInstanceId === intent.parentInstanceId && operation.slotId === intent.slotId && operation.index === intent.index || intent.type === "prop.inline" && operation.type === "prop.patch" && operation.instanceId === intent.instanceId && operation.propName === intent.propName && operation.binding.kind === "inline" && operation.binding.value === intent.value || intent.type === "styles.adjust" && operation.type === "styles.patch" && operation.instanceId === intent.instanceId;
+  return matches ? { intent, operation, result } : null;
+}
+function parseReconciliation(value) {
+  if (!isRecord(value) || value.reason !== "route" && value.reason !== "loader" && value.reason !== "suspense" && value.reason !== "hmr" || !isOpaqueId(value.documentId) || value.route !== void 0 && typeof value.route !== "string" || !isNonnegativeInteger(value.revision) || !isNullableOpaqueId(value.selectedInstanceId) || value.selectionStatus !== "active" && value.selectionStatus !== "out-of-route" && value.selectionStatus !== "none" || !Array.isArray(value.mountedInstanceIds) || !value.mountedInstanceIds.every(isOpaqueId)) {
+    return null;
+  }
+  return value;
+}
+function createHydrogenEditorPreviewRuntime({
+  adminOrigin,
+  documentId,
+  manifest,
+  now = Date.now,
+  onProtocolFailure,
+  route,
+  security,
+  target,
+  transport
+}) {
+  const trustedAdminOrigin = exactOrigin(adminOrigin, "adminOrigin");
+  validateSecurityContext(security, now());
+  const parsedManifest = HydrogenEditorManifestSchema.parse(manifest);
+  if (parsedManifest.source.baseSha !== security.baseSha) {
+    throw new HydrogenEditorConfigurationError(
+      "manifest source baseSha does not match the editor session"
+    );
+  }
+  const store = new HydrogenEditorPreviewStoreImpl(parsedManifest, documentId, route);
+  const inbound = { sequence: 0, messages: /* @__PURE__ */ new Map() };
+  const buffered = [];
+  let outboundSequence = 0;
+  let canvasOperationSequence = 0;
+  let ready = false;
+  let disposed = false;
+  const reportProtocolFailure = (failure) => {
+    onProtocolFailure?.(failure);
+  };
+  const post = (type, payload) => {
+    if (now() >= security.expiresAt) {
+      reportProtocolFailure(protocolFailure("MESSAGE_EXPIRED", "editor preview token has expired"));
+      return;
+    }
+    outboundSequence += 1;
+    postEnvelope(
+      target,
+      trustedAdminOrigin,
+      createEnvelope(PREVIEW_SOURCE, security, outboundSequence, type, payload)
+    );
+  };
+  const postReady = () => {
+    try {
+      post("editor.ready", readyDocument(store));
+    } catch (error) {
+      const failure = protocolFailure(
+        "MESSAGE_TOO_LARGE",
+        error instanceof Error ? error.message : "ready document exceeds bridge bounds"
+      );
+      reportProtocolFailure(failure);
+      post("editor.protocol.failure", failure);
+    }
+  };
+  const process = (envelope) => {
+    if (now() >= security.expiresAt) {
+      reportProtocolFailure(
+        protocolFailure("MESSAGE_EXPIRED", "buffered editor message expired before ready")
+      );
+      return;
+    }
+    switch (envelope.type) {
+      case "editor.protocol.failure": {
+        const failure = parseProtocolFailure(envelope.payload);
+        onProtocolFailure?.(
+          failure ?? protocolFailure("UNKNOWN_MESSAGE", "preview protocol failure payload is invalid")
+        );
+        return;
+      }
+      case "editor.ready.request":
+        postReady();
+        return;
+      case "instance.hover": {
+        const instanceId = isRecord(envelope.payload) && isNullableOpaqueId(envelope.payload.instanceId) ? envelope.payload.instanceId : void 0;
+        if (instanceId === void 0 || !store.setHover(instanceId)) {
+          reportProtocolFailure(
+            protocolFailure("UNKNOWN_MESSAGE", "hover targets an unknown instance")
+          );
+        }
+        return;
+      }
+      case "instance.select": {
+        const instanceId = isRecord(envelope.payload) && isNullableOpaqueId(envelope.payload.instanceId) ? envelope.payload.instanceId : void 0;
+        if (instanceId === void 0 || !store.setSelection(instanceId)) {
+          reportProtocolFailure(
+            protocolFailure("UNKNOWN_MESSAGE", "selection targets an unknown instance")
+          );
+        }
+        return;
+      }
+      case "preview.operation.apply": {
+        const operation = parseOperation(envelope.payload);
+        const result = operation === null ? rejectOperation(
+          { operationId: "invalid" },
+          store.revision,
+          operationFailure("INVALID_OPERATION", "operation payload is invalid")
+        ) : store.apply(operation);
+        post("preview.operation.result", result);
+        return;
+      }
+      default:
+        reportProtocolFailure(
+          protocolFailure("UNKNOWN_MESSAGE", `unknown host message "${envelope.type}"`)
+        );
+    }
+  };
+  const onMessage = (event) => {
+    if (disposed || event.origin !== trustedAdminOrigin) return;
+    if (event.source !== target) return;
+    const parsed = parseEnvelope(event.data, HOST_SOURCE, security, inbound, now());
+    if ("code" in parsed) {
+      reportProtocolFailure(parsed);
+      return;
+    }
+    if (parsed.duplicate) return;
+    if (!ready) {
+      if (buffered.length >= HYDROGEN_EDITOR_BRIDGE_LIMITS.maxBufferedMessages) {
+        reportProtocolFailure(
+          protocolFailure(
+            "BUFFER_LIMIT_EXCEEDED",
+            "pre-ready Hydrogen editor message buffer is full"
+          )
+        );
+        return;
+      }
+      buffered.push(parsed.envelope);
+      return;
+    }
+    process(parsed.envelope);
+  };
+  transport.addEventListener("message", onMessage);
+  return {
+    manifest: parsedManifest,
+    store,
+    ready: () => {
+      if (disposed) return;
+      ready = true;
+      postReady();
+      while (buffered.length > 0) {
+        const envelope = buffered.shift();
+        if (envelope !== void 0) process(envelope);
+      }
+    },
+    reconcile: (nextDocumentId, reason, nextRoute) => {
+      if (disposed) return;
+      store.reconcile(nextDocumentId, nextRoute);
+      if (ready) post("editor.reconciled", reconciliationDocument(store, reason));
+    },
+    registerInstance: (instanceId) => {
+      if (disposed || store.getInstanceSnapshot(instanceId) === null) return () => void 0;
+      store.setMounted(instanceId, true);
+      if (ready && store.selectedInstanceId === instanceId) {
+        post("editor.reconciled", reconciliationDocument(store, "suspense"));
+      }
+      return () => {
+        store.setMounted(instanceId, false);
+        if (ready && store.selectedInstanceId === instanceId) {
+          post("editor.reconciled", reconciliationDocument(store, "suspense"));
+        }
+      };
+    },
+    hoverInstance: (instanceId) => {
+      if (disposed || !store.setHover(instanceId)) return;
+      if (ready) post("instance.hover", { instanceId });
+    },
+    selectInstance: (instanceId) => {
+      if (disposed || !store.setSelection(instanceId)) return;
+      if (ready) post("instance.select", { instanceId });
+    },
+    dispatchCanvasIntent: (value) => {
+      const intent = parseHydrogenEditorCanvasIntent(value);
+      if (disposed || !ready || intent === null) {
+        return {
+          status: "rejected",
+          revision: store.revision,
+          failure: operationFailure(
+            "INVALID_OPERATION",
+            disposed ? "editor preview runtime is disposed" : !ready ? "editor preview runtime is not ready" : "canvas intent is invalid"
+          )
+        };
+      }
+      if (intent.type === "slot.insert.request") {
+        const failure = validateCanvasInsertRequest(store, intent);
+        if (failure !== null) {
+          return { status: "rejected", revision: store.revision, failure };
+        }
+        post("canvas.insert.request", intent);
+        return { status: "insert-requested", intent, revision: store.revision };
+      }
+      canvasOperationSequence += 1;
+      const operation = canvasOperationForIntent(store, intent, `canvas:${canvasOperationSequence}`);
+      if ("code" in operation) {
+        return {
+          status: "rejected",
+          revision: store.revision,
+          failure: operation
+        };
+      }
+      const result = store.apply(operation);
+      post("canvas.operation", { intent, operation, result });
+      return { status: "operation", intent, operation, result };
+    },
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      buffered.length = 0;
+      transport.removeEventListener("message", onMessage);
+    }
+  };
+}
+function createHydrogenEditorHostBridge({
+  manifest,
+  now = Date.now,
+  onCanvasInsertRequest,
+  onCanvasOperation,
+  onHoverInstance,
+  onOperationResult,
+  onProtocolFailure,
+  onReady,
+  onReconcile,
+  onSelectInstance,
+  previewOrigin,
+  resolveTarget,
+  security,
+  target,
+  transport
+}) {
+  const trustedPreviewOrigin = exactOrigin(previewOrigin, "previewOrigin");
+  validateSecurityContext(security, now());
+  const expectedManifest = cloneManifest(manifest);
+  if (expectedManifest.source.baseSha !== security.baseSha) {
+    throw new HydrogenEditorConfigurationError(
+      "manifest source baseSha does not match the editor session"
+    );
+  }
+  const inbound = { sequence: 0, messages: /* @__PURE__ */ new Map() };
+  const buffered = [];
+  const submittedInstances = /* @__PURE__ */ new Map();
+  let outboundSequence = 0;
+  let ready = false;
+  let disposed = false;
+  const currentTarget = () => resolveTarget?.() ?? target;
+  const post = (type, payload) => {
+    if (now() >= security.expiresAt) {
+      throw new HydrogenEditorConfigurationError("editor preview security context is expired");
+    }
+    outboundSequence += 1;
+    postEnvelope(
+      currentTarget(),
+      trustedPreviewOrigin,
+      createEnvelope(HOST_SOURCE, security, outboundSequence, type, payload)
+    );
+  };
+  const process = (envelope) => {
+    switch (envelope.type) {
+      case "editor.protocol.failure": {
+        const failure = parseProtocolFailure(envelope.payload);
+        onProtocolFailure?.(
+          failure ?? protocolFailure("UNKNOWN_MESSAGE", "preview protocol failure payload is invalid")
+        );
+        return;
+      }
+      case "instance.hover":
+      case "instance.select": {
+        const instanceId = isRecord(envelope.payload) && isNullableOpaqueId(envelope.payload.instanceId) ? envelope.payload.instanceId : void 0;
+        if (instanceId === void 0) {
+          onProtocolFailure?.(
+            protocolFailure("UNKNOWN_MESSAGE", `${envelope.type} payload is invalid`)
+          );
+          return;
+        }
+        if (envelope.type === "instance.hover") onHoverInstance?.(instanceId);
+        else onSelectInstance?.(instanceId);
+        return;
+      }
+      case "preview.operation.result": {
+        const result = parseApplyResult(envelope.payload);
+        if (result === null) {
+          onProtocolFailure?.(
+            protocolFailure("UNKNOWN_MESSAGE", "operation result payload is invalid")
+          );
+          return;
+        }
+        onOperationResult?.(result);
+        return;
+      }
+      case "canvas.operation": {
+        const event = parseCanvasOperationEvent(envelope.payload);
+        if (event === null) {
+          onProtocolFailure?.(
+            protocolFailure("UNKNOWN_MESSAGE", "canvas operation payload is invalid")
+          );
+          return;
+        }
+        onOperationResult?.(event.result);
+        onCanvasOperation?.(event.intent, event.operation, event.result);
+        return;
+      }
+      case "canvas.insert.request": {
+        const request = parseHydrogenEditorCanvasIntent(envelope.payload);
+        if (request === null || request.type !== "slot.insert.request") {
+          onProtocolFailure?.(
+            protocolFailure("UNKNOWN_MESSAGE", "canvas insertion request payload is invalid")
+          );
+          return;
+        }
+        onCanvasInsertRequest?.(request);
+        return;
+      }
+      case "editor.reconciled": {
+        const reconciliation = parseReconciliation(envelope.payload);
+        if (reconciliation === null) {
+          onProtocolFailure?.(
+            protocolFailure("UNKNOWN_MESSAGE", "reconciliation payload is invalid")
+          );
+          return;
+        }
+        onReconcile?.(reconciliation);
+        return;
+      }
+      default:
+        onProtocolFailure?.(
+          protocolFailure("UNKNOWN_MESSAGE", `unknown preview message "${envelope.type}"`)
+        );
+    }
+  };
+  const onMessage = (event) => {
+    if (disposed || event.origin !== trustedPreviewOrigin) return;
+    const expectedTarget = currentTarget();
+    if (event.source !== expectedTarget) return;
+    const parsed = parseEnvelope(event.data, PREVIEW_SOURCE, security, inbound, now());
+    if ("code" in parsed) {
+      onProtocolFailure?.(parsed);
+      return;
+    }
+    if (parsed.duplicate) return;
+    if (parsed.envelope.type === "editor.protocol.failure") {
+      process(parsed.envelope);
+      return;
+    }
+    if (parsed.envelope.type === "editor.ready") {
+      const readyDocumentPayload = parseReadyDocument(
+        parsed.envelope.payload,
+        expectedManifest,
+        submittedInstances
+      );
+      if (readyDocumentPayload === null) {
+        onProtocolFailure?.(protocolFailure("UNKNOWN_MESSAGE", "ready payload is invalid"));
+        return;
+      }
+      ready = true;
+      onReady?.(readyDocumentPayload);
+      while (buffered.length > 0) {
+        const envelope = buffered.shift();
+        if (envelope !== void 0) process(envelope);
+      }
+      return;
+    }
+    if (!ready) {
+      if (buffered.length >= HYDROGEN_EDITOR_BRIDGE_LIMITS.maxBufferedMessages) {
+        onProtocolFailure?.(
+          protocolFailure(
+            "BUFFER_LIMIT_EXCEEDED",
+            "pre-ready Hydrogen preview message buffer is full"
+          )
+        );
+        return;
+      }
+      buffered.push(parsed.envelope);
+      return;
+    }
+    process(parsed.envelope);
+  };
+  transport.addEventListener("message", onMessage);
+  return {
+    requestReady: () => post("editor.ready.request"),
+    hoverInstance: (instanceId) => {
+      if (instanceId !== null && !isOpaqueId(instanceId)) return;
+      post("instance.hover", { instanceId });
+    },
+    selectInstance: (instanceId) => {
+      if (instanceId !== null && !isOpaqueId(instanceId)) return;
+      post("instance.select", { instanceId });
+    },
+    applyOperation: (operation) => {
+      const parsed = parseOperation(operation);
+      if (parsed === null) {
+        throw new HydrogenEditorConfigurationError("operation does not satisfy the bridge contract");
+      }
+      if (parsed.type === "slot.insert") {
+        submittedInstances.set(parsed.instance.instanceId, parsed.instance);
+      }
+      post("preview.operation.apply", parsed);
+    },
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      buffered.length = 0;
+      transport.removeEventListener("message", onMessage);
+    }
+  };
+}
+function resolveHydrogenEditorStyles(manifest, instance, viewportWidth) {
+  const component = manifest.components.find(
+    (candidate) => candidate.componentId === instance.componentId
+  );
+  if (component === void 0) return {};
+  const matchingBreakpoints = viewportWidth === void 0 ? [] : [...manifest.breakpoints].filter((breakpoint) => breakpoint.minWidth <= viewportWidth).sort(
+    (left, right) => left.minWidth - right.minWidth || left.breakpointId.localeCompare(right.breakpointId)
+  );
+  const variant = component.variants.find((candidate) => candidate.variantId === instance.variantId);
+  const tokens = {
+    ...variant?.styles.tokens,
+    ...instance.styles.base.tokens
+  };
+  const layout = {
+    ...variant?.styles.layout,
+    ...instance.styles.base.layout
+  };
+  for (const breakpoint of matchingBreakpoints) {
+    const override = instance.styles.overrides.find(
+      (candidate) => candidate.breakpointId === breakpoint.breakpointId
+    );
+    Object.assign(tokens, override?.values.tokens);
+    Object.assign(layout, override?.values.layout);
+  }
+  const styles = {};
+  for (const token of component.styles.tokens) {
+    const value = tokens[token.tokenId];
+    if (typeof value === "string" || typeof value === "number") {
+      styles[token.cssVariable] = value;
+    }
+  }
+  for (const control of component.styles.layout) {
+    const value = layout[control.controlId];
+    if (typeof value === "string" || typeof value === "number") {
+      styles[control.cssProperty] = value;
+    }
+  }
+  return styles;
+}
+
+export { HYDROGEN_EDITOR_BRIDGE_LIMITS, HYDROGEN_EDITOR_PROTOCOL_VERSION, HydrogenEditorConfigurationError, createHydrogenEditorHostBridge, createHydrogenEditorPreviewRuntime, createHydrogenEditorSourceProjection, parseHydrogenEditorCanvasIntent, resolveHydrogenEditorStyles };
+//# sourceMappingURL=chunk-XXNCFWXT.js.map
+//# sourceMappingURL=chunk-XXNCFWXT.js.map