evals-lab 0.10.0 → 0.12.0

package/lab/server.py

@@ -42,6 +42,7 @@ import urllib.error
 import urllib.parse
 import urllib.request
 import zipfile
+from concurrent.futures import ThreadPoolExecutor
 from contextlib import closing
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
@@ -53,6 +54,9 @@ OLLAMA = os.environ.get("OLLAMA_URL", "http://127.0.0.1:11434")
 # as a lab run on a workstation always has been; the deployed one sets it,
 # because it keeps setups and API keys and can spend GPU time.
 PASSWORD = os.environ.get("LAB_PASSWORD") or None
+# A lab file imported on every start (docs/lab-export.md): a demo lab that
+# keeps no data starts set up, its keys from $EVALSLAB_API_KEY_<SLUG>.
+LAB_IMPORT = os.environ.get("LAB_IMPORT") or None
 # Where what follows the user between browsers is kept (#463). Unset means
 # nothing is, and the page stays with its browser as it always has.
 DATA_DIR = os.environ.get("DATA_DIR") or None
@@ -170,6 +174,21 @@ def auth_headers(ctype: str, key: str) -> dict:
     return {"Authorization": "Bearer " + key}
 
 
+def http_key_header(how, key: str) -> dict:
+    """The header an HTTP endpoint connection sends its key in: its Key header
+    setting, kept flat on the connection (evals-core.ts's KEY_HEADERS)."""
+    if not key:
+        return {}
+    how = str(how or "bearer")
+    if how == "x-api-key":
+        return {"x-api-key": key}
+    if how == "api-key":
+        return {"api-key": key}
+    if how == "none":
+        return {}
+    return {"Authorization": "Bearer " + key}
+
+
 def connection_url(base: str, ctype: str) -> str:
     path = CONNECTION_CHAT_PATHS.get(ctype, "/chat/completions")
     if ctype in ("ollama", "ollama-cloud"):
@@ -348,7 +367,8 @@ SOURCE_PROVIDERS = {
     # The API call provider (docs/dynamic-sources.md § 2): HTTP GET plus a verb,
     # headers and a body, keyed from a connection -- the same relay fetch, one
     # layer up. `produce` and `take` are attached below, beside http-get's.
-    "api": {"label": "API call", "noun": "call", "tier": "pull", "flag": None,
+    # `keyed`: it sends a connection's key, so a pack may not carry one (read_pack).
+    "api": {"label": "API call", "noun": "call", "tier": "pull", "flag": None, "keyed": True,
             "uploads": dict(_CALL_UPLOADS), "longConfig": {"body": 8000}},
     # Supplied has no `produce`: the caller hands items in (the CLI's --items, or
     # an Upload… by hand), so the server fetches and executes nothing -- it only
@@ -565,7 +585,20 @@ def redact_flow(value):
 # again, so a page that got it wrong cannot put a key or a malformed record on
 # disk.
 RECORD_FORMAT = "evals-lab/record"
-RECORD_VERSION = 1
+RECORD_VERSION = 2
+# The origins a record names. Version 2 added `edited`: a call changed in the
+# Call dialog, keeping the `run` and `iteration` it came from.
+RECORD_ORIGINS = ("run", "hand", "upload", "edited")
+
+
+def upgrade_record(value):
+    """A version-1 record as today's: flows/record.ts's upgradeRecord. Version
+    2 only widened the origins, so the upgrade is the number. Anything else is
+    returned as it is, for record_problems to judge."""
+    if isinstance(value, dict) and value.get("format") == RECORD_FORMAT and value.get("version") == 1 \
+            and not isinstance(value.get("version"), bool):
+        return {**value, "version": RECORD_VERSION}
+    return value
 
 
 def record_problems(value):
@@ -600,8 +633,8 @@ def record_problems(value):
             or isinstance(res.get("error"), dict))):
         bad.append("a record's result is { status, body }, { error } or null")
     origin = value.get("origin")
-    if not isinstance(origin, dict) or origin.get("kind") not in ("run", "hand", "upload"):
-        bad.append("a record's origin is run, hand or upload")
+    if not isinstance(origin, dict) or origin.get("kind") not in RECORD_ORIGINS:
+        bad.append("a record's origin is run, hand, upload or edited")
     return bad
 
 
@@ -612,6 +645,7 @@ def take_record(name, data):
         value = json.loads(data.decode("utf-8"))
     except (UnicodeDecodeError, ValueError):
         return None, (400, f"{name} is not JSON")
+    value = upgrade_record(value)
     bad = record_problems(value)
     if bad:
         return None, (400, f"{name}: {bad[0]}")
@@ -689,6 +723,12 @@ def take_dynamic(name, data):
         return None, (400, f"{name} is not text")
     if TOKEN_SHAPE.search(text):
         return None, (400, f"{name} holds a token, and a token never reaches the server")
+    # The lab's own secrets have no shape to redact by, and a command can read
+    # them from its parent's environment, so they are matched by value -- a
+    # verbatim read only; an encoded one gets past. A value under 8 characters is too likely to
+    # be ordinary text to refuse a Call for.
+    if any(len(v) >= 8 and v in text for v in (os.environ.get(k) or "" for k in _LAB_SECRET_ENV)):
+        return None, (400, f"{name} holds one of the lab's own secrets")
     for pattern, to in SECRET_TEXT:
         text = pattern.sub(to, text)
     return text.encode("utf-8"), None
@@ -750,31 +790,32 @@ def _header_pairs(spec):
 def connection_auth(pid):
     """The one auth header a dynamic API Source borrows from the connection
     [pid] it names, and the key it carries so the relay's https-or-loopback
-    rule can bind. The key is the profiles store's, by id, sent the way the
+    rule can bind. The key is the connections store's, by id, sent the way the
     connection's type says (an HTTP endpoint's Key header, else the type's own,
     auth_headers) -- it never leaves the server or reaches a Call (#258).
     Returns (headers, key, None); ({}, "", None) for no connection or no key;
-    or (None, None, (code, why))."""
+    or (None, None, (code, why)). This is the third seam a connection resolves
+    to a key, beside worker_destinations and the relay's _unshared, so it
+    refuses a connection not shared with the bound workspace the same way --
+    the request thread's for a snapshot, the submitting request's for a live
+    run (docs/workspaces.md)."""
     if not pid:
         return {}, "", None
-    doc = (STORE.all().get("promptlab.profiles") or {}) if STORE is not None else {}
+    doc = (STORE.all().get("promptlab.connections") or {}) if STORE is not None else {}
     profiles = (doc.get("body") or {}).get("list") or []
     profile = next((p for p in profiles if isinstance(p, dict) and p.get("id") == pid), None)
     if profile is None:
         return None, None, (400, "that Source's auth connection is not one the lab has")
+    ws = workspace_of(STORE)
+    if not STORE.shared("profile", pid, ws):
+        return None, None, (403, not_shared_sentence([profile.get("name") or pid], STORE.workspace_name(ws)))
     key = str(profile.get("key") or "").strip()
     if not key:
         return {}, "", None
     if not header_safe(key):
         return None, None, (400, "that connection's key cannot be sent in a header")
     ctype = profile.get("type")
-    if ctype == "http":
-        options = profile.get("options") if isinstance(profile.get("options"), dict) else {}
-        how = str(options.get("auth") or "bearer")
-        head = ({"x-api-key": key} if how == "x-api-key" else {"api-key": key} if how == "api-key"
-                else {} if how == "none" else {"Authorization": "Bearer " + key})
-    else:
-        head = auth_headers(ctype, key)
+    head = http_key_header(profile.get("auth"), key) if ctype == "http" else auth_headers(ctype, key)
     return head, key, None
 
 
@@ -789,6 +830,10 @@ def produce_api(config):
     method = (cfg.get("method").upper() if isinstance(cfg.get("method"), str) and cfg.get("method").strip()
               else "GET")
     auth, key, why = connection_auth(cfg.get("connection"))
+    if why and why[0] == 403:
+        # Refused, not failed: no request went out, so the caller answers the
+        # refusal rather than keeping a failed Call.
+        return {"error": why[1], "refused": why, "request": {"url": url, "method": method}, "status": None}
     if why:
         return {"error": why[1], "request": {"url": url, "method": method}, "status": None}
     headers = {**_header_pairs(cfg.get("reqHeaders")), **auth}
@@ -858,7 +903,8 @@ def _outside_root(real):
     root = Path(LOCAL_ROOT).resolve()
     return real != root and root not in real.parents
 
-# The lab's own secrets in its environment, never handed to a command it runs.
+# The lab's own secrets in its environment, never handed to a command it runs
+# nor kept in a Call (take_dynamic).
 _LAB_SECRET_ENV = ("LAB_PASSWORD", "GOOGLE_CLIENT_SECRET", "GOOGLE_API_KEY")
 
 
@@ -895,7 +941,8 @@ def command_config_problems(config):
 def produce_file(config):
     """Read a File on disk Source's one Call now: the path its config names,
     capped at the file cap. The lab's own data directory is never read -- it
-    holds the store, keys included. Returns the shape _relay_produce does."""
+    holds the store, keys included -- nor /proc, which holds the server's
+    environment. Returns the shape _relay_produce does."""
     path = config.get("path") if isinstance(config, dict) else None
     request = {"path": path}
     if not isinstance(path, str) or not path.strip():
@@ -910,6 +957,10 @@ def produce_file(config):
     for own in {Path(d).resolve() for d in (DATA_DIR, STORE and Path(STORE.path).parent) if d}:
         if real == own or own in real.parents:
             return {"error": "the lab's own data is not a file it reads", "request": request, "status": None}
+    # /proc holds the server's own environment (every secret it was started
+    # with, not only the lab's) and its memory: the process, not a file.
+    if real == Path("/proc") or Path("/proc") in real.parents:
+        return {"error": "the server's own process is not a file it reads", "request": request, "status": None}
     if not real.is_file():
         return {"error": "that path is not a file", "request": request, "status": None}
     try:
@@ -1024,8 +1075,10 @@ SIGN_INS = {"microsoft": lambda: microsoft_config() is not None}
 # in the store: a document is not migrated or deleted because nothing reads it.
 # promptlab.cases, .rules and their .base copies went that way when a dataset
 # became a row of its own (#86), and promptlab.mappings once a dataset named
-# the Source it grades (#199).
-SYNCED = ("promptlab.workflows", "promptlab.profiles",
+# the Source it grades (#199). promptlab.profiles went once a Target profile
+# was split into an AI Connection and a Connection Profile (#445), each kept
+# in a document of its own; its rows are what the split read.
+SYNCED = ("promptlab.workflows", "promptlab.connections", "promptlab.connectionProfiles",
           "promptlab.versions", "promptlab.tokens")
 MAX_DOC = 8 * 1024 * 1024
 RUNS_PAGE = 25
@@ -1088,14 +1141,16 @@ QUEUE_WAIT = 1.0
 WATCH_EVERY = 5.0
 
 
-# A Target profile's key is written from the page and never read back by it
+# An AI Connection's key is written from the page and never read back by it
 # (#258): a client holding the lab's password -- CI's runners and their logs
-# among them -- is handed no key. Where a profile holds one, what is served
+# among them -- is handed no key. Where a connection holds one, what is served
 # (/api/state, the page's carried copy, a refused write's current copy) holds
-# KEY_HELD and the profile's id instead, and a write that brings that back
-# keeps the key the store holds for the id: the profile's own, or the one it
-# was cloned or restored from. KEY_HELD starts with a character no key can
-# (header_safe), so a pasted key is never taken for it.
+# KEY_HELD and the connection's id instead, and a write that brings that back
+# keeps the key the store holds for the id: the connection's own, or the one
+# it was cloned or restored from. KEY_HELD starts with a character no key can
+# (header_safe), so a pasted key is never taken for it. A Target profile held
+# the key before the split (#445); a connection keeps its id, so a KEY_HELD
+# the page carried then still names it.
 KEY_HELD = "\u2022held:"
 
 
@@ -1104,11 +1159,12 @@ def held(key) -> bool:
 
 
 def profiles_in(name: str, body):
-    """Every profile a synced document holds: the profiles store's list, and
-    each profile version's copy."""
+    """Everything keyed a synced document holds: the connections store's
+    list, and each profile version's copy -- a Target profile's settings and
+    key, under its connection's id."""
     if not isinstance(body, dict):
         return
-    if name == "promptlab.profiles":
+    if name == "promptlab.connections":
         for p in body.get("list") or []:
             if isinstance(p, dict):
                 yield p
@@ -1165,7 +1221,9 @@ SHARE_NEW = "*new"
 # its pipeline/dataset slices per-workspace, its profile slice global, because
 # profiles are global so their Restore must be too. served()/write() route
 # each key by these; any other key is per-workspace.
-DOC_GLOBAL = ("promptlab.profiles", "promptlab.tokens")
+# promptlab.profiles stays global though no longer served: its row is what
+# the split on open reads (split_profiles).
+DOC_GLOBAL = ("promptlab.connections", "promptlab.connectionProfiles", "promptlab.profiles", "promptlab.tokens")
 DOC_SPLIT = "promptlab.versions"
 
 
@@ -1232,6 +1290,30 @@ class Store:
             db.execute("UPDATE runs SET workspace = ? WHERE workspace IS NULL", (self.default_ws,))
             if cols and "workspace" not in cols:
                 self._rebuild_docs(db)
+            self._split_profiles(db)
+
+    def _split_profiles(self, db):
+        """A store from before the split (#445) opened once: its Target
+        profiles become AI Connections, each keeping the profile's id, its key
+        and its Setup choices (`at`, the lab's grader), and -- where a profile
+        set settings of its own -- Connection Profiles (split_profiles). The
+        old document stays, unserved. Idempotent: a store holding the
+        connections document already, even an emptied one, is left as it is;
+        a store with no profiles has nothing to split."""
+        if db.execute("SELECT 1 FROM docs WHERE name = 'promptlab.connections' AND workspace IS NULL").fetchone():
+            return
+        row = db.execute("SELECT body FROM docs WHERE name = 'promptlab.profiles' AND workspace IS NULL").fetchone()
+        try:
+            body = json.loads(row[0]) if row and row[0] else None
+        except ValueError:
+            body = None
+        if not isinstance(body, dict):
+            return
+        connections, profiles = split_profiles(body.get("list"))
+        kept = {k: body[k] for k in ("at", "grader") if k in body}
+        at = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+        self._put(db, "promptlab.connections", None, 1, {"list": connections, "at": "", **kept}, at)
+        self._put(db, "promptlab.connectionProfiles", None, 1, {"list": profiles}, at)
 
     def _ensure_default(self, db) -> str:
         """The flagged default workspace's id, seeding "Default" (/w/default,
@@ -1363,8 +1445,8 @@ class Store:
                 (name, ws, version, text, at))
 
     def _keyring(self, db, now: dict) -> dict:
-        """Each profile id's key as the store holds it: its profile's, else a
-        dropped one's, else its newest version's."""
+        """Each connection id's key as the store holds it: its connection's,
+        else a dropped one's, else its newest version's."""
         ring = {}
         for p in profiles_in("promptlab.versions", now.get("promptlab.versions", {}).get("body")):
             pid, key = str(p.get("id") or ""), p.get("key")
@@ -1372,7 +1454,7 @@ class Store:
                 ring[pid] = key
         db.execute("DELETE FROM dropped_keys WHERE at < ?", (time.time() - TRASH_SECONDS,))
         ring.update(db.execute("SELECT id, key FROM dropped_keys").fetchall())
-        for p in profiles_in("promptlab.profiles", now.get("promptlab.profiles", {}).get("body")):
+        for p in profiles_in("promptlab.connections", now.get("promptlab.connections", {}).get("body")):
             key = p.get("key")
             if isinstance(key, str) and key and not held(key):
                 ring[str(p.get("id") or "")] = key
@@ -1408,14 +1490,14 @@ class Store:
                     for p in profiles_in(n, d["body"]):
                         if held(p.get("key")):
                             p["key"] = ring.get(p["key"][len(KEY_HELD):], "")
-                if "promptlab.profiles" in docs:
+                if "promptlab.connections" in docs:
                     kept = {str(p.get("id") or "") for p in profiles_in(
-                        "promptlab.profiles", docs["promptlab.profiles"]["body"])}
+                        "promptlab.connections", docs["promptlab.connections"]["body"])}
                     db.executemany("DELETE FROM dropped_keys WHERE id = ?", [(i,) for i in kept])
                     db.executemany(
                         "INSERT OR REPLACE INTO dropped_keys (id, key, at) VALUES (?, ?, ?)",
                         [(str(p.get("id") or ""), p["key"], time.time())
-                         for p in profiles_in("promptlab.profiles", have("promptlab.profiles")["body"])
+                         for p in profiles_in("promptlab.connections", have("promptlab.connections")["body"])
                          if str(p.get("id") or "") not in kept and isinstance(p.get("key"), str) and p["key"]])
                 for n, d in docs.items():
                     version, body = have(n)["version"] + 1, d["body"]
@@ -1434,9 +1516,10 @@ class Store:
             return {n: have(n)["version"] + 1 for n in docs}, None
 
     # ---- shared-by-choice connections (docs/workspaces.md) ------------------
-    # A Target profile or an Account (kind "profile"/"account", id the
-    # profile's or the account's) is usable in a workspace by its share set in
-    # `connection_shares`: a row for that workspace, or the SHARE_ALL sentinel.
+    # An AI Connection or an Account (kind "profile"/"account", id the
+    # connection's -- the Target profile's it kept -- or the account's) is
+    # usable in a workspace by its share set in `connection_shares`: a row for
+    # that workspace, or the SHARE_ALL sentinel.
     # No row at all is the migration and new-connection default -- shared with
     # every workspace, so nothing stops running the moment workspaces exist
     # (open question 2, resolved All); narrowing a connection is adding the
@@ -1498,10 +1581,10 @@ class Store:
         return row[0] if row else "this workspace"
 
     def profile_name(self, pid: str) -> str:
-        """A Target profile's display name, by id, from the global profiles
+        """An AI Connection's display name, by id, from the global connections
         document -- for the refusal sentence. The id itself when none is held."""
         with self.lock, closing(sqlite3.connect(self.path)) as db:
-            row = db.execute("SELECT body FROM docs WHERE name = 'promptlab.profiles' "
+            row = db.execute("SELECT body FROM docs WHERE name = 'promptlab.connections' "
                              "AND workspace IS NULL").fetchone()
         try:
             for p in (json.loads(row[0]) or {}).get("list", []) if row and row[0] else []:
@@ -1827,6 +1910,15 @@ CONFIG_KEYS_MAX = 10
 CONFIG_VALUE_MAX = 400
 
 
+class _Refused(Exception):
+    """A refusal found inside a transaction: rolls it back, carrying the
+    (code, sentence) the caller answers with."""
+
+    def __init__(self, err):
+        super().__init__(err[1])
+        self.err = err
+
+
 class Sources:
     """
     A named bag of files a run might be over (#526).
@@ -2421,16 +2513,19 @@ class Sources:
         if produce is None:
             return None, (400, "that provider cannot be produced from on the server")
         result = produce(cfg)
+        if result.get("refused"):
+            return None, result["refused"]
         request = result.get("request")
         status = result.get("status")
         content = result.get("content")
         if content is None:
             # A failed production: kept as a Call with its error, no file.
-            name = dynamic_item_name(cfg, (request or {}).get("url", "") or secrets.token_hex(6))
+            name = self._snapshot_name(sid, dynamic_item_name(cfg, (request or {}).get("url", "")
+                                                              or secrets.token_hex(6)))
             self._record_call(sid, name, "snapshot", provider, request, status, result.get("error"), None)
             return {"name": name, "origin": "snapshot", "at": None, "provider": provider,
                     "request": request, "status": status, "error": result.get("error")}, None
-        name = dynamic_item_name(cfg, content)
+        name = self._snapshot_name(sid, dynamic_item_name(cfg, content))
         kept, take_err = entry["take"](name, content)
         if take_err:
             code, message = take_err
@@ -2438,7 +2533,8 @@ class Sources:
             return {"name": name, "origin": "snapshot", "at": None, "provider": provider,
                     "request": request, "status": status, "error": message}, None
         # The name is stable (the URL's), so a re-snapshot overwrites the item
-        # rather than adding a second: remove the old file first, then add.
+        # rather than adding a second: remove the old file first, then add. An
+        # Edited Call is never the one overwritten (_snapshot_name).
         self.remove_files(sid, [name])
         stored, add_err = self.add_file(sid, name, kept)
         if add_err:
@@ -2447,6 +2543,162 @@ class Sources:
         return {"name": stored, "origin": "snapshot", "at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
                 "provider": provider, "request": request, "status": status, "bytes": len(kept)}, None
 
+    def _snapshot_name(self, sid, name):
+        """The name a snapshot is kept under: [name], unless an Edited Call
+        holds it -- a snapshot never overwrites an edit -- and then the first
+        of `<stem>-2`, `<stem>-3`... that none does. One that is not Edited is
+        overwritten, as the stable name always was."""
+        with self.store.lock, closing(sqlite3.connect(self.store.path)) as db:
+            edited = {r[0] for r in db.execute(
+                "SELECT name FROM source_calls WHERE source = ? AND origin = 'edited'", (sid,))}
+        if name not in edited:
+            return name
+        stem, ext = os.path.splitext(name)
+        n = 2
+        while f"{stem}-{n}{ext}" in edited:
+            n += 1
+        return f"{stem}-{n}{ext}"
+
+    # ---- a Call opened in the Call dialog: edited, renamed, cloned (#438) ---
+    #
+    # Both kinds of Call -- a dynamic Source's and a Power Automate record --
+    # are files of a Source whose kind has a `take` hook, so a saved edit goes
+    # through the same check as content arriving any other way: a key refused,
+    # the rest redacted. A File Library has no hook and no Calls.
+
+    # The origins a dynamic Call's provenance row may be put back to (Undo).
+    CALL_ORIGINS = ("snapshot", "run", "upload", "hand", "edited")
+
+    def _calls_entry(self, sid):
+        """The enforcement entry of a user Source whose files are Calls, or
+        (None, error)."""
+        with self.store.lock, closing(sqlite3.connect(self.store.path)) as db:
+            r = db.execute("SELECT system FROM sources WHERE id = ? AND (workspace = ? OR system = 1)",
+                           (sid, workspace_of(self.store))).fetchone()
+        if r is None:
+            return None, (404, "no such source")
+        if r[0]:
+            return None, (403, "the sample library is read-only")
+        entry = self.type_of(sid) or {}
+        if entry.get("take") is None:
+            return None, (400, "that Source keeps no Calls")
+        return entry, None
+
+    def _names_held(self, db, sid):
+        """Every name a Source's files and Calls hold: what a new name may not be."""
+        return ({r[0] for r in db.execute("SELECT name FROM source_files WHERE source = ?", (sid,))}
+                | {r[0] for r in db.execute("SELECT name FROM source_calls WHERE source = ?", (sid,))})
+
+    def edit_call(self, sid, name, to=None, content=None, origin=None, named_by=None):
+        """One Call as the Call dialog saves it: renamed to [to], its text
+        replaced by [content], or both, in one write. The text goes through
+        the Source's `take` hook as an upload does. A rename keeps the
+        extension and refuses a name in use, or a Call that a dataset's cases
+        name ([named_by] answers which datasets do), since a case finds its
+        item by name. A dynamic Call's origin becomes `edited` when its text
+        changed -- a rename alone is no edit -- unless [origin] puts back the
+        one it had (Undo). Nothing is written unless all of it passes.
+        Returns ({name, origin, bytes}, None), or (None, (code, sentence)) --
+        (code, sentence, "name") when the Name field is what is wrong."""
+        entry, err = self._calls_entry(sid)
+        if err:
+            return None, err
+        path = self.file_path(sid, name)
+        if path is None or not path.is_file():
+            return None, (404, f"{name} is not a Call of that Source")
+        if origin is not None and origin not in self.CALL_ORIGINS:
+            return None, (400, "that is not an origin a Call has")
+        new = name
+        if to is not None and to != name:
+            new = source_name(to)
+            if new is None or new != to:
+                return None, (400, "that name is not accepted here", "name")
+            if Path(new).suffix.lower() != Path(name).suffix.lower():
+                return None, (400, "a Call keeps its extension", "name")
+            with self.store.lock, closing(sqlite3.connect(self.store.path)) as db:
+                taken = new in self._names_held(db, sid)
+            if taken:
+                return None, (409, f"{new} is taken.", "name")
+            users = named_by(name) if named_by else []
+            if users:
+                return None, (409, f"{users[0]} names {name} in its cases.", "name")
+        old = path.read_bytes()
+        data = old
+        if content is not None:
+            if not isinstance(content, str):
+                return None, (400, "a Call's content is text")
+            raw = content.encode("utf-8")
+            if not raw:
+                return None, (400, "a Call needs some content")
+            if len(raw) > MAX_FILE:
+                return None, (413, "that is over the file cap")
+            data, take_err = entry["take"](new, raw)
+            if take_err:
+                return None, take_err
+        changed = data != old
+        folder = self.dir / sid
+        tmp = None
+        if changed or new != name:
+            with tempfile.NamedTemporaryFile("wb", dir=folder, delete=False) as f:
+                f.write(data)
+                tmp = f.name
+        try:
+            with self.store.lock, closing(sqlite3.connect(self.store.path)) as db, db:
+                if new != name and new in self._names_held(db, sid):
+                    raise _Refused((409, f"{new} is taken.", "name"))
+                total = db.execute("SELECT bytes FROM sources WHERE id = ?", (sid,)).fetchone()[0]
+                if total + len(data) - len(old) > MAX_SOURCE:
+                    raise _Refused((413, "that would take the source past its cap"))
+                db.execute("UPDATE source_files SET name = ?, bytes = ? WHERE source = ? AND name = ?",
+                           (new, len(data), sid, name))
+                db.execute("UPDATE sources SET bytes = bytes + ? WHERE id = ?", (len(data) - len(old), sid))
+                row = db.execute("SELECT origin FROM source_calls WHERE source = ? AND name = ?",
+                                 (sid, name)).fetchone()
+                now = None
+                if row is not None:
+                    now = origin or ("edited" if changed else row[0])
+                    db.execute("UPDATE source_calls SET name = ?, file = ?, origin = ? "
+                               "WHERE source = ? AND name = ?", (new, new, now, sid, name))
+        except _Refused as no:
+            if tmp:
+                os.unlink(tmp)
+            return None, no.err
+        if tmp:
+            os.replace(tmp, folder / new)
+            if new != name:
+                (folder / name).unlink(missing_ok=True)
+        return {"name": new, "origin": now, "bytes": len(data)}, None
+
+    def clone_call(self, sid, name):
+        """A copy of one Call under `<stem>-copy` (then `-copy-2`, ...), its
+        file and, for a dynamic Call, its provenance -- origin, request,
+        status and when it was produced -- as they are. Returns ({name}, None),
+        or (None, error)."""
+        entry, err = self._calls_entry(sid)
+        if err:
+            return None, err
+        path = self.file_path(sid, name)
+        if path is None or not path.is_file():
+            return None, (404, f"{name} is not a Call of that Source")
+        stem, ext = os.path.splitext(name)
+        with self.store.lock, closing(sqlite3.connect(self.store.path)) as db:
+            held = self._names_held(db, sid)
+        n = 1
+        while True:
+            tail = "-copy" if n == 1 else f"-copy-{n}"
+            copy = stem[:120 - len(tail) - len(ext)] + tail + ext
+            if copy not in held:
+                break
+            n += 1
+        stored, err = self.add_file(sid, copy, path.read_bytes())
+        if err:
+            return None, err
+        with self.store.lock, closing(sqlite3.connect(self.store.path)) as db, db:
+            db.execute("INSERT INTO source_calls (source, name, origin, at, provider, request, status, error, file) "
+                       "SELECT source, ?, origin, at, provider, request, status, error, ? "
+                       "FROM source_calls WHERE source = ? AND name = ?", (stored, stored, sid, name))
+        return {"name": stored}, None
+
     def remove_calls(self, sid, names):
         """Calls out by name: a file-backed Call to the trash (Undo restores
         it), a failed Call's row dropped outright (it has no file). Returns
@@ -3871,6 +4123,24 @@ class Datasets:
             "SELECT name FROM datasets WHERE trash IS NULL AND id IS NOT ? AND workspace = ?",
             (but, workspace_of(self.store)))}
 
+    def naming_item(self, sid, item) -> list:
+        """The names of this workspace's groups previewed against Source
+        [sid] whose cases name [item]: what renaming that item would break."""
+        out = []
+        with self.store.lock, self._connect() as db:
+            for r in db.execute("SELECT name, body, preview FROM datasets WHERE trash IS NULL "
+                                "AND workspace = ? AND preview IS NOT NULL ORDER BY name COLLATE NOCASE",
+                                (workspace_of(self.store),)):
+                try:
+                    ref, body = json.loads(r["preview"]), json.loads(r["body"])
+                except ValueError:
+                    continue
+                cases = body.get("cases") if isinstance(body, dict) else None
+                if isinstance(ref, dict) and ref.get("id") == sid and isinstance(cases, list) \
+                        and any(isinstance(c, dict) and c.get("item") == item for c in cases):
+                    out.append(r["name"])
+        return out
+
     def list(self) -> list:
         with self.store.lock, self._connect() as db:
             counts = self._counts(db)
@@ -4781,32 +5051,47 @@ class Pipelines:
         self.store._put(db, self.VERSIONS, target_ws, tv + 1, tbody, self._now())
 
 
-def make_thumbs(sid, name):
-    """JPEGs a browser can render, beside a stored file: a tile-size one
-    for every image type, and a full-size render for the formats a browser
-    cannot decode, whose zoom view has no original to show. Non-fatal by
-    design: a missing thumb is a blank tile, not a failed upload, and the
-    startup sweep clears an orphan on a later start. #33 #527"""
+def thumb_jobs(sid, name):
+    """The `magick` runs that make a stored file's thumbnails, each (argv,
+    out): a tile-size JPEG for every image type, and a full-size render for
+    the formats a browser cannot decode, whose zoom view has no original to
+    show. The paths are looked up here, in the request's own thread, since a
+    Source is found through the workspace bound to it. #33 #527"""
     if CONVERT is None or Path(name).suffix.lower() not in IMAGE_TYPES:
-        return
+        return []
+    jobs = []
     for full in (False, True):
         if full and Path(name).suffix.lower() not in THUMB_TYPES:
             continue
         path = SOURCES.file_path(sid, name)
         out = SOURCES.thumb_path(sid, name, full)
         if path is None or out is None:
-            return
+            return jobs
         size = FULL_SIZE if full else TILE_SIZE
-        out.parent.mkdir(parents=True, exist_ok=True)
-        try:
-            subprocess.run([CONVERT, str(path), "-auto-orient",
-                            "-thumbnail", f"{size}x{size}>",
-                            "-quality", str(FULL_QUALITY if full else TILE_QUALITY),
-                            str(out)],
-                           timeout=30, stdout=subprocess.DEVNULL,
-                           stderr=subprocess.DEVNULL, check=True)
-        except (subprocess.SubprocessError, OSError):
-            out.unlink(missing_ok=True)
+        jobs.append(([CONVERT, str(path), "-auto-orient",
+                      "-thumbnail", f"{size}x{size}>",
+                      "-quality", str(FULL_QUALITY if full else TILE_QUALITY),
+                      str(out)], out))
+    return jobs
+
+
+def run_thumb(job):
+    """One thumbnail. Non-fatal by design: a missing thumb is a blank tile,
+    not a failed upload, and the startup sweep clears an orphan on a later
+    start."""
+    argv, out = job
+    out.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        subprocess.run(argv, timeout=30, stdout=subprocess.DEVNULL,
+                       stderr=subprocess.DEVNULL, check=True)
+    except (subprocess.SubprocessError, OSError):
+        out.unlink(missing_ok=True)
+
+
+def make_thumbs(sid, name):
+    """A stored file's thumbnails, made now (thumb_jobs)."""
+    for job in thumb_jobs(sid, name):
+        run_thumb(job)
 
 
 # ---- Packs ------------------------------------------------------------------
@@ -4877,7 +5162,9 @@ def pack_requires_problem(manifest: dict, plugins: set) -> str:
 def read_pack(data: bytes):
     """A pack's zip read and checked whole: (pack, None) or (None, why). The
     pack is {manifest, datasets: [(key, name, body, raw)], pipelines:
-    [(key, doc)], presets: [...], sources: {name: [(file, bytes)]}}."""
+    [(key, doc)], presets: [...], sources: {name: [(file, bytes)]}, source_meta:
+    {name: {name, type, config}}} -- a Source's meta from its folder's
+    `source.json`, or the folder's name as a File Library."""
     try:
         zf = zipfile.ZipFile(io.BytesIO(data))
     except zipfile.BadZipFile:
@@ -4906,7 +5193,8 @@ def read_pack(data: bytes):
     for k in ("name", "packVersion"):
         if not isinstance(manifest.get(k), str) or not manifest[k].strip():
             return None, f"a pack's manifest needs a {k}"
-    pack = {"manifest": manifest, "datasets": [], "pipelines": [], "presets": [], "sources": {}}
+    pack = {"manifest": manifest, "datasets": [], "pipelines": [], "presets": [], "sources": {}, "source_meta": {}}
+    declared = {}
     for name in sorted(names):
         parts = name.split("/")
         if name == "manifest.json":
@@ -4949,21 +5237,86 @@ def read_pack(data: bytes):
                     or not (isinstance(doc.get("jobs"), list) or isinstance(doc.get("chains"), list))):
                 return None, f"{name} is not a pipeline document the lab reads"
             pack["pipelines"].append((parts[1][:-5], doc))
+        elif len(parts) == 3 and parts[0] == "sources" and parts[2] == PACK_SOURCE_META:
+            src = source_name(parts[1])
+            meta, why = load(name)
+            if why:
+                return None, why
+            if src is None or not isinstance(meta, dict):
+                return None, f"{name} is not a Source's {PACK_SOURCE_META}"
+            declared[src] = meta
         elif len(parts) == 3 and parts[0] == "sources":
             src, file = source_name(parts[1]), source_name(parts[2])
-            if src is None or file is None or Path(file).suffix.lower() not in FILE_TYPES:
+            if src is None or file is None:
                 return None, f"{name} is not a file a Source takes"
             if names[name].file_size > MAX_FILE:
                 return None, f"{name} is over the cap for a file"
             pack["sources"].setdefault(src, []).append((file, zf.read(name)))
         else:
             return None, f"{name} is not something a pack holds"
-    for src, files in pack["sources"].items():
+    for src in sorted(set(pack["sources"]) | set(declared)):
+        meta, why = pack_source_meta(src, declared.get(src))
+        if why:
+            return None, why
+        pack["source_meta"][src] = meta
+        files = pack["sources"].setdefault(src, [])
+        entry = source_entry(meta["type"], meta["config"]) or {}
+        takes, take = entry.get("uploads") or {}, entry.get("take")
+        for i, (file, blob) in enumerate(files):
+            if Path(file).suffix.lower() not in takes:
+                return None, f"sources/{src}/{file} is not a file a Source takes"
+            # A shipped Call is checked as any other is: a token refuses the
+            # pack, and a secret's shape is redacted before it is kept.
+            if take is not None:
+                blob, err = take(file, blob)
+                if err:
+                    return None, f"sources/{src}/{file}: {err[1]}"
+                files[i] = (file, blob)
         if sum(len(b) for _, b in files) > MAX_SOURCE:
             return None, f"the Source {src} is over the cap for a Source"
     return pack, None
 
 
+# A pack Source's own meta, beside its files: {name?, type?, config?}.
+PACK_SOURCE_META = "source.json"
+
+
+def pack_source_meta(folder, meta):
+    """A pack Source's {name, type, config} from its folder's source.json (or
+    None: a File Library named after the folder), or (None, why). A pack may
+    carry a File Library or a dynamic Source whose provider pulls with no key
+    and is enrolled here -- the line a plugin's provider is held to
+    (docs/packs.md); anything else refuses the pack whole."""
+    meta = meta or {}
+    at = f"sources/{folder}/{PACK_SOURCE_META}"
+    unknown = set(meta) - {"name", "type", "config"}
+    if unknown:
+        return None, f"{at} holds {sorted(unknown)[0]}, which a pack Source does not"
+    name, err = Sources._name(meta.get("name", folder))
+    if err:
+        return None, f"{at}: {err[1]}"
+    kind = meta.get("type", DEFAULT_SOURCE_TYPE)
+    config = meta.get("config")
+    if kind == DEFAULT_SOURCE_TYPE:
+        if config is not None:
+            return None, f"{at}: a File Library takes no config"
+        return {"name": name, "type": kind, "config": None}, None
+    if not (SOURCE_TYPES.get(kind) or {}).get("providers"):
+        return None, f"{at}: a pack carries a File Library or a dynamic Source, not {kind!r}"
+    provider = config.get("provider") if isinstance(config, dict) else None
+    entry = SOURCE_PROVIDERS.get(provider)
+    if entry is None:
+        return None, f"{at}: the lab has no provider {provider!r}"
+    if entry.get("tier") != "pull" or entry.get("keyed") or config.get("connection"):
+        return None, f"{at}: a pack's dynamic Source pulls with no key, and {entry.get('label', provider)} does not"
+    if not provider_enrolled(entry):
+        return None, f"{at}: this lab does not enrol {entry.get('label', provider)}"
+    _, err = Sources._checked(kind, config)
+    if err:
+        return None, f"{at}: {err[1]}"
+    return {"name": name, "type": kind, "config": config}, None
+
+
 class Packs:
     """What each installed pack made, so it can be updated and removed."""
 
@@ -5098,22 +5451,41 @@ class Packs:
             made = {}
             # Sources first, then datasets: a pipeline names both.
             src_ids = {}
+            thumbs = []
             for name, files in pack["sources"].items():
+                meta = pack["source_meta"][name]
                 sid = owned.get(("source", name))
-                if sid and SOURCES.get(sid):
-                    old = [f["name"] for f in SOURCES.get(sid)["files"]]
+                have = SOURCES.get(sid) if sid else None
+                # An update keeps the Source's name, so one renamed here, or
+                # by a later pack, is not renamed back. Another kind is
+                # another Source.
+                if have and have.get("type") == meta["type"]:
+                    old = [f["name"] for f in have["files"]]
                     if old:
                         SOURCES.remove_files(sid, old)
+                    if meta["config"] is not None:
+                        SOURCES.update(sid, {"config": meta["config"]})
                 else:
                     taken = {s["name"] for s in SOURCES.list()}
-                    src, _ = SOURCES.create(unique_dataset_name(name, taken))
+                    src, _ = SOURCES.create(unique_dataset_name(meta["name"], taken), meta["type"], meta["config"])
                     sid = src["id"]
                 for file, blob in files:
                     stored, err = SOURCES.add_file(sid, file, blob)
-                    if not err:
-                        make_thumbs(sid, stored)
+                    if err:
+                        continue
+                    thumbs += thumb_jobs(sid, stored)
+                    # A dynamic Source's files are Calls: the pack's are its
+                    # snapshot, fetched when the pack was made.
+                    if meta["type"] != DEFAULT_SOURCE_TYPE:
+                        cfg = meta["config"]
+                        request = {"url": cfg["url"], "method": cfg.get("method") or "GET"} if cfg.get("url") else None
+                        SOURCES._record_call(sid, stored, "snapshot", cfg.get("provider"), request, None, None, stored)
                 src_ids[name] = sid
                 made[("source", name)] = sid
+            # The demo pack installs as the server starts, before it answers,
+            # and one `magick` at a time was most of that wait.
+            with ThreadPoolExecutor(max_workers=min(4, os.cpu_count() or 1)) as pool:
+                list(pool.map(run_thumb, thumbs))
             ds_ids = {}
             cuts = []   # (kind, id, the document as it was), kept before it changes
             for key, name, body, raw, preview in pack["datasets"]:
@@ -5170,7 +5542,8 @@ class Packs:
                     entry = next((w for w in body["list"] if w.get("id") == wid), None) if wid else None
                     if entry:
                         cuts.append(("pipeline", wid, entry.get("work")))
-                        entry["work"] = doc
+                        # Its name is the lab's now, as a dataset's is.
+                        entry["work"] = {**doc, "name": entry.get("name") or doc.get("name")}
                     else:
                         wid = "w" + secrets.token_hex(6)
                         name = unique_dataset_name(doc.get("name") or key, {w.get("name") for w in body["list"]})
@@ -6942,7 +7315,7 @@ def bundle_problems(files, keys=()):
         for key in keys:
             key = str(key or "").strip()
             if len(key) >= 4 and key in text:
-                return f"{path} holds a Target profile's key, and a key never leaves the lab"
+                return f"{path} holds a connection's key, and a key never leaves the lab"
         if TOKEN_SHAPE.search(text):
             return f"{path} holds a token, and a key never leaves the lab"
         m = BUNDLE_KEY_FIELD.search(text)
@@ -6965,7 +7338,7 @@ def build_bundle(payload):
         return None, (400, "a bundle holds pipeline.yaml and profiles.yaml")
     stored = []
     if STORE is not None:
-        stored = ((STORE.all().get("promptlab.profiles") or {}).get("body") or {}).get("list") or []
+        stored = ((STORE.all().get("promptlab.connections") or {}).get("body") or {}).get("list") or []
     why = bundle_problems(files, [p.get("key") for p in stored if isinstance(p, dict)])
     if why:
         return None, (400, why)
@@ -6994,10 +7367,12 @@ def build_bundle(payload):
 
 
 # Shared-by-choice enforcement (docs/workspaces.md): the one sentence the Run
-# bar turns into a Share link, and the profiles that earn it -- the run's
-# Target profiles not shared with workspace `ws`. A local profile reaches
-# nothing, so sharing does not gate it. Keyed by the run's profiles table,
-# whose keys are the profile ids the share set is written against.
+# bar turns into a Share link, and the connections that earn it -- the AI
+# Connections the run resolved to that are not shared with workspace `ws`,
+# a profile's own connection included where it answers on one. A local
+# connection reaches nothing, so sharing does not gate it. A share set is
+# written against the id a Target profile had, which its connection keeps
+# (#445), so a "profile" row names the connection.
 def not_shared_sentence(names, wsname: str) -> str:
     verb = "is" if len(names) == 1 else "are"
     return f"{', '.join(names)} {verb} not shared with {wsname}."
@@ -7007,12 +7382,16 @@ def unshared_profiles(run: dict, ws):
     table = run.get("profiles") if isinstance(run, dict) else None
     if not isinstance(table, dict) or STORE is None:
         return []
-    out = []
-    for pid, conn in table.items():
+    out, seen = [], set()
+    for key, conn in table.items():
         if isinstance(conn, dict) and conn.get("type") in LOCAL_CONNECTIONS:
             continue
-        if not STORE.shared("profile", pid, ws):
-            out.append({"id": pid, "name": (isinstance(conn, dict) and conn.get("name")) or pid})
+        cid = answer_connection(key, conn)
+        if cid in seen:
+            continue
+        seen.add(cid)
+        if not STORE.shared("profile", cid, ws):
+            out.append({"id": cid, "name": (isinstance(conn, dict) and conn.get("name")) or cid})
     return out
 
 
@@ -7029,28 +7408,38 @@ def worker_destinations(run: dict):
         return None, not_shared_sentence([b["name"] for b in bad], STORE.workspace_name(ws))
     stored = []
     if STORE is not None:
-        doc = STORE.all().get("promptlab.profiles") or {}
+        doc = STORE.all().get("promptlab.connections") or {}
         stored = (doc.get("body") or {}).get("list") or []
-    env = {}
-    for pid, conn in table.items():
+    # One variable a connection, however many targets or profiles share it --
+    # and never two connections one variable, whichever path the run came by:
+    # a stored snapshot is not checked again as a submit is (run_problems),
+    # and the runner reads each connection's key from its slug's variable, so
+    # the second would send the first one's key to its own address.
+    env, spelt = {}, {}
+    for key, conn in table.items():
+        pid = answer_connection(key, conn)
         name = conn.get("name") or pid
+        var = key_var(pid, conn.get("slug") if isinstance(conn.get("slug"), str) else None)
+        if var in spelt and spelt[var][0] != pid:
+            return None, f"Connections {spelt[var][1]} and {name} both take their key from ${var}"
+        spelt[var] = (pid, name)
         if isinstance(conn, dict) and conn.get("type") in LOCAL_CONNECTIONS:
             continue
         base = api_base(str(conn.get("url") or "")) or api_base(OLLAMA)
         why = allowed(base, "")
         if why:
-            return None, f"Target profile {name}: {why}"
+            return None, f"Connection {name}: {why}"
         profile = next((p for p in stored if isinstance(p, dict) and p.get("id") == pid), None)
         if profile is None:
-            return None, f"Target profile {name} not found"
+            return None, f"Connection {name} not found"
         key = str(profile.get("key") or "").strip()
         if key:
             if not header_safe(key):
-                return None, f"Target profile {name} has a key that cannot go in a header"
+                return None, f"Connection {name} has a key that cannot go in a header"
             why = allowed(base, key)
             if why:
-                return None, f"Target profile {name}: {why}"
-            env[key_var(pid, conn.get("slug"))] = key
+                return None, f"Connection {name}: {why}"
+            env[var] = key
     return env, None
 
 
@@ -7078,11 +7467,16 @@ def worker_destinations(run: dict):
 # inline Drop items / Reject rules migrate into a private one (§18, #339).
 # 15: every cleaning step is a filter -- a job's Tidy / Drop prompt echoes /
 # Remove duplicates / Keep first / Case modifiers and its List `preamble`
-# setting migrate into before/after-Read-as filter sets (§18, #405).
-PIPELINE_VERSION = 15
+# setting migrate into Pre-/Post-format filter sets (§18, #405).
+# 16: a target names an AI Connection and, optionally, a Connection Profile,
+# where it named one Target profile; the run's table is keyed by the pair
+# (answer_key), each entry naming the connection whose key it takes (#445).
+# 17: an HTTP Request target has no `api` of its own; its job's flow step's
+# is the one its body is read by (#477).
+PIPELINE_VERSION = 17
 # What a stored run may be: the current version, and the ones evals-core.ts's
 # upgradePipeline reads. A new submission is upgraded to the current one.
-READABLE_VERSIONS = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
+READABLE_VERSIONS = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17)
 TARGET_CAP = 4
 # Target steps whose words the Prompt library does not record as a use: they
 # ask no model (evals-core.ts's STEP_TYPES.echo).
@@ -7115,7 +7509,7 @@ CONNECTION_TYPES = {
     "echo": (),
     # An HTTP endpoint (evals-core.ts): an address and how its key travels; an
     # HTTP Request step builds the whole request.
-    "http": ("auth", "headers", "testPath"),
+    "http": ("auth", "headers", "testPath", "requestFormat"),
     "ollama": ("seed", "nPredict", "temperature", "repeatPenalty"),
     "ollama-cloud": ("seed", "nPredict", "temperature", "repeatPenalty"),
     "openai-compatible": ("temperature", "nPredict"),
@@ -7133,11 +7527,88 @@ BUILTIN_CONNECTION_TYPES = dict(CONNECTION_TYPES)
 BUILTIN_LOCAL = set(LOCAL_CONNECTIONS)
 BUILTIN_CHAT_PATHS = dict(CONNECTION_CHAT_PATHS)
 BUILTIN_AUTH = dict(CONNECTION_AUTH)
-CONNECTION_FIELDS = ("name", "slug", "url", "model", "type", "temperature", "px", "format",
+CONNECTION_FIELDS = ("name", "slug", "connection", "url", "model", "type", "temperature", "px", "format",
                      "quality", "options")
 LOOKS_LIKE_A_KEY = re.compile(r"^(?:api[-_]?)?key$|^(?:authorization|bearer|secret|password|token)$",
                               re.IGNORECASE)
 PROFILE_ID = re.compile(r"[A-Za-z0-9]+(?:-[A-Za-z0-9]+)?")
+# A run's table key (evals-core.ts answerKey): a connection's id, then a dot
+# and its profile's id -- or nothing, for none -- or a grader's bare id.
+ANSWER_KEY = re.compile(r"[A-Za-z0-9]+(?:-[A-Za-z0-9]+)?(?:\.(?:[A-Za-z0-9]+(?:-[A-Za-z0-9]+)?)?)?")
+
+
+def answer_key(connection: str, profile=None) -> str:
+    return f"{connection}.{profile or ''}"
+
+
+def answer_connection(key, conn) -> str:
+    """The AI Connection a run's entry [key] takes its key from: the one it
+    names, or -- a run from before version 16 -- the key's own id."""
+    cid = conn.get("connection") if isinstance(conn, dict) else None
+    return cid if isinstance(cid, str) and cid else str(key).split(".", 1)[0]
+
+
+def run_answer(table, key):
+    """What a run's table holds for [key] (evals-core.ts runAnswer): its own
+    entry, or -- a run from before version 16, keyed by Target profile id --
+    the connection's, where the key names no profile."""
+    if key in table:
+        return table[key]
+    head, dot, tail = key.partition(".")
+    return table.get(head) if dot and not tail else None
+
+
+# What an AI Connection keeps of a Target profile (evals-core.ts
+# AI_CONNECTION_FIELDS), beside the settings of its type that say how it is
+# reached (CONNECTION_SCOPED, the registry's `scope: "connection"`); every
+# other setting set is a Connection Profile's. Mirrored, and held to the
+# core's splitProfile, by proxy-check.py.
+AI_CONNECTION_FIELDS = ("id", "name", "slug", "type", "url", "key", "model", "profile")
+CONNECTION_SCOPED = {"http": ("auth", "headers", "testPath", "requestFormat")}
+# evals-core.ts REPLY_TOKENS_BEFORE, and the setting of each type that sent it.
+REPLY_TOKENS_BEFORE = "160"
+REPLY_TOKENS_SETTING = {"openai-compatible": "nPredict", "llama.cpp": "nPredict", "anthropic": "maxTokens"}
+
+
+def pin_reply_tokens(p):
+    """evals-core.ts pinReplyTokens: a profile with no Reply tokens setting, of
+    a type that sent the cap, has the cap it was sending written in. The split
+    keeps no blank setting, so after it nothing could tell such a profile from
+    one made since; it is pinned here, before."""
+    key = REPLY_TOKENS_SETTING.get(str(p.get("type")))
+    return p if not key or key in p else {**p, key: REPLY_TOKENS_BEFORE}
+
+
+def split_profile(p):
+    """A Target profile as (AI Connection, Connection Profile or None): the
+    connection keeps its id, key and address; a profile, stamped with the id
+    it came from, holds every other setting it set (its reply-token cap
+    pinned, pin_reply_tokens)."""
+    p = pin_reply_tokens(p)
+    scoped = CONNECTION_SCOPED.get(p.get("type"), ())
+    conn, settings = {}, {}
+    for k, v in p.items():
+        if k in AI_CONNECTION_FIELDS or k in scoped:
+            conn[k] = v
+        elif v is not None and v != "":
+            settings[k] = v
+    if not settings:
+        return conn, None
+    pid = str(p.get("id") or "")
+    return conn, {"id": pid, "name": str(p.get("name") or ""), "fromProfile": pid, **settings}
+
+
+def split_profiles(listed):
+    """A profiles store's list as (connections, connection profiles)."""
+    connections, profiles = [], []
+    for p in listed if isinstance(listed, list) else []:
+        if not isinstance(p, dict):
+            continue
+        conn, prof = split_profile(p)
+        connections.append(conn)
+        if prof is not None:
+            profiles.append(prof)
+    return connections, profiles
 # evals-core.ts's SLUG and SLUG_MAX: what a key's variable is spelt from.
 PROFILE_SLUG = re.compile(r"[a-z0-9]+(?:-[a-z0-9]+)*")
 SLUG_MAX = 32
@@ -7195,14 +7666,7 @@ def http_endpoint_test(payload, key):
             name, value = part.split(":", 1)
             if name.strip():
                 headers[name.strip()] = value.strip()
-    if key:
-        how = str(settings.get("auth") or "bearer")
-        if how == "x-api-key":
-            headers["x-api-key"] = key
-        elif how == "api-key":
-            headers["api-key"] = key
-        elif how != "none":
-            headers["Authorization"] = "Bearer " + key
+    headers.update(http_key_header(settings.get("auth"), key))
     if not all(header_safe(v) for v in headers.values()):
         return "", {}, "A header of this profile has characters that cannot be sent."
     return origin + (path if path.startswith("/") else "/" + path), headers, ""
@@ -7218,7 +7682,7 @@ def connection_problems(pid, conn, at, bad):
     if slug is not None and not (isinstance(slug, str) and PROFILE_SLUG.fullmatch(slug) and len(slug) <= SLUG_MAX):
         bad.append(f"{at}: slug has to be lowercase letters and digits, with hyphens between, at most {SLUG_MAX}")
         slug = None
-    var = key_var(pid, slug)
+    var = key_var(answer_connection(pid, conn), slug)
     _fields(conn, at, CONNECTION_FIELDS, bad, var)
     ctype = conn.get("type")
     if not isinstance(ctype, str) or ctype not in CONNECTION_TYPES:
@@ -7364,17 +7828,23 @@ def run_problems(run):
     spelt = {}
     for pid, conn in table.items():
         at = f"profile {pid}"
-        if not PROFILE_ID.fullmatch(str(pid)):
+        if not ANSWER_KEY.fullmatch(str(pid)):
             bad.append(f"{at}: an id is letters and digits, with at most one hyphen")
             continue
         if not isinstance(conn, dict):
             bad.append(f"{at} has to be an object")
             continue
-        # Two profiles spelling one variable would hand one the other's key.
-        var = key_var(pid, conn.get("slug") if isinstance(conn.get("slug"), str) else None)
-        if var in spelt:
-            bad.append(f"profiles {spelt[var]} and {pid} both take their key from ${var}")
-        spelt[var] = pid
+        if conn.get("connection") is not None and not (
+                isinstance(conn["connection"], str) and PROFILE_ID.fullmatch(conn["connection"])):
+            bad.append(f"{at}: connection has to be an AI Connection's id")
+            continue
+        # Entries sharing a connection share its key; two connections
+        # spelling one variable would hand one the other's.
+        cid = answer_connection(pid, conn)
+        var = key_var(cid, conn.get("slug") if isinstance(conn.get("slug"), str) else None)
+        if var in spelt and spelt[var] != cid:
+            bad.append(f"profiles {spelt[var]} and {cid} both take their key from ${var}")
+        spelt[var] = cid
         connection_problems(pid, conn, at, bad)
     targets = run.get("targets")
     if not isinstance(targets, list) or not 1 <= len(targets) <= TARGET_CAP:
@@ -7394,10 +7864,17 @@ def run_problems(run):
         if not isinstance(steps, list) or len(steps) != len(jobs):
             bad.append(f"{at} has to have one step per job")
             continue
-        # A target with no profile is one whose steps ask none (Echo) or each
-        # name their own; which steps need one is the core's to judge.
-        refs = ([t["profile"]] if t.get("profile") is not None else []) + [
-            st.get("profile") for st in steps if isinstance(st, dict) and st.get("profile") is not None]
+        # A target with no connection is one whose steps ask none (Echo) or
+        # each name their own; which steps need one is the core's to judge.
+        # Each pair named -- the target's, a step's own -- is one the run
+        # carries (evals-core.ts targetAnswerOf).
+        def pair(o, base=None):
+            c = o.get("connection") if o.get("connection") is not None else (base or {}).get("connection")
+            p = o.get("profile")
+            return c, p
+        refs = [pair(t)] if t.get("connection") is not None or t.get("profile") is not None else []
+        refs += [pair(st, t) for st in steps
+                 if isinstance(st, dict) and (st.get("connection") is not None or st.get("profile") is not None)]
         # Whether the words may be blank -- Echo answering from the item --
         # is the core's to judge, and the worker refuses the run in its words.
         for k, step in enumerate(steps):
@@ -7408,9 +7885,11 @@ def run_problems(run):
             elif step.get("from") is not None and not (
                     isinstance(step["from"], dict) and isinstance(step["from"].get("id"), str)):
                 bad.append(f"{at}, job {k + 1} names the prompt it was picked from without an id")
-        for ref in refs:
-            if not isinstance(ref, dict) or ref.get("id") not in table:
-                bad.append(f"{at} names a Target profile the run does not carry")
+        for c, p in refs:
+            if (not isinstance(c, dict) or not isinstance(c.get("id"), str)
+                    or (p is not None and not (isinstance(p, dict) and isinstance(p.get("id"), str)))
+                    or run_answer(table, answer_key(c["id"], p["id"] if p else None)) is None):
+                bad.append(f"{at} names a connection the run does not carry")
     content = content_of(run)
     kind = content.get("type") if isinstance(content, dict) else None
     if kind == "source":
@@ -7747,7 +8226,7 @@ class Handler(BaseHTTPRequestHandler):
                 return self._send(404, b"not found", "text/plain")
             return self._json(200, {"plugins": PLUGINS.list(), "cap": PLUGIN_CAP})
         if path == "/api/connections/shares":
-            # Which workspaces may use each Target profile and Account
+            # Which workspaces may use each AI Connection and Account
             # (docs/workspaces.md): the share sets the Connections menus read.
             # Keyed by "<kind>:<id>", workspace ids and the sentinels, no key.
             if STORE is None:
@@ -7773,6 +8252,16 @@ class Handler(BaseHTTPRequestHandler):
                 return self._send(404, b"not found", "text/plain")
             ctype = TYPES[".json"] if f.suffix in (".json", ".map") else TYPES[".js"]
             return self._send(200, f.read_bytes(), ctype, (("Cache-Control", "no-store"),))
+        if path == "/api/lab-export":
+            # The lab's settings as a file (docs/lab-export.md): every
+            # workspace's entry, or ?workspace=<slug>'s alone. No key.
+            if STORE is None or WORKSPACES is None:
+                return self._send(404, b"not found", "text/plain")
+            only = (urllib.parse.parse_qs(urllib.parse.urlsplit(self.path).query).get("workspace") or [None])[0]
+            out = lab_export(only)
+            if out is None:
+                return self._json(404, {"error": f"no workspace at /w/{only}"})
+            return self._json(200, out)
         if path == "/api/packs":
             if PACKS is None:
                 return self._send(404, b"not found", "text/plain")
@@ -8125,6 +8614,22 @@ class Handler(BaseHTTPRequestHandler):
             return self._filter_sets_post(path)
         if path == "/api/copy-move" or path.startswith("/api/copy-move/"):
             return self._copy_move_post(path)
+        if path == "/api/lab-import":
+            # A lab file into this lab (docs/lab-export.md), adding what it
+            # lacks. `keys` is what `evals-lab import` read from its own
+            # $EVALSLAB_API_KEY_<SLUG> variables; the page sends none.
+            if STORE is None or WORKSPACES is None:
+                return self._send(404, b"not found", "text/plain")
+            payload = self._payload()
+            if payload is None:
+                return self._json(400, {"error": "an import is {lab, keys?} as JSON"})
+            keys = payload.get("keys") if isinstance(payload.get("keys"), dict) else {}
+            keys = {k: v for k, v in keys.items()
+                    if isinstance(k, str) and k.startswith("EVALSLAB_API_KEY_") and isinstance(v, str)}
+            said, err = lab_import(payload.get("lab"), keys)
+            if err:
+                return self._json(err[0], {"error": err[1]})
+            return self._json(200, {"said": said})
         if path == "/api/packs" or path.startswith("/api/packs/"):
             return self._packs_post(path)
         if path == "/api/workspaces" or path.startswith("/api/workspaces/"):
@@ -8283,8 +8788,8 @@ class Handler(BaseHTTPRequestHandler):
         else None. Only a held key (KEY_HELD<id>) names a stored profile; a key
         typed into the Setup form is a connection not yet saved, so nothing
         gates it. This is the relay/Test seam, beside worker_destinations' run
-        seam -- the two places a connection resolves to a key, so the two
-        places sharing is enforced. The caller writes the 403: a helper that
+        seam and connection_auth's API Source seam -- the places a connection
+        resolves to a key, so the places sharing is enforced. The caller writes the 403: a helper that
         answers here would send the body and still fall through to the proxy."""
         if STORE is None:
             return None
@@ -8480,7 +8985,7 @@ class Handler(BaseHTTPRequestHandler):
                     if revs[name] is None:
                         return self._json(400, {"error": f"{name!r} is not in that Source"})
                 content["revs"] = revs
-        # A profile not shared with this workspace blocks the run with the
+        # A connection not shared with this workspace blocks the run with the
         # sentence the Run bar shows and the connections it names, so its Share
         # link can grant them at once (docs/workspaces.md).
         ws = workspace_of(STORE) if STORE is not None else None
@@ -8551,6 +9056,8 @@ class Handler(BaseHTTPRequestHandler):
         if produce is None:
             return None, None, (400, "that provider cannot be produced from on the server")
         result = produce(cfg)
+        if result.get("refused"):
+            return None, None, result["refused"]
         content = result.get("content")
         if content is None:
             return None, None, (502, "the live fetch produced nothing: " + (result.get("error") or "unknown"))
@@ -9001,6 +9508,24 @@ class Handler(BaseHTTPRequestHandler):
                 code, message = err
                 return self._json(code, {"error": message})
             return self._json(200, {"trash": token})
+        if len(parts) == 6 and parts[4] == "calls" and parts[5] in ("edit", "clone"):
+            payload = self._payload() or {}
+            name = source_name(payload.get("name"))
+            if name is None:
+                return self._json(400, {"error": "a call name is not accepted here"})
+            if parts[5] == "clone":
+                call, err = SOURCES.clone_call(parts[3], name)
+            else:
+                to = payload.get("to")
+                if to is not None and not isinstance(to, str):
+                    return self._json(400, {"error": "that name is not accepted here", "field": "name"})
+                sid = parts[3]
+                call, err = SOURCES.edit_call(
+                    sid, name, to, payload.get("content"), payload.get("origin"),
+                    named_by=(lambda item: DATASETS.naming_item(sid, item)) if DATASETS else None)
+            if err:
+                return self._json(err[0], {"error": err[1], **({"field": err[2]} if len(err) > 2 else {})})
+            return self._json(201 if parts[5] == "clone" else 200, {"call": call})
         if len(parts) == 5 and parts[4] == "copy":
             payload = self._payload() or {}
             source, err = SOURCES.copy_files(parts[3], payload.get("from"),
@@ -9150,6 +9675,252 @@ class Handler(BaseHTTPRequestHandler):
             return self._json(502, {"error": f"{url}: {e.reason}"})
 
 
+# ---- Lab export and import (docs/lab-export.md) -----------------------------
+#
+# A lab's settings as one file: its AI Connections, Connection Profiles and
+# grader, and its workspaces, so a new lab can start as another one is set up
+# -- by Setup › Workspaces › Data, by `evals-lab export`/`import`, or on every
+# start with LAB_IMPORT (a demo lab that keeps no data). An import only adds:
+# what the lab already has, by a connection's or profile's id and a
+# workspace's address, is left as it is, so importing twice changes nothing
+# and a lab that keeps its data keeps its edits. The file never holds a key
+# (#258): each comes from $EVALSLAB_API_KEY_<SLUG>, as a CI run's does, and a
+# key that comes is the connection's from then on, a rotated one included.
+# A connection carries its share set (`shares`, workspace slugs and the
+# sentinels; absent is All) from version 2: version 1 carried none, so an
+# import reads its connections as All.
+
+LAB_FORMAT = "evals-lab/lab"
+LAB_VERSIONS = (1, 2)
+LAB_FIELDS = ("format", "version", "exportedAt", "connections", "connectionProfiles", "grader", "workspaces")
+
+
+def lab_export(only=None) -> dict:
+    """The lab's settings as a file, every workspace's entry or the one at
+    /w/[only]; None when no workspace is at that address. One workspace's file
+    carries only what that workspace can use: the connections shared with it,
+    the profiles over them (or over none) and the grader if it is one of them,
+    each share set narrowed to that workspace, the one the file names, and
+    *new kept where the connection has it. A connection shared only with
+    workspaces in the trash is usable nowhere, and an empty share set would
+    import as All, so it is left out, and out as the grader too."""
+    body = (STORE.all().get("promptlab.connections") or {}).get("body") or {}
+    profiles = (STORE.all().get("promptlab.connectionProfiles") or {}).get("body") or {}
+    every = WORKSPACES.list()
+    spaces = [w for w in every if not only or w["slug"] == only]
+    if only and not spaces:
+        return None
+    slug_of = {w["id"]: w["slug"] for w in (spaces if only else every)}
+    rows = STORE.shares()
+    conns, nowhere = [], set()
+    for c in body.get("list") or []:
+        if not isinstance(c, dict) or (only and not STORE.shared("profile", str(c.get("id") or ""), spaces[0]["id"])):
+            continue
+        entry = {k: v for k, v in c.items() if k not in ("key", "shares")}
+        held = rows.get(f"profile:{c.get('id')}")
+        if held and SHARE_ALL not in held:
+            entry["shares"] = [w if w == SHARE_NEW else slug_of[w] for w in held if w == SHARE_NEW or w in slug_of]
+            if not entry["shares"]:
+                nowhere.add(c.get("id"))
+                continue
+        conns.append(entry)
+    kept = {c["id"] for c in conns}
+
+    def over_kept(p):
+        ref = p.get("connection")
+        return not ref or not only or (isinstance(ref, dict) and ref.get("id") in kept)
+    out = {"format": LAB_FORMAT, "version": LAB_VERSIONS[-1],
+           "exportedAt": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+           "connections": conns,
+           "connectionProfiles": [p for p in profiles.get("list") or [] if isinstance(p, dict) and over_kept(p)],
+           "workspaces": [{"slug": w["slug"], "name": w["name"], **({"archived": True} if w["archived"] else {})}
+                          for w in spaces]}
+    if (isinstance(body.get("grader"), str) and body["grader"] and body["grader"] not in nowhere
+            and (not only or body["grader"] in kept)):
+        out["grader"] = body["grader"]
+    return out
+
+
+def _keyless(entry, what):
+    """A sentence when [entry] holds a key, which a lab file never does."""
+    for k, v in entry.items():
+        if LOOKS_LIKE_A_KEY.match(k) and v not in ("", None):
+            return f"{what} holds a {k}; a lab file holds no key -- set ${key_var(entry['id'], entry.get('slug'))}"
+    return None
+
+
+def lab_problems(doc) -> str:
+    """Why [doc] is not a lab file this lab imports, or None. Checked whole
+    before anything is written, as a pack is."""
+    if not isinstance(doc, dict) or doc.get("format") != LAB_FORMAT:
+        return f"not a lab file: its format is not {LAB_FORMAT}"
+    if doc.get("version") not in LAB_VERSIONS:
+        return f"a lab file of version {doc.get('version')!r}; this lab reads {', '.join(map(str, LAB_VERSIONS))}"
+    extra = sorted(set(doc) - set(LAB_FIELDS))
+    if extra:
+        return f"a lab file holds no {', '.join(extra)}"
+    seen = set()
+    for i, c in enumerate(doc.get("connections") or []):
+        what = f"connection {i + 1}"
+        if not isinstance(c, dict) or not isinstance(c.get("id"), str) or not PROFILE_ID.fullmatch(c["id"]):
+            return f"{what} has no id of letters and digits"
+        what = f"connection {c['id']}"
+        if c["id"] in seen:
+            return f"{what} is listed twice"
+        seen.add(c["id"])
+        if not isinstance(c.get("name"), str) or not c["name"].strip():
+            return f"{what} has no name"
+        if c.get("type") not in CONNECTION_TYPES:
+            return f"{what} is of type {c.get('type')!r}, which this lab has no connection type for"
+        bad = next((k for k, v in c.items() if not isinstance(v, str) and k != "shares"), None)
+        if "shares" in c and doc["version"] < 2:
+            bad = "shares"
+        if bad:
+            return f"{what}'s {bad} is not text"
+        why = _keyless(c, what)
+        if why:
+            return why
+    seen = set()
+    for i, p in enumerate(doc.get("connectionProfiles") or []):
+        what = f"connection profile {i + 1}"
+        if not isinstance(p, dict) or not isinstance(p.get("id"), str) or not PROFILE_ID.fullmatch(p["id"]):
+            return f"{what} has no id of letters and digits"
+        what = f"connection profile {p['id']}"
+        if p["id"] in seen:
+            return f"{what} is listed twice"
+        seen.add(p["id"])
+        if not isinstance(p.get("name"), str) or not p["name"].strip():
+            return f"{what} has no name"
+        why = _keyless(p, what)
+        if why:
+            return why
+    if "grader" in doc and not isinstance(doc["grader"], str):
+        return "the grader is not a connection's id"
+    seen = set()
+    for i, w in enumerate(doc.get("workspaces") or []):
+        what = f"workspace {i + 1}"
+        if not isinstance(w, dict) or not isinstance(w.get("slug"), str) or not w["slug"]:
+            return f"{what} has no address"
+        if w["slug"] in seen:
+            return f"workspace {w['slug']} is listed twice"
+        seen.add(w["slug"])
+        if not isinstance(w.get("name"), str) or not w["name"].strip():
+            return f"workspace {w['slug']} has no name"
+        if Workspaces._slugify(w["slug"]) != w["slug"]:
+            return f"workspace {w['slug']}'s address is not one a lab makes: it would be {Workspaces._slugify(w['slug'])}"
+        fields = {"slug", "name"} | ({"archived"} if doc["version"] >= 2 else set())
+        if set(w) - fields:
+            return f"workspace {w['slug']} holds no {', '.join(sorted(set(w) - fields))}"
+        if "archived" in w and not isinstance(w["archived"], bool):
+            return f"workspace {w['slug']}'s archived is not true or false"
+    for k in ("connections", "connectionProfiles", "workspaces"):
+        if k in doc and not isinstance(doc[k], list):
+            return f"a lab file's {k} is a list"
+    # Workspaces before shares: a share names the file's workspaces or the lab's.
+    known = seen | ({w["slug"] for w in WORKSPACES.list()} if WORKSPACES is not None else set())
+    for c in doc.get("connections") or []:
+        if "shares" not in c:
+            continue
+        if not isinstance(c["shares"], list) or not all(isinstance(s, str) for s in c["shares"]):
+            return f"connection {c['id']}'s shares is a list of workspace addresses"
+        # No rows is All in the store, so an empty list would grant everywhere.
+        if not c["shares"]:
+            return (f"connection {c['id']}'s shares is empty; leave shares out for All, "
+                    "or name a workspace or *new")
+        lost = [s for s in c["shares"] if s not in (SHARE_ALL, SHARE_NEW) and s not in known]
+        if lost:
+            return f"connection {c['id']} is shared with {', '.join(lost)}, which neither the file nor this lab has"
+    return None
+
+
+def lab_import(doc, keys) -> tuple:
+    """[doc] into this lab, adding what it lacks; [keys] is where each
+    connection's key is looked up by its variable's name ($EVALSLAB_API_KEY_
+    <SLUG>) -- the server's environment as it starts, or what `evals-lab
+    import` sent. Returns (lines saying what happened, None) or (None, error).
+    No line holds a key."""
+    why = lab_problems(doc)
+    if why:
+        return None, (400, why)
+    said = []
+    # A file's address to this lab's workspace id; one added where the trash
+    # holds its address lands at the next free one, and its shares follow it.
+    wid_of = {w["slug"]: w["id"] for w in WORKSPACES.list()}
+    for w in doc.get("workspaces") or []:
+        if w["slug"] in wid_of:
+            continue
+        wid, err = WORKSPACES.create(w["name"], w["slug"])
+        wid_of[w["slug"]] = wid
+        if not err and w.get("archived"):
+            _, err = WORKSPACES.archive(wid)
+        if err:
+            return None, err
+        said.append(f"workspace {w['name']} added at /w/{WORKSPACES.get(wid)['slug']}"
+                    + (", archived" if w.get("archived") else ""))
+    for _ in range(3):
+        docs = STORE.all()
+        cur = docs.get("promptlab.connections") or {"version": 0, "body": None}
+        pcur = docs.get("promptlab.connectionProfiles") or {"version": 0, "body": None}
+        body = json.loads(json.dumps(cur["body"] or {"list": [], "at": ""}))
+        pbody = json.loads(json.dumps(pcur["body"] or {"list": []}))
+        conns = body.setdefault("list", [])
+        lines, changed, pchanged, added = [], False, False, []
+        for c in doc.get("connections") or []:
+            mine = next((x for x in conns if isinstance(x, dict) and x.get("id") == c["id"]), None)
+            if mine is None:
+                mine = {**{k: v for k, v in c.items() if k != "shares"}, "key": ""}
+                added.append(c)
+                conns.append(mine)
+                changed = True
+                lines.append(f"connection {c['name']} added")
+            key = str(keys.get(key_var(c["id"], c.get("slug"))) or "").strip()
+            if key and mine.get("key") != key:
+                if not header_safe(key):
+                    return None, (400, f"${key_var(c['id'], c.get('slug'))} cannot go in a header")
+                mine["key"] = key
+                changed = True
+                lines.append(f"connection {mine.get('name') or c['name']} takes its key from "
+                             f"${key_var(c['id'], c.get('slug'))}")
+        profs = pbody.setdefault("list", [])
+        for p in doc.get("connectionProfiles") or []:
+            if not any(isinstance(x, dict) and x.get("id") == p["id"] for x in profs):
+                profs.append(dict(p))
+                pchanged = True
+                lines.append(f"connection profile {p['name']} added")
+        if doc.get("grader") and not body.get("grader"):
+            body["grader"] = doc["grader"]
+            changed = True
+            lines.append(f"grader set to {doc['grader']}")
+        # Only an added connection takes the file's share set: one the lab had
+        # keeps its own, as everything else it had does. Set before the write,
+        # so the connection is never there and shared with All in between; a
+        # failed write puts back what the rows were, since its ids never landed.
+        before = STORE.shares()
+        for c in added:
+            if "shares" in c:
+                STORE.set_shares("profile", c["id"], [s if s in (SHARE_ALL, SHARE_NEW) else wid_of[s]
+                                                      for s in c["shares"]])
+        writes = {}
+        if changed:
+            body["at"] = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+            writes["promptlab.connections"] = {"version": cur["version"], "body": body}
+        if pchanged:
+            writes["promptlab.connectionProfiles"] = {"version": pcur["version"], "body": pbody}
+        if not writes:
+            break
+        # Global documents, so the default workspace's write reaches them.
+        ok, _ = STORE.write(writes, STORE.default_ws)
+        if ok:
+            break
+        for c in added:
+            if "shares" in c:
+                STORE.set_shares("profile", c["id"], before.get(f"profile:{c['id']}") or [])
+    else:
+        return None, (409, "the lab's connections kept changing while they were imported; import again")
+    said += lines
+    return said or ["nothing to add"], None
+
+
 def main():
     if not (WEB_DIST / "index.html").is_file():
         raise SystemExit(f"no {WEB_DIST / 'index.html'} -- the page is built from web/: "
@@ -9161,6 +9932,11 @@ def main():
     # package, not one without the app: said at once, not at Sign in.
     if PUBLIC_GOOGLE_PROBLEM:
         raise SystemExit(PUBLIC_GOOGLE_PROBLEM)
+    # A lab file named and not there is a broken deployment, said at once.
+    if LAB_IMPORT and not Path(LAB_IMPORT).is_file():
+        raise SystemExit(f"LAB_IMPORT names {LAB_IMPORT}, which is not a file")
+    if LAB_IMPORT and STORE is None:
+        raise SystemExit("LAB_IMPORT needs DATA_DIR: a lab file's settings are kept in its store")
     # A root that is not there would refuse every File Source -- said at once.
     if LOCAL_ROOT and not Path(LOCAL_ROOT).is_dir():
         raise SystemExit(f"SOURCE_LOCAL_ROOT names {LOCAL_ROOT}, which is not a directory")
@@ -9229,6 +10005,24 @@ def main():
         # The drop-in folder: a pack put there is installed as the lab starts.
         for line in PACKS.install_dropins(Path(DATA_DIR) / "packs"):
             print(f"pack:      {line}", flush=True)
+    if LAB_IMPORT:
+        # After the demo: a lab file adds settings, never datasets, so the
+        # demo still finds the new lab it installs into.
+        try:
+            doc = json.loads(Path(LAB_IMPORT).read_text("utf-8"))
+        except (OSError, ValueError) as e:
+            raise SystemExit(f"LAB_IMPORT: {LAB_IMPORT} is not JSON ({e})") from None
+        said, err = lab_import(doc, os.environ)
+        if err:
+            raise SystemExit(f"LAB_IMPORT: {err[1]}")
+        for line in said:
+            print(f"import:    {line}", flush=True)
+        # A held key goes wherever a submitted run points it, so a lab open to
+        # its network with keys in it is as loud as one with a Local provider on.
+        if local_exposed() and any(os.environ.get(key_var(c["id"], c.get("slug")))
+                                   for c in doc.get("connections") or []):
+            print(f"WARNING:   LAB_IMPORT gave a connection its key, and {HOST} is beyond loopback with no "
+                  "LAB_PASSWORD -- anyone who can reach this port can run against it", flush=True)
     if QUEUE is not None:
         QUEUE.start()
     ThreadingHTTPServer((HOST, PORT), Handler).serve_forever()