@popcraft/kit 0.31.0 → 0.32.1

package/dist/chunks/runtime-ZFSHTK76.js

@@ -0,0 +1,32 @@
+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 {
+  getDirection,
+  getLocale,
+  hasMessage,
+  initialLocale,
+  intlLocale,
+  pendingLocale,
+  setLocale,
+  subscribeLocale,
+  t,
+  tx
+} from "./chunk-JIZTNKHY.js";
+import "./chunk-FFS4SO7R.js";
+import "./chunk-LJSVREWM.js";
+export {
+  getDirection,
+  getLocale,
+  hasMessage,
+  initialLocale,
+  intlLocale,
+  pendingLocale,
+  setLocale,
+  subscribeLocale,
+  t,
+  tx
+};

package/dist/chunks/shader-preview-JS5LL5R7.js

@@ -0,0 +1,518 @@
+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 {
+  diagnosticsText,
+  mapCompilerMessages,
+  plainDiagnostics
+} from "./chunk-VFRAUFQT.js";
+import {
+  encodeFrames
+} from "./chunk-65GOYE3V.js";
+import "./chunk-ZJLDYEFO.js";
+import "./chunk-IJANP2KO.js";
+import "./chunk-YSNU3DDN.js";
+import "./chunk-IEGVTRIS.js";
+import "./chunk-3PLIWIWJ.js";
+import {
+  encodeRaster
+} from "./chunk-Q6KVUFQF.js";
+import "./chunk-GNTJQ6T6.js";
+import "./chunk-K2PZVX43.js";
+import "./chunk-5BRPP33E.js";
+import "./chunk-WHWQQG2J.js";
+import "./chunk-HYVJVSMY.js";
+import "./chunk-NL4IY2P4.js";
+import "./chunk-ZDZ2CP7W.js";
+import {
+  readTextureRGBA
+} from "./chunk-AYS2PW7E.js";
+import {
+  getActiveRenderer
+} from "./chunk-L655IQHW.js";
+import "./chunk-PAIMIUEI.js";
+import "./chunk-CQSM4IS4.js";
+import "./chunk-E722S2DP.js";
+import "./chunk-4PKYJYJQ.js";
+import "./chunk-R74YSMDO.js";
+import "./chunk-NKU65PDL.js";
+import "./chunk-XJRLX66V.js";
+import "./chunk-757XHU62.js";
+import "./chunk-QZWEMMEL.js";
+import "./chunk-6WESPS7R.js";
+import "./chunk-Q47DN67O.js";
+import "./chunk-6YRHCDDT.js";
+import "./chunk-YQC2IVAU.js";
+import "./chunk-EAVQBTTA.js";
+import "./chunk-VDJPGIAE.js";
+import "./chunk-Z73UNUL7.js";
+import "./chunk-QLDV5WV5.js";
+import "./chunk-HOC36BAJ.js";
+import "./chunk-N7XUSTLZ.js";
+import "./chunk-XBVMM6ZD.js";
+import "./chunk-5XSI3MNX.js";
+import "./chunk-2LYY4KTS.js";
+import "./chunk-SMR77HUB.js";
+import "./chunk-2YBOCBPA.js";
+import "./chunk-FREAHUVP.js";
+import "./chunk-PXXO7PQR.js";
+import "./chunk-4VICNBUI.js";
+import "./chunk-IPETYEVH.js";
+import "./chunk-RW67KLLE.js";
+import "./chunk-5X7A23T7.js";
+import "./chunk-ONN5A5XM.js";
+import "./chunk-EPG7TW6Z.js";
+import "./chunk-NMFXCSU4.js";
+import {
+  init_shader_params,
+  packShaderParams,
+  reflectShader
+} from "./chunk-TSWHCDM7.js";
+import "./chunk-CK43FENV.js";
+import "./chunk-X53QDCNX.js";
+import "./chunk-VBAS5IB5.js";
+import "./chunk-CZXJDKOJ.js";
+import {
+  init_define_POPCRAFT_COMPONENT_IDS
+} from "./chunk-FFS4SO7R.js";
+import "./chunk-LJSVREWM.js";
+
+// lib/client/shader-preview.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+init_shader_params();
+
+// lib/engine/shader-fill.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+init_shader_params();
+var TARGET_FORMAT = "rgba8unorm";
+var MAX_SIZE = 2048;
+var MIN_SIZE = 4;
+var STALE_MS = 2e3;
+var FRAME_MS = 12;
+var MAX_SIZES_PER_SHADER = 4;
+var SWEEP_IDLE_MS = 1e4;
+var SWEEP_EVERY_MS = 2e3;
+function shaderFillKey(code, width, height, params) {
+  const paramsHash = packShaderParams(code, params).hash;
+  const prefix = `${code}|${width}x${height}|`;
+  return { key: prefix + paramsHash, prefix, paramsHash };
+}
+var shaderTextureSize = (v) => Math.max(MIN_SIZE, Math.min(MAX_SIZE, Math.round(v) || MIN_SIZE));
+function shaderTextureDims(width, height) {
+  const big = Math.max(width, height);
+  const k = big > MAX_SIZE ? MAX_SIZE / big : 1;
+  return [shaderTextureSize(width * k), shaderTextureSize(height * k)];
+}
+function wrapUserCode(userCode) {
+  const params = reflectShader(userCode).size > 0;
+  return `
+struct ShaderUniforms {
+  resolution: vec2<f32>,
+  time: f32,
+  _pad: f32,
+};
+@group(0) @binding(0) var<uniform> u: ShaderUniforms;
+${params ? "@group(0) @binding(1) var<uniform> p: Params;" : ""}
+// \u2500\u2500 user code \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+${userCode}
+// \u2500\u2500 /user code \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+struct VOut {
+  @builtin(position) pos: vec4<f32>,
+  @location(0) uv: vec2<f32>,
+};
+
+@vertex
+fn vs_main(@builtin(vertex_index) vi: u32) -> VOut {
+  var verts = array<vec2<f32>, 3>(
+    vec2<f32>(-1.0, -1.0),
+    vec2<f32>( 3.0, -1.0),
+    vec2<f32>(-1.0,  3.0),
+  );
+  let xy = verts[vi];
+  var o: VOut;
+  o.pos = vec4<f32>(xy, 0.0, 1.0);
+  // 0..1, top-left origin \u2014 matches the image-fill sampling (localPos + 0.5)
+  o.uv = vec2<f32>((xy.x + 1.0) * 0.5, (1.0 - xy.y) * 0.5);
+  return o;
+}
+
+@fragment
+fn fs_main(in: VOut) -> @location(0) vec4<f32> {
+  return shade(in.uv, u.resolution, u.time);
+}
+`;
+}
+var USER_CODE_OFFSET = wrapUserCode("").split("\n").findIndex((l) => l.startsWith("// \u2500\u2500 user code")) + 1;
+var ShaderFillManager = class {
+  ctx;
+  pipelines = /* @__PURE__ */ new Map();
+  entries = /* @__PURE__ */ new Map();
+  // key: shaderFillKey (code|w×h|paramsHash)
+  errorListeners = /* @__PURE__ */ new Set();
+  transparentTex = null;
+  sweptAt = 0;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  // 1x1 fully-transparent texture — a broken shader renders as an empty fill
+  // rather than the opaque dummy texture.
+  getTransparent() {
+    if (!this.transparentTex) {
+      this.transparentTex = this.ctx.device.createTexture({
+        size: [1, 1],
+        format: TARGET_FORMAT,
+        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
+      });
+      this.ctx.device.queue.writeTexture(
+        { texture: this.transparentTex },
+        new Uint8Array([0, 0, 0, 0]),
+        { bytesPerRow: 4 },
+        [1, 1, 1]
+      );
+    }
+    return this.transparentTex;
+  }
+  onError(cb) {
+    this.errorListeners.add(cb);
+    return () => this.errorListeners.delete(cb);
+  }
+  getPipeline(code) {
+    const cached = this.pipelines.get(code);
+    if (cached) {
+      cached.lastUsed = performance.now();
+      return cached;
+    }
+    const { device } = this.ctx;
+    const reflection = reflectShader(code);
+    if (reflection.errors.length) {
+      const diagnostics2 = plainDiagnostics(reflection.errors);
+      const entry2 = { pipeline: null, error: diagnosticsText(diagnostics2), diagnostics: diagnostics2, settled: true, ready: Promise.resolve(), lastUsed: performance.now() };
+      this.pipelines.set(code, entry2);
+      this.emitError(code, entry2);
+      return entry2;
+    }
+    device.pushErrorScope("validation");
+    let shaderModule = null;
+    let pipeline = null;
+    let thrown = null;
+    try {
+      shaderModule = device.createShaderModule({ code: wrapUserCode(code) });
+      const uniform = (binding) => ({ binding, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } });
+      const bindGroupLayout = device.createBindGroupLayout({ entries: reflection.size ? [uniform(0), uniform(1)] : [uniform(0)] });
+      pipeline = device.createRenderPipeline({
+        layout: device.createPipelineLayout({ bindGroupLayouts: [bindGroupLayout] }),
+        vertex: { module: shaderModule, entryPoint: "vs_main" },
+        fragment: { module: shaderModule, entryPoint: "fs_main", targets: [{ format: TARGET_FORMAT }] },
+        primitive: { topology: "triangle-list" }
+      });
+    } catch (e) {
+      thrown = e instanceof Error && e.message ? e.message : "Shader compile failed";
+    }
+    const diagnostics = thrown ? plainDiagnostics([thrown]) : [];
+    const entry = { pipeline, error: thrown, diagnostics, settled: false, ready: Promise.resolve(), lastUsed: performance.now() };
+    this.pipelines.set(code, entry);
+    if (thrown) this.emitError(code, entry);
+    const info = shaderModule?.getCompilationInfo ? shaderModule.getCompilationInfo().catch(() => null) : Promise.resolve(null);
+    const scope = device.popErrorScope().catch(() => null);
+    entry.ready = Promise.all([info, scope]).then(([info2, err]) => {
+      const mapped = info2 ? mapCompilerMessages(info2.messages, USER_CODE_OFFSET, code.split("\n").length) : [];
+      const failed = mapped.some((d) => d.severity === "error");
+      entry.diagnostics = failed ? mapped : err ? [...mapped, ...plainDiagnostics([err.message])] : thrown ? [...mapped, ...diagnostics] : mapped;
+      entry.settled = true;
+      if (!failed && !err) return;
+      entry.pipeline = null;
+      entry.error = diagnosticsText(entry.diagnostics);
+      this.emitError(code, entry);
+    });
+    return entry;
+  }
+  emitError(code, entry) {
+    for (const cb of this.errorListeners) cb(code, entry.error, entry.diagnostics);
+  }
+  /** What compiling `code` found, or null when it has not been compiled or the compiler has not answered yet. */
+  diagnostics(code) {
+    const entry = this.pipelines.get(code);
+    return entry?.settled ? entry.diagnostics : null;
+  }
+  /** Compile `code` (once: the pipeline is cached for drawing it) and resolve to what the compiler found. */
+  async checkShader(code) {
+    const entry = this.getPipeline(code);
+    await entry.ready;
+    return entry.diagnostics;
+  }
+  release(key, e) {
+    e.texture.destroy();
+    e.uniformBuffer.destroy();
+    e.paramsBuffer?.destroy();
+    this.entries.delete(key);
+  }
+  /**
+   * Render (or re-render) the shader into a texture and return it. `time` (seconds: the playhead's under
+   * Animate and in exports) drives a shader that reads it; `params` fill its `struct Params`. A texture is only
+   * allocated for a new size; a new params value re-renders the entry the last frame used for this size.
+   * Returns null when the shader failed to compile (caller falls back).
+   */
+  getTexture(code, width, height, time, params) {
+    if (!code) return null;
+    if (performance.now() - this.sweptAt > SWEEP_EVERY_MS) this.sweep();
+    const compiled = this.getPipeline(code);
+    if (!compiled.pipeline) return this.getTransparent();
+    const [w, h] = shaderTextureDims(width, height);
+    const { key, prefix } = shaderFillKey(code, w, h, params);
+    const packed = packShaderParams(code, params);
+    const { device } = this.ctx;
+    const now = performance.now();
+    let entry = this.entries.get(key);
+    if (!entry) {
+      const reuse = [...this.entries].find(([k, e]) => k.startsWith(prefix) && now - e.lastUsed >= FRAME_MS);
+      if (reuse) {
+        this.entries.delete(reuse[0]);
+        entry = reuse[1];
+        entry.renderedAt = null;
+        this.entries.set(key, entry);
+      }
+    }
+    if (!entry) {
+      const sameCode = [...this.entries].filter(([k]) => k.startsWith(code + "|")).sort((a, b) => b[1].lastUsed - a[1].lastUsed);
+      sameCode.forEach(([k, e], i) => {
+        const usedThisFrame = now - e.lastUsed < FRAME_MS;
+        if (!usedThisFrame && (i >= MAX_SIZES_PER_SHADER - 1 || now - e.lastUsed > STALE_MS)) this.release(k, e);
+      });
+      const texture = device.createTexture({
+        size: [w, h],
+        format: TARGET_FORMAT,
+        // COPY_SRC: the code editor's preview copies its texture to a canvas.
+        usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
+      });
+      const uniformBuffer = device.createBuffer({
+        size: 16,
+        // vec2 resolution + f32 time + f32 pad
+        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+      });
+      const paramsBuffer = packed.data.length ? device.createBuffer({ size: packed.data.byteLength, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST }) : null;
+      const bindGroup = device.createBindGroup({
+        layout: compiled.pipeline.getBindGroupLayout(0),
+        entries: paramsBuffer ? [{ binding: 0, resource: { buffer: uniformBuffer } }, { binding: 1, resource: { buffer: paramsBuffer } }] : [{ binding: 0, resource: { buffer: uniformBuffer } }]
+      });
+      entry = { code, texture, width: w, height: h, bindGroup, uniformBuffer, paramsBuffer, animated: reflectShader(code).animated, renderedAt: null, lastUsed: now };
+      this.entries.set(key, entry);
+    }
+    entry.lastUsed = now;
+    if (entry.renderedAt !== null && (!entry.animated || entry.renderedAt === time)) return entry.texture;
+    entry.renderedAt = time;
+    device.queue.writeBuffer(entry.uniformBuffer, 0, new Float32Array([w, h, time, 0]));
+    if (entry.paramsBuffer) device.queue.writeBuffer(entry.paramsBuffer, 0, packed.data);
+    const encoder = device.createCommandEncoder();
+    const pass = encoder.beginRenderPass({
+      colorAttachments: [{
+        view: entry.texture.createView(),
+        clearValue: { r: 0, g: 0, b: 0, a: 0 },
+        loadOp: "clear",
+        storeOp: "store"
+      }]
+    });
+    pass.setPipeline(compiled.pipeline);
+    pass.setBindGroup(0, entry.bindGroup);
+    pass.draw(3);
+    pass.end();
+    device.queue.submit([encoder.finish()]);
+    return entry.texture;
+  }
+  /** True if any live shader fill animates — the caller keeps the loop ticking. */
+  hasAnimated() {
+    for (const e of this.entries.values()) if (e.animated) return true;
+    return false;
+  }
+  /**
+   * Free the textures and pipelines nothing has drawn for `idleMs`. Never one drawn in the last moment: its draw may
+   * already be batched into the frame being built. A failed compile's pipeline goes too, so its error comes back
+   * the next time that code is drawn.
+   */
+  sweep(now = performance.now(), idleMs = SWEEP_IDLE_MS) {
+    this.sweptAt = now;
+    const live = /* @__PURE__ */ new Set();
+    for (const [k, e] of [...this.entries]) {
+      if (now - e.lastUsed > idleMs) this.release(k, e);
+      else live.add(e.code);
+    }
+    for (const [code, p] of [...this.pipelines]) if (!live.has(code) && now - p.lastUsed > idleMs) this.pipelines.delete(code);
+  }
+  /** How many pipelines and textures are held (tests and the dev overlay). */
+  get size() {
+    return { pipelines: this.pipelines.size, textures: this.entries.size };
+  }
+  destroy() {
+    for (const e of this.entries.values()) {
+      e.texture.destroy();
+      e.uniformBuffer.destroy();
+      e.paramsBuffer?.destroy();
+    }
+    this.transparentTex?.destroy();
+    this.transparentTex = null;
+    this.entries.clear();
+    this.pipelines.clear();
+    this.errorListeners.clear();
+  }
+};
+
+// lib/engine/shader-preview.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+init_shader_params();
+var PREVIEW_WIDTH = 168;
+var PREVIEW_HEIGHT = 112;
+var PREVIEW_FPS = 12;
+var PREVIEW_LOOP_S = 2.5;
+var PREVIEW_FADE_FRAMES = 8;
+var PREVIEW_START_S = 1;
+var PREVIEW_GROUND = [24, 26, 34];
+var BEAT_S = 0.5;
+var TAU = Math.PI * 2;
+var frac = (x) => x - Math.floor(x);
+function previewAudio(signal, t, bin = 0.2) {
+  const kick = Math.exp(-frac(t / BEAT_S) * 5);
+  const hat = Math.exp(-frac(t / BEAT_S + 0.5) * 7);
+  const swell = 0.5 + 0.5 * Math.sin(TAU * t / PREVIEW_LOOP_S);
+  const bass = 0.2 + 0.8 * kick;
+  const treble = 0.25 + 0.6 * hat;
+  switch (signal) {
+    case "beat":
+      return kick;
+    case "onset":
+      return Math.max(kick, 0.7 * hat);
+    case "bass":
+      return bass;
+    case "treble":
+      return treble;
+    case "mid":
+      return 0.35 + 0.35 * swell + 0.2 * kick;
+    case "spectrum":
+      return bass + (treble - bass) * Math.min(1, Math.max(0, bin));
+    case "level":
+    default:
+      return 0.35 + 0.35 * kick + 0.2 * swell;
+  }
+}
+function previewParams(code, params, t) {
+  const audio = reflectShader(code).params.filter((p) => p.audio);
+  if (!audio.length) return params;
+  const out = { ...params ?? {} };
+  for (const p of audio) out[p.name] = previewAudio(p.audio.signal, t, p.audio.bin);
+  return out;
+}
+function previewFrames() {
+  const n = Math.round(PREVIEW_LOOP_S * PREVIEW_FPS);
+  const k = Math.min(PREVIEW_FADE_FRAMES, n - 1);
+  return Array.from({ length: n }, (_, i) => ({ t: PREVIEW_START_S + i / PREVIEW_FPS, fade: i < n - k ? 0 : (i - (n - k) + 1) / (k + 1) }));
+}
+function mixInto(a, b, w) {
+  for (let i = 0; i < a.length; i++) a[i] = Math.round(a[i] + (b[i] - a[i]) * w);
+  return a;
+}
+function overGround(rgba) {
+  const [gr, gg, gb] = PREVIEW_GROUND;
+  for (let i = 0; i < rgba.length; i += 4) {
+    const a = rgba[i + 3] / 255;
+    if (a >= 1) continue;
+    rgba[i] = Math.round(rgba[i] * a + gr * (1 - a));
+    rgba[i + 1] = Math.round(rgba[i + 1] * a + gg * (1 - a));
+    rgba[i + 2] = Math.round(rgba[i + 2] * a + gb * (1 - a));
+    rgba[i + 3] = 255;
+  }
+  return rgba;
+}
+async function renderShaderPreview(device, fills, code, params, zoom = 1) {
+  if ((await fills.checkShader(code)).some((d) => d.severity === "error")) return null;
+  const w = PREVIEW_WIDTH, h = PREVIEW_HEIGHT;
+  const W = Math.round(w * Math.max(1, zoom)), H = Math.round(h * Math.max(1, zoom));
+  const middle = { x: Math.floor((W - w) / 2), y: Math.floor((H - h) / 2), w, h };
+  const draw = async (t) => {
+    const tex = fills.getTexture(code, W, H, t, previewParams(code, params, t));
+    if (!tex || tex.width !== W || tex.height !== H) return null;
+    return readTextureRGBA(device, tex, middle);
+  };
+  const animated = reflectShader(code).animated;
+  if (!animated) {
+    const still = await draw(0);
+    return still && { type: "image/png", bytes: await encodeRaster("PNG", w, h, overGround(still)), width: w, height: h, animated };
+  }
+  const frames = [];
+  for (const f of previewFrames()) {
+    const drawn = await draw(f.t);
+    if (!drawn) return null;
+    const rgba = overGround(drawn);
+    if (f.fade > 0) {
+      const earlier = await draw(f.t - PREVIEW_LOOP_S);
+      if (!earlier) return null;
+      mixInto(rgba, overGround(earlier), f.fade);
+    }
+    frames.push({ rgba, delay: 1e3 / PREVIEW_FPS });
+  }
+  return { type: "image/gif", bytes: await encodeFrames("gif", w, h, frames, PREVIEW_FPS), width: w, height: h, animated };
+}
+
+// lib/client/shader-preview.ts
+var MAX_CACHED = 64;
+var manager = null;
+var previews = /* @__PURE__ */ new Map();
+var urls = /* @__PURE__ */ new Map();
+var queue = Promise.resolve();
+function previewFills(device, onReset) {
+  if (manager?.device !== device) {
+    manager?.fills.destroy();
+    previews.clear();
+    for (const u of urls.values()) void u.then((url) => url && URL.revokeObjectURL(url));
+    urls.clear();
+    onReset?.();
+    manager = { device, fills: new ShaderFillManager({ device }) };
+  }
+  return manager.fills;
+}
+var keyOf = (code, params, zoom = 1) => `${packShaderParams(code, params).hash}|${zoom}|${code}`;
+function evict(cache, drop) {
+  while (cache.size > MAX_CACHED) {
+    const k = cache.keys().next().value;
+    drop?.(cache.get(k));
+    cache.delete(k);
+  }
+}
+function shaderPreview(code, params, zoom = 1) {
+  const device = getActiveRenderer()?.getDevice();
+  if (!device || typeof GPUTextureUsage === "undefined") return Promise.resolve(null);
+  const fills = previewFills(device);
+  const key = keyOf(code, params, zoom);
+  let hit = previews.get(key);
+  if (!hit) {
+    hit = queue.then(() => renderShaderPreview(device, fills, code, params, zoom)).catch(() => null);
+    queue = hit;
+    previews.set(key, hit);
+    evict(previews);
+  }
+  return hit;
+}
+function shaderPreviewUrl(code, params, zoom = 1) {
+  const key = keyOf(code, params, zoom);
+  let hit = urls.get(key);
+  if (!hit) {
+    hit = shaderPreview(code, params, zoom).then((p) => p ? URL.createObjectURL(new Blob([p.bytes], { type: p.type })) : null);
+    urls.set(key, hit);
+    evict(urls, (u) => void u.then((url) => url && URL.revokeObjectURL(url)));
+  }
+  return hit;
+}
+async function shaderPreviewDataUrl(code, params) {
+  const p = await shaderPreview(code, params);
+  if (!p) return null;
+  let bin = "";
+  for (let i = 0; i < p.bytes.length; i += 32768) bin += String.fromCharCode(...p.bytes.subarray(i, i + 32768));
+  return `data:${p.type};base64,${btoa(bin)}`;
+}
+export {
+  previewFills,
+  shaderPreview,
+  shaderPreviewDataUrl,
+  shaderPreviewUrl
+};

package/dist/chunks/sites-XV7IK35R.js

@@ -0,0 +1,33 @@
+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 {
+  deleteSite,
+  publishSite,
+  renameSite,
+  setSiteVersion,
+  siteStatus,
+  workspaceSites
+} from "./chunk-JTLL324P.js";
+import "./chunk-ZFALJ2Y6.js";
+import "./chunk-PJY3DG52.js";
+import "./chunk-D5UTY5ZB.js";
+import "./chunk-R22FHI7D.js";
+import "./chunk-L637JZMZ.js";
+import "./chunk-RSE6FJ2C.js";
+import "./chunk-EGL3UDSX.js";
+import "./chunk-FPG2DJ7G.js";
+import "./chunk-JIZTNKHY.js";
+import "./chunk-FFS4SO7R.js";
+import "./chunk-LJSVREWM.js";
+export {
+  deleteSite,
+  publishSite,
+  renameSite,
+  setSiteVersion,
+  siteStatus,
+  workspaceSites
+};