@appinternalleads/ui 0.4.1 → 0.4.2

package/tools/ask/dist/components.mjs

@@ -1767,10 +1767,10 @@ function validateExportFormat(c) {
   if (!Array.isArray(c.formats)) return [{ path: "formats", message: "formats must be a list." }];
   const issues = [];
   const values = /* @__PURE__ */ new Set();
-  c.formats.forEach((f, i) => {
-    if (values.has(f.value)) issues.push({ path: `formats[${i}].value`, message: `The value \u201C${f.value}\u201D is used twice.` });
-    values.add(f.value);
-    if (!f.ext) issues.push({ path: `formats[${i}].ext`, message: "Every format needs an extension." });
+  c.formats.forEach((f2, i) => {
+    if (values.has(f2.value)) issues.push({ path: `formats[${i}].value`, message: `The value \u201C${f2.value}\u201D is used twice.` });
+    values.add(f2.value);
+    if (!f2.ext) issues.push({ path: `formats[${i}].ext`, message: "Every format needs an extension." });
   });
   if (c.formats.length && !values.has(c.defaultFormat)) issues.push({ path: "defaultFormat", message: `\u201C${c.defaultFormat}\u201D is not one of the formats.` });
   return issues;
@@ -6198,8 +6198,8 @@ var FILE_SHARED_PRESETS = presets_default25;
 function validateFileShared(c) {
   if (!Array.isArray(c.files)) return [{ path: "files", message: "files must be a list." }];
   const issues = [];
-  c.files.forEach((f, i) => {
-    if (!f || !f.name) issues.push({ path: `files[${i}].name`, message: "Every file needs a name." });
+  c.files.forEach((f2, i) => {
+    if (!f2 || !f2.name) issues.push({ path: `files[${i}].name`, message: "Every file needs a name." });
   });
   if (!(Number.isInteger(c.failIndex) && c.failIndex >= 0)) issues.push({ path: "failIndex", message: "failIndex is a whole number from 0." });
   return issues;
@@ -19839,13 +19839,13 @@ function validateReceiptPrinter(c) {
   });
   const keys = /* @__PURE__ */ new Set();
   if (fields.length > RECEIPT_MAX_FIELDS) issues.push({ path: "fields", message: `At most ${RECEIPT_MAX_FIELDS} fields \u2014 this has ${fields.length}.` });
-  else fields.forEach((f, i) => {
-    const key = f?.key;
+  else fields.forEach((f2, i) => {
+    const key = f2?.key;
     if (typeof key !== "string" || !FIELD_KEY.test(key)) issues.push({ path: `fields[${i}].key`, message: "A key starts with a letter and uses only letters, digits and _, like bookName." });
     else if (keys.has(key)) issues.push({ path: `fields[${i}].key`, message: `${key} is used twice.` });
     else keys.add(key);
-    if (!isText(f?.label)) issues.push({ path: `fields[${i}].label`, message: "Each field needs a label." });
-    if (f?.value !== void 0 && typeof f.value !== "string") issues.push({ path: `fields[${i}].value`, message: "A value is text." });
+    if (!isText(f2?.label)) issues.push({ path: `fields[${i}].label`, message: "Each field needs a label." });
+    if (f2?.value !== void 0 && typeof f2.value !== "string") issues.push({ path: `fields[${i}].value`, message: "A value is text." });
   });
   if (items.length > RECEIPT_MAX_ITEMS) issues.push({ path: "items", message: `A receipt prints at most ${RECEIPT_MAX_ITEMS} lines \u2014 this has ${items.length}.` });
   else items.forEach((it, i) => {
@@ -21143,8 +21143,8 @@ function validateThresholdFlow(doc) {
   if (typeof d.key !== "string" || !KEY.test(d.key)) issues.push({ code: "schema", message: "key must match ^[a-z][a-z0-9_]*$." });
   const p = d.props;
   if (!p || typeof p !== "object") return [...issues, { code: "schema", message: "props is required." }];
-  for (const f of ["title", "valueLabel"]) {
-    if (typeof p[f] !== "string" || !p[f]) issues.push({ code: "schema", message: `props.${f} is required.` });
+  for (const f2 of ["title", "valueLabel"]) {
+    if (typeof p[f2] !== "string" || !p[f2]) issues.push({ code: "schema", message: `props.${f2} is required.` });
   }
   if (!Array.isArray(p.defaultItems)) return [...issues, { code: "schema", message: "props.defaultItems must be an array." }];
   if (p.type !== void 0 && !DATA_TYPES.includes(p.type)) issues.push({ code: "unknown-type", message: `Unknown type "${String(p.type)}".` });
@@ -21254,8 +21254,8 @@ function checkValue(spec, v, path, c) {
       if (spec.maxItems !== void 0 && v.length > spec.maxItems) push(c, path, "MAX_ITEMS", layer, `${path} holds at most ${spec.maxItems} (has ${v.length}).`, `\u2264 ${spec.maxItems} items`);
       v.forEach((x, i) => checkValue(spec.item, x, `${path}[${i}]`, c));
       if (spec.item.type === "object") {
-        for (const [k, f] of Object.entries(spec.item.fields)) {
-          if (f.type !== "text" || !f.unique) continue;
+        for (const [k, f2] of Object.entries(spec.item.fields)) {
+          if (f2.type !== "text" || !f2.unique) continue;
           const seen = /* @__PURE__ */ new Set();
           v.forEach((x, i) => {
             const val = x?.[k];
@@ -21290,15 +21290,15 @@ function checkFields(fields, v, path, c) {
   for (const k of Object.keys(v)) {
     if (!(k in fields)) push(c, `${path}.${k}`, "UNKNOWN_KEY", "schema", `${path} has no "${k}". It takes: ${expected.join(", ") || "nothing"}.`, expected);
   }
-  for (const [k, f] of Object.entries(fields)) {
-    if (f.required && v[k] === void 0) push(c, `${path}.${k}`, "REQUIRED", c.section === "data" ? "data" : "configuration", `${path}.${k} is required: ${f.description}`);
-    else checkValue(f, v[k], `${path}.${k}`, c);
+  for (const [k, f2] of Object.entries(fields)) {
+    if (f2.required && v[k] === void 0) push(c, `${path}.${k}`, "REQUIRED", c.section === "data" ? "data" : "configuration", `${path}.${k} is required: ${f2.description}`);
+    else checkValue(f2, v[k], `${path}.${k}`, c);
   }
 }
 function checkOwners(fields, v, path, c) {
-  for (const [k, f] of Object.entries(fields)) {
-    if (v[k] !== void 0 && f.owners && !f.owners.includes("agent")) {
-      push(c, `${path}.${k}`, "NOT_ALLOWED", "configuration", `${path}.${k} is set by the ${f.owners.join(" or ")}, not by an agent.`, f.owners);
+  for (const [k, f2] of Object.entries(fields)) {
+    if (v[k] !== void 0 && f2.owners && !f2.owners.includes("agent")) {
+      push(c, `${path}.${k}`, "NOT_ALLOWED", "configuration", `${path}.${k} is set by the ${f2.owners.join(" or ")}, not by an agent.`, f2.owners);
     }
   }
 }
@@ -21315,22 +21315,22 @@ function valuesAt(root, ref) {
   return cur;
 }
 function checkRefs(fields, v, path, root, c) {
-  for (const [k, f] of Object.entries(fields)) visitRef(f, v?.[k], `${path}.${k}`, root, c);
+  for (const [k, f2] of Object.entries(fields)) visitRef(f2, v?.[k], `${path}.${k}`, root, c);
 }
-function visitRef(f, v, path, root, c) {
+function visitRef(f2, v, path, root, c) {
   if (v === void 0 || v === null) return;
-  if (f.ref && (typeof v === "string" || typeof v === "number")) {
-    const allowed = valuesAt(root, f.ref).filter((x) => typeof x === "string" || typeof x === "number");
+  if (f2.ref && (typeof v === "string" || typeof v === "number")) {
+    const allowed = valuesAt(root, f2.ref).filter((x) => typeof x === "string" || typeof x === "number");
     if (!allowed.includes(v)) {
-      push(c, path, "REFERENCE", c.section === "data" ? "data" : "configuration", `${path} must name one of ${f.ref} (got "${v}").`, allowed.map(String));
+      push(c, path, "REFERENCE", c.section === "data" ? "data" : "configuration", `${path} must name one of ${f2.ref} (got "${v}").`, allowed.map(String));
     }
   }
-  if (f.type === "list" && Array.isArray(v)) v.forEach((x, i) => visitRef(f.item, x, `${path}[${i}]`, root, c));
-  if (f.type === "object" && v && typeof v === "object") for (const [k, g] of Object.entries(f.fields)) visitRef(g, v[k], `${path}.${k}`, root, c);
+  if (f2.type === "list" && Array.isArray(v)) v.forEach((x, i) => visitRef(f2.item, x, `${path}[${i}]`, root, c));
+  if (f2.type === "object" && v && typeof v === "object") for (const [k, g] of Object.entries(f2.fields)) visitRef(g, v[k], `${path}.${k}`, root, c);
 }
 function withDefaults(fields, v = {}) {
   const out = { ...v };
-  for (const [k, f] of Object.entries(fields)) if (out[k] === void 0 && f.default !== void 0) out[k] = structuredClone(f.default);
+  for (const [k, f2] of Object.entries(fields)) if (out[k] === void 0 && f2.default !== void 0) out[k] = structuredClone(f2.default);
   return out;
 }
 var PLACEHOLDER = /\{(\w+)\}/g;
@@ -22724,8 +22724,8 @@ function check(value, shape, path, out) {
   if (k === "array" && shape.item) value.forEach((v, i) => check(v, shape.item, `${path}[${i}]`, out));
   if (k === "object" && shape.fields) {
     for (const [key, v] of Object.entries(value)) {
-      const f = shape.fields.get(key);
-      if (f) check(v, f, path ? `${path}.${key}` : key, out);
+      const f2 = shape.fields.get(key);
+      if (f2) check(v, f2, path ? `${path}.${key}` : key, out);
     }
   }
 }
@@ -22745,8 +22745,8 @@ var word = (v, fallback2) => typeof v === "string" && v.trim() ? v : fallback2;
 var blankItem = () => ({ name: "", quantity: "1", amount: "" });
 function fieldDrafts(c) {
   const defs = (Array.isArray(c.fields) ? c.fields : []).slice(0, RECEIPT_MAX_FIELDS);
-  const first = defs.findIndex((f) => f?.heading === true);
-  return defs.map((f, i) => ({ key: text2(f?.key), label: text2(f?.label), value: text2(f?.value), heading: i === first, keyTouched: true }));
+  const first = defs.findIndex((f2) => f2?.heading === true);
+  return defs.map((f2, i) => ({ key: text2(f2?.key), label: text2(f2?.label), value: text2(f2?.value), heading: i === first, keyTouched: true }));
 }
 function initialDraft(c) {
   const currencies = currenciesOf(c);
@@ -22775,15 +22775,15 @@ function formErrors(draft, c) {
   const m = messagesOf(c);
   if (draft.message.trim().length > RECEIPT_MAX_LENGTH.message) e.message = fill(m.tooLong, { max: RECEIPT_MAX_LENGTH.message });
   const keys = /* @__PURE__ */ new Set();
-  draft.fields.forEach((f, i) => {
-    const label = f.label.trim();
+  draft.fields.forEach((f2, i) => {
+    const label = f2.label.trim();
     if (!label) e[`fields.${i}.label`] = m.labelMissing;
     else if (label.length > RECEIPT_MAX_LENGTH.fieldLabel) e[`fields.${i}.label`] = fill(m.labelTooLong, { max: RECEIPT_MAX_LENGTH.fieldLabel });
-    if (!FIELD_KEY.test(f.key)) e[`fields.${i}.key`] = m.keyInvalid;
-    else if (keys.has(f.key)) e[`fields.${i}.key`] = fill(m.keyTaken, { key: f.key });
-    keys.add(f.key);
-    const v = f.value.trim();
-    const max = f.heading ? RECEIPT_MAX_LENGTH.heading : RECEIPT_MAX_LENGTH.fieldValue;
+    if (!FIELD_KEY.test(f2.key)) e[`fields.${i}.key`] = m.keyInvalid;
+    else if (keys.has(f2.key)) e[`fields.${i}.key`] = fill(m.keyTaken, { key: f2.key });
+    keys.add(f2.key);
+    const v = f2.value.trim();
+    const max = f2.heading ? RECEIPT_MAX_LENGTH.heading : RECEIPT_MAX_LENGTH.fieldValue;
     if (!v) e[`fields.${i}.value`] = label ? fill(m.valueMissing, { label: label.toLowerCase() }) : m.valueMissingNoLabel;
     else if (v.length > max) e[`fields.${i}.value`] = fill(m.tooLong, { max });
   });
@@ -22810,7 +22810,7 @@ function formErrors(draft, c) {
 }
 function valuesOf(draft) {
   return {
-    fields: Object.fromEntries(draft.fields.map((f) => [f.key, f.value.trim()])),
+    fields: Object.fromEntries(draft.fields.map((f2) => [f2.key, f2.value.trim()])),
     items: draft.items.map((it) => ({ name: it.name.trim(), quantity: Number(it.quantity.trim()), amount: Number(it.amount.trim()) })),
     currency: draft.currency,
     paymentMethod: draft.paymentMethod,
@@ -22833,14 +22833,14 @@ function receiptLines(v, c, defs = fieldDrafts(c)) {
   const minor = 10 ** (currency?.decimals ?? 2);
   const total = v.items.reduce((sum, it) => sum + Math.round(it.quantity * it.amount * minor), 0) / minor;
   const paid = word(c.paidLabel, "") ? ` (${c.paidLabel.toUpperCase()})` : "";
-  const heading = defs.find((f) => f.heading);
+  const heading = defs.find((f2) => f2.heading);
   const title = heading ? v.fields[heading.key] ?? "" : "";
   return {
     title: title.toUpperCase(),
     badge: (title.match(/[\p{L}\p{N}]/u)?.[0] ?? "\u2022").toUpperCase(),
     total: formatMoney(total, currency),
     meta: `${receiptDate(v.date, c.monthNames?.length === 12 ? c.monthNames : RECEIPT_MONTHS)} | ${method.toUpperCase()}${paid}`,
-    details: defs.filter((f) => !f.heading).map((f) => ({ label: f.label, value: v.fields[f.key] ?? "" })),
+    details: defs.filter((f2) => !f2.heading).map((f2) => ({ label: f2.label, value: v.fields[f2.key] ?? "" })),
     items: v.items.map((it) => ({ line: fill(messagesOf(c).itemLine, { quantity: it.quantity, name: it.name }), amount: formatMoney(it.quantity * it.amount, currency) })),
     paymentMethod: method,
     message: v.message.toUpperCase(),
@@ -25147,10 +25147,10 @@ function controlKit(groupOf3, easingNames) {
     ...o.unit ? { unit: o.unit } : {},
     ...o.step !== void 0 ? { step: o.step } : {}
   });
-  const num9 = (path, def, min, max, description, o = {}) => ({ path, group: groupOf3(path), type: "number", default: def, min, max, description, ...base4({ step: 0.01, ...o }) });
+  const num10 = (path, def, min, max, description, o = {}) => ({ path, group: groupOf3(path), type: "number", default: def, min, max, description, ...base4({ step: 0.01, ...o }) });
   const int4 = (path, def, min, max, description, o = {}) => ({ path, group: groupOf3(path), type: "integer", default: def, min, max, description, ...base4({ step: 1, ...o }) });
   const k = {
-    num: num9,
+    num: num10,
     int: int4,
     frames: (path, def, max, description, min = 0) => int4(path, def, min, max, description, { unit: "frames" }),
     bool: (path, def, description, o = {}) => ({ path, group: groupOf3(path), type: "boolean", default: def, description, ...base4(o) }),
@@ -25169,12 +25169,12 @@ function controlKit(groupOf3, easingNames) {
     }),
     easing: (path, def, description) => ({ path, group: groupOf3(path), type: "easing", default: def, options: easingNames, description, ...base4() }),
     asset: (path, description) => ({ path, group: groupOf3(path), type: "asset", default: "", maxLength: 2048, description, ...base4() }),
-    opacity: (path, def, description) => num9(path, def, 0, 1, description, { unit: "fraction" }),
-    du: (path, def, min, max, description) => num9(path, def, min, max, description, { step: 1, unit: "du" }),
-    pu: (path, def, min, max, description) => num9(path, def, min, max, description, { step: 1, unit: "pu" }),
-    norm: (path, def, min, max, description) => num9(path, def, min, max, description, { step: 5e-3, unit: "normalized" }),
-    deg: (path, def, min, max, description) => num9(path, def, min, max, description, { step: 0.5, unit: "deg" }),
-    factor: (path, def, min, max, description) => num9(path, def, min, max, description, { step: 0.01, unit: "factor" })
+    opacity: (path, def, description) => num10(path, def, 0, 1, description, { unit: "fraction" }),
+    du: (path, def, min, max, description) => num10(path, def, min, max, description, { step: 1, unit: "du" }),
+    pu: (path, def, min, max, description) => num10(path, def, min, max, description, { step: 1, unit: "pu" }),
+    norm: (path, def, min, max, description) => num10(path, def, min, max, description, { step: 5e-3, unit: "normalized" }),
+    deg: (path, def, min, max, description) => num10(path, def, min, max, description, { step: 0.5, unit: "deg" }),
+    factor: (path, def, min, max, description) => num10(path, def, min, max, description, { step: 0.01, unit: "factor" })
   };
   return k;
 }
@@ -29202,7 +29202,7 @@ var NOT_CONFIGURABLE = [
 ];
 function motionOutputFormats(t) {
   const { fps } = t.motion;
-  const canvases = (t.motion.formats ?? [{ id: "default", aspectRatio: "", width: t.motion.width, height: t.motion.height }]).map((f) => `${f.width}\xD7${f.height}${f.aspectRatio ? ` (${f.aspectRatio})` : ""}`).join(" or ");
+  const canvases = (t.motion.formats ?? [{ id: "default", aspectRatio: "", width: t.motion.width, height: t.motion.height }]).map((f2) => `${f2.width}\xD7${f2.height}${f2.aspectRatio ? ` (${f2.aspectRatio})` : ""}`).join(" or ");
   const composition = t.id.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
   return [
     {
@@ -29230,24 +29230,24 @@ function listMotionTemplates() {
     title: t.title,
     description: t.description,
     canvas: { width: t.motion.width, height: t.motion.height },
-    ...t.motion.formats ? { aspectRatios: t.motion.formats.map((f) => f.aspectRatio) } : {},
+    ...t.motion.formats ? { aspectRatios: t.motion.formats.map((f2) => f2.aspectRatio) } : {},
     ...t.motion.sequence ? { kind: "sequence" } : {},
     seconds: seconds(t, t.motion.durationInFrames),
     slots: t.slots.length,
-    formats: motionOutputFormats(t).map((f) => f.format)
+    formats: motionOutputFormats(t).map((f2) => f2.format)
   })).concat(Object.values(CONFIGURABLE_MOTION_TEMPLATES).map((t) => ({
     template: t.id,
     version: t.version,
     title: t.title,
     description: t.description,
     canvas: { width: t.formats[0].width, height: t.formats[0].height },
-    aspectRatios: t.formats.map((f) => f.aspectRatio),
+    aspectRatios: t.formats.map((f2) => f2.aspectRatio),
     kind: "configurableMotion",
     renderer: t.renderer,
     seconds: Math.round(t.durationInFrames / t.fps * 100) / 100,
     slots: 0,
     controls: t.controls.length,
-    formats: configurableOutputFormats(t).map((f) => f.format)
+    formats: configurableOutputFormats(t).map((f2) => f2.format)
   })));
 }
 function getConfigurableMotionTemplate(id) {
@@ -29260,7 +29260,7 @@ var CONFIG_API = {
 };
 var LIVE_PLAYER = { "promo-product-showcase": "PromoShowcasePlayer", "paper-fold-promo": "PaperFoldPlayer" };
 function configurableOutputFormats(t) {
-  const canvases = t.formats.map((f) => `${f.width}\xD7${f.height} (${f.aspectRatio})`).join(", ");
+  const canvases = t.formats.map((f2) => `${f2.width}\xD7${f2.height} (${f2.aspectRatio})`).join(", ");
   if (t.renderer === "remotion") {
     return [
       { output: "live", format: "HTML + CSS (DOM)", detail: `Any size, ${t.fps} fps; drawn procedurally from the config by the package's renderer (${LIVE_PLAYER[t.id] ?? "its player"} on the web). Not a video file.` },
@@ -29377,7 +29377,7 @@ function describeDom(id) {
     }])),
     theme: Object.fromEntries(t.theme.map((c) => [`theme.${c.token}`, { type: "hex colour", default: c.default, description: c.description }])),
     optionalScenes: t.optionalScenes.map((id2) => ({ scene: id2, effect: `leave "${id2}" out of content (or set it to null) to ${t.motion.sequence ? "hide it" : "end the video before it"}` })),
-    ...t.motion.formats ? { aspectRatio: { field: "aspectRatio", values: t.motion.formats.map((f) => ({ value: f.aspectRatio, width: f.width, height: f.height })), default: t.motion.formats[0].aspectRatio, effect: "the same animation, laid out for that canvas" } } : {},
+    ...t.motion.formats ? { aspectRatio: { field: "aspectRatio", values: t.motion.formats.map((f2) => ({ value: f2.aspectRatio, width: f2.width, height: f2.height })), default: t.motion.formats[0].aspectRatio, effect: "the same animation, laid out for that canvas" } } : {},
     ...t.motion.sequence ? { sequence: describeSequence(t) } : {},
     notConfigurable: NOT_CONFIGURABLE,
     example: { schema: MOTION_REQUEST_SCHEMA, template: t.id, content: t.exampleContent },
@@ -29429,6 +29429,1079 @@ function motionPreviewUrl(request, origin = "https://comppack.vercel.app") {
   return `${origin.replace(/\/+$/, "")}/animations/${encodeURIComponent(request.template)}?request=${b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "")}`;
 }
 
+// src/motion/neon/config.ts
+var NEON_CONSTRUCTIONS = ["outline", "monoline"];
+var NEON_ALIGNS = ["start", "middle", "end"];
+var DEFAULT_NEON_CONFIG = {
+  text: "CAFE",
+  typography: {
+    fontFamily: "Oswald, 'Arial Narrow', 'Helvetica Neue', Arial, sans-serif",
+    fontSize: 220,
+    fontWeight: 500,
+    fontStyle: "normal",
+    letterSpacing: 4,
+    lineHeight: 1.15,
+    strokeWidth: 8,
+    construction: "outline",
+    align: "middle"
+  },
+  neon: {
+    color: "#FF4655",
+    coreColor: "#FFF5F5",
+    tubeColor: "#FF4655",
+    glowColor: "#FF1838",
+    bloomColor: "#D4002F",
+    intensity: 1,
+    bloomIntensity: 1,
+    tubeBrightness: 1,
+    coreBrightness: 1,
+    glowRadius: 20,
+    bloomRadius: 70,
+    coreWidth: 0.47,
+    glassOpacity: 0.16,
+    shadow: { enabled: true, color: "#000000", opacity: 0.5, offsetX: 0.035, offsetY: 0.045, blur: 6 }
+  },
+  animation: {
+    enabled: true,
+    speed: 1,
+    seed: 7356951,
+    flickerEnabled: true,
+    flickerIntensity: 0.15,
+    flickerFrequency: 0.08,
+    flickerSpeed: 1,
+    flickerRandomness: 0.6,
+    flickerRecovery: 0.7,
+    flickerMinBrightness: 0.05,
+    glitchEnabled: true,
+    glitchIntensity: 0.15,
+    glitchFrequency: 0.04,
+    glitchDuration: 180,
+    glitchDisplacement: 1,
+    glitchRgbSplit: 1,
+    glitchSlices: 1,
+    glitchGlowSeparation: 1
+  },
+  background: null
+};
+var NEON_COLOR_PRESETS = {
+  red: { color: "#FF3B4D", coreColor: "#FFF5F5", tubeColor: "#FF3B4D", glowColor: "#FF1744", bloomColor: "#C40030" },
+  blue: { color: "#00D9FF", coreColor: "#F5FFFF", tubeColor: "#00D9FF", glowColor: "#009DFF", bloomColor: "#0055FF" },
+  purple: { color: "#D66BFF", coreColor: "#FFF5FF", tubeColor: "#D66BFF", glowColor: "#9C27FF", bloomColor: "#5E00B8" },
+  green: { color: "#39FF88", coreColor: "#F5FFF5", tubeColor: "#39FF88", glowColor: "#00D95F", bloomColor: "#008F3D" }
+};
+var NEON_TEXT_PRESETS = {
+  cafe: { text: "CAFE", typography: { construction: "outline", fontFamily: DEFAULT_NEON_CONFIG.typography.fontFamily, fontWeight: 500, strokeWidth: 8, letterSpacing: 4 } },
+  open: { text: "OPEN", typography: { construction: "outline", fontFamily: DEFAULT_NEON_CONFIG.typography.fontFamily, fontWeight: 500, strokeWidth: 8, letterSpacing: 10 } },
+  night: { text: "NIGHT", typography: { construction: "outline", fontFamily: DEFAULT_NEON_CONFIG.typography.fontFamily, fontWeight: 500, strokeWidth: 8, letterSpacing: 6 } },
+  "24/7": { text: "24/7", typography: { construction: "monoline", fontFamily: "Quicksand, 'Arial Rounded MT Bold', 'Helvetica Neue', Arial, sans-serif", fontWeight: 500, strokeWidth: 10, letterSpacing: 2 } },
+  hello: { text: "Hello", typography: { construction: "monoline", fontFamily: "Sacramento, 'Snell Roundhand', 'Brush Script MT', cursive", fontWeight: 400, strokeWidth: 7, letterSpacing: 0 } }
+};
+var HEX7 = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i;
+var isHexColor = (v) => typeof v === "string" && HEX7.test(v);
+function hexToRgb(hex) {
+  const h = hex.length === 4 ? hex.slice(1).split("").map((c) => c + c).join("") : hex.slice(1);
+  return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)];
+}
+var rgbToHex = (rgb) => "#" + rgb.map((v) => Math.round(Math.max(0, Math.min(255, v))).toString(16).padStart(2, "0")).join("").toUpperCase();
+function mixHex(a, b, t) {
+  const x = hexToRgb(a);
+  const y = hexToRgb(b);
+  return rgbToHex(x.map((v, i) => v + (y[i] - v) * t));
+}
+function toHsl([r, g, b]) {
+  const [R, G2, B] = [r / 255, g / 255, b / 255];
+  const max = Math.max(R, G2, B);
+  const min = Math.min(R, G2, B);
+  const l = (max + min) / 2;
+  if (max === min) return [0, 0, l];
+  const d = max - min;
+  const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+  const h = max === R ? (G2 - B) / d + (G2 < B ? 6 : 0) : max === G2 ? (B - R) / d + 2 : (R - G2) / d + 4;
+  return [h * 60, s, l];
+}
+function fromHsl(h, s, l) {
+  const k = (n) => (n + h / 30) % 12;
+  const a = s * Math.min(l, 1 - l);
+  const f2 = (n) => l - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)));
+  return rgbToHex([f2(0) * 255, f2(8) * 255, f2(4) * 255]);
+}
+function deriveNeonPalette(color4) {
+  const base4 = isHexColor(color4) ? color4 : DEFAULT_NEON_CONFIG.neon.color;
+  const [h, s, l] = toHsl(hexToRgb(base4));
+  const drift = (deg3) => s < 0.08 ? h : (h + deg3 + 360) % 360;
+  return {
+    coreColor: mixHex(base4, "#FFFFFF", 0.94),
+    tubeColor: rgbToHex(hexToRgb(base4)),
+    glowColor: fromHsl(drift(-6), Math.min(1, s + 0.15), Math.max(0.3, l * 0.84)),
+    bloomColor: fromHsl(drift(-10), Math.min(1, s + 0.2), Math.max(0.18, l * 0.6))
+  };
+}
+var isObj5 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var NEON_CONTROLS = [
+  { path: "text", label: "Text", group: "Text", type: "text", description: "What the sign says. A new line (\\n) starts a second row." },
+  { path: "typography.fontFamily", label: "Font", group: "Typography", type: "text", description: "A CSS font-family list; the page must load the font." },
+  { path: "typography.fontSize", label: "Font size", group: "Typography", type: "number", min: 12, max: 1e3, step: 1, unit: "units", description: "The em size, in SVG user units." },
+  { path: "typography.fontWeight", label: "Font weight", group: "Typography", type: "number", min: 100, max: 900, step: 100, description: "CSS font-weight." },
+  { path: "typography.fontStyle", label: "Font style", group: "Typography", type: "enum", options: ["normal", "italic"], description: "Upright or italic." },
+  { path: "typography.letterSpacing", label: "Letter spacing", group: "Typography", type: "number", min: -50, max: 200, step: 1, unit: "units", description: "Extra space between letters." },
+  { path: "typography.lineHeight", label: "Line height", group: "Typography", type: "number", min: 0.6, max: 3, step: 0.05, unit: "\xD7 size", description: "Row pitch for multi-line text." },
+  { path: "typography.strokeWidth", label: "Tube width", group: "Typography", type: "number", min: 0.5, max: 80, step: 0.5, unit: "units", description: "The glass tube. The reference is \u2248 0.033 \xD7 font size." },
+  { path: "typography.construction", label: "Construction", group: "Typography", type: "enum", options: NEON_CONSTRUCTIONS, description: "outline: the tube traces each letter (CAFE). monoline: the letter is the tube (24/7)." },
+  { path: "typography.align", label: "Align", group: "Typography", type: "enum", options: NEON_ALIGNS, description: "Row alignment for multi-line text." },
+  { path: "neon.color", label: "Neon colour", group: "Colour", type: "color", description: "The primary colour; the others follow it unless set." },
+  { path: "neon.tubeColor", label: "Tube colour", group: "Colour", type: "color-or-null", description: "The lit glass. null follows the neon colour." },
+  { path: "neon.coreColor", label: "Core colour", group: "Colour", type: "color-or-null", description: "The hot centre line. null follows the neon colour." },
+  { path: "neon.glowColor", label: "Glow colour", group: "Colour", type: "color-or-null", description: "The tight halo. null follows the neon colour." },
+  { path: "neon.bloomColor", label: "Bloom colour", group: "Colour", type: "color-or-null", description: "The light on the wall. null follows the neon colour." },
+  { path: "neon.intensity", label: "Glow intensity", group: "Light", type: "number", min: 0, max: 3, step: 0.05, description: "0 is a bare tube; 1 the reference." },
+  { path: "neon.bloomIntensity", label: "Bloom intensity", group: "Light", type: "number", min: 0, max: 3, step: 0.05, description: "The wall bloom\u2019s own strength." },
+  { path: "neon.tubeBrightness", label: "Tube brightness", group: "Light", type: "number", min: 0, max: 1.5, step: 0.01, description: "How bright the lit glass is." },
+  { path: "neon.coreBrightness", label: "Core brightness", group: "Light", type: "number", min: 0, max: 1.5, step: 0.01, description: "How bright the hot centre line is." },
+  { path: "neon.glowRadius", label: "Glow radius", group: "Light", type: "number", min: 0, max: 200, step: 1, unit: "units", description: "Reach of the tight halo." },
+  { path: "neon.bloomRadius", label: "Bloom radius", group: "Light", type: "number", min: 0, max: 400, step: 1, unit: "units", description: "Reach of the wall bloom." },
+  { path: "neon.coreWidth", label: "Core width", group: "Light", type: "number", min: 0, max: 1, step: 0.01, unit: "\xD7 tube", description: "The hot core, as a share of the tube." },
+  { path: "neon.glassOpacity", label: "Unlit glass", group: "Light", type: "number", min: 0, max: 1, step: 0.01, description: "How much dark glass shows when the tube dims." },
+  { path: "neon.shadow.enabled", label: "Shadow", group: "Light", type: "boolean", description: "The tube\u2019s dark cast shadow on the wall." },
+  { path: "neon.shadow.color", label: "Shadow colour", group: "Light", type: "color", description: "Shadow colour." },
+  { path: "neon.shadow.opacity", label: "Shadow opacity", group: "Light", type: "number", min: 0, max: 1, step: 0.01, description: "Shadow strength." },
+  { path: "neon.shadow.offsetX", label: "Shadow x", group: "Light", type: "number", min: -0.5, max: 0.5, step: 5e-3, unit: "\xD7 size", description: "Shadow offset, across." },
+  { path: "neon.shadow.offsetY", label: "Shadow y", group: "Light", type: "number", min: -0.5, max: 0.5, step: 5e-3, unit: "\xD7 size", description: "Shadow offset, down." },
+  { path: "neon.shadow.blur", label: "Shadow blur", group: "Light", type: "number", min: 0, max: 100, step: 0.5, unit: "units", description: "Shadow softness." },
+  { path: "animation.enabled", label: "Animation", group: "Animation", type: "boolean", description: "Flicker and glitch on or off." },
+  { path: "animation.speed", label: "Animation speed", group: "Animation", type: "number", min: 0.1, max: 5, step: 0.05, unit: "\xD7", description: "Plays everything faster or slower." },
+  { path: "animation.seed", label: "Seed", group: "Animation", type: "number", min: 0, max: 4294967295, step: 1, description: "Same seed, same performance." },
+  { path: "animation.flickerEnabled", label: "Flicker", group: "Flicker", type: "boolean", description: "Brightness flicker on or off." },
+  { path: "animation.flickerIntensity", label: "Flicker intensity", group: "Flicker", type: "number", min: 0, max: 1, step: 0.01, description: "0.25 plays the full hardware ranges." },
+  { path: "animation.flickerFrequency", label: "Flicker frequency", group: "Flicker", type: "number", min: 0, max: 5, step: 0.01, unit: "/ s", description: "Noticeable flicker events per second." },
+  { path: "animation.flickerSpeed", label: "Flicker speed", group: "Flicker", type: "number", min: 0.1, max: 5, step: 0.05, unit: "\xD7", description: "How fast each flicker event plays." },
+  { path: "animation.flickerRandomness", label: "Randomness", group: "Flicker", type: "number", min: 0, max: 1, step: 0.01, description: "How much events vary in depth and length." },
+  { path: "animation.flickerRecovery", label: "Recovery speed", group: "Flicker", type: "number", min: 0, max: 1, step: 0.01, description: "How fast the tube comes back after a dip or failure." },
+  { path: "animation.flickerMinBrightness", label: "Minimum brightness", group: "Flicker", type: "number", min: 0, max: 1, step: 0.01, description: "The tube never falls below this." },
+  { path: "animation.glitchEnabled", label: "Glitch", group: "Glitch", type: "boolean", description: "Occasional glitches on or off." },
+  { path: "animation.glitchIntensity", label: "Glitch intensity", group: "Glitch", type: "number", min: 0, max: 1, step: 0.01, description: "How far slices shift and colours split." },
+  { path: "animation.glitchFrequency", label: "Glitch frequency", group: "Glitch", type: "number", min: 0, max: 5, step: 0.01, unit: "/ s", description: "Glitches per second." },
+  { path: "animation.glitchDuration", label: "Glitch duration", group: "Glitch", type: "number", min: 20, max: 2e3, step: 10, unit: "ms", description: "A glitch\u2019s typical length." },
+  { path: "animation.glitchDisplacement", label: "Horizontal displacement", group: "Glitch", type: "number", min: 0, max: 2, step: 0.05, unit: "\xD7", description: "The whole-sign sideways jump." },
+  { path: "animation.glitchRgbSplit", label: "RGB separation", group: "Glitch", type: "number", min: 0, max: 2, step: 0.05, unit: "\xD7", description: "The red/cyan split." },
+  { path: "animation.glitchSlices", label: "Slice displacement", group: "Glitch", type: "number", min: 0, max: 2, step: 0.05, unit: "\xD7", description: "How far the sliced bands shift." },
+  { path: "animation.glitchGlowSeparation", label: "Glow separation", group: "Glitch", type: "number", min: 0, max: 2, step: 0.05, unit: "\xD7", description: "How far the glow slips from the tube." },
+  { path: "background", label: "Background", group: "Colour", type: "color-or-null", description: "A colour behind the sign, or null for transparent." }
+];
+function getPath4(obj2, path) {
+  return path.split(".").reduce((o, k) => isObj5(o) ? o[k] : void 0, obj2);
+}
+var MAX_NEON_TEXT_LENGTH = 200;
+function validateNeonConfig(config) {
+  const errors = [];
+  if (!isObj5(config)) return [{ path: "", message: "The config must be an object." }];
+  for (const c of NEON_CONTROLS) {
+    const v = getPath4(config, c.path);
+    const where = c.path;
+    if (c.type === "text") {
+      if (typeof v !== "string") errors.push({ path: where, message: "Must be text." });
+      else if (c.path === "text" && v.length > MAX_NEON_TEXT_LENGTH) errors.push({ path: where, message: `At most ${MAX_NEON_TEXT_LENGTH} characters.` });
+      else if (c.path !== "text" && !v.trim()) errors.push({ path: where, message: "Must not be empty." });
+    } else if (c.type === "number") {
+      if (typeof v !== "number" || !Number.isFinite(v)) errors.push({ path: where, message: "Must be a number." });
+      else if (c.min !== void 0 && v < c.min || c.max !== void 0 && v > c.max) errors.push({ path: where, message: `Must be between ${c.min} and ${c.max}.` });
+    } else if (c.type === "boolean") {
+      if (typeof v !== "boolean") errors.push({ path: where, message: "Must be true or false." });
+    } else if (c.type === "enum") {
+      if (!c.options.includes(v)) errors.push({ path: where, message: `Must be one of: ${c.options.join(", ")}.` });
+    } else if (c.type === "color") {
+      if (!isHexColor(v)) errors.push({ path: where, message: "Must be a hex colour like #FF3B4D." });
+    } else if (v !== null && !isHexColor(v)) {
+      errors.push({ path: where, message: "Must be a hex colour like #FF3B4D, or null." });
+    }
+  }
+  return errors;
+}
+
+// src/motion/neon/artwork.ts
+var SHAPES = /* @__PURE__ */ new Set(["path", "circle", "ellipse", "rect", "line", "polyline", "polygon"]);
+var CONTAINERS = /* @__PURE__ */ new Set(["g", "a", "switch"]);
+var SKIP = /* @__PURE__ */ new Set(["defs", "style", "script", "title", "desc", "metadata", "clippath", "mask", "pattern", "lineargradient", "radialgradient", "filter", "symbol", "marker", "text", "foreignobject", "image", "use"]);
+var ATTRS = /* @__PURE__ */ new Set(["d", "cx", "cy", "r", "rx", "ry", "x", "y", "width", "height", "x1", "y1", "x2", "y2", "points", "transform", "fill-rule"]);
+var SAFE_VALUE = /^[\s\d.,eE+\-MmLlHhVvCcSsQqTtAaZz()a-z%]*$/;
+var SAFE_TRANSFORM = /^\s*((matrix|translate|scale|rotate|skewX|skewY)\s*\([\d\s.,eE+-]*\)\s*,?\s*)*$/;
+function parseAttrs(src) {
+  const out = {};
+  for (const m of src.matchAll(/([a-zA-Z_:][\w:.-]*)\s*=\s*("([^"]*)"|'([^']*)')/g)) out[m[1].toLowerCase()] = m[3] ?? m[4] ?? "";
+  return out;
+}
+var MAX_SVG_BYTES = 5e5;
+var MAX_NODES = 2e3;
+function parseSvgArtwork(svg) {
+  if (typeof svg !== "string" || !svg.trim()) throw new Error("The SVG is empty.");
+  if (svg.length > MAX_SVG_BYTES) throw new Error(`The SVG is larger than ${MAX_SVG_BYTES / 1e3} kB.`);
+  const clean = svg.replace(/<!--[\s\S]*?-->/g, "").replace(/<!\[CDATA\[[\s\S]*?\]\]>/g, "").replace(/<![^>]*>/g, "").replace(/<\?[\s\S]*?\?>/g, "");
+  const root = { tag: "g", attrs: {}, children: [] };
+  const stack = [{ node: root, tag: "#root" }];
+  let viewBox = null;
+  let count = 0;
+  let shapes = 0;
+  for (const m of clean.matchAll(/<(\/?)([a-zA-Z][\w:.-]*)((?:\s+[^\s=>/]+\s*=\s*(?:"[^"]*"|'[^']*'))*)\s*(\/?)>/g)) {
+    const [, close, rawTag, rawAttrs, selfClose] = m;
+    const tag = rawTag.toLowerCase().replace(/^svg:/, "");
+    if (close) {
+      while (stack.length > 1) {
+        const top = stack.pop();
+        if (top.tag === tag) break;
+      }
+      continue;
+    }
+    const parent = stack[stack.length - 1].node;
+    const attrs = parseAttrs(rawAttrs ?? "");
+    if (tag === "svg" && !viewBox) {
+      const vb = (attrs.viewbox ?? "").trim().split(/[\s,]+/).map(Number);
+      if (vb.length === 4 && vb.every(Number.isFinite) && vb[2] > 0 && vb[3] > 0) viewBox = vb;
+      else {
+        const w = parseFloat(attrs.width ?? "");
+        const h = parseFloat(attrs.height ?? "");
+        if (w > 0 && h > 0) viewBox = [0, 0, w, h];
+      }
+    }
+    if (tag === "svg") {
+      if (!selfClose) stack.push({ node: parent, tag });
+      continue;
+    }
+    let node = null;
+    if (parent && !SKIP.has(tag) && (SHAPES.has(tag) || CONTAINERS.has(tag)) && count < MAX_NODES) {
+      const kept = {};
+      for (const [k, v] of Object.entries(attrs)) {
+        if (!ATTRS.has(k)) continue;
+        if (k === "transform" ? !SAFE_TRANSFORM.test(v) : !SAFE_VALUE.test(v)) continue;
+        if (CONTAINERS.has(tag) && k !== "transform") continue;
+        kept[k] = v;
+      }
+      node = { tag: SHAPES.has(tag) ? tag : "g", attrs: kept, children: [] };
+      parent.children.push(node);
+      count++;
+      if (SHAPES.has(tag)) shapes++;
+    }
+    if (!selfClose && !SHAPES.has(tag)) stack.push({ node: SKIP.has(tag) ? null : node, tag });
+    else if (!selfClose && SHAPES.has(tag)) stack.push({ node: null, tag });
+  }
+  if (!shapes) throw new Error("The SVG has no shapes to bend into tubes (paths, circles, rects, lines or polygons).");
+  return { viewBox: viewBox ?? [0, 0, 100, 100], nodes: root.children, shapes };
+}
+var NEON_ARTWORK_LIBRARY = {
+  heart: { name: "Heart", svg: '<svg viewBox="0 0 100 100"><path d="M50 84 C22 64 8 48 12 32 C16 17 35 13 45 24 C48 27 49 30 50 33 C51 30 52 27 55 24 C65 13 84 17 88 32 C92 48 78 64 50 84 Z"/></svg>' },
+  star: { name: "Star", svg: '<svg viewBox="0 0 100 100"><polygon points="50,9 61,37 91,38 67,57 76,87 50,70 24,87 33,57 9,38 39,37"/></svg>' },
+  bolt: { name: "Lightning", svg: '<svg viewBox="0 0 100 100"><path d="M60 7 L26 55 L49 55 L40 93 L75 42 L52 42 Z"/></svg>' },
+  moon: { name: "Moon", svg: '<svg viewBox="0 0 100 100"><path d="M64 12 C40 16 26 35 28 55 C30 76 50 90 72 87 C56 80 45 66 45 49 C45 33 52 20 64 12 Z"/></svg>' },
+  sparkle: { name: "Sparkle", svg: '<svg viewBox="0 0 100 100"><path d="M50 8 C54 38 62 46 92 50 C62 54 54 62 50 92 C46 62 38 54 8 50 C38 46 46 38 50 8 Z"/></svg>' },
+  note: { name: "Music note", svg: '<svg viewBox="0 0 100 100"><path d="M38 74 C38 83 21 86 19 77 C17 69 33 64 38 71 L38 20 L80 11 L80 64 C80 73 63 76 61 67 C59 59 75 54 80 61"/><path d="M38 31 L80 22"/></svg>' },
+  arrow: { name: "Arrow", svg: '<svg viewBox="0 0 100 100"><path d="M10 50 L84 50"/><path d="M62 28 L86 50 L62 72"/></svg>' },
+  cocktail: { name: "Cocktail", svg: '<svg viewBox="0 0 100 100"><path d="M18 18 L82 18 L50 54 Z"/><path d="M50 54 L50 86 M32 86 L68 86"/><circle cx="70" cy="12" r="7"/></svg>' },
+  rocket: { name: "Rocket", svg: '<svg viewBox="0 0 100 100"><path d="M50 8 C66 22 70 44 64 66 L36 66 C30 44 34 22 50 8 Z"/><circle cx="50" cy="36" r="7"/><path d="M36 54 L24 72 L36 68 M64 54 L76 72 L64 68 M44 74 L50 90 L56 74"/></svg>' },
+  crown: { name: "Crown", svg: '<svg viewBox="0 0 100 100"><path d="M14 74 L10 30 L32 50 L50 20 L68 50 L90 30 L86 74 Z"/><path d="M16 84 L84 84"/></svg>' }
+};
+
+// src/motion/neon/fonts.ts
+var f = (id, name, category, fallback2, google, weight3, construction, stroke) => ({ id, name, category, family: google ? `'${name}', ${fallback2}` : fallback2, google, weight: weight3, construction, stroke });
+var NEON_FONTS = [
+  f("tilt-neon", "Tilt Neon", "neon tube", "Quicksand, sans-serif", "Tilt+Neon", 400, "monoline", 0.04),
+  f("bebas-neue", "Bebas Neue", "condensed", "Oswald, 'Arial Narrow', sans-serif", "Bebas+Neue", 400, "outline", 0.033),
+  f("anton", "Anton", "bold", "'Arial Narrow', Impact, sans-serif", "Anton", 400, "outline", 0.03),
+  f("oswald", "Oswald", "condensed", "'Arial Narrow', 'Helvetica Neue', Arial, sans-serif", "Oswald:wght@300;400;500;600;700", 500, "outline", 0.036),
+  f("space-grotesk", "Space Grotesk", "geometric", "'Helvetica Neue', Arial, sans-serif", "Space+Grotesk:wght@400;500;700", 500, "outline", 0.033),
+  f("orbitron", "Orbitron", "futuristic", "'Eurostile', sans-serif", "Orbitron:wght@400;600;800", 600, "outline", 0.03),
+  f("audiowide", "Audiowide", "futuristic", "sans-serif", "Audiowide", 400, "outline", 0.03),
+  f("russo-one", "Russo One", "signage", "Impact, 'Arial Black', sans-serif", "Russo+One", 400, "outline", 0.03),
+  f("rajdhani", "Rajdhani", "industrial", "'Arial Narrow', sans-serif", "Rajdhani:wght@500;600;700", 600, "outline", 0.033),
+  f("exo-2", "Exo 2", "futuristic", "sans-serif", "Exo+2:wght@300;500;700", 500, "outline", 0.033),
+  f("montserrat", "Montserrat", "geometric", "'Helvetica Neue', Arial, sans-serif", "Montserrat:wght@300;500;700", 500, "outline", 0.033),
+  f("inter", "Inter", "geometric", "system-ui, 'Helvetica Neue', Arial, sans-serif", "Inter:wght@300;500;700", 500, "outline", 0.033),
+  f("archivo", "Archivo", "signage", "'Helvetica Neue', Arial, sans-serif", "Archivo:wght@400;600;800", 600, "outline", 0.033),
+  f("barlow-condensed", "Barlow Condensed", "condensed", "'Arial Narrow', sans-serif", "Barlow+Condensed:wght@400;600", 600, "outline", 0.034),
+  f("sora", "Sora", "geometric", "sans-serif", "Sora:wght@300;500;700", 500, "outline", 0.033),
+  f("raleway", "Raleway", "thin", "'Helvetica Neue', sans-serif", "Raleway:wght@200;300;500", 300, "monoline", 0.03),
+  f("press-start-2p", "Press Start 2P", "arcade", "'Courier New', monospace", "Press+Start+2P", 400, "outline", 0.03),
+  f("pacifico", "Pacifico", "handwritten", "'Brush Script MT', cursive", "Pacifico", 400, "outline", 0.026),
+  f("dm-sans", "DM Sans", "rounded", "'Helvetica Neue', Arial, sans-serif", "DM+Sans:wght@300;500;700", 500, "outline", 0.033),
+  f("quicksand", "Quicksand", "rounded", "'Arial Rounded MT Bold', 'Helvetica Neue', Arial, sans-serif", "Quicksand:wght@300;400;500;600;700", 500, "monoline", 0.045),
+  f("sacramento", "Sacramento", "handwritten", "'Snell Roundhand', 'Brush Script MT', cursive", "Sacramento", 400, "monoline", 0.03),
+  f("righteous", "Righteous", "retro", "sans-serif", "Righteous", 400, "outline", 0.03),
+  f("space-mono", "Space Mono", "monospace", "'Courier New', monospace", "Space+Mono:wght@400;700", 400, "monoline", 0.03),
+  f("great-vibes", "Great Vibes", "elegant", "'Snell Roundhand', cursive", "Great+Vibes", 400, "monoline", 0.022),
+  f("black-ops-one", "Black Ops One", "industrial", "Impact, sans-serif", "Black+Ops+One", 400, "outline", 0.026),
+  f("monoton", "Monoton", "display", "sans-serif", "Monoton", 400, "monoline", 8e-3),
+  f("system", "System", "system", "system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif", null, 600, "outline", 0.033)
+];
+var NEON_EMOJI_FONT = f("noto-emoji", "Noto Emoji", "display", "sans-serif", "Noto+Emoji:wght@400;500;700", 500, "outline", 0.03);
+function findNeonFont(query) {
+  const q = query.trim().toLowerCase().replace(/[-_]+/g, " ");
+  if (!q) return void 0;
+  return NEON_FONTS.find((x) => x.id.replace(/-/g, " ") === q || x.name.toLowerCase() === q) ?? NEON_FONTS.find((x) => x.name.toLowerCase().startsWith(q) || x.family.toLowerCase().startsWith(`'${q}`)) ?? NEON_FONTS.find((x) => x.name.toLowerCase().includes(q));
+}
+
+// src/motion/neon/material.ts
+function materialPad(neon, t) {
+  const shadow = neon.shadow.enabled ? Math.hypot(neon.shadow.offsetX, neon.shadow.offsetY) * t.fontSize + neon.shadow.blur * 2 : 0;
+  const light2 = neon.intensity > 0 ? Math.max(neon.bloomRadius * 1.25, neon.glowRadius * 1.6) : 0;
+  return Math.ceil(Math.max(shadow, light2) + t.strokeWidth * 2 + t.fontSize * 0.04);
+}
+
+// src/motion/neon/typography.ts
+var NARROW = /* @__PURE__ */ new Set([..."iIl.,:;!|'`jft1"]);
+var WIDE = /* @__PURE__ */ new Set([..."MWmw@%"]);
+var CAPS = /[A-Z0-9]/;
+var estimateTextWidth = (text6, t) => {
+  const condensed = /oswald|bebas|narrow|condensed|compressed|league gothic|anton/i.test(t.fontFamily) ? 0.8 : 1;
+  const weight3 = 0.92 + (t.fontWeight - 400) / 2500;
+  let em = 0;
+  for (const ch of text6) {
+    if (ch === " ") em += 0.28;
+    else if (NARROW.has(ch)) em += 0.3;
+    else if (WIDE.has(ch)) em += 0.86;
+    else if (ch === "/") em += 0.4;
+    else if (CAPS.test(ch)) em += 0.64;
+    else em += 0.54;
+  }
+  return em * condensed * weight3 * t.fontSize;
+};
+function textRows(text6) {
+  const rows = String(text6 ?? "").replace(/\\n/g, "\n").replace(/\r\n?/g, "\n").replace(/\t/g, " ").split("\n");
+  return rows.length && rows.some((r) => r.length) ? rows : [" "];
+}
+var CAP = 0.74;
+var DESCENT = 0.24;
+function layoutText(text6, t, pad, measure = estimateTextWidth) {
+  const rows = textRows(text6);
+  const pitch = t.fontSize * t.lineHeight;
+  const measured = rows.map((r, i) => {
+    const glyphs = [...r].length;
+    let w;
+    try {
+      w = measure(r, t);
+    } catch {
+      w = estimateTextWidth(r, t);
+    }
+    if (!Number.isFinite(w) || w < 0) w = estimateTextWidth(r, t);
+    return { text: r, y: i * pitch, width: w + t.letterSpacing * Math.max(0, glyphs - 1) };
+  });
+  const width = Math.max(t.fontSize * 0.3, ...measured.map((r) => r.width));
+  const textAnchor = t.align;
+  const anchorX = textAnchor === "start" ? -width / 2 : textAnchor === "end" ? width / 2 : 0;
+  const top = -t.fontSize * CAP - t.strokeWidth;
+  const bottom = (rows.length - 1) * pitch + t.fontSize * DESCENT + t.strokeWidth;
+  const box = { x: -width / 2 - t.strokeWidth, y: top, width: width + 2 * t.strokeWidth, height: bottom - top };
+  return {
+    rows: measured,
+    anchorX,
+    textAnchor,
+    box,
+    viewBox: { x: box.x - pad, y: box.y - pad, width: box.width + 2 * pad, height: box.height + 2 * pad },
+    pad
+  };
+}
+
+// src/motion/neon/wall.ts
+var DEFAULT_NEON_WALL = {
+  enabled: true,
+  seed: 7356951,
+  brickWidth: 150,
+  brickHeight: 52,
+  mortar: 4,
+  brickColor: "#0D1230",
+  mortarColor: "#030409",
+  variation: 0.5,
+  texture: 0.5,
+  ambientColor: "#1F2FD0",
+  ambient: 0.55,
+  vignette: 0.85,
+  lightSpill: 1,
+  spillRadius: 260,
+  glitchAffectsWall: true
+};
+
+// src/motion/neon/scene.ts
+var DEFAULT_NEON_AUDIO = {
+  enabled: false,
+  muted: false,
+  master: 0.7,
+  hum: 0.45,
+  flicker: 0.45,
+  dip: 0.55,
+  failure: 0.6,
+  glitch: 0.3,
+  recovery: 0.45,
+  scrub: true,
+  scrubVolume: 0.5
+};
+var common = (id, seed) => ({
+  id,
+  x: 800,
+  y: 500,
+  scale: 1,
+  rotation: 0,
+  opacity: 1,
+  visible: true,
+  locked: false,
+  neon: { ...DEFAULT_NEON_CONFIG.neon, shadow: { ...DEFAULT_NEON_CONFIG.neon.shadow } },
+  animation: { ...DEFAULT_NEON_CONFIG.animation, seed }
+});
+var DEFAULT_NEON_ELEMENTS = {
+  text: { ...common("text-1", 7356951), type: "text", text: "CAFE", typography: { ...DEFAULT_NEON_CONFIG.typography, fontSize: 300, strokeWidth: 10.5, letterSpacing: 6 } },
+  emoji: { ...common("emoji-1", 7356952), type: "emoji", emoji: "\u2615", size: 240, strokeWidth: 8, construction: "outline", fontWeight: 500, fontFamily: NEON_EMOJI_FONT.family },
+  artwork: { ...common("artwork-1", 7356953), type: "artwork", artwork: { kind: "library", id: "heart" }, size: 260, strokeWidth: 8, construction: "outline" }
+};
+var DEFAULT_NEON_SCENE = {
+  type: "neonScene",
+  version: 1,
+  stage: { width: 1600, height: 1e3 },
+  elements: [DEFAULT_NEON_ELEMENTS.text],
+  wall: DEFAULT_NEON_WALL,
+  audio: DEFAULT_NEON_AUDIO,
+  timeline: { duration: 8e3, loop: true, triggers: [] }
+};
+var isObj6 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function merge(base4, over) {
+  if (!isObj6(base4) || !isObj6(over)) return over === void 0 ? base4 : over;
+  const out = { ...base4 };
+  for (const [k, v] of Object.entries(over)) {
+    if (v === void 0) continue;
+    out[k] = isObj6(out[k]) && isObj6(v) ? merge(out[k], v) : v;
+  }
+  return out;
+}
+function withDerivedColours(el, input) {
+  const n = isObj6(input) && isObj6(input.neon) ? input.neon : void 0;
+  const primary = n && typeof n.color === "string" ? n.color : n && typeof n.tubeColor === "string" ? n.tubeColor : void 0;
+  if (!n || !isHexColor(primary)) return el;
+  const d = deriveNeonPalette(primary);
+  const neon = { ...el.neon, color: primary };
+  for (const k of ["coreColor", "tubeColor", "glowColor", "bloomColor"]) if (n[k] === void 0) neon[k] = d[k];
+  return { ...el, neon };
+}
+function resolveNeonElement(input, index = 0) {
+  const type = isObj6(input) && (input.type === "emoji" || input.type === "artwork") ? input.type : "text";
+  const base4 = DEFAULT_NEON_ELEMENTS[type];
+  const seeded = { ...base4, id: `${type}-${index + 1}`, animation: { ...base4.animation, seed: base4.animation.seed + index * 101 } };
+  const el = merge(seeded, isObj6(input) ? input : {});
+  return withDerivedColours({ ...el, type }, input);
+}
+function resolveNeonScene(input) {
+  const i = isObj6(input) ? input : {};
+  const elements = Array.isArray(i.elements) ? i.elements.map((e, n) => resolveNeonElement(e, n)) : DEFAULT_NEON_SCENE.elements;
+  return {
+    ...DEFAULT_NEON_SCENE,
+    stage: merge(DEFAULT_NEON_SCENE.stage, i.stage),
+    wall: merge(DEFAULT_NEON_SCENE.wall, i.wall),
+    audio: merge(DEFAULT_NEON_SCENE.audio, i.audio),
+    timeline: merge(DEFAULT_NEON_SCENE.timeline, i.timeline),
+    elements
+  };
+}
+var num9 = (v, min, max) => typeof v === "number" && Number.isFinite(v) && v >= min && v <= max;
+var WALL_RANGES = [
+  ["brickWidth", 20, 1e3],
+  ["brickHeight", 10, 500],
+  ["mortar", 0, 40],
+  ["variation", 0, 1],
+  ["texture", 0, 1],
+  ["ambient", 0, 1],
+  ["vignette", 0, 1],
+  ["lightSpill", 0, 2],
+  ["spillRadius", 0, 2e3],
+  ["seed", 0, 4294967295]
+];
+var AUDIO_KEYS = ["master", "hum", "flicker", "dip", "failure", "glitch", "recovery", "scrubVolume"];
+function textLike(el) {
+  if (el.type === "text") return { text: el.text, typography: el.typography };
+  return {
+    text: emojiText(el.emoji),
+    typography: { fontFamily: el.fontFamily, fontSize: el.size, fontWeight: el.fontWeight, fontStyle: "normal", letterSpacing: 0, lineHeight: 1, strokeWidth: el.strokeWidth, construction: el.construction, align: "middle" }
+  };
+}
+var emojiText = (e) => `${String(e ?? "").replace(/️/g, "")}\uFE0E`;
+function validateNeonElement(el, at = "") {
+  if (!isObj6(el)) return [{ path: at, message: "An element must be an object." }];
+  const errors = [];
+  const p = (k) => at ? `${at}.${k}` : k;
+  if (!["text", "emoji", "artwork"].includes(el.type)) errors.push({ path: p("type"), message: "Must be text, emoji or artwork." });
+  if (typeof el.id !== "string" || !el.id) errors.push({ path: p("id"), message: "Must be a non-empty id." });
+  for (const [k, lo, hi] of [["x", -5e3, 1e4], ["y", -5e3, 1e4], ["scale", 0.01, 20], ["rotation", -360, 360], ["opacity", 0, 1]]) {
+    if (!num9(el[k], lo, hi)) errors.push({ path: p(k), message: `Must be a number between ${lo} and ${hi}.` });
+  }
+  if (typeof el.visible !== "boolean") errors.push({ path: p("visible"), message: "Must be true or false." });
+  if (typeof el.locked !== "boolean") errors.push({ path: p("locked"), message: "Must be true or false." });
+  const asText = { ...DEFAULT_NEON_CONFIG, neon: el.neon, animation: el.animation };
+  for (const e of validateNeonConfig(asText)) if (e.path.startsWith("neon") || e.path.startsWith("animation")) errors.push({ path: p(e.path), message: e.message });
+  if (el.type === "text") {
+    for (const e of validateNeonConfig({ ...DEFAULT_NEON_CONFIG, text: el.text, typography: el.typography })) if (e.path === "text" || e.path.startsWith("typography")) errors.push({ path: p(e.path), message: e.message });
+  } else if (el.type === "emoji" || el.type === "artwork") {
+    if (!num9(el.size, 8, 2e3)) errors.push({ path: p("size"), message: "Must be a number between 8 and 2000." });
+    if (!num9(el.strokeWidth, 0.5, 80)) errors.push({ path: p("strokeWidth"), message: "Must be a number between 0.5 and 80." });
+    if (el.construction !== "outline" && el.construction !== "monoline") errors.push({ path: p("construction"), message: "Must be outline or monoline." });
+    if (el.type === "emoji") {
+      if (typeof el.emoji !== "string" || !el.emoji.trim() || [...el.emoji].length > 12) errors.push({ path: p("emoji"), message: "Must be one emoji (or a few characters)." });
+      if (!num9(el.fontWeight, 100, 900)) errors.push({ path: p("fontWeight"), message: "Must be between 100 and 900." });
+      if (typeof el.fontFamily !== "string" || !el.fontFamily.trim()) errors.push({ path: p("fontFamily"), message: "Must be a font-family." });
+    } else {
+      const a = el.artwork;
+      if (!isObj6(a)) errors.push({ path: p("artwork"), message: "Must be { kind: library | svg | raster, \u2026 }." });
+      else if (a.kind === "library") {
+        if (!NEON_ARTWORK_LIBRARY[a.id]) errors.push({ path: p("artwork.id"), message: `Must be one of: ${Object.keys(NEON_ARTWORK_LIBRARY).join(", ")}.` });
+      } else if (a.kind === "svg") {
+        try {
+          parseSvgArtwork(a.svg);
+        } catch (err) {
+          errors.push({ path: p("artwork.svg"), message: err.message });
+        }
+      } else if (a.kind === "raster") {
+        if (typeof a.src !== "string" || !/^(data:image\/(png|webp|jpeg|gif);base64,|https?:\/\/|\/)/.test(a.src)) errors.push({ path: p("artwork.src"), message: "Must be a PNG/WebP data URL or an image URL." });
+        if (!num9(a.width, 1, 2e4) || !num9(a.height, 1, 2e4)) errors.push({ path: p("artwork.width"), message: "Width and height must be the image\u2019s pixel size." });
+        if (a.mode !== "alpha" && a.mode !== "luminance") errors.push({ path: p("artwork.mode"), message: "Must be alpha or luminance." });
+        if (!num9(a.threshold, 0, 1)) errors.push({ path: p("artwork.threshold"), message: "Must be between 0 and 1." });
+      } else errors.push({ path: p("artwork.kind"), message: "Must be library, svg or raster." });
+    }
+  }
+  return errors;
+}
+function validateNeonScene(scene) {
+  if (!isObj6(scene)) return [{ path: "", message: "The scene must be an object." }];
+  const errors = [];
+  const st = scene.stage;
+  if (!isObj6(st) || !num9(st.width, 100, 8e3) || !num9(st.height, 100, 8e3)) errors.push({ path: "stage", message: "width and height must be 100\u20268000." });
+  if (!Array.isArray(scene.elements)) errors.push({ path: "elements", message: "Must be a list." });
+  else {
+    if (scene.elements.length > 40) errors.push({ path: "elements", message: "At most 40 elements." });
+    const ids = /* @__PURE__ */ new Set();
+    scene.elements.forEach((el, i) => {
+      errors.push(...validateNeonElement(el, `elements.${i}`));
+      if (isObj6(el) && typeof el.id === "string") {
+        if (ids.has(el.id)) errors.push({ path: `elements.${i}.id`, message: "Ids must be unique." });
+        ids.add(el.id);
+      }
+    });
+  }
+  const w = scene.wall;
+  if (!isObj6(w)) errors.push({ path: "wall", message: "Must be an object." });
+  else {
+    if (typeof w.enabled !== "boolean") errors.push({ path: "wall.enabled", message: "Must be true or false." });
+    for (const [k, lo, hi] of WALL_RANGES) if (!num9(w[k], lo, hi)) errors.push({ path: `wall.${k}`, message: `Must be a number between ${lo} and ${hi}.` });
+    for (const k of ["brickColor", "mortarColor", "ambientColor"]) if (!isHexColor(w[k])) errors.push({ path: `wall.${k}`, message: "Must be a hex colour." });
+  }
+  const a = scene.audio;
+  if (!isObj6(a)) errors.push({ path: "audio", message: "Must be an object." });
+  else {
+    for (const k of ["enabled", "muted", "scrub"]) if (typeof a[k] !== "boolean") errors.push({ path: `audio.${k}`, message: "Must be true or false." });
+    for (const k of AUDIO_KEYS) if (!num9(a[k], 0, 1)) errors.push({ path: `audio.${k}`, message: "Must be a number between 0 and 1." });
+  }
+  const t = scene.timeline;
+  if (!isObj6(t) || !num9(t.duration, 500, 6e5) || typeof t.loop !== "boolean" || !Array.isArray(t.triggers)) errors.push({ path: "timeline", message: "Needs duration (500\u2026600000 ms), loop and a triggers list." });
+  else t.triggers.forEach((tr, i) => {
+    if (!isObj6(tr) || !["sag", "flicker", "dip", "failure", "glitch", "normal"].includes(tr.kind) || !num9(tr.at, 0, 6e5)) errors.push({ path: `timeline.triggers.${i}`, message: "Needs kind (sag, flicker, dip, failure, glitch, normal) and at (ms)." });
+  });
+  return errors;
+}
+var r3 = (v) => Math.round(v * 1e3) / 1e3;
+function localNeon(neon, k) {
+  return { ...neon, glowRadius: neon.glowRadius * k, bloomRadius: neon.bloomRadius * k, shadow: { ...neon.shadow, blur: neon.shadow.blur * k } };
+}
+function elementGeometry(el, measure = estimateTextWidth) {
+  let shape;
+  let box;
+  let unit2 = 1;
+  let em;
+  let metrics;
+  if (el.type === "text" || el.type === "emoji") {
+    const { text: text6, typography } = textLike(el);
+    const layout = layoutText(text6, typography, 0, el.type === "emoji" ? () => typography.fontSize * 1.05 : measure);
+    shape = { kind: "text", layout, typography, text: text6 };
+    box = layout.box;
+    em = typography.fontSize;
+    metrics = { fontSize: typography.fontSize, strokeWidth: typography.strokeWidth, construction: typography.construction };
+  } else {
+    let vb = [0, 0, 100, 100];
+    const a = el.artwork;
+    try {
+      if (a.kind === "raster") {
+        const w = Math.max(1, el.size);
+        const h = w * a.height / Math.max(1, a.width);
+        vb = [0, 0, a.width >= a.height ? w : w * a.width / a.height, a.width >= a.height ? h : w];
+        shape = { kind: "raster", src: a.src, width: vb[2], height: vb[3], mode: a.mode, threshold: a.threshold };
+      } else {
+        const art = parseSvgArtwork(a.kind === "library" ? (NEON_ARTWORK_LIBRARY[a.id] ?? NEON_ARTWORK_LIBRARY.heart).svg : a.svg);
+        vb = art.viewBox;
+        shape = { kind: "svg", art };
+      }
+    } catch (err) {
+      shape = { kind: "none", reason: err.message };
+    }
+    const side = Math.max(vb[2], vb[3]);
+    unit2 = side / Math.max(1, el.size);
+    box = { x: vb[0], y: vb[1], width: vb[2], height: vb[3] };
+    em = side;
+    metrics = { fontSize: side, strokeWidth: el.strokeWidth * unit2, construction: el.construction };
+  }
+  const neon = unit2 === 1 ? el.neon : localNeon(el.neon, unit2);
+  const pad = materialPad(neon, metrics);
+  const cx = box.x + box.width / 2;
+  const cy = box.y + box.height / 2;
+  const s = el.scale / unit2;
+  const transform = `translate(${r3(el.x)} ${r3(el.y)}) rotate(${r3(el.rotation)}) scale(${r3(s)}) translate(${r3(-cx)} ${r3(-cy)})`;
+  const hw = box.width / 2 * s;
+  const hh = box.height / 2 * s;
+  const rad = el.rotation * Math.PI / 180;
+  const bw = Math.abs(hw * Math.cos(rad)) + Math.abs(hh * Math.sin(rad));
+  const bh = Math.abs(hw * Math.sin(rad)) + Math.abs(hh * Math.cos(rad));
+  return { shape, box, unit: unit2, em, metrics, neon, pad, transform, bounds: { x: el.x - bw, y: el.y - bh, width: 2 * bw, height: 2 * bh } };
+}
+var fontFor = (id) => NEON_FONTS.find((x) => x.id === id);
+function textEl(id, text6, fontId, color4, over = {}) {
+  const font = fontFor(fontId);
+  return {
+    id,
+    type: "text",
+    text: text6,
+    typography: { fontFamily: font.family, fontWeight: font.weight, construction: font.construction, fontSize: 300, strokeWidth: Math.round(300 * font.stroke * 2) / 2, ...over.typography ?? {} },
+    neon: color4,
+    ...Object.fromEntries(Object.entries(over).filter(([k]) => k !== "typography"))
+  };
+}
+var anim = (o) => o;
+var NEON_SCENE_PRESETS = [
+  { id: "cafe-red", name: "CAFE RED", description: "The reference: red outline CAFE on a navy brick wall.", scene: { elements: [textEl("text-1", "CAFE", "oswald", NEON_COLOR_PRESETS.red, { animation: anim({ flickerIntensity: 0.18, flickerFrequency: 0.25, glitchFrequency: 0.1 }) })] } },
+  { id: "cafe-blue", name: "CAFE BLUE", description: "CAFE in ice blue.", scene: { elements: [textEl("text-1", "CAFE", "oswald", NEON_COLOR_PRESETS.blue)] } },
+  { id: "cafe-purple", name: "CAFE PURPLE", description: "CAFE in violet.", scene: { elements: [textEl("text-1", "CAFE", "oswald", NEON_COLOR_PRESETS.purple)] } },
+  { id: "cafe-green", name: "CAFE GREEN", description: "CAFE in acid green.", scene: { elements: [textEl("text-1", "CAFE", "oswald", NEON_COLOR_PRESETS.green)] } },
+  {
+    id: "retro-red",
+    name: "RETRO RED",
+    description: "A 1950s diner sign: Righteous, warm red, a tired transformer.",
+    scene: {
+      elements: [
+        textEl("text-1", "DINER", "righteous", { color: "#FF3040" }, { y: 470, animation: anim({ flickerIntensity: 0.3, flickerFrequency: 0.45, flickerRandomness: 0.8, glitchEnabled: false }) }),
+        { id: "artwork-1", type: "artwork", artwork: { kind: "library", id: "star" }, size: 170, x: 1370, y: 300, rotation: 12, neon: { color: "#FFC24A" }, animation: { seed: 91 } }
+      ],
+      wall: { ambientColor: "#3A1F7A", ambient: 0.45, lightSpill: 1.2 },
+      audio: { hum: 0.55, failure: 0.7 }
+    }
+  },
+  {
+    id: "cyber-blue",
+    name: "CYBER BLUE",
+    description: "Orbitron in electric blue with frequent digital glitches.",
+    scene: {
+      elements: [textEl("text-1", "CYBER", "orbitron", NEON_COLOR_PRESETS.blue, { animation: anim({ flickerIntensity: 0.12, flickerFrequency: 0.15, glitchIntensity: 0.6, glitchFrequency: 0.35, glitchRgbSplit: 1.6 }) })],
+      wall: { ambientColor: "#0D3DD8", ambient: 0.6 },
+      audio: { glitch: 0.5 }
+    }
+  },
+  {
+    id: "purple-night",
+    name: "PURPLE NIGHT",
+    description: "A handwritten \u201Cnight\u201D under a neon moon.",
+    scene: {
+      elements: [
+        textEl("text-1", "night", "sacramento", NEON_COLOR_PRESETS.purple, { y: 540, typography: { fontSize: 420, strokeWidth: 9 } }),
+        { id: "emoji-1", type: "emoji", emoji: "\u{1F319}", size: 200, x: 1200, y: 290, neon: { color: "#E0B3FF" }, animation: { seed: 7356951 } }
+      ],
+      wall: { ambientColor: "#4A1FB8", ambient: 0.5 }
+    }
+  },
+  {
+    id: "electric-green",
+    name: "ELECTRIC GREEN",
+    description: "Audiowide \u201C24/7\u201D with a bolt, both on one circuit.",
+    scene: {
+      elements: [
+        textEl("text-1", "24/7", "audiowide", NEON_COLOR_PRESETS.green, { x: 700, animation: anim({ seed: 4242, flickerIntensity: 0.22, flickerFrequency: 0.3 }) }),
+        { id: "emoji-1", type: "emoji", emoji: "\u26A1", size: 230, x: 1300, y: 480, neon: { color: "#F4FF3A" }, animation: { seed: 4242, flickerIntensity: 0.22, flickerFrequency: 0.3 } }
+      ],
+      wall: { ambientColor: "#123A7A", ambient: 0.5 }
+    }
+  },
+  {
+    id: "warm-white",
+    name: "WARM WHITE",
+    description: "Tilt Neon \u201CHello\u201D in warm white; nearly steady.",
+    scene: {
+      elements: [textEl("text-1", "Hello", "tilt-neon", { color: "#FFE3B8", coreColor: "#FFFFFF", tubeColor: "#FFE3B8", glowColor: "#FFC98A", bloomColor: "#C98A3A" }, { typography: { fontSize: 340, strokeWidth: 12 }, animation: anim({ flickerIntensity: 0.06, flickerFrequency: 0.05, glitchEnabled: false }) })],
+      wall: { ambientColor: "#2A2A6A", ambient: 0.4, lightSpill: 1.3 },
+      audio: { hum: 0.35 }
+    }
+  }
+];
+var NEON_NAMED_COLORS = {
+  red: NEON_COLOR_PRESETS.red.color,
+  blue: NEON_COLOR_PRESETS.blue.color,
+  purple: NEON_COLOR_PRESETS.purple.color,
+  green: NEON_COLOR_PRESETS.green.color,
+  pink: "#FF4FB8",
+  magenta: "#FF2BD6",
+  cyan: "#2BF7FF",
+  teal: "#1FFFD0",
+  amber: "#FFB300",
+  orange: "#FF7A1A",
+  yellow: "#F4FF3A",
+  white: "#F2F6FF",
+  "warm white": "#FFE3B8",
+  "cool white": "#DDEBFF",
+  violet: "#9C5BFF",
+  lime: "#B6FF2B"
+};
+var NEON_FLICKER_LEVELS = {
+  none: { flickerEnabled: false, flickerIntensity: 0, flickerFrequency: 0 },
+  subtle: { flickerEnabled: true, flickerIntensity: 0.1, flickerFrequency: 0.06 },
+  medium: { flickerEnabled: true, flickerIntensity: 0.2, flickerFrequency: 0.2 },
+  heavy: { flickerEnabled: true, flickerIntensity: 0.3, flickerFrequency: 0.5 },
+  failing: { flickerEnabled: true, flickerIntensity: 0.6, flickerFrequency: 1.2 }
+};
+var NEON_GLITCH_LEVELS = {
+  none: { glitchEnabled: false, glitchIntensity: 0, glitchFrequency: 0 },
+  rare: { glitchEnabled: true, glitchIntensity: 0.15, glitchFrequency: 0.03 },
+  occasional: { glitchEnabled: true, glitchIntensity: 0.3, glitchFrequency: 0.1 },
+  frequent: { glitchEnabled: true, glitchIntensity: 0.5, glitchFrequency: 0.35 }
+};
+function neonColor(nameOrHex) {
+  if (isHexColor(nameOrHex)) return nameOrHex.toUpperCase();
+  return NEON_NAMED_COLORS[String(nameOrHex).trim().toLowerCase().replace(/[-_]+/g, " ")];
+}
+function neonElementFromSpec(spec, index = 0) {
+  const type = spec.type ?? (spec.emoji ? "emoji" : spec.artwork ? "artwork" : "text");
+  const out = { type, id: spec.id ?? `${type}-${index + 1}` };
+  const color4 = spec.color ? neonColor(spec.color) : void 0;
+  if (color4) out.neon = { color: color4 };
+  const flicker = spec.flicker ? NEON_FLICKER_LEVELS[spec.flicker] : void 0;
+  const glitch = spec.glitch ? NEON_GLITCH_LEVELS[spec.glitch] : void 0;
+  if (flicker || glitch) out.animation = { ...flicker, ...glitch };
+  if (type === "text") {
+    out.text = spec.text ?? "OPEN";
+    const font = spec.font ? findNeonFont(spec.font) : void 0;
+    const size = spec.size ?? 300;
+    out.typography = { fontSize: size, ...font ? { fontFamily: font.family, fontWeight: font.weight, construction: font.construction, strokeWidth: Math.max(2, Math.round(size * font.stroke * 2) / 2) } : {} };
+  } else if (type === "emoji") {
+    out.emoji = spec.emoji ?? "\u2B50";
+    out.size = spec.size ?? 240;
+  } else {
+    const art = spec.artwork ?? "heart";
+    out.artwork = NEON_ARTWORK_LIBRARY[art] ? { kind: "library", id: art } : { kind: "svg", svg: art };
+    out.size = spec.size ?? 260;
+  }
+  return out;
+}
+
+// tools/ask/neon.ts
+var NEON_TEMPLATE = "neon-sign";
+var NEON_RENDER_TOOL = "render_neon_sign";
+var NEON_FORMATS = ["mp4", "webm", "gif"];
+var STAGE_WIDTH = 1600;
+var DEFAULT_FONT = "oswald";
+var DEFAULT_SEED = 7356951;
+var COLOR_NAMES = Object.keys(NEON_NAMED_COLORS);
+var FONT_IDS = NEON_FONTS.map((f2) => f2.id);
+var FLICKER = Object.keys(NEON_FLICKER_LEVELS);
+var GLITCH = Object.keys(NEON_GLITCH_LEVELS);
+var ARTWORK = Object.keys(NEON_ARTWORK_LIBRARY);
+var TRIGGER_KINDS = ["sag", "flicker", "dip", "failure", "glitch", "normal"];
+var colorField = (what) => ({ type: "string", description: `${what} A hex colour (#FF4FB8) or a name: ${COLOR_NAMES.join(", ")}.` });
+var LOOK = {
+  color: colorField("The neon colour; core, tube, glow and bloom derive from it unless given."),
+  tubeColor: colorField("The lit glass."),
+  coreColor: colorField("The hot centre line."),
+  glowColor: colorField("The tight halo around the tube."),
+  bloomColor: colorField("The wide light thrown on the wall."),
+  font: { type: "string", enum: FONT_IDS, description: "A neon font by id." },
+  fontSize: { type: "number", description: "Letter height in stage units (the stage is 1600 wide). Default 300. Signs wider than the stage are scaled to fit." },
+  flicker: { type: "string", enum: FLICKER, description: "How much the tube flickers." },
+  glitch: { type: "string", enum: GLITCH, description: "How often the sign glitches." }
+};
+var NEON_INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    text: { type: "string", description: 'The sign, when it is one piece in one colour ("OPEN"; "\\n" starts a new line). For several pieces or colours use `elements`.' },
+    elements: {
+      type: "array",
+      description: 'The pieces of the sign, in reading order. Each has its own colour, font and animation, so "EG in pink, LAB in green" is two text elements. Pieces without x/y are placed side by side (see `layout`, `gap`) and centred. The scene contains exactly these and nothing else.',
+      items: {
+        type: "object",
+        properties: {
+          type: { type: "string", enum: ["text", "emoji", "artwork"], description: "Default: text, or emoji / artwork when that field is given." },
+          text: { type: "string", description: "The letters of a text element." },
+          emoji: { type: "string", description: "One emoji, drawn as a neon outline." },
+          artwork: { type: "string", description: `A library shape (${ARTWORK.join(", ")}) or SVG markup.` },
+          ...LOOK,
+          size: { type: "number", description: "Emoji or artwork size in stage units." },
+          x: { type: "number", description: "Centre x in stage units (0\u20261600). Omit to place automatically." },
+          y: { type: "number", description: "Centre y in stage units. Omit to place automatically." },
+          scale: { type: "number" },
+          rotation: { type: "number", description: "Degrees, clockwise." },
+          opacity: { type: "number", description: "0\u20261." },
+          id: { type: "string", description: "A name for `triggers[].target`." },
+          neon: { type: "object", description: "Advanced material overrides: intensity (0\u20263), bloomIntensity, tubeBrightness, coreBrightness, glowRadius, bloomRadius, coreWidth, glassOpacity, shadow { enabled, color, opacity, offsetX, offsetY, blur }." },
+          animation: { type: "object", description: "Advanced animation overrides: speed, seed, flickerEnabled, flickerIntensity (0\u20261), flickerFrequency (events per second), flickerSpeed, flickerRandomness, flickerRecovery, flickerMinBrightness, glitchEnabled, glitchIntensity (0\u20261), glitchFrequency, glitchDuration (ms), glitchDisplacement, glitchRgbSplit, glitchSlices, glitchGlowSeparation." },
+          typography: { type: "object", description: "Advanced letter overrides: letterSpacing, lineHeight, strokeWidth, fontWeight, fontStyle (normal | italic), construction (outline | monoline), align (start | middle | end)." }
+        }
+      }
+    },
+    ...LOOK,
+    layout: { type: "string", enum: ["row", "column"], description: "How automatically placed elements are arranged. Default row." },
+    gap: { type: "number", description: "Space between neighbouring elements in stage units. Default 0 in a row: adjacent text elements sit a letter apart and read as one word; about 0.3 \xD7 fontSize is a word space." },
+    sync: { type: "boolean", description: "true (default): every element flickers together, as one sign on one circuit. false: each flickers on its own." },
+    seed: { type: "number", description: "Same seed, same performance. Change it for a different, equally natural one." },
+    background: {
+      type: "object",
+      description: "What is behind the sign. Default: a dark navy brick wall lit by the neon.",
+      properties: {
+        type: { type: "string", enum: ["brick-wall", "none"], description: "none: a flat `color` and no wall." },
+        color: { type: "string", description: "Hex. The flat background when type is none. Default #000000." },
+        brickColor: { type: "string", description: "Hex. Darker reads as a darker wall." },
+        mortarColor: { type: "string", description: "Hex." },
+        ambientColor: { type: "string", description: "Hex. The room's own light on the wall." },
+        ambient: { type: "number", description: "0\u20261. Lower is a darker room." },
+        lightSpill: { type: "number", description: "0\u20262. How strongly the neon lights the wall." },
+        spillRadius: { type: "number", description: "How far that light reaches, stage units." },
+        vignette: { type: "number", description: "0\u20261. Edge darkening." },
+        texture: { type: "number", description: "0\u20261. Surface grain." },
+        variation: { type: "number", description: "0\u20261. Brick-to-brick shade variation." },
+        brickWidth: { type: "number" },
+        brickHeight: { type: "number" },
+        mortar: { type: "number" },
+        seed: { type: "number" }
+      }
+    },
+    triggers: {
+      type: "array",
+      description: "Scripted moments on top of the natural flicker.",
+      items: {
+        type: "object",
+        properties: {
+          kind: { type: "string", enum: TRIGGER_KINDS },
+          at: { type: "number", description: "Seconds from the start." },
+          target: { type: "string", description: "An element id; omit for every element." }
+        },
+        required: ["kind", "at"]
+      }
+    },
+    duration: { type: "number", description: "Seconds, 0.5\u202660. Default 6." },
+    fps: { type: "number", description: "Frames per second, 1\u202660. Default 30." },
+    format: { type: "string", enum: [...NEON_FORMATS], description: "Default mp4 (H.264)." },
+    width: { type: "number", description: "Output width in pixels, 320\u20263840. Default 1920." },
+    height: { type: "number", description: "Output height in pixels, 180\u20262160. Default 1080." }
+  }
+};
+var TOP_KEYS = Object.keys(NEON_INPUT_SCHEMA.properties);
+var ELEMENT_KEYS = Object.keys(NEON_INPUT_SCHEMA.properties.elements.items.properties);
+var BACKGROUND_KEYS = Object.keys(NEON_INPUT_SCHEMA.properties.background.properties);
+var WALL_NUMBERS = ["ambient", "lightSpill", "spillRadius", "vignette", "texture", "variation", "brickWidth", "brickHeight", "mortar", "seed"];
+var WALL_COLORS = ["brickColor", "mortarColor", "ambientColor"];
+var COLOR_KEYS2 = ["color", "tubeColor", "coreColor", "glowColor", "bloomColor"];
+var isObj7 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var even = (n) => Math.max(2, Math.round(n / 2) * 2);
+var r32 = (v) => Math.round(v * 1e3) / 1e3;
+function elementInput(spec, defaults, i, at, sync, seed, errors) {
+  const before = errors.length;
+  const bad = (key, message) => errors.push({ path: `${at}.${key}`, message });
+  for (const k of Object.keys(spec)) if (!ELEMENT_KEYS.includes(k)) bad(k, `Unknown key. An element takes: ${ELEMENT_KEYS.join(", ")}.`);
+  const type = spec.type ?? (spec.emoji !== void 0 ? "emoji" : spec.artwork !== void 0 ? "artwork" : "text");
+  if (!["text", "emoji", "artwork"].includes(type)) {
+    bad("type", "Must be text, emoji or artwork.");
+    return null;
+  }
+  const content = spec[type];
+  if (typeof content !== "string" || !content.trim()) bad(type, type === "text" ? "A text element needs its text." : type === "emoji" ? "An emoji element needs its emoji." : `An artwork element needs a library shape (${ARTWORK.join(", ")}) or SVG markup.`);
+  const pick = (k) => spec[k] ?? defaults[k];
+  const colors = {};
+  for (const k of COLOR_KEYS2) {
+    const v = pick(k);
+    if (v === void 0) continue;
+    const hex = typeof v === "string" ? neonColor(v) : void 0;
+    if (hex) colors[k] = hex;
+    else errors.push({ path: `${spec[k] !== void 0 ? `${at}.` : ""}${k}`, message: `Must be a hex colour like #FF4FB8 or one of: ${COLOR_NAMES.join(", ")}.` });
+  }
+  const fontQuery = pick("font") ?? DEFAULT_FONT;
+  const font = typeof fontQuery === "string" ? findNeonFont(fontQuery) : void 0;
+  if (!font) errors.push({ path: `${spec.font !== void 0 ? `${at}.` : ""}font`, message: `Must be one of: ${FONT_IDS.join(", ")}.` });
+  const flicker = pick("flicker");
+  if (flicker !== void 0 && !FLICKER.includes(flicker)) errors.push({ path: `${spec.flicker !== void 0 ? `${at}.` : ""}flicker`, message: `Must be one of: ${FLICKER.join(", ")}.` });
+  const glitch = pick("glitch");
+  if (glitch !== void 0 && !GLITCH.includes(glitch)) errors.push({ path: `${spec.glitch !== void 0 ? `${at}.` : ""}glitch`, message: `Must be one of: ${GLITCH.join(", ")}.` });
+  for (const k of ["size", "x", "y", "scale", "rotation", "opacity"]) if (spec[k] !== void 0 && (typeof spec[k] !== "number" || !Number.isFinite(spec[k]))) bad(k, "Must be a number.");
+  const fontSize = pick("fontSize");
+  if (fontSize !== void 0 && (typeof fontSize !== "number" || !Number.isFinite(fontSize))) errors.push({ path: `${spec.fontSize !== void 0 ? `${at}.` : ""}fontSize`, message: "Must be a number." });
+  for (const k of ["neon", "animation", "typography"]) if (spec[k] !== void 0 && !isObj7(spec[k])) bad(k, "Must be an object.");
+  if (spec.id !== void 0 && (typeof spec.id !== "string" || !spec.id)) bad("id", "Must be a non-empty id.");
+  if (errors.length > before) return null;
+  const base4 = neonElementFromSpec({
+    type,
+    [type]: content,
+    id: spec.id,
+    font: font.id,
+    flicker,
+    glitch,
+    size: type === "text" ? fontSize : spec.size
+  }, i);
+  const out = { ...base4 };
+  out.neon = { ...colors, ...spec.neon };
+  out.animation = { ...base4.animation, ...sync ? { seed } : {}, ...spec.animation };
+  if (type === "text") out.typography = { ...base4.typography, ...spec.typography };
+  for (const k of ["x", "y", "scale", "rotation", "opacity"]) if (spec[k] !== void 0) out[k] = spec[k];
+  return out;
+}
+function arrange(scene, auto, column, gap, measure) {
+  const placed = scene.elements.filter((e) => auto.has(e.id));
+  if (!placed.length) return scene;
+  const { width: W, height: H } = scene.stage;
+  const boxes = placed.map((e) => elementGeometry({ ...e, x: 0, y: 0 }, measure).bounds);
+  const em = Math.max(...placed.map((e) => (e.type === "text" ? e.typography.fontSize : e.size) * e.scale));
+  const g = gap ?? (column ? em * 0.12 : 0);
+  const along = (b) => column ? b.height : b.width;
+  const across = (b) => column ? b.width : b.height;
+  const total = boxes.reduce((s, b) => s + along(b), 0) + g * (boxes.length - 1);
+  const room = column ? H * 0.8 : W * 0.86;
+  const roomAcross = column ? W * 0.86 : H * 0.72;
+  const k = Math.min(1, room / Math.max(1, total), roomAcross / Math.max(1, ...boxes.map(across)));
+  let cursor = ((column ? H : W) - total * k) / 2;
+  const at = /* @__PURE__ */ new Map();
+  placed.forEach((e, n) => {
+    const centre = cursor + along(boxes[n]) * k / 2;
+    cursor += (along(boxes[n]) + g) * k;
+    at.set(e.id, column ? { x: W / 2, y: r32(centre), scale: r32(e.scale * k) } : { x: r32(centre), y: H / 2, scale: r32(e.scale * k) });
+  });
+  return { ...scene, elements: scene.elements.map((e) => at.has(e.id) ? { ...e, ...at.get(e.id) } : e) };
+}
+function buildNeonScene(content, measure = estimateTextWidth) {
+  if (!isObj7(content)) return { valid: false, errors: [{ path: "", message: "Must be an object with `text` or `elements`." }] };
+  const errors = [];
+  for (const k of Object.keys(content)) if (!TOP_KEYS.includes(k)) errors.push({ path: k, message: `Unknown key. A neon sign takes: ${TOP_KEYS.join(", ")}.` });
+  const specs = [];
+  if (content.text !== void 0 && typeof content.text !== "string") errors.push({ path: "text", message: "Must be text." });
+  else if (typeof content.text === "string" && content.text.trim()) specs.push({ spec: { text: content.text }, at: "text" });
+  if (content.elements !== void 0 && !Array.isArray(content.elements)) errors.push({ path: "elements", message: "Must be a list." });
+  else content.elements?.forEach((spec, i) => specs.push({ spec, at: `elements.${i}` }));
+  if (!specs.length && !errors.length) errors.push({ path: "elements", message: "Nothing to draw: give `text`, or `elements` with at least one piece." });
+  const num10 = (k, lo, hi, fallback2) => {
+    const v = content[k];
+    if (v === void 0) return fallback2;
+    if (typeof v !== "number" || !Number.isFinite(v) || v < lo || v > hi) {
+      errors.push({ path: k, message: `Must be a number between ${lo} and ${hi}.` });
+      return fallback2;
+    }
+    return v;
+  };
+  const durationSeconds = num10("duration", 0.5, 60, 6);
+  const fps = Math.round(num10("fps", 1, 60, 30));
+  const width = even(num10("width", 320, 3840, 1920));
+  const height = even(num10("height", 180, 2160, 1080));
+  const seed = num10("seed", 0, 4294967295, DEFAULT_SEED);
+  const gap = content.gap === void 0 ? void 0 : num10("gap", -2e3, 4e3, 0);
+  const format = content.format ?? "mp4";
+  if (!NEON_FORMATS.includes(format)) errors.push({ path: "format", message: `Must be one of: ${NEON_FORMATS.join(", ")}.` });
+  if (content.layout !== void 0 && content.layout !== "row" && content.layout !== "column") errors.push({ path: "layout", message: "Must be row or column." });
+  if (content.sync !== void 0 && typeof content.sync !== "boolean") errors.push({ path: "sync", message: "Must be true or false." });
+  const wall = {};
+  let backgroundColor = "#000000";
+  const bg = content.background;
+  if (bg !== void 0 && !isObj7(bg)) errors.push({ path: "background", message: "Must be an object." });
+  else if (isObj7(bg)) {
+    for (const k of Object.keys(bg)) if (!BACKGROUND_KEYS.includes(k)) errors.push({ path: `background.${k}`, message: `Unknown key. A background takes: ${BACKGROUND_KEYS.join(", ")}.` });
+    if (bg.type !== void 0 && bg.type !== "brick-wall" && bg.type !== "none") errors.push({ path: "background.type", message: "Must be brick-wall or none." });
+    wall.enabled = bg.type !== "none";
+    if (bg.color !== void 0) {
+      if (isHexColor(bg.color)) backgroundColor = bg.color;
+      else errors.push({ path: "background.color", message: "Must be a hex colour." });
+    }
+    for (const k of [...WALL_COLORS, ...WALL_NUMBERS]) if (bg[k] !== void 0) wall[k] = bg[k];
+  }
+  const triggers = [];
+  if (content.triggers !== void 0 && !Array.isArray(content.triggers)) errors.push({ path: "triggers", message: "Must be a list." });
+  else content.triggers?.forEach((t, i) => {
+    if (!isObj7(t) || !TRIGGER_KINDS.includes(t.kind) || typeof t.at !== "number" || t.at < 0 || t.at > durationSeconds) errors.push({ path: `triggers.${i}`, message: `Needs kind (${TRIGGER_KINDS.join(", ")}) and at (seconds, within the duration).` });
+    else triggers.push({ kind: t.kind, at: Math.round(t.at * 1e3), ...typeof t.target === "string" ? { target: t.target } : {} });
+  });
+  const auto = /* @__PURE__ */ new Set();
+  const inputs = [];
+  specs.forEach(({ spec, at }, i) => {
+    if (!isObj7(spec)) {
+      errors.push({ path: at, message: "An element must be an object." });
+      return;
+    }
+    const input = elementInput(spec, content, i, at, content.sync !== false, seed, errors);
+    if (!input) return;
+    if (spec.x === void 0 && spec.y === void 0) auto.add(String(input.id));
+    inputs.push(input);
+  });
+  if (errors.length) return { valid: false, errors };
+  const stage2 = { width: STAGE_WIDTH, height: Math.round(STAGE_WIDTH * height / width) };
+  let scene = resolveNeonScene({ stage: stage2, elements: inputs, wall, timeline: { duration: Math.round(durationSeconds * 1e3), loop: false, triggers } });
+  scene = arrange(scene, auto, content.layout === "column", gap, measure);
+  const sceneErrors = validateNeonScene(scene).map((e) => ({ path: e.path.replace(/^wall\./, "background."), message: e.message }));
+  if (sceneErrors.length) return { valid: false, errors: sceneErrors };
+  return { valid: true, errors: [], scene, backgroundColor, output: { format, width, height, durationSeconds, fps, frameCount: Math.max(1, Math.round(durationSeconds * fps)) } };
+}
+var neonSceneSummary = (scene) => scene.elements.map((e) => ({
+  id: e.id,
+  type: e.type,
+  content: e.type === "text" ? e.text : e.type === "emoji" ? e.emoji : e.artwork.kind === "library" ? e.artwork.id : "svg",
+  color: e.neon.color,
+  x: e.x,
+  y: e.y,
+  scale: e.scale
+}));
+var EXAMPLE = {
+  elements: [{ text: "HELLO", color: "cyan" }, { artwork: "heart", color: "pink" }],
+  font: "tilt-neon",
+  flicker: "medium",
+  glitch: "rare",
+  gap: 60,
+  background: { type: "brick-wall" },
+  duration: 6,
+  fps: 30,
+  format: "mp4"
+};
+function listNeonAnimation() {
+  return {
+    template: NEON_TEMPLATE,
+    version: 1,
+    title: "Neon sign",
+    description: `A neon sign on a brick wall: any text, emoji or artwork, each piece with its own colour and font, with natural flicker and glitches. Renders to a video file with ${NEON_RENDER_TOOL}.`,
+    canvas: { width: 1920, height: 1080 },
+    kind: "neonScene",
+    renderer: NEON_RENDER_TOOL,
+    seconds: 6,
+    slots: 0,
+    formats: ["MP4 (H.264)", "WebM (VP9)", "GIF", "JSON (motion/1)"]
+  };
+}
+function describeNeonAnimation() {
+  return {
+    template: NEON_TEMPLATE,
+    version: 1,
+    kind: "neonScene",
+    title: "Neon sign",
+    description: listNeonAnimation().description,
+    render: { tool: NEON_RENDER_TOOL, arguments: "The `content` below, plus an optional outputPath. Returns the video file's path." },
+    request: { schema: "motion/1", template: NEON_TEMPLATE, content: "<object: see inputSchema>" },
+    output: { width: 1920, height: 1080, fps: 30, seconds: 6, formats: [...NEON_FORMATS] },
+    rules: [
+      "The scene contains exactly the elements you send. Nothing is added.",
+      "One colour per element: text in two colours is two text elements, in reading order.",
+      "Elements without x/y are placed side by side and centred, a letter apart, so neighbouring text reads as one word; set `gap` to separate them.",
+      "Sizes and positions are stage units on a stage 1600 wide, whatever the output resolution.",
+      "Unknown keys, colours, fonts and levels are refused, never guessed."
+    ],
+    inputSchema: NEON_INPUT_SCHEMA,
+    colors: NEON_NAMED_COLORS,
+    fonts: NEON_FONTS.map((f2) => ({ id: f2.id, name: f2.name, category: f2.category })),
+    flicker: FLICKER,
+    glitch: GLITCH,
+    artwork: ARTWORK,
+    example: { schema: "motion/1", template: NEON_TEMPLATE, content: EXAMPLE }
+  };
+}
+function validateNeonRequest(request) {
+  if (!isObj7(request) || request.schema !== "motion/1" || request.template !== NEON_TEMPLATE) {
+    return { valid: false, errors: [{ path: "", message: `Must be { schema: "motion/1", template: "${NEON_TEMPLATE}", content }.` }] };
+  }
+  const b = buildNeonScene(request.content);
+  if (!b.valid) return { valid: false, errors: b.errors };
+  return { valid: true, seconds: b.output.durationSeconds, output: b.output, elements: neonSceneSummary(b.scene), request };
+}
+
 // tools/ask/components.ts
 function listComponents() {
   return [
@@ -29455,17 +30528,25 @@ function checkConfig(name, preset, config) {
 }
 export {
   AGENT_COMPONENTS,
+  NEON_INPUT_SCHEMA,
+  NEON_RENDER_TOOL,
+  NEON_TEMPLATE,
   agentAvailability,
+  buildNeonScene,
   checkConfig,
   describeComponent,
   describeMotionTemplate,
+  describeNeonAnimation,
   isAgentComponent,
   isComponent,
   listAgentComponents,
   listComponents,
   listMotionTemplates,
+  listNeonAnimation,
   motionPreviewUrl,
+  neonSceneSummary,
   searchComponents,
   validateMotionRequest,
+  validateNeonRequest,
   validateRenderRequest
 };