@openeditor/custom-block 0.0.46 → 0.0.47

package/dist/index.js

@@ -1,627 +1,492 @@
 import { validateDocument } from '@openeditor/core';
-import { defaultDocumentContract } from '@openeditor/extensions';
 
 // src/index.ts
 var OPENEDITOR_CUSTOM_BLOCK_NODE = "customBlock";
 var ID_PATTERN = /^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)+$/;
-var CUSTOM_BLOCK_DEFINITION_BRAND = /* @__PURE__ */ Symbol.for("@openeditor/custom-block/definition");
-var OPENEDITOR_CUSTOM_BLOCK_ASSET_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+var DEFINITION_BRAND = /* @__PURE__ */ Symbol.for("@openeditor/custom-block/definition");
+var LIMITS = {
+  depth: 32,
+  values: 1e4,
+  stringLength: 1e6,
+  arrayLength: 1e4,
+  objectKeys: 1e4
+};
 var plainObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
-var positiveInteger = (value) => typeof value === "number" && Number.isInteger(value) && value > 0;
+var positiveInteger = (value) => typeof value === "number" && Number.isSafeInteger(value) && value > 0;
 var clone = (value) => structuredClone(value);
 var deepFreeze = (value) => {
   if (value && typeof value === "object" && !Object.isFrozen(value)) {
     Object.freeze(value);
-    for (const child of Object.values(value)) deepFreeze(child);
+    for (const child of Object.values(value))
+      deepFreeze(child);
   }
   return value;
 };
-var VALIDATION_LIMITS = { depth: 32, values: 1e4, stringLength: 1e6, arrayLength: 1e4, objectKeys: 1e4 };
 var inspectJson = (value, path = "$.data", depth = 0, budget = { values: 0 }) => {
   budget.values += 1;
-  if (budget.values > VALIDATION_LIMITS.values) return [{ path, message: "Custom block data exceeds the value limit." }];
-  if (depth > VALIDATION_LIMITS.depth) return [{ path, message: "Custom block data exceeds the nesting limit." }];
-  if (typeof value === "string" && value.length > VALIDATION_LIMITS.stringLength) return [{ path, message: "String exceeds the size limit." }];
-  if (value === null || ["string", "boolean"].includes(typeof value) || typeof value === "number" && Number.isFinite(value)) return [];
+  if (budget.values > LIMITS.values)
+    return [{ path, message: "Custom block data exceeds the value limit." }];
+  if (depth > LIMITS.depth)
+    return [{ path, message: "Custom block data exceeds the nesting limit." }];
+  if (typeof value === "string" && value.length > LIMITS.stringLength)
+    return [{ path, message: "String exceeds the size limit." }];
+  if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value))
+    return [];
   if (Array.isArray(value)) {
-    if (value.length > VALIDATION_LIMITS.arrayLength) return [{ path, message: "Array exceeds the size limit." }];
-    return value.flatMap((item, index) => inspectJson(item, `${path}[${index}]`, depth + 1, budget));
+    if (value.length > LIMITS.arrayLength)
+      return [{ path, message: "Array exceeds the size limit." }];
+    return value.flatMap(
+      (item, index) => inspectJson(item, `${path}[${index}]`, depth + 1, budget)
+    );
   }
   if (plainObject(value)) {
     const entries = Object.entries(value);
-    if (entries.length > VALIDATION_LIMITS.objectKeys) return [{ path, message: "Object exceeds the key limit." }];
-    return entries.flatMap(([key, item]) => inspectJson(item, `${path}.${key}`, depth + 1, budget));
+    if (entries.length > LIMITS.objectKeys)
+      return [{ path, message: "Object exceeds the key limit." }];
+    return entries.flatMap(
+      ([key, item]) => inspectJson(item, `${path}.${key}`, depth + 1, budget)
+    );
   }
   return [{ path, message: "Custom block data must contain only JSON values." }];
 };
-var PORTABLE_SCHEMA_TYPES = /* @__PURE__ */ new Set(["any", "string", "number", "boolean", "null", "oneOf", "document", "array", "object"]);
-var PORTABLE_PATH_PATTERN = /^(?:[A-Za-z_][A-Za-z0-9_-]*|\*)(?:\.(?:[A-Za-z_][A-Za-z0-9_-]*|\*))*$/;
-var PORTABLE_FIELD_PATTERN = /^[A-Za-z_][A-Za-z0-9_-]*(?:\.[A-Za-z_][A-Za-z0-9_-]*)*$/;
-var requirePortablePath = (value, label, allowWildcards = true) => {
-  if (typeof value !== "string" || !(allowWildcards ? PORTABLE_PATH_PATTERN : PORTABLE_FIELD_PATTERN).test(value)) throw new Error(`Invalid portable constraint ${label}.`);
-};
-var assertPortableSchema = (schema, path = "$.dataSchema", depth = 0) => {
-  if (depth > VALIDATION_LIMITS.depth || !plainObject(schema) || typeof schema.type !== "string" || !PORTABLE_SCHEMA_TYPES.has(schema.type)) throw new Error(`Invalid portable schema at ${path}: type is not supported.`);
-  if (schema.nullable !== void 0 && typeof schema.nullable !== "boolean") throw new Error(`Invalid portable schema at ${path}: nullable must be a boolean.`);
-  if (schema.enum !== void 0 && (!Array.isArray(schema.enum) || inspectJson(schema.enum, `${path}.enum`).length)) throw new Error(`Invalid portable schema at ${path}: enum must contain JSON values.`);
-  const boundedInteger = (name) => {
-    const value = schema[name];
-    if (value !== void 0 && (!Number.isSafeInteger(value) || Number(value) < 0)) throw new Error(`Invalid portable schema at ${path}: ${name} must be a nonnegative integer.`);
-  };
-  if (schema.type === "string") {
-    boundedInteger("minLength");
-    boundedInteger("maxLength");
-    if (schema.minLength !== void 0 && schema.maxLength !== void 0 && Number(schema.minLength) > Number(schema.maxLength)) throw new Error(`Invalid portable schema at ${path}: string bounds are inconsistent.`);
-    if (schema.format !== void 0 && schema.format !== "asset-id") throw new Error(`Invalid portable schema at ${path}: format is not supported.`);
-  } else if (schema.type === "number") {
-    if (schema.integer !== void 0 && typeof schema.integer !== "boolean") throw new Error(`Invalid portable schema at ${path}: integer must be a boolean.`);
-    for (const name of ["minimum", "maximum"]) if (schema[name] !== void 0 && (typeof schema[name] !== "number" || !Number.isFinite(schema[name]))) throw new Error(`Invalid portable schema at ${path}: ${name} must be finite.`);
-    if (schema.minimum !== void 0 && schema.maximum !== void 0 && Number(schema.minimum) > Number(schema.maximum)) throw new Error(`Invalid portable schema at ${path}: number bounds are inconsistent.`);
-  } else if (schema.type === "array") {
-    boundedInteger("minItems");
-    boundedInteger("maxItems");
-    if (schema.minItems !== void 0 && schema.maxItems !== void 0 && Number(schema.minItems) > Number(schema.maxItems)) throw new Error(`Invalid portable schema at ${path}: array bounds are inconsistent.`);
-    if (schema.items !== void 0) assertPortableSchema(schema.items, `${path}.items`, depth + 1);
-  } else if (schema.type === "object") {
-    if (schema.properties !== void 0 && !plainObject(schema.properties)) throw new Error(`Invalid portable schema at ${path}: properties must be an object.`);
-    const properties = plainObject(schema.properties) ? schema.properties : {};
-    for (const [key, child] of Object.entries(properties)) assertPortableSchema(child, `${path}.properties.${key}`, depth + 1);
-    if (schema.required !== void 0 && (!Array.isArray(schema.required) || schema.required.some((key) => typeof key !== "string") || new Set(schema.required).size !== schema.required.length)) throw new Error(`Invalid portable schema at ${path}: required must contain unique strings.`);
-    if (Array.isArray(schema.required) && schema.required.some((key) => !(key in properties))) throw new Error(`Invalid portable schema at ${path}: required fields must have schemas.`);
-    if (schema.additionalProperties !== void 0 && typeof schema.additionalProperties !== "boolean") assertPortableSchema(schema.additionalProperties, `${path}.additionalProperties`, depth + 1);
-  } else if (schema.type === "oneOf") {
-    if (!Array.isArray(schema.variants) || schema.variants.length < 1) throw new Error(`Invalid portable schema at ${path}: variants must be a nonempty array.`);
-    schema.variants.forEach((variant, index) => assertPortableSchema(variant, `${path}.variants[${index}]`, depth + 1));
-  }
-};
-var assertPortableConstraints = (constraints) => {
-  if (constraints === void 0) return;
-  if (!Array.isArray(constraints)) throw new Error("Invalid portable constraints: expected an array.");
-  for (const constraint of constraints) {
-    if (!plainObject(constraint) || typeof constraint.kind !== "string") throw new Error("Invalid portable constraint shape.");
-    if (constraint.kind === "unique") requirePortablePath(constraint.array, "array path");
-    else if (constraint.kind === "uniqueBy") {
-      requirePortablePath(constraint.array, "array path");
-      if (!Array.isArray(constraint.keys) || !constraint.keys.length || constraint.keys.some((key) => {
-        try {
-          requirePortablePath(key, "key", false);
-          return false;
-        } catch {
-          return true;
-        }
-      })) throw new Error("Invalid portable constraint keys.");
-    } else if (constraint.kind === "keysIn") {
-      if (constraint.scope !== void 0) requirePortablePath(constraint.scope, "scope path");
-      requirePortablePath(constraint.objects, "objects path");
-      requirePortablePath(constraint.keys, "keys path");
-      if (constraint.requireAll !== void 0 && typeof constraint.requireAll !== "boolean") throw new Error("Invalid portable constraint requireAll flag.");
-    } else if (constraint.kind === "reference") {
-      requirePortablePath(constraint.array, "array path");
-      requirePortablePath(constraint.field, "field", false);
-      requirePortablePath(constraint.targetArray, "target array path");
-      requirePortablePath(constraint.targetField, "target field", false);
-      if (constraint.nullable !== void 0 && typeof constraint.nullable !== "boolean") throw new Error("Invalid portable constraint nullable flag.");
-    } else if (constraint.kind === "acyclic" || constraint.kind === "graph") {
-      requirePortablePath(constraint.array, "array path");
-      requirePortablePath(constraint.id, "id", false);
-      requirePortablePath(constraint.parent, "parent", false);
-      if (constraint.siblingKeys !== void 0 && (!Array.isArray(constraint.siblingKeys) || constraint.siblingKeys.some((key) => {
-        try {
-          requirePortablePath(key, "sibling key", false);
-          return false;
-        } catch {
-          return true;
-        }
-      }))) throw new Error("Invalid portable constraint sibling keys.");
-    } else if (constraint.kind === "url") {
-      requirePortablePath(constraint.path, "URL path");
-      for (const flag of ["allowRelative", "requireSchemeSeparator"]) if (constraint[flag] !== void 0 && typeof constraint[flag] !== "boolean") throw new Error(`Invalid portable constraint ${flag}.`);
-      for (const name of ["schemes", "denySchemes"]) if (constraint[name] !== void 0 && (!Array.isArray(constraint[name]) || constraint[name].some((scheme) => typeof scheme !== "string" || !/^[a-z][a-z\d+.-]*$/.test(scheme)))) throw new Error(`Invalid portable constraint ${name} scheme.`);
-      if (constraint.when !== void 0 && (!plainObject(constraint.when) || (() => {
-        try {
-          requirePortablePath(constraint.when.field, "condition field", false);
-          return false;
-        } catch {
-          return true;
-        }
-      })() || inspectJson(constraint.when.equals, "$.when.equals").length)) throw new Error("Invalid portable constraint condition.");
-    } else throw new Error(`Invalid portable constraint kind "${constraint.kind}".`);
-  }
-};
-var recursivelyFrozen = (value, seen = /* @__PURE__ */ new Set()) => {
-  if (!value || typeof value !== "object") return true;
-  if (seen.has(value)) return true;
-  seen.add(value);
-  return Object.isFrozen(value) && Object.values(value).every((child) => recursivelyFrozen(child, seen));
-};
-var validateValue = (value, schema, path, depth = 0, budget = { values: 0 }) => {
-  budget.values += 1;
-  if (budget.values > VALIDATION_LIMITS.values) return [{ path, message: "Custom block data exceeds the value limit." }];
-  if (depth > VALIDATION_LIMITS.depth) return [{ path, message: "Custom block data exceeds the nesting limit." }];
-  if (value === null && schema.nullable) return [];
-  if (schema.enum && !schema.enum.some((item) => JSON.stringify(item) === JSON.stringify(value))) return [{ path, message: "Value is not in the allowed set." }];
-  const errors = [];
-  if (schema.type === "any") return errors;
-  if (schema.type === "oneOf") {
-    const results = schema.variants.map((variant) => validateValue(value, variant, path, depth + 1, { values: budget.values }));
-    const matches = results.filter((result) => result.length === 0).length;
-    return matches === 1 ? [] : [{ path, message: matches === 0 ? "Value does not match an allowed variant." : "Value matches more than one variant." }];
-  }
-  if (schema.type === "null") return value === null ? errors : [{ path, message: "Expected null." }];
-  if (schema.type === "document") {
-    if (!plainObject(value) || value.type !== "doc" || value.version !== 1 || !Array.isArray(value.content)) return [{ path, message: "Expected an OpenEditor document." }];
-    const result = validateDocument(value, { contract: defaultDocumentContract, limits: { requireNodeIds: true } });
-    return result.valid ? [] : result.issues.map((issue) => ({ path: `${path}${issue.path.slice(1)}`, message: issue.message }));
-  }
-  if (schema.type === "string") {
-    if (typeof value !== "string") return [{ path, message: "Expected a string." }];
-    if (value.length > VALIDATION_LIMITS.stringLength) return [{ path, message: "String exceeds the size limit." }];
-    if (schema.minLength !== void 0 && value.length < schema.minLength) errors.push({ path, message: `Expected at least ${schema.minLength} characters.` });
-    if (schema.maxLength !== void 0 && value.length > schema.maxLength) errors.push({ path, message: `Expected at most ${schema.maxLength} characters.` });
-    if (schema.format === "asset-id" && !OPENEDITOR_CUSTOM_BLOCK_ASSET_ID_PATTERN.test(value)) errors.push({ path, message: "Expected an opaque host asset ID." });
-  } else if (schema.type === "number") {
-    if (typeof value !== "number" || !Number.isFinite(value)) return [{ path, message: "Expected a finite number." }];
-    if (schema.integer && !Number.isInteger(value)) errors.push({ path, message: "Expected an integer." });
-    if (schema.minimum !== void 0 && value < schema.minimum) errors.push({ path, message: `Expected ${schema.minimum} or more.` });
-    if (schema.maximum !== void 0 && value > schema.maximum) errors.push({ path, message: `Expected ${schema.maximum} or less.` });
-  } else if (schema.type === "boolean") {
-    if (typeof value !== "boolean") errors.push({ path, message: "Expected a boolean." });
-  } else if (schema.type === "array") {
-    if (!Array.isArray(value)) return [{ path, message: "Expected an array." }];
-    if (value.length > VALIDATION_LIMITS.arrayLength) return [{ path, message: "Array exceeds the size limit." }];
-    if (schema.minItems !== void 0 && value.length < schema.minItems) errors.push({ path, message: `Expected at least ${schema.minItems} items.` });
-    if (schema.maxItems !== void 0 && value.length > schema.maxItems) errors.push({ path, message: `Expected at most ${schema.maxItems} items.` });
-    if (schema.items) value.forEach((item, index) => errors.push(...validateValue(item, schema.items, `${path}[${index}]`, depth + 1, budget)));
-  } else if (schema.type === "object") {
-    if (!plainObject(value)) return [{ path, message: "Expected an object." }];
-    if (Object.keys(value).length > VALIDATION_LIMITS.objectKeys) return [{ path, message: "Object exceeds the key limit." }];
-    for (const key of schema.required ?? []) if (!(key in value)) errors.push({ path: `${path}.${key}`, message: "Required value is missing." });
-    for (const [key, item] of Object.entries(value)) {
-      const property = schema.properties?.[key];
-      if (property) errors.push(...validateValue(item, property, `${path}.${key}`, depth + 1, budget));
-      else if (schema.additionalProperties === false) errors.push({ path: `${path}.${key}`, message: "Additional values are not allowed." });
-      else if (plainObject(schema.additionalProperties)) errors.push(...validateValue(item, schema.additionalProperties, `${path}.${key}`, depth + 1, budget));
-    }
-  }
-  return errors;
-};
-var validateOpenEditorCustomBlockDataValue = (value, schema) => {
-  const diagnostics = [...inspectJson(value, "$"), ...validateValue(value, schema, "$")].sort((a, b) => a.path.localeCompare(b.path));
-  return diagnostics.length ? { valid: false, diagnostics } : { valid: true, diagnostics: [] };
-};
-var valuesAt = (root, expression) => expression.split(".").filter(Boolean).reduce((current, segment) => current.flatMap((item) => {
-  if (segment === "*") return Array.isArray(item.value) ? item.value.map((value, index) => ({ value, path: `${item.path}[${index}]` })) : [];
-  return plainObject(item.value) && segment in item.value ? [{ value: item.value[segment], path: `${item.path}.${segment}` }] : [];
-}), [{ value: root, path: "$.data" }]);
-var fieldAt = (value, field) => field.split(".").reduce((current, key) => plainObject(current) ? current[key] : void 0, value);
-var hasUnsafeUrlSyntax = (value) => {
-  if (/[\u0000-\u001f\u007f]/.test(value)) return true;
-  const colon = value.indexOf(":");
-  const path = value.indexOf("/");
-  const query = value.indexOf("?");
-  const firstPathOrQuery = Math.min(...[path, query].filter((index) => index >= 0), Number.POSITIVE_INFINITY);
-  return colon >= 0 && colon < firstPathOrQuery && value.slice(0, colon).includes("&");
-};
-var validateConstraints = (data, constraints = []) => {
-  const diagnostics = [];
-  for (const constraint of constraints) {
-    if (constraint.kind === "unique") for (const located of valuesAt(data, constraint.array)) {
-      if (!Array.isArray(located.value)) continue;
-      const seen = /* @__PURE__ */ new Set();
-      located.value.forEach((item, index) => {
-        const key = JSON.stringify(item);
-        if (seen.has(key)) diagnostics.push({ path: `${located.path}[${index}]`, message: "Array values must be unique." });
-        else seen.add(key);
-      });
-    }
-    else if (constraint.kind === "uniqueBy") for (const located of valuesAt(data, constraint.array)) {
-      if (!Array.isArray(located.value)) continue;
-      const seen = /* @__PURE__ */ new Map();
-      located.value.forEach((item, index) => {
-        const key = JSON.stringify(constraint.keys.map((field) => fieldAt(item, field)));
-        if (seen.has(key)) diagnostics.push({ path: `${located.path}[${index}]`, message: `Values must be unique by ${constraint.keys.join(", ")}.` });
-        else seen.set(key, index);
-      });
-    }
-    else if (constraint.kind === "keysIn") {
-      const scopes = constraint.scope ? valuesAt(data, constraint.scope) : [{ value: data, path: "$.data" }];
-      for (const scope of scopes) {
-        const objects = valuesAt(scope.value, constraint.objects);
-        const keySet = valuesAt(scope.value, constraint.keys)[0]?.value;
-        const allowed = new Set(Array.isArray(keySet) ? keySet : []);
-        for (const located of objects) {
-          if (!plainObject(located.value)) continue;
-          const objectPath = `${scope.path}${located.path.slice("$.data".length)}`;
-          for (const key of Object.keys(located.value)) if (!allowed.has(key)) diagnostics.push({ path: `${objectPath}.${key}`, message: "Object key is not in the allowed key collection." });
-          if (constraint.requireAll) {
-            for (const key of allowed) if (typeof key === "string" && !(key in located.value)) diagnostics.push({ path: `${objectPath}.${key}`, message: "Required object key is missing." });
-          }
-        }
-      }
-    } else if (constraint.kind === "reference") {
-      const targets = new Set(valuesAt(data, constraint.targetArray).flatMap((item) => Array.isArray(item.value) ? item.value.map((target) => fieldAt(target, constraint.targetField)) : []));
-      for (const located of valuesAt(data, constraint.array)) if (Array.isArray(located.value)) located.value.forEach((item, index) => {
-        const reference = fieldAt(item, constraint.field);
-        if ((reference === null || reference === void 0) && constraint.nullable) return;
-        if (!targets.has(reference)) diagnostics.push({ path: `${located.path}[${index}].${constraint.field}`, message: "Reference does not identify an available value." });
-      });
-    } else if (constraint.kind === "acyclic" || constraint.kind === "graph") for (const located of valuesAt(data, constraint.array)) {
-      if (!Array.isArray(located.value)) continue;
-      const parents = new Map(located.value.map((item) => [fieldAt(item, constraint.id), fieldAt(item, constraint.parent)]));
-      if (constraint.kind === "graph") {
-        const ids = /* @__PURE__ */ new Set();
-        const siblings = /* @__PURE__ */ new Set();
-        located.value.forEach((item, index) => {
-          const id = fieldAt(item, constraint.id);
-          if (ids.has(id)) diagnostics.push({ path: `${located.path}[${index}].${constraint.id}`, message: "Node identifiers must be unique in the collection." });
-          else ids.add(id);
-        });
-        located.value.forEach((item, index) => {
-          const parent = fieldAt(item, constraint.parent);
-          if (parent !== null && parent !== void 0 && !ids.has(parent)) diagnostics.push({ path: `${located.path}[${index}].${constraint.parent}`, message: "Parent must identify a value in the same collection." });
-          const sibling = JSON.stringify([parent, ...(constraint.siblingKeys ?? []).map((field) => fieldAt(item, field))]);
-          if (siblings.has(sibling)) diagnostics.push({ path: `${located.path}[${index}]`, message: "Sibling ordering values must be unique." });
-          else siblings.add(sibling);
-        });
-      }
-      for (const [id] of parents) {
-        const seen = /* @__PURE__ */ new Set();
-        let current = id;
-        while (current !== null && current !== void 0) {
-          if (seen.has(current)) {
-            diagnostics.push({ path: located.path, message: "Parent references must be acyclic." });
-            break;
-          }
-          seen.add(current);
-          current = parents.get(current);
-        }
-      }
-    }
-    else if (constraint.kind === "url") for (const located of valuesAt(data, constraint.path)) {
-      if (located.value === null || located.value === void 0) continue;
-      if (typeof located.value !== "string") {
-        diagnostics.push({ path: located.path, message: "URL must be a string." });
-        continue;
-      }
-      if (constraint.when) {
-        const parentPath = located.path.replace(/\.[^.\[]+$/, "");
-        const parentExpression = parentPath.replace(/^\$\.data\.?/, "").replace(/\[\d+\]/g, ".*");
-        const parent = valuesAt(data, parentExpression).find((item) => item.path === parentPath)?.value;
-        if (!plainObject(parent) || JSON.stringify(fieldAt(parent, constraint.when.field)) !== JSON.stringify(constraint.when.equals)) continue;
-      }
-      const normalized = located.value.trim();
-      const scheme = /^([a-z][a-z\d+.-]*):/i.exec(normalized)?.[1]?.toLowerCase();
-      const unsafeRelative = !scheme && (!normalized.startsWith("/") || normalized.startsWith("//") || normalized.includes("\\"));
-      if (!scheme && (!constraint.allowRelative || unsafeRelative) || scheme && (constraint.requireSchemeSeparator && !normalized.toLowerCase().startsWith(`${scheme}://`) || constraint.schemes && !constraint.schemes.includes(scheme) || constraint.denySchemes?.includes(scheme)) || hasUnsafeUrlSyntax(normalized)) diagnostics.push({ path: located.path, message: "URL is not allowed." });
-    }
-  }
-  return diagnostics;
+var envelopeFrom = (value) => {
+  if (!plainObject(value)) return null;
+  const blockId = value.blockId;
+  const version = value.version;
+  const data = value.data;
+  return typeof blockId === "string" && ID_PATTERN.test(blockId) && positiveInteger(version) && plainObject(data) ? {
+    blockId,
+    version,
+    data
+  } : null;
 };
 var defineOpenEditorCustomBlock = (input) => {
-  if (!ID_PATTERN.test(input.id)) throw new Error(`OpenEditor custom block IDs must be namespaced lowercase identifiers. Received "${input.id}".`);
-  if (!Number.isSafeInteger(input.version) || input.version < 1) throw new Error("OpenEditor custom block versions must be positive integers.");
-  if (typeof input.label !== "string" || !input.label.trim() || input.label.length > 200) throw new Error("OpenEditor custom block labels must be nonempty strings of 200 characters or less.");
-  assertPortableSchema(input.dataSchema);
-  assertPortableConstraints(input.constraints);
-  if (input.dataSchema.type !== "object") throw new Error('OpenEditor custom block data schemas must have type "object".');
-  const dataSchema = deepFreeze(clone(input.dataSchema));
-  const constraints = input.constraints ? deepFreeze(clone(input.constraints)) : void 0;
-  const migrations = input.migrations ? Object.freeze({ ...input.migrations }) : void 0;
-  const manifest = deepFreeze({ id: input.id, label: input.label, version: input.version, dataSchema, ...constraints ? { constraints } : {} });
-  const definition = { ...input, dataSchema, ...constraints ? { constraints } : {}, ...migrations ? { migrations } : {}, manifest };
-  Object.defineProperty(definition, CUSTOM_BLOCK_DEFINITION_BRAND, { value: true });
+  if (!ID_PATTERN.test(input.id))
+    throw new Error(
+      `OpenEditor custom block IDs must be namespaced lowercase identifiers. Received "${input.id}".`
+    );
+  if (!positiveInteger(input.version))
+    throw new Error(
+      "OpenEditor custom block versions must be positive integers."
+    );
+  if (!input.label.trim() || input.label.length > 200)
+    throw new Error(
+      "OpenEditor custom block labels must be nonempty strings of 200 characters or less."
+    );
+  const manifest = deepFreeze({
+    id: input.id,
+    label: input.label,
+    version: input.version
+  });
+  const definition = { ...input, manifest };
+  Object.defineProperty(definition, DEFINITION_BRAND, { value: true });
   return Object.freeze(definition);
 };
-var envelopeFromNode = (node) => {
-  const attrs = node.attrs;
-  return attrs && typeof attrs.blockId === "string" && typeof attrs.version === "number" && plainObject(attrs.data) ? { blockId: attrs.blockId, version: attrs.version, data: attrs.data } : null;
-};
-var escapeOpenEditorCustomBlockHtml = (value) => String(value).replace(/[&<>"']/g, (character) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[character]);
-var SAFE_TAGS = /* @__PURE__ */ new Set(["div", "span", "p", "h1", "h2", "h3", "h4", "h5", "h6", "article", "section", "aside", "blockquote", "figure", "figcaption", "ul", "ol", "li", "dl", "dt", "dd", "table", "caption", "thead", "tbody", "tr", "th", "td", "strong", "em", "u", "s", "code", "pre", "a", "img", "br", "hr"]);
-var SAFE_ATTRS = /* @__PURE__ */ new Set(["aria-label", "aria-current", "role", "title", "href", "src", "alt", "width", "height", "start", "colspan", "rowspan", "scope"]);
-var safeStaticUrl = (value, context) => {
-  const normalized = value.trim();
-  if (!normalized || hasUnsafeUrlSyntax(normalized)) return null;
-  const scheme = /^([a-z][a-z\d+.-]*):/i.exec(normalized)?.[1]?.toLowerCase();
-  if (!scheme) {
-    if (normalized.startsWith("//") || normalized.includes("\\")) return null;
-    return normalized;
+var parseDefinitionData = (definition, data) => {
+  const diagnostics = inspectJson(data);
+  if (diagnostics.length) return { valid: false, diagnostics };
+  try {
+    const parsed = definition.parseData(deepFreeze(clone(data)));
+    const parsedDiagnostics = inspectJson(parsed);
+    if (!plainObject(parsed) || parsedDiagnostics.length)
+      return {
+        valid: false,
+        diagnostics: parsedDiagnostics.length ? parsedDiagnostics : [{ path: "$.data", message: "The block parser must return an object." }]
+      };
+    return { valid: true, data: deepFreeze(clone(parsed)) };
+  } catch (error) {
+    return {
+      valid: false,
+      diagnostics: [
+        {
+          path: "$.data",
+          message: error instanceof Error ? error.message : "Custom block data is invalid."
+        }
+      ]
+    };
   }
-  const schemes = context === "asset" ? ["http", "https"] : ["http", "https", "mailto", "tel"];
-  return schemes.includes(scheme) ? normalized : null;
-};
-var renderOpenEditorCustomBlockSafeHtml = (value) => {
-  const seen = /* @__PURE__ */ new WeakSet();
-  let nodes = 0;
-  let stringBytes = 0;
-  const countRendered = (rendered) => {
-    stringBytes += rendered.length;
-    if (stringBytes > VALIDATION_LIMITS.stringLength) throw new Error("Safe HTML output exceeds its text limit.");
-    return rendered;
-  };
-  const render = (item, depth) => {
-    nodes += 1;
-    if (nodes > VALIDATION_LIMITS.values || depth > VALIDATION_LIMITS.depth) throw new Error("Safe HTML output exceeds its structural limit.");
-    if (item && typeof item === "object") {
-      if (seen.has(item)) throw new Error("Safe HTML output must not contain cycles.");
-      seen.add(item);
-    }
-    const value2 = item;
-    if (value2 === null || value2 === false) return "";
-    if (typeof value2 === "string" || typeof value2 === "number") return countRendered(escapeOpenEditorCustomBlockHtml(value2));
-    if (!plainObject(value2) || typeof value2.tag !== "string" || !SAFE_TAGS.has(value2.tag)) return "";
-    const attrs = Object.entries(value2.attrs ?? {}).flatMap(([name, raw]) => {
-      if (raw === void 0 || !SAFE_ATTRS.has(name) || name === "href" && value2.tag !== "a" || name === "src" && value2.tag !== "img" || name === "start" && value2.tag !== "ol" || ["colspan", "rowspan", "scope"].includes(name) && !["td", "th"].includes(value2.tag)) return [];
-      const safe = name === "href" ? safeStaticUrl(String(raw), "navigation") : name === "src" ? safeStaticUrl(String(raw), "asset") : String(raw);
-      return safe === null ? [] : [countRendered(` ${name}="${escapeOpenEditorCustomBlockHtml(safe)}"`)];
-    }).join("");
-    const children = (value2.children ?? []).map((child) => render(child, depth + 1)).join("");
-    return ["img", "br", "hr"].includes(value2.tag) ? `<${value2.tag}${attrs}>` : `<${value2.tag}${attrs}>${children}</${value2.tag}>`;
-  };
-  return render(value, 0);
 };
 var createOpenEditorCustomBlockRegistry = (definitions, options = {}) => {
   const byId = /* @__PURE__ */ new Map();
   for (const definition of definitions) {
-    try {
-      assertPortableSchema(definition.dataSchema);
-      assertPortableConstraints(definition.constraints);
-    } catch {
+    if (definition[DEFINITION_BRAND] !== true || !Object.isFrozen(definition) || !ID_PATTERN.test(definition.id) || !positiveInteger(definition.version))
       throw new Error(`Invalid custom block definition "${definition.id ?? "unknown"}".`);
-    }
-    if (definition[CUSTOM_BLOCK_DEFINITION_BRAND] !== true || !recursivelyFrozen(definition.dataSchema) || !recursivelyFrozen(definition.constraints) || !recursivelyFrozen(definition.manifest) || !recursivelyFrozen(definition.migrations) || !Object.isFrozen(definition) || !ID_PATTERN.test(definition.id) || !Number.isSafeInteger(definition.version) || definition.version < 1 || definition.dataSchema?.type !== "object" || definition.manifest?.id !== definition.id || definition.manifest?.version !== definition.version || definition.manifest?.dataSchema !== definition.dataSchema || definition.manifest?.constraints !== definition.constraints) throw new Error(`Invalid custom block definition "${definition.id ?? "unknown"}".`);
-    if (byId.has(definition.id)) throw new Error(`Duplicate custom block ID "${definition.id}".`);
+    if (byId.has(definition.id))
+      throw new Error(`Duplicate custom block ID "${definition.id}".`);
     byId.set(definition.id, definition);
   }
   const disabled = new Set(options.disabled ?? []);
-  const resolve = (node) => {
-    const envelope = envelopeFromNode(node);
-    if (node.type !== OPENEDITOR_CUSTOM_BLOCK_NODE || !envelope) return { status: "invalid", node, diagnostics: [{ path: "$", message: "Expected a valid OpenEditor custom block envelope." }] };
-    if (typeof node.attrs?.["openeditor-id"] !== "string" || !node.attrs["openeditor-id"].trim()) return { status: "invalid", node, blockId: envelope.blockId, diagnostics: [{ path: "$.attrs.openeditor-id", message: "Custom block instance ID is required." }] };
-    const definition = byId.get(envelope.blockId);
-    if (!definition) return { status: "missing", node, blockId: envelope.blockId, diagnostics: [] };
-    if (disabled.has(envelope.blockId)) return { status: "disabled", node, blockId: envelope.blockId, diagnostics: [] };
-    if (envelope.version > definition.version) return { status: "incompatible", node, blockId: envelope.blockId, diagnostics: [{ path: "$.version", message: `Stored version ${envelope.version} is newer than supported version ${definition.version}.` }] };
-    let version = envelope.version;
-    let data = clone(envelope.data);
-    try {
-      while (version < definition.version) {
-        const migrate = definition.migrations?.[version];
-        if (!migrate) return { status: "incompatible", node, blockId: envelope.blockId, diagnostics: [{ path: "$.version", message: `No migration exists from version ${version}.` }] };
-        data = clone(migrate(Object.freeze(clone(data))));
-        version += 1;
+  const resolveEnvelope = (raw) => {
+    const initial = envelopeFrom(raw);
+    if (!initial)
+      return {
+        status: "invalid",
+        diagnostics: [
+          {
+            path: "$",
+            message: "Expected a valid OpenEditor custom block envelope."
+          }
+        ]
+      };
+    const definition = byId.get(initial.blockId);
+    if (!definition)
+      return { status: "missing", blockId: initial.blockId, diagnostics: [] };
+    if (disabled.has(initial.blockId))
+      return { status: "disabled", blockId: initial.blockId, diagnostics: [] };
+    if (initial.version > definition.version)
+      return {
+        status: "incompatible",
+        blockId: initial.blockId,
+        diagnostics: [
+          {
+            path: "$.version",
+            message: `Stored version ${initial.version} is newer than supported version ${definition.version}.`
+          }
+        ]
+      };
+    let envelope = clone(initial);
+    let attempts = 0;
+    while (envelope.version < definition.version) {
+      if (!definition.migrate)
+        return {
+          status: "incompatible",
+          blockId: initial.blockId,
+          diagnostics: [
+            {
+              path: "$.version",
+              message: `No migration exists from version ${envelope.version}.`
+            }
+          ]
+        };
+      try {
+        const next = definition.migrate({
+          version: envelope.version,
+          data: deepFreeze(clone(envelope.data))
+        });
+        const checked = envelopeFrom(next);
+        if (!checked || checked.blockId !== definition.id || checked.version <= envelope.version || checked.version > definition.version)
+          throw new Error("The custom block migration returned an invalid envelope.");
+        envelope = checked;
+      } catch (error) {
+        return {
+          status: "invalid",
+          blockId: initial.blockId,
+          diagnostics: [
+            {
+              path: "$.data",
+              message: error instanceof Error ? error.message : "Migration failed."
+            }
+          ]
+        };
       }
-    } catch (error) {
-      return { status: "invalid", node, blockId: envelope.blockId, diagnostics: [{ path: "$.data", message: error instanceof Error ? error.message : "Migration failed." }] };
+      attempts += 1;
+      if (attempts > 100)
+        return {
+          status: "invalid",
+          blockId: initial.blockId,
+          diagnostics: [
+            { path: "$.version", message: "Migration exceeded the step limit." }
+          ]
+        };
     }
-    const diagnostics = [...inspectJson(data), ...validateValue(data, definition.dataSchema, "$.data"), ...validateConstraints(data, definition.constraints)].sort((a, b) => a.path.localeCompare(b.path));
-    try {
-      const refinement = definition.validateData?.(deepFreeze(clone(data)));
-      if (typeof refinement === "string") diagnostics.push({ path: "$.data", message: refinement });
-      else for (const message of refinement ?? []) diagnostics.push({ path: "$.data", message });
-    } catch (error) {
-      diagnostics.push({ path: "$.data", message: error instanceof Error ? error.message : "Custom validation failed." });
-    }
-    if (diagnostics.length) return { status: "invalid", node, blockId: envelope.blockId, diagnostics };
-    const migrated = version !== envelope.version;
-    const readyData = deepFreeze(clone(data));
-    return { status: "ready", definition, data: readyData, migrated, node: migrated ? { ...node, attrs: { ...node.attrs, blockId: definition.id, version, data: readyData } } : node };
+    const parsed = parseDefinitionData(definition, envelope.data);
+    return parsed.valid ? {
+      status: "ready",
+      definition,
+      envelope: { ...envelope, data: parsed.data },
+      migrated: envelope.version !== initial.version
+    } : {
+      status: "invalid",
+      blockId: initial.blockId,
+      diagnostics: parsed.diagnostics
+    };
   };
-  const defaultDocumentSafeTree = (document) => {
-    let count = 0;
-    const renderNode = (node, depth = 0) => {
-      count += 1;
-      if (count > VALIDATION_LIMITS.values || depth > VALIDATION_LIMITS.depth) return "";
-      if (node.type === "text") {
-        let output = node.text ?? "";
-        for (const mark of [...node.marks ?? []].reverse()) {
-          if (mark.type === "bold") output = { tag: "strong", children: [output] };
-          else if (mark.type === "italic") output = { tag: "em", children: [output] };
-          else if (mark.type === "underline") output = { tag: "u", children: [output] };
-          else if (mark.type === "strike") output = { tag: "s", children: [output] };
-          else if (mark.type === "code") output = { tag: "code", children: [output] };
-          else if (mark.type === "link" && typeof mark.attrs?.href === "string") output = { tag: "a", attrs: { href: mark.attrs.href }, children: [output] };
+  const resolve = (node) => {
+    const resolved = resolveEnvelope(node.attrs);
+    if (node.type !== OPENEDITOR_CUSTOM_BLOCK_NODE)
+      return {
+        status: "invalid",
+        node,
+        diagnostics: [
+          { path: "$.type", message: "Expected a customBlock node." }
+        ]
+      };
+    if (resolved.status !== "ready") return { ...resolved, node };
+    if (typeof node.attrs?.["openeditor-id"] !== "string" || !node.attrs["openeditor-id"].trim())
+      return {
+        status: "invalid",
+        node,
+        blockId: resolved.definition.id,
+        diagnostics: [
+          {
+            path: "$.attrs.openeditor-id",
+            message: "Custom block instance ID is required."
+          }
+        ]
+      };
+    const migratedNode = {
+      ...node,
+      attrs: { ...node.attrs, ...resolved.envelope }
+    };
+    return {
+      status: "ready",
+      definition: resolved.definition,
+      data: resolved.envelope.data,
+      migrated: resolved.migrated,
+      node: migratedNode
+    };
+  };
+  const renderNestedHtml = (document) => {
+    const valid = validateDocument(document);
+    if (!valid.valid) return "";
+    return {
+      tag: "div",
+      children: document.content.map((node) => {
+        if (node.type === "text") return node.text ?? "";
+        if (node.type === OPENEDITOR_CUSTOM_BLOCK_NODE) {
+          const nested = resolve(node);
+          return nested.status === "ready" ? nested.definition.toHtml({
+            data: nested.data,
+            renderDocument: options.renderDocument ?? renderNestedHtml,
+            documentToText: options.documentToText ?? renderNestedText
+          }) : `[${String(node.attrs?.blockId ?? "custom block")}: ${nested.status}]`;
         }
-        return output;
-      }
-      if (node.type === OPENEDITOR_CUSTOM_BLOCK_NODE) {
-        const nested = resolve(node);
-        return nested.status === "ready" ? exportNestedSafeTree(nested) : `[${envelopeFromNode(node)?.blockId ?? "custom block"}: ${nested.status}]`;
-      }
-      const children = node.content?.map((child) => renderNode(child, depth + 1)) ?? [];
-      if (node.type === "image") return { tag: "figure", children: [{ tag: "img", attrs: { alt: typeof node.attrs?.alt === "string" ? node.attrs.alt : "Image" } }] };
-      if (node.type === "page") return { tag: "span", children: children.length ? children : [typeof node.attrs?.title === "string" ? node.attrs.title : "Untitled page"] };
-      if (node.type === "attachment") return { tag: "span", children: [typeof node.attrs?.name === "string" && node.attrs.name ? node.attrs.name : "Attachment"] };
-      const heading = node.type === "heading" ? `h${Math.min(6, Math.max(1, Number(node.attrs?.level) || 2))}` : null;
-      const tag = heading ?? (node.type === "paragraph" ? "p" : node.type === "bulletList" || node.type === "taskList" ? "ul" : node.type === "orderedList" ? "ol" : ["listItem", "taskItem", "toggleListItem"].includes(node.type) ? "li" : node.type === "blockquote" ? "blockquote" : node.type === "codeBlock" ? "pre" : node.type === "table" ? "table" : node.type === "tableRow" ? "tr" : node.type === "tableHeader" ? "th" : node.type === "tableCell" ? "td" : node.type === "hardBreak" ? "br" : node.type === "divider" || node.type === "horizontalRule" ? "hr" : node.type === "callout" ? "aside" : node.type === "diagram" || node.type === "mermaidDiagram" ? "figure" : "div");
-      const attrs = node.type === "orderedList" && positiveInteger(node.attrs?.start) ? { start: Number(node.attrs?.start) } : node.type === "tableHeader" || node.type === "tableCell" ? { ...positiveInteger(node.attrs?.colspan) ? { colspan: Number(node.attrs?.colspan) } : {}, ...positiveInteger(node.attrs?.rowspan) ? { rowspan: Number(node.attrs?.rowspan) } : {}, ...node.type === "tableHeader" && typeof node.attrs?.scope === "string" ? { scope: node.attrs.scope } : {} } : void 0;
-      return { tag, ...attrs ? { attrs } : {}, children };
+        const children = node.content?.map(
+          (child) => renderNestedHtml({ type: "doc", version: 1, content: [child] })
+        );
+        return {
+          tag: node.type === "paragraph" ? "p" : "div",
+          children
+        };
+      })
     };
-    return { tag: "div", children: document.content.map((node) => renderNode(node)) };
   };
-  const defaultDocumentText = (document) => {
-    let count = 0;
-    const renderNode = (node, depth = 0) => {
-      count += 1;
-      if (count > VALIDATION_LIMITS.values || depth > VALIDATION_LIMITS.depth) return "";
+  const renderNestedText = (document) => {
+    const visit = (node) => {
       if (node.type === OPENEDITOR_CUSTOM_BLOCK_NODE) {
         const nested = resolve(node);
-        return nested.status === "ready" ? exportNestedText(nested) : "";
+        return nested.status === "ready" ? nested.definition.toText({
+          data: nested.data,
+          renderDocument: options.renderDocument ?? renderNestedHtml,
+          documentToText: options.documentToText ?? renderNestedText
+        }) : "";
       }
-      if (node.type === "image") return typeof node.attrs?.alt === "string" ? node.attrs.alt : "Image";
-      if (node.type === "page" && !node.content?.length) return typeof node.attrs?.title === "string" ? node.attrs.title : "Untitled page";
-      if (node.type === "attachment") return typeof node.attrs?.name === "string" && node.attrs.name ? node.attrs.name : "Attachment";
       if (node.text) return node.text;
-      const content = node.content?.map((child) => renderNode(child, depth + 1)).filter(Boolean) ?? [];
-      return ["doc", "paragraph", "heading", "listItem", "taskItem", "blockquote", "codeBlock", "tableRow", "callout"].includes(node.type) ? content.join("") : content.join("\n");
+      return node.content?.map(visit).filter(Boolean).join("\n") ?? "";
     };
-    return renderNode(document).trim();
-  };
-  const fallbackLabel = (node, status) => `Custom block ${envelopeFromNode(node)?.blockId ?? "unknown"} is unavailable: ${status}.`;
-  const fallback = (node, result) => `<p role="status" data-openeditor-custom-block-error="${escapeOpenEditorCustomBlockHtml(result.status)}" data-block-id="${escapeOpenEditorCustomBlockHtml(envelopeFromNode(node)?.blockId ?? "unknown")}">${escapeOpenEditorCustomBlockHtml(fallbackLabel(node, result.status))}</p>`;
-  const exportReadySafeTree = (result) => result.definition.toHtml({ data: result.data, renderDocument: options.renderDocument ?? defaultDocumentSafeTree, documentToText: options.documentToText ?? defaultDocumentText });
-  const exportReadyText = (result) => result.definition.toText({ data: result.data, renderDocument: options.renderDocument ?? defaultDocumentSafeTree, documentToText: options.documentToText ?? defaultDocumentText });
-  const exportNestedSafeTree = (result) => {
-    try {
-      const tree = exportReadySafeTree(result);
-      renderOpenEditorCustomBlockSafeHtml(tree);
-      return tree;
-    } catch {
-      return { tag: "p", attrs: { role: "status" }, children: [fallbackLabel(result.node, "invalid")] };
-    }
+    return document.content.map(visit).filter(Boolean).join("\n").trim();
   };
-  const exportNestedText = (result) => {
-    try {
-      return exportReadyText(result);
-    } catch {
-      return fallbackLabel(result.node, "invalid");
-    }
-  };
-  return Object.freeze({
+  const fallbackLabel = (node, status) => `Custom block ${String(node.attrs?.blockId ?? "unknown")} is unavailable: ${status}.`;
+  const registry = {
     definitions: Object.freeze([...definitions]),
     manifests: Object.freeze(definitions.map((item) => item.manifest)),
     get: (id) => byId.get(id),
     isEnabled: (id) => byId.has(id) && !disabled.has(id),
     resolve,
+    validate: (raw) => {
+      const result = resolveEnvelope(raw);
+      return result.status === "ready" ? { valid: true, envelope: result.envelope } : { valid: false, diagnostics: result.diagnostics };
+    },
+    assets: (raw) => {
+      const result = resolveEnvelope(raw);
+      if (result.status !== "ready" || !result.definition.assets) return [];
+      try {
+        return result.definition.assets(result.envelope.data).filter(
+          (reference) => typeof reference.id === "string" && reference.id.length > 0 && typeof reference.path === "string" && reference.path.startsWith("$.data")
+        );
+      } catch {
+        return [];
+      }
+    },
     toHtml: (node) => {
       const result = resolve(node);
-      if (result.status !== "ready") return fallback(node, result);
+      if (result.status !== "ready")
+        return `<p role="status" data-openeditor-custom-block-error="${escapeOpenEditorCustomBlockHtml(result.status)}">${escapeOpenEditorCustomBlockHtml(fallbackLabel(node, result.status))}</p>`;
       try {
-        const rendered = renderOpenEditorCustomBlockSafeHtml(exportReadySafeTree(result));
-        return rendered || fallback(node, { status: "invalid", node, blockId: result.definition.id, diagnostics: [{ path: "$.toHtml", message: "Static HTML output is invalid." }] });
+        return renderOpenEditorCustomBlockSafeHtml(
+          result.definition.toHtml({
+            data: result.data,
+            renderDocument: options.renderDocument ?? renderNestedHtml,
+            documentToText: options.documentToText ?? renderNestedText
+          })
+        );
       } catch {
-        return fallback(node, { status: "invalid", blockId: result.definition.id});
+        return `<p role="status" data-openeditor-custom-block-error="invalid">${escapeOpenEditorCustomBlockHtml(fallbackLabel(node, "invalid"))}</p>`;
       }
     },
     toText: (node) => {
       const result = resolve(node);
       if (result.status !== "ready") return fallbackLabel(node, result.status);
       try {
-        return exportReadyText(result);
+        return result.definition.toText({
+          data: result.data,
+          renderDocument: options.renderDocument ?? renderNestedHtml,
+          documentToText: options.documentToText ?? renderNestedText
+        });
       } catch {
         return fallbackLabel(node, "invalid");
       }
     }
-  });
+  };
+  return Object.freeze(registry);
 };
 var createOpenEditorCustomBlockNode = (registry, id, data, options = {}) => {
   const definition = registry.get(id);
-  if (!definition) throw new Error(`OpenEditor custom block "${id}" is not registered.`);
-  const value = clone(data ?? definition.initialData());
-  const diagnostics = validateValue(value, definition.dataSchema, "$.data");
-  if (diagnostics.length) throw new Error(`Invalid initial data for "${id}": ${diagnostics.map((item) => `${item.path}: ${item.message}`).join("; ")}`);
-  const instanceId = options.instanceId ?? options.createInstanceId?.() ?? globalThis.crypto.randomUUID();
-  if (!instanceId.trim()) throw new Error("OpenEditor custom block instance IDs must not be empty.");
-  const node = { type: OPENEDITOR_CUSTOM_BLOCK_NODE, attrs: { "openeditor-id": instanceId, blockId: definition.id, version: definition.version, data: value } };
-  const resolved = registry.resolve(node);
-  if (resolved.status !== "ready") throw new Error(`Invalid initial data for "${id}": ${resolved.diagnostics.map((item) => `${item.path}: ${item.message}`).join("; ") || resolved.status}`);
-  return node;
-};
-var resolveOpenEditorCustomBlockNode = (registry, node) => registry.resolve(node);
-var validateOpenEditorCustomBlockEnvelope = (value, manifests, options = {}) => {
-  const ids = /* @__PURE__ */ new Set();
-  for (const manifest2 of manifests) {
-    if (ids.has(manifest2.id)) return { valid: false, diagnostics: [{ path: "$.manifests", message: `Duplicate custom block manifest "${manifest2.id}".` }] };
-    ids.add(manifest2.id);
-    if (!ID_PATTERN.test(manifest2.id) || !Number.isSafeInteger(manifest2.version) || manifest2.version < 1) return { valid: false, diagnostics: [{ path: "$.manifests", message: "Custom block manifest identity or version is invalid." }] };
-  }
-  if (!plainObject(value) || typeof value.blockId !== "string" || typeof value.version !== "number" || !plainObject(value.data)) return { valid: false, diagnostics: [{ path: "$", message: "Expected a custom block envelope." }] };
-  const manifest = manifests.find((item) => item.id === value.blockId);
-  if (options.mode === "preserve" && (!manifest || options.disabled?.includes(value.blockId) || manifest && value.version !== manifest.version)) {
-    const diagnostics2 = inspectJson(value.data);
-    return diagnostics2.length ? { valid: false, diagnostics: diagnostics2 } : { valid: true, diagnostics: [], status: "preserved" };
-  }
-  if (!manifest) return { valid: false, diagnostics: [{ path: "$.blockId", message: `Unknown custom block "${value.blockId}".` }] };
-  if (value.version !== manifest.version) return { valid: false, diagnostics: [{ path: "$.version", message: `Expected version ${manifest.version}.` }] };
-  const nestedDiagnostics = [];
-  const nestedSeen = /* @__PURE__ */ new WeakSet();
-  const inspectNested = (input, path) => {
-    if (!plainObject(input) || nestedSeen.has(input)) return;
-    nestedSeen.add(input);
-    if (input.type === OPENEDITOR_CUSTOM_BLOCK_NODE && plainObject(input.attrs)) {
-      const nested = validateOpenEditorCustomBlockEnvelope(input.attrs, manifests, options);
-      if (!nested.valid) nestedDiagnostics.push(...nested.diagnostics.map((item) => ({ path: `${path}.attrs${item.path.slice(1)}`, message: item.message })));
-      return;
-    }
-    if (Array.isArray(input.content)) input.content.forEach((item, index) => inspectNested(item, `${path}.content[${index}]`));
-  };
-  const inspectDeclaredDocuments = (input, schema, path) => {
-    if (schema.type === "document") {
-      inspectNested(input, path);
-      return;
-    }
-    if (schema.type === "array" && Array.isArray(input) && schema.items) input.forEach((item, index) => inspectDeclaredDocuments(item, schema.items, `${path}[${index}]`));
-    if (schema.type === "object" && plainObject(input)) for (const [key, item] of Object.entries(input)) {
-      const property = schema.properties?.[key];
-      if (property) inspectDeclaredDocuments(item, property, `${path}.${key}`);
-      else if (plainObject(schema.additionalProperties)) inspectDeclaredDocuments(item, schema.additionalProperties, `${path}.${key}`);
-    }
-    if (schema.type === "oneOf") {
-      for (const variant of schema.variants) if (validateValue(input, variant, path).length === 0) inspectDeclaredDocuments(input, variant, path);
+  if (!definition)
+    throw new Error(`OpenEditor custom block "${id}" is not registered.`);
+  const node = {
+    type: OPENEDITOR_CUSTOM_BLOCK_NODE,
+    attrs: {
+      "openeditor-id": options.instanceId ?? options.createInstanceId?.() ?? crypto.randomUUID(),
+      blockId: definition.id,
+      version: definition.version,
+      data: data ?? definition.createData()
     }
   };
-  inspectDeclaredDocuments(value.data, manifest.dataSchema, "$.data");
-  const diagnostics = [...inspectJson(value.data), ...validateValue(value.data, manifest.dataSchema, "$.data"), ...validateConstraints(value.data, manifest.constraints), ...nestedDiagnostics].sort((a, b) => a.path.localeCompare(b.path));
-  if (options.mode === "preserve" && diagnostics.length && inspectJson(value.data).length === 0) return { valid: true, diagnostics, status: "preserved-invalid" };
-  return diagnostics.length ? { valid: false, diagnostics } : { valid: true, diagnostics: [] };
-};
-var extractOpenEditorCustomBlockAssetReferences = (value, manifests) => {
-  const byId = new Map(manifests.map((manifest) => [manifest.id, manifest]));
-  const references = [];
-  const seen = /* @__PURE__ */ new Set();
-  const visitSchema = (input, schema, path) => {
-    if (input === null || input === void 0) return;
-    if (schema.type === "string" && schema.format === "asset-id" && typeof input === "string" && OPENEDITOR_CUSTOM_BLOCK_ASSET_ID_PATTERN.test(input)) {
-      const key = `${path}\0${input}`;
-      if (!seen.has(key)) {
-        seen.add(key);
-        references.push({ id: input, path });
-      }
-      return;
-    }
-    if (schema.type === "array" && Array.isArray(input) && schema.items) input.forEach((item, index) => visitSchema(item, schema.items, `${path}[${index}]`));
-    if (schema.type === "object" && plainObject(input)) for (const [key, item] of Object.entries(input)) {
-      const property = schema.properties?.[key];
-      if (property) visitSchema(item, property, `${path}.${key}`);
-      else if (plainObject(schema.additionalProperties)) visitSchema(item, schema.additionalProperties, `${path}.${key}`);
-    }
-    if (schema.type === "document" && plainObject(input)) visitNested(input, path);
-    if (schema.type === "oneOf") for (const variant of schema.variants) {
-      if (validateValue(input, variant, path).length === 0) visitSchema(input, variant, path);
-    }
-  };
-  const visitNested = (input, path) => {
-    if (!plainObject(input)) return;
-    if (input.type === OPENEDITOR_CUSTOM_BLOCK_NODE && plainObject(input.attrs)) {
-      const manifest = typeof input.attrs.blockId === "string" ? byId.get(input.attrs.blockId) : void 0;
-      if (manifest && plainObject(input.attrs.data) && validateOpenEditorCustomBlockEnvelope(input.attrs, manifests).valid) visitSchema(input.attrs.data, manifest.dataSchema, `${path}.attrs.data`);
-      return;
-    }
-    if (Array.isArray(input.content)) input.content.forEach((item, index) => visitNested(item, `${path}.content[${index}]`));
-  };
-  if (plainObject(value) && typeof value.blockId === "string" && plainObject(value.data)) {
-    const manifest = byId.get(value.blockId);
-    if (manifest && validateOpenEditorCustomBlockEnvelope(value, manifests).valid) visitSchema(value.data, manifest.dataSchema, "$.data");
-  }
-  return references;
+  const resolved = registry.resolve(node);
+  if (resolved.status !== "ready")
+    throw new Error(
+      `Invalid initial data for custom block "${id}": ${resolved.diagnostics.map((item) => item.message).join(" ")}`
+    );
+  return resolved.node;
 };
+var resolveOpenEditorCustomBlockNode = (registry, node) => registry.resolve(node);
+var validateOpenEditorCustomBlockEnvelope = (value, registry) => registry.validate(value);
+var extractOpenEditorCustomBlockAssetReferences = (value, registry) => registry.assets(value);
 var conformOpenEditorCustomBlock = (definition) => {
-  const diagnostics = [];
   try {
     const registry = createOpenEditorCustomBlockRegistry([definition]);
-    const node = createOpenEditorCustomBlockNode(registry, definition.id, void 0, { instanceId: "conformance-instance" });
-    const envelope = node.attrs;
-    const validated = validateOpenEditorCustomBlockEnvelope(envelope, registry.manifests);
-    if (!validated.valid) diagnostics.push(...validated.diagnostics);
+    const node = createOpenEditorCustomBlockNode(
+      registry,
+      definition.id,
+      void 0,
+      { instanceId: "conformance-instance" }
+    );
     const html = registry.toHtml(node);
     const text = registry.toText(node);
-    if (html.includes('data-openeditor-custom-block-error="invalid"') || text === `Custom block ${definition.id} is unavailable: invalid.`) diagnostics.push({ path: "$.staticExport", message: "Custom block static export failed conformance." });
+    return html.includes('data-openeditor-custom-block-error="invalid"') || text === `Custom block ${definition.id} is unavailable: invalid.` ? [
+      {
+        path: "$.staticExport",
+        message: "Custom block static export failed conformance."
+      }
+    ] : [];
   } catch (error) {
-    diagnostics.push({ path: "$", message: error instanceof Error ? error.message : "Custom block conformance failed." });
+    return [
+      {
+        path: "$",
+        message: error instanceof Error ? error.message : "Custom block conformance failed."
+      }
+    ];
   }
-  return diagnostics;
+};
+var escapeOpenEditorCustomBlockHtml = (value) => String(value).replace(
+  /[&<>"']/g,
+  (character) => ({
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+  })[character]
+);
+var SAFE_TAGS = /* @__PURE__ */ new Set([
+  "div",
+  "span",
+  "p",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "article",
+  "section",
+  "aside",
+  "blockquote",
+  "figure",
+  "figcaption",
+  "ul",
+  "ol",
+  "li",
+  "dl",
+  "dt",
+  "dd",
+  "table",
+  "caption",
+  "thead",
+  "tbody",
+  "tr",
+  "th",
+  "td",
+  "strong",
+  "em",
+  "u",
+  "s",
+  "code",
+  "pre",
+  "a",
+  "img",
+  "br",
+  "hr"
+]);
+var SAFE_ATTRS = /* @__PURE__ */ new Set([
+  "aria-label",
+  "aria-current",
+  "role",
+  "title",
+  "href",
+  "src",
+  "alt",
+  "width",
+  "height",
+  "start",
+  "colspan",
+  "rowspan",
+  "scope"
+]);
+var safeStaticUrl = (value, context) => {
+  const normalized = value.trim();
+  if (!normalized) return null;
+  const scheme = /^([a-z][a-z\d+.-]*):/i.exec(normalized)?.[1]?.toLowerCase();
+  if (!scheme)
+    return normalized.startsWith("//") || normalized.includes("\\") ? null : normalized;
+  const allowed = context === "asset" ? ["http", "https"] : ["http", "https", "mailto", "tel"];
+  return allowed.includes(scheme) ? normalized : null;
+};
+var renderOpenEditorCustomBlockSafeHtml = (value) => {
+  const seen = /* @__PURE__ */ new WeakSet();
+  let nodes = 0;
+  let stringBytes = 0;
+  const count = (rendered) => {
+    stringBytes += rendered.length;
+    if (stringBytes > LIMITS.stringLength)
+      throw new Error("Safe HTML output exceeds its text limit.");
+    return rendered;
+  };
+  const render = (item, depth) => {
+    nodes += 1;
+    if (nodes > LIMITS.values || depth > LIMITS.depth)
+      throw new Error("Safe HTML output exceeds its structural limit.");
+    if (item && typeof item === "object") {
+      if (seen.has(item)) throw new Error("Safe HTML output must not contain cycles.");
+      seen.add(item);
+    }
+    if (item === null || item === false) return "";
+    if (typeof item === "string" || typeof item === "number")
+      return count(escapeOpenEditorCustomBlockHtml(item));
+    if (!plainObject(item) || typeof item.tag !== "string" || !SAFE_TAGS.has(item.tag))
+      return "";
+    const attrs = Object.entries(item.attrs ?? {}).flatMap(([name, raw]) => {
+      if (raw === void 0 || !SAFE_ATTRS.has(name)) return [];
+      const safe = name === "href" ? safeStaticUrl(String(raw), "navigation") : name === "src" ? safeStaticUrl(String(raw), "asset") : String(raw);
+      return safe === null ? [] : [count(` ${name}="${escapeOpenEditorCustomBlockHtml(safe)}"`)];
+    }).join("");
+    const children = (item.children ?? []).map((child) => render(child, depth + 1)).join("");
+    return ["img", "br", "hr"].includes(item.tag) ? `<${item.tag}${attrs}>` : `<${item.tag}${attrs}>${children}</${item.tag}>`;
+  };
+  return render(value, 0);
 };
 
-export { OPENEDITOR_CUSTOM_BLOCK_ASSET_ID_PATTERN, OPENEDITOR_CUSTOM_BLOCK_NODE, conformOpenEditorCustomBlock, createOpenEditorCustomBlockNode, createOpenEditorCustomBlockRegistry, defineOpenEditorCustomBlock, escapeOpenEditorCustomBlockHtml, extractOpenEditorCustomBlockAssetReferences, renderOpenEditorCustomBlockSafeHtml, resolveOpenEditorCustomBlockNode, validateOpenEditorCustomBlockDataValue, validateOpenEditorCustomBlockEnvelope };
+export { OPENEDITOR_CUSTOM_BLOCK_NODE, conformOpenEditorCustomBlock, createOpenEditorCustomBlockNode, createOpenEditorCustomBlockRegistry, defineOpenEditorCustomBlock, escapeOpenEditorCustomBlockHtml, extractOpenEditorCustomBlockAssetReferences, renderOpenEditorCustomBlockSafeHtml, resolveOpenEditorCustomBlockNode, validateOpenEditorCustomBlockEnvelope };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map