@playdrop/playdrop-cli 0.17.5 → 0.17.14

package/node_modules/@playdrop/procedural/dist/index.js

@@ -0,0 +1,763 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dist_exports = {};
+__export(dist_exports, {
+  PLAYDROP_PROCEDURAL_MANIFEST_PROTOCOL: () => PLAYDROP_PROCEDURAL_MANIFEST_PROTOCOL,
+  PLAYDROP_PROCEDURAL_PACK_PROTOCOL: () => PLAYDROP_PROCEDURAL_PACK_PROTOCOL,
+  PLAYDROP_PROCEDURAL_PROTOCOL: () => PLAYDROP_PROCEDURAL_PROTOCOL,
+  PROCEDURAL_PARAMETER_ICON_IDS: () => PROCEDURAL_PARAMETER_ICON_IDS,
+  requireResolvedAssetParameter: () => requireResolvedAssetParameter,
+  validateCompleteProceduralParameters: () => validateCompleteProceduralParameters,
+  validateProceduralManifest: () => validateProceduralManifest,
+  validateProceduralModule: () => validateProceduralModule,
+  validateProceduralParameters: () => validateProceduralParameters,
+  validateResolvedAssetParameter: () => validateResolvedAssetParameter
+});
+module.exports = __toCommonJS(dist_exports);
+const PLAYDROP_PROCEDURAL_PROTOCOL = "playdrop-procedural@1";
+const PLAYDROP_PROCEDURAL_PACK_PROTOCOL = "playdrop-procedural-pack@1";
+const PLAYDROP_PROCEDURAL_MANIFEST_PROTOCOL = "playdrop-procedural-manifest@1";
+const PROCEDURAL_PARAMETER_ICON_IDS = [
+  "adjust",
+  "asset",
+  "angle",
+  "color",
+  "count",
+  "depth",
+  "height",
+  "length",
+  "light",
+  "material",
+  "radius",
+  "scale",
+  "size",
+  "toggle",
+  "variation",
+  "visibility",
+  "width"
+];
+const SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const CAPABILITY_ID_PATTERN = /^[A-Za-z][A-Za-z0-9._-]*$/;
+const EXACT_ASSET_REF_PATTERN = /^asset:[a-z0-9]+(?:-[a-z0-9]+)*\/[a-z0-9]+(?:-[a-z0-9]+)*@r[1-9][0-9]*$/;
+const COLOR_PATTERN = /^#[0-9a-f]{6}$/i;
+const SAFE_RELATIVE_PATH_PATTERN = /^(?!\/)(?!.*\\)(?!.*(?:^|\/)\.\.(?:\/|$))[^\0]+$/;
+const ASSET_SPEC_FAMILY_PATTERN = /^asset-spec:[a-z0-9]+(?:-[a-z0-9]+)*\/[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const PARAMETER_ICON_IDS = new Set(PROCEDURAL_PARAMETER_ICON_IDS);
+const PARAMETER_AFFECTS = /* @__PURE__ */ new Set(["geometry", "material", "animation"]);
+const PARAMETER_CONTROLS = /* @__PURE__ */ new Set([
+  "auto",
+  "slider",
+  "stepper",
+  "toggle",
+  "select",
+  "segmented",
+  "color",
+  "palette",
+  "asset"
+]);
+const PARAMETER_CONTROLS_BY_TYPE = {
+  number: /* @__PURE__ */ new Set(["auto", "slider", "stepper"]),
+  boolean: /* @__PURE__ */ new Set(["auto", "toggle"]),
+  color: /* @__PURE__ */ new Set(["auto", "color"]),
+  select: /* @__PURE__ */ new Set(["auto", "select", "segmented", "palette"]),
+  asset: /* @__PURE__ */ new Set(["auto", "asset"])
+};
+const ASSET_CATEGORIES = /* @__PURE__ */ new Set(["IMAGE", "VIDEO", "AUDIO", "SPRITESHEET", "MODEL_3D", "CUSTOM"]);
+const PRESENTATION_SCENE_PRESETS = /* @__PURE__ */ new Set(["studio", "light", "dark", "outdoor"]);
+const PRESENTATION_CAMERA_VIEWS = /* @__PURE__ */ new Set(["perspective", "front", "side", "top"]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function finitePositive(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function validateUniqueStrings(value, label, errors) {
+  if (!Array.isArray(value)) {
+    errors.push(`${label} must be an array`);
+    return [];
+  }
+  const strings = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of value) {
+    if (!nonEmptyString(item)) {
+      errors.push(`${label} entries must be non-empty strings`);
+      continue;
+    }
+    if (seen.has(item))
+      errors.push(`${label} entries must be unique: ${item}`);
+    else {
+      seen.add(item);
+      strings.push(item);
+    }
+  }
+  return strings;
+}
+function selectOptionValue(option) {
+  return typeof option === "string" ? option : option.value;
+}
+function validateSelectOptions(value, label, errors) {
+  if (!Array.isArray(value)) {
+    errors.push(`${label} must be an array`);
+    return [];
+  }
+  const values = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const option of value) {
+    let optionValue;
+    if (typeof option === "string") {
+      optionValue = option;
+    } else if (isRecord(option)) {
+      optionValue = option.value;
+      if (!nonEmptyString(option.label))
+        errors.push(`${label} entries must have a label`);
+      if (option.swatches !== void 0) {
+        const swatches = validateUniqueStrings(option.swatches, `${label} swatches`, errors);
+        if (swatches.length === 0 || swatches.length > 4) {
+          errors.push(`${label} swatches must contain between one and four colors`);
+        }
+        for (const swatch of swatches) {
+          if (!COLOR_PATTERN.test(swatch))
+            errors.push(`${label} swatches must be six-digit hex colors`);
+        }
+      }
+    } else {
+      errors.push(`${label} entries must be strings or option objects`);
+      continue;
+    }
+    if (!nonEmptyString(optionValue)) {
+      errors.push(`${label} entries must have a non-empty value`);
+      continue;
+    }
+    if (seen.has(optionValue))
+      errors.push(`${label} entries must be unique: ${optionValue}`);
+    else {
+      seen.add(optionValue);
+      values.push(optionValue);
+    }
+  }
+  return values;
+}
+function validateParameterPresentation(id, type, value, errors) {
+  if (value === void 0)
+    return;
+  if (!isRecord(value)) {
+    errors.push(`Parameter ${id} presentation must be an object`);
+    return;
+  }
+  if (value.icon !== void 0 && (typeof value.icon !== "string" || !PARAMETER_ICON_IDS.has(value.icon))) {
+    errors.push(`Parameter ${id} presentation.icon is unsupported`);
+  }
+  if (value.control !== void 0) {
+    if (typeof value.control !== "string" || !PARAMETER_CONTROLS.has(value.control)) {
+      errors.push(`Parameter ${id} presentation.control is unsupported`);
+    } else if (!PARAMETER_CONTROLS_BY_TYPE[type].has(value.control)) {
+      errors.push(`Parameter ${id} presentation.control does not match ${type}`);
+    }
+  }
+  if (value.unit !== void 0 && !nonEmptyString(value.unit)) {
+    errors.push(`Parameter ${id} presentation.unit must be a non-empty string`);
+  }
+  if (value.precision !== void 0 && (!Number.isInteger(value.precision) || Number(value.precision) < 0 || Number(value.precision) > 6)) {
+    errors.push(`Parameter ${id} presentation.precision must be an integer from 0 to 6`);
+  }
+  if (value.order !== void 0 && (typeof value.order !== "number" || !Number.isFinite(value.order))) {
+    errors.push(`Parameter ${id} presentation.order must be finite`);
+  }
+}
+function validateParameterDefinitions(value, errors) {
+  if (!isRecord(value)) {
+    errors.push("parameters must be an object");
+    return {};
+  }
+  const definitions = {};
+  for (const [id, candidate] of Object.entries(value)) {
+    if (!CAPABILITY_ID_PATTERN.test(id))
+      errors.push(`Parameter id is invalid: ${id}`);
+    if (!isRecord(candidate)) {
+      errors.push(`Parameter ${id} must be an object`);
+      continue;
+    }
+    if (!nonEmptyString(candidate.label))
+      errors.push(`Parameter ${id} must have a label`);
+    if (candidate.description !== void 0 && !nonEmptyString(candidate.description)) {
+      errors.push(`Parameter ${id} description must be a non-empty string`);
+    }
+    if (candidate.group !== void 0 && !nonEmptyString(candidate.group)) {
+      errors.push(`Parameter ${id} group must be a non-empty string`);
+    }
+    if (candidate.affects !== void 0 && (typeof candidate.affects !== "string" || !PARAMETER_AFFECTS.has(candidate.affects))) {
+      errors.push(`Parameter ${id} affects is unsupported`);
+    }
+    if (candidate.type === "number") {
+      validateParameterPresentation(id, "number", candidate.presentation, errors);
+      if (typeof candidate.min !== "number" || !Number.isFinite(candidate.min))
+        errors.push(`Parameter ${id} min must be finite`);
+      if (typeof candidate.max !== "number" || !Number.isFinite(candidate.max))
+        errors.push(`Parameter ${id} max must be finite`);
+      if (!finitePositive(candidate.step))
+        errors.push(`Parameter ${id} step must be greater than zero`);
+      if (typeof candidate.min === "number" && Number.isFinite(candidate.min) && typeof candidate.max === "number" && Number.isFinite(candidate.max) && candidate.min > candidate.max)
+        errors.push(`Parameter ${id} min must not exceed max`);
+    } else if (candidate.type === "select") {
+      validateParameterPresentation(id, "select", candidate.presentation, errors);
+      const options = validateSelectOptions(candidate.options, `Parameter ${id} options`, errors);
+      if (options.length === 0)
+        errors.push(`Parameter ${id} must have at least one option`);
+    } else if (candidate.type === "boolean") {
+      validateParameterPresentation(id, "boolean", candidate.presentation, errors);
+    } else if (candidate.type === "color") {
+      validateParameterPresentation(id, "color", candidate.presentation, errors);
+    } else if (candidate.type === "asset") {
+      validateParameterPresentation(id, "asset", candidate.presentation, errors);
+      if (candidate.default !== null && (typeof candidate.default !== "string" || !EXACT_ASSET_REF_PATTERN.test(candidate.default))) {
+        errors.push(`Parameter ${id} default must be null or an exact asset revision ref`);
+      }
+      if (candidate.required !== void 0 && typeof candidate.required !== "boolean") {
+        errors.push(`Parameter ${id} required must be a boolean`);
+      }
+      if (!isRecord(candidate.accepts)) {
+        errors.push(`Parameter ${id} accepts must be an object`);
+      } else {
+        const accepts = candidate.accepts;
+        validateKnownKeys(accepts, /* @__PURE__ */ new Set(["category", "subcategory", "formats", "assetSpec"]), `Parameter ${id} accepts`, errors);
+        if (accepts.category !== void 0 && (typeof accepts.category !== "string" || !ASSET_CATEGORIES.has(accepts.category))) {
+          errors.push(`Parameter ${id} accepts.category is unsupported`);
+        }
+        if (accepts.subcategory !== void 0 && (typeof accepts.subcategory !== "string" || !SLUG_PATTERN.test(accepts.subcategory))) {
+          errors.push(`Parameter ${id} accepts.subcategory must be a slug`);
+        }
+        if (accepts.formats !== void 0) {
+          const formats = validateUniqueStrings(accepts.formats, `Parameter ${id} accepts.formats`, errors);
+          for (const format of formats) {
+            if (!/^[A-Z0-9_]+$/.test(format))
+              errors.push(`Parameter ${id} accepts.formats entries must be uppercase format ids`);
+          }
+        }
+        if (accepts.assetSpec !== void 0 && (typeof accepts.assetSpec !== "string" || !ASSET_SPEC_FAMILY_PATTERN.test(accepts.assetSpec))) {
+          errors.push(`Parameter ${id} accepts.assetSpec must be an asset spec family ref`);
+        }
+        if (Object.keys(accepts).length === 0)
+          errors.push(`Parameter ${id} accepts must declare a compatibility filter`);
+      }
+    } else {
+      errors.push(`Parameter ${id} has an unsupported type`);
+    }
+    definitions[id] = candidate;
+  }
+  return definitions;
+}
+function validateDefinitions(value, label, errors, validate) {
+  if (!Array.isArray(value)) {
+    errors.push(`${label} must be an array`);
+    return [];
+  }
+  const result = [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const item of value) {
+    if (!isRecord(item) || !nonEmptyString(item.id)) {
+      errors.push(`${label} entries must have a non-empty id`);
+      continue;
+    }
+    if (!CAPABILITY_ID_PATTERN.test(item.id))
+      errors.push(`${label} id is invalid: ${item.id}`);
+    if (ids.has(item.id))
+      errors.push(`${label} ids must be unique: ${item.id}`);
+    else
+      ids.add(item.id);
+    validate(item, item.id);
+    result.push(item);
+  }
+  return result;
+}
+function parameterError(id, definition, value) {
+  if (definition.type === "number") {
+    if (typeof value !== "number" || !Number.isFinite(value))
+      return `${id} must be a finite number`;
+    if (value < definition.min || value > definition.max)
+      return `${id} must be between ${definition.min} and ${definition.max}`;
+    return null;
+  }
+  if (definition.type === "boolean")
+    return typeof value === "boolean" ? null : `${id} must be a boolean`;
+  if (definition.type === "color")
+    return typeof value === "string" && COLOR_PATTERN.test(value) ? null : `${id} must be a six-digit hex color`;
+  if (definition.type === "select" && Array.isArray(definition.options)) {
+    const optionValues = definition.options.map(selectOptionValue);
+    return typeof value === "string" && optionValues.includes(value) ? null : `${id} must be one of ${optionValues.join(", ")}`;
+  }
+  if (definition.type === "asset") {
+    if (value === null && !definition.required)
+      return null;
+    return typeof value === "string" && EXACT_ASSET_REF_PATTERN.test(value) ? null : `${id} must be an exact asset revision ref`;
+  }
+  return `${id} has an invalid definition`;
+}
+function validateProceduralParameters(definitions, values) {
+  const errors = [];
+  if (!isRecord(definitions))
+    return { valid: false, errors: ["parameters must be an object"] };
+  if (!isRecord(values))
+    return { valid: false, errors: ["parameter values must be an object"] };
+  for (const [id, value] of Object.entries(values)) {
+    const definition = definitions[id];
+    if (!isRecord(definition)) {
+      errors.push(`Unknown parameter: ${id}`);
+      continue;
+    }
+    const error = parameterError(id, definition, value);
+    if (error)
+      errors.push(error);
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateCompleteProceduralParameters(definitions, values) {
+  const validation = validateProceduralParameters(definitions, values);
+  const errors = [...validation.errors];
+  if (!isRecord(definitions) || !isRecord(values))
+    return validation;
+  for (const [id, definition] of Object.entries(definitions)) {
+    if (isRecord(definition) && definition.type === "asset" && definition.required === true && !(id in values)) {
+      errors.push(`${id} must be an exact asset revision ref`);
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function assetSpecFamily(reference) {
+  const versionIndex = reference.indexOf("@");
+  return versionIndex >= 0 ? reference.slice(0, versionIndex) : reference;
+}
+function validateResolvedAssetParameter(definition, asset) {
+  const errors = [];
+  const accepts = definition.accepts;
+  if (!EXACT_ASSET_REF_PATTERN.test(asset.reference))
+    errors.push("Resolved asset reference must be exact");
+  if (accepts.category && asset.category !== accepts.category)
+    errors.push(`Resolved asset category must be ${accepts.category}`);
+  if (accepts.subcategory && asset.subcategory !== accepts.subcategory) {
+    errors.push(`Resolved asset subcategory must be ${accepts.subcategory}`);
+  }
+  if (accepts.formats && !accepts.formats.includes(asset.format)) {
+    errors.push(`Resolved asset format must be one of ${accepts.formats.join(", ")}`);
+  }
+  if (accepts.assetSpec && (!asset.assetSpec || assetSpecFamily(asset.assetSpec) !== accepts.assetSpec)) {
+    errors.push(`Resolved asset must use ${accepts.assetSpec}`);
+  }
+  if (!nonEmptyString(asset.primary?.url))
+    errors.push("Resolved asset primary URL is required");
+  return { valid: errors.length === 0, errors };
+}
+function requireResolvedAssetParameter(context, id, definition) {
+  const reference = context.parameters?.[id];
+  const valueError = parameterError(id, definition, reference);
+  if (valueError)
+    throw new Error(valueError);
+  if (typeof reference !== "string")
+    throw new Error(`${id} must be selected`);
+  const asset = context.resolveAsset?.(reference) ?? null;
+  if (!asset)
+    throw new Error(`Asset parameter ${id} was not resolved: ${reference}`);
+  if (asset.reference !== reference)
+    throw new Error(`Resolved asset reference mismatch for ${id}`);
+  const validation = validateResolvedAssetParameter(definition, asset);
+  if (!validation.valid)
+    throw new Error(`Asset parameter ${id} is incompatible: ${validation.errors.join("; ")}`);
+  return asset;
+}
+function validateKnownKeys(value, allowed, label, errors) {
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key))
+      errors.push(`${label}.${key} is unsupported`);
+  }
+}
+function validateProceduralPresentation(value, parameters, animations, errors) {
+  if (value === void 0)
+    return;
+  if (!isRecord(value)) {
+    errors.push("presentation must be an object");
+    return;
+  }
+  validateKnownKeys(value, /* @__PURE__ */ new Set(["parameters", "animation", "scene", "camera"]), "presentation", errors);
+  if (Object.keys(value).length === 0)
+    errors.push("presentation must not be empty");
+  if (value.parameters !== void 0) {
+    const result = validateProceduralParameters(parameters, value.parameters);
+    errors.push(...result.errors.map((error) => `presentation.parameters: ${error}`));
+  }
+  if (value.animation !== void 0) {
+    if (!isRecord(value.animation))
+      errors.push("presentation.animation must be an object");
+    else {
+      const animationRecipe = value.animation;
+      validateKnownKeys(animationRecipe, /* @__PURE__ */ new Set(["id", "time"]), "presentation.animation", errors);
+      const animation = animations.find((candidate) => candidate.id === animationRecipe.id);
+      if (!animation)
+        errors.push("presentation.animation.id must match a declared animation");
+      if (typeof animationRecipe.time !== "number" || !Number.isFinite(animationRecipe.time) || animationRecipe.time < 0) {
+        errors.push("presentation.animation.time must be a finite number at or above zero");
+      } else if (animation && animationRecipe.time > animation.duration) {
+        errors.push("presentation.animation.time must not exceed the animation duration");
+      }
+    }
+  }
+  if (value.scene !== void 0 && (typeof value.scene !== "string" || !PRESENTATION_SCENE_PRESETS.has(value.scene))) {
+    errors.push("presentation.scene is unsupported");
+  }
+  if (value.camera !== void 0) {
+    if (!isRecord(value.camera))
+      errors.push("presentation.camera must be an object");
+    else {
+      validateKnownKeys(value.camera, /* @__PURE__ */ new Set(["view", "azimuth", "elevation", "padding"]), "presentation.camera", errors);
+      const view = value.camera.view;
+      if (view !== void 0 && (typeof view !== "string" || !PRESENTATION_CAMERA_VIEWS.has(view))) {
+        errors.push("presentation.camera.view is unsupported");
+      }
+      if (value.camera.azimuth !== void 0 && (typeof value.camera.azimuth !== "number" || !Number.isFinite(value.camera.azimuth) || value.camera.azimuth < -180 || value.camera.azimuth > 180)) {
+        errors.push("presentation.camera.azimuth must be between -180 and 180 degrees");
+      }
+      if (value.camera.elevation !== void 0 && (typeof value.camera.elevation !== "number" || !Number.isFinite(value.camera.elevation) || value.camera.elevation < -80 || value.camera.elevation > 80)) {
+        errors.push("presentation.camera.elevation must be between -80 and 80 degrees");
+      }
+      if (value.camera.padding !== void 0 && (typeof value.camera.padding !== "number" || !Number.isFinite(value.camera.padding) || value.camera.padding < 1 || value.camera.padding > 3)) {
+        errors.push("presentation.camera.padding must be between 1 and 3");
+      }
+      if (view !== void 0 && view !== "perspective" && (value.camera.azimuth !== void 0 || value.camera.elevation !== void 0)) {
+        errors.push("presentation.camera angles require the perspective view");
+      }
+    }
+  }
+}
+function validateProceduralManifest(value) {
+  const errors = [];
+  if (!isRecord(value))
+    return { valid: false, errors: ["Manifest must be an object"] };
+  const manifest = value;
+  if (manifest.manifestProtocol !== PLAYDROP_PROCEDURAL_MANIFEST_PROTOCOL)
+    errors.push("Unsupported manifest protocol");
+  if (manifest.protocol !== PLAYDROP_PROCEDURAL_PROTOCOL)
+    errors.push("Unsupported procedural protocol");
+  if (typeof manifest.id !== "string" || !SLUG_PATTERN.test(manifest.id))
+    errors.push("Asset id must be a slug");
+  for (const field of ["title", "version", "summary"]) {
+    if (!nonEmptyString(manifest[field]))
+      errors.push(`${field} must be a non-empty string`);
+  }
+  if (!["model", "vfx", "character"].includes(manifest.kind))
+    errors.push("kind must be model, vfx, or character");
+  validateUniqueStrings(manifest.tags, "tags", errors);
+  if (!isRecord(manifest.pack))
+    errors.push("pack must be an object");
+  else {
+    if (!nonEmptyString(manifest.pack.id) || !SLUG_PATTERN.test(manifest.pack.id))
+      errors.push("pack.id must be a slug");
+    if (!nonEmptyString(manifest.pack.title))
+      errors.push("pack.title must be a non-empty string");
+    if (!nonEmptyString(manifest.pack.sourceProject))
+      errors.push("pack.sourceProject must be a non-empty string");
+  }
+  if (typeof manifest.sourceEntry !== "string" || !SAFE_RELATIVE_PATH_PATTERN.test(manifest.sourceEntry) || !manifest.sourceEntry.endsWith(".ts"))
+    errors.push("Source entry must be a safe relative TypeScript path");
+  if (typeof manifest.distFile !== "string" || !SAFE_RELATIVE_PATH_PATTERN.test(manifest.distFile) || !manifest.distFile.endsWith(".mjs"))
+    errors.push("Dist artifact must be a safe relative ES module path");
+  if (!isRecord(manifest.requirements) || manifest.requirements.renderer !== "webgl")
+    errors.push("Procedural v1 requires WebGL");
+  if (!isRecord(manifest.requirements) || manifest.requirements.three !== "0.183.2")
+    errors.push("Procedural v1 requires Three.js 0.183.2");
+  if (manifest.platformAssetRef !== null && (typeof manifest.platformAssetRef !== "string" || !EXACT_ASSET_REF_PATTERN.test(manifest.platformAssetRef))) {
+    errors.push("platformAssetRef must be null or an exact asset revision ref");
+  }
+  const parameters = validateParameterDefinitions(manifest.parameters, errors);
+  const defaults = Object.fromEntries(Object.entries(parameters).filter(([, definition]) => definition.type !== "asset" || definition.default !== null).map(([id, definition]) => [id, definition.default]));
+  errors.push(...validateProceduralParameters(parameters, defaults).errors);
+  if ("actions" in manifest) {
+    errors.push("actions are unsupported; use non-looping animations");
+  }
+  if ("states" in manifest) {
+    errors.push("states are unsupported; declare a select parameter");
+  }
+  const animations = validateDefinitions(manifest.animations, "animations", errors, (candidate, id) => {
+    if (!nonEmptyString(candidate.label))
+      errors.push(`Animation ${id} must have a label`);
+    if (!finitePositive(candidate.duration))
+      errors.push(`Animation ${id} duration must be greater than zero`);
+    if (typeof candidate.loop !== "boolean")
+      errors.push(`Animation ${id} loop must be a boolean`);
+  });
+  validateProceduralPresentation(manifest.presentation, parameters, animations, errors);
+  validateUniqueStrings(manifest.parts, "parts", errors);
+  validateUniqueStrings(manifest.sockets, "sockets", errors);
+  if (!isRecord(manifest.capabilities))
+    errors.push("capabilities must be an object");
+  else {
+    for (const key of ["controls", "selection", "timeline", "character"]) {
+      if (typeof manifest.capabilities[key] !== "boolean")
+        errors.push(`capabilities.${key} must be a boolean`);
+    }
+  }
+  if ("configuration" in manifest)
+    errors.push("configuration is unsupported; declare typed parameters instead");
+  if (manifest.character !== void 0) {
+    if (!isRecord(manifest.character))
+      errors.push("character must be an object");
+    else {
+      if (!nonEmptyString(manifest.character.rig))
+        errors.push("character.rig must be a non-empty string");
+      if (!nonEmptyString(manifest.character.skinProtocol))
+        errors.push("character.skinProtocol must be a non-empty string");
+      const templates = validateUniqueStrings(manifest.character.supportedTemplates, "character.supportedTemplates", errors);
+      if (templates.length === 0)
+        errors.push("character.supportedTemplates must not be empty");
+      if (!finitePositive(manifest.character.unitsPerMeter))
+        errors.push("character.unitsPerMeter must be greater than zero");
+      if (!Number.isInteger(manifest.character.boneCount) || Number(manifest.character.boneCount) <= 0) {
+        errors.push("character.boneCount must be a positive integer");
+      }
+    }
+  }
+  if (manifest.kind === "character" && !manifest.character)
+    errors.push("Character manifests must declare character metadata");
+  return { valid: errors.length === 0, errors };
+}
+function validateFiniteObjectHierarchy(object, errors, label = "object") {
+  object.updateMatrixWorld(true);
+  object.traverse((node) => {
+    const nodeLabel = node.name ? `${label}.${node.name}` : `${label}.${node.type}`;
+    const transformValues = [
+      node.position.x,
+      node.position.y,
+      node.position.z,
+      node.quaternion.x,
+      node.quaternion.y,
+      node.quaternion.z,
+      node.quaternion.w,
+      node.scale.x,
+      node.scale.y,
+      node.scale.z
+    ];
+    if (transformValues.some((entry) => !Number.isFinite(entry))) {
+      errors.push(`${nodeLabel} has a non-finite transform`);
+    }
+    const geometry = node.geometry;
+    if (!geometry?.attributes)
+      return;
+    for (const [attributeId, attribute] of Object.entries(geometry.attributes)) {
+      if (!attribute?.array)
+        continue;
+      for (let index = 0; index < attribute.array.length; index += 1) {
+        if (!Number.isFinite(attribute.array[index])) {
+          errors.push(`${nodeLabel} geometry.${attributeId} contains a non-finite value`);
+          break;
+        }
+      }
+    }
+    if (geometry.index?.array) {
+      for (let index = 0; index < geometry.index.array.length; index += 1) {
+        if (!Number.isFinite(geometry.index.array[index])) {
+          errors.push(`${nodeLabel} geometry.index contains a non-finite value`);
+          break;
+        }
+      }
+    }
+  });
+}
+function isDescendantOf(entry, root) {
+  let current = entry;
+  while (current) {
+    if (current === root)
+      return true;
+    current = current.parent;
+  }
+  return false;
+}
+function parameterValidationSamples(id, definition, context) {
+  if (definition.type === "number")
+    return [definition.default, definition.min, definition.max];
+  if (definition.type === "boolean")
+    return [definition.default, !definition.default];
+  if (definition.type === "color")
+    return [definition.default, "#000000", "#ffffff"];
+  if (definition.type === "select")
+    return definition.options.map(selectOptionValue);
+  if (definition.default !== null)
+    return [definition.default];
+  const supplied = context.parameters?.[id];
+  return supplied ? [supplied] : [];
+}
+function validateRuntimeControlValues(definitions, values) {
+  const validation = validateCompleteProceduralParameters(definitions, values);
+  const errors = [...validation.errors];
+  if (!isRecord(values))
+    return validation;
+  for (const id of Object.keys(definitions)) {
+    if (!(id in values))
+      errors.push(`controls.values() is missing ${id}`);
+  }
+  return { valid: errors.length === 0, errors };
+}
+function sameDeclaration(left, right) {
+  if (left === right)
+    return true;
+  if (Array.isArray(left) && Array.isArray(right)) {
+    return left.length === right.length && left.every((item, index) => sameDeclaration(item, right[index]));
+  }
+  if (!isRecord(left) || !isRecord(right))
+    return false;
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every((key) => key in right && sameDeclaration(left[key], right[key]));
+}
+function validateProceduralModule(value, context = {}, manifest) {
+  const errors = [];
+  if (!isRecord(value) || !isRecord(value.info) || typeof value.create !== "function") {
+    return { valid: false, errors: ["Module must expose info and create()"] };
+  }
+  const module2 = value;
+  if (module2.info.protocol !== PLAYDROP_PROCEDURAL_PROTOCOL)
+    errors.push("Unsupported procedural protocol");
+  if (!SLUG_PATTERN.test(module2.info.id))
+    errors.push("Asset id must be a slug");
+  if (!isRecord(module2.info.requirements) || module2.info.requirements.renderer !== "webgl")
+    errors.push("Procedural v1 requires WebGL");
+  if (!isRecord(module2.info.requirements) || module2.info.requirements.three !== "0.183.2")
+    errors.push("Procedural v1 requires Three.js 0.183.2");
+  if (manifest) {
+    for (const field of ["protocol", "id", "title", "version", "kind", "summary", "tags", "pack", "requirements", "presentation", "character"]) {
+      if (!sameDeclaration(module2.info[field], manifest[field]))
+        errors.push(`manifest.${field} does not match module.info.${field}`);
+    }
+  }
+  let instance;
+  try {
+    instance = module2.create(context);
+    if (manifest) {
+      const capabilities = instance.capabilities;
+      for (const name of ["controls", "selection", "timeline", "character"]) {
+        if (Boolean(capabilities?.[name]) !== manifest.capabilities[name])
+          errors.push(`manifest.capabilities.${name} does not match create().capabilities.${name}`);
+      }
+      if (!sameDeclaration(capabilities?.controls?.parameters ?? {}, manifest.parameters))
+        errors.push("manifest.parameters does not match controls.parameters");
+      if (!sameDeclaration(capabilities?.timeline?.animations ?? [], manifest.animations))
+        errors.push("manifest.animations does not match timeline.animations");
+      for (const name of ["parts", "sockets"]) {
+        const entries = capabilities?.selection?.[name] ?? {};
+        for (const id of manifest[name]) {
+          if (!(id in entries))
+            errors.push(`manifest.${name}.${id} is missing from selection.${name}`);
+        }
+      }
+    }
+    if (!instance.object?.isObject3D)
+      errors.push("create() must expose a THREE.Object3D");
+    else
+      validateFiniteObjectHierarchy(instance.object, errors);
+    const controls = instance.capabilities?.controls;
+    if (controls) {
+      const unsafeControls = controls;
+      if ("actions" in unsafeControls || "trigger" in unsafeControls) {
+        errors.push("actions are unsupported; use non-looping animations");
+      }
+      if ("states" in unsafeControls || "stateValues" in unsafeControls || "setState" in unsafeControls) {
+        errors.push("states are unsupported; declare a select parameter");
+      }
+      const definitions = validateParameterDefinitions(controls.parameters, errors);
+      const currentValues = controls.values();
+      errors.push(...validateRuntimeControlValues(definitions, currentValues).errors);
+      for (const [id, definition] of Object.entries(definitions)) {
+        for (const sample of parameterValidationSamples(id, definition, context)) {
+          try {
+            instance.reset?.();
+            controls.configure({ [id]: sample });
+            const configuredValues = controls.values();
+            errors.push(...validateRuntimeControlValues(definitions, configuredValues).errors);
+            if (configuredValues[id] !== sample)
+              errors.push(`configure(${id}) did not apply the requested value`);
+            validateFiniteObjectHierarchy(instance.object, errors, `configured.${id}`);
+          } catch (error) {
+            errors.push(`configure(${id}) failed: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
+      }
+    }
+    const selection = instance.capabilities?.selection;
+    if (selection) {
+      for (const [kind, entries] of [["parts", selection.parts], ["sockets", selection.sockets]]) {
+        for (const [id, entry] of Object.entries(entries)) {
+          if (!CAPABILITY_ID_PATTERN.test(id))
+            errors.push(`${kind} id is invalid: ${id}`);
+          if (!entry?.isObject3D)
+            errors.push(`${kind}.${id} must be a THREE.Object3D`);
+          else if (!isDescendantOf(entry, instance.object))
+            errors.push(`${kind}.${id} must belong to the asset object`);
+        }
+      }
+    }
+    const timeline = instance.capabilities?.timeline;
+    if (timeline) {
+      validateDefinitions(timeline.animations, "animations", errors, (candidate, id) => {
+        if (!nonEmptyString(candidate.label))
+          errors.push(`Animation ${id} must have a label`);
+        if (!finitePositive(candidate.duration))
+          errors.push(`Animation ${id} duration must be greater than zero`);
+        if (typeof candidate.loop !== "boolean")
+          errors.push(`Animation ${id} loop must be a boolean`);
+      });
+      for (const animation of timeline.animations) {
+        try {
+          timeline.play(animation.id);
+          for (const time of [0, animation.duration / 2, animation.duration]) {
+            timeline.seek(time);
+            validateFiniteObjectHierarchy(instance.object, errors, `animation.${animation.id}`);
+          }
+          timeline.pause();
+        } catch (error) {
+          errors.push(`Animation ${animation.id} failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+    }
+    instance.reset?.();
+    instance.update?.(1 / 60, 1 / 60);
+    if (instance.object?.isObject3D)
+      validateFiniteObjectHierarchy(instance.object, errors, "updated");
+  } catch (error) {
+    errors.push(error instanceof Error ? error.message : String(error));
+  } finally {
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      try {
+        instance?.dispose();
+      } catch (error) {
+        errors.push(`dispose() failed on call ${attempt + 1}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PLAYDROP_PROCEDURAL_MANIFEST_PROTOCOL,
+  PLAYDROP_PROCEDURAL_PACK_PROTOCOL,
+  PLAYDROP_PROCEDURAL_PROTOCOL,
+  PROCEDURAL_PARAMETER_ICON_IDS,
+  requireResolvedAssetParameter,
+  validateCompleteProceduralParameters,
+  validateProceduralManifest,
+  validateProceduralModule,
+  validateProceduralParameters,
+  validateResolvedAssetParameter
+});