@popcraft/kit 0.53.3 → 0.53.5

package/dist/chunks/chunk-UCAHBPB6.js

@@ -0,0 +1,172 @@
+import { createRequire as __popcraftRequire } from 'node:module';
+import { fileURLToPath as __popcraftPath } from 'node:url';
+import { dirname as __popcraftDirname } from 'node:path';
+const require = __popcraftRequire(import.meta.url);
+const __filename = __popcraftPath(import.meta.url);
+const __dirname = __popcraftDirname(__filename);
+import {
+  brackets,
+  buzz,
+  cyberBrand,
+  fitBrackets,
+  fitGlitch,
+  fitRulers,
+  fitStreet,
+  glitch,
+  hazard,
+  holoBox,
+  lift,
+  plate,
+  rulers,
+  split,
+  street
+} from "./chunk-XVGKDWCY.js";
+import {
+  MONO
+} from "./chunk-AXAAXHZF.js";
+import {
+  HOLD,
+  blink,
+  cutOff,
+  cutOn
+} from "./chunk-CLQ3FUJI.js";
+import {
+  pill,
+  postVariants,
+  verticalPadding
+} from "./chunk-KOAJ6HD2.js";
+import {
+  defineTemplate
+} from "./chunk-YDW25Z3P.js";
+import {
+  Kit,
+  preset
+} from "./chunk-4G7VHQUV.js";
+import {
+  init_define_POPCRAFT_COMPONENT_IDS
+} from "./chunk-WKDVCZ45.js";
+
+// templates/src/social/cyberpunk-implant-post.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var DURATION = 7500;
+var RAIN = 768;
+var SPECS = [
+  ["Slot", "IMP-03 \xB7 any agent, any model"],
+  ["Trigger", "/deadbolt kill support-bot-7"],
+  ["Effect", "keys revoked, sessions dead"],
+  ["Latency", "300 ms, measured from Slack"]
+];
+var cues = [
+  blink("Neon accent", 0, 420),
+  blink("Neon secondary", 160, 420),
+  blink("Neon primary", 320, 380),
+  cutOn("Banner", 400),
+  cutOn("Name plate", 700),
+  blink("Headline", 700, 300),
+  { layer: "Glitch", preset: "impact-frame", at: 700, params: { duration: 170 } },
+  { layer: "Sub", preset: "fade-in", at: 1100, params: { duration: 500 } },
+  cutOn("Lock", 1400),
+  blink("Lock", 2e3, 300),
+  cutOn("Spec", 2100),
+  { layer: "Spec value", preset: "typewriter", at: 2300, params: { duration: 480 }, stagger: { delay: 520 } },
+  { layer: "Chip", preset: "pop-in", at: 4700, params: { duration: 360 } },
+  { layer: "Site", preset: "fade-in", at: 4900, params: { duration: 400 } },
+  { layer: "Chip", preset: "pulse", at: 5600, params: { duration: 700, amount: 0.05 } },
+  { layer: "Glitch", preset: "impact-frame", at: 6900, params: { duration: 170 } },
+  cutOff(["Banner", "Name plate", "Lock", "Spec", "Chip", "Site"], 7e3, 60)
+];
+var SCENE = {
+  post: { horizon: 0.84, courier: false, holo: 0.29, holoSize: 240, rate: RAIN },
+  portrait: { horizon: 0.84, courier: false, holo: 0.322, holoSize: 380, rate: RAIN },
+  vertical: { horizon: 0.76, courier: false, holo: 0.281, holoSize: 300, rate: RAIN }
+};
+function lockBox(w, h, o) {
+  const b = holoBox(w, h, o);
+  return { x: b.x - 24, y: b.y - 24, width: b.width + 48, height: b.height + 48 };
+}
+var cyberpunk_implant_post_default = defineTemplate({
+  id: "motion-cyberpunk-implant-post",
+  meta: {
+    name: "Cyberpunk new implant post (animated)",
+    description: "A feature announcement as a new implant: neon signs flicker on down a rain-slick street, NEW IMPLANT cuts on between hazard stripes, the feature\u2019s name lands with its colours split and a frame of glitch, a HUD\u2019s brackets lock onto a holographic padlock and the spec sheet is typed a line at a time \u2014 a seven-second loop, square with 4:5 and 9:16 cuts",
+    category: "animation",
+    tags: ["animation", "cyberpunk", "neon", "hud", "glitch", "rain", "hologram", "feature", "changelog", "security", "ai agents", "dev tool", "saas", "post", "mono", "loop"],
+    platforms: ["instagram", "linkedin", "x", "threads"],
+    formats: ["post", "portrait-post", "story"],
+    useCases: ["announcement", "changelog", "launch"],
+    created: "2026-10-02",
+    updated: "2026-10-02"
+  },
+  stableNumbers: true,
+  motion: { cues, loop: true },
+  build() {
+    const k = new Kit("Cyberpunk new implant post (animated)", preset("ig-post"));
+    k.quantizeGeometry = true;
+    cyberBrand(k, { feature: "KILL SWITCH" });
+    k.textStyle("Banner 26", { ...MONO, size: 26, fontWeight: 800, letterSpacing: 5, lineHeight: 32, textCase: "UPPER" });
+    k.textStyle("Display 132", { size: 132, fontWeight: 900, letterSpacing: -2.5, lineHeight: 122 });
+    k.textStyle("Sub 30", { size: 30, fontWeight: 500, lineHeight: 40 });
+    k.textStyle("Spec label 18", { ...MONO, size: 18, fontWeight: 700, letterSpacing: 2, lineHeight: 34, textCase: "UPPER" });
+    k.textStyle("Spec 24", { ...MONO, size: 24, fontWeight: 600, lineHeight: 34 });
+    k.textStyle("Chip 22", { ...MONO, size: 22, fontWeight: 800, lineHeight: 28 });
+    k.textStyle("Site 22", { ...MONO, size: 22, fontWeight: 700, lineHeight: 28 });
+    pill(k, "Chip", { fill: "primary", ink: "onPrimary", style: "Chip 22", label: "Installed on every plan today", pad: [13, 20], radius: 0 });
+    const sheet = k.sheet;
+    const W = 1080, H = 1080, PAD = 64;
+    k.flowSheet(sheet, 0, PAD, "paper", "SPACE_BETWEEN", "MIN");
+    k.patch(sheet, { clipsContent: true });
+    k.timeline(sheet, { duration: DURATION, fps: 30 });
+    const st = street(k, sheet, W, H, SCENE.post);
+    buzz(k, st);
+    rulers(k, sheet, W, H);
+    const top = k.stack(sheet, { gap: 0, name: "Top" });
+    const banner = k.stack(top, { gap: 0, name: "Banner" });
+    hazard(k, banner, 16);
+    const label = k.stack(banner, { fill: "primary", padding: { top: 8, right: 18, bottom: 8, left: 18 }, name: "Banner label" });
+    k.text(label, "New implant // {{brand.name}} 2.4", { style: "Banner 26", color: "onPrimary", name: "Banner words" });
+    hazard(k, banner, 16);
+    const bottom = k.stack(sheet, { gap: 16, name: "Bottom" });
+    const name = plate(k, bottom, { gap: 14, padding: { top: 26, right: 34, bottom: 30, left: 34 }, edge: "primary", tab: false, name: "Name plate", effects: [lift(k)] });
+    k.text(name, "{{brand.feature}}", { style: "Display 132", color: "onCard", name: "Headline", effects: split(k, 7) });
+    k.text(name, "Revoke any agent\u2019s credentials from Slack. Every session it holds dies with them.", { style: "Sub 30", color: "onCard", name: "Sub" });
+    const spec = plate(k, bottom, { gap: 0, padding: { top: 20, right: 28, bottom: 20, left: 28 }, name: "Spec", effects: [lift(k)] });
+    for (const [labelText, value] of SPECS) {
+      const row = k.stack(spec, { direction: "HORIZONTAL", gap: 12, name: "Spec row" });
+      k.text(row, labelText, { style: "Spec label 18", color: "onCard", width: 150, name: "Spec label" });
+      k.text(row, value, { style: "Spec 24", color: "onCard", name: "Spec value" });
+    }
+    const foot = k.stack(bottom, { direction: "HORIZONTAL", gap: 14, align: "CENTER", name: "Foot" });
+    k.instance(foot, "Chip", { Label: "Installed on every plan today" }, { name: "Chip" });
+    const site = plate(k, foot, { width: "HUG", padding: { top: 11, right: 16, bottom: 11, left: 16 }, tab: false, name: "Site" });
+    k.text(site, "{{brand.site}}", { style: "Site 22", color: "onCard", autoWidth: true, name: "Site text" });
+    const hb = lockBox(W, H, SCENE.post);
+    const lock = brackets(k, sheet, hb.width, hb.height, { name: "Lock", len: 56, width: 6, absolute: { x: hb.x, y: hb.y } });
+    glitch(k, sheet, W, H);
+    k.cues(sheet, cues);
+    const close = [1.6, 1.4, 1.22, 1.08, 1];
+    for (const axis of ["scaleX", "scaleY"]) k.animate(lock, axis, close.map((v, i) => ({ t: 1400 + i * 150, v, ease: HOLD })));
+    const refit = (kit, id, size) => {
+      const f = kit.node(id);
+      fitStreet(kit, id, f.width, f.height, { ...SCENE[size], at: { x: 0, y: 0 } });
+      fitGlitch(kit, id, f.width, f.height);
+      fitRulers(kit, id, f.width, f.height);
+      const b = lockBox(f.width, f.height, SCENE[size]);
+      for (const n of kit.named(id, "Lock")) {
+        fitBrackets(kit, n, b.width, b.height, 56);
+        kit.patch(n, { x: b.x, y: b.y });
+      }
+    };
+    k.variants(sheet, postVariants({ portrait: PAD }, {
+      portrait: (kit, id) => refit(kit, id, "portrait"),
+      vertical: (kit, id) => {
+        kit.patch(id, { padding: verticalPadding() });
+        refit(kit, id, "vertical");
+      }
+    }));
+    return k.finish();
+  }
+});
+
+export {
+  cyberpunk_implant_post_default
+};

package/dist/chunks/chunk-UCGZ6DEK.js

@@ -0,0 +1,265 @@
+import { createRequire as __popcraftRequire } from 'node:module';
+import { fileURLToPath as __popcraftPath } from 'node:url';
+import { dirname as __popcraftDirname } from 'node:path';
+const require = __popcraftRequire(import.meta.url);
+const __filename = __popcraftPath(import.meta.url);
+const __dirname = __popcraftDirname(__filename);
+import {
+  defineTemplate
+} from "./chunk-YDW25Z3P.js";
+import {
+  Kit,
+  preset
+} from "./chunk-4G7VHQUV.js";
+import {
+  ease
+} from "./chunk-PLZLKHOI.js";
+import {
+  init_define_POPCRAFT_COMPONENT_IDS
+} from "./chunk-WKDVCZ45.js";
+
+// templates/src/lottie/lottie-kit.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var SECTORS = {
+  ai: "AI",
+  fintech: "Fintech",
+  health: "Health",
+  commerce: "E-commerce",
+  saas: "SaaS",
+  education: "Education",
+  travel: "Travel",
+  food: "Food delivery",
+  realestate: "Real estate",
+  security: "Security",
+  climate: "Climate",
+  techniques: "Techniques"
+};
+var SIZES = { icon: "lottie-icon", button: "lottie-button", spot: "lottie-spot", hero: "lottie-hero" };
+var ROLES = {
+  hero: "Hero loop",
+  icon: "Animated icon",
+  loader: "Loader",
+  "empty-state": "Empty state",
+  success: "Success state",
+  error: "Error state",
+  onboarding: "Onboarding illustration",
+  explainer: "Feature explainer",
+  stat: "Chart animation",
+  "micro-interaction": "Micro-interaction"
+};
+var E = {
+  /** Fast, then settling: an entrance. */
+  out: ease.bezier(0.22, 1, 0.36, 1),
+  /** Slow, then fast: an exit. */
+  in: ease.bezier(0.55, 0, 1, 0.45),
+  /** Both ends soft: a breath, a sway, a travel between two rests. */
+  inOut: ease.bezier(0.65, 0, 0.35, 1),
+  /** Overshoots and settles back: a pop. */
+  pop: ease.bezier(0.34, 1.56, 0.64, 1),
+  linear: ease.linear,
+  hold: ease.hold
+};
+var lottieId = (s) => `motion-lottie-${s.sector}-${s.slug}`;
+function lottieTemplate(s) {
+  const src = defineTemplate({
+    id: lottieId(s),
+    meta: {
+      name: s.name,
+      description: s.description,
+      category: "animation",
+      tags: ["lottie", s.sector === "ai" ? "ai" : SECTORS[s.sector].toLowerCase(), s.role, ...s.loop ? ["loop"] : [], ...s.tags ?? []],
+      platforms: ["web", "ios", "android"],
+      formats: [],
+      useCases: s.useCases ?? [],
+      created: "2026-09-29",
+      updated: "2026-09-29"
+    },
+    motion: { cues: [], loop: s.loop },
+    build() {
+      const k = new Kit(s.name, preset(SIZES[s.size]));
+      k.brand(s.colors);
+      const sheet = k.sheet;
+      k.patch(sheet, { name: s.name, fills: s.ground ? k.paint(s.ground) : [], clipsContent: true, layoutMode: "VERTICAL", layoutSizingHorizontal: "FIXED", layoutSizingVertical: "FIXED", padding: { top: 0, right: 0, bottom: 0, left: 0 }, itemSpacing: 0 });
+      k.timeline(sheet, { duration: s.duration, fps: s.fps ?? 30 });
+      s.build(new Lot(k, sheet, s.duration));
+      return k.finish();
+    }
+  });
+  return { ...src, lottie: s };
+}
+var Lot = class {
+  constructor(k, sheet, duration) {
+    this.k = k;
+    this.sheet = sheet;
+    this.duration = duration;
+  }
+  // ── Shapes ──
+  /** A plain frame (no layout) at a box, to group, clip or mask what goes in it; it turns and scales about its centre. */
+  box(parent, x, y, w, h, name, o = {}) {
+    return this.k.stack(parent, { name, width: w, height: h, absolute: { x, y }, clip: o.clip ?? false, ...o.fill ? { fill: o.fill } : {}, ...o.stroke ? { stroke: o.stroke } : {}, radius: o.radius ?? 0 });
+  }
+  rect(parent, x, y, w, h, fill, o = {}) {
+    return this.k.rect(parent, w, h, fill, { ...o, absolute: { x, y } });
+  }
+  /** A circle by its centre and radius. */
+  circle(parent, cx, cy, r, fill, o = {}) {
+    return this.k.ellipse(parent, r * 2, fill, { ...o, absolute: { x: cx - r, y: cy - r } });
+  }
+  /** A ring: a circle's outline, `width` wide, centred on radius `r`. */
+  ring(parent, cx, cy, r, color, width, o = {}) {
+    return this.k.ellipse(parent, r * 2, [], { ...o, stroke: { color, width }, absolute: { x: cx - r, y: cy - r } });
+  }
+  /** A filled shape through `pts` (sheet or parent px), with an optional outline. */
+  shape(parent, pts, fill, o = {}) {
+    return this.vector(parent, [{ pts, closed: o.closed ?? true }], fill, o);
+  }
+  /**
+   * A line through `pts`, stroked `width` wide with round caps and joins. A straight segment (two points) is a bar
+   * with round ends, turned along it: the canvas draws a vector's stroke with its fill, and a two-point path has none.
+   */
+  line(parent, pts, color, width, o = {}) {
+    const two = pts.map(point);
+    if (two.length === 2 && !o.closed && !two.some((q) => q.handleIn || q.handleOut)) {
+      const [a, b] = two;
+      const len = Math.hypot(b.x - a.x, b.y - a.y) + width;
+      const id = this.rect(parent, (a.x + b.x) / 2 - len / 2, (a.y + b.y) / 2 - width / 2, len, width, color, { ...o, radius: width / 2 });
+      this.k.patch(id, { rotation: Math.atan2(b.y - a.y, b.x - a.x) * 180 / Math.PI });
+      return id;
+    }
+    return this.vector(parent, [{ pts, closed: o.closed ?? false }], color, { ...o, strokeWidth: width });
+  }
+  /** Several contours in one layer (a glyph with a hole: even-odd is not needed, the packs cut nothing). */
+  vector(parent, contours, fill, o = {}) {
+    const all = contours.flatMap((c) => c.pts.flatMap((p) => {
+      const q = point(p);
+      return [q, ...q.handleIn ? [q.handleIn] : [], ...q.handleOut ? [q.handleOut] : []];
+    }));
+    const minX = Math.min(...all.map((p) => p.x)), minY = Math.min(...all.map((p) => p.y));
+    const maxX = Math.max(...all.map((p) => p.x)), maxY = Math.max(...all.map((p) => p.y));
+    const rel = (p) => ({ x: p.x - minX, y: p.y - minY });
+    const paths = contours.map((c) => ({
+      closed: c.closed,
+      points: c.pts.map((p) => {
+        const q = point(p);
+        return { ...rel(q), ...q.handleIn ? { handleIn: rel(q.handleIn) } : {}, ...q.handleOut ? { handleOut: rel(q.handleOut) } : {} };
+      })
+    }));
+    return this.k.vector(parent, Math.max(1, maxX - minX), Math.max(1, maxY - minY), paths, fill, { ...o, absolute: { x: minX, y: minY } });
+  }
+  // ── Motion ──
+  /** Key `path` on `id`. */
+  keys(id, path, ks) {
+    const once = ks.filter((key, i) => !ks.slice(i + 1).some((o) => Math.abs(o[0] - key[0]) < 1));
+    this.k.animate(id, path, once.map(([t, v, e], i) => ({ t, v, ...i < once.length - 1 ? { ease: e ?? E.inOut } : {} })));
+    return id;
+  }
+  /** Scale on both axes. */
+  scale(id, ks) {
+    this.keys(id, "scaleX", ks);
+    return this.keys(id, "scaleY", ks);
+  }
+  /** Turn `turns` whole turns over the timeline at an even rate (a loop that meets itself). */
+  spin(id, turns, from = 0) {
+    return this.keys(id, "rotation", [[0, from, E.linear], [this.duration, from + 360 * turns]]);
+  }
+  /** Where its turns and scales pivot, as a fraction of its box (0.5, 0.5 is the centre). */
+  pivot(id, ax, ay) {
+    this.k.patch(id, { anchorX: ax, anchorY: ay });
+    return id;
+  }
+  /** Hidden until `t`, then shown (an opacity hold): a layer that pops in later. */
+  opacity(id, ks) {
+    return this.keys(id, "opacity", ks);
+  }
+};
+var point = (p) => Array.isArray(p) ? { x: p[0], y: p[1] } : p;
+function around(cx, cy, r, n, start = 0, inner) {
+  const out = [];
+  const count = inner === void 0 ? n : n * 2;
+  for (let i = 0; i < count; i++) {
+    const a = (start + 360 * i / count) * Math.PI / 180;
+    const rr = inner !== void 0 && i % 2 ? inner : r;
+    out.push([cx + rr * Math.sin(a), cy - rr * Math.cos(a)]);
+  }
+  return out;
+}
+function sparkle(cx, cy, r) {
+  const k = r * 0.14;
+  const pinchOf = (q) => [{ x: cx + k, y: cy - k }, { x: cx + k, y: cy + k }, { x: cx - k, y: cy + k }, { x: cx - k, y: cy - k }][q];
+  const tips = [{ x: cx, y: cy - r }, { x: cx + r, y: cy }, { x: cx, y: cy + r }, { x: cx - r, y: cy }];
+  return tips.map((t, q) => ({ ...t, handleIn: pinchOf((q + 3) % 4), handleOut: pinchOf(q) }));
+}
+function heart(cx, y, w) {
+  const h = w * 0.9, s = w / 2;
+  return [
+    { x: cx, y: y + h * 0.28, handleIn: { x: cx - s * 0.1, y }, handleOut: { x: cx + s * 0.1, y } },
+    { x: cx + s, y: y + h * 0.3, handleIn: { x: cx + s, y: y - h * 0.02 }, handleOut: { x: cx + s, y: y + h * 0.55 } },
+    { x: cx, y: y + h, handleIn: { x: cx + s * 0.5, y: y + h * 0.75 }, handleOut: { x: cx - s * 0.5, y: y + h * 0.75 } },
+    { x: cx - s, y: y + h * 0.3, handleIn: { x: cx - s, y: y + h * 0.55 }, handleOut: { x: cx - s, y: y - h * 0.02 } }
+  ];
+}
+function pin(cx, tipY, w) {
+  const r = w / 2, top = tipY - w * 1.35, c = 0.5523 * r;
+  const cy = top + r;
+  return [
+    { x: cx, y: tipY, handleIn: { x: cx + r * 0.25, y: tipY - r * 0.35 }, handleOut: { x: cx - r * 0.25, y: tipY - r * 0.35 } },
+    { x: cx - r, y: cy, handleIn: { x: cx - r, y: cy + r * 0.8 }, handleOut: { x: cx - r, y: cy - c } },
+    { x: cx, y: top, handleIn: { x: cx - c, y: top }, handleOut: { x: cx + c, y: top } },
+    { x: cx + r, y: cy, handleIn: { x: cx + r, y: cy - c }, handleOut: { x: cx + r, y: cy + r * 0.8 } }
+  ];
+}
+function roundRect(x, y, w, h, r) {
+  const rr = Math.min(r, w / 2, h / 2), c = 0.5523 * rr;
+  return [
+    { x: x + rr, y, handleIn: { x: x + rr - c, y } },
+    { x: x + w - rr, y, handleOut: { x: x + w - rr + c, y } },
+    { x: x + w, y: y + rr, handleIn: { x: x + w, y: y + rr - c } },
+    { x: x + w, y: y + h - rr, handleOut: { x: x + w, y: y + h - rr + c } },
+    { x: x + w - rr, y: y + h, handleIn: { x: x + w - rr + c, y: y + h } },
+    { x: x + rr, y: y + h, handleOut: { x: x + rr - c, y: y + h } },
+    { x, y: y + h - rr, handleIn: { x, y: y + h - rr + c } },
+    { x, y: y + rr, handleOut: { x, y: y + rr - c } }
+  ];
+}
+function arc(cx, cy, r, a0, a1) {
+  const n = Math.max(1, Math.ceil(Math.abs(a1 - a0) / 90));
+  const step = (a1 - a0) / n;
+  const k = 4 / 3 * Math.tan(step * Math.PI / 720) * r;
+  const at = (deg) => {
+    const a = deg * Math.PI / 180;
+    return { x: cx + r * Math.sin(a), y: cy - r * Math.cos(a), tx: Math.cos(a), ty: Math.sin(a) };
+  };
+  return Array.from({ length: n + 1 }, (_, i) => {
+    const p = at(a0 + i * step);
+    return {
+      x: p.x,
+      y: p.y,
+      ...i > 0 ? { handleIn: { x: p.x - p.tx * k, y: p.y - p.ty * k } } : {},
+      ...i < n ? { handleOut: { x: p.x + p.tx * k, y: p.y + p.ty * k } } : {}
+    };
+  });
+}
+function cloud(l, parent, x, y, s, color = "white") {
+  const c = l.box(parent, x, y, 220 * s, 100 * s, "Cloud");
+  l.vector(c, [{ pts: roundRect(0, 50 * s, 220 * s, 50 * s, 25 * s), closed: true }], color, { name: "Cloud base" });
+  l.circle(c, 70 * s, 55 * s, 40 * s, color, { name: "Cloud puff" });
+  l.circle(c, 130 * s, 45 * s, 45 * s, color, { name: "Cloud puff" });
+  return c;
+}
+
+export {
+  SECTORS,
+  SIZES,
+  ROLES,
+  E,
+  lottieId,
+  lottieTemplate,
+  Lot,
+  around,
+  sparkle,
+  heart,
+  pin,
+  roundRect,
+  arc,
+  cloud
+};

package/dist/chunks/chunk-UCUPGBWW.js

@@ -0,0 +1,181 @@
+import { createRequire as __popcraftRequire } from 'node:module';
+import { fileURLToPath as __popcraftPath } from 'node:url';
+import { dirname as __popcraftDirname } from 'node:path';
+const require = __popcraftRequire(import.meta.url);
+const __filename = __popcraftPath(import.meta.url);
+const __dirname = __popcraftDirname(__filename);
+import {
+  SCENE,
+  mover
+} from "./chunk-OMIZ3MNS.js";
+import {
+  MONO
+} from "./chunk-AXAAXHZF.js";
+import {
+  bloom,
+  glow,
+  hardShadow
+} from "./chunk-YORIY3BT.js";
+import {
+  line,
+  pt3,
+  rng
+} from "./chunk-EJLCQVQK.js";
+import {
+  init_define_POPCRAFT_COMPONENT_IDS
+} from "./chunk-WKDVCZ45.js";
+
+// templates/src/themes/festival-presale-electronic-kit.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var W = SCENE.w;
+var H = SCENE.h;
+var FLOOR = 1330;
+var arch = (cx, cy, r, n = 40) => ({ closed: false, points: Array.from({ length: n + 1 }, (_, i) => {
+  const a = Math.PI + Math.PI * i / n;
+  return pt3(cx + r * Math.cos(a), cy + r * Math.sin(a));
+}) });
+function stage(k, art, still) {
+  const move = mover(k, still);
+  const cx = W / 2;
+  const haze = glow(k, art, { x: cx, y: FLOOR - 40, w: 1700, h: 980, role: "magenta", alpha: 0.42, name: "Haze" });
+  move(haze, "opacity", 0.18, 2);
+  glow(k, art, { x: cx, y: FLOOR - 560, w: 1300, h: 900, role: "violet", alpha: 0.36, name: "High haze" });
+  glow(k, art, { x: 140, y: FLOOR, w: 620, role: "cyan", alpha: 0.24, name: "Side haze" });
+  glow(k, art, { x: W - 140, y: FLOOR, w: 620, role: "cyan", alpha: 0.24, name: "Side haze" });
+  const r0 = rng(61), dust = [];
+  for (let i = 0; i < 90; i++) {
+    const x = r0() * W, y = r0() * (FLOOR - 500), s = 1.5 + r0() * 2.5;
+    dust.push({ closed: true, points: [pt3(x, y - s), pt3(x + s, y), pt3(x, y + s), pt3(x - s, y)] });
+  }
+  const motes = k.vector(art, W, FLOOR, dust, "flash", { name: "Dust", opacity: 0.35, absolute: { x: 0, y: 0 } });
+  move(motes, "opacity", 0.15, 1);
+  const runway = [];
+  for (let i = -11; i <= 11; i++) runway.push(line(cx + i * 14, FLOOR, cx + i * 170, H));
+  for (const y of [FLOOR, FLOOR + 14, FLOOR + 36, FLOOR + 70, FLOOR + 120]) runway.push(line(0, y, W, y));
+  k.vector(art, W, H - FLOOR + 2, runway.map((p) => ({ ...p, points: p.points.map((q) => pt3(q.x, q.y - FLOOR)) })), "violet", { name: "Runway", strokeWidth: 1.5, opacity: 0.5, absolute: { x: 0, y: FLOOR } });
+  const rings = [170, 240, 315, 395, 480, 570, 665, 765];
+  const roles = ["lime", "cyan", "magenta"];
+  rings.forEach((r2, i) => {
+    const role = roles[i % 3];
+    const id = k.vector(art, r2 * 2, r2, [arch(r2, r2, r2)], role, { name: "Ring", strokeWidth: i % 3 === 0 ? 6 : 3.5, opacity: 0.66, effects: [bloom(k, role, 20, 0.85)], absolute: { x: cx - r2, y: FLOOR - r2 } });
+    move(id, "opacity", 0.34, 3, -i / rings.length);
+  });
+  const spokes = [];
+  for (let i = 1; i < 14; i++) {
+    const a = Math.PI + Math.PI * i / 14;
+    spokes.push(line(765 + 170 * Math.cos(a), 765 + 170 * Math.sin(a), 765 + 765 * Math.cos(a), 765 + 765 * Math.sin(a)));
+  }
+  k.vector(art, 1530, 765, spokes, "truss", { name: "Spokes", strokeWidth: 2, opacity: 0.9, absolute: { x: cx - 765, y: FLOOR - 765 } });
+  for (const x of [52, W - 52 - 48]) {
+    const lattice = [line(0, 0, 0, 760), line(48, 0, 48, 760), line(-14, 0, 62, 0)];
+    for (let y = 0; y < 760; y += 44) {
+      lattice.push(line(0, y, 48, y + 44));
+      lattice.push(line(48, y, 0, y + 44));
+    }
+    k.vector(art, 48, 760, lattice, "truss", { name: "Tower", strokeWidth: 2.5, absolute: { x, y: FLOOR - 760 } });
+  }
+  const fan = (ox, oy, mid, spread, n, role, amp, phase, len = 1700) => {
+    const lines = Array.from({ length: n }, (_, i) => {
+      const a = (mid + spread * (i / (n - 1) - 0.5)) * Math.PI / 180;
+      return line(len, len, len + len * Math.cos(a), len + len * Math.sin(a));
+    });
+    const id = k.vector(art, len * 2, len * 2, lines, role, { name: "Lasers", strokeWidth: 2.5, opacity: 0.5, effects: [bloom(k, role, 10, 0.9)], absolute: { x: ox - len, y: oy - len } });
+    move(id, "rotation", amp, 2, phase);
+  };
+  const top = FLOOR - 760;
+  fan(76, top, -40, 44, 8, "lime", 9, 0);
+  fan(W - 76, top, 220, 44, 8, "lime", 9, 0.5);
+  fan(cx, FLOOR - 765, -90, 110, 11, "magenta", 7, 0.25);
+  fan(76, top, 30, 30, 5, "cyan", 12, 0.3);
+  fan(W - 76, top, 150, 30, 5, "cyan", 12, 0.8);
+  const r = rng(27);
+  for (let i = 0; i < 30; i++) {
+    const a = Math.PI + Math.PI * r(), rr = rings[Math.floor(r() * rings.length)], s = 8 + Math.round(r() * 6);
+    const id = k.ellipse(art, s, "flash", { name: "Strobe", effects: [bloom(k, "flash", 16, 0.9)], absolute: { x: Math.round(cx + rr * Math.cos(a)) - s / 2, y: Math.round(FLOOR + rr * Math.sin(a)) - s / 2 } });
+    k.patch(id, { opacity: 0.6 });
+    move(id, "opacity", 0.4, 3 + i % 4 * 3, r());
+  }
+  const crowd = (base, step, head, seed) => {
+    const q = rng(seed);
+    const pts = [pt3(-20, H + 20), pt3(-20, base)];
+    for (let x = -10; x < W + 20; x += step) {
+      const y = base + (q() - 0.5) * head * 0.9, arm = q();
+      if (arm > 0.76) {
+        const up = head * (1.5 + q() * 0.8);
+        pts.push(pt3(x - head * 0.42, y), pt3(x - head * 0.62, y - up), pt3(x - head * 0.5, y - up - head * 0.35), pt3(x - head * 0.22, y - up - head * 0.3), pt3(x - head * 0.1, y - up), pt3(x, y - head * 0.2));
+      }
+      pts.push(pt3(x, y), pt3(x + head * 0.12, y - head * 0.75), pt3(x + head * 0.5, y - head), pt3(x + head * 0.88, y - head * 0.75), pt3(x + head, y));
+    }
+    pts.push(pt3(W + 20, base), pt3(W + 20, H + 20));
+    return { closed: true, points: pts };
+  };
+  const off = (p, dy) => ({ ...p, points: p.points.map((q) => pt3(q.x, q.y - dy)) });
+  k.vector(art, W, 340, [off(crowd(FLOOR + 40, 30, 22, 5), FLOOR - 120)], "crowdFar", { name: "Crowd far", absolute: { x: 0, y: FLOOR - 120 } });
+  const near = k.vector(art, W, 340, [off(crowd(FLOOR + 84, 46, 34, 9), FLOOR - 120)], "crowd", { name: "Crowd", absolute: { x: 0, y: FLOOR - 120 } });
+  move(near, "translateY", 4, 6);
+}
+var KILOVOLT = {
+  slug: "electronic",
+  name: "KILOVOLT",
+  brand: (k, fields = {}) => {
+    k.brand(
+      { paper: "#0A0912", text: "#F3F1FA", onPaper: "#ABA7C0", primary: "#C8FF3E", onPrimary: "#0A0912", accent: "#FF2D8E", onAccent: "#14000A", card: "#161424", onCard: "#F3F1FA", cardMuted: "#ABA7C0", panel: "#221F38", onPanel: "#F3F1FA", panelMuted: "#B9B5D0", chip: "#2C2944", onChip: "#E6E3F4", stage: "#07060F", onStage: "#F3F1FA", stageMuted: "#C2BEDA" },
+      { name: "KILOVOLT", ...fields }
+    );
+    k.palette({ lime: "#C8FF3E", magenta: "#FF2D8E", cyan: "#39E6FF", violet: "#7B5CFF", truss: "#3B3660", flash: "#FFFFFF", crowd: "#020106", crowdFar: "#0D0A1E", gate: "#0B0A16" });
+  },
+  type: {
+    Name: { fontWeight: 900, ls: -0.045, lh: 0.86, upper: true },
+    Head: { fontWeight: 900, ls: -0.035, lh: 0.98, upper: true },
+    Act: { fontWeight: 800, ls: -0.015, lh: 1.25, upper: true },
+    More: { ...MONO, fontWeight: 600, ls: 0.02, lh: 1.5, upper: true },
+    Kicker: { ...MONO, fontWeight: 700, ls: 0.1, lh: 1.35, upper: true },
+    Clock: { ...MONO, fontWeight: 800, ls: -0.035, lh: 1.04, tnum: true },
+    Unit: { ...MONO, fontWeight: 700, ls: 0.1, lh: 1.3, upper: true },
+    Body: { fontWeight: 500, ls: 0, lh: 1.4 },
+    Button: { fontWeight: 800, ls: 0.04, lh: 1.3, upper: true },
+    Caption: { fontWeight: 800, ls: -0.01, lh: 1.2 },
+    Price: { fontWeight: 900, ls: -0.04, lh: 1, tnum: true }
+  },
+  look: {
+    radius: 0,
+    chip: 0,
+    button: 0,
+    plate: "gate",
+    plateAlpha: 0.86,
+    plateStroke: { color: "lime", width: 2, align: "INSIDE" },
+    tile: "panel",
+    tileInk: "onPanel",
+    tileMuted: "panelMuted",
+    nameEffects: (k) => [hardShadow(k, "magenta", 7, 7), hardShadow(k, "cyan", -5, -5)],
+    glow: "magenta",
+    hot: "lime",
+    hotInk: "gate",
+    sep: "\xB7"
+  },
+  scene: stage,
+  horizon: FLOOR,
+  // The pass header shows the arch's crown, not its lower rings.
+  passFocus: 0.4,
+  dates: "9 \u2013 11 July 2027",
+  place: "Nordhafen Airfield, Hallstrand",
+  kicker: "Three days \xB7 Four stages \xB7 40,000 people",
+  heads: ["Vanta Rae", "HEXA/MODE", "Solveig Nox"],
+  acts: ["Dial Tone Saints", "Marguerite Vox", "Sable & Ives", "K-Lattice (live)", "Lumen Kid", "The Long Fade"],
+  more: ["Greyfold", "Petra Null", "Okta Okta", "Pale Signal", "Dune Protocol", "NNOVA", "Brine"],
+  tba: "+ 36 more names on 2 March",
+  presale: { by: "Sun 24 Jan", code: "Tue 26 Jan", opens: "Thu 28 Jan \xB7 10:00 CET", day: "Thursday 28 January", time: "10:00 CET", queue: "09:30", limit: "up to four passes" },
+  clock: { days: "12", hours: "06", minutes: "41", from: 47, to: 41 },
+  tier: { tag: "Tier 1", name: "Three-day pass", price: "\u20AC199", next: "\u20AC229", was: "\u20AC169", sold: "Early bird sold out in 11 minutes", note: "On sale now to 2026 ticket holders. What is left opens to presale codes on 28 January.", stock: { label: "Selling fast", from: 2351, left: 2318, total: 12e3 } },
+  cta: "Get presale access",
+  code: "KV27-PRE-4R8Q",
+  gate: "Gate B",
+  track: "edm",
+  picture: "the main stage at night: an arch of pulsing light rings, truss towers, sweeping laser fans, strobes, haze and the crowd",
+  tags: ["electronic music", "rave", "techno", "lasers", "night", "neon"],
+  captions: ["The first names are in.", "Presale opens Thursday, 28 January.", "Register by Sunday for codes.", "Sign up for a code."]
+};
+
+export {
+  KILOVOLT
+};