erdraft 0.0.1 → 0.0.2

package/README.md

@@ -1,6 +1,6 @@
 # Erdraft
 
-A project's data model, drafted with an agent while a person watches. The agent reads the schema and proposes changes through Erdraft's MCP (or its CLI); each proposal is a **draft**, drawn at once in a window beside the schema the code has, its tables and columns marked added, changed or removed. Asked for ideas, the agent proposes two or three **alternatives** in one group, compared a tab each. The person **adopts** one; only then does the agent write it in the code. Erdraft never changes the code nor the database.
+A project's data model, drafted with an agent while a person watches. The agent reads the schema and proposes changes through Erdraft's MCP (or its CLI); each proposal is a **draft**, drawn at once in a window beside the schema the code has, its tables and columns marked added, changed or removed. Asked for ideas, the agent proposes two or three **alternatives** in one group, compared a tab each, an arrow at each end of the tabs going to the one before or after (the tabs scroll where there are more than the card holds). The person **adopts** one; only then does the agent write it in the code. Erdraft never changes the code nor the database.
 
 ## Install
 
@@ -14,7 +14,16 @@ With pnpm, allow esbuild's install script when it asks (`pnpm approve-builds`):
 
 ## Set it up
 
-A `.erdraft.json` at the project's root says where its schema is, and the project's name (none given, its folder's), which its drafts are kept by:
+From the project's root:
+
+```sh
+npx erdraft init      # .erdraft.json, Erdraft's MCP in .mcp.json, the skill for the project's agents
+npx erdraft studio    # the window, at http://localhost:9369 (the schema read from the code as it opens)
+```
+
+`init` finds the schema in the module drizzle-kit's config names (`drizzle.config.ts` and its kin, at the root or in a package of `packages/` or `apps/`), else where schemas usually are (`src/db/schema.ts`, `src/server/db/schema.ts`...), and names the project after its `package.json`, so every checkout of it shares its drafts whatever its folder is called. It reads the schema before it ends, to show it is one Erdraft reads, and says what to do next. Give it the module when it finds none, or when drizzle-kit's config names several or a glob (Erdraft reads one module that exports every table), and another name: `npx erdraft init src/db/index.ts --name Acme`. Run again, it keeps what is there; `--force` writes `.erdraft.json` and the skill over.
+
+What it writes is a `.erdraft.json`, which says where the schema is and the project's name, its drafts kept by it:
 
 ```json
 {
@@ -23,13 +32,7 @@ A `.erdraft.json` at the project's root says where its schema is, and the projec
 }
 ```
 
-Then open the window, and give your agent Erdraft's MCP and its skill:
-
-```sh
-npx erdraft studio          # the window, at http://localhost:9369 (the schema read from the code as it opens)
-npx erdraft install-skill   # the skill, in .claude/skills/erdraft, for the project's agents
-npx erdraft --help          # every command
-```
+and Erdraft's server beside the others in Claude Code's `.mcp.json`; any agent that speaks MCP over stdio runs `erdraft mcp` the same way:
 
 ```json
 {
@@ -39,7 +42,7 @@ npx erdraft --help          # every command
 }
 ```
 
-That is Claude Code's `.mcp.json`, at the project's root; any agent that speaks MCP over stdio runs `erdraft mcp` the same way.
+Keep it in the project (`npm install --save-dev erdraft`, or the project's package manager's), so `npx erdraft` runs the version installed rather than the latest; `npx erdraft --help` says every command.
 
 ## Staying up to date
 
@@ -53,6 +56,12 @@ Ask in your own words, *propose two alternatives for tagging projects*, from eit
 - **The bell**, at the rail's foot over the theme, allows the browser's notifications (the browser asks once): a draft the agent proposes while the window is not in front is told in a notification, its id and title, and the window opens on it when it is clicked. The bell turns them off and on after, kept; refused, it says where the browser's settings allow them again.
 - **Your agent's session**: with the MCP in the project's `.mcp.json`, a Claude Code session started after it was added offers its tools once approved.
 
+## Share it
+
+**Share**, at the top bar's end before the assistant, gives a link to the window over the internet, for someone on another machine to follow the schema and the drafts as they change: **Create a link**, then **Copy link**, and **Stop sharing** when done (the window's process ending stops it too). The link opens on what the window shows as it is copied (the draft open, the table in focus, the relationships drawn: the address's query). Whoever opens the link only reads: the window says *View only*, with no Share, no assistant, no Adopt or Set aside, no draft's bin, no database's menu (its name alone), no Connect an agent (the MCP runs on this machine alone) and no Read the schema again, and what it is shown through refuses whatever would change something.
+
+The link goes through a tunnel provider, ngrok for now (`tunnel` in `.erdraft.json`), through its SDK in Erdraft's process, with no ngrok program to install: add the SDK to the project (`npm install --save-dev @ngrok/ngrok`, an optional peer of Erdraft's). The first time, the panel asks for an ngrok account's authtoken (a free account's, from [its dashboard](https://dashboard.ngrok.com/get-started/your-authtoken), *Get one*), and keeps it in the system's keychain once a link has opened with it (macOS's Keychain, Windows' Credential Manager, Linux's Secret Service; never in a file), so it is not asked again; *Forget it* takes it out. An authtoken ngrok refuses is said and not kept; where the keychain cannot keep one, it is kept until Erdraft stops. `NGROK_AUTHTOKEN`, when set, goes before the one kept, and the panel says so. On ngrok's free plan, whoever opens the link is shown ngrok's warning page once before the window.
+
 ## Commands
 
 ```text
@@ -61,6 +70,9 @@ erdraft: a project's data model, drafted with an agent while a person watches
 Usage: erdraft <command> [options] [--database <id>]
        erdraft --version
 
+  init [<schema>] [--name <name>] [--force]
+                              Set the project up: .erdraft.json (its Drizzle schema found, or the one given), the MCP
+                              in .mcp.json, the skill for its agents
   studio                      Open the window (the diagram, live)
   mcp                         Serve the MCP on stdin and stdout, for an agent
   read                        Read the schema again from the code
@@ -99,6 +111,7 @@ where the databases' schemas and their drafts are.
 | `port` | `9369` | The window's port, on 127.0.0.1: none given, 9369, unassigned by IANA and outside every system's ephemeral range (decisions/0006) |
 | `claude` | `claude` | The Claude Code the assistant runs |
 | `model` | `sonnet` | The assistant's model, an alias or a model's full name |
+| `tunnel` | `ngrok` | The provider the window is shared through (Share it); none given, ngrok, the one there is so far |
 
 ## Where a field keeps its value
 
@@ -142,12 +155,13 @@ A field is known by its label (its `aria-label`, the text it is labelled by, its
 
 ## How it works
 
-- **The base** is the schema as the code has it: the Drizzle module read by tsx in a process of its own each time (a table changed since is read as it is now; what the module prints never reaches the MCP), by the paths of the `tsconfig.json` nearest it, an ES module's or a CommonJS project's alike, its tables (one in a schema of its own, `pgSchema('auth')`, named `auth.users`), columns, keys, indexes (a unique constraint of several columns among them), checks and enums written to `base.json` (`read`, `read_schema`, and each time the window opens). A module with no Postgres table is refused, a MySQL or SQLite one among them.
+- **The base** is the schema as the code has it, read again from the top bar's arrows after the page's name (Read the schema again, `POST /api/read`, every window and the shared link drawing it at once, no page loaded again; a module that cannot be read said beside them), never as the module is saved (a file saved half written would break the read): the Drizzle module read by tsx in a process of its own each time (a table changed since is read as it is now; what the module prints never reaches the MCP), by the paths of the `tsconfig.json` nearest it, an ES module's or a CommonJS project's alike, its tables (one in a schema of its own, `pgSchema('auth')`, named `auth.users`), columns, keys, indexes (a unique constraint of several columns among them), checks and enums written to `base.json` (`read`, `read_schema`, and each time the window opens). A module with no Postgres table is refused, a MySQL or SQLite one among them.
 - **A draft** is a list of operations on the base (`add_table`, `drop_table`, `rename_table`, `add_column`, `drop_column`, `alter_column`, `add_foreign_key`, `drop_foreign_key`, `add_index`, `drop_index`, `add_check`, `drop_check`, `add_enum`, `set_enum_values`, `drop_enum`), applied in order. One that cannot be applied is refused, naming its step; a base read again keeps every draft on it, and a draft that no longer applies says why in the window (one set aside says nothing of it), unless the base holds what it comes to (adopted, then written in the code: the draft laid over the code's schema, each table and enum it touches the same there as in the code, its columns and checks by name, its foreign keys by what they join, its indexes by their columns, an enum's values; what its own steps added and took away again gone from both, what the code holds more kept; `src/core/written-in.ts`), which the window, `show_draft` and `erdraft draft` say instead, the diagram the schema as the code has it with what the draft did marked on it, as a draft still proposed is marked (the tables and columns it added, those it changed and named again, the keys, indexes and checks it added; `src/core/mark-written.ts`).
 - **The store** is changed by one process at a time, every other waiting its turn (a `.lock` file in it): the CLI, the MCP and the window read a file, change it and write it whole, so an agent proposing three alternatives at once keeps all three, each its own number.
 - **The window's server** listens on 127.0.0.1 and answers its own page alone: a request to its API from another site's page, or to another host than this machine (a name turned to 127.0.0.1), is refused, so a page the person has open can neither read the schema nor adopt a draft nor start the assistant. The inspector's routes answer any page of this machine, the project's app.
+- **Sharing** (`POST /api/share`, the credential typed in its body; `DELETE` to stop; `DELETE /api/share/credential` to forget the one kept; the link in the state, and where the credential comes from, never the credential): a second server on a port the system gives, on 127.0.0.1 (`src/share/serve-shared.ts`), is what the tunnel reaches. The link's token (24 random bytes, `?share=`) is kept in an HttpOnly cookie and taken out of the address, and every request without it refused; with it, GET and HEAD alone are passed on to the window's own server as a page of this machine asks them (of `localhost`, with no `Origin` and no cookie), of the API only `/api/state` and `/api/events`. A provider is a `TunnelProvider` (`src/share/tunnel-provider.ts`: its name, the credential it opens with, its name, where one is got and its environment variable, and `open(port, credential)` its address and `close`), named in `src/share/tunnels.ts`, its credential kept by the keychain under `erdraft` and the provider's id (`src/share/keychain.ts`, `@napi-rs/keyring`, loaded when a credential is first asked for); it must carry server-sent events, or the shared window never changes (decisions/0008). Run from Erdraft's source, the window is Vite's, and the link reaches what Vite serves.
 - **The diff** sets the draft beside the base, a table or column renamed matched to its old name, a foreign key matched by what it joins.
-- **The window** (Vite, React, React Flow) keeps what it shows in its address (`?draft=d3&table=users&relations=users`), so a reload or a link opens it again (a draft's card closed from its X, the schema shown again where the view stood, never framed whole, the table in focus and the relationships drawn kept), and Back and Forward go from screen to screen (another draft or other relationships a step; the focus alone none). It fetches the state and hears the store's folder change through server-sent events: a draft proposed by the agent is shown within a second, and selected. Its tables keep the base's places (dagre, top to bottom), a table a draft adds at the nearest free place beside a table it joins. The diagram opens already framed (on the table in focus, else on what a draft changes, else whole), never zoomed to as it appears; panned away, the controls' target (Center the tables in focus, beside the whole diagram's) brings those tables back to the middle of the view, and the draft card's own, at its bottom left (Center its tables under the pointer), the tables the draft changes (adopted and written in the code, or no longer applying, the tables its operations touch that the code has, `src/core/touched-tables.ts`), the table in focus let go. The lines run under the cards, each in a tone of its own (five hues, its hue halfway to its foreground so each reads on the canvas light or dark), those meeting at a card each another, so a person presenting the diagram can say which they mean (a line a draft adds or takes away in the colour of what it does), each a lane apart from the others sharing a card (`TURN` and `LANE`, `lib/graph.ts`), never one over another, and running across in the gap between its two cards where they stand now, never behind one (`LaneEdge`, `lib/route.ts`); a line clicked lights the two tables it joins and the columns it joins, frames them and fades the rest, let go with a click on the pane or a table. A card the person drags stays where they leave it, kept in the store's `layouts.json` (shared by every workspace) by what the window showed (the schema, a draft, a table's relationships in either), for every window and the next visit; Reset layout, in the controls, sets it back to the diagram's own. Each drag (several cards dragged together one) is undone and done again from the controls' arrows or with ⌘Z and ⇧⌘Z (Ctrl+Z, Ctrl+Y), never while writing in a field.
+- **The window** (Vite, React, React Flow) keeps what it shows in its address (`?draft=d3&table=users&relations=users`), so a reload or a link opens it again (a draft's card closed from its X, the schema shown again where the view stood, never framed whole, the table in focus and the relationships drawn kept), and Back and Forward go from screen to screen (another draft or other relationships a step; the focus alone none). It fetches the state and hears the store's folder change through server-sent events: a draft proposed by the agent is shown within a second, and selected. Its tables keep the base's places, a table a draft adds at the nearest free place beside a table it joins; the base laid out as the person arranges it from the controls (Arrange tables, kept in the browser for every view): top to bottom (dagre, the default), left to right (dagre's ranks across), or square (columns as many as make the diagram as wide as it is high, each card under the shortest, in the order the ranks read; `positionsOf`, `lib/graph.ts`), every card going where the arrangement lays it as a step undone like a drag, the cards moved by hand in the view shown too. The diagram opens already framed (on the table in focus, else on what a draft changes, else whole), never zoomed to as it appears; panned away, the controls' target (Center the tables in focus, beside the whole diagram's) brings those tables back to the middle of the view, and the draft card's own, at its bottom left (Center its tables under the pointer), the tables the draft changes (adopted and written in the code, or no longer applying, the tables its operations touch that the code has, `src/core/touched-tables.ts`), the table in focus let go. The lines run under the cards, each in a tone of its own (five hues, its hue halfway to its foreground so each reads on the canvas light or dark), those meeting at a card each another, so a person presenting the diagram can say which they mean (a line a draft adds or takes away in the colour of what it does), each a lane apart from the others sharing a card (`TURN` and `LANE`, `lib/graph.ts`), never one over another, and running across in the gap between its two cards where they stand now, never behind one (`LaneEdge`, `lib/route.ts`); a line clicked lights the two tables it joins and the columns it joins, frames them and fades the rest, let go with a click on the pane or a table. A card the person drags stays where they leave it, kept in the store's `layouts.json` (shared by every workspace) by what the window showed (the schema, a draft, a table's relationships in either), for every window and the next visit; Reset layout, in the controls, sets it back to the diagram's own. Each drag (several cards dragged together one) is undone and done again from the controls' arrows or with ⌘Z and ⇧⌘Z (Ctrl+Z, Ctrl+Y), never while writing in a field.
 - **The assistant** (`POST /api/assistant`) runs `claude -p` from the project's folder, the person's words on its stdin (never among its arguments), with `--strict-mcp-config` (Erdraft's MCP alone), `--tools ""` and `--allowedTools mcp__erdraft`, its stream (`--output-format stream-json --include-partial-messages`) read into the window's events: words as they are written, each tool as a step, the session to `--resume`. Stopping it or closing the panel stops the agent.
 - **The window follows the agent**: asked to see a table, its relationships or a draft, the agent calls `show_in_window` (the CLI, `show`), which writes the workspace's `view.json` in the store; the window, hearing the folder change, opens the draft, focuses the table and, for its relationships, draws only it and the tables it joins by a foreign key either way, laid out on their own, under the card the way back (Show all); the person asks for a draft's tables' from its card, beside Center (the tables joined by commas in the address, `?relations=wiki_pages,wiki_page_stars`), and for a table's own from its card's header (Show its relationships beside its count, Show all tables there while they are drawn), and goes along a foreign key from its column's link, an arrow under the pointer (Go to its table): the table it points to focused, the column it points to lit, every table drawn again when it is out of the relationships drawn. An ask made before the window opened is not applied.
 - **Deleting** is the person's too: a draft's bin in the column, said again in a dialog, or `erdraft delete <id>`; the draft goes for good with its layouts, and its id is never given again (`sequence.json`). The agent only sets a draft aside.
@@ -182,7 +196,8 @@ skill/SKILL.md          The skill install-skill writes into a project (src/core/
 src/core/               The schema read from Drizzle (in a process of its own, read-schema-child.ts), the operations, the diff, the store and its lock, the config, the text the CLI and the MCP answer with
 src/cli/run.ts          The CLI's commands
 src/mcp/create-server.ts  The MCP server and its tools
-src/server/             The window's API (state, events, adopt, discard, the assistant, the inspector's) and what it refuses (refusal-of.ts), Claude Code's stream read, the built window served (serve-window.ts), its Vite config
+src/server/             The window's API (state, events, adopt, discard, the schema read again, the share, the assistant, the inspector's) and what it refuses (refusal-of.ts), Claude Code's stream read, the built window served (serve-window.ts), its Vite config
+src/share/              The window shared over the internet (decisions/0008): the providers (tunnel-provider.ts, tunnels.ts, providers/ngrok.ts), their credentials in the system's keychain (keychain.ts), the read-only server the tunnel reaches (serve-shared.ts), one link at a time (create-share.ts)
 src/inspect/            The inspector: the Drizzle logger and the rows it reads from a statement, the value matched, and the overlay a project's app draws (its fields, their changes, the browser's storage)
 src/ui/                 The window: app.tsx, its hooks, its components (the assistant's panel and composer among them), its contexts (contexts/relations.ts, what a table's card reaches of the diagram), the diagram's layout (lib/graph.ts), the conversation's messages (lib/assistant-message.ts)
 src/test-utils/         A small Drizzle schema and the fakes the tests use
@@ -197,6 +212,8 @@ pnpm bundle             # dist/: the CLI and the inspector (tsup), the window (V
 
 - **A window open keeps the core it started with.** Vite brings a change to `src/ui/` into it at once, but its server applies the drafts with the `src/core/` it loaded: a change to the core (a column's fields, the diff, how a draft is read) reaches it only once `studio` is started again, and an agent's MCP only once it is connected again. The CLI runs the source afresh each time.
 - **A change is looked at in a window of its own,** never by stopping the one a person is using: `studio` started from a folder whose `.erdraft.json` gives another `port` and the same `schema` and `store` (absolute paths), so it shows the same drafts; photographed in a headless browser, then stopped (2026-11-03, a json column's shape on port 4101).
+- **A control added to the window says what a shared window does with it.** Whoever opens a shared link only reads: nothing that changes something (adopt, set aside, delete, the database switched or added, the assistant, Share, Read the schema again) nor that belongs to the developer's machine (Connect an agent, its MCP on stdio) is drawn there, `viewOnly()` (`src/ui/lib/view-only.ts`) deciding, and the share's server refusing it whatever the page shows (decisions/0008; 2026-11-04, the owner's correction: Add a database in a shared window).
+- **A shared window is looked at without a tunnel:** `serveShared(<the test window's port>, <a token>)` (`src/share/serve-shared.ts`) in a script, and Chromium launched with `--host-resolver-rules=MAP shared.test 127.0.0.1`, the share's cookie (`erdraft_share`, the token) added to its context before the page is opened, as a `Secure` cookie is not kept over http; a host that is not this machine's is what turns the window to View only (2026-11-04, port 9398).
 
 The source runs as TypeScript through tsx; Node does not strip the types of a file inside `node_modules`, so the package ships it built (`prepack`): `dist/cli.js`, the inspector's two entries with their types, and the window Vite built, which the CLI serves with its API beside it, where from the source Vite serves it. It is published with pnpm (`pnpm publish`), which writes `publishConfig`'s `bin` and `exports`, the built files', over the source's; `npm publish` is refused (`prepublishOnly`), as it would publish a package whose command is not in it.
 

package/dist/{chunk-SSLBX2OF.js → chunk-IQ5YYSCP.js}

@@ -750,7 +750,7 @@ function store(folder, workspace = "default") {
 }
 
 // package.json
-var version = "0.0.1";
+var version = "0.0.2";
 
 // src/core/version.ts
 var VERSION = version;
@@ -1703,7 +1703,7 @@ ${describeDiff(diffDraft(schema, draft.operations))}`;
 }
 
 // src/server/create-api.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 import { mkdirSync, watch } from "fs";
 import { text as text4 } from "stream/consumers";
 
@@ -1796,7 +1796,7 @@ function promptOf(config, context) {
     ...seen.filter(Boolean)
   ].join("\n\n");
 }
-function argumentsOf(config, ask) {
+function argumentsOf(config, ask2) {
   return [
     "-p",
     "--output-format",
@@ -1815,8 +1815,8 @@ function argumentsOf(config, ask) {
     "--model",
     config.model,
     "--append-system-prompt",
-    promptOf(config, ask.context),
-    ...ask.session ? ["--resume", ask.session] : []
+    promptOf(config, ask2.context),
+    ...ask2.session ? ["--resume", ask2.session] : []
   ];
 }
 function send(response, event) {
@@ -1825,7 +1825,7 @@ function send(response, event) {
 `);
 }
 function createAssistant(config, spawn = spawnProcess) {
-  return async function ask(request, response) {
+  return async function ask2(request, response) {
     const asked = askSchema.safeParse(JSON.parse(await text2(request) || "{}"));
     if (!asked.success) {
       response.writeHead(400, { "content-type": "application/json" });
@@ -1872,8 +1872,260 @@ function createAssistant(config, spawn = spawnProcess) {
   };
 }
 
-// src/server/create-inspect-api.ts
+// src/share/create-share.ts
+import { randomBytes } from "crypto";
+
+// src/share/keychain.ts
+var SERVICE = "erdraft";
+async function entryOf(account) {
+  const { Entry } = await import("@napi-rs/keyring");
+  return new Entry(SERVICE, account);
+}
+var keychain = {
+  async read(account) {
+    try {
+      return (await entryOf(account)).getPassword();
+    } catch {
+      return null;
+    }
+  },
+  async save(account, secret) {
+    const entry = await entryOf(account);
+    entry.setPassword(secret);
+  },
+  async forget(account) {
+    const entry = await entryOf(account);
+    entry.deletePassword();
+  }
+};
+var keychain_default = keychain;
+
+// src/share/providers/ngrok.ts
+var ngrok = {
+  name: "ngrok",
+  credential: {
+    label: "ngrok authtoken",
+    help: "https://dashboard.ngrok.com/get-started/your-authtoken",
+    env: "NGROK_AUTHTOKEN"
+  },
+  async open(port, authtoken) {
+    const sdk = await import("@ngrok/ngrok").catch(() => void 0);
+    if (!sdk) {
+      throw new Error(
+        "Sharing through ngrok needs its package in the project: npm install --save-dev @ngrok/ngrok"
+      );
+    }
+    const listener = await sdk.forward({ addr: `127.0.0.1:${port}`, authtoken }).catch((error) => {
+      throw String(error).includes("ERR_NGROK_105") ? new Error(
+        "ngrok does not take this authtoken: copy it again from its dashboard"
+      ) : error;
+    });
+    const url = listener.url();
+    if (url === null) {
+      await listener.close();
+      throw new Error("ngrok opened the tunnel without an address");
+    }
+    return { url, close: () => listener.close() };
+  }
+};
+var ngrok_default = ngrok;
+
+// src/share/tunnels.ts
+var TUNNEL_IDS = ["ngrok"];
+var TUNNELS = { ngrok: ngrok_default };
+var tunnels_default = TUNNELS;
+
+// src/share/serve-shared.ts
+import {
+  request as ask,
+  createServer as createServer2
+} from "http";
+import { timingSafeEqual } from "crypto";
+import { once } from "events";
 import { z as z8 } from "zod";
+var COOKIE = "erdraft_share";
+var READS = /* @__PURE__ */ new Set(["/api/state", "/api/events"]);
+var PASSED = [
+  "accept",
+  "accept-encoding",
+  "accept-language",
+  "cache-control",
+  "if-modified-since",
+  "if-none-match",
+  "last-event-id",
+  "range"
+];
+function refuse(response, status, message) {
+  response.writeHead(status, { "content-type": "text/plain; charset=utf-8" });
+  response.end(message);
+}
+function sameToken(given, token) {
+  const a = Buffer.from(given ?? "");
+  const b = Buffer.from(token);
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+function cookieOf(request) {
+  const pair = (request.headers.cookie ?? "").split(";").map((each) => each.trim()).find((each) => each.startsWith(`${COOKIE}=`));
+  return pair?.slice(COOKIE.length + 1);
+}
+function forward(request, response, port, path) {
+  const headers = {
+    host: `localhost:${port}`
+  };
+  for (const name of PASSED) {
+    const value = request.headers[name];
+    if (value !== void 0) {
+      headers[name] = value;
+    }
+  }
+  const upstream = ask(
+    { host: "127.0.0.1", port, method: request.method, path, headers },
+    (answer2) => {
+      response.writeHead(Number(answer2.statusCode), answer2.headers);
+      answer2.on("error", () => response.destroy());
+      answer2.pipe(response);
+    }
+  );
+  upstream.on("error", () => {
+    if (!response.destroyed) {
+      refuse(response, 502, "The window is not answering");
+    }
+  });
+  response.on("close", () => upstream.destroy());
+  upstream.end();
+}
+async function serveShared(port, token) {
+  const server = createServer2((request, response) => {
+    const url = new URL(String(request.url), "http://localhost");
+    const given = url.searchParams.get("share");
+    if (given !== null) {
+      if (!sameToken(given, token)) {
+        refuse(response, 403, "This link is not shared, or no longer");
+        return;
+      }
+      url.searchParams.delete("share");
+      response.writeHead(303, {
+        location: `${url.pathname}${url.search}`,
+        "set-cookie": `${COOKIE}=${token}; Path=/; HttpOnly; Secure; SameSite=Lax`
+      });
+      response.end();
+      return;
+    }
+    if (!sameToken(cookieOf(request), token)) {
+      refuse(response, 403, "This link is not shared, or no longer");
+      return;
+    }
+    if (request.method !== "GET" && request.method !== "HEAD") {
+      refuse(response, 405, "A shared window only reads");
+      return;
+    }
+    if (url.pathname.startsWith("/api/") && !READS.has(url.pathname)) {
+      refuse(response, 403, "A shared window only reads");
+      return;
+    }
+    forward(request, response, port, `${url.pathname}${url.search}`);
+  });
+  server.listen(0, "127.0.0.1");
+  await once(server, "listening");
+  return {
+    server,
+    port: z8.object({ port: z8.number() }).parse(server.address()).port
+  };
+}
+
+// src/share/create-share.ts
+function createShare(config, {
+  provider = tunnels_default[config.tunnel],
+  token = () => randomBytes(24).toString("base64url"),
+  keychain: kept = keychain_default,
+  env = process.env
+} = {}) {
+  const account = config.tunnel;
+  let open;
+  let starting;
+  let remembered;
+  async function credentialOf() {
+    const given = env[provider.credential.env];
+    if (given) {
+      return { secret: given, from: "environment" };
+    }
+    remembered ??= kept.read(account).then(
+      (secret) => ({
+        secret,
+        from: secret === null ? null : "keychain"
+      })
+    );
+    return remembered;
+  }
+  async function begin(given) {
+    const credential = given || (await credentialOf()).secret;
+    if (!credential) {
+      throw new Error(
+        `Sharing through ${provider.name} needs its ${provider.credential.label}`
+      );
+    }
+    const secret = token();
+    const { server, port } = await serveShared(config.port, secret);
+    const closeServer = () => {
+      server.closeAllConnections();
+      server.close();
+    };
+    const tunnel = await provider.open(port, credential).catch((error) => {
+      closeServer();
+      throw error;
+    });
+    if (given) {
+      const from = await kept.save(account, given).then(
+        () => "keychain",
+        () => "memory"
+      );
+      remembered = Promise.resolve({ secret: given, from });
+    }
+    open = {
+      url: `${tunnel.url}/?share=${secret}`,
+      // Its server closed whatever the provider answers: a tunnel that fails to close reaches nothing behind it
+      close: async () => {
+        closeServer();
+        await tunnel.close().catch(() => void 0);
+      }
+    };
+    return { url: open.url, provider: provider.name };
+  }
+  return {
+    async state() {
+      const { from } = await credentialOf();
+      return {
+        provider: provider.name,
+        url: open?.url ?? null,
+        credential: { ...provider.credential, from }
+      };
+    },
+    // Shared, with the credential given or the one there is, or the link it is shared by already; two asked at
+    // once, one link
+    start(given) {
+      if (open) {
+        return Promise.resolve({ url: open.url, provider: provider.name });
+      }
+      starting ??= begin(given).finally(() => {
+        starting = void 0;
+      });
+      return starting;
+    },
+    async stop() {
+      const was = open;
+      open = void 0;
+      await was?.close();
+    },
+    // The credential kept forgotten, in the keychain and in this run: the window asks for it again
+    async forget() {
+      await kept.forget(account);
+      remembered = Promise.resolve({ secret: null, from: null });
+    }
+  };
+}
+
+// src/server/create-inspect-api.ts
+import { z as z9 } from "zod";
 import { text as text3 } from "stream/consumers";
 
 // src/inspect/holds-value.ts
@@ -1896,9 +2148,9 @@ function holdsValue(kept, typed) {
 // src/server/create-inspect-api.ts
 var KEPT_WRITES = 500;
 var KEPT_FOR = 15 * 6e4;
-var writesSchema = z8.object({
-  writes: z8.array(
-    z8.object({ table: z8.string(), values: z8.record(z8.string(), z8.unknown()) })
+var writesSchema = z9.object({
+  writes: z9.array(
+    z9.object({ table: z9.string(), values: z9.record(z9.string(), z9.unknown()) })
   )
 });
 var tracedSchema = fieldSchema.omit({ tracedAt: true });
@@ -1931,7 +2183,7 @@ function createInspectApi(now = Date.now) {
     if (request.method === "POST" && url.pathname === "/api/inspect/writes") {
       const sent = writesSchema.safeParse(await body(request));
       if (!sent.success) {
-        json(response, 400, { error: z8.prettifyError(sent.error) }, headers);
+        json(response, 400, { error: z9.prettifyError(sent.error) }, headers);
         return true;
       }
       const at = now();
@@ -1968,7 +2220,7 @@ function createInspectApi(now = Date.now) {
     if (request.method === "POST" && url.pathname === "/api/inspect/fields") {
       const field = tracedSchema.safeParse(await body(request));
       if (!field.success) {
-        json(response, 400, { error: z8.prettifyError(field.error) }, headers);
+        json(response, 400, { error: z9.prettifyError(field.error) }, headers);
         return true;
       }
       const kept = await drafts.saveField(field.data);
@@ -2014,25 +2266,29 @@ function refusalOf(request, asker) {
 var SETTLE = 40;
 var DRAFT_ACTION = /^\/api\/drafts\/([^/]+)\/(adopt|discard)$/;
 var DRAFT_DELETE = /^\/api\/drafts\/([^/]+)$/;
-var layoutSchema = z9.object({ key: z9.string().min(1), places: placesSchema });
+var layoutSchema = z10.object({ key: z10.string().min(1), places: placesSchema });
+function messageOf(error) {
+  return String(error).replace(/^Error: /, "");
+}
 function json2(response, status, value) {
   response.writeHead(status, { "content-type": "application/json" });
   response.end(JSON.stringify(value));
 }
-function createApi(config, { spawn } = {}) {
-  const ask = createAssistant(config, spawn);
+function createApi(config, { spawn, share = createShare(config) } = {}) {
+  const ask2 = createAssistant(config, spawn);
   const inspect = createInspectApi();
   const clients = /* @__PURE__ */ new Set();
   let timer;
-  mkdirSync(config.store, { recursive: true });
-  const watcher = watch(config.store, { recursive: true }, () => {
+  function tell() {
     clearTimeout(timer);
     timer = setTimeout(() => {
       for (const client of clients) {
         client.write("event: change\ndata: {}\n\n");
       }
     }, SETTLE);
-  });
+  }
+  mkdirSync(config.store, { recursive: true });
+  const watcher = watch(config.store, { recursive: true }, tell);
   async function handle(request, response) {
     const { pathname } = new URL(String(request.url), "http://localhost");
     if (!pathname.startsWith("/api/")) {
@@ -2057,6 +2313,7 @@ function createApi(config, { spawn } = {}) {
         port: config.port,
         databases: config.databases.map(({ id, name }) => ({ id, name })),
         database: { id: database.id, name: database.name },
+        share: await share.state(),
         ...await drafts.read()
       });
       return true;
@@ -2073,11 +2330,54 @@ function createApi(config, { spawn } = {}) {
       return true;
     }
     if (request.method === "POST" && pathname === "/api/assistant") {
-      await ask(request, response);
+      await ask2(request, response);
+      return true;
+    }
+    if (request.method === "POST" && pathname === "/api/read") {
+      try {
+        const base = await readSchema(config, database, drafts);
+        json2(response, 200, {
+          source: base.source,
+          tables: base.schema.tables.length,
+          enums: base.schema.enums.length
+        });
+      } catch (error) {
+        json2(response, 422, { error: messageOf(error) });
+      }
+      return true;
+    }
+    if (request.method === "POST" && pathname === "/api/share") {
+      const given = z10.object({ credential: z10.string().trim().min(1).optional() }).safeParse(JSON.parse(await text4(request) || "{}"));
+      try {
+        json2(
+          response,
+          200,
+          await share.start(given.success ? given.data.credential : void 0)
+        );
+      } catch (error) {
+        json2(response, 502, { error: messageOf(error) });
+      }
+      tell();
+      return true;
+    }
+    if (request.method === "DELETE" && pathname === "/api/share/credential") {
+      try {
+        await share.forget();
+        json2(response, 200, { ok: true });
+      } catch (error) {
+        json2(response, 502, { error: messageOf(error) });
+      }
+      tell();
+      return true;
+    }
+    if (request.method === "DELETE" && pathname === "/api/share") {
+      await share.stop();
+      json2(response, 200, { ok: true });
+      tell();
       return true;
     }
     if (request.method === "POST" && pathname === "/api/database") {
-      const chosen = z9.object({ id: z9.string() }).safeParse(JSON.parse(await text4(request) || "{}"));
+      const chosen = z10.object({ id: z10.string() }).safeParse(JSON.parse(await text4(request) || "{}"));
       try {
         const id = chosen.success ? chosen.data.id : "";
         json2(response, 200, await chooseDatabase(config, id));
@@ -2091,7 +2391,7 @@ function createApi(config, { spawn } = {}) {
         JSON.parse(await text4(request) || "{}")
       );
       if (!layout.success) {
-        json2(response, 400, { error: z9.prettifyError(layout.error) });
+        json2(response, 400, { error: z10.prettifyError(layout.error) });
         return true;
       }
       await drafts.saveLayout(layout.data.key, layout.data.places);
@@ -2138,6 +2438,7 @@ function createApi(config, { spawn } = {}) {
       for (const client of clients) {
         client.end();
       }
+      share.stop();
     }
   };
 }
@@ -2158,5 +2459,6 @@ export {
   describeDraft,
   describeDecision,
   createServer,
+  TUNNEL_IDS,
   createApi
 };