@lampdotdev/lamp 0.36.2-nightly.19 → 0.36.2-nightly.21

package/README.md

@@ -33,7 +33,7 @@ Mac app, `projectOf`), or any folder with an `index.html`; without one, the fold
 | `lamp unshare` | Takes the link down. |
 | `lamp account [username] [--email address]` | The maker's account on lamp.dev, which their links go under (`lamp.dev/<username>/<app>`): with a username and an email it asks the site for one (`askAccount`), whose key lamp keeps with its state (`account.json`, by site) and sends with every share (`X-Lamp-Account`); the link in the email the site sends confirms it. With only an email that has an account, it signs in to it, with a key of its own. On its own, it says which it's signed in as. A share before the email's link is opened goes out as links always have (`/w/<id>-<name>`), and moves under the username at its next share. |
 | `lamp play <link> [--to folder] [--newest]` | Plays an app shared on lamp.dev on this computer: the link's file (`latestOf`, its `.lampapp`), unpacked as `lamp unpack` does into a folder of its own in `~/Lamp Games` (or `--to`), with Lamp's own files beside its page, then opened as `lamp open` opens any folder. Its AI is answered by `lamp dev` (`ai.mjs`) in any browser, Safari included, where a shared page can't reach the computer. lamp remembers which folder each link went into (a file for each link under `played/` in its state), so playing it again goes on where it was; `--newest` takes the link's latest version into a new folder. |
-| `lamp ai [--forget]` | Answers the AI of pages shared on lamp.dev, played in a browser on this computer, with the person's own Claude Code, Codex or OpenRouter key (`cli/local-ai.mjs`, the same answers as `ai.mjs` gives `lamp dev`), until it's stopped. It listens on this computer alone at a port lamp.js knows (`LOCAL_AI_PORT`, `NEARBY` in lamp.js), and answers only a link's own page (`<id in hex>.play.lamp.dev`, `playOrigin`): the first time a page uses the AI, the person is asked in the terminal, and the page keeps the token it's given. Whether there's an AI is answered without asking. The browser asks the person too, once, before a page may reach this computer, so the link's frame on lamp.dev is given that permission. Safari never lets the page reach it (Safari 27, checked against a stand-in on the port), so lamp.js tells someone playing in Safari to use Chrome, Lamp or `lamp play` instead. `--forget` takes back every page allowed. Lamp's app runs the same server while it's open (`sharedPages` in `calls.mjs`, `SharedPagesAI`): it asks the person in a dialog and answers with the AI they set up in Lamp, and the pages allowed are the same list; whichever of the two starts first answers. |
+| `lamp ai [--forget]` | Answers the AI of pages shared on lamp.dev, played in a browser on this computer, with the person's own Claude Code, Codex or OpenRouter key (`cli/local-ai.mjs`, the same answers as `ai.mjs` gives `lamp dev`), until it's stopped. It listens on this computer alone at a port lamp.js knows (`LOCAL_AI_PORT`, `NEARBY` in lamp.js), and answers only a link's own page (`<id in hex>.play.lamp.dev`, `playOrigin`): the first time a page uses the AI, the person is asked in the terminal, and the page keeps the token it's given. Whether there's an AI is answered without asking. The browser asks the person too, once, before a page may reach this computer, so the link's frame on lamp.dev is given that permission; lamp.js reaches the port only once that's granted, the page has a token, or the person asks (`LampAI.connect()` from a button, or a real AI call), so the browser doesn't ask as the page loads. Safari never lets the page reach it (Safari 27, checked against a stand-in on the port), so lamp.js tells someone playing in Safari to use Chrome, Lamp or `lamp play` instead. `--forget` takes back every page allowed. Lamp's app runs the same server while it's open (`sharedPages` in `calls.mjs`, `SharedPagesAI`): it asks the person in a dialog and answers with the AI they set up in Lamp, and the pages allowed are the same list; whichever of the two starts first answers. |
 | `lamp devices [add \| forget <name>]` | The person's devices lamp puts a page on: an Xbox in Developer Mode (those set up and those found on the network), and Android (lamp's emulators, and the phones, tablets and TVs plugged in with USB debugging on). `add` sets one up, a step at a time; `add android` downloads Android's tools. |
 | `lamp open --on xbox` | Packages the page, installs it on the device and opens it there. `lamp look --on xbox` is the device's screen and the app's log there, `lamp stop --on xbox` ends it, and `lamp remove --on xbox` takes it off. |
 | `lamp open --on android [--hidden]` | Builds Lamp's Android app around the page and opens it in lamp's Android emulator (`--on android-tv`: its TV emulator; a device of the person's by its name), with `look`, `stop` and `remove` as on any device, and `lamp use --on android` to tap, type and press there. `--hidden` starts the emulator with no window. |

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

@@ -20,7 +20,10 @@ opening comment for the whole list. What it gives:
   on it, check `LampAI.status('text')` and, when it can't answer, show its `reason` as it's given: lamp.js words it
   for where the page is (away from the Mac's Wi‑Fi, Lamp closed, a link on lamp.dev), so don't write your own. Where it
   gives `help` (a page away from Lamp), add a link to it beside the reason, "How to turn on AI", so someone who has never
-  heard of Lamp finds out how.
+  heard of Lamp finds out how. Where it answers `connect: true` (a page on lamp.dev that hasn't reached this computer
+  yet), also show a small "Connect AI" button that calls `LampAI.connect(capability)` with the same kind of AI you asked
+  `status` about (`LampAI.connect('pictures')` for pictures) and use the answer it gives as `status`'s;
+  never call `connect()` as the page loads, since it makes the browser ask the person.
 - **LampAI.act**: the person asks the app to do something in their own words, and the app's own reads and writes do
   it; "Doing things for the person" below, with **LampVoice** and **LampAI.hear** for saying it.
 - **LampStore**: what the app saves, as JSON on the device. Once something is saved, only ever add to it: a new field

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

@@ -254,6 +254,26 @@
     var ua = (window.navigator && navigator.userAgent) || '';
     return /Safari\//.test(ua) && !/Chrome|Chromium|CriOS|Edg|OPR|Firefox|FxiOS/.test(ua);
   }
+  var SAFARI_AI = 'AI here works in Chrome or in Lamp, or with Lamp\'s command line: lamp play and this page\'s link.';
+
+  // Reaching this computer makes the browser ask the person about it, so a shared page doesn't reach out just to
+  // see whether there's an AI: only once the browser already lets it, the page has paired before, or the person
+  // has asked for it (LampAI.connect, from a button, or a real AI call).
+  var nearbyAsked = false;
+  function nearbyAllowed() {
+    // Connected before in this browser (kept with the page's saved things): the browser has had its say already.
+    if (nearbyAsked || read('nearby.token', null) || read('nearby.connected', false)) return Promise.resolve(true);
+    var permissions = window.navigator && navigator.permissions;
+    if (!permissions || typeof permissions.query !== 'function') return Promise.resolve(false);
+    // Chrome has named this permission more than one way; any that's granted will do, and one it doesn't know is unknown.
+    var names = ['local-network-access', 'loopback-network', 'local-network'];
+    return Promise.all(names.map(function (name) {
+      try {
+        return Promise.resolve(permissions.query({ name: name })).then(function (s) { return !!s && s.state === 'granted'; }, function () { return false; });
+      } catch (e) { return false; }
+    })).then(function (states) { return states.indexOf(true) !== -1; });
+  }
+
   function nearby(path, body, timeout, deadline) {
     var text = JSON.stringify(body);
     function go(t) { return exchange(NEARBY, path, t, text, deadline ? Math.max(1000, deadline - Date.now()) : timeout); }
@@ -276,7 +296,7 @@
     return done.then(null, function (e) {
       if (e instanceof Failure) throw e;
       // Safari never lets a page on the web reach this computer this way, so Lamp or lamp ai open here wouldn't help.
-      if (safari()) throw new Failure('AI here works in Chrome or in Lamp, or with Lamp\'s command line: lamp play and this page\'s link.', null, AI_HELP);
+      if (safari()) throw new Failure(SAFARI_AI, null, AI_HELP);
       throw new Failure('AI isn\'t available here. Open Lamp on this computer, or with Lamp\'s command line, run lamp ai.', null, AI_HELP);
     });
   }
@@ -738,31 +758,58 @@
    * a feature depends on it, and show the feature with its `reason` as it's given rather than words of the app's
    * own, or hiding it or failing at it, and where it gives `help` (a page away from Lamp), a link to it beside the
    * reason: "How to turn on AI". A call that fails for that reason has `needsSetup`, or `help`, set on its error.
+   * On a page shared on lamp.dev that hasn't reached this computer yet, `status` asks nothing and answers
+   * `connect: true`: show a small "Connect AI" button beside its reason that calls `LampAI.connect(capability)` with
+   * the same kind of AI (`connect('pictures')` for pictures), and use what that gives as `status`'s answer. Never
+   * call `connect()` as the page loads.
    */
   var LampAI = {
     Failure: Failure,
 
     /** Whether this kind of AI ('text', 'decisions', 'pictures', 'act' or 'hear') can answer now: { available, reason,
-     *  help }, where `reason` is the short line to show when it can't, written for where the page is, and `help`, when
-     *  it's there, the page that says how to turn AI on, to link to beside it. */
+     *  help, connect }, where `reason` is the short line to show when it can't, written for where the page is, `help`,
+     *  when it's there, the page that says how to turn AI on, to link to beside it, and `connect`, when true, that
+     *  a button calling `LampAI.connect()` would find out (a page on lamp.dev, before it has reached this computer). */
     status: function (capability) {
       var no = function (reason, help) {
         var said = { available: false, reason: reason || 'AI isn\'t set up for this here.' };
         if (help) said.help = help;
         return said;
       };
-      // 'act' is asked of /ai/act itself: available only when this lamp.js has it, the app around the page lets the
-      // route through (an older one answers Not found) and the AI that answers the app can take it. 'hear' the same.
-      if (capability === 'act' || capability === 'hear') {
-        return post('/ai/' + capability, { probe: true }, 10000).then(function (reply) {
-          return reply[capability] === true ? { available: true, reason: '' } : no(reply.reason || reply.why);
+      if (!bridge && shared()) {
+        return nearbyAllowed().then(function (allowed) {
+          if (allowed) return ask(capability);
+          if (safari()) return no(SAFARI_AI, AI_HELP);
+          return { available: false, connect: true, reason: 'Connect to the AI on this computer to use this.', help: AI_HELP };
+        });
+      }
+      return ask(capability);
+      function ask(capability) {
+        // 'act' is asked of /ai/act itself: available only when this lamp.js has it, the app around the page lets the
+        // route through (an older one answers Not found) and the AI that answers the app can take it. 'hear' the same.
+        if (capability === 'act' || capability === 'hear') {
+          return post('/ai/' + capability, { probe: true }, 10000).then(function (reply) {
+            return reply[capability] === true ? { available: true, reason: '' } : no(reply.reason || reply.why);
+          }, function (e) { return no(e && e.message, e && e.help); });
+        }
+        return post('/ai/status', {}, 10000).then(function (reply) {
+          if (reply[capability] === true) return { available: true, reason: '' };
+          var detail = reply.details && reply.details[capability];
+          return no(detail && detail.reason);
         }, function (e) { return no(e && e.message, e && e.help); });
       }
-      return post('/ai/status', {}, 10000).then(function (reply) {
-        if (reply[capability] === true) return { available: true, reason: '' };
-        var detail = reply.details && reply.details[capability];
-        return no(detail && detail.reason);
-      }, function (e) { return no(e && e.message, e && e.help); });
+    },
+
+    /** On a page shared on lamp.dev, reaches the AI on this computer, so the browser asks the person then: call it
+     *  from a button ("Connect AI") shown when `status` answers `connect: true`, never as the page loads. Gives what
+     *  `status` gives for that kind of AI ('text' unless named). Anywhere else it's just `status`. */
+    connect: function (capability) {
+      nearbyAsked = true;
+      return LampAI.status(capability || 'text').then(function (said) {
+        // Reached it (whatever it said of this kind of AI): later visits look without asking first.
+        if (said.available || !said.help) write('nearby.connected', true);
+        return said;
+      });
     },
 
     /** Whether this kind of AI can answer now, as `status` says. */

package/cli/lamps/lamp.js

@@ -254,6 +254,26 @@
     var ua = (window.navigator && navigator.userAgent) || '';
     return /Safari\//.test(ua) && !/Chrome|Chromium|CriOS|Edg|OPR|Firefox|FxiOS/.test(ua);
   }
+  var SAFARI_AI = 'AI here works in Chrome or in Lamp, or with Lamp\'s command line: lamp play and this page\'s link.';
+
+  // Reaching this computer makes the browser ask the person about it, so a shared page doesn't reach out just to
+  // see whether there's an AI: only once the browser already lets it, the page has paired before, or the person
+  // has asked for it (LampAI.connect, from a button, or a real AI call).
+  var nearbyAsked = false;
+  function nearbyAllowed() {
+    // Connected before in this browser (kept with the page's saved things): the browser has had its say already.
+    if (nearbyAsked || read('nearby.token', null) || read('nearby.connected', false)) return Promise.resolve(true);
+    var permissions = window.navigator && navigator.permissions;
+    if (!permissions || typeof permissions.query !== 'function') return Promise.resolve(false);
+    // Chrome has named this permission more than one way; any that's granted will do, and one it doesn't know is unknown.
+    var names = ['local-network-access', 'loopback-network', 'local-network'];
+    return Promise.all(names.map(function (name) {
+      try {
+        return Promise.resolve(permissions.query({ name: name })).then(function (s) { return !!s && s.state === 'granted'; }, function () { return false; });
+      } catch (e) { return false; }
+    })).then(function (states) { return states.indexOf(true) !== -1; });
+  }
+
   function nearby(path, body, timeout, deadline) {
     var text = JSON.stringify(body);
     function go(t) { return exchange(NEARBY, path, t, text, deadline ? Math.max(1000, deadline - Date.now()) : timeout); }
@@ -276,7 +296,7 @@
     return done.then(null, function (e) {
       if (e instanceof Failure) throw e;
       // Safari never lets a page on the web reach this computer this way, so Lamp or lamp ai open here wouldn't help.
-      if (safari()) throw new Failure('AI here works in Chrome or in Lamp, or with Lamp\'s command line: lamp play and this page\'s link.', null, AI_HELP);
+      if (safari()) throw new Failure(SAFARI_AI, null, AI_HELP);
       throw new Failure('AI isn\'t available here. Open Lamp on this computer, or with Lamp\'s command line, run lamp ai.', null, AI_HELP);
     });
   }
@@ -738,31 +758,58 @@
    * a feature depends on it, and show the feature with its `reason` as it's given rather than words of the app's
    * own, or hiding it or failing at it, and where it gives `help` (a page away from Lamp), a link to it beside the
    * reason: "How to turn on AI". A call that fails for that reason has `needsSetup`, or `help`, set on its error.
+   * On a page shared on lamp.dev that hasn't reached this computer yet, `status` asks nothing and answers
+   * `connect: true`: show a small "Connect AI" button beside its reason that calls `LampAI.connect(capability)` with
+   * the same kind of AI (`connect('pictures')` for pictures), and use what that gives as `status`'s answer. Never
+   * call `connect()` as the page loads.
    */
   var LampAI = {
     Failure: Failure,
 
     /** Whether this kind of AI ('text', 'decisions', 'pictures', 'act' or 'hear') can answer now: { available, reason,
-     *  help }, where `reason` is the short line to show when it can't, written for where the page is, and `help`, when
-     *  it's there, the page that says how to turn AI on, to link to beside it. */
+     *  help, connect }, where `reason` is the short line to show when it can't, written for where the page is, `help`,
+     *  when it's there, the page that says how to turn AI on, to link to beside it, and `connect`, when true, that
+     *  a button calling `LampAI.connect()` would find out (a page on lamp.dev, before it has reached this computer). */
     status: function (capability) {
       var no = function (reason, help) {
         var said = { available: false, reason: reason || 'AI isn\'t set up for this here.' };
         if (help) said.help = help;
         return said;
       };
-      // 'act' is asked of /ai/act itself: available only when this lamp.js has it, the app around the page lets the
-      // route through (an older one answers Not found) and the AI that answers the app can take it. 'hear' the same.
-      if (capability === 'act' || capability === 'hear') {
-        return post('/ai/' + capability, { probe: true }, 10000).then(function (reply) {
-          return reply[capability] === true ? { available: true, reason: '' } : no(reply.reason || reply.why);
+      if (!bridge && shared()) {
+        return nearbyAllowed().then(function (allowed) {
+          if (allowed) return ask(capability);
+          if (safari()) return no(SAFARI_AI, AI_HELP);
+          return { available: false, connect: true, reason: 'Connect to the AI on this computer to use this.', help: AI_HELP };
+        });
+      }
+      return ask(capability);
+      function ask(capability) {
+        // 'act' is asked of /ai/act itself: available only when this lamp.js has it, the app around the page lets the
+        // route through (an older one answers Not found) and the AI that answers the app can take it. 'hear' the same.
+        if (capability === 'act' || capability === 'hear') {
+          return post('/ai/' + capability, { probe: true }, 10000).then(function (reply) {
+            return reply[capability] === true ? { available: true, reason: '' } : no(reply.reason || reply.why);
+          }, function (e) { return no(e && e.message, e && e.help); });
+        }
+        return post('/ai/status', {}, 10000).then(function (reply) {
+          if (reply[capability] === true) return { available: true, reason: '' };
+          var detail = reply.details && reply.details[capability];
+          return no(detail && detail.reason);
         }, function (e) { return no(e && e.message, e && e.help); });
       }
-      return post('/ai/status', {}, 10000).then(function (reply) {
-        if (reply[capability] === true) return { available: true, reason: '' };
-        var detail = reply.details && reply.details[capability];
-        return no(detail && detail.reason);
-      }, function (e) { return no(e && e.message, e && e.help); });
+    },
+
+    /** On a page shared on lamp.dev, reaches the AI on this computer, so the browser asks the person then: call it
+     *  from a button ("Connect AI") shown when `status` answers `connect: true`, never as the page loads. Gives what
+     *  `status` gives for that kind of AI ('text' unless named). Anywhere else it's just `status`. */
+    connect: function (capability) {
+      nearbyAsked = true;
+      return LampAI.status(capability || 'text').then(function (said) {
+        // Reached it (whatever it said of this kind of AI): later visits look without asking first.
+        if (said.available || !said.help) write('nearby.connected', true);
+        return said;
+      });
     },
 
     /** Whether this kind of AI can answer now, as `status` says. */

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

@@ -1 +1 @@
-{"platform":"mac","instance":"12A4CA51-92CD-4391-8AD0-548165ABFCAE","exe":"ZqxAppName","name":"Zqx App Name"}
+{"exe":"ZqxAppName","name":"Zqx App Name","instance":"66001C8E-04AF-4B31-9585-64F312C02625","platform":"mac"}

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

@@ -254,6 +254,26 @@
     var ua = (window.navigator && navigator.userAgent) || '';
     return /Safari\//.test(ua) && !/Chrome|Chromium|CriOS|Edg|OPR|Firefox|FxiOS/.test(ua);
   }
+  var SAFARI_AI = 'AI here works in Chrome or in Lamp, or with Lamp\'s command line: lamp play and this page\'s link.';
+
+  // Reaching this computer makes the browser ask the person about it, so a shared page doesn't reach out just to
+  // see whether there's an AI: only once the browser already lets it, the page has paired before, or the person
+  // has asked for it (LampAI.connect, from a button, or a real AI call).
+  var nearbyAsked = false;
+  function nearbyAllowed() {
+    // Connected before in this browser (kept with the page's saved things): the browser has had its say already.
+    if (nearbyAsked || read('nearby.token', null) || read('nearby.connected', false)) return Promise.resolve(true);
+    var permissions = window.navigator && navigator.permissions;
+    if (!permissions || typeof permissions.query !== 'function') return Promise.resolve(false);
+    // Chrome has named this permission more than one way; any that's granted will do, and one it doesn't know is unknown.
+    var names = ['local-network-access', 'loopback-network', 'local-network'];
+    return Promise.all(names.map(function (name) {
+      try {
+        return Promise.resolve(permissions.query({ name: name })).then(function (s) { return !!s && s.state === 'granted'; }, function () { return false; });
+      } catch (e) { return false; }
+    })).then(function (states) { return states.indexOf(true) !== -1; });
+  }
+
   function nearby(path, body, timeout, deadline) {
     var text = JSON.stringify(body);
     function go(t) { return exchange(NEARBY, path, t, text, deadline ? Math.max(1000, deadline - Date.now()) : timeout); }
@@ -276,7 +296,7 @@
     return done.then(null, function (e) {
       if (e instanceof Failure) throw e;
       // Safari never lets a page on the web reach this computer this way, so Lamp or lamp ai open here wouldn't help.
-      if (safari()) throw new Failure('AI here works in Chrome or in Lamp, or with Lamp\'s command line: lamp play and this page\'s link.', null, AI_HELP);
+      if (safari()) throw new Failure(SAFARI_AI, null, AI_HELP);
       throw new Failure('AI isn\'t available here. Open Lamp on this computer, or with Lamp\'s command line, run lamp ai.', null, AI_HELP);
     });
   }
@@ -738,31 +758,58 @@
    * a feature depends on it, and show the feature with its `reason` as it's given rather than words of the app's
    * own, or hiding it or failing at it, and where it gives `help` (a page away from Lamp), a link to it beside the
    * reason: "How to turn on AI". A call that fails for that reason has `needsSetup`, or `help`, set on its error.
+   * On a page shared on lamp.dev that hasn't reached this computer yet, `status` asks nothing and answers
+   * `connect: true`: show a small "Connect AI" button beside its reason that calls `LampAI.connect(capability)` with
+   * the same kind of AI (`connect('pictures')` for pictures), and use what that gives as `status`'s answer. Never
+   * call `connect()` as the page loads.
    */
   var LampAI = {
     Failure: Failure,
 
     /** Whether this kind of AI ('text', 'decisions', 'pictures', 'act' or 'hear') can answer now: { available, reason,
-     *  help }, where `reason` is the short line to show when it can't, written for where the page is, and `help`, when
-     *  it's there, the page that says how to turn AI on, to link to beside it. */
+     *  help, connect }, where `reason` is the short line to show when it can't, written for where the page is, `help`,
+     *  when it's there, the page that says how to turn AI on, to link to beside it, and `connect`, when true, that
+     *  a button calling `LampAI.connect()` would find out (a page on lamp.dev, before it has reached this computer). */
     status: function (capability) {
       var no = function (reason, help) {
         var said = { available: false, reason: reason || 'AI isn\'t set up for this here.' };
         if (help) said.help = help;
         return said;
       };
-      // 'act' is asked of /ai/act itself: available only when this lamp.js has it, the app around the page lets the
-      // route through (an older one answers Not found) and the AI that answers the app can take it. 'hear' the same.
-      if (capability === 'act' || capability === 'hear') {
-        return post('/ai/' + capability, { probe: true }, 10000).then(function (reply) {
-          return reply[capability] === true ? { available: true, reason: '' } : no(reply.reason || reply.why);
+      if (!bridge && shared()) {
+        return nearbyAllowed().then(function (allowed) {
+          if (allowed) return ask(capability);
+          if (safari()) return no(SAFARI_AI, AI_HELP);
+          return { available: false, connect: true, reason: 'Connect to the AI on this computer to use this.', help: AI_HELP };
+        });
+      }
+      return ask(capability);
+      function ask(capability) {
+        // 'act' is asked of /ai/act itself: available only when this lamp.js has it, the app around the page lets the
+        // route through (an older one answers Not found) and the AI that answers the app can take it. 'hear' the same.
+        if (capability === 'act' || capability === 'hear') {
+          return post('/ai/' + capability, { probe: true }, 10000).then(function (reply) {
+            return reply[capability] === true ? { available: true, reason: '' } : no(reply.reason || reply.why);
+          }, function (e) { return no(e && e.message, e && e.help); });
+        }
+        return post('/ai/status', {}, 10000).then(function (reply) {
+          if (reply[capability] === true) return { available: true, reason: '' };
+          var detail = reply.details && reply.details[capability];
+          return no(detail && detail.reason);
         }, function (e) { return no(e && e.message, e && e.help); });
       }
-      return post('/ai/status', {}, 10000).then(function (reply) {
-        if (reply[capability] === true) return { available: true, reason: '' };
-        var detail = reply.details && reply.details[capability];
-        return no(detail && detail.reason);
-      }, function (e) { return no(e && e.message, e && e.help); });
+    },
+
+    /** On a page shared on lamp.dev, reaches the AI on this computer, so the browser asks the person then: call it
+     *  from a button ("Connect AI") shown when `status` answers `connect: true`, never as the page loads. Gives what
+     *  `status` gives for that kind of AI ('text' unless named). Anywhere else it's just `status`. */
+    connect: function (capability) {
+      nearbyAsked = true;
+      return LampAI.status(capability || 'text').then(function (said) {
+        // Reached it (whatever it said of this kind of AI): later visits look without asking first.
+        if (said.available || !said.help) write('nearby.connected', true);
+        return said;
+      });
     },
 
     /** Whether this kind of AI can answer now, as `status` says. */

package/package.json

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