@vibecook/ice 0.15.0-desk.2 → 0.15.0-desk.3

package/README.md

@@ -102,7 +102,9 @@ export const Clock = defineObject({
 - **Being a container** — `ObjectKind.face` and `faceLaw: { radius, chips, finishes }`; a child's `chip()` names its finish.
 - **Held tools and menu acts** — a tool's `glyph` is a name of the bar's set or its own `{ path }`; `menu` acts show for a
   selection of the kind and run through `ops.runMenuAction`.
-- **Stills** — `handle.pinAsset(entity, asset)` pins the kind's own `ctx.asset`.
+- **Stills** — `handle.pinAsset(entity, asset)` pins the kind's own `ctx.asset`; and a kind's pixel proof needs no desk layer:
+  `createStill({ device, format, size, dpr, objects, stage })` draws ONE frame on your device (Dawn in Node, or a browser's), no
+  canvas — `stage` lays its world (`engine.ops.spawnWidget`, `pinAsset`) — and hands back its RGBA to hold to a golden of your own.
 
 React and `react-dom` are **optional** peer dependencies — the core, desk and dom
 entries are React-free; `three` is imported nowhere.

package/dist/{chunk-52GMQ2BN.js → chunk-DNMUIKNE.js}

@@ -18,6 +18,7 @@ import {
   HOLD,
   LAYER_IDLE_MS,
   MARKS,
+  MAT,
   MAT_GRID,
   MISSING,
   MatUniforms,
@@ -75,6 +76,7 @@ import {
   smoothstep,
   solveFlightStart,
   spring,
+  themeFrom,
   tilted
 } from "./chunk-K4HUZAYJ.js";
 import {
@@ -132,6 +134,7 @@ import {
   WidgetEquipped,
   closeTray,
   compareStackOrder,
+  createCanvasEngine,
   createSiblingOrderIndex,
   currentNavFrame,
   defineQuery,
@@ -3356,8 +3359,8 @@ function renderHeldFrame(device, hold, root, pool, grid, into, inputs, held, cac
   device.queue.submit([encoder.finish()]);
   return cache.stats ?? { k0: 0, fade: 0, wind: false, kinds: hand.kinds, outgoing: null, portals: 0 };
 }
-var captureNumber = (what, v, positive) => {
-  if (typeof v !== "number" || !Number.isFinite(v) || positive && v <= 0) throw new Error(`capture: ${what} must be a ${positive ? "positive " : ""}finite number (got ${String(v)})`);
+var captureNumber = (what, v, positive2) => {
+  if (typeof v !== "number" || !Number.isFinite(v) || positive2 && v <= 0) throw new Error(`capture: ${what} must be a ${positive2 ? "positive " : ""}finite number (got ${String(v)})`);
   return v;
 };
 function checkCapture(opts) {
@@ -8166,6 +8169,151 @@ async function ablateKinds(a, opts = {}) {
   return { frames, rounds, base: baseS, control: sampled(c), aa: median(c) - baseS.median, noise, kinds: out, samples: Object.fromEntries(ms) };
 }
 
+// ../desk/src/still.ts
+async function createStillDesk(opts) {
+  const mat = await CuttingMat.create(opts.device, opts.format, matShaders(shaderText(MAT_SHADER_FILES)));
+  let root;
+  try {
+    root = await createSlotSet(opts.device, opts.format, mat, opts.kinds, opts.onError);
+  } catch (err) {
+    mat.dispose();
+    throw err;
+  }
+  mat.setNoise(blueNoise());
+  const pool = new SlotPool(root);
+  let disposed = false;
+  return {
+    mat,
+    root,
+    pool,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      pool.dispose();
+      root.card?.dispose();
+      for (const k of [...root.kinds.values()].reverse()) k.pass.dispose();
+      root.missing?.dispose();
+      mat.dispose();
+    }
+  };
+}
+var FORMATS = ["rgba8unorm", "bgra8unorm"];
+var THEMES = ["light", "dark"];
+var STILL_PALETTE = { canvasBg: MAT.ground, select: MARKS.inks.pencil };
+var positive = (what, v) => {
+  if (typeof v !== "number" || !Number.isFinite(v) || v <= 0) throw new Error(`createStill: ${what} must be a positive finite number (got ${String(v)})`);
+  return v;
+};
+var finite = (what, v) => {
+  if (typeof v !== "number" || !Number.isFinite(v)) throw new Error(`createStill: ${what} must be a finite number (got ${String(v)})`);
+  return v;
+};
+function kindsOf2(objects) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const t of objects) {
+    const k = objectKindOf(t);
+    if (k === void 0) throw new Error(`createStill: "${t.type}" is not a desk object \u2014 a still draws object types (\`defineObject\`)`);
+    if (!byName.has(k.name)) byName.set(k.name, k);
+  }
+  return [...byName.values()];
+}
+var SCOPES2 = ["validation", "out-of-memory", "internal"];
+var watched2 = (device) => typeof device.pushErrorScope === "function";
+var pushScopes2 = (device) => {
+  if (watched2(device)) for (const f of SCOPES2) device.pushErrorScope(f);
+};
+var popScopes2 = (device) => watched2(device) ? Promise.all(SCOPES2.map(() => device.popErrorScope())).then((errors) => errors.find((e) => e !== null) ?? null) : Promise.resolve(null);
+var gpuError = (e) => `${e.constructor?.name ?? "GPUError"}: ${e.message}`;
+var queues = /* @__PURE__ */ new WeakMap();
+function inTurn(device, run) {
+  const turn = (queues.get(device) ?? Promise.resolve()).then(run);
+  queues.set(device, turn.then(() => void 0, () => void 0));
+  return turn;
+}
+function createStill(opts) {
+  if (typeof opts !== "object" || opts === null) throw new Error("createStill: options are required");
+  if (typeof opts.device !== "object" || opts.device === null) throw new Error("createStill: `device` is required \u2014 the caller's GPUDevice");
+  if (!FORMATS.includes(opts.format)) throw new Error(`createStill: format must be ${FORMATS.map((f) => `"${f}"`).join(" or ")} (got ${String(opts.format)})`);
+  const width = positive("size.width", opts.size?.width);
+  const height = positive("size.height", opts.size?.height);
+  const dpr = positive("dpr", opts.dpr);
+  if (!Array.isArray(opts.objects)) throw new Error("createStill: `objects` must be a list of object types (`defineObject`)");
+  const kinds = kindsOf2(opts.objects);
+  const theme = opts.theme ?? "light";
+  if (!THEMES.includes(theme)) throw new Error(`createStill: theme must be "light" or "dark" (got ${String(theme)})`);
+  const cam = opts.camera === void 0 ? { x: -width / 2, y: -height / 2, zoom: 1 } : { x: finite("camera.x", opts.camera.x), y: finite("camera.y", opts.camera.y), zoom: positive("camera.zoom", opts.camera.zoom) };
+  if (typeof opts.stage !== "function") throw new Error("createStill: `stage` must be a function \u2014 it lays the still's world");
+  const plan = { width, height, dpr, kinds, theme, palette: opts.palette ?? STILL_PALETTE, cam };
+  return inTurn(opts.device, () => drawStill(opts, plan));
+}
+async function drawStill(opts, plan) {
+  const { device, format } = opts;
+  const { width, height, dpr, cam } = plan;
+  let unattributed2 = null;
+  const desk = await createStillDesk({ device, format, kinds: plan.kinds, onError: (e) => {
+    unattributed2 ??= e;
+  } });
+  let engine;
+  let builder;
+  try {
+    const refused = desk.root.faults?.[0];
+    if (refused !== void 0) throw new Error(`createStill: the kind "${refused.kind}" was ${refused.reason}`);
+    if (unattributed2 !== null) throw new Error(`createStill: a GPU error while the kinds were made, no kind's alone \u2014 ${gpuError(unattributed2)}`);
+    const theme = themeFrom(plan.theme, plan.palette);
+    const looks = looksOf(plan.kinds, plan.palette, theme);
+    engine = createCanvasEngine({ widgets: [...opts.objects] });
+    engine.docs.create();
+    const world = engine.world;
+    world.setResource(Viewport, { w: width, h: height, dpr });
+    world.setResource(Camera, { x: cam.x, y: cam.y, zoom: cam.zoom, gesturing: false });
+    const b = createDeskBuilder(world, { objects: [...opts.objects] });
+    builder = b;
+    await opts.stage({ engine, world, pinAsset: (e, asset) => b.pin(e, asset), pinFlux: (e, targets) => b.pinFlux(e, targets) });
+    engine.step(16);
+    engine.step(32);
+    b.changed();
+    const built = b.build(cam, { width, height, dpr }, 0, theme, DEFAULT_GRID, looks, { now: 0 });
+    const inputs = {
+      view: { camX: cam.x, camY: cam.y, zoom: cam.zoom, width, height, dpr },
+      grid: built.grid,
+      objects: built.objects,
+      ...built.portals.length > 0 ? { portals: built.portals } : {},
+      ...built.lodZoom !== void 0 ? { lodZoom: built.lodZoom } : {},
+      ...built.present !== void 0 ? { present: built.present } : {},
+      ...built.light !== void 0 ? { light: built.light } : {},
+      ...built.outgoing !== void 0 ? { outgoing: built.outgoing } : {},
+      theme
+    };
+    const passes = { root: desk.root, pool: desk.pool, grid: built.grid, marks: null, hold: null, tray: null, traySlots: null };
+    pushScopes2(device);
+    let shot;
+    let threw = null;
+    try {
+      shot = await captureFrame(device, passes, format, inputs, { stamp: null, stats: null, copies: 0 });
+    } catch (err) {
+      threw = { err };
+    }
+    const raised = await popScopes2(device);
+    if (threw !== null) throw threw.err;
+    if (raised !== null) throw new Error(`createStill: a GPU error while the still was drawn \u2014 ${gpuError(raised)}`);
+    if (shot === void 0) throw new Error("createStill: the device was lost before the still was read back");
+    const rgba = shot.bytes;
+    if (format === "bgra8unorm") {
+      for (let i = 0; i < rgba.length; i += 4) {
+        const blue = rgba[i];
+        rgba[i] = rgba[i + 2];
+        rgba[i + 2] = blue;
+      }
+    }
+    return { width: shot.width, height: shot.height, rgba, dispose() {
+    } };
+  } finally {
+    builder?.dispose();
+    engine?.dispose();
+    desk.dispose();
+  }
+}
+
 export {
   KIND_STRIKES,
   KIND_MISSING,
@@ -8264,6 +8412,8 @@ export {
   inkRaster,
   kindsIn,
   withoutKind,
-  ablateKinds
+  ablateKinds,
+  STILL_PALETTE,
+  createStill
 };
-//# sourceMappingURL=chunk-52GMQ2BN.js.map
+//# sourceMappingURL=chunk-DNMUIKNE.js.map