@lampdotdev/lamp 0.0.0-stage → 0.36.2-nightly.16

package/cli/png.mjs

@@ -0,0 +1,184 @@
+// Just enough PNG for the pictures lamp makes itself: an app's icon on the tile a device shows it on, at the sizes the
+// device's package names (`DeviceSupport.iconPNG` in Lamp's app, which draws the same tile with AppKit).
+
+import { deflateSync, inflateSync } from "node:zlib";
+
+const SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+const CRC = Array.from({ length: 256 }, (_, n) => { let c = n; for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1; return c >>> 0; });
+function crc32(bytes) {
+  let c = 0xffffffff;
+  for (let i = 0; i < bytes.length; i++) c = CRC[(c ^ bytes[i]) & 0xff] ^ (c >>> 8);
+  return (c ^ 0xffffffff) >>> 0;
+}
+
+function chunk(type, data) {
+  const head = Buffer.alloc(8), sum = Buffer.alloc(4);
+  head.writeUInt32BE(data.length, 0);
+  head.write(type, 4, "latin1");
+  sum.writeUInt32BE(crc32(Buffer.concat([head.subarray(4), data])), 0);
+  return Buffer.concat([head, data, sum]);
+}
+
+/** A PNG of these pixels (four bytes each: red, green, blue, alpha). */
+export function encode(width, height, rgba) {
+  const header = Buffer.alloc(13);
+  header.writeUInt32BE(width, 0);
+  header.writeUInt32BE(height, 4);
+  header[8] = 8;                                 // eight bits a channel
+  header[9] = 6;                                 // color with alpha
+  const rows = Buffer.alloc((width * 4 + 1) * height);
+  for (let y = 0; y < height; y++) rgba.copy(rows, y * (width * 4 + 1) + 1, y * width * 4, (y + 1) * width * 4);
+  return Buffer.concat([SIGNATURE, chunk("IHDR", header), chunk("IDAT", deflateSync(rows)), chunk("IEND", Buffer.alloc(0))]);
+}
+
+/**
+ * A PNG's pixels (four bytes each), or null for one this doesn't read: only what an icon is saved as, eight bits a
+ * channel and not interlaced.
+ */
+export function decode(bytes) {
+  try {
+    if (bytes.length < 33 || !bytes.subarray(0, 8).equals(SIGNATURE)) return null;
+    let width = 0, height = 0, kind = 0, palette = null, clear = null;
+    const packed = [];
+    for (let at = 8; at + 12 <= bytes.length;) {
+      const length = bytes.readUInt32BE(at), type = bytes.toString("latin1", at + 4, at + 8), data = bytes.subarray(at + 8, at + 8 + length);
+      if (type === "IHDR") {
+        width = data.readUInt32BE(0); height = data.readUInt32BE(4); kind = data[9];
+        if (data[8] !== 8 || data[12] !== 0 || ![0, 2, 3, 4, 6].includes(kind)) return null;
+      } else if (type === "PLTE") palette = data;
+      else if (type === "tRNS") clear = data;
+      else if (type === "IDAT") packed.push(data);
+      else if (type === "IEND") break;
+      at += 12 + length;
+    }
+    if (!width || !height || width > 8192 || height > 8192) return null;
+    const channels = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 }[kind], stride = width * channels;
+    const raw = inflateSync(Buffer.concat(packed));
+    if (raw.length < (stride + 1) * height) return null;
+    const lines = Buffer.alloc(stride * height);
+    for (let y = 0; y < height; y++) {
+      const filter = raw[y * (stride + 1)], from = y * (stride + 1) + 1, to = y * stride;
+      for (let x = 0; x < stride; x++) {
+        const left = x >= channels ? lines[to + x - channels] : 0, up = y ? lines[to + x - stride] : 0;
+        const corner = x >= channels && y ? lines[to + x - stride - channels] : 0;
+        let guess = 0;
+        if (filter === 1) guess = left;
+        else if (filter === 2) guess = up;
+        else if (filter === 3) guess = (left + up) >> 1;
+        else if (filter === 4) {
+          const p = left + up - corner, a = Math.abs(p - left), b = Math.abs(p - up), c = Math.abs(p - corner);
+          guess = a <= b && a <= c ? left : b <= c ? up : corner;
+        }
+        lines[to + x] = (raw[from + x] + guess) & 0xff;
+      }
+    }
+    const rgba = Buffer.alloc(width * height * 4);
+    for (let i = 0; i < width * height; i++) {
+      const at = i * channels;
+      let r, g, b, a = 255;
+      if (kind === 0) r = g = b = lines[at];
+      else if (kind === 4) { r = g = b = lines[at]; a = lines[at + 1]; }
+      else if (kind === 2) { r = lines[at]; g = lines[at + 1]; b = lines[at + 2]; }
+      else if (kind === 6) { r = lines[at]; g = lines[at + 1]; b = lines[at + 2]; a = lines[at + 3]; }
+      else {
+        if (!palette) return null;
+        const index = lines[at];
+        r = palette[index * 3]; g = palette[index * 3 + 1]; b = palette[index * 3 + 2];
+        a = clear && index < clear.length ? clear[index] : 255;
+      }
+      rgba[i * 4] = r; rgba[i * 4 + 1] = g; rgba[i * 4 + 2] = b; rgba[i * 4 + 3] = a;
+    }
+    return { width, height, rgba };
+  } catch { return null; }
+}
+
+/** A PNG's size in pixels, read from its header; null when it isn't one. */
+export function sizeOf(bytes) {
+  if (bytes.length < 24 || !bytes.subarray(0, 8).equals(SIGNATURE)) return null;
+  return { width: bytes.readUInt32BE(16), height: bytes.readUInt32BE(20) };
+}
+
+/**
+ * The app's icon as a square of that many pixels, clear where the icon is: what a phone's home screen shows. Null for
+ * no icon, or one this can't read.
+ */
+export function scaled(icon, side) {
+  const picture = icon && decode(icon);
+  if (!picture) return null;
+  const out = Buffer.alloc(side * side * 4), across = picture.width / side, down = picture.height / side;
+  for (let y = 0; y < side; y++) {
+    for (let x = 0; x < side; x++) {
+      const x0 = Math.floor(x * across), x1 = Math.max(x0 + 1, Math.min(picture.width, Math.ceil((x + 1) * across)));
+      const y0 = Math.floor(y * down), y1 = Math.max(y0 + 1, Math.min(picture.height, Math.ceil((y + 1) * down)));
+      let r = 0, g = 0, b = 0, a = 0;
+      for (let sy = y0; sy < y1; sy++) {
+        for (let sx = x0; sx < x1; sx++) {
+          const at = (Math.min(sy, picture.height - 1) * picture.width + Math.min(sx, picture.width - 1)) * 4, alpha = picture.rgba[at + 3];
+          r += picture.rgba[at] * alpha; g += picture.rgba[at + 1] * alpha; b += picture.rgba[at + 2] * alpha; a += alpha;
+        }
+      }
+      if (!a) continue;
+      const at = (y * side + x) * 4;
+      out[at] = Math.round(r / a); out[at + 1] = Math.round(g / a); out[at + 2] = Math.round(b / a);
+      out[at + 3] = Math.round(a / ((x1 - x0) * (y1 - y0)));
+    }
+  }
+  return encode(side, side, out);
+}
+
+/** A PNG made `width` pixels wide, its height in proportion; null for one this can't read. */
+export function resized(bytes, width) {
+  const picture = decode(bytes);
+  if (!picture) return null;
+  width = Math.max(1, Math.round(width));
+  const height = Math.max(1, Math.round((picture.height * width) / picture.width)), out = Buffer.alloc(width * height * 4);
+  const across = picture.width / width, down = picture.height / height;
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const x0 = Math.floor(x * across), x1 = Math.max(x0 + 1, Math.min(picture.width, Math.ceil((x + 1) * across)));
+      const y0 = Math.floor(y * down), y1 = Math.max(y0 + 1, Math.min(picture.height, Math.ceil((y + 1) * down)));
+      const sum = [0, 0, 0, 0];
+      for (let sy = y0; sy < y1; sy++) for (let sx = x0; sx < x1; sx++) { const at = (sy * picture.width + sx) * 4; for (let c = 0; c < 4; c++) sum[c] += picture.rgba[at + c]; }
+      const count = (x1 - x0) * (y1 - y0), at = (y * width + x) * 4;
+      for (let c = 0; c < 4; c++) out[at + c] = Math.round(sum[c] / count);
+    }
+  }
+  return encode(width, height, out);
+}
+
+// The tile's color: Lamp's dark blue, the same one the package's manifest names for the tile behind it.
+const TILE = [27, 27, 58];
+
+/**
+ * The app's icon centered on its tile's color at a logo's size, or the color alone when the app has no icon (or one
+ * this can't read): a device's package names these files, and shows nothing in their place without them.
+ */
+export function tile(icon, width, height) {
+  const out = Buffer.alloc(width * height * 4);
+  for (let i = 0; i < width * height; i++) { out[i * 4] = TILE[0]; out[i * 4 + 1] = TILE[1]; out[i * 4 + 2] = TILE[2]; out[i * 4 + 3] = 255; }
+  const picture = icon && decode(icon);
+  if (picture) {
+    const side = Math.round(Math.min(width, height) * 0.8), left = Math.round((width - side) / 2), top = Math.round((height - side) / 2);
+    const across = picture.width / side, down = picture.height / side;
+    for (let y = 0; y < side; y++) {
+      for (let x = 0; x < side; x++) {
+        // Each pixel is the average of the part of the icon it covers, so a large icon made small stays smooth.
+        const x0 = Math.floor(x * across), x1 = Math.max(x0 + 1, Math.min(picture.width, Math.ceil((x + 1) * across)));
+        const y0 = Math.floor(y * down), y1 = Math.max(y0 + 1, Math.min(picture.height, Math.ceil((y + 1) * down)));
+        let r = 0, g = 0, b = 0, a = 0;
+        for (let sy = y0; sy < y1; sy++) {
+          for (let sx = x0; sx < x1; sx++) {
+            const at = (Math.min(sy, picture.height - 1) * picture.width + Math.min(sx, picture.width - 1)) * 4, alpha = picture.rgba[at + 3];
+            r += picture.rgba[at] * alpha; g += picture.rgba[at + 1] * alpha; b += picture.rgba[at + 2] * alpha; a += alpha;
+          }
+        }
+        if (!a) continue;
+        const cover = a / ((x1 - x0) * (y1 - y0)) / 255, at = ((top + y) * width + left + x) * 4;
+        out[at] = Math.round((r / a) * cover + TILE[0] * (1 - cover));
+        out[at + 1] = Math.round((g / a) * cover + TILE[1] * (1 - cover));
+        out[at + 2] = Math.round((b / a) * cover + TILE[2] * (1 - cover));
+      }
+    }
+  }
+  return encode(width, height, out);
+}

package/cli/share.mjs

@@ -0,0 +1,270 @@
+// A link to the page on lamp.dev: anyone who opens it plays the page there, and can send its maker an idea. The page
+// zipped as the site takes it, then the link's words and picture and the page sent in parts, through the site's API
+// as link.mjs speaks it (the same for Lamp's app's Share Link card).
+//
+// The link's secret, which is what lets it be changed or taken down, is kept with lamp's own state for the folder,
+// never in the folder: a folder is committed and published, and the secret is whoever shared it's alone.
+
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { deflateRawSync } from "node:zlib";
+import { NOTES_FILE, Problem, stateOf } from "./state.mjs";
+import { ANY_BROWSER, CONTROLLERS, CONTROLLERS_FILE, DEVICE_FILE, lampJS, LIBRARIES } from "./dev.mjs";
+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 } from "./lampapp.mjs";
+
+export { siteOrigin };
+
+const linkFileOf = (folder) => join(stateOf(folder), "link.json");
+
+
+/**
+ * The maker's account on a site, as lamp keeps it (`lamp account`): `{ username, key }`, the key sent with every share
+ * so a link goes under the username (lamp.dev/<username>/<app>). Kept with lamp's state, never in a folder.
+ */
+const accountsFile = () => join(process.env.LAMP_DEV_HOME || join(homedir(), ".lamp", "dev"), "account.json");
+export function accountFor(site = siteOrigin()) {
+  try { const kept = JSON.parse(readFileSync(accountsFile(), "utf8"))[site]; return kept?.key ? kept : null; } catch { return null; }
+}
+export function keepAccount(site, account) {
+  let all = {};
+  try { all = JSON.parse(readFileSync(accountsFile(), "utf8")) || {}; } catch {}
+  all[site] = account;
+  mkdirSync(dirname(accountsFile()), { recursive: true });
+  writeFileSync(accountsFile(), JSON.stringify(all, null, 2), { mode: 0o600 });
+}
+
+/** The folder's link, as it was last shared: its address, its secret and the words it went out with. */
+export function readLink(folder) {
+  try { return JSON.parse(readFileSync(linkFileOf(folder), "utf8")); } catch { return null; }
+}
+/** Forgets the folder's link here, leaving it on the site (one Lamp's app let go of, say). */
+export function forgetLink(folder) { rmSync(linkFileOf(folder), { force: true }); }
+export function writeLink(folder, link) {
+  mkdirSync(stateOf(folder), { recursive: true });
+  writeFileSync(linkFileOf(folder), JSON.stringify(link, null, 2), { mode: 0o600 });
+}
+
+// MARK: The page, as a zip
+
+const CRC = Array.from({ length: 256 }, (_, n) => { let c = n; for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1; return c >>> 0; });
+function crc32(bytes) {
+  let c = 0xffffffff;
+  for (let i = 0; i < bytes.length; i++) c = CRC[(c ^ bytes[i]) & 0xff] ^ (c >>> 8);
+  return (c ^ 0xffffffff) >>> 0;
+}
+
+/** A zip of these files (`[path, bytes]`), each packed where that makes it smaller. */
+export function zipOf(files) {
+  const parts = [], listing = [];
+  let offset = 0;
+  for (const [path, bytes] of files) {
+    const name = Buffer.from(path, "utf8"), packed = deflateRawSync(bytes), stored = packed.length >= bytes.length;
+    const data = stored ? bytes : packed, sum = crc32(bytes);
+    const head = Buffer.alloc(30);
+    head.writeUInt32LE(0x04034b50, 0);
+    head.writeUInt16LE(20, 4);
+    head.writeUInt16LE(0x0800, 6);              // the name is UTF-8
+    head.writeUInt16LE(stored ? 0 : 8, 8);
+    head.writeUInt32LE(sum, 14);
+    head.writeUInt32LE(data.length, 18);
+    head.writeUInt32LE(bytes.length, 22);
+    head.writeUInt16LE(name.length, 26);
+    const entry = Buffer.alloc(46);
+    entry.writeUInt32LE(0x02014b50, 0);
+    entry.writeUInt16LE(20, 4);
+    entry.writeUInt16LE(20, 6);
+    head.copy(entry, 8, 6, 30);                 // the same flags, method, sum, sizes and name length
+    entry.writeUInt32LE(offset, 42);
+    parts.push(head, name, data);
+    listing.push(entry, name);
+    offset += 30 + name.length + data.length;
+  }
+  const directory = Buffer.concat(listing), end = Buffer.alloc(22);
+  end.writeUInt32LE(0x06054b50, 0);
+  end.writeUInt16LE(files.length, 8);
+  end.writeUInt16LE(files.length, 10);
+  end.writeUInt32LE(directory.length, 12);
+  end.writeUInt32LE(offset, 16);
+  return Buffer.concat([...parts, directory, end]);
+}
+
+/**
+ * Every file of the page as it's played from the link: what's in its folder (nothing hidden, no link followed, the
+ * app's notes left out), and for a game Lamp's own files beside it, as Lamp's app puts them in a copy it publishes
+ * (`GamePage.stage`): the device a browser on any device is, the build's name, and what the folder has none of.
+ * A copy for one device (place.mjs) is given that device in its place.
+ */
+export function pageFiles(layout, { device = ANY_BROWSER } = {}) {
+  const files = new Map();
+  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.isDirectory()) walk(join(dir, entry.name), path + "/");
+      else if (entry.isFile()) files.set(path, readFileSync(join(dir, entry.name)));
+    }
+  };
+  walk(layout.root, "");
+  if (layout.game) {
+    files.set(DEVICE_FILE, Buffer.from(device));
+    if (!files.has(CONTROLLERS_FILE)) files.set(CONTROLLERS_FILE, readFileSync(CONTROLLERS));
+    if (!files.has("lamp.js")) files.set("lamp.js", Buffer.from(lampJS(true)));
+    // A library the page's import map names from beside it and the folder has none of: Lamp's copy.
+    const map = /<script[^>]*type=["']importmap["'][^>]*>([\s\S]*?)<\/script>/i.exec(String(files.get("index.html") ?? ""))?.[1] ?? "";
+    for (const name of ["three", "phaser", "rapier"]) {
+      if (!new RegExp(`:\\s*["'](?:\\./)?${name}/`).test(map) || [...files.keys()].some((path) => path.startsWith(`${name}/`))) continue;
+      const from = join(LIBRARIES, name);
+      if (!existsSync(from)) continue;
+      const copy = (dir, prefix) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+          if (entry.isDirectory()) copy(join(dir, entry.name), `${prefix}${entry.name}/`);
+          else if (entry.isFile() && !lstatSync(join(dir, entry.name)).isSymbolicLink()) files.set(prefix + entry.name, readFileSync(join(dir, entry.name)));
+        }
+      };
+      copy(from, `${name}/`);
+    }
+    // The build's name, for the runtime to tell a newer copy of the game by: named for the files as they are.
+    files.delete("lamp-build.js");
+    const hash = createHash("sha256");
+    for (const path of [...files.keys()].sort()) hash.update(path).update(files.get(path));
+    files.set("lamp-build.js", Buffer.from(`export default "${hash.digest("hex").slice(0, 16)}";\n`));
+  }
+  return [...files].sort(([a], [b]) => a.localeCompare(b));
+}
+
+// MARK: The site
+
+/** The repository a git remote's address names on GitHub, as "owner/name", or null for any other place. */
+export function githubRepoOf(remote) {
+  const found = /^(?:https:\/\/(?:[^@/]+@)?github\.com\/|git@github\.com:|ssh:\/\/git@github\.com\/)([A-Za-z0-9-]{1,39})\/([A-Za-z0-9._-]{1,100}?)(?:\.git)?\/?$/.exec(String(remote ?? "").trim());
+  return found && found[2] !== "." && found[2] !== ".." ? `${found[1]}/${found[2]}` : null;
+}
+
+/**
+ * The folder's repository on GitHub, for its link's page to point to: only when the folder is the top of a git
+ * checkout whose origin is on GitHub, and GitHub, asked with no sign-in, says anyone can read it. Null otherwise, and
+ * when git or GitHub can't answer, so nothing is linked that might not be public.
+ */
+export async function publicRepoOf(folder) {
+  let top, remote;
+  try {
+    top = execFileSync("git", ["-C", folder, "rev-parse", "--show-toplevel"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    remote = execFileSync("git", ["-C", folder, "remote", "get-url", "origin"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch { return null; }
+  if (resolve(top) !== resolve(folder)) return null;
+  const repo = githubRepoOf(remote);
+  if (!repo) return null;
+  try {
+    const answer = await fetch(`https://api.github.com/repos/${repo}`, { headers: { accept: "application/vnd.github+json" }, signal: AbortSignal.timeout(6000) });
+    if (!answer.ok) return null;
+    return (await answer.json())?.private === false ? repo : null;
+  } catch { return null; }
+}
+
+const megabytes = (bytes) => `${(bytes / 1_000_000).toFixed(bytes < 10_000_000 ? 1 : 0)} MB`;
+
+/**
+ * Shares the page, or sends it again to the link the folder has: the link's words and picture, then the page. `words`
+ * are what the link says (`name`, `words`, and `line`, `by` and `asks` when given), `picture` a PNG or JPEG of the
+ * page or null, `shape` "fill" or the page's width over its height. Answers the link and what went up.
+ */
+export async function share({ layout, words, picture = null, shape = "fill", site = siteOrigin(), said = () => {}, file = true, anyway = false, github, fromLamp = false }) {
+  // The app's own file goes with the link, as Lamp's Share Link sends it, so whoever follows the link can open it in
+  // Lamp too: made first, with Share…'s checks, so a page that can't be shared (a key in it) puts nothing up.
+  const app = file ? exportApp(layout.folder, { anyway }) : null;
+  const files = pageFiles(layout);
+  const unpacked = files.reduce((total, [, bytes]) => total + bytes.length, 0);
+  if (!files.some(([path]) => path === "index.html")) throw new Problem("the page has no index.html at its top");
+  if (files.length > PAGE_LIMITS.files) throw new Problem(`the page is ${files.length} files, and a link carries ${PAGE_LIMITS.files} at most`);
+  if (unpacked > PAGE_LIMITS.total) throw new Problem(`the page is ${megabytes(unpacked)}, and a link carries ${megabytes(PAGE_LIMITS.total)} at most`);
+  const zip = zipOf(files);
+  if (zip.length > FILE_LIMITS.total) throw new Problem(`the page is ${megabytes(zip.length)} packed, and a link carries ${megabytes(FILE_LIMITS.total)} at most`);
+  if (picture && picture.length > LIMITS.picture) picture = null;
+  // The page links to the folder's public repository on GitHub, when it's one (`github` given in its place by a test).
+  const repo = github === undefined ? await publicRepoOf(layout.folder) : github;
+
+  const body = {
+    name: words.name, words: words.words, shape,
+    ...(words.line ? { line: words.line } : {}), ...(words.by ? { by: words.by } : {}),
+    ...(words.asks?.length ? { asks: words.asks } : {}), ...(picture ? { picture: picture.toString("base64") } : {}),
+    ...(repo ? { github: repo } : {}),
+  };
+  // The folder's own link when it has one on this site, changed in place; a link that's gone is made again.
+  let earlier = readLink(layout.folder);
+  if (earlier && earlier.site !== site) earlier = null;
+  // A file an earlier share sent stays on the record until it's taken away, so a retry after a failed removal tries again.
+  // A link that's a Lamp's (`fromLamp`, the app in its own folder) stays so in every write, a share that fails partway too.
+  let link = { site, ...(await publishLink({ site, body, earlier, account: accountFor(site)?.key })), ...words, shape, ...(earlier?.file ? { file: true } : {}),
+    ...(fromLamp ? { fromLamp: true } : {}) };
+  // Kept before the page goes up: a link whose page didn't make it is still this folder's to send again or take down.
+  writeLink(layout.folder, link);
+
+  // The file, or none: a link that carried one and shouldn't now has it taken away (and its page with it, sent next).
+  if (app) {
+    link.file = true;
+    writeLink(layout.folder, link);
+    await sendFile({ site, link, bytes: app.bytes, said });
+  } else if (link.file) {
+    await removeFile({ site, link });
+    link.file = false;
+    writeLink(layout.folder, link);
+  }
+  const version = await sendFile({ site, link, bytes: zip, page: true, said });
+  link = { ...link, version, shared: new Date().toISOString() };
+  writeLink(layout.folder, link);
+  await pageUp({ site, id: link.id, version, said });
+  return { url: link.url, version, files: files.length, bytes: zip.length, picture: !!picture, file: !!app, github: repo || null };
+}
+
+/** Takes the folder's link down, with its page and the ideas sent to it. */
+export async function unshare(folder) {
+  const link = readLink(folder);
+  if (!link) throw new Problem("this folder has no link");
+  await removeLink({ site: link.site, link });
+  rmSync(linkFileOf(folder), { force: true });
+  return link.url;
+}
+
+/** The ideas people playing the link have sent its maker and that are still open: each with its number. */
+export async function ideas(folder, { earlier = false } = {}) {
+  const link = readLink(folder);
+  if (!link) throw new Problem("this folder has no link: lamp share makes one");
+  return { url: link.url, ideas: await ideasOf({ site: link.site, link, earlier }) };
+}
+
+/** Says what became of an idea: it's in (the site writes to whoever asked to hear), or it's let go. */
+export async function finishIdea(folder, n, built, note) {
+  const link = readLink(folder);
+  if (!link) throw new Problem("this folder has no link");
+  return removeIdea({ site: link.site, link, n, built, note });
+}
+
+/** Says something more about an idea to whoever sent it; with no note, that their answer is seen to. */
+export async function answerIdea(folder, n, note) {
+  const link = readLink(folder);
+  if (!link) throw new Problem("this folder has no link");
+  return replyIdea({ site: link.site, link, n, note });
+}
+
+/** The maker's own address for the link's ideas, or, with `email`, given ("" takes it away). */
+export async function makerEmail(folder, email) {
+  const link = readLink(folder);
+  if (!link) throw new Problem("this folder has no link: lamp share makes one");
+  return makerOf({ site: link.site, link, email });
+}
+
+/** The page's name where nothing gave one: its title, or its folder's name. */
+export function nameOf(layout) {
+  try {
+    const title = /<title[^>]*>([^<]*)<\/title>/i.exec(readFileSync(join(layout.root, "index.html"), "utf8"))?.[1]?.trim();
+    if (title) return title.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').slice(0, LIMITS.name);
+  } catch {}
+  return basename(layout.folder).slice(0, LIMITS.name);
+}
+
+export { LIMITS };