@justai/cuts 0.40.0 → 0.42.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@justai/cuts",
-  "version": "0.40.0",
+  "version": "0.42.0",
   "description": "A persona's named parts — the page shell that holds them, and the cuts themselves.",
   "license": "UNLICENSED",
   "repository": {

package/src/ActionRow.astro

@@ -51,11 +51,18 @@ interface Props {
   // without knowing this component's internals.
   /** Key for a runtime translator — lands on the LABEL, never on the row. */
   i18n?: string;
+  /**
+   * ANYTHING ELSE LANDS ON THE BUTTON. A consumer's `data-*` is how strings reach a bundled script
+   * in this ecosystem — a module script cannot read the frontmatter, so the DOM carries them — and
+   * a component that silently swallowed them would send the consumer looking for a bug in its own
+   * code. Astro drops unknown props unless they are spread, so they are spread.
+   */
+  [key: string]: unknown;
 }
-const { id, label, tone = "plain", detail, hidden, i18n } = Astro.props;
+const { id, label, tone = "plain", detail, hidden, i18n, ...rest } = Astro.props;
 ---
 
-<button class:list={["jal-row", tone !== "plain" && `is-${tone}`]} type="button" id={id} hidden={hidden}>
+<button class:list={["jal-row", tone !== "plain" && `is-${tone}`]} type="button" id={id} hidden={hidden} {...rest}>
   <span class="jal-ico" aria-hidden="true"><slot name="icon" /></span>
   <span class="jal-label" id={id ? `${id}-label` : undefined} data-i={i18n}>{label}</span>
   {detail && <span class="jal-detail">{detail}</span>}

package/src/FilePicker.astro

@@ -43,8 +43,9 @@ import Sheet from "./Sheet.astro";
  *
  *     const saved = await document.getElementById("logoPicker").save({
  *       name: "café wifi.qr", bytes, mime: "application/vnd.justai.qr+json",
+ *       thumb: await canvas.convertToBlob(),   // optional: give the file a face
  *     });
- *     // → { path, name } | null
+ *     // → { path, id, name } | null
  *
  * One element rather than two cuts, because it is one room: two frames would be two documents,
  * two atrium routers and two copies of the same kernel open at once, to ask the same file system
@@ -152,6 +153,19 @@ const { id, title = "Choose a file", src = "/files" } = Astro.props;
     /** Save BACK to a file already saved once. NO QUESTION IS ASKED: it was answered the first time. */
     id?: string;
     bytes: ArrayBuffer | Uint8Array;
+    /**
+     * THE FILE'S FACE — the ecosystem's optional standard, and worth taking.
+     *
+     * Most files can show themselves; a persona's OWN format cannot, and the persona is the only
+     * thing in the system that knows what it looks like. Hand over a small render (a 256px PNG is
+     * plenty) and the file has a face in the list and in its detail sheet instead of a large empty
+     * box saying there is no preview for this kind. Say nothing and nothing is lost.
+     *
+     * Kept small on purpose: the kernel drops a face over 64 KB rather than let a thumbnail become
+     * a second copy of the work in an evictable quota. Over the ceiling the FILE is still written —
+     * a cosmetic loss must never become a refused save.
+     */
+    thumb?: ArrayBuffer | Uint8Array | Blob;
     mime?: string;
     title?: string;
     timeout?: number;
@@ -302,10 +316,19 @@ const { id, title = "Choose a file", src = "/files" } = Astro.props;
       // text does) would otherwise have to know that the kernel wants the buffer, and that a typed
       // array's `.buffer` may be a larger pool it is only a window onto — a subtle way to save a
       // file with somebody else's bytes stuck to the end of it.
-      const b: any = req.bytes;
-      const bytes: ArrayBuffer =
-        b instanceof ArrayBuffer ? b : b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength);
-      const args = { name: req.name, ext: req.ext, id: req.id, bytes, mime: req.mime };
+      // THE CUT BRINGS ITS OWN GROUND for both payloads. A caller holds whatever its work produced
+      // — a typed array from an encoder, a Blob from a canvas — and must not have to know that a
+      // typed array's `.buffer` may be a larger pool it is only a window onto, which is a subtle
+      // way to save a file with somebody else's bytes stuck to the end of it.
+      const buffer = async (v: any): Promise<ArrayBuffer | undefined> => {
+        if (!v) return undefined;
+        if (v instanceof ArrayBuffer) return v;
+        if (typeof Blob !== "undefined" && v instanceof Blob) return v.arrayBuffer();
+        return v.buffer.slice(v.byteOffset, v.byteOffset + v.byteLength);
+      };
+      const bytes = (await buffer(req.bytes))!;
+      const thumb = await buffer(req.thumb);
+      const args = { name: req.name, ext: req.ext, id: req.id, bytes, thumb, mime: req.mime };
       // SAVING BACK OPENS NO SHEET, and that is the point rather than an optimisation. The person
       // named this file the first time; asking again on every save is not care, it is a persona
       // that cannot remember what it is working on. So this path never touches `ask`.