@vibecook/ice 0.15.0 → 0.16.0-portals.3

package/dist/{chunk-US7WJNR6.js → chunk-NB4ALBIY.js}

@@ -12,7 +12,7 @@ import {
   defineQuery,
   field,
   init
-} from "./chunk-SPG45AVV.js";
+} from "./chunk-SHU3HVMF.js";
 
 // ../desk/src/lattice/lod.ts
 var BASE_SPACING = 20;
@@ -759,7 +759,7 @@ var PIECES = {
   ruler: { file: "mat/ruler.wgsl" },
   book: { structs: [NbUniforms, NbBook], file: "kit/book.wgsl" }
 };
-var ALIASES = { lamp: "light", gobo: "light", night: "light", noise: "light" };
+var ALIASES = { lamp: "light", gobo: "light", night: "light", noise: "light", mat: "light" };
 var KIT_WGSL_FILES = Object.fromEntries(
   Object.entries(PIECES).flatMap(([name, p]) => "file" in p ? [[name, p.file]] : [])
 );
@@ -1139,26 +1139,26 @@ var HOLD = {
   bar: { travelMs: 340, backMs: 200 }
 };
 var isNarrow = (vp) => vp.width < HOLD.narrow;
-function readingTarget(extent, vp, spread = false, face = 0, reserves = HOLD) {
+function readingTarget(extent2, vp, spread = false, face = 0, reserves = HOLD) {
   const narrow = isNarrow(vp);
   const m = narrow ? HOLD.marginPhone : HOLD.margin;
   const top = narrow ? HOLD.topPhone : reserves.top;
   const boxW = Math.max(40, vp.width - 2 * m);
   const boxH = Math.max(40, vp.height - top - reserves.band);
-  let s = Math.min(boxW / extent.w, boxH / extent.h, HOLD.max);
+  let s = Math.min(boxW / extent2.w, boxH / extent2.h, HOLD.max);
   let single = false;
   if (spread && narrow && vp.width < vp.height * 0.85) {
     const own = Math.max(40, vp.height - top - HOLD.band);
-    const s0 = Math.min(boxW / extent.w, own / extent.h, HOLD.max);
-    if (Math.min(boxW / (extent.w / 2), own / extent.h, HOLD.max) > s0 * 1.3) {
-      s = Math.min(boxW / (extent.w / 2), boxH / extent.h, HOLD.max);
+    const s0 = Math.min(boxW / extent2.w, own / extent2.h, HOLD.max);
+    if (Math.min(boxW / (extent2.w / 2), own / extent2.h, HOLD.max) > s0 * 1.3) {
+      s = Math.min(boxW / (extent2.w / 2), boxH / extent2.h, HOLD.max);
       single = true;
     }
   }
-  return { cx: vp.width / 2 - (single ? extent.w / 4 * s * (1 - 2 * face) : 0), cy: top + boxH / 2, s, single };
+  return { cx: vp.width / 2 - (single ? extent2.w / 4 * s * (1 - 2 * face) : 0), cy: top + boxH / 2, s, single };
 }
-function homePose(extent, angle, cam) {
-  return { cx: (extent.cx - cam.x) * cam.zoom, cy: (extent.cy - cam.y) * cam.zoom, s: cam.zoom, angle };
+function homePose(extent2, angle, cam) {
+  return { cx: (extent2.cx - cam.x) * cam.zoom, cy: (extent2.cy - cam.y) * cam.zoom, s: cam.zoom, angle };
 }
 var HELD_USER_REST = { zoom: 1, panX: 0, panY: 0 };
 function heldPose(home, target, user, e) {
@@ -1188,11 +1188,11 @@ function heldFocus(e, vp, theme) {
     light: night ? mixLight(theme.matLight, DAY_LIGHT, e) : theme.matLight
   };
 }
-function heldCamera(pose, rect, extent, deskZoom, eye, vp) {
+function heldCamera(pose, rect, extent2, deskZoom, eye, vp) {
   const zoom = eye ? Math.min(deskZoom, pose.s) : pose.s;
   const grow = pose.s / zoom;
-  const ox = rect.cx - extent.cx;
-  const oy = rect.cy - extent.cy;
+  const ox = rect.cx - extent2.cx;
+  const oy = rect.cy - extent2.cy;
   const c = Math.cos(pose.angle);
   const sn = Math.sin(pose.angle);
   const sx = pose.cx + (c * ox - sn * oy) * pose.s;
@@ -1202,11 +1202,11 @@ function heldCamera(pose, rect, extent, deskZoom, eye, vp) {
   const ey = rect.cy - (sy - vp.height / 2) / (grow * zoom);
   return { cam: { x: ex - vp.width / (2 * zoom), y: ey - vp.height / (2 * zoom), zoom }, grow };
 }
-function heldFrame(pose, extent, single, face = 0) {
-  if (!single) return { cx: pose.cx, cy: pose.cy, hx: extent.w / 2 * pose.s, hy: extent.h / 2 * pose.s, s: pose.s };
-  const half = extent.w / 4 * pose.s;
+function heldFrame(pose, extent2, single, face = 0) {
+  if (!single) return { cx: pose.cx, cy: pose.cy, hx: extent2.w / 2 * pose.s, hy: extent2.h / 2 * pose.s, s: pose.s };
+  const half = extent2.w / 4 * pose.s;
   const q = half * (1 - 2 * face);
-  return { cx: pose.cx + q * Math.cos(pose.angle), cy: pose.cy + q * Math.sin(pose.angle), hx: half, hy: extent.h / 2 * pose.s, s: pose.s };
+  return { cx: pose.cx + q * Math.cos(pose.angle), cy: pose.cy + q * Math.sin(pose.angle), hx: half, hy: extent2.h / 2 * pose.s, s: pose.s };
 }
 var focusOf = (e, vp) => ({ blur: (isNarrow(vp) ? HOLD.blurPhone : HOLD.blur) * e, dim: HOLD.dim * e });
 
@@ -1675,6 +1675,329 @@ function eyeValues(e, reach = 900) {
   return { eye: [e.ex, e.ey, e.h, e.zoom], view: [e.vw, e.vh, near, far] };
 }
 
+// ../desk/src/kit/mips.ts
+var WGSL2 = (
+  /* wgsl */
+  `
+@group(0) @binding(0) var src: texture_2d<f32>;
+@group(0) @binding(1) var samp: sampler;
+struct VO { @builtin(position) pos: vec4f, @location(0) uv: vec2f }
+@vertex fn vs(@builtin(vertex_index) i: u32) -> VO {
+  let p = array<vec2f, 3>(vec2f(-1.0, -1.0), vec2f(3.0, -1.0), vec2f(-1.0, 3.0))[i];
+  var o: VO; o.pos = vec4f(p, 0.0, 1.0); o.uv = vec2f(0.5 * p.x + 0.5, 0.5 - 0.5 * p.y); return o;
+}
+@fragment fn fs(v: VO) -> @location(0) vec4f { return textureSampleLevel(src, samp, v.uv, 0.0); }
+`
+);
+var cache = /* @__PURE__ */ new WeakMap();
+var mipCount = (w, h) => Math.floor(Math.log2(Math.max(w, h, 1))) + 1;
+function pipeOf(device, format) {
+  let c = cache.get(device);
+  if (!c) {
+    c = { module: device.createShaderModule({ label: "photo/mips", code: WGSL2 }), sampler: device.createSampler({ minFilter: "linear", magFilter: "linear" }), pipes: /* @__PURE__ */ new Map() };
+    cache.set(device, c);
+  }
+  let pipe = c.pipes.get(format);
+  if (!pipe) {
+    pipe = device.createRenderPipeline({
+      label: `photo/mips ${format}`,
+      layout: "auto",
+      vertex: { module: c.module, entryPoint: "vs" },
+      fragment: { module: c.module, entryPoint: "fs", targets: [{ format }] }
+    });
+    c.pipes.set(format, pipe);
+  }
+  return { pipe, sampler: c.sampler };
+}
+function generateMips(device, texture) {
+  const { pipe, sampler } = pipeOf(device, texture.format);
+  const encoder = device.createCommandEncoder({ label: "photo/mips" });
+  for (let level = 1; level < texture.mipLevelCount; level++) {
+    const src = texture.createView({ baseMipLevel: level - 1, mipLevelCount: 1 });
+    const dst = texture.createView({ baseMipLevel: level, mipLevelCount: 1 });
+    const group = device.createBindGroup({ layout: pipe.getBindGroupLayout(0), entries: [{ binding: 0, resource: src }, { binding: 1, resource: sampler }] });
+    const pass = encoder.beginRenderPass({ colorAttachments: [{ view: dst, loadOp: "clear", storeOp: "store", clearValue: { r: 0, g: 0, b: 0, a: 0 } }] });
+    pass.setPipeline(pipe);
+    pass.setBindGroup(0, group);
+    pass.draw(3);
+    pass.end();
+  }
+  device.queue.submit([encoder.finish()]);
+}
+var chains = /* @__PURE__ */ new WeakMap();
+function mipsInto(device, encoder, texture, from, to) {
+  const first = Math.max(1, Math.floor(from));
+  const last = Math.min(Math.floor(to), texture.mipLevelCount - 1);
+  if (last < first) return;
+  let chain = chains.get(texture);
+  if (chain === void 0) {
+    const { pipe, sampler } = pipeOf(device, texture.format);
+    chain = { pipe, sampler, views: [], groups: [] };
+    chains.set(texture, chain);
+  }
+  const c = chain;
+  const view = (level) => {
+    let v = c.views[level];
+    if (v === void 0) {
+      v = texture.createView({ baseMipLevel: level, mipLevelCount: 1 });
+      c.views[level] = v;
+    }
+    return v;
+  };
+  for (let level = first; level <= last; level++) {
+    let group = c.groups[level];
+    if (group === void 0) {
+      group = device.createBindGroup({ layout: c.pipe.getBindGroupLayout(0), entries: [{ binding: 0, resource: view(level - 1) }, { binding: 1, resource: c.sampler }] });
+      c.groups[level] = group;
+    }
+    const pass = encoder.beginRenderPass({ colorAttachments: [{ view: view(level), loadOp: "clear", storeOp: "store", clearValue: { r: 0, g: 0, b: 0, a: 0 } }] });
+    pass.setPipeline(c.pipe);
+    pass.setBindGroup(0, group);
+    pass.draw(3);
+    pass.end();
+  }
+}
+
+// ../desk/src/kit/live.ts
+function extent(what, v) {
+  if (typeof v !== "number" || !Number.isFinite(v) || v < 1) throw new Error(`createLiveTexture: ${what} must be a finite number \u2265 1 (got ${String(v)})`);
+  return Math.floor(v);
+}
+function logicalOf(l) {
+  if (l === void 0) return null;
+  const ok = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
+  if (!Array.isArray(l) || !ok(l[0]) || !ok(l[1])) throw new Error(`LiveWriter: a logical size is [width, height], each finite and > 0 (got ${JSON.stringify(l)})`);
+  return [l[0], l[1]];
+}
+var isVideoFrame = (s) => typeof s.close === "function" && typeof s.codedWidth === "number";
+function wholeOf(s) {
+  if (isVideoFrame(s)) return { x: 0, y: 0, width: s.displayWidth, height: s.displayHeight };
+  const c = s;
+  return { x: 0, y: 0, width: c.width, height: c.height };
+}
+function createLiveTexture(device, o) {
+  const format = o.format ?? "rgba8unorm-srgb";
+  if (format !== "rgba8unorm-srgb" && format !== "rgba8unorm") throw new Error(`createLiveTexture: format must be "rgba8unorm-srgb" or "rgba8unorm" (got ${String(format)})`);
+  if (typeof o.label !== "string") throw new Error("createLiveTexture: `label` is required \u2014 the caller's, `<kind>/live <key>` by convention");
+  const chain = o.mips !== false;
+  let width = extent("width", o.width);
+  let height = extent("height", o.height);
+  const make = (w, h) => device.createTexture({
+    label: o.label,
+    size: [w, h],
+    format,
+    mipLevelCount: chain ? mipCount(w, h) : 1,
+    usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT
+  });
+  let texture = make(width, height);
+  let view = null;
+  let revision = 0;
+  let epoch = 0;
+  let mipped = { epoch: -1, revision: -1, depth: 0 };
+  let logical = null;
+  let gone = false;
+  const sized = (w, h) => {
+    if (w === width && h === height) return;
+    logical = null;
+    texture.destroy();
+    width = w;
+    height = h;
+    texture = make(w, h);
+    view = null;
+    epoch += 1;
+  };
+  const face = {
+    get width() {
+      return width;
+    },
+    get height() {
+      return height;
+    },
+    format,
+    get revision() {
+      return revision;
+    },
+    get epoch() {
+      return epoch;
+    },
+    view() {
+      if (view === null) view = texture.createView();
+      return view;
+    },
+    prepare(encoder, upTo) {
+      if (gone || revision === 0) return;
+      if (mipped.epoch !== epoch || mipped.revision !== revision) mipped = { epoch, revision, depth: 0 };
+      const to = Math.min(Math.floor(upTo), texture.mipLevelCount - 1);
+      if (!(to > mipped.depth)) return;
+      mipsInto(device, encoder, texture, mipped.depth + 1, to);
+      mipped.depth = to;
+    },
+    get bytes() {
+      return chainBytes(width, height, texture.mipLevelCount);
+    },
+    get logical() {
+      return logical ?? [width, height];
+    }
+  };
+  return {
+    face,
+    present(source, rect, size) {
+      try {
+        if (gone) return;
+        const r = rect ?? wholeOf(source);
+        const w = extent("the source's width", r.width);
+        const h = extent("the source's height", r.height);
+        const l = logicalOf(size);
+        sized(w, h);
+        device.queue.copyExternalImageToTexture({ source, origin: [r.x, r.y] }, { texture, premultipliedAlpha: false }, [w, h]);
+        logical = l;
+        revision += 1;
+      } finally {
+        if (isVideoFrame(source)) source.close();
+      }
+    },
+    presentBytes(bytes, w0, h0, size) {
+      if (gone) return;
+      const w = extent("width", w0);
+      const h = extent("height", h0);
+      if (bytes.byteLength < w * h * 4) throw new Error(`LiveWriter.presentBytes: ${bytes.byteLength} bytes for ${w} \xD7 ${h} RGBA8 rows (${w * h * 4} wanted)`);
+      const l = logicalOf(size);
+      sized(w, h);
+      device.queue.writeTexture({ texture }, bytes, { bytesPerRow: w * 4, rowsPerImage: h }, [w, h]);
+      logical = l;
+      revision += 1;
+    },
+    presentTexture(src, rect, size) {
+      if (gone) return;
+      const r = rect ?? { x: 0, y: 0, width: src.width, height: src.height };
+      const w = extent("the source's width", r.width);
+      const h = extent("the source's height", r.height);
+      const l = logicalOf(size);
+      sized(w, h);
+      const encoder = device.createCommandEncoder({ label: `${o.label} present` });
+      encoder.copyTextureToTexture({ texture: src, origin: [r.x, r.y] }, { texture }, [w, h]);
+      device.queue.submit([encoder.finish()]);
+      logical = l;
+      revision += 1;
+    },
+    resize(w, h) {
+      if (gone) return;
+      sized(extent("width", w), extent("height", h));
+    },
+    destroy() {
+      if (gone) return;
+      gone = true;
+      texture.destroy();
+    }
+  };
+}
+function liveDepth(face, px) {
+  const ratio = Math.max(face.width / Math.max(px[0], 1e-6), face.height / Math.max(px[1], 1e-6));
+  return ratio <= 1 ? 0 : Math.ceil(Math.log2(ratio) - 1e-9);
+}
+var LIVE = serviceKey("live");
+var UNSEEN = { seen: false, px: [0, 0], held: false };
+var sameSeen = (a, b) => a.seen === b.seen && a.held === b.held && a.px[0] === b.px[0] && a.px[1] === b.px[1];
+function createSight(frames) {
+  const facts = /* @__PURE__ */ new Map();
+  const fold = /* @__PURE__ */ new Map();
+  let foldAt = -1;
+  let stepped = -1;
+  return {
+    saw(e, slot, face) {
+      if (slot.target === "copy" || slot.target === "capture") return;
+      if (frames !== void 0) {
+        const n = frames();
+        if (n !== foldAt) {
+          fold.clear();
+          foldAt = n;
+        }
+      }
+      const k = slot.view.zoom * slot.view.dpr;
+      const glimpse = { w: Math.round(face.w * k), h: Math.round(face.h * k), held: slot.target === "hand" };
+      const had = fold.get(e);
+      if (had === void 0) {
+        fold.set(e, glimpse);
+        return;
+      }
+      if (glimpse.w * glimpse.h > had.w * had.h) {
+        had.w = glimpse.w;
+        had.h = glimpse.h;
+      }
+      had.held ||= glimpse.held;
+    },
+    step() {
+      const moved = /* @__PURE__ */ new Map();
+      if (frames !== void 0) {
+        const n = frames();
+        if (foldAt === n) {
+          fold.clear();
+          foldAt = -1;
+        }
+        if (n === stepped) return moved;
+        stepped = n;
+        if (foldAt !== n - 1) fold.clear();
+      }
+      for (const [e, g] of fold) {
+        const now = { seen: true, px: [g.w, g.h], held: g.held };
+        const was = facts.get(e);
+        if (was === void 0 || !sameSeen(was, now)) {
+          facts.set(e, now);
+          moved.set(e, now);
+        }
+      }
+      for (const [e, was] of facts) {
+        if (fold.has(e) || !was.seen) continue;
+        facts.set(e, UNSEEN);
+        moved.set(e, UNSEEN);
+      }
+      if (frames === void 0) fold.clear();
+      return moved;
+    },
+    of: (e) => facts.get(e),
+    owed: () => frames !== void 0 && frames() !== stepped,
+    forget(e) {
+      facts.delete(e);
+      fold.delete(e);
+    }
+  };
+}
+function stillLive(device, frames) {
+  const open = /* @__PURE__ */ new Set();
+  return {
+    open(key, spec) {
+      if (open.has(key)) throw new Error(`stillLive: the face "${key}" is open twice \u2014 one face per key per desk (design-019 \xA73.2)`);
+      open.add(key);
+      const still = typeof frames === "function" ? frames(key, spec) : frames[key];
+      let writer;
+      let taken = false;
+      let closed = false;
+      return {
+        key,
+        texture: () => writer?.face,
+        take() {
+          if (taken || closed || still === void 0) return false;
+          taken = true;
+          writer = createLiveTexture(device, { label: `live/still ${key}`, width: still.width, height: still.height });
+          writer.presentBytes(still.bytes, still.width, still.height, still.logical);
+          return true;
+        },
+        state: () => closed ? { is: "closed" } : still === void 0 ? { is: "starting" } : { is: "live" },
+        info: () => still?.info ?? {},
+        demand: () => {
+        },
+        close() {
+          if (closed) return;
+          closed = true;
+          writer?.destroy();
+          writer = void 0;
+          open.delete(key);
+        }
+      };
+    }
+  };
+}
+
 // ../desk/src/kit/mesh.ts
 var VERTEX_FLOATS = 16;
 var VERTEX_BYTES = VERTEX_FLOATS * 4;
@@ -1752,52 +2075,6 @@ var MeshWriter = class {
   }
 };
 
-// ../desk/src/kit/mips.ts
-var WGSL2 = (
-  /* wgsl */
-  `
-@group(0) @binding(0) var src: texture_2d<f32>;
-@group(0) @binding(1) var samp: sampler;
-struct VO { @builtin(position) pos: vec4f, @location(0) uv: vec2f }
-@vertex fn vs(@builtin(vertex_index) i: u32) -> VO {
-  let p = array<vec2f, 3>(vec2f(-1.0, -1.0), vec2f(3.0, -1.0), vec2f(-1.0, 3.0))[i];
-  var o: VO; o.pos = vec4f(p, 0.0, 1.0); o.uv = vec2f(0.5 * p.x + 0.5, 0.5 - 0.5 * p.y); return o;
-}
-@fragment fn fs(v: VO) -> @location(0) vec4f { return textureSampleLevel(src, samp, v.uv, 0.0); }
-`
-);
-var cache = /* @__PURE__ */ new WeakMap();
-var mipCount = (w, h) => Math.floor(Math.log2(Math.max(w, h, 1))) + 1;
-function generateMips(device, texture) {
-  let c = cache.get(device);
-  if (!c) {
-    c = { module: device.createShaderModule({ label: "photo/mips", code: WGSL2 }), sampler: device.createSampler({ minFilter: "linear", magFilter: "linear" }), pipes: /* @__PURE__ */ new Map() };
-    cache.set(device, c);
-  }
-  let pipe = c.pipes.get(texture.format);
-  if (!pipe) {
-    pipe = device.createRenderPipeline({
-      label: `photo/mips ${texture.format}`,
-      layout: "auto",
-      vertex: { module: c.module, entryPoint: "vs" },
-      fragment: { module: c.module, entryPoint: "fs", targets: [{ format: texture.format }] }
-    });
-    c.pipes.set(texture.format, pipe);
-  }
-  const encoder = device.createCommandEncoder({ label: "photo/mips" });
-  for (let level = 1; level < texture.mipLevelCount; level++) {
-    const src = texture.createView({ baseMipLevel: level - 1, mipLevelCount: 1 });
-    const dst = texture.createView({ baseMipLevel: level, mipLevelCount: 1 });
-    const group = device.createBindGroup({ layout: pipe.getBindGroupLayout(0), entries: [{ binding: 0, resource: src }, { binding: 1, resource: c.sampler }] });
-    const pass = encoder.beginRenderPass({ colorAttachments: [{ view: dst, loadOp: "clear", storeOp: "store", clearValue: { r: 0, g: 0, b: 0, a: 0 } }] });
-    pass.setPipeline(pipe);
-    pass.setBindGroup(0, group);
-    pass.draw(3);
-    pass.end();
-  }
-  device.queue.submit([encoder.finish()]);
-}
-
 // ../desk/src/kit/paper-tex.ts
 var PAPER_TEX = 256;
 var TOOTH_SCALE = 48;
@@ -2356,12 +2633,18 @@ export {
   unproject,
   rayThrough,
   eyeValues,
+  mipCount,
+  generateMips,
+  mipsInto,
+  createLiveTexture,
+  liveDepth,
+  LIVE,
+  createSight,
+  stillLive,
   VERTEX_FLOATS,
   VERTEX_BYTES,
   FLAG_TWO_SIDED,
   MeshWriter,
-  mipCount,
-  generateMips,
   PAPER_TEX,
   TOOTH_SCALE,
   paperTexture,
@@ -2399,4 +2682,4 @@ export {
   writeChanged,
   lineWeight
 };
-//# sourceMappingURL=chunk-US7WJNR6.js.map
+//# sourceMappingURL=chunk-NB4ALBIY.js.map