@notionhq/custom-blocks-host 0.2.8 → 0.2.9

package/dist/browser.js

@@ -0,0 +1,3308 @@
+// host/src/autoBindProperties.ts
+function getAutoBoundPropertyIdsByKey(args) {
+  const { manifestProperties, propertySchemasById } = args;
+  const mappings = [];
+  for (const [propertyKey, manifestProperty] of Object.entries(
+    manifestProperties
+  )) {
+    const propertyId = getAutoBoundPropertyId({
+      propertyKey,
+      manifestProperty,
+      propertySchemasById
+    });
+    if (propertyId !== void 0) {
+      mappings.push([propertyKey, propertyId]);
+    }
+  }
+  return Object.fromEntries(mappings);
+}
+function getAutoBoundPropertyId(args) {
+  const { propertyKey, manifestProperty, propertySchemasById } = args;
+  const normalizedManifestName = normalizePropertyDisplayName(
+    manifestProperty.name
+  );
+  const candidates = Object.entries(propertySchemasById).filter(
+    ([schemaId, propertySchema]) => propertySchema.type === manifestProperty.type && (schemaId === propertyKey || normalizePropertyDisplayName(propertySchema.name) === normalizedManifestName)
+  );
+  return candidates.length === 1 ? candidates[0][0] : void 0;
+}
+function normalizePropertyDisplayName(value) {
+  return value.trim().toLowerCase();
+}
+
+// node_modules/.pnpm/valibot@1.4.2_typescript@7.0.2/node_modules/valibot/dist/index.mjs
+var store$4;
+var DEFAULT_CONFIG = {
+  lang: void 0,
+  message: void 0,
+  abortEarly: void 0,
+  abortPipeEarly: void 0
+};
+// @__NO_SIDE_EFFECTS__
+function getGlobalConfig(config$1) {
+  if (!config$1 && !store$4) return DEFAULT_CONFIG;
+  return {
+    lang: config$1?.lang ?? store$4?.lang,
+    message: config$1?.message,
+    abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
+    abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
+  };
+}
+var store$3;
+// @__NO_SIDE_EFFECTS__
+function getGlobalMessage(lang) {
+  return store$3?.get(lang);
+}
+var store$2;
+// @__NO_SIDE_EFFECTS__
+function getSchemaMessage(lang) {
+  return store$2?.get(lang);
+}
+var store$1;
+// @__NO_SIDE_EFFECTS__
+function getSpecificMessage(reference, lang) {
+  return store$1?.get(reference)?.get(lang);
+}
+// @__NO_SIDE_EFFECTS__
+function _stringify(input) {
+  const type = typeof input;
+  if (type === "string") return `"${input}"`;
+  if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
+  if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+  return type;
+}
+function _addIssue(context, label, dataset, config$1, other) {
+  const input = other && "input" in other ? other.input : dataset.value;
+  const expected = other?.expected ?? context.expects ?? null;
+  const received = other?.received ?? /* @__PURE__ */ _stringify(input);
+  const issue = {
+    kind: context.kind,
+    type: context.type,
+    input,
+    expected,
+    received,
+    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+    requirement: context.requirement,
+    path: other?.path,
+    issues: other?.issues,
+    lang: config$1.lang,
+    abortEarly: config$1.abortEarly,
+    abortPipeEarly: config$1.abortPipeEarly
+  };
+  const isSchema = context.kind === "schema";
+  const message$1 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config$1.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+  if (message$1 !== void 0) issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
+  if (isSchema) dataset.typed = false;
+  if (dataset.issues) dataset.issues.push(issue);
+  else dataset.issues = [issue];
+}
+var _standardCache = /* @__PURE__ */ new WeakMap();
+// @__NO_SIDE_EFFECTS__
+function _getStandardProps(context) {
+  let cached = _standardCache.get(context);
+  if (!cached) {
+    cached = {
+      version: 1,
+      vendor: "valibot",
+      validate(value$1) {
+        return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
+      }
+    };
+    _standardCache.set(context, cached);
+  }
+  return cached;
+}
+// @__NO_SIDE_EFFECTS__
+function _isValidObjectKey(object$1, key) {
+  return Object.prototype.hasOwnProperty.call(object$1, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+}
+// @__NO_SIDE_EFFECTS__
+function _joinExpects(values$1, separator) {
+  const list = [...new Set(values$1)];
+  if (list.length > 1) return `(${list.join(` ${separator} `)})`;
+  return list[0] ?? "never";
+}
+var ValiError = class extends Error {
+  /**
+  * Creates a Valibot error with useful information.
+  *
+  * @param issues The error issues.
+  */
+  constructor(issues) {
+    super(issues[0].message);
+    this.name = "ValiError";
+    this.issues = issues;
+  }
+};
+// @__NO_SIDE_EFFECTS__
+function brand(name) {
+  return {
+    kind: "transformation",
+    type: "brand",
+    reference: brand,
+    async: false,
+    name,
+    "~run"(dataset) {
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function finite(message$1) {
+  return {
+    kind: "validation",
+    type: "finite",
+    reference: finite,
+    async: false,
+    expects: null,
+    requirement: Number.isFinite,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "finite", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function maxLength(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "max_length",
+    reference: maxLength,
+    async: false,
+    expects: `<=${requirement}`,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && dataset.value.length > this.requirement) _addIssue(this, "length", dataset, config$1, { received: `${dataset.value.length}` });
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function minLength(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "min_length",
+    reference: minLength,
+    async: false,
+    expects: `>=${requirement}`,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && dataset.value.length < this.requirement) _addIssue(this, "length", dataset, config$1, { received: `${dataset.value.length}` });
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function minValue(requirement, message$1) {
+  return {
+    kind: "validation",
+    type: "min_value",
+    reference: minValue,
+    async: false,
+    expects: `>=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
+    requirement,
+    message: message$1,
+    "~run"(dataset, config$1) {
+      if (dataset.typed && !(dataset.value >= this.requirement)) _addIssue(this, "value", dataset, config$1, { received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value) });
+      return dataset;
+    }
+  };
+}
+var ABORT_EARLY_CONFIG = { abortEarly: true };
+// @__NO_SIDE_EFFECTS__
+function getFallback(schema, dataset, config$1) {
+  return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
+}
+// @__NO_SIDE_EFFECTS__
+function getDefault(schema, dataset, config$1) {
+  return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
+}
+// @__NO_SIDE_EFFECTS__
+function array(item, message$1) {
+  return {
+    kind: "schema",
+    type: "array",
+    reference: array,
+    expects: "Array",
+    async: false,
+    item,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (Array.isArray(input)) {
+        dataset.typed = true;
+        dataset.value = [];
+        for (let key = 0; key < input.length; key++) {
+          const value$1 = input[key];
+          const itemDataset = this.item["~run"]({ value: value$1 }, config$1);
+          if (itemDataset.issues) {
+            const pathItem = {
+              type: "array",
+              origin: "value",
+              input,
+              key,
+              value: value$1
+            };
+            for (const issue of itemDataset.issues) {
+              if (issue.path) issue.path.unshift(pathItem);
+              else issue.path = [pathItem];
+              dataset.issues?.push(issue);
+            }
+            if (!dataset.issues) dataset.issues = itemDataset.issues;
+            if (config$1.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          if (!itemDataset.typed) dataset.typed = false;
+          dataset.value.push(itemDataset.value);
+        }
+      } else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function boolean(message$1) {
+  return {
+    kind: "schema",
+    type: "boolean",
+    reference: boolean,
+    expects: "boolean",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "boolean") dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function literal(literal_, message$1) {
+  return {
+    kind: "schema",
+    type: "literal",
+    reference: literal,
+    expects: /* @__PURE__ */ _stringify(literal_),
+    async: false,
+    literal: literal_,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (dataset.value === this.literal) dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function nan(message$1) {
+  return {
+    kind: "schema",
+    type: "nan",
+    reference: nan,
+    expects: "NaN",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (Number.isNaN(dataset.value)) dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function nullable(wrapped, default_) {
+  return {
+    kind: "schema",
+    type: "nullable",
+    reference: nullable,
+    expects: `(${wrapped.expects} | null)`,
+    async: false,
+    wrapped,
+    default: default_,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (dataset.value === null) {
+        if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+        if (dataset.value === null) {
+          dataset.typed = true;
+          return dataset;
+        }
+      }
+      return this.wrapped["~run"](dataset, config$1);
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function number(message$1) {
+  return {
+    kind: "schema",
+    type: "number",
+    reference: number,
+    expects: "number",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "number" && !isNaN(dataset.value)) dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function object(entries$1, message$1) {
+  return {
+    kind: "schema",
+    type: "object",
+    reference: object,
+    expects: "Object",
+    async: false,
+    entries: entries$1,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
+          const valueSchema = this.entries[key];
+          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key,
+                value: value$1
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path) issue.path.unshift(pathItem);
+                else issue.path = [pathItem];
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues) dataset.issues = valueDataset.issues;
+              if (config$1.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!valueDataset.typed) dataset.typed = false;
+            dataset.value[key] = valueDataset.value;
+          } else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue(this, "key", dataset, config$1, {
+              input: void 0,
+              expected: `"${key}"`,
+              path: [{
+                type: "object",
+                origin: "key",
+                input,
+                key,
+                value: input[key]
+              }]
+            });
+            if (config$1.abortEarly) break;
+          }
+        }
+      } else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function optional(wrapped, default_) {
+  return {
+    kind: "schema",
+    type: "optional",
+    reference: optional,
+    expects: `(${wrapped.expects} | undefined)`,
+    async: false,
+    wrapped,
+    default: default_,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (dataset.value === void 0) {
+        if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
+        if (dataset.value === void 0) {
+          dataset.typed = true;
+          return dataset;
+        }
+      }
+      return this.wrapped["~run"](dataset, config$1);
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function picklist(options, message$1) {
+  return {
+    kind: "schema",
+    type: "picklist",
+    reference: picklist,
+    expects: /* @__PURE__ */ _joinExpects(options.map(_stringify), "|"),
+    async: false,
+    options,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (this.options.includes(dataset.value)) dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function record(key, value$1, message$1) {
+  return {
+    kind: "schema",
+    type: "record",
+    reference: record,
+    expects: "Object",
+    async: false,
+    key,
+    value: value$1,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const entryKey in input) if (/* @__PURE__ */ _isValidObjectKey(input, entryKey)) {
+          const entryValue = input[entryKey];
+          const keyDataset = this.key["~run"]({ value: entryKey }, config$1);
+          if (keyDataset.issues) {
+            const pathItem = {
+              type: "object",
+              origin: "key",
+              input,
+              key: entryKey,
+              value: entryValue
+            };
+            for (const issue of keyDataset.issues) {
+              issue.path = [pathItem];
+              dataset.issues?.push(issue);
+            }
+            if (!dataset.issues) dataset.issues = keyDataset.issues;
+            if (config$1.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          const valueDataset = this.value["~run"]({ value: entryValue }, config$1);
+          if (valueDataset.issues) {
+            const pathItem = {
+              type: "object",
+              origin: "value",
+              input,
+              key: entryKey,
+              value: entryValue
+            };
+            for (const issue of valueDataset.issues) {
+              if (issue.path) issue.path.unshift(pathItem);
+              else issue.path = [pathItem];
+              dataset.issues?.push(issue);
+            }
+            if (!dataset.issues) dataset.issues = valueDataset.issues;
+            if (config$1.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          if (!keyDataset.typed || !valueDataset.typed) dataset.typed = false;
+          if (keyDataset.typed) dataset.value[keyDataset.value] = valueDataset.value;
+        }
+      } else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function strictObject(entries$1, message$1) {
+  return {
+    kind: "schema",
+    type: "strict_object",
+    reference: strictObject,
+    expects: "Object",
+    async: false,
+    entries: entries$1,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
+          const valueSchema = this.entries[key];
+          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
+            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
+            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key,
+                value: value$1
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path) issue.path.unshift(pathItem);
+                else issue.path = [pathItem];
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues) dataset.issues = valueDataset.issues;
+              if (config$1.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!valueDataset.typed) dataset.typed = false;
+            dataset.value[key] = valueDataset.value;
+          } else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue(this, "key", dataset, config$1, {
+              input: void 0,
+              expected: `"${key}"`,
+              path: [{
+                type: "object",
+                origin: "key",
+                input,
+                key,
+                value: input[key]
+              }]
+            });
+            if (config$1.abortEarly) break;
+          }
+        }
+        if (!dataset.issues || !config$1.abortEarly) {
+          for (const key in input) if (!(key in this.entries)) {
+            _addIssue(this, "key", dataset, config$1, {
+              input: key,
+              expected: "never",
+              path: [{
+                type: "object",
+                origin: "key",
+                input,
+                key,
+                value: input[key]
+              }]
+            });
+            break;
+          }
+        }
+      } else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function string(message$1) {
+  return {
+    kind: "schema",
+    type: "string",
+    reference: string,
+    expects: "string",
+    async: false,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      if (typeof dataset.value === "string") dataset.typed = true;
+      else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function _subIssues(datasets) {
+  let issues;
+  if (datasets) for (const dataset of datasets) if (issues) for (const issue of dataset.issues) issues.push(issue);
+  else issues = dataset.issues;
+  return issues;
+}
+// @__NO_SIDE_EFFECTS__
+function union(options, message$1) {
+  return {
+    kind: "schema",
+    type: "union",
+    reference: union,
+    expects: /* @__PURE__ */ _joinExpects(options.map((option) => option.expects), "|"),
+    async: false,
+    options,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      let validDataset;
+      let typedDatasets;
+      let untypedDatasets;
+      for (const schema of this.options) {
+        const optionDataset = schema["~run"]({ value: dataset.value }, config$1);
+        if (optionDataset.typed) if (optionDataset.issues) if (typedDatasets) typedDatasets.push(optionDataset);
+        else typedDatasets = [optionDataset];
+        else {
+          validDataset = optionDataset;
+          break;
+        }
+        else if (untypedDatasets) untypedDatasets.push(optionDataset);
+        else untypedDatasets = [optionDataset];
+      }
+      if (validDataset) return validDataset;
+      if (typedDatasets) {
+        if (typedDatasets.length === 1) return typedDatasets[0];
+        _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(typedDatasets) });
+        dataset.typed = true;
+      } else if (untypedDatasets?.length === 1) return untypedDatasets[0];
+      else _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(untypedDatasets) });
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function unknown() {
+  return {
+    kind: "schema",
+    type: "unknown",
+    reference: unknown,
+    expects: "unknown",
+    async: false,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset) {
+      dataset.typed = true;
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function variant(key, options, message$1) {
+  return {
+    kind: "schema",
+    type: "variant",
+    reference: variant,
+    expects: "Object",
+    async: false,
+    key,
+    options,
+    message: message$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        let outputDataset;
+        let maxDiscriminatorPriority = 0;
+        let invalidDiscriminatorKey = this.key;
+        let expectedDiscriminators = [];
+        const parseOptions = (variant$1, allKeys) => {
+          for (const schema of variant$1.options) {
+            if (schema.type === "variant") parseOptions(schema, new Set(allKeys).add(schema.key));
+            else {
+              let keysAreValid = true;
+              let currentPriority = 0;
+              for (const currentKey of allKeys) {
+                const discriminatorSchema = schema.entries[currentKey];
+                if (currentKey in input ? discriminatorSchema["~run"]({
+                  typed: false,
+                  value: input[currentKey]
+                }, ABORT_EARLY_CONFIG).issues : discriminatorSchema.type !== "exact_optional" && discriminatorSchema.type !== "optional" && discriminatorSchema.type !== "nullish") {
+                  keysAreValid = false;
+                  if (invalidDiscriminatorKey !== currentKey && (maxDiscriminatorPriority < currentPriority || maxDiscriminatorPriority === currentPriority && currentKey in input && !(invalidDiscriminatorKey in input))) {
+                    maxDiscriminatorPriority = currentPriority;
+                    invalidDiscriminatorKey = currentKey;
+                    expectedDiscriminators = [];
+                  }
+                  if (invalidDiscriminatorKey === currentKey) expectedDiscriminators.push(schema.entries[currentKey].expects);
+                  break;
+                }
+                currentPriority++;
+              }
+              if (keysAreValid) {
+                const optionDataset = schema["~run"]({ value: input }, config$1);
+                if (!outputDataset || !outputDataset.typed && optionDataset.typed) outputDataset = optionDataset;
+              }
+            }
+            if (outputDataset && !outputDataset.issues) break;
+          }
+        };
+        parseOptions(this, /* @__PURE__ */ new Set([this.key]));
+        if (outputDataset) return outputDataset;
+        _addIssue(this, "type", dataset, config$1, {
+          input: input[invalidDiscriminatorKey],
+          expected: /* @__PURE__ */ _joinExpects(expectedDiscriminators, "|"),
+          path: [{
+            type: "object",
+            origin: "value",
+            input,
+            key: invalidDiscriminatorKey,
+            value: input[invalidDiscriminatorKey]
+          }]
+        });
+      } else _addIssue(this, "type", dataset, config$1);
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function omit(schema, keys) {
+  const entries$1 = { ...schema.entries };
+  for (const key of keys) delete entries$1[key];
+  return {
+    ...schema,
+    entries: entries$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    }
+  };
+}
+function parse(schema, input, config$1) {
+  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
+  if (dataset.issues) throw new ValiError(dataset.issues);
+  return dataset.value;
+}
+// @__NO_SIDE_EFFECTS__
+function pipe(...pipe$1) {
+  return {
+    ...pipe$1[0],
+    pipe: pipe$1,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config$1) {
+      for (const item of pipe$1) if (item.kind !== "metadata") {
+        if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+          dataset.typed = false;
+          break;
+        }
+        if (!dataset.issues || !config$1.abortEarly && !config$1.abortPipeEarly) dataset = item["~run"](dataset, config$1);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function safeParse(schema, input, config$1) {
+  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
+  return {
+    typed: dataset.typed,
+    success: !dataset.issues,
+    output: dataset.value,
+    issues: dataset.issues
+  };
+}
+
+// protocol/src/ids.ts
+var notionBlockIdSchema = pipe(string(), brand("NotionBlockId"));
+var notionDataSourceIdSchema = pipe(
+  string(),
+  brand("NotionDataSourceId")
+);
+var notionPageIdSchema = pipe(string(), brand("NotionPageId"));
+var notionAgentIdSchema = pipe(string(), brand("NotionAgentId"));
+var notionSpaceIdSchema = pipe(string(), brand("NotionSpaceId"));
+
+// protocol/src/dataSources/propertySchema.ts
+var notionPropertyColorSchema = picklist([
+  "default",
+  "gray",
+  "brown",
+  "orange",
+  "yellow",
+  "green",
+  "blue",
+  "purple",
+  "pink",
+  "red",
+  "gray_background",
+  "brown_background",
+  "orange_background",
+  "yellow_background",
+  "green_background",
+  "blue_background",
+  "purple_background",
+  "pink_background",
+  "red_background",
+  "default_background"
+]);
+var notionPropertyOptionSchema = object({
+  id: string(),
+  name: string(),
+  color: optional(notionPropertyColorSchema),
+  description: optional(string())
+});
+var notionStatusGroupSchema = object({
+  id: string(),
+  name: string(),
+  color: optional(notionPropertyColorSchema),
+  option_ids: array(string())
+});
+var notionDualPropertySchema = object({
+  synced_property_id: string(),
+  synced_property_name: string()
+});
+var baseProp = object({
+  name: string(),
+  description: optional(string())
+});
+var NOTION_PROPERTY_TYPES = [
+  "title",
+  "rich_text",
+  "number",
+  "checkbox",
+  "url",
+  "email",
+  "phone_number",
+  "select",
+  "multi_select",
+  "status",
+  "date",
+  "people",
+  "files",
+  "unique_id",
+  "relation",
+  "place",
+  "formula",
+  "rollup",
+  "button",
+  "verification",
+  "last_visited_time",
+  "location",
+  "created_time",
+  "last_edited_time",
+  "created_by",
+  "last_edited_by"
+];
+var notionPropertyTypeSchema = picklist(NOTION_PROPERTY_TYPES);
+var CUSTOM_BLOCK_DATA_SOURCE_SORTABLE_PROPERTY_TYPES = [
+  "title",
+  "rich_text",
+  "number",
+  "checkbox",
+  "url",
+  "email",
+  "phone_number",
+  "date",
+  "created_time",
+  "last_edited_time"
+];
+var notionPropertySchemaSchema = variant("type", [
+  object({ ...baseProp.entries, type: literal("title") }),
+  object({ ...baseProp.entries, type: literal("rich_text") }),
+  object({ ...baseProp.entries, type: literal("number") }),
+  object({ ...baseProp.entries, type: literal("checkbox") }),
+  object({ ...baseProp.entries, type: literal("url") }),
+  object({ ...baseProp.entries, type: literal("email") }),
+  object({ ...baseProp.entries, type: literal("phone_number") }),
+  object({
+    ...baseProp.entries,
+    type: literal("select"),
+    options: array(notionPropertyOptionSchema)
+  }),
+  object({
+    ...baseProp.entries,
+    type: literal("multi_select"),
+    options: array(notionPropertyOptionSchema)
+  }),
+  object({
+    ...baseProp.entries,
+    type: literal("status"),
+    options: array(notionPropertyOptionSchema),
+    groups: array(notionStatusGroupSchema)
+  }),
+  object({ ...baseProp.entries, type: literal("date") }),
+  object({ ...baseProp.entries, type: literal("people") }),
+  object({ ...baseProp.entries, type: literal("files") }),
+  object({ ...baseProp.entries, type: literal("unique_id") }),
+  object({
+    ...baseProp.entries,
+    type: literal("relation"),
+    data_source_id: optional(string()),
+    dual_property: optional(notionDualPropertySchema)
+  }),
+  object({ ...baseProp.entries, type: literal("place") }),
+  object({ ...baseProp.entries, type: literal("formula") }),
+  object({ ...baseProp.entries, type: literal("rollup") }),
+  // Internal-only types passed through under their bridge-native names.
+  object({ ...baseProp.entries, type: literal("button") }),
+  object({ ...baseProp.entries, type: literal("verification") }),
+  object({ ...baseProp.entries, type: literal("last_visited_time") }),
+  object({ ...baseProp.entries, type: literal("location") }),
+  // Synthetic built-ins. The host always emits one of each per data source.
+  object({ ...baseProp.entries, type: literal("created_time") }),
+  object({ ...baseProp.entries, type: literal("last_edited_time") }),
+  object({ ...baseProp.entries, type: literal("created_by") }),
+  object({ ...baseProp.entries, type: literal("last_edited_by") })
+]);
+var NOTION_BUILTIN_PROPERTY_SCHEMAS = {
+  created_time: { type: "created_time", name: "Created time" },
+  last_edited_time: { type: "last_edited_time", name: "Last edited time" },
+  created_by: { type: "created_by", name: "Created by" },
+  last_edited_by: { type: "last_edited_by", name: "Last edited by" }
+};
+
+// protocol/src/dataSources/dataSource.ts
+var collectionPointerValidator = object({
+  id: notionDataSourceIdSchema,
+  table: string(),
+  spaceId: optional(notionSpaceIdSchema)
+});
+var notionCollectionSchemaValidator = object({
+  id: optional(notionDataSourceIdSchema),
+  /**
+   * Describes actual database properties in protocol 5. Protocol 3/4 payloads can also include
+   * synthetic metadata for compatibility. Use this map to resolve property bindings. Use this map
+   * to validate filter and sort references.
+   */
+  propertiesById: record(string(), notionPropertySchemaSchema)
+});
+var notionDataSourceSchema = object({
+  key: string(),
+  collectionPointer: optional(collectionPointerValidator),
+  /**
+   * Describes database properties. Use this schema to resolve property bindings. Use this
+   * schema to validate filter and sort references. Undefined when the host does not provide a
+   * database schema.
+   */
+  collectionSchema: optional(notionCollectionSchemaValidator),
+  /**
+   * Maps user-defined property keys to database property IDs. Use this map to resolve a key
+   * such as `name` to its database property ID. A value of `undefined` marks a declared
+   * property without a valid binding. Synthetic metadata does not add entries to this map.
+   */
+  propertyIdsByKey: record(string(), optional(string())),
+  /**
+   * Describes property values in query snapshots. Keys use the same property IDs as a snapshot's
+   * `propertiesById` map.
+   *
+   * Includes four synthetic metadata fields, even when the database schema is unavailable:
+   * `created_time`, `last_edited_time`, `created_by`, and `last_edited_by`. Also includes
+   * database properties when the host provides their schema.
+   *
+   * Use `propertiesById` to read a value. Use this map to read the value's schema. Use
+   * `collectionSchema` to validate filter and sort references.
+   */
+  propertySchemasById: record(string(), notionPropertySchemaSchema)
+});
+var notionDataSourceBindingSchema = object({
+  collectionPointer: optional(collectionPointerValidator),
+  /**
+   * Describes database properties. Use this schema to resolve property bindings. Use this
+   * schema to validate filter and sort references. Undefined when the host does not provide a
+   * database schema.
+   */
+  collectionSchema: optional(notionCollectionSchemaValidator),
+  /**
+   * Maps user-defined property keys to database property IDs. Use this map to resolve a key
+   * such as `name` to its database property ID. A value of `undefined` marks a declared
+   * property without a binding. Omitted when the host does not provide property mappings.
+   * Synthetic metadata does not add entries to this map.
+   */
+  propertyIdsByKey: optional(record(string(), optional(string())))
+});
+var notionDataSourceBindingsSchema = record(
+  string(),
+  notionDataSourceBindingSchema
+);
+
+// protocol/src/manifest.ts
+var manifestIconSchema = variant("type", [
+  object({
+    type: literal("emoji"),
+    emoji: string()
+  }),
+  object({
+    type: literal("external"),
+    url: string()
+  })
+]);
+var manifestPropertySchema = object({
+  name: string(),
+  description: optional(string()),
+  type: notionPropertyTypeSchema
+});
+var manifestDataSourceSchema = object({
+  name: string(),
+  description: optional(string()),
+  icon: optional(manifestIconSchema),
+  properties: optional(record(string(), manifestPropertySchema), {})
+});
+var manifestSchema = object({
+  version: literal(1),
+  dataSources: record(string(), manifestDataSourceSchema)
+});
+
+// protocol/src/contrast.ts
+var notionContrastModeSchema = picklist(["standard", "high"]);
+var DEFAULT_CONTRAST_MODE = "standard";
+
+// protocol/src/messages/contrastModeChanged.ts
+var contrastModeChangedMessageSchema = object({
+  type: literal("contrastModeChanged"),
+  contrastMode: notionContrastModeSchema
+});
+
+// protocol/src/parent.ts
+var notionParentSchema = variant("type", [
+  object({ type: literal("page_id"), page_id: notionPageIdSchema }),
+  object({
+    type: literal("data_source_id"),
+    data_source_id: notionDataSourceIdSchema
+  }),
+  object({ type: literal("workspace"), workspace: literal(true) }),
+  object({ type: literal("block_id"), block_id: notionBlockIdSchema }),
+  object({ type: literal("agent_id"), agent_id: notionAgentIdSchema }),
+  object({ type: literal("unavailable") })
+]);
+
+// protocol/src/pages/page.ts
+var customBlockPageSchema = variant("type", [
+  /** The viewer cannot access the containing page; its ID and parent are not exposed. */
+  object({ type: literal("unavailable") }),
+  /** The viewer can access the containing page; includes its ID and parent location. */
+  object({
+    type: literal("page"),
+    id: notionPageIdSchema,
+    /**
+     * The containing page's own parent. It lets a block distinguish a freestanding page from a
+     * database row without a round trip. Not to be confused with the top-level `parent` runtime
+     * value, which is the custom block's own parent.
+     */
+    parent: notionParentSchema
+  })
+]);
+var notionEmojiIconSchema = object({
+  type: literal("emoji"),
+  emoji: string()
+});
+var notionCustomEmojiIconSchema = object({
+  type: literal("custom_emoji"),
+  custom_emoji: object({
+    id: string(),
+    name: optional(string()),
+    url: optional(string())
+  })
+});
+var notionExternalFileSchema = object({
+  type: literal("external"),
+  external: object({ url: string() })
+});
+var notionHostedFileSchema = object({
+  type: literal("file"),
+  file: object({
+    url: string(),
+    expiry_time: optional(string())
+  })
+});
+var notionPageIconSchema = variant("type", [
+  notionEmojiIconSchema,
+  notionCustomEmojiIconSchema,
+  notionExternalFileSchema,
+  notionHostedFileSchema
+]);
+var notionPageCoverSchema = variant("type", [
+  notionExternalFileSchema,
+  notionHostedFileSchema
+]);
+var nullableStringSchema = nullable(string());
+var notionRichTextItemSchema = record(string(), unknown());
+var notionSelectOptionInputSchema = union([
+  object({
+    id: string(),
+    name: optional(string()),
+    color: optional(string()),
+    description: optional(nullableStringSchema)
+  }),
+  object({
+    name: string(),
+    id: optional(string()),
+    color: optional(string()),
+    description: optional(nullableStringSchema)
+  })
+]);
+var notionDateInputSchema = object({
+  start: string(),
+  end: optional(nullableStringSchema),
+  time_zone: optional(nullableStringSchema)
+});
+var notionUserInputSchema = union([
+  object({
+    object: optional(literal("user")),
+    id: string()
+  }),
+  object({
+    object: literal("group"),
+    id: string(),
+    name: optional(nullableStringSchema)
+  })
+]);
+var notionRelationInputSchema = object({ id: string() });
+var notionFileInputSchema = union([
+  object({
+    type: literal("external"),
+    name: string(),
+    external: object({ url: string() })
+  }),
+  object({
+    type: literal("file"),
+    name: string(),
+    file: object({
+      url: string(),
+      expiry_time: optional(string())
+    })
+  })
+]);
+var notionPlaceInputSchema = object({
+  lat: number(),
+  lon: number(),
+  name: optional(nullableStringSchema),
+  address: optional(nullableStringSchema),
+  aws_place_id: optional(nullableStringSchema),
+  google_place_id: optional(nullableStringSchema)
+});
+var pagePropertyBaseSchema = {
+  id: string()
+};
+var notionPagePropertyValueSchema = variant("type", [
+  object({
+    ...pagePropertyBaseSchema,
+    type: literal("title"),
+    title: array(notionRichTextItemSchema)
+  }),
+  object({
+    ...pagePropertyBaseSchema,
+    type: literal("rich_text"),
+    rich_text: array(notionRichTextItemSchema)
+  }),
+  object({
+    ...pagePropertyBaseSchema,
+    type: literal("number"),
+    number: nullable(number())
+  }),
+  object({
+    ...pagePropertyBaseSchema,
+    type: literal("url"),
+    url: nullableStringSchema
+  }),
+  object({
+    ...pagePropertyBaseSchema,
+    type: literal("email"),
+    email: nullableStringSchema
+  }),
+  object({
+    ...pagePropertyBaseSchema,
+    type: literal("phone_number"),
+    phone_number: nullableStringSchema
+  }),
+  object({
+    ...pagePropertyBaseSchema,
+    type: literal("checkbox"),
+    checkbox: boolean()
+  }),
+  object({
+    ...pagePropertyBaseSchema,
+    type: literal("select"),
+    select: nullable(notionSelectOptionInputSchema)
+  }),
+  object({
+    ...pagePropertyBaseSchema,
+    type: literal("status"),
+    status: nullable(notionSelectOptionInputSchema)
+  }),
+  object({
+    ...pagePropertyBaseSchema,
+    type: literal("multi_select"),
+    multi_select: array(notionSelectOptionInputSchema)
+  }),
+  object({
+    ...pagePropertyBaseSchema,
+    type: literal("date"),
+    date: nullable(notionDateInputSchema)
+  }),
+  object({
+    ...pagePropertyBaseSchema,
+    type: literal("people"),
+    people: array(notionUserInputSchema)
+  }),
+  object({
+    ...pagePropertyBaseSchema,
+    type: literal("relation"),
+    has_more: optional(boolean()),
+    relation: array(notionRelationInputSchema)
+  }),
+  object({
+    ...pagePropertyBaseSchema,
+    type: literal("files"),
+    files: array(notionFileInputSchema)
+  }),
+  object({
+    ...pagePropertyBaseSchema,
+    type: literal("place"),
+    place: nullable(notionPlaceInputSchema)
+  })
+]);
+var notionPagePropertyWriteMapSchema = record(
+  string(),
+  notionPagePropertyValueSchema
+);
+var notionPageSchema = object({
+  object: literal("page"),
+  id: notionPageIdSchema,
+  parent: notionParentSchema,
+  properties: notionPagePropertyWriteMapSchema,
+  created_time: optional(string()),
+  last_edited_time: optional(string()),
+  icon: optional(notionPageIconSchema),
+  cover: optional(notionPageCoverSchema),
+  url: optional(string()),
+  public_url: optional(string()),
+  /** Whether the page or an ancestor is archived. */
+  is_archived: boolean(),
+  /** Whether the page or an ancestor is in Trash. */
+  in_trash: boolean()
+});
+
+// protocol/src/messages/createPageResult.ts
+var customBlockCreatePageErrorCodeSchema = string();
+var customBlockCreatePageErrorInfoSchema = object({
+  code: customBlockCreatePageErrorCodeSchema,
+  message: string(),
+  isRetryable: boolean()
+});
+var createPageResultMessageSchema = variant("status", [
+  object({
+    type: literal("createPageResult"),
+    requestId: string(),
+    status: literal("success"),
+    /** The newly created page. */
+    page: notionPageSchema
+  }),
+  object({
+    type: literal("createPageResult"),
+    requestId: string(),
+    status: literal("error"),
+    error: customBlockCreatePageErrorInfoSchema
+  })
+]);
+
+// protocol/src/users/user.ts
+var notionUserIdSchema = pipe(string(), brand("NotionUserId"));
+var notionUserSchema = object({
+  object: literal("user"),
+  id: notionUserIdSchema,
+  name: optional(string()),
+  avatar_url: nullable(string()),
+  type: literal("person"),
+  person: object({
+    email: string()
+  })
+});
+var notionUserListSchema = object({
+  object: literal("list"),
+  results: array(notionUserSchema),
+  next_cursor: nullable(string()),
+  has_more: boolean(),
+  type: literal("user"),
+  user: record(string(), unknown())
+});
+
+// protocol/src/messages/currentUserChanged.ts
+var currentUserChangedMessageSchema = object({
+  type: literal("currentUserChanged"),
+  currentUser: notionUserSchema
+});
+
+// protocol/src/messages/dataSourcesChanged.ts
+var dataSourcesChangedMessageSchema = object({
+  type: literal("dataSourcesChanged"),
+  dataSources: object({
+    bindings: notionDataSourceBindingsSchema
+  })
+});
+
+// protocol/src/messages/getPage.ts
+var customBlockGetPageErrorCodeSchema = string();
+var customBlockGetPageErrorInfoSchema = object({
+  code: customBlockGetPageErrorCodeSchema,
+  message: string(),
+  isRetryable: boolean()
+});
+var getPageMessageSchema = object({
+  type: literal("getPage"),
+  requestId: string(),
+  pageId: notionPageIdSchema
+});
+var getPageResultMessageSchema = variant("status", [
+  object({
+    type: literal("getPageResult"),
+    requestId: string(),
+    status: literal("success"),
+    page: notionPageSchema
+  }),
+  object({
+    type: literal("getPageResult"),
+    requestId: string(),
+    status: literal("error"),
+    error: customBlockGetPageErrorInfoSchema
+  })
+]);
+
+// protocol/src/messages/getUser.ts
+var customBlockGetUserErrorCodeSchema = string();
+var customBlockGetUserErrorInfoSchema = object({
+  code: customBlockGetUserErrorCodeSchema,
+  message: string(),
+  isRetryable: boolean()
+});
+var getUserMessageSchema = object({
+  type: literal("getUser"),
+  requestId: string(),
+  userId: notionUserIdSchema
+});
+var getUserResultMessageSchema = variant("status", [
+  object({
+    type: literal("getUserResult"),
+    requestId: string(),
+    status: literal("success"),
+    user: notionUserSchema
+  }),
+  object({
+    type: literal("getUserResult"),
+    requestId: string(),
+    status: literal("error"),
+    error: customBlockGetUserErrorInfoSchema
+  })
+]);
+
+// protocol/src/theme.ts
+var notionThemeSchema = picklist(["light", "dark"]);
+
+// protocol/src/messages/init.ts
+var customBlockInitErrorCodeSchema = string();
+var customBlockInitErrorInfoSchema = object({
+  code: customBlockInitErrorCodeSchema,
+  message: string(),
+  isRetryable: boolean()
+});
+var initMessageSchema = variant("status", [
+  object({
+    type: literal("init"),
+    initializationId: string(),
+    status: literal("success"),
+    theme: notionThemeSchema,
+    contrastMode: notionContrastModeSchema,
+    blockId: notionBlockIdSchema,
+    parent: notionParentSchema,
+    page: customBlockPageSchema,
+    manifest: manifestSchema,
+    dataSources: object({
+      bindings: notionDataSourceBindingsSchema
+    }),
+    currentUser: notionUserSchema
+  }),
+  object({
+    type: literal("init"),
+    initializationId: string(),
+    status: literal("error"),
+    error: customBlockInitErrorInfoSchema
+  })
+]);
+
+// protocol/src/messages/invalidSandboxMessage.ts
+var invalidSandboxMessageSchema = object({
+  type: literal("invalidSandboxMessage"),
+  /**
+   * A human-readable string intended for sandbox-side logging. It has no structured contract.
+   */
+  reason: string()
+});
+
+// protocol/src/messages/listUsers.ts
+var customBlockListUsersErrorCodeSchema = string();
+var customBlockListUsersErrorInfoSchema = object({
+  code: customBlockListUsersErrorCodeSchema,
+  message: string(),
+  isRetryable: boolean()
+});
+var listUsersMessageSchema = object({
+  type: literal("listUsers"),
+  requestId: string(),
+  startCursor: optional(string()),
+  pageSize: optional(number())
+});
+var listUsersResultMessageSchema = variant("status", [
+  object({
+    type: literal("listUsersResult"),
+    requestId: string(),
+    status: literal("success"),
+    list: notionUserListSchema
+  }),
+  object({
+    type: literal("listUsersResult"),
+    requestId: string(),
+    status: literal("error"),
+    error: customBlockListUsersErrorInfoSchema
+  })
+]);
+
+// protocol/src/messages/openPage.ts
+var openPageModeSchema = picklist(["side_peek", "center_peek"]);
+var customBlockOpenPageErrorCodeSchema = string();
+var customBlockOpenPageErrorInfoSchema = object({
+  code: customBlockOpenPageErrorCodeSchema,
+  message: string(),
+  isRetryable: boolean()
+});
+var openPageMessageSchema = object({
+  type: literal("openPage"),
+  requestId: string(),
+  pageId: notionPageIdSchema,
+  mode: openPageModeSchema
+});
+var openPageResultMessageSchema = variant("status", [
+  object({
+    type: literal("openPageResult"),
+    requestId: string(),
+    status: literal("success"),
+    pageId: notionPageIdSchema
+  }),
+  object({
+    type: literal("openPageResult"),
+    requestId: string(),
+    status: literal("error"),
+    error: customBlockOpenPageErrorInfoSchema
+  })
+]);
+
+// protocol/src/messages/pageChanged.ts
+var pageChangedMessageSchema = object({
+  type: literal("pageChanged"),
+  page: customBlockPageSchema
+});
+
+// protocol/src/messages/parentChanged.ts
+var parentChangedMessageSchema = object({
+  type: literal("parentChanged"),
+  parent: notionParentSchema
+});
+
+// protocol/src/dataSources/dateValue.ts
+var notionDateReminderSchema = object({
+  unit: picklist(["year", "month", "week", "day"]),
+  value: number(),
+  time: string(),
+  defaultTimeZone: optional(string())
+});
+var notionTimeReminderSchema = object({
+  unit: picklist(["hour", "minute"]),
+  value: number()
+});
+var notionNoReminderSchema = object({
+  unit: literal("none")
+});
+var notionDateTimeReminderSchema = union([
+  notionDateReminderSchema,
+  notionTimeReminderSchema
+]);
+var dateOrNoReminder = optional(
+  union([notionDateReminderSchema, notionNoReminderSchema])
+);
+var dateTimeOrNoReminder = optional(
+  union([notionDateTimeReminderSchema, notionNoReminderSchema])
+);
+var notionDateSchema = object({
+  type: literal("date"),
+  start_date: string(),
+  reminder: dateOrNoReminder
+});
+var notionDateRangeSchema = object({
+  type: literal("daterange"),
+  start_date: string(),
+  end_date: string(),
+  reminder: dateOrNoReminder
+});
+var notionDateTimeSchema = object({
+  type: literal("datetime"),
+  start_date: string(),
+  start_time: string(),
+  time_zone: optional(string()),
+  reminder: dateTimeOrNoReminder
+});
+var notionDateTimeRangeSchema = object({
+  type: literal("datetimerange"),
+  start_date: string(),
+  start_time: string(),
+  end_date: string(),
+  end_time: string(),
+  time_zone: optional(string()),
+  reminder: dateTimeOrNoReminder
+});
+var notionDateValueSchema = variant("type", [
+  notionDateSchema,
+  notionDateRangeSchema,
+  notionDateTimeSchema,
+  notionDateTimeRangeSchema
+]);
+
+// protocol/src/dataSources/recordPointer.ts
+var notionRecordPointerSchema = object({
+  id: string(),
+  table: string()
+});
+
+// protocol/src/dataSources/dataSourceValue.ts
+var notionDataSourceValueSchema = union([
+  string(),
+  number(),
+  boolean(),
+  notionDateValueSchema,
+  array(string()),
+  array(notionRecordPointerSchema)
+]);
+
+// protocol/src/dataSources/dataSourcePage.ts
+var notionDataSourcePageBridgeSchema = object({
+  id: notionPageIdSchema,
+  /** Whether the page or an ancestor is archived. */
+  is_archived: boolean(),
+  /** Whether the page or an ancestor is in Trash. */
+  in_trash: boolean(),
+  propertiesById: record(string(), optional(notionDataSourceValueSchema))
+});
+
+// protocol/src/messages/queryDataSourceResult.ts
+var customBlockQueryDataSourceErrorCodeSchema = string();
+var customBlockQueryDataSourceErrorInfoSchema = object({
+  code: customBlockQueryDataSourceErrorCodeSchema,
+  message: string(),
+  isRetryable: boolean()
+});
+var queryDataSourceResultMessageSchema = variant("status", [
+  object({
+    type: literal("queryDataSourceResult"),
+    subscriptionId: string(),
+    status: literal("success"),
+    items: array(notionDataSourcePageBridgeSchema),
+    hasMore: boolean()
+  }),
+  object({
+    type: literal("queryDataSourceResult"),
+    subscriptionId: string(),
+    status: literal("error"),
+    error: customBlockQueryDataSourceErrorInfoSchema
+  })
+]);
+
+// protocol/src/messages/themeChanged.ts
+var themeChangedMessageSchema = object({
+  type: literal("themeChanged"),
+  theme: notionThemeSchema
+});
+
+// protocol/src/messages/updatePageResult.ts
+var customBlockUpdatePageErrorCodeSchema = string();
+var customBlockUpdatePageErrorInfoSchema = object({
+  code: customBlockUpdatePageErrorCodeSchema,
+  message: string(),
+  isRetryable: boolean()
+});
+var updatePageResultMessageSchema = variant("status", [
+  object({
+    type: literal("updatePageResult"),
+    requestId: string(),
+    status: literal("success"),
+    page: notionPageSchema
+  }),
+  object({
+    type: literal("updatePageResult"),
+    requestId: string(),
+    status: literal("error"),
+    error: customBlockUpdatePageErrorInfoSchema
+  })
+]);
+
+// protocol/src/messages/hostToSandbox.ts
+var hostToSandboxMessageSchema = variant("type", [
+  initMessageSchema,
+  themeChangedMessageSchema,
+  contrastModeChangedMessageSchema,
+  parentChangedMessageSchema,
+  pageChangedMessageSchema,
+  currentUserChangedMessageSchema,
+  dataSourcesChangedMessageSchema,
+  queryDataSourceResultMessageSchema,
+  createPageResultMessageSchema,
+  getPageResultMessageSchema,
+  getUserResultMessageSchema,
+  listUsersResultMessageSchema,
+  openPageResultMessageSchema,
+  updatePageResultMessageSchema,
+  invalidSandboxMessageSchema
+]);
+
+// protocol/src/protocolVersion.ts
+var LATEST_BRIDGE_PROTOCOL_VERSION = 5;
+
+// host/src/lifecycle/initErrors.ts
+var UNKNOWN_ERROR_MESSAGE = "Unexpected error while initializing custom block.";
+function initErrorForFailureReason(reason, data = {}) {
+  switch (reason) {
+    case "no_connect":
+      return {
+        code: reason,
+        message: "Sandbox did not send a connect message.",
+        isRetryable: true
+      };
+    case "invalid_connect_payload":
+      return {
+        code: reason,
+        message: "Sandbox sent an invalid connect message.",
+        // The sandbox must be updated to send a valid connect message.
+        isRetryable: false
+      };
+    case "manifest_unavailable":
+      return {
+        code: reason,
+        message: "The custom block manifest is unavailable.",
+        isRetryable: true
+      };
+    case "manifest_invalid":
+      return {
+        code: reason,
+        message: "Sandbox sent an invalid manifest.",
+        // The sandbox must be updated to a valid manifest.
+        isRetryable: false
+      };
+    case "invalid_protocol_version": {
+      const versionText = data.currentBridgeProtocolVersion ? `: ${data.currentBridgeProtocolVersion}` : ".";
+      return {
+        code: reason,
+        message: `Sandbox reported an invalid bridge protocol version ${versionText}`,
+        // The sandbox must be updated to a supported protocol version.
+        isRetryable: false
+      };
+    }
+    case "unsupported_protocol_version": {
+      const currentVersionText = data.currentBridgeProtocolVersion ? `${data.currentBridgeProtocolVersion} ` : "";
+      const minVersionText = data.minBridgeProtocolVersion ? ` Minimum supported version is ${data.minBridgeProtocolVersion}.` : "";
+      return {
+        code: reason,
+        message: `Sandbox bridge protocol version ${currentVersionText}is not supported.${minVersionText}`,
+        // The sandbox must be updated to a supported protocol version.
+        isRetryable: false
+      };
+    }
+    case "init_timeout":
+      return {
+        code: reason,
+        message: "Host dependencies did not finish loading before the timeout.",
+        isRetryable: true
+      };
+    case "context_unavailable":
+      return {
+        code: reason,
+        message: "Host page context is unavailable.",
+        isRetryable: true
+      };
+    case "current_user_unavailable":
+      return {
+        code: reason,
+        message: "Current user is unavailable.",
+        isRetryable: true
+      };
+    case "initial_state_timeout":
+      return {
+        code: reason,
+        message: "Host did not prepare initial state before the timeout.",
+        isRetryable: true
+      };
+    case "missing_data_source_binding":
+      return {
+        code: reason,
+        message: "A required data source is not mapped.",
+        // Host configuration must be changed before this block can initialize.
+        isRetryable: false
+      };
+    case "data_source_unavailable":
+      return {
+        code: reason,
+        message: "A mapped data source is unavailable.",
+        // This error combines some retryable errors (e.g. data source failed to load) with
+        // some non-retryable errors (e.g. data source does not exist or user does not have
+        // access). Fallback to assuming the error is retryable.
+        isRetryable: true
+      };
+    case "missing_property_binding":
+      return {
+        code: reason,
+        message: "A required data source property is not mapped.",
+        // Host configuration must be changed before this block can initialize.
+        isRetryable: false
+      };
+    case "invalid_property_binding":
+      return {
+        code: reason,
+        message: "A mapped data source property is missing or incompatible.",
+        // The bound property's schema must be updated or the binding must be updated to
+        // a property with a compatible schema.
+        isRetryable: false
+      };
+    case "no_init_result":
+      return {
+        code: reason,
+        message: "Sandbox did not acknowledge initialization.",
+        isRetryable: true
+      };
+    case "invalid_init_result_payload":
+      return {
+        code: reason,
+        message: "Sandbox sent an invalid initialization result.",
+        isRetryable: false
+      };
+    case "invalid_init_bindings":
+      return {
+        code: reason,
+        message: "Sandbox rejected the host-provided data source bindings.",
+        isRetryable: false
+      };
+    case "not_in_iframe":
+      return {
+        code: reason,
+        message: "<NotionCustomBlock> only works inside an iframe.",
+        // The block must be embedded in an iframe.
+        isRetryable: false
+      };
+    case "unknown_error":
+      return {
+        code: reason,
+        message: UNKNOWN_ERROR_MESSAGE,
+        // Treat unknown errors as non-retryable.
+        isRetryable: false
+      };
+    default:
+      console.warn(`Unexpected custom block init error: ${reason}`);
+      return {
+        code: reason,
+        message: UNKNOWN_ERROR_MESSAGE,
+        // Treat unknown error codes as non-retryable.
+        isRetryable: false
+      };
+  }
+}
+
+// host/src/utils.ts
+function unreachable(value) {
+  throw new Error(
+    `[custom-blocks-host] Unexpected value encountered: ${JSON.stringify(value)}`
+  );
+}
+
+// host/src/lifecycle/protocolVersion.ts
+function isValidBridgeProtocolVersion(version) {
+  return Number.isFinite(version) && Number.isInteger(version) && version >= 1;
+}
+
+// host/src/lifecycle/initializationController.ts
+var DEFAULT_NO_CONNECT_TIMEOUT_MS = 5e3;
+var DEFAULT_INITIAL_STATE_TIMEOUT_MS = 5e3;
+var DEFAULT_NO_INIT_RESULT_TIMEOUT_MS = 5e3;
+function createInitializationController(options) {
+  const {
+    prepareInit,
+    sendInitMessage,
+    warn,
+    flushPendingHostStateChanges,
+    minBridgeProtocolVersion,
+    noConnectTimeoutMs = DEFAULT_NO_CONNECT_TIMEOUT_MS,
+    initialStateTimeoutMs = DEFAULT_INITIAL_STATE_TIMEOUT_MS,
+    noInitResultTimeoutMs = DEFAULT_NO_INIT_RESULT_TIMEOUT_MS,
+    stopHostWithFailure,
+    onInitResult,
+    onConnectionFailure
+  } = options;
+  let initStatus = "waitingForConnect";
+  let noConnectTimeoutId;
+  let initialStateTimeoutId;
+  let noInitResultTimeoutId;
+  let activeInitializationId;
+  let hasObservedIframeLoad = false;
+  let hasConnectedSandbox = false;
+  function clearNoConnectTimeout() {
+    if (noConnectTimeoutId !== void 0) {
+      window.clearTimeout(noConnectTimeoutId);
+      noConnectTimeoutId = void 0;
+    }
+  }
+  function clearInitialStateTimeout() {
+    if (initialStateTimeoutId !== void 0) {
+      window.clearTimeout(initialStateTimeoutId);
+      initialStateTimeoutId = void 0;
+    }
+  }
+  function clearNoInitResultTimeout() {
+    if (noInitResultTimeoutId !== void 0) {
+      window.clearTimeout(noInitResultTimeoutId);
+      noInitResultTimeoutId = void 0;
+    }
+  }
+  function sendInitError(args) {
+    const { initializationId, error } = args;
+    switch (initStatus) {
+      case "waitingForConnect":
+      case "preparingInit":
+        break;
+      case "waitingForInitResult":
+      case "initialized":
+      case "error":
+      case "stopped":
+        return;
+      default:
+        return unreachable(initStatus);
+    }
+    initStatus = "error";
+    activeInitializationId = initializationId;
+    clearNoConnectTimeout();
+    clearInitialStateTimeout();
+    sendInitMessage({
+      type: "init",
+      initializationId,
+      status: "error",
+      error
+    });
+    onConnectionFailure?.(error);
+  }
+  async function prepareAndSendInit(connect) {
+    if (initStatus !== "waitingForConnect") {
+      return;
+    }
+    initStatus = "preparingInit";
+    activeInitializationId = connect.initializationId;
+    clearNoConnectTimeout();
+    initialStateTimeoutId = window.setTimeout(() => {
+      if (initStatus !== "preparingInit") {
+        return;
+      }
+      const error = initErrorForFailureReason("initial_state_timeout");
+      warn({
+        ...error,
+        initializationId: connect.initializationId
+      });
+      sendInitError({ initializationId: connect.initializationId, error });
+    }, initialStateTimeoutMs);
+    try {
+      const preparation = await prepareInit(connect);
+      if (initStatus !== "preparingInit") {
+        return;
+      }
+      clearInitialStateTimeout();
+      if (preparation.status === "error") {
+        sendInitError({
+          initializationId: connect.initializationId,
+          error: preparation.error
+        });
+        return;
+      }
+      initStatus = "waitingForInitResult";
+      const message = {
+        type: "init",
+        initializationId: connect.initializationId,
+        status: "success",
+        theme: preparation.initialState.theme,
+        contrastMode: preparation.initialState.contrastMode ?? DEFAULT_CONTRAST_MODE,
+        blockId: preparation.initialState.blockId,
+        parent: preparation.initialState.parent,
+        page: preparation.initialState.page,
+        currentUser: preparation.initialState.currentUser,
+        manifest: preparation.initialState.manifest,
+        dataSources: preparation.initialState.dataSources
+      };
+      sendInitMessage(message);
+      noInitResultTimeoutId = window.setTimeout(() => {
+        if (initStatus !== "waitingForInitResult") {
+          return;
+        }
+        initStatus = "error";
+        const error = initErrorForFailureReason("no_init_result");
+        onConnectionFailure?.(error);
+        warn({
+          ...error,
+          initializationId: connect.initializationId
+        });
+      }, noInitResultTimeoutMs);
+    } catch (error) {
+      if (initStatus !== "preparingInit") {
+        return;
+      }
+      warn({
+        message: "Failed to prepare custom block initialization",
+        error
+      });
+      sendInitError({
+        initializationId: connect.initializationId,
+        error: initErrorForFailureReason("unknown_error")
+      });
+    }
+  }
+  function handleConnect(message) {
+    if (initStatus === "stopped") {
+      return;
+    }
+    if (initStatus !== "waitingForConnect") {
+      return;
+    }
+    if (!isValidBridgeProtocolVersion(message.bridgeProtocolVersion)) {
+      const initError = initErrorForFailureReason("invalid_protocol_version", {
+        currentBridgeProtocolVersion: message.bridgeProtocolVersion
+      });
+      sendInitError({
+        initializationId: message.initializationId,
+        error: initError
+      });
+      return;
+    }
+    if (message.bridgeProtocolVersion < minBridgeProtocolVersion) {
+      const initError = initErrorForFailureReason(
+        "unsupported_protocol_version",
+        {
+          currentBridgeProtocolVersion: message.bridgeProtocolVersion,
+          minBridgeProtocolVersion
+        }
+      );
+      sendInitError({
+        initializationId: message.initializationId,
+        error: initError
+      });
+      return;
+    }
+    if (message.status === "error") {
+      sendInitError({
+        initializationId: message.initializationId,
+        error: message.error
+      });
+      return;
+    }
+    hasConnectedSandbox = true;
+    void prepareAndSendInit(message);
+  }
+  function handleInvalidConnect(args) {
+    if (initStatus === "stopped") {
+      return "handled";
+    }
+    if (initStatus !== "waitingForConnect") {
+      return "handled";
+    }
+    const { initializationId, bridgeProtocolVersion } = args;
+    if (initializationId === void 0) {
+      return "nack";
+    }
+    let error = args.error;
+    if (bridgeProtocolVersion !== void 0) {
+      if (!isValidBridgeProtocolVersion(bridgeProtocolVersion)) {
+        error = initErrorForFailureReason("invalid_protocol_version");
+      } else if (bridgeProtocolVersion < minBridgeProtocolVersion) {
+        error = initErrorForFailureReason("unsupported_protocol_version", {
+          currentBridgeProtocolVersion: bridgeProtocolVersion,
+          minBridgeProtocolVersion
+        });
+      }
+    }
+    sendInitError({ initializationId, error });
+    return "handled";
+  }
+  function handleInvalidInitResult(args) {
+    const { initializationId, error } = args;
+    if (initStatus !== "waitingForInitResult" || initializationId === void 0 || initializationId !== activeInitializationId) {
+      return;
+    }
+    clearNoConnectTimeout();
+    clearNoInitResultTimeout();
+    initStatus = "error";
+    warn(error);
+    onConnectionFailure?.(error);
+  }
+  function onIframeLoad() {
+    if (initStatus === "stopped") {
+      return;
+    }
+    if (hasObservedIframeLoad) {
+      stopHostWithFailure({
+        code: "iframe_reloaded",
+        message: "The iframe reloaded. Create a new host and iframe to reconnect.",
+        isRetryable: true
+      });
+      return;
+    }
+    hasObservedIframeLoad = true;
+    clearNoConnectTimeout();
+    if (initStatus !== "waitingForConnect") {
+      return;
+    }
+    noConnectTimeoutId = window.setTimeout(() => {
+      if (initStatus !== "waitingForConnect") {
+        return;
+      }
+      initStatus = "error";
+      const error = initErrorForFailureReason("no_connect");
+      warn(error);
+      onConnectionFailure?.(error);
+    }, noConnectTimeoutMs);
+  }
+  function handleInitResult(message) {
+    if (initStatus !== "waitingForInitResult" || message.initializationId !== activeInitializationId) {
+      warn({
+        message: "Ignored stale or unexpected initResult",
+        payload: message
+      });
+      return;
+    }
+    clearNoInitResultTimeout();
+    initStatus = message.status === "success" ? "initialized" : "error";
+    if (message.status === "success") {
+      flushPendingHostStateChanges();
+    } else {
+      onConnectionFailure?.(message.error);
+    }
+    onInitResult?.(message);
+  }
+  function stop() {
+    initStatus = "stopped";
+    clearNoConnectTimeout();
+    clearInitialStateTimeout();
+    clearNoInitResultTimeout();
+  }
+  return {
+    get status() {
+      return initStatus;
+    },
+    get hasConnectedSandbox() {
+      return hasConnectedSandbox;
+    },
+    handleConnect,
+    handleInitResult,
+    handleInvalidConnect,
+    handleInvalidInitResult,
+    onIframeLoad,
+    stop
+  };
+}
+
+// host/src/lifecycle/normalizeHostToSandboxMessage.ts
+function normalizeHostToSandboxMessage(message, bridgeProtocolVersion) {
+  if (bridgeProtocolVersion >= 5) {
+    return message;
+  }
+  const containsDataSources = message.type === "init" && message.status === "success" || message.type === "dataSourcesChanged";
+  if (!containsDataSources) {
+    return message;
+  }
+  return {
+    ...message,
+    dataSources: {
+      bindings: Object.fromEntries(
+        Object.entries(message.dataSources.bindings).map(([key, binding]) => [
+          key,
+          {
+            ...binding,
+            collectionSchema: {
+              ...binding.collectionSchema,
+              propertiesById: {
+                ...binding.collectionSchema?.propertiesById,
+                ...NOTION_BUILTIN_PROPERTY_SCHEMAS
+              }
+            }
+          }
+        ])
+      )
+    }
+  };
+}
+
+// host/src/lifecycle/types.ts
+var customBlockHostInitialStateSchema = object({
+  theme: notionThemeSchema,
+  /**
+   * Defaults to standard for existing host integrations.
+   * TODO(custom-blocks): Make this required when MIN_HOST_SUPPORTED_BRIDGE_PROTOCOL_VERSION increases to 4.
+   */
+  contrastMode: optional(notionContrastModeSchema),
+  blockId: notionBlockIdSchema,
+  parent: notionParentSchema,
+  page: customBlockPageSchema,
+  manifest: manifestSchema,
+  dataSources: object({ bindings: notionDataSourceBindingsSchema }),
+  currentUser: notionUserSchema
+});
+
+// protocol/src/messages/isInitHandshakeMessage.ts
+function isInitHandshakeMessage(message) {
+  switch (message.type) {
+    case "connect":
+    case "init":
+    case "initResult":
+      return true;
+    default:
+      return false;
+  }
+}
+
+// protocol/src/errors.ts
+var customBlockErrorInfoSchema = object({
+  code: string(),
+  message: string(),
+  isRetryable: boolean()
+});
+
+// protocol/src/messages/connect.ts
+var connectMessageCommonEntries = {
+  type: literal("connect"),
+  initializationId: string(),
+  /**
+   * The bridge protocol version this sandbox uses to communicate with its host.
+   * Hosts control which versions they support and can support multiple versions
+   * at the same time. Support for older versions is eventually removed, so blocks
+   * may need to update their SDK to continue working.
+   */
+  bridgeProtocolVersion: number(),
+  /**
+   * Semver version of the SDK package that sent this connect message. Should only be used for
+   * analytics purposes. Business logic should compare against `bridgeProtocolVersion` instead.
+   */
+  sdkVersion: string()
+};
+var connectMessageSchema = variant("status", [
+  object({
+    status: literal("success"),
+    /**
+     * The data sources and settings the custom block expects. Hosts may omit
+     * this when they already have an authoritative manifest.
+     */
+    manifest: optional(manifestSchema),
+    ...connectMessageCommonEntries
+  }),
+  object({
+    status: literal("error"),
+    error: customBlockErrorInfoSchema,
+    ...connectMessageCommonEntries
+  })
+]);
+
+// protocol/src/messages/createPage.ts
+var notionCreatePagePositionSchema = variant("type", [
+  object({ type: literal("start") }),
+  object({ type: literal("end") }),
+  object({ type: literal("before"), blockId: notionBlockIdSchema }),
+  object({ type: literal("after"), blockId: notionBlockIdSchema })
+]);
+var createPageParentSchema = variant("type", [
+  object({ type: literal("page_id"), page_id: notionPageIdSchema }),
+  object({
+    type: literal("data_source_id"),
+    data_source_id: notionDataSourceIdSchema
+  })
+]);
+var createPageMessageSchema = object({
+  type: literal("createPage"),
+  requestId: string(),
+  parent: createPageParentSchema,
+  /**
+   * Property values, keyed by raw property IDs from Notion.
+   *
+   * Each value must carry the same raw property ID in its `id` field.
+   * To create a page with manifest-defined property keys, call `pages.create`. The SDK resolves
+   * those keys before it sends this message.
+   */
+  properties: notionPagePropertyWriteMapSchema,
+  position: optional(notionCreatePagePositionSchema)
+});
+
+// protocol/src/messages/initResult.ts
+var customBlockInitResultErrorCodeSchema = string();
+var customBlockInitResultErrorInfoSchema = object({
+  code: customBlockInitResultErrorCodeSchema,
+  message: string(),
+  isRetryable: boolean()
+});
+var initResultMessageSchema = variant("status", [
+  object({
+    type: literal("initResult"),
+    initializationId: string(),
+    status: literal("success"),
+    /** Height of the initial rendered custom-block content, in CSS pixels. */
+    // Older SDKs can omit the height. Current SDKs always send it.
+    // TODO(custom-blocks): Make this required when MIN_HOST_SUPPORTED_BRIDGE_PROTOCOL_VERSION increases to 4.
+    initialHeight: optional(pipe(number(), finite(), minValue(0)))
+  }),
+  object({
+    type: literal("initResult"),
+    initializationId: string(),
+    status: literal("error"),
+    error: customBlockInitResultErrorInfoSchema
+  })
+]);
+
+// protocol/src/messages/invalidHostMessage.ts
+var invalidHostMessageSchema = object({
+  type: literal("invalidHostMessage"),
+  /**
+   * A human-readable string intended for sandbox-side logging. It has no structured contract.
+   */
+  reason: string()
+});
+
+// protocol/src/messages/queryDataSource.ts
+var emptyOperatorSchema = union([
+  strictObject({ is_empty: literal(true) }),
+  strictObject({ is_not_empty: literal(true) })
+]);
+var stringOrStringArraySchema = union([string(), array(string())]);
+var customBlockPersonFilterValueSchema = strictObject({
+  object: picklist(["user", "group"]),
+  id: pipe(string(), minLength(1))
+});
+var customBlockPeopleFilterOperatorSchema = union([
+  strictObject({ contains: customBlockPersonFilterValueSchema }),
+  strictObject({ does_not_contain: customBlockPersonFilterValueSchema }),
+  emptyOperatorSchema
+]);
+var customBlockCreatorFilterValueSchema = strictObject({
+  object: literal("user"),
+  id: pipe(string(), minLength(1), maxLength(2e3))
+});
+var customBlockCreatedByFilterOperatorSchema = union([
+  strictObject({ contains: customBlockCreatorFilterValueSchema }),
+  strictObject({ does_not_contain: customBlockCreatorFilterValueSchema }),
+  strictObject({ is_empty: literal(true) }),
+  strictObject({ is_not_empty: literal(true) })
+]);
+var customBlockTextFilterOperatorSchema = union([
+  strictObject({ equals: string() }),
+  strictObject({ does_not_equal: string() }),
+  strictObject({ contains: string() }),
+  strictObject({ does_not_contain: string() }),
+  strictObject({ starts_with: string() }),
+  strictObject({ ends_with: string() }),
+  emptyOperatorSchema
+]);
+var customBlockNumberFilterOperatorSchema = union([
+  strictObject({ equals: number() }),
+  strictObject({ does_not_equal: number() }),
+  strictObject({ greater_than: number() }),
+  strictObject({ less_than: number() }),
+  strictObject({ greater_than_or_equal_to: number() }),
+  strictObject({ less_than_or_equal_to: number() }),
+  emptyOperatorSchema
+]);
+var customBlockCheckboxFilterOperatorSchema = union([
+  strictObject({ equals: boolean() }),
+  strictObject({ does_not_equal: boolean() })
+]);
+var customBlockOptionFilterOperatorSchema = union([
+  strictObject({ equals: stringOrStringArraySchema }),
+  strictObject({ does_not_equal: stringOrStringArraySchema }),
+  emptyOperatorSchema
+]);
+var customBlockStatusGroupNameSchema = picklist([
+  "To-do",
+  "In progress",
+  "Complete",
+  "Current",
+  "Future"
+]);
+var customBlockStatusGroupFilterValueSchema = union([
+  customBlockStatusGroupNameSchema,
+  pipe(
+    array(customBlockStatusGroupNameSchema),
+    minLength(1),
+    maxLength(5)
+  )
+]);
+var customBlockStatusGroupFilterOperatorSchema = union([
+  strictObject({ group_equals: customBlockStatusGroupFilterValueSchema }),
+  strictObject({
+    group_does_not_equal: customBlockStatusGroupFilterValueSchema
+  })
+]);
+var customBlockStatusFilterOperatorSchema = union([
+  customBlockOptionFilterOperatorSchema,
+  customBlockStatusGroupFilterOperatorSchema
+]);
+var customBlockContainsFilterOperatorSchema = union([
+  strictObject({ contains: stringOrStringArraySchema }),
+  strictObject({ contains_all: stringOrStringArraySchema }),
+  strictObject({ does_not_contain: stringOrStringArraySchema }),
+  emptyOperatorSchema
+]);
+var dateTargetSchema = picklist(["start_date", "end_date"]);
+var customBlockRelativeDateValueSchema = picklist([
+  "today",
+  "tomorrow",
+  "yesterday",
+  "one_week_ago",
+  "one_week_from_now",
+  "one_month_ago",
+  "one_month_from_now"
+]);
+var dateComparisonValueSchema = union([
+  customBlockRelativeDateValueSchema,
+  string()
+]);
+var customBlockDateFilterOperatorSchema = union([
+  strictObject({
+    target: optional(dateTargetSchema),
+    equals: dateComparisonValueSchema
+  }),
+  strictObject({
+    target: optional(dateTargetSchema),
+    before: dateComparisonValueSchema
+  }),
+  strictObject({
+    target: optional(dateTargetSchema),
+    after: dateComparisonValueSchema
+  }),
+  strictObject({
+    target: optional(dateTargetSchema),
+    on_or_before: dateComparisonValueSchema
+  }),
+  strictObject({
+    target: optional(dateTargetSchema),
+    on_or_after: dateComparisonValueSchema
+  }),
+  strictObject({
+    target: optional(dateTargetSchema),
+    this_week: strictObject({})
+  }),
+  strictObject({
+    target: optional(dateTargetSchema),
+    past_week: strictObject({})
+  }),
+  strictObject({
+    target: optional(dateTargetSchema),
+    past_month: strictObject({})
+  }),
+  strictObject({
+    target: optional(dateTargetSchema),
+    past_year: strictObject({})
+  }),
+  strictObject({
+    target: optional(dateTargetSchema),
+    next_week: strictObject({})
+  }),
+  strictObject({
+    target: optional(dateTargetSchema),
+    next_month: strictObject({})
+  }),
+  strictObject({
+    target: optional(dateTargetSchema),
+    next_year: strictObject({})
+  }),
+  strictObject({
+    target: optional(dateTargetSchema),
+    is_empty: literal(true)
+  }),
+  strictObject({
+    target: optional(dateTargetSchema),
+    is_not_empty: literal(true)
+  })
+]);
+var resolvedCustomBlockDataSourcePropertyFilterSchema = union([
+  strictObject({
+    propertyId: string(),
+    created_by: customBlockCreatedByFilterOperatorSchema
+  }),
+  strictObject({
+    propertyId: string(),
+    title: customBlockTextFilterOperatorSchema
+  }),
+  strictObject({
+    propertyId: string(),
+    rich_text: customBlockTextFilterOperatorSchema
+  }),
+  strictObject({
+    propertyId: string(),
+    url: customBlockTextFilterOperatorSchema
+  }),
+  strictObject({
+    propertyId: string(),
+    email: customBlockTextFilterOperatorSchema
+  }),
+  strictObject({
+    propertyId: string(),
+    phone_number: customBlockTextFilterOperatorSchema
+  }),
+  strictObject({
+    propertyId: string(),
+    number: customBlockNumberFilterOperatorSchema
+  }),
+  strictObject({
+    propertyId: string(),
+    checkbox: customBlockCheckboxFilterOperatorSchema
+  }),
+  strictObject({
+    propertyId: string(),
+    select: customBlockOptionFilterOperatorSchema
+  }),
+  strictObject({
+    propertyId: string(),
+    multi_select: customBlockContainsFilterOperatorSchema
+  }),
+  strictObject({
+    propertyId: string(),
+    status: customBlockStatusFilterOperatorSchema
+  }),
+  strictObject({
+    propertyId: string(),
+    date: customBlockDateFilterOperatorSchema
+  }),
+  strictObject({
+    propertyId: string(),
+    people: customBlockPeopleFilterOperatorSchema
+  })
+]);
+var resolvedCustomBlockDataSourceFilterSchema = union([
+  resolvedCustomBlockDataSourcePropertyFilterSchema,
+  strictObject({
+    and: array(resolvedCustomBlockDataSourcePropertyFilterSchema)
+  })
+]);
+var CUSTOM_BLOCK_DATA_SOURCE_QUERY_MAX_SORTS = 10;
+var resolvedCustomBlockDataSourceSortSchema = strictObject({
+  propertyId: string(),
+  direction: picklist(["ascending", "descending"])
+});
+var queryDataSourceMessageSchema = object({
+  type: literal("queryDataSource"),
+  /** Stable for the lifetime of this query subscription. */
+  subscriptionId: string(),
+  /** The raw Notion data source ID to read from. */
+  dataSourceId: notionDataSourceIdSchema,
+  /** The number of items to return in each subscription update. */
+  limit: number(),
+  /** A sandbox-resolved property filter. */
+  filter: optional(resolvedCustomBlockDataSourceFilterSchema),
+  /** Sandbox-resolved property sorts, in priority order. */
+  sorts: optional(array(resolvedCustomBlockDataSourceSortSchema))
+});
+
+// protocol/src/messages/resize.ts
+var resizeMessageSchema = object({
+  type: literal("resize"),
+  height: pipe(number(), finite(), minValue(0))
+});
+
+// protocol/src/messages/unsubscribeDataSourceQuery.ts
+var unsubscribeDataSourceQueryMessageSchema = object({
+  type: literal("unsubscribeDataSourceQuery"),
+  /** The subscription to remove from the host. */
+  subscriptionId: string()
+});
+
+// protocol/src/messages/updatePage.ts
+var updatePageMessageSchema = object({
+  type: literal("updatePage"),
+  requestId: string(),
+  pageId: notionPageIdSchema,
+  /**
+   * Property values, keyed by raw property IDs from Notion.
+   *
+   * Each value must carry the same raw property ID in its `id` field.
+   * To update a page with manifest-defined property keys, call `row.update()` on a row returned
+   * by `useDataSource()`. The SDK resolves those keys before it sends this message.
+   */
+  properties: optional(notionPagePropertyWriteMapSchema),
+  icon: optional(notionPageIconSchema),
+  cover: optional(notionPageCoverSchema),
+  archived: optional(boolean())
+});
+
+// protocol/src/messages/sandboxToHost.ts
+var sandboxToHostMessageSchema = variant("type", [
+  connectMessageSchema,
+  initResultMessageSchema,
+  queryDataSourceMessageSchema,
+  unsubscribeDataSourceQueryMessageSchema,
+  createPageMessageSchema,
+  getPageMessageSchema,
+  getUserMessageSchema,
+  listUsersMessageSchema,
+  openPageMessageSchema,
+  updatePageMessageSchema,
+  resizeMessageSchema,
+  invalidHostMessageSchema
+]);
+
+// protocol/src/messages/incomingType.ts
+function readIncomingType(data) {
+  if (typeof data === "object" && data !== null && "type" in data && typeof data.type === "string") {
+    return data.type;
+  }
+  return void 0;
+}
+
+// host/src/messages/invalidSandboxMessage.ts
+function getInvalidSandboxMessageResponse(data) {
+  const incomingType = readIncomingType(data);
+  if (incomingType === "invalidHostMessage" || incomingType === "invalidSandboxMessage") {
+    return { incomingType };
+  }
+  return {
+    incomingType,
+    nack: {
+      type: "invalidSandboxMessage",
+      reason: nackReasonForInvalidSandboxMessage(incomingType)
+    }
+  };
+}
+function nackReasonForInvalidSandboxMessage(incomingType) {
+  if (incomingType !== void 0) {
+    return `Unsupported sandbox message of type "${incomingType}"`;
+  }
+  return "Unsupported sandbox message (no `type` field or non-object payload)";
+}
+
+// host/src/messages/sandboxMessageRouter.ts
+var initializationIdentitySchema = object({
+  initializationId: string()
+});
+var bridgeProtocolVersionSchema = object({
+  // NaN is not a valid protocol version. Keep it in this parser so the host can
+  // report `invalid_protocol_version`.
+  bridgeProtocolVersion: union([number(), nan()])
+});
+function createSandboxMessageRouter(options) {
+  const {
+    iframe,
+    sandboxOrigin,
+    getInitStatus,
+    emit,
+    sendNack,
+    onInvalidConnect,
+    onInvalidInitResult,
+    onConnect,
+    onInitResult,
+    onQueryDataSource,
+    onUnsubscribeDataSourceQuery,
+    onCreatePage,
+    onGetPage,
+    onOpenPage,
+    onGetUser,
+    onListUsers,
+    onUpdatePage,
+    onResize
+  } = options;
+  function onInvalidSandboxMessage(data, issues) {
+    emit("warn", {
+      message: "Ignored unsupported sandbox message",
+      payload: data,
+      issues
+    });
+    const response = getInvalidSandboxMessageResponse(data);
+    if (response.incomingType === "connect") {
+      const parsedIdentity = safeParse(initializationIdentitySchema, data);
+      const parsedVersion = safeParse(bridgeProtocolVersionSchema, data);
+      const responseType = onInvalidConnect({
+        initializationId: parsedIdentity.success ? parsedIdentity.output.initializationId : void 0,
+        error: initErrorForFailureReason("invalid_connect_payload"),
+        bridgeProtocolVersion: parsedVersion.success ? parsedVersion.output.bridgeProtocolVersion : void 0
+      });
+      if (responseType === "handled") {
+        return;
+      }
+    }
+    if (response.incomingType === "initResult") {
+      const parsedIdentity = safeParse(initializationIdentitySchema, data);
+      onInvalidInitResult({
+        initializationId: parsedIdentity.success ? parsedIdentity.output.initializationId : void 0,
+        error: initErrorForFailureReason("invalid_init_result_payload")
+      });
+    }
+    if (response.nack !== void 0 && getInitStatus() !== "stopped") {
+      sendNack(response.nack);
+    }
+  }
+  return function onMessage(event) {
+    const isExpectedSource = event.source === iframe.contentWindow;
+    const isExpectedOrigin = event.origin === sandboxOrigin;
+    if (!isExpectedSource || !isExpectedOrigin) {
+      return;
+    }
+    const parsed = safeParse(sandboxToHostMessageSchema, event.data);
+    if (!parsed.success) {
+      onInvalidSandboxMessage(event.data, parsed.issues);
+      return;
+    }
+    const message = parsed.output;
+    if (!isInitHandshakeMessage(message) && getInitStatus() !== "initialized") {
+      emit("warn", {
+        message: `Ignored ${message.type} before initialization completed`,
+        payload: message
+      });
+      return;
+    }
+    emit("in", message);
+    switch (message.type) {
+      case "connect":
+        onConnect(message);
+        return;
+      case "initResult":
+        onInitResult(message);
+        return;
+      case "queryDataSource":
+        void onQueryDataSource(message);
+        return;
+      case "unsubscribeDataSourceQuery":
+        onUnsubscribeDataSourceQuery(message);
+        return;
+      case "createPage":
+        void onCreatePage(message);
+        return;
+      case "openPage":
+        void onOpenPage(message);
+        return;
+      case "getPage":
+        void onGetPage(message);
+        return;
+      case "getUser":
+        void onGetUser(message);
+        return;
+      case "listUsers":
+        void onListUsers(message);
+        return;
+      case "updatePage":
+        void onUpdatePage(message);
+        return;
+      case "resize":
+        onResize(message);
+        return;
+      case "invalidHostMessage":
+        return;
+      default:
+        unreachable(message);
+    }
+  };
+}
+
+// host/src/protocolVersion.ts
+var MIN_HOST_SUPPORTED_BRIDGE_PROTOCOL_VERSION = 3;
+
+// host/src/queries/querySubscriptions.ts
+var QuerySubscriptions = class {
+  constructor(onUnsubscribe) {
+    this.onUnsubscribe = onUnsubscribe;
+  }
+  onUnsubscribe;
+  bySubscriptionId = /* @__PURE__ */ new Map();
+  subscribe(message) {
+    this.unsubscribe(message.subscriptionId);
+    const token = {
+      _tag: "QuerySubscriptionToken"
+    };
+    this.bySubscriptionId.set(message.subscriptionId, {
+      message,
+      token,
+      isRefreshing: true,
+      shouldRefreshAgain: false
+    });
+    return token;
+  }
+  isCurrent(subscriptionId, token) {
+    return this.bySubscriptionId.get(subscriptionId)?.token === token;
+  }
+  unsubscribe(subscriptionId) {
+    if (this.bySubscriptionId.delete(subscriptionId)) {
+      this.onUnsubscribe(subscriptionId);
+    }
+  }
+  refresh(dataSourceId) {
+    const refreshes = [];
+    let hasSubscriptions = false;
+    for (const queryState of this.bySubscriptionId.values()) {
+      if (queryState.message.dataSourceId !== dataSourceId) {
+        continue;
+      }
+      hasSubscriptions = true;
+      if (queryState.isRefreshing) {
+        queryState.shouldRefreshAgain = true;
+        continue;
+      }
+      queryState.isRefreshing = true;
+      refreshes.push({
+        message: queryState.message,
+        token: queryState.token
+      });
+    }
+    return hasSubscriptions ? refreshes : void 0;
+  }
+  finish(subscriptionId, token) {
+    const state = this.bySubscriptionId.get(subscriptionId);
+    if (state?.token !== token) {
+      return void 0;
+    }
+    state.isRefreshing = false;
+    if (!state.shouldRefreshAgain) {
+      return void 0;
+    }
+    state.shouldRefreshAgain = false;
+    state.isRefreshing = true;
+    return { message: state.message, token: state.token };
+  }
+  unsubscribeAll() {
+    for (const subscriptionId of this.bySubscriptionId.keys()) {
+      this.unsubscribe(subscriptionId);
+    }
+  }
+};
+
+// host/src/queries/validateQueryDataSourceFilter.ts
+function validateQueryDataSourceFilter(filter, collectionSchema) {
+  if (filter === void 0) {
+    return void 0;
+  }
+  const propertyFilters = "and" in filter ? filter.and : [filter];
+  for (const propertyFilter of propertyFilters) {
+    const error = validatePropertyFilter(propertyFilter, collectionSchema);
+    if (error !== void 0) {
+      return error;
+    }
+  }
+  return void 0;
+}
+function validatePropertyFilter(filter, collectionSchema) {
+  if (!Object.hasOwn(collectionSchema.propertiesById, filter.propertyId)) {
+    return {
+      code: "invalid_data_source_query_filter",
+      message: `Data source query filter property ID "${filter.propertyId}" is not defined in the bound data source schema.`,
+      isRetryable: false
+    };
+  }
+  const propertySchema = collectionSchema.propertiesById[filter.propertyId];
+  const branch = Object.keys(filter).find((key) => key !== "propertyId");
+  if (branch !== propertySchema.type) {
+    return {
+      code: "invalid_data_source_query_filter",
+      message: `Data source query filter branch "${branch}" does not match property type "${propertySchema.type}".`,
+      isRetryable: false
+    };
+  }
+  if ("status" in filter && propertySchema.type === "status") {
+    const operator = filter.status;
+    if ("group_equals" in operator || "group_does_not_equal" in operator) {
+      const value = "group_equals" in operator ? operator.group_equals : operator.group_does_not_equal;
+      const names = Array.isArray(value) ? value : [value];
+      const unknownName = names.find(
+        (name) => !propertySchema.groups.some((group) => group.name === name)
+      );
+      return unknownName === void 0 ? void 0 : {
+        code: "invalid_data_source_query_filter",
+        message: `Unknown status group "${unknownName}".`,
+        isRetryable: false
+      };
+    }
+  }
+  const optionFilter = getOptionFilter(filter);
+  if (optionFilter === void 0 || propertySchema.type !== optionFilter.propertyType) {
+    return void 0;
+  }
+  const optionNames = new Set(propertySchema.options.map((option) => option.name));
+  const invalidOptionName = getOptionFilterValues(optionFilter.operator).find(
+    (optionName) => !optionNames.has(optionName)
+  );
+  if (invalidOptionName === void 0) {
+    return void 0;
+  }
+  return {
+    code: "invalid_data_source_query_filter",
+    message: `Data source query filter option "${invalidOptionName}" is not defined for property "${filter.propertyId}".`,
+    isRetryable: false
+  };
+}
+function getOptionFilter(filter) {
+  if ("select" in filter) {
+    return { propertyType: "select", operator: filter.select };
+  }
+  if ("multi_select" in filter) {
+    return { propertyType: "multi_select", operator: filter.multi_select };
+  }
+  if ("status" in filter) {
+    const operator = filter.status;
+    return "group_equals" in operator || "group_does_not_equal" in operator ? void 0 : { propertyType: "status", operator };
+  }
+  return void 0;
+}
+function getOptionFilterValues(operator) {
+  let value;
+  if ("equals" in operator) {
+    value = operator.equals;
+  } else if ("does_not_equal" in operator) {
+    value = operator.does_not_equal;
+  } else if ("contains" in operator) {
+    value = operator.contains;
+  } else if ("contains_all" in operator) {
+    value = operator.contains_all;
+  } else if ("does_not_contain" in operator) {
+    value = operator.does_not_contain;
+  } else if ("is_empty" in operator || "is_not_empty" in operator) {
+    return [];
+  } else {
+    return unreachable(operator);
+  }
+  return Array.isArray(value) ? value : [value];
+}
+
+// host/src/queries/validateQueryDataSourceSorts.ts
+var supportedDataSourceSortPropertyTypes = new Set(
+  CUSTOM_BLOCK_DATA_SOURCE_SORTABLE_PROPERTY_TYPES
+);
+function validateQueryDataSourceSorts(sorts, collectionSchema) {
+  if (sorts === void 0) {
+    return void 0;
+  }
+  if (sorts.length > CUSTOM_BLOCK_DATA_SOURCE_QUERY_MAX_SORTS) {
+    return {
+      code: "invalid_data_source_query_sort",
+      message: `Data source query sorts may contain at most ${CUSTOM_BLOCK_DATA_SOURCE_QUERY_MAX_SORTS} entries.`,
+      isRetryable: false
+    };
+  }
+  const seenPropertyIds = /* @__PURE__ */ new Set();
+  for (const sort of sorts) {
+    if (seenPropertyIds.has(sort.propertyId)) {
+      return {
+        code: "invalid_data_source_query_sort",
+        message: `Data source query sorts cannot contain duplicate property ID "${sort.propertyId}".`,
+        isRetryable: false
+      };
+    }
+    seenPropertyIds.add(sort.propertyId);
+    if (!Object.hasOwn(collectionSchema.propertiesById, sort.propertyId)) {
+      return {
+        code: "invalid_data_source_query_sort",
+        message: `Data source query sort property ID "${sort.propertyId}" is not defined in the bound data source schema.`,
+        isRetryable: false
+      };
+    }
+    const propertySchema = collectionSchema.propertiesById[sort.propertyId];
+    if (!supportedDataSourceSortPropertyTypes.has(propertySchema.type)) {
+      return {
+        code: "invalid_data_source_query_sort",
+        message: `Data source query sorts do not yet support property type "${propertySchema.type}".`,
+        isRetryable: false
+      };
+    }
+  }
+  return void 0;
+}
+
+// host/src/createCustomBlockHost.ts
+var BRIDGE_PROTOCOL_VERSION_INTRODUCING_UNAVAILABLE_PAGE = 5;
+function createCustomBlockHost(options) {
+  const {
+    iframe,
+    getInitialState,
+    handlers,
+    onManifest,
+    onInitialized,
+    onConnectionFailure,
+    onLog,
+    onQueryUnsubscribed,
+    sandboxOrigin,
+    minBridgeProtocolVersion: configuredMinBridgeProtocolVersion,
+    noConnectTimeoutMs,
+    initialStateTimeoutMs,
+    noInitResultTimeoutMs
+  } = options;
+  const minBridgeProtocolVersion = Math.max(
+    configuredMinBridgeProtocolVersion ?? MIN_HOST_SUPPORTED_BRIDGE_PROTOCOL_VERSION,
+    MIN_HOST_SUPPORTED_BRIDGE_PROTOCOL_VERSION
+  );
+  let pendingState = {};
+  let hasPreparedInitialState = false;
+  let manifest;
+  let activeDataSources;
+  let sandboxBridgeProtocolVersion = LATEST_BRIDGE_PROTOCOL_VERSION;
+  const querySubscriptions = new QuerySubscriptions((subscriptionId) => {
+    onQueryUnsubscribed?.(subscriptionId);
+  });
+  function emit(direction, payload) {
+    onLog?.(direction, payload);
+  }
+  function postToSandbox(message) {
+    const status = initializationController.status;
+    switch (status) {
+      case "waitingForConnect":
+      case "preparingInit":
+      case "waitingForInitResult":
+      case "initialized":
+      case "error":
+        break;
+      // A stopped host must not send messages, including pending responses.
+      // Return from the function to skip delivery below.
+      case "stopped":
+        return;
+      default:
+        return unreachable(status);
+    }
+    const sandboxMessage = normalizeHostToSandboxMessage(
+      message,
+      sandboxBridgeProtocolVersion
+    );
+    emit("out", sandboxMessage);
+    iframe.contentWindow?.postMessage(sandboxMessage, sandboxOrigin);
+  }
+  function sendInitMessage(message) {
+    postToSandbox(parse(initMessageSchema, message));
+  }
+  function sendNack(message) {
+    postToSandbox(message);
+  }
+  function sendInitializedMessage(message) {
+    const status = initializationController.status;
+    switch (status) {
+      case "initialized":
+        postToSandbox(parse(hostToSandboxMessageSchema, message));
+        return;
+      // Send state updates and handler results only after initialization succeeds.
+      case "waitingForConnect":
+      case "preparingInit":
+      case "waitingForInitResult":
+      case "error":
+      case "stopped":
+        return;
+      default:
+        unreachable(status);
+    }
+  }
+  async function respondToRequest(message, handler) {
+    if (handler === void 0) {
+      return;
+    }
+    const response = await handler(message);
+    sendInitializedMessage({
+      type: `${message.type}Result`,
+      requestId: message.requestId,
+      ...response
+    });
+  }
+  function postQueryDataSourceResult(args) {
+    const message = args.response.status === "error" ? {
+      type: "queryDataSourceResult",
+      subscriptionId: args.subscriptionId,
+      status: "error",
+      error: args.response.error
+    } : {
+      type: "queryDataSourceResult",
+      subscriptionId: args.subscriptionId,
+      status: "success",
+      items: args.response.items,
+      hasMore: args.response.hasMore
+    };
+    sendInitializedMessage(message);
+  }
+  async function handleQuery(message, token = querySubscriptions.subscribe(message)) {
+    try {
+      const collectionSchema = getCollectionSchema(
+        activeDataSources,
+        message.dataSourceId
+      );
+      const queryError = getQueryValidationError(message, collectionSchema);
+      if (queryError !== void 0) {
+        if (querySubscriptions.isCurrent(message.subscriptionId, token)) {
+          querySubscriptions.unsubscribe(message.subscriptionId);
+          postQueryDataSourceResult({
+            subscriptionId: message.subscriptionId,
+            response: { status: "error", error: queryError }
+          });
+        }
+        return;
+      }
+      const response = await handlers.queryDataSource(message);
+      if (!querySubscriptions.isCurrent(message.subscriptionId, token)) {
+        return;
+      }
+      if (response.status === "error" && !response.error.isRetryable) {
+        querySubscriptions.unsubscribe(message.subscriptionId);
+      }
+      postQueryDataSourceResult({
+        subscriptionId: message.subscriptionId,
+        response
+      });
+    } finally {
+      const refresh = querySubscriptions.finish(message.subscriptionId, token);
+      if (refresh !== void 0) {
+        void handleQuery(refresh.message, refresh.token);
+      }
+    }
+  }
+  function updateHostState(update) {
+    if (initializationController.status === "stopped" || initializationController.status === "error") {
+      return;
+    }
+    Object.assign(pendingState, update);
+    flushPendingHostStateChanges();
+  }
+  function flushPendingHostStateChanges() {
+    if (initializationController.status !== "initialized") {
+      return;
+    }
+    const changes = pendingState;
+    pendingState = {};
+    if (changes.theme !== void 0) {
+      sendInitializedMessage({ type: "themeChanged", theme: changes.theme });
+    }
+    if (changes.contrastMode !== void 0) {
+      sendInitializedMessage({
+        type: "contrastModeChanged",
+        contrastMode: changes.contrastMode
+      });
+    }
+    if (changes.parent !== void 0) {
+      sendInitializedMessage({ type: "parentChanged", parent: changes.parent });
+    }
+    if (changes.page !== void 0) {
+      sendInitializedMessage({ type: "pageChanged", page: changes.page });
+    }
+    if (changes.dataSources !== void 0) {
+      sendInitializedMessage({
+        type: "dataSourcesChanged",
+        dataSources: changes.dataSources
+      });
+    }
+    if (changes.currentUser !== void 0) {
+      sendInitializedMessage({
+        type: "currentUserChanged",
+        currentUser: changes.currentUser
+      });
+    }
+  }
+  const initializationController = createInitializationController({
+    async prepareInit(connect) {
+      sandboxBridgeProtocolVersion = connect.bridgeProtocolVersion;
+      const result = await getInitialState(connect);
+      if (initializationController.status !== "preparingInit") {
+        return result;
+      }
+      return prepareInitialState(result);
+    },
+    sendInitMessage,
+    warn: (payload) => emit("warn", payload),
+    flushPendingHostStateChanges,
+    minBridgeProtocolVersion,
+    noConnectTimeoutMs,
+    initialStateTimeoutMs,
+    noInitResultTimeoutMs,
+    stopHostWithFailure: stopWithFailure,
+    onInitResult(message) {
+      if (message.status === "success" && manifest !== void 0) {
+        onInitialized?.({ manifest, initialHeight: message.initialHeight });
+      }
+    },
+    onConnectionFailure
+  });
+  function prepareInitialState(result) {
+    if (result.status === "error") {
+      return result;
+    }
+    manifest = parse(manifestSchema, result.initialState.manifest);
+    onManifest?.(manifest);
+    const initialStateInput = {
+      ...result.initialState,
+      ...pendingState
+    };
+    pendingState = {};
+    const initialState = {
+      ...parse(
+        omit(customBlockHostInitialStateSchema, ["manifest"]),
+        initialStateInput
+      ),
+      manifest
+    };
+    if (sandboxBridgeProtocolVersion < BRIDGE_PROTOCOL_VERSION_INTRODUCING_UNAVAILABLE_PAGE && initialState.page.type === "unavailable") {
+      return {
+        status: "error",
+        error: initErrorForFailureReason("context_unavailable")
+      };
+    }
+    const bindingErrorCode = getBindingErrorCode(
+      initialState.manifest,
+      initialState.dataSources
+    );
+    if (bindingErrorCode !== void 0) {
+      return {
+        status: "error",
+        error: initErrorForFailureReason(bindingErrorCode)
+      };
+    }
+    activeDataSources = initialState.dataSources;
+    hasPreparedInitialState = true;
+    return { status: "success", initialState };
+  }
+  const onMessage = createSandboxMessageRouter({
+    iframe,
+    sandboxOrigin,
+    getInitStatus: () => initializationController.status,
+    emit,
+    sendNack,
+    onInvalidConnect: initializationController.handleInvalidConnect,
+    onInvalidInitResult: initializationController.handleInvalidInitResult,
+    onConnect: initializationController.handleConnect,
+    onInitResult: initializationController.handleInitResult,
+    onQueryDataSource: handleQuery,
+    onUnsubscribeDataSourceQuery: (message) => querySubscriptions.unsubscribe(message.subscriptionId),
+    onCreatePage: (message) => respondToRequest(message, handlers.createPage),
+    onGetPage: (message) => respondToRequest(message, handlers.getPage),
+    onOpenPage: (message) => respondToRequest(message, handlers.openPage),
+    onGetUser: (message) => respondToRequest(message, handlers.getUser),
+    onListUsers: (message) => respondToRequest(message, handlers.listUsers),
+    onUpdatePage: (message) => respondToRequest(message, handlers.updatePage),
+    onResize: (message) => handlers.resize?.(message)
+  });
+  window.addEventListener("message", onMessage);
+  iframe.addEventListener("load", initializationController.onIframeLoad);
+  function stop() {
+    window.removeEventListener("message", onMessage);
+    iframe.removeEventListener("load", initializationController.onIframeLoad);
+    initializationController.stop();
+    querySubscriptions.unsubscribeAll();
+  }
+  function stopWithFailure(error) {
+    stop();
+    emit("warn", error);
+    onConnectionFailure?.(error);
+  }
+  return {
+    stop,
+    setTheme(theme) {
+      updateHostState({ theme });
+    },
+    setContrastMode(contrastMode) {
+      updateHostState({ contrastMode });
+    },
+    setParent(parent) {
+      updateHostState({ parent });
+    },
+    setPage(page) {
+      if (page.type === "unavailable" && sandboxBridgeProtocolVersion < BRIDGE_PROTOCOL_VERSION_INTRODUCING_UNAVAILABLE_PAGE && (initializationController.status === "preparingInit" && hasPreparedInitialState || initializationController.status === "waitingForInitResult" || initializationController.status === "initialized")) {
+        stopWithFailure(initErrorForFailureReason("context_unavailable"));
+        return;
+      }
+      updateHostState({ page });
+    },
+    setCurrentUser(currentUser) {
+      updateHostState({ currentUser });
+    },
+    setDataSources(dataSources) {
+      const normalizedDataSources = {
+        bindings: parse(
+          notionDataSourceBindingsSchema,
+          dataSources.bindings
+        )
+      };
+      if (initializationController.hasConnectedSandbox && manifest !== void 0 && getBindingErrorCode(manifest, normalizedDataSources) !== void 0) {
+        emit("warn", {
+          message: "Ignored invalid data source bindings update",
+          payload: normalizedDataSources
+        });
+        return;
+      }
+      activeDataSources = normalizedDataSources;
+      updateHostState({ dataSources: normalizedDataSources });
+    },
+    refreshQuery({ dataSourceId }) {
+      if (initializationController.status !== "initialized") {
+        return;
+      }
+      const normalizedDataSourceId = parse(
+        notionDataSourceIdSchema,
+        dataSourceId
+      );
+      const refreshes = querySubscriptions.refresh(normalizedDataSourceId);
+      if (refreshes === void 0) {
+        emit("warn", `No active query exists for data source "${dataSourceId}"`);
+        return;
+      }
+      for (const refresh of refreshes) {
+        void handleQuery(refresh.message, refresh.token);
+      }
+    }
+  };
+}
+function getCollectionSchema(dataSources, dataSourceId) {
+  return Object.values(dataSources?.bindings ?? {}).find(
+    (binding) => binding.collectionPointer?.id === dataSourceId
+  )?.collectionSchema;
+}
+function getBindingErrorCode(manifest, dataSources) {
+  for (const [dataSourceKey, manifestDataSource] of Object.entries(
+    manifest.dataSources
+  )) {
+    const binding = dataSources.bindings[dataSourceKey];
+    if (binding?.collectionPointer === void 0 || binding.collectionSchema === void 0) {
+      return "missing_data_source_binding";
+    }
+    for (const [propertyKey, manifestProperty] of Object.entries(
+      manifestDataSource.properties ?? {}
+    )) {
+      const propertyId = binding.propertyIdsByKey?.[propertyKey];
+      if (propertyId === void 0) {
+        return "missing_property_binding";
+      }
+      if (binding.collectionSchema.propertiesById[propertyId]?.type !== manifestProperty.type) {
+        return "invalid_property_binding";
+      }
+    }
+  }
+  return void 0;
+}
+function getQueryValidationError(message, collectionSchema) {
+  if (collectionSchema === void 0) {
+    if (message.filter === void 0 && (message.sorts?.length ?? 0) === 0) {
+      return void 0;
+    }
+    return {
+      code: "data_source_schema_unavailable",
+      message: "You cannot query this data source with filters or sorts because its schema is unavailable.",
+      isRetryable: false
+    };
+  }
+  return validateQueryDataSourceFilter(message.filter, collectionSchema) ?? validateQueryDataSourceSorts(message.sorts, collectionSchema);
+}
+export {
+  createCustomBlockHost,
+  getAutoBoundPropertyIdsByKey
+};