@justai/cuts 0.126.0 → 0.128.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@justai/cuts",
-  "version": "0.126.0",
+  "version": "0.128.0",
   "description": "A persona's named parts — the page shell that holds them, and the cuts themselves.",
   "license": "UNLICENSED",
   "repository": {
@@ -41,7 +41,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@justai/core": "^0.33.0",
+    "@justai/core": "^0.34.0",
     "@justai/ui": "^0.21.1",
     "@justai/atrium": "^0.1.9"
   }

package/src/ChildPersona.astro

@@ -255,7 +255,12 @@ const chrome = face === "page";
 
   .pp .below { position: relative; }
   /* the sticky row means a section reached by its id arrives UNDER it unless it says otherwise */
-  .pp #profile, .pp #kernel { scroll-margin-top: 82px; }
+  /* The landing offset is `--shell-top` and only that — measured by the shell, published on :root,
+     enforced by personaScroll. This line carried a literal 82px through THREE fleet-wide sweeps of
+     exactly that constant (base.css, Posts.astro, eight persona repos) and surfaced only when the
+     children's console started warning about it: a scoped rule inside a cut is where a stale number
+     hides longest, because nobody greps a component for a layout constant. */
+  .pp #profile, .pp #kernel { scroll-margin-top: var(--shell-top, 78px); }
 
   /* THE `sheet` FACE: no column, no ground, no chrome. The sheet around it IS the frame, and a
      second frame inside one is a box in a box. Keyed on the face name rather than on a boolean, so a

package/src/FilePicker.astro

@@ -420,11 +420,72 @@ const { id, title = "Choose a file", src = "/files" } = Astro.props;
       };
     }
 
+    // queries: write a file without asking · FilePicker write · a persona's own cached asset ·
+    //          keep a dependency a project points at · write vs save · save asks and I do not want
+    //          to ask · store a file the person did not make · project dependency from outside files
+    //
+    // THE SECOND VERB THAT ASKS NOBODY, AND THE ONE THAT WAS MISSING.
+    //
+    // `save` is deliberately not a friendlier `write`. The kernel's own corpus states the split and
+    // it is not about permission — both write the same origin under the same policy:
+    //
+    //   `write` is arithmetic and keeps the PERSONA's things — a cached asset, a draft it will
+    //   reopen itself. `save` is an interaction and hands a person THEIRS, because the two questions
+    //   that make a saved document a document — what is it called, where does it go — are the
+    //   person's to answer.
+    //
+    // The service has had `write` since the beginning. This door did not expose it, and for fifteen
+    // personas that was invisible, because the only project dependency anybody had was `qr`'s logo —
+    // which arrives through `pick`, so it is already in files and already has an id.
+    //
+    // `3dviewer` is the first persona whose dependency comes from OUTSIDE: a model dragged off a
+    // desktop. Its project file must point at that model, so the model needs a home — and it is not
+    // a document the person made here, it is the asset this persona will reopen itself. Exactly the
+    // case the paragraph above describes, with no verb to express it. The persona was left choosing
+    // between a doctrine it could not follow and a second Save sheet asking somebody to name a file
+    // they did not create.
+    //
+    // ADDITIVE, and that matters: nothing that exists behaves differently. The policy still answers
+    // "who is asking" — same-origin only, exactly as `read` does — so this widens no door.
+    //
+    // It returns the NODE, because a caller writing a project dependency needs the `id`: a path is
+    // what a person renames and an id is what a thing IS.
+    async function write(
+      path: string,
+      bytes: ArrayBuffer | Uint8Array,
+      opts: { mime?: string; keepVersions?: number } = {},
+    ): Promise<{ id: string; name: string; path: string } | null> {
+      const bus = await router();
+      ensureFrame();
+      const body = bytes instanceof Uint8Array
+        ? (bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength
+            ? bytes.buffer
+            : bytes.slice().buffer)
+        : bytes;
+      const node = await arrived!
+        .then(() => bus.proxy({
+          service: "files",
+          method: "write",
+          args: { path, bytes: body, mime: opts.mime, keepVersions: opts.keepVersions },
+          // The same 30s ceiling `read` uses. A model is tens of megabytes and a phone's storage is
+          // not fast; the default would time out on exactly the files this verb exists for.
+          options: { timeout: 30000 },
+        }))
+        .catch(() => null);
+      // A quota that is full, or a path the kernel refused. `null` rather than a throw, for the same
+      // reason `read` returns null: a caller must be able to carry on and say so.
+      if (!node) return null;
+      const n = node as { id: string; name: string };
+      return { id: n.id, name: n.name, path };
+    }
+
     (host as any).pick = pick;
     (sheet as any).pick = pick;
     (host as any).save = save;
     (sheet as any).save = save;
     (host as any).read = read;
     (sheet as any).read = read;
+    (host as any).write = write;
+    (sheet as any).write = write;
   }
 </script>