@lampdotdev/lamp 0.36.2-nightly.24 → 0.36.2-nightly.26

package/README.md

@@ -18,7 +18,7 @@ Mac app, `projectOf`), or any folder with an `index.html`; without one, the fold
 | `lamp new <folder> [--name "Its Name"] [--web \| --mac]` | Makes a new web game's folder from Lamp's starting files, or with `--web` a new web app's, or with `--mac` a new Mac app in Swift. |
 | `lamp init [--update]` | Puts Lamp's game runtime beside a page that's already there, changing none of the page's own files. `--update` writes again the Lamp files the folder has (`lamp.js` too), adding the game's only to a page that's a game already. |
 | `lamp unpack <file.lampapp> [folder]` | Unpacks a Lamp app file into a new folder beside it, named for it. A file carries none of Lamp's own files: a page gets them beside it as it's unpacked (the runtime for a game, lamp.js, the libraries its import map names), and a Mac app gets Package.swift, build.sh and LampSupport.swift from Lamp's starting files as it's first built (`writeMacStarter`), where it has none. One with a widget, a share extension or a 3D scene is left to Lamp's app, which writes the files they're built with. |
-| `lamp export [--to file] [--anyway]` | Makes the app's Lamp app file as Lamp's Share… does (`Sharing.export`, followed by `cli/lampapp.mjs`): its own files as its kind travels, Assets/, APP.md, what it declares, its credits with the app added to the chain, the licenses they name, its icon's design and lamp-app.json, never Lamp's own files. Refused when a license its credits name is gone or something in it is shaped like a key; `--anyway` sends work its credits give no license for. The shapes of keys, the names a license goes by and the sizes another Lamp opens are in `Resources/share-rules.json`, which Lamp's app reads too (`ShareRules`). |
+| `lamp export [--to file] [--anyway]` | Makes the app's Lamp app file as Lamp's Share… does (`Sharing.export`, followed by `cli/lampapp.mjs`): its own files as its kind travels, Assets/, APP.md, what it declares, its credits with the app added to the chain, the licenses they name, its icon's design and lamp-app.json, never Lamp's own files, nor what the folder's `.lampignore` names. Refused when a license its credits name is gone or something in it is shaped like a key; `--anyway` sends work its credits give no license for. The shapes of keys, the names a license goes by and the sizes another Lamp opens are in `Resources/share-rules.json`, which Lamp's app reads too (`ShareRules`). |
 | `lamp dev [--open] [--lan] [--port N]` | Runs the page and says how each change went. Each save goes into every open copy of it, with the card Lamp's app puts on an app taking a change (`page.js`, left out of lamp's pictures; `lamp changing "<words>"` says on it what's changing). `--open` opens a window for it; `--lan` lets other devices on the network open it. |
 | `lamp open` | Shows the page in a window, running it in the background if it isn't running, and returns at once. |
 | `lamp open --in-lamp` | Gives a Mac app to Lamp's app (`cli/outside.mjs`), over the socket the person's own coding agent uses (`OutsideServer`, `OutsideWork`): `open_project` takes the folder on, with Lamp's review the first time, and from then on `look`, `reload` and `dev` call `apply_change`, so a change goes into the open app as Lamp's app puts it there (`LiveReload`) and its outcome is said: live, held, reopened, not_built, crashed. `use` calls `use_app`, in plain sight in the app Lamp's app has open, and `stop` calls `close_app`. A folder Lamp's app no longer has (its refusal says `taken_on: false`) is lamp's own again, said once. `lamp open --here` has lamp run its own copy again. `LAMP_APP` names another Lamp by its bundle id (a Lamp Dev instance). A Mac app `lamp new --mac` makes has the `lamp-app.json` Lamp's app takes a folder on by. |
@@ -26,7 +26,7 @@ Mac app, `projectOf`), or any folder with an `index.html`; without one, the fold
 | `lamp use key w 2` | Tries it as a person would, then looks: `click`, `type`, `key` (several at once with `w+d`), `drag`, `scroll`, `wait`, and in a game on Lamp's runtime `stick` and `button`, which hold Lamp's own controller as Lamp's app does (`window.__lampDrive`) and give it back when the person plays. Several moves with `then` between them go one after another, with one look at the end. |
 | `lamp reload [--fresh]` | Opens the page again from its files, a game from where the player is, or with `--fresh` from its beginning (`window.lampFreshStart`). |
 | `lamp stop` | Stops running it. |
-| `lamp share --words "…"` | Puts the page on lamp.dev: anyone with the link plays it there and can send an idea. Again, it sends the page as it is now to the same link. The app's icon goes with it (`iconOf`: a square `icon.png` or `apple-touch-icon.png` beside the page, a PNG its index.html names as its icon, or Lamp's `.lamp/icon.png`, made 512 pixels a side when bigger), for its page and the browser's tab. |
+| `lamp share --words "…"` | Puts the page on lamp.dev: anyone with the link plays it there and can send an idea. Again, it sends the page as it is now to the same link. What the folder's `.lampignore` names stays out (`cli/ignore.mjs`: gitignore's simpler half, one pattern a line, `*`, `?`, `**`, a trailing `/` for a folder, no `!`; the app's own file counts for a page in Web/ too), so a page whose data is too big for a link shares from its own folder. The app's icon goes with it (`iconOf`: a square `icon.png` or `apple-touch-icon.png` beside the page, a PNG its index.html names as its icon, or Lamp's `.lamp/icon.png`, made 512 pixels a side when bigger), for its page and the browser's tab. |
 | `lamp share` (a page of Lamp's) | A web app or game in a Lamp's own folder is lamp's to share like any other page, Lamp open or not, to the link that Lamp keeps for it: lamp takes the link from the Lamp's `Wish Links.json` (by the app's instance id in `.lamp/meta.json`, `lampsKeptLink`) the first time, and tells it what went after each share or `unshare` (`keepInLamp`), so its Share Link card shows the link as it is. `ideas` and `unshare` take the link the same way. |
 | `lamp share` (any other app of Lamp's) | For a folder in Lamp's own (or a link to one) that lamp doesn't share as a page, shared by Lamp's app over its socket (`share_link`, `OutsideWork`): its Share Link card filled as it fills itself (`WishLinkCards.prepare`: the link's last words, the questions and what's new Lamp writes, the app's file, the GitHub release) and shared without its window, with `--line`, `--by`, `--asks`, `--notes`, `--no-file`, `--no-github`, `--put-on-github` in place of the card's own, and `--preview` to see it first. The link's secret stays in Lamp. Which Lamp is the one whose folder it is (`lampOwning`), or the one it was given to (`lamp open --in-lamp`, `givenTo`); any other folder is lamp's to share, whatever Lamp is running, and so is a given folder when its Lamp is too old to share for lamp. |
 | `lamp ideas [in <n> \| dismiss <n> \| reply <n> \| done <n> \| email <address\|off>] [note]` | The ideas people playing the link have sent and what's been said since, saying what became of one, and answering whoever sent it. |

package/Resources/skills/web-app/SKILL.md

@@ -75,7 +75,7 @@ needs Lamp (for AI, `LampAI.status`'s `reason`), never an error or an empty scre
 
 `LampAI.act(request, { about, context, tools, history, onStep })` runs a short loop: the AI picks calls among the
 app's tools, the page runs them, the AI sees the results, until it replies (at most 4 AI calls and 6 writes a
-turn, and no time limit unless the app sets one with `limits: { seconds }`, for a feature that should answer quickly). It works with
+turn, and no time limit unless the app sets one with `limits: { seconds }`, for a feature that should answer quickly; each read gives the AI up to 32 KB of its result, and an app whose state is bigger raises it with `limits: { result }`, up to 256 KB, rather than having the AI page through it). It works with
 whichever AI the person set up for apps' text, so don't tie it to voice: typing works wherever `act` does. Its comment in lamp.js has the shapes. This is the one recipe for it:
 
 - Show the feature where `LampAI.status('act')` says it's available, and keep the app's own buttons for everything:

package/cli/app-ai.mjs

@@ -14,7 +14,7 @@
 // (OpenRouter: `chatBody`, `readMessage`), or one prompt whose answer must fit the step's JSON shape (Claude Code, Codex:
 // `planPrompt`, `planSchema`, `readPlan`).
 
-export const MAX_TOOLS = 24, MAX_CALLS = 8, MAX_STEPS = 4, MAX_BODY = 256 * 1024, MAX_CHOICES = 4, MAX_CHOICE = 24;
+export const MAX_TOOLS = 24, MAX_CALLS = 8, MAX_STEPS = 4, MAX_BODY = 2 * 1024 * 1024, MAX_CHOICES = 4, MAX_CHOICE = 24;
 /** The longest a step may take, whatever its route, before its call is taken to have stopped answering (`ACT_STEP_SECONDS`
  *  in lamp.js, `AppAct.turnSeconds`). A turn has no time of its own unless the app gives it one. */
 export const MAX_TURN_SECONDS = 600;
@@ -66,7 +66,7 @@ function parseArg(raw, path) {
  * steps, route, seconds, final}`, each tool's `args` as [name, shape] pairs by name. Throws `Refused`.
  */
 export function readStep(text) {
-  if (Buffer.byteLength(text) > MAX_BODY) throw new Refused(413, "A step can carry at most 256 KB.");
+  if (Buffer.byteLength(text) > MAX_BODY) throw new Refused(413, "A step can carry at most 2 MB.");
   let body;
   try { body = JSON.parse(text); } catch {}
   if (!body || typeof body !== "object" || Array.isArray(body)) throw new Refused(400, "A step needs a JSON object.");

package/cli/ignore.mjs

@@ -0,0 +1,56 @@
+// `.lampignore`: what an app's folder keeps out of what it shares (its page on lamp.dev, and the app's file that goes
+// with its link): data only its maker's computer needs, too big to share, say (a 600 MB parts library a page fetches
+// from elsewhere when it isn't there). The patterns are gitignore's simpler half: one a line, `#` for a note, `*`, `?` and
+// `**`, a trailing `/` for a folder, a leading `/` (or any `/` inside) for a path from the folder's top, and otherwise a
+// name matched at any depth. Nothing starting with `!`: what's left out stays out.
+
+import { readFileSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+
+export const IGNORE_FILE = ".lampignore";
+
+/** A pattern as a regular expression over a path from the folder's top ("ldraw/parts/3001.dat"). */
+function compile(line) {
+  let pattern = line.trim();
+  const folder = pattern.endsWith("/");
+  if (folder) pattern = pattern.replace(/\/+$/, "");
+  const anchored = pattern.startsWith("/") || pattern.includes("/");
+  pattern = pattern.replace(/^\/+/, "");
+  if (!pattern) return null;
+  let source = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const c = pattern[i];
+    if (c === "*" && pattern[i + 1] === "*") {
+      // `**/` matches any folders, none included; a lone `**` anything at all.
+      if (pattern[i + 2] === "/") { source += "(?:.*/)?"; i += 2; } else { source += ".*"; i += 1; }
+    } else if (c === "*") source += "[^/]*";
+    else if (c === "?") source += "[^/]";
+    else source += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  }
+  // What it names is left out with everything under it; a folder pattern names folders only, so it must have more after it.
+  return new RegExp(`^${anchored ? "" : "(?:.*/)?"}${source}${folder ? "/" : "(?:/|$)"}`);
+}
+
+/**
+ * Whether a path from the folder's top ("ldraw/parts/3001.dat"), a folder's when `folder` is true, is one its
+ * `.lampignore` leaves out; never, with none.
+ */
+export function ignoredIn(folder) {
+  let lines = [];
+  try { lines = readFileSync(join(folder, IGNORE_FILE), "utf8").split(/\r?\n/); } catch {}
+  const tests = lines.map((line) => line.trim()).filter((line) => line && !line.startsWith("#") && !line.startsWith("!")).map(compile).filter(Boolean);
+  if (!tests.length) return () => false;
+  // A folder's own path is asked about with a trailing slash too, so a folder-only pattern names it (and never a file).
+  return (path, folder = false) => tests.some((test) => test.test(path) || (folder && test.test(`${path}/`)));
+}
+
+/**
+ * Whether a path from a page's top is left out by the page's `.lampignore` or by its app's (`app`, the folder above it
+ * when the page is in Web/, whose patterns count from its own top).
+ */
+export function ignoredFor(root, app = root) {
+  const own = ignoredIn(root);
+  if (app === root) return own;
+  const outer = ignoredIn(app), under = relative(app, root).split(sep).join("/");
+  return (path, folder = false) => own(path, folder) || outer(under ? `${under}/${path}` : path, folder);
+}

package/cli/lampapp.mjs

@@ -9,6 +9,7 @@ import { inflateRawSync } from "node:zlib";
 import { Problem, RESOURCES, manifestOf, projectOf, stateOf } from "./state.mjs";
 import { LIMITS, nameOf, zipOf } from "./share.mjs";
 import { isID } from "../site/lib/shared-wishes.js";
+import { ignoredFor, ignoredIn } from "./ignore.mjs";
 
 // What a Lamp app file may hold, written once in Resources/share-rules.json, which Lamp's app reads too (`ShareRules`):
 // the sizes another Lamp opens, the names a license goes by, and the shapes of keys a shared file never carries.
@@ -185,7 +186,7 @@ function filesUnder(dir, prefix = "", { hidden = () => false, skip = () => false
   try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return found; }
   for (const entry of entries) {
     const path = prefix + entry.name;
-    if ((entry.name.startsWith(".") && !hidden(path)) || skip(path)) continue;
+    if ((entry.name.startsWith(".") && !hidden(path)) || skip(path, entry.isDirectory())) continue;
     if (entry.isDirectory()) found.push(...filesUnder(join(dir, entry.name), path + "/", { hidden: () => false, skip }));
     else if (entry.isFile()) found.push(path);
   }
@@ -237,6 +238,10 @@ export function exportApp(given, { anyway = false, link = null } = {}) {
   }
 
   const files = new Map(), from = (path) => readFileSync(join(app, path));
+  // The folder's .lampignore covers the app's own files too (its code beside the page, Assets/), as they are from the
+  // folder's top; a wish's own copy in .lamp-wish/ isn't the folder's, so its rules don't reach in there.
+  const appIgnored = app === folder ? ignoredIn(folder) : () => false;
+  const keep = (path) => !appIgnored(path);
   let kind, site = false, flags = {};
   if (project.kind === "page") {
     kind = typeof manifest?.platform === "string" ? manifest.platform : project.game ? "game" : "web-app";
@@ -245,19 +250,21 @@ export function exportApp(given, { anyway = false, link = null } = {}) {
     // page is Web/ in the file and whose own files beside it go as themselves.
     // A site stays one at every export, whether its page is at the folder's top or (unpacked) in Web/.
     site = kind === "web-app" && (manifest?.site === true || !project.lamps);
-    for (const path of filesUnder(project.root, "", { hidden: (path) => site && SERVED_HIDDEN.has(path), skip: (path) => path === "node_modules" || (!project.lamps && (wishFolder ? path === ".lamp-wish" || path === "LAMP-LICENSE.txt" : WISH_FILES.has(path))) })) {
+    // What the folder's .lampignore keeps to this computer stays out of the file, as it does of the page.
+    const ignored = ignoredFor(project.root, folder);
+    for (const path of filesUnder(project.root, "", { hidden: (path) => site && SERVED_HIDDEN.has(path), skip: (path, dir) => path === "node_modules" || ignored(path, dir) || (!project.lamps && (wishFolder ? path === ".lamp-wish" || path === "LAMP-LICENSE.txt" : WISH_FILES.has(path))) })) {
       if (!lamps(path)) files.set(`Web/${path}`, readFileSync(join(project.root, path)));
     }
     if (project.lamps || wishFolder) {
       // The Swift beside the page that answers its calls of the device, and a game's phone page.
-      for (const path of filesUnder(join(app, "Sources"), "Sources/")) if (path.endsWith(".swift") && (kind === "game" ? path === "Sources/Native.swift" : !["Sources/LampSupport.swift", "Sources/LampPage.swift", "Sources/LampControllerKit.swift", "Sources/LampScreen.swift", "Sources/LampWebApp.swift"].includes(path))) files.set(path, from(path));
-      if (kind === "game") for (const path of [...filesUnder(join(app, "Phone"), "Phone/"), ...filesUnder(join(app, "src"), "src/")]) files.set(path, from(path));
+      for (const path of filesUnder(join(app, "Sources"), "Sources/")) if (keep(path) && path.endsWith(".swift") && (kind === "game" ? path === "Sources/Native.swift" : !["Sources/LampSupport.swift", "Sources/LampPage.swift", "Sources/LampControllerKit.swift", "Sources/LampScreen.swift", "Sources/LampWebApp.swift"].includes(path))) files.set(path, from(path));
+      if (kind === "game") for (const path of [...filesUnder(join(app, "Phone"), "Phone/"), ...filesUnder(join(app, "src"), "src/")]) if (keep(path)) files.set(path, from(path));
     }
   } else {
     kind = "mac";
-    for (const path of filesUnder(join(folder, "Sources"), "Sources/")) if (path.endsWith(".swift") && !SWIFT_LAMPS.has(basename(path))) files.set(path, from(path));
+    for (const path of filesUnder(join(folder, "Sources"), "Sources/")) if (keep(path) && path.endsWith(".swift") && !SWIFT_LAMPS.has(basename(path))) files.set(path, from(path));
     for (const [extra, flag] of [["Widget", "widget"], ["Share", "share"]]) {
-      const code = filesUnder(join(folder, extra), `${extra}/`).filter((path) => path.endsWith(".swift") && !SWIFT_LAMPS.has(basename(path)));
+      const code = filesUnder(join(folder, extra), `${extra}/`).filter((path) => keep(path) && path.endsWith(".swift") && !SWIFT_LAMPS.has(basename(path)));
       for (const path of code) files.set(path, from(path));
       flags[flag] = code.length > 0;
     }
@@ -271,11 +278,12 @@ export function exportApp(given, { anyway = false, link = null } = {}) {
   let attached = 0;
   // A page at the folder's top with no `.lamp-wish/` keeps an Assets/ there as its own: it went with the page.
   for (const path of project.kind === "page" && !project.lamps && !wishFolder ? [] : filesUnder(join(app, "Assets"), "Assets/")) {
+    if (!keep(path)) continue;
     attached += statSync(join(app, path)).size;
     if (attached > MAX_ARCHIVE - 8 * 1024 * 1024) throw new Problem(`${name} is too big to share: its pictures and other files come to over ${Math.floor((MAX_ARCHIVE - 8 * 1024 * 1024) / 1_000_000)} MB`);
     files.set(path, from(path));
   }
-  if (existsSync(join(app, "APP.md"))) files.set("APP.md", from("APP.md"));
+  if (keep("APP.md") && existsSync(join(app, "APP.md"))) files.set("APP.md", from("APP.md"));
   // What the app declares; the Lamp that opens the file checks each of it again as it reads it.
   let declares = false;
   try {
@@ -286,7 +294,7 @@ export function exportApp(given, { anyway = false, link = null } = {}) {
   // icon.png at the top of a page lamp made is the page's, which went with it.
   for (const icon of ["icon.json", "icon-glass.json", "icon-art.png", "icon.png"]) {
     if (icon === "icon.png" && project.kind === "page" && !project.lamps && !wishFolder) continue;
-    if (existsSync(join(app, icon))) files.set(icon, from(icon));
+    if (keep(icon) && existsSync(join(app, icon))) files.set(icon, from(icon));
   }
   const releases = releasesOf(app);
   if (releases.length) files.set("releases.json", Buffer.from(JSON.stringify(releases, null, 2)));

package/cli/lamps/lamp-for-games.js

@@ -521,16 +521,33 @@
   // given ACT_STEP_SECONDS, which only a call that has stopped answering reaches. An app that wants a quicker turn
   // asks for one (`limits: { seconds }`); steps and writes it may only lower.
   var ACT_LIMITS = { steps: 4, writes: 6 };
+  // How much of one read goes back to the model: room for a real app's state (a 184-piece model, a week's calendar)
+  // in one step, since paging through it costs steps a turn needs for its work. An app with more raises it
+  // (`limits: { result }`), up to ACT_RESULT_MAX.
+  var ACT_RESULT = 32768, ACT_RESULT_MAX = 262144;
+  // What a turn's reads give back in all, which every later step carries again: kept under what a step may carry
+  // (`MAX_BODY` in lamp's app-ai.mjs), with room for the request, the tools and the steps' own words.
+  var ACT_TURN_RESULTS = 1200000;
   var ACT_STEP_SECONDS = 600;
   var actRan = {};      // turn id -> call key -> the result a write gave, while this copy of the page is open
   function actId() { return 't' + Date.now().toString(36) + Math.random().toString(36).slice(2, 8); }
   function isList(v) { return Object.prototype.toString.call(v) === '[object Array]'; }
-  /** At most 4 KB of a result goes back to the model, cut with a note. */
-  function actValue(value) {
+  /** A text's size in UTF-8 bytes, as a step is measured where it's checked. */
+  function utf8Bytes(text) { try { return unescape(encodeURIComponent(text)).length; } catch (e) { return text.length * 3; } }
+  /** At most `max` bytes of a result go back to the model, as it's sent (UTF-8, its cut wrapper included), cut with a note. */
+  function actValue(value, max) {
     var json = jsonState(value === undefined ? null : value), text;
     try { text = JSON.stringify(json); } catch (e) { return { note: 'The result couldn\'t be read.' }; }
-    if (text && text.length > 4096) return { cut: text.slice(0, 4000), note: 'Cut short: ask for less.' };
-    return json;
+    if (!text || utf8Bytes(text) <= max) return json;
+    // The cut is JSON inside JSON, so its quotes are escaped again: shrink it until the whole wrapper fits.
+    var cut = text.slice(0, max);
+    for (var i = 0; i < 24; i++) {
+      var wrapped = { cut: cut, note: 'Cut short: ask for less.' };
+      var size = utf8Bytes(JSON.stringify(wrapped));
+      if (size <= max) return wrapped;
+      cut = cut.slice(0, Math.max(0, Math.floor(cut.length * max / size) - 16));
+    }
+    return { note: 'Cut short: ask for less.' };
   }
   /** The page's own check of a call before it runs: a tool it declared, its arguments an object with nothing
    *  undeclared and nothing required missing. Lamp has checked the shapes; this is what the page itself can hold to. */
@@ -552,6 +569,15 @@
       limits[k] = Math.max(1, Math.min(asked, ACT_LIMITS[k]));
     });
     var asked = o.limits && typeof o.limits.seconds === 'number' && o.limits.seconds > 0 ? o.limits.seconds : null;
+    var resultMax = o.limits && typeof o.limits.result === 'number' && o.limits.result > 0
+      ? Math.min(Math.max(1024, Math.floor(o.limits.result)), ACT_RESULT_MAX) : ACT_RESULT;
+    // Each result takes from the turn's allowance, so later reads get less rather than the step growing past it.
+    var resultsLeft = ACT_TURN_RESULTS;
+    function sized(value) {
+      var kept = actValue(value, Math.max(1024, Math.min(resultMax, resultsLeft)));
+      try { resultsLeft = Math.max(0, resultsLeft - utf8Bytes(JSON.stringify(kept))); } catch (e) {}
+      return kept;
+    }
     var id = o.turn || actId();
     if (!actRan[id]) {
       var kept = Object.keys(actRan);
@@ -601,7 +627,7 @@
         }).then(function (value) {
           if (value === NOT_RUN) return;
           out.reads.push({ name: c.name, args: c.args });
-          results[c.id] = { id: c.id, ok: true, value: actValue(value) };
+          results[c.id] = { id: c.id, ok: true, value: sized(value) };
         }, function (e) { results[c.id] = { id: c.id, ok: false, error: refused(e) }; });
       })).then(function () {
         var stopped = null;
@@ -638,7 +664,7 @@
             var running;
             try { running = Promise.resolve(tool.run(c.args, call)); } catch (e) { running = Promise.reject(e); }
             return running.then(function (value) {
-              var kept = actValue(value);
+              var kept = sized(value);
               ran[key] = kept;
               var entry = { name: c.name, args: c.args, result: value };
               if (value && typeof value === 'object' && value.partly) entry.partly = String(value.partly);

package/cli/lamps/lamp.js

@@ -521,16 +521,33 @@
   // given ACT_STEP_SECONDS, which only a call that has stopped answering reaches. An app that wants a quicker turn
   // asks for one (`limits: { seconds }`); steps and writes it may only lower.
   var ACT_LIMITS = { steps: 4, writes: 6 };
+  // How much of one read goes back to the model: room for a real app's state (a 184-piece model, a week's calendar)
+  // in one step, since paging through it costs steps a turn needs for its work. An app with more raises it
+  // (`limits: { result }`), up to ACT_RESULT_MAX.
+  var ACT_RESULT = 32768, ACT_RESULT_MAX = 262144;
+  // What a turn's reads give back in all, which every later step carries again: kept under what a step may carry
+  // (`MAX_BODY` in lamp's app-ai.mjs), with room for the request, the tools and the steps' own words.
+  var ACT_TURN_RESULTS = 1200000;
   var ACT_STEP_SECONDS = 600;
   var actRan = {};      // turn id -> call key -> the result a write gave, while this copy of the page is open
   function actId() { return 't' + Date.now().toString(36) + Math.random().toString(36).slice(2, 8); }
   function isList(v) { return Object.prototype.toString.call(v) === '[object Array]'; }
-  /** At most 4 KB of a result goes back to the model, cut with a note. */
-  function actValue(value) {
+  /** A text's size in UTF-8 bytes, as a step is measured where it's checked. */
+  function utf8Bytes(text) { try { return unescape(encodeURIComponent(text)).length; } catch (e) { return text.length * 3; } }
+  /** At most `max` bytes of a result go back to the model, as it's sent (UTF-8, its cut wrapper included), cut with a note. */
+  function actValue(value, max) {
     var json = jsonState(value === undefined ? null : value), text;
     try { text = JSON.stringify(json); } catch (e) { return { note: 'The result couldn\'t be read.' }; }
-    if (text && text.length > 4096) return { cut: text.slice(0, 4000), note: 'Cut short: ask for less.' };
-    return json;
+    if (!text || utf8Bytes(text) <= max) return json;
+    // The cut is JSON inside JSON, so its quotes are escaped again: shrink it until the whole wrapper fits.
+    var cut = text.slice(0, max);
+    for (var i = 0; i < 24; i++) {
+      var wrapped = { cut: cut, note: 'Cut short: ask for less.' };
+      var size = utf8Bytes(JSON.stringify(wrapped));
+      if (size <= max) return wrapped;
+      cut = cut.slice(0, Math.max(0, Math.floor(cut.length * max / size) - 16));
+    }
+    return { note: 'Cut short: ask for less.' };
   }
   /** The page's own check of a call before it runs: a tool it declared, its arguments an object with nothing
    *  undeclared and nothing required missing. Lamp has checked the shapes; this is what the page itself can hold to. */
@@ -552,6 +569,15 @@
       limits[k] = Math.max(1, Math.min(asked, ACT_LIMITS[k]));
     });
     var asked = o.limits && typeof o.limits.seconds === 'number' && o.limits.seconds > 0 ? o.limits.seconds : null;
+    var resultMax = o.limits && typeof o.limits.result === 'number' && o.limits.result > 0
+      ? Math.min(Math.max(1024, Math.floor(o.limits.result)), ACT_RESULT_MAX) : ACT_RESULT;
+    // Each result takes from the turn's allowance, so later reads get less rather than the step growing past it.
+    var resultsLeft = ACT_TURN_RESULTS;
+    function sized(value) {
+      var kept = actValue(value, Math.max(1024, Math.min(resultMax, resultsLeft)));
+      try { resultsLeft = Math.max(0, resultsLeft - utf8Bytes(JSON.stringify(kept))); } catch (e) {}
+      return kept;
+    }
     var id = o.turn || actId();
     if (!actRan[id]) {
       var kept = Object.keys(actRan);
@@ -601,7 +627,7 @@
         }).then(function (value) {
           if (value === NOT_RUN) return;
           out.reads.push({ name: c.name, args: c.args });
-          results[c.id] = { id: c.id, ok: true, value: actValue(value) };
+          results[c.id] = { id: c.id, ok: true, value: sized(value) };
         }, function (e) { results[c.id] = { id: c.id, ok: false, error: refused(e) }; });
       })).then(function () {
         var stopped = null;
@@ -638,7 +664,7 @@
             var running;
             try { running = Promise.resolve(tool.run(c.args, call)); } catch (e) { running = Promise.reject(e); }
             return running.then(function (value) {
-              var kept = actValue(value);
+              var kept = sized(value);
               ran[key] = kept;
               var entry = { name: c.name, args: c.args, result: value };
               if (value && typeof value === 'object' && value.partly) entry.partly = String(value.partly);

package/cli/lamps/mac-starter/.lamp/meta.json

@@ -1 +1 @@
-{"name":"Zqx App Name","exe":"ZqxAppName","platform":"mac","instance":"EC9221D5-9306-400D-8A12-28239D505919"}
+{"exe":"ZqxAppName","name":"Zqx App Name","platform":"mac","instance":"10DC6CFC-3873-414E-B724-6AA904DC37A0"}

package/cli/lamps/mac-starter/Sources/LampSupport.swift

@@ -12017,6 +12017,9 @@
             let request: String
             var answers: [(question: String, answer: String)] = []
             var writes = 0
+            /// What its reads may still give back in all: every later step carries them again, under what a step may
+            /// carry (`MAX_BODY` in lamp's app-ai.mjs).
+            var resultsLeft = 1_200_000
         }
         private var operation: Operation?
         /// Each change's result by its key, so the same change asked again gets it without running again.
@@ -12028,14 +12031,19 @@
         private let send: ([String: Any], TimeInterval) async throws -> [String: Any]
         /// The longest a request may take, when the app wants a quick answer; nil for no limit.
         let seconds: Double?
+        /// How much of one read goes back to the AI, in bytes: room for an app's real state in one step, since paging
+        /// through it costs steps a request needs for its work.
+        let resultBytes: Int
 
         /// `seconds` limits each request's time, for a feature that should answer quickly; leave it out for no limit.
+        /// `resultBytes` raises how much of a read the AI sees (32 KB unless given, 256 KB at most).
         /// `send` stands in for Lamp in a test; leave it out.
-        init(about: String = "", tools: [LampActTool], seconds: Double? = nil,
+        init(about: String = "", tools: [LampActTool], seconds: Double? = nil, resultBytes: Int? = nil,
              send: (([String: Any], TimeInterval) async throws -> [String: Any])? = nil) {
             self.about = about
             self.tools = tools
             self.seconds = seconds.map { max(1, $0) }
+            self.resultBytes = min(max(resultBytes ?? 32_768, 1024), 262_144)
             self.send = send ?? { body, timeout in try await LampAI.post("/ai/act", body, timeout: timeout) }
         }
 
@@ -12192,7 +12200,9 @@
                 onStep(.reading(tool.name))
                 do {
                     let value = try await tool.perform(args(call), callInfo(call, key: ""))
-                    results[id] = ["id": id, "ok": true, "value": Self.cut(value)]
+                    let kept = Self.cut(value, max: max(1024, min(resultBytes, op.resultsLeft)))
+                    op.resultsLeft = max(0, op.resultsLeft - ((try? JSONSerialization.data(withJSONObject: [kept]))?.count ?? 0))
+                    results[id] = ["id": id, "ok": true, "value": kept]
                 } catch {
                     results[id] = ["id": id, "ok": false, "error": Self.words(error)]
                 }
@@ -12251,13 +12261,21 @@
 
         private static func words(_ error: Error) -> String { (error as? LampAI.Failure)?.message ?? error.localizedDescription }
 
-        /// At most 4 KB of a read goes back to the AI, cut with a note.
-        private static func cut(_ value: Any) -> Any {
+        /// At most `max` bytes of a read go back to the AI, cut with a note.
+        private static func cut(_ value: Any, max: Int) -> Any {
             guard JSONSerialization.isValidJSONObject([value]), let data = try? JSONSerialization.data(withJSONObject: [value]) else {
                 return ["note": "The result couldn't be read."]
             }
-            guard data.count > 4096 else { return value }
-            return ["cut": String(String(decoding: data, as: UTF8.self).prefix(4000)), "note": "Cut short: ask for less."]
+            guard data.count > max else { return value }
+            // The cut is JSON inside JSON, so its quotes are escaped again: shrink it until the whole wrapper fits.
+            var cut = String(decoding: data.prefix(max), as: UTF8.self)
+            for _ in 0..<24 {
+                let wrapped: [String: Any] = ["cut": cut, "note": "Cut short: ask for less."]
+                let size = (try? JSONSerialization.data(withJSONObject: [wrapped]))?.count ?? Int.max
+                if size <= max { return wrapped }
+                cut = String(cut.prefix(Swift.max(0, cut.count * max / Swift.max(size, 1) - 16)))
+            }
+            return ["note": "Cut short: ask for less."]
         }
 
         private static func canonical(_ value: Any) -> String {

package/cli/lamps/web-starter/lamp.js

@@ -521,16 +521,33 @@
   // given ACT_STEP_SECONDS, which only a call that has stopped answering reaches. An app that wants a quicker turn
   // asks for one (`limits: { seconds }`); steps and writes it may only lower.
   var ACT_LIMITS = { steps: 4, writes: 6 };
+  // How much of one read goes back to the model: room for a real app's state (a 184-piece model, a week's calendar)
+  // in one step, since paging through it costs steps a turn needs for its work. An app with more raises it
+  // (`limits: { result }`), up to ACT_RESULT_MAX.
+  var ACT_RESULT = 32768, ACT_RESULT_MAX = 262144;
+  // What a turn's reads give back in all, which every later step carries again: kept under what a step may carry
+  // (`MAX_BODY` in lamp's app-ai.mjs), with room for the request, the tools and the steps' own words.
+  var ACT_TURN_RESULTS = 1200000;
   var ACT_STEP_SECONDS = 600;
   var actRan = {};      // turn id -> call key -> the result a write gave, while this copy of the page is open
   function actId() { return 't' + Date.now().toString(36) + Math.random().toString(36).slice(2, 8); }
   function isList(v) { return Object.prototype.toString.call(v) === '[object Array]'; }
-  /** At most 4 KB of a result goes back to the model, cut with a note. */
-  function actValue(value) {
+  /** A text's size in UTF-8 bytes, as a step is measured where it's checked. */
+  function utf8Bytes(text) { try { return unescape(encodeURIComponent(text)).length; } catch (e) { return text.length * 3; } }
+  /** At most `max` bytes of a result go back to the model, as it's sent (UTF-8, its cut wrapper included), cut with a note. */
+  function actValue(value, max) {
     var json = jsonState(value === undefined ? null : value), text;
     try { text = JSON.stringify(json); } catch (e) { return { note: 'The result couldn\'t be read.' }; }
-    if (text && text.length > 4096) return { cut: text.slice(0, 4000), note: 'Cut short: ask for less.' };
-    return json;
+    if (!text || utf8Bytes(text) <= max) return json;
+    // The cut is JSON inside JSON, so its quotes are escaped again: shrink it until the whole wrapper fits.
+    var cut = text.slice(0, max);
+    for (var i = 0; i < 24; i++) {
+      var wrapped = { cut: cut, note: 'Cut short: ask for less.' };
+      var size = utf8Bytes(JSON.stringify(wrapped));
+      if (size <= max) return wrapped;
+      cut = cut.slice(0, Math.max(0, Math.floor(cut.length * max / size) - 16));
+    }
+    return { note: 'Cut short: ask for less.' };
   }
   /** The page's own check of a call before it runs: a tool it declared, its arguments an object with nothing
    *  undeclared and nothing required missing. Lamp has checked the shapes; this is what the page itself can hold to. */
@@ -552,6 +569,15 @@
       limits[k] = Math.max(1, Math.min(asked, ACT_LIMITS[k]));
     });
     var asked = o.limits && typeof o.limits.seconds === 'number' && o.limits.seconds > 0 ? o.limits.seconds : null;
+    var resultMax = o.limits && typeof o.limits.result === 'number' && o.limits.result > 0
+      ? Math.min(Math.max(1024, Math.floor(o.limits.result)), ACT_RESULT_MAX) : ACT_RESULT;
+    // Each result takes from the turn's allowance, so later reads get less rather than the step growing past it.
+    var resultsLeft = ACT_TURN_RESULTS;
+    function sized(value) {
+      var kept = actValue(value, Math.max(1024, Math.min(resultMax, resultsLeft)));
+      try { resultsLeft = Math.max(0, resultsLeft - utf8Bytes(JSON.stringify(kept))); } catch (e) {}
+      return kept;
+    }
     var id = o.turn || actId();
     if (!actRan[id]) {
       var kept = Object.keys(actRan);
@@ -601,7 +627,7 @@
         }).then(function (value) {
           if (value === NOT_RUN) return;
           out.reads.push({ name: c.name, args: c.args });
-          results[c.id] = { id: c.id, ok: true, value: actValue(value) };
+          results[c.id] = { id: c.id, ok: true, value: sized(value) };
         }, function (e) { results[c.id] = { id: c.id, ok: false, error: refused(e) }; });
       })).then(function () {
         var stopped = null;
@@ -638,7 +664,7 @@
             var running;
             try { running = Promise.resolve(tool.run(c.args, call)); } catch (e) { running = Promise.reject(e); }
             return running.then(function (value) {
-              var kept = actValue(value);
+              var kept = sized(value);
               ran[key] = kept;
               var entry = { name: c.name, args: c.args, result: value };
               if (value && typeof value === 'object' && value.partly) entry.partly = String(value.partly);

package/cli/local-ai.mjs

@@ -21,7 +21,7 @@ import { answer as answerAI, engine } from "./ai.mjs";
 /** The port lamp.js on a shared page asks (`LOCAL_AI` there): one, fixed, since the page can't be told another. */
 export const LOCAL_AI_PORT = 47423;
 const PLAY_HOST = "play.lamp.dev";
-const MOST = 2_000_000, AT_ONCE = 3, ASKING_FOR = 120_000;
+const MOST = 4_000_000, AT_ONCE = 3, ASKING_FOR = 120_000;
 const ROUTES = new Set(["/ai/status", "/ai", "/ai/act", "/ai/decide", "/ai/hear", "/ai/image"]);
 
 const keptFile = () => join(process.env.LAMP_DEV_HOME || join(homedir(), ".lamp", "dev"), "shared-pages-ai.json");

package/cli/share.mjs

@@ -17,6 +17,7 @@ import { LIMITS, FILE_LIMITS, PAGE_LIMITS } from "../site/lib/shared-wishes.js";
 import { ideasOf, makerOf, pageUp, publishLink, removeFile, removeIdea, removeLink, replyIdea, sendFile, siteOrigin } from "./link.mjs";
 import { exportApp, sourceLinkOf } from "./lampapp.mjs";
 import { scaled, sizeOf } from "./png.mjs";
+import { ignoredFor } from "./ignore.mjs";
 
 export { siteOrigin };
 
@@ -104,10 +105,12 @@ export function zipOf(files) {
  */
 export function pageFiles(layout, { device = ANY_BROWSER } = {}) {
   const files = new Map();
+  // What the folder's .lampignore keeps to this computer (data too big to share, say) never goes.
+  const ignored = ignoredFor(layout.root, layout.folder);
   const walk = (dir, prefix) => {
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
       const path = prefix + entry.name;
-      if (entry.name.startsWith(".") || entry.name === "node_modules" || path === NOTES_FILE) continue;
+      if (entry.name.startsWith(".") || entry.name === "node_modules" || path === NOTES_FILE || ignored(path, entry.isDirectory())) continue;
       if (entry.isDirectory()) walk(join(dir, entry.name), path + "/");
       else if (entry.isFile()) files.set(path, readFileSync(join(dir, entry.name)));
     }

package/cli/skill/SKILL.md

@@ -198,7 +198,9 @@ Only when the person asks: a link is public, and anyone who has it can play the
   and their email, and run `{{lamp}} account <username> --email <theirs>`; they confirm it from the email, and the link
   moves there at its next share. `{{lamp}} account` says which they're signed in as. A page that's logging errors
   isn't shared until they're put right. Again, after changes, it sends the page as it is now to the same link, with the
-  same words unless you give new ones.
+  same words unless you give new ones. Files only this computer needs (data too big for a link, which the page fetches
+  from elsewhere when it isn't there) go in a `.lampignore` at the folder's top, gitignore's way (`ldraw/`, `*.csv`):
+  share and export leave them out. Never share from a copy of the folder made for it.
 - `{{lamp}} ideas` lists what people playing it have sent, each with the address of a picture of the app as they saw
   it when they kept one in: look at it before building the idea. Once one is in the game and the game shared again,
   `{{lamp}} ideas in <number>` says so, and whoever asked to hear is written to; `{{lamp}} ideas dismiss <number>` lets

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lampdotdev/lamp",
-  "version": "0.36.2-nightly.24",
+  "version": "0.36.2-nightly.26",
   "description": "Runs a web app or game from its folder and puts each saved change into the open page.",
   "type": "module",
   "bin": {