@407dev/field-types 0.1.0

package/dist/index.js

@@ -0,0 +1,1670 @@
+// src/registry.ts
+var registry = /* @__PURE__ */ new Map();
+function registerFieldType(def) {
+  registry.set(def.id, def);
+}
+function getFieldType(id) {
+  return registry.get(id);
+}
+function hasFieldType(id) {
+  return registry.has(id);
+}
+function listFieldTypes() {
+  return Array.from(registry.values());
+}
+function listFieldTypeIds() {
+  return Array.from(registry.keys());
+}
+function fieldTypeAliases() {
+  const aliases = /* @__PURE__ */ new Map();
+  for (const def of registry.values()) {
+    if (def.aliases) {
+      for (const alias of def.aliases) {
+        aliases.set(alias, def.id);
+      }
+    }
+  }
+  return aliases;
+}
+function resolveTypeAlias(name) {
+  if (registry.has(name)) {
+    return name;
+  }
+  const aliasMap = fieldTypeAliases();
+  return aliasMap.get(name) ?? name;
+}
+function normalizeFieldValue(typeId, value, constraints) {
+  const canonicalId = resolveTypeAlias(typeId);
+  const typeDef = registry.get(canonicalId) || registry.get(typeId);
+  if (!typeDef?.normalize) {
+    return value;
+  }
+  try {
+    return typeDef.normalize(value, constraints);
+  } catch {
+    return value;
+  }
+}
+function unknownTypeIds(ids) {
+  return ids.filter((id) => !registry.has(resolveTypeAlias(id)));
+}
+function validateFieldValue(typeId, value, constraints) {
+  const canonicalId = resolveTypeAlias(typeId);
+  const typeDef = registry.get(canonicalId) || registry.get(typeId);
+  if (!typeDef) {
+    return {
+      valid: false,
+      errors: [
+        {
+          path: "",
+          message: `Unknown field type: '${typeId}'`,
+          keyword: "unknown_type"
+        }
+      ]
+    };
+  }
+  try {
+    return typeDef.validate(value, constraints);
+  } catch (err) {
+    return {
+      valid: false,
+      errors: [
+        {
+          path: "",
+          message: err instanceof Error ? err.message : "Validation exception",
+          keyword: "validation_error"
+        }
+      ]
+    };
+  }
+}
+function resetRegistry() {
+  registry.clear();
+}
+
+// src/types/address.ts
+var ALLOWED_ADDRESS_KEYS = /* @__PURE__ */ new Set([
+  "line1",
+  "line2",
+  "city",
+  "region",
+  "postal",
+  "country",
+  "lat",
+  "lng"
+]);
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var ISO2_REGEX = /^[A-Za-z]{2}$/;
+var addressType = {
+  id: "address",
+  defaultValue: null,
+  constraintsSchema: {
+    type: "object",
+    properties: {
+      countryFormat: { type: "string", enum: ["iso2", "free"], default: "iso2" }
+    },
+    additionalProperties: false
+  },
+  validate(value, constraints) {
+    if (value === null || value === void 0) {
+      return { valid: true };
+    }
+    const errors = [];
+    const c = constraints || {};
+    const countryFormat = c.countryFormat || "iso2";
+    if (typeof value !== "object" || Array.isArray(value)) {
+      return {
+        valid: false,
+        errors: [
+          {
+            path: "",
+            message: `Expected address object, got ${typeof value}`,
+            keyword: "type"
+          }
+        ]
+      };
+    }
+    const record = value;
+    for (const key of Object.keys(record)) {
+      if (FORBIDDEN_KEYS.has(key) || !ALLOWED_ADDRESS_KEYS.has(key)) {
+        errors.push({
+          path: key,
+          message: `Unknown or forbidden property '${key}' in address`,
+          keyword: "additional_properties"
+        });
+      }
+    }
+    const requiredStringFields = [
+      "line1",
+      "city",
+      "region",
+      "postal",
+      "country"
+    ];
+    for (const field of requiredStringFields) {
+      const val = record[field];
+      if (typeof val !== "string" || !val.trim()) {
+        errors.push({
+          path: field,
+          message: `Address field '${field}' is required and must be a non-empty string`,
+          keyword: "required"
+        });
+      }
+    }
+    if (record.line2 !== void 0 && record.line2 !== null && record.line2 !== "") {
+      if (typeof record.line2 !== "string") {
+        errors.push({
+          path: "line2",
+          message: "Address line2 must be a string",
+          keyword: "type"
+        });
+      }
+    }
+    if (typeof record.country === "string" && record.country.trim()) {
+      if (countryFormat === "iso2" && !ISO2_REGEX.test(record.country.trim())) {
+        errors.push({
+          path: "country",
+          message: `Country '${record.country}' must be a 2-letter ISO-3166-1 alpha-2 code`,
+          keyword: "country_format"
+        });
+      }
+    }
+    if (record.lat !== void 0 && record.lat !== null) {
+      if (typeof record.lat !== "number" || !Number.isFinite(record.lat)) {
+        errors.push({
+          path: "lat",
+          message: "Latitude must be a finite number",
+          keyword: "type"
+        });
+      } else if (record.lat < -90 || record.lat > 90) {
+        errors.push({
+          path: "lat",
+          message: `Latitude ${record.lat} is out of bounds (must be between -90 and 90)`,
+          keyword: "lat_out_of_bounds"
+        });
+      }
+    }
+    if (record.lng !== void 0 && record.lng !== null) {
+      if (typeof record.lng !== "number" || !Number.isFinite(record.lng)) {
+        errors.push({
+          path: "lng",
+          message: "Longitude must be a finite number",
+          keyword: "type"
+        });
+      } else if (record.lng < -180 || record.lng > 180) {
+        errors.push({
+          path: "lng",
+          message: `Longitude ${record.lng} is out of bounds (must be between -180 and 180)`,
+          keyword: "lng_out_of_bounds"
+        });
+      }
+    }
+    if (errors.length === 0) {
+      return { valid: true };
+    }
+    return { valid: false, errors };
+  }
+};
+var addressListType = {
+  id: "address.list",
+  aliases: ["addressList"],
+  defaultValue: [],
+  constraintsSchema: {
+    type: "object",
+    properties: {
+      minItems: { type: "integer", minimum: 0 },
+      maxItems: { type: "integer", minimum: 0, default: 25 },
+      countryFormat: { type: "string", enum: ["iso2", "free"], default: "iso2" }
+    },
+    additionalProperties: false
+  },
+  validate(value, constraints) {
+    if (value === null || value === void 0) {
+      return { valid: true };
+    }
+    const errors = [];
+    const c = constraints || {};
+    const maxItems = typeof c.maxItems === "number" ? c.maxItems : 25;
+    if (!Array.isArray(value)) {
+      return {
+        valid: false,
+        errors: [
+          {
+            path: "",
+            message: `Expected array for address.list, got ${typeof value}`,
+            keyword: "type"
+          }
+        ]
+      };
+    }
+    if (typeof c.minItems === "number" && value.length < c.minItems) {
+      errors.push({
+        path: "",
+        message: `Address list item count (${value.length}) is less than minimum (${c.minItems})`,
+        keyword: "min_items"
+      });
+    }
+    if (value.length > maxItems) {
+      errors.push({
+        path: "",
+        message: `Address list item count (${value.length}) exceeds maximum (${maxItems})`,
+        keyword: "max_items"
+      });
+    }
+    for (let i = 0; i < value.length; i++) {
+      const item = value[i];
+      const itemResult = addressType.validate(item, constraints);
+      if (!itemResult.valid) {
+        for (const err of itemResult.errors) {
+          const itemPath = err.path ? `[${i}].${err.path}` : `[${i}]`;
+          errors.push({
+            path: itemPath,
+            message: err.message,
+            keyword: err.keyword
+          });
+        }
+      }
+    }
+    if (errors.length === 0) {
+      return { valid: true };
+    }
+    return { valid: false, errors };
+  }
+};
+
+// src/types/geoArea.ts
+var FORBIDDEN_KEYS2 = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function crossProduct(a, b, c) {
+  return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+}
+var EPSILON = 1e-12;
+function isPointOnSegment(p, a, b) {
+  return p[0] >= Math.min(a[0], b[0]) - EPSILON && p[0] <= Math.max(a[0], b[0]) + EPSILON && p[1] >= Math.min(a[1], b[1]) - EPSILON && p[1] <= Math.max(a[1], b[1]) + EPSILON;
+}
+function segmentsIntersect(a, b, c, d) {
+  const cp1 = crossProduct(a, b, c);
+  const cp2 = crossProduct(a, b, d);
+  const cp3 = crossProduct(c, d, a);
+  const cp4 = crossProduct(c, d, b);
+  if ((cp1 > EPSILON && cp2 < -EPSILON || cp1 < -EPSILON && cp2 > EPSILON) && (cp3 > EPSILON && cp4 < -EPSILON || cp3 < -EPSILON && cp4 > EPSILON)) {
+    return true;
+  }
+  if (Math.abs(cp1) <= EPSILON && isPointOnSegment(c, a, b)) return true;
+  if (Math.abs(cp2) <= EPSILON && isPointOnSegment(d, a, b)) return true;
+  if (Math.abs(cp3) <= EPSILON && isPointOnSegment(a, c, d)) return true;
+  if (Math.abs(cp4) <= EPSILON && isPointOnSegment(b, c, d)) return true;
+  return false;
+}
+function findRingSelfIntersection(ring) {
+  const numSegments = ring.length - 1;
+  if (numSegments < 3) return null;
+  for (let i = 0; i < numSegments; i++) {
+    const a = ring[i];
+    const b = ring[i + 1];
+    for (let j = i + 1; j < numSegments; j++) {
+      if (j === i + 1) continue;
+      if (i === 0 && j === numSegments - 1) continue;
+      const c = ring[j];
+      const d = ring[j + 1];
+      if (segmentsIntersect(a, b, c, d)) {
+        return [i, j];
+      }
+    }
+  }
+  return null;
+}
+function normalizeRing(rawRing) {
+  if (!Array.isArray(rawRing) || rawRing.length === 0) {
+    return [];
+  }
+  const cleaned = [];
+  for (const pos of rawRing) {
+    if (!Array.isArray(pos) || pos.length < 2) continue;
+    const lon = Number(pos[0]);
+    const lat = Number(pos[1]);
+    if (!Number.isFinite(lon) || !Number.isFinite(lat)) continue;
+    if (cleaned.length > 0) {
+      const prev = cleaned[cleaned.length - 1];
+      if (Math.abs(prev[0] - lon) < EPSILON && Math.abs(prev[1] - lat) < EPSILON) {
+        continue;
+      }
+    }
+    cleaned.push([lon, lat]);
+  }
+  if (cleaned.length >= 1) {
+    const first = cleaned[0];
+    const last = cleaned[cleaned.length - 1];
+    if (Math.abs(first[0] - last[0]) >= EPSILON || Math.abs(first[1] - last[1]) >= EPSILON) {
+      cleaned.push([first[0], first[1]]);
+    }
+  }
+  return cleaned;
+}
+function normalizeGeoArea(value) {
+  if (!value) {
+    return value;
+  }
+  let obj = value;
+  if (typeof value === "string") {
+    try {
+      obj = JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+    return value;
+  }
+  if (obj.type === "Polygon" && Array.isArray(obj.coordinates)) {
+    const newCoords = obj.coordinates.map((ring) => normalizeRing(ring));
+    return {
+      ...obj,
+      type: "Polygon",
+      coordinates: newCoords
+    };
+  }
+  if (obj.type === "MultiPolygon" && Array.isArray(obj.coordinates)) {
+    const newCoords = obj.coordinates.map(
+      (poly) => Array.isArray(poly) ? poly.map((ring) => normalizeRing(ring)) : []
+    );
+    return {
+      ...obj,
+      type: "MultiPolygon",
+      coordinates: newCoords
+    };
+  }
+  return value;
+}
+var geoAreaType = {
+  id: "geo.area",
+  aliases: ["geoArea"],
+  defaultValue: null,
+  constraintsSchema: {
+    type: "object",
+    properties: {
+      maxVertices: { type: "integer", minimum: 4, default: 2e3 },
+      maxRings: { type: "integer", minimum: 1, default: 20 }
+    },
+    additionalProperties: false
+  },
+  normalize: normalizeGeoArea,
+  validate(value, constraints) {
+    if (value === null || value === void 0 || value === "") {
+      return { valid: true };
+    }
+    const errors = [];
+    const c = constraints || {};
+    const maxVertices = typeof c.maxVertices === "number" ? c.maxVertices : 2e3;
+    const maxRings = typeof c.maxRings === "number" ? c.maxRings : 20;
+    let targetValue = value;
+    if (typeof value === "string") {
+      try {
+        targetValue = JSON.parse(value);
+      } catch {
+        return {
+          valid: false,
+          errors: [
+            {
+              path: "",
+              message: "Expected GeoJSON object for geo.area, got invalid JSON string",
+              keyword: "type"
+            }
+          ]
+        };
+      }
+    }
+    if (typeof targetValue !== "object" || targetValue === null || Array.isArray(targetValue)) {
+      return {
+        valid: false,
+        errors: [
+          {
+            path: "",
+            message: `Expected GeoJSON object for geo.area, got ${typeof targetValue}`,
+            keyword: "type"
+          }
+        ]
+      };
+    }
+    const record = targetValue;
+    for (const key of Object.keys(record)) {
+      if (FORBIDDEN_KEYS2.has(key)) {
+        errors.push({
+          path: key,
+          message: `Forbidden property '${key}' in GeoJSON object`,
+          keyword: "forbidden_property"
+        });
+      }
+    }
+    if (record.type !== "Polygon" && record.type !== "MultiPolygon") {
+      errors.push({
+        path: "type",
+        message: `GeoJSON type must be 'Polygon' or 'MultiPolygon', got '${String(record.type)}'`,
+        keyword: "geo_invalid_type"
+      });
+      return { valid: false, errors };
+    }
+    if (!Array.isArray(record.coordinates)) {
+      errors.push({
+        path: "coordinates",
+        message: "GeoJSON coordinates property must be an array",
+        keyword: "type"
+      });
+      return { valid: false, errors };
+    }
+    const rings = [];
+    if (record.type === "Polygon") {
+      const polyCoords = record.coordinates;
+      for (let r = 0; r < polyCoords.length; r++) {
+        if (!Array.isArray(polyCoords[r])) {
+          errors.push({
+            path: `coordinates[${r}]`,
+            message: `LinearRing at coordinates[${r}] must be an array of coordinates`,
+            keyword: "type"
+          });
+        } else {
+          rings.push({ ring: polyCoords[r], path: `coordinates[${r}]` });
+        }
+      }
+    } else {
+      const multiCoords = record.coordinates;
+      for (let p = 0; p < multiCoords.length; p++) {
+        const poly = multiCoords[p];
+        if (!Array.isArray(poly)) {
+          errors.push({
+            path: `coordinates[${p}]`,
+            message: `Polygon at coordinates[${p}] must be an array of rings`,
+            keyword: "type"
+          });
+          continue;
+        }
+        for (let r = 0; r < poly.length; r++) {
+          if (!Array.isArray(poly[r])) {
+            errors.push({
+              path: `coordinates[${p}][${r}]`,
+              message: `LinearRing at coordinates[${p}][${r}] must be an array of coordinates`,
+              keyword: "type"
+            });
+          } else {
+            rings.push({ ring: poly[r], path: `coordinates[${p}][${r}]` });
+          }
+        }
+      }
+    }
+    if (rings.length > maxRings) {
+      errors.push({
+        path: "coordinates",
+        message: `Total rings count (${rings.length}) exceeds maximum allowed (${maxRings})`,
+        keyword: "geo_ring_cap"
+      });
+    }
+    let totalVertices = 0;
+    for (const { ring, path } of rings) {
+      totalVertices += ring.length;
+      if (ring.length < 4) {
+        errors.push({
+          path,
+          message: `LinearRing at ${path} must contain at least 4 positions (got ${ring.length})`,
+          keyword: "geo_ring_too_short"
+        });
+      }
+      let allPositionsValid = true;
+      const validPoints = [];
+      for (let p = 0; p < ring.length; p++) {
+        const pos = ring[p];
+        const posPath = `${path}[${p}]`;
+        if (!Array.isArray(pos) || pos.length !== 2) {
+          errors.push({
+            path: posPath,
+            message: `Position at ${posPath} must be a 2-element [longitude, latitude] array (elevation is not supported)`,
+            keyword: "geo_position_invalid"
+          });
+          allPositionsValid = false;
+          continue;
+        }
+        const lon = pos[0];
+        const lat = pos[1];
+        if (typeof lon !== "number" || typeof lat !== "number" || !Number.isFinite(lon) || !Number.isFinite(lat)) {
+          errors.push({
+            path: posPath,
+            message: `Position at ${posPath} contains non-finite numbers`,
+            keyword: "geo_position_invalid"
+          });
+          allPositionsValid = false;
+          continue;
+        }
+        if (lon < -180 || lon > 180 || lat < -90 || lat > 90) {
+          errors.push({
+            path: posPath,
+            message: `Position [${lon}, ${lat}] at ${posPath} is out of bounds (longitude must be in [-180, 180], latitude in [-90, 90])`,
+            keyword: "geo_out_of_bounds"
+          });
+          allPositionsValid = false;
+          continue;
+        }
+        validPoints.push([lon, lat]);
+      }
+      if (allPositionsValid && validPoints.length >= 4) {
+        const first = validPoints[0];
+        const last = validPoints[validPoints.length - 1];
+        if (Math.abs(first[0] - last[0]) > EPSILON || Math.abs(first[1] - last[1]) > EPSILON) {
+          errors.push({
+            path,
+            message: `LinearRing at ${path} is not closed (first position [${first[0]}, ${first[1]}] does not match last position [${last[0]}, ${last[1]}])`,
+            keyword: "geo_ring_not_closed"
+          });
+        } else {
+          const intersection = findRingSelfIntersection(validPoints);
+          if (intersection) {
+            errors.push({
+              path,
+              message: `LinearRing at ${path} self-intersects between segment ${intersection[0]} and segment ${intersection[1]}`,
+              keyword: "geo_self_intersection"
+            });
+          }
+        }
+      }
+    }
+    if (totalVertices > maxVertices) {
+      errors.push({
+        path: "coordinates",
+        message: `Total vertex count (${totalVertices}) exceeds maximum allowed (${maxVertices})`,
+        keyword: "geo_vertex_cap"
+      });
+    }
+    if (errors.length === 0) {
+      return { valid: true };
+    }
+    return { valid: false, errors };
+  }
+};
+
+// src/types/image.ts
+var imageType = {
+  id: "image",
+  aliases: ["img"],
+  defaultValue: null,
+  renderHint: { tag: "img" },
+  constraintsSchema: {
+    type: "object",
+    properties: {
+      maxSizeBytes: { type: "integer", minimum: 0 },
+      allowedMimeTypes: {
+        type: "array",
+        items: { type: "string" }
+      }
+    },
+    additionalProperties: false
+  },
+  validate(value) {
+    const errors = [];
+    if (value === null || value === void 0 || value === "") {
+      return { valid: true };
+    }
+    if (typeof value === "string") {
+      return { valid: true };
+    }
+    if (typeof value === "object" && value !== null) {
+      const obj = value;
+      if (obj.kind === "asset" && typeof obj.id === "string" && obj.id.trim()) {
+        return { valid: true };
+      }
+      if (obj.kind === "url" && typeof obj.src === "string" && obj.src.trim()) {
+        return { valid: true };
+      }
+      if (typeof obj.id === "string" || typeof obj.url === "string") {
+        return { valid: true };
+      }
+      errors.push({
+        path: "",
+        message: "Image object must contain an id, url, or valid kind (asset/url)",
+        keyword: "image_structure"
+      });
+      return { valid: false, errors };
+    }
+    return {
+      valid: false,
+      errors: [
+        {
+          path: "",
+          message: `Expected image reference (UUID string, URL, or asset object), got ${typeof value}`,
+          keyword: "type"
+        }
+      ]
+    };
+  }
+};
+
+// src/types/number.ts
+var numberType = {
+  id: "number",
+  defaultValue: 0,
+  constraintsSchema: {
+    type: "object",
+    properties: {
+      min: { type: "number" },
+      max: { type: "number" },
+      step: { type: "number", exclusiveMinimum: 0 },
+      integer: { type: "boolean" }
+    },
+    additionalProperties: false
+  },
+  validate(value, constraints) {
+    const errors = [];
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      return {
+        valid: false,
+        errors: [
+          {
+            path: "",
+            message: `Expected finite number, got ${typeof value === "number" ? "NaN/Infinity" : typeof value}`,
+            keyword: "type"
+          }
+        ]
+      };
+    }
+    const c = constraints || {};
+    if (c.integer && !Number.isInteger(value)) {
+      errors.push({
+        path: "",
+        message: `Value ${value} must be an integer`,
+        keyword: "integer"
+      });
+    }
+    if (typeof c.min === "number" && value < c.min) {
+      errors.push({
+        path: "",
+        message: `Value ${value} is less than minimum ${c.min}`,
+        keyword: "min"
+      });
+    }
+    if (typeof c.max === "number" && value > c.max) {
+      errors.push({
+        path: "",
+        message: `Value ${value} exceeds maximum ${c.max}`,
+        keyword: "max"
+      });
+    }
+    if (typeof c.step === "number" && c.step > 0) {
+      const base = typeof c.min === "number" ? c.min : 0;
+      const diff = Math.abs(value - base);
+      const remainder = diff % c.step;
+      const isMultiple = remainder < 1e-9 || Math.abs(remainder - c.step) < 1e-9;
+      if (!isMultiple) {
+        errors.push({
+          path: "",
+          message: `Value ${value} is not a valid step multiple of ${c.step}`,
+          keyword: "step"
+        });
+      }
+    }
+    if (errors.length === 0) {
+      return { valid: true };
+    }
+    return { valid: false, errors };
+  }
+};
+
+// src/url.ts
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function stripUrlControlChars(raw) {
+  if (typeof raw !== "string") return "";
+  return raw.replace(/[\x00-\x20\x7F-\x9F\u200B-\u200D\uFEFF\s]/g, "");
+}
+function isSafeRelativeOrAnchor(cleaned) {
+  if (!cleaned) return false;
+  if (cleaned.startsWith("\\")) return false;
+  const lower = cleaned.toLowerCase();
+  if (lower.startsWith("/%5c") || lower.startsWith("%5c")) return false;
+  if (cleaned.startsWith("#")) {
+    return !cleaned.includes("\\");
+  }
+  if (cleaned.startsWith("/")) {
+    if (cleaned.length === 1) return true;
+    const second = cleaned[1];
+    if (second === "/" || second === "\\") return false;
+    return true;
+  }
+  return false;
+}
+function isSafeMediaSrc(raw, allowedHosts) {
+  if (typeof raw !== "string") return false;
+  const cleaned = stripUrlControlChars(raw);
+  if (!cleaned) return false;
+  if (UUID_REGEX.test(cleaned)) {
+    return true;
+  }
+  if (isSafeRelativeOrAnchor(cleaned)) {
+    return true;
+  }
+  const lower = cleaned.toLowerCase();
+  if (lower.startsWith("https://") || lower.startsWith("http://")) {
+    if (cleaned.includes("\\") || lower.includes("%5c")) return false;
+    try {
+      const parsed = new URL(cleaned);
+      if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return false;
+      if (parsed.protocol === "http:") {
+        const hostname = parsed.hostname.toLowerCase();
+        if (hostname === "localhost" || hostname === "127.0.0.1") return true;
+        if (!allowedHosts || allowedHosts.length === 0) return false;
+        const allowed = allowedHosts.map((h) => h.toLowerCase());
+        return allowed.includes(hostname);
+      }
+      if (allowedHosts && allowedHosts.length > 0) {
+        const allowed = allowedHosts.map((h) => h.toLowerCase());
+        return allowed.includes(parsed.hostname.toLowerCase());
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function isSafeActionHref(raw, allowedHosts) {
+  if (typeof raw !== "string") return false;
+  const cleaned = stripUrlControlChars(raw);
+  if (!cleaned) return false;
+  const lower = cleaned.toLowerCase();
+  if (lower.startsWith("javascript:") || lower.startsWith("data:") || lower.startsWith("blob:") || lower.startsWith("mailto:") || lower.startsWith("tel:") || lower.startsWith("http:")) {
+    return false;
+  }
+  if (isSafeRelativeOrAnchor(cleaned)) {
+    return true;
+  }
+  if (lower.startsWith("https://")) {
+    if (!allowedHosts || allowedHosts.length === 0) {
+      return false;
+    }
+    if (cleaned.includes("\\") || lower.includes("%5c")) return false;
+    try {
+      const parsed = new URL(cleaned);
+      if (parsed.protocol !== "https:") return false;
+      const allowed = allowedHosts.map((h) => h.toLowerCase());
+      return allowed.includes(parsed.hostname.toLowerCase());
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+// src/richtext.ts
+var DEFAULT_ALLOWED_NODES = [
+  "doc",
+  "paragraph",
+  "heading",
+  "bulletList",
+  "orderedList",
+  "listItem",
+  "blockquote",
+  "codeBlock",
+  "hardBreak",
+  "horizontalRule",
+  "text",
+  "image"
+];
+var DEFAULT_ALLOWED_MARKS = ["bold", "italic", "underline", "strike", "code", "link"];
+var FORBIDDEN_PROPERTY_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isValidLinkHref(rawHref) {
+  if (typeof rawHref !== "string") return false;
+  const cleaned = stripUrlControlChars(rawHref);
+  if (cleaned.length === 0) return false;
+  if (isSafeRelativeOrAnchor(cleaned)) {
+    return true;
+  }
+  const lower = cleaned.toLowerCase();
+  if (lower.startsWith("https://") || lower.startsWith("mailto:") || lower.startsWith("tel:")) {
+    return true;
+  }
+  return false;
+}
+function isValidImageSrc(rawSrc) {
+  if (typeof rawSrc !== "string") return false;
+  const cleaned = stripUrlControlChars(rawSrc);
+  if (cleaned.length === 0) return false;
+  if (isSafeRelativeOrAnchor(cleaned)) return true;
+  const lower = cleaned.toLowerCase();
+  if (lower.startsWith("https://")) return true;
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(cleaned)) {
+    return true;
+  }
+  return false;
+}
+var ALLOWED_NODE_ATTRS = {
+  doc: {},
+  paragraph: {},
+  heading: {
+    level: (v) => typeof v === "number" && Number.isInteger(v) && v >= 1 && v <= 6
+  },
+  bulletList: {},
+  orderedList: {
+    order: (v) => typeof v === "number" && Number.isInteger(v),
+    start: (v) => typeof v === "number" && Number.isInteger(v)
+  },
+  listItem: {},
+  blockquote: {},
+  codeBlock: {
+    language: (v) => typeof v === "string" && v.length <= 100,
+    params: (v) => typeof v === "string" && v.length <= 100
+  },
+  hardBreak: {},
+  horizontalRule: {},
+  text: {},
+  image: {
+    src: (v) => typeof v === "string" && isValidImageSrc(v),
+    alt: (v) => typeof v === "string" && v.length <= 2e3,
+    title: (v) => typeof v === "string" && v.length <= 2e3,
+    width: (v) => typeof v === "number" && v > 0,
+    height: (v) => typeof v === "number" && v > 0
+  }
+};
+var ALLOWED_MARK_ATTRS = {
+  bold: {},
+  italic: {},
+  underline: {},
+  strike: {},
+  code: {},
+  link: {
+    href: (v) => typeof v === "string" && isValidLinkHref(v),
+    title: (v) => typeof v === "string" && v.length <= 2e3,
+    target: (v) => typeof v === "string" && ["_blank", "_self", "_parent", "_top"].includes(v),
+    rel: (v) => typeof v === "string" && v.length <= 100
+  }
+};
+function validateProseMirrorDoc(doc, constraints) {
+  const errors = [];
+  const maxDepth = constraints?.maxDepth ?? 50;
+  const maxNodes = constraints?.maxNodes ?? 1e4;
+  const allowedNodes = new Set(constraints?.nodes ?? DEFAULT_ALLOWED_NODES);
+  const allowedMarks = new Set(constraints?.marks ?? DEFAULT_ALLOWED_MARKS);
+  if (doc === null || typeof doc !== "object" || Array.isArray(doc)) {
+    return {
+      valid: false,
+      errors: [{ path: "doc", message: "Document root must be a JSON object", keyword: "type" }]
+    };
+  }
+  const rootObj = doc;
+  if (rootObj.type !== "doc") {
+    return {
+      valid: false,
+      errors: [
+        {
+          path: "doc",
+          message: `Document root type must be 'doc', got '${String(rootObj.type)}'`,
+          keyword: "invalid_root_type"
+        }
+      ]
+    };
+  }
+  let nodeCount = 0;
+  const seenObjects = /* @__PURE__ */ new WeakSet();
+  function validateNode(node, path, depth) {
+    if (depth > maxDepth) {
+      errors.push({
+        path,
+        message: `Maximum nesting depth of ${maxDepth} exceeded`,
+        keyword: "maxDepth"
+      });
+      return false;
+    }
+    nodeCount++;
+    if (nodeCount > maxNodes) {
+      errors.push({
+        path,
+        message: `Maximum node budget of ${maxNodes} exceeded`,
+        keyword: "maxNodes"
+      });
+      return false;
+    }
+    if (node === null || typeof node !== "object" || Array.isArray(node)) {
+      errors.push({
+        path,
+        message: "Node must be a JSON object",
+        keyword: "type"
+      });
+      return false;
+    }
+    if (seenObjects.has(node)) {
+      errors.push({
+        path,
+        message: "Cyclic reference detected in document",
+        keyword: "cycle"
+      });
+      return false;
+    }
+    seenObjects.add(node);
+    const obj = node;
+    for (const key of Object.keys(obj)) {
+      if (FORBIDDEN_PROPERTY_KEYS.has(key)) {
+        errors.push({
+          path: `${path}/${key}`,
+          message: `Forbidden property '${key}' detected`,
+          keyword: "security"
+        });
+        return false;
+      }
+    }
+    const nodeType = typeof obj.type === "string" ? obj.type : "";
+    if (!nodeType || !allowedNodes.has(nodeType)) {
+      errors.push({
+        path,
+        message: `Unknown or disallowed node type: '${nodeType || String(obj.type)}'`,
+        keyword: "disallowed_node_type"
+      });
+      return false;
+    }
+    const allowedAttrsForType = ALLOWED_NODE_ATTRS[nodeType];
+    if (obj.attrs !== void 0) {
+      if (obj.attrs === null || typeof obj.attrs !== "object" || Array.isArray(obj.attrs)) {
+        errors.push({
+          path: `${path}/attrs`,
+          message: "Node attrs must be an object",
+          keyword: "type"
+        });
+      } else {
+        const attrsObj = obj.attrs;
+        for (const [attrKey, attrVal] of Object.entries(attrsObj)) {
+          if (FORBIDDEN_PROPERTY_KEYS.has(attrKey)) {
+            errors.push({
+              path: `${path}/attrs/${attrKey}`,
+              message: `Forbidden attribute key '${attrKey}'`,
+              keyword: "security"
+            });
+            continue;
+          }
+          const validator = allowedAttrsForType?.[attrKey];
+          if (!validator) {
+            errors.push({
+              path: `${path}/attrs/${attrKey}`,
+              message: `Unknown attribute '${attrKey}' for node type '${nodeType}'`,
+              keyword: "unknown_attribute"
+            });
+          } else if (!validator(attrVal)) {
+            errors.push({
+              path: `${path}/attrs/${attrKey}`,
+              message: `Invalid value for attribute '${attrKey}' on node type '${nodeType}'`,
+              keyword: "invalid_attribute_value"
+            });
+          }
+        }
+      }
+    }
+    if (nodeType === "text") {
+      if (typeof obj.text !== "string") {
+        errors.push({
+          path: `${path}/text`,
+          message: "Text node must have a string text property",
+          keyword: "missing_text"
+        });
+      }
+      if (obj.content !== void 0) {
+        errors.push({
+          path: `${path}/content`,
+          message: "Text node must not have content",
+          keyword: "invalid_content"
+        });
+      }
+    }
+    if (obj.marks !== void 0) {
+      if (!Array.isArray(obj.marks)) {
+        errors.push({
+          path: `${path}/marks`,
+          message: "Marks must be an array",
+          keyword: "type"
+        });
+      } else {
+        obj.marks.forEach((mark, markIdx) => {
+          const markPath = `${path}/marks/${markIdx}`;
+          if (mark === null || typeof mark !== "object" || Array.isArray(mark)) {
+            errors.push({
+              path: markPath,
+              message: "Mark must be an object",
+              keyword: "type"
+            });
+            return;
+          }
+          const markObj = mark;
+          const markType = typeof markObj.type === "string" ? markObj.type : "";
+          if (!markType || !allowedMarks.has(markType)) {
+            errors.push({
+              path: markPath,
+              message: `Unknown or disallowed mark type: '${markType || String(markObj.type)}'`,
+              keyword: "disallowed_mark_type"
+            });
+            return;
+          }
+          const allowedMarkAttrs = ALLOWED_MARK_ATTRS[markType];
+          if (markObj.attrs !== void 0) {
+            if (markObj.attrs === null || typeof markObj.attrs !== "object" || Array.isArray(markObj.attrs)) {
+              errors.push({
+                path: `${markPath}/attrs`,
+                message: "Mark attrs must be an object",
+                keyword: "type"
+              });
+            } else {
+              const attrsObj = markObj.attrs;
+              for (const [attrKey, attrVal] of Object.entries(attrsObj)) {
+                if (FORBIDDEN_PROPERTY_KEYS.has(attrKey)) {
+                  errors.push({
+                    path: `${markPath}/attrs/${attrKey}`,
+                    message: `Forbidden attribute key '${attrKey}' in mark`,
+                    keyword: "security"
+                  });
+                  continue;
+                }
+                const validator = allowedMarkAttrs?.[attrKey];
+                if (!validator) {
+                  errors.push({
+                    path: `${markPath}/attrs/${attrKey}`,
+                    message: `Unknown attribute '${attrKey}' for mark '${markType}'`,
+                    keyword: "unknown_attribute"
+                  });
+                } else if (!validator(attrVal)) {
+                  errors.push({
+                    path: `${markPath}/attrs/${attrKey}`,
+                    message: `Invalid value for attribute '${attrKey}' in mark '${markType}'`,
+                    keyword: "invalid_attribute_value"
+                  });
+                }
+              }
+            }
+          }
+        });
+      }
+    }
+    if (obj.content !== void 0) {
+      if (!Array.isArray(obj.content)) {
+        errors.push({
+          path: `${path}/content`,
+          message: "Content must be an array of nodes",
+          keyword: "type"
+        });
+      } else {
+        for (let i = 0; i < obj.content.length; i++) {
+          const childPath = `${path}/content/${i}`;
+          const ok = validateNode(obj.content[i], childPath, depth + 1);
+          if (!ok && (nodeCount > maxNodes || depth + 1 > maxDepth)) {
+            break;
+          }
+        }
+      }
+    }
+    return errors.length === 0;
+  }
+  validateNode(doc, "doc", 1);
+  if (errors.length === 0) {
+    return { valid: true };
+  }
+  return { valid: false, errors };
+}
+
+// src/types/richtext.ts
+var richtextType = {
+  id: "richtext",
+  aliases: ["richText"],
+  defaultValue: {
+    type: "doc",
+    content: []
+  },
+  renderHint: { tag: "div" },
+  constraintsSchema: {
+    type: "object",
+    properties: {
+      nodes: {
+        type: "array",
+        items: { type: "string" }
+      },
+      marks: {
+        type: "array",
+        items: { type: "string" }
+      },
+      maxDepth: { type: "integer", minimum: 1 },
+      maxNodes: { type: "integer", minimum: 1 }
+    },
+    additionalProperties: false
+  },
+  validate(value, constraints) {
+    return validateProseMirrorDoc(value, constraints);
+  }
+};
+
+// src/types/select.ts
+var selectType = {
+  id: "select",
+  defaultValue: "",
+  constraintsSchema: {
+    type: "object",
+    properties: {
+      options: {
+        type: "array",
+        items: {
+          anyOf: [
+            { type: "string" },
+            {
+              type: "object",
+              properties: {
+                label: { type: "string" },
+                value: { type: "string" }
+              },
+              required: ["label", "value"],
+              additionalProperties: false
+            }
+          ]
+        }
+      }
+    },
+    additionalProperties: false
+  },
+  validate(value, constraints) {
+    const errors = [];
+    if (typeof value !== "string") {
+      return {
+        valid: false,
+        errors: [
+          {
+            path: "",
+            message: `Expected string, got ${typeof value}`,
+            keyword: "type"
+          }
+        ]
+      };
+    }
+    const c = constraints || {};
+    if (Array.isArray(c.options) && c.options.length > 0) {
+      const allowedValues = c.options.map(
+        (opt) => typeof opt === "string" ? opt : opt && typeof opt === "object" ? opt.value : ""
+      );
+      if (value !== "" && !allowedValues.includes(value)) {
+        errors.push({
+          path: "",
+          message: `Value '${value}' is not in allowed options: [${allowedValues.map((v) => JSON.stringify(v)).join(", ")}]`,
+          keyword: "enum"
+        });
+      }
+    }
+    if (errors.length === 0) {
+      return { valid: true };
+    }
+    return { valid: false, errors };
+  }
+};
+
+// src/types/streamVideo.ts
+var ALLOWED_KEYS = /* @__PURE__ */ new Set(["uid", "durationMs", "thumbnail", "ready"]);
+var FORBIDDEN_KEYS3 = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var STREAM_UID_REGEX = /^[0-9a-f]{32}$/;
+var streamVideoType = {
+  id: "media.streamVideo",
+  aliases: ["streamVideo"],
+  defaultValue: null,
+  renderHint: { tag: "video" },
+  constraintsSchema: {
+    type: "object",
+    properties: {
+      maxDurationSeconds: { type: "integer", minimum: 0 },
+      allowedThumbnailHosts: {
+        type: "array",
+        items: { type: "string" }
+      }
+    },
+    additionalProperties: false
+  },
+  validate(value, constraints) {
+    const errors = [];
+    const c = constraints || {};
+    if (value === null || value === void 0 || value === "") {
+      return { valid: true };
+    }
+    if (typeof value !== "object" || Array.isArray(value)) {
+      return {
+        valid: false,
+        errors: [
+          {
+            path: "",
+            message: `Expected streamVideo object or null, got ${typeof value}`,
+            keyword: "type"
+          }
+        ]
+      };
+    }
+    const obj = value;
+    for (const key of Object.keys(obj)) {
+      if (FORBIDDEN_KEYS3.has(key) || !ALLOWED_KEYS.has(key)) {
+        errors.push({
+          path: key,
+          message: `Unknown or forbidden property '${key}' in streamVideo object`,
+          keyword: "additional_properties"
+        });
+      }
+    }
+    if (typeof obj.uid !== "string" || !STREAM_UID_REGEX.test(obj.uid.trim())) {
+      errors.push({
+        path: "uid",
+        message: "streamVideo uid is required and must be a 32-character hexadecimal string",
+        keyword: "pattern"
+      });
+    }
+    if (obj.durationMs !== void 0 && obj.durationMs !== null) {
+      if (typeof obj.durationMs !== "number" || Number.isNaN(obj.durationMs) || obj.durationMs < 0) {
+        errors.push({
+          path: "durationMs",
+          message: "durationMs must be a non-negative number",
+          keyword: "type"
+        });
+      } else if (c.maxDurationSeconds !== void 0 && obj.durationMs > c.maxDurationSeconds * 1e3) {
+        errors.push({
+          path: "durationMs",
+          message: `Video duration (${Math.round(obj.durationMs / 1e3)}s) exceeds max duration of ${c.maxDurationSeconds}s`,
+          keyword: "max_duration"
+        });
+      }
+    }
+    if (obj.thumbnail !== void 0 && obj.thumbnail !== null && obj.thumbnail !== "") {
+      if (typeof obj.thumbnail !== "string") {
+        errors.push({
+          path: "thumbnail",
+          message: "thumbnail must be a string URL",
+          keyword: "type"
+        });
+      } else if (!isSafeMediaSrc(obj.thumbnail, c.allowedThumbnailHosts)) {
+        errors.push({
+          path: "thumbnail",
+          message: `Thumbnail '${obj.thumbnail}' is not a valid or safe media URL`,
+          keyword: "thumbnail_invalid"
+        });
+      }
+    }
+    if (obj.ready !== void 0 && obj.ready !== null) {
+      if (typeof obj.ready !== "boolean") {
+        errors.push({
+          path: "ready",
+          message: "ready must be a boolean",
+          keyword: "type"
+        });
+      }
+    }
+    if (errors.length === 0) {
+      return { valid: true };
+    }
+    return { valid: false, errors };
+  }
+};
+
+// src/types/text.ts
+var textType = {
+  id: "text",
+  defaultValue: "",
+  constraintsSchema: {
+    type: "object",
+    properties: {
+      minLength: { type: "integer", minimum: 0 },
+      maxLength: { type: "integer", minimum: 0 },
+      pattern: { type: "string" }
+    },
+    additionalProperties: false
+  },
+  validate(value, constraints) {
+    const errors = [];
+    if (typeof value !== "string") {
+      return {
+        valid: false,
+        errors: [
+          {
+            path: "",
+            message: `Expected string, got ${typeof value}`,
+            keyword: "type"
+          }
+        ]
+      };
+    }
+    const c = constraints || {};
+    if (typeof c.minLength === "number" && value.length < c.minLength) {
+      errors.push({
+        path: "",
+        message: `String length ${value.length} is less than minimum ${c.minLength}`,
+        keyword: "minLength"
+      });
+    }
+    if (typeof c.maxLength === "number" && value.length > c.maxLength) {
+      errors.push({
+        path: "",
+        message: `String length ${value.length} exceeds maximum ${c.maxLength}`,
+        keyword: "maxLength"
+      });
+    }
+    if (typeof c.pattern === "string") {
+      try {
+        const regex = new RegExp(c.pattern);
+        if (!regex.test(value)) {
+          errors.push({
+            path: "",
+            message: `String does not match required pattern ${c.pattern}`,
+            keyword: "pattern"
+          });
+        }
+      } catch (_e) {
+        errors.push({
+          path: "",
+          message: `Invalid regex pattern in constraints: ${c.pattern}`,
+          keyword: "pattern_invalid"
+        });
+      }
+    }
+    if (errors.length === 0) {
+      return { valid: true };
+    }
+    return { valid: false, errors };
+  }
+};
+
+// src/types/toggle.ts
+var toggleType = {
+  id: "toggle",
+  defaultValue: false,
+  constraintsSchema: {
+    type: "object",
+    properties: {},
+    additionalProperties: false
+  },
+  validate(value) {
+    if (typeof value !== "boolean") {
+      return {
+        valid: false,
+        errors: [
+          {
+            path: "",
+            message: `Expected boolean, got ${typeof value}`,
+            keyword: "type"
+          }
+        ]
+      };
+    }
+    return { valid: true };
+  }
+};
+
+// src/types/video.ts
+var videoType = {
+  id: "video",
+  aliases: ["vid"],
+  defaultValue: null,
+  renderHint: { tag: "video" },
+  constraintsSchema: {
+    type: "object",
+    properties: {
+      maxSizeBytes: { type: "integer", minimum: 0 },
+      allowedMimeTypes: {
+        type: "array",
+        items: { type: "string" }
+      }
+    },
+    additionalProperties: false
+  },
+  validate(value) {
+    const errors = [];
+    if (value === null || value === void 0 || value === "") {
+      return { valid: true };
+    }
+    if (typeof value === "string") {
+      return { valid: true };
+    }
+    if (typeof value === "object" && value !== null) {
+      const obj = value;
+      if (obj.kind === "asset" && typeof obj.id === "string" && obj.id.trim()) {
+        return { valid: true };
+      }
+      if (obj.kind === "url" && typeof obj.src === "string" && obj.src.trim()) {
+        return { valid: true };
+      }
+      if (typeof obj.id === "string" || typeof obj.url === "string") {
+        return { valid: true };
+      }
+      errors.push({
+        path: "",
+        message: "Video object must contain an id, url, or valid kind (asset/url)",
+        keyword: "video_structure"
+      });
+      return { valid: false, errors };
+    }
+    return {
+      valid: false,
+      errors: [
+        {
+          path: "",
+          message: `Expected video reference (UUID string, URL, or asset object), got ${typeof value}`,
+          keyword: "type"
+        }
+      ]
+    };
+  }
+};
+
+// src/types/videoList.ts
+var ALLOWED_ITEM_KEYS = /* @__PURE__ */ new Set(["src", "poster", "caption", "href"]);
+var FORBIDDEN_KEYS4 = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var videoListType = {
+  id: "media.videoList",
+  aliases: ["videoList"],
+  defaultValue: [],
+  constraintsSchema: {
+    type: "object",
+    properties: {
+      maxItems: { type: "integer", minimum: 0, default: 24 },
+      allowedSrcHosts: {
+        type: "array",
+        items: { type: "string" }
+      },
+      allowedHrefHosts: {
+        type: "array",
+        items: { type: "string" }
+      },
+      maxCaptionLength: { type: "integer", minimum: 0, default: 300 }
+    },
+    additionalProperties: false
+  },
+  validate(value, constraints) {
+    const errors = [];
+    const c = constraints || {};
+    const maxItems = typeof c.maxItems === "number" ? c.maxItems : 24;
+    const maxCaptionLength = typeof c.maxCaptionLength === "number" ? c.maxCaptionLength : 300;
+    if (value === null || value === void 0) {
+      return { valid: true };
+    }
+    if (!Array.isArray(value)) {
+      return {
+        valid: false,
+        errors: [
+          {
+            path: "",
+            message: `Expected array for videoList, got ${typeof value}`,
+            keyword: "type"
+          }
+        ]
+      };
+    }
+    if (value.length > maxItems) {
+      errors.push({
+        path: "",
+        message: `Video list exceeds maximum item count of ${maxItems} (got ${value.length})`,
+        keyword: "max_items"
+      });
+    }
+    for (let i = 0; i < value.length; i++) {
+      const item = value[i];
+      const itemPath = `videos[${i}]`;
+      if (!item || typeof item !== "object" || Array.isArray(item)) {
+        errors.push({
+          path: itemPath,
+          message: `Expected video item object, got ${item === null ? "null" : Array.isArray(item) ? "array" : typeof item}`,
+          keyword: "type"
+        });
+        continue;
+      }
+      const record = item;
+      for (const k of Object.keys(record)) {
+        if (FORBIDDEN_KEYS4.has(k) || !ALLOWED_ITEM_KEYS.has(k)) {
+          errors.push({
+            path: `${itemPath}.${k}`,
+            message: `Unknown or forbidden property '${k}' in video item`,
+            keyword: "additional_properties"
+          });
+        }
+      }
+      if (typeof record.src === "string") {
+        if (!record.src.trim()) {
+          errors.push({
+            path: `${itemPath}.src`,
+            message: "Video src is required and must be a non-empty string",
+            keyword: "required"
+          });
+        } else if (!isSafeMediaSrc(record.src, c.allowedSrcHosts)) {
+          errors.push({
+            path: `${itemPath}.src`,
+            message: `Video src '${record.src}' is not a valid or safe media URL/reference`,
+            keyword: "video_src_invalid"
+          });
+        }
+      } else if (typeof record.src === "object" && record.src !== null) {
+        const srcObj = record.src;
+        if (srcObj.kind === "asset") {
+          if (typeof srcObj.id !== "string" || !srcObj.id.trim()) {
+            errors.push({
+              path: `${itemPath}.src`,
+              message: "Video asset reference must include a valid id",
+              keyword: "required"
+            });
+          }
+        } else if (srcObj.kind === "url") {
+          if (typeof srcObj.src !== "string" || !srcObj.src.trim()) {
+            errors.push({
+              path: `${itemPath}.src`,
+              message: "Video url reference must include a valid src",
+              keyword: "required"
+            });
+          } else if (!isSafeMediaSrc(srcObj.src, c.allowedSrcHosts)) {
+            errors.push({
+              path: `${itemPath}.src`,
+              message: `Video src '${srcObj.src}' is not a valid or safe media URL/reference`,
+              keyword: "video_src_invalid"
+            });
+          }
+        } else {
+          errors.push({
+            path: `${itemPath}.src`,
+            message: 'Video src object must have kind "asset" or "url"',
+            keyword: "type"
+          });
+        }
+      } else {
+        errors.push({
+          path: `${itemPath}.src`,
+          message: "Video src is required and must be a string or media reference object",
+          keyword: "required"
+        });
+      }
+      if (record.poster !== void 0 && record.poster !== null && record.poster !== "") {
+        if (typeof record.poster === "string") {
+          if (!isSafeMediaSrc(record.poster, c.allowedSrcHosts)) {
+            errors.push({
+              path: `${itemPath}.poster`,
+              message: `Video poster '${record.poster}' is not a valid or safe media URL/reference`,
+              keyword: "video_poster_invalid"
+            });
+          }
+        } else if (typeof record.poster === "object" && record.poster !== null) {
+          const posterObj = record.poster;
+          if (posterObj.kind === "asset") {
+            if (typeof posterObj.id !== "string" || !posterObj.id.trim()) {
+              errors.push({
+                path: `${itemPath}.poster`,
+                message: "Poster asset reference must include a valid id",
+                keyword: "required"
+              });
+            }
+          } else if (posterObj.kind === "url") {
+            if (typeof posterObj.src !== "string" || !posterObj.src.trim()) {
+              errors.push({
+                path: `${itemPath}.poster`,
+                message: "Poster url reference must include a valid src",
+                keyword: "required"
+              });
+            } else if (!isSafeMediaSrc(posterObj.src, c.allowedSrcHosts)) {
+              errors.push({
+                path: `${itemPath}.poster`,
+                message: `Video poster '${posterObj.src}' is not a valid or safe media URL/reference`,
+                keyword: "video_poster_invalid"
+              });
+            }
+          } else {
+            errors.push({
+              path: `${itemPath}.poster`,
+              message: 'Video poster object must have kind "asset" or "url"',
+              keyword: "type"
+            });
+          }
+        } else {
+          errors.push({
+            path: `${itemPath}.poster`,
+            message: "Video poster must be a string or media reference object",
+            keyword: "type"
+          });
+        }
+      }
+      if (record.href !== void 0 && record.href !== null && record.href !== "") {
+        if (typeof record.href !== "string") {
+          errors.push({
+            path: `${itemPath}.href`,
+            message: "Video href must be a string",
+            keyword: "type"
+          });
+        } else if (!isSafeActionHref(record.href, c.allowedHrefHosts)) {
+          errors.push({
+            path: `${itemPath}.href`,
+            message: `Video href '${record.href}' is not allowed or invalid`,
+            keyword: "video_href_not_allowed"
+          });
+        }
+      }
+      if (record.caption !== void 0 && record.caption !== null) {
+        if (typeof record.caption !== "string") {
+          errors.push({
+            path: `${itemPath}.caption`,
+            message: "Video caption must be a string",
+            keyword: "type"
+          });
+        } else if (record.caption.length > maxCaptionLength) {
+          errors.push({
+            path: `${itemPath}.caption`,
+            message: `Video caption length (${record.caption.length}) exceeds maximum ${maxCaptionLength}`,
+            keyword: "max_length"
+          });
+        }
+      }
+    }
+    if (errors.length === 0) {
+      return { valid: true };
+    }
+    return { valid: false, errors };
+  }
+};
+
+// src/index.ts
+function registerBaseTypes() {
+  registerFieldType(textType);
+  registerFieldType(numberType);
+  registerFieldType(toggleType);
+  registerFieldType(selectType);
+  registerFieldType(imageType);
+  registerFieldType(richtextType);
+  registerFieldType(videoType);
+  registerFieldType(videoListType);
+  registerFieldType(geoAreaType);
+  registerFieldType(addressType);
+  registerFieldType(addressListType);
+  registerFieldType(streamVideoType);
+}
+registerBaseTypes();
+
+export { DEFAULT_ALLOWED_MARKS, DEFAULT_ALLOWED_NODES, addressListType, addressType, fieldTypeAliases, geoAreaType, getFieldType, hasFieldType, imageType, isSafeActionHref, isSafeMediaSrc, isSafeRelativeOrAnchor, isValidLinkHref, listFieldTypeIds, listFieldTypes, normalizeFieldValue, normalizeGeoArea, numberType, registerBaseTypes, registerFieldType, resetRegistry, resolveTypeAlias, richtextType, selectType, streamVideoType, stripUrlControlChars, textType, toggleType, unknownTypeIds, validateFieldValue, validateProseMirrorDoc, videoListType, videoType };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map